Repository: ezQuake/ezquake-source
Branch: master
Commit: 7d97990f80ae
Files: 615
Total size: 7.9 MB

Directory structure:
gitextract_jn4z67cv/

├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug-report.md
│   │   └── feature_request.md
│   └── workflows/
│       └── main.yml
├── .gitignore
├── .gitmodules
├── BUILD.md
├── CMakeLists.txt
├── CMakePresets.json
├── LICENSE
├── README.md
├── bootstrap.ps1
├── bootstrap.sh
├── build-linux.sh
├── cmake/
│   ├── AddResources.cmake
│   ├── CheckDependency.cmake
│   ├── FindSpeex.cmake
│   ├── FindSpeexDSP.cmake
│   ├── GitUtils.cmake
│   ├── ResourceCompiler.cmake
│   └── triplets/
│       ├── arm64-osx.cmake
│       ├── x64-mingw-static.cmake
│       ├── x64-osx.cmake
│       └── x86-mingw-static.cmake
├── dist/
│   ├── gen-release.sh
│   ├── linux/
│   │   ├── io.github.ezQuake.appdata.xml
│   │   └── io.github.ezQuake.desktop
│   ├── macOS/
│   │   ├── MacOSXBundleInfo.plist.in
│   │   ├── ezquake.entitlements.plist
│   │   └── ezquake.icns
│   └── windows/
│       └── ezQuake.rc.in
├── help_cmdline_params.json
├── help_commands.json
├── help_macros.json
├── help_variables.json
├── misc/
│   ├── appimage/
│   │   ├── appimage-manual_creation.sh
│   │   └── ezquake.appdata.xml.template
│   ├── cfg/
│   │   ├── cams.cfg
│   │   ├── cams.tcl
│   │   ├── eq260.cfg
│   │   ├── ezhud.cfg
│   │   ├── gfx_gl_eyecandy.cfg
│   │   ├── gfx_gl_faithful.cfg
│   │   ├── gfx_gl_fast.cfg
│   │   ├── gfx_gl_higheyecandy.cfg
│   │   ├── gfx_sw_default.cfg
│   │   ├── gfx_sw_fast.cfg
│   │   ├── how_to_use_these_files.txt
│   │   ├── hud_aas.cfg
│   │   ├── hud_berzerk.cfg
│   │   ├── hud_corner.cfg
│   │   ├── hud_dobbz.cfg
│   │   ├── hud_empezar.cfg
│   │   ├── hud_murdoc.cfg
│   │   ├── hud_senft.cfg
│   │   ├── hud_vleesh.cfg
│   │   ├── movement.cfg
│   │   ├── mvdhud_1on1.cfg
│   │   ├── mvdhud_2on2.cfg
│   │   ├── mvdhud_3on3.cfg
│   │   ├── mvdhud_4on4.cfg
│   │   ├── mvdhud_base.cfg
│   │   ├── mvdhud_base_2.cfg
│   │   ├── mvdhud_base_3.cfg
│   │   ├── mvdhud_base_4.cfg
│   │   ├── mvdhud_base_del.cfg
│   │   ├── mvdhud_base_other.cfg
│   │   ├── mvdhud_custom.cfg
│   │   ├── pingdump.cfg
│   │   ├── teamplay.cfg
│   │   └── teamtime.cfg
│   ├── pak.lst
│   └── sb/
│       ├── au-sv.txt
│       ├── cache/
│       │   └── empty
│       ├── check_sources.sh
│       ├── ctf.txt
│       ├── eu-4on4.txt
│       ├── eu-sv.txt
│       ├── global.txt
│       ├── na-sv.txt
│       ├── qizmo.txt
│       ├── sa-sv.txt
│       ├── sources.txt
│       ├── tf.txt
│       └── update_sources.bat
├── src/
│   ├── Ctrl.c
│   ├── Ctrl.h
│   ├── Ctrl_EditBox.c
│   ├── Ctrl_EditBox.h
│   ├── Ctrl_PageViewer.c
│   ├── Ctrl_PageViewer.h
│   ├── Ctrl_ScrollBar.c
│   ├── Ctrl_Tab.c
│   ├── Ctrl_Tab.h
│   ├── EX_FileList.c
│   ├── EX_FileList.h
│   ├── EX_browser.c
│   ├── EX_browser.h
│   ├── EX_browser_net.c
│   ├── EX_browser_pathfind.c
│   ├── EX_browser_ping.c
│   ├── EX_browser_qtvlist.c
│   ├── EX_browser_sources.c
│   ├── EX_qtvlist.c
│   ├── EX_qtvlist.h
│   ├── anorm_dots.h
│   ├── anorms.h
│   ├── bspfile.h
│   ├── cd_linux.c
│   ├── cd_null.c
│   ├── cd_win.c
│   ├── cdaudio.h
│   ├── central.c
│   ├── central.h
│   ├── cl_cam.c
│   ├── cl_cmd.c
│   ├── cl_demo.c
│   ├── cl_ents.c
│   ├── cl_input.c
│   ├── cl_main.c
│   ├── cl_multiview.c
│   ├── cl_nqdemo.c
│   ├── cl_parse.c
│   ├── cl_pred.c
│   ├── cl_screen.c
│   ├── cl_screenshot.c
│   ├── cl_skygroups.c
│   ├── cl_slist.c
│   ├── cl_slist.h
│   ├── cl_tent.c
│   ├── cl_view.c
│   ├── cl_view.h
│   ├── client.h
│   ├── cmd.c
│   ├── cmd.h
│   ├── cmdline_params.h
│   ├── cmdline_params_ids.h
│   ├── cmodel.c
│   ├── cmodel.h
│   ├── collision.c
│   ├── com_msg.c
│   ├── common.c
│   ├── common.h
│   ├── common_draw.c
│   ├── common_draw.h
│   ├── config_manager.c
│   ├── config_manager.h
│   ├── console.c
│   ├── console.h
│   ├── crc.c
│   ├── crc.h
│   ├── cvar.c
│   ├── cvar.h
│   ├── cvar_groups.h
│   ├── demo_controls.c
│   ├── demo_controls.h
│   ├── demo_spawnwarn.c
│   ├── demo_spawnwarn.h
│   ├── document_rendering.c
│   ├── document_rendering.h
│   ├── draw.h
│   ├── ez_button.c
│   ├── ez_button.h
│   ├── ez_controls.c
│   ├── ez_controls.h
│   ├── ez_label.c
│   ├── ez_label.h
│   ├── ez_listview.c
│   ├── ez_listview.h
│   ├── ez_listviewitem.c
│   ├── ez_listviewitem.h
│   ├── ez_scrollbar.c
│   ├── ez_scrollbar.h
│   ├── ez_scrollpane.c
│   ├── ez_scrollpane.h
│   ├── ez_slider.c
│   ├── ez_slider.h
│   ├── ez_window.c
│   ├── ez_window.h
│   ├── ezquake-icon.c
│   ├── fchecks.c
│   ├── fchecks.h
│   ├── fmod.c
│   ├── fmod.h
│   ├── fonts.c
│   ├── fonts.h
│   ├── fragstats.c
│   ├── fs.c
│   ├── fs.h
│   ├── g_public.h
│   ├── gl_aliasmodel.c
│   ├── gl_aliasmodel_md3.c
│   ├── gl_buffers.c
│   ├── gl_debug.c
│   ├── gl_drawcall_wrappers.c
│   ├── gl_framebuffer.c
│   ├── gl_framebuffer.h
│   ├── gl_local.h
│   ├── gl_misc.c
│   ├── gl_model.h
│   ├── gl_program.c
│   ├── gl_sdl.c
│   ├── gl_sprite3d.c
│   ├── gl_sprite3d.h
│   ├── gl_state.c
│   ├── gl_texture.c
│   ├── gl_texture.h
│   ├── gl_texture_functions.c
│   ├── gl_texture_internal.h
│   ├── glc_aliasmodel.c
│   ├── glc_aliasmodel_mesh.c
│   ├── glc_bloom.c
│   ├── glc_brushmodel.c
│   ├── glc_draw.c
│   ├── glc_framebuffer.c
│   ├── glc_lightmaps.c
│   ├── glc_local.h
│   ├── glc_main.c
│   ├── glc_matrix.c
│   ├── glc_matrix.h
│   ├── glc_md3.c
│   ├── glc_misc.c
│   ├── glc_particles.c
│   ├── glc_performance.c
│   ├── glc_sdl.c
│   ├── glc_sky.c
│   ├── glc_sprite3d.c
│   ├── glc_state.c
│   ├── glc_state.h
│   ├── glc_surf.c
│   ├── glc_turb_surface.c
│   ├── glc_vao.c
│   ├── glc_vao.h
│   ├── glc_warp.c
│   ├── glm_aliasmodel.c
│   ├── glm_brushmodel.c
│   ├── glm_brushmodel.h
│   ├── glm_draw.c
│   ├── glm_draw.h
│   ├── glm_framebuffer.c
│   ├── glm_lightmaps.c
│   ├── glm_local.h
│   ├── glm_main.c
│   ├── glm_md3.c
│   ├── glm_misc.c
│   ├── glm_particles.c
│   ├── glm_particles.h
│   ├── glm_performance.c
│   ├── glm_rmain.c
│   ├── glm_rsurf.c
│   ├── glm_sdl.c
│   ├── glm_sprite.c
│   ├── glm_sprite3d.c
│   ├── glm_state.c
│   ├── glm_texture_arrays.c
│   ├── glm_texture_arrays.h
│   ├── glm_vao.c
│   ├── glm_vao.h
│   ├── glsl/
│   │   ├── common.glsl
│   │   ├── constants.glsl
│   │   ├── draw_aliasmodel.fragment.glsl
│   │   ├── draw_aliasmodel.vertex.glsl
│   │   ├── draw_sprites.fragment.glsl
│   │   ├── draw_sprites.vertex.glsl
│   │   ├── draw_world.fragment.glsl
│   │   ├── draw_world.vertex.glsl
│   │   ├── fx_world_geometry.fragment.glsl
│   │   ├── fx_world_geometry.vertex.glsl
│   │   ├── glc/
│   │   │   ├── glc_aliasmodel_shadow.fragment.glsl
│   │   │   ├── glc_aliasmodel_shadow.vertex.glsl
│   │   │   ├── glc_aliasmodel_shell.fragment.glsl
│   │   │   ├── glc_aliasmodel_shell.vertex.glsl
│   │   │   ├── glc_aliasmodel_std.fragment.glsl
│   │   │   ├── glc_aliasmodel_std.vertex.glsl
│   │   │   ├── glc_caustics.fragment.glsl
│   │   │   ├── glc_caustics.vertex.glsl
│   │   │   ├── glc_draw_sprites.fragment.glsl
│   │   │   ├── glc_draw_sprites.vertex.glsl
│   │   │   ├── glc_hud_images.fragment.glsl
│   │   │   ├── glc_hud_images.vertex.glsl
│   │   │   ├── glc_post_process_screen.fragment.glsl
│   │   │   ├── glc_post_process_screen.vertex.glsl
│   │   │   ├── glc_sky.fragment.glsl
│   │   │   ├── glc_sky.vertex.glsl
│   │   │   ├── glc_turbsurface.fragment.glsl
│   │   │   ├── glc_turbsurface.vertex.glsl
│   │   │   ├── glc_world_drawflat.fragment.glsl
│   │   │   ├── glc_world_drawflat.vertex.glsl
│   │   │   ├── glc_world_secondpass.fragment.glsl
│   │   │   ├── glc_world_secondpass.vertex.glsl
│   │   │   ├── glc_world_textured.fragment.glsl
│   │   │   └── glc_world_textured.vertex.glsl
│   │   ├── hud_draw_circle.fragment.glsl
│   │   ├── hud_draw_circle.vertex.glsl
│   │   ├── hud_draw_image.fragment.glsl
│   │   ├── hud_draw_image.geometry.glsl
│   │   ├── hud_draw_image.vertex.glsl
│   │   ├── hud_draw_line.fragment.glsl
│   │   ├── hud_draw_line.vertex.glsl
│   │   ├── hud_draw_polygon.fragment.glsl
│   │   ├── hud_draw_polygon.vertex.glsl
│   │   ├── lighting.compute.glsl
│   │   ├── post_process_screen.fragment.glsl
│   │   ├── post_process_screen.vertex.glsl
│   │   ├── shared/
│   │   │   └── fxaa.h.glsl
│   │   ├── simple.fragment.glsl
│   │   ├── simple.vertex.glsl
│   │   ├── simple3d.fragment.glsl
│   │   └── simple3d.vertex.glsl
│   ├── hash.c
│   ├── hash.h
│   ├── help.c
│   ├── help.h
│   ├── help_files.c
│   ├── host.c
│   ├── hud.c
│   ├── hud.h
│   ├── hud_262.c
│   ├── hud_ammo.c
│   ├── hud_armor.c
│   ├── hud_autoid.c
│   ├── hud_centerprint.c
│   ├── hud_clock.c
│   ├── hud_common.c
│   ├── hud_common.h
│   ├── hud_editor.c
│   ├── hud_editor.h
│   ├── hud_face.c
│   ├── hud_frags.c
│   ├── hud_gamesummary.c
│   ├── hud_groups.c
│   ├── hud_guns.c
│   ├── hud_health.c
│   ├── hud_items.c
│   ├── hud_net.c
│   ├── hud_performance.c
│   ├── hud_qtv.c
│   ├── hud_radar.c
│   ├── hud_scores.c
│   ├── hud_speed.c
│   ├── hud_teaminfo.c
│   ├── hud_tracking.c
│   ├── hud_weapon_stats.c
│   ├── ignore.c
│   ├── ignore.h
│   ├── image.c
│   ├── image.h
│   ├── in_osx.h
│   ├── in_osx.m
│   ├── in_sdl2.c
│   ├── input.h
│   ├── irc.c
│   ├── irc.h
│   ├── irc_filter.c
│   ├── irc_filter.h
│   ├── keys.c
│   ├── keys.h
│   ├── linux_signals.c
│   ├── localtime.h
│   ├── localtime_posix.c
│   ├── localtime_win.c
│   ├── logging.c
│   ├── logging.h
│   ├── macro_definitions.h
│   ├── macro_ids.h
│   ├── match_tools.c
│   ├── match_tools_challenge.c
│   ├── mathlib.c
│   ├── mathlib.h
│   ├── md4.c
│   ├── menu.c
│   ├── menu.h
│   ├── menu_demo.c
│   ├── menu_demo.h
│   ├── menu_ingame.c
│   ├── menu_ingame.h
│   ├── menu_multiplayer.c
│   ├── menu_multiplayer.h
│   ├── menu_options.c
│   ├── menu_options.h
│   ├── menu_proxy.c
│   ├── menu_proxy.h
│   ├── modelgen.h
│   ├── movie.c
│   ├── movie.h
│   ├── movie_avi.c
│   ├── movie_avi.h
│   ├── mvd_autotrack.c
│   ├── mvd_utils.c
│   ├── mvd_utils.h
│   ├── mvd_utils_common.h
│   ├── mvd_xmlstats.c
│   ├── net.c
│   ├── net.h
│   ├── net_chan.c
│   ├── parser.c
│   ├── parser.h
│   ├── particles_classic.h
│   ├── pmove.c
│   ├── pmove.h
│   ├── pmovetst.c
│   ├── pr2.h
│   ├── pr2_cmds.c
│   ├── pr2_edict.c
│   ├── pr2_exec.c
│   ├── pr_cmds.c
│   ├── pr_comp.h
│   ├── pr_edict.c
│   ├── pr_exec.c
│   ├── progdefs.h
│   ├── progs.h
│   ├── q_platform.h
│   ├── q_shared.c
│   ├── q_shared.h
│   ├── qmb_particles.h
│   ├── qsound.h
│   ├── qtv.c
│   ├── qtv.h
│   ├── quakedef.h
│   ├── qwsvdef.h
│   ├── r_aliasmodel.c
│   ├── r_aliasmodel.h
│   ├── r_aliasmodel_md3.c
│   ├── r_aliasmodel_md3.h
│   ├── r_aliasmodel_mesh.c
│   ├── r_aliasmodel_skins.c
│   ├── r_atlas.c
│   ├── r_bloom.c
│   ├── r_brushmodel.c
│   ├── r_brushmodel.h
│   ├── r_brushmodel_bspx.c
│   ├── r_brushmodel_load.c
│   ├── r_brushmodel_sky.c
│   ├── r_brushmodel_sky.h
│   ├── r_brushmodel_surfaces.c
│   ├── r_brushmodel_textures.c
│   ├── r_brushmodel_warpsurfaces.c
│   ├── r_brushmodel_warpsurfaces_sin.h
│   ├── r_buffers.c
│   ├── r_buffers.h
│   ├── r_chaticons.c
│   ├── r_chaticons.h
│   ├── r_draw.c
│   ├── r_draw.h
│   ├── r_draw_charset.c
│   ├── r_draw_circle.c
│   ├── r_draw_image.c
│   ├── r_draw_line.c
│   ├── r_draw_polygon.c
│   ├── r_framestats.h
│   ├── r_hud.c
│   ├── r_lighting.h
│   ├── r_lightmaps.c
│   ├── r_lightmaps.h
│   ├── r_lightmaps_internal.h
│   ├── r_local.h
│   ├── r_main.c
│   ├── r_matrix.c
│   ├── r_matrix.h
│   ├── r_misc.c
│   ├── r_misc.cpp
│   ├── r_model.c
│   ├── r_netgraph.c
│   ├── r_palette.c
│   ├── r_part.c
│   ├── r_part_trails.c
│   ├── r_particles_qmb.c
│   ├── r_particles_qmb.h
│   ├── r_particles_qmb_spawn.c
│   ├── r_particles_qmb_trails.c
│   ├── r_performance.c
│   ├── r_performance.h
│   ├── r_program.h
│   ├── r_refrag.c
│   ├── r_renderer.h
│   ├── r_renderer_structure.h
│   ├── r_rlight.c
│   ├── r_rmain.c
│   ├── r_rmisc.c
│   ├── r_shared.h
│   ├── r_sprite3d.c
│   ├── r_sprite3d.h
│   ├── r_sprite3d_internal.h
│   ├── r_sprites.c
│   ├── r_state.h
│   ├── r_states.c
│   ├── r_texture.c
│   ├── r_texture.h
│   ├── r_texture_cvars.c
│   ├── r_texture_internal.h
│   ├── r_texture_load.c
│   ├── r_texture_util.c
│   ├── r_trace.h
│   ├── r_vao.h
│   ├── render.h
│   ├── resource.h
│   ├── rulesets.c
│   ├── rulesets.h
│   ├── sbar.c
│   ├── sbar.h
│   ├── screen.h
│   ├── server.h
│   ├── settings.h
│   ├── settings_page.c
│   ├── settings_page.h
│   ├── sha1.c
│   ├── sha1.h
│   ├── sha3.c
│   ├── sha3.h
│   ├── skin.c
│   ├── snd_main.c
│   ├── snd_mem.c
│   ├── snd_mix.c
│   ├── snd_qizmo.c
│   ├── snd_voip.c
│   ├── spritegn.h
│   ├── stats_grid.c
│   ├── stats_grid.h
│   ├── sv_ccmds.c
│   ├── sv_demo.c
│   ├── sv_demo_misc.c
│   ├── sv_demo_qtv.c
│   ├── sv_ents.c
│   ├── sv_init.c
│   ├── sv_log.h
│   ├── sv_login.c
│   ├── sv_main.c
│   ├── sv_master.c
│   ├── sv_mod_frags.c
│   ├── sv_mod_frags.h
│   ├── sv_move.c
│   ├── sv_nchan.c
│   ├── sv_null.c
│   ├── sv_phys.c
│   ├── sv_save.c
│   ├── sv_send.c
│   ├── sv_sys_unix.c
│   ├── sv_sys_win.c
│   ├── sv_user.c
│   ├── sv_world.c
│   ├── sv_world.h
│   ├── sys.h
│   ├── sys_osx.m
│   ├── sys_posix.c
│   ├── sys_sdl2.c
│   ├── sys_win.c
│   ├── teamplay.c
│   ├── teamplay.h
│   ├── teamplay_locfiles.c
│   ├── textencoding.c
│   ├── textencoding.h
│   ├── tp_msgs.c
│   ├── tp_msgs.h
│   ├── tp_triggers.c
│   ├── tp_triggers.h
│   ├── tr_types.h
│   ├── utils.c
│   ├── utils.h
│   ├── version.c
│   ├── version.h
│   ├── vfs.h
│   ├── vfs_doomwad.c
│   ├── vfs_gzip.c
│   ├── vfs_mmap.c
│   ├── vfs_os.c
│   ├── vfs_pak.c
│   ├── vfs_tar.c
│   ├── vfs_tar.h
│   ├── vfs_tcp.c
│   ├── vfs_zip.c
│   ├── vid.h
│   ├── vid_common_gl.c
│   ├── vid_sdl2.c
│   ├── vid_vsync.c
│   ├── vk_blending.c
│   ├── vk_buffers.c
│   ├── vk_debug.c
│   ├── vk_draw.c
│   ├── vk_graphics_pipeline.c
│   ├── vk_instance.c
│   ├── vk_lightmaps.c
│   ├── vk_local.h
│   ├── vk_main.c
│   ├── vk_md3.c
│   ├── vk_misc.c
│   ├── vk_physical_devices.c
│   ├── vk_renderpass.c
│   ├── vk_sdl.c
│   ├── vk_swapchain.c
│   ├── vk_vao.c
│   ├── vk_vao.h
│   ├── vk_window_surface.c
│   ├── vm.c
│   ├── vm.h
│   ├── vm_interpreted.c
│   ├── vm_local.h
│   ├── vm_x86.c
│   ├── vx_camera.c
│   ├── vx_camera.h
│   ├── vx_coronas.c
│   ├── vx_stuff.c
│   ├── vx_stuff.h
│   ├── vx_tracker.c
│   ├── vx_tracker.h
│   ├── vx_vertexlights.c
│   ├── vx_vertexlights.h
│   ├── wad.c
│   ├── wad.h
│   ├── winquake.rc
│   ├── xsd.c
│   ├── xsd.h
│   ├── xsd_document.c
│   ├── xsd_document.h
│   ├── zone.c
│   └── zone.h
└── vcpkg.json

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/ISSUE_TEMPLATE/bug-report.md
================================================
---
name: Bug report
about: Create a report to help us improve
title: 'BUG: <description>'
labels: ''
assignees: ''

---

Please search for existing issues and check for potential duplicates before filing yours.

**ezQuake version:**
(Specify the Git commit hash if using a non-stable build - this is available through the `/version` command)

**OS/device including version:**
Specify GPU model, drivers, and the renderer (classic or modern) if graphics-related.

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
A clear and concise description of what you expected to happen.

**Screenshots**
If applicable, add screenshots to help explain your problem.
Also please attach your config (.cfg) file

**Additional context**
Add any other context about the problem here.


================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for this project
title: 'REQ: <description>'
labels: ''
assignees: ''

---

Please ensure that your request is predominantly client-based, and not better suited to being logged with the server or mod aspects of QuakeWorld (e.g. mvdsv or ktx)

**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

**Describe the solution you'd like**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.

**Impact on server or mods**


================================================
FILE: .github/workflows/main.yml
================================================
name: main

on:
  push:
    # Only build branches on push, tags will be handled by 'release' job.
    branches:
      - '**'
  pull_request:
  workflow_dispatch:
  release:
    types: [published]

jobs:
  build:
    strategy:
      matrix:
        include:
          - os: windows-latest
            configurePreset: msbuild-x64
            buildPreset: msbuild-x64-release
            name: ezQuake-windows-x64
            artifact: "ezquake.exe"
            container: null
          - os: macos-latest
            configurePreset: macos-arm64
            buildPreset: macos-arm64-release
            name: ezQuake-macOS-arm64
            artifact: "ezQuake.zip"
            packages: ["autoconf", "automake", "libtool"]
            container: null
          - os: macos-latest
            configurePreset: macos-x64
            buildPreset: macos-x64-release
            name: ezQuake-macOS-x64
            artifact: "ezQuake.zip"
            packages: ["autoconf", "automake", "libtool"]
            container: null
          - os: ubuntu-latest
            configurePreset: dynamic
            buildPreset: dynamic-release
            name: ezQuake-linux-x86_64
            artifact: "ezQuake-x86_64.AppImage"
            cflags: "-march=nehalem"
            packages: ["build-essential", "ca-certificates", "cmake", "curl", "file", "git", "libcurl4-openssl-dev", "libexpat1-dev", "libfreetype-dev", "libfuse3-dev", "libjansson-dev", "libjpeg-dev", "libminizip-dev", "libpcre2-dev", "libpng-dev", "libsdl2-2.0-0", "libsdl2-dev", "libsndfile1-dev", "libspeex-dev", "libspeexdsp-dev", "ninja-build", "unzip"]
            container:
              image: debian:testing
              options: --privileged

    name: ${{ matrix.name }}
    runs-on: ${{ matrix.os }}
    container: ${{ matrix.container }}

    steps:
    - name: Prepare Linux environment
      run: |
        apt-get -qq update && apt-get -qq install --no-install-recommends ${{ join(matrix.packages, ' ') }}
        git config --global --add safe.directory $PWD
      if: matrix.os == 'ubuntu-latest'

    - name: Prepare macOS environment
      run: brew install -q ${{ join(matrix.packages, ' ') }}
      if: matrix.os == 'macos-latest'

    - name: Check out code
      uses: actions/checkout@v4
      with:
        submodules: true
        # To get correct revision which is needed by server to detect certain client bugs
        fetch-depth: 0

    - name: Fetch upstream tags for version metadata
      run: |
          git remote add upstream https://github.com/QW-Group/ezquake-source.git
          git fetch --tags --no-recurse-submodules upstream
      if: github.repository != 'QW-Group/ezquake-source'

    - name: Set library build type to release
      shell: bash
      run: |
        # Hopefully overrideable via environment in the future. Done here as
        # vcpkg is chainloaded before cmake, and doesn't seem to apply args.
        # Avoids building both -dbg and -rel versions of static libraries.
        for x in {cmake/triplets/*,vcpkg/triplets/{*,community/*}}; do
          if [[ -f $x ]]; then
            echo >> $x
            echo 'set(VCPKG_BUILD_TYPE release)' >> $x
          fi
        done
      if: matrix.os != 'ubuntu-latest'

    - uses: lukka/get-cmake@latest
      with:
        cmakeVersion: "~3.28.0"
      if: matrix.os != 'ubuntu-latest'

    - name: Setup vcpkg
      uses: lukka/run-vcpkg@v11
      if: matrix.os != 'ubuntu-latest'

    - name: Run CMake
      uses: lukka/run-cmake@v10
      with:
        configurePreset: ${{ matrix.configurePreset }}
        buildPreset: ${{ matrix.buildPreset }}
      env:
        CFLAGS: ${{ matrix.cflags }}

    - name: Generate Linux AppImage
      run: |
        export EXECUTABLE=$(echo build-${{ matrix.configurePreset }}/Release/ezquake*)
        ./misc/appimage/appimage-manual_creation.sh
        mv ezQuake-x86_64.AppImage build-${{ matrix.configurePreset }}/Release/
      if: matrix.os == 'ubuntu-latest'

    - name: Preserve macOS executable bit
      run: |
        zip -r -9 ezQuake.zip ezQuake.app
      working-directory: build-${{ matrix.configurePreset }}/Release
      if: matrix.os == 'macos-latest'

    - name: Archive client
      uses: actions/upload-artifact@v4
      with:
        name: ${{ matrix.name }}
        path: |
          build-${{ matrix.configurePreset }}/Release/${{ matrix.artifact }}
        compression-level: 9

  macos-universal:
    needs: build

    name: "ezQuake-macOS-universal"
    runs-on: macos-latest

    steps:
    - name: Check out code
      uses: actions/checkout@v4

    - name: Download ARM64 Build
      uses: actions/download-artifact@v4
      with:
        name: ezQuake-macOS-arm64
        path: artifacts/arm64

    - name: Download Intel Build
      uses: actions/download-artifact@v4
      with:
        name: ezQuake-macOS-x64
        path: artifacts/x64

    - name: Create Universal Binary
      run: |
        (cd artifacts/x64 && unzip -qq ezQuake.zip) && (cd artifacts/arm64 && unzip -qq ezQuake.zip)
        cp -r artifacts/arm64/ezQuake.app .
        lipo -create -output ezQuake.app/Contents/MacOS/ezQuake \
            artifacts/x64/ezQuake.app/Contents/MacOS/ezQuake \
            artifacts/arm64/ezQuake.app/Contents/MacOS/ezQuake
        codesign --force --sign - --entitlements dist/macOS/ezquake.entitlements.plist --options runtime --timestamp ezQuake.app
        zip -r ezQuake-macOS-universal.zip ezQuake.app

    - name: Delete macOS arch specific builds
      uses: geekyeggo/delete-artifact@v5
      with:
        name: |
          ezQuake-macOS-arm64
          ezQuake-macOS-x64

    - name: Upload Build Artifact
      uses: actions/upload-artifact@v4
      with:
        name: ezQuake-macOS-universal
        path: ezQuake-macOS-universal.zip
        compression-level: 9

  upload:
    if: github.repository == 'QW-group/ezquake-source' && ((github.event_name == 'push' && github.ref == 'refs/heads/master') || github.event_name == 'release')
    needs: [macos-universal]
    runs-on: ubuntu-latest
    steps:
      - name: Download Artifacts
        uses: actions/download-artifact@v4
        with:
          path: artifacts

      - name: Checkout
        uses: actions/checkout@v4
        with:
          path: ezquake
          submodules: true
          # To get correct revision when generating version.json for source release tarball
          fetch-depth: 0
        if: github.event_name == 'release'

      - name: Get release date
        run: |
          REF_NAME="${{ github.ref_name || github.event.release.tag_name }}"
          RELEASE_DATE=$(git log -1 --format=%cI "$REF_NAME")
          echo "RELEASE_DATE=$RELEASE_DATE" >> $GITHUB_ENV
        working-directory: ezquake
        if: github.event_name == 'release'

      - name: Collect GitHub release artifacts
        run: |
          set -e

          dist_dir="${GITHUB_WORKSPACE}/dist"
          mkdir "${dist_dir}"

          # Reset timestamp to time of commit before compression
          find "artifacts" -type f -exec touch --date="${RELEASE_DATE}" {} +

          # Set executable bit for all files
          find "artifacts" -type f -exec chmod 755 {} +

          # Recompress before attaching to release, avoiding double-zip of macOS
          (
            cd artifacts
            for target in *; do
              if ls "${target}"/*.zip &> /dev/null; then
                cp "${target}"/*.zip "${dist_dir}/${target}.zip"
              else
                (cd "${target}"; zip -o -9 "${dist_dir}/${target}.zip" *)
              fi
            done;
          )

          # Generate source release with submodule, version.json etc
          (
            cd "${GITHUB_WORKSPACE}/ezquake"
            dist/gen-release.sh
            mv *.tar.gz "${dist_dir}/"
          )

          find "${dist_dir}" -type f -execdir sha256sum {} \; > "checksums.txt"
          mv "checksums.txt" "${dist_dir}/"

          # Reset timestamp to time of commit for all release artifacts
          find "${dist_dir}" -type f -exec touch --date="${RELEASE_DATE}" {} +

          echo "Release artifacts:"
          ls -lR "${dist_dir}"

          echo "Checksums:"
          cat "${dist_dir}/checksums.txt"

          echo "GITHUB_ARTIFACTS=$dist_dir" >> $GITHUB_ENV
        if: github.event_name == 'release'

      - name: Attach artifacts to GitHub release
        uses: softprops/action-gh-release@v2
        with:
          files: ${{ env.GITHUB_ARTIFACTS }}/*
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        if: github.event_name == 'release'

      - name: Prepare Upload Environemnt
        run: |
          sudo apt-get -qq update
          sudo apt-get -qq --no-install-recommends install openssh-client

      - name: Setup SSH
        run: |
          ssh-agent -a $SSH_AUTH_SOCK > /dev/null
          ssh-add - <<< "${{ secrets.SSH_PRIVATE_KEY }}"
        env:
          SSH_AUTH_SOCK: /tmp/ssh_agent.sock

      - name: Prepare upload to builds.quakeworld.nu
        run: |
          # Build file structure for uploading
          # snapshots:
          #  upload/snapshots/latest/$os/$arch/$filename
          #  upload/snapshots/$os/$arch/$prefix_$filename
          # releases:
          #  upload/releases/latest/$os/$arch/$filename
          #  upload/releases/$tag/$os/$arch/$filename

          set -e

          upload_dir="${GITHUB_WORKSPACE}/upload"
          if [[ $GITHUB_REF == refs/tags/* ]]; then
            main_dir="${upload_dir}/releases/${{ github.ref_name }}"
            latest_dir="${upload_dir}/releases/latest"
            prefix=""
            upload_prefix="releases"
          else
            main_dir="${upload_dir}/snapshots"
            latest_dir="${upload_dir}/snapshots/latest"
            date=$(TZ="Europe/Amsterdam" date "+%Y%m%d-%H%M%S")
            prefix="${date}_${GITHUB_SHA::7}_"
            upload_prefix="snapshots"
          fi

          # Collect upload structure
          for artifact in artifacts/*/*; do
            artifact_file=$(basename "${artifact}")
            artifact_dir=$(dirname "${artifact}")

            IFS='-' read -r ezq os arch <<< "${artifact_dir}"

            mkdir -p "${main_dir}/${os}/${arch}" "${latest_dir}/${os}/${arch}"

            cp "${artifact}" "${main_dir}/${os}/${arch}/${prefix}${artifact_file}"
            cp "${artifact}" "${latest_dir}/${os}/${arch}/${artifact_file}"
          done

          # Set executable bit for all files
          find "${upload_dir}" -type f -exec chmod 755 {} +

          # Generate checksums
          for artifact in $(find "${upload_dir}" -type f); do
            artifact_file=$(basename "${artifact}")
            artifact_dir=$(dirname "${artifact}")
            (cd "${artifact_dir}" && md5sum "${artifact_file}" > "${artifact_file}.md5")
          done

          # Reset timestamp to time of commit
          find "${upload_dir}" -type f -exec touch --date="${RELEASE_DATE}" {} +

          echo "Upload artifacts:"
          ls -lR "${upload_dir}"

          echo "UPLOAD_PREFIX=${upload_prefix}" >> $GITHUB_ENV

      - name: Upload to builds.quakeworld.nu
        env:
          SSH_AUTH_SOCK: /tmp/ssh_agent.sock
        run: |
          sftp -rp -o 'StrictHostKeyChecking no' -o 'UserKnownHostsFile /dev/null' -P ${{ secrets.SFTP_PORT }} ${{ secrets.SFTP_USERNAME }}@${{ secrets.SFTP_HOST }}:/${{ env.UPLOAD_PREFIX }} <<< $'put -rp upload/${{ env.UPLOAD_PREFIX }}/*'


================================================
FILE: .gitignore
================================================
ezquake
ezquake.exe
ezquake-*.exe
ezquake-*-*
ezQuake.aps
*.vcxproj*.user
*.vcxproj*.cache
SysPrintf.log
.ezquake/
.vs
/.vscode
*.json.c
*.glsl.c
vcpkg_installed/
src/.msversion.h
/build*/

!.gitignore

# Local documentation files (not for repository)
CR*.md
EZQUAKE_HUD_*.md
TRACKER_*.md


================================================
FILE: .gitmodules
================================================
[submodule "src/qwprot"]
	path = src/qwprot
	url = https://github.com/QW-Group/qwprot.git
	branch = master
[submodule "vcpkg"]
	path = vcpkg
	url = https://github.com/Microsoft/vcpkg


================================================
FILE: BUILD.md
================================================
# Compiling ezQuake

## Introduction

To provide a consistent build on Windows, Linux, macOS and BSD across various compilers,
dynamic and static linking, all described in one single file, [CMake][cmake] is used, with
the help of [vcpkg][vcpkg] to support static linking.

In its most basic form on Linux/BSD, with dynamic linking, a build can be invoked as follows:

```shell
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release # Configuration phase
make -j $(nproc)                    # Build phase
```

This will locate all system-wide dependencies and show a clear message if a mandatory
dependency is not installed. Check the output to see if it matches your expectations
in regard to optional dependencies.

When configure phase passes, the build phase will produce a dynamically linked binary.
The resulting binary can be found in the build directory at `build/ezquake-linux-x86_64`.

The default mode of compilation is to not show the full command line, only errors and
warnings. To enable verbose mode, set `CMAKE_VERBOSE_MAKEFILE` to `ON`.

While CMake can be configured via `CMAKE_C_CFLAGS`, it also supports picking up `CFLAGS`
from the aptly named environment variable `CFLAGS`.

The ezQuake build also declares a few options on its own to customize the resulting executable.
Unfortunately CMake CLI has no built-in command to list them, so check `CMakeLists.txt`:

```shell
grep -E ^option CMakeLists.txt
```

Putting the above customizations to work may look like this:
```shell
export CFLAGS=-march=native
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_VERBOSE_MAKEFILE=ON -DRENDERER_CLASSIC_OPENGL=OFF
make -j $(nproc)
```

CMake caches as much as possible when the build is initialized to allow for fast iteration
when developing. Should an option not activate as expected, removing the build directory
and starting over is always a failsafe. Static dependencies are [cached elsewhere](#Caches)
and will not have to be rebuilt if only the build directory is removed.

## CMake Presets

[CMake presets][cmake-presets] can be seen as aliases that associates a number of build
settings to a name. While this may not add much value for the trivial dynamically linked
Linux/BSD build, the presets do add some desirable conveniences for other targets as is 
seen in later sections.

There are two types of presets relevant to the ezQuake build:

* Configuration Presets
* Build Presets

The available presets can be listed via:

```shell
$ cmake --list-presets
Available configure presets:

  "mingw64-x64-cross"
  "mingw64-i686-cross"
  ...

$ cmake --build --list-presets
Available build presets:

  "msbuild-x64-debug"                 - Build msbuild-x64 debug
  "msbuild-x64-release"               - Build msbuild-x64 release
  "msbuild-x64-relwithdebinfo"        - Build msbuild-x64 release with debug info
  ...
```

These can be invoked, regardless of underlying build system, via:

```shell
# Creates build-dynamic directory, and initializes the build
cmake --preset dynamic 

# Builds executable in build-dynamic/Release/ezquake
cmake --build --preset dynamic-release

# ...or if skipping the build preset, pass path to build directory instead
camke --build build-dynamic --config Release
```

The build directory is by convention always called `build-${presetName}` when using presets.

All declared presets are of type _Multi-Config_ so they're able to produce _Debug_,
_Release_, and _RelWithDebInfo_ variants from the same configuration.

While build presets are somewhat optional when building from the terminal, they add
convenience when working from within an editor with CMake support.

## Static linking

Static builds are supported on Windows, Linux and macOS and offloads building of
dependencies to [vcpkg][vcpkg]. The CMake configuration is agnostic to dynamic or
static linking and enabling of static linking happens via parametrizing the CMake
invocation with the vcpkg toolchain. This is done automatically by using any of the
Windows, macOS, or the static presets.

Before starting a static build, vcpkg needs to be initialized. This is done by invoking
`bootstrap.sh` on *nix-like platforms. Depending on which [type of build](#Visual-Studio)
is used on Windows, the `bootstrap.ps1` PowerShell script does the equivalent.

The invocation of a Linux static build is near identical to a dynamic build:
```shell
./bootstrap.sh
cmake --preset static
cmake --build build-static --config Release
```

If you haven't compiled a static version before, or if the project has updated the vcpkg
repository version since last build, this will take a few minutes.

Note that for Linux/BSD builds, you have to install the appropriate X11/Wayland development
headers for the static build to work with each of those targets.

## Cross-Compilation to Windows

Any *nix environment can produce a Windows build via:
```shell
./bootstrap.sh
cmake --preset mingw64-x64-cross
cmake --build build-mingw64-x64-cross --config Release
```

Be sure to install mingw-w64 before running the above commands. A native compiler is also needed as parts of the vcpkg
build need to execute on the host.

## Visual Studio

### CMake Mode

Microsoft is highly invested in both CMake and vcpkg, so native support in Visual Studio has
existed for a number of years by now. Importing the project in Visual Studio 17 detects the
CMake and vcpkg combination and builds the dependencies.

Once done, the build presets will be listed in the _Configurations_ drop down. The `msbuild-*`
or `ninja-msvc-*` related build presets are typically a good fit.

To run ezQuake against a specific game directory, go via menu to _Debug_ > _Debug and Launch
Settings for ezquake_ which will open up the `launch_schema.json` file where you introduce
`currentDir` similar to the following:

```json
{
  "version": "...",
  "defaults": {},
  "configurations": [
    {
      "type": "...",
      "currentDir": "C:\\Quake"
    }
  ]
}
```

### Visual Studio Solution Mode

As the Visual Studio Solution is generated first after CMake configuration phase has finished,
the `./bootstrap.ps1` PowerShell script must be invoked the first time to initialize vcpkg.

```shell
powershell -File bootstrap.ps1
cmake --preset msbuild-x64
```

Once done you will have a Visual Studio Solution in `build-msbuild-x64/ezquake.sln`.
Any compilation changes that should be upstreamed must be updated in `CMakeLists.txt`.

During the configuration phase, if a `ezquake.vcxproj.user` file exists in the top directory,
this will be copied to the build directory next to the Visual Studio Solution to allow for
persisting custom settings as the solution is generated.

## Xcode / macOS

To simplify bundling static linking is used to build ezQuake on macOS, so start off by
invoking `bootstrap.sh` first. When initializing for example the `macos-arm64` preset
an Xcode project will be produced at `build-macos-arm64/ezquake.xcodeproj` with similar
structure to that of Visual Studio.

The same preset is also used when building via the terminal:
```
./bootstrap.sh
cmake --preset macos-arm64
cmake --build build-macos-arm64 --config Release
```
This will produce `ezQuake.app` under `build-macos-arm64/Release/ezQuake.app` by invoking
`xcodebuild` behind the scenes to do the actual building and bundling.

## Caches

If you don't intend to build ezQuake again and want to reclaim some space, you can find the shared vcpkg cache at:

* All platforms
  * `./vcpkg/buildtrees`
* *nix
  * `~/.cache/vcpkg/`
* Windows
  * `c:\Users\$UserName\AppData\Local\vcpkg`

## Developer Tidbits

### Adding new files to the project

In [CMakeLists.txt](CMakeLists.txt) source files are categorized into their approximate use
cases (client, server, common, sys, etc), and this also applies to header files. The reason
for this is to serve editors with the correct context, and if generating either a Xcode or
Visual Studio project this categorization is also visualized in the project tree view.

Looking forward, this will allow adding a `ezquake-sv` target by just reusing the relevant
subset of source files.

### Managing static dependencies

Vcpkg is used in [manifest mode][vcpkg-manifest], with the dependencies declared in `vcpkg.json`.
While it's possible to lock dependencies at a specific version, this is not used today. Instead
the vcpkg submodule dictates the set of dependency versions the project relies on.

If adding a new mandatory dependency that static versions of ezQuake should use, first find it
at [vcpkg.io][vcpkg-list], and if missing, read up on [overlay ports][vcpkg-overlay].

### Target platforms

If a specific platform requires customizations to how the static dependencies are built a [_triplet_][vcpkg-triplets]
for this platform can be introduced. An example of such an override is the [x64 MinGW](cmake/triplets/x64-mingw-static.cmake)
triplet that adds `-march=nehalem` when building dependencies.

 [cmake]: https://cmake.org/
 [cmake-presets]: https://cmake.org/cmake/help/latest/manual/cmake-presets.7.html
 [cmake-cflags]: https://cmake.org/cmake/help/latest/envvar/CFLAGS.html
 [vcpkg]: https://learn.microsoft.com/en-us/vcpkg/
 [vcpkg-manifest]: https://learn.microsoft.com/en-us/vcpkg/concepts/manifest-mode
 [vcpkg-list]: https://vcpkg.io/en/
 [vcpkg-overlay]: https://learn.microsoft.com/en-us/vcpkg/concepts/overlay-ports
 [vcpkg-triplets]: https://learn.microsoft.com/en-us/vcpkg/users/triplets
 [vscmake]: https://learn.microsoft.com/en-us/cpp/build/cmake-projects-in-visual-studio


================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.22)

project(ezquake C)

if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    enable_language(OBJC)
endif()

option(USE_SYSTEM_LIBS          "Use system libraries instead of VCPKG"       ON)
option(RENDERER_MODERN_OPENGL   "Enable modern OpenGL renderer"               ON)
option(RENDERER_CLASSIC_OPENGL  "Enable classic OpenGL renderer"              ON)
option(DEBUG_MEMORY_ALLOCATIONS "Enable debug prints for memory allocations" OFF)
option(ENABLE_SANDBOX           "Enables application sandboxing (macOS)"      ON)
option(ENABLE_LTO               "Enable Link Time Optimization"               ON)

if(NOT RENDERER_CLASSIC_OPENGL AND NOT RENDERER_MODERN_OPENGL)
    message(FATAL_ERROR "At least one of RENDERER_CLASSIC_OPENGL or RENDERER_MODERN_OPENGL must be enabled.")
endif()

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)

include(GitUtils)
include(AddResources)
include(CheckIPOSupported)
include(CheckCCompilerFlag)
include(CheckDependency)

git_refresh_submodules()
git_extract_version(git_version)

# Xcode has its own LTO features.
if(ENABLE_LTO AND NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    check_ipo_supported(RESULT USE_LTO)
    if(USE_LTO)
        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO TRUE)
    else()
        message(FATAL_ERROR "Link Time Optimization requested, but not available.")
    endif()
endif()

if(ENABLE_LTO)
    message("-- Link Time Optimization: Enabled")
endif()

if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
    add_compile_options(
            /nologo
            /W3
            /WX-
            /diagnostics:column
    )

    set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded$<$<CONFIG:Debug>:Debug>)
    set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT $<$<CONFIG:Debug>:ProgramDatabase>)

    # Enable automatic parallelization of MSBuild
    set(CMAKE_VS_GLOBALS
            "UseMultiToolTask=true"
            "EnforceProcessCountAcrossBuilds=true"
    )

    if(EXISTS "${PROJECT_SOURCE_DIR}/ezquake.vcxproj.user")
        configure_file("${PROJECT_SOURCE_DIR}/ezquake.vcxproj.user" "${CMAKE_BINARY_DIR}/ezquake.vcxproj.user" COPYONLY)
    endif()
else()
    add_compile_options(
            -std=gnu89

            -Wall
            -Wno-pointer-to-int-cast
            -Wno-int-to-pointer-cast
            -Wno-strict-aliasing
            -Wno-deprecated-declarations

            -fvisibility=hidden

            -Werror=format
            -Werror=strict-prototypes
            -Werror=old-style-definition

            $<$<CONFIG:Release>:-Werror=unused-function>
            $<$<CONFIG:Release>:-Werror=unused-variable>
    )

    check_c_compiler_flag("-Wstrlcpy-strlcat-size" HAS_STRLCPY_STRLCAT_SIZE)
    if(HAS_STRLCPY_STRLCAT_SIZE)
        add_compile_options("-Werror=strlcpy-strlcat-size")
    endif()
    check_c_compiler_flag("-Wformat-truncation" HAS_FORMAT_TRUNCATION)
    if(HAS_FORMAT_TRUNCATION)
        add_compile_options("-Wno-error=format-truncation" "-Wno-format-truncation")
    endif()
    check_c_compiler_flag("-Wparentheses" HAS_PARENTHESIS)
    if(HAS_PARENTHESIS)
        add_compile_options("-Wno-parentheses")
    endif()
    check_c_compiler_flag("-Wmisleading-indentation" HAS_MISLEADING_INDENTATION)
    if(HAS_MISLEADING_INDENTATION)
        add_compile_options("-Wno-misleading-indentation")
    endif()
    # While not gnu89, it's in practice allowed by all supported compilers
    check_c_compiler_flag("-Wtypedef-redefinition" HAS_TYPE_REDEFINITION)
    if(HAS_TYPE_REDEFINITION)
        add_compile_options("-Wno-typedef-redefinition")
    endif()
    # Should mostly be fixed in mvdsv, and next sync can remove this
    check_c_compiler_flag("-Wshorten-64-to-32" HAS_SHORTEN_64_TO_32)
    if(HAS_TYPE_REDEFINITION)
        add_compile_options("-Wno-shorten-64-to-32")
    endif()
endif()

find_library(MATH m)

# Override by configuring with -DOpenGL_GL_PREFERENCE=GLVND
if(NOT OpenGL_GL_PREFERENCE)
    set(OpenGL_GL_PREFERENCE LEGACY)
endif()
find_package(OpenGL REQUIRED)
find_package(Threads REQUIRED)

# Args: target name, pkg-config name, vcpkg package name, vcpkg target name, extra args
check_dependency(Expat    "expat"      "EXPAT"              "expat::expat"                 REQUIRED CONFIG)
check_dependency(FreeType "freetype2"  "Freetype"           "Freetype::Freetype"           OPTIONAL)
check_dependency(JPEG     "libjpeg"    "JPEG"               "JPEG::JPEG"                   REQUIRED)
check_dependency(Jansson  "jansson"    "jansson"            "jansson::jansson"             REQUIRED)
check_dependency(MiniZip  "minizip"    "unofficial-minizip" "unofficial::minizip::minizip" REQUIRED)
check_dependency(PCRE2    "libpcre2-8" "PCRE2"              "pcre2::pcre2-8-static"        REQUIRED)
check_dependency(PNG      "libpng"     "PNG"                "PNG::PNG"                     REQUIRED)
check_dependency(SDL2     "sdl2"       "SDL2"               "SDL2::SDL2-static"            REQUIRED)
check_dependency(SndFile  "sndfile"    "SndFile"            "SndFile::sndfile"             REQUIRED)
check_dependency(Speex    "speex"      "Speex"              "SPEEX::SPEEX"                 OPTIONAL)
check_dependency(SpeexDSP "speexdsp"   "SpeexDSP"           "SPEEX::SPEEXDSP"              OPTIONAL)
check_dependency(cURL     "libcurl"    "CURL"               "CURL::libcurl"                REQUIRED CONFIG)
check_dependency(zlib     "zlib"       "ZLIB"               "ZLIB::ZLIB"                   REQUIRED)

if(USE_SYSTEM_LIBS AND HAVE_MINIZIP)
    find_path(EZQUAKE_MINIZIP_INCLUDE_DIR
            NAMES unzip.h
            HINTS ${MiniZip_INCLUDE_DIRS}
            PATH_SUFFIXES minizip
            REQUIRED
    )
endif()

if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    find_library(FRAMEWORK_APPKIT AppKit REQUIRED)
    find_library(FRAMEWORK_FOUNDATION Foundation REQUIRED)
    find_library(FRAMEWORK_CORESERVICES CoreServices REQUIRED)
    find_library(FRAMEWORK_GAMECONTROLLER GameController REQUIRED)
endif()

# Place special CMake targets in separate VS/Xcode folder
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set_property(GLOBAL PROPERTY VS_STARTUP_PROJECT "ezquake")

set(SOURCE_DIR ${PROJECT_SOURCE_DIR}/src)

set(common_headers
        ${SOURCE_DIR}/bspfile.h
        ${SOURCE_DIR}/cmd.h
        ${SOURCE_DIR}/cmdline_params.h
        ${SOURCE_DIR}/cmdline_params_ids.h
        ${SOURCE_DIR}/cmodel.h
        ${SOURCE_DIR}/common.h
        ${SOURCE_DIR}/crc.h
        ${SOURCE_DIR}/cvar.h
        ${SOURCE_DIR}/cvar_groups.h
        ${SOURCE_DIR}/fs.h
        ${SOURCE_DIR}/hash.h
        ${SOURCE_DIR}/macro_definitions.h
        ${SOURCE_DIR}/macro_ids.h
        ${SOURCE_DIR}/mathlib.h
        ${SOURCE_DIR}/net.h
        ${SOURCE_DIR}/parser.h
        ${SOURCE_DIR}/pmove.h
        ${SOURCE_DIR}/q_platform.h
        ${SOURCE_DIR}/q_shared.h
        ${SOURCE_DIR}/sha1.h
        ${SOURCE_DIR}/sha3.h
        ${SOURCE_DIR}/version.h
        ${SOURCE_DIR}/vfs.h
        ${SOURCE_DIR}/vfs_tar.h
        ${SOURCE_DIR}/zone.h
)
set(common
        ${SOURCE_DIR}/cmd.c
        ${SOURCE_DIR}/cmodel.c
        ${SOURCE_DIR}/com_msg.c
        ${SOURCE_DIR}/common.c
        ${SOURCE_DIR}/crc.c
        ${SOURCE_DIR}/cvar.c
        ${SOURCE_DIR}/fs.c
        ${SOURCE_DIR}/hash.c
        ${SOURCE_DIR}/mathlib.c
        ${SOURCE_DIR}/md4.c
        ${SOURCE_DIR}/net.c
        ${SOURCE_DIR}/net_chan.c
        ${SOURCE_DIR}/parser.c
        ${SOURCE_DIR}/pmove.c
        ${SOURCE_DIR}/pmovetst.c
        ${SOURCE_DIR}/q_shared.c
        ${SOURCE_DIR}/sha1.c
        ${SOURCE_DIR}/sha3.c
        ${SOURCE_DIR}/version.c
        ${SOURCE_DIR}/vfs_doomwad.c
        ${SOURCE_DIR}/vfs_gzip.c
        ${SOURCE_DIR}/vfs_mmap.c
        ${SOURCE_DIR}/vfs_os.c
        ${SOURCE_DIR}/vfs_pak.c
        ${SOURCE_DIR}/vfs_tar.c
        ${SOURCE_DIR}/vfs_tcp.c
        ${SOURCE_DIR}/vfs_zip.c
        ${SOURCE_DIR}/zone.c
        ${common_headers}
)
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/common" FILES ${common})
source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/common" FILES ${common_headers})

set(QWPROT_SOURCE_DIR ${SOURCE_DIR}/qwprot/src)
set(qwprot_headers
        ${QWPROT_SOURCE_DIR}/protocol.h
)
source_group(TREE ${QWPROT_SOURCE_DIR} PREFIX "Header Files/qwprot" FILES ${qwprot_headers})

set(server_headers
        ${SOURCE_DIR}/g_public.h
        ${SOURCE_DIR}/pr2.h
        ${SOURCE_DIR}/pr_comp.h
        ${SOURCE_DIR}/progdefs.h
        ${SOURCE_DIR}/progs.h
        ${SOURCE_DIR}/qwsvdef.h
        ${SOURCE_DIR}/server.h
        ${SOURCE_DIR}/sv_log.h
        ${SOURCE_DIR}/sv_mod_frags.h
        ${SOURCE_DIR}/sv_world.h
        ${SOURCE_DIR}/vm.h
        ${SOURCE_DIR}/vm_local.h
)
set(server
        ${SOURCE_DIR}/pr2_cmds.c
        ${SOURCE_DIR}/pr2_edict.c
        ${SOURCE_DIR}/pr2_exec.c
        ${SOURCE_DIR}/pr_cmds.c
        ${SOURCE_DIR}/pr_edict.c
        ${SOURCE_DIR}/pr_exec.c
        ${SOURCE_DIR}/sv_ccmds.c
        ${SOURCE_DIR}/sv_demo.c
        ${SOURCE_DIR}/sv_demo_misc.c
        ${SOURCE_DIR}/sv_demo_qtv.c
        ${SOURCE_DIR}/sv_ents.c
        ${SOURCE_DIR}/sv_init.c
        ${SOURCE_DIR}/sv_login.c
        ${SOURCE_DIR}/sv_main.c
        ${SOURCE_DIR}/sv_master.c
        ${SOURCE_DIR}/sv_mod_frags.c
        ${SOURCE_DIR}/sv_move.c
        ${SOURCE_DIR}/sv_nchan.c
        ${SOURCE_DIR}/sv_phys.c
        ${SOURCE_DIR}/sv_save.c
        ${SOURCE_DIR}/sv_send.c
        ${SOURCE_DIR}/sv_user.c
        ${SOURCE_DIR}/sv_world.c
        ${SOURCE_DIR}/vm.c
        ${SOURCE_DIR}/vm_interpreted.c
        ${SOURCE_DIR}/vm_x86.c
        ${server_headers}
)
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/server" FILES ${server})
source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/server" FILES ${server_headers})

if(RENDERER_MODERN_OPENGL OR RENDERER_CLASSIC_OPENGL)
    set(SHARED_GLSL_DIR ${SOURCE_DIR}/glsl/shared)
    add_resources(shaders_shared
            ${SHARED_GLSL_DIR}/fxaa.h.glsl
    )
    source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/shared_opengl" FILES ${shared_opengl})
    source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/shared_opengl" FILES ${shared_opengl_headers})
endif()

if(RENDERER_MODERN_OPENGL)
    set(MODERN_GLSL_DIR ${SOURCE_DIR}/glsl)
    add_resources(shaders_modern
            ${MODERN_GLSL_DIR}/common.glsl
            ${MODERN_GLSL_DIR}/constants.glsl
            ${MODERN_GLSL_DIR}/draw_aliasmodel.fragment.glsl
            ${MODERN_GLSL_DIR}/draw_aliasmodel.vertex.glsl
            ${MODERN_GLSL_DIR}/draw_sprites.fragment.glsl
            ${MODERN_GLSL_DIR}/draw_sprites.vertex.glsl
            ${MODERN_GLSL_DIR}/draw_world.fragment.glsl
            ${MODERN_GLSL_DIR}/draw_world.vertex.glsl
            ${MODERN_GLSL_DIR}/fx_world_geometry.fragment.glsl
            ${MODERN_GLSL_DIR}/fx_world_geometry.vertex.glsl
            ${MODERN_GLSL_DIR}/hud_draw_circle.fragment.glsl
            ${MODERN_GLSL_DIR}/hud_draw_circle.vertex.glsl
            ${MODERN_GLSL_DIR}/hud_draw_image.fragment.glsl
            ${MODERN_GLSL_DIR}/hud_draw_image.geometry.glsl
            ${MODERN_GLSL_DIR}/hud_draw_image.vertex.glsl
            ${MODERN_GLSL_DIR}/hud_draw_line.fragment.glsl
            ${MODERN_GLSL_DIR}/hud_draw_line.vertex.glsl
            ${MODERN_GLSL_DIR}/hud_draw_polygon.fragment.glsl
            ${MODERN_GLSL_DIR}/hud_draw_polygon.vertex.glsl
            ${MODERN_GLSL_DIR}/lighting.compute.glsl
            ${MODERN_GLSL_DIR}/post_process_screen.fragment.glsl
            ${MODERN_GLSL_DIR}/post_process_screen.vertex.glsl
            ${MODERN_GLSL_DIR}/simple.fragment.glsl
            ${MODERN_GLSL_DIR}/simple.vertex.glsl
            ${MODERN_GLSL_DIR}/simple3d.fragment.glsl
            ${MODERN_GLSL_DIR}/simple3d.vertex.glsl
    )

    set(modern_opengl_headers
            ${SOURCE_DIR}/glm_brushmodel.h
            ${SOURCE_DIR}/glm_draw.h
            ${SOURCE_DIR}/glm_local.h
            ${SOURCE_DIR}/glm_particles.h
            ${SOURCE_DIR}/glm_texture_arrays.h
            ${SOURCE_DIR}/glm_vao.h
    )
    set(modern_opengl
            ${SOURCE_DIR}/glm_aliasmodel.c
            ${SOURCE_DIR}/glm_brushmodel.c
            ${SOURCE_DIR}/glm_draw.c
            ${SOURCE_DIR}/glm_framebuffer.c
            ${SOURCE_DIR}/glm_lightmaps.c
            ${SOURCE_DIR}/glm_main.c
            ${SOURCE_DIR}/glm_md3.c
            ${SOURCE_DIR}/glm_misc.c
            ${SOURCE_DIR}/glm_particles.c
            ${SOURCE_DIR}/glm_performance.c
            ${SOURCE_DIR}/glm_rmain.c
            ${SOURCE_DIR}/glm_rsurf.c
            ${SOURCE_DIR}/glm_sdl.c
            ${SOURCE_DIR}/glm_sprite.c
            ${SOURCE_DIR}/glm_sprite3d.c
            ${SOURCE_DIR}/glm_state.c
            ${SOURCE_DIR}/glm_texture_arrays.c
            ${SOURCE_DIR}/glm_vao.c
            ${modern_opengl_headers}
    )
    source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/modern_opengl" FILES ${modern_opengl})
    source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/modern_opengl" FILES ${modern_opengl_headers})
endif()

if(RENDERER_CLASSIC_OPENGL)
    set(CLASSIC_GLSL_DIR ${SOURCE_DIR}/glsl/glc)
    add_resources(shaders_classic
            ${CLASSIC_GLSL_DIR}/glc_aliasmodel_shadow.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_aliasmodel_shadow.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_aliasmodel_shell.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_aliasmodel_shell.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_aliasmodel_std.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_aliasmodel_std.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_caustics.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_caustics.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_draw_sprites.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_draw_sprites.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_hud_images.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_hud_images.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_post_process_screen.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_post_process_screen.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_sky.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_sky.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_turbsurface.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_turbsurface.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_world_drawflat.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_world_drawflat.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_world_secondpass.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_world_secondpass.vertex.glsl
            ${CLASSIC_GLSL_DIR}/glc_world_textured.fragment.glsl
            ${CLASSIC_GLSL_DIR}/glc_world_textured.vertex.glsl
    )

    set(classic_opengl_headers
            ${SOURCE_DIR}/glc_local.h
            ${SOURCE_DIR}/glc_matrix.h
            ${SOURCE_DIR}/glc_state.h
            ${SOURCE_DIR}/glc_vao.h
    )
    set(classic_opengl
            ${SOURCE_DIR}/glc_aliasmodel.c
            ${SOURCE_DIR}/glc_aliasmodel_mesh.c
            ${SOURCE_DIR}/glc_bloom.c
            ${SOURCE_DIR}/glc_brushmodel.c
            ${SOURCE_DIR}/glc_draw.c
            ${SOURCE_DIR}/glc_framebuffer.c
            ${SOURCE_DIR}/glc_lightmaps.c
            ${SOURCE_DIR}/glc_main.c
            ${SOURCE_DIR}/glc_matrix.c
            ${SOURCE_DIR}/glc_md3.c
            ${SOURCE_DIR}/glc_misc.c
            ${SOURCE_DIR}/glc_particles.c
            ${SOURCE_DIR}/glc_performance.c
            ${SOURCE_DIR}/glc_sdl.c
            ${SOURCE_DIR}/glc_sky.c
            ${SOURCE_DIR}/glc_sprite3d.c
            ${SOURCE_DIR}/glc_state.c
            ${SOURCE_DIR}/glc_surf.c
            ${SOURCE_DIR}/glc_turb_surface.c
            ${SOURCE_DIR}/glc_vao.c
            ${SOURCE_DIR}/glc_warp.c
            ${classic_opengl_headers}
    )
    source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/classic_opengl" FILES ${classic_opengl})
    source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/classic_opengl" FILES ${classic_opengl_headers})
endif()

set(common_opengl_headers
        ${SOURCE_DIR}/gl_framebuffer.h
        ${SOURCE_DIR}/gl_local.h
        ${SOURCE_DIR}/gl_sprite3d.h
        ${SOURCE_DIR}/gl_texture.h
        ${SOURCE_DIR}/gl_texture_internal.h
)
set(common_opengl
        ${SOURCE_DIR}/gl_aliasmodel.c
        ${SOURCE_DIR}/gl_aliasmodel_md3.c
        ${SOURCE_DIR}/gl_buffers.c
        ${SOURCE_DIR}/gl_debug.c
        ${SOURCE_DIR}/gl_drawcall_wrappers.c
        ${SOURCE_DIR}/gl_framebuffer.c
        ${SOURCE_DIR}/gl_misc.c
        ${SOURCE_DIR}/gl_program.c
        ${SOURCE_DIR}/gl_sdl.c
        ${SOURCE_DIR}/gl_sprite3d.c
        ${SOURCE_DIR}/gl_state.c
        ${SOURCE_DIR}/gl_texture.c
        ${SOURCE_DIR}/gl_texture_functions.c
        ${SOURCE_DIR}/vid_common_gl.c
        ${SOURCE_DIR}/r_vao.h
        ${common_opengl_headers}
)
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/common_opengl" FILES ${common_opengl})
source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/common_opengl" FILES ${common_opengl_headers})

set(common_renderer_headers
        ${SOURCE_DIR}/anorm_dots.h
        ${SOURCE_DIR}/anorms.h
        ${SOURCE_DIR}/draw.h
        ${SOURCE_DIR}/gl_model.h
        ${SOURCE_DIR}/modelgen.h
        ${SOURCE_DIR}/particles_classic.h
        ${SOURCE_DIR}/qmb_particles.h
        ${SOURCE_DIR}/quakedef.h
        ${SOURCE_DIR}/r_aliasmodel.h
        ${SOURCE_DIR}/r_aliasmodel_md3.h
        ${SOURCE_DIR}/r_brushmodel.h
        ${SOURCE_DIR}/r_brushmodel_sky.h
        ${SOURCE_DIR}/r_brushmodel_warpsurfaces_sin.h
        ${SOURCE_DIR}/r_buffers.h
        ${SOURCE_DIR}/r_chaticons.h
        ${SOURCE_DIR}/r_draw.h
        ${SOURCE_DIR}/r_framestats.h
        ${SOURCE_DIR}/r_lighting.h
        ${SOURCE_DIR}/r_lightmaps.h
        ${SOURCE_DIR}/r_lightmaps_internal.h
        ${SOURCE_DIR}/r_local.h
        ${SOURCE_DIR}/r_matrix.h
        ${SOURCE_DIR}/r_particles_qmb.h
        ${SOURCE_DIR}/r_performance.h
        ${SOURCE_DIR}/r_program.h
        ${SOURCE_DIR}/r_renderer.h
        ${SOURCE_DIR}/r_renderer_structure.h
        ${SOURCE_DIR}/r_shared.h
        ${SOURCE_DIR}/r_sprite3d.h
        ${SOURCE_DIR}/r_sprite3d_internal.h
        ${SOURCE_DIR}/r_state.h
        ${SOURCE_DIR}/r_texture.h
        ${SOURCE_DIR}/r_texture_internal.h
        ${SOURCE_DIR}/r_trace.h
        ${SOURCE_DIR}/render.h
        ${SOURCE_DIR}/spritegn.h
        ${SOURCE_DIR}/vx_camera.h
        ${SOURCE_DIR}/vx_stuff.h
        ${SOURCE_DIR}/vx_tracker.h
        ${SOURCE_DIR}/vx_vertexlights.h
)
set(common_renderer
        ${SOURCE_DIR}/r_aliasmodel.c
        ${SOURCE_DIR}/r_aliasmodel_md3.c
        ${SOURCE_DIR}/r_aliasmodel_mesh.c
        ${SOURCE_DIR}/r_aliasmodel_skins.c
        ${SOURCE_DIR}/r_atlas.c
        ${SOURCE_DIR}/r_bloom.c
        ${SOURCE_DIR}/r_brushmodel.c
        ${SOURCE_DIR}/r_brushmodel_bspx.c
        ${SOURCE_DIR}/r_brushmodel_load.c
        ${SOURCE_DIR}/r_brushmodel_sky.c
        ${SOURCE_DIR}/r_brushmodel_surfaces.c
        ${SOURCE_DIR}/r_brushmodel_textures.c
        ${SOURCE_DIR}/r_brushmodel_warpsurfaces.c
        ${SOURCE_DIR}/r_buffers.c
        ${SOURCE_DIR}/r_chaticons.c
        ${SOURCE_DIR}/r_draw.c
        ${SOURCE_DIR}/r_draw_charset.c
        ${SOURCE_DIR}/r_draw_circle.c
        ${SOURCE_DIR}/r_draw_image.c
        ${SOURCE_DIR}/r_draw_line.c
        ${SOURCE_DIR}/r_draw_polygon.c
        ${SOURCE_DIR}/r_hud.c
        ${SOURCE_DIR}/r_lightmaps.c
        ${SOURCE_DIR}/r_main.c
        ${SOURCE_DIR}/r_matrix.c
        ${SOURCE_DIR}/r_misc.c
        ${SOURCE_DIR}/r_model.c
        ${SOURCE_DIR}/r_netgraph.c
        ${SOURCE_DIR}/r_palette.c
        ${SOURCE_DIR}/r_part.c
        ${SOURCE_DIR}/r_part_trails.c
        ${SOURCE_DIR}/r_particles_qmb.c
        ${SOURCE_DIR}/r_particles_qmb_spawn.c
        ${SOURCE_DIR}/r_particles_qmb_trails.c
        ${SOURCE_DIR}/r_performance.c
        ${SOURCE_DIR}/r_refrag.c
        ${SOURCE_DIR}/r_rlight.c
        ${SOURCE_DIR}/r_rmain.c
        ${SOURCE_DIR}/r_rmisc.c
        ${SOURCE_DIR}/r_sprite3d.c
        ${SOURCE_DIR}/r_sprites.c
        ${SOURCE_DIR}/r_states.c
        ${SOURCE_DIR}/r_texture.c
        ${SOURCE_DIR}/r_texture_cvars.c
        ${SOURCE_DIR}/r_texture_load.c
        ${SOURCE_DIR}/r_texture_util.c
        ${SOURCE_DIR}/vx_camera.c
        ${SOURCE_DIR}/vx_coronas.c
        ${SOURCE_DIR}/vx_stuff.c
        ${SOURCE_DIR}/vx_vertexlights.c
        ${common_renderer_headers}
)
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/common_renderer" FILES ${common_renderer})
source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/common_renderer" FILES ${common_renderer_headers})

set(common_hud_headers
        ${SOURCE_DIR}/common_draw.h
        ${SOURCE_DIR}/hud.h
        ${SOURCE_DIR}/hud_common.h
        ${SOURCE_DIR}/hud_editor.h
)
set(common_hud
        ${SOURCE_DIR}/hud.c
        ${SOURCE_DIR}/hud_262.c
        ${SOURCE_DIR}/hud_ammo.c
        ${SOURCE_DIR}/hud_armor.c
        ${SOURCE_DIR}/hud_autoid.c
        ${SOURCE_DIR}/hud_centerprint.c
        ${SOURCE_DIR}/hud_clock.c
        ${SOURCE_DIR}/hud_common.c
        ${SOURCE_DIR}/hud_editor.c
        ${SOURCE_DIR}/hud_face.c
        ${SOURCE_DIR}/hud_frags.c
        ${SOURCE_DIR}/hud_gamesummary.c
        ${SOURCE_DIR}/hud_groups.c
        ${SOURCE_DIR}/hud_guns.c
        ${SOURCE_DIR}/hud_health.c
        ${SOURCE_DIR}/hud_items.c
        ${SOURCE_DIR}/hud_net.c
        ${SOURCE_DIR}/hud_performance.c
        ${SOURCE_DIR}/hud_qtv.c
        ${SOURCE_DIR}/hud_radar.c
        ${SOURCE_DIR}/hud_scores.c
        ${SOURCE_DIR}/hud_speed.c
        ${SOURCE_DIR}/hud_teaminfo.c
        ${SOURCE_DIR}/hud_tracking.c
        ${SOURCE_DIR}/hud_weapon_stats.c
        ${common_hud_headers}
)
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/common_hud" FILES ${common_hud})
source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/common_hud" FILES ${common_hud_headers})

set(DOCUMENTATION_DIR ${PROJECT_SOURCE_DIR})
add_resources(documentation
        ${DOCUMENTATION_DIR}/help_cmdline_params.json
        ${DOCUMENTATION_DIR}/help_commands.json
        ${DOCUMENTATION_DIR}/help_macros.json
        ${DOCUMENTATION_DIR}/help_variables.json
)

set(client_headers
        ${SOURCE_DIR}/Ctrl.h
        ${SOURCE_DIR}/Ctrl_EditBox.h
        ${SOURCE_DIR}/Ctrl_PageViewer.h
        ${SOURCE_DIR}/Ctrl_Tab.h
        ${SOURCE_DIR}/EX_FileList.h
        ${SOURCE_DIR}/EX_browser.h
        ${SOURCE_DIR}/EX_qtvlist.h
        ${SOURCE_DIR}/cdaudio.h
        ${SOURCE_DIR}/cl_slist.h
        ${SOURCE_DIR}/cl_view.h
        ${SOURCE_DIR}/client.h
        ${SOURCE_DIR}/config_manager.h
        ${SOURCE_DIR}/console.h
        ${SOURCE_DIR}/demo_controls.h
        ${SOURCE_DIR}/document_rendering.h
        ${SOURCE_DIR}/ez_button.h
        ${SOURCE_DIR}/ez_controls.h
        ${SOURCE_DIR}/ez_label.h
        ${SOURCE_DIR}/ez_listview.h
        ${SOURCE_DIR}/ez_listviewitem.h
        ${SOURCE_DIR}/ez_scrollbar.h
        ${SOURCE_DIR}/ez_scrollpane.h
        ${SOURCE_DIR}/ez_slider.h
        ${SOURCE_DIR}/ez_window.h
        ${SOURCE_DIR}/fchecks.h
        ${SOURCE_DIR}/fmod.h
        ${SOURCE_DIR}/fonts.h
        ${SOURCE_DIR}/help.h
        ${SOURCE_DIR}/ignore.h
        ${SOURCE_DIR}/image.h
        ${SOURCE_DIR}/input.h
        ${SOURCE_DIR}/keys.h
        ${SOURCE_DIR}/logging.h
        ${SOURCE_DIR}/menu.h
        ${SOURCE_DIR}/menu_demo.h
        ${SOURCE_DIR}/menu_ingame.h
        ${SOURCE_DIR}/menu_multiplayer.h
        ${SOURCE_DIR}/menu_options.h
        ${SOURCE_DIR}/menu_proxy.h
        ${SOURCE_DIR}/movie.h
        ${SOURCE_DIR}/movie_avi.h
        ${SOURCE_DIR}/mvd_utils.h
        ${SOURCE_DIR}/mvd_utils_common.h
        ${SOURCE_DIR}/qsound.h
        ${SOURCE_DIR}/qtv.h
        ${SOURCE_DIR}/rulesets.h
        ${SOURCE_DIR}/sbar.h
        ${SOURCE_DIR}/screen.h
        ${SOURCE_DIR}/settings.h
        ${SOURCE_DIR}/settings_page.h
        ${SOURCE_DIR}/demo_spawnwarn.h
        ${SOURCE_DIR}/stats_grid.h
        ${SOURCE_DIR}/sys.h
        ${SOURCE_DIR}/teamplay.h
        ${SOURCE_DIR}/textencoding.h
        ${SOURCE_DIR}/tp_msgs.h
        ${SOURCE_DIR}/tp_triggers.h
        ${SOURCE_DIR}/tr_types.h
        ${SOURCE_DIR}/utils.h
        ${SOURCE_DIR}/vid.h
        ${SOURCE_DIR}/wad.h
        ${SOURCE_DIR}/xsd.h
        ${SOURCE_DIR}/xsd_document.h
)
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    list(APPEND client_headers ${SOURCE_DIR}/movie_avi.h)
endif()
set(client
        ${SOURCE_DIR}/Ctrl.c
        ${SOURCE_DIR}/Ctrl_EditBox.c
        ${SOURCE_DIR}/Ctrl_PageViewer.c
        ${SOURCE_DIR}/Ctrl_ScrollBar.c
        ${SOURCE_DIR}/Ctrl_Tab.c
        ${SOURCE_DIR}/EX_FileList.c
        ${SOURCE_DIR}/EX_browser.c
        ${SOURCE_DIR}/EX_browser_net.c
        ${SOURCE_DIR}/EX_browser_pathfind.c
        ${SOURCE_DIR}/EX_browser_ping.c
        ${SOURCE_DIR}/EX_browser_qtvlist.c
        ${SOURCE_DIR}/EX_browser_sources.c
        ${SOURCE_DIR}/EX_qtvlist.c
        ${SOURCE_DIR}/cd_null.c
        ${SOURCE_DIR}/cl_cam.c
        ${SOURCE_DIR}/cl_cmd.c
        ${SOURCE_DIR}/cl_demo.c
        ${SOURCE_DIR}/cl_ents.c
        ${SOURCE_DIR}/cl_input.c
        ${SOURCE_DIR}/cl_main.c
        ${SOURCE_DIR}/cl_multiview.c
        ${SOURCE_DIR}/cl_nqdemo.c
        ${SOURCE_DIR}/cl_parse.c
        ${SOURCE_DIR}/cl_pred.c
        ${SOURCE_DIR}/cl_screen.c
        ${SOURCE_DIR}/cl_screenshot.c
        ${SOURCE_DIR}/cl_skygroups.c
        ${SOURCE_DIR}/cl_slist.c
        ${SOURCE_DIR}/cl_tent.c
        ${SOURCE_DIR}/cl_view.c
        ${SOURCE_DIR}/collision.c
        ${SOURCE_DIR}/common_draw.c
        ${SOURCE_DIR}/config_manager.c
        ${SOURCE_DIR}/console.c
        ${SOURCE_DIR}/demo_controls.c
        ${SOURCE_DIR}/document_rendering.c
        ${SOURCE_DIR}/ez_button.c
        ${SOURCE_DIR}/ez_controls.c
        ${SOURCE_DIR}/ez_label.c
        ${SOURCE_DIR}/ez_scrollbar.c
        ${SOURCE_DIR}/ez_scrollpane.c
        ${SOURCE_DIR}/ez_slider.c
        ${SOURCE_DIR}/ez_window.c
        ${SOURCE_DIR}/fchecks.c
        ${SOURCE_DIR}/fmod.c
        ${SOURCE_DIR}/fonts.c
        ${SOURCE_DIR}/fragstats.c
        ${SOURCE_DIR}/help.c
        ${SOURCE_DIR}/help_files.c
        ${SOURCE_DIR}/host.c
        ${SOURCE_DIR}/ignore.c
        ${SOURCE_DIR}/image.c
        ${SOURCE_DIR}/in_sdl2.c
        ${SOURCE_DIR}/irc.c
        ${SOURCE_DIR}/irc_filter.c
        ${SOURCE_DIR}/keys.c
        ${SOURCE_DIR}/logging.c
        ${SOURCE_DIR}/match_tools.c
        ${SOURCE_DIR}/match_tools_challenge.c
        ${SOURCE_DIR}/menu.c
        ${SOURCE_DIR}/menu_demo.c
        ${SOURCE_DIR}/menu_ingame.c
        ${SOURCE_DIR}/menu_multiplayer.c
        ${SOURCE_DIR}/menu_options.c
        ${SOURCE_DIR}/menu_proxy.c
        ${SOURCE_DIR}/movie.c
        ${SOURCE_DIR}/mvd_autotrack.c
        ${SOURCE_DIR}/mvd_utils.c
        ${SOURCE_DIR}/mvd_xmlstats.c
        ${SOURCE_DIR}/demo_spawnwarn.c
        ${SOURCE_DIR}/qtv.c
        ${SOURCE_DIR}/rulesets.c
        ${SOURCE_DIR}/sbar.c
        ${SOURCE_DIR}/settings_page.c
        ${SOURCE_DIR}/skin.c
        ${SOURCE_DIR}/snd_main.c
        ${SOURCE_DIR}/snd_mem.c
        ${SOURCE_DIR}/snd_mix.c
        ${SOURCE_DIR}/snd_qizmo.c
        ${SOURCE_DIR}/snd_voip.c
        ${SOURCE_DIR}/stats_grid.c
        ${SOURCE_DIR}/sys_sdl2.c
        ${SOURCE_DIR}/teamplay.c
        ${SOURCE_DIR}/teamplay_locfiles.c
        ${SOURCE_DIR}/textencoding.c
        ${SOURCE_DIR}/tp_msgs.c
        ${SOURCE_DIR}/tp_triggers.c
        ${SOURCE_DIR}/utils.c
        ${SOURCE_DIR}/vid_sdl2.c
        ${SOURCE_DIR}/vid_vsync.c
        ${SOURCE_DIR}/vx_tracker.c
        ${SOURCE_DIR}/wad.c
        ${SOURCE_DIR}/xsd.c
        ${SOURCE_DIR}/xsd_document.c
        ${client_headers}
)
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    list(APPEND client ${SOURCE_DIR}/movie_avi.c)
endif()
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/client" FILES ${client})
source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/client" FILES ${client_headers})

set(sys_headers ${SOURCE_DIR}/localtime.h)
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    set(sys ${SOURCE_DIR}/localtime_win.c)
else()
    set(sys
            ${SOURCE_DIR}/localtime_posix.c
            ${SOURCE_DIR}/linux_signals.c
    )
endif()
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    list(APPEND sys_headers
            ${SOURCE_DIR}/in_osx.h
    )
    list(APPEND sys
            ${SOURCE_DIR}/in_osx.m
            ${SOURCE_DIR}/sys_osx.m
    )
endif()
list(APPEND sys ${sys_headers})
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/sys" FILES ${sys})
source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/sys" FILES ${sys_headers})

set(central_headers
        ${SOURCE_DIR}/central.h
)
set(central
        ${SOURCE_DIR}/central.c
        ${central_headers}
)
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/central" FILES ${central})
source_group(TREE ${SOURCE_DIR} PREFIX "Header Files/central" FILES ${central_headers})

if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    set(main ${SOURCE_DIR}/sys_win.c)
else()
    set(main ${SOURCE_DIR}/sys_posix.c)
endif()
source_group(TREE ${SOURCE_DIR} PREFIX "Source Files/main" FILES ${main})

get_target_property(version_major git_version VERSION_MAJOR)
get_target_property(version_minor git_version VERSION_MINOR)
get_target_property(version_patch git_version VERSION_PATCH)
get_target_property(version_build git_version REVISION)
get_target_property(version_commit git_version COMMIT)

# macOS icon
set(macos_icon "${PROJECT_SOURCE_DIR}/dist/macOS/ezquake.icns")
set_source_files_properties(${macos_icon} PROPERTIES MACOSX_PACKAGE_LOCATION Resources)

# Windows icon, and exe metadata
set(windows_icon "${CMAKE_CURRENT_BINARY_DIR}/ezQuake.rc")
set(EZQUAKE_RESOURCE_AUTHOR "QW-Group")
set(EZQUAKE_RESOURCE_NAME "ezQuake")
set(EZQUAKE_RESOURCE_DESCRIPTION "ezQuake - a QuakeWorld client")
set(EZQUAKE_RESOURCE_ICON "${PROJECT_SOURCE_DIR}/dist/windows/ezquake.ico")
set(EZQUAKE_RESOURCE_VERSION "${version_major},${version_minor},${version_patch},${version_build}")
set(EZQUAKE_RESOURCE_COMMIT "${version_commit}")
configure_file("${PROJECT_SOURCE_DIR}/dist/windows/ezQuake.rc.in" ${windows_icon} @ONLY)

if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    # Mark the executable as a non-console application
    set(TARGET_TYPE WIN32)
elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    # Mark the executable for bundling as .app
    set(TARGET_TYPE MACOSX_BUNDLE)
endif()

add_executable(ezquake ${TARGET_TYPE}
        ${main}
        ${sys}
        ${central}
        ${common}
        ${common_hud}
        ${server}
        ${client}

        ${common_opengl}
        ${common_renderer}
        $<$<BOOL:${RENDERER_MODERN_OPENGL}>:${modern_opengl}>
        $<$<BOOL:${RENDERER_CLASSIC_OPENGL}>:${classic_opengl}>

        ${qwprot_headers}

        $<IF:$<PLATFORM_ID:Darwin>,${macos_icon},>
        $<IF:$<PLATFORM_ID:Windows>,${windows_icon},>
)

target_include_directories(ezquake PRIVATE
        ${SOURCE_DIR}/qwprot/src
        ${EZQUAKE_MINIZIP_INCLUDE_DIR}
)

target_compile_definitions(ezquake PRIVATE
        BUILDSTRING="${CMAKE_SYSTEM_NAME}"
        CPUSTRING="${CMAKE_SYSTEM_PROCESSOR}"

        JSS_CAM
        USE_PR2
        WITH_NQPROGS

        $<$<BOOL:${DEBUG_MEMORY_ALLOCATIONS}>:DEBUG_MEMORY_ALLOCATIONS>
        $<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:WITH_RENDERING_TRACE>

        $<$<PLATFORM_ID:Darwin>:GL_SILENCE_DEPRECATION>

        $<$<BOOL:${RENDERER_MODERN_OPENGL}>:RENDERER_OPTION_MODERN_OPENGL>
        $<$<BOOL:${RENDERER_CLASSIC_OPENGL}>:RENDERER_OPTION_CLASSIC_OPENGL>

        WITH_PNG
        WITH_JPEG
        WITH_ZIP
        WITH_ZLIB

        $<$<BOOL:${HAVE_FREETYPE}>:EZ_FREETYPE_SUPPORT>
        $<$<BOOL:${HAVE_FREETYPE}>:EZ_FREETYPE_SUPPORT_STATIC>

        $<$<AND:$<BOOL:${HAVE_SPEEX}>,$<BOOL:${HAVE_SPEEXDSP}>>:WITH_SPEEX>

        PCRE2_CODE_UNIT_WIDTH=8
)

target_link_libraries(ezquake PRIVATE
        $<$<BOOL:${RENDERER_MODERN_OPENGL}>:shaders_modern>
        $<$<BOOL:${RENDERER_CLASSIC_OPENGL}>:shaders_classic>
        shaders_shared
        documentation
        git_version

        ${CMAKE_DL_LIBS}

        Dep::zlib
        Dep::cURL
        Dep::Expat
        Dep::JPEG
        Dep::PCRE2
        Dep::SDL2
        Dep::Jansson
        Dep::SndFile
        Dep::PNG
        Dep::MiniZip

        $<$<BOOL:${HAVE_FREETYPE}>:Dep::FreeType>

        $<$<AND:$<BOOL:${HAVE_SPEEX}>,$<BOOL:${HAVE_SPEEXDSP}>>:Dep::Speex>
        $<$<AND:$<BOOL:${HAVE_SPEEX}>,$<BOOL:${HAVE_SPEEXDSP}>>:Dep::SpeexDSP>

        OpenGL::GL
        Threads::Threads

        ${FRAMEWORK_APPKIT}
        ${FRAMEWORK_FOUNDATION}
        ${FRAMEWORK_CORESERVICES}
        ${FRAMEWORK_GAMECONTROLLER}
)

if(MATH)
    target_link_libraries(ezquake PRIVATE ${MATH})
endif()

if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    string(TOLOWER "ezQuake" EXECUTABLE_NAME)
elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    string(TOLOWER "ezquake" EXECUTABLE_NAME)
else()
    string(TOLOWER "ezquake-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}" EXECUTABLE_NAME)
endif()

set_target_properties(ezquake PROPERTIES OUTPUT_NAME ${EXECUTABLE_NAME})

if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    get_target_property(version git_version GIT_DESCRIBE)

    set_target_properties(ezquake PROPERTIES
            XCODE_ATTRIBUTE_PRODUCT_NAME                            "ezQuake"
            XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER               "com.ezquake.ezQuake"
            XCODE_ATTRIBUTE_MARKETING_VERSION                       "${version}"
            XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION                 "${version}"
            XCODE_ATTRIBUTE_LLVM_LTO                                $<IF:$<OR:$<CONFIG:Debug>,$<NOT:$<BOOL:${ENABLE_LTO}>>>,NO,Monolithic>
            XCODE_ATTRIBUTE_GCC_OPTIMIZATION_LEVEL                  $<IF:$<CONFIG:Debug>,0,3>
            XCODE_ATTRIBUTE_DEAD_CODE_STRIPPING                     YES
            XCODE_ATTRIBUTE_GENERATE_INFOPLIST_FILE                 YES
            XCODE_ATTRIBUTE_INFOPLIST_KEY_CFBundleDisplayName       "ezQuake"
            XCODE_ATTRIBUTE_INFOPLIST_KEY_LSApplicationCategoryType "public.app-category.action-games"
            XCODE_ATTRIBUTE_INFOPLIST_KEY_NSHumanReadableCopyright  "GNU General Public License, version 2"
            XCODE_ATTRIBUTE_INFOPLIST_FILE                          "${PROJECT_SOURCE_DIR}/dist/macOS/MacOSXBundleInfo.plist.in"
    )

    if(ENABLE_SANDBOX)
        set_target_properties(ezquake PROPERTIES
                XCODE_ATTRIBUTE_ENABLE_APP_SANDBOX                                         YES
                XCODE_ATTRIBUTE_ENABLE_HARDENED_RUNTIME                                    YES
                XCODE_ATTRIBUTE_CODE_SIGN_INJECT_BASE_ENTITLEMENTS[variant=Debug]          YES
                XCODE_ATTRIBUTE_CODE_SIGN_INJECT_BASE_ENTITLEMENTS[variant=RelWithDebInfo] YES
                XCODE_ATTRIBUTE_CODE_SIGN_INJECT_BASE_ENTITLEMENTS[variant=Release]        NO
                XCODE_ATTRIBUTE_CODE_SIGN_ENTITLEMENTS "dist/macOS/ezquake.entitlements.plist"
        )
    endif()
endif()


================================================
FILE: CMakePresets.json
================================================
{
    "version": 3,
    "cmakeMinimumRequired": {
        "major": 3,
        "minor": 22,
        "patch": 0
    },
    "configurePresets": [
        {
            "name": "template-common",
            "hidden": true,
            "binaryDir": "${sourceDir}/build-${presetName}",
            "cacheVariables": {
                "CMAKE_VERBOSE_MAKEFILE": "OFF",
                "CMAKE_COLOR_DIAGNOSTICS": "ON",
                "CMAKE_CONFIGURATION_TYPES": "Debug;RelWithDebInfo;Release"
            }
        },
        {
            "name": "template-vcpkg",
            "hidden": true,
            "inherits": "template-common",
            "cacheVariables": {
                "CMAKE_TOOLCHAIN_FILE": {
                    "type": "FILEPATH",
                    "value": "vcpkg/scripts/buildsystems/vcpkg.cmake"
                },
                "VCPKG_OVERLAY_TRIPLETS": "${sourceDir}/cmake/triplets",
                "VCPKG_LIBRARY_LINKAGE": "static",
                "VCPKG_CRT_LINKAGE": "dynamic",
                "VCPKG_INSTALL_OPTIONS": "--clean-after-build",
                "VCPKG_ENABLE_METRICS": "0",
                "VCPKG_APPLOCAL_DEPS": "OFF",
                "USE_SYSTEM_LIBS": "OFF"
            }
        },
        {
            "name": "template-gcc-mingw-cross",
            "hidden": true,
            "cacheVariables": {
                "CMAKE_SYSTEM_NAME": "Windows"
            }
        },
        {
            "name": "template-gcc-mingw-i686",
            "hidden": true,
            "inherits": "template-vcpkg",
            "cacheVariables": {
                "CMAKE_C_COMPILER": "i686-w64-mingw32-gcc",
                "CMAKE_CXX_COMPILER": "i686-w64-mingw32-g++",
                "CMAKE_RC_COMPILER": "i686-w64-mingw32-windres",
                "CMAKE_C_FLAGS": "-msse2"
            }
        },
        {
            "name": "template-gcc-mingw-x64",
            "hidden": true,
            "inherits": "template-vcpkg",
            "cacheVariables": {
                "CMAKE_C_COMPILER": "x86_64-w64-mingw32-gcc",
                "CMAKE_CXX_COMPILER": "x86_64-w64-mingw32-g++",
                "CMAKE_RC_COMPILER": "x86_64-w64-mingw32-windres",
                "CMAKE_C_FLAGS": "-march=nehalem"
            }
        },
        {
            "name": "msbuild-x64",
            "description": "Configure as Visual Studio project",
            "generator": "Visual Studio 17 2022",
            "inherits": "template-vcpkg",
            "cacheVariables": {
                "VCPKG_TARGET_TRIPLET": "x64-windows-static"
            },
            "condition": {
                "type": "equals",
                "lhs": "${hostSystemName}",
                "rhs": "Windows"
            }
        },
        {
            "name": "msbuild-arm64",
            "description": "Configure as Visual Studio project",
            "generator": "Visual Studio 17 2022",
            "inherits": "template-vcpkg",
            "cacheVariables": {
                "VCPKG_TARGET_TRIPLET": "arm64-windows-static"
            },
            "condition": {
                "type": "equals",
                "lhs": "${hostSystemName}",
                "rhs": "Windows"
            }
        },
        {
            "name": "msvc-x64",
            "description": "Configure using Ninja to build with msvc",
            "generator": "Ninja Multi-Config",
            "inherits": "template-vcpkg",
            "cacheVariables": {
                "VCPKG_TARGET_TRIPLET": "x64-windows-static"
            },
            "condition": {
                "type": "equals",
                "lhs": "${hostSystemName}",
                "rhs": "Windows"
            }
        },
        {
            "name": "mingw64-x64-shared",
            "hidden": true,
            "description": "Configure using Ninja to build with mingw64 for x64",
            "generator": "Ninja Multi-Config",
            "inherits": "template-gcc-mingw-x64",
            "architecture": {
                "value": "x64",
                "strategy": "external"
            },
            "cacheVariables": {
                "VCPKG_TARGET_TRIPLET": "x64-mingw-static",
                "CMAKE_SYSTEM_PROCESSOR": "x86_64"
            }
        },
        {
            "name": "mingw64-x64",
            "inherits": ["mingw64-x64-shared"],
            "condition": {
                "type": "equals",
                "lhs": "${hostSystemName}",
                "rhs": "Windows"
            }
        },
        {
            "name": "mingw64-x64-cross",
            "inherits": ["mingw64-x64-shared", "template-gcc-mingw-cross"],
            "condition": {
                "type": "notEquals",
                "lhs": "${hostSystemName}",
                "rhs": "Windows"
            }
        },
        {
            "name": "mingw64-i686-shared",
            "hidden": true,
            "description": "Configure with Ninja to build with mingw64 for i686",
            "generator": "Ninja Multi-Config",
            "inherits": ["template-gcc-mingw-i686"],
            "architecture": {
                "value": "x86",
                "strategy": "external"
            },
            "cacheVariables": {
                "VCPKG_TARGET_TRIPLET": "x86-mingw-static",
                "CMAKE_SYSTEM_PROCESSOR": "x86"
            }
        },
        {
            "name": "mingw64-i686",
            "inherits": ["mingw64-i686-shared"],
            "condition": {
                "type": "equals",
                "lhs": "${hostSystemName}",
                "rhs": "Windows"
            }
        },
        {
            "name": "mingw64-i686-cross",
            "inherits": ["mingw64-i686-shared", "template-gcc-mingw-cross"],
            "cacheVariables": {
                "CMAKE_SYSTEM_PROCESSOR": "i686"
            },
            "condition": {
                "type": "notEquals",
                "lhs": "${hostSystemName}",
                "rhs": "Windows"
            }
        },
        {
            "name": "macos",
            "hidden": true,
            "description": "Configure XCode project file",
            "generator": "Xcode",
            "inherits": "template-vcpkg",
            "condition": {
                "type": "equals",
                "lhs": "${hostSystemName}",
                "rhs": "Darwin"
            }
        },
        {
            "name": "macos-arm64",
            "displayName": "XCode (arm64)",
            "inherits": "macos",
            "cacheVariables": {
                "VCPKG_TARGET_TRIPLET": "arm64-osx",
                "CMAKE_OSX_ARCHITECTURES": "arm64",
                "CMAKE_OSX_DEPLOYMENT_TARGET": "11.0"
            }
        },
        {
            "name": "macos-x64",
            "displayName": "XCode (x64)",
            "inherits": "macos",
            "cacheVariables": {
                "VCPKG_TARGET_TRIPLET": "x64-osx",
                "CMAKE_OSX_ARCHITECTURES": "x86_64",
                "CMAKE_OSX_DEPLOYMENT_TARGET": "11.0"
            }
        },
        {
            "name": "dynamic",
            "description": "Configure XCode project file",
            "generator": "Ninja Multi-Config",
            "inherits": "template-common",
            "cacheVariables": {
                "USE_SYSTEM_LIBS": "ON"
            }
        },
        {
            "name": "static",
            "description": "Configure XCode project file",
            "generator": "Ninja Multi-Config",
            "inherits": "template-vcpkg"
        }
    ],
    "buildPresets": [
        {
            "name": "msbuild-x64-debug",
            "configurePreset": "msbuild-x64",
            "displayName": "Build msbuild-x64 debug",
            "description": "Build Visual Studio Debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "msbuild-x64-release",
            "configurePreset": "msbuild-x64",
            "displayName": "Build msbuild-x64 release",
            "description": "Build Visual Studio Release configuration",
            "configuration": "Release"
        },
        {
            "name": "msbuild-x64-relwithdebinfo",
            "configurePreset": "msbuild-x64",
            "displayName": "Build msbuild-x64 release with debug info",
            "description": "Build Visual Studio Release configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "msbuild-arm64-debug",
            "configurePreset": "msbuild-arm64",
            "displayName": "Build msbuild-arm64 debug",
            "description": "Build Visual Studio Debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "msbuild-arm64-release",
            "configurePreset": "msbuild-arm64",
            "displayName": "Build msbuild-arm64 release",
            "description": "Build Visual Studio Release configuration",
            "configuration": "Release"
        },
        {
            "name": "msbuild-arm64-relwithdebinfo",
            "configurePreset": "msbuild-arm64",
            "displayName": "Build msbuild-arm64 release with debug info",
            "description": "Build Visual Studio Release configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "msvc-x64-debug",
            "configurePreset": "msvc-x64",
            "displayName": "Build msvc-x64 debug",
            "description": "Build MSVC debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "msvc-x64-release",
            "configurePreset": "msvc-x64",
            "displayName": "Build ninja-msvc-x64 release",
            "description": "Build MSVC release configuration",
            "configuration": "Release"
        },
        {
            "name": "msvc-x64-relwithdebinfo",
            "configurePreset": "msvc-x64",
            "displayName": "Build MSVC release with debug symbols",
            "description": "Build MSVC release with debug info configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "mingw64-x64-debug",
            "configurePreset": "mingw64-x64",
            "displayName": "Build mingw64-x64 debug",
            "description": "Build Windows Subsystem for Linux Debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "mingw64-x64-cross-debug",
            "configurePreset": "mingw64-x64-cross",
            "displayName": "Build mingw64-x64 debug",
            "description": "Cross-compile with mingw64-x64 Debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "mingw64-x64-release",
            "configurePreset": "mingw64-x64",
            "displayName": "Build mingw64-x64 release",
            "description": "Build Windows Subsystem for Linux Release configuration",
            "configuration": "Release"
        },
        {
            "name": "mingw64-x64-cross-release",
            "configurePreset": "mingw64-x64-cross",
            "displayName": "Build mingw64-x64 release",
            "description": "Cross-compile with mingw64-x64 Release configuration",
            "configuration": "Release"
        },
        {
            "name": "mingw64-x64-relwithdebinfo",
            "configurePreset": "mingw64-x64",
            "displayName": "Build mingw64-x64 release with debug info",
            "description": "Build Windows Subsystem for Linux Release with debug info configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "mingw64-x64-cross-relwithdebinfo",
            "configurePreset": "mingw64-x64-cross",
            "displayName": "Build mingw64-x64 release with debug info",
            "description": "Cross-compile with mingw64-x64 Release with debug info configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "mingw64-i686-debug",
            "configurePreset": "mingw64-i686",
            "displayName": "Build mingw64-i686 debug",
            "description": "Build Windows Subsystem for Linux Debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "mingw64-i686-cross-debug",
            "configurePreset": "mingw64-i686-cross",
            "displayName": "Build mingw64-i686 debug",
            "description": "Build Windows Subsystem for Linux Debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "mingw64-i686-release",
            "configurePreset": "mingw64-i686",
            "displayName": "Build mingw64-i686 release",
            "description": "Build Windows Subsystem for Linux Debug configuration",
            "configuration": "Release"
        },
        {
            "name": "mingw64-i686-cross-release",
            "configurePreset": "mingw64-i686-cross",
            "displayName": "Build mingw64-i686 release",
            "description": "Build Windows Subsystem for Linux Debug configuration",
            "configuration": "Release"
        },
        {
            "name": "mingw64-i686-relwithdebinfo",
            "configurePreset": "mingw64-i686",
            "displayName": "Build mingw64-i686 release with debug info",
            "description": "Build Windows Subsystem for Linux Debug configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "mingw64-i686-cross-relwithdebinfo",
            "configurePreset": "mingw64-i686-cross",
            "displayName": "Build mingw64-i686 release with debug info",
            "description": "Cross-compile with mingw64-i686 Release with debug info configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "macos-arm64-debug",
            "configurePreset": "macos-arm64",
            "displayName": "Build Xcode debug",
            "description": "Build Xcode Debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "macos-arm64-release",
            "configurePreset": "macos-arm64",
            "displayName": "Build Xcode release",
            "description": "Build Xcode Release configuration",
            "configuration": "Release"
        },
        {
            "name": "macos-arm64-relwithdebinfo",
            "configurePreset": "macos-arm64",
            "displayName": "Build Xcode release with debug info",
            "description": "Build Xcode Release with debug info configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "macos-x64-debug",
            "configurePreset": "macos-x64",
            "displayName": "Build Xcode debug",
            "description": "Build Xcode Debug configuration",
            "configuration": "Debug"
        },
        {
            "name": "macos-x64-release",
            "configurePreset": "macos-x64",
            "displayName": "Build Xcode release",
            "description": "Build Xcode Release configuration",
            "configuration": "Release"
        },
        {
            "name": "macos-x64-relwithdebinfo",
            "configurePreset": "macos-x64",
            "displayName": "Build Xcode release with debug info",
            "description": "Build Xcode Release with debug info configuration",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "dynamic-debug",
            "configurePreset": "dynamic",
            "displayName": "Build native dynamically linked release",
            "description": "Build with community release triplet",
            "configuration": "Debug"
        },
        {
            "name": "dynamic-release",
            "configurePreset": "dynamic",
            "displayName": "Build native dynamically linked release",
            "description": "Build with community release triplet",
            "configuration": "Release"
        },
        {
            "name": "dynamic-relwithdebinfo",
            "configurePreset": "dynamic",
            "displayName": "Build native dynamically linked release",
            "description": "Build with community release triplet",
            "configuration": "RelWithDebInfo"
        },
        {
            "name": "static-debug",
            "configurePreset": "static",
            "displayName": "Build native statically linked debug",
            "description": "Build with statically linked debug",
            "configuration": "Debug"
        },
        {
            "name": "static-release",
            "configurePreset": "static",
            "displayName": "Build native statically linked release",
            "description": "Build with statically linked release",
            "configuration": "Release"
        },
        {
            "name": "static-relwithdebinfo",
            "configurePreset": "static",
            "displayName": "Build native statically linked release with debug info",
            "description": "Build with statically linked release with debug info",
            "configuration": "RelWithDebInfo"
        }
    ]
}


================================================
FILE: LICENSE
================================================
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991 

Copyright (C) 1989, 1991 Free Software Foundation, Inc.  
59 Temple Place - Suite 330, Boston, MA  02111-1307, USA

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. 

When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. 

To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. 

For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. 

We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. 

Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. 

Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. 

The precise terms and conditions for copying, distribution and modification follow. 

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". 

Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 

1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. 

You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 

2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: 


a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. 

b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. 

c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) 
These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. 
Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. 

In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 

3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: 

a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, 

b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, 

c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) 
The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. 
If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 

4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 

5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 

6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 

7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. 

If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. 

It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. 

This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 

8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 

9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. 

Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 

10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. 

NO WARRANTY

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 


END OF TERMS AND CONDITIONS


================================================
FILE: README.md
================================================
# ezQuake — Modern QuakeWorld Client
Homepage: [https://ezquake.com][homepage]

Community discord: [http://discord.quake.world][discord]

This is the right place to start playing QuakeWorld&reg; — the fastest first
person shooter action game ever.

Combining the features of all modern QuakeWorld® clients, ezQuake makes
QuakeWorld&reg; easier to start and play. The immortal first person shooter
Quake&reg; in the brand new skin with superb graphics and extremely fast
gameplay.

## Features

 * Modern graphics
 * [QuakeTV][qtv] support
 * Rich menus
 * Multiview support
 * Tons of features to serve latest pro-gaming needs
 * Built in server browser & MP3 player control
 * Recorded games browser
 * Customization of all possible graphics elements of the game including Heads Up Display
 * All sorts of scripting possibilities
 * Windows, Linux, MacOSX and FreeBSD platforms supported (SDL2).

Our client comes only with bare minimum of game media. If you want to
experience ezQuake with modern graphics and other additional media including
custom configurations, maps, textures and more, try using the [nQuake][nQuake]-installer.

## Support

Need help with using ezQuake? Try #dev-corner on [discord][discord]

Or (less populated these days) visit us on IRC at QuakeNet, channel #ezQuake: [webchat][webchat] or [IRC][IRC].

Sometimes help from other users of ezQuake might be more useful to you so you
can also try visiting the [quakeworld.nu Client Talk-forums][forum].

If you have found a bug, please report it [here][issues]

## Installation guide

To play Quakeworld you need the files *pak0.pak* and *pak1.pak* from the original Quake-game.

### Install ezQuake to an existing Quake-installation
If you have an existing Quake-installation simply extract the ezQuake executable into your Quake-directory.

A typical error message when installing ezQuake into a pre-existing directory is about *glide2x.dll* missing.
To get rid of this error, remove the file *opengl32.dll* from your Quake directory.

### Upgrade an nQuake-installation
If you have a version of [nQuake][nQuake] already installed you can upgrade ezQuake by extracting the new executable into the nQuake-directory.

### Minimal clean installation
If you want to make a clean installation of ezQuake you can do this by following these steps:

1. Create a new directory
2. Extract the ezQuake-executable into this directory
3. Create a subdirectory called *id1*
4. Copy *pak0.pak* and *pak1.pak* into this subdirectory

## Compiling

On Linux, `./build-linux.sh` produces an ezQuake binary in the top directory. 

For a more in-depth description of how to build on all platforms, have a look at 
[BUILD.md](BUILD.md).

## Nightly builds

Nightly builds can be found [here][nightly]

 [nQuake]: http://nquake.com/
 [webchat]: http://webchat.quakenet.org/?channels=#ezquake
 [IRC]: irc://irc.quakenet.org/#ezquake
 [forum]: http://www.quakeworld.nu/forum/8
 [qtv]: http://qtv.quakeworld.nu/
 [nightly]: https://builds.quakeworld.nu/ezquake/snapshots/
 [releases]: https://github.com/ezQuake/ezquake-source/releases
 [issues]: https://github.com/ezQuake/ezquake-source/issues
 [homepage]: https://ezquake.com
 [discord]: http://discord.quake.world/


================================================
FILE: bootstrap.ps1
================================================
function Show-MessageBox {
    param ([string]$message)
    Add-Type -AssemblyName PresentationFramework
    [System.Windows.MessageBox]::Show($message, "Bootstrap Error", 'OK', 'Warning')
}

if (-not (Get-Command git -ErrorAction SilentlyContinue)) {
    Show-MessageBox "Git is needed to checkout vcpkg, but it's not installed or not available in PATH."
    exit 1
}

git submodule update --init --recursive

if (-not (Test-Path "vcpkg/.git")) {
    if (-not (Test-Path "version.json")) {
        Show-MessageBox "Unable to checkout correct version of vcpkg without 'version.json'."
        exit 1
    }

    try {
        $versionData = Get-Content -Raw -Path "version.json" | ConvertFrom-Json
    } catch {
        Show-MessageBox "version.json is not valid JSON."
        exit 1
    }

    $vcpkgVersion = $versionData.vcpkg

    if (Test-Path "vcpkg") {
        Remove-Item -Recurse -Force "vcpkg"
    }

    git clone --branch $vcpkgVersion --depth 1 https://github.com/microsoft/vcpkg.git "vcpkg"
    $cloneExitCode = $LASTEXITCODE

    if ($cloneExitCode -ne 0) {
        Show-MessageBox "Checkout of vcpkg failed."
        exit 1
    }
}

& "vcpkg/bootstrap-vcpkg.bat" -disableMetrics

================================================
FILE: bootstrap.sh
================================================
#!/bin/sh -e

show_error() {
    printf "\e[31mError\e[0m: $1\n"
    exit 1
}

required_commands="cmake ninja git automake autoconf pkg-config curl zip unzip tar"

missing_deps=""
for cmd in $required_commands; do
    if ! command -v "$cmd" >/dev/null 2>&1; then
        missing_deps="$missing_deps $cmd"
    fi
done

# naming differs on macOS/Linux
if ! command -v "libtoolize" >/dev/null 2>&1 && ! command -v "glibtoolize" >/dev/null 2>&1; then
    missing_deps="$missing_deps libtool";
fi

if [ -n "$missing_deps" ]; then
    show_error "Install packages that provide support for:$missing_deps"
fi

if [ -e ".git" ]; then
    echo "Updating submodules..."
    git submodule update --init --recursive
fi

if [ ! -e "vcpkg/.git" ]; then
    if [ ! -f "version.json" ]; then
        show_error "Unable to checkout vcpkg without 'version.json'."
    fi

    vcpkg_version=$(sed -n 's/.*"vcpkg": *"\(.*\)".*/\1/p' version.json)
    if [ -z "$vcpkg_version" ]; then
        show_error "Could not extract vcpkg version from version.json."
    fi

    if [ -d "vcpkg" ]; then
        rm -rf "vcpkg"
    fi

    git clone --branch "$vcpkg_version" --depth 1 https://github.com/microsoft/vcpkg.git "vcpkg"
    if [ $? -ne 0 ]; then
        show_error "Checkout of vcpkg failed."
    fi
fi

vcpkg/bootstrap-vcpkg.sh -disableMetrics
if [ $? -ne 0 ]; then
    show_error "vcpkg bootstrap failed."
fi


================================================
FILE: build-linux.sh
================================================
#!/bin/sh -e
# simple build script for linux

# ANSI color codes
RED='\e[31m'
GREEN='\e[32m'
YELLOW='\e[33m'
NC='\e[0m'

BUILD_LOG=/tmp/ezquake-build.log

SKIP_DEPS="${SKIP_DEPS:-0}"

PKGS_DEB="git cmake build-essential libsdl2-2.0-0 libsdl2-dev libjansson-dev libexpat1-dev libcurl4-openssl-dev libpng-dev libjpeg-dev libspeex-dev libspeexdsp-dev libfreetype-dev libsndfile1-dev libpcre2-dev libminizip-dev"
PKGS_RPM="pcre2-devel cmake mesa-libGL-devel SDL2-devel make gcc jansson-devel expat-devel libcurl-devel libpng-devel libjpeg-turbo-devel speex-devel speexdsp-devel freetype-devel libsndfile-devel libXxf86vm-devel minizip-devel"
PKGS_ARCH="base-devel cmake libpng libjpeg-turbo sdl2 expat libcurl-compat freetype2 speex speexdsp jansson libsndfile minizip"
PKGS_VOID="base-devel cmake SDL2-devel pcre2-devel jansson-devel expat-devel libcurl-devel libpng-devel libjpeg-turbo-devel speex-devel speexdsp-devel freetype-devel libsndfile-devel libXxf86vm-devel minizip"

CPU=$(uname -m | sed -e s/i.86/i386/ -e s/amd64/x86_64/ -e s/sun4u/sparc64/ -e s/arm.*/arm/ -e s/sa110/arm/ -e s/alpha/axp/)

error() {
	[ ! -e $BUILD_LOG ] || cat $BUILD_LOG
	printf "${RED}[ERROR]${NC} %s\n" "$*"
	exit 1
}

step() {
	printf "${GREEN}[STEP ]${NC} %s\n" "$*"
}

info() {
	printf "[INFO ] %s\n" "$*"
}

warn() {
	printf "${YELLOW}[WARN ]${NC} %s\n" "$*"
}

install_check_deb() {
	step "Install/check dependecies (packages)..."
	info "You might be prompted to input your password as superuser privileges are required."

	info "Updating apt repo list... (running with sudo)"
	sudo apt-get update -y -qq || error "Failed to update package sources. Exiting."
	info "Checking/installing required packages... (running with sudo)"
	sudo apt-get install -y -q $PKGS_DEB >>$BUILD_LOG 2>&1 || error "Failed to install required packages. Exiting."
}

install_check_rpm() {
	step "Install/check dependecies (packages)..."
	info "You might be prompted to input your password as superuser privileges are required."
	info "Updating yum repo list... (running with sudo)"
	sudo yum clean all -yqqq && sudo yum check-update -yqqq >>$BUILD_LOG 2>&1 || error "Failed to update repo list. Exiting."
	info "Checking/installing required packages... (running with sudo)"
	sudo yum install -yq $PKGS_RPM >>$BUILD_LOG 2>&1 || error "Failed to install required packages. Exiting."
}

install_check_arch() {
	step "Install/check dependecies (packages)..."
	info "You might be prompted to input your password as superuser privileges are required."
	sudo pacman -Sy >>$BUILD_LOG 2>&1 || error "Failed to update repository cache. Exiting."
	sudo pacman -S --needed --noconfirm $PKGS_ARCH >>$BUILD_LOG 2>&1 || error "Failed to install required packages. Exiting."
}

install_check_void() {
    step "Install/check dependencies (packages)..."
    info "You might be prompted to input your password as superuser privileges are required."

    info "Updating xbps repo list... (running with sudo)"
    sudo xbps-install -Sy >>$BUILD_LOG 2>&1 || error "Failed to update package sources. Exiting."
    info "Checking/installing required packages... (running with sudo)"
    sudo xbps-install -y $PKGS_VOID >>$BUILD_LOG 2>&1 || error "Failed to install required packages. Exiting."
}

if [ -f $BUILD_LOG ];then
	rm -f $BUILD_LOG ||:
fi

[ -e CMakeLists.txt ] || error "Cannot find 'CMakeLists.txt', please run this script from the source code directory."

if [ $SKIP_DEPS -eq 0 ];then
	command -v sudo &>/dev/null || error "Could not find sudo, please install it. Exiting."

	if [ -f /etc/os-release ]; then
		. /etc/os-release || error "Failed to source os-release file"
	else
		error "Your environment isn't supported by this script. Exiting."
	fi

	[ -n "${ID}" ] || error "Your dist does not specify ID in /etc/os-release. Exiting."
	[ -n "${VERSION_ID}" ] || VERSION_ID=0
	case $ID in
		arch)
			install_check_arch
			;;
		manjaro)
			install_check_arch
			;;
		void)
			install_check_void
			;;
		linuxmint)
			[ $VERSION_ID -ge 18 ] || error "Your Linux Mint version '$VERSION_ID' is too old. Exiting."
			install_check_deb
			;;
		ubuntu)
			VERSION_ID=${VERSION_ID%.*}
			[ $VERSION_ID -ge 16 ] || error "Your Ubuntu version '$VERSION_ID' is too old. Exiting."
			install_check_deb
			;;
		devuan)
			if [ $VERSION_ID -gt 0 ] && [ $VERSION_ID -lt 4 ] ; then
				error "Your Devuan version '$VERSION_ID' is too old. Exiting."
			fi
			# Includes Devuan testing/unstable as they don't provide a VERSION_ID
			install_check_deb
			;;
		debian)
			if [ $VERSION_ID -gt 0 ] && [ $VERSION_ID -lt 8 ]; then
				error "Your Debian version '$VERSION_ID' is too old. Exiting."
			fi
			# Includes Debian testing/unstable as they don't provide a VERSION_ID
			install_check_deb
			;;
		pop)
			VERSION_ID=${VERSION_ID%.*}
			[ $VERSION_ID -ge 17 ] || error "Your Pop!_OS version '$VERSION_ID' is too old. Exiting."
			install_check_deb
			;;
		centos|rhel|fedora)
			# FIXME: Versions checks?
			install_check_rpm
			;;
		*)
			error "Your dist '$ID' isn't supported by this script. Exiting."
			;;
	esac
fi

if [ -d ".git" ]; then
	step "Checking out git submodules..."
	git submodule update --init --recursive >> $BUILD_LOG 2>&1 || error "Failed to checkout git submodules. Exiting."
fi

if [ ! -f src/qwprot/src/protocol.h ]; then
  error "Bad source code directory, not a git repository, and lacks src/qwprot/src/protocol.h." \
        "Download an official source release or checkout the official git repository."
fi

step "Configure build..."
if command -v ninja >/dev/null 2>&1; then
  GENERATOR="-G Ninja"
fi
cmake -B build "${GENERATOR}" -DCMAKE_BUILD_TYPE=Release

step "Compiling sources (this might take a while, please wait)..."
cmake --build build --parallel

printf "\n${GREEN}Build completed successfully.${NC}\n"
printf "Copy ${YELLOW}build/ezquake-linux-${CPU}${NC} into your quake directory.\n\n"


================================================
FILE: cmake/AddResources.cmake
================================================
# Generate C source code that embeds arbitrary files via calling the
# ResourceCompiler CMake script using CMake itself.
#
# Declared like this:
# const unsigned char blabla[] = {
#   0x23,0x76,0x65,...,
# };
# const unsigned int blabla_len = 581;

find_program(JQ_EXECUTABLE jq)

macro(add_resources target_var)
    add_library(${target_var} OBJECT)
    set(RESOURCE_COMPILER "${PROJECT_SOURCE_DIR}/cmake/ResourceCompiler.cmake")

    set(generated_base_directory "${CMAKE_CURRENT_BINARY_DIR}/${target_var}.dir/resources")

    foreach(source_file ${ARGN})
        file(RELATIVE_PATH source_file_relative "${CMAKE_SOURCE_DIR}" "${source_file}")
        get_filename_component(source_file_dir "${source_file}" DIRECTORY)
        get_filename_component(source_file_dir_relative "${source_file_relative}" DIRECTORY)
        set(generated_directory "${generated_base_directory}/${source_file_dir_relative}")

        file(MAKE_DIRECTORY ${generated_directory})

        get_filename_component(source_file_name "${source_file}" NAME)
        set(generated_file_name "${generated_directory}/${source_file_name}.c")

        get_filename_component(source_ext "${source_file}" EXT)
        if (source_ext STREQUAL ".json" AND JQ_EXECUTABLE)
            set(validation_command ${JQ_EXECUTABLE} empty "${source_file}")
        endif()

        add_custom_command(
                OUTPUT ${generated_file_name}
                COMMAND ${validation_command}
                COMMAND ${CMAKE_COMMAND} -P ${RESOURCE_COMPILER} "${source_file}" "${generated_file_name}"
                WORKING_DIRECTORY "${source_file_dir}"
                DEPENDS ${source_file} ${RESOURCE_COMPILER}
                COMMENT "Generating C file from ${source_file_relative}"
                VERBATIM
        )
        target_sources(${target_var} PRIVATE ${generated_file_name} ${source_file})
        set_source_files_properties("${CMAKE_SOURCE_DIR}/${source_file}" PROPERTIES HEADER_FILE_ONLY TRUE)
        set_source_files_properties("${generated_file_name}" PROPERTIES GENERATED TRUE)

        source_group(TREE "${CMAKE_SOURCE_DIR}" PREFIX "Source Files" FILES ${source_file})
        source_group(TREE "${generated_base_directory}" PREFIX "Generated Sources" FILES ${generated_file_name})
    endforeach()
endmacro()



================================================
FILE: cmake/CheckDependency.cmake
================================================
# Check if a dependency exists and declare a target named Dep::$name.
# If USE_SYSTEM_LIBS variable is set, find dependency via pkg-config.

if (USE_SYSTEM_LIBS)
    find_package(PkgConfig REQUIRED)
endif()

macro(check_dependency target_var pkg_config_name vcpkg_name vcpkg_target_name)
    cmake_parse_arguments(_ARG "REQUIRED;CONFIG" "" "" ${ARGN})
    set(_REQUIRED "")
    if (_ARG_REQUIRED)
        set(_REQUIRED "REQUIRED")
    endif()
    set(_CONFIG "")
    if (_ARG_CONFIG)
        set(_CONFIG "CONFIG")
    endif()
    string(TOUPPER ${target_var} _TARGET_VAR_UPPER)
    set(HAVE_${_TARGET_VAR_UPPER} FALSE)
    if (USE_SYSTEM_LIBS)
        pkg_check_modules(${target_var} ${_REQUIRED} IMPORTED_TARGET ${pkg_config_name})
        if (${target_var}_FOUND)
            add_library(Dep::${target_var} ALIAS PkgConfig::${target_var})
            set(HAVE_${_TARGET_VAR_UPPER} TRUE)
        endif()
    else()
        find_package(${vcpkg_name} ${_CONFIG} ${_REQUIRED})
        if (TARGET ${vcpkg_target_name})
            set(actual_target ${vcpkg_target_name})
            get_target_property(aliased_target ${actual_target} ALIASED_TARGET)
            if (aliased_target AND NOT "${aliased_target}" MATCHES "NOTFOUND")
                set(actual_target ${aliased_target})
            endif()
            add_library(Dep::${target_var} ALIAS ${actual_target})
            set(HAVE_${_TARGET_VAR_UPPER} TRUE)
        endif()
    endif()
endmacro()


================================================
FILE: cmake/FindSpeex.cmake
================================================
# Can be removed once vcpkg speexdsp package has gained a proper cmake-wrapper.
set(_VCPKG_ARCH_DIR "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}")
find_path(SPEEX_INCLUDE_DIR NAMES speex/speex.h PATHS "${_VCPKG_ARCH_DIR}/include" NO_DEFAULT_PATH REQUIRED)
find_library(SPEEX_LIB_RELEASE NAMES speex PATHS "${_VCPKG_ARCH_DIR}/lib" NO_DEFAULT_PATH)
find_library(SPEEX_LIB_DEBUG NAMES speex PATHS "${_VCPKG_ARCH_DIR}/debug/lib" NO_DEFAULT_PATH)
if(NOT SPEEX_LIB_RELEASE AND NOT SPEEX_LIB_DEBUG)
    message(FATAL_ERROR "Speex library not found")
endif()
add_library(SPEEX::SPEEX STATIC IMPORTED)
set_target_properties(SPEEX::SPEEX PROPERTIES
        IMPORTED_CONFIGURATIONS "Debug;Release"
        IMPORTED_LOCATION_RELEASE "${SPEEX_LIB_RELEASE}"
        IMPORTED_LOCATION_DEBUG "${SPEEX_LIB_DEBUG}"
        INTERFACE_INCLUDE_DIRECTORIES "${SPEEX_INCLUDE_DIR}"
)

================================================
FILE: cmake/FindSpeexDSP.cmake
================================================
# Can be removed once vcpkg speexdsp package has gained a proper cmake-wrapper.
set(_VCPKG_ARCH_DIR "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}")
find_path(SPEEXDSP_INCLUDE_DIR NAMES speex/speexdsp_types.h PATHS "${_VCPKG_ARCH_DIR}/include" NO_DEFAULT_PATH REQUIRED)
find_library(SPEEXDSP_LIB_RELEASE NAMES speexdsp PATHS "${_VCPKG_ARCH_DIR}/lib" NO_DEFAULT_PATH)
find_library(SPEEXDSP_LIB_DEBUG NAMES speexdsp PATHS "${_VCPKG_ARCH_DIR}/debug/lib" NO_DEFAULT_PATH)
if(NOT SPEEXDSP_LIB_RELEASE AND NOT SPEEXDSP_LIB_DEBUG)
    message(FATAL_ERROR "SpeexDSP library not found")
endif()
add_library(SPEEX::SPEEXDSP STATIC IMPORTED)
set_target_properties(SPEEX::SPEEXDSP PROPERTIES
        IMPORTED_CONFIGURATIONS "Debug;Release"
        IMPORTED_LOCATION_RELEASE "${SPEEXDSP_LIB_RELEASE}"
        IMPORTED_LOCATION_DEBUG "${SPEEXDSP_LIB_DEBUG}"
        INTERFACE_INCLUDE_DIRECTORIES "${SPEEXDSP_INCLUDE_DIR}"
)

================================================
FILE: cmake/GitUtils.cmake
================================================
find_package(Git QUIET)

function(git_refresh_submodules)
    if (GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
        option(GIT_SUBMODULE "Check submodules during build" ON)
        if (GIT_SUBMODULE)
            message(STATUS "Submodule update")
            execute_process(
                    COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                    RESULT_VARIABLE GIT_SUBMOD_RESULT
                    OUTPUT_QUIET
            )
            if (NOT GIT_SUBMOD_RESULT EQUAL "0")
                message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
            endif()
        endif()
    endif()
endfunction()

# Will load the version from 'version.json' file on configuration time if it exists.
#
# The content of this file looks like this:
# {
#   "version": "3.6.5-92-g8e3875f40",
#   "revision": 7739,
#   "commit": "595806cd2449d4b17024b892c6e5b169512be5e0",
#   "date": "2024-08-18T16:53:29+02:00",
#   "vcpkg": "2024-02-14"
# }
function(git_extract_version target_var)
    if (GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
        execute_process(
                COMMAND ${GIT_EXECUTABLE} rev-parse --is-shallow-repository
                OUTPUT_VARIABLE GIT_IS_SHALLOW
                OUTPUT_STRIP_TRAILING_WHITESPACE
                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )

        if (GIT_IS_SHALLOW MATCHES "true")
            message(WARNING "Shallow repository detected, revision not available.")
            set(GIT_REVISION "0")
        else()
            execute_process(
                    COMMAND ${GIT_EXECUTABLE} rev-list HEAD --count
                    OUTPUT_VARIABLE GIT_REVISION
                    OUTPUT_STRIP_TRAILING_WHITESPACE
                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
            )
        endif()

        execute_process(
                COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
                OUTPUT_VARIABLE GIT_COMMIT_HASH
                OUTPUT_STRIP_TRAILING_WHITESPACE
                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )

        execute_process(
                COMMAND ${GIT_EXECUTABLE} describe --tags --always
                OUTPUT_VARIABLE GIT_DESCRIBE
                RESULT_VARIABLE GIT_DESCRIBE_RESULT
                OUTPUT_STRIP_TRAILING_WHITESPACE
                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )
    elseif (EXISTS "${PROJECT_SOURCE_DIR}/version.json")
        message("-- Loading version from 'version.json'")
        file(READ "${CMAKE_CURRENT_SOURCE_DIR}/version.json" VERSION_CONTENT)
        string(JSON GIT_DESCRIBE GET "${VERSION_CONTENT}" "version")
        string(JSON GIT_REVISION GET "${VERSION_CONTENT}" "revision")
        string(JSON GIT_COMMIT_HASH GET "${VERSION_CONTENT}" "commit")
    endif()

    if (NOT GIT_DESCRIBE)
        set(GIT_DESCRIBE "0.0.0-0-g00000000")
    endif()

    if (NOT GIT_REVISION)
        set(GIT_REVISION "0")
    endif()

    if (NOT GIT_COMMIT_HASH)
        set(GIT_COMMIT_HASH "0000000000000000000000000000000000000000")
    endif()

    string(SUBSTRING ${GIT_COMMIT_HASH} 0 9 GIT_COMMIT_SHORT_HASH)

    add_library(${target_var} INTERFACE)
    target_compile_definitions(${target_var} INTERFACE
            REVISION=${GIT_REVISION}
            VERSION="${GIT_REVISION}~${GIT_COMMIT_SHORT_HASH}"
    )

    set(VERSION_MAJOR 0)
    set(VERSION_MINOR 0)
    set(VERSION_PATCH 0)

    string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+).*" "\\1;\\2;\\3" SEMVER_MATCH "${GIT_DESCRIBE}")
    list(LENGTH SEMVER_MATCH PARTS_SIZE)

    if(SEMVER_MATCH)
        if(PARTS_SIZE GREATER 0)
            list(GET SEMVER_MATCH 0 VERSION_MAJOR)
        endif()

        if(PARTS_SIZE GREATER 1)
            list(GET SEMVER_MATCH 1 VERSION_MINOR)
        endif()

        if(PARTS_SIZE GREATER 2)
            list(GET SEMVER_MATCH 2 VERSION_PATCH)
        endif()
    else()
        message(WARNING "Upstream tags missing. Using default version 0.0.0")
    endif()

    set_target_properties(${target_var} PROPERTIES
            REVISION      "${GIT_REVISION}"
            VERSION       "${GIT_REVISION}~${GIT_COMMIT_SHORT_HASH}"
            COMMIT        "${GIT_COMMIT_HASH}"
            GIT_DESCRIBE  "${GIT_DESCRIBE}"
            VERSION_MAJOR "${VERSION_MAJOR}"
            VERSION_MINOR "${VERSION_MINOR}"
            VERSION_PATCH "${VERSION_PATCH}"
    )

    message(STATUS "Version: ${GIT_DESCRIBE} (${GIT_REVISION}~${GIT_COMMIT_SHORT_HASH})")
endfunction()

================================================
FILE: cmake/ResourceCompiler.cmake
================================================
# Generate C code with some content encoded as an array of unsigned char.
# See AddResources.cmake for more information.

set(input_file "${CMAKE_ARGV3}")
set(output_file "${CMAKE_ARGV4}")

get_filename_component(base_name "${input_file}" NAME)
string(REGEX REPLACE "[.]" "_" variable_name "${base_name}")

file(READ "${input_file}" content HEX)

string(LENGTH "${content}" content_length)
math(EXPR data_length "${content_length} / 2")

string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," data "${content}")

string(APPEND data "0x00,")

file(WRITE "${output_file}" "const unsigned char ${variable_name}[] = {\n${data}\n};\nconst unsigned int ${variable_name}_len = ${data_length};\n")


================================================
FILE: cmake/triplets/arm64-osx.cmake
================================================
set(VCPKG_TARGET_ARCHITECTURE arm64)
set(VCPKG_CRT_LINKAGE dynamic)
set(VCPKG_LIBRARY_LINKAGE static)

set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
set(VCPKG_OSX_ARCHITECTURES arm64)
set(VCPKG_OSX_DEPLOYMENT_TARGET "11.0")

================================================
FILE: cmake/triplets/x64-mingw-static.cmake
================================================
set(VCPKG_TARGET_ARCHITECTURE x64)
set(VCPKG_CRT_LINKAGE dynamic)
set(VCPKG_LIBRARY_LINKAGE static)
set(VCPKG_ENV_PASSTHROUGH PATH)

set(VCPKG_CMAKE_SYSTEM_NAME MinGW)

set(VCPKG_C_FLAGS "-march=nehalem ")
set(VCPKG_CXX_FLAGS "-march=nehalem ")

================================================
FILE: cmake/triplets/x64-osx.cmake
================================================
set(VCPKG_TARGET_ARCHITECTURE x64)
set(VCPKG_CRT_LINKAGE dynamic)
set(VCPKG_LIBRARY_LINKAGE static)

set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
set(VCPKG_OSX_ARCHITECTURES x86_64)
set(VCPKG_OSX_DEPLOYMENT_TARGET "11.0")

================================================
FILE: cmake/triplets/x86-mingw-static.cmake
================================================
set(VCPKG_TARGET_ARCHITECTURE x86)
set(VCPKG_CRT_LINKAGE dynamic)
set(VCPKG_LIBRARY_LINKAGE static)
set(VCPKG_ENV_PASSTHROUGH PATH)

set(VCPKG_CMAKE_SYSTEM_NAME MinGW)

set(VCPKG_C_FLAGS "-msse2 ")
set(VCPKG_CXX_FLAGS "-msse2 ")

================================================
FILE: dist/gen-release.sh
================================================
#!/bin/sh

TOP_DIR=$(git rev-parse --show-toplevel)

cd "${TOP_DIR}"

git submodule update --init --recursive

rm -rf release
mkdir release
cd release

EZQ_DIR=$(git rev-parse --absolute-git-dir)
VCPKG_DIR=$(git -C "${TOP_DIR}/vcpkg" rev-parse --absolute-git-dir)
QWPROT_DIR=$(git -C "${TOP_DIR}/src/qwprot" rev-parse --absolute-git-dir)

GIT_REVISION=$(git --git-dir="${EZQ_DIR}" rev-list HEAD --count)
GIT_COMMIT_HASH=$(git --git-dir="${EZQ_DIR}" rev-parse HEAD)
GIT_DESCRIBE=$(git --git-dir="${EZQ_DIR}" describe --tags)
GIT_COMMIT_DATE=$(git --git-dir="${EZQ_DIR}" log -1 --format=%cI)
GIT_COMMIT_TIMESTAMP=$(git --git-dir="${EZQ_DIR}" log -1 --format=%cd --date=format-local:%Y%m%d%H%M.%S)

VCPKG_TAG=$(git --git-dir="${VCPKG_DIR}" describe --tags)

EZQ_NAME="ezquake-source-${GIT_DESCRIBE}"
EZQ_TAR="${EZQ_NAME}.tar"
EZQ_VERSION="${EZQ_NAME}/version.json"
EZQ_CHECKSUM="${EZQ_NAME}/checksum"

QWPROT_TAR="qwprot.tar"

echo "* Release: ${GIT_DESCRIBE} (rev: ${GIT_REVISION}, vcpkg: ${VCPKG_TAG})"

echo "* Creating ${EZQ_TAR}"
git --git-dir="${EZQ_DIR}" archive --format=tar --prefix="${EZQ_NAME}/" HEAD > "${EZQ_TAR}"

echo "* Creating ${QWPROT_TAR}"
git --git-dir="${QWPROT_DIR}" archive --format=tar --prefix=src/qwprot/ HEAD > "${QWPROT_TAR}"

echo "* Prepare merging tarballs"
tar -xf "${EZQ_TAR}"
tar -xf "${QWPROT_TAR}" -C "${EZQ_NAME}/"

echo "* Generating ${EZQ_VERSION}"
cat > "${EZQ_VERSION}" <<EOF
{
  "version": "${GIT_DESCRIBE}",
  "revision": ${GIT_REVISION},
  "commit": "${GIT_COMMIT_HASH}",
  "date": "${GIT_COMMIT_DATE}",
  "vcpkg": "${VCPKG_TAG}"
}
EOF

echo "* Generating ${EZQ_CHECKSUM}"
echo "${GIT_DESCRIBE}" >> "${EZQ_CHECKSUM}"
shasum "${EZQ_VERSION}" >> "${EZQ_CHECKSUM}"
git --git-dir="${EZQ_DIR}" ls-tree -r HEAD >> "${EZQ_CHECKSUM}"
git --git-dir="${QWPROT_DIR}" ls-tree -r HEAD >> "${EZQ_CHECKSUM}"

echo "* Resetting timestamp of generated files"
touch -t $GIT_COMMIT_TIMESTAMP "${EZQ_VERSION}"
touch -t $GIT_COMMIT_TIMESTAMP "${EZQ_CHECKSUM}"

echo "* Assembling ${EZQ_TAR}.gz"
tar cfz "${TOP_DIR}/${EZQ_TAR}.gz" "${EZQ_NAME}"

cd "${TOP_DIR}"
rm -rf release


================================================
FILE: dist/linux/io.github.ezQuake.appdata.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!-- Copyright 2019 Kevin Degeling -->

<component type="desktop">
  <id>io.github.ezQuake</id>
  <name>ezQuake</name>
  <summary>a modern QuakeWorld client focused on competitive online play</summary>
  <metadata_license>CC0-1.0</metadata_license>
  <project_license>GPL-2.0</project_license>

  <developer_name>ezQuake team</developer_name>
  <update_contact>ezquake @ github</update_contact>

  <url type="homepage">https://ezquake.github.io/</url>
  <url type="bugtracker">https://github.com/ezQuake/ezquake-source</url>
  <url type="help">https://ezquake.github.io/manual.html</url>
  <url type="contact">https://www.quakeworld.nu/forum</url>

  <launchable type="desktop-id">io.github.ezQuake.desktop</launchable>

  <description>
    <p>
      Welcome to the home of ezQuake, a modern QuakeWorld client focused on competitive online play. Combining the features of modern QuakeWorld® clients, ezQuake makes QuakeWorld® easier to start and play. The immortal first person shooter Quake® in a brand new skin with superb graphics and extremely fast gameplay.
    </p>
    <ul>
      <li>Modern Graphics: Particle explosions, shaft beam, gunshots, nails, rocket and grenade trails, blood, and others, MD3 models, fog, water effects, killing spree messages, rain</li>
      <li>Modern competitive gaming features: Fullbright skins, forcing team/enemy colors, advanced weapon handling, teamplay messages, auto game recording, automated screenshots and console logging</li>
      <li>Graphics customization: Customize your HUD, colors of walls and liquids, turn superfluous graphics effects off, change world textures, crosshair, sky picture, console background, game font</li>
      <li>Independent Physics: Get the smoothest experience possible without being limited by server or network settings</li>
      <li>Integrated Server Browser: Easy searching and filtering of online servers</li>
      <li>Enhanced demo/QTV playback: View recorded games from multiple points of view, watch action on radar, all player stats in a handy table, autotrack the strongest player</li>
    </ul>
    <p>
     Commercial data files are required to run the supported games. These can be aquired though a multitude of sources. See the manual for more info on this.
    </p>
  </description>

  <screenshots>
    <screenshot type="default">
      <image>https://ezquake.github.io/screenshots/armor_battle.png</image>
      <caption>Battle for armor</caption>
    </screenshot>
    <screenshot>
      <image>https://ezquake.github.io/screenshots/bloom.jpg</image>
      <caption>Bloom effect</caption>
    </screenshot>
    <screenshot>
      <image>https://ezquake.github.io/screenshots/shambler_cutf_bluefog.jpg</image>
      <caption>Special effects</caption>
    </screenshot>
  </screenshots>

  <releases>
    <release version="3.2.3" date="2021-02-10">
    </release>
    <release version="3.2.2" date="2020-09-23">
    </release>
    <release version="3.2.1" date="2020-06-24">
    </release>
    <release version="3.2.0" date="2020-03-19">
    </release>
    <release version="3.1.0" date="2019-09-24">
    </release>
  </releases>

  <content_rating type="oars-1.1">
    <content_attribute id="violence-realistic">moderate</content_attribute>
    <content_attribute id="violence-bloodshed">moderate</content_attribute>
    <content_attribute id="violence-desecration">moderate</content_attribute>
    <!-- Full multiplayer functionality with voicechat support -->
    <content_attribute id="social-chat">intense</content_attribute>
    <content_attribute id="social-audio">intense</content_attribute>
  </content_rating>
</component>



================================================
FILE: dist/linux/io.github.ezQuake.desktop
================================================
[Desktop Entry]
Comment=A modern QuakeWorld client focused on competitive online play
Categories=Game;Shooter;
Exec=ezquake.sh
Icon=io.github.ezQuake
Name=ezQuake
StartupNotify=true
PrefersNonDefaultGPU=true
Terminal=false
Type=Application
Keywords=quake;first;person;shooter;multiplayer;


================================================
FILE: dist/macOS/MacOSXBundleInfo.plist.in
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleIconFile</key>
	<string>ezquake.icns</string>
	<key>CFBundleDocumentTypes</key>
	<array>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>mvd</string>
				<string>qwd</string>
				<string>dem</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>ezquake.icns</string>
			<key>CFBundleTypeName</key>
			<string>Quake demo</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
		</dict>
	</array>
	<key>CFBundleURLTypes</key>
	<array>
		<dict>
			<key>CFBundleURLName</key>
			<string>QW</string>
			<key>CFBundleURLSchemes</key>
			<array>
				<string>qw</string>
			</array>
		</dict>
	</array>
	<key>NSHighResolutionCapable</key>
	<true/>
</dict>
</plist>


================================================
FILE: dist/macOS/ezquake.entitlements.plist
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>com.apple.security.app-sandbox</key>
	<true/>
	<key>com.apple.security.device.audio-input</key>
	<true/>
	<key>com.apple.security.network.client</key>
	<true/>
	<key>com.apple.security.network.server</key>
	<true/>
	<key>com.apple.security.files.user-selected.read-write</key>
	<true/>
	<key>com.apple.security.files.bookmarks.app-scope</key>
	<true/>
</dict>
</plist>


================================================
FILE: dist/windows/ezQuake.rc.in
================================================
#include <winres.h>

IDI_ICON1 ICON "@EZQUAKE_RESOURCE_ICON@"

VS_VERSION_INFO VERSIONINFO
 FILEVERSION @EZQUAKE_RESOURCE_VERSION@
 BEGIN
    BLOCK "StringFileInfo"
    BEGIN
        BLOCK "040904b0"
        BEGIN
            VALUE "FileDescription", "@EZQUAKE_RESOURCE_DESCRIPTION@\0"
            VALUE "ProductName", "@EZQUAKE_RESOURCE_NAME@\0"
            VALUE "ProductVersion", "@EZQUAKE_RESOURCE_COMMIT@\0"
            VALUE "LegalCopyright", "@EZQUAKE_RESOURCE_AUTHOR@\0"
        END
    END
    BLOCK "VarFileInfo"
    BEGIN
        VALUE "Translation", 0x409, 1200
    END
 END

================================================
FILE: help_cmdline_params.json
================================================
{
  "-allowmultiple": {
    "description": "On Windows, launch multiple copies of ezQuake rather than re-using the existing instance",
    "systems": [
      "windows"
    ]
  },
  "-basedir": {
    "arguments": "<path>",
    "description": "The \"base\" directory is the path to the directory holding the quake.exe and all game directories.\n\nThis can be overridden with the \"-basedir\" command line parm to allow code debugging in a different directory."
  },
  "-bpp": {
    "arguments": "<integer>",
    "description": "Allows setting of 'r_colorbits' cvar during start-up"
  },
  "-cdaudio": {
    "flags": [
      "incomplete"
    ]
  },
  "-cddev": {
    "arguments": "<path>",
    "description": "On Linux, specifies the cd device to use.  Must specify -cdaudio for this to have effect",
    "remarks": "(is this only used in meson build?)",
    "systems": [
      "linux"
    ]
  },
  "-cheats": {
    "description": "enable cheats on local server (/noclip etc)"
  },
  "-clientport": {
    "flags": [
      "incomplete"
    ]
  },
  "-conbufsize": {
    "arguments": "<size-in-kb>",
    "description": "set size of console buffer",
    "remarks": "between 32KB & 4MB, default is 64KB"
  },
  "-condebug": {
    "description": "log all console output to qw/qconsole.log"
  },
  "-conheight": {
    "description": "set vid_conheight during startup"
  },
  "-conwidth": {
    "description": "set vid_conwidth during startup"
  },
  "-data": {
    "system-generated": true
  },
  "-democache": {
    "arguments": "<size-in-kb>",
    "description": "create memory buffer during startup, used instead of writing directly to disk when recording demos",
    "remarks": "Minimum value 2048KB"
  },
  "-detailtrails": {
    "description": "sets /gl_particle_fulldetail 1 during startup"
  },
  "-dev": {
    "system-generated": true
  },
  "-display": {
    "flags": [
      "incomplete"
    ]
  },
  "-enablelocalcommand": {
    "flags": [
      "incomplete"
    ]
  },
  "-forceTextureReload": {
    "flags": [
      "incomplete"
    ]
  },
  "-forcetexturereload": {
    "system-generated": true
  },
  "-freq": {
    "flags": [
      "incomplete"
    ]
  },
  "-game": {
    "flags": [
      "incomplete"
    ]
  },
  "-gamma": {
    "flags": [
      "incomplete"
    ]
  },
  "-gl-debug": {
    "description": "enables OpenGL debug output.  Must be used in conjunction with -dev"
  },
  "-gl-forward-only-profile": {
    "system-generated": true
  },
  "-gl_ext": {
    "flags": [
      "incomplete"
    ]
  },
  "-glsl-renderer": {
    "flags": [
      "incomplete"
    ]
  },
  "-heapsize": {
    "flags": [
      "incomplete"
    ]
  },
  "-height": {
    "flags": [
      "incomplete"
    ]
  },
  "-ip": {
    "flags": [
      "incomplete"
    ]
  },
  "-maxtmu2": {
    "flags": [
      "incomplete"
    ]
  },
  "-mem": {
    "flags": [
      "incomplete"
    ]
  },
  "-minmemory": {
    "flags": [
      "incomplete"
    ]
  },
  "-no-accel-visuals": {
    "description": "Requests un-accelerated graphics (used in debugging to create OpenGL 1.1 context)"
  },
  "-no-triple-gl-buffer": {
    "flags": [
      "incomplete"
    ]
  },
  "-no24bit": {
    "flags": [
      "incomplete"
    ]
  },
  "-noatlas": {
    "system-generated": true
  },
  "-noconinput": {
    "flags": [
      "incomplete"
    ]
  },
  "-nodesktopres": {
    "system-generated": true
  },
  "-nohome": {
    "flags": [
      "incomplete"
    ]
  },
  "-nohwgamma": {
    "flags": [
      "incomplete"
    ]
  },
  "-nohwtimer": {
    "flags": [
      "incomplete"
    ]
  },
  "-noindphys": {
    "flags": [
      "incomplete"
    ]
  },
  "-noinvlmaps": {
    "flags": [
      "incomplete"
    ]
  },
  "-nolibjpeg": {
    "flags": [
      "incomplete"
    ]
  },
  "-nolibpng": {
    "flags": [
      "incomplete"
    ]
  },
  "-nomouse": {
    "flags": [
      "incomplete"
    ]
  },
  "-nomtex": {
    "flags": [
      "incomplete"
    ]
  },
  "-nonpot": {
    "system-generated": true
  },
  "-nopriority": {
    "flags": [
      "incomplete"
    ]
  },
  "-norjscripts": {
    "flags": [
      "incomplete"
    ]
  },
  "-noscripts": {
    "flags": [
      "incomplete"
    ]
  },
  "-nosound": {
    "flags": [
      "incomplete"
    ]
  },
  "-nostdout": {
    "flags": [
      "incomplete"
    ]
  },
  "-oldgamma": {
    "system-generated": true
  },
  "-particles": {
    "flags": [
      "incomplete"
    ]
  },
  "-port": {
    "flags": [
      "incomplete"
    ]
  },
  "-progtype": {
    "flags": [
      "incomplete"
    ]
  },
  "-r-debug": {
    "system-generated": true
  },
  "-r-no-amd-fix": {
    "system-generated": true
  },
  "-r-nocallback": {
    "system-generated": true
  },
  "-r-nomultibind": {
    "system-generated": true
  },
  "-r-novao": {
    "system-generated": true
  },
  "-r-trace": {
    "system-generated": true
  },
  "-r-verify": {
    "system-generated": true
  },
  "-r-dump-shaders": {
    "description": "Write expanded shader source to qw/shaders/<name>.<type>"
  },
  "-ruleset": {
    "flags": [
      "incomplete"
    ]
  },
  "-showliberrors": {
    "flags": [
      "incomplete"
    ]
  },
  "-startwindowed": {
    "flags": [
      "incomplete"
    ]
  },
  "-userdir": {
    "flags": [
      "incomplete"
    ]
  },
  "-width": {
    "flags": [
      "incomplete"
    ]
  },
  "-window": {
    "flags": [
      "incomplete"
    ]
  }
}


================================================
FILE: help_commands.json
================================================
{
  "+attack": {
    "description": "When active the player will fire the weapon he is currently holding.\nThis is the primary command used to make the player fire the gun.\nFor as long as the key that is bound to this command is held down and this command is active the player will keep on firing the gun."
  },
  "+attack2": {
    "description": "Secondary attack button."
  },
  "+back": {
    "description": "When active the player will move backwards."
  },
  "+cl_wp_stats": {
    "system-generated": true
  },
  "+fire": {
    "system-generated": true
  },
  "+fire_ar": {
    "system-generated": true
  },
  "+forward": {
    "description": "When active the player will move forward."
  },
  "+jump": {
    "description": "When active the player will do a single jump. The next jump won't be performed until \"-jump\" has been issued."
  },
  "+klook": {
    "description": "When active, \"+forward\" and \"+back\" become \"+lookup\" and \"+lookdown\"  respectively.\nThis command is useful if the player needs to look at objects which are above or below him."
  },
  "+left": {
    "description": "When active the player will turn left."
  },
  "+lookdown": {
    "description": "When active the player will look down."
  },
  "+lookup": {
    "description": "When active the player will look up."
  },
  "+mlook": {
    "description": "When active moving the mouse or joystick forwards and backwards performs \"+lookup\" and \"+lookdown\" respectively.\nThis command is very useful if the player needs to look at objects which are above or below him.\nMost players execute this command and never remove it. This way they can use the keyboard to move the player forward and back and strafe left and right, while using the mouse to turn the player left and right and to make him look up and down.\nIn order to have this command set permanently you will have to create a file called autoexec.cfg in the qw/ directory and put in the line \"+mlook\" into that file.\nBy doing this the game will automatically execute the autoexec.cfg file and it will also active that command.\nAlmost every player uses this command nowadays, because the combination of using mouse and keyboard is widely considered the best."
  },
  "+movedown": {
    "description": "When active the player will swim down when in the water."
  },
  "+moveleft": {
    "description": "When active the player will strafe left."
  },
  "+moveright": {
    "description": "When active the player will strafe right."
  },
  "+moveup": {
    "description": "When active the player will swim up when in the water."
  },
  "+qtv_delay": {
    "system-generated": true
  },
  "+right": {
    "description": "When active the player will turn right."
  },
  "+showscores": {
    "description": "Display scoreboard."
  },
  "+showteamscores": {
    "description": "Display team scoreboard."
  },
  "+speed": {
    "description": "When active the player will run."
  },
  "+strafe": {
    "description": "When active, \"+left\" and \"+right\" function like \"+moveleft\" and \"+moveright\", strafing in that direction."
  },
  "+use": {
    "description": "When used it will activate objects in the game that have been designed to react at \"+use\""
  },
  "+voip": {
    "system-generated": true
  },
  "+zoom": {
    "system-generated": true
  },
  "-attack": {
    "description": "When used the player will stop firing the gun if \"+attack\" is active."
  },
  "-attack2": {
    "description": "Secondary attack button."
  },
  "-back": {
    "description": "When used the player will stop moving back if \"+back\" is active."
  },
  "-cl_wp_stats": {
    "system-generated": true
  },
  "-fire": {
    "system-generated": true
  },
  "-fire_ar": {
    "system-generated": true
  },
  "-forward": {
    "description": "When used the player will stop moving forward if \"+forward\" is active."
  },
  "-jump": {
    "description": "When used the player will stop jumping if \"+jump\" is active."
  },
  "-klook": {
    "description": "When used the forward and back keys will stop making the player look up and down if \"+klook\" is active."
  },
  "-left": {
    "description": "When used the player will stop turning left if \"+left\" is active."
  },
  "-lookdown": {
    "description": "When used the player will stop looking down if \"+lookdown\" is active."
  },
  "-lookup": {
    "description": "When used the player will stop looking up if \"+lookup\" is active."
  },
  "-mlook": {
    "description": "When used the mouse forward and back movement will stop making the player look up and down if \"+mlook\" is active."
  },
  "-movedown": {
    "description": "When used the player will stop moving down if \"+movedown\" is active."
  },
  "-moveleft": {
    "description": "When used the player will stop moving left if \"+moveleft\" is active."
  },
  "-moveright": {
    "description": "When used the player will stop moving right if \"+moveright\" is active."
  },
  "-moveup": {
    "description": "When used the player will stop moving up if \"+moveup\" is active."
  },
  "-qtv_delay": {
    "system-generated": true
  },
  "-right": {
    "description": "When used the player will stop turning right if \"+right\" is active."
  },
  "-showscores": {
    "description": "When used the score screen will disappear if +showscores is active."
  },
  "-showteamscores": {
    "description": "When used the score screen will disappear if +showteamscores is active."
  },
  "-speed": {
    "description": "When used the player will walk."
  },
  "-strafe": {
    "description": "When used the turn left and turn right keys will once again perform their original functions."
  },
  "-use": {
    "description": "When used it will stop activating objects in the game that have been designed to react at \"+use\"."
  },
  "-voip": {
    "system-generated": true
  },
  "-zoom": {
    "system-generated": true
  },
  "acc_block": {
    "system-generated": true
  },
  "acc_create": {
    "system-generated": true
  },
  "acc_list": {
    "system-generated": true
  },
  "acc_remove": {
    "system-generated": true
  },
  "acc_unblock": {
    "system-generated": true
  },
  "addip": {
    "description": "Add a single IP or a domain of IPs to the IP list of the server.\nVery useful for banning people or for specifying which IPs only have access to the server.\n\nExamples:\naddip 123.123.123.123\naddip 123.123.123",
    "syntax": "<ip>"
  },
  "addloc": {
    "arguments": [
      {
        "description": "The name of the loc.",
        "name": "locname"
      }
    ],
    "description": "Adds a new loc with the specified name at current location.",
    "syntax": "\"locname\""
  },
  "addserver": {
    "description": "Server Browser: This allows you to add a server to the UNBOUND source.\nThis can be used to quickly bookmark servers."
  },
  "alias": {
    "description": "Used to create a reference to a command or list of commands.\nWhen used without parameters, displays all current aliases.",
    "remarks": "Enclose multiple commands within quotes and separate each command with a semi-colon."
  },
  "alias_in": {
    "arguments": [
      {
        "description": "Alias to be changed",
        "name": "alias"
      },
      {
        "description": "Variable whose value is inserted into alias",
        "name": "variable"
      },
      {
        "description": "Bitmask:\n0 - insert from left\n1 - from right side\n2 - check in advance whether a string being inserted already exists in alias\n4 - print an error message if the inserted string is already present in the alias\n8 - automatically create an alias if it doesn't exist yet",
        "name": "options"
      }
    ],
    "description": "Inserts contents of variable into alias.",
    "syntax": "<alias> <variable> [<options>]"
  },
  "alias_out": {
    "system-generated": true
  },
  "aliasedit": {
    "description": "Allows you to edit your alias in console manually.",
    "syntax": "<alias>"
  },
  "aliaslist": {
    "arguments": [
      {
        "description": "Prints only [regexp] matching aliases",
        "name": "[regexp]"
      }
    ],
    "description": "Prints all aliases.",
    "syntax": "[regexp]"
  },
  "align": {
    "system-generated": true
  },
  "allskins": {
    "description": "Downloads all skins that is currently in use.\nUseful for refreshing skins without exiting the level."
  },
  "authenticate": {
    "system-generated": true
  },
  "autotrack": {
    "description": "Toggles auto-tracking.\nAuto-tracking switches views for you when you are a spectator or when you are watching a demo or a broadcasted QTV match.\nIt chooses the best available autotrack - if you are spectator, looks for server-side command autotrack, if you are watching a demo or QTV stream, turns on both demo_autotrack and mvd_autotrack, mvd_autotrack will get turned off as soon as demo_autotrack data are found.\nAs a last resort if all previous autotrack are not available, cl_hightrack will be used."
  },
  "bar_armor": {
    "description": "HUD element that displays a bar representing your amount of armor."
  },
  "bar_health": {
    "description": "HUD element that displays a bar representing your amount of health."
  },
  "batteryinfo": {
    "system-generated": true
  },
  "bf": {
    "description": "This command shows a background screen flash that is the same one that is produced when the player picked up an item in the game.\nThis command basically serves no useful function except when people want to use it in scripts to give the user some visual feedback when an aliases is used for example."
  },
  "bind": {
    "description": "This command binds one or several commands to a key.\nTo bind multiple commands to a key, enclose the commands in double-quotes (\") and separate them with semicolons (;)."
  },
  "bindedit": {
    "description": "Allows you to edit your bind in the console.",
    "syntax": "<key>"
  },
  "bindlist": {
    "description": "Prints all binds."
  },
  "calc_fov": {
    "arguments": [
      {
        "description": "The old wide aspect FOV used in v2.x",
        "name": "old_fov"
      }
    ],
    "description": "Converts (ezq2) wide aspect FOV to new FOV."
  },
  "calendar": {
    "description": "Same as \"date\" but also shows a small calendar of the month. Nice :)"
  },
  "cam_angles": {
    "arguments": [
      {
        "description": "",
        "name": "pitch"
      },
      {
        "description": "",
        "name": "yaw"
      }
    ],
    "description": "Set new camera angles.",
    "syntax": "<pitch> <yaw> or cam_angles \"pitch yaw\""
  },
  "cam_pos": {
    "arguments": [
      {
        "description": "X coordinate",
        "name": "x"
      },
      {
        "description": "Y coordinate",
        "name": "y"
      },
      {
        "description": "Z coordinate",
        "name": "z"
      }
    ],
    "description": "Set new camera position.",
    "syntax": "<x> <y> <z> or cam_pos \"x y z"
  },
  "cancel": {
    "system-generated": true
  },
  "cd": {
    "description": "cd play 5 plays cd track #5",
    "remarks": "You need -cdaudio to use this command."
  },
  "centerview": {
    "description": "Centers the player's view ahead after +lookup or +lookdown."
  },
  "cfg_load": {
    "description": "This will do a cfg_reset and then execute filename.cfg (ezquake/configs).",
    "syntax": "<filename>"
  },
  "cfg_reset": {
    "description": "This command will unbind all keys, delete all aliases, msg_triggers, reset all plus commands, teamplay settings and reset all variables.\nUser made variables (created with set/seta) are deleted.\nAfter resetting all the above, it executes default.cfg and then autoexec.cfg."
  },
  "cfg_save": {
    "description": "This command will dump all aliases, bindings, plus commands, msg_triggers, teamplay settings and variables to filename.cfg .\nUser made variables (created with set/seta) are saved as well.",
    "remarks": "Configs saved with cfg_save are saved in quake/ezquake/configs/*.cfg",
    "syntax": "<filename>"
  },
  "check_maps": {
    "system-generated": true
  },
  "cl_messages": {
    "description": "Prints amount and size of messages sent from server to ezQuake client."
  },
  "clear": {
    "description": "This command clears the console screen of any text."
  },
  "clearlocs": {
    "description": "Clear all currently loaded locs."
  },
  "clipboard": {
    "description": "Copies all the following arguments to the system clipboard"
  },
  "cmd": {
    "description": "Sends a command directly to the server."
  },
  "cmdlist": {
    "description": "Prints a list of all available commands into the console."
  },
  "cmdlist_re": {
    "description": "This command same as cmdlist, but supports (perl) regexp matching."
  },
  "color": {
    "description": "This command sets the color for the player's shirt and pants.",
    "remarks": "If only the shirt color is given, the pant color will match."
  },
  "connect": {
    "arguments": [
      {
        "description": "IP address of a QuakeWorld server.",
        "name": "address"
      }
    ],
    "description": "Connects your client to a QuakeWorld server.",
    "syntax": "<address>"
  },
  "connectbr": {
    "description": "Connects to given server via fastest available path (ping-wise)."
  },
  "cuff": {
    "system-generated": true
  },
  "cvar_in": {
    "system-generated": true
  },
  "cvar_out": {
    "system-generated": true
  },
  "cvar_reset": {
    "description": "Resets the cvar to default.\n\nExample:\ncvar_reset topcolor\n - sets topcolor to default.",
    "syntax": "<cvar>"
  },
  "cvar_reset_re": {
    "description": "Resets cvar(s) matching the regex to default.\n\nExample:\ncvar_reset ^gl_.*\n- resets all gl_ settings to default values.",
    "syntax": "[regex]"
  },
  "cvaredit": {
    "system-generated": true
  },
  "cvarlist": {
    "description": "Print cvars."
  },
  "cvarlist_re": {
    "description": "This command same as cvarlist, but supports (perl) regexp matching."
  },
  "date": {
    "description": "Shows current time, date, month and year."
  },
  "demo_capture": {
    "arguments": [
      {
        "description": "Tells the client to start capturing.",
        "name": "start"
      },
      {
        "description": "Duration of the capture, in seconds.\nCan be float value. Must be positive. Required argument.",
        "name": "time"
      },
      {
        "description": "An .avi file is saved instead of screenshots. See demo_capture_codec.",
        "name": "avifile"
      },
      {
        "description": "Stop the capture manually before <time>.\nExample: demo_capture stop",
        "name": "stop"
      }
    ],
    "description": "Captures a series of screenshots or an .avi file.",
    "syntax": "<start> <time> [avifile] | <stop>"
  },
  "demo_controls": {
    "system-generated": true
  },
  "demo_jump": {
    "description": "Jumps playback to a point in time.\n\nExamples:\ndemo_jump 120\n - Jump playback to 120 seconds from the start of the demo.\ndemo_jump 4:30\n - Jump playback to 4 minutes and 30 seconds from the start of the demo.",
    "syntax": "[+|-][m:]<s>"
  },
  "demo_jump_end": {
    "system-generated": true
  },
  "demo_jump_mark": {
    "system-generated": true
  },
  "demo_jump_status": {
    "arguments": [
      {
        "description": "For example h<1 +rl or +lg",
        "name": "condition"
      }
    ],
    "description": "Fast-forward in the demo playback until certain condition holds.",
    "syntax": "<condition>"
  },
  "demo_playlist_clear": {
    "description": "Clears the demo playlist."
  },
  "demo_playlist_next": {
    "description": "Goes to the next demo in the playlist."
  },
  "demo_playlist_prev": {
    "description": "Goes to the previous demo in the playlist."
  },
  "demo_playlist_stop": {
    "description": "Stops the demo playlist playback."
  },
  "demo_setspeed": {
    "description": "You can vary the speed of demo playback with the 'demo_setspeed' command.\n'demo_setspeed x' sets the playback speed to x% of normal speed so that 'demo_setspeed 50' is half speed and 'demo_setspeed 300' gives you triple speed.",
    "syntax": "[default: 100]"
  },
  "describe": {
    "description": "Prints manual info about given variable or command into the console.",
    "syntax": "<variable or command name>"
  },
  "dev_cache_print": {
    "system-generated": true
  },
  "dev_cache_report": {
    "system-generated": true
  },
  "dev_dump_defaults": {
    "system-generated": true
  },
  "dev_gfxbenchmarklightmaps": {
    "system-generated": true
  },
  "dev_gfxtrace": {
    "system-generated": true
  },
  "dev_help_issues": {
    "system-generated": true
  },
  "dev_help_verify_config": {
    "system-generated": true
  },
  "dev_hunk_print": {
    "system-generated": true
  },
  "dev_physicsnormalsave": {
    "system-generated": true
  },
  "dev_physicsnormalset": {
    "system-generated": true
  },
  "dev_physicsnormalshow": {
    "system-generated": true
  },
  "dev_pointfile": {
    "description": "The pointfile command will load a .pts file and give a dotted line indicating where the leak(s) are on the level.",
    "remarks": "If a leak exists in the level, qbsp generates a non-zero .pts file in the maps directory.",
    "syntax": "<filename>"
  },
  "devmap": {
    "description": "Try it in cheats mode, start a map (devmap dm6) and type fly."
  },
  "dir": {
    "system-generated": true
  },
  "disconnect": {
    "description": "This command will disconnect you from the server/demo/proxy you are currently connected to."
  },
  "dns": {
    "description": "Performs DNS lookups and reverse lookups.",
    "syntax": "<address>"
  },
  "download": {
    "description": "Manually download a quake file from the server.\n\nExample:\ndownload skins/foo.pcx"
  },
  "easyrecord": {
    "description": "This start recording demo and rename it like you have put with match_* settings."
  },
  "echo": {
    "description": "This command will print text to your local console.",
    "syntax": "<text>"
  },
  "edict": {
    "description": "Reports information on a given edict in the game."
  },
  "edictcount": {
    "description": "Displays summary information on the edicts in the game."
  },
  "edicts": {
    "description": "Displays information on all edicts in the game."
  },
  "enemycolor": {
    "description": "This will override enemy color.\n\nExample:\nenemycolor 12 13",
    "remarks": "If only the shirt color is given, the pant color will match."
  },
  "eval": {
    "arguments": [
      {
        "description": "Arithmetic expression, can also contain strings",
        "name": "expression"
      }
    ],
    "description": "Evaluates given expression and prints the result into the console.",
    "syntax": "<expression>"
  },
  "exec": {
    "description": "Executes a config file from \\qw, \\id1 or \\ezquake."
  },
  "f_modified": {
    "description": "All the usual dm models, sounds, palettes etc are included in the check.\nIn Team Fortress the TF flag, dispensers and sentry guns are also checked. There is also an f_modified command which will print your f_modified response.",
    "remarks": "You need to install security files."
  },
  "f_ruleset": {
    "system-generated": true
  },
  "f_server": {
    "description": "Prints proxies you are using."
  },
  "filter": {
    "description": "Message filtering system. Only team messages are filtered.\nUse filter with no parameters to list current filters and filter clear to remove all filters.\n\nExample:\nfilter #a  say_team i can see this message #a.\nsay_team i can't see this message #d."
  },
  "find": {
    "description": "Lists all the players on all servers. Based on QTV."
  },
  "find_and_follow": {
    "description": "Find a player by name and connect to the same server. Based on QTV."
  },
  "find_update": {
    "description": "Update the database of the current players on all servers. Based on QTV."
  },
  "floodprot": {
    "arguments": [
      {
        "description": "Number of allowed messages per client in given time period.",
        "name": "messages"
      },
      {
        "description": "Time period in which more than <messages> cannot be sent by a client.",
        "name": "seconds"
      },
      {
        "description": "Time the flooding player will be muted for.",
        "name": "silence"
      }
    ],
    "description": "Sets flood protection parameters.",
    "syntax": "<messages> <seconds> <silence>"
  },
  "floodprotmsg": {
    "system-generated": true
  },
  "flush": {
    "description": "This command will clear the current game cache.\nIt is usually used by developers to flush the memory of all game information and objects to test if the mechanism which handles the loading of the necessary files into memory works properly.\nSometimes the game cache can become filled with unnecessary information and may need to be flushed manually. This is usually not necessary since the game automatically flushes all the data between every map."
  },
  "fly": {
    "description": "You can fly around the map with flymode on.",
    "remarks": "Needs cheat support by server."
  },
  "fontlist": {
    "description": "Lists TrueType fonts available on the system."
  },
  "fontload": {
    "description": "Loads specified TrueType font for use where _proportional is set."
  },
  "force_centerview": {
    "description": "This command centers the player's screen.\nIt was created because the original \"centerview\" command did not work when \"+mlook\" was enabled.\nThis command will center the screen in any mode no matter commands are active."
  },
  "fraglogfile": {
    "description": "Enables logging of kills to a file.\nUseful for external frag polling programs.\nThe file name is frag_##.log"
  },
  "fs_diff": {
    "system-generated": true
  },
  "fs_dir": {
    "system-generated": true
  },
  "fs_loadpak": {
    "system-generated": true
  },
  "fs_locate": {
    "system-generated": true
  },
  "fs_path": {
    "system-generated": true
  },
  "fs_removepak": {
    "system-generated": true
  },
  "fs_restart": {
    "system-generated": true
  },
  "fs_search": {
    "description": "Search the filesystem cache by suffix."
  },
  "fullinfo": {
    "description": "Used by QuakeSpy and Qlist to set setinfo variables.\n\nExample:\nfullinfo \"\\quote\\I am the only Lamer!\\\"",
    "remarks": "Use the setinfo command to see the output."
  },
  "gamedir": {
    "description": "Specifies the directory where the QWPROGS.DAT file is found and other additional files such as maps, models, sound, and skins for Quake modifications.",
    "remarks": "This command can be specified while a game is in progress, after the current map ends this command will take effect."
  },
  "gamma": {
    "description": "You can edit brightness.",
    "remarks": "This is a shortcut for sw_gamma in vga and gl_gamma in gl."
  },
  "give": {
    "description": "Give user a certain amount of an item.\nItems:\n1 - Axe\n2 - Shotgun\n3 - Double-Barrelled Shotgun\n4 - Nailgun\n5 - Super Nailgun\n6 - Grenade Launcher\n7 - Rocket Launcher\n8 - ThunderBolt\nC - Cells\nH - Health\nN - Nails\nR - Rockets\nS - Shells\n\nExamples:\ngive 1234 R 99\n - gives 99 rockets to user 1234\ngive 1234 7\n - gives the rocket launcher to user 1234",
    "remarks": "The -cheats parameter must be used to launch the server to use the give command. Also the key and value *cheats ON will be displayed in the serverinfo information."
  },
  "gl_checkmodels": {
    "description": "Not well implemented yet. Quickly looks at the pmodel and emodel listed in every player's infokey and reports anything unusual it finds.\nBasically it saves you having to type \"users. user x\" and then comparing the models for everyone."
  },
  "gl_inferno": {
    "description": "Clientside (no one else can see it) hard-striking rocket, serves well for your entertainment."
  },
  "gl_setmode": {
    "description": "Quickly sets many variables to fit pre-defined scheme.\nTry using \"newtrails\" or \"vultwah\".",
    "syntax": "<modename>"
  },
  "god": {
    "description": "You are immortal with god mode on.",
    "remarks": "Needs cheats support by server."
  },
  "hash": {
    "system-generated": true
  },
  "heartbeat": {
    "description": "Forces a heartbeat to be sent to the master server.\nA heartbeat informs the master server of the server's IP address thus making sure that the master server knows that the server is still alive."
  },
  "help": {
    "description": "Enters manual pages. Use arrows, [Page Down], [Page Up], [Tab] and [Enter] for navigation."
  },
  "hide": {
    "system-generated": true
  },
  "hud262_add": {
    "arguments": [
      {
        "description": "Can be cvar or str",
        "name": "type"
      },
      {
        "description": "String or cvarname",
        "name": "param"
      }
    ],
    "description": "Creates or changes a HUD element with hud_name.\nThe following types of HUD elements are available:\ncvar - a value of a variable is displayed; in this case param must be a name of this variable.\nstr - a string defined by param is displayed\nCvar and %macros expansion is performed every time element is shown.",
    "syntax": "<hud_name> <type> <param>"
  },
  "hud262_alpha": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "name"
      },
      {
        "description": "From 0 up to 1 (0 - invisible, 1 - opaque)",
        "name": "value"
      }
    ],
    "description": "Sets a transparency for strings-HUD element.",
    "syntax": "<name> <value>"
  },
  "hud262_bg": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "hud_name"
      },
      {
        "description": "color 111 - yellow, 79 - red, etc",
        "name": "bg_color"
      }
    ],
    "description": "Defines a color of the HUD element background.\n0 - transparent (default).",
    "syntax": "<hud_name> <bg_color>"
  },
  "hud262_blink": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "name"
      },
      {
        "description": "Blinking period in milliseconds",
        "name": "period"
      },
      {
        "description": "Defines what exactly should blink:\n0 - nothing\n1 - text only\n2 - background only\n3 - text and background",
        "name": "mask"
      }
    ],
    "description": "Allows to make blinking strings-HUD elements.",
    "syntax": "<name> <period> <mask>"
  },
  "hud262_bringtofront": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "name"
      }
    ],
    "description": "Transfers all HUD elements created after hud_name element (including) to the end of drawing list, that in short means that they will be displayed above all other elements which could be present on that place already.",
    "syntax": "<name>"
  },
  "hud262_disable": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "hud_name"
      }
    ],
    "description": "Prohibits to display one or more HUD elements.",
    "syntax": "<hud_name> [hud_name2...]"
  },
  "hud262_enable": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "hud_name"
      }
    ],
    "description": "Allows to display one or more HUD elements.",
    "syntax": "<hud_name> [hud_name2...]"
  },
  "hud262_list": {
    "arguments": [
      {
        "description": "Print only [regexp] matching HUDs",
        "name": "regexp"
      }
    ],
    "description": "Prints a list of strings-HUD elements.",
    "syntax": "[regexp]"
  },
  "hud262_move": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "hud_name"
      },
      {
        "description": "Horizontal shift",
        "name": "dx"
      },
      {
        "description": "Vertical shift",
        "name": "dy"
      }
    ],
    "description": "Moves a HUD element.\ndx and dy deviations are measured in symbols.",
    "syntax": "<hud_name> <dx> <dy>"
  },
  "hud262_position": {
    "arguments": [
      {
        "description": "Name of your HUD element",
        "name": "hud_name"
      },
      {
        "description": "Position:\n1 - upper left corner\n2 - upper right corner\n3 - lower right corner\n4 - lower left corner\n5 - upper central position\n6 - lower central position",
        "name": "pos"
      },
      {
        "description": "Horizontal offset",
        "name": "x"
      },
      {
        "description": "Vertical offset",
        "name": "y"
      }
    ],
    "description": "Indicates position of a HUD element on the screen.",
    "syntax": "<hud_name> <pos> <x> <y>"
  },
  "hud262_remove": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "hud_name"
      }
    ],
    "description": "Kills a HUD element.",
    "syntax": "<hud_name>"
  },
  "hud262_width": {
    "arguments": [
      {
        "description": "HUD element's name",
        "name": "hud_name"
      },
      {
        "description": "The range of width is 0-128, the value 0 (default) cancels the width forcing.",
        "name": "width"
      }
    ],
    "description": "Forces a HUD element width and cuts undesired space or adds it when needed.",
    "syntax": "<hud_name> <width>"
  },
  "hud_editor": {
    "description": "Toggles the HUD editor on or off."
  },
  "hud_export": {
    "arguments": [
      {
        "description": "Name (with optional path) of saved file. If .cfg extension is not present it will be automatically added.",
        "name": "filename"
      }
    ],
    "description": "Saves setup of your HUD (scr_newHUD 1) into a separate .cfg file.",
    "syntax": "<filename>"
  },
  "hud_fps_min_reset": {
    "system-generated": true
  },
  "hud_recalculate": {
    "description": "Refresh the positions of your HUD elements."
  },
  "hunk_print": {
    "system-generated": true
  },
  "if": {
    "arguments": [
      {
        "description": "A string where you usually use your own text, macros, and values of variables (like $volume).",
        "name": "expr1"
      },
      {
        "description": "==, =, !=, <>, >, <, >=, <=, isin, !isin\nWhere 'isin' means \"expr1 is a substring of expr2\" and '!isin' is a negation of this.\nThe others are standard mathematical comparison.",
        "name": "operator"
      },
      {
        "description": "See expr1",
        "name": "expr2"
      },
      {
        "description": "Will get executed if the binary operation succeeds.",
        "name": "cmd1"
      },
      {
        "description": "Will get executed if the binary operation fails.",
        "name": "cmd2"
      }
    ],
    "description": "Condition clause.",
    "syntax": "<expr1> <operator> <expr2> <cmd1> [else <cmd1>]"
  },
  "if_exists": {
    "description": "If an object <name> of a type <type> exists, a command <cmd1> will be issued, or a command <cmd2> if such object could not be found.\nThe type of the object can be either cvar, alias, trigger or HUD.",
    "syntax": "<type> <name>  <cmd1> [<cmd2>]"
  },
  "ignore": {
    "description": "You can give ignore either a player's name (name completion is useful for this) or a user ID (ignore <name|userid>).\nIgnore without any command line parameters displays your ignore list.",
    "syntax": "<name|userid>"
  },
  "ignore_id": {
    "description": "Identical to ignore, except it only accepts user IDs (only useful if there is a player whose name is the user ID of someone you want to ignore).",
    "syntax": "<userid>"
  },
  "ignore_team": {
    "description": "Ignores a team instead of players.\n\nExample:\nignore_team nine\n - ignores whole clan nine."
  },
  "ignore_voip": {
    "system-generated": true
  },
  "ignorelist": {
    "description": "Prints ignore list."
  },
  "impulse": {
    "description": "This command calls a game function or QuakeC function.\nOften impulses are used by the mod by defining aliases for game functions like \"ready\" and \"break\" that call certain impulses."
  },
  "in_evdevlist": {
    "description": "Prints list of evdev devices.\nIf the list is empty, you probably don't have access rights to /dev/input/eventX\nsudo chmod 644 /dev/input/event* should help you."
  },
  "in_restart": {
    "system-generated": true
  },
  "inc": {
    "description": "Increments a variable by one or adds to it the optional second argument.\nThere are no 'add' or 'dec' commands because 'inc' can handle both addition and subtraction.\n\nExample:\ninc sensitivity -2\n - subtracts 2 from sensitivity."
  },
  "itemsclock": {
    "description": "HUD element displaying items that will spawn soon in the game. Works only in MVD and QTV playback."
  },
  "join": {
    "description": "Joins a specified server as player.\nIf no address is specified, join will reconnect to the last visited server as a player.\n\nExample:\njoin 123.124.125.126",
    "syntax": "<address>"
  },
  "joyadvancedupdate": {
    "description": "This command must be run to apply changes made to the joyadvaxis[xyzruv] or joyindex cvars."
  },
  "kick": {
    "description": "Removes a user from the server. Use the status command to receive the user's id.\n\nExample:\nkick 1234",
    "syntax": "<userid>"
  },
  "kill": {
    "description": "Suicide. (-2 frags on ktpro/kteam servers)"
  },
  "legacyquake": {
    "arguments": [
      {
        "description": "Optional argument, when specified, will disable only new features from specified client version",
        "name": "ver"
      }
    ],
    "description": "Command that turns off new features added to the client that may confuse experienced users who don't like new features :-)",
    "syntax": "[ver]"
  },
  "listip": {
    "description": "Prints out the current list of IPs on the server list. Not to be confused with the status command which prints out the list of the IPs of the connected players."
  },
  "load": {
    "description": "Load 123 loads saved game 123.",
    "syntax": "<filename>"
  },
  "loadFragfile": {
    "system-generated": true
  },
  "loadcharset": {
    "description": "You can change your console font from within ezQuake. Put all your charset images in qw/textures/charsets/*.png (and *.tga) and use /loadcharset XXX to load XXX.png (or tga).\n\"/loadcharset original\" will restore the 8bit font in your gfx.wad (this is default).",
    "remarks": "This command is just a 'shortcut' for the new gl_consolefont variable."
  },
  "loadfont": {
    "system-generated": true
  },
  "loadfragfile": {
    "description": "Loads the specified fragfile.",
    "syntax": "<filename>"
  },
  "loadloc": {
    "description": "Loads a loc file (must be located in id1/locs, qw/locs, or ezquake/locs.\nThe \".loc\" extension is optional, for example, \"loadloc dm6\"; if the file name has no extension, use its explicit name (\"loadloc dm6.\").",
    "syntax": "<filename>"
  },
  "loadpak": {
    "system-generated": true
  },
  "loadsky": {
    "description": "Loads your skybox (qw\\env).\n\nExample:\nloadsky snow",
    "syntax": "<filename>"
  },
  "localinfo": {
    "description": "Shows or sets localinfo variables. Useful for mod programmers who need to allow the admin to change settings.\nThis is an alternative storage space to the serverinfo space for mod variables. The variables stored in this space are not broadcast on the network.\nThis space also has a 32-kilobyte limit which is much greater then the 512-byte limit on the serverinfo space.\nSpecial Keys: (current map) (next map) - Using this combination will allow the creation of a custom map cycle without editing code.\n\nExamples:\nlocalinfo dm2 dm4\nlocalinfo dm4 dm6\nlocalinfo dm6 dm2"
  },
  "locate": {
    "system-generated": true
  },
  "locations_add": {
    "system-generated": true
  },
  "locations_clearall": {
    "system-generated": true
  },
  "locations_loadfile": {
    "system-generated": true
  },
  "locations_remove": {
    "system-generated": true
  },
  "locations_savefile": {
    "system-generated": true
  },
  "locname": {
    "description": "Create a new location in the current spot."
  },
  "log": {
    "description": "If you type \"log filename\" it will log console to filename.log in your gamedir.\nIt overwrites logs without asking.",
    "syntax": "<filename>"
  },
  "logerrors": {
    "system-generated": true
  },
  "logfile": {
    "system-generated": true
  },
  "logplayers": {
    "system-generated": true
  },
  "logrcon": {
    "system-generated": true
  },
  "logtelnet": {
    "system-generated": true
  },
  "ls": {
    "system-generated": true
  },
  "macrolist": {
    "description": "Prints a list of all available macros."
  },
  "map": {
    "description": "Loads a map and starts a game.\n\nExample:\nmap e1m1"
  },
  "mapgroup": {
    "description": "mapgroup 2fort5r 2fort5: will make 2fort5r and 2fort5 use the 2fort5r textures, locs and etc...",
    "syntax": "mapgroup [map1] [map2] ..."
  },
  "master_rcon_password": {
    "system-generated": true
  },
  "match_forcestart": {
    "description": "Simulates the start of a match (so that auto recording etc is triggered).\nUseful if you join a ktpro server after countdown has started, or you are playing a mode that doesn't have a proper countdown (eg race mode).\nMost importantly this is useful for TF servers, since you can use a msg_trigger to execute match_forcestart on \"MATCH BEGINS NOW\"."
  },
  "match_format_macrolist": {
    "description": "Prints a list of the macros and their meaning for autorecording and autoscreenshots."
  },
  "match_save": {
    "description": "If you are using 'match_auto_record 1' then a temp demo will be recorded to c:\\quake\\ezquake\\temp\\_!_temp_!_.qwd each time a map starts.\nThis temp demo will be overwritten when the next match starts.\nIf you want to keep the temp demo, use the \"match_save\" command. This will move the demo to the same folder and filename that easyrecord would have used."
  },
  "menu_demos": {
    "description": "This command will display the demos menu."
  },
  "menu_fps": {
    "description": "This command will display the fps menu."
  },
  "menu_help": {
    "description": "This command will display the help menu."
  },
  "menu_keys": {
    "description": "This command will display the keys menu."
  },
  "menu_load": {
    "description": "This command will display the singleplayer load menu."
  },
  "menu_main": {
    "description": "This command will display the main menu."
  },
  "menu_mp3_control": {
    "description": "This command will display the mp3 menu."
  },
  "menu_mp3_playlist": {
    "description": "This command will display the mp3 playlist menu."
  },
  "menu_multiplayer": {
    "description": "This command will display the multiplayer menu."
  },
  "menu_options": {
    "description": "This command will display the options menu."
  },
  "menu_quit": {
    "description": "This command will display the quit menu."
  },
  "menu_save": {
    "description": "This command will display the singleplayer save menu."
  },
  "menu_setup": {
    "description": "This command will display the setup menu."
  },
  "menu_singleplayer": {
    "description": "This command will display the singleplayer menu."
  },
  "menu_slist": {
    "description": "This command will display the server browser."
  },
  "menu_video": {
    "description": "This command will display the video menu."
  },
  "messagemode": {
    "description": "Prompts for string to broadcast to all other players."
  },
  "messagemode2": {
    "description": "Prompts for string to broadcast to team members."
  },
  "messagemodeqtvtogame": {
    "description": "Go into message mode for chatting in the QTV chat."
  },
  "mod": {
    "system-generated": true
  },
  "modfraglogfile": {
    "system-generated": true
  },
  "move": {
    "system-generated": true
  },
  "mp3_fadeout": {
    "description": "Like stop but fades out."
  },
  "mp3_fforward": {
    "description": "Fast forward 5seconds."
  },
  "mp3_loadplaylist": {
    "description": "Loads the playlist filename.m3u\n\nExample:\nmp3_loadplaylist top10\n - loads top10.m3u.",
    "syntax": "<filename>"
  },
  "mp3_next": {
    "description": "Next song."
  },
  "mp3_pause": {
    "description": "Pause mp3."
  },
  "mp3_play": {
    "description": "Play mp3."
  },
  "mp3_playlist": {
    "description": "Displays playlist. Currently playing track is highlighted."
  },
  "mp3_playtrack": {
    "description": "Play track number #num from playlist.\n\nExample:\nmp3_playtrack 5\n - plays track 5 from playlist.",
    "syntax": "<track>"
  },
  "mp3_prev": {
    "description": "Previous song."
  },
  "mp3_repeat": {
    "description": "Repeat playlist.",
    "syntax": "<off|on>"
  },
  "mp3_rewind": {
    "description": "Rewind 5seconds."
  },
  "mp3_shuffle": {
    "description": "Shuffle mp3s.",
    "syntax": "<off|on>"
  },
  "mp3_songinfo": {
    "description": "Displays song title and other info like time elapsed, total time, and whether paused, stopped or playing."
  },
  "mp3_startwinamp": {
    "description": "Starts winamp if it is not running."
  },
  "mp3_stop": {
    "description": "Stop mp3."
  },
  "mp3_volume": {
    "system-generated": true
  },
  "msg_trigger": {
    "arguments": [
      {
        "description": "The name of the alias you want to be executed when trigger matches the string.",
        "name": "alias"
      },
      {
        "description": "Case-sensitive substring of the message you want to catch in this trigger.",
        "name": "string"
      },
      {
        "description": "Level of the message.\n0 - pickup messages\n1 - death messages\n2 - critical messages\n3 - chat messages\nEverything else is level 4.",
        "name": "level"
      }
    ],
    "description": "Allows you to set rules that will automatically execute actions when a certain message is sent from a server.\nThis is very useful in Team Fortress, in deathmatch it can be used for example for auto-reporting \"quad in 30\" when you receive \"Quad Damage is wearing out\" message.",
    "remarks": "Only some server messages can be triggered. Usually no pickup messages nor your teammates text is triggered.",
    "syntax": "<alias> <string> [-l] <level>"
  },
  "mute": {
    "system-generated": true
  },
  "mutesound": {
    "system-generated": true
  },
  "mvd_dumpstats": {
    "description": "Dumps statistics gathered from a MVD demo into a \"stats.xml\" file in the current working directory."
  },
  "mvd_list_items": {
    "system-generated": true
  },
  "mvd_name_item": {
    "system-generated": true
  },
  "mvd_remove_item": {
    "system-generated": true
  },
  "mvdrecord": {
    "system-generated": true
  },
  "mvdstop": {
    "system-generated": true
  },
  "netproblem": {
    "description": "HUD element - icon displayed when network traffic is experiencing problems like lost packets, large delay, etc."
  },
  "noclip": {
    "description": "You can fly and go thru objects free mode as spectator",
    "remarks": "Needs cheats support by server."
  },
  "nslookup": {
    "system-generated": true
  },
  "observe": {
    "description": "Connects you to a server as a spectator. If no address is specified, observe will reconnect to the last visited server as a spectator.\n\nExample:\nobserve 123.124.125.126",
    "syntax": "<address>"
  },
  "observebr": {
    "description": "Connects to given server as spectator via fastest available path (ping-wise)."
  },
  "observeqtv": {
    "system-generated": true
  },
  "order": {
    "system-generated": true
  },
  "packet": {
    "description": "Sends a packet with specified contents to the destination.\n\nExample:\npacket 123.123.123.123:27500 \"status\"",
    "syntax": "<address>"
  },
  "password": {
    "description": "Set the password to enter a password protected server."
  },
  "path": {
    "description": "Shows what paths ezQuake is using."
  },
  "pause": {
    "description": "Pauses a game.",
    "remarks": "Servers must support pausing."
  },
  "penaltylist": {
    "system-generated": true
  },
  "penaltyremove": {
    "system-generated": true
  },
  "place": {
    "system-generated": true
  },
  "play": {
    "description": "Plays a sound effect.\n\nExample:\nplay misc/runekey.wav",
    "syntax": "<filename>"
  },
  "playdemo": {
    "description": "Plays a recorded demo.\n\nExample:\nplaydemo thresh.qwd",
    "syntax": "<filename>"
  },
  "playvol": {
    "description": "Plays a sound at a given volume.\n\nExamples:\nplayvol items/protect.wav .5\nplayvol items/protect.wav 2",
    "syntax": "<filename> (volume)"
  },
  "profile": {
    "description": "Reports information about QuakeC stuff."
  },
  "qstat": {
    "system-generated": true
  },
  "qtv": {
    "arguments": [
      {
        "description": "IP address of the internet QTV broadcasting some QW action",
        "name": "address"
      }
    ],
    "description": "Connects you to internet QTV broadcasting some action, using your local proxy.\nStarts local QTV proxy, tells it what broadcasting proxy it should connect to and by connecting to it you'll see the action broadcasted on the IP you've specified.",
    "syntax": "<address>"
  },
  "qtv_close": {
    "system-generated": true
  },
  "qtv_fixuser": {
    "system-generated": true
  },
  "qtv_list": {
    "system-generated": true
  },
  "qtv_query_demolist": {
    "system-generated": true
  },
  "qtv_query_sourcelist": {
    "system-generated": true
  },
  "qtv_reconnect": {
    "description": "Reconnect to last QTV server the client was connected to."
  },
  "qtv_status": {
    "system-generated": true
  },
  "qtv_update": {
    "system-generated": true
  },
  "qtvplay": {
    "system-generated": true
  },
  "qtvreconnect": {
    "system-generated": true
  },
  "qtvusers": {
    "system-generated": true
  },
  "quit": {
    "description": "Exit - disconnects from the server and closes the client."
  },
  "qwurl": {
    "system-generated": true
  },
  "radar": {
    "description": "HUD element showing a map overview.",
    "syntax": "<property> <value>"
  },
  "rcon": {
    "description": "Issue the set of commands to the server you are currently connected to or have set in rcon_address.\nYou must know the rcon password for that specific server."
  },
  "re_trigger": {
    "arguments": [
      {
        "description": "re_trigger name",
        "name": "rt_name"
      },
      {
        "description": "Regexp defines which messages (or whatever) will activate a trigger.\nThe client uses the PCRE library (Perl-compatible regular expression library).\nYou can find information how to write regexps in the PCRE's documentation.",
        "name": "regexp"
      }
    ],
    "description": "When used w/o parameter, prints a list of all triggers.\nWhen regexp is not defined prints options set for rt_name trigger; otherwise creates or changes rt_name trigger.",
    "syntax": "re_trigger [rt_name [regexp]]"
  },
  "re_trigger_delete": {
    "arguments": [
      {
        "description": "re_trigger name",
        "name": "rt_name"
      }
    ],
    "description": "Deletes the corresponding trigger.",
    "syntax": "re_trigger_delete rt_name"
  },
  "re_trigger_disable": {
    "arguments": [
      {
        "description": "Re_trigger name. Can be REGEXP.",
        "name": "rt_name"
      }
    ],
    "description": "Disables activation of one or more triggers.",
    "syntax": "re_trigger_disable rt_name1 [rt_name2...]"
  },
  "re_trigger_enable": {
    "arguments": [
      {
        "description": "Re_trigger name. Can be REGEXP.",
        "name": "rt_name"
      }
    ],
    "description": "Enables activation of one or more triggers.",
    "syntax": "re_trigger_enable rt_name1 [rt_name2...]"
  },
  "re_trigger_match": {
    "arguments": [
      {
        "description": "re_trigger name",
        "name": "trigger_name"
      },
      {
        "description": "Your string",
        "name": "string"
      }
    ],
    "description": "Allows to direct a <string> to a trigger <trigger_name>. If this string match regexp, then a corresponding alias is activated.",
    "syntax": "re_trigger_match <trigger_name> <string>"
  },
  "re_trigger_options": {
    "arguments": [
      {
        "description": "Value represents a bit mask which determines which types of messages can cause activation of a trigger:\n1 - pickup messages\n2 - death messages\n4 - critical messages (most of Team Fortress messages)\n8 - chat\n16 - centerprint\n32 - echo command output\n64 - other strings printed in the console\nThe default mask for any trigger equals 31.",
        "name": "mask"
      },
      {
        "description": "Sets a minimal interval of trigger activation (in seconds). If a second activation happened earlier than the value time, it is ignored.\nDefault is 0.",
        "name": "interval"
      },
      {
        "description": "If activation of this trigger happened, the remaining (in the list of triggers) triggers are not checked.\nTriggers are checked in a reversed order of their definition.",
        "name": "final"
      },
      {
        "description": "Activation of such trigger doesn't stop the checking of other triggers (default).",
        "name": "notfinal"
      },
      {
        "description": "A string which caused activation of a trigger is not printed on the screen.",
        "name": "remove"
      },
      {
        "description": "A string which caused activation of a trigger is printed on the screen (default).",
        "name": "noremove"
      },
      {
        "description": "A string which caused activation of a trigger is not added to a log-file.",
        "name": "log"
      },
      {
        "description": "A string which caused activation of a trigger is added to a log-file (default).",
        "name": "nolog"
      },
      {
        "description": "A corresponding alias is not executed upon a trigger activation.\nThere is no need to exec alias if all you need is to use remove option :)",
        "name": "noaction"
      },
      {
        "description": "A corresponding alias is executed upon a trigger activation (default).",
        "name": "action"
      }
    ],
    "description": "Changes options for a corresponding trigger.",
    "syntax": "re_trigger_options rt_name option_list"
  },
  "reconnect": {
    "description": "Reconnects to the last server/proxy."
  },
  "record": {
    "description": "Records a demo.\n\nExample:\nrecord test\n - records test.qwd to qw folder",
    "syntax": "<filename>"
  },
  "recordqwd": {
    "system-generated": true
  },
  "register_qwurl_protocol": {
    "system-generated": true
  },
  "removeip": {
    "description": "Removes an IP address from the server IP list.\n\nExamples:\nremoveip 123.123.123.123\nremoveip 123.123.123",
    "syntax": "<ip>"
  },
  "removeloc": {
    "description": "Remove the closest location (use teamsay to see which)."
  },
  "removepak": {
    "system-generated": true
  },
  "reset": {
    "system-generated": true
  },
  "rm": {
    "system-generated": true
  },
  "rmdir": {
    "system-generated": true
  },
  "rotate": {
    "description": "Rotates the player by x degrees.\n\nExample: \"rotate 180\"\n - rotates your POV by 180 degrees.",
    "remarks": "Negative values can also be used for the desired angle."
  },
  "s_audiodevicelist": {
    "system-generated": true
  },
  "s_listdrivers": {
    "system-generated": true
  },
  "s_restart": {
    "system-generated": true
  },
  "save": {
    "description": "Saves a game in singleplayer.\n\nExample:\nsave 123"
  },
  "saveloc": {
    "arguments": [
      {
        "description": "The .loc file the locs should be saved in.",
        "name": "filename"
      }
    ],
    "description": "Saves the current locs in memory to the specified file.",
    "syntax": "<filename>"
  },
  "say": {
    "description": "Broadcasts a string to all other players.\n\nExample:\nsay ezQuake rules!"
  },
  "say_team": {
    "description": "Broadcasts a string to teammates.\n\nExample:\nsay_team stop boring!"
  },
  "sb_buildpingtree": {
    "system-generated": true
  },
  "sb_pingsdump": {
    "description": "Dumps a list of pairs (IP address, ping) into the console based on the current content of the Server Browser list."
  },
  "sb_proxygetpings": {
    "system-generated": true
  },
  "sb_refresh": {
    "description": "Causes Server Browser refresh ping and status info for all servers."
  },
  "sb_sourceadd": {
    "arguments": [
      {
        "description": "Name of the source",
        "name": "name"
      },
      {
        "description": "(IP) address of master server or filename of the server list file",
        "name": "source"
      },
      {
        "description": "\"master\" for master server or \"file\" for server list file",
        "name": "type"
      }
    ],
    "description": "Adds new server list source.",
    "syntax": "<name> <source> <type>"
  },
  "sb_sourcemark": {
    "description": "Marks \"source-name\" as selected server source list.",
    "syntax": "<source-name>"
  },
  "sb_sourcesupdate": {
    "description": "Reload server lists from all marked server sources."
  },
  "sb_sourceunmarkall": {
    "description": "Unmarks all servers sources."
  },
  "score_difference": {
    "description": "HUD element which displays the frag difference between you (your team) and your enemy (enemy team)."
  },
  "score_enemy": {
    "description": "HUD element which displays amount of frags made by all the enemies."
  },
  "score_own": {
    "description": "HUD element which display your (or the person's you are observing) amount of frags."
  },
  "score_position": {
    "description": "HUD element which displays your position on the frag leaders board."
  },
  "screenshot": {
    "arguments": [
      {
        "description": "Optional. When used tells the destination filename.\nIf extension is not preset it will be added automatically according to sshot_format setting.",
        "name": "name"
      }
    ],
    "description": "Saves a still picture of current screen to your hard drive.",
    "syntax": "[name]"
  },
  "script": {
    "system-generated": true
  },
  "serverexec": {
    "system-generated": true
  },
  "serverinfo": {
    "description": "Reports the current server info."
  },
  "serverstatus": {
    "description": "Prints the status of the ezQuake server."
  },
  "set": {
    "arguments": [
      {
        "description": "Name of variable or custom variable.",
        "name": "varname"
      },
      {
        "description": "Value you want to store in the variable.",
        "name": "value"
      }
    ],
    "description": "Sets a variable to a given value.",
    "syntax": "<varname> <value>"
  },
  "set_alias_str": {
    "description": "Assigns variable a value which contains an indicated alias.",
    "syntax": "<cvar> <alias>"
  },
  "set_bind_str": {
    "description": "Assigns variable a value which contains anything bound to an indicated key.",
    "syntax": "<cvar> <key>"
  },
  "set_calc": {
    "arguments": [
      {
        "description": "Name of variable you want to save the result in.",
        "name": "cvar"
      },
      {
        "description": "Possible commands:\nstrlen - gets length of given string\nint - converts given float value to integer\nsubstr - return substring of given string\nset_substr - replaces given position in string with another string\npos - gets position of substring in given string",
        "name": "command"
      },
      {
        "description": "Arguments of commands:\nstrlen <string>\nint <float>\nsubstr <sourcestr> <position> [<length>]\nset_substr <replacestr> <position>\npos <haystack> <needle>",
        "name": "cmdargs"
      },
      {
        "description": "First argument",
        "name": "arg1"
      },
      {
        "description": "Possible operators: +, -, *, /, div, %%, and, or, xor.",
        "name": "oper"
      },
      {
        "description": "Second argument.",
        "name": "arg2"
      }
    ],
    "description": "Advanced variables customization.",
    "syntax": "<cvar command cmdargs> | <cvar arg1 oper arg2>"
  },
  "set_eval": {
    "system-generated": true
  },
  "set_ex": {
    "description": "Assigns a new value to a variable, expansion of %macros and variables is performed even in case if a parameter is inside the dual quotation marks.",
    "syntax": "<cvar> <value>"
  },
  "set_ex2": {
    "system-generated": true
  },
  "set_tp": {
    "system-generated": true
  },
  "setinfo": {
    "description": "Sets information about your FuhWorld user.\nUsed without a key it will list all of your current settings. Specifying a non-existent key and a value will create the new key."
  },
  "setmaster": {
    "description": "Lists the server with up to eight masters.\nWhen a server is listed with a master, the master is aware of the server's IP address and port and it is added to the list of current server connected to a master. A heartbeat is sent to the master from the server to indicated that the server is still running and alive.\n\nExamples:\nsetmaster 192.246.40.12:27002\nsetmaster 192.246.40.12:27002 192.246.40.12:27004"
  },
  "show": {
    "system-generated": true
  },
  "showskins": {
    "system-generated": true
  },
  "sizedown": {
    "description": "Reduces the screen size."
  },
  "sizeup": {
    "description": "Increases the screen size."
  },
  "skins": {
    "description": "Refreshes skin settings.",
    "remarks": "If you have set noskins to 0 and do this it will download all skins that players are using on server."
  },
  "skygroup": {
    "description": "In basics works same as mapgroup.",
    "syntax": "skyboxname map1 [map2] ..."
  },
  "skywind": {
    "description": "Sets the animation parameters of the skybox. Requires a skybox with some level of transparency.",
    "syntax": "skywind [distance] [yaw] [period] [pitch]"
  },
  "skywind_load": {
    "description": "Loads the skywind config for the loaded skymap. The file is expected to contain: skywind [distance] [yaw] [period] [pitch]."
  },
  "skywind_lookdir": {
    "description": "Updates the skywind direction to current point of view with optional overrides of period and distance.",
    "syntax": "skywind_lookdir [period] [distance]"
  },
  "skywind_rotate": {
    "description": "Updates the skywind direction with yaw (horizontal) and pitch (vertical) adjustment.",
    "syntax": "skywind_rotate [yaw] [pitch]"
  },
  "skywind_save": {
    "description": "Saves the current skywind configuration as gfx/env/$skybox_wind.cfg."
  },
  "snap": {
    "description": "Remote screenshot from a player.\n\nExample:\nsnap 1234\n - server requests remote screenshot from user 1234",
    "syntax": "<userid>"
  },
  "snapall": {
    "description": "Remote screenshots from all players."
  },
  "soundinfo": {
    "description": "Reports information on the sound system."
  },
  "soundlist": {
    "description": "Reports a list of sounds in the cache."
  },
  "spectator_password": {
    "description": "Sets spectator password to ezQuake local server.",
    "remarks": "Spectators must use \"spectator <password>\" to connect to a server with a spectator password."
  },
  "speed": {
    "description": "Shows your current movement speed."
  },
  "speed2": {
    "description": "An alternative speed-o-meter that is drawn as a half-circle."
  },
  "status": {
    "description": "Reports information on the current connected clients and the server."
  },
  "stop": {
    "description": "Stops demo recording."
  },
  "stopqwd": {
    "system-generated": true
  },
  "stopsound": {
    "description": "Stops all sounds currently being played."
  },
  "stopsound_script": {
    "system-generated": true
  },
  "sv_democancel": {
    "system-generated": true
  },
  "sv_demoeasyrecord": {
    "system-generated": true
  },
  "sv_demoembedinfo": {
    "system-generated": true
  },
  "sv_demoinfo": {
    "system-generated": true
  },
  "sv_demoinfoadd": {
    "system-generated": true
  },
  "sv_demoinforemove": {
    "system-generated": true
  },
  "sv_demolist": {
    "system-generated": true
  },
  "sv_demolistr": {
    "system-generated": true
  },
  "sv_demolistregex": {
    "system-generated": true
  },
  "sv_demonumremove": {
    "system-generated": true
  },
  "sv_demorecord": {
    "system-generated": true
  },
  "sv_demoremove": {
    "system-generated": true
  },
  "sv_demostop": {
    "system-generated": true
  },
  "sv_gamedir": {
    "description": "Displays or determines the value of the serverinfo *gamedir variable.\nThis is the directory clients will use.\n\nExamples:\ngamedir tf2_5; sv_gamedir fortress\ngamedir ctf4_2; sv_gamedir ctf\ngamedir ktffa; sv_gamedir qw  // FFA servers should use default *gamedir",
    "remarks": "Useful when the physical gamedir directory has a different name than the widely accepted gamedir directory."
  },
  "sv_lastscores": {
    "system-generated": true
  },
  "sv_status": {
    "system-generated": true
  },
  "sv_usercmdtrace": {
    "system-generated": true
  },
  "svadmin": {
    "system-generated": true
  },
  "sys_forget_sandbox": {
    "description": "Clears the currently selected sandbox directory. On the next restart, ezQuake will prompt you to select a directory again.",
    "remarks": "macOS only"
  },
  "tcl_eval": {
    "description": "Execute <string> as Tcl code.",
    "syntax": "<string>"
  },
  "tcl_exec": {
    "description": "Execute a config as Tcl script.",
    "syntax": "<filename>"
  },
  "tcl_proc": {
    "description": "Execute a Tcl procedure <name> with parameters <parameters>. Procedure must be defined before thru tcl_eval or tcl_exec commands.",
    "syntax": "<name> [parameters]"
  },
  "tcpconnect": {
    "arguments": [
      {
        "description": "IP address of a QuakeWorld server.",
        "name": "address"
      },
      {
        "description": "TCP port of a QuakeWorld server.",
        "name": "port"
      }
    ],
    "description": "Connects your client to a QuakeWorld server via TCP.",
    "syntax": "<address>:<port>"
  },
  "teamcolor": {
    "description": "This will override team color.\n\nExample:\nteamcolor 12 13",
    "remarks": "If only the shirt color is given, the pant color will match."
  },
  "teamholdbar": {
    "description": "Displays overall map control per team when watching multiview demo."
  },
  "teamholdinfo": {
    "description": "Displays items possession stats per team when watching multiview demo."
  },
  "tempalias": {
    "description": "Sets a temporary alias.\nTempaliases will not save to your config."
  },
  "timedemo": {
    "description": "This command will load and play a demo at full speed. It will then divide the total number of frames in the demo by the total time it took finish, and calculate the average frames-per-second rate.\n\nExample:\ntimedemo demoname",
    "syntax": "<filename>"
  },
  "timedemo2": {
    "system-generated": true
  },
  "timerefresh": {
    "description": "This command will perform a 360 degree turn and calculate the frames-per-second rate."
  },
  "toggle": {
    "description": "You can turn off/on cvars.\n\nExample:\ntoggle sensitivity turns off sensitivity and toggle sensitivity again turns on."
  },
  "toggle_re": {
    "description": "You can turn variable values ON and OFF.\n\nExample:\ntoggle ^gl_part.* - turns all particle effects on/off.",
    "syntax": "[cvar_regexp1] [cvar_regexp2] ... [cvar_regexpN]"
  },
  "toggleconsole": {
    "description": "Brings the console up and down."
  },
  "togglehud": {
    "system-generated": true
  },
  "togglemenu": {
    "description": "Displays the menu screens."
  },
  "toggleproxymenu": {
    "system-generated": true
  },
  "togglespec": {
    "system-generated": true
  },
  "tp_msgcoming": {
    "description": "Will send a message to your teammates telling them where you are coming from, and what your status is.\nDoubles as tp_lost when you are dead (because you can't be coming from somewhere if you're dead)."
  },
  "tp_msgenemypwr": {
    "description": "This command could be used for all cases involving players with powerup.\nIf you, a teammate, or enemy has powerup, this bind will report it.\nIf eyes is in your point, we assume enemy only because this is tp_ENEMYpwr, otherwise there is no way to tell if a player with ring is enemy or teammate."
  },
  "tp_msggetpent": {
    "description": "Informs your teammates to get the pent.\nWill print enemy/team pent if you, teammate, or enemy has pent and they're in your point.\nWill print nothing if eyes is in point."
  },
  "tp_msggetquad": {
    "description": "Informs your teammates to get the quad.\nReports team/enemy quad if you, a teammate, or an enemy has quad and they are in your point.\nReports nothing if eyes is in your point."
  },
  "tp_msghelp": {
    "description": "Requests help at a location. Also gives your status."
  },
  "tp_msgitemsoon": {
    "system-generated": true
  },
  "tp_msgkillme": {
    "system-generated": true
  },
  "tp_msglost": {
    "description": "Will send a message to your teammates telling them you died at a location.\nAlso tells them how many enemies are there, and what weapon (if any) you dropped."
  },
  "tp_msgneed": {
    "description": "Equivalent of %u (need macro).\nWill display what you need (health/armor/ammo)."
  },
  "tp_msgnocancel": {
    "system-generated": true
  },
  "tp_msgpoint": {
    "description": "Will report to your team item you see in your point at its location.\nWill report team/enemy powerup if you, a teammate, or an enemy has a powerup and are in your point.",
    "remarks": "Note that tp_pointpriorities defaults to 1 and it is strongly suggested to keep this value. You can alter the priorities of this bind by altering tp_point."
  },
  "tp_msgquaddead": {
    "description": "Reports quad is dead. Will print enemy/team powerup if you, a teammate, or an enemy have quad and are in your point."
  },
  "tp_msgreplace": {
    "description": "Requests a teammate to replace you at your location."
  },
  "tp_msgreport": {
    "description": "Will send a message to your teammates about your current status: health, armor, location, powerups, weapon.\nDoubles as tp_lost when you are dead."
  },
  "tp_msgsafe": {
    "description": "Will send a message to your teammates informing them your current location is safe.\nWill print nothing if there is enemy in your point.\nAlso reports your status."
  },
  "tp_msgslipped": {
    "system-generated": true
  },
  "tp_msgtfconced": {
    "system-generated": true
  },
  "tp_msgtook": {
    "description": "Informs your team of the last item you took.\nSaves each item in memory for 15 seconds."
  },
  "tp_msgtrick": {
    "description": "Requests a trick at a location.\nBest for cases like dm2 when you need a teammate to help you get quad from stairs."
  },
  "tp_msgutake": {
    "system-generated": true
  },
  "tp_msgwaiting": {
    "system-generated": true
  },
  "tp_msgyesok": {
    "system-generated": true
  },
  "tp_pickup": {
    "description": "Item can be: quad, pent, ring, suit, ra, ya, ga, mh, health, lg, rl, gl, sng, ng, ssg, pack, cells, rockets, nails, shells, flag, armor, weapons, powerups, ammo, all, default, none"
  },
  "tp_point": {
    "description": "Specifies which items will be used in point (%x or $point) macro.\nIf you point at an item and such item is not listed here, your message will be tp_name_nothing (default: \"nothing\").\nSupported items: powerups, quad, pent, ring, armor, ra, ya, ga, weapons, lg, rl, gl, sng, ng, ssg, ammo, cells, rockets, nails, shells, players, eyes, teammate, enemy, mh, health, pack, flag, all, default, none, suit\nItem names can be customized with tp_name_item.",
    "syntax": "item1 item2 ... DO NOT USE QUOTES"
  },
  "tp_took": {
    "description": "Specifies which items will be included in the took (%X or $took) macro.\nIf you took an item and it's not listed in tp_took list, %X and $took macro will display tp_name_nothing (default: \"nothing\").\nSupported items: quad, pent, ring, suit, ra, ya, ga, mh, health, lg, rl, gl, sng, ng, ssg, pack, cells, rockets, nails, shells, flag, armor, weapons, powerups, ammo, all, default, none\nItem names can be customized with tp_name_item.",
    "syntax": "item1 item2 ... DO NOT USE QUOTES"
  },
  "track": {
    "system-generated": true
  },
  "track-": {
    "description": "This means when you are spectating or watching an mvd, keys will automatically be assigned to track certain players.\nSo in a 4v4 8 keys are needed, the first 4 make you track the 4 players in the first team and the last 4 make you track the second team."
  },
  "track1": {
    "system-generated": true
  },
  "track2": {
    "system-generated": true
  },
  "track3": {
    "system-generated": true
  },
  "track4": {
    "system-generated": true
  },
  "trackkiller": {
    "description": "Will switch view to the player who killed the player we are tracking at the moment."
  },
  "trackteam": {
    "arguments": [
      {
        "description": "Team number. In standard 4on4 use 1 or 2.",
        "name": "teamnum"
      }
    ],
    "description": "When using MultiView, allows you to assign all available points of view to a desired team.",
    "syntax": "<teamnum>"
  },
  "troubleshoot": {
    "description": "Performs a check on client settings and displays possible sources of issues."
  },
  "unalias": {
    "description": "Example:\nunalias myreport\n - removes myreport alias."
  },
  "unalias_re": {
    "description": "Deletes given alias(es).\n\nExample:\nunalias ^_zoom.\n - removes all aliases beginning with '_zoom', e.g. _zoom_in, _zoom_out",
    "syntax": "<cvar1> [cvar2] ..."
  },
  "unaliasall": {
    "description": "Removes all aliases."
  },
  "unbind": {
    "description": "Example: unbind x delete strings on x button."
  },
  "unbindall": {
    "description": "Removes all keyboard bindings."
  },
  "unignore": {
    "description": "Removes name or user ID number from ignore list.",
    "syntax": "<name|userid>"
  },
  "unignoreAll": {
    "description": "Removes all users from ignore list."
  },
  "unignoreAll_team": {
    "description": "Removes all ignored teams from ignore list."
  },
  "unignore_id": {
    "description": "Removes userid from ignore list.",
    "syntax": "<userid>"
  },
  "unignore_team": {
    "description": "Removes team from ignore list."
  },
  "unignore_voip": {
    "system-generated": true
  },
  "unset": {
    "description": "Removes user-created variable.",
    "syntax": "<cvar1> [cvar2] ..."
  },
  "unset_re": {
    "description": "Removes user-created variable.",
    "syntax": "<cvar1|regex1> [cvar2|regex2] ..."
  },
  "user": {
    "description": "This command queries the user for his setinfo information.",
    "syntax": "<userid>"
  },
  "userdir": {
    "arguments": [
      {
        "description": "String used as the <dir> part in the final path (see 'type' argument below).",
        "name": "dir"
      },
      {
        "description": "Optional number. Default is 0.\n0 - <quake_dir>/<gamedir>/<dir>\n1 - <quake_dir>/<dir>/<gamedir>\n2 - <quake_dir>/qw/<dir>/<gamedir>\n3 - <quake_dir>/qw/<dir>\n4 - <quake_dir>/<dir>\n5 - $HOME/qw/<dir>",
        "name": "type"
      }
    ],
    "description": "A userdir command can be used for addition of directories to the list searched for files by the client (configs, sounds, models, etc.).\nReal handy when several players with their own configs files play Quake on a single computer.\nWhen issuing this command after reconnection to a server or parameter is not defined, a current userdir is printed in the console.",
    "syntax": "[dir [type]]"
  },
  "userinfo": {
    "description": "Prints your user settings."
  },
  "users": {
    "description": "Reports information on connected players and retrieve user IDs."
  },
  "v_cshift": {
    "description": "This adjusts all of the colors currently being displayed.\nUsed when you are underwater, hit, have the Ring of Shadows, or Quad Damage.\n\nExample:\nv_cshift 16 32 64\n",
    "syntax": "<red> <green> <blue> <intensity>"
  },
  "validate_clients": {
    "description": "This shows authed ezQuake users, non-authed and non-ezQuake users."
  },
  "version": {
    "description": "Prints client version number and date into the console."
  },
  "vid_displaylist": {
    "system-generated": true
  },
  "vid_forcemode": {
    "description": "This command will force ezQuake to use a certain video mode."
  },
  "vid_fullscreen": {
    "description": "This command will switch to a fullscreen video mode specified in the \"vid_fullscreen_mode\" variable."
  },
  "vid_gfxinfo": {
    "description": "This command will print out useful information about your video card, GL version, and refresh rate, video mode (width/height resolution and color depth) to console.\nUseful to make sure everything is right, and also to screenshot to show other people."
  },
  "vid_minimize": {
    "description": "This command will minimize the windowed game screen.\nIt was made available because the game takes control over the mouse when it is moved onto the game window thus prohibiting the normal minimization of the game window."
  },
  "vid_modelist": {
    "description": "Prints all supported video modes."
  },
  "vid_reload": {
    "system-generated": true
  },
  "vid_restart": {
    "description": "Will restart your video renderer. Needed for some changes to take affect."
  },
  "vid_testmode": {
    "description": "This command will switch to the specified video mode for 5-seconds in order to test it."
  },
  "vid_windowed": {
    "description": "This command will switch the a windowed video mode specified in the \"vid_windowed_mode\" variable."
  },
  "viewalias": {
    "description": "Example:\nviewalias mystatus\n - prints mystatus alias."
  },
  "vip_addip": {
    "system-generated": true
  },
  "vip_listip": {
    "system-generated": true
  },
  "vip_removeip": {
    "system-generated": true
  },
  "vip_writeip": {
    "system-generated": true
  },
  "vminfo": {
    "system-generated": true
  },
  "wait": {
    "description": "Adds one wait frame."
  },
  "weapon": {
    "description": "Weapon selection command.\nWill select the best available weapon according to the sequence you choose.",
    "syntax": "<w1> [<w2> [...]]"
  },
  "windows": {
    "description": "Switches away from client and back to the Windows OS."
  },
  "writeip": {
    "description": "Records all IP addresses on the server IP list. The file name is listip.cfg."
  },
  "z_ext_list": {
    "system-generated": true
  }
}


================================================
FILE: help_macros.json
================================================
{
  "ammo": {
    "description": "returns amount of ammo held for currently selected weapon",
    "teamplay-restricted": false,
    "type": "integer"
  },
  "armor": {
    "description": "returns current armor value",
    "teamplay-restricted": false,
    "type": "integer"
  },
  "armortype": {
    "description": "returns current armor type",
    "related-cvars": [
      "tp_name_armortype_ga",
      "tp_name_armortype_ya",
      "tp_name_armortype_ra",
      "tp_name_armortype_none"
    ],
    "teamplay-restricted": false,
    "type": "string"
  },
  "bestammo": {
    "description": "returns ammo held for the 'best' weapon",
    "related-cvars": [
      "tp_weapon_order"
    ],
    "teamplay-restricted": false,
    "type": "integer"
  },
  "bestweapon": {
    "description": "returns name of best weapon in inventory",
    "related-cvars": [
      "tp_weapon_order",
      "tp_name_sg",
      "tp_name_ssg",
      "tp_name_ng",
      "tp_name_sng",
      "tp_name_gl",
      "tp_name_rl",
      "tp_name_lg"
    ],
    "teamplay-restricted": false,
    "type": "string"
  },
  "cam_angles": {
    "description": "returns current camera angles, in format that can be passed to /cam_angles command.",
    "flags": [
      "spectator-only"
    ],
    "teamplay-restricted": true,
    "type": "string"
  },
  "cam_angles_pitch": {
    "description": "returns current camera pitch (vertical angle).",
    "flags": [
      "spectator-only"
    ],
    "teamplay-restricted": true,
    "type": "float"
  },
  "cam_angles_roll": {
    "description": "returns current camera roll (not used).",
    "flags": [
      "spectator-only"
    ],
    "teamplay-restricted": true,
    "type": "float"
  },
  "cam_angles_yaw": {
    "description": "returns current camera yaw (horizontal angle).",
    "flags": [
      "spectator-only"
    ],
    "teamplay-restricted": true,
    "type": "float"
  },
  "cam_pos": {
    "description": "returns current camera position, in format that can be passed to /cam_pos command.",
    "flags": [
      "spectator-only"
    ],
    "teamplay-restricted": true,
    "type": "string"
  },
  "cam_pos_x": {
    "description": "returns one component of current camera position.",
    "flags": [
      "spectator-only"
    ],
    "teamplay-restricted": true,
    "type": "float"
  },
  "cam_pos_y": {
    "description": "returns one component of current camera position.",
    "flags": [
      "spectator-only"
    ],
    "teamplay-restricted": true,
    "type": "float"
  },
  "cam_pos_z": {
    "description": "returns one component of current camera position.",
    "flags": [
      "spectator-only"
    ],
    "teamplay-restricted": true,
    "type": "float"
  },
  "cells": {
    "description": "returns number of cells held, regardless of weapon selected",
    "teamplay-restricted": false,
    "type": "integer"
  },
  "colored_armor": {
    "description": "returns $armor, surrounded by color codes so it is displayed in &c0b0red&r, &cff0yellow&r, &e00green&r or &cfffwhite&r",
    "teamplay-restricted": false,
    "type": "string"
  },
  "colored_powerups": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "colored_short_powerups": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "conheight": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "connectiontype": {
    "description": "returns the current type of the connection",
    "enum": [
      {
        "description": "client is disconnected from the server",
        "value": "disconnected"
      },
      {
        "description": "client is connected as a spectator",
        "value": "spectator"
      },
      {
        "description": "client is connected as a player",
        "value": "player"
      }
    ],
    "teamplay-restricted": true,
    "type": "string"
  },
  "conwidth": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "date": {
    "description": "returns the current date in the format <day>.<month>.<year>",
    "teamplay-restricted": true,
    "type": "string"
  },
  "dateiso": {
    "system-generated": true,
    "teamplay-restricted": true
  },
  "deathloc": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "demolength": {
    "description": "returns the expected length of the current demo, in seconds",
    "teamplay-restricted": true,
    "type": "integer"
  },
  "demoname": {
    "description": "returns the name of the current demo, minus extension",
    "teamplay-restricted": true,
    "type": "string"
  },
  "demoplayback": {
    "description": "returns whether or not the client is current watching a demo",
    "teamplay-restricted": true,
    "type": "boolean"
  },
  "demotime": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "droploc": {
    "description": "returns the name of the location where the last backpack was dropped by the current player.",
    "teamplay-restricted": false,
    "type": "string"
  },
  "droptime": {
    "description": "returns the number of seconds since the last backpack was dropped by the current player.",
    "teamplay-restricted": false,
    "type": "integer"
  },
  "gamedir": {
    "description": "returns the current gamedir, which is often set when a server is running a mod.\ne.g: 'fortress' for Team Fortress mods",
    "teamplay-restricted": true,
    "type": "string"
  },
  "health": {
    "description": "the current player's health (0 - 250)",
    "teamplay-restricted": false
  },
  "lastip": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "lastloc": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "lastpowerup": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "latency": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "ledpoint": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "ledstatus": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "location": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "matchname": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "matchstatus": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "matchtype": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "mp3_volume": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "mp3info": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "nails": {
    "description": "returns number of nails held, regardless of weapon selected",
    "teamplay-restricted": false,
    "type": "integer"
  },
  "need": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "ping": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "point": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "pointatloc": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "pointloc": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "powerups": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "qt": {
    "description": "returns \" - useful to clear cvars in scripts",
    "teamplay-restricted": true
  },
  "rand": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "rockets": {
    "description": "returns number of rockets held, regardless of weapon selected",
    "teamplay-restricted": false,
    "type": "integer"
  },
  "serverip": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "shells": {
    "description": "returns number of shells held, regardless of weapon selected",
    "teamplay-restricted": false,
    "type": "integer"
  },
  "team1": {
    "system-generated": true,
    "teamplay-restricted": true
  },
  "team2": {
    "system-generated": true,
    "teamplay-restricted": true
  },
  "tf_skin": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "time": {
    "description": "returns the local time in the format <hours>:<minutes>",
    "teamplay-restricted": true,
    "type": "string"
  },
  "timestamp": {
    "system-generated": true,
    "teamplay-restricted": true
  },
  "took": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "tookatloc": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "tookloc": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  },
  "tp_powerups": {
    "description": "$colored_powerups or $colored_short_powerups, depending on value of tp_poweruptextstyle",
    "related-cvars": [
      "tp_poweruptextstyle"
    ],
    "teamplay-restricted": false,
    "type": "boolean"
  },
  "triggermatch": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "weapon": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "weaponnum": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": true
  },
  "weapons": {
    "flags": [
      "incomplete"
    ],
    "teamplay-restricted": false
  }
}

================================================
FILE: help_variables.json
================================================
{
  "groups": [
    {
      "id": "0",
      "major-group": "Miscellaneous",
      "name": "(added by system)"
    },
    {
      "id": "2",
      "major-group": "Miscellaneous",
      "name": "Other"
    },
    {
      "id": "3",
      "major-group": "HUD",
      "name": "Chat Settings"
    },
    {
      "id": "4",
      "major-group": "Miscellaneous",
      "name": "Config Management"
    },
    {
      "id": "5",
      "major-group": "HUD",
      "name": "Console Settings"
    },
    {
      "id": "6",
      "major-group": "Graphics",
      "name": "Crosshair Settings"
    },
    {
      "id": "7",
      "major-group": "Demos",
      "name": "Demo Handling"
    },
    {
      "id": "8",
      "major-group": "Graphics",
      "name": "FPS and EyeCandy Settings"
    },
    {
      "id": "9",
      "major-group": "Input",
      "name": "Input - Keyboard"
    },
    {
      "id": "10",
      "major-group": "Input",
      "name": "Input - Misc"
    },
    {
      "id": "11",
      "major-group": "Input",
      "name": "Input - Mouse"
    },
    {
      "id": "12",
      "major-group": "Miscellaneous",
      "name": "IRC Client"
    },
    {
      "id": "13",
      "major-group": "Teamplay",
      "name": "Item Names"
    },
    {
      "id": "14",
      "major-group": "Teamplay",
      "name": "Item Need Amounts"
    },
    {
      "id": "15",
      "major-group": "Graphics",
      "name": "Lighting"
    },
    {
      "id": "16",
      "major-group": "Demos",
      "name": "Match Tools"
    },
    {
      "id": "17",
      "major-group": "Miscellaneous",
      "name": "Menu"
    },
    {
      "id": "18",
      "major-group": "Sound",
      "name": "MP3 Settings"
    },
    {
      "id": "19",
      "major-group": "HUD",
      "name": "MQWCL HUD"
    },
    {
      "id": "20",
      "major-group": "Demos",
      "name": "MultiView Demos"
    },
    {
      "id": "21",
      "major-group": "Multiplayer",
      "name": "Network Settings"
    },
    {
      "id": "22",
      "major-group": "Miscellaneous",
      "name": "Not settable"
    },
    {
      "id": "23",
      "major-group": "Obsolete",
      "name": "Obsolete"
    },
    {
      "id": "24",
      "major-group": "Obsolete",
      "name": "Obsolete (2.2)"
    },
    {
      "id": "25",
      "major-group": "Obsolete",
      "name": "Obsolete (2.2) - Custom Browser Fields"
    },
    {
      "id": "26",
      "major-group": "Obsolete",
      "name": "Obsolete (3.0) - Audio"
    },
    {
      "id": "27",
      "major-group": "Obsolete",
      "name": "Obsolete (3.0) - Authentication"
    },
    {
      "id": "28",
      "major-group": "Obsolete",
      "name": "Obsolete (3.0) - Input Systems"
    },
    {
      "id": "29",
      "major-group": "Obsolete",
      "name": "Obsolete (3.0) - Invalid"
    },
    {
      "id": "30",
      "major-group": "Obsolete",
      "name": "Obsolete (3.0) - Software Renderer"
    },
    {
      "id": "31",
      "major-group": "Obsolete",
      "name": "Obsolete (3.0) - Video"
    },
    {
      "id": "32",
      "major-group": "Sound",
      "name": "VOIP"
    },
    {
      "id": "33",
      "major-group": "Obsolete",
      "name": "Obsolete (Commands)"
    },
    {
      "id": "34",
      "major-group": "Obsolete",
      "name": "Obsolete (server infokeys)"
    },
    {
      "id": "35",
      "major-group": "Graphics",
      "name": "OpenGL Rendering"
    },
    {
      "id": "36",
      "major-group": "Graphics",
      "name": "Particle Effects"
    },
    {
      "id": "37",
      "major-group": "Multiplayer",
      "name": "Player Settings"
    },
    {
      "id": "38",
      "major-group": "Multiplayer",
      "name": "QTV Settings"
    },
    {
      "id": "39",
      "major-group": "Graphics",
      "name": "Screen & Powerup Blends"
    },
    {
      "id": "40",
      "major-group": "Graphics",
      "name": "Screen Settings"
    },
    {
      "id": "41",
      "major-group": "Graphics",
      "name": "Screenshot Settings"
    },
    {
      "id": "42",
      "major-group": "Multiplayer",
      "name": "Server Browser"
    },
    {
      "id": "43",
      "major-group": "Server",
      "name": "Server Settings"
    },
    {
      "id": "44",
      "major-group": "Multiplayer",
      "name": "Skin Settings"
    },
    {
      "id": "45",
      "major-group": "Sound",
      "name": "Sound Settings"
    },
    {
      "id": "46",
      "major-group": "Multiplayer",
      "name": "Spectator Tracking"
    },
    {
      "id": "47",
      "major-group": "HUD",
      "name": "Status Bar and Scoreboard"
    },
    {
      "id": "48",
      "major-group": "Miscellaneous",
      "name": "System Settings"
    },
    {
      "id": "49",
      "major-group": "Teamplay",
      "name": "Teamplay Communications"
    },
    {
      "id": "50",
      "major-group": "Graphics",
      "name": "Texture Settings"
    },
    {
      "id": "51",
      "major-group": "Graphics",
      "name": "Turbulency and Sky Settings"
    },
    {
      "id": "52",
      "major-group": "Graphics",
      "name": "Video Settings"
    },
    {
      "id": "53",
      "major-group": "Graphics",
      "name": "View Settings"
    },
    {
      "id": "54",
      "major-group": "Graphics",
      "name": "Weapon View Model Settings"
    }
  ],
  "vars": {
    "_vid_default_mode": {
      "desc": "This variable sets the default video mode that the client uses.",
      "group-id": "31",
      "type": "float"
    },
    "_vid_default_mode_win": {
      "desc": "This variable sets the default video mode that the client uses when windowed.",
      "group-id": "31",
      "type": "float"
    },
    "_windowed_mouse": {
      "group-id": "28",
      "type": "boolean",
      "values": [
        {
          "description": "Disable windowed mouse support so you can use the mouse in other applications.",
          "name": "false"
        },
        {
          "description": "Enabled windowed mouse support so you can use the mouse in the client.",
          "name": "true"
        }
      ]
    },
    "allow_download": {
      "default": "1",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Clients can download game data from the server.",
          "name": "true"
        }
      ]
    },
    "allow_download_demos": {
      "default": "1",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable",
          "name": "0"
        },
        {
          "description": "Clients can download demo files from the server.",
          "name": "1"
        }
      ]
    },
    "allow_download_gfx": {
      "desc": "Enables downloading files from the server from the gfx directory.",
      "group-id": "43",
      "remarks": "Server-side.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "allow_download_maps": {
      "default": "1",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Clients can download .bsp map files from the server.",
          "name": "true"
        }
      ]
    },
    "allow_download_models": {
      "default": "1",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Clients can download .mdl files from the server.",
          "name": "true"
        }
      ]
    },
    "allow_download_other": {
      "default": "0",
      "desc": "Enables downloading files from the server which are not in \"skins\", \"progs\", \"sound\", \"maps\" nor \"gfx\" directories.",
      "group-id": "43",
      "remarks": "Server-side.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "allow_download_pakmaps": {
      "default": "1",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Clients can download map files in paks from the server.",
          "name": "true"
        }
      ]
    },
    "allow_download_skins": {
      "default": "1",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Clients can download .pcx skin files from the server.",
          "name": "true"
        }
      ]
    },
    "allow_download_sounds": {
      "default": "1",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Clients can download .wav sound files from the server.",
          "name": "true"
        }
      ]
    },
    "allow_f_cmdline": {
      "default": "1",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "Your client will not respond to f_cmdline checks.",
          "name": "false"
        },
        {
          "description": "Your client will respond to f_cmdline checks with your current command line used to run current ezQuake instance.",
          "name": "true"
        }
      ]
    },
    "allow_f_system": {
      "default": "1",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "Your client will not respond to f_system checks.",
          "name": "false"
        },
        {
          "description": "Your client will respond to f_system checks displaying your PC configuration.",
          "name": "true"
        }
      ]
    },
    "allow_scripts": {
      "default": "2",
      "desc": "Controls the complexity of movement scripts allowed in your client (e.g. rocket jump scripts). Other players can check your setting with 'f_scripts'.",
      "group-id": "9",
      "remarks": "If anyone said 'f_scripts' since the last map change, your client will also auto-report any change of allow_scripts.\nCommand line switches -norjscripts or -noscripts set allow_scripts to 0.\nMay not be changed during a match in some rulesets.",
      "type": "enum",
      "values": [
        {
          "description": "Same as 1, but also block fast +lookdown/+lookup, so even simple rjump will be impossible.\nBlocks KTPro /kfjump and /krjump aliases.",
          "name": "0"
        },
        {
          "description": "Allow only simple scripts - it will block left/right turning, so fjump (for example) will be impossible, but normal rjump (+lookdown;+attack;+jump) will be possible.\nBlocks KTPro alias /kfjump too.",
          "name": "1"
        },
        {
          "description": "Allow scripts (default).",
          "name": "2"
        }
      ]
    },
    "auth_timeout": {
      "desc": "Not currently used.",
      "group-id": "43",
      "type": "float"
    },
    "auth_validate": {
      "group-id": "27",
      "remarks": "If you have 'auth_warninvalid 1' and someone gives a dirty hash in a version response (because they are using a hacked client that can't work out the right response), the client will print something like\n'Warning Invalid Client: playername (userid)' in your console ('auth_warninvalid 0' is default).",
      "type": "boolean",
      "values": [
        {
          "description": "If you don't want your client to validate other ezQuake clients.",
          "name": "false"
        },
        {
          "description": "Performs the validation (but you need to use 'validate_clients')",
          "name": "true"
        }
      ]
    },
    "auth_viewcrc": {
      "group-id": "27",
      "type": "boolean",
      "values": [
        {
          "description": "the client hides the authentication CRC in f_version responses.",
          "name": "false"
        },
        {
          "description": "the client shows you the authentication CRC in f_version responses.",
          "name": "true"
        }
      ]
    },
    "auth_warninvalid": {
      "desc": "Check auth_validate.",
      "group-id": "27",
      "type": "float"
    },
    "b_switch": {
      "default": "",
      "desc": "This variable allows you to define the highest weapon that the client should switch to upon a backpack pickup.\nThe possible arguments of \"b_switch\" refer to the impulse that is used to switch to a certain weapon.\nNote that a setting of 1 will effectively disable backpack weapon switching.",
      "group-id": "37",
      "type": "enum",
      "values": [
        {
          "description": "Axe",
          "name": "1"
        },
        {
          "description": "Shotgun",
          "name": "2"
        },
        {
          "description": "Double-Barreled Shotgun",
          "name": "3"
        },
        {
          "description": "Nailgun",
          "name": "4"
        },
        {
          "description": "Super Nailgun",
          "name": "5"
        },
        {
          "description": "Grenade Launcher",
          "name": "6"
        },
        {
          "description": "Rocket Launcher",
          "name": "7"
        },
        {
          "description": "ThunderBolt",
          "name": "8"
        }
      ]
    },
    "baseskin": {
      "default": "base",
      "desc": "Defines what skin you see other people using if you don't have their skin and don't have skin forcing on.",
      "group-id": "44",
      "type": "string"
    },
    "bgmvolume": {
      "default": "1",
      "desc": "This variable sets the volume of the CD music.",
      "group-id": "45",
      "type": "float"
    },
    "block_switch": {
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not block task-switching",
          "name": "false"
        },
        {
          "description": "Block task-switching",
          "name": "true"
        }
      ]
    },
    "bottomcolor": {
      "default": "",
      "desc": "Sets the pants color.",
      "group-id": "37",
      "type": "enum",
      "values": [
        {
          "description": "White",
          "name": "0"
        },
        {
          "description": "Brown",
          "name": "1"
        },
        {
          "description": "Lavender",
          "name": "2"
        },
        {
          "description": "Khaki",
          "name": "3"
        },
        {
          "description": "Red",
          "name": "4"
        },
        {
          "description": "Lt Brown",
          "name": "5"
        },
        {
          "description": "Peach",
          "name": "6"
        },
        {
          "description": "Lt Peach",
          "name": "7"
        },
        {
          "description": "Purple",
          "name": "8"
        },
        {
          "description": "Dk Purple",
          "name": "9"
        },
        {
          "description": "Tan",
          "name": "10"
        },
        {
          "description": "Green",
          "name": "11"
        },
        {
          "description": "Yellow",
          "name": "12"
        },
        {
          "description": "Blue",
          "name": "13"
        },
        {
          "description": "Orange.",
          "name": "14"
        },
        {
          "description": "Bright red.",
          "name": "15"
        },
        {
          "description": "Black.",
          "name": "16"
        }
      ]
    },
    "cam_dist": {
      "default": "100",
      "desc": "Distance from player. Use +forward/+back to adjust it smoothly.",
      "group-id": "46",
      "remarks": "For use with cam_thirdperson.",
      "type": "float"
    },
    "cam_lockdir": {
      "default": "0",
      "desc": "Force camera to locked direction mode.",
      "group-id": "46",
      "type": "boolean",
      "values": [
        {
          "description": "Don't force",
          "name": "false"
        },
        {
          "description": "Force",
          "name": "true"
        }
      ]
    },
    "cam_lockpos": {
      "default": "0",
      "desc": "Force camera to locked position mode.",
      "group-id": "46",
      "remarks": "EXPERIMENTAL.",
      "type": "boolean",
      "values": [
        {
          "description": "Don't force",
          "name": "false"
        },
        {
          "description": "Force",
          "name": "true"
        }
      ]
    },
    "cam_thirdperson": {
      "default": "0",
      "desc": "Enables third person view in demo playback and spectator mode.\nIn track mode, we look at the person being tracked rather than through his eyes.\nUnlike cl_camera_tpp, you can use the mouse to look around.",
      "group-id": "46",
      "remarks": "in track mode, we look at the person being tracked rather than through his eyes.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cam_zoomaccel": {
      "default": "2000",
      "desc": "To control how fast you zoom in onto the target with +forward/+back in cam_thirdperson mode.",
      "group-id": "46",
      "type": "float"
    },
    "cam_zoomspeed": {
      "default": "300",
      "desc": "To control how fast you zoom in onto the target with +forward/+back in cam_thirdperson mode.",
      "group-id": "46",
      "type": "float"
    },
    "cfg_backup": {
      "default": "0",
      "group-id": "4",
      "type": "boolean",
      "values": [
        {
          "description": "No backup of your config.",
          "name": "false"
        },
        {
          "description": "Backs up your old config before overwriting it with cfg_save.",
          "name": "true"
        }
      ]
    },
    "cfg_browser_democolor": {
      "desc": "Color of the demo entries in the cfg browser.",
      "group-id": "25",
      "type": "string"
    },
    "cfg_browser_dircolor": {
      "desc": "Color of the dir entries in the cfg browser.",
      "group-id": "25",
      "type": "string"
    },
    "cfg_browser_interline": {
      "desc": "Size of the space between entries in the cfg browser.",
      "group-id": "25",
      "type": "integer"
    },
    "cfg_browser_scrollnames": {
      "desc": "Toggle scrolling of the filenames in the cfg browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cfg_browser_selectedcolor": {
      "desc": "Color of the selected entries in the cfg browser.",
      "group-id": "25",
      "type": "string"
    },
    "cfg_browser_showdate": {
      "desc": "Toggle the date column in the cfg browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cfg_browser_showsize": {
      "desc": "Toggle the file size column in the cfg browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cfg_browser_showstatus": {
      "desc": "Toggle the display of the status bar in the cfg browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cfg_browser_showtime": {
      "desc": "Toggle the time column in the cfg browse.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cfg_browser_sortmode": {
      "desc": "Sorting mode in the cfg browser. Each number represents one column. Their order represents the priority of the sorting.",
      "group-id": "25",
      "type": "string"
    },
    "cfg_browser_stripnames": {
      "desc": "Toggle stripping of the filenames in the cfg browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cfg_browser_zipcolor": {
      "desc": "Color of the zip entries in the cfg browser.",
      "group-id": "25",
      "type": "string"
    },
    "cfg_legacy_exec": {
      "default": "1",
      "group-id": "4",
      "type": "enum",
      "values": [
        {
          "description": "Do not execute config.cfg and frontend.cfg in gamedir ever.",
          "name": "0"
        },
        {
          "description": "Execute config.cfg and frontend.cfg in gamedir (unless gamedir = qw)",
          "name": "1"
        },
        {
          "description": "Execute config.cfg and frontend.cfg even if gamedir = qw.",
          "name": "2"
        },
        {
          "description": "Execute config.cfg and frontend.cfg even if gamedir = qw. If not found in current gamedir, execute from qw dir.",
          "name": "3"
        }
      ]
    },
    "cfg_save_aliases": {
      "default": "1",
      "group-id": "4",
      "type": "boolean",
      "values": [
        {
          "description": "Won't save aliases.",
          "name": "false"
        },
        {
          "description": "cfg_save saves aliases.",
          "name": "true"
        }
      ]
    },
    "cfg_save_binds": {
      "default": "1",
      "group-id": "4",
      "type": "boolean",
      "values": [
        {
          "description": "Won't save binds.",
          "name": "false"
        },
        {
          "description": "Toggles whether cfg_save saves binds.",
          "name": "true"
        }
      ]
    },
    "cfg_save_cmdline": {
      "default": "1",
      "group-id": "4",
      "type": "boolean",
      "values": [
        {
          "description": "Won't save command line.",
          "name": "false"
        },
        {
          "description": "Writes your command line in configs made with cfg_save (commented out of course)",
          "name": "true"
        }
      ]
    },
    "cfg_save_cmds": {
      "default": "1",
      "group-id": "4",
      "type": "boolean",
      "values": [
        {
          "description": "Won't save commands.",
          "name": "false"
        },
        {
          "description": "Saves commands.",
          "name": "true"
        }
      ]
    },
    "cfg_save_cvars": {
      "default": "1",
      "group-id": "4",
      "type": "boolean",
      "values": [
        {
          "description": "Won't save variables.",
          "name": "false"
        },
        {
          "description": "Saves variables.",
          "name": "true"
        }
      ]
    },
    "cfg_save_onquit": {
      "default": "0",
      "desc": "When enabled, your main configuration (config.cfg) will be saved when you exit the application.",
      "group-id": "4",
      "remarks": "Configuration will be saved in the main user configuration file, that is config.cfg which can either be placed in the quake/ezquake/configs in your quakedir, or in your home dir in /ezquake, depending on cfg_use_home setting.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not save configuration on exit",
          "name": "false"
        },
        {
          "description": "Automatically save the configuration on exit",
          "name": "true"
        }
      ]
    },
    "cfg_save_sysinfo": {
      "default": "0",
      "desc": "Not implemented yet.",
      "group-id": "4",
      "type": "boolean"
    },
    "cfg_save_unchanged": {
      "default": "0",
      "group-id": "4",
      "type": "boolean",
      "values": [
        {
          "description": "Makes cfg_save only write variables that are not default valued to the config file.",
          "name": "false"
        },
        {
          "description": "Makes cfg_save write all variables to the config file.",
          "name": "true"
        }
      ]
    },
    "cfg_save_userinfo": {
      "default": "2",
      "group-id": "4",
      "remarks": "Note: 'cfg_save_userinfo 1' is best for teamfortress so you don't get kicked for changing bottom color.\ncfg_save will never save the password variable, even though technically it is a userinfo variable.",
      "type": "enum",
      "values": [
        {
          "description": "Do not save userinfo variables.",
          "name": "0"
        },
        {
          "description": "Save all userinfo variables except spectator, topcolor, bottomcolor, teamcolor, skin, team, rate, msg, w and b_switch.",
          "name": "1"
        },
        {
          "description": "Save all userinfo variables",
          "name": "2"
        }
      ]
    },
    "cfg_use_gamedir": {
      "default": "0",
      "desc": "If set & gamedir is not 'qw', configurations will be saved to subdirectory based on gamedir.\nUseful if configurations differ depending on gametype (e.g. team fortress)",
      "group-id": "4",
      "type": "boolean"
    },
    "cfg_use_home": {
      "default": "0",
      "desc": "When turned on, configuration will be saved into user's profile (home) directory.",
      "group-id": "4",
      "remarks": "This affects only cfg_save and cfg_load commands.",
      "type": "boolean",
      "values": [
        {
          "description": "Save the configuration into <quake>/ezquake/configs",
          "name": "false"
        },
        {
          "description": "Save the configuration into user's home dir",
          "name": "true"
        }
      ]
    },
    "cl_allow_downloads": {
      "default": "bsp,lmp,loc,mdl,mvd,pcx,spr,wad,wav",
      "desc": "This variable controls which file extensions a client/server can download/upload from/to the server/client.",
      "group-id": "9",
      "type": "string"
    },
    "cl_allow_uploads": {
      "default": "0",
      "group-id": "9",
      "type": "boolean",
      "values": [
        {
          "description": "Don't allow uploads.",
          "name": "0"
        },
        {
          "description": "Allow uploads.",
          "name": "1"
        }
      ]
    },
    "cl_anglespeedkey": {
      "default": "1.5",
      "desc": "This variable sets multiplier by which your \"cl_yawspeed\" (how fast you turn) is multiplied when running (+speed).",
      "group-id": "9",
      "type": "float"
    },
    "cl_backpackfilter": {
      "default": "0",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Don't filter backpacks.",
          "name": "0"
        },
        {
          "description": "Filter backpacks.",
          "name": "1"
        }
      ]
    },
    "cl_backspeed": {
      "default": "400",
      "desc": "This allows you to set your backward speed.\nObviously this is also limited by the server, usually to \"320\".",
      "group-id": "9",
      "remarks": "Sign of the value is ignored.",
      "type": "float"
    },
    "cl_bob": {
      "default": "0",
      "desc": "This variable controls how much your weapon moves up and down when walking.",
      "group-id": "54",
      "type": "float"
    },
    "cl_bobcycle": {
      "default": "0.0",
      "desc": "This variable determines how quickly your weapon moves up and down when walking.",
      "group-id": "54",
      "type": "float"
    },
    "cl_bobhead": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "cl_bobup": {
      "default": "0.0",
      "desc": "This variable controls how long your weapon stays up before cycling when walking.",
      "group-id": "54",
      "type": "float"
    },
    "cl_bonusflash": {
      "default": "0",
      "desc": "Controls weapon and item pickup flash.",
      "group-id": "39",
      "type": "boolean"
    },
    "cl_c2sImpulseBackup": {
      "default": "3",
      "desc": "Used with cl_c2spps, it controls how many backup copies of packets with non-zero impulses are to be sent to the server.\nThe recommended value is 3, but you can try 2 or even 1 to reduce traffic if you don't have any packet loss.",
      "group-id": "21",
      "type": "integer"
    },
    "cl_c2sdupe": {
      "default": "0",
      "desc": "Controls whether to send duplicate packets to the server.",
      "group-id": "21",
      "remarks": "Requires server support.",
      "type": "integer"
    },
    "cl_c2spps": {
      "default": "0",
      "desc": "Packet filtering (a la Qizmo's .c2spps command).\nUse this to reduce network traffic if you're playing on a 28800 (or worse) connection and can't set cl_maxfps 72 because it causes lag.\nAlso consider use of FPS independent physics in conjunction with cl_physfps.",
      "group-id": "21",
      "type": "integer"
    },
    "cl_camera_death": {
      "default": "0",
      "desc": "Camera view above your body after death.",
      "group-id": "46",
      "remarks": "Enabled only for viewing demos and observing games.",
      "type": "boolean"
    },
    "cl_camera_tpp": {
      "default": "0",
      "group-id": "46",
      "remarks": "Enabled only for viewing demos and observing games.",
      "type": "enum",
      "values": [
        {
          "description": "1st person view",
          "name": "0"
        },
        {
          "description": "3rd person view ala Tomb Raider (such a fun!)",
          "name": "1"
        },
        {
          "description": "3rd person view ala cl_chasecam 0 (buggy)",
          "name": "2"
        }
      ]
    },
    "cl_camera_tpp_distance": {
      "default": "-56",
      "desc": "Sets distance of 3rd person camera from tracked player.\nYou can use negative values too.",
      "group-id": "46",
      "remarks": "For use with cl_camera_tpp. See cl_camera_tpp_height too.",
      "type": "float"
    },
    "cl_camera_tpp_height": {
      "default": "24",
      "desc": "Sets vertical position of 3rd person camera.\nYou can use negative values too.",
      "group-id": "46",
      "remarks": "Set cl_camera_tpp 1 first.",
      "type": "float"
    },
    "cl_chasecam": {
      "default": "1",
      "desc": "Toggle between 3rd-person view and 1st-person view while observing or during demo playback.",
      "group-id": "46",
      "type": "boolean",
      "values": [
        {
          "description": "Third-person view.",
          "name": "false"
        },
        {
          "description": "First-person (\"through-eyes\") view.",
          "name": "true"
        }
      ]
    },
    "cl_chatmode": {
      "default": "2",
      "desc": "Console chat mode.",
      "group-id": "5",
      "type": "enum",
      "values": [
        {
          "description": "Text in the console is always treated as a command and in order to chat you have to use messagemode/messagemode2 or use the say/say_team commands.",
          "name": "0"
        },
        {
          "description": "Everything typed in the console goes into chat. In order to issue a command, prefix it with a slash (/).",
          "name": "1"
        },
        {
          "description": "If the first word in the line is a command, it is executed. Otherwise, the line is sent as chat.",
          "name": "2"
        }
      ]
    },
    "cl_chunksperframe": {
      "default": "30",
      "desc": "Affects the download speed when using chunked downloads, more chunks per frame results in higher download speed.",
      "group-id": "21",
      "remarks": "Servers can limit the amount of chunks sent per frame.",
      "type": "integer"
    },
    "cl_clock": {
      "default": "0",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Off.",
          "name": "0"
        },
        {
          "description": "Shows the time you spent on server.",
          "name": "1"
        },
        {
          "description": "Shows the time of day.",
          "name": "2"
        }
      ]
    },
    "cl_clock_format": {
      "default": "0",
      "desc": "Changes the format of the clock which is displayed if cl_clock is non-zero.",
      "group-id": "40",
      "remarks": "This was changed to an enumerated type in ezQuake 3.5, to match hud_clock_format.",
      "type": "enum",
      "values": [
        {
          "description": "24hr time with seconds",
          "name": "0"
        },
        {
          "description": "12hr time (AM/PM) without seconds",
          "name": "1"
        },
        {
          "description": "12hr time (AM/PM) with seconds",
          "name": "2"
        },
        {
          "description": "24hr time without seconds",
          "name": "3"
        }
      ]
    },
    "cl_clock_x": {
      "default": "0",
      "desc": "Horizontal coordinates of the clock.",
      "group-id": "40",
      "type": "float"
    },
    "cl_clock_y": {
      "default": "-1",
      "desc": "Vertical coordinates of the clock.\nIf < 0, the coordinates are calculated from bottom up, e.g. -1 means the screen line just above the scoreboard.",
      "group-id": "40",
      "type": "float"
    },
    "cl_cmdline": {
      "default": "",
      "desc": "Read-only variable showing you what were the commandline options used to launch the client.",
      "group-id": "2",
      "type": "string"
    },
    "cl_confirmquit": {
      "default": "0",
      "desc": "This sets whether to confirm on quit or quit with no confirmation.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Do not ask for confirmation on quit.",
          "name": "false"
        },
        {
          "description": "Ask for confirmation on quit. This will display the 'About' message box where you have to press [Y] to quit.",
          "name": "true"
        }
      ]
    },
    "cl_crossx": {
      "default": "0",
      "desc": "This variable allows you to move the position of the crosshair on the X-axis by the specified amount of pixels.",
      "group-id": "6",
      "type": "float"
    },
    "cl_crossy": {
      "default": "0",
      "desc": "This variable allows you to move the position of the crosshair on the Y-axis by the specified amount of pixels.",
      "group-id": "6",
      "type": "float"
    },
    "cl_crypt_rcon": {
      "default": "1",
      "desc": "Encrypts rcon messages sent to server.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_curlybraces": {
      "default": "0",
      "desc": "Enables new syntax to be used for Quake scripting allowing you to enclose commands into curly braces.",
      "group-id": "5",
      "remarks": "See scripting manual for further info.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_deadbodyFilter": {
      "default": "0",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "Don't filter dead bodies.",
          "name": "0"
        },
        {
          "description": "Filter dead bodies after they fall on the ground.",
          "name": "1"
        },
        {
          "description": "Instantly filter dead bodies.",
          "name": "2"
        },
        {
          "description": "Filter dead bodies (instantly) unless you are playing a TeamFortress game.",
          "name": "3"
        }
      ]
    },
    "cl_debug_antilag_ghost": {
      "default": "0",
      "desc": "Allows rendering a translucent copy of player position on supported .mvd/qtv streams.",
      "group-id": "21",
      "type": "enum",
      "values": [
        {
          "description": "Normal",
          "name": "0"
        },
        {
          "description": "Antilag-rewind",
          "name": "1"
        },
        {
          "description": "Client position",
          "name": "2"
        }
      ]
    },
    "cl_debug_antilag_lines": {
      "default": "0",
      "desc": "Chooses if lines are drawn between the different player positions on supported .mvd/qtv streams.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_debug_antilag_self": {
      "default": "0",
      "desc": "Chooses whether to include the currently tracked player in antilag debugging.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_debug_antilag_send": {
      "default": "0",
      "desc": "Sends location of opponents, which is stored in .mvd on supported servers.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_debug_antilag_view": {
      "default": "0",
      "desc": "Chooses which location is used when rendering players on supported .mvd/qtv streams.",
      "group-id": "21",
      "type": "enum",
      "values": [
        {
          "description": "Normal",
          "name": "0"
        },
        {
          "description": "Antilag-rewind",
          "name": "1"
        },
        {
          "description": "Client position",
          "name": "2"
        }
      ]
    },
    "cl_debug_weapon_send": {
      "default": "0",
      "desc": "Sends information about client-side weapon selection, which is stored in .mvd on supported servers.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_debug_weapon_view": {
      "default": "0",
      "desc": "Views the client-side weapon debugging messages, if stored in .mvd.",
      "group-id": "0",
      "type": "boolean"
    },
    "cl_delay_packet": {
      "default": "0",
      "desc": "Client will delay incoming and outgoing packets, allowing user to increase his ping in the game.",
      "group-id": "21",
      "remarks": "Specified in ms. If delay is 20ms, incoming packets will be delayed by 10ms, outgoing packets too. It's preferred to use the least value that gives the desired ping.",
      "type": "integer"
    },
    "cl_delay_packet_deviation": {
      "default": "0",
      "desc": "Allows random deviation to be added to /cl_delay_packet delay.",
      "group-id": "21",
      "remarks": "Specified in ms.  Makes /cl_delay_packet better simulate high-ping connections.",
      "type": "integer"
    },
    "cl_delay_packet_target": {
      "default": "0",
      "desc": "Targets a particular ping, rather than specifying the additional delay.\nAdds half the ping to the outgoing packet and the remainder to incoming.",
      "group-id": "21",
      "type": "integer"
    },
    "cl_demoPingInterval": {
      "default": "5",
      "desc": "How often to request ping updates when recording demos.\nThis variable doesn't affect ping updates when the scoreboard is shown (they are always one update per 2 seconds).",
      "group-id": "7",
      "type": "integer",
      "values": [
        {
          "description": "Disable automatic ping requests.",
          "name": "0"
        },
        {
          "description": "Request every 5 seconds (default).",
          "name": "5"
        }
      ]
    },
    "cl_demo_qwd_delta": {
      "default": "1",
      "desc": "Whether or not to write delta packets for entities into .qwd files.\nOlder clients may not be able to play these back.",
      "group-id": "7",
      "type": "boolean"
    },
    "cl_democlock": {
      "default": "0",
      "desc": "A clock showing how much time has elapsed since the start of the demo.",
      "group-id": "40",
      "type": "boolean"
    },
    "cl_democlock_x": {
      "default": "0",
      "desc": "Determine where the democlock is positioned on your screen on the X co-ordinate.",
      "group-id": "40",
      "type": "float"
    },
    "cl_democlock_y": {
      "default": "-2",
      "desc": "Determine where the democlock is positioned on your screen on the Y co-ordinate.",
      "group-id": "40",
      "type": "float"
    },
    "cl_demoplay_flash": {
      "default": "0.33",
      "desc": "Reduces flash grenade effect when watching demos.",
      "group-id": "39",
      "type": "float",
      "values": [
        {
          "description": "Flash effects disabled",
          "name": "0"
        },
        {
          "description": "Adjust the intensity of the flash.",
          "name": "0.x"
        },
        {
          "description": "Original",
          "name": "1"
        }
      ]
    },
    "cl_demospeed": {
      "default": "1",
      "desc": "Controls the speed of demo playback in percentage (can be changed during demo playback if you wish).",
      "group-id": "7",
      "type": "float"
    },
    "cl_demoteamplay": {
      "default": "0",
      "desc": "If set, teamplay settings enabled during .dem playback.",
      "group-id": "7",
      "type": "boolean"
    },
    "cl_earlypackets": {
      "default": "1",
      "desc": "Read network data independently on physical frames.\nWhen using independent physics, network data will be read as early as possible, compared to the old way when it was read only on every physframe (77 times per second).",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_fakename": {
      "default": "",
      "desc": "Automatically prefixes all team messages with a shorter version of your nick unless the message has a \"fake\" part already (so no configs are broken).",
      "group-id": "3",
      "remarks": "Applies for say_team and messagemode2.",
      "type": "string"
    },
    "cl_fakename_suffix": {
      "default": ": ",
      "desc": "Suffix for cl_fakename.",
      "group-id": "3",
      "type": "string"
    },
    "cl_fakeshaft": {
      "default": "0",
      "desc": "Smoothes out shaft movement.\n0 = no smoothing at all\n1 = 100% smoothing\nA value of about 0.5 is recommended for modem players.\n\nNote that this only affects the visual display of the shaft beam; the 'true' beam remains in the original location.",
      "group-id": "8",
      "type": "float"
    },
    "cl_fakeshaft_extra_updates": {
      "default": "1",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Update shaft position only when network packet received from server",
          "name": "0"
        },
        {
          "description": "Update shaft position every frame",
          "name": "1"
        }
      ]
    },
    "cl_filterdrawviewmodel": {
      "default": "0",
      "desc": "Prevents r_drawviewmodel from being changed by servers like Rocket Arena.",
      "group-id": "54",
      "type": "boolean"
    },
    "cl_fix_mvd": {
      "default": "0",
      "desc": "A fix for buggy MVD demos, making the client to parse them properly",
      "group-id": "21",
      "remarks": "Was caused by a flaw in MVDSV server",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_floodprot": {
      "default": "0",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "Disable floodprot.",
          "name": "false"
        },
        {
          "description": "Enable floodprot.",
          "name": "true"
        }
      ]
    },
    "cl_forwardspeed": {
      "default": "400",
      "desc": "This allows you to set your forward speed.\nObviously this is also limited by the server, usually to \"320\".",
      "group-id": "9",
      "remarks": "Sign of the value is ignored.",
      "type": "float"
    },
    "cl_fp_messages": {
      "default": "4",
      "desc": "This variable is used in conjunction with the variable \"cl_fp_persecond\" to define when the floodprot protection should be triggered (if \"cl_floodprot\" is set to \"1\").",
      "group-id": "3",
      "type": "float"
    },
    "cl_fp_persecond": {
      "default": "4",
      "desc": "This variable is used in conjunction with the variable \"cl_fp_messages\" to define when the floodprot protection should be triggered (if \"cl_floodprot\" is set to \"1\").",
      "group-id": "3",
      "type": "float"
    },
    "cl_gameclock": {
      "default": "0",
      "desc": "Displays clock with seconds on the screen.",
      "group-id": "40",
      "remarks": "Use cl_gameclock_x and cl_gameclock_y to place it anywhere on the screen.",
      "type": "enum",
      "values": [
        {
          "description": "Turned OFF",
          "name": "0"
        },
        {
          "description": "Counts up from the start of the match.",
          "name": "1"
        },
        {
          "description": "Counts down from the start of the match.",
          "name": "2"
        },
        {
          "description": "Same as 1 but only minutes:seconds (hours are not being displayed).",
          "name": "3"
        },
        {
          "description": "Same as 2 but only minutes:seconds (hours are not being displayed).",
          "name": "4"
        }
      ]
    },
    "cl_gameclock_offset": {
      "default": "0",
      "desc": "Allows using gameclock in custom mods that don't support standard KT-like clock synchronization.",
      "group-id": "40",
      "remarks": "Some Capture The Flag or Team Fortress mods can take a use of this.",
      "type": "integer"
    },
    "cl_gameclock_x": {
      "default": "0",
      "desc": "Adjusts horizontal placement of the clock with seconds.",
      "group-id": "40",
      "remarks": "See cl_gameclock for detailed info about the clock.",
      "type": "float"
    },
    "cl_gameclock_y": {
      "default": "-3",
      "desc": "Adjusts vertical placement of the clock with seconds.",
      "group-id": "40",
      "remarks": "See cl_gameclock for detailed info about the clock.",
      "type": "float"
    },
    "cl_gameclock_style": {
      "default": "0",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "White numbers",
          "name": "0"
        },
        {
          "description": "Red numbers",
          "name": "1"
        },
        {
          "description": "Green numbers (high bit)",
          "name": "2"
        },
        {
          "description": "Green numbers (low bit)",
          "name": "3"
        }
      ]
    },
    "cl_gibFilter": {
      "default": "0",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Gibs are displayed.",
          "name": "false"
        },
        {
          "description": "Gibs are filtered.",
          "name": "true"
        }
      ]
    },
    "cl_hidenails": {
      "default": "0",
      "desc": "Toggles nails visibility.",
      "group-id": "8",
      "type": "float"
    },
    "cl_hiderockets": {
      "default": "0",
      "desc": "Toggles rockets visibility. Variable cl_r2g must be 0 for this to work.",
      "group-id": "8",
      "type": "float"
    },
    "cl_hightrack": {
      "default": "0",
      "desc": "Turns auto-tracking player with most frags ON when spectating or watching a demo.",
      "group-id": "46",
      "type": "float"
    },
    "cl_hud": {
      "default": "1",
      "desc": "Enables/Disables strings-hud.\nStrings hud is not mqwcl hud. It gives you ability put any string (or value of some variable) on your hud.",
      "group-id": "40",
      "remarks": "Strings hud banned for ruleset smackdown and smackdrive.",
      "type": "boolean",
      "values": [
        {
          "description": "Strings hud disabled",
          "name": "false"
        },
        {
          "description": "Strings hud enabled",
          "name": "true"
        }
      ]
    },
    "cl_hudswap": {
      "default": "0",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "The inventory is drawn on the right side of the screen.",
          "name": "false"
        },
        {
          "description": "The inventory is drawn on the left side of the screen.",
          "name": "true"
        }
      ]
    },
    "cl_iDrive": {
      "default": "0",
      "desc": "Emulates \"strafe script\". When turned on, you will always change direction instead of stopping when holding opposing movement keys +moveleft and +moveright, or +forward and +back.",
      "group-id": "9",
      "remarks": "Reported in your f_ruleset reply with the '+i' flag.\nCan not be changed during a match.",
      "type": "boolean",
      "values": [
        {
          "description": "Pressing keys for both directions will stop movement on that axis.",
          "name": "false"
        },
        {
          "description": "Auto-releases one of the keys when both directions are pressed.",
          "name": "true"
        }
      ]
    },
    "cl_independentPhysics": {
      "default": "1",
      "desc": "This enables independent physics. This means that you can achieve more FPS in the game than allowed by the server.\nThe amount of FPS used to communicate with the server is set by /cl_physfps and the amount of graphics FPS is set by /cl_maxfps.\nNote that you must have vid_vsync 0.",
      "group-id": "8",
      "remarks": "This variable can only be switched from 0<->1 when disconnected from a server (Qizmo/eztv are also servers).",
      "type": "boolean",
      "values": [
        {
          "description": "Disable independent physics.",
          "name": "false"
        },
        {
          "description": "Enable independent physics.",
          "name": "true"
        }
      ]
    },
    "cl_keypad": {
      "default": "1",
      "group-id": "9",
      "type": "enum",
      "values": [
        {
          "description": "QW compatibility: all keypad keys treated as though equivalent button pushed, eg KP_8 acts like uparrow would.",
          "name": "0"
        },
        {
          "description": "You will be able to bind all numpad keys independently of standard keys.\nUse kp_enter, kp_8 etc to differentiate from standard keys.",
          "name": "1"
        },
        {
          "description": "As 'cl_keypad 0' in game, 'cl_keypad 1' when in menus/console etc.",
          "name": "2"
        }
      ]
    },
    "cl_lerp_monsters": {
      "default": "1",
      "desc": "Enables linear interpolation on Quake monsters and creatures.",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_loadFragfiles": {
      "default": "1",
      "group-id": "47",
      "remarks": "Also needed to parse stats for extended scoreboard and frags tracker.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Enable displaying team fortress related statistics in the scoreboard (flag touches, steals, caps, etc)",
          "name": "true"
        }
      ]
    },
    "cl_maxfps": {
      "default": "0",
      "desc": "This variable sets the maximum limit for frames-per-second while in-game. Please see cl_maxfps_menu, vid_vsync, cl_independentphysics, and cl_physfps.",
      "group-id": "8",
      "type": "float"
    },
    "cl_maxfps_menu": {
      "default": "0",
      "desc": "This variable sets the maximum limit for frames-per-second while disconnected, has a minimum of 30, set lower to use display frequency.",
      "group-id": "8",
      "type": "float"
    },
    "cl_mediaroot": {
      "default": "0",
      "desc": "Changes where demos, screenshots and logs are saved, how variables demo_dir, sshot_dir and log_dir are treated.",
      "group-id": "48",
      "type": "enum",
      "values": [
        {
          "description": "Treat paths as relative to the Quake dir",
          "name": "0"
        },
        {
          "description": "Treat paths as relative to user home dir",
          "name": "1"
        },
        {
          "description": "Treat paths as system absolute paths",
          "name": "2"
        }
      ]
    },
    "cl_model_bobbing": {
      "default": "1",
      "desc": "Rotating models bob up and down like in Quake3.",
      "group-id": "8",
      "type": "boolean"
    },
    "cl_movespeedkey": {
      "default": "2.0",
      "desc": "This variable is the multiplier for how fast you move when running (+speed) in relation to when walking (-speed).",
      "group-id": "9",
      "remarks": "Sign of the value is ignored.",
      "type": "float"
    },
    "cl_multiview": {
      "default": "0",
      "desc": "This client adds a multiview component to mvd playback. Up to four views can be displayed at once. Use this variable to turn multiview on.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Multiview disabled",
          "name": "0"
        },
        {
          "description": "Still no multiview but you can use cl_mvdisplayhud to show small complex hud.",
          "name": "1"
        },
        {
          "description": "Two screens.",
          "name": "2"
        },
        {
          "description": "Three screens.",
          "name": "3"
        },
        {
          "description": "Four screens.",
          "name": "4"
        }
      ]
    },
    "cl_muzzleflash": {
      "default": "1",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "All turned off.",
          "name": "0"
        },
        {
          "description": "All turned on.",
          "name": "1"
        },
        {
          "description": "Own flash off, all other on.",
          "name": "2"
        }
      ]
    },
    "cl_mvdisplayhud": {
      "default": "1",
      "desc": "Toggle drawing of small compact HUD in each screen of Multiview control.",
      "group-id": "40",
      "remarks": "Also see cl_mvhudpos and cl_mvhudvertical when this is set to a value greater than 1.",
      "type": "enum",
      "values": [
        {
          "description": "Don't draw mini-HUDs when in multiview.",
          "name": "0"
        },
        {
          "description": "Draw original mini-HUDs when in multiview. (Only strings)",
          "name": "1"
        },
        {
          "description": "Draw names only.",
          "name": "2"
        },
        {
          "description": "Draw graphics. Icons for weapons, healthbar, armorbar.",
          "name": "3"
        },
        {
          "description": "Same as 3 but with values showing the health/armor on the bars.",
          "name": "4"
        },
        {
          "description": "Same as 4 but with a semitransparent black background.",
          "name": "5"
        }
      ]
    },
    "cl_mvhudflip": {
      "default": "0",
      "desc": "Flips the mini-HUD in multiview mode.",
      "group-id": "40",
      "remarks": "This only works when cl_mvdisplayhud is greater than 1. See also cl_mvhudvertical and cl_mvhudpos.",
      "type": "boolean",
      "values": [
        {
          "description": "Don't flip the mini-HUD drawing.",
          "name": "false"
        },
        {
          "description": "Flip the mini-HUD drawing.",
          "name": "true"
        }
      ]
    },
    "cl_mvhudpos": {
      "default": "bottom center",
      "desc": "Sets the position of the multiview mini-HUDs.",
      "group-id": "40",
      "remarks": "This only applies to the mini-HUD when cl_mvdisplayhud has a value greater than 1.\nOtherwise old mini-HUD will be used (just strings).",
      "type": "enum",
      "values": [
        {
          "description": "bottom, centered horizontally",
          "name": "bottom center"
        },
        {
          "description": "bottom, left hand side",
          "name": "bottom left"
        },
        {
          "description": "bottom, right hand side",
          "name": "bottom right"
        },
        {
          "description": "The mini-HUDs are all \"gathered\" towards the center of the screen. Top left view has the hud in the lower right corner; bottom left view has it in the upper left corner and so on.",
          "name": "gather"
        },
        {
          "description": "top, centered horizontally",
          "name": "top center"
        },
        {
          "description": "top, left hand side",
          "name": "top left"
        },
        {
          "description": "top, right hand side",
          "name": "top right"
        },
        {
          "description": "bottom, centered horizontally",
          "name": "bc"
        },
        {
          "description": "bottom, left hand side",
          "name": "bl"
        },
        {
          "description": "bottom, right hand side",
          "name": "br"
        },
        {
          "description": "The mini-HUDs are all \"gathered\" towards the center of the screen. Top left view has the hud in the lower right corner; bottom left view has it in the upper left corner and so on.",
          "name": "g"
        },
        {
          "description": "top, centered horizontally",
          "name": "tc"
        },
        {
          "description": "top, left hand side",
          "name": "tl"
        },
        {
          "description": "top, right hand side",
          "name": "tr"
        }
      ]
    },
    "cl_mvhudvertical": {
      "default": "0",
      "desc": "Set whetever the mini-HUDs in multiview mode will be drawn vertically or not.",
      "group-id": "40",
      "remarks": "This only applies if cl_mvdisplayhud has a value greater than 1, otherwise the old style is used for the mini-HUDs (only strings).",
      "type": "boolean",
      "values": [
        {
          "description": "Draw mini-HUDs horizontally",
          "name": "false"
        },
        {
          "description": "Draw mini-HUDs vertically",
          "name": "true"
        }
      ]
    },
    "cl_mvinset": {
      "default": "0",
      "desc": "Turns inset screen with multitrack on/off.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Divide screen in 2/3/4 areas according to cl_multiview settings.",
          "name": "false"
        },
        {
          "description": "Display 2nd POV inside main screen in the right top corner.",
          "name": "true"
        }
      ]
    },
    "cl_mvinset_offset_x": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "cl_mvinset_offset_y": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "cl_mvinset_right": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "cl_mvinset_size_x": {
      "default": "0.333",
      "group-id": "0",
      "system-generated": true
    },
    "cl_mvinset_size_y": {
      "default": "0.333",
      "group-id": "0",
      "system-generated": true
    },
    "cl_mvinset_top": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "cl_mvinsetcrosshair": {
      "default": "1",
      "desc": "Turn crosshair in inset POV in multiview on/off.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display crosshair in inset POV.",
          "name": "false"
        },
        {
          "description": "Display crosshair in inset POV.",
          "name": "true"
        }
      ]
    },
    "cl_mvinsethud": {
      "default": "1",
      "desc": "Turns inset HUD for inset POV with multiview on/off.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display inset HUD.",
          "name": "false"
        },
        {
          "description": "Display inset HUD (usually nick of tracked player).",
          "name": "true"
        }
      ]
    },
    "cl_name_as_skin": {
      "default": "0",
      "desc": "Allows you to override user skin settings and use player's name or ID as a his (her) skin.",
      "group-id": "44",
      "remarks": "There are many other skin settings that can override, e.g. all enemy*skin, team*skin settings override this setting.",
      "type": "enum",
      "values": [
        {
          "description": "Use player's skin setting",
          "name": "0"
        },
        {
          "description": "Use player's name as his skin",
          "name": "1"
        },
        {
          "description": "Use player's ID as his skin",
          "name": "2"
        }
      ]
    },
    "cl_net_clientport": {
      "default": "27001",
      "desc": "The UDP port opened by the client for communication with the server.",
      "group-id": "21",
      "remarks": "Can set to 0 to use a dynamically allocated port",
      "type": "integer"
    },
    "cl_newlerp": {
      "default": "0",
      "desc": "Experimental rockets/grenades/spikes smoothing code.\nFor example, a value of 0.1 means use 90% of our 'vision' and 10% of server 'vision'. Should be OK for most cases (see remarks).",
      "group-id": "8",
      "remarks": "Range between 0 and 1.\nThis smoothing algorithm only works well with stable ping.",
      "type": "float"
    },
    "cl_nodelta": {
      "default": "0",
      "desc": "Control the network packet delta compression.\nWhen you get blue lines in your netgraph, you should set 'cl_nodelta 1'.",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "Enable delta compression.",
          "name": "false"
        },
        {
          "description": "Disable delta compression.",
          "name": "true"
        }
      ]
    },
    "cl_nofake": {
      "default": "2",
      "desc": "This command effects name faking using $/ or cl_fakename used by players.",
      "group-id": "3",
      "type": "enum",
      "values": [
        {
          "description": "No unfaking.",
          "name": "0"
        },
        {
          "description": "Unfake all messages.",
          "name": "1"
        },
        {
          "description": "Unfake messages from enemies only.",
          "name": "2"
        }
      ]
    },
    "cl_nolerp": {
      "default": "0",
      "desc": "Allows you to disable the linear interpolation (lerp) of objects in the game.\nInformation about objects' states arrive periodically via the net connection. By default between these moments the client tries to interpolate where the objects are. After the new packet arrives client corrects the position of the object.\nIf the interpolation is disabled, client will leave object in the state described in the last received packet until a new one arrives.",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Interpolate objects",
          "name": "false"
        },
        {
          "description": "Disable interpolation",
          "name": "true"
        }
      ]
    },
    "cl_nolerp_on_entity": {
      "default": "0",
      "desc": "Disables linear interpolation only when player is standing on an entity.\nIt is a workaround to remove jittering of floating platforms under feets.",
      "group-id": "8",
      "remarks": "No effect if fps independent physics is turned off. See cl_nolerp.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_nopred": {
      "default": "0",
      "desc": "For debugging, disables movement prediction for your character; other players are still predicted.",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "Predict movement",
          "name": "false"
        },
        {
          "description": "Don't predict movement",
          "name": "true"
        }
      ]
    },
    "cl_novweps": {
      "default": "0",
      "desc": "If set, disables support for zquake vwep extension.",
      "group-id": "8",
      "type": "boolean"
    },
    "cl_onload": {
      "default": "menu",
      "desc": "Tells what will be the start-up screen of the client.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Server browser will be your start-up screen",
          "name": "browser"
        },
        {
          "description": "After start-up you can immediately type into the console",
          "name": "console"
        },
        {
          "description": "You'll see the main menu after the start-up",
          "name": "menu"
        },
        {
          "description": "A command/script to be executed on start-up",
          "name": "<other>"
        }
      ]
    },
    "cl_parseFrags": {
      "default": "1",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Enable displaying team fortress related statistics in the scoreboard (flag touches, steals, caps, etc).",
          "name": "true"
        }
      ]
    },
    "cl_parseFunChars": {
      "default": "1",
      "group-id": "3",
      "remarks": "Full list:\n$R - red lamp\n$G - green lamp\n$B - blue lamp\n$Y - yellow lamp\n$\\ - carriage return\n$( - big left bracket\n$= - big equal sign\n$) - big right bracket\n$. - red middle dot\n$, - white dot (names only)\n$< - small left bracket\n$- - small equal sign\n$> - small right bracket\n$a - big grey block\n$: - line feed\n$b - filled red block\n$d - right pointing red arrow\n$[ - gold left square bracket\n$] - gold right square bracket\n$^ - white ^ (names only)\n^x - red x (names only)\n$0-9 - yellow number\n$xyy - char with hex code yy\n(In order to use the lamps, you'll need the Ocrana pak).",
      "type": "boolean",
      "values": [
        {
          "description": "Off.",
          "name": "false"
        },
        {
          "description": "You can use Ocrana LED's by hand right out of the console and chat anonymously through \"$\\\" without showing your name (chat messages that are seen without your name at the beginning).",
          "name": "true"
        }
      ]
    },
    "cl_parseSay": {
      "default": "1",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "Disable %-macros (%a %h %b etc...)",
          "name": "false"
        },
        {
          "description": "You can use macros such as %a %h %l (like in Qizmo).",
          "name": "true"
        }
      ]
    },
    "cl_parseWhiteText": {
      "default": "1",
      "desc": "Convert text between { and } to white or not in chat/team chat.",
      "group-id": "3",
      "type": "enum",
      "values": [
        {
          "description": "Convert none.",
          "name": "0"
        },
        {
          "description": "Convert all (chat and team chat).",
          "name": "1"
        },
        {
          "description": "Convert team chat only.",
          "name": "2"
        }
      ]
    },
    "cl_pext": {
      "default": "1",
      "desc": "If set, enable support for FTE's protocol extensions.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_pext_256packetentities": {
      "default": "1",
      "desc": "Allow protocol extension for allowing more packet entities.",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_pext_alpha": {
      "default": "1",
      "desc": "If set, enable support for FTE's alpha attribute protocol extension.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_pext_chunkeddownloads": {
      "default": "1",
      "desc": "Enables protocol extension called \"Chunked downloads\". Allows you to download maps and demos from servers faster.",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_pext_colourmod": {
      "default": "1",
      "desc": "If set, enable support for FTE's colour attribute extension.\n Allows the server to color models, etc.'",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_pext_floatcoords": {
      "default": "1",
      "desc": "If set, enable support for FTE's floating point coordinate protocol extension.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_pext_lagteleport": {
      "default": "0",
      "desc": "Enable support for MVDSV to correct movement commands when travelling through teleports.\nSee https://www.quakeworld.nu/forum/topic/7239 for more details.",
      "group-id": "21",
      "remarks": "You must reconnect to the server for changes to take effect.",
      "type": "boolean",
      "values": [
        {
          "description": "No adjustment made server-side",
          "name": "false"
        },
        {
          "description": "Server will adjust movement in the delay between entering & exiting teleports",
          "name": "true"
        }
      ]
    },
    "cl_pext_limits": {
      "default": "1",
      "desc": "Enable support for FTE's extensions to support enhanced number of entities and models.",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "FTE extensions disabled.  Some enemies/projectiles may be invisible.",
          "name": "false"
        },
        {
          "description": "FTE extensions enabled.",
          "name": "true"
        }
      ]
    },
    "cl_pext_other": {
      "default": "0",
      "desc": "Allows other protocol extensions other than Chunked downloads.",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_pext_serversideweapon": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "cl_pext_warndemos": {
      "default": "1",
      "desc": "If set, warning will be displayed when recording a demo that is not backwards compatible with old clients.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_physfps": {
      "default": "0",
      "desc": "Sets the amount of FPS used to communicate with the server.\nThis variable is used when cl_independentphysics 1 is set, and controls the FPS sent/received to/from the server.\nThe graphical FPS is limited by cl_maxfps (vid_vsync must be 0).\n\nWhen set to 0, the current cl_maxfps value is used.\nWhen cl_maxfps is set to 0 too, client displays as much FPS as server and data rate allows.",
      "group-id": "8",
      "type": "float"
    },
    "cl_physfps_spectator": {
      "default": "77",
      "desc": "Amount of updates the client will send/receive while being spectator.\nLower values make the client smooth-out the field of view movement greatly.",
      "group-id": "8",
      "remarks": "This can increase your ping (only) when you are a spectator.",
      "type": "integer"
    },
    "cl_pitchspeed": {
      "default": "150",
      "desc": "This variable determines how fast you you turn up/down when using \"+lookup\" and \"+lookdown\".",
      "group-id": "9",
      "type": "float"
    },
    "cl_portpingprobe_delay": {
      "default": "0",
      "desc": "Specifies the number of milliseconds to sleep between each probe. Defaults to no delay",
      "group-id": "21",
      "type": "integer"
    },
    "cl_portpingprobe_enable": {
      "default": "0",
      "desc": "Toggle whether a port ping probe should be performed when connecting to a server.",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "Do not perform a port ping probe before connecting to a server.",
          "name": "false"
        },
        {
          "description": "Perform a port ping probe before connecting to a server.",
          "name": "true"
        }
      ]
    },
    "cl_portpingprobe_port_probes": {
      "default": "1",
      "desc": "Lets you set how many times each port should be probed when connecting to a server.",
      "group-id": "21",
      "type": "integer",
      "values": [
        {
          "description": "Range 1 to 5.",
          "name": "*"
        }
      ]
    },
    "cl_portpingprobe_probes": {
      "default": "500",
      "desc": "Lets you set how many port ping probes that should be performed when connecting to a server.",
      "group-id": "21",
      "type": "integer",
      "values": [
        {
          "description": "Range 1 to 1000.",
          "name": "*"
        }
      ]
    },
    "cl_predict_half": {
      "default": "0",
      "group-id": "21",
      "remarks": "The new default eliminates player models' jittering when independent physics is enabled; a possible downside is larger prediction errors of modem players' movement, hence the option to revert to old behavior.",
      "type": "boolean",
      "values": [
        {
          "description": "Full prediction of players' movement (ezQuake default)",
          "name": "false"
        },
        {
          "description": "Predicting half the move (QW 2.30 default)",
          "name": "true"
        }
      ]
    },
    "cl_predict_players": {
      "default": "1",
      "desc": "This toggles the prediction for other players' movement. Unless you are having problems this variable should be left at \"1\".",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_proxyaddr": {
      "default": "",
      "desc": "IP address of the proxy server to use while connecting to servers.",
      "group-id": "21",
      "remarks": "This will override the /connect and /reconnect commands so that the connection is established via given proxy server.",
      "type": "string"
    },
    "cl_r2g": {
      "default": "0",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Normal rockets models.",
          "name": "false"
        },
        {
          "description": "Converts all rockets to grenades.",
          "name": "true"
        }
      ]
    },
    "cl_remote_capabilities": {
      "default": "+attack,-attack,alias,bf,changing,cmd,color,download,exec,fullserverinfo,impulse,infoset,ktx_infoset,ktx_sinfoset,nextul,on_admin,on_connect,on_connect_ctf,on_connect_ffa,on_enter,on_enter_ctf,on_enter_ffa,on_matchend,on_matchstart,on_observe,on_observe_ctf,on_observe_ffa,on_spec_enter,on_spec_enter_ctf,on_spec_enter_ffa,on_spec_matchend,on_spec_matchstart,on_unadmin,packet,play,rate,reconnect,say,sinfoset,skin,skins,team,tempalias,track,wait",
      "desc": "This variable controls which commands and variables a server is allowed to execute or set on the client. Input a comma-separated list of commands and variables to toggle access. The default values are adapted for KTX use.",
      "group-id": "9",
      "type": "string"
    },
    "cl_restrictions": {
      "default": "0",
      "desc": "Triggers and re/msg trigger restrictions for spectator and demoplay modes.",
      "group-id": "3",
      "remarks": "FuhQuake always behaves as cl_restrictions 1. QW262 has cl_restrictions 1 by default.",
      "type": "boolean",
      "values": [
        {
          "description": "Allow triggers and huds",
          "name": "false"
        },
        {
          "description": "Disallow triggers and huds",
          "name": "true"
        }
      ]
    },
    "cl_rollalpha": {
      "default": "20",
      "desc": "You can turn off the 'dodging' or 'rolling' effect for your own point of view while still see other player models affected by cl_rollangle.",
      "group-id": "53",
      "remarks": "0 disables, 1 is standard. Disabled by ruleset smackdown and smackdrive.",
      "type": "integer"
    },
    "cl_rollangle": {
      "default": "0",
      "desc": "This variable controls how much your screen tilts when strafing.",
      "group-id": "53",
      "type": "float"
    },
    "cl_rollspeed": {
      "default": "200",
      "desc": "This variable controls how quickly you and other players straighten out after strafing.",
      "group-id": "53",
      "type": "float"
    },
    "cl_safestrafe": {
      "default": "0",
      "desc": "Enables safestrafe mode in client regardless of server enforcement.",
      "group-id": "9",
      "remarks": "Safestrafe is a serverside SOCD fairness feature that requires one or more stop frames between direction changes.",
      "type": "integer",
      "values": [
        {
          "description": "Disabled",
          "name": "0 "
        },
        {
          "description": "Enabled (requires one stop frame between direction changes)",
          "name": "1 "
        },
        {
          "description": "Sets the number of required stop frames between direction changes.",
          "name": "2+"
        }
      ]
    },
    "cl_savehistory": {
      "default": "1",
      "desc": "Save console commands history to .ezquake_history. Loads history from this file while starting ezquake.",
      "group-id": "5",
      "type": "boolean",
      "values": [
        {
          "description": "don't save",
          "name": "false"
        },
        {
          "description": "save",
          "name": "true"
        }
      ]
    },
    "cl_sayfilter_coloredtext": {
      "default": "0",
      "desc": "Allows you to filter your own outgoing messages out of markup that is used in this client to send colored text.",
      "group-id": "49",
      "remarks": "Colored text is not supported by some other clients. See cl_sayfilter_sendboth for compatibility mode with other clients.\nIf you want to filter incoming messages out of colors, use scr_coloredtext.",
      "type": "enum",
      "values": [
        {
          "description": "Send messages as they are",
          "name": "0"
        },
        {
          "description": "Filter out colored markup",
          "name": "1"
        },
        {
          "description": "Filter out colored and white text markup",
          "name": "2"
        }
      ]
    },
    "cl_sayfilter_sendboth": {
      "default": "0",
      "desc": "When used with cl_sayfilter_coloredtext, sends two versions of the teamplay colored messages: colored one with \"#c\" at the end and uncolored version of the message with \"#u\" at the end of the message.",
      "group-id": "49",
      "remarks": "FuhQuake users then can use \"filter #u\" to see only uncolored messages, ezQuake users can set \"filter #c\" to see only colored messages.",
      "type": "boolean",
      "values": [
        {
          "description": "Send only one version of the message",
          "name": "false"
        },
        {
          "description": "Send two versions of the message",
          "name": "true"
        }
      ]
    },
    "cl_sbar": {
      "default": "0",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Use the new transparent HUD.",
          "name": "false"
        },
        {
          "description": "Use the old status bar.",
          "name": "true"
        }
      ]
    },
    "cl_shownet": {
      "default": "0",
      "desc": "This variable toggles the display of current net info.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Do not display any information.",
          "name": "0"
        },
        {
          "description": "Print current incoming packet size in byte.",
          "name": "1"
        },
        {
          "description": "Print information about the current in coming packet and it's size.",
          "name": "2"
        }
      ]
    },
    "cl_sidespeed": {
      "default": "400",
      "desc": "This allows you to set your strafe speed.\nObviously this is also limited by the server, usually to \"320\".",
      "group-id": "9",
      "remarks": "Sign of the value is ignored.",
      "type": "float"
    },
    "cl_smartjump": {
      "default": "1",
      "desc": "Will convert +jump commands to +moveup commands when in liquid (water, lava, slime) and in spectator mode.",
      "group-id": "9",
      "type": "boolean"
    },
    "cl_solid_players": {
      "default": "1",
      "desc": "If not set then client will not perform collision detection against other players.",
      "group-id": "21",
      "type": "boolean"
    },
    "cl_startupdemo": {
      "default": "",
      "desc": "Demo that should be played on client's startup.",
      "group-id": "7",
      "type": "string",
      "values": [
        {
          "description": "File name of the demo.",
          "name": "*"
        }
      ]
    },
    "cl_staticSounds": {
      "default": "1",
      "group-id": "45",
      "type": "boolean",
      "values": [
        {
          "description": "Disable static sounds.",
          "name": "false"
        },
        {
          "description": "Enable static sounds.",
          "name": "true"
        }
      ]
    },
    "cl_sv_packetsync": {
      "default": "1",
      "desc": "Determines if internal server should process packets as soon as received from client.",
      "group-id": "43",
      "remarks": "Should only affect playing on local server, when cl_delay_packet is enabled.\nRecommend to disable for older mods which fake players (frogbots) and leave enabled for KTX.",
      "type": "boolean"
    },
    "cl_textencoding": {
      "default": "0",
      "desc": "Determines method used to encoding non-standard characters in outgoing messages.",
      "group-id": "48",
      "type": "enum",
      "values": [
        {
          "description": "Use KOI8-R encoding (ezQuake 2.2 compatible)",
          "name": "0"
        },
        {
          "description": "Use UTF8 encoding (larger range of characters)",
          "name": "1"
        },
        {
          "description": "Use FTE's ^Uxxxx encoding",
          "name": "2"
        }
      ]
    },
    "cl_timeout": {
      "default": "60",
      "desc": "This variable defines the timeout value in seconds until the client considers himself to be disconnected from the server.",
      "group-id": "21",
      "type": "float"
    },
    "cl_upspeed": {
      "default": "400",
      "desc": "This allows you to set the speed with which you move up and down in liquids or in spectator mode.\nObviously this is also limited by the server, usually to 320*0.7 = 224 when being in liquid and to 500 in spectator mode.",
      "group-id": "9",
      "remarks": "Sign of the value is ignored.",
      "type": "float"
    },
    "cl_useimagesinfraglog": {
      "default": "0",
      "desc": "Turns on using images in the frags tracker window to show which weapon did take the role in the frag.",
      "group-id": "47",
      "remarks": "See Tracer Stats manual page for further info.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_useproxy": {
      "default": "0",
      "desc": "This toggles whether Qizmo should be used (if detected) to a server. When enabled the server browser will use an existing connection to a Qizmo when connecting another server by using the ezQuake Server Browser.",
      "group-id": "21",
      "type": "boolean",
      "values": [
        {
          "description": "do not use Qizmo to connect a server chosen in the Server Browser",
          "name": "false"
        },
        {
          "description": "use Qizmo to connect a server chosen in the Server Browser",
          "name": "true"
        }
      ]
    },
    "cl_username": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "cl_verify_qwprotocol": {
      "default": "1",
      "desc": "Enables the check on client startup for handling URLs starting with qw://",
      "group-id": "40",
      "remarks": "When enabled and the client is not associated with handling of qw:// URLs, user will be prompted if he wishes to associate the client with the protocol.",
      "type": "enum",
      "values": [
        {
          "description": "Do not check if client is associated with qw:// URLs",
          "name": "0"
        },
        {
          "description": "Check if client is associated, prompt if not",
          "name": "1"
        },
        {
          "description": "Always associate client with qw:// URLs",
          "name": "2"
        }
      ]
    },
    "cl_voip_capturingvol": {
      "default": "0.5",
      "group-id": "0",
      "system-generated": true
    },
    "cl_voip_capturingvol ": {
      "desc": "Volume multiplier applied while capturing, to avoid your audio from being heard by others.",
      "group-id": "32",
      "type": "integer"
    },
    "cl_voip_demorecord": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "cl_voip_micamp": {
      "default": "2",
      "desc": "Amplifies your microphone when using voip.",
      "group-id": "32",
      "type": "integer"
    },
    "cl_voip_play": {
      "default": "1",
      "desc": "Enables voip (voice chat) playback.",
      "group-id": "32",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "cl_voip_send": {
      "default": "0",
      "desc": "Enable sending of voice (voip) to the server.",
      "group-id": "32",
      "remarks": "Commands +void / -void emulate toggling this value to 2.",
      "type": "enum",
      "values": [
        {
          "description": "disabled",
          "name": "0"
        },
        {
          "description": "voice-activated",
          "name": "1"
        },
        {
          "description": "always activated",
          "name": "2"
        }
      ]
    },
    "cl_voip_showmeter": {
      "default": "1",
      "desc": "Shows your speech volume above the at the bottom-left of the screen.",
      "group-id": "32",
      "type": "enum",
      "values": [
        {
          "description": "Hide",
          "name": "0"
        },
        {
          "description": "Show when transmitting",
          "name": "1"
        },
        {
          "description": "Always show (ignore voice-activation)",
          "name": "2"
        }
      ]
    },
    "cl_voip_showmeter_x": {
      "default": "0",
      "desc": "Adjust horizontal position of the voice volume meter.",
      "group-id": "32",
      "remarks": "See cl_voip_showmeter.",
      "type": "integer"
    },
    "cl_voip_showmeter_y": {
      "default": "0",
      "desc": "Adjust vertical position of the voice volume meter.",
      "group-id": "32",
      "remarks": "See cl_voip_showmeter.",
      "type": "integer"
    },
    "cl_voip_vad_delay": {
      "default": "0.3",
      "desc": "Keeps sending voice data for this many seconds after voice activation would normally stop.",
      "group-id": "32",
      "type": "float"
    },
    "cl_voip_vad_threshhold": {
      "default": "15",
      "desc": "This is the threshhold for voice-activation-detection when sending voip data.",
      "group-id": "32",
      "type": "float"
    },
    "cl_warncmd": {
      "default": "1",
      "group-id": "2",
      "remarks": "Note: Not saved to config with cfg_save command.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable the unknown command messages.",
          "name": "false"
        },
        {
          "description": "Enable the unknown command messages.",
          "name": "true"
        }
      ]
    },
    "cl_warnexec": {
      "default": "1",
      "desc": "If set, the names of script files will be printed to console as they are executed.",
      "group-id": "5",
      "type": "boolean"
    },
    "cl_weaponforgetondeath": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "cl_weaponforgetorder": {
      "default": "0",
      "group-id": "9",
      "type": "boolean",
      "values": [
        {
          "description": "weapon/impulse command sets best weapon order, will select best weapon as ammo or weapon obtained",
          "name": "0"
        },
        {
          "description": "weapon/impulse command picks best weapon at the time of command, with fallback to axe or sg (see /cl_weaponhide_axe)",
          "name": "1"
        }
      ]
    },
    "cl_weaponhide": {
      "default": "0",
      "desc": "On -attack will cause your weapon to be automatically switched back to the shotgun or axe.",
      "group-id": "9",
      "remarks": "This is used in majority of teamplay games. If you don't have ammo for shotgun the axe gets selected.",
      "type": "enum",
      "values": [
        {
          "description": "Weapon will not be automatically hidden",
          "name": "0"
        },
        {
          "description": "After you fire your weapon, it will get switched to shotgun or axe",
          "name": "1"
        },
        {
          "description": "Like option 1, but only for deathmatch mode 1.",
          "name": "2"
        }
      ]
    },
    "cl_weaponhide_axe": {
      "default": "0",
      "desc": "Determines if axe should be used as \"dummy\" weapon when using automated weapon hiding (cl_weaponhide).",
      "group-id": "9",
      "remarks": "See cl_weaponhide and cl_weaponpreselect.",
      "type": "boolean",
      "values": [
        {
          "description": "Use shotgun as dummy weapon",
          "name": "false"
        },
        {
          "description": "Use axe as dummy weapon",
          "name": "true"
        }
      ]
    },
    "cl_weaponpreselect": {
      "default": "0",
      "desc": "When using the weapon command, this variable allows weapon preselection instead of standard immediate weapon selection.\nPreselection means that the preselected weapon will be switch right before +attack command, that is right before you shoot from your weapon.",
      "group-id": "9",
      "remarks": "Usefull in most teamplay games where you don't want to carry your best weapon in your hands but want to be ready to instantly shoot from it.\nNote: Doesn't work for impulse command, you have to use new weapon command.",
      "type": "enum",
      "values": [
        {
          "description": "Immediate weapon selection",
          "name": "0"
        },
        {
          "description": "Weapon preselection",
          "name": "1"
        },
        {
          "description": "Weapon preselection when not holding +attack. When holding +attack, select weapon immediately.",
          "name": "2"
        },
        {
          "description": "Like option 1, but only for deathmatch mode 1, otherwise like 0.",
          "name": "3"
        },
        {
          "description": "Like option 2, but only for deathmatch mode 1, otherwise like 0.",
          "name": "4"
        }
      ]
    },
    "cl_window_caption": {
      "default": "1",
      "desc": "Choose different window caption formats for your taskbar when you play in windowed mode or when the client is minimized in the taskbar.",
      "group-id": "40",
      "remarks": "The caption doesn't refresh regularly on some configurations. We recommend to use vid_flashonactivity 1 as well.",
      "type": "enum",
      "values": [
        {
          "description": "Format: ezQuake: address",
          "name": "0"
        },
        {
          "description": "Format: <server state> - pl: <number of players> - <map>",
          "name": "1"
        },
        {
          "description": "Fixed: ezQuake",
          "name": "2"
        },
        {
          "description": "Format: ezQuake <version> or <number of players>/<max players> <delim> <map>",
          "name": "3"
        }
      ]
    },
    "cl_window_caption_delimiter": {
      "default": " | ",
      "desc": "Delimiter between <number of players>/<max players> and <map> when using cl_window_caption 3.",
      "group-id": "40",
      "type": "string"
    },
    "cl_www_address": {
      "default": "https://badplace.eu/",
      "group-id": "0",
      "system-generated": true
    },
    "cl_yawspeed": {
      "default": "140",
      "desc": "This variable defines how quickly you turn left (+left) or right (+right).",
      "group-id": "9",
      "type": "float"
    },
    "con_bindphysical": {
      "default": "0",
      "desc": "Affects behaviour of bind command.",
      "group-id": "5",
      "remarks": "con_bindphysical will always be set to 1 at start of executing a script, and be reset after.",
      "type": "boolean",
      "values": [
        {
          "description": "'bind x y' will bind y to the key used to produce character x at the console (layout-aware)",
          "name": "0"
        },
        {
          "description": "'bind x y' will bind y to physical key x, as if using an American keyboard layout (layout independent)",
          "name": "1"
        }
      ]
    },
    "con_clearnotify": {
      "default": "1",
      "group-id": "5",
      "type": "boolean",
      "values": [
        {
          "description": "Messages stay even when you toggle console.",
          "name": "false"
        },
        {
          "description": "Messages won't say when you toggle console.",
          "name": "true"
        }
      ]
    },
    "con_completion_changed_mark": {
      "default": "1",
      "desc": "Whether add or not asterisk before variables which values were changed.",
      "group-id": "5",
      "remarks": "Works only with con_completion_format > 0.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "con_completion_color_changed_mark": {
      "default": "f30",
      "desc": "Color of changed mark used in modern completion formatting.",
      "group-id": "5",
      "remarks": "Example: 39f",
      "type": "string",
      "values": [
        {
          "description": "Use following color format: RGB",
          "name": "*"
        }
      ]
    },
    "con_completion_color_colon": {
      "default": "fff",
      "desc": "Color of colon used in modern completion formatting.",
      "group-id": "5",
      "remarks": "Example: 39f",
      "type": "string",
      "values": [
        {
          "description": "Use following color format: RGB",
          "name": "*"
        }
      ]
    },
    "con_completion_color_name": {
      "default": "8ff",
      "desc": "Color of variable name in used in modern completion formatting.",
      "group-id": "5",
      "remarks": "Example: 39f",
      "type": "string",
      "values": [
        {
          "description": "Use following color format: RGB",
          "name": "*"
        }
      ]
    },
    "con_completion_color_quotes_current": {
      "default": "ff8",
      "desc": "Color of quotes of current variable value used in modern completion formatting.",
      "group-id": "5",
      "remarks": "Example: 39f",
      "type": "string",
      "values": [
        {
          "description": "Use following color format: RGB",
          "name": "*"
        }
      ]
    },
    "con_completion_color_quotes_default": {
      "default": "ff8",
      "desc": "Color of quotes of default variable value used in modern completion formatting.",
      "group-id": "5",
      "remarks": "Example: 39f",
      "type": "string",
      "values": [
        {
          "description": "Use following color format: RGB",
          "name": "*"
        }
      ]
    },
    "con_completion_color_title": {
      "default": "ff3",
      "desc": "Color of completion type title (variables, aliases or commands) used in modern completion formatting.",
      "group-id": "5",
      "remarks": "Example: 39f",
      "type": "string",
      "values": [
        {
          "description": "Use following color format: RGB",
          "name": "*"
        }
      ]
    },
    "con_completion_color_value_current": {
      "default": "fff",
      "desc": "Color of current variable value used in modern completion formatting.",
      "group-id": "5",
      "remarks": "Example: 39f",
      "type": "string",
      "values": [
        {
          "description": "Use following color format: RGB",
          "name": "*"
        }
      ]
    },
    "con_completion_color_value_default": {
      "default": "fff",
      "desc": "Color of default variable value used in modern completion formatting.",
      "group-id": "5",
      "remarks": "Example: 39f",
      "type": "string",
      "values": [
        {
          "description": "Use following color format: RGB",
          "name": "*"
        }
      ]
    },
    "con_completion_format": {
      "default": "2",
      "desc": "Console completion variants format.",
      "group-id": "5",
      "remarks": " - Modern: plain list with colorization.\n - Old: somehow grouped list without colorization.",
      "type": "enum",
      "values": [
        {
          "description": "Old completion format",
          "name": "0"
        },
        {
          "description": "Modern one, shows current and default values",
          "name": "1"
        },
        {
          "description": "Modern one, shows current values only",
          "name": "2"
        },
        {
          "description": "Modern one, shows default values only",
          "name": "3"
        },
        {
          "description": "Modern one, shows current and default values if it differs",
          "name": "4"
        },
        {
          "description": "Modern one, without any values of cvars",
          "name": "5"
        }
      ]
    },
    "con_completion_padding": {
      "default": "2",
      "desc": "Number of spaces to pad command completion variants.",
      "group-id": "5",
      "remarks": "con_completion_format must be > 1.",
      "type": "integer"
    },
    "con_deadkey": {
      "default": "1",
      "desc": "Set this if the console toggle button is also a deadkey. The operating system will be sent a backspace character as the console is toggled.",
      "group-id": "5",
      "remarks": "Windows only.",
      "type": "boolean"
    },
    "con_fragmessages": {
      "default": "1",
      "desc": "Controls whether frag messages should be printed into console and notification area.",
      "group-id": "47",
      "remarks": "Requires cl_loadfragfiles and cl_parsefrags variables to be set to 1.",
      "type": "enum",
      "values": [
        {
          "description": "Do not print frag messages",
          "name": "0"
        },
        {
          "description": "Print frag messages to console and notification area (QW default).",
          "name": "1"
        },
        {
          "description": "Print frag messages to console only",
          "name": "2"
        }
      ]
    },
    "con_funchars_mode": {
      "default": "0",
      "desc": "Orange text, LEDs and special chars with [Ctrl] key - kind of MQWCL behaviour when set to 1.",
      "group-id": "5",
      "type": "boolean",
      "values": [
        {
          "description": "FuhQuake behaviour: [Ctrl] + key for yellow numbers and LEDs",
          "name": "false"
        },
        {
          "description": "MQWCL behaviour: [Ctrl] + [Y] turns on yellow number input",
          "name": "true"
        }
      ]
    },
    "con_hide_chat_input": {
      "default": "1",
      "desc": "Hides the input of own chat text in the console.",
      "group-id": "5",
      "remarks": "cl_chatmode must be 1 or 2.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "con_highlight": {
      "default": "0",
      "desc": "Console highlighting mode. Will highlight a line in the console which contains your nickname.",
      "group-id": "5",
      "remarks": "See con_highlight_mark.",
      "type": "enum",
      "values": [
        {
          "description": "No highlighting",
          "name": "0"
        },
        {
          "description": "Highlighted line will be all white.",
          "name": "1"
        },
        {
          "description": "Highlighted line will start with the text given in con_highlight_mark",
          "name": "2"
        },
        {
          "description": "Both 1 and 2: highlighted line will be white and start with special text",
          "name": "3"
        }
      ]
    },
    "con_highlight_mark": {
      "default": "",
      "desc": "Specifies the text that will be used to highlight lines with con_highlight 2 and 3.",
      "group-id": "5",
      "type": "string",
      "values": [
        {
          "description": "This text will be used on the beginning of the highlighted line",
          "name": "*"
        }
      ]
    },
    "con_margin_left": {
      "default": "0",
      "desc": "If set, messages are padded on the left by the number of spaces defined in the variable",
      "group-id": "47",
      "type": "integer"
    },
    "con_mm2_only": {
      "default": "0",
      "desc": "If set, notification area is limited to mm2 (/say_team) messages.",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "All messages",
          "name": "false"
        },
        {
          "description": "MM2 messages only",
          "name": "true"
        }
      ]
    },
    "con_notify": {
      "default": "1",
      "desc": "Toggles the display of the notification area.",
      "group-id": "5",
      "remarks": "Notification area is the place where chat and game messages are displayed.",
      "type": "boolean",
      "values": [
        {
          "description": "hide notification area",
          "name": "false"
        },
        {
          "description": "show notification area",
          "name": "true"
        }
      ]
    },
    "con_notifylines": {
      "default": "4",
      "desc": "This variable sets the maximum number of notify lines (default 4, max 15) to be used at the top of the screen.",
      "group-id": "5",
      "remarks": "Only affects con_notify.",
      "type": "integer"
    },
    "con_notifytime": {
      "default": "3",
      "desc": "How long console messages stay on screen.",
      "group-id": "5",
      "type": "float"
    },
    "con_prompt_charcode": {
      "default": "93",
      "desc": "ASCII code of prompt character.",
      "group-id": "5",
      "type": "integer",
      "values": [
        {
          "description": "Range 32 to 255.",
          "name": "false"
        }
      ]
    },
    "con_proportional": {
      "default": "0",
      "desc": "Enable TrueType fonts on console text.",
      "group-id": "5",
      "type": "boolean"
    },
    "con_shift": {
      "default": "-10",
      "desc": "Adjusts vertical offset of background of the console.",
      "group-id": "5",
      "type": "float"
    },
    "con_tilde_mode": {
      "default": "0",
      "desc": "When enabled, allows you to use the tilde key also in the console and when typing messages.",
      "group-id": "5",
      "remarks": "To exit the console with con_tilde_mode 1, use Escape.",
      "type": "enum",
      "values": [
        {
          "description": "Always use tilde to toggle the console",
          "name": "0"
        },
        {
          "description": "Treat tilde as a key leading to typing the character associated with it (tilde does not close the console)",
          "name": "1"
        },
        {
          "description": "Same as 1, but tilde does close the console if the console is empty",
          "name": "2"
        }
      ]
    },
    "con_timestamps": {
      "default": "0",
      "desc": "Toggles time stamps before mm1 or spectator messages. Does not apply to messages with cl_fakename.",
      "group-id": "5",
      "type": "enum",
      "values": [
        {
          "description": "Do not display timestamps.",
          "name": "0"
        },
        {
          "description": "Display [HH:mm]",
          "name": "1"
        },
        {
          "description": "Display [HH:mm:ss]",
          "name": "2"
        }
      ]
    },
    "con_wordwrap": {
      "default": "1",
      "group-id": "5",
      "type": "boolean",
      "values": [
        {
          "description": "Disable word wrapping.",
          "name": "false"
        },
        {
          "description": "Enable word wrapping.",
          "name": "true"
        }
      ]
    },
    "coop": {
      "default": "0",
      "desc": "Whether the next \"map\" command should start a coop (cooperative) game.\nOnly works when deathmatch var is 0, otherwise coop will be forced off and a deathmatch game will start.\n\nYou need a file, spprogs.dat, in your quake/qw/ folder for coop games to work.",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable cooperative.",
          "name": "false"
        },
        {
          "description": "Enable cooperative.",
          "name": "true"
        }
      ]
    },
    "crosshair": {
      "default": "4",
      "group-id": "6",
      "type": "enum",
      "values": [
        {
          "description": "Crosshair off.",
          "name": "0"
        },
        {
          "description": "Conchar crosshair (messagemode1 +).",
          "name": "1"
        },
        {
          "description": "Quakeworld crosshair.",
          "name": "2"
        },
        {
          "description": "A small cross crosshair.",
          "name": "3"
        },
        {
          "description": "A dot crosshair.",
          "name": "4"
        },
        {
          "description": "Star wars crosshair.",
          "name": "5"
        },
        {
          "description": "F22 simulator crosshair.",
          "name": "6"
        },
        {
          "description": "(same as 6)",
          "name": "7"
        }
      ]
    },
    "crosshairalpha": {
      "default": "1",
      "desc": "This command regulates crosshair transparency, you can use any value from \"0\" to \"1\".",
      "group-id": "6",
      "type": "boolean",
      "values": [
        {
          "description": "Transparent crosshair.",
          "name": "false"
        },
        {
          "description": "Opaque crosshair.",
          "name": "true"
        }
      ]
    },
    "crosshaircolor": {
      "default": "255 0 0",
      "desc": "This variable defines the color of the crosshair.",
      "group-id": "6",
      "type": "string"
    },
    "crosshairimage": {
      "default": "",
      "desc": "The filename of the crosshair image.",
      "group-id": "6",
      "remarks": "Crosshair images should be placed in ./ezquake/crosshairs or ./qw/crosshairs directory.",
      "type": "string"
    },
    "crosshairscale": {
      "default": "0",
      "desc": "When using built-in crosshairs, increases the resolution of the crosshair, giving a crisper image on screen.",
      "group-id": "6",
      "remarks": "Max value 5. Increasing this value will require lowering of /crosshairsize to give same size image on screen.",
      "type": "enum",
      "values": [
        {
          "description": "8x8",
          "name": "0"
        },
        {
          "description": "16x16",
          "name": "1"
        },
        {
          "description": "32x32",
          "name": "2"
        },
        {
          "description": "64x64",
          "name": "3"
        },
        {
          "description": "128x128",
          "name": "4"
        },
        {
          "description": "256x256",
          "name": "5"
        }
      ]
    },
    "crosshairscalemethod": {
      "default": "0",
      "desc": "Determines how crosshair images are scaled.",
      "group-id": "6",
      "remarks": "When changing this value, /crosshairscale & /crosshairsize should be adjusted accordingly.",
      "type": "boolean",
      "value": [
        {
          "description": "Quake standard scaling: resolution width / 320",
          "name": "0"
        },
        {
          "description": "No scaling, sizes are in pixels",
          "name": "1"
        }
      ]
    },
    "crosshairsize": {
      "default": "1",
      "desc": "Performs basic scaling of the crosshair.",
      "group-id": "6",
      "remarks": "Maximum value 20. For example, /crosshairsize 0.5 halves the size, and /crosshair 2 doubles it.",
      "type": "float"
    },
    "cvar_viewdefault": {
      "default": "1",
      "desc": "When you type a cvar name into console (like 'gl_gamma' or 'r_rocketlight'), the client will tell you the default value of the cvar.",
      "group-id": "5",
      "type": "boolean"
    },
    "cvar_viewhelp": {
      "default": "1",
      "desc": "Automatically prints manual page when a variable name is typed in the console.",
      "group-id": "5",
      "type": "boolean",
      "values": [
        {
          "description": "Do not print help",
          "name": "false"
        },
        {
          "description": "Print help automatically",
          "name": "true"
        }
      ]
    },
    "cvar_viewlatched": {
      "default": "1",
      "desc": "When you type a variable name in the console, you'll be able to see it's latched value if this is turned on.",
      "group-id": "5",
      "remarks": "Latched values are used for example for renderer settings. Variable value is latched until the renderer is restarted, in that moment the latched value becomes the actuall value of the variable.",
      "type": "boolean",
      "values": [
        {
          "description": "Don't display latched value",
          "name": "false"
        },
        {
          "description": "Display latched value (if any)",
          "name": "true"
        }
      ]
    },
    "d_mipcap": {
      "group-id": "30",
      "type": "enum",
      "values": [
        {
          "description": "High texture detail.",
          "name": "0"
        },
        {
          "description": "Medium texture detail.",
          "name": "1"
        },
        {
          "description": "Low texture detail.",
          "name": "2"
        },
        {
          "description": "Minimum texture detail.",
          "name": "3"
        }
      ]
    },
    "d_mipscale": {
      "group-id": "30",
      "type": "enum",
      "values": [
        {
          "description": "Full object detail",
          "name": "0"
        },
        {
          "description": "Some object detail",
          "name": "1"
        },
        {
          "description": "Medium object detail",
          "name": "2"
        },
        {
          "description": "Low object detail",
          "name": "3"
        }
      ]
    },
    "d_subdiv16": {
      "group-id": "30",
      "type": "boolean",
      "values": [
        {
          "description": "Precise texture mapping (slower, more accurate).",
          "name": "false"
        },
        {
          "description": "Perspective correction only every 16 pixels (faster, less accurate).",
          "name": "true"
        }
      ]
    },
    "deathmatch": {
      "default": "3",
      "desc": "Chooses between basic multiplayer gameplay modes.",
      "group-id": "43",
      "type": "integer",
      "values": [
        {
          "description": "Weapons disappear after pickup (used in 4on4)",
          "name": "1"
        },
        {
          "description": "Weapons stay after pickup, ammo/armor does not (not used)",
          "name": "2"
        },
        {
          "description": "Weapons stay after pickup (used in 1on1)",
          "name": "3"
        },
        {
          "description": "Arena mode: players have all weapons and full health/armor",
          "name": "4"
        }
      ]
    },
    "default_fov": {
      "default": "90",
      "desc": "Very useful in TeamFortress, and other mods that reset your fov when you spawn to 90.\nBasically, when the server sends you \"fov 90\", your fov is set to default_fov.",
      "group-id": "53",
      "remarks": "-",
      "type": "float"
    },
    "demo_autotrack": {
      "default": "0",
      "desc": "Enables server-side autotrack to be accepted.",
      "group-id": "7",
      "remarks": "Server-side autotrack is recorded in MVD demos and in QTV stream allowing all the observers of the match observe the same player at the same time.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "demo_benchmarkdumps": {
      "default": "1",
      "desc": "Allows you to automatically dump timedemo benchmark results into $log_dir/timedemo.log file.\nThe output is in XML markup format and contains info about your operating system, hardware configuration, client version, rendering, screen resolution and the result FPS.",
      "group-id": "7",
      "remarks": "See timedemo command description for more info.\nNote: The result file is not a well-formed XML file.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable timedemo result dumping",
          "name": "false"
        },
        {
          "description": "Dump results of timedemo benchmark",
          "name": "true"
        }
      ]
    },
    "demo_browser_democolor": {
      "desc": "Color of the demo entries in the demo browser.",
      "group-id": "25",
      "type": "string"
    },
    "demo_browser_dircolor": {
      "desc": "Color of the dir entries in the demo browser.",
      "group-id": "25",
      "type": "string"
    },
    "demo_browser_interline": {
      "desc": "Size of the space between entries in the demo browser.",
      "group-id": "25",
      "type": "integer"
    },
    "demo_browser_scrollnames": {
      "desc": "Toggle scrolling of the filenames in the demo browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "demo_browser_selectedcolor": {
      "desc": "Color of the selected entries in the demo browser.",
      "group-id": "25",
      "type": "string"
    },
    "demo_browser_showdate": {
      "desc": "Toggle the date column in the demo browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "demo_browser_showsize": {
      "desc": "Toggle the file size column in the demo browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "demo_browser_showstatus": {
      "desc": "Toggle the display of the status bar in the demo browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "demo_browser_showtime": {
      "desc": "Toggle the time column in the demo browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "demo_browser_sortmode": {
      "desc": "Sorting mode in the demo browser. Each number represents one column. Their order represents the priority of the sorting.",
      "group-id": "25",
      "type": "string"
    },
    "demo_browser_stripnames": {
      "desc": "Toggle stripping of the filenames in the demo browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "demo_browser_zipcolor": {
      "desc": "Color of the zip entries in the demo browser.",
      "group-id": "25",
      "type": "string"
    },
    "demo_capture_background_threads": {
      "default": "0",
      "desc": "Determines how many background threads should be used writing images to disk.",
      "group-id": "7",
      "type": "integer"
    },
    "demo_capture_codec": {
      "default": "0",
      "desc": "Determines what codes should be used for captured video stream compression. E.g: xvid, divx, x264, ...",
      "group-id": "7",
      "type": "float"
    },
    "demo_capture_dir": {
      "default": "capture",
      "desc": "Change the default capture directory.",
      "group-id": "7",
      "type": "string"
    },
    "demo_capture_fps": {
      "default": "30.0",
      "desc": "Change the default capture fps.",
      "group-id": "7",
      "type": "float"
    },
    "demo_capture_mp3": {
      "default": "0",
      "desc": "When set to 1 .avi capturing captures sound compressed in MP3 format.",
      "group-id": "7",
      "remarks": "See demo_capture_mp3_kbps too.",
      "type": "boolean",
      "values": [
        {
          "description": "Captures uncompressed sound",
          "name": "false"
        },
        {
          "description": "Captures sound in MP3 format",
          "name": "true"
        }
      ]
    },
    "demo_capture_mp3_kbps": {
      "default": "128",
      "desc": "Sets bitrate for captured sound stream when demo_capture_mp3 is set to 1.",
      "group-id": "7",
      "type": "float"
    },
    "demo_capture_quiet": {
      "desc": "Stops sound being played during demo capture.",
      "group-id": "7",
      "type": "boolean"
    },
    "demo_capture_steadycam": {
      "default": "0",
      "desc": "Changes behaviour of keyboard/mouse input when capturing.",
      "group-id": "7",
      "type": "float"
    },
    "demo_capture_vid_maxlen": {
      "default": "0",
      "desc": "If set, multiple files will be created. This variable determines length of each file in MB.",
      "group-id": "7",
      "remarks": "The .avi format has issues with files over 2GB in size.",
      "type": "integer"
    },
    "demo_dir": {
      "default": "",
      "desc": "Change the demos and autorecord directory.",
      "group-id": "7",
      "type": "string"
    },
    "demo_format": {
      "default": "qwz",
      "desc": "Specifies the demo file format used when recording demo with Match tools.",
      "group-id": "7",
      "remarks": "See qwdtools_dir, qizmo_dir, match_auto_record.",
      "type": "enum",
      "values": [
        {
          "description": "MultiView Demo, usually contains less frames per second.",
          "name": "mvd"
        },
        {
          "description": "Original QuakeWorld demo format.",
          "name": "qwd"
        },
        {
          "description": "Qizmo compressed demo.",
          "name": "qwz"
        }
      ]
    },
    "demo_getpings": {
      "default": "1",
      "desc": "This toggles whether the client should always record pings into the demo or only when the player died and show(team)scores are being shown (QWCL default).",
      "group-id": "7",
      "type": "boolean",
      "values": [
        {
          "description": "only update pings in the demo when the player died and show(team)scores are being shown",
          "name": "false"
        },
        {
          "description": "always update pings",
          "name": "true"
        }
      ]
    },
    "demo_jump_rewind": {
      "default": "-10",
      "desc": "Specifies the automatic rewind time before /demo_jump_mark or /demo_jump_status triggers normal playback.",
      "group-id": "40",
      "remarks": "Time in seconds, must be negative.",
      "type": "float"
    },
    "demo_jump_skip_messages": {
      "default": "1",
      "desc": "Determines if messages should be printed to console during demo jumps.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Display all messages during demo jump.",
          "name": "false"
        },
        {
          "description": "Skip messages during demo jump.",
          "name": "true"
        }
      ]
    },
    "demo_playlist_loop": {
      "default": "0",
      "desc": "will toggle playlist looping.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "will not loop the demo playlist",
          "name": "false"
        },
        {
          "description": "will loop the demo playlist",
          "name": "true"
        }
      ]
    },
    "demo_playlist_track_name": {
      "default": "",
      "desc": "will set the default track name in the demo playlist for mvd demos.\nExample: jogi, will always track the player jogi or versions of it (jogihoogi, angryjogi, etc).",
      "group-id": "40",
      "type": "string"
    },
    "demo_spawnwarn": {
      "default": "0",
      "desc": "Warns during demo playback when the current POV crosses a deathmatch spawn or teleporter exit.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Disable spawn crossing warnings in demos.",
          "name": "false"
        },
        {
          "description": "Enable spawn crossing warnings in demos.",
          "name": "true"
        }
      ]
    },
    "demo_spawnwarn_text": {
      "default": "you crossed a spawn",
      "desc": "Sets the centerprint text shown when demo_spawnwarn detects a spawn crossing.",
      "group-id": "40",
      "type": "string"
    },
    "developer": {
      "default": "0",
      "desc": "Enables debug mode which prints more messages into the console than for normal user.",
      "group-id": "2",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "download_map_url": {
      "default": "",
      "desc": "MVDSV : URL announced to clients for faster map downloads over HTTP.",
      "group-id": "43",
      "type": "string"
    },
    "enemybothskin": {
      "default": "",
      "desc": "Overrides the enemy quad pent skin so you can define the skin which applies to enemys with both the quad and pent powerups.",
      "group-id": "44",
      "type": "string"
    },
    "enemybottomcolor": {
      "default": "-1",
      "desc": "Determines the color of the pants of the enemies you see. Overrides player's skin settings.",
      "group-id": "44",
      "remarks": "To be able to use RGB 24bit colors, look for r_enemyskincolor variable.",
      "type": "enum",
      "values": [
        {
          "description": "Disabled",
          "name": "-1"
        },
        {
          "description": "White",
          "name": "0"
        },
        {
          "description": "Brown",
          "name": "1"
        },
        {
          "description": "Lavender",
          "name": "2"
        },
        {
          "description": "Khaki",
          "name": "3"
        },
        {
          "description": "Red",
          "name": "4"
        },
        {
          "description": "Light Brown",
          "name": "5"
        },
        {
          "description": "Peach",
          "name": "6"
        },
        {
          "description": "Light Peach",
          "name": "7"
        },
        {
          "description": "Purple",
          "name": "8"
        },
        {
          "description": "Dark Purple",
          "name": "9"
        },
        {
          "description": "Tan",
          "name": "10"
        },
        {
          "description": "Green",
          "name": "11"
        },
        {
          "description": "Yellow",
          "name": "12"
        },
        {
          "description": "Blue",
          "name": "13"
        },
        {
          "description": "Orange.",
          "name": "14"
        },
        {
          "description": "Bright red.",
          "name": "15"
        },
        {
          "description": "Black.",
          "name": "16"
        }
      ]
    },
    "enemyforceskins": {
      "default": "0",
      "desc": "Allows you to set different skin for every enemy player even if they all have same skin names set or use names of skins that you do not have in your Quake dir.",
      "group-id": "44",
      "remarks": "Read \"Player skins\" manual page for more info on skin rules.",
      "type": "enum",
      "values": [
        {
          "description": "Disabled",
          "name": "0"
        },
        {
          "description": "Use player's name as the name of the skin to be used",
          "name": "1"
        },
        {
          "description": "Use player's userid number (only useful for video capturing)",
          "name": "2"
        },
        {
          "description": "Assign skins \"e1\", \"e2\", \"e3\", etc. to the enemies.",
          "name": "3"
        }
      ]
    },
    "enemypentskin": {
      "default": "",
      "desc": "Overrides the enemy pent skin so you can define the skin which applies to enemy pents.",
      "group-id": "44",
      "type": "string"
    },
    "enemyquadskin": {
      "default": "",
      "desc": "Overrides the enemy quad skin so you can define the skin which applies to enemy quads.",
      "group-id": "44",
      "type": "string"
    },
    "enemyskin": {
      "default": "",
      "desc": "Overrides the enemies skin so you can define the skin which applies to enemies.",
      "group-id": "44",
      "type": "string"
    },
    "enemytopcolor": {
      "default": "-1",
      "desc": "Determines the color of the shirt of the enemies you see. Overrides player's skin settings.",
      "group-id": "44",
      "remarks": "To be able to use RGB 24bit colors, look for r_enemyskincolor variable.",
      "type": "integer",
      "values": [
        {
          "description": "Disabled",
          "name": "-1"
        },
        {
          "description": "White",
          "name": "0"
        },
        {
          "description": "Brown",
          "name": "1"
        },
        {
          "description": "Lavender",
          "name": "2"
        },
        {
          "description": "Khaki",
          "name": "3"
        },
        {
          "description": "Red",
          "name": "4"
        },
        {
          "description": "Light Brown",
          "name": "5"
        },
        {
          "description": "Peach",
          "name": "6"
        },
        {
          "description": "Light Peach",
          "name": "7"
        },
        {
          "description": "Purple",
          "name": "8"
        },
        {
          "description": "Dark Purple",
          "name": "9"
        },
        {
          "description": "Tan",
          "name": "10"
        },
        {
          "description": "Green",
          "name": "11"
        },
        {
          "description": "Yellow",
          "name": "12"
        },
        {
          "description": "Blue",
          "name": "13"
        },
        {
          "description": "Orange.",
          "name": "14"
        },
        {
          "description": "Bright red.",
          "name": "15"
        },
        {
          "description": "Black.",
          "name": "16"
        }
      ]
    },
    "extralogname": {
      "default": "unset",
      "group-id": "0",
      "system-generated": true
    },
    "file_browser_archive_color": {
      "default": "255 170 0 255",
      "desc": "Color of archive files in the file browser.",
      "group-id": "17",
      "type": "string"
    },
    "file_browser_dir_color": {
      "default": "170 80 0 255",
      "desc": "Color of directories in the file browser.",
      "group-id": "17",
      "type": "string"
    },
    "file_browser_file_color": {
      "default": "255 255 255 255",
      "desc": "Color of files in the file browser.",
      "group-id": "17",
      "type": "string"
    },
    "file_browser_interline": {
      "default": "0",
      "desc": "Spacing between each row in the file browser.",
      "group-id": "17",
      "type": "string",
      "values": [
        {
          "description": "Range 0 to 6.",
          "name": "*"
        }
      ]
    },
    "file_browser_scrollnames": {
      "default": "1",
      "desc": "If set, the currently selected file will scroll to let you see the full name.",
      "group-id": "17",
      "type": "boolean"
    },
    "file_browser_selected_color": {
      "default": "0 150 235 255",
      "desc": "Color of the current selection in the file browser.",
      "group-id": "17",
      "type": "string"
    },
    "file_browser_show_date": {
      "default": "1",
      "desc": "Toggles whether the file modified date is shown in the file browser.",
      "group-id": "17",
      "type": "boolean"
    },
    "file_browser_show_size": {
      "default": "1",
      "desc": "Toggles whether the filesize is shown in the file browser.",
      "group-id": "17",
      "type": "boolean"
    },
    "file_browser_show_status": {
      "default": "1",
      "desc": "Toggles whether a statusbar is shown in the file browser.",
      "group-id": "17",
      "type": "boolean"
    },
    "file_browser_show_time": {
      "default": "0",
      "desc": "Toggles whether the file modified time is shown in the file browser.",
      "group-id": "17",
      "type": "boolean"
    },
    "file_browser_sort_archives": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "file_browser_sort_mode": {
      "default": "1",
      "desc": "Determines sort order of files in the file browser.",
      "group-id": "17",
      "type": "enum",
      "values": [
        {
          "description": "sort by name",
          "name": "1"
        },
        {
          "description": "sort by size",
          "name": "2"
        },
        {
          "description": "sort by date/time",
          "name": "3"
        },
        {
          "description": "sort by type",
          "name": "4"
        },
        {
          "description": "sort by name, then by type",
          "name": "14"
        }
      ]
    },
    "file_browser_strip_names": {
      "default": "1",
      "desc": "If set, strips extra spaces from filenames in the file browser.",
      "group-id": "17",
      "type": "boolean"
    },
    "filterban": {
      "default": "1",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Only IP addresses on the Ban list will be allowed onto the server.",
          "name": "false"
        },
        {
          "description": "Only IP addresses NOT on the Ban list will be allowed onto the server.",
          "name": "true"
        }
      ]
    },
    "floodprotmsg": {
      "desc": "Sets the message displayed after flood protection is invoked.\nExample: floodprotmsg \"Shut up whiner!\"",
      "group-id": "33",
      "type": "float"
    },
    "font_capitalize": {
      "default": "0",
      "desc": "Draw all TrueType text in capital letters.",
      "group-id": "5",
      "type": "boolean"
    },
    "font_facepath": {
      "default": "",
      "desc": "Current TrueType font file.",
      "group-id": "5",
      "type": "string"
    },
    "font_gradient_alternate_color1": {
      "default": "175 120 52",
      "desc": "Top color in Alternate TrueType text.",
      "group-id": "5",
      "type": "string"
    },
    "font_gradient_alternate_color2": {
      "default": "75 52 22",
      "desc": "Bottom color in Alternate TrueType text.",
      "group-id": "5",
      "type": "string"
    },
    "font_gradient_alternate_percent": {
      "default": "0.4",
      "desc": "Slope of the gradient for Alternate TrueType text.",
      "group-id": "5",
      "type": "float"
    },
    "font_gradient_normal_color1": {
      "default": "255 255 255",
      "desc": "Top color in Normal TrueType text.",
      "group-id": "5",
      "type": "string"
    },
    "font_gradient_normal_color2": {
      "default": "107 98 86",
      "desc": "Bottom color in Normal TrueType text.",
      "group-id": "5",
      "type": "string"
    },
    "font_gradient_normal_percent": {
      "default": "0.2",
      "desc": "Slope of the gradient for Normal TrueType text.",
      "group-id": "5",
      "type": "float"
    },
    "font_gradient_number_color1": {
      "default": "255 255 150",
      "desc": "Top color in Number TrueType text.",
      "group-id": "5",
      "type": "string"
    },
    "font_gradient_number_color2": {
      "default": "218 132 7",
      "desc": "Bottom color in Number TrueType text.",
      "group-id": "5",
      "type": "string"
    },
    "font_gradient_number_percent": {
      "default": "0.2",
      "desc": "Slope of the gradient for Number TrueType text.",
      "group-id": "5",
      "type": "float"
    },
    "font_outline_width": {
      "default": "2",
      "desc": "Scale of the outline around TrueType text.",
      "group-id": "5",
      "type": "integer"
    },
    "fov": {
      "default": "90",
      "desc": "This variable defines your field of vision, which determines how close your vision field is to the objects.",
      "group-id": "53",
      "remarks": "While the default is 90, many players prefer using a higher FOV.\nNote that this would typically be scaled up when using a monitor with widescreen aspect ratio.",
      "type": "float"
    },
    "frag_log_type": {
      "default": "0",
      "group-id": "43",
      "type": ""
    },
    "fraglimit": {
      "default": "0",
      "desc": "Amount of frags any player has to reach before the match is over.",
      "group-id": "43",
      "remarks": "When set to 0, there won't be any limit.",
      "type": "integer"
    },
    "freelook": {
      "default": "1",
      "group-id": "10",
      "remarks": "direction up or down.",
      "type": "boolean",
      "values": [
        {
          "description": "Both -mlook and freelook 0 must be specified to disable free look mode.",
          "name": "false"
        },
        {
          "description": "Enables free look mode, that is, moving the mouse forward and back moves your view",
          "name": "true"
        }
      ]
    },
    "fs_cache": {
      "default": "1",
      "desc": "Enables Quake File System caching of files lists.",
      "group-id": "48",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "fs_savegame_home": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "gender": {
      "default": "",
      "desc": "Indicates the gender of the player.",
      "group-id": "37",
      "remarks": "This relies on server/mod support to function correctly.",
      "type": "enum",
      "values": [
        {
          "description": "Not specified (use gender-neutral language)",
          "name": ""
        },
        {
          "description": "Male (he, his)",
          "name": "0"
        },
        {
          "description": "Female (she, her)",
          "name": "1"
        },
        {
          "description": "None (it, its)",
          "name": "2"
        }
      ]
    },
    "gl_alphafont": {
      "default": "1",
      "desc": "Allows alpha transparency layer support for the console font.",
      "group-id": "5",
      "type": "boolean",
      "values": [
        {
          "description": "Use only 2 levels of transparency for console font",
          "name": "false"
        },
        {
          "description": "Use full 256 levels of transparency for console font",
          "name": "true"
        }
      ]
    },
    "gl_anisotropy": {
      "default": "16",
      "desc": "Anisotropic filtering. Improves texture detail on angled surfaces.",
      "group-id": "50",
      "remarks": "Depends on your Graphics card capabilities and settings. Make sure you have set your graphic card's Anisotropic Filtering setting to \"Application controlled\".",
      "type": "integer",
      "values": [
        {
          "description": "0 and 1 means turned off, then usually up to 16 for the highest quality.",
          "name": "*"
        }
      ]
    },
    "gl_bounceparticles": {
      "default": "1",
      "desc": "Controls whether sparks bounce off walls.",
      "group-id": "36",
      "remarks": "Bouncing particles look nicer, but may eat up CPU.",
      "type": "boolean"
    },
    "gl_brush_polygonoffset": {
      "default": "2.0",
      "desc": "Offset drawing of entity models to stop z-fighting.",
      "group-id": "35",
      "remarks": "Disabled for qcon (can cause flickering areas, most often on Intel cards).",
      "type": "float",
      "values": [
        {
          "description": "Range 0 to 2.",
          "name": "*"
        }
      ]
    },
    "gl_brush_polygonoffset_factor": {
      "default": "0.05",
      "desc": "Set the factor for gl_brush_polygonoffset. Negative values offset the brushes towards the player.",
      "group-id": "35",
      "type": "float",
      "values": [
        {
          "description": "Range -1 to 1.",
          "name": "*"
        }
      ]
    },
    "gl_buildingsparks": {
      "default": "0",
      "desc": "Buildings that are destroyed in TF will continue to throw sparks until they disappear.",
      "group-id": "35",
      "type": "float"
    },
    "gl_caustics": {
      "default": "0",
      "desc": "Enable reflections in submerged areas (under water, lava, slime).",
      "group-id": "51",
      "remarks": "Multi-texturing is required for this setting.",
      "type": "boolean"
    },
    "gl_charsets_min": {
      "default": "1",
      "desc": "Speeds up start-up time by only searching for minimum number of charsets during start-up.",
      "group-id": "5",
      "type": "boolean",
      "values": [
        {
          "description": "Search for full range of unicode charsets",
          "name": "false"
        },
        {
          "description": "Search for default and -cyr only (as per ezQuake 2.2)",
          "name": "true"
        }
      ]
    },
    "gl_clear": {
      "default": "0",
      "desc": "Clears the screen with gl_clearcolor between each frame.\nPrevents hall-of-mirrors glitches, e.g. when flying out of the map.",
      "group-id": "35",
      "remarks": "This can cause problems when going through the surface of a liquid, as you may see a colored flash where the liquid texture would normally glitch.",
      "type": "boolean"
    },
    "gl_clearColor": {
      "default": "0 0 0",
      "desc": "Sets clear color (gl_clear 1).",
      "group-id": "35",
      "remarks": "When using vid_framebuffer, the GPU starts from a clean, black buffer and this value is effectively ignored.",
      "type": "string"
    },
    "gl_clipparticles": {
      "default": "1",
      "desc": "Limits the number of blended particles close to you. This can give a big FPS increase when blended particles take up a big proportion of your screen and challenge your video card's fillrate.",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_colorlights": {
      "default": "1",
      "desc": "Toggles color on lighting from glowing items (quad, pent, flags in TF, etc).",
      "group-id": "15",
      "remarks": "This implementation does not give a speed increase when gl_colorlights is set to 0, but it does not require a map restart for changes to take effect.",
      "type": "boolean"
    },
    "gl_consolefont": {
      "default": "povo5",
      "desc": "Changes your console font.\nPut all your charset images in qw/textures/charsets/*.png (and *.tga).\n\"/gl_consolefont original\" will restore the 8bit font in your gfx.wad.",
      "group-id": "5",
      "remarks": "loadcharset is an alias for gl_consolefont.",
      "type": "string"
    },
    "gl_contrast": {
      "default": "1.0",
      "desc": "Change contrast.",
      "group-id": "40",
      "type": "float",
      "values": [
        {
          "description": "Range 1 to 3.",
          "name": "*"
        }
      ]
    },
    "gl_coronas": {
      "default": "0",
      "desc": "Adds coronas to some effects:\n\n - Explosions: Basically just a bright flash since the default explosions didn't feel powerful enough.\n - Weapon impacts (optional, see gl_particle_*).\n - Muzzleflashes.\n - Lightning bolts.\n - Fire: Torches have glows.\n - Rocket Lights.",
      "group-id": "15",
      "type": "float"
    },
    "gl_coronas_tele": {
      "default": "0",
      "desc": "Adds a blue glow to spawn/teleport effects.",
      "group-id": "15",
      "remarks": "Requires gl_coronas 1.",
      "type": "boolean"
    },
    "gl_cshiftpercent": {
      "default": "100",
      "desc": "This variable sets the percentage value for palette shifting effects (damage flash, powerup blend). (needs gl_polyblend 1).",
      "group-id": "39",
      "type": "float"
    },
    "gl_custom_grenade_color": {
      "default": "",
      "desc": "Allows color of grenades to be set without requiring a texture change.",
      "group-id": "35",
      "remarks": "Leave blank to disable.\nSee gl_custom_grenade_fullbright.",
      "type": "string"
    },
    "gl_custom_grenade_fullbright": {
      "default": "1",
      "desc": "Determines if gl_custom_grenade_color refers to a fullbright color or standard.",
      "group-id": "35",
      "remarks": "Has no effect if gl_custom_grenade_color is blank.",
      "type": "boolean"
    },
    "gl_custom_grenade_tf": {
      "default": "1",
      "desc": "Allows gl_custom_grenade_* variables to be ignored when playing Team Fortress.",
      "group-id": "35",
      "type": "boolean"
    },
    "gl_custom_lg_color": {
      "default": "",
      "desc": "Allows color of lightning shaft to be set without requiring a texture change.",
      "group-id": "35",
      "remarks": "Leave blank to disable.\nHas no effect if particle shaft is enabled.",
      "type": "string"
    },
    "gl_custom_lg_fullbright": {
      "default": "1",
      "desc": "Determines if gl_custom_lg_color refers to a fullbright color or standard.",
      "group-id": "35",
      "remarks": "Has no effect if gl_custom_lg_color is blank.",
      "type": "boolean"
    },
    "gl_custom_lgpack_color": {
      "default": "64 64 255",
      "desc": "Color lightning gun backpacks with this value.",
      "group-id": "35",
      "remarks": "Leave blank to disable. QTV/MVD only, KTX 1.38+ only.",
      "type": "string"
    },
    "gl_custom_rlpack_color": {
      "default": "255 64 64",
      "desc": "Tints rocket launcher backpacks with this value.",
      "group-id": "35",
      "remarks": "Leave blank to disable. QTV/MVD only, KTX 1.38+ only.",
      "type": "string"
    },
    "gl_custom_rocket_color": {
      "default": "",
      "desc": "Allows color of rockets to be set without requiring a texture change.",
      "group-id": "35",
      "remarks": "Leave blank to disable.\nSee gl_custom_rocket_fullbright.",
      "type": "string"
    },
    "gl_custom_rocket_fullbright": {
      "default": "1",
      "desc": "Determines if gl_custom_rocket_color refers to a fullbright color or standard.",
      "group-id": "35",
      "remarks": "Has no effect if gl_custom_rocket_color is blank.",
      "type": "boolean"
    },
    "gl_custom_spike_color": {
      "default": "",
      "desc": "Allows color of spikes/nails to be set without requiring a texture change.",
      "group-id": "35",
      "remarks": "Leave blank to disable.\nSee gl_custom_spike_fullbright.",
      "type": "string"
    },
    "gl_custom_spike_fullbright": {
      "default": "1",
      "desc": "Determines if gl_custom_spike_color refers to a fullbright color or standard.",
      "group-id": "35",
      "remarks": "Has no effect if gl_custom_spike_color is blank.",
      "type": "boolean"
    },
    "gl_cutf_tesla_effect": {
      "default": "0",
      "desc": "When a shambler is preparing to throw lightning, or a tesla coil (TF) is charging to fire, a particle effect is generated.",
      "group-id": "35",
      "type": "float"
    },
    "gl_detail": {
      "default": "0",
      "desc": "Toggles an extra layer of fine detail over world textures.",
      "group-id": "8",
      "remarks": "Can impact performance on weak GPUs.",
      "type": "boolean"
    },
    "gl_detpacklights": {
      "default": "0",
      "desc": "A little green light appears on the detpack, and when the timer reaches 5, the light changes to red.",
      "group-id": "35",
      "remarks": "gl_coronas must be turned on for this to work.",
      "type": "float"
    },
    "gl_ext_texture_compression": {
      "default": "0",
      "desc": "Compress textures on GPUs that support it to save VRAM, at the cost of longer load times and degraded quality.",
      "group-id": "50",
      "remarks": "No longer needed when you have many hundreds of Mb of VRAM.",
      "type": "boolean"
    },
    "gl_externalTextures_bmodels": {
      "default": "1",
      "desc": "Toggles loading external 24-bit textures for non-world bsp models, i.e. health and ammo boxes.",
      "group-id": "50",
      "type": "boolean",
      "values": [
        {
          "description": "Disable (classic look).",
          "name": "false"
        },
        {
          "description": "Enable.",
          "name": "true"
        }
      ]
    },
    "gl_externalTextures_world": {
      "default": "1",
      "desc": "Toggles loading external 24-bit textures for the world, i.e. the actual map.",
      "group-id": "50",
      "type": "boolean",
      "values": [
        {
          "description": "Disable (classic look).",
          "name": "false"
        },
        {
          "description": "Enable.",
          "name": "true"
        }
      ]
    },
    "gl_extratrails": {
      "default": "0",
      "desc": "Misc trails that appear on objects that frequently move, such as TF grenades, caltrops, etc.\nRailguns in TF also leave behind unique trails.",
      "group-id": "35",
      "type": "float"
    },
    "gl_fb_bmodels": {
      "default": "1",
      "desc": "Enable \"fullbright\" colors on bsp models (World, health boxes, etc). Might give you a couple more fps.",
      "group-id": "15",
      "type": "boolean"
    },
    "gl_fb_models": {
      "default": "1",
      "desc": "Enable \"fullbright\" colors on alias models (grenades, player models, etc). Might give you a couple more fps.",
      "group-id": "15",
      "type": "boolean"
    },
    "gl_finish": {
      "default": "0",
      "desc": "Wait until OpenGL has finished working to start rendering the next frame.",
      "group-id": "35",
      "remarks": "In the past, this setting might have helped (or worsened) some types of graphics glitches and timing issues.\nIt is mostly there for compatibility reasons and best left disabled unless you have bugs, performance problems, an unusual setup (in any combination).",
      "type": "boolean"
    },
    "gl_flashblend": {
      "default": "0",
      "desc": "This variable affects when glow bubbles are displayed in the client. You can change the color of the rocket glow by r_rocketLightColor, the color of explosions by r_explosionLightColor, and the color of flag carriers by r_flagColor.",
      "group-id": "15",
      "type": "enum",
      "values": [
        {
          "description": "No glow bubbles.",
          "name": "0"
        },
        {
          "description": "A glow bubble will appear on explosions and flag/quad/pent carrier.",
          "name": "1"
        },
        {
          "description": "Same as (1), but also around rockets in the air.",
          "name": "2"
        }
      ]
    },
    "gl_gamma": {
      "default": "1.0",
      "desc": "Change gamma.",
      "group-id": "40",
      "type": "float",
      "values": [
        {
          "description": "Range 0.3 to 3.",
          "name": "*"
        }
      ]
    },
    "gl_hwblend": {
      "default": "0",
      "desc": "Toggles between OpenGL and Hardware palette changing.",
      "group-id": "39",
      "remarks": "1 can be slow on WinNT/2K.",
      "type": "boolean"
    },
    "gl_inferno_speed": {
      "default": "1000",
      "desc": "Changes speed of gl_inferno missile trail.",
      "group-id": "35",
      "type": "float"
    },
    "gl_inferno_trail": {
      "default": "2",
      "desc": "Changes type of gl_inferno missile trail.",
      "group-id": "35",
      "type": "float"
    },
    "gl_lerpimages": {
      "default": "1",
      "desc": "Improves quality of non-power of two textures, at a slight load time cost. No impact on framerates.",
      "group-id": "50",
      "remarks": "Only applies to GPUs which do not support non-power of two textures.",
      "type": "boolean",
      "values": [
        {
          "description": "Worse texture quality, faster loading maps.",
          "name": "false"
        },
        {
          "description": "Better texture quality, slower loading maps.",
          "name": "true"
        }
      ]
    },
    "gl_lighting_color": {
      "default": "0",
      "desc": "Alias models are effected by colored lights around them.",
      "group-id": "15",
      "type": "float"
    },
    "gl_lighting_vertex": {
      "default": "0",
      "desc": "Alias models no longer have the same level of light on all sides.\nThis may not work correctly if colored lighting is disabled.",
      "group-id": "15",
      "type": "float"
    },
    "gl_lightmode": {
      "default": "1",
      "desc": "Enables overbright lightmaps.\nBrings more contrast, making world lighting look more like software Quake, and less like GLQuake.",
      "group-id": "15",
      "remarks": "Takes effect when the map reloads.",
      "type": "boolean",
      "values": [
        {
          "description": "Makes the map lighter, but fullbrights don't look as good. (0% overbrights)",
          "name": "false"
        },
        {
          "description": "Makes the map darker, but makes fullbrights stand out more (looks better). (33% overbrights)",
          "name": "true"
        }
      ]
    },
    "gl_lightning": {
      "default": "0",
      "desc": "Toggles particle lightning beams. Glow is controlled by gl_coronas.",
      "group-id": "35",
      "remarks": "Restricted in rulesets qcon and smackdown/drive (glow effect remains).",
      "type": "boolean"
    },
    "gl_lightning_color": {
      "default": "120 140 255",
      "desc": "The RGB color of particle lightning beam and sparks.",
      "group-id": "35",
      "type": "string",
      "values": [
        {
          "description": "R G B alpha, each 0-255",
          "name": "*"
        }
      ]
    },
    "gl_lightning_size": {
      "default": "3",
      "desc": "Adjusts size of lightning particle beam.",
      "group-id": "35",
      "type": "float",
      "values": [
        {
          "description": "Range 3 to 30.",
          "name": "*"
        }
      ]
    },
    "gl_lightning_sparks": {
      "default": "0",
      "desc": "Sparks fly from walls when hit by lightning gun.",
      "group-id": "35",
      "type": "float"
    },
    "gl_lightning_sparks_size": {
      "default": "300",
      "desc": "Size of lightning sparks.",
      "group-id": "35",
      "type": "integer"
    },
    "gl_loadlitfiles": {
      "default": "1",
      "desc": "Controls when external 24-bit lighting will be used.\n24-bit/colored lighting is either embedded in newer .bsp files, or loaded from external .lit files.",
      "group-id": "15",
      "type": "enum",
      "values": [
        {
          "description": "Disable 24-bit lighting.",
          "name": "0"
        },
        {
          "description": "Load lit files & use inline colored lighting.",
          "name": "1"
        },
        {
          "description": "Load lit files only.",
          "name": "2"
        },
        {
          "description": "Use inline colored lighting only.",
          "name": "3"
        }
      ]
    },
    "gl_luma_level": {
      "default": "1",
      "desc": "Some luma textures have black non-transparent pixels. This can make them transparent.",
      "group-id": "50",
      "remarks": "Setting this to 0 will disable the functionality. For some commonly used texture packs value 1 is necessary.",
      "type": "integer",
      "values": [
        {
          "description": "e.g. value 10 makes particular pixels transparent if each color component is LESS than 10.",
          "name": "*"
        }
      ]
    },
    "gl_lumatextures": {
      "default": "1",
      "desc": "Turns using luma textures (named *_luma) ON when set to 1 and allowed by server.",
      "group-id": "50",
      "type": "float"
    },
    "gl_max_size": {
      "default": "32768",
      "desc": "This variable determines the detail level for loaded textures.\nWhen set to \"1\", the objects and walls will be textured with 1x1 pixel textures.",
      "group-id": "50",
      "type": "float"
    },
    "gl_miptexLevel": {
      "default": "0",
      "desc": "Downscale textures in a way that looks like the 'd_mipcap' setting from classic software-rendered QW.\nHas no effect on external 24-bit textures.",
      "group-id": "50",
      "type": "float"
    },
    "gl_modulate": {
      "default": "1",
      "desc": "Controls how bright the lightmap gets.",
      "group-id": "35",
      "type": "float",
      "values": [
        {
          "description": "Range 0.5 to 3.",
          "name": "*"
        }
      ]
    },
    "gl_motion_blur": {
      "default": "0",
      "desc": "Enables motion blur effect (set gl_motion_blur_* variables to configure)",
      "group-id": "8",
      "type": "boolean"
    },
    "gl_motion_blur_dead": {
      "default": "0.5",
      "desc": "Level of blending of current scene with previous, when the player is dead.",
      "group-id": "8",
      "type": "float"
    },
    "gl_motion_blur_fps": {
      "default": "77",
      "desc": "How often to copy the current frame to apply motion blur effect. Defaults to 77.",
      "group-id": "8",
      "type": "integer"
    },
    "gl_motion_blur_hurt": {
      "default": "0.5",
      "desc": "Level of blending of current scene with previous, when the player has recently been hurt.",
      "group-id": "8",
      "type": "float"
    },
    "gl_motion_blur_norm": {
      "default": "0.5",
      "desc": "Level of blending of current scene with previous, when the player is alive and not recently hurt.",
      "group-id": "8",
      "type": "float"
    },
    "gl_multisamples": {
      "default": "0",
      "desc": "The number of samples used around each pixel for anti-aliasing.",
      "group-id": "52",
      "type": "integer",
      "values": [
        {
          "description": "Range 0 to 16.",
          "name": "*"
        }
      ]
    },
    "gl_nailtrail": {
      "default": "0",
      "desc": "Adds a white trail onto nails as they fly around.",
      "group-id": "35",
      "remarks": "This feature won't work on servers not running with sv_nailhack set to 1.",
      "type": "boolean"
    },
    "gl_nailtrail_plasma": {
      "default": "0",
      "desc": "Adds a blue plasma trail to nail trails.",
      "group-id": "35",
      "remarks": "Requires gl_nailtrail 1.",
      "type": "boolean"
    },
    "gl_nailtrail_turb": {
      "default": "0",
      "desc": "Switches between two type of bubbles nails leave behind in water.",
      "group-id": "35",
      "remarks": "gl_turb_trails 1 needs to be set.",
      "type": "enum",
      "values": [
        {
          "description": "Smaller bubbles",
          "name": "0"
        },
        {
          "description": "Larger bubbles",
          "name": "1"
        }
      ]
    },
    "gl_no24bit": {
      "default": "0",
      "desc": "Disables support of alternate 24-bit textures.",
      "group-id": "50",
      "type": "boolean",
      "values": [
        {
          "description": "Allow 24-bit textures",
          "name": "false"
        },
        {
          "description": "Disable 24-bit textures",
          "name": "true"
        }
      ]
    },
    "gl_nocolors": {
      "default": "0",
      "desc": "Enable top/bottom colors on 8-bit .pcx skins.",
      "group-id": "35",
      "type": "boolean"
    },
    "gl_oldlitscaling": {
      "default": "0",
      "desc": "Scales lit files the 'old' way ('makes colored areas too dark').",
      "group-id": "15",
      "type": "boolean"
    },
    "gl_outline": {
      "default": "0",
      "desc": "Controls outlining of models and map. Disallowed in qcon ruleset.",
      "group-id": "35",
      "remarks": "World outlines require vid_framebuffer 1|2 and Modern OpenGL (vid_renderer 1). With vid_renderer 0, ruleset default and sv_cheats 1, gl_outline 2 draws outlines of every surface that is rendered.",
      "type": "enum",
      "values": [
        {
          "description": "Outlining disabled",
          "name": "0"
        },
        {
          "description": "Outline models",
          "name": "1"
        },
        {
          "description": "Outline world",
          "name": "2"
        },
        {
          "description": "Outline models and world",
          "name": "3"
        }
      ]
    },
    "gl_outline_color_enemy": {
      "default": "",
      "desc": "Determines the outline color of enemy players. Set to \"\" to use the value of gl_outline_color_model.",
      "group-id": "35",
      "remarks": "Requires vid_renderer 1",
      "type": "string"
    },
    "gl_outline_color_model": {
      "default": "0 0 0",
      "desc": "Determines the color of model outlines.",
      "group-id": "35",
      "remarks": "Requires vid_renderer 1",
      "type": "string"
    },
    "gl_outline_color_team": {
      "default": "",
      "desc": "Determines the outline color of friendly players. Set to \"\" to use the value of gl_outline_color_model.",
      "group-id": "35",
      "remarks": "Requires vid_renderer 1",
      "type": "string"
    },
    "gl_outline_color_world": {
      "default": "0 0 0",
      "desc": "Determines the color of world outlines.",
      "group-id": "35",
      "type": "string"
    },
    "gl_outline_scale_model": {
      "default": "1",
      "desc": "Determines the scale of model outlines. Allows values 0 to 1 for rulesets smackdown, smackdrive and qcon, and 0 to 5 for other rulesets.",
      "group-id": "35",
      "remarks": "Requires vid_renderer 1",
      "type": "float"
    },
    "gl_outline_use_player_color": {
      "default": "0",
      "desc": "Use the top and bottom color for drawing player outlines",
      "group-id": "35",
      "remarks": "Requires vid_renderer 1",
      "type": "boolean"
    },
    "gl_outline_world_depth_threshold": {
      "default": "4",
      "desc": "Threshold for finding edges with depth values. Higher value means vanishing lines at close range. Lower value means false positives at longer range.",
      "group-id": "35",
      "type": "float",
      "values": [
        {
          "description": "Range 1 to 16.",
          "name": "*"
        }
      ]
    },
    "gl_outline_world_normal_threshold": {
      "default": "0.997",
      "desc": "Threshold for finding edges face orientation. Higher value is more edges.",
      "group-id": "35",
      "type": "float",
      "values": [
        {
          "description": "Range 0 to 0.999",
          "name": "*"
        }
      ]
    },
    "gl_part_blobs": {
      "default": "0",
      "desc": "Determines particles used for blob explosions (EMPs).",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_blood": {
      "default": "0",
      "desc": "Determines particles used for blood effects.",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_bloodtrails": {
      "default": "1",
      "desc": "Determines particles used for blood trails (gibs).",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_bubble": {
      "default": "1",
      "desc": "Advanced particles for bubbles (drowning effect).",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_cache": {
      "default": "1",
      "description": "Reduce CPU overhead when newer particle effects are used.",
      "group-id": "36",
      "type": "boolean",
      "values": [
        {
          "description": "Do not cache hull-traces",
          "name": "false"
        },
        {
          "description": "Reduce hull-traces as particles move",
          "name": "true"
        }
      ]
    },
    "gl_part_detpackexplosion_fire_color": {
      "default": "",
      "desc": "Change color of the detpack explosion fire (TF).",
      "group-id": "36",
      "type": "string"
    },
    "gl_part_detpackexplosion_ray_color": {
      "default": "",
      "desc": "Change the color of the detpack explosion rays (Team Fortress).",
      "group-id": "36",
      "type": "string"
    },
    "gl_part_explosions": {
      "default": "0",
      "desc": "Determines particles used for explosions.",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_gunshots": {
      "default": "0",
      "desc": "Determines particles used for gunshots.",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_inferno": {
      "default": "0",
      "desc": "Determines particles used for pyro flames in TF.",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_lavasplash": {
      "default": "0",
      "desc": "Determines particles used for lava splashes (Spy Gren).",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_spikes": {
      "default": "0",
      "desc": "Determines particles used for spikes (nailgun etc).",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_part_telesplash": {
      "default": "0",
      "desc": "Determines particles used for teleport effects.",
      "group-id": "36",
      "type": "enum",
      "values": [
        {
          "description": "Use classic quake teleport particles.",
          "name": "0"
        },
        {
          "description": "Use 'new/eye-candy' teleport particles: 'dots' and 'rays'",
          "name": "1"
        },
        {
          "description": "Use 'new/eye-candy' teleport particles: 'dots' only",
          "name": "2"
        }
      ]
    },
    "gl_part_tracer1_color": {
      "default": "0 124 0",
      "desc": "Changes the color of the tracer1 trail, which allows you to customize the rockettrail color (see remarks).",
      "group-id": "36",
      "remarks": "If you set r_rockettrail 6 and gl_part_trails 1, this variable will change your rockettrail color.",
      "type": "string",
      "values": [
        {
          "description": "\"R G B\" format accepted, e.g. \"255 255 0\" for yellow",
          "name": "*"
        }
      ]
    },
    "gl_part_tracer1_size": {
      "default": "3.75",
      "desc": "Changes the size of the tracer1 trail, which allows you to customize the rockettrail size (see remarks).",
      "group-id": "36",
      "remarks": "If you set r_rockettrail 6 and gl_part_trails 1, this variable will change your rockettrail size.",
      "type": "float"
    },
    "gl_part_tracer1_time": {
      "default": "0.5",
      "desc": "Changes the duration of the tracer1 trail, which allows you to customize the rockettrail (see remarks).",
      "group-id": "36",
      "remarks": "If you set r_rockettrail 6 and gl_part_trails 1, this variable will change your rockettrail duration.",
      "type": "float"
    },
    "gl_part_tracer2_color": {
      "default": "255 77 0",
      "desc": "Changes the color of the tracer2 trail, which allows you to customize the rockettrail color (see remarks).",
      "group-id": "36",
      "remarks": "If you set r_rockettrail 7 and gl_part_trails 1, this variable will change your rockettrail color.",
      "type": "string",
      "values": [
        {
          "description": "\"R G B\" format accepted, e.g. \"255 255 0\" for yellow",
          "name": "*"
        }
      ]
    },
    "gl_part_tracer2_size": {
      "default": "3.75",
      "desc": "Changes the size of the tracer2 trail, which allows you to customize the rockettrail size (see remarks).",
      "group-id": "36",
      "remarks": "If you set r_rockettrail 7 and gl_part_trails 1, this variable will change your rockettrail size.",
      "type": "float"
    },
    "gl_part_tracer2_time": {
      "default": "0.5",
      "desc": "Changes the duration of the tracer2 trail, which allows you to customize the rockettrail (see remarks).",
      "group-id": "36",
      "remarks": "If you set r_rockettrail 7 and gl_part_trails 1, this variable will change your rockettrail duration.",
      "type": "float"
    },
    "gl_part_trails": {
      "default": "0",
      "desc": "Determines particles used for (rocket etc) trails.",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_particle_blobs": {
      "default": "0",
      "desc": "Determines size of blob explosions.\nIf set to 0, standard non-particle explosions will be used instead.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_blood": {
      "default": "0",
      "desc": "Determines size of blood effect.\nIf set to 0, standard blood effect will be used instead.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_blood_color": {
      "default": "1",
      "desc": "Changes color of blood particles.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_blood_type": {
      "default": "1",
      "desc": "Chooses among types of blood particles.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_deatheffect": {
      "default": "0",
      "desc": "Adds extra blood effects to gibs.",
      "group-id": "36",
      "type": "enum",
      "values": [
        {
          "description": "No extra effects",
          "name": "0"
        },
        {
          "description": "Death effect enabled for all corpses",
          "name": "1"
        },
        {
          "description": "Death effect for gibbed players only",
          "name": "2"
        }
      ]
    },
    "gl_particle_explosions": {
      "default": "0",
      "desc": "Determines alternate particles for explosions.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_fasttrails": {
      "default": "0",
      "desc": "Changes particle trails indicating motion.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_fire": {
      "default": "0",
      "desc": "Replaces torches with a particle flame effect.\nIncludes people being burnt by the pyro in TF.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_firecolor": {
      "default": "",
      "desc": "Color of the fire particles.",
      "group-id": "36",
      "type": "string"
    },
    "gl_particle_fulldetail": {
      "default": "0",
      "desc": "Allows full detail depth for gl_particle_* effects.",
      "group-id": "36",
      "remarks": "Requires vid_restart.",
      "type": "boolean"
    },
    "gl_particle_gibtrails": {
      "default": "0",
      "desc": "Enable alternate gib trails with bright blood.",
      "group-id": "36",
      "remarks": "Requires gl_part_trails 1.",
      "type": "float"
    },
    "gl_particle_gunshots": {
      "default": "0",
      "desc": "Enable alternate gunshot impact effects.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_gunshots_type": {
      "default": "1",
      "desc": "Selects alternate gunshot impact effects.",
      "group-id": "36",
      "remarks": "Light flashes also appear with gl_coronas 1.",
      "type": "float",
      "values": [
        {
          "description": "Long, thin, curving orange sparks.",
          "name": "0 and 1"
        },
        {
          "description": "Large, bright yellowish sparks.",
          "name": "2 and 3"
        },
        {
          "description": "Short, straight orange sparks.",
          "name": "4"
        }
      ]
    },
    "gl_particle_muzzleflash": {
      "default": "0",
      "desc": "Adds a particle effect when monsters and other players fire a weapon.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_shockwaves": {
      "default": "0",
      "desc": "Controls the volumetric shockwave for the alternate blob explosion effects (r_explosiontype 6).",
      "group-id": "36",
      "remarks": "Requires gl_particle_explosions 1.",
      "type": "boolean"
    },
    "gl_particle_shockwaves_flat": {
      "default": "0",
      "desc": "Adds a flat, orange shockwave to alternate explosion effects.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_sparks": {
      "default": "0",
      "desc": "Controls particle sparks.\nTrails appear more beam-like and don't look stupid when they bounce.\nThis applies for wizards and knights only.",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_particle_spikes": {
      "default": "0",
      "desc": "Enable alternate spike impact effects.",
      "group-id": "36",
      "remarks": "Light flashes also appear with gl_coronas 1.",
      "type": "float"
    },
    "gl_particle_spikes_type": {
      "default": "1",
      "desc": "Selects alternate spike impact effects.",
      "group-id": "36",
      "remarks": "Light flashes also appear with gl_coronas 1.",
      "type": "float",
      "values": [
        {
          "description": "Long, thin, curving orange sparks.",
          "name": "0 and 1"
        },
        {
          "description": "Large, bright yellowish sparks.",
          "name": "2 and 3"
        },
        {
          "description": "Short, straight orange sparks.",
          "name": "4"
        }
      ]
    },
    "gl_particle_telesplash": {
      "default": "0",
      "desc": "Enable alternative teleport effect with extra sparks.",
      "group-id": "36"
    },
    "gl_particle_trail_detail": {
      "default": "1",
      "desc": "Controls the level of detail on the particle lightning beams, and some types of sparks.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_trail_length": {
      "default": "1",
      "desc": "X - Multiplies the length of the trail on particle trails.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_trail_time": {
      "default": "1",
      "desc": "X - Multiplies the length of time the particle bounces around for.",
      "group-id": "36",
      "type": "float"
    },
    "gl_particle_trail_type": {
      "default": "1",
      "desc": "Changes the type of particle on alt. gunshots, fuel rod explosions...",
      "group-id": "36",
      "type": "integer",
      "values": [
        {
          "description": "Long, thin, curving orange sparks.",
          "name": "0 and 1"
        },
        {
          "description": "A mist of small white pebbles.",
          "name": "2"
        }
      ]
    },
    "gl_particle_trail_width": {
      "default": "3",
      "desc": "Changes width of particle trails, e.g. wall hit by nail, explosion particles trail, etc.",
      "group-id": "36",
      "type": "float"
    },
    "gl_picmip": {
      "default": "0",
      "desc": "Determines the level of detail for world textures.",
      "group-id": "50",
      "remarks": "Does not apply to models, liquids, simple icons, but you can also picmip these with the gl_playermip and gl_scale* cvars.",
      "type": "float",
      "values": [
        {
          "description": "Original size.",
          "name": "0"
        },
        {
          "description": "Half the dimensions.",
          "name": "1"
        },
        {
          "description": "One-fourth the dimensions.",
          "name": "2"
        },
        {
          "description": "Etc...",
          "name": "x"
        }
      ]
    },
    "gl_playermip": {
      "default": "0",
      "desc": "Determines the level of detail of player model textures.",
      "group-id": "50",
      "type": "enum",
      "values": [
        {
          "description": "Full detail.",
          "name": "0"
        },
        {
          "description": "Medium detail.",
          "name": "1"
        },
        {
          "description": "Low detail.",
          "name": "2"
        },
        {
          "description": "Etc...",
          "name": "x"
        }
      ]
    },
    "gl_polyblend": {
      "default": "1",
      "desc": "Controls a short burst of screen tinting when submerged, taking a powerup, or taking damage.\nVariables to look at are: gl_cshiftpercent (controls overall palette shifting) v_damagechisft v_quadcshift v_pentcshift v_ringcshift v_suitcshift.",
      "group-id": "39",
      "type": "boolean"
    },
    "gl_powerupshells": {
      "default": "1",
      "desc": "Enables a flashing layer over players carrying powerups.",
      "group-id": "8",
      "type": "boolean"
    },
    "gl_powerupshells_base1level": {
      "default": "0.05",
      "group-id": "8",
      "type": "float"
    },
    "gl_powerupshells_base2level": {
      "default": "0.1",
      "group-id": "8",
      "type": "float"
    },
    "gl_powerupshells_effect1level": {
      "default": "0.75",
      "group-id": "8",
      "type": "float"
    },
    "gl_powerupshells_effect2level": {
      "default": "0.4",
      "group-id": "8",
      "type": "float"
    },
    "gl_powerupshells_size": {
      "default": "5",
      "desc": "Size of the powerupshells effect layer.",
      "group-id": "8",
      "type": "integer"
    },
    "gl_program_aliasmodels": {
      "default": "1",
      "desc": "Determines if GLSL will be used to render aliasmodels.",
      "group-id": "35",
      "remarks": "Applies to classic OpenGL renderer only.",
      "renderers": [
        "classic"
      ],
      "type": "integer"
    },
    "gl_program_hud": {
      "default": "1",
      "desc": "Determines if GLSL will be used to render the HUD.",
      "group-id": "35",
      "remarks": "Applies to classic OpenGL renderer only.",
      "renderers": [
        "classic"
      ],
      "type": "integer"
    },
    "gl_program_sky": {
      "default": "1",
      "desc": "Determines if GLSL will be used to render skybox/skydome surfaces.\nr_fastsky does not use this setting.",
      "group-id": "35",
      "remarks": "Applies to classic OpenGL renderer only.",
      "renderers": [
        "classic"
      ],
      "type": "integer"
    },
    "gl_program_sprites": {
      "default": "1",
      "desc": "Determines if GLSL will be used to render sprites.",
      "group-id": "35",
      "remarks": "Applies to classic OpenGL renderer only.",
      "renderers": [
        "classic"
      ],
      "type": "integer"
    },
    "gl_program_turbsurfaces": {
      "default": "1",
      "desc": "Determines if GLSL will be used to render 'liquid' surfaces.\nr_fastturb does not use this setting.",
      "group-id": "35",
      "remarks": "Applies to classic OpenGL renderer only.",
      "renderers": [
        "classic"
      ],
      "type": "integer"
    },
    "gl_program_world": {
      "default": "1",
      "desc": "Determines if GLSL will be used to render world surfaces (walls, floors..).",
      "group-id": "35",
      "remarks": "Applies to classic OpenGL renderer only.",
      "renderers": [
        "classic"
      ],
      "type": "integer"
    },
    "gl_rl_globe": {
      "default": "0",
      "desc": "Helps customize rocket light independent of gl_flashblend.",
      "group-id": "15",
      "type": "integer",
      "values": [
        {
          "description": "Rocket light controlled by gl_flashblend",
          "name": "0"
        },
        {
          "description": "Rocket light looks like with gl_flashblend 2, but no dynamic lighting",
          "name": "1"
        },
        {
          "description": "Rocket light looks like with gl_flashblend 0 or 1",
          "name": "2"
        },
        {
          "description": "Rocket light looks like with gl_flashblend 2, with dynamic lighting",
          "name": "3"
        }
      ]
    },
    "gl_scaleAlphaTextures": {
      "default": "0",
      "desc": "Applies picmip/max_size/miptexlevel to alpha masked textures (fence).",
      "group-id": "50",
      "type": "boolean"
    },
    "gl_scaleModelSimpleTextures": {
      "default": "0",
      "desc": "Applies picmip/max_size/miptexlevel to gl_simpleitem icons.",
      "group-id": "50",
      "type": "boolean"
    },
    "gl_scaleModelTextures": {
      "default": "0",
      "desc": "Applies picmip/max_size/miptexlevel to model textures.",
      "group-id": "50",
      "type": "boolean"
    },
    "gl_scaleTurbTextures": {
      "default": "1",
      "desc": "Applies picmip/max_size/miptexlevel to turb textures (lava, water, slime, teleports).",
      "group-id": "50",
      "type": "boolean"
    },
    "gl_scaleskytextures": {
      "default": "0",
      "desc": "Applies picmip/max_size/miptexlevel to sky textures (skydome and skybox).",
      "group-id": "50",
      "type": "boolean"
    },
    "gl_shaftlight": {
      "default": "1",
      "desc": "Toggles between darker/fullbright shaft beams.",
      "group-id": "15",
      "type": "boolean"
    },
    "gl_simpleitems": {
      "default": "0",
      "desc": "Toggles drawing simple icons instead of 3D item models.",
      "group-id": "8",
      "type": "boolean"
    },
    "gl_simpleitems_orientation": {
      "default": "2",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "Orientation based on player's view",
          "name": "0"
        },
        {
          "description": "Facing the player, horizontally only",
          "name": "1"
        },
        {
          "description": "Directly facing the player",
          "name": "2"
        },
        {
          "description": "Items rotate",
          "name": "3"
        }
      ]
    },
    "gl_simpleitems_size": {
      "default": "16",
      "desc": "Size of simple items. Max size 16.",
      "group-id": "8",
      "type": "integer"
    },
      "gl_smoothmodels": {
      "default": "1",
      "desc": "Toggles between flat-shaded and smooth shaded models.",
      "group-id": "35",
      "remarks": "Applies to GLSL OpenGL renderer only.",
      "type": "boolean"
    },
    "gl_spec_xray": {
      "default": "0",
      "desc": "See players through walls (demo/qtv only). Is affected by gl_outline_* values like color, scale, etc.",
      "group-id": "35",
      "remarks": "Requires vid_renderer 1",
      "type": "boolean"
    },
    "gl_spec_xray_distance": {
      "default": "1500",
      "desc": "Distance from which you can see the players through walls, see gl_spec_xray",
      "group-id": "35",
      "type": "float"
    },
    "gl_squareparticles": {
      "default": "0",
      "desc": "Toggles between circle and square particles.",
      "group-id": "36",
      "type": "boolean"
    },
    "gl_subdivide_size": {
      "default": "64",
      "desc": "This variable sets the division value for the sky brushes.\nThe higher the value the better the performance, but the smoothness of the sky suffers.",
      "group-id": "50",
      "type": "float"
    },
    "gl_surface_lava": {
      "default": "0",
      "desc": "Adds boiling bubbles over the lava.",
      "group-id": "51",
      "type": "enum",
      "values": [
        {
          "description": "Disabled",
          "name": "0"
        },
        {
          "description": "Small fumes",
          "name": "1"
        },
        {
          "description": "Large fumes",
          "name": "2"
        },
        {
          "description": "Like 1 but adjusted by HyperNewbie",
          "name": "3"
        },
        {
          "description": "Like 2 but adjusted by HyperNewbie",
          "name": "4"
        }
      ]
    },
    "gl_surface_slime": {
      "default": "0",
      "desc": "Adds bubbles and fumes of slime over the slime.",
      "group-id": "51",
      "type": "enum",
      "values": [
        {
          "description": "Disabled",
          "name": "0"
        },
        {
          "description": "Small fumes",
          "name": "1"
        },
        {
          "description": "Large fumes",
          "name": "2"
        },
        {
          "description": "Like 1 but adjusted by HyperNewbie",
          "name": "3"
        },
        {
          "description": "Like 2 but adjusted by HyperNewbie",
          "name": "4"
        }
      ]
    },
    "gl_textureless": {
      "default": "0",
      "desc": "Toggles between textures and flat colors based on the textures (looks like gl_max_size 1).\nFor custom colors, look for r_drawflat.",
      "group-id": "50",
      "remarks": "The effect varies with picmip/max_size.\nCan not be changed during a match.",
      "type": "boolean",
      "values": [
        {
          "description": "Use world textures.",
          "name": "false"
        },
        {
          "description": "Use flat colors based on the world textures.",
          "name": "true"
        }
      ]
    },
    "gl_texturemode": {
      "default": "GL_LINEAR_MIPMAP_LINEAR",
      "group-id": "50",
      "remarks": "GL_NEAREST* modes are often used with gl_miptexlevel 3.",
      "type": "enum",
      "values": [
        {
          "description": "Linear filtering, no blending.",
          "name": "GL_LINEAR"
        },
        {
          "description": "Trilinear interpolation. Highest quality, lowest performance.",
          "name": "GL_LINEAR_MIPMAP_LINEAR"
        },
        {
          "description": "Bilinear interpolation.",
          "name": "GL_LINEAR_MIPMAP_NEAREST"
        },
        {
          "description": "Point sampled (software-like). Lowest quality, highest performance.",
          "name": "GL_NEAREST"
        },
        {
          "description": "GL_NEAREST but with even more quality for far objects.",
          "name": "GL_NEAREST_MIPMAP_LINEAR"
        },
        {
          "description": "GL_NEAREST but with a bit more quality for far objects.",
          "name": "GL_NEAREST_MIPMAP_NEAREST"
        }
      ]
    },
    "gl_texturemode_viewmodels": {
      "default": "GL_LINEAR",
      "group-id": "50",
      "remarks": "GL_NEAREST* modes are often used with gl_miptexlevel 3.",
      "type": "enum",
      "values": [
        {
          "description": "Linear filtering, no blending.",
          "name": "GL_LINEAR"
        },
        {
          "description": "Trilinear interpolation. Highest quality, lowest performance.",
          "name": "GL_LINEAR_MIPMAP_LINEAR"
        },
        {
          "description": "Bilinear interpolation.",
          "name": "GL_LINEAR_MIPMAP_NEAREST"
        },
        {
          "description": "Point sampled (software-like). Lowest quality, highest performance.",
          "name": "GL_NEAREST"
        },
        {
          "description": "GL_NEAREST but with even more quality for far objects.",
          "name": "GL_NEAREST_MIPMAP_LINEAR"
        },
        {
          "description": "GL_NEAREST but with a bit more quality for far objects.",
          "name": "GL_NEAREST_MIPMAP_NEAREST"
        }
      ]
    },
    "gl_triplebuffer": {
      "default": "1",
      "desc": "Triple buffering of HUD graphics. If you have problems with screen graphics, turn this on.",
      "group-id": "35",
      "remarks": "This has nothing to do with 3D rendering, it will not increase graphics \"lag\" or anything like that. It only affects 2D HUD graphics.",
      "type": "boolean"
    },
    "gl_turb_effects": {
      "default": "1",
      "desc": "Controls if shotgun/nailgun impact points will spawn bubbles underwater.",
      "group-id": "51",
      "remarks": "Requires QMB particles to be enabled (corresponding gl_particle_xxx option enabled).",
      "type": "boolean"
    },
    "gl_turb_fire": {
      "default": "1",
      "desc": "Controls if explosions/fire will spawn bubbles underwater.",
      "group-id": "51",
      "remarks": "Requires QMB particles to be enabled (corresponding gl_particle_xxx option enabled).",
      "type": "boolean"
    },
    "gl_turb_trails": {
      "default": "0",
      "desc": "This gives rockets/grenades/nails and other things an alternate underwater trail.\nVery nice to have nailgun fights underwater...",
      "group-id": "51",
      "type": "float"
    },
    "gl_turbalpha": {
      "default": "1",
      "desc": "This variable determines the level of opacity for liquids, which requires the use of maps that were VISed with transparent water.\nWhen using maps that have not been VISed in such a way, you have to use \"r_novis 1\".\nIf \"r_novis\" is set to \"1\" or when using a map VISed with transparent water and using setting \"gl_turbalpha\" to a value lower than \"1\", the player will be able to see objects and walls through liquids if the server allows that.\nThis is a very nice feature to have in the game, for more information refer to the \"r_novis\" command.\n\nYou can use any value between \"0\" and \"1\" for \"gl_turbalpha\", here are some examples:",
      "group-id": "51",
      "type": "float",
      "values": [
        {
          "description": "Transparent.",
          "name": "0.00"
        },
        {
          "description": "Low opacity.",
          "name": "0.25"
        },
        {
          "description": "Medium opacity.",
          "name": "0.50"
        },
        {
          "description": "High opacity.",
          "name": "0.75"
        },
        {
          "description": "Solid.",
          "name": "1.00"
        }
      ]
    },
    "gl_vbo_clientmemory": {
      "default": "0",
      "desc": "Use client memory when rendering dynamic geometry.",
      "group-id": "35",
      "remarks": "No effect unless using compatibility mode.",
      "type": "boolean"
    },
    "gl_weather_rain": {
      "default": "0",
      "desc": "Turns on rain outdoors.\nRain density is equal to whatever gl_weather_rain is set to.",
      "group-id": "51",
      "remarks": "Works on all custom maps except death32c, dakyne and some others.",
      "type": "float"
    },
    "gl_weather_rain_fast": {
      "default": "0",
      "desc": "Adjusts rain effects performance.",
      "group-id": "51",
      "type": "float",
      "values": [
        {
          "description": "Default",
          "name": "0"
        },
        {
          "description": "Turn off all splashes",
          "name": "1"
        },
        {
          "description": "Turn off only water splashes",
          "name": "2"
        }
      ]
    },
    "halflifebsp": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "help_files_dircolor": {
      "desc": "The RGB color of directories in the help browser.",
      "group-id": "25",
      "type": "string",
      "values": [
        {
          "description": "Example: \"255 255 255\"",
          "name": "*"
        }
      ]
    },
    "help_files_filecolor": {
      "desc": "The RGB color for files in the help browser.",
      "group-id": "25",
      "type": "string",
      "values": [
        {
          "description": "Example: \"255 255 255\"",
          "name": "*"
        }
      ]
    },
    "help_files_interline": {
      "desc": "Adjust interlining of file list in /help filebrowser.",
      "group-id": "25",
      "type": "float"
    },
    "help_files_scrollnames": {
      "desc": "Should the filenames in the help browser get scrolled if they don't fit when the file is selected?",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "Don't scroll names",
          "name": "false"
        },
        {
          "description": "Scroll names",
          "name": "true"
        }
      ]
    },
    "help_files_selectedcolor": {
      "desc": "The RGB color of a selected file in the help browser.",
      "group-id": "25",
      "type": "string",
      "values": [
        {
          "description": "Example: \"255 255 255\"",
          "name": "*"
        }
      ]
    },
    "help_files_showdate": {
      "desc": "Shows column displaying file last modification date in /help file browser.",
      "group-id": "25",
      "type": "float"
    },
    "help_files_showsize": {
      "desc": "Shows column displaying file size in /help file browser.",
      "group-id": "25",
      "type": "float"
    },
    "help_files_showstatus": {
      "desc": "Show quick info about selected help file in /help file browser.",
      "group-id": "25",
      "type": "float"
    },
    "help_files_showtime": {
      "desc": "Shows column displaying file last modification time in /help file browser.",
      "group-id": "25",
      "type": "float"
    },
    "help_files_sortmode": {
      "desc": "Switches sorting methods of files /help file browser.",
      "group-id": "25",
      "type": "float"
    },
    "help_files_stripnames": {
      "desc": "Strips filenames of help files.",
      "group-id": "25",
      "type": "float"
    },
    "hostname": {
      "default": "unnamed",
      "desc": "Server variable, changes the name of the server displayed in server browsers and server lists.",
      "group-id": "43",
      "type": "string"
    },
    "hud_ammo1_align": {
      "desc": "Sets align of number of shells for both horizontal and vertical direction.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo1_align_x": {
      "desc": "Sets horizontal align of number of shells.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo1_align_y": {
      "desc": "Sets vertical align of number of shells.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo1_digits": {
      "desc": "Sets number of digits for number of shells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo1_frame": {
      "desc": "Sets frame visibility and style for number of shells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo1_frame_color": {
      "desc": "Defines the color of the background of the ammo1 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo1_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo1_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_ammo1_place": {
      "desc": "Sets relative positioning for number of shells.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo1_pos_x": {
      "desc": "Sets horizontal position of number of shells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo1_pos_y": {
      "desc": "Sets vertical position of number of shells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo1_scale": {
      "desc": "Sets size of number of shells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo1_show": {
      "desc": "Switches showing of number of shells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo1_style": {
      "desc": "Switches graphical style of number of shells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo1_text_color_low": {
      "desc": "Text color when low on shells (only used with style 1 or 3, format: 0-255 0-255 0-255)",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo1_text_color_normal": {
      "desc": "Text color when shell count is normal (only used with style 1 or 3, format: 0-255 0-255 0-255)",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo2_align": {
      "desc": "Sets align of number of nails.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo2_align_x": {
      "desc": "Sets horizontal align of number of nails.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo2_align_y": {
      "desc": "Sets vertical align of number of nails.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo2_digits": {
      "desc": "Sets number of digits for number of nails.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo2_frame": {
      "desc": "Sets frame visibility and style for number of nails.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo2_frame_color": {
      "desc": "Defines the color of the background of the ammo2 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo2_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo2_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_ammo2_place": {
      "desc": "Sets relative positioning for number of nails.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo2_pos_x": {
      "desc": "Sets horizontal position of number of nails.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo2_pos_y": {
      "desc": "Sets vertical position of number of nails.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo2_scale": {
      "desc": "Sets size of number of nails.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo2_show": {
      "desc": "Switches showing of number of nails.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo2_style": {
      "desc": "Switches graphical style of number of nails.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo2_text_color_low": {
      "desc": "Text color when low on nails (only used with style 1 or 3, format: 0-255 0-255 0-255)",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo2_text_color_normal": {
      "desc": "Text color when nail count is normal (only used with style 1 or 3, format: 0-255 0-255 0-255)",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo3_align": {
      "desc": "Sets align of number of rockets.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo3_align_x": {
      "desc": "Sets horizontal align of number of rockets.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo3_align_y": {
      "desc": "Sets vertical align of number of rockets.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo3_digits": {
      "desc": "Sets number of digits for number of rockets.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo3_frame": {
      "desc": "Sets frame visibility and style for number of rockets.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo3_frame_color": {
      "desc": "Defines the color of the background of the ammo3 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo3_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo3_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_ammo3_place": {
      "desc": "Sets relative positioning for number of rockets.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo3_pos_x": {
      "desc": "Sets horizontal position of number of rockets.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo3_pos_y": {
      "desc": "Sets vertical position of number of rockets.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo3_scale": {
      "desc": "Sets size of number of rockets.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo3_show": {
      "desc": "Switches showing of number of rockets.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo3_style": {
      "desc": "Switches graphical style of number of rockets.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo3_text_color_low": {
      "desc": "Text color when low on rockets (only used with style 1 or 3, format: 0-255 0-255 0-255)",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo3_text_color_normal": {
      "desc": "Text color when rocket count is normal (only used with style 1 or 3, format: 0-255 0-255 0-255)",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo4_align": {
      "desc": "Sets align of number of cells.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo4_align_x": {
      "desc": "Sets horizontal align of number of cells.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo4_align_y": {
      "desc": "Sets vertical align of number of cells.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo4_digits": {
      "desc": "Sets number of digits for number of cells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo4_frame": {
      "desc": "Sets frame visibility and style for number of cells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo4_frame_color": {
      "desc": "Defines the color of the background of the ammo4 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo4_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo4_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_ammo4_place": {
      "desc": "Sets relative positioning for number of cells.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo4_pos_x": {
      "desc": "Sets horizontal position of number of cells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo4_pos_y": {
      "desc": "Sets vertical position of number of cells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo4_scale": {
      "desc": "Sets size of number of cells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo4_show": {
      "desc": "Switches showing of number of cells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo4_style": {
      "desc": "Switches graphical style of number of cells.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo4_text_color_low": {
      "desc": "Text color when low on cells (only used with style 1 or 3, format: 0-255 0-255 0-255)",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo4_text_color_normal": {
      "desc": "Text color when cell count is normal (only used with style 1 or 3, format: 0-255 0-255 0-255)",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo_align": {
      "desc": "Sets align of current ammo value.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo_align_x": {
      "desc": "Sets horizontal align of current ammo value.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo_align_y": {
      "desc": "Sets vertical align of current ammo value.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo_digits": {
      "desc": "Sets number of digits for current ammo value.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo_frame": {
      "desc": "Sets frame visibility and style for current ammo value.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo_frame_color": {
      "desc": "Defines the color of the background of the ammo HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_ammo_place": {
      "desc": "Sets relative positioning for current ammo value.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ammo_pos_x": {
      "desc": "Sets horizontal position of current ammo value.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo_pos_y": {
      "desc": "Sets vertical position of current ammo value.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo_scale": {
      "desc": "Sets size of current ammo value.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo_show": {
      "desc": "Switches showing of current ammo value.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ammo_style": {
      "desc": "Switches graphical style of current ammo value.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_align": {
      "desc": "Sets align of armor level.",
      "group-id": "19",
      "type": "string"
    },
    "hud_armor_align_x": {
      "desc": "Sets horizontal align of armor level.",
      "group-id": "19",
      "type": "string"
    },
    "hud_armor_align_y": {
      "desc": "Sets vertical align of armor level.",
      "group-id": "19",
      "type": "string"
    },
    "hud_armor_digits": {
      "desc": "Sets number of digits for armor level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_frame": {
      "desc": "Sets frame visibility and style for armor level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_frame_color": {
      "desc": "Defines the color of the background of the armor HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_armor_hidezero": {
      "desc": "Hide armor number if 0.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_armor_pent_666": {
      "group-id": "19",
      "type": ""
    },
    "hud_armor_place": {
      "desc": "Sets relative positioning for armor level.",
      "group-id": "19",
      "type": "string"
    },
    "hud_armor_pos_x": {
      "desc": "Sets horizontal position of armor level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_pos_y": {
      "desc": "Sets vertical position of armor level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_scale": {
      "desc": "Sets size of armor level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_show": {
      "desc": "Switches showing of armor level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armor_style": {
      "desc": "Switches graphical style of armor level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armordamage_align": {
      "desc": "Sets armordamage HUD element alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "horizontal: left, center, right, before, after\nvertical: top, center, bottom, console, before, after",
          "name": "*"
        }
      ]
    },
    "hud_armordamage_align_x": {
      "desc": "Sets armordamage HUD element horizontal alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "left, center, right, before, after",
          "name": "*"
        }
      ]
    },
    "hud_armordamage_align_y": {
      "desc": "Sets armordamage HUD element vertical alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "top, center, bottom, console, before, after",
          "name": "*"
        }
      ]
    },
    "hud_armordamage_digits": {
      "desc": "Sets highest possible number of digits displayed in HUD element armordamage.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armordamage_duration": {
      "desc": "Sets how long armordamage should be visible after last damage to armor has been done.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Float number",
          "name": "*"
        }
      ]
    },
    "hud_armordamage_frame": {
      "desc": "Sets frame visibility and style for this HUD element.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Adjust background opacity",
          "name": "0.x to 1"
        },
        {
          "description": "Bevelled frame.",
          "name": "2"
        }
      ]
    },
    "hud_armordamage_frame_color": {
      "desc": "Defines the color of the background of the armordamage HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_armordamage_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_armordamage_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_armordamage_place": {
      "desc": "Sets placement for this HUD element. You can align some elements relative to other elements.",
      "group-id": "19",
      "remarks": "First you have to decide, if the element that you are locating now (element B) is to be positioned inside another element (element A) or outside it. See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "to place this element inside element B set this variable to \"@B\", to place it outside B element set this variable to \"B\"",
          "name": "*"
        }
      ]
    },
    "hud_armordamage_pos_x": {
      "desc": "Sets horizontal position of this HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armordamage_pos_y": {
      "desc": "Sets vertical position of this HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_armordamage_scale": {
      "desc": "Sets overall size of this HUD element.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Use positive floating point numbers.",
          "name": "*"
        }
      ]
    },
    "hud_armordamage_show": {
      "desc": "Toggles visibility of this HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw this element",
          "name": "false"
        },
        {
          "description": "Draw this element",
          "name": "true"
        }
      ]
    },
    "hud_armordamage_style": {
      "desc": "Toggles between different numbers styles.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "large font, texture",
          "name": "false"
        },
        {
          "description": "small font, gfxwad",
          "name": "true"
        }
      ]
    },
    "hud_bar_armor_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_bar_armor_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_bar_armor_color_ga": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_color_ga_over": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_color_noarmor": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_color_ra": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_color_unnatural": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_color_ya": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_direction": {
      "desc": "Direction of colored part inside HUD element that designates amount of armor.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "left->right",
          "name": "0"
        },
        {
          "description": "right->left",
          "name": "1"
        },
        {
          "description": "down -> up",
          "name": "2"
        },
        {
          "description": "up -> down",
          "name": "3"
        }
      ]
    },
    "hud_bar_armor_frame": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_height": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_bar_armor_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_bar_armor_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_armor_width": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_bar_health_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_bar_health_color_mega": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_color_nohealth": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_color_normal": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_color_twomega": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_color_unnatural": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_direction": {
      "desc": "Direction of colored part inside HUD element that designates amount of health.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "left->right",
          "name": "0"
        },
        {
          "description": "right->left",
          "name": "1"
        },
        {
          "description": "down -> up",
          "name": "2"
        },
        {
          "description": "up -> down",
          "name": "3"
        }
      ]
    },
    "hud_bar_health_frame": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_height": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_bar_health_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_bar_health_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_bar_health_width": {
      "group-id": "19",
      "type": ""
    },
    "hud_clock_align_x": {
      "desc": "Sets horizontal align of clock.",
      "group-id": "19",
      "type": "string"
    },
    "hud_clock_align_y": {
      "desc": "Sets vertical align of clock.",
      "group-id": "19",
      "type": "string"
    },
    "hud_clock_big": {
      "desc": "Switches unsing larger version of clock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_clock_blink": {
      "desc": "Switches blinking colon of clock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_clock_content": {
      "desc": "Controls what time to display.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Local system time",
          "name": "0"
        },
        {
          "description": "Client uptime",
          "name": "1"
        },
        {
          "description": "Time spent on server",
          "name": "2"
        }
      ]
    },
    "hud_clock_format": {
      "desc": "Controls in what format the clock is displayed.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "24hr time with seconds",
          "name": "0"
        },
        {
          "description": "12hr time (AM/PM) without seconds",
          "name": "1"
        },
        {
          "description": "12hr time (AM/PM) with seconds",
          "name": "2"
        },
        {
          "description": "24hr time without seconds",
          "name": "3"
        }
      ]
    },
    "hud_clock_frame": {
      "desc": "Sets frame visibility and style for clock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_clock_frame_color": {
      "desc": "Defines the color of the background of the clock HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_clock_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_clock_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_clock_place": {
      "desc": "Sets relative positioning for clock.",
      "group-id": "19",
      "type": "string"
    },
    "hud_clock_pos_x": {
      "desc": "Sets horizontal position of clock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_clock_pos_y": {
      "desc": "Sets vertical position of clock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_clock_scale": {
      "desc": "Size of the clock HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_clock_show": {
      "desc": "Switches showing of clock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_clock_style": {
      "desc": "Switches graphical style of clock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_democlock_align_x": {
      "desc": "Vertical alignment of the democlock HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_democlock_align_y": {
      "desc": "Vertical alignment of the democlock HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_democlock_big": {
      "desc": "Enables larger version of the democlock.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_democlock_blink": {
      "desc": "Enables democlock colon blinking.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_democlock_frame": {
      "desc": "Opacity of the background of the democlock HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_democlock_frame_color": {
      "desc": "Defines the color of the background of the democlock HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_democlock_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_democlock_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_democlock_place": {
      "desc": "Placement of the democlock HUD element. HUD elements can be place into various screen areas or other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_democlock_pos_x": {
      "desc": "Horizontal relative position of the democlock HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_democlock_pos_y": {
      "desc": "Vertical relative position of the democlock HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_democlock_scale": {
      "desc": "Size of the democlock HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_democlock_show": {
      "desc": "Visibility of the democlock HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_democlock_style": {
      "desc": "Toggles democlock render styles.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_digits_trim": {
      "desc": "Changes how large numbers are treated in Head Up Display.",
      "group-id": "19",
      "remarks": "Applies to all HUD elements with 'digits' property.",
      "type": "enum",
      "values": [
        {
          "description": "10030 will be displayed as \"999\" with hud_*_digits 3",
          "name": "0"
        },
        {
          "description": "10030 will be displayed as \"030\" with hud_*_digits 3",
          "name": "1"
        },
        {
          "description": "10030 will be displayed as \"100\" with hud_*_digits 3",
          "name": "2"
        }
      ]
    },
    "hud_editor_allowalign": {
      "desc": "Should aligning be allowed when using the HUD editor?",
      "group-id": "19",
      "remarks": "This can also be toggled when in the HUD editor by using the F3 button.",
      "type": "boolean",
      "values": [
        {
          "description": "Dissallow aligning in the HUD editor",
          "name": "false"
        },
        {
          "description": "Allow aligning in the HUD editor (alt + mouse 1)",
          "name": "true"
        }
      ]
    },
    "hud_editor_allowmove": {
      "desc": "Allow moving HUD elements when in HUD editor mode.",
      "group-id": "19",
      "remarks": "This can also be toggled when in the HUD editor by using the F1 button.",
      "type": "boolean",
      "values": [
        {
          "description": "Dissalow moving objects in the HUD editor",
          "name": "false"
        },
        {
          "description": "Allow moving objects in the HUD editor.",
          "name": "true"
        }
      ]
    },
    "hud_editor_allowplace": {
      "desc": "Allow placing HUD elements in HUD editor mode.",
      "group-id": "19",
      "remarks": "This can also be toggled when in the HUD editor by using the F4 button.",
      "type": "boolean",
      "values": [
        {
          "description": "Dissallow placing HUD elements in the HUD editor",
          "name": "false"
        },
        {
          "description": "Allow placing HUD elements in the HUD editor (ctrl + mouse 1)",
          "name": "true"
        }
      ]
    },
    "hud_editor_allowresize": {
      "desc": "Allow resizing HUD elements in HUD editor mode.",
      "group-id": "19",
      "remarks": "This can also be toggled when in the HUD editor by using the F2 button.",
      "type": "boolean",
      "values": [
        {
          "description": "Dissalow resizing HUD elements in the HUD editor",
          "name": "false"
        },
        {
          "description": "Allow resizing HUD elements in the HUD editor",
          "name": "true"
        }
      ]
    },
    "hud_face_align_x": {
      "desc": "Sets horizontal align of player face.",
      "group-id": "19",
      "type": "string"
    },
    "hud_face_align_y": {
      "desc": "Sets vertical align of player face.",
      "group-id": "19",
      "type": "string"
    },
    "hud_face_frame": {
      "desc": "Sets frame visibility and style for player face.",
      "group-id": "19",
      "type": "float"
    },
    "hud_face_frame_color": {
      "desc": "Defines the color of the background of the face HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_face_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_face_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_face_place": {
      "desc": "Sets relative positioning for player face.",
      "group-id": "19",
      "type": "string"
    },
    "hud_face_pos_x": {
      "desc": "Sets horizontal position of player face.",
      "group-id": "19",
      "type": "float"
    },
    "hud_face_pos_y": {
      "desc": "Sets vertical position of player face.",
      "group-id": "19",
      "type": "float"
    },
    "hud_face_scale": {
      "desc": "Sets size of player face.",
      "group-id": "19",
      "type": "float"
    },
    "hud_face_show": {
      "desc": "Switches showing of player face.",
      "group-id": "19",
      "type": "float"
    },
    "hud_fps_align_x": {
      "desc": "Sets horizontal align of fps counter.",
      "group-id": "19",
      "type": "string"
    },
    "hud_fps_align_y": {
      "desc": "Sets vertical align of fps counter.",
      "group-id": "19",
      "type": "string"
    },
    "hud_fps_decimals": {
      "desc": "How many decimal number should the FPS HUD element contain.",
      "group-id": "29",
      "remarks": "Code says always three decimals.",
      "type": "integer"
    },
    "hud_fps_drop": {
      "desc": "Sets the value which will trigger displaying the fps (requires hud_fps_style 2 or 3). For example, with value hud_fps_drop 70, the fps will only be displayed if it drops to 70 or below. For fps values greater than 70, the fps will not be displayed.\nCan also be set to a negative value, interpretted as relative to cl_maxfps",
      "group-id": "19",
      "type": "float"
    },
    "hud_fps_frame": {
      "desc": "Sets frame visibility and style for fps counter.",
      "group-id": "19",
      "type": "float"
    },
    "hud_fps_frame_color": {
      "desc": "Defines the color of the background of the fps HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_fps_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_fps_min_reset_interval": {
      "group-id": "8",
      "type": ""
    },
    "hud_fps_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_fps_place": {
      "desc": "Sets relative positioning for fps counter.",
      "group-id": "19",
      "type": "string"
    },
    "hud_fps_pos_x": {
      "desc": "Sets horizontal position of fps counter.",
      "group-id": "19",
      "type": "float"
    },
    "hud_fps_pos_y": {
      "desc": "Sets vertical position of fps counter.",
      "group-id": "19",
      "type": "float"
    },
    "hud_fps_show": {
      "desc": "Switches showing of fps counter.",
      "group-id": "19",
      "type": "float"
    },
    "hud_fps_show_min": {
      "desc": "Switches showing of fps counter.",
      "group-id": "19",
      "type": "float"
    },
    "hud_fps_style": {
      "desc": "Alters how and when the fps is drawn. Please see hud_fps_drop for styles 2 and 3.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "white text",
          "name": "0"
        },
        {
          "description": "brown text",
          "name": "1"
        },
        {
          "description": "white text, fps will show only if the client's fps is less than or equal to hud_fps_drop value",
          "name": "2"
        },
        {
          "description": "brown text, same as 2",
          "name": "3"
        }
      ]
    },
    "hud_fps_title": {
      "desc": "Switches displaying the text \"fps\" of fps counter.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_align_x": {
      "desc": "Sets horizontal align of frags bar.",
      "group-id": "19",
      "type": "string"
    },
    "hud_frags_align_y": {
      "desc": "Sets vertical align of frags bar.",
      "group-id": "19",
      "type": "string"
    },
    "hud_frags_bignum": {
      "desc": "Changes the scale of the fragcount number.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "If this is 0 the fragcount will use the normal charset. If it's above 0 it will scale a big number character instead.",
          "name": "*"
        }
      ]
    },
    "hud_frags_cell_height": {
      "desc": "Sets cell height of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_cell_width": {
      "desc": "Sets cell width of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_colors_alpha": {
      "desc": "Sets the opacity of the players colors for the frags hud element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_cols": {
      "desc": "Sets number of columns of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_extra_spec_info": {
      "desc": "Enables to see when people have rocket launchers, lightning guns, powerups and how much health and armor they have using icons next to the frags. Works while watching MVD demo.",
      "group-id": "19",
      "type": "string",
      "values": [
        {
          "description": "No extra information is shown.",
          "name": "0"
        },
        {
          "description": "Show RL, LG, powerups armor and health.",
          "name": "ALL"
        },
        {
          "description": "Show powerups, armor and health. (No RLs/LGs)",
          "name": "POWERUPARMORHEALTH"
        },
        {
          "description": "Show RL, LG, powerups and health. (No armor)",
          "name": "RLLGPOWERUPHEALTH"
        },
        {
          "description": "Show RL, LG, powerups and armor. (No health)",
          "name": "RLLGPOWERUPARMOR"
        },
        {
          "description": "Show RL, LG, armor and health. (No powerups)",
          "name": "RLLGARMORHEALTH"
        },
        {
          "description": "Show only powerups.",
          "name": "POWERUP"
        },
        {
          "description": "Show only health.",
          "name": "HEALTH"
        },
        {
          "description": "Show only armor.",
          "name": "ARMOR"
        },
        {
          "description": "Show horizontal health meter.",
          "name": "HMETER"
        },
        {
          "description": "Show horizontal power meter.",
          "name": "PMETER"
        }
      ]
    },
    "hud_frags_fliptext": {
      "desc": "Toggles alignment of players nick and team name in frags HUD element.",
      "group-id": "19",
      "remarks": "Use 'frags shownames 1' and/or 'frags showteams 1' to show names and team names of players.",
      "type": "integer",
      "values": [
        {
          "description": "Rows aligned to the left side, names and team tags are on the right side of frag counts.",
          "name": "0"
        },
        {
          "description": "Rows aligned to the right side, names and team tags are on the left side of frag counts.",
          "name": "1"
        },
        {
          "description": "Rows aligned toward the inside of each column.",
          "name": "2"
        },
        {
          "description": "Rows aligned toward the outside of each column.",
          "name": "3"
        }
      ]
    },
    "hud_frags_frame": {
      "desc": "Sets frame visibility and style for frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_frame_color": {
      "desc": "Defines the color of the background of the frags HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_frags_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_maxname": {
      "desc": "The max number of characters to use for displaying the names in the frags element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_frags_notintp": {
      "group-id": "19",
      "type": ""
    },
    "hud_frags_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_frags_padtext": {
      "desc": "Toggles text padding in 'frags' HUD element.",
      "group-id": "19",
      "remarks": "Use 'frags shownames 1' and/or 'frags showteams 1'.",
      "type": "boolean",
      "values": [
        {
          "description": "No spaces between text fields.",
          "name": "false"
        },
        {
          "description": "Adds padding so frags, names, team tags aligned into columns.",
          "name": "true"
        }
      ]
    },
    "hud_frags_place": {
      "desc": "Sets relative positioning for frags bar.",
      "group-id": "19",
      "type": "string"
    },
    "hud_frags_pos_x": {
      "desc": "Sets horizontal position of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_pos_y": {
      "desc": "Sets vertical position of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_rows": {
      "desc": "Sets number of rows in frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_show": {
      "desc": "Switches showing of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_shownames": {
      "desc": "Draws players names next to frag counts in 'frags' HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Don't display players' names.",
          "name": "false"
        },
        {
          "description": "Display players' names.",
          "name": "true"
        }
      ]
    },
    "hud_frags_showself_always": {
      "desc": "Forces the client to show the part of frags table where you are.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Display highest frags only.",
          "name": "false"
        },
        {
          "description": "Display the part of table where you are.",
          "name": "true"
        }
      ]
    },
    "hud_frags_showteams": {
      "desc": "Draws players' team tags next to frag counts in 'frags' HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display players' team tags.",
          "name": "false"
        },
        {
          "description": "Display players' team tags.",
          "name": "true"
        }
      ]
    },
    "hud_frags_space_x": {
      "desc": "Sets vertical spacing of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_space_y": {
      "desc": "Sets horizontal spacing of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_strip": {
      "desc": "Switches stripped version of frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_style": {
      "desc": "Sets drawing style of 'frags' HUD element.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Golden brackets around your own frags field.",
          "name": "0"
        },
        {
          "description": "Arrow pointing to your own frags field.",
          "name": "1"
        },
        {
          "description": "Red rectangle around your own frags fiels.",
          "name": "2"
        },
        {
          "description": "No pointer or indicator.",
          "name": "3"
        },
        {
          "description": "Sets background color for your own field to 'teamcolor'.",
          "name": "4"
        },
        {
          "description": "Sets background color for all field to teamcolors enemycolors, all fields 50% transparent, your own field not transparent. Red rectangle around your own field including name and team tag.",
          "name": "5"
        },
        {
          "description": "Red rectangle around your own field including name and team tag. Background color only for your own field and set to 'teamcolor'.",
          "name": "6"
        },
        {
          "description": "Background color for whole table 50% transparent red, your own field not transparent.",
          "name": "7"
        },
        {
          "description": "Red background color only for your own field including name and team tag.",
          "name": "8"
        }
      ]
    },
    "hud_frags_teamsort": {
      "desc": "Switches sorting by teams in frags bar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_frags_vertical": {
      "desc": "Switches vertical rendering of frags bar.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "No vertical rendering.",
          "name": "0"
        },
        {
          "description": "Legacy vertical rendering.",
          "name": "1"
        },
        {
          "description": "New vertical rendering: split columns evenly based on number of players.",
          "name": "2"
        }
      ]
    },
    "hud_gameclock_align_x": {
      "desc": "Vertical alignment of the gameclock HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gameclock_align_y": {
      "desc": "Vertical alignment of the gameclock HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gameclock_big": {
      "desc": "Draw the text of the gameclock using big numbers.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Draw the gameclock using the normal charset",
          "name": "false"
        },
        {
          "description": "Draw the gameclock with big numbers.",
          "name": "true"
        }
      ]
    },
    "hud_gameclock_blink": {
      "desc": "Blink the colon on the gameclock hud element every second.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Blink the colon.",
          "name": "false"
        },
        {
          "description": "Don't blink the colon.",
          "name": "true"
        }
      ]
    },
    "hud_gameclock_countdown": {
      "desc": "Changes the direction of the game clock (gameclock HUD element)",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Count from 0:00 upwards",
          "name": "false"
        },
        {
          "description": "Countdown from match time to zero",
          "name": "true"
        }
      ]
    },
    "hud_gameclock_frame": {
      "desc": "Opacity of the background of the gameclock HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gameclock_frame_color": {
      "desc": "Defines the color of the background of the gameclock HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gameclock_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gameclock_offset": {
      "desc": "Allows using gameclock in custom mods that don't support standard KT-like clock synchronization.",
      "group-id": "19",
      "remarks": "Some Capture The Flag or Team Fortress mods can take a use of this.",
      "type": "integer"
    },
    "hud_gameclock_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gameclock_place": {
      "desc": "Placement of the gameclock HUD element. HUD elements can be place into various screen areas or other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gameclock_pos_x": {
      "desc": "Horizontal relative position of the gameclock HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gameclock_pos_y": {
      "desc": "Vertical relative position of the gameclock HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gameclock_scale": {
      "desc": "Size of the gameclock HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gameclock_show": {
      "desc": "Visibility of the gameclock HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_gameclock_style": {
      "desc": "Sets the style of the gameclock hud element.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Gameclock is white.",
          "name": "0"
        },
        {
          "description": "Gameclock is red.",
          "name": "1"
        }
      ]
    },
    "hud_gamesummary_format": {
      "default": "RYM myr",
      "desc": "Sets the content of the gamesummary hud element.",
      "group-id": "19",
      "remarks": "MVD playback only.  if the letter is in upper-case, it refers to the first team, otherwise the second.",
      "type": "string",
      "values": [
        {
          "description": "number of megahealths taken",
          "name": "m"
        },
        {
          "description": "number of red armors taken",
          "name": "r"
        },
        {
          "description": "number of yellow armors taken",
          "name": "y"
        },
        {
          "description": "number of green armors taken",
          "name": "g"
        },
        {
          "description": "number of players with rocket launchers on current team",
          "name": "o"
        },
        {
          "description": "number of players with lightning gun on current team",
          "name": "l"
        },
        {
          "description": "number of players with rocket launcher or lightning gun on current team",
          "name": "w"
        },
        {
          "description": "number of quads taken",
          "name": "q"
        },
        {
          "description": "number of pents taken",
          "name": "p"
        },
        {
          "description": "number of rings taken",
          "name": "e"
        }
      ]
    },
    "hud_group1_align_x": {
      "desc": "Sets horizontal align of grouping object 1.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group1_align_y": {
      "desc": "Sets vertical align of grouping object 1.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group1_frame": {
      "desc": "Sets frame visibility and style for grouping object 1.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group1_frame_color": {
      "desc": "Defines the color of the background of the group1 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group1_height": {
      "desc": "Sets vertical size of grouping object 1.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group1_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group1_name": {
      "desc": "Sets name of grouping object 1.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group1_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group1_pic_alpha": {
      "desc": "Transparency level of the background image of the group1 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group1_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group1 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group1_picture": {
      "desc": "Sets background picture of grouping object 1.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group1_place": {
      "desc": "Sets relative positioning for grouping object 1.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group1_pos_x": {
      "desc": "Sets horizontal position of grouping object 1.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group1_pos_y": {
      "desc": "Sets vertical position of grouping object 1.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group1_show": {
      "desc": "Switches showing of grouping object 1.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group1_width": {
      "desc": "Sets horizontal size of grouping object 1.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group2_align_x": {
      "desc": "Sets horizontal align of grouping object 2.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group2_align_y": {
      "desc": "Sets vertical align of grouping object 2.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group2_frame": {
      "desc": "Sets frame visibility and style for grouping object 2.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group2_frame_color": {
      "desc": "Defines the color of the background of the group2 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group2_height": {
      "desc": "Sets vertical size of grouping object 2.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group2_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group2_name": {
      "desc": "Sets name of grouping object 2.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group2_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group2_pic_alpha": {
      "desc": "Transparency level of the background image of the group2 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group2_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group2 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group2_picture": {
      "desc": "Sets background picture of grouping object 2.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group2_place": {
      "desc": "Sets relative positioning for grouping object 2.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group2_pos_x": {
      "desc": "Sets horizontal position of grouping object 2.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group2_pos_y": {
      "desc": "Sets vertical position of grouping object 2.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group2_show": {
      "desc": "Switches showing of grouping object 2.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group2_width": {
      "desc": "Sets horizontal size of grouping object 2.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group3_align_x": {
      "desc": "Sets horizontal align of grouping object 3.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group3_align_y": {
      "desc": "Sets vertical align of grouping object 3.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group3_frame": {
      "desc": "Sets frame visibility and style for grouping object 3.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group3_frame_color": {
      "desc": "Defines the color of the background of the group3 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group3_height": {
      "desc": "Sets vertical size of grouping object 3.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group3_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group3_name": {
      "desc": "Sets name of grouping object 3.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group3_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group3_pic_alpha": {
      "desc": "Transparency level of the background image of the group3 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group3_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group3 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group3_picture": {
      "desc": "Sets background picture of grouping object 3.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group3_place": {
      "desc": "Sets relative positioning for grouping object 3.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group3_pos_x": {
      "desc": "Sets horizontal position of grouping object 3.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group3_pos_y": {
      "desc": "Sets vertical position of grouping object 3.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group3_show": {
      "desc": "Switches showing of grouping object 3.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group3_width": {
      "desc": "Sets horizontal size of grouping object 3.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group4_align_x": {
      "desc": "Sets horizontal align of grouping object 4.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group4_align_y": {
      "desc": "Sets vertical align of grouping object 4.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group4_frame": {
      "desc": "Sets frame visibility and style for grouping object 4.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group4_frame_color": {
      "desc": "Defines the color of the background of the group4 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group4_height": {
      "desc": "Sets vertical size of grouping object 4.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group4_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group4_name": {
      "desc": "Sets name of grouping object 4.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group4_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group4_pic_alpha": {
      "desc": "Transparency level of the background image of the group4 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group4_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group4 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group4_picture": {
      "desc": "Sets background picture of grouping object 4.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group4_place": {
      "desc": "Sets relative positioning for grouping object 4.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group4_pos_x": {
      "desc": "Sets horizontal position of grouping object 4.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group4_pos_y": {
      "desc": "Sets vertical position of grouping object 4.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group4_show": {
      "desc": "Switches showing of grouping object 4.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group4_width": {
      "desc": "Sets horizontal size of grouping object 4.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group5_align_x": {
      "desc": "Sets horizontal align of grouping object 5.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group5_align_y": {
      "desc": "Sets vertical align of grouping object 5.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group5_frame": {
      "desc": "Sets frame visibility and style for grouping object 5.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group5_frame_color": {
      "desc": "Defines the color of the background of the group5 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group5_height": {
      "desc": "Sets vertical size of grouping object 5.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group5_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group5_name": {
      "desc": "Sets name of grouping object 5.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group5_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group5_pic_alpha": {
      "desc": "Transparency level of the background image of the group5 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group5_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group5 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group5_picture": {
      "desc": "Sets background picture of grouping object 5.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group5_place": {
      "desc": "Sets relative positioning for grouping object 5.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group5_pos_x": {
      "desc": "Sets horizontal position of grouping object 5.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group5_pos_y": {
      "desc": "Sets vertical position of grouping object 5.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group5_show": {
      "desc": "Switches showing of grouping object 5.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group5_width": {
      "desc": "Sets horizontal size of grouping object 5.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group6_align_x": {
      "desc": "Sets horizontal align of grouping object 6.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group6_align_y": {
      "desc": "Sets vertical align of grouping object 6.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group6_frame": {
      "desc": "Sets frame visibility and style for grouping object 6.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group6_frame_color": {
      "desc": "Defines the color of the background of the group6 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group6_height": {
      "desc": "Sets vertical size of grouping object 6.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group6_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group6_name": {
      "desc": "Sets name of grouping object 6.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group6_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group6_pic_alpha": {
      "desc": "Transparency level of the background image of the group6 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group6_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group6 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group6_picture": {
      "desc": "Sets background picture of grouping object 6.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group6_place": {
      "desc": "Sets relative positioning for grouping object 6.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group6_pos_x": {
      "desc": "Sets horizontal position of grouping object 6.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group6_pos_y": {
      "desc": "Sets vertical position of grouping object 6.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group6_show": {
      "desc": "Switches showing of grouping object 6.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group6_width": {
      "desc": "Sets horizontal size of grouping object 6.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group7_align_x": {
      "desc": "Sets horizontal align of grouping object 7.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group7_align_y": {
      "desc": "Sets vertical align of grouping object 7.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group7_frame": {
      "desc": "Sets frame visibility and style for grouping object 7.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group7_frame_color": {
      "desc": "Defines the color of the background of the group7 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group7_height": {
      "desc": "Sets vertical size of grouping object 7.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group7_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group7_name": {
      "desc": "Sets name of grouping object 7.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group7_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group7_pic_alpha": {
      "desc": "Transparency level of the background image of the group7 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group7_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group7 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group7_picture": {
      "desc": "Sets background picture of grouping object 7.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group7_place": {
      "desc": "Sets relative positioning for grouping object 7.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group7_pos_x": {
      "desc": "Sets horizontal position of grouping object 7.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group7_pos_y": {
      "desc": "Sets vertical position of grouping object 7.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group7_show": {
      "desc": "Switches showing of grouping object 7.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group7_width": {
      "desc": "Sets horizontal size of grouping object 7.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group8_align_x": {
      "desc": "Sets horizontal align of grouping object 8.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group8_align_y": {
      "desc": "Sets vertical align of grouping object 8.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group8_frame": {
      "desc": "Sets frame visibility and style for grouping object 8.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group8_frame_color": {
      "desc": "Defines the color of the background of the group8 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group8_height": {
      "desc": "Sets vertical size of grouping object 8.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group8_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group8_name": {
      "desc": "Sets name of grouping object 8.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group8_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group8_pic_alpha": {
      "desc": "Transparency level of the background image of the group8 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group8_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group8 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group8_picture": {
      "desc": "Sets background picture of grouping object 8.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group8_place": {
      "desc": "Sets relative positioning for grouping object 8.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group8_pos_x": {
      "desc": "Sets horizontal position of grouping object 8.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group8_pos_y": {
      "desc": "Sets vertical position of grouping object 8.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group8_show": {
      "desc": "Switches showing of grouping object 8.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group8_width": {
      "desc": "Sets horizontal size of grouping object 8.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group9_align_x": {
      "desc": "Sets horizontal align of grouping object 9.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group9_align_y": {
      "desc": "Sets vertical align of grouping object 9.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group9_frame": {
      "desc": "Sets frame visibility and style for grouping object 9.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group9_frame_color": {
      "desc": "Defines the color of the background of the group9 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group9_height": {
      "desc": "Sets vertical size of grouping object 9.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group9_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_group9_name": {
      "desc": "Sets name of grouping object 9.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group9_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group9_pic_alpha": {
      "desc": "Transparency level of the background image of the group9 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group9_pic_scalemode": {
      "desc": "Changes the style how the background picture is aligned and stretched for the group9 HUD element. Values from 0 to 5 are supported. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_group9_picture": {
      "desc": "Sets background picture of grouping object 9.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group9_place": {
      "desc": "Sets relative positioning for grouping object 9.",
      "group-id": "19",
      "type": "string"
    },
    "hud_group9_pos_x": {
      "desc": "Sets horizontal position of grouping object 9.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group9_pos_y": {
      "desc": "Sets vertical position of grouping object 9.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group9_show": {
      "desc": "Switches showing of grouping object 9.",
      "group-id": "19",
      "type": "float"
    },
    "hud_group9_width": {
      "desc": "Sets horizontal size of grouping object 9.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun2_align_x": {
      "desc": "Sets horizontal align of shotgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun2_align_y": {
      "desc": "Sets vertical align of shotgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun2_frame": {
      "desc": "Sets frame visibility and style for shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun2_frame_color": {
      "desc": "Defines the color of the background of the gun2 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun2_frame_hide": {
      "desc": "Hide the frame unless you have the weapon.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun2_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gun2_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun2_place": {
      "desc": "Sets relative positioning for shotgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun2_pos_x": {
      "desc": "Sets horizontal position of shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun2_pos_y": {
      "desc": "Sets vertical position of shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun2_scale": {
      "desc": "Sets size of shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun2_show": {
      "desc": "Switches showing of shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun2_style": {
      "desc": "Switches the graphical style of the shotgun icon.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Picture",
          "name": "0"
        },
        {
          "description": "Text: gold inactive, white active",
          "name": "1"
        },
        {
          "description": "Numbers: gold inactive, white active",
          "name": "2"
        },
        {
          "description": "Text: white inactive, gold active",
          "name": "3"
        },
        {
          "description": "Numbers: white inactive, gold active",
          "name": "4"
        },
        {
          "description": "Text: value of tp_name_sg active, gold inactive",
          "name": "5"
        },
        {
          "description": "Text: white active, value of tp_name_sg inactive",
          "name": "6"
        },
        {
          "description": "Text: value of tp_name_sg active, white inactive",
          "name": "7"
        },
        {
          "description": "Text: gold active, value of tp_name_sg inactive",
          "name": "8"
        }
      ]
    },
    "hud_gun3_align_x": {
      "desc": "Sets horizontal align of super shotgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun3_align_y": {
      "desc": "Sets vertical align of super shotgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun3_frame": {
      "desc": "Sets frame visibility and style for super shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun3_frame_color": {
      "desc": "Defines the color of the background of the gun3 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun3_frame_hide": {
      "desc": "Hide the frame unless you have the weapon.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun3_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gun3_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun3_place": {
      "desc": "Sets relative positioning for super shotgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun3_pos_x": {
      "desc": "Sets horizontal position of super shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun3_pos_y": {
      "desc": "Sets vertical position of super shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun3_scale": {
      "desc": "Sets size of super shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun3_show": {
      "desc": "Switches showing of super shotgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun3_style": {
      "desc": "Switches the graphical style of the super shotgun icon.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Picture",
          "name": "0"
        },
        {
          "description": "Text: gold inactive, white active",
          "name": "1"
        },
        {
          "description": "Numbers: gold inactive, white active",
          "name": "2"
        },
        {
          "description": "Text: white inactive, gold active",
          "name": "3"
        },
        {
          "description": "Numbers: white inactive, gold active",
          "name": "4"
        },
        {
          "description": "Text: value of tp_name_ssg active, gold inactive",
          "name": "5"
        },
        {
          "description": "Text: white active, value of tp_name_ssg inactive",
          "name": "6"
        },
        {
          "description": "Text: value of tp_name_ssg active, white inactive",
          "name": "7"
        },
        {
          "description": "Text: gold active, value of tp_name_ssg inactive",
          "name": "8"
        }
      ]
    },
    "hud_gun4_align_x": {
      "desc": "Sets horizontal align of nailgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun4_align_y": {
      "desc": "Sets vertical align of nailgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun4_frame": {
      "desc": "Sets frame visibility and style for nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun4_frame_color": {
      "desc": "Defines the color of the background of the gun4 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun4_frame_hide": {
      "desc": "Hide the frame unless you have the weapon.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun4_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gun4_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun4_place": {
      "desc": "Sets relative positioning for nailgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun4_pos_x": {
      "desc": "Sets horizontal position of nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun4_pos_y": {
      "desc": "Sets vertical position of nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun4_scale": {
      "desc": "Sets size of nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun4_show": {
      "desc": "Switches showing of nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun4_style": {
      "desc": "Switches the graphical style of the nailgun icon.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Picture",
          "name": "0"
        },
        {
          "description": "Text: gold inactive, white active",
          "name": "1"
        },
        {
          "description": "Numbers: gold inactive, white active",
          "name": "2"
        },
        {
          "description": "Text: white inactive, gold active",
          "name": "3"
        },
        {
          "description": "Numbers: white inactive, gold active",
          "name": "4"
        },
        {
          "description": "Text: value of tp_name_ng active, gold inactive",
          "name": "5"
        },
        {
          "description": "Text: white active, value of tp_name_ng inactive",
          "name": "6"
        },
        {
          "description": "Text: value of tp_name_ng active, white inactive",
          "name": "7"
        },
        {
          "description": "Text: gold active, value of tp_name_ng inactive",
          "name": "8"
        }
      ]
    },
    "hud_gun5_align_x": {
      "desc": "Sets horizontal align of super nailgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun5_align_y": {
      "desc": "Sets vertical align of super nailgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun5_frame": {
      "desc": "Sets frame visibility and style for super nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun5_frame_color": {
      "desc": "Defines the color of the background of the gun5 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun5_frame_hide": {
      "desc": "Hide the frame unless you have the weapon.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun5_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gun5_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun5_place": {
      "desc": "Sets relative positioning for super nailgun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun5_pos_x": {
      "desc": "Sets horizontal position of super nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun5_pos_y": {
      "desc": "Sets vertical position of super nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun5_scale": {
      "desc": "Sets size of super nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun5_show": {
      "desc": "Switches showing of super nailgun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun5_style": {
      "desc": "Switches the graphical style of the super nailgun icon.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Picture",
          "name": "0"
        },
        {
          "description": "Text: gold inactive, white active",
          "name": "1"
        },
        {
          "description": "Numbers: gold inactive, white active",
          "name": "2"
        },
        {
          "description": "Text: white inactive, gold active",
          "name": "3"
        },
        {
          "description": "Numbers: white inactive, gold active",
          "name": "4"
        },
        {
          "description": "Text: value of tp_name_sng active, gold inactive",
          "name": "5"
        },
        {
          "description": "Text: white active, value of tp_name_sng inactive",
          "name": "6"
        },
        {
          "description": "Text: value of tp_name_sng active, white inactive",
          "name": "7"
        },
        {
          "description": "Text: gold active, value of tp_name_sng inactive",
          "name": "8"
        }
      ]
    },
    "hud_gun6_align_x": {
      "desc": "Sets horizontal align of grenade launcher icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun6_align_y": {
      "desc": "Sets vertical align of grenade launcher icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun6_frame": {
      "desc": "Sets frame visibility and style for grenade launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun6_frame_color": {
      "desc": "Defines the color of the background of the gun6 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun6_frame_hide": {
      "desc": "Hide the frame unless you have the weapon.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun6_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gun6_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun6_place": {
      "desc": "Sets relative positioning for grenade launcher icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun6_pos_x": {
      "desc": "Sets horizontal position of grenade launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun6_pos_y": {
      "desc": "Sets vertical position of grenade launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun6_scale": {
      "desc": "Sets size of grenade launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun6_show": {
      "desc": "Switches showing of grenade launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun6_style": {
      "desc": "Switches the graphical style of the grenade launcher icon.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Picture",
          "name": "0"
        },
        {
          "description": "Text: gold inactive, white active",
          "name": "1"
        },
        {
          "description": "Numbers: gold inactive, white active",
          "name": "2"
        },
        {
          "description": "Text: white inactive, gold active",
          "name": "3"
        },
        {
          "description": "Numbers: white inactive, gold active",
          "name": "4"
        },
        {
          "description": "Text: value of tp_name_gl active, gold inactive",
          "name": "5"
        },
        {
          "description": "Text: white active, value of tp_name_gl inactive",
          "name": "6"
        },
        {
          "description": "Text: value of tp_name_gl active, white inactive",
          "name": "7"
        },
        {
          "description": "Text: gold active, value of tp_name_gl inactive",
          "name": "8"
        }
      ]
    },
    "hud_gun7_align_x": {
      "desc": "Sets horizontal align of rocket launcher icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun7_align_y": {
      "desc": "Sets vertical align of rocket launcher icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun7_frame": {
      "desc": "Sets frame visibility and style for rocket launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun7_frame_color": {
      "desc": "Defines the color of the background of the gun7 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun7_frame_hide": {
      "desc": "Hide the frame unless you have the weapon.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun7_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gun7_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun7_place": {
      "desc": "Sets relative positioning for rocket launcher icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun7_pos_x": {
      "desc": "Sets horizontal position of rocket launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun7_pos_y": {
      "desc": "Sets vertical position of rocket launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun7_scale": {
      "desc": "Sets size of rocket launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun7_show": {
      "desc": "Switches showing of rocket launcher icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun7_style": {
      "desc": "Switches the graphical style of the rocket launcher icon.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Picture",
          "name": "0"
        },
        {
          "description": "Text: gold inactive, white active",
          "name": "1"
        },
        {
          "description": "Numbers: gold inactive, white active",
          "name": "2"
        },
        {
          "description": "Text: white inactive, gold active",
          "name": "3"
        },
        {
          "description": "Numbers: white inactive, gold active",
          "name": "4"
        },
        {
          "description": "Text: value of tp_name_rl active, gold inactive",
          "name": "5"
        },
        {
          "description": "Text: white active, value of tp_name_rl inactive",
          "name": "6"
        },
        {
          "description": "Text: value of tp_name_rl active, white inactive",
          "name": "7"
        },
        {
          "description": "Text: gold active, value of tp_name_rl inactive",
          "name": "8"
        }
      ]
    },
    "hud_gun8_align_x": {
      "desc": "Sets horizontal align of lightning gun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun8_align_y": {
      "desc": "Sets vertical align of lightning gun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun8_frame": {
      "desc": "Sets frame visibility and style for lightning gun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun8_frame_color": {
      "desc": "Defines the color of the background of the gun8 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun8_frame_hide": {
      "desc": "Hide the frame unless you have the weapon.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun8_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gun8_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun8_place": {
      "desc": "Sets relative positioning for lightning gun icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun8_pos_x": {
      "desc": "Sets horizontal position of lightning gun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun8_pos_y": {
      "desc": "Sets vertical position of lightning gun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun8_scale": {
      "desc": "Sets size of lightning gun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun8_show": {
      "desc": "Switches showing of lightning gun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun8_style": {
      "desc": "Switches the graphical style of the lightning gun icon.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Picture",
          "name": "0"
        },
        {
          "description": "Text: gold inactive, white active",
          "name": "1"
        },
        {
          "description": "Numbers: gold inactive, white active",
          "name": "2"
        },
        {
          "description": "Text: white inactive, gold active",
          "name": "3"
        },
        {
          "description": "Numbers: white inactive, gold active",
          "name": "4"
        },
        {
          "description": "Text: value of tp_name_lg active, gold inactive",
          "name": "5"
        },
        {
          "description": "Text: white active, value of tp_name_lg inactive",
          "name": "6"
        },
        {
          "description": "Text: value of tp_name_lg active, white inactive",
          "name": "7"
        },
        {
          "description": "Text: gold active, value of tp_name_lg inactive",
          "name": "8"
        }
      ]
    },
    "hud_gun8_wide": {
      "desc": "Switches wide and short of version of lightning gun icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun_align_x": {
      "desc": "Sets horizontal align of current weapon icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun_align_y": {
      "desc": "Sets vertical align of current weapon icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun_frame": {
      "desc": "Sets frame visibility and style for current weapon icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun_frame_color": {
      "desc": "Defines the color of the background of the gun HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_gun_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_gun_place": {
      "desc": "Sets relative positioning for current weapon icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_gun_pos_x": {
      "desc": "Sets horizontal position of current weapon icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun_pos_y": {
      "desc": "Sets vertical position of current weapon icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun_scale": {
      "desc": "Sets size of current weapon icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun_show": {
      "desc": "Switches showing of current weapon icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_gun_style": {
      "desc": "Switches graphical style of the current weapon's icon.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Picture",
          "name": "0"
        },
        {
          "description": "Text, white",
          "name": "1"
        },
        {
          "description": "Number, white",
          "name": "2"
        },
        {
          "description": "Text, gold",
          "name": "3"
        },
        {
          "description": "Number, gold",
          "name": "4"
        },
        {
          "description": "Text: value of tp_name_X, where X is the name of the current gun held.",
          "name": "5"
        }
      ]
    },
    "hud_gun_wide": {
      "desc": "Switches between wide and short version of current weapon icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_health_align": {
      "desc": "Sets align of health level.",
      "group-id": "19",
      "type": "string"
    },
    "hud_health_align_x": {
      "desc": "Sets horizontal align of health level.",
      "group-id": "19",
      "type": "string"
    },
    "hud_health_align_y": {
      "desc": "Sets vertical align of health level.",
      "group-id": "19",
      "type": "string"
    },
    "hud_health_digits": {
      "desc": "Sets number of digits for health level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_health_frame": {
      "desc": "Sets frame visibility and style for health level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_health_frame_color": {
      "desc": "Defines the color of the background of the health HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_health_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_health_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_health_place": {
      "desc": "Sets relative positioning for health level.",
      "group-id": "19",
      "type": "string"
    },
    "hud_health_pos_x": {
      "desc": "Sets horizontal position of health level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_health_pos_y": {
      "desc": "Sets vertical position of health level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_health_scale": {
      "desc": "Sets size of health level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_health_show": {
      "desc": "Switches showing of health level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_health_style": {
      "desc": "Switches graphical style of health level.",
      "group-id": "19",
      "type": "float"
    },
    "hud_healthdamage_align": {
      "desc": "Sets healthdamage HUD element alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "horizontal: left, center, right, before, after\nvertical: top, center, bottom, console, before, after",
          "name": "*"
        }
      ]
    },
    "hud_healthdamage_align_x": {
      "desc": "Sets healthdamage HUD element horizontal alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "left, center, right, before, after",
          "name": "*"
        }
      ]
    },
    "hud_healthdamage_align_y": {
      "desc": "Sets healthdamage HUD element vertical alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "top, center, bottom, console, before, after",
          "name": "*"
        }
      ]
    },
    "hud_healthdamage_digits": {
      "desc": "Sets highest possible number of digits displayed in HUD element healthdamage.",
      "group-id": "19",
      "type": "float"
    },
    "hud_healthdamage_duration": {
      "desc": "Sets how long healthdamage should be visible after last damage to health has been done.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Float number",
          "name": "*"
        }
      ]
    },
    "hud_healthdamage_frame": {
      "desc": "Sets frame visibility and style for this HUD element.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Adjust background opacity",
          "name": "0.x to 1"
        },
        {
          "description": "Bevelled frame.",
          "name": "2"
        }
      ]
    },
    "hud_healthdamage_frame_color": {
      "desc": "Defines the color of the background of the healthdamage HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_healthdamage_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_healthdamage_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_healthdamage_place": {
      "desc": "Sets placement for this HUD element. You can align some elements relative to other elements.",
      "group-id": "19",
      "remarks": "First you have to decide, if the element that you are locating now (element B) is to be positioned inside another element (element A) or outside it. See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "to place this element inside element B set this variable to \"@B\", to place it outside B element set this variable to \"B\"",
          "name": "*"
        }
      ]
    },
    "hud_healthdamage_pos_x": {
      "desc": "Sets horizontal position of this HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_healthdamage_pos_y": {
      "desc": "Sets vertical position of this HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_healthdamage_scale": {
      "desc": "Sets overall size of this HUD element.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Use positive floating point numbers.",
          "name": "*"
        }
      ]
    },
    "hud_healthdamage_show": {
      "desc": "Toggles visibility of this HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw this element",
          "name": "false"
        },
        {
          "description": "Draw this element",
          "name": "true"
        }
      ]
    },
    "hud_healthdamage_style": {
      "desc": "Toggles between different numbers styles.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "large font, texture",
          "name": "false"
        },
        {
          "description": "small font, gfxwad",
          "name": "true"
        }
      ]
    },
    "hud_iammo1_align_x": {
      "desc": "Sets horizontal align of shells icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo1_align_y": {
      "desc": "Sets vertical align of shells icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo1_frame": {
      "desc": "Sets frame visibility and style for shells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo1_frame_color": {
      "desc": "Defines the color of the background of the iammo1 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo1_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo1_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_iammo1_place": {
      "desc": "Sets relative positioning for shells icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo1_pos_x": {
      "desc": "Sets horizontal position of shells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo1_pos_y": {
      "desc": "Sets vertical position of shells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo1_scale": {
      "desc": "Sets size of shells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo1_show": {
      "desc": "Switches showing of shells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo1_style": {
      "desc": "Switches graphical style of shells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo2_align_x": {
      "desc": "Sets horizontal align of nails icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo2_align_y": {
      "desc": "Sets vertical align of nails icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo2_frame": {
      "desc": "Sets frame visibility and style for nails icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo2_frame_color": {
      "desc": "Defines the color of the background of the iammo2 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo2_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo2_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_iammo2_place": {
      "desc": "Sets relative positioning for nails icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo2_pos_x": {
      "desc": "Sets horizontal position of nails icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo2_pos_y": {
      "desc": "Sets vertical position of nails icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo2_scale": {
      "desc": "Sets size of nails icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo2_show": {
      "desc": "Switches showing of nails icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo2_style": {
      "desc": "Switches graphical style of nails icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo3_align_x": {
      "desc": "Sets horizontal align of rockets icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo3_align_y": {
      "desc": "Sets vertical align of rockets icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo3_frame": {
      "desc": "Sets frame visibility and style for rockets icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo3_frame_color": {
      "desc": "Defines the color of the background of the iammo3 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo3_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo3_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_iammo3_place": {
      "desc": "Sets relative positioning for rockets icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo3_pos_x": {
      "desc": "Sets horizontal position of rockets icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo3_pos_y": {
      "desc": "Sets vertical position of rockets icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo3_scale": {
      "desc": "Sets size of rockets icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo3_show": {
      "desc": "Switches showing of rockets icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo3_style": {
      "desc": "Switches graphical style of rockets icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo4_align_x": {
      "desc": "Sets horizontal align of cells icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo4_align_y": {
      "desc": "Sets vertical align of cells icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo4_frame": {
      "desc": "Sets frame visibility and style for cells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo4_frame_color": {
      "desc": "Defines the color of the background of the iammo4 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo4_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo4_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_iammo4_place": {
      "desc": "Sets relative positioning for cells icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo4_pos_x": {
      "desc": "Sets horizontal position of cells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo4_pos_y": {
      "desc": "Sets vertical position of cells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo4_scale": {
      "desc": "Sets size of cells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo4_show": {
      "desc": "Switches showing of cells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo4_style": {
      "desc": "Switches graphical style of cells icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo_align_x": {
      "desc": "Sets horizontal align of current ammo icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo_align_y": {
      "desc": "Sets vertical align of current ammo icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo_frame": {
      "desc": "Sets frame visibility and style for current ammo icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo_frame_color": {
      "desc": "Defines the color of the background of the iammo HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_iammo_place": {
      "desc": "Sets relative positioning for current ammo icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iammo_pos_x": {
      "desc": "Sets horizontal position of current ammo icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo_pos_y": {
      "desc": "Sets vertical position of current ammo icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo_scale": {
      "desc": "Sets size of current ammo icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo_show": {
      "desc": "Switches showing of current ammo icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iammo_style": {
      "desc": "Switches graphical style of current ammo icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iarmor_align_x": {
      "desc": "Sets horizontal align of armor icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iarmor_align_y": {
      "desc": "Sets vertical align of armor icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iarmor_frame": {
      "desc": "Sets frame visibility and style for armor icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iarmor_frame_color": {
      "desc": "Defines the color of the background of the iarmor HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iarmor_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_iarmor_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_iarmor_place": {
      "desc": "Sets relative positioning for armor icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_iarmor_pos_x": {
      "desc": "Sets horizontal position of armor icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iarmor_pos_y": {
      "desc": "Sets vertical position of armor icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iarmor_scale": {
      "desc": "Sets size of armor icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iarmor_show": {
      "desc": "Switches showing of armor icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_iarmor_style": {
      "desc": "Switches graphical style of armor icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_itemsclock_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_itemsclock_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_itemsclock_filter": {
      "desc": "Space-separated list of items to NOT be shown.",
      "group-id": "19",
      "remarks": "Options are: gl, rl, lg, quad, pent, ring, suit, mh, ga, ya, ra.",
      "type": "integer",
      "values": [
        {
          "description": "hide grenade launcher, green armor & suit from items list",
          "name": "gl ga suit"
        }
      ]
    },
    "hud_itemsclock_frame": {
      "group-id": "19",
      "type": ""
    },
    "hud_itemsclock_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_itemsclock_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_itemsclock_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_itemsclock_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_itemsclock_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_itemsclock_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_itemsclock_scale": {
      "desc": "Sets size of items clock items relative to standard font size.",
      "group-id": "19",
      "type": "float"
    },
    "hud_itemsclock_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_itemsclock_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_itemsclock_timelimit": {
      "group-id": "19",
      "type": ""
    },
    "hud_key1_align_x": {
      "desc": "Sets horizontal align of silver key.",
      "group-id": "19",
      "type": "string"
    },
    "hud_key1_align_y": {
      "desc": "Sets vertical align of silver key.",
      "group-id": "19",
      "type": "string"
    },
    "hud_key1_frame": {
      "desc": "Sets frame visibility and style for silver key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key1_frame_color": {
      "desc": "Defines the color of the background of the key1 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_key1_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_key1_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_key1_place": {
      "desc": "Sets relative positioning for silver key.",
      "group-id": "19",
      "type": "string"
    },
    "hud_key1_pos_x": {
      "desc": "Sets horizontal position of silver key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key1_pos_y": {
      "desc": "Sets vertical position of silver key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key1_scale": {
      "desc": "Sets size of silver key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key1_show": {
      "desc": "Switches showing of silver key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key1_style": {
      "desc": "Switches graphical style of silver key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key2_align_x": {
      "desc": "Sets horizontal align of gold key.",
      "group-id": "19",
      "type": "string"
    },
    "hud_key2_align_y": {
      "desc": "Sets vertical align of gold key.",
      "group-id": "19",
      "type": "string"
    },
    "hud_key2_frame": {
      "desc": "Sets frame visibility and style for gold key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key2_frame_color": {
      "desc": "Defines the color of the background of the key2 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_key2_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_key2_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_key2_place": {
      "desc": "Sets relative positioning for gold key.",
      "group-id": "19",
      "type": "string"
    },
    "hud_key2_pos_x": {
      "desc": "Sets horizontal position of gold key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key2_pos_y": {
      "desc": "Sets vertical position of gold key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key2_scale": {
      "desc": "Sets size of gold key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key2_show": {
      "desc": "Switches showing of gold key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_key2_style": {
      "desc": "Switches graphical style of gold key.",
      "group-id": "19",
      "type": "float"
    },
    "hud_keys_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_keys_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_keys_frame": {
      "group-id": "19",
      "type": "float"
    },
    "hud_keys_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_keys_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_keys_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_keys_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_keys_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_keys_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_keys_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_keys_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_mouserate_align_x": {
      "desc": "Vertical alignment of the mouserate HUD element. See the HUD manual for more info.",
      "group-id": "28",
      "type": "string"
    },
    "hud_mouserate_align_y": {
      "desc": "Vertical alignment of the mouserate HUD element. See the HUD manual for more info.",
      "group-id": "28",
      "type": "string"
    },
    "hud_mouserate_frame": {
      "desc": "Opacity of the background of the mouserate HUD element.",
      "group-id": "28",
      "type": "float"
    },
    "hud_mouserate_frame_color": {
      "desc": "Defines the color of the background of the mouserate HUD element. See HUD manual for more info.",
      "group-id": "28",
      "type": "string"
    },
    "hud_mouserate_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "28",
      "type": "integer"
    },
    "hud_mouserate_place": {
      "desc": "Placement of the mouserate HUD element. HUD elements can be place into various screen areas or other elements. See HUD manual for more info.",
      "group-id": "28",
      "type": "string"
    },
    "hud_mouserate_pos_x": {
      "desc": "Horizontal relative position of the mouserate HUD element.",
      "group-id": "28",
      "type": "integer"
    },
    "hud_mouserate_pos_y": {
      "desc": "Vertical relative position of the mouserate HUD element.",
      "group-id": "28",
      "type": "integer"
    },
    "hud_mouserate_show": {
      "desc": "Visibility of the mouserate HUD element.",
      "group-id": "28",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_name_remove_prefixes": {
      "default": "",
      "desc": "Space-separated list of prefixes to remove from player names before displaying in the tracker & teaminfo.",
      "group-id": "40",
      "remarks": "Useful if one team has clan prefixes that stop the names appearing fully.",
      "type": "string"
    },
    "hud_net_align_x": {
      "desc": "Sets horizontal align of net statistics.",
      "group-id": "19",
      "type": "string"
    },
    "hud_net_align_y": {
      "desc": "Sets vertical align of net statistics.",
      "group-id": "19",
      "type": "string"
    },
    "hud_net_frame": {
      "desc": "Sets frame visibility and style for net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_net_frame_color": {
      "desc": "Defines the color of the background of the net HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_net_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_net_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_net_period": {
      "desc": "Sets period for updating net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_net_place": {
      "desc": "Sets relative positioning for net statistics.",
      "group-id": "19",
      "type": "string"
    },
    "hud_net_pos_x": {
      "desc": "Sets horizontal position of net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_net_pos_y": {
      "desc": "Sets vertical position of net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_net_show": {
      "desc": "Switches showing of net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_align_x": {
      "desc": "Sets horizontal align of everything about net.",
      "group-id": "19",
      "type": "string"
    },
    "hud_netgraph_align_y": {
      "desc": "Sets vertical align of everything about net.",
      "group-id": "19",
      "type": "string"
    },
    "hud_netgraph_alpha": {
      "desc": "Sets transparency level of everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_frame": {
      "desc": "Sets frame visibility and style for everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_frame_color": {
      "desc": "Defines the color of the background of the netgraph HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_netgraph_height": {
      "desc": "Sets vertical size of everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_inframes": {
      "desc": "setting this to \"1\" lets you measure your latency in an alternate way every level of netgraph will mean one frame of delay, between sending it to server and getting answer. On local/lan server you'll always get one frame of delay, even with low FPS.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_lostscale": {
      "desc": "Lets you cut down those red, yellow, blue and gray bars, which are always full-height.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Range 0 to 1.",
          "name": "*"
        }
      ]
    },
    "hud_netgraph_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_netgraph_place": {
      "desc": "Sets relative positioning for everything about net.",
      "group-id": "19",
      "type": "string"
    },
    "hud_netgraph_ploss": {
      "desc": "print packet loss or not everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_pos_x": {
      "desc": "Sets horizontal position of everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_pos_y": {
      "desc": "Sets vertical position of everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_scale": {
      "desc": "Sets size of everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_show": {
      "desc": "Switches showing of everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_swap_x": {
      "desc": "reverse horizontally, like for placing at left edge of the screen.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_swap_y": {
      "desc": "reverse vertically, like for top edge.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netgraph_width": {
      "desc": "Sets horizontal size of everything about net.",
      "group-id": "19",
      "type": "float"
    },
    "hud_netproblem_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_netproblem_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_netproblem_frame": {
      "group-id": "19",
      "type": ""
    },
    "hud_netproblem_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_netproblem_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_netproblem_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_netproblem_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_netproblem_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_netproblem_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_netproblem_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_netproblem_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_notify_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_notify_cols": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_frame": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_notify_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_notify_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_rows": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_notify_time": {
      "group-id": "19",
      "type": ""
    },
    "hud_ownfrags_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_ownfrags_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_ownfrags_frame": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ownfrags_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_ownfrags_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ownfrags_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_ownfrags_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_ownfrags_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_ownfrags_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_ownfrags_scale": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ownfrags_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_ownfrags_timeout": {
      "group-id": "19",
      "type": ""
    },
    "hud_pent_align_x": {
      "desc": "Sets horizontal align of pentagram icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_pent_align_y": {
      "desc": "Sets vertical align of pentagram icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_pent_frame": {
      "desc": "Sets frame visibility and style for pentagram icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_pent_frame_color": {
      "desc": "Defines the color of the background of the pent HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_pent_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_pent_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_pent_place": {
      "desc": "Sets relative positioning for pentagram icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_pent_pos_x": {
      "desc": "Sets horizontal position of pentagram icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_pent_pos_y": {
      "desc": "Sets vertical position of pentagram icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_pent_scale": {
      "desc": "Sets size of pentagram icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_pent_show": {
      "desc": "Switches showing of pentagram icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_pent_style": {
      "desc": "Switches graphical style of pentagram icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_align_x": {
      "desc": "Sets horizontal align of small net statistics.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ping_align_y": {
      "desc": "Sets vertical align of small net statistics.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ping_blink": {
      "desc": "Enable yellow blinking dot, which shows when your ping is recalculated.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_frame": {
      "desc": "Sets frame visibility and style for small net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_frame_color": {
      "desc": "Defines the color of the background of the ping HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ping_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_ping_period": {
      "desc": "Period of time between updates (minimum value is your frame time)",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_place": {
      "desc": "Sets relative positioning for small net statistics.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ping_pos_x": {
      "desc": "Sets horizontal position of small net statistics;",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_pos_y": {
      "desc": "Sets vertical position of small net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_show": {
      "desc": "Switches showing of small net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_show_dev": {
      "desc": "Switches showing of small net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_show_max": {
      "desc": "Switches showing of small net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_show_min": {
      "desc": "Switches showing of small net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_show_pl": {
      "desc": "Switches showing of small net statistics.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ping_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_planmode": {
      "desc": "Toggles special hud-editing mode where all hud elements are being displayed.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Plan-mode off.",
          "name": "false"
        },
        {
          "description": "Plan-mode on.",
          "name": "true"
        }
      ]
    },
    "hud_quad_align_x": {
      "desc": "Sets horizontal align of quad icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_quad_align_y": {
      "desc": "Sets vertical align of quad icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_quad_frame": {
      "desc": "Sets frame visibility and style for quad icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_quad_frame_color": {
      "desc": "Defines the color of the background of the quad HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_quad_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_quad_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_quad_place": {
      "desc": "Sets relative positioning for quad icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_quad_pos_x": {
      "desc": "Sets horizontal position of quad icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_quad_pos_y": {
      "desc": "Sets vertical position of quad icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_quad_scale": {
      "desc": "Sets size of quad icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_quad_show": {
      "desc": "Switches showing of quad icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_quad_style": {
      "desc": "Switches graphical style of quad icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_radar_align_x": {
      "desc": "Vertical alignment of the radar HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_radar_align_y": {
      "desc": "Vertical alignment of the radar HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_radar_autosize": {
      "desc": "Automatically size the Radar hud item to show the radar picture at the resolution it was created for.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "The width and height values decides how big the radar picture is.",
          "name": "false"
        },
        {
          "description": "The hud item is sized after the size of the radar picture.",
          "name": "true"
        }
      ]
    },
    "hud_radar_fade_players": {
      "desc": "Fade players (make them more transparent) as they lose health/armor.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Players stay a solid color no matter what health/armor.",
          "name": "false"
        },
        {
          "description": "Players color fades as they get weaker.",
          "name": "true"
        }
      ]
    },
    "hud_radar_frame": {
      "desc": "Opacity of the background of the radar HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_radar_frame_color": {
      "desc": "Defines the color of the background of the radar HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_radar_height": {
      "desc": "Sets the height of the radar hud item.",
      "group-id": "19",
      "remarks": "Note that if hud_radar_autosize is set, this value will be ignored.",
      "type": "integer"
    },
    "hud_radar_highlight": {
      "desc": "Show a highlight around the currently tracked player on the radar or not.",
      "group-id": "19",
      "remarks": "Change the color of the higlight using the hud_radar_highlight_color variable.",
      "type": "enum",
      "values": [
        {
          "description": "Don't highlight the tracked player.",
          "name": "0"
        },
        {
          "description": "Only highlight the name of the player (show_names needs to be on)",
          "name": "1"
        },
        {
          "description": "Draw a variably sized circle outline around the tracked player.",
          "name": "2"
        },
        {
          "description": "Draw a fixed sized circle outline around the tracked player.",
          "name": "3"
        },
        {
          "description": "Draw a variably sized circle around the tracked player.",
          "name": "4"
        },
        {
          "description": "Draw a variably sized circle around the tracked player.",
          "name": "5"
        },
        {
          "description": "Draw a line from the bottom center of the radar to the tracked player.",
          "name": "6"
        },
        {
          "description": "Draw a line from the center of the radar to the tracked player.",
          "name": "7"
        },
        {
          "description": "Draw a line from the top center of the radar to the tracked player.",
          "name": "8"
        },
        {
          "description": "Draw a line from each corner of the radar to the tracked player.",
          "name": "9"
        }
      ]
    },
    "hud_radar_highlight_color": {
      "desc": "Sets the RGBA color of the highlight of the tracked player for the radar HUD element.",
      "group-id": "19",
      "type": "string",
      "values": [
        {
          "description": "Example: \"255 255 255 150\"",
          "name": "*"
        }
      ]
    },
    "hud_radar_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_radar_itemfilter": {
      "desc": "Decides what items should be shown on the radar. Such as ammo, health packs, backpacks and powerups.",
      "group-id": "19",
      "remarks": "Any character/whitespace can be used as a delimiter. Make sure you enter the value between quotes if you use whitespaces.",
      "type": "string",
      "values": [
        {
          "description": "Valid values: backpack, health, armor, rockets, nails, cells, shells, quad, pent, ring, suit, mega",
          "name": "*"
        }
      ]
    },
    "hud_radar_onlytp": {
      "desc": "Decides whetever the radar hud item should be shown only when in teamplay mode, or demo playback.",
      "group-id": "19",
      "remarks": "The radar will NOT be visible when playing as a normal player no matter what you set this to, this only applies to spectators/during demo playback.",
      "type": "enum",
      "values": [
        {
          "description": "Always show.",
          "name": "0"
        },
        {
          "description": "Only show when teamplay is on.",
          "name": "1"
        },
        {
          "description": "Only show when in demo playback.",
          "name": "2"
        },
        {
          "description": "Only show when teamplay is on and in demo playback.",
          "name": "3"
        }
      ]
    },
    "hud_radar_opacity": {
      "desc": "The opacity of the radar.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "0 is fully transparent and 1 is opague.",
          "name": "*"
        }
      ]
    },
    "hud_radar_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_radar_otherfilter": {
      "desc": "Decides what \"other\" things, such as projectiles (rockets, nails, shaft beam), gibs, and explosions, that should be shown on the radar.",
      "group-id": "19",
      "remarks": "Any character/whitespace can be used as a delimiter. Make sure you enter the value between quotes if you use whitespaces.",
      "type": "string",
      "values": [
        {
          "description": "Valid values: projectiles, nails, rockets, shaft, gibs, explosions",
          "name": "*"
        }
      ]
    },
    "hud_radar_place": {
      "desc": "Placement of the radar HUD element. HUD elements can be place into various screen areas or other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_radar_player_size": {
      "desc": "The radius in of the players on the radar.",
      "group-id": "19",
      "remarks": "If show_height is turned on, then this ofcourse depends on what height the player is located at.",
      "type": "float"
    },
    "hud_radar_pos_x": {
      "desc": "Horizontal relative position of the radar HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_radar_pos_y": {
      "desc": "Vertical relative position of the radar HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_radar_show": {
      "desc": "Visibility of the radar HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_radar_show_height": {
      "desc": "Should the players become bigger as they move to higher points on the map or not?",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Players always stay the same size on the radar.",
          "name": "false"
        },
        {
          "description": "Players change size depending on their altitude on the level.",
          "name": "true"
        }
      ]
    },
    "hud_radar_show_hold": {
      "desc": "This will show the name of all the important items on the map (RL, LG, GL, SNG, Quad, Pent, Ring, Suit, Mega, Armors). A circle is drawn around the items, the team who has the highest weight inside this area is considered to be holding that particular item. See the teamholdinfo hud item.",
      "group-id": "19",
      "remarks": "It is not recommended to have this visible at all times. Instead it's meant for a quick glance to know which item is named what when using the Teamholdbarinfo hud item. For instance if the map has two YA's, one is named YA and the other YA2. Use this feature to see which is which.",
      "type": "boolean",
      "values": [
        {
          "description": "Don't show the items and circles on the radar.",
          "name": "false"
        },
        {
          "description": "Show the item names and circle on the radar.",
          "name": "true"
        }
      ]
    },
    "hud_radar_show_names": {
      "desc": "Show the names of the players on the radar.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_radar_show_powerups": {
      "desc": "Highlight players with powerups on the radar hud item with a colored circle around them, depending on what type of powerup.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Don't highlight players with powerups.",
          "name": "false"
        },
        {
          "description": "Highlight players with powerups.",
          "name": "true"
        }
      ]
    },
    "hud_radar_show_stats": {
      "desc": "Decides what type of stats should be shown on the radar.",
      "group-id": "19",
      "remarks": "The team stats are calculated depending on how strong a player is. A strong player with a good weapon raises the weight for a certain area more than a weak one. The team with the highest weight for a certain area is considered to hold that area.",
      "type": "enum"
    },
    "hud_radar_weaponfilter": {
      "desc": "Decides which weapons that should be shown on the radar.",
      "group-id": "19",
      "remarks": "Any character/whitespace can be used as a delimiter. Make sure you enter the value between quotes if you use whitespaces.",
      "type": "string",
      "values": [
        {
          "description": "Valid values: ssg, ng, sng, rl, gl, lg",
          "name": "*"
        }
      ]
    },
    "hud_radar_width": {
      "desc": "The width of the radar hud item.",
      "group-id": "19",
      "remarks": "Note that if hud_radar_autosize is set, this value will be ignored.",
      "type": "integer"
    },
    "hud_ring_align_x": {
      "desc": "Sets horizontal align of ring icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ring_align_y": {
      "desc": "Sets vertical align of ring icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ring_frame": {
      "desc": "Sets frame visibility and style for ring icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ring_frame_color": {
      "desc": "Defines the color of the background of the ring HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ring_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_ring_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_ring_place": {
      "desc": "Sets relative positioning for ring icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_ring_pos_x": {
      "desc": "Sets horizontal position of ring icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ring_pos_y": {
      "desc": "Sets vertical position of ring icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ring_scale": {
      "desc": "Sets size of ring icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ring_show": {
      "desc": "Switches showing of ring icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_ring_style": {
      "desc": "Switches graphical style of ring icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_score_bar_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_bar_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_bar_fixed_order": {
      "desc": "If set, order of player names is fixed, irrespective of who is currently being tracked.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Current player is always %t",
          "name": "0"
        },
        {
          "description": "Fixed order of player names",
          "name": "1"
        }
      ]
    },
    "hud_score_bar_format_big": {
      "desc": "Format string for score_bar HUD element.",
      "group-id": "19",
      "remarks": "%d - score difference between you and enemy.\n%D - score difference between you and enemy, red chars.\n%t - team score.\n%T - your (team) score, red chars.\n%e - enemy (team) score.\n%E - enemy (team) score, red chars.\n%d - score (team) difference.\n%D - score (team) difference, red chars.\n%p - your (team) position on scoreboard.\n%z - score difference between you and enemy, unsigned. Red chars used for negative difference.\n%z - score difference between you and enemy, unsigned. Red chars used for positive difference.",
      "type": "string"
    },
    "hud_score_bar_format_reversed_big": {
      "desc": "Format string for score_bar HUD element, used when hud_score_bar_fixed_order has taken effect.\nIf not set, hud_score_bar_format_big will be used instead.",
      "group-id": "19",
      "remarks": "See hud_score_bar_format_big for format codes.",
      "type": "string"
    },
    "hud_score_bar_format_reversed_small": {
      "desc": "Format string for score_bar HUD element, used when hud_score_bar_fixed_order has taken effect.\nIf not set, hud_score_bar_format_reversed_small will be used instead.",
      "group-id": "19",
      "remarks": "See hud_score_bar_format_reversed_small for format codes.",
      "type": "string"
    },
    "hud_score_bar_format_small": {
      "desc": "Format string for score_bar HUD element.",
      "group-id": "19",
      "remarks": "%d - score difference between you and enemy.\n%D - score difference between you and enemy, always signed.\n%t - your (team) score.\n%T - your (team) name.\n%e - enemy (team) score.\n%E - enemy (team) name.\n%d - score difference.\n%D - score difference, always signed.\n%p - Your (team) position on scoreboard.\n\nAlso, you could use color codes.",
      "type": "string"
    },
    "hud_score_bar_frag_length": {
      "desc": "Minimum number of characters to use when displaying frags.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_score_bar_frame": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_bar_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_bar_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_bar_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_bar_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_bar_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_bar_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_bar_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_bar_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_bar_style": {
      "desc": "Style of score_bar HUD element.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "Use small characterss (conchars)",
          "name": "0"
        },
        {
          "description": "Use big characters (num* and anum* images)",
          "name": "1"
        }
      ]
    },
    "hud_score_difference_align": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_difference_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_difference_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_difference_colorize": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_difference_digits": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_difference_frame": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_difference_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_difference_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_difference_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_difference_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_difference_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_difference_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_difference_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_difference_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_difference_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_align": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_enemy_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_enemy_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_enemy_colorize": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_digits": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_frame": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_enemy_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_enemy_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_enemy_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_enemy_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_align": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_position_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_position_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_position_colorize": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_digits": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_frame": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_position_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_position_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_position_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_position_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_align": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_team_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_team_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_team_colorize": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_digits": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_frame": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_team_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_score_team_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_score_team_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_score_team_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_scoreclock_align_x": {
      "desc": "Sets horizontal align of scoreclock.",
      "group-id": "19",
      "type": "string"
    },
    "hud_scoreclock_align_y": {
      "desc": "Sets vertical align of scoreclock.",
      "group-id": "19",
      "type": "string"
    },
    "hud_scoreclock_format": {
      "desc": "Controls in what format the scoreclock is displayed. Check the link below for available options. You can also add text, e.g. \"time: %H:%M:%S\"",
      "group-id": "19",
      "remarks": "https://www.man7.org/linux/man-pages/man3/strftime.3.html",
      "type": "string"
    },
    "hud_scoreclock_frame": {
      "desc": "Sets frame visibility and style for scoreclock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_scoreclock_frame_color": {
      "desc": "Defines the color of the background of the scoreclock HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_scoreclock_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_scoreclock_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_scoreclock_place": {
      "desc": "Sets relative positioning for scoreclock.",
      "group-id": "19",
      "type": "string"
    },
    "hud_scoreclock_pos_x": {
      "desc": "Sets horizontal position of scoreclock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_scoreclock_pos_y": {
      "desc": "Sets vertical position of scoreclock.",
      "group-id": "19",
      "type": "float"
    },
    "hud_scoreclock_proportional": {
      "desc": "Toggles whether the scoreclock uses charset chars or TTF chars",
      "group-id": "19",
      "type": "boolean"
    },
    "hud_scoreclock_scale": {
      "desc": "Scale of the scoreclock HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_scoreclock_show": {
      "desc": "Toggles whether the scoreclock is displayed. It is only displayed when the scoreboard is open.",
      "group-id": "19",
      "type": "boolean"
    },
    "hud_scoremapname_align_x": {
      "desc": "Sets horizontal align of scoremapname.",
      "group-id": "19",
      "type": "string"
    },
    "hud_scoremapname_align_y": {
      "desc": "Sets vertical align of scoremapname.",
      "group-id": "19",
      "type": "string"
    },
    "hud_scoremapname_frame": {
      "desc": "Sets frame visibility and style for scoremapname.",
      "group-id": "19",
      "type": "float"
    },
    "hud_scoremapname_frame_color": {
      "desc": "Defines the color of the background of the scoremapname HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_scoremapname_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_scoremapname_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_scoremapname_place": {
      "desc": "Sets relative positioning for scoremapname.",
      "group-id": "19",
      "type": "string"
    },
    "hud_scoremapname_pos_x": {
      "desc": "Sets horizontal position of scoremapname.",
      "group-id": "19",
      "type": "float"
    },
    "hud_scoremapname_pos_y": {
      "desc": "Sets vertical position of scoremapname.",
      "group-id": "19",
      "type": "float"
    },
    "hud_scoremapname_proportional": {
      "desc": "Toggles whether the scoremapname uses charset chars or TTF chars",
      "group-id": "19",
      "type": "boolean"
    },
    "hud_scoremapname_scale": {
      "desc": "Scale of the scoremapname HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_scoremapname_show": {
      "desc": "Toggles whether the scoremapname is displayed. It is only displayed when the scoreboard is open.",
      "group-id": "19",
      "type": "boolean"
    },
    "hud_scoremapname_style": {
      "desc": "Style of the scoremapname HUD element.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Full name, example: The Abandoned Base (dm3)",
          "name": "0"
        },
        {
          "description": "Level name, example: The Abandoned Base",
          "name": "1"
        },
        {
          "description": "Map name, example: dm3",
          "name": "2"
        }
      ]
    },
    "hud_sigil1_align_x": {
      "desc": "Sets horizontal align of sigil 1 icon (rune)",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil1_align_y": {
      "desc": "Sets vertical align of sigil 1 icon (rune)",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil1_frame": {
      "desc": "Sets frame visibility and style for sigil 1 icon (rune)",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil1_frame_color": {
      "desc": "Defines the color of the background of the sigil1 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil1_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil1_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_sigil1_place": {
      "desc": "Sets relative positioning for sigil 1 icon (rune)",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil1_pos_x": {
      "desc": "Sets horizontal position of sigil 1 icon (rune)",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil1_pos_y": {
      "desc": "Sets vertical position of sigil 1 icon (rune)",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil1_scale": {
      "desc": "Sets size of sigil 1 icon (rune)",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil1_show": {
      "desc": "Switches showing of sigil 1 icon (rune)",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil1_style": {
      "desc": "Switches graphical style of sigil 1 icon (rune)",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil2_align_x": {
      "desc": "Sets horizontal align of sigil 2 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil2_align_y": {
      "desc": "Sets vertical align of sigil 2 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil2_frame": {
      "desc": "Sets frame visibility and style for sigil 2 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil2_frame_color": {
      "desc": "Defines the color of the background of the sigil2 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil2_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil2_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_sigil2_place": {
      "desc": "Sets relative positioning for sigil 2 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil2_pos_x": {
      "desc": "Sets horizontal position of sigil 2 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil2_pos_y": {
      "desc": "Sets vertical position of sigil 2 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil2_scale": {
      "desc": "Sets size of sigil 2 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil2_show": {
      "desc": "Switches showing of sigil 2 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil2_style": {
      "desc": "Switches graphical style of sigil 2 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil3_align_x": {
      "desc": "Sets horizontal align of sigil 3 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil3_align_y": {
      "desc": "Sets vertical align of sigil 3 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil3_frame": {
      "desc": "Sets frame visibility and style for sigil 3 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil3_frame_color": {
      "desc": "Defines the color of the background of the sigil3 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil3_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil3_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_sigil3_place": {
      "desc": "Sets relative positioning for sigil 3 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil3_pos_x": {
      "desc": "Sets horizontal position of sigil 3 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil3_pos_y": {
      "desc": "Sets vertical position of sigil 3 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil3_scale": {
      "desc": "Sets size of sigil 3 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil3_show": {
      "desc": "Switches showing of sigil 3 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil3_style": {
      "desc": "Switches graphical style of sigil 3 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil4_align_x": {
      "desc": "Sets horizontal align of sigil 4 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil4_align_y": {
      "desc": "Sets vertical align of sigil 4 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil4_frame": {
      "desc": "Sets frame visibility and style for sigil 4 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil4_frame_color": {
      "desc": "Defines the color of the background of the sigil4 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil4_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil4_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_sigil4_place": {
      "desc": "Sets relative positioning for sigil 4 icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_sigil4_pos_x": {
      "desc": "Sets horizontal position of sigil 4 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil4_pos_y": {
      "desc": "Sets vertical position of sigil 4 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil4_scale": {
      "desc": "Sets size of sigil 4 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil4_show": {
      "desc": "Switches showing of sigil 4 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sigil4_style": {
      "desc": "Switches graphical style of sigil 4 icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_sortrules_includeself": {
      "desc": "Determines how the current player is sorted.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "No special treatment, sort as normal.",
          "name": "0"
        },
        {
          "description": "The current player always appears in first place.",
          "name": "1"
        },
        {
          "description": "The current player be in first or second place.",
          "name": "2"
        }
      ]
    },
    "hud_sortrules_playersort": {
      "desc": "Determines how players are sorted.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Sort by name.",
          "name": "0"
        },
        {
          "description": "Sort by frags, then by name.",
          "name": "1"
        },
        {
          "description": "Sort by team, then name.",
          "name": "2"
        },
        {
          "description": "Sort by team, frags, then name.",
          "name": "3"
        }
      ]
    },
    "hud_sortrules_teamsort": {
      "desc": "Determines how teams are sorted.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Sort by name.",
          "name": "0"
        },
        {
          "description": "Sort by frags, then by name.",
          "name": "1"
        }
      ]
    },
    "hud_speed2_align_x": {
      "desc": "Vertical alignment of the speed2 HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_speed2_align_y": {
      "desc": "Vertical alignment of the speed2 HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_speed2_color_fast": {
      "desc": "Sets the color of the speed2 hud item when the speed is above the wrap speed.",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).\nSee hud_radar2_wrapspeed also.",
      "type": "integer"
    },
    "hud_speed2_color_fastest": {
      "desc": "Sets the color of the speed2 hud item when the speed is above 2x wrap speed.",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).\nSee hud_radar2_wrapspeed also.",
      "type": "integer"
    },
    "hud_speed2_color_insane": {
      "desc": "Sets the color of the speed2 hud item when the speed is above 3x wrap speed.",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).\nSee hud_radar2_wrapspeed also.",
      "type": "integer"
    },
    "hud_speed2_color_normal": {
      "desc": "Sets the color of the speed2 hud item when the speed is between 1 and the wrap speed.",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).\nSee hud_radar2_wrapspeed also.",
      "type": "integer"
    },
    "hud_speed2_color_stopped": {
      "desc": "Sets the color of the speed2 hud item when the speed is 0. Default is green.",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).",
      "type": "integer"
    },
    "hud_speed2_frame": {
      "desc": "Opacity of the background of the speed2 HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_speed2_frame_color": {
      "desc": "Defines the color of the background of the speed2 HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_speed2_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_speed2_opacity": {
      "desc": "Sets the opacity of the speed2 hud item.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "0 is fully transparent, and 1 is opague.",
          "name": "*"
        }
      ]
    },
    "hud_speed2_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_speed2_orientation": {
      "desc": "The orientation of the speed2 hud item. This can be set to, up, down, left and right. That is, the direction that the hud item will be pointing in.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Point upwards.",
          "name": "0"
        },
        {
          "description": "Point downwards.",
          "name": "1"
        },
        {
          "description": "Point to the right.",
          "name": "2"
        },
        {
          "description": "Point to the left.",
          "name": "3"
        }
      ]
    },
    "hud_speed2_place": {
      "desc": "Placement of the speed2 HUD element. HUD elements can be place into various screen areas or other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_speed2_pos_x": {
      "desc": "Horizontal relative position of the speed2 HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_speed2_pos_y": {
      "desc": "Vertical relative position of the speed2 HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_speed2_radius": {
      "desc": "Sets the radius of the half circle. The width and height is based on this.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "The radius of the half circle.",
          "name": "*"
        }
      ]
    },
    "hud_speed2_show": {
      "desc": "Visibility of the speed2 HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_speed2_wrapspeed": {
      "desc": "Sets the speed when the speed needle will reset to the original position, and the next color is shown (to indicate faster speed).",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "The wrap speed.",
          "name": "*"
        }
      ]
    },
    "hud_speed2_xyz": {
      "desc": "Base the speed calculation on up/down movement also.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Only use the X/Y movement to calculate the speed.",
          "name": "false"
        },
        {
          "description": "Use X/Y/Z movement to calculate the speed. (movement up/down included).",
          "name": "true"
        }
      ]
    },
    "hud_speed_align_x": {
      "desc": "Sets horizontal align of your current speed.",
      "group-id": "19",
      "type": "string"
    },
    "hud_speed_align_y": {
      "desc": "Sets vertical align of your current speed.",
      "group-id": "19",
      "type": "string"
    },
    "hud_speed_color_fast": {
      "desc": "Sets the color of the speed hud item when the player is moving at a \"fast\" speed (above 500).",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).",
      "type": "integer"
    },
    "hud_speed_color_fastest": {
      "desc": "Sets the color of the speed hud item when the player is moving at a really \"fast\" speed (above 1000).",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).",
      "type": "integer"
    },
    "hud_speed_color_insane": {
      "desc": "Sets the color of the speed hud item when the player is moving at a crazy speed (above 1500... I think).",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).",
      "type": "integer"
    },
    "hud_speed_color_normal": {
      "desc": "Sets the color of the speed hud item when the player is moving at a \"normal\" speed (below 500).",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).",
      "type": "integer"
    },
    "hud_speed_color_stopped": {
      "desc": "The color that the fill part of the speed hud item has when the player isn't moving. Default is green.",
      "group-id": "19",
      "remarks": "Uses quake palette colors (0-255).",
      "type": "integer"
    },
    "hud_speed_frame": {
      "desc": "Sets frame visibility and style for your current speed.",
      "group-id": "19",
      "type": "float"
    },
    "hud_speed_frame_color": {
      "desc": "Defines the color of the background of the speed HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_speed_height": {
      "desc": "Sets the height of the speed hud item.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_speed_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_speed_opacity": {
      "desc": "Sets the opacity of the speed hud item.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "A value of 0 gives full transparency, 1 is opague.",
          "name": "*"
        }
      ]
    },
    "hud_speed_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_speed_place": {
      "desc": "Sets relative positioning for your current speed.",
      "group-id": "19",
      "type": "string"
    },
    "hud_speed_pos_x": {
      "desc": "Sets horizontal position of your current speed.",
      "group-id": "19",
      "type": "float"
    },
    "hud_speed_pos_y": {
      "desc": "Sets vertical position of your current speed.",
      "group-id": "19",
      "type": "float"
    },
    "hud_speed_show": {
      "desc": "Switches showing of your current speed.",
      "group-id": "19",
      "type": "float"
    },
    "hud_speed_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_speed_text_align": {
      "desc": "Sets how the text on the speed hud item should be aligned.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Don't draw the text at all.",
          "name": "0"
        },
        {
          "description": "Draw the text left aligned (or at the top when in vertical mode).",
          "name": "1"
        },
        {
          "description": "Draw the text center aligned.",
          "name": "2"
        },
        {
          "description": "Draw the text left aligned (or at the bottom when in vertical mode).",
          "name": "3"
        }
      ]
    },
    "hud_speed_tick_spacing": {
      "desc": "Sets the \"tick spacing\" for the speed hud item.",
      "group-id": "19",
      "type": "float"
    },
    "hud_speed_vertical": {
      "desc": "Sets whetever the speed hud item should be drawn vertically or horizontally.",
      "group-id": "19",
      "remarks": "Also see hud_speed_vertical_text to choose if the text should be drawn vertically also.",
      "type": "boolean",
      "values": [
        {
          "description": "Draw speed horizontally.",
          "name": "false"
        },
        {
          "description": "Draw speed vertically.",
          "name": "true"
        }
      ]
    },
    "hud_speed_vertical_text": {
      "desc": "Sets whetever the text on the speed hud item should be drawn vertically when the hud item itself is being drawn vertically.",
      "group-id": "19",
      "remarks": "This has no effect if the hud item isn't drawn vertically.",
      "type": "boolean",
      "values": [
        {
          "description": "Draw the text horizontally.",
          "name": "false"
        },
        {
          "description": "Draw the text vertically when the speed hud item is being drawn vertically.",
          "name": "true"
        }
      ]
    },
    "hud_speed_width": {
      "desc": "Sets the width of the speed hud item.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_speed_xyz": {
      "desc": "Sets This toggles whether the speed is measured over the XY axis (xyz 0) or the XYZ axis (xyz 1)",
      "group-id": "19",
      "type": "float"
    },
    "hud_suit_align_x": {
      "desc": "Sets horizontal align of suit icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_suit_align_y": {
      "desc": "Sets vertical align of suit icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_suit_frame": {
      "desc": "Sets frame visibility and style for suit icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_suit_frame_color": {
      "desc": "Defines the color of the background of the suit HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_suit_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_suit_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_suit_place": {
      "desc": "Sets relative positioning for suit icon.",
      "group-id": "19",
      "type": "string"
    },
    "hud_suit_pos_x": {
      "desc": "Sets horizontal position of suit icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_suit_pos_y": {
      "desc": "Sets vertical position of suit icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_suit_scale": {
      "desc": "Sets size of suit icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_suit_show": {
      "desc": "Switches showing of suit icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_suit_style": {
      "desc": "Switches graphical style of suit icon.",
      "group-id": "19",
      "type": "float"
    },
    "hud_teamfrags_align_x": {
      "desc": "Sets teamfrags HUD element horizontal alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "left, center, right, before, after",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_align_y": {
      "desc": "Sets teamfrags HUD element vertical alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "top, center, bottom, console, before, after",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_bignum": {
      "desc": "Changes the scale of the fragcount number.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "If this is 0 the fragcount will use the normal charset. If it's above 0 it will scale a big number character instead.",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_cell_height": {
      "desc": "Sets cell height for cells in 'teamfrags' HUD element.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "Use positive values.",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_cell_width": {
      "desc": "Sets cell width for cells in 'teamfrags' HUD element.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "Use positive values.",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_colors_alpha": {
      "desc": "Sets the opacity of the teams colors for the teamfrags hud element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_teamfrags_cols": {
      "desc": "Sets number of columns used to draw table in 'teamfrags' HUD element.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "Use positive values.",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_extra_spec_info": {
      "desc": "Enables to see what people have rocket launchers, powerups and how much health and armor they have using icons next to the frags. Works while watching MVD demo.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "No extra information is shown.",
          "name": "0"
        },
        {
          "description": "Show RL, powerups armor and health.",
          "name": "1"
        },
        {
          "description": "Show only powerups.",
          "name": "10"
        },
        {
          "description": "Show only health.",
          "name": "11"
        },
        {
          "description": "Show only armor.",
          "name": "12"
        },
        {
          "description": "Show only RL.",
          "name": "13"
        },
        {
          "description": "Show only RL.  Show weapons as text instead of a picture.",
          "name": "14"
        },
        {
          "description": "Show RL, powerups armor and health.  Show weapons as text instead of a picture.",
          "name": "2"
        },
        {
          "description": "Show powerups, armor and health. (No RL's)",
          "name": "3"
        },
        {
          "description": "Show RL, powerups and health. (No armor)",
          "name": "4"
        },
        {
          "description": "Show RL, powerups and health. (No armor)  Show weapons as text instead of a picture.",
          "name": "5"
        },
        {
          "description": "Show RL, powerups and armor. (No health)",
          "name": "6"
        },
        {
          "description": "Show RL, powerups and armor. (No health)  Show weapons as text instead of a picture.",
          "name": "7"
        },
        {
          "description": "Show RL, armor and health. (No powerups)",
          "name": "8"
        },
        {
          "description": "Show RL, armor and health. (No powerups)  Show weapons as text instead of a picture.",
          "name": "9"
        }
      ]
    },
    "hud_teamfrags_fliptext": {
      "desc": "Toggles alignment of team names in 'teamfrags' HUD element.",
      "group-id": "19",
      "remarks": "Use 'teamfrags shownames 1' to show names of teams.",
      "type": "boolean",
      "values": [
        {
          "description": "Rows aligned to the left side, team tags are on the right side of frag counts.",
          "name": "false"
        },
        {
          "description": "Rows aligned to the right side, team tags are on the left side of frag counts.",
          "name": "true"
        }
      ]
    },
    "hud_teamfrags_frame": {
      "desc": "Sets frame visibility and style for this HUD element.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Adjust background opacity",
          "name": "0.x to 1"
        },
        {
          "description": "Bevelled frame.",
          "name": "2"
        }
      ]
    },
    "hud_teamfrags_frame_color": {
      "desc": "Defines the color of the background of the teamfrags HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamfrags_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_teamfrags_maxname": {
      "desc": "The max number of characters to use for displaying the teamnames in the teamfrags element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamfrags_onlytp": {
      "desc": "Decides whetever the teamfrags hud item should be shown only when in teamplay mode.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Show always.",
          "name": "false"
        },
        {
          "description": "Only show during teamplay.",
          "name": "true"
        }
      ]
    },
    "hud_teamfrags_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamfrags_padtext": {
      "desc": "Toggles text padding in 'frags' HUD element.",
      "group-id": "19",
      "remarks": "Use 'teamfrags shownames 1'.",
      "type": "boolean",
      "values": [
        {
          "description": "No spaces between text fields.",
          "name": "false"
        },
        {
          "description": "Adds padding so frags and team tags are aligned into columns.",
          "name": "true"
        }
      ]
    },
    "hud_teamfrags_place": {
      "desc": "Sets placement for this HUD element. You can align some elements relative to other elements.",
      "group-id": "19",
      "remarks": "First you have to decide, if the element that you are locating now (element B) is to be positioned inside another element (element A) or outside it. See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "to place this element inside element B set this variable to \"@B\", to place it outside B element set this variable to \"B\"",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_pos_x": {
      "desc": "Sets horizontal position of this HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_teamfrags_pos_y": {
      "desc": "Sets vertical position of this HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_teamfrags_rows": {
      "desc": "Sets number of rows used to draw table in 'teamfrags' HUD element.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "Use positive values.",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_show": {
      "desc": "Toggles visibility of this HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw this element",
          "name": "false"
        },
        {
          "description": "Draw this element",
          "name": "true"
        }
      ]
    },
    "hud_teamfrags_shownames": {
      "desc": "Draws players' team tags next to frag counts in 'teamfrags' HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display team tags.",
          "name": "false"
        },
        {
          "description": "Display team tags.",
          "name": "true"
        }
      ]
    },
    "hud_teamfrags_space_x": {
      "desc": "Sets horizontal spacing for teamfrags fields.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "Use zero or positive values.",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_space_y": {
      "desc": "Sets vertical spacing for teamfrags fields.",
      "group-id": "19",
      "type": "integer",
      "values": [
        {
          "description": "Use zero or positive values.",
          "name": "*"
        }
      ]
    },
    "hud_teamfrags_strip": {
      "desc": "Toggles stripped formatting of teamfrags fields.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Standard display.",
          "name": "false"
        },
        {
          "description": "Stripped format.",
          "name": "true"
        }
      ]
    },
    "hud_teamfrags_style": {
      "desc": "Sets drawing style of 'teamfrags' HUD element.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Golden brackets around field with your team frags.",
          "name": "0"
        },
        {
          "description": "Arrow pointing to your own team frags field.",
          "name": "1"
        },
        {
          "description": "Red rectangle around your own team frags field.",
          "name": "2"
        },
        {
          "description": "Similar to 0.",
          "name": "3"
        },
        {
          "description": "Sets background color for your own team field to 'teamcolor'.",
          "name": "4"
        },
        {
          "description": "Sets background color for fields to teamcolors and enemycolors. Red rectangle around your own field including name and team tag.",
          "name": "5"
        },
        {
          "description": "Red rectangle around your own team field including team tag. Background color only for your own team field and set to 'teamcolor'.",
          "name": "6"
        },
        {
          "description": "Background color for whole table 50% transparent red, your own team field not transparent.",
          "name": "7"
        },
        {
          "description": "Red background color only for your own team field including team tag.",
          "name": "8"
        }
      ]
    },
    "hud_teamfrags_vertical": {
      "desc": "Toggles vertical ordering of teamfrags fields.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Order cells horizontally first.",
          "name": "false"
        },
        {
          "description": "Order cells vertically first.",
          "name": "true"
        }
      ]
    },
    "hud_teamholdbar_align_x": {
      "desc": "Vertical alignment of the teamholdbar HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamholdbar_align_y": {
      "desc": "Vertical alignment of the teamholdbar HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamholdbar_frame": {
      "desc": "Opacity of the background of the teamholdbar HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_teamholdbar_frame_color": {
      "desc": "Defines the color of the background of the teamholdbar HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamholdbar_height": {
      "desc": "Height of the teamholdbar HUD element in pixels. Some elements support relative heights, e.g. 25%",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdbar_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_teamholdbar_onlytp": {
      "desc": "Decides whetever the teamholdbar hud item should be shown only when in teamplay mode, or demo playback.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Always show.",
          "name": "0"
        },
        {
          "description": "Only show when teamplay is on.",
          "name": "1"
        },
        {
          "description": "Only show when in demo playback.",
          "name": "2"
        },
        {
          "description": "Only show when teamplay is on and in demo playback.",
          "name": "3"
        }
      ]
    },
    "hud_teamholdbar_opacity": {
      "desc": "Sets the opacity of the background for the teamholdbar.",
      "group-id": "19",
      "type": "float"
    },
    "hud_teamholdbar_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdbar_place": {
      "desc": "Placement of the teamholdbar HUD element. HUD elements can be place into various screen areas or other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamholdbar_pos_x": {
      "desc": "Horizontal relative position of the teamholdbar HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdbar_pos_y": {
      "desc": "Vertical relative position of the teamholdbar HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdbar_show": {
      "desc": "Visibility of the teamholdbar HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_teamholdbar_show_text": {
      "desc": "Shows the percent for each team on the teamholdbar.",
      "group-id": "19",
      "remarks": "vertical_text can be used when vertical mode is set to draw the text vertically also.",
      "type": "boolean",
      "values": [
        {
          "description": "Don't show the percentages.",
          "name": "false"
        },
        {
          "description": "Show the percentages for the teams.",
          "name": "true"
        }
      ]
    },
    "hud_teamholdbar_vertical": {
      "desc": "Draw the teamholdbar vertically.",
      "group-id": "19",
      "remarks": "Use vertical_text to make the text vertical also.",
      "type": "boolean",
      "values": [
        {
          "description": "Draw horizontally.",
          "name": "false"
        },
        {
          "description": "Draw vertically.",
          "name": "true"
        }
      ]
    },
    "hud_teamholdbar_vertical_text": {
      "desc": "Draw the text vertically for the teamholdbar.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Draw the text horizontally.",
          "name": "false"
        },
        {
          "description": "Draw the text vertically.",
          "name": "true"
        }
      ]
    },
    "hud_teamholdbar_width": {
      "desc": "Width of the teamholdbar HUD element in pixels. Some elements support relative width, e.g. 25%",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdinfo_align_x": {
      "desc": "Vertical alignment of the teamholdinfo HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamholdinfo_align_y": {
      "desc": "Vertical alignment of the teamholdinfo HUD element. See the HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamholdinfo_frame": {
      "desc": "Opacity of the background of the teamholdinfo HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_teamholdinfo_frame_color": {
      "desc": "Defines the color of the background of the teamholdinfo HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamholdinfo_height": {
      "desc": "Height of the teamholdinfo HUD element in pixels. Some elements support relative heights, e.g. 25%",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdinfo_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_teamholdinfo_itemfilter": {
      "desc": "Decides what items should be shown in the list.",
      "group-id": "19",
      "remarks": "Any character/whitespace can be used as a delimiter. Make sure you enter the value between quotes if you use whitespaces.",
      "type": "string",
      "values": [
        {
          "description": "Values: RL, LG, GL, SNG, Quad, Pent, Ring, Suit, Mega, RA, YA, GA",
          "name": "*"
        }
      ]
    },
    "hud_teamholdinfo_onlytp": {
      "desc": "Decides whetever the teamholdinfo hud item should be shown only when in teamplay mode, or demo playback.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Always show.",
          "name": "0"
        },
        {
          "description": "Only show when teamplay is on.",
          "name": "1"
        },
        {
          "description": "Only show when in demo playback.",
          "name": "2"
        },
        {
          "description": "Only show when teamplay is on and in demo playback.",
          "name": "3"
        }
      ]
    },
    "hud_teamholdinfo_opacity": {
      "desc": "Sets the background opacity for the teamholdinfo hud element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_teamholdinfo_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdinfo_place": {
      "desc": "Placement of the teamholdinfo HUD element. HUD elements can be place into various screen areas or other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_teamholdinfo_pos_x": {
      "desc": "Horizontal relative position of the teamholdinfo HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdinfo_pos_y": {
      "desc": "Vertical relative position of the teamholdinfo HUD element.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teamholdinfo_show": {
      "desc": "Visibility of the teamholdinfo HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_teamholdinfo_style": {
      "desc": "The style of the teamholdinfo hud item.",
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Show the name of the team holding the items next to it.",
          "name": "0"
        },
        {
          "description": "Show a teamholdbar for each item showing how much of the item each team is holding.",
          "name": "1"
        }
      ]
    },
    "hud_teamholdinfo_width": {
      "desc": "Width of the teamholdinfo HUD element in pixels. Some elements support relative width, e.g. 25%",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teaminfo_align_right": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_teaminfo_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_teaminfo_armor_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_flag_style": {
      "group-id": "19",
      "type": "enum",
      "values": [
        {
          "description": "Flag icons.",
          "name": "1"
        },
        {
          "description": "Colored text.",
          "name": "2"
        }
      ]
    },
    "hud_teaminfo_frame": {
      "group-id": "19",
      "type": "float"
    },
    "hud_teaminfo_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_header_spacing": {
      "desc": "Lines spacing between teams when showing headers",
      "group-id": "19",
      "type": "float"
    },
    "hud_teaminfo_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_teaminfo_layout": {
      "group-id": "19",
      "type": "string"
    },
    "hud_teaminfo_loc_width": {
      "desc": "Number of character spaces used to display the location information in hud_teaminfo.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teaminfo_low_health": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_name_width": {
      "desc": "Number of character spaces used to display the player name in hud_teaminfo.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_teaminfo_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_teaminfo_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_powerup_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_teaminfo_show": {
      "desc": "Display information about your team and optionally enemies.",
      "group-id": "19",
      "remarks": "Enemy information can be enabled through hud_teaminfo_show_enemies 1.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_teaminfo_show_ammo": {
      "desc": "Display ammo count next to best weapon in the teaminfo.",
      "group-id": "19",
      "remarks": "If disabled, ammo can still be displayed by adding %c to /hud_teaminfo_layout",
      "type": "boolean",
      "values": [
        {
          "description": "Do not show ammo next to best weapon",
          "name": "0"
        },
        {
          "description": "Show ammo next to best weapon",
          "name": "1"
        }
      ]
    },
    "hud_teaminfo_show_countdown": {
      "desc": "Shows respawn time instead of powerups during wipeout mode.",
      "group-id": "19",
      "remarks": "If disabled, countdown can still be displayed by adding %r to /hud_teaminfo_layout",
      "type": "boolean",
      "values": [
        {
          "description": "Do not show respawn time instead of powerups in wipeout mode",
          "name": "0"
        },
        {
          "description": "Show respawn time instead of powerups in wipeout mode",
          "name": "1"
        }
      ]
    },
    "hud_teaminfo_show_enemies": {
      "desc": "Show information about the enemy team(s) in the teaminfo window. Displays a header for each team consisting of the team name and the current team score.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Hides information about enemy team(s)",
          "name": "false"
        },
        {
          "description": "Shows information about enemy team(s)",
          "name": "true"
        }
      ]
    },
    "hud_teaminfo_show_self": {
      "desc": "Display your self (or player spectated) in the teaminfo list.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "hud_teaminfo_weapon_style": {
      "group-id": "19",
      "type": ""
    },
    "hud_tp_need": {
      "desc": "Toggles connection of tp_need_* variables with hud elements.",
      "group-id": "19",
      "remarks": "E.g.: Use with 'tp_need_health 40' and your health indicator will display red numbers if your health is 40 or lower.",
      "type": "boolean",
      "values": [
        {
          "description": "Numbers in HUD elements get red when below standard values.",
          "name": "false"
        },
        {
          "description": "Numbers in HUD get red when they are lower than appropriate tp_need_* values.",
          "name": "true"
        }
      ]
    },
    "hud_tracking_align_x": {
      "desc": "Sets tracking HUD element horizontal alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "left, center, right, before, after",
          "name": "*"
        }
      ]
    },
    "hud_tracking_align_y": {
      "desc": "Sets tracking HUD element vertical alignment.",
      "group-id": "19",
      "remarks": "See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "top, center, bottom, console, before, after",
          "name": "*"
        }
      ]
    },
    "hud_tracking_format": {
      "desc": "Changes the format of descriptive text displayed when you are tracking someone as spectator or watching a demo where you can see player's team and name.",
      "group-id": "19",
      "type": "string",
      "values": [
        {
          "description": "Pattern %n will be replaced with tracked player's name, %t will be replaced with player's team.",
          "name": "*"
        }
      ]
    },
    "hud_tracking_frame": {
      "desc": "Sets frame visibility and style for this HUD element.",
      "group-id": "19",
      "type": "float",
      "values": [
        {
          "description": "Adjust background opacity",
          "name": "0.x to 1"
        },
        {
          "description": "Bevelled frame.",
          "name": "2"
        }
      ]
    },
    "hud_tracking_frame_color": {
      "desc": "Defines the color of the background of the tracking HUD element. See HUD manual for more info.",
      "group-id": "19",
      "type": "string"
    },
    "hud_tracking_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_tracking_order": {
      "desc": "This defines the order of drawing the HUD elements. That means you can change will be drawn on top of other elements. See HUD manual for more info.",
      "group-id": "19",
      "type": "integer"
    },
    "hud_tracking_place": {
      "desc": "Sets placement for this HUD element. You can align some elements relative to other elements.",
      "group-id": "19",
      "remarks": "First you have to decide, if the element that you are locating now (element B) is to be positioned inside another element (element A) or outside it. See HUD manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "to place this element inside element B set this variable to \"@B\", to place it outside B element set this variable to \"B\"",
          "name": "*"
        }
      ]
    },
    "hud_tracking_pos_x": {
      "desc": "Sets horizontal position of this HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_tracking_pos_y": {
      "desc": "Sets vertical position of this HUD element.",
      "group-id": "19",
      "type": "float"
    },
    "hud_tracking_scale": {
      "group-id": "19",
      "type": ""
    },
    "hud_tracking_show": {
      "desc": "Toggles visibility of this HUD element.",
      "group-id": "19",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw this element",
          "name": "false"
        },
        {
          "description": "Draw this element",
          "name": "true"
        }
      ]
    },
    "hud_vidlag_align_x": {
      "group-id": "19",
      "type": "string"
    },
    "hud_vidlag_align_y": {
      "group-id": "19",
      "type": "string"
    },
    "hud_vidlag_frame": {
      "group-id": "19",
      "type": ""
    },
    "hud_vidlag_frame_color": {
      "group-id": "19",
      "type": ""
    },
    "hud_vidlag_item_opacity": {
      "group-id": "19",
      "type": "float"
    },
    "hud_vidlag_order": {
      "group-id": "19",
      "type": ""
    },
    "hud_vidlag_place": {
      "group-id": "19",
      "type": "string"
    },
    "hud_vidlag_pos_x": {
      "group-id": "19",
      "type": ""
    },
    "hud_vidlag_pos_y": {
      "group-id": "19",
      "type": ""
    },
    "hud_vidlag_show": {
      "group-id": "19",
      "type": ""
    },
    "hud_vidlag_style": {
      "group-id": "19",
      "type": ""
    },
    "ignore_flood": {
      "default": "0",
      "group-id": "3",
      "type": "enum",
      "values": [
        {
          "description": "Off.",
          "name": "0"
        },
        {
          "description": "Ignores repeated 'say' and spectator messages.",
          "name": "1"
        },
        {
          "description": "Ignores repeated 'say', 'say_team' and spectator messages.",
          "name": "2"
        }
      ]
    },
    "ignore_flood_duration": {
      "default": "4",
      "desc": "You can change the 4 second cooldown with the 'ignore_flood_duration' variable.",
      "group-id": "3",
      "type": "float"
    },
    "ignore_mode": {
      "default": "0",
      "desc": "Someone is on your ignore list, you won't see any messagemode (/say hello) messages from them (even if they are a spec).",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "Ignore say only.",
          "name": "false"
        },
        {
          "description": "Ignore say_team too.",
          "name": "true"
        }
      ]
    },
    "ignore_no_weapon": {
      "default": "0",
      "desc": "Toggle showing the \"no weapon.\" message emitted by KTX when attempting to fire a weapon you don't have.",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "ignore_not_enough_ammo": {
      "default": "0",
      "desc": "Toggle showing the \"not enough ammo.\" message emitted by KTX when attempting to fire a weapon without enough ammo.",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "ignore_opponents": {
      "default": "0",
      "group-id": "3",
      "type": "enum",
      "values": [
        {
          "description": "Do not ignore opponent team.",
          "name": "0"
        },
        {
          "description": "Alway ignore opponent team.",
          "name": "1"
        },
        {
          "description": "Only ignore opponent team during the match.",
          "name": "2"
        }
      ]
    },
    "ignore_qizmo_spec": {
      "default": "0",
      "desc": "Ignores all Qizmo spectators (= observers). Very useful on big matches with 100 and more spectators.",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "Ignoring OFF.",
          "name": "false"
        },
        {
          "description": "Ignoring ON.",
          "name": "true"
        }
      ]
    },
    "ignore_qtv": {
      "default": "0",
      "desc": "Ignore chat messages from the Quake-TV broadcast.",
      "group-id": "3",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "ignore_spec": {
      "default": "0",
      "group-id": "3",
      "type": "enum",
      "values": [
        {
          "description": "Off",
          "name": "0"
        },
        {
          "description": "Ignore spec chat unless you are a spectator.",
          "name": "1"
        },
        {
          "description": "Ignore spec chat even if you are a spectator.",
          "name": "2"
        }
      ]
    },
    "image_jpeg_quality_level": {
      "default": "75",
      "desc": "You can set quality of jpeg screenshots with 'image_jpeg_quality_level x' where x is an integer from 0 to 100 inclusive.\nThe larger x is, the better the quality of a jpeg screenshot, but also the bigger the size.",
      "group-id": "41",
      "type": "float"
    },
    "image_png_compression_level": {
      "default": "1",
      "desc": "You can set the amount of png compression with 'image_png_compression_level x' where x is an integer from 0 to 9 inclusive.\n0 gives no compression and 9 gives maximum compression (and slowest writing time).",
      "group-id": "41",
      "type": "float"
    },
    "in_builtinkeymap": {
      "default": "0",
      "desc": "Allows you to use old Quake keyboard mapping.",
      "group-id": "9",
      "type": "boolean",
      "values": [
        {
          "description": "Use your operating system keyboard layout",
          "name": "false"
        },
        {
          "description": "Use Quake keyboard layout",
          "name": "true"
        }
      ]
    },
    "in_di_buffered": {
      "desc": "Direct Input: Use Immedia data instead of buffered mode of reading.",
      "group-id": "28",
      "remarks": "This setting has been added only because Direct Input allows such mode of use. It is not going to decrease input lag, make the mouse responsiveness better, or anything like that. Read the official documentation on Direct Input to know the difference between buffered and immediate mode of use.",
      "type": "boolean",
      "values": [
        {
          "description": "Use immediate data",
          "name": "false"
        },
        {
          "description": "Use events buffer to process the input data",
          "name": "true"
        }
      ]
    },
    "in_di_bufsize": {
      "desc": "Size of the direct input buffer.",
      "group-id": "28",
      "remarks": "On some circumstances the default size does not have to be sufficient.",
      "type": "integer"
    },
    "in_evdevice": {
      "desc": "Specify device for evdev mouse.\nShould be absolute path like /dev/input/event0.\nUse in_evdevlist command to get lost of devices.",
      "group-id": "28",
      "remarks": "You should have read access to your device.\nsudo chmod 644 /dev/input/event* should help you if you have trouble.",
      "type": "string",
      "values": [
        {
          "description": "absolute path to mouse event device",
          "name": "*"
        }
      ]
    },
    "in_grab_windowed_mouse": {
      "default": "1",
      "desc": "If set, will grab mouse input when not fullscreen.",
      "group-id": "11",
      "type": "boolean"
    },
    "in_ignore_deadkeys": {
      "default": "1",
      "desc": "Ignores operating-system interpretation of keypresses while deadkey is held down",
      "group-id": "11",
      "systems": [
        "macos"
      ],
      "type": "enum",
      "values": [
        {
          "description": "Disabled",
          "name": "0"
        },
        {
          "description": "Enabled when option keys are held down",
          "name": "1"
        },
        {
          "description": "Enabled when alt keys are held down (for standard keyboard on MacOS)",
          "name": "2"
        }
      ]
    },
    "in_ignore_touch_events": {
      "default": "1",
      "desc": "If set, will ignore events from touch inputs (events from a real mouse should be unaffected)",
      "group-id": "11",
      "type": "boolean"
    },
    "in_ignore_unfocused_keyb": {
      "default": "0",
      "desc": "If set, will ignore keyboard events received immediately after regaining focus.  Should stop shortcut keys from firing in-game.",
      "group-id": "11",
      "remarks": "X11 systems only.",
      "systems": [
        "linux"
      ],
      "type": "boolean"
    },
    "in_m_os_parameters": {
      "desc": "Allows you to use your system mouse settings in the client.",
      "group-id": "28",
      "type": "enum",
      "values": [
        {
          "description": "Do not keep any of the system mouse settings",
          "name": "0"
        },
        {
          "description": "Keep acceleration settings",
          "name": "1"
        },
        {
          "description": "Keep speed settings",
          "name": "2"
        },
        {
          "description": "Keep both acceleration and speed settings",
          "name": "3"
        }
      ]
    },
    "in_m_smooth": {
      "desc": "Enables advanced mouse smoothing.\nYou have to be using Direct Input for this to work.",
      "group-id": "28",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "in_mmt": {
      "desc": "Multithreaded mouse.\nFor most users in_mmt 1 + evdev gives the most smooth input.",
      "group-id": "28",
      "remarks": "Linux only and evdev (in_mouse 3) only.",
      "type": "boolean",
      "values": [
        {
          "description": "Read mouse data in main thread",
          "name": "false"
        },
        {
          "description": "Use separate thread for reading mouse data",
          "name": "true"
        }
      ]
    },
    "in_mouse": {
      "desc": "Different types of mouse input\n[OBSOLETE in ezQuake 3.0]",
      "group-id": "28",
      "remarks": "Linux: You have to set in_evdevice to proper value (/dev/input/eventX). Use command in_evdevlist to get the lost of proper values. Also in_mmt makes your mouse more smooth.",
      "type": "enum",
      "values": [
        {
          "description": "Mouse off",
          "name": "0"
        },
        {
          "description": "Windows: standard mouse; Linux: DGA mouse",
          "name": "1"
        },
        {
          "description": "Windows: Direct Input; Linux: X Mouse",
          "name": "2"
        },
        {
          "description": "Windows: Raw Input; Linux: EVDEV mouse",
          "name": "3"
        }
      ]
    },
    "in_raw": {
      "default": "1",
      "desc": "Whether or not ezQuake will use raw input to sample mouse events.",
      "group-id": "11",
      "remarks": "It is recommended to leave this set.",
      "type": "boolean",
      "values": [
        {
          "description": "Disabled, correlates to /in_mouse 1 in ezQuake 2.2",
          "name": "false"
        },
        {
          "description": "Enabled, correlates to /in_mouse 3 in ezQuake 2.2",
          "name": "true"
        }
      ]
    },
    "in_raw_allbuttons": {
      "desc": "Forces RAW Input handler to treat more incoming signals as mouse buttons.\nHelps if you cannot get some mouse buttons working in the game.",
      "group-id": "28",
      "type": "boolean",
      "values": [
        {
          "description": "Only standard set of events is interpreted as mouse buttons",
          "name": "false"
        },
        {
          "description": "More events are interpreted as mouse buttons",
          "name": "true"
        }
      ]
    },
    "in_release_mouse_modes": {
      "default": "2",
      "desc": "Controls under which mode(s) the cursor will be released back to the operating system when not fullscreen.",
      "group-id": "11",
      "remarks": "To specify more than one mode, add the values together.\n\nTo always release the cursor, set in_grab_windowed_mouse 0.",
      "type": "enum",
      "values": [
        {
          "description": "Never release mouse cursor",
          "name": "0"
        },
        {
          "description": "Release when playing (demo playback only)",
          "name": "1"
        },
        {
          "description": "Release when console is down",
          "name": "2"
        },
        {
          "description": "Release when using /messagemode",
          "name": "4"
        },
        {
          "description": "Release when menu on-screen",
          "name": "8"
        },
        {
          "description": "Release when using hud editor",
          "name": "16"
        },
        {
          "description": "Release when using demo controls",
          "name": "32"
        }
      ]
    },
    "irc_server_address": {
      "desc": "IP address of the IRC server to connect to on irc connect command.",
      "group-id": "12",
      "type": "string"
    },
    "irc_server_password": {
      "desc": "Password for IRC server connection.",
      "group-id": "12",
      "type": "string"
    },
    "irc_server_port": {
      "desc": "Port number for IRC server connection.",
      "group-id": "12",
      "type": "integer"
    },
    "irc_user_nick": {
      "desc": "Your nickname used to log-in to the IRC server.",
      "group-id": "12",
      "type": "string"
    },
    "irc_user_realname": {
      "desc": "Real name field used to log-in to the IRC server.",
      "group-id": "12",
      "type": "string"
    },
    "irc_user_username": {
      "desc": "Username used to log-in to the IRC server.",
      "group-id": "12",
      "type": "string"
    },
    "joyadvanced": {
      "default": "0",
      "desc": "Enables advanced joystick features.",
      "group-id": "28",
      "type": "boolean"
    },
    "joyadvaxisr": {
      "default": "0",
      "desc": "Mapping for joystick's R axis.  joyadvanced must be enabled.  See joyadvaxisx for arguments.",
      "group-id": "28",
      "type": "integer"
    },
    "joyadvaxisu": {
      "default": "0",
      "desc": "Mapping for joystick's U axis.  joyadvanced must be enabled.  See joyadvaxisx for arguments.",
      "group-id": "28",
      "type": "integer"
    },
    "joyadvaxisv": {
      "default": "0",
      "desc": "Mapping for joystick's V axis.  joyadvanced must be enabled.  See joyadvaxisx for arguments.",
      "group-id": "28",
      "type": "integer"
    },
    "joyadvaxisx": {
      "default": "0",
      "desc": "Mapping for joystick's X axis.  joyadvanced must be enabled.",
      "group-id": "28",
      "type": "integer",
      "values": [
        {
          "description": "Unmapped (axis input ignored).",
          "name": "0"
        },
        {
          "description": "Map to forward/backward motion.",
          "name": "1"
        },
        {
          "description": "Map to pitch up/down.",
          "name": "2"
        },
        {
          "description": "Map to strafing motion.",
          "name": "3"
        },
        {
          "description": "Map to turning left/right.",
          "name": "4"
        },
        {
          "description": "Map to vertical motion.",
          "name": "5"
        }
      ]
    },
    "joyadvaxisy": {
      "default": "0",
      "desc": "Mapping for joystick's Y axis.  joyadvanced must be enabled.  See joyadvaxisx for arguments.",
      "group-id": "28",
      "type": "integer"
    },
    "joyadvaxisz": {
      "default": "0",
      "desc": "Mapping for joystick's Z axis.  joyadvanced must be enabled.  See joyadvaxisx for arguments.",
      "group-id": "28",
      "type": "integer"
    },
    "joyflysensitivity": {
      "default": "-1.0",
      "desc": "Scale multiplier for vertical movement.",
      "group-id": "28",
      "type": "float"
    },
    "joyflythreshold": {
      "default": "0.15",
      "desc": "Minimum deflection required for vertical movement.\nRange [0.0,1.0]",
      "group-id": "28",
      "type": "float"
    },
    "joyforwardsensitivity": {
      "default": "-1.0",
      "desc": "Scale multiplier for forward movement.",
      "group-id": "28",
      "type": "float"
    },
    "joyforwardthreshold": {
      "default": "0.15",
      "desc": "Minimum deflection required for forward movement.\nRange [0.0,1.0]",
      "group-id": "28",
      "type": "float"
    },
    "joyindex": {
      "default": "0",
      "desc": "Index number of joystick device to use.\nDevices typically start numbering from 0.",
      "group-id": "28",
      "type": "integer"
    },
    "joyname": {
      "default": "joystick",
      "desc": "User-assigned name of the joystick.",
      "group-id": "28",
      "type": "string"
    },
    "joypitchsensitivity": {
      "default": "1.0",
      "desc": "Scale multiplier for pitching up/down.",
      "group-id": "28",
      "type": "float"
    },
    "joypitchthreshold": {
      "default": "0.15",
      "desc": "Minimum deflection required for pitching up/down.\nRange [0.0,1.0]",
      "group-id": "28",
      "type": "float"
    },
    "joysidesensitivity": {
      "default": "-1.0",
      "desc": "Scale multiplier for strafing movement.",
      "group-id": "28",
      "type": "float"
    },
    "joysidethreshold": {
      "default": "0.15",
      "desc": "Minimum deflection required for strafing movement.\nRange [0.0,1.0]",
      "group-id": "28",
      "type": "float"
    },
    "joystick": {
      "default": "0",
      "desc": "Enables usage of joystick device.",
      "group-id": "28",
      "type": "boolean",
      "values": [
        {
          "description": "Do not use joystick.",
          "name": "false"
    },
        {
          "description": "Use joystick input.",
          "name": "true"
        }
      ]
    },
    "joyyawsensitivity": {
      "default": "-1.0",
      "desc": "Scale multiplier for turning left/right.",
      "group-id": "28",
      "type": "float"
    },
    "joyyawthreshold": {
      "default": "0.15",
      "desc": "Minimum deflection required for turning left/right.\nRange [0.0,1.0]",
      "group-id": "28",
      "type": "float"
    },
    "localid": {
      "default": "",
      "group-id": "2",
      "type": "string"
    },
    "log_dir": {
      "default": "",
      "desc": "The logging dir.",
      "group-id": "5",
      "type": "string"
    },
    "log_readable": {
      "default": "1",
      "description": "Converts all non-printable characters to printable characters in your log (ie colored text, Ocrana LEDs) to make it more readable.",
      "group-id": "5",
      "type": "boolean"
    },
    "lookspring": {
      "default": "0",
      "desc": "This variable toggles the centering of the screen after the -klook command.",
      "group-id": "10",
      "type": "boolean",
      "values": [
        {
          "description": "Disable automatic force_centerview.",
          "name": "false"
        },
        {
          "description": "Enable automatic force_centerview.",
          "name": "true"
        }
      ]
    },
    "lookstrafe": {
      "default": "0",
      "desc": "This variable toggles the automatic strafing when the +klook command is used.\nWhen set to \"1\" and the player used the +klook command, the keys that are bound to the +left and +right commands will now act as if they were bound to +moveleft and +moveright.\nThis command was put it in order to allow keyboard player to combine the +strafe and +klook commands into one.\nThis command also has effect on the mouse controls. When set to \"1\" moving the mouse left and right will make the player move left and right instead of making him turn left and right.",
      "group-id": "10",
      "type": "float"
    },
    "m_accel": {
      "default": "0",
      "desc": "Values >0 will amplify mouse movement proportional to velocity.\nSmall values have great effect.",
      "group-id": "11",
      "remarks": "A lot of good Quake Live players use around the 0.1-0.2 mark, but this depends on your mouse CPI and polling rate.",
      "type": "float"
    },
    "m_accel_offset": {
      "default": "0",
      "desc": "Acceleration will not be active until the mouse movement exceeds this speed (counts per millisecond).\nNegative values are supported, which has the effect of causing higher rates of acceleration to happen at lower velocities.",
      "group-id": "11",
      "type": "float"
    },
    "m_accel_power": {
      "default": "2",
      "desc": "Values 1 or below are dumb.\n2 is linear and the default.\nAbove 2 begins to amplify exponentially and you will get more acceleration at higher velocities. Great if you want low accel for slow movements, and high accel for fast movements. Good in combination with a sensitivity cap (m_accel_senscap)",
      "group-id": "11",
      "type": "float"
    },
    "m_accel_senscap": {
      "default": "0",
      "desc": "Sets an upper limit on the amplified mouse movement. Great for tuning acceleration around lower velocities while still remaining in control of fast motion such as flicking.",
      "group-id": "11",
      "type": "float"
    },
    "m_filter": {
      "default": "0",
      "desc": "This variable toggles mouse input filtering.\nWhen set to \"1\", the values which are received from the mouse's input will first be averaged together and then that value will be used in the game.\nThe reason for this command is that some mice had problems with sending sporadic coordinates which make the input from the mouse jerky, also when using a serial or PS/2 mouse, the Windows operating system will only sample mouse input every 25ms, that is 40 times a second (for USB mice the sample rate is 125 Hz, that is every 8 ms).\nWhen set to \"1\" this variable will smooth out the input but it will cause latency between the movement of the mouse and the actual response in the game.\nWhen using a PS/2 mouse it is thus first recommended to try to increase the sampling rate either by changing it via your mouse driver or by using the ps2rate program which can be downloaded at ps2rate homepage.\nIf you are playing the game at frame rates above 40 FPS and if you can't increase the sampling rate of your PS/2 rate or if you are playing with a serial mouse it is recommended that you enable this toggle.",
      "group-id": "11",
      "type": "float"
    },
    "m_forcewheel": {
      "group-id": "28",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "If you have problems to get MWHEELUP and MWHEELDOWN working set this to 1.",
          "name": "true"
        }
      ]
    },
    "m_forward": {
      "default": "1",
      "desc": "This variable controls how fast the player should move forward and back when the mouse is moved forward and back.\nThis command has no effect if the +mlook command is in effect because when the mouse is moved forward and back the player looks up and down instead of moving forward and back.\nSome players might want to set this variable to \"0\" if they happen not to use +mlook constantly and they only want to use the mouse to turn the player.\nSetting this variable to \"0\" will prevent the inadvertent movement of the player forward and back while trying to make precise turns with the mouse.",
      "group-id": "11",
      "type": "float"
    },
    "m_pitch": {
      "default": "0.022",
      "desc": "This variable sets the level of precision when the mouse is used to make the player look up and down while the +mlook command is in effect.\nBy default this variable is set in such a way that moving the mouse forward makes the player look up and moving the mouse backward makes the player look down.\nSome people prefer to have this movement inverted just like it is inverted for airplane controls.\nIf you wish to use this inverted mouse movement then you should set this variable to a negative value (for example \"-0.022\"). It is a matter of preference which movement method is used by players.\nAlso lowering the value for this variable will increase the level of precision when the mouse is used to make the player look up and down.\nThis variable can be used separately from the sensitivity variable to provide greater control over the mouse sensitivity for movement along the pitch. It is advisable to keep the value for this variable constant at 0.022 or -0.022 and instead use the sensitivity variable to change the overall sensitivity of the mouse.\nAlso, some script writers lower the value for this variable along with a lowered value for the fov variable in order to provide more precision when the fov variable is used to zoom.",
      "group-id": "11",
      "type": "float"
    },
    "m_rate": {
      "desc": "This variable should be set to your mouse rate (in Hz).\nNote: need -m_smooth and -dinput to commandline.",
      "group-id": "28",
      "type": "float"
    },
    "m_showrate": {
      "group-id": "28",
      "remarks": "Note: need -m_smooth and -dinput to commandline.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable",
          "name": "false"
        },
        {
          "description": "Print current mouse rate",
          "name": "true"
        }
      ]
    },
    "m_side": {
      "default": "0.8",
      "desc": "When the +strafe command is active or when \"lookspring\" is set to \"1\" this variable is used to control the sensitivity when the mouse is moved left and right to make the player move left and right.",
      "group-id": "11",
      "type": "float"
    },
    "m_yaw": {
      "default": "0.022",
      "desc": "This variable controls how fast the player turns left and right when the mouse is moved left and right.\nIt is recommended that this variable be left alone and instead the \"sensitivity\" variable is used to change the level of precision.\nIf you set this variable to a negative value you will reverse the mouse movement.\nSome script writers use this variable to increase the level of precision when the \"fov\" variable is used to zoom the screen.",
      "group-id": "11",
      "type": "float"
    },
    "mapname": {
      "default": "",
      "desc": "Contains the name of the current map.",
      "group-id": "2",
      "type": "string"
    },
    "match_auto_logconsole": {
      "default": "1",
      "desc": "When set to 1 or 2, a temp console log will automatically be created when a match starts (usually when the countdown starts).",
      "group-id": "16",
      "type": "enum",
      "values": [
        {
          "description": "Do not auto-log console.",
          "name": "0"
        },
        {
          "description": "Auto record console but requires manuall saving. See 'match_save'.",
          "name": "1"
        },
        {
          "description": "Automatically saves the console log after the match is completed.",
          "name": "2"
        }
      ]
    },
    "match_auto_logupload": {
      "default": "0",
      "desc": "Automatically upload match console log to remote server specified in match_auto_logurl.",
      "group-id": "16",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "match_auto_logupload_token": {
      "default": "",
      "group-id": "16",
      "type": "string"
    },
    "match_auto_logurl": {
      "default": "http://stats.quakeworld.nu/logupload",
      "group-id": "16",
      "type": "string"
    },
    "match_auto_minlength": {
      "default": "30",
      "desc": "When using 'match_auto_record 2', temp demo's auto recorded won't be saved automatically if they are shorter than the number of seconds match_auto_minlength' is set to.",
      "group-id": "16",
      "remarks": "If a temp demo is too short to autosave, you can still save it manually with \"match_save\".",
      "type": "integer",
      "values": [
        {
          "description": "number of seconds",
          "name": "*"
        }
      ]
    },
    "match_auto_record": {
      "default": "0",
      "desc": "When set to 1 or 2, a temp demo will automatically be recorded when a match starts (usually when the countdown starts).",
      "group-id": "16",
      "type": "enum",
      "values": [
        {
          "description": "No auto recording.",
          "name": "0"
        },
        {
          "description": "Demo will be recorded but requires manual saving with match_save",
          "name": "1"
        },
        {
          "description": "Automatically saves the demo after the match is completed.",
          "name": "2"
        }
      ]
    },
    "match_auto_spectating": {
      "default": "0",
      "desc": "When set to 1, auto recording will also occur when in spectator mode.",
      "group-id": "16",
      "type": "boolean",
      "values": [
        {
          "description": "Don't auto record demos in spectator mode.",
          "name": "false"
        },
        {
          "description": "Auto record demos even in spectator mode.",
          "name": "true"
        }
      ]
    },
    "match_auto_sshot": {
      "default": "0",
      "desc": "Automatically take a screenshot at the end of a game.\nIf your console is down or you are in the menus, the client will remove the console/menu for a split second so it can take a screenshot of the scoreboard without any interference.",
      "group-id": "16",
      "type": "boolean",
      "values": [
        {
          "description": "Do not take auto screenshot.",
          "name": "false"
        },
        {
          "description": "Take auto screenshot on match end.",
          "name": "true"
        }
      ]
    },
    "match_auto_unminimize": {
      "default": "1",
      "desc": "Bring client from minimized state on countdown start.",
      "group-id": "16",
      "remarks": "Only works on KT* servers.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "match_challenge": {
      "default": "0",
      "desc": "When enabled, sends announcements to duel ladder server about match start and match end.\nCan be activated by special startup *.qw file or by opening special qw: URL.",
      "group-id": "16",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "match_challenge_url": {
      "default": "http://stats.quakeworld.nu/post-challenge",
      "desc": "Web address where POST requests announcing challenge match start and end will be sent.",
      "group-id": "16",
      "type": "string"
    },
    "match_format_2on2": {
      "default": "2on2/%n - [%k%v%l] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"qw\", 2 teams with at least 1 team having 2 people)",
          "name": "*"
        }
      ]
    },
    "match_format_3on3": {
      "default": "tdm/%n - [%Oon%E_%t%v%e] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"qw\", 2 teams with at least 1 team having 3 people)",
          "name": "*"
        }
      ]
    },
    "match_format_4on4": {
      "default": "tdm/%n - [%Oon%E_%t%v%e] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"qw\", 2 teams with at least 1 team having 4 people)",
          "name": "*"
        }
      ]
    },
    "match_format_arena": {
      "default": "arena/%n - %p%v%e - [%F_frags] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"arena\")",
          "name": "*"
        }
      ]
    },
    "match_format_coop": {
      "default": "coop/%n - [%C_player_coop] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"qw\", at least 2 people, deathmatch is off)",
          "name": "*"
        }
      ]
    },
    "match_format_duel": {
      "default": "duel/%n - %p%v%e - [dmm%D] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"qw\", 2 players)",
          "name": "*"
        }
      ]
    },
    "match_format_ffa": {
      "default": "ffa/%n - [%C_player_ffa] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"qw\", more than 2 players, teamplay off)",
          "name": "*"
        }
      ]
    },
    "match_format_multiteam": {
      "default": "tdm/%n - [%a_%b] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"qw\", 3 or more teams)",
          "name": "*"
        }
      ]
    },
    "match_format_race": {
      "default": "race/%n - [race] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = qw, serverinfo \"race\" key present and equal to mapname)",
          "name": "*"
        }
      ]
    },
    "match_format_solo": {
      "default": "solo/%n - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (any gamedir, 1 player on a server, not in race mode)",
          "name": "*"
        }
      ]
    },
    "match_format_tdm": {
      "default": "tdm/%n - [%Oon%E_%t%v%e] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"qw\", 2 teams with at least 1 team having 5 people)",
          "name": "*"
        }
      ]
    },
    "match_format_tf_clanwar": {
      "default": "tfwar/%n - [%Oon%E_%t%v%e] - [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"fortress\", at least 2 teams)",
          "name": "*"
        }
      ]
    },
    "match_format_tf_duel": {
      "default": "tfduel/%n - %p%v%e [%M]",
      "desc": "Each match category has a name format variable associated with it. This variable is called match_format_<category>. For example, there is match_format_duel, match_format_2on2, etc, etc. All these variables can contain macro's that are expanded according to the macro list given below.  You can also use the \"match_format_macrolist\" command inside the client to display a list of the macros and their meaning.",
      "group-id": "16",
      "remarks": "See 'match_format_macrolist' command and Match tools manual for more info.",
      "type": "string",
      "values": [
        {
          "description": "This pattern will be used in following situation: (gamedir = \"fortress\", 2 players)",
          "name": "*"
        }
      ]
    },
    "match_ladder_id": {
      "default": "1",
      "desc": "Identification of the current duel ladder. Not used right now, always 1.",
      "group-id": "16",
      "type": "string"
    },
    "match_name_and": {
      "default": "_&_",
      "desc": "Used for separating names in %k and %l.",
      "group-id": "16",
      "type": "string"
    },
    "match_name_nick": {
      "default": "",
      "desc": "%n uses this if its not \"\", otherwise it uses your in game name.",
      "group-id": "16",
      "remarks": "See match_format_macrolist.",
      "type": "string"
    },
    "match_name_on": {
      "default": "on",
      "desc": "Used for separating numbers in %a.",
      "group-id": "16",
      "type": "string"
    },
    "match_name_spec": {
      "default": "(SPEC)",
      "desc": "This is placed after your nick when using %n and are in spec mode. Eg. if you use \"match_name_nick foo\" and leave match_name_spec default, then %n will be \"foo(SPEC)\" in spec mode and \"foo\" when not in spec mode.",
      "group-id": "16",
      "remarks": "See match_format_macrolist.",
      "type": "string"
    },
    "match_name_versus": {
      "default": "_vs_",
      "desc": "Used for separating names in %b.",
      "group-id": "16",
      "type": "string"
    },
    "maxclients": {
      "default": "24",
      "desc": "Highest number of players allowed on the server.",
      "group-id": "43",
      "type": "integer"
    },
    "maxfps": {
      "default": "77",
      "group-id": "0",
      "system-generated": true
    },
    "maxspectators": {
      "default": "8",
      "desc": "Highest number of spectators allowed to connect to the server.",
      "group-id": "43",
      "type": "integer"
    },
    "maxvip_spectators": {
      "default": "0",
      "group-id": "43",
      "type": ""
    },
    "menu_advanced": {
      "default": "0",
      "desc": "Shows/hides advanced options entries in the Options menu.",
      "group-id": "17",
      "type": "boolean",
      "values": [
        {
          "description": "Hide advanced options",
          "name": "false"
        },
        {
          "description": "Show advanced options",
          "name": "true"
        }
      ]
    },
    "menu_botmatch_gamedir": {
      "default": "fbca",
      "desc": "The gamedir that ezQuake will switch to when starting a botmatch through the multiplayer menu.",
      "group-id": "17",
      "type": "string"
    },
    "menu_botmatch_mod_old": {
      "default": "1",
      "desc": "If set, starting a botmatch through multiplayer menu will disable features that cause problems for older mods that spawn bots as non-clients.",
      "group-id": "17",
      "type": "boolean"
    },
    "menu_ingame": {
      "default": "1",
      "desc": "Enables/disables ingame menu - menu that typically appears if you press Esc key during the game.",
      "group-id": "17",
      "type": "boolean",
      "values": [
        {
          "description": "in-game menu disabled",
          "name": "false"
        },
        {
          "description": "in-game menu enabled",
          "name": "true"
        }
      ]
    },
    "menu_marked_bgcolor": {
      "default": "20 20 20 128",
      "desc": "The color of the selected entry in options menu.",
      "group-id": "17",
      "type": "string"
    },
    "menu_marked_fade": {
      "default": "4",
      "desc": "Speed of menu entry highlight flashing. Zero disables the flashing effect.",
      "group-id": "17",
      "type": "float"
    },
    "msg": {
      "default": "1",
      "group-id": "37",
      "type": "enum",
      "values": [
        {
          "description": "Maximum reporting of messages.",
          "name": "0"
        },
        {
          "description": "Parsed reporting of messages.",
          "name": "1"
        },
        {
          "description": "Limited reporting of messages.",
          "name": "2"
        },
        {
          "description": "Minimal reporting of messages.",
          "name": "3"
        },
        {
          "description": "No reporting of messages.",
          "name": "4"
        }
      ]
    },
    "msg_filter": {
      "default": "0",
      "group-id": "3",
      "type": "enum",
      "values": [
        {
          "description": "Filters nothing (default)",
          "name": "0"
        },
        {
          "description": "Filters mm1 and spec messages",
          "name": "1"
        },
        {
          "description": "Filters mm2 messages",
          "name": "2"
        },
        {
          "description": "Filters mm1, mm2, and spec messages",
          "name": "3"
        }
      ]
    },
    "mtu": {
      "default": "",
      "desc": "Maximum transmission unit size.\nSuggests maximum packet size to server, if supported.",
      "group-id": "37",
      "type": "integer"
    },
    "mumble_enabled": {
      "desc": "Turn on mumble positional audio support.",
      "group-id": "32",
      "remarks": "Requires mumble to be loaded before toggling this on.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "mvd_autoadd_items": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "mvd_autohud": {
      "default": "0",
      "desc": "Will load different Head Up Display settings when watching MultiView Demos.",
      "group-id": "20",
      "type": "enum",
      "values": [
        {
          "description": "Won't do anything",
          "name": "0"
        },
        {
          "description": "Will load appropriate config according to current match type. Possible types: 1on1, 4on4, custom. Config is like cfg/mvdhud_4on4.cfg",
          "name": "1"
        },
        {
          "description": "Will always load cfg/mvdhud_custom.cfg",
          "name": "2"
        }
      ]
    },
    "mvd_autotrack": {
      "default": "0",
      "desc": "Turns auto-tracking function ON / OFF.\nThis feature can be used while watching MultiView Demo. The client will choose and switch to the best player point of view using appropriate algorithm.",
      "group-id": "20",
      "remarks": "You can change the switching algorithm properties using mvd_autotrack_1on1, mvd_autotrack_2on2, etc. variables. The setting no. 4. cannot be customized and is independent on other autotrack client settings, except of mvd_autotrack_lockteam.",
      "type": "enum",
      "values": [
        {
          "description": "Off",
          "name": "0"
        },
        {
          "description": "Autodetect current gametype and use the appropriate xonx settings",
          "name": "1"
        },
        {
          "description": "Force the use of mvd_autotrack_custom* settings",
          "name": "2"
        },
        {
          "description": "Enables the use of mvd_multitrack_1 - 4 allowing to set separate algorithms for every window with cl_multiview 2-4",
          "name": "3"
        },
        {
          "description": "Simple algorithm which prefers pent+rl over quad+rl, quad+rl over pent, quad over noquad, weapon over no weapon player\nCannot be customized",
          "name": "4"
        }
      ]
    },
    "mvd_autotrack_1on1": {
      "default": "%a * %A + 50 * %W + %p + %f",
      "desc": "Will be used if mvd_autotrack = 1 and a 1on1 game is played. Its an algorithm for selecting the best player.",
      "group-id": "20",
      "remarks": "For a full description read the manual.",
      "type": "string"
    },
    "mvd_autotrack_1on1_values": {
      "default": "1 2 3 2 3 5 8 8 1 2 3 0 0 0",
      "desc": "Allows you to customize autotrack algorithm. See autotrack manual page for more info.",
      "group-id": "20",
      "type": "string"
    },
    "mvd_autotrack_2on2": {
      "default": "%a * %A + 50 * %W + %p + %f",
      "desc": "Will be used if mvd_autotrack = 1 and a 2on2 game is played. Its an algorithm for selecting the best player.",
      "group-id": "20",
      "remarks": "For a full description read the manual.",
      "type": "string"
    },
    "mvd_autotrack_2on2_values": {
      "default": "1 2 3 2 3 5 8 8 1 2 3 500 900 1000",
      "desc": "Allows you to customize autotrack algorithm. See autotrack manual page for more info.",
      "group-id": "20",
      "type": "string"
    },
    "mvd_autotrack_4on4": {
      "default": "%a * %A + 50 * %W + %p + %f",
      "desc": "Will be used if mvd_autotrack = 1 and a 4on4 game is played. Its an algorithm for selecting the best player.",
      "group-id": "20",
      "remarks": "For a full description read the manual.",
      "type": "string"
    },
    "mvd_autotrack_4on4_values": {
      "default": "1 2 4 2 4 6 10 10 1 2 3 500 900 1000",
      "desc": "Allows you to customize autotrack algorithm. See autotrack manual page for more info.",
      "group-id": "20",
      "type": "string"
    },
    "mvd_autotrack_custom": {
      "default": "%a * %A + 50 * %W + %p + %f",
      "desc": "Will be used if mvd_autotrack = 2.\n Its an algorithm for selecting the best player.",
      "group-id": "20",
      "remarks": "For a full description read the manual.",
      "type": "string"
    },
    "mvd_autotrack_custom_values": {
      "default": "1 2 3 2 3 4 6 6 1 2 3 500 900 1000",
      "desc": "Allows you to customize autotrack algorithm. See autotrack manual page for more info.",
      "group-id": "20",
      "type": "string"
    },
    "mvd_autotrack_instant": {
      "default": "0",
      "desc": "Makes mvd_autotrack always find the best player and switch to him instantly.",
      "group-id": "20",
      "remarks": "In KTPro autotrack tracked player is changed only when some events happen. In instant mvd_autotrack tracked player is changed everytime a better player is found.",
      "type": "boolean",
      "values": [
        {
          "description": "mvd_autotrack will work more like ktpro autotrack",
          "name": "false"
        },
        {
          "description": "player change will happen more often",
          "name": "true"
        }
      ]
    },
    "mvd_autotrack_lockteam": {
      "default": "0",
      "desc": "If set to 1, autotrack will keep switching POVs only from players within the same team.",
      "group-id": "20",
      "type": "boolean",
      "values": [
        {
          "description": "Autotrack will switch between all players.",
          "name": "false"
        },
        {
          "description": "Autotrack will stay within one team.",
          "name": "true"
        }
      ]
    },
    "mvd_info": {
      "default": "0",
      "desc": "When watching Multi View Demo (.mvd) you can show a table on the screen with full info about players' status.",
      "group-id": "20",
      "remarks": "See mvd_info_setup for setting up displayed informations.",
      "type": "boolean",
      "values": [
        {
          "description": "Turned OFF",
          "name": "false"
        },
        {
          "description": "Turned ON",
          "name": "true"
        }
      ]
    },
    "mvd_info_setup": {
      "default": "%p%n \u0010%l\u0011 %h/%a %w",
      "group-id": "20",
      "type": "string"
    },
    "mvd_info_show_header": {
      "default": "0",
      "desc": "Will show a line above the mvd_info table telling you wich column is armor/health/location etc.",
      "group-id": "20",
      "type": "boolean",
      "values": [
        {
          "description": "Turn Off",
          "name": "false"
        },
        {
          "description": "Turned ON",
          "name": "true"
        }
      ]
    },
    "mvd_info_x": {
      "default": "0",
      "desc": "You can adjust horizontal placement of Players' info table.",
      "group-id": "20",
      "remarks": "See scr_mvdinfo and scr_mvdinfo_setup description for more details.",
      "type": "float"
    },
    "mvd_info_y": {
      "default": "0",
      "desc": "You can adjust vertical placement of Players' info table.",
      "group-id": "20",
      "remarks": "See scr_mvdinfo and scr_mvdinfo_setup description for more details.",
      "type": "float"
    },
    "mvd_moreinfo": {
      "default": "0",
      "desc": "When playing MultiView Demo (MVD), you can turn on more messages printed in the console, like those you might know from moreinfo command in ktpro.\nE.g.: Nabbe picked up quad.",
      "group-id": "20",
      "type": "boolean"
    },
    "mvd_multitrack_1": {
      "default": "%f",
      "desc": "Will be used if mvd_autotrack = 3 and cl_multiview is enabled.\nIts an algorithm for selecting the best player on viewport 1.",
      "group-id": "20",
      "remarks": "For a full description read the manual.",
      "type": "string"
    },
    "mvd_multitrack_1_values": {
      "default": "1 2 3 2 3 5 8 8 1 2 3 0 0 0",
      "desc": "Allows you to customize autotrack algorithm. See autotrack manual page for more info.",
      "group-id": "20",
      "type": "string"
    },
    "mvd_multitrack_2": {
      "default": "%W",
      "desc": "Will be used if mvd_autotrack = 3 and cl_multiview is enabled.\nIts an algorithm for selecting the best player on viewport 2.",
      "group-id": "20",
      "remarks": "For a full description read the manual.",
      "type": "string"
    },
    "mvd_multitrack_2_values": {
      "default": "1 2 3 2 3 5 8 8 1 2 3 0 0 0",
      "desc": "Allows you to customize autotrack algorithm. See autotrack manual page for more info.",
      "group-id": "20",
      "type": "string"
    },
    "mvd_multitrack_3": {
      "default": "%h",
      "desc": "Will be used if mvd_autotrack = 3 and cl_multiview is enabled.\nIts an algorithm for selecting the best player on viewport 3.",
      "group-id": "20",
      "remarks": "For a full description read the manual.",
      "type": "string"
    },
    "mvd_multitrack_3_values": {
      "default": "1 2 3 2 3 5 8 8 1 2 3 0 0 0",
      "desc": "Allows you to customize autotrack algorithm. See autotrack manual page for more info.",
      "group-id": "20",
      "type": "string"
    },
    "mvd_multitrack_4": {
      "default": "%A",
      "desc": "Will be used if mvd_autotrack = 3 and cl_multiview is enabled.\nIts an algorithm for selecting the best player on viewport 4.",
      "group-id": "20",
      "remarks": "For a full description read the manual.",
      "type": "string"
    },
    "mvd_multitrack_4_values": {
      "default": "1 2 3 2 3 5 8 8 1 2 3 0 0 0",
      "desc": "Allows you to customize autotrack algorithm. See autotrack manual page for more info.",
      "group-id": "20",
      "type": "string"
    },
    "mvd_pc_pent_1": {
      "default": "",
      "desc": "Describes the position and viewing angles of the p1 cam.\nx y z rot_x rot_y",
      "group-id": "20",
      "type": "string"
    },
    "mvd_pc_pent_2": {
      "default": "",
      "desc": "Describes the position and viewing angles of the p2 cam.\nx y z rot_x rot_y",
      "group-id": "20",
      "type": "string"
    },
    "mvd_pc_pent_3": {
      "default": "",
      "desc": "Describes the position and viewing angles of the p3 cam.\nx y z rot_x rot_y",
      "group-id": "20",
      "type": "string"
    },
    "mvd_pc_quad_1": {
      "default": "",
      "desc": "Describes the position and viewing angles of the q1 cam.\nx y z rot_x rot_y",
      "group-id": "20",
      "type": "string"
    },
    "mvd_pc_quad_2": {
      "default": "",
      "desc": "Describes the position and viewing angles of the q2 cam.\nx y z rot_x rot_y",
      "group-id": "20",
      "type": "string"
    },
    "mvd_pc_quad_3": {
      "default": "",
      "desc": "Describes the position and viewing angles of the q3 cam.\nx y z rot_x rot_y",
      "group-id": "20",
      "type": "string"
    },
    "mvd_pc_view_1": {
      "default": "",
      "desc": "Sets the powerup camera for viewport 1.",
      "group-id": "20",
      "type": "enum",
      "values": [
        {
          "description": "(disabled)",
          "name": ""
        },
        {
          "description": "mvd_pc_pent_1",
          "name": "p1"
        },
        {
          "description": "mvd_pc_pent_2",
          "name": "p2"
        },
        {
          "description": "mvd_pc_pent_3",
          "name": "p3"
        },
        {
          "description": "mvd_pc_quad_1",
          "name": "q1"
        },
        {
          "description": "mvd_pc_quad_2",
          "name": "q2"
        },
        {
          "description": "mvd_pc_quad_3",
          "name": "q3"
        }
      ]
    },
    "mvd_pc_view_2": {
      "default": "",
      "desc": "Sets the powerup camera for viewport 2.",
      "group-id": "20",
      "type": "enum",
      "values": [
        {
          "description": "(disabled)",
          "name": ""
        },
        {
          "description": "mvd_pc_pent_1",
          "name": "p1"
        },
        {
          "description": "mvd_pc_pent_2",
          "name": "p2"
        },
        {
          "description": "mvd_pc_pent_3",
          "name": "p3"
        },
        {
          "description": "mvd_pc_quad_1",
          "name": "q1"
        },
        {
          "description": "mvd_pc_quad_2",
          "name": "q2"
        },
        {
          "description": "mvd_pc_quad_3",
          "name": "q3"
        }
      ]
    },
    "mvd_pc_view_3": {
      "default": "",
      "desc": "Sets the powerup camera for viewport 3.",
      "group-id": "20",
      "type": "enum",
      "values": [
        {
          "description": "(disabled)",
          "name": ""
        },
        {
          "description": "mvd_pc_pent_1",
          "name": "p1"
        },
        {
          "description": "mvd_pc_pent_2",
          "name": "p2"
        },
        {
          "description": "mvd_pc_pent_3",
          "name": "p3"
        },
        {
          "description": "mvd_pc_quad_1",
          "name": "q1"
        },
        {
          "description": "mvd_pc_quad_2",
          "name": "q2"
        },
        {
          "description": "mvd_pc_quad_3",
          "name": "q3"
        }
      ]
    },
    "mvd_pc_view_4": {
      "default": "",
      "desc": "Sets the powerup camera for viewport 4.",
      "group-id": "20",
      "type": "enum",
      "values": [
        {
          "description": "(disabled)",
          "name": ""
        },
        {
          "description": "mvd_pc_pent_1",
          "name": "p1"
        },
        {
          "description": "mvd_pc_pent_2",
          "name": "p2"
        },
        {
          "description": "mvd_pc_pent_3",
          "name": "p3"
        },
        {
          "description": "mvd_pc_quad_1",
          "name": "q1"
        },
        {
          "description": "mvd_pc_quad_2",
          "name": "q2"
        },
        {
          "description": "mvd_pc_quad_3",
          "name": "q3"
        }
      ]
    },
    "mvd_powerup_cam": {
      "default": "0",
      "desc": "Will enable powerupcams, cams will be enabled on every viewport 5 seconds before the powerup spawns.",
      "group-id": "20",
      "remarks": "For setting up the viewports cams look at mvd_pc_view_1-4.\nFor setting the locations of the cams look at\nmvd_pc_quad_1-3 and mvd_pc_pent_1-3.",
      "type": "boolean",
      "values": [
        {
          "description": "Turn OFF",
          "name": "false"
        },
        {
          "description": "Turned ON",
          "name": "true"
        }
      ]
    },
    "mvd_sortitems": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "mvd_status": {
      "default": "0",
      "desc": "Shows information of the player you are currently tracking.\n\nInformation includes:\n - Taken/dropped items and powerups.\n - Last 3 runs (including the current one)\nRun is from powerup-took/spawn to powerup-end/death.",
      "group-id": "20",
      "type": "boolean",
      "values": [
        {
          "description": "Turned OFF",
          "name": "false"
        },
        {
          "description": "Turned ON",
          "name": "true"
        }
      ]
    },
    "mvd_status_x": {
      "default": "0",
      "desc": "Adjusts the horizontal placement of mvd_status table.",
      "group-id": "20",
      "type": "float"
    },
    "mvd_status_y": {
      "default": "0",
      "desc": "Adjusts the vertical placement of mvd_status table.",
      "group-id": "20",
      "type": "float"
    },
    "mvd_write_xml": {
      "desc": "Enables dumping of XML stats from a MVD.",
      "group-id": "24",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "name": {
      "default": "player",
      "desc": "Player's name.",
      "group-id": "37",
      "type": "string"
    },
    "net_tcp_timeout": {
      "default": "2000",
      "desc": "Timeout (in ms) when making TCP connections (such as connecting to QTV)",
      "group-id": "21",
      "remarks": "Range 500 to 5000.",
      "type": "integer"
    },
    "noaim": {
      "default": "1",
      "desc": "This variable toggles whether a server-sided aiming-help should be used when shooting rockets (not possible when the server variable \"sv_aim\" is set to \"0\").",
      "group-id": "37",
      "type": "boolean",
      "values": [
        {
          "description": "Enable server-side aiming help for rockets (if allowed by the server).",
          "name": "false"
        },
        {
          "description": "Disable server-side aiming help for rockets.",
          "name": "true"
        }
      ]
    },
    "noskins": {
      "default": "0",
      "group-id": "44",
      "type": "enum",
      "values": [
        {
          "description": "Enable skins.",
          "name": "0"
        },
        {
          "description": "Disable skins.",
          "name": "1"
        },
        {
          "description": "Enable skins but do not download new skins.",
          "name": "2"
        }
      ]
    },
    "not_auth_timeout": {
      "desc": "Not currently used.",
      "group-id": "43",
      "type": "integer"
    },
    "password": {
      "default": "",
      "desc": "Password players have to use to connect to local server.",
      "group-id": "43",
      "remarks": "Server-side.",
      "type": "string"
    },
    "pausable": {
      "default": "0",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable pause.",
          "name": "false"
        },
        {
          "description": "Enable pause.",
          "name": "true"
        }
      ]
    },
    "pext_ezquake_verfortrans": {
      "default": "7814",
      "group-id": "0",
      "system-generated": true
    },
    "pm_airstep": {
      "default": "",
      "desc": "Airstep player-move-extension.\nChanges the physics of the game and allows to do jumps on stairs.",
      "group-id": "43",
      "remarks": "Server-side.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "pm_bunnyspeedcap": {
      "default": "",
      "desc": "This is experimental code intended to restore class balance in TF.\nIf you set this cvar to something like 1.5 or 2, a solider will not be able to bunnyhop as fast as a scout does :)\nNote that this cvar is optional and disabled by default, so it will in NO WAY affect gameplay unless you set it explicitly to anything but 0.",
      "group-id": "34",
      "type": "float"
    },
    "pm_ktjump": {
      "default": "1",
      "desc": "If enabled (the standard), when the player jumps, velocity will always be at least 270 (standard jump).\nWithout this set, jumping when moving down a slope would result in lower velocity.",
      "group-id": "34",
      "type": "float"
    },
    "pm_pground": {
      "default": "",
      "desc": "Enables 'persistent onground flag' physics tweak.\nIts only use is that it makes pm_airstep work better.",
      "group-id": "34",
      "remarks": "This extension makes use of Z_EXT_PF_ONGROUND to ensure correct movement prediction by clients. Prediction errors shouldn't be very noticeable anyway even with old clients.",
      "type": "integer"
    },
    "pm_rampjump": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "pm_slidefix": {
      "default": "",
      "desc": "When set to 1, Upon decsension from a sloped surface, the player doesn't \"drop\" (which is a bug in QW), but smoothly slides, as it was in NQ.",
      "group-id": "34",
      "type": "boolean",
      "values": [
        {
          "description": "Disable",
          "name": "false"
        },
        {
          "description": "Enable",
          "name": "true"
        }
      ]
    },
    "qconsole_log_say": {
      "default": "0",
      "desc": "Log chat messages into the main server console log.",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "qizmo_dir": {
      "default": "qizmo",
      "desc": "Change the default qizmo directory.",
      "group-id": "7",
      "type": "string"
    },
    "qport": {
      "default": "0",
      "desc": "Local port the client uses to connect to servers.",
      "group-id": "2",
      "type": "integer"
    },
    "qtv_adjustbuffer": {
      "default": "1",
      "desc": "Enables balancing of the buffer length of the QTV stream.\nWhen turned on, the size of the stream buffer (the delay from the actual action) will be auto-adjusted (by changing the playback speed when necessary) so that it stays on the same level most of the time.",
      "group-id": "38",
      "remarks": "When turned on, the speed of the playback may change sometimes - that's how the buffer length is balanced. But usually you want to have this turned on when you are watching a shoutcast-commentated game because you want to stay synchronized with the commentary.\nSee qtv_buffer hud element for monitoring.",
      "type": "enum",
      "values": [
        {
          "description": "Do not adjust buffer size, always play at 100% speed",
          "name": "0"
        },
        {
          "description": "Auto-adjust buffer size, to stay within % of total buffer length (see /qtv_buffertime, /qtv_adjustlowstart, /qtv_adjusthighstart)",
          "name": "1"
        },
        {
          "description": "Auto-adjust buffer size, to stay close to total buffer length (see /qtv_buffertime)",
          "name": "2"
        }
      ]
    },
    "qtv_adjusthighstart": {
      "default": "1",
      "desc": "The level on which QTV buffer auto-adjusting will start.\nE.g. when set to 1.5, (and qtv_adjustbuffer is 1), QTV buffer auto-adjusting will start when buffer length reached 150% of it's normal length (determined by qtv_buffertime setting)",
      "group-id": "38",
      "type": "float",
      "values": [
        {
          "description": "Only values higher than 1.0 make sense",
          "name": "*"
        }
      ]
    },
    "qtv_adjustlowstart": {
      "default": "0.3",
      "desc": "The bottom level on which QTV buffer auto-adjusting will start.\nE.g. when set to 0.5, (and qtv_adjustbuffer is 1), QTV buffer auto-adjusting will start when buffer length reached 50% of it's normal length (determined by qtv_buffertime setting)",
      "group-id": "38",
      "type": "float",
      "values": [
        {
          "description": "Only values lower than 1.0 make sense",
          "name": "*"
        }
      ]
    },
    "qtv_adjustmaxspeed": {
      "default": "999",
      "desc": "The fastest possible playback speed when QTV buffer becomes excessive and auto-adjusting starts.\nThe higher the speed is, the faster the QTV buffer length will go down to normal levels.",
      "group-id": "38",
      "remarks": "Works in conjunction with qtv_adjustbuffer 1.",
      "type": "float",
      "values": [
        {
          "description": "Only values above 1.0 make sense",
          "name": "*"
        }
      ]
    },
    "qtv_adjustminspeed": {
      "default": "0",
      "desc": "The slowest possible playback speed when QTV buffer adjusting takes action.\nThe slower the speed is, the faster the QTV buffer will fill up.",
      "group-id": "38",
      "remarks": "Not allowing to slow down enough, buffer level might still drop down to zero if there were longer network lag. This causes pausing during playback. Allowing to slow down too much is noticeable.",
      "type": "float",
      "values": [
        {
          "description": "0.5 means 50% of the normal playback speed",
          "name": "*"
        }
      ]
    },
    "qtv_allow_pause": {
      "default": "0",
      "desc": "Allows QTV streams to be affected by cl_demospeed.",
      "group-id": "38",
      "type": "boolean"
    },
    "qtv_api_url": {
      "default": "http://qtvapi.quakeworld.nu/api/v1/servers",
      "desc": "URL used by /qtv command to resolve servers to QTV addresses and vice versa.",
      "group-id": "38",
      "type": "string"
    },
    "qtv_buffertime": {
      "default": "0.5",
      "desc": "Defines how much the client buffers from the QTV stream (in seconds).",
      "group-id": "38",
      "remarks": "This determines the \"delay\" you will get from what is actually happening. For example if you want to synchronize shoutcast commentary with the QTV stream, this is the variable you need to change.",
      "type": "float",
      "values": [
        {
          "description": "Range 0.1 to 30.",
          "name": "*"
        }
      ]
    },
    "qtv_chatprefix": {
      "default": "$[{QTV}$] ",
      "desc": "String that will be added at the beginning of all messages send to a QTV chat.",
      "group-id": "38",
      "type": "string"
    },
    "qtv_event_changename": {
      "default": " &cFF0changed name to&r ",
      "desc": "Text pattern used when an user changes his name on a QTV stream.",
      "group-id": "38",
      "type": "string"
    },
    "qtv_event_join": {
      "default": " &c2F2joined&r",
      "desc": "Text pattern used when an user joins a QTV stream.",
      "group-id": "38",
      "type": "string"
    },
    "qtv_event_leave": {
      "default": " &cF22left&r",
      "desc": "Text pattern used when an user leaves a QTV stream.",
      "group-id": "38",
      "type": "string"
    },
    "qtv_event_msglevel": {
      "default": "2",
      "desc": "Controls the visibility of QTV event messages, allowing them to be enabled, disabled, or hidden during an active match.",
      "group-id": "38",
      "type": "enum",
      "values": [
        {
          "description": "Disables QTV event messages.",
          "name": "0"
        },
        {
          "description": "Enables QTV event messages.",
          "name": "1"
        },
        {
          "description": "Hides QTV event messages when a match has started.",
          "name": "2"
        }
      ]
    },
    "qtv_gamechatprefix": {
      "default": "$[{QTV>game}$] ",
      "desc": "String that will be added at the beginning of all messages send from QTV to the server where the broadcasted game is being played.",
      "group-id": "38",
      "type": "string"
    },
    "qtv_maxstreams": {
      "default": "1",
      "desc": "Maximum number of simultaneous QTV connections.",
      "group-id": "43",
      "type": "integer"
    },
    "qtv_password": {
      "default": "",
      "desc": "Password required for QTV to connect to the streamport.",
      "group-id": "43",
      "type": "string"
    },
    "qtv_pendingtimeout": {
      "default": "5",
      "desc": "Number of seconds to wait before timing out a pending QTV connection.",
      "group-id": "43",
      "type": "float"
    },
    "qtv_prebuffertime": {
      "default": "0",
      "desc": "Number of seconds to buffer before starting playback from QTV.",
      "group-id": "38",
      "remarks": "See /qtv_buffertime.",
      "type": "float",
      "values": [
        {
          "description": "Use qtv_buffertime for prebuffer.",
          "name": "0"
        },
        {
          "description": "Range 0.1 to 10.",
          "name": "*"
        }
      ]
    },
    "qtv_say_team": {
      "default": "0",
      "group-id": "38",
      "type": "boolean",
      "values": [
        {
          "description": "say_team will be blocked when sending to QTV.",
          "name": "false"
        },
        {
          "description": "say_team allowed as normal on QTV.",
          "name": "true"
        }
      ]
    },
    "qtv_sayenabled": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "qtv_skipchained": {
      "default": "1",
      "group-id": "38",
      "type": "boolean",
      "values": [
        {
          "description": "QTV chat messages will have prefix detailing userIDs and proxy addresses",
          "name": "false"
        },
        {
          "description": "QTV chat messages will be in simpler form <name>: <message>",
          "name": "true"
        }
      ]
    },
    "qtv_streamport": {
      "default": "0",
      "desc": "Server variable, TCP port on which the server will listen for QTV connections.",
      "group-id": "43",
      "type": "integer"
    },
    "qtv_streamtimeout": {
      "default": "45",
      "desc": "Number of seconds to wait before timing out a QTV stream.",
      "group-id": "43",
      "type": "float"
    },
    "qwdtools_dir": {
      "default": "qwdtools",
      "desc": "Specifies the qwdtools utility placement.",
      "group-id": "7",
      "type": "string",
      "values": [
        {
          "description": "Use path relative to your quakedir",
          "name": "*"
        }
      ]
    },
    "qwm_builddate": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "qwm_buildnum": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "qwm_fullname": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "qwm_homepage": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "qwm_name": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "qwm_platform": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "qwm_version": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "qws_builddate": {
      "default": "Jun 10 2025, 22:10:07",
      "group-id": "0",
      "system-generated": true
    },
    "qws_buildnum": {
      "default": "unknown",
      "group-id": "0",
      "system-generated": true
    },
    "qws_fullname": {
      "default": "MVDSV: MultiView Demo SerVer",
      "group-id": "0",
      "system-generated": true
    },
    "qws_homepage": {
      "default": "https://mvdsv.deurk.net",
      "group-id": "0",
      "system-generated": true
    },
    "qws_name": {
      "default": "EZQUAKE",
      "group-id": "0",
      "system-generated": true
    },
    "qws_platform": {
      "default": "w",
      "group-id": "0",
      "system-generated": true
    },
    "qws_version": {
      "default": "0.34-beta",
      "group-id": "0",
      "system-generated": true
    },
    "r_aliastransadj": {
      "desc": "Not much is known about this variable except for that increasing the value will cause the player models to be displayed smaller.",
      "group-id": "31",
      "type": "float"
    },
    "r_aliastransbase": {
      "desc": "Not much is known about this variable except for that increasing the value will cause the player models to be displayed smaller.",
      "group-id": "31",
      "type": "float"
    },
    "r_ambient": {
      "desc": "This variable controls the amount of ambient lighting on the map.\nWhen this variable is increased the map will become brighter and all walls and objects will be rendered in a lighter color.\nIt was removed in QWCL and has been re-introduced in this client, however it can only be used when the server is running with cheats enabled (for example \"qwsv -cheats\"), because it could be used as a cheat by making it easier to see players in dark corners when no fullbright skins are used.",
      "group-id": "31",
      "type": "float"
    },
    "r_bloom": {
      "default": "0",
      "desc": "Enables lights blooming.",
      "group-id": "8",
      "remarks": "Lights will have a \"diamond\" effect near them.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "r_bloom_alpha": {
      "default": "0.5",
      "desc": "Transparency level of the blooming effect.",
      "group-id": "8",
      "type": "float"
    },
    "r_bloom_darken": {
      "default": "3",
      "desc": "Level of \"darkness\" of the blooming effect.",
      "group-id": "8",
      "type": "integer"
    },
    "r_bloom_diamond_size": {
      "default": "8",
      "desc": "Size of the diamond particle used in the blooming effect.",
      "group-id": "8",
      "type": "integer"
    },
    "r_bloom_fast_sample": {
      "default": "0",
      "desc": "Faster variant of the blooming effect.",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "r_bloom_intensity": {
      "default": "1",
      "desc": "Intensity of the blooming effect.",
      "group-id": "8",
      "type": "integer"
    },
    "r_bloom_sample_size": {
      "default": "256",
      "desc": "Size of the particle used in the blooming effect.",
      "group-id": "8",
      "type": "integer"
    },
    "r_chaticons_alpha": {
      "default": "0.8",
      "desc": "Opacity of chaticons.",
      "group-id": "8",
      "type": "float",
      "values": [
        {
          "description": "0 mean no icons at all, 0.5 mean half opacity and 1 is opaque.",
          "name": "*"
        }
      ]
    },
    "r_clearcolor": {
      "desc": "This variable changes the color of the areas outside the map, commonly seen when free floating as a spectator.",
      "group-id": "31",
      "type": "float"
    },
    "r_damagestats": {
      "default": "0",
      "desc": "Displays the amount of damage taken recently on the screen above your armour and health.",
      "group-id": "47",
      "type": "float"
    },
    "r_drawdisc": {
      "default": "1",
      "desc": "Displays an indicator in top-right of screen when disk IO is in progress.",
      "group-id": "8",
      "type": "boolean"
    },
    "r_drawentities": {
      "default": "1",
      "desc": "This variable can be used to disable that any object entities are drawn.\nThis command is useful to map authors who wish to take a look at their map without drawing any objects such as lifts, buttons, platforms or items.",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Display no entities.",
          "name": "false"
        },
        {
          "description": "Display all entities.",
          "name": "true"
        }
      ]
    },
    "r_drawflame": {
      "default": "1",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Display no flames.",
          "name": "false"
        },
        {
          "description": "Display all flames.",
          "name": "true"
        }
      ]
    },
    "r_drawflat": {
      "default": "0",
      "desc": "Replaces wall/floor textures with a solid color (/r_wallcolor or /r_floorcolor, depending on the angle of the surface).",
      "group-id": "50",
      "remarks": "Usually used for performance improvements at the expense of eyecandy. See /r_wallcolor, /r_floorcolor & /r_drawflat_mode.\nCan not be changed during a match.",
      "type": "enum",
      "values": [
        {
          "description": "Use textures for walls and floors.",
          "name": "0"
        },
        {
          "description": "Use custom colored walls and floors.",
          "name": "1"
        },
        {
          "description": "Use colored floors and textured walls.",
          "name": "2"
        },
        {
          "description": "Use colored walls and textured floors.",
          "name": "3"
        }
      ]
    },
    "r_drawflat_mode": {
      "default": "0",
      "desc": "Sets the method used to adjust wall & floor textures (/r_drawflat) by the corresponding color (/r_wallcolor & /r_floorcolor)",
      "group-id": "50",
      "remarks": "Works in GLSL modes only (see /gl_program_world).\nMode 0 will give best performance, mode 2 is the recommended setting for different colors.\nCan not be changed during a match.",
      "type": "enum",
      "values": [
        {
          "description": "Walls/floors will be solid color, as per /r_drawflat setting.",
          "name": "0"
        },
        {
          "description": "Walls/floors will be textured and blended with custom colors.",
          "name": "1"
        },
        {
          "description": "Walls/floors will be monochrome textures using custom colors.",
          "name": "2"
        }
      ]
    },
    "r_drawhud": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "r_drawparticles": {
      "default": "1",
      "desc": "Toggles drawing particle effects.\nIntended for helping isolate rendering performance issues.",
      "group-id": "8",
      "remarks": "Limited by particle ruleset.",
      "type": "boolean",
      "values": [
        {
          "description": "Hide particles",
          "name": "0"
        },
        {
          "description": "Draw particles",
          "name": "1"
        }
      ]
    },
    "r_drawviewmodel": {
      "default": "1",
      "desc": "Controls transparency level of the currently-held weapon.",
      "group-id": "54",
      "remarks": "Example: 0.5 = 50% transparency.\nr_drawviewmodel 2 will cause weapon to be hidden when fov > 90.",
      "type": "float",
      "values": [
        {
          "description": "Fully transparent.",
          "name": "0"
        },
        {
          "description": "Fully opaque.",
          "name": "1"
        }
      ]
    },
    "r_drawviewmodel_invisible": {
      "default": "0",
      "desc": "This command controls whether or not to draw the weapon when invisible. It needs to be used in conjunction with r_drawviewmodel > 0.",
      "group-id": "54",
      "type": "boolean",
      "values": [
        {
          "description": "Don't display the weapon when invisible.",
          "name": "0"
        },
        {
          "description": "Display the weapon when invisible.",
          "name": "1"
        }
      ]
    },
    "r_drawvweps": {
      "default": "1",
      "desc": "Whether to draw vweps (other players' weapon models).",
      "group-id": "8",
      "remarks": "In order for vweps to work, you must have the appropriate models (vwplayer.mdl and w_*.mdl), and the server you're playing on must have vwep support enabled.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "r_drawworld": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "r_dspeeds": {
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display renderer speed statistics.",
          "name": "false"
        },
        {
          "description": "Display renderer speed statistics.",
          "name": "true"
        }
      ]
    },
    "r_dynamic": {
      "default": "2",
      "desc": "Controls dynamic lighting (muzzle-flash, quad & rocket glow, etc) on world surfaces.",
      "group-id": "15",
      "type": "enum",
      "values": [
        {
          "description": "Do not display dynamic lighting.",
          "name": "0"
        },
        {
          "description": "Display dynamic lighting (calculated on CPU)",
          "name": "1"
        },
        {
          "description": "Display dynamic lighting (calculated on GPU - GLSL only)",
          "name": "2"
        }
      ]
    },
    "r_enemyskincolor": {
      "default": "",
      "desc": "Allows you to set color for enemies you see in RGB format.",
      "group-id": "44",
      "remarks": "See r_skincolormode for more info.",
      "type": "string"
    },
    "r_explosionLight": {
      "default": "1",
      "desc": "Size of the light effect around explosions.",
      "group-id": "8",
      "type": "float",
      "values": [
        {
          "description": "No explosion light.",
          "name": "0"
        },
        {
          "description": "50% explosion light.",
          "name": "0.5"
        },
        {
          "description": "100% explosion light.",
          "name": "1"
        }
      ]
    },
    "r_explosionLightColor": {
      "default": "0",
      "desc": "Determines the color of the explosion light.",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "Normal (light yellow)",
          "name": "0"
        },
        {
          "description": "Red",
          "name": "1"
        },
        {
          "description": "Blue",
          "name": "2"
        },
        {
          "description": "Purple",
          "name": "3"
        },
        {
          "description": "Green",
          "name": "4"
        },
        {
          "description": "Yellow",
          "name": "5"
        },
        {
          "description": "Cyan",
          "name": "6"
        },
        {
          "description": "White",
          "name": "7"
        },
        {
          "description": "Random",
          "name": "8"
        }
      ]
    },
    "r_explosionType": {
      "default": "1",
      "desc": "Sets the type of effect used for explosions.",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "Fire + sparks",
          "name": "0"
        },
        {
          "description": "Fire only",
          "name": "1"
        },
        {
          "description": "Teleport",
          "name": "2"
        },
        {
          "description": "Blood",
          "name": "3"
        },
        {
          "description": "Big blood",
          "name": "4"
        },
        {
          "description": "Double gunshot",
          "name": "5"
        },
        {
          "description": "Blob effect",
          "name": "6"
        },
        {
          "description": "Big explosion",
          "name": "7"
        },
        {
          "description": "Fuel Rod Gun explosion",
          "name": "8"
        },
        {
          "description": "Sparks",
          "name": "9"
        },
        {
          "description": "None",
          "name": "10"
        }
      ]
    },
    "r_farclip": {
      "default": "8192",
      "desc": "Can be used to overcome vision being limited to 4096 units in GL clients (good for xpress2 etc).",
      "group-id": "35",
      "remarks": "See also: r_nearclip.",
      "type": "float"
    },
    "r_fastsky": {
      "default": "0",
      "group-id": "51",
      "type": "boolean",
      "values": [
        {
          "description": "Disable fastsky.",
          "name": "false"
        },
        {
          "description": "Enable fastsky, helps fps a bit on maps with large sky areas.",
          "name": "true"
        }
      ]
    },
    "r_fastturb": {
      "default": "0",
      "group-id": "51",
      "type": "boolean",
      "values": [
        {
          "description": "All turbulences will be displayed normally.",
          "name": "false"
        },
        {
          "description": "All turbulences will be replaced by single-colored surfaces.",
          "name": "true"
        }
      ]
    },
    "r_flagColor": {
      "default": "0",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "Normal",
          "name": "0"
        },
        {
          "description": "Red",
          "name": "1"
        },
        {
          "description": "Blue",
          "name": "2"
        },
        {
          "description": "Purple",
          "name": "3"
        },
        {
          "description": "Green",
          "name": "4"
        },
        {
          "description": "White",
          "name": "5"
        }
      ]
    },
    "r_floorcolor": {
      "default": "50 100 150",
      "desc": "Changes color of floors and ceilings when r_drawflat is set to 1.\nEnter RGB value here, e.g. r_floorcolor \"128 128 128\" goes for gray floor.",
      "group-id": "50",
      "remarks": "Can not be changed during a match.",
      "type": "string"
    },
    "r_fullbright": {
      "default": "0",
      "desc": "This variable toggles the use of lights at full brightness on the map.\nThis allows map authors to remove all of the lighting effects from the map, effectively removing all shadows.",
      "group-id": "15",
      "remarks": "This variable can only be used when the server is running with cheats enabled (for example \"mvdsv -cheats\" or sv_cheats 1), because it could be used as a cheat by making it easier to see players in shadows.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not fullbright the map.",
          "name": "false"
        },
        {
          "description": "Fullbrights the map (need -cheats or sv_cheats 1 enabled in server)",
          "name": "true"
        }
      ]
    },
    "r_fullbrightSkins": {
      "default": "1",
      "desc": "Determines the fullbright percentage of skins.\nFullbright skins can always be used during demo playback.\nThe f_skins response will indicate the brightness level being used as a percentage.",
      "group-id": "44",
      "type": "float",
      "values": [
        {
          "description": "Being 0% fullbright.",
          "name": "0"
        },
        {
          "description": "Being 50% fullbright.",
          "name": "0.5"
        },
        {
          "description": "Being 100% fullbright.",
          "name": "1"
        }
      ]
    },
    "r_fx_fog": {
      "default": "0",
      "desc": "Enables fog.",
      "group-id": "51",
      "remarks": "See also other r_fx_fog cvars for fine-tuning.",
      "type": "enum",
      "values": [
        {
          "description": "Off",
          "name": "0"
        },
        {
          "description": "On",
          "name": "1"
        },
        {
          "description": "In water/slime/lava only",
          "name": "2"
        }
      ]
    },
    "r_fx_fog_color_air": {
      "default": "153 128 103",
      "desc": "Color of fog when not underwater.",
      "group-id": "51",
      "type": "string",
      "values": [
        {
          "description": "R G B, each 0-255",
          "name": "*"
        }
      ]
    },
    "r_fx_fog_color_lava": {
      "default": "255 64 0",
      "desc": "Color of fog in lava.",
      "group-id": "51",
      "type": "string",
      "values": [
        {
          "description": "R G B, each 0-255",
          "name": "*"
        }
      ]
    },
    "r_fx_fog_color_slime": {
      "default": "128 255 0",
      "desc": "Color of fog in slime.",
      "group-id": "51",
      "type": "string",
      "values": [
        {
          "description": "R G B, each 0-255",
          "name": "*"
        }
      ]
    },
    "r_fx_fog_color_water": {
      "default": "32 64 128",
      "desc": "Color of fog in water.",
      "group-id": "51",
      "type": "string",
      "values": [
        {
          "description": "R G B, each 0-255",
          "name": "*"
        }
      ]
    },
    "r_fx_fog_density": {
      "default": "0.125",
      "desc": "Sets the density of the fog when r_fx_fog_model is an exponential model (1 or 2)",
      "group-id": "51",
      "type": "float"
    },
    "r_fx_fog_end": {
      "default": "800.0",
      "desc": "Sets ending distance for rendering the fog when r_fx_fog_model is 0 (linear).",
      "group-id": "51",
      "type": "float"
    },
    "r_fx_fog_model": {
      "default": "2",
      "desc": "Sets the fog rendering model.",
      "group-id": "51",
      "type": "enum",
      "values": [
        {
          "description": "Linear - range is r_fx_fog_start/r_fx_fog_end",
          "name": "0"
        },
        {
          "description": "Exponential - density r_fx_fog_density",
          "name": "1"
        },
        {
          "description": "Exponential squared - density r_fx_fog_density.  Used when map fog is enabled",
          "name": "2"
        }
      ]
    },
    "r_fx_fog_sky": {
      "default": "0.3",
      "desc": "Percentage of shading effect to apply to sky textures",
      "group-id": "51",
      "type": "float"
    },
    "r_fx_fog_start": {
      "default": "50.0",
      "desc": "Sets starting distance for rendering the fog when r_fx_fog_model is 0 (linear).\nThe greater the number is, the better visibility in game is and the fog is \"thinner\".",
      "group-id": "51",
      "type": "float"
    },
    "r_fx_fog_usemap": {
      "default": "2",
      "desc": "When to use fog settings from the map, rather than config.",
      "group-id": "51",
      "type": "enum",
      "values": [
        {
          "description": "Never use map-specific settings",
          "name": "0"
        },
        {
          "description": "Always use map-specific settings, if specified",
          "name": "1"
        },
        {
          "description": "Only use map-specific settings in local single-player mode",
          "name": "2"
        }
      ]
    },
    "r_glstats": {
      "default": "0",
      "desc": "When enabled, it creates a window in the top right of the screen showing the number of particles and etc. in use.",
      "group-id": "40",
      "type": "float"
    },
    "r_graphheight": {
      "desc": "This variable used to set the number of lines displayed in the \"r_timegraph\" command.",
      "group-id": "31",
      "type": "float"
    },
    "r_grenadeTrail": {
      "default": "1",
      "desc": "Customizable grenade trails.",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "No grenade trail.",
          "name": "0"
        },
        {
          "description": "Smoke (grenade) trail.",
          "name": "1"
        },
        {
          "description": "Normal (rocket) trail.",
          "name": "2"
        },
        {
          "description": "Alternative normal trail.",
          "name": "3"
        },
        {
          "description": "Slight blood trail.",
          "name": "4"
        },
        {
          "description": "Big blood trail.",
          "name": "5"
        },
        {
          "description": "Green Tracer trail.",
          "name": "6"
        },
        {
          "description": "Orange/Yellow Tracer trail.",
          "name": "7"
        },
        {
          "description": "Blue/White Plasma trail.",
          "name": "8"
        },
        {
          "description": "Lavaball trail.",
          "name": "9"
        },
        {
          "description": "Green Fuel Rod Gun trail.",
          "name": "10"
        },
        {
          "description": "Orange/Yellow Plasma Rocket Mk II trail.",
          "name": "11"
        },
        {
          "description": "Similar to 3, but with a white line and less smoke.",
          "name": "12"
        }
      ]
    },
    "r_instagibTrail": {
      "default": "1",
      "desc": "Type of trail to use when viewing trails left in /instagib mode.",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "No railtrail.",
          "name": "0"
        },
        {
          "description": "Normal grenade trail.",
          "name": "1"
        },
        {
          "description": "Normal rocket trail.",
          "name": "2"
        },
        {
          "description": "Alternative rocket trail.",
          "name": "3"
        },
        {
          "description": "Slight blood trail.",
          "name": "4"
        },
        {
          "description": "Big blood trail.",
          "name": "5"
        },
        {
          "description": "Green Tracer trail.",
          "name": "6"
        },
        {
          "description": "Orange/Yellow Tracer trail.",
          "name": "7"
        },
        {
          "description": "Vore trail.",
          "name": "8"
        },
        {
          "description": "Classic railtrail.",
          "name": "9"
        },
        {
          "description": "New railtrail.",
          "name": "10"
        },
        {
          "description": "Particle railtrail.",
          "name": "11"
        },
        {
          "description": "Lava trail",
          "name": "12"
        },
        {
          "description": "Particle rocket trail",
          "name": "13"
        }
      ]
    },
    "r_lavacolor": {
      "default": "80 0 0",
      "desc": "Changes color of lava when r_fastturb set to 1.",
      "group-id": "51",
      "type": "string"
    },
    "r_lerpframes": {
      "default": "1",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Disable smoothing.",
          "name": "false"
        },
        {
          "description": "Enable smoothing (watch people moving in mvd demos with cl_demospeed 0.1).",
          "name": "true"
        }
      ]
    },
    "r_lerpmuzzlehack": {
      "default": "1",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "No fix for interpolated muzzle flashes.",
          "name": "false"
        },
        {
          "description": "Fix for interpolated muzzle flashes.",
          "name": "true"
        }
      ]
    },
    "r_lgbloodColor": {
      "default": "225",
      "desc": "Determines the color of the blood particles emitted when hitting entities with the lightning gun.",
      "group-id": "8",
      "type": "integer"
    },
    "r_lightdecayrate": {
      "default": "2",
      "desc": "Determines how fast lights decay (radius decreases).\nMinimum value 1 (QWCL)",
      "group-id": "8",
      "type": "float"
    },
    "r_lightflicker": {
      "default": "1",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Disable rocket/explosion/flag/powerup light flickering.",
          "name": "false"
        },
        {
          "description": "Enable rocket/explosion/flag/powerup light flickering.",
          "name": "true"
        }
      ]
    },
    "r_lightmap_lateupload": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "r_lightmap_packbytexture": {
      "default": "2",
      "group-id": "0",
      "system-generated": true
    },
    "r_max_size_1": {
      "group-id": "31",
      "type": "enum",
      "values": [
        {
          "description": "Off.",
          "name": "0"
        },
        {
          "description": "Blend map textures.",
          "name": "1"
        },
        {
          "description": "Blend map textures and bsp entities (ammo, health etc.)",
          "name": "2"
        }
      ]
    },
    "r_maxedges": {
      "desc": "This variable sets the maximum number of plane surface edges to be rendered.\nActual default (and minimal) value is 2000.\nOn some new maps you may need to increase this value.\nSee also r_maxsurfs, r_reportedgeout, r_reportsurfout.",
      "group-id": "31",
      "type": "float"
    },
    "r_maxsurfs": {
      "desc": "This variable sets the maximum number of plane surfaces to be rendered.\nActual default (and minimal) value is 2000.\nOn some new maps you may need to increase this value.\nSee also r_maxedges, r_reportedgeout, r_reportsurfout.",
      "group-id": "31",
      "type": "float"
    },
    "r_nearclip": {
      "default": "2",
      "desc": "Distance of clipping nearest objects (v_models).",
      "group-id": "53",
      "remarks": "See also: r_farclip.",
      "type": "float"
    },
    "r_netgraph": {
      "default": "0",
      "desc": "Netgraph is a diagnostic tool to help you tweak your rate.\nIf you find that you suffer from short pauses in the game and you see red spikes in your netgraph, you should try setting the rate down a bit.\nThe height of the pink lines towards the bottom is your latency on received packets.\nRed lines are lost packets. (bad)\nYellow lines are from the rate command kicking in, it's data that wasn't sent to you because you didn't have the bandwidth for it. (OK)\nBlue lines are very bad, they invalid delta's, and are related to the U_REMOVE warnings.",
      "group-id": "40",
      "remarks": "If during your play, you frequently see a string of messages with the term \"U_REMOVE\" in them, and your play seems to freeze for serveral seconds, use the console command cl_nodelta 1. This is a slightly less efficient way for QuakeWorld to work, but if your ISP is overloaded or has some configuration problems, it may not pass packets to QuakeWorld properly and cause difficulty.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display the netgraph.",
          "name": "false"
        },
        {
          "description": "Display the netgraph.",
          "name": "true"
        }
      ]
    },
    "r_netstats": {
      "default": "0",
      "desc": "Shows information about ping, packetloss, average packet size and incoming/outgoing traffic.\nEquivalent with 'net' HUD element.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw network statistics.",
          "name": "false"
        },
        {
          "description": "Draw network statistics.",
          "name": "true"
        }
      ]
    },
    "r_novis": {
      "default": "0",
      "desc": "This variable toggles the use of VIS information from the map data.\nWhen this variable is set to \"1\" the game will calculate it's own VIS information on the fly instead of using the information stored in the map data, this will cause a severe performance penalty in the game.\nWhen \"r_novis\" is set to \"1\", the variable \"gl_turbalpha\" has a value lower than \"1\" and the server allows the client to display liquid transparently the player will be able to see through liquids.\nThis is a nice effect to see but it is not recommended to keep this variable set to \"1\" because of the huge performance penalty.\nIt is possible to enable transparent liquids and still keep this variable set to \"0\" (and thus not experience such a severe performance drop) by using maps that are VISed accordingly.\nYou can visit the official Water VIS site at \"http://www.sod.net/\" and download the vispatch program along with the patch data files which you would use to update the VIS data for all of your game maps.\nThere are also map packs available that contain VISed versions of the original ID maps.",
      "group-id": "51",
      "type": "boolean",
      "values": [
        {
          "description": "Do not calculate VIS information for unVISed maps.",
          "name": "false"
        },
        {
          "description": "Calculate VIS information for unVISed maps.",
          "name": "true"
        }
      ]
    },
    "r_numedges": {
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not print information about the number of edges.",
          "name": "false"
        },
        {
          "description": "Print information about the number of edges.",
          "name": "true"
        }
      ]
    },
    "r_numsurfs": {
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not print information about the number of surfaces.",
          "name": "false"
        },
        {
          "description": "Print information about the number of surfaces.",
          "name": "true"
        }
      ]
    },
    "r_particles_count": {
      "default": "2048",
      "desc": "Maximum ammount of particles displayed.",
      "group-id": "36",
      "remarks": "You can adjust graphics performance with this.",
      "type": "integer",
      "values": [
        {
          "description": "1024 or 2048 is quite enough",
          "name": "*"
        }
      ]
    },
    "r_polymodelstats": {
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not print polygon model statistics.",
          "name": "false"
        },
        {
          "description": "Print polygon model statistics.",
          "name": "true"
        }
      ]
    },
    "r_powerupGlow": {
      "default": "1",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "Powerup glow is turned off on all players.",
          "name": "0"
        },
        {
          "description": "Powerup glow on.",
          "name": "1"
        },
        {
          "description": "Disables the powerup glow from yourself only.",
          "name": "2"
        }
      ]
    },
    "r_railTrail": {
      "default": "1",
      "desc": "Customizable rail trails.",
      "group-id": "8",
      "remarks": "See /r_instagibTrail for customising /instagib mode in KTX.",
      "type": "enum",
      "values": [
        {
          "description": "No rail trail.",
          "name": "0"
        },
        {
          "description": "Smoke trail.",
          "name": "1"
        },
        {
          "description": "Normal (rocket) trail.",
          "name": "2"
        },
        {
          "description": "Alternative normal trail.",
          "name": "3"
        },
        {
          "description": "Slight blood trail.",
          "name": "4"
        },
        {
          "description": "Big blood trail.",
          "name": "5"
        },
        {
          "description": "Green Tracer trail.",
          "name": "6"
        },
        {
          "description": "Orange/Yellow Tracer trail.",
          "name": "7"
        },
        {
          "description": "Blue/White Plasma trail.",
          "name": "8"
        },
        {
          "description": "Lavaball trail.",
          "name": "9"
        },
        {
          "description": "Green Fuel Rod Gun trail.",
          "name": "10"
        },
        {
          "description": "Orange/Yellow Plasma Rocket Mk II trail.",
          "name": "11"
        },
        {
          "description": "Similar to 3, but with a white line and less smoke.",
          "name": "12"
        }
      ]
    },
    "r_remove_collinear_vertices": {
      "default": "0",
      "desc": "Filter out vertices causing triangles to have zero area. These types of triangles are a sore spot in some GPUs that risk introducing glitches. An expected side effect is a risk of seeing a sparkling pixel.",
      "group-id": "35",
      "remarks": "For macOS arm64 this is force-enabled to prevent cheating. This filtering is a temporary workaround before adding code to avoid generating such triangles in the first place.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable filtering of collinear vertices.",
          "name": "false"
        },
        {
          "description": "Enable filtering of collinear vertices.",
          "name": "true"
        }
      ]
    },
    "r_reportedgeout": {
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not report when running out of edges.",
          "name": "false"
        },
        {
          "description": "Report when running out of edges.",
          "name": "true"
        }
      ]
    },
    "r_reportsurfout": {
      "desc": "Toggle the display of how many surfaces where not displayed.\nThis shouldn't happen during normal game play, only when in noclip mode.",
      "group-id": "31",
      "type": "float"
    },
    "r_rlbloodColor_big": {
      "default": "73",
      "desc": "Determines the color of the blood particles emitted when hitting entities with the rocket launcher. Requires the rocket explosion to be big blood (cl_explosiontype 4).",
      "group-id": "8",
      "type": "integer"
    },
    "r_rlbloodColor_small": {
      "default": "225",
      "desc": "Determines the color of the blood particles emitted when hitting entities with the rocket launcher. Requires the rocket explosion to be small blood (cl_explosiontype 3).",
      "group-id": "8",
      "type": "integer"
    },
    "r_rocketLight": {
      "default": "1",
      "desc": "Enables rocket lights.\nValues from 0-1 can be used to scale the light.",
      "group-id": "8",
      "type": "float",
      "values": [
        {
          "description": "Disable dynamic rocket lights.",
          "name": "0"
        },
        {
          "description": "Enable dynamic rocket lights, maximum scale.",
          "name": "1"
        }
      ]
    },
    "r_rocketLightColor": {
      "default": "0",
      "desc": "Determines the color of the rocket lights.",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "Normal",
          "name": "0"
        },
        {
          "description": "Red",
          "name": "1"
        },
        {
          "description": "Blue",
          "name": "2"
        },
        {
          "description": "Purple",
          "name": "3"
        },
        {
          "description": "Green",
          "name": "4"
        },
        {
          "description": "Yellow",
          "name": "5"
        },
        {
          "description": "Cyan",
          "name": "6"
        },
        {
          "description": "White",
          "name": "7"
        }
      ]
    },
    "r_rocketTrail": {
      "default": "1",
      "desc": "Customizable rocket trails.",
      "group-id": "8",
      "type": "enum",
      "values": [
        {
          "description": "No rocket trail.",
          "name": "0"
        },
        {
          "description": "Normal (rocket) trail.",
          "name": "1"
        },
        {
          "description": "Smoke (grenade) trail.",
          "name": "2"
        },
        {
          "description": "Alternative normal trail.",
          "name": "3"
        },
        {
          "description": "Slight blood trail.",
          "name": "4"
        },
        {
          "description": "Big blood trail.",
          "name": "5"
        },
        {
          "description": "Green Tracer trail.",
          "name": "6"
        },
        {
          "description": "Orange/Yellow Tracer trail.",
          "name": "7"
        },
        {
          "description": "Blue/White Plasma trail.",
          "name": "8"
        },
        {
          "description": "Lavaball trail.",
          "name": "9"
        },
        {
          "description": "Green Fuel Rod Gun trail.",
          "name": "10"
        },
        {
          "description": "Orange/Yellow Plasma Rocket Mk II trail.",
          "name": "11"
        },
        {
          "description": "Similar to 3, but with a white line and less smoke.",
          "name": "12"
        }
      ]
    },
    "r_sgbloodColor": {
      "default": "73",
      "desc": "Determines the color of the blood particles emitted when hitting entities with weapons other than the lightning gun.",
      "group-id": "8",
      "type": "integer"
    },
    "r_shadows": {
      "default": "0",
      "group-id": "15",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display shadows for entities.",
          "name": "false"
        },
        {
          "description": "Display shadows for entities.",
          "name": "true"
        }
      ]
    },
    "r_shaftalpha": {
      "default": "1",
      "desc": "Adds transparency to the lightning gun beam (shaft).",
      "group-id": "8",
      "remarks": "Disabled in ruleset smackdown and smackdrive.",
      "type": "float",
      "values": [
        {
          "description": "Values from 0.0 (transparent) to 1.0 (opaque) possible",
          "name": "*"
        }
      ]
    },
    "r_shiftbeam": {
      "default": "0",
      "desc": "Shift start of the shaft lights.",
      "group-id": "8",
      "remarks": "Doesn't work with ruleset smackdown and smackdrive. Intended for movies.",
      "type": "float"
    },
    "r_skincolormode": {
      "default": "0",
      "desc": "Toggles different modes of how colors from r_enemyskincolor and r_teamskincolor are applied to players.",
      "group-id": "44",
      "type": "enum",
      "values": [
        {
          "description": "Solid color",
          "name": "0"
        },
        {
          "description": "Color doesn't affect skin",
          "name": "1"
        },
        {
          "description": "Blends skin texture and color",
          "name": "2"
        },
        {
          "description": "Effectively the same as 1",
          "name": "3"
        },
        {
          "description": "Adds color to skin",
          "name": "4"
        },
        {
          "description": "Hues skin by color",
          "name": "5"
        }
      ]
    },
    "r_skincolormodedead": {
      "default": "-1",
      "desc": "Sets r_skincolormode for players upon death.",
      "group-id": "44",
      "remarks": "See r_skincolormode for valid values.",
      "type": "enum",
      "values": [
        {
          "description": "Do not change r_skincolormode when player dies.",
          "name": "-1"
        }
      ]
    },
    "r_skycolor": {
      "default": "40 80 150",
      "desc": "Changes color of sky when r_fastsky set to 1.",
      "group-id": "51",
      "type": "string"
    },
    "r_skyname": {
      "default": "",
      "desc": "Allows the sky to be rendered using an external skybox, rather than using textures from the map",
      "group-id": "51",
      "remarks": "Specifying a value will disable loading of skyboxes specified by the map.\nSkyboxes should be placed in 'env' or 'gfx/env' folders",
      "type": "string"
    },
    "r_skywind": {
      "default": "1",
      "desc": "Sets the scale factor of skybox animation if above 0, and skybox has an animation configuration.",
      "group-id": "51",
      "remarks": "Specifying a value above 1.0 will increase the pace of the configured animation.",
      "type": "float"
    },
    "r_slimecolor": {
      "default": "10 60 10",
      "desc": "Changes color of slime when r_fastturb set to 1.",
      "group-id": "51",
      "type": "string"
    },
    "r_smoothalphahack": {
      "default": "0",
      "desc": "Controls the alpha blending style for HUD text.",
      "group-id": "50",
      "type": "boolean",
      "values": [
        {
          "description": "Corrected HUD text alpha blending (clean edges).",
          "name": "false"
        },
        {
          "description": "Pre-ezQuake 3.6 HUD text alpha blending (creats faint outlines around the edges).",
          "name": "true"
        }
      ]
    },
    "r_smoothcrosshair": {
      "default": "1",
      "desc": "Controls texture filtering on the crosshair.",
      "group-id": "6",
      "type": "boolean",
      "values": [
        {
          "description": "Nearest filtering - sharp, pixelated crosshair.",
          "name": "false"
        },
        {
          "description": "Linear filtering - smooth crosshair.",
          "name": "true"
        }
      ]
    },
    "r_smoothimages": {
      "default": "1",
      "desc": "Controls texture filtering on HUD graphics : menu, console background, big numbers, icons, radar...",
      "group-id": "50",
      "remarks": "Classic graphics usually look better with 1.\nHigher res content will work better with 1.",
      "type": "boolean",
      "values": [
        {
          "description": "Nearest filtering - sharp, pixelated images.",
          "name": "false"
        },
        {
          "description": "Linear filtering - smooth images.",
          "name": "true"
        }
      ]
    },
    "r_smoothtext": {
      "default": "1",
      "desc": "Controls texture filtering on HUD text.",
      "group-id": "50",
      "remarks": "Classic fonts usually look better with 0.\nHigher res fonts will work better with 1.",
      "type": "boolean",
      "values": [
        {
          "description": "Nearest filtering - sharp, pixelated text.",
          "name": "false"
        },
        {
          "description": "Linear filtering - smooth text.",
          "name": "true"
        }
      ]
    },
    "r_speeds": {
      "default": "0",
      "desc": "Toggles the displaying of drawing time and stats of what is currently being viewed.\nExample:\n32.7 ms 267/196/ 74 poly   3 surf\n38.6 ms 267/196/ 74 poly  20 surf\n60.4 ms 267/196/ 74 poly  18 surf\n38.2 ms 267/196/ 73 poly  18 surf",
      "group-id": "40",
      "type": "float"
    },
    "r_teamskincolor": {
      "default": "",
      "desc": "Allows you to set color for teammates you see in RGB format.",
      "group-id": "44",
      "remarks": "See r_skincolormode for more info.",
      "type": "string"
    },
    "r_telecolor": {
      "default": "255 60 60",
      "desc": "Changes color of teleport when r_fastturb set to 1.",
      "group-id": "51",
      "type": "string"
    },
    "r_telesplash": {
      "default": "1",
      "desc": "Toggles teleport splash effect.",
      "group-id": "8",
      "type": "boolean",
      "values": [
        {
          "description": "Disable teleport splashes.",
          "name": "false"
        },
        {
          "description": "Enable teleport splashes.",
          "name": "true"
        }
      ]
    },
    "r_timegraph": {
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display the timegraph.",
          "name": "false"
        },
        {
          "description": "Display the timegraph.",
          "name": "true"
        }
      ]
    },
    "r_tracker": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "r_tracker_align_right": {
      "default": "1",
      "desc": "Controls the alignment of the extra frag messages window.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Extra frag messages window will be shown on the left side of the screen.",
          "name": "false"
        },
        {
          "description": "Extra frag messages window will be shown on the right side of the screen.",
          "name": "true"
        }
      ]
    },
    "r_tracker_color_bad": {
      "default": "900",
      "desc": "Color to use when reporting a frag by opponent's team.",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_color_fragonme": {
      "default": "900",
      "desc": "Color to use when reporting an opponent killed the current player.",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_color_good": {
      "default": "090",
      "desc": "Color to use when reporting a kill by current player's team.",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_color_myfrag": {
      "default": "090",
      "desc": "Color to use when reporting a frag by current player.",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_color_suicide": {
      "default": "900",
      "desc": "Color to use when reporting a suicide.",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_color_tkbad": {
      "default": "009",
      "desc": "Color to use when reporting a teamkill by current player's team.",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_color_tkgood": {
      "default": "990",
      "desc": "Color to use when reporting an opponent's teamkill.",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_colorfix": {
      "default": "0",
      "desc": "Both players in fragline will be colored according to good/bad/myfrag/etc values.",
      "group-id": "40",
      "type": "integer"
    },
    "r_tracker_flags": {
      "default": "0",
      "desc": "Everytime you take, capture or drop a flag, the number of times is displayed on the screen.",
      "group-id": "40",
      "remarks": "See r_tracker_*, cl_parseFrags and cl_loadFragFiles variables description for further info.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "r_tracker_frags": {
      "default": "1",
      "desc": "Controls which frag messages will be shown in extra window, beside the standard onscreen chat (notify area).",
      "group-id": "40",
      "remarks": "Values 1 and 2 requires cl_loadfragfiles and cl_parsefrags to be set to 1.",
      "type": "enum",
      "values": [
        {
          "description": "No extra frag messages shown.",
          "name": "0"
        },
        {
          "description": "Frag messages related to yourself will be shown in extra window.",
          "name": "1"
        },
        {
          "description": "All frag messages will be shown in extra window.",
          "name": "2"
        }
      ]
    },
    "r_tracker_frame_color": {
      "default": "0 0 0 0",
      "desc": "Controls the opacity and color of the background of the extra frag messages window.",
      "group-id": "40",
      "remarks": "See other r_tracker_* variables description for further info.",
      "type": "string",
      "values": [
        {
          "description": "<r g b><a> = red, green, blue and alpha values 0..255.",
          "name": "*"
        }
      ]
    },
    "r_tracker_images_scale": {
      "default": "1",
      "desc": "Controls the size of images when using the tracker.",
      "group-id": "40",
      "type": "float",
      "values": [
        {
          "description": "Range 0.1 to 10.",
          "name": "*"
        }
      ]
    },
    "r_tracker_inconsole": {
      "default": "0",
      "desc": "Controls how tracker messages will appear in the console/notify area.",
      "group-id": "40",
      "remarks": "To see full death messages in the console, use con_fragmessages 2.",
      "type": "enum",
      "values": [
        {
          "description": "Tracker messages will not be shown in the console.",
          "name": "0"
        },
        {
          "description": "Tracker messages will be shown in console and notify area (disables regular tracker messages)",
          "name": "1"
        },
        {
          "description": "Tracker messages will be shown in console and notify area (regular tracker messages enabled)",
          "name": "2"
        },
        {
          "description": "Tracker messages will be shown in console and regular tracker area but not in notify area.",
          "name": "3"
        }
      ]
    },
    "r_tracker_inconsole_colored_weapon": {
      "default": "0",
      "desc": "Use colored weapon string in death messages",
      "group-id": "40",
      "remarks": "The colors will be selected from r_tracker_color_good, r_tracker_color_bad, r_tracker_color_myfrag and r_tracker_color_fragonme",
      "type": "enum",
      "values": [
        {
          "description": "Weapon text will not be colored",
          "name": "0"
        },
        {
          "description": "Weapon text will be colored",
          "name": "1"
        }
      ]
    },
    "r_tracker_messages": {
      "default": "20",
      "desc": "Maximum number of custom frag messages to be displayed in extra frag messages window.",
      "group-id": "40",
      "remarks": "See other r_tracker_*, cl_parseFrags and cl_loadFragFiles variables description for further info.",
      "type": "integer"
    },
    "r_tracker_name_width": {
      "default": "0",
      "desc": "Maximum length of player names in the tracker.",
      "group-id": "40",
      "type": "integer"
    },
    "r_tracker_own_frag_prefix": {
      "default": "You fragged ",
      "desc": "Text to show before frag messages relating to the current player.",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_pickups": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "r_tracker_positive_enemy_suicide": {
      "default": "0",
      "desc": "If enabled frag tracker draws enemy suicides using color value of r_tracker_color_good variable.",
      "group-id": "40",
      "type": "integer"
    },
    "r_tracker_positive_enemy_vs_enemy": {
      "default": "0",
      "desc": "If enabled frag tracker draws enemy vs enemy kills using color value of r_tracker_color_good variable.",
      "group-id": "40",
      "type": "integer"
    },
    "r_tracker_row_spacing": {
      "default": "0",
      "desc": "Additional pixels to add between tracker message rows. Positive values increase spacing, negative values decrease it.",
      "group-id": "40",
      "type": "integer"
    },
    "r_tracker_proportional": {
      "default": "0",
      "desc": "Enable TrueType fonts on tracker text.",
      "group-id": "5",
      "type": "boolean"
    },
    "r_tracker_scale": {
      "default": "1",
      "desc": "Allows you to change the font size in the extra frag messages.",
      "group-id": "40",
      "remarks": "See other r_tracker_* variables.",
      "type": "float"
    },
    "r_tracker_streaks": {
      "default": "0",
      "desc": "Everytime a player makes a set number of consecutive kills, it will display a message showing they are on a streak.\nWhen the player is killed, it will display the name of the person who ended that streak.",
      "group-id": "40",
      "type": "float"
    },
    "r_tracker_string_died": {
      "default": " (died)",
      "desc": "Text appearing in the tracker when a player dies (typically lava, slime, drowning etc)",
      "group-id": "40",
      "remarks": "Relates to PLAYER_DEATH rules in fragfile.dat.",
      "type": "string"
    },
    "r_tracker_string_enemy": {
      "default": "enemy",
      "desc": "Text appearing in the tracker when a player earns a frag.",
      "group-id": "40",
      "remarks": "Relates to X_FRAGS_UNKNOWN rules in fragfile.dat.",
      "type": "string"
    },
    "r_tracker_string_inconsole_prefix": {
      "default": "",
      "desc": "Prefix to prepend before tracker messages in the console",
      "group-id": "40",
      "remarks": "The prefix is only visible when r_tracker_inconsole has a value greater than 0",
      "type": "string"
    },
    "r_tracker_string_suicides": {
      "default": " (suicides)",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_string_teammate": {
      "default": "teammate",
      "group-id": "40",
      "type": "string"
    },
    "r_tracker_time": {
      "default": "4",
      "desc": "Number of seconds the tracker information is drawn on the screen.",
      "group-id": "40",
      "remarks": "See other 'r_tracker_*' variables too.",
      "type": "float",
      "values": [
        {
          "description": "Use positive numbers.",
          "name": "*"
        }
      ]
    },
    "r_tracker_weapon_first": {
      "default": "0",
      "desc": "Print the weapon icon or name before the player name.",
      "group-id": "40",
      "type": "boolean"
    },
    "r_tracker_x": {
      "default": "0",
      "desc": "Adjusts the position of extra frag messages window.",
      "group-id": "40",
      "remarks": "See other r_tracker_* variables description for more info.",
      "type": "integer",
      "values": [
        {
          "description": "horizontal position.",
          "name": "*"
        }
      ]
    },
    "r_tracker_y": {
      "default": "0",
      "desc": "Adjusts the position of extra frag messages window.",
      "group-id": "40",
      "remarks": "See other r_tracker_* variables description for more info.",
      "type": "integer",
      "values": [
        {
          "description": "vertical position.",
          "name": "*"
        }
      ]
    },
    "r_turbwarp": {
      "group-id": "31",
      "remarks": "SW only!\nThis variable has the same effect as r_waterwarp in other quake clients.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable warping of surfaces.",
          "name": "false"
        },
        {
          "description": "Enable warping of surfaces.",
          "name": "true"
        }
      ]
    },
    "r_viewmodelSize": {
      "default": "1",
      "desc": "This allows you to change the size of the viewmodel (the model of your active weapon displayed on the center of your screen) a little.\nUseful if you prefer to use \"r_drawviewmodel 1\" and higher fov values (for demos for example).\nFor \"fov 110\" you could try \"r_viewmodelSize 0.8\" or 0.85 for example.",
      "group-id": "54",
      "type": "float"
    },
    "r_viewmodellastfired": {
      "default": "0",
      "desc": "Display last fired weapon instead of currently held one on MVD / QTV playback.",
      "group-id": "54",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "r_viewmodeloffset": {
      "default": "",
      "desc": "Moves the gun model to the right (positive value) or to the left (negative value).\nGood for people who like to see right/left-handed looking weapons.",
      "group-id": "54",
      "remarks": "You can also change Y and Z coordinates, just provide parameters in \"X Y Z\" format.\nSee also r_shiftbeam variable.",
      "type": "string",
      "values": [
        {
          "description": "Range -10 to 10.",
          "name": "*"
        }
      ]
    },
    "r_viewpreselgun": {
      "default": "0",
      "desc": "Will show a gun that was picked as the best by weapon pre-selection.",
      "group-id": "54",
      "remarks": "See cl_weaponpreselect and cl_weaponhide.",
      "type": "boolean",
      "values": [
        {
          "description": "Display the weapon you really hold.",
          "name": "false"
        },
        {
          "description": "Disaply the current pre-selected weapon.",
          "name": "true"
        }
      ]
    },
    "r_wallcolor": {
      "default": "255 255 255",
      "desc": "Changes color of walls when r_drawflat is set to 1.\nEnter RGB value here, e.g. r_wallcolor \"128 128 128\" goes for gray walls.",
      "group-id": "50",
      "remarks": "Can not be changed during a match.",
      "type": "string"
    },
    "r_watercolor": {
      "default": "10 50 80",
      "desc": "Changes color of water when r_fastturb set to 1.",
      "group-id": "51",
      "type": "string"
    },
    "r_zgraph": {
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not display the z-graph.",
          "name": "false"
        },
        {
          "description": "Display the z-graph.",
          "name": "true"
        }
      ]
    },
    "railcolor": {
      "default": "",
      "desc": "Player's rail color.",
      "group-id": "37",
      "remarks": "Sent to server, requires mod support.",
      "type": "enum",
      "values": [
        {
          "description": "Server decides color.",
          "name": ""
        },
        {
          "description": "White.",
          "name": "0"
        },
        {
          "description": "Blue.",
          "name": "1"
        },
        {
          "description": "Green.",
          "name": "2"
        },
        {
          "description": "Light Blue.",
          "name": "3"
        },
        {
          "description": "Red.",
          "name": "4"
        },
        {
          "description": "Magenta.",
          "name": "5"
        },
        {
          "description": "Yellow.",
          "name": "6"
        },
        {
          "description": "White.",
          "name": "7"
        }
      ]
    },
    "rate": {
      "default": "25000",
      "desc": "Sets the maximum amount of bytes per second that the server should send to the client.",
      "group-id": "37",
      "type": "float"
    },
    "rcon_address": {
      "default": "",
      "desc": "Address of the server to query with remote console commands.",
      "group-id": "2",
      "type": "string"
    },
    "rcon_password": {
      "default": "",
      "desc": "Password used for remote console communication.",
      "group-id": "2",
      "type": "string"
    },
    "re_trigger_match_0": {
      "default": "",
      "desc": "Whole matched pattern of the regular expression match.",
      "group-id": "22",
      "type": "string"
    },
    "re_trigger_match_1": {
      "default": "",
      "desc": "First matched subpattern of the regexp match.",
      "group-id": "22",
      "type": "string"
    },
    "re_trigger_match_2": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "re_trigger_match_3": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "re_trigger_match_4": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "re_trigger_match_5": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "re_trigger_match_6": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "re_trigger_match_7": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "re_trigger_match_8": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "re_trigger_match_9": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "registered": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "ruleset": {
      "default": "default",
      "desc": "Enforces a set of restrictions on the client features.",
      "group-id": "37",
      "remarks": "Most commonly used is \"smackdown\"",
      "type": "string"
    },
    "s_alsa_device": {
      "default": "default",
      "desc": "Sets which device ALSA will be trying to open (when s_driver is set to alsa).\nIf \"default\" fails it will try \"hw\" and if that fails too, \"plug:hw\" will be tried.",
      "group-id": "26",
      "type": "string"
    },
    "s_alsa_latency": {
      "desc": "Specifies latency for ALSA.\nIf you got distortion in sound, upper the value a bit.\nIf you experience delays, try lowering this value.",
      "group-id": "26",
      "type": "float"
    },
    "s_alsa_noworkaround": {
      "desc": "If you are having problems with ALSA you can try to set this var to 1 before you try legacy drivers.",
      "group-id": "26",
      "remarks": "Linux/FreeBSD only.",
      "type": "enum",
      "values": [
        {
          "description": "Workaround enabled.",
          "name": "0"
        },
        {
          "description": "Workaround disabled. Try this if you are having problems with new ALSA driver.",
          "name": "1"
        }
      ]
    },
    "s_ambientfade": {
      "default": "100",
      "desc": "How fast the volume of ambient sounds changes as you move around the map.",
      "group-id": "45",
      "type": "float"
    },
    "s_ambientlevel": {
      "default": "0.3",
      "desc": "Volume level of ambient sounds (produced by liquid and sky brushes).",
      "group-id": "45",
      "type": "float"
    },
    "s_audiodevice": {
      "default": "0",
      "desc": "Audio device to use.",
      "group-id": "45",
      "type": "integer"
    },
    "s_bits": {
      "desc": "This defines how many sampling bits should be used, when using 16 bits the interpolation quality will be better.",
      "group-id": "26",
      "remarks": "Linux only.\nUse s_restart after you change it.",
      "type": "enum",
      "values": [
        {
          "description": "16 bit sound.",
          "name": "16"
        },
        {
          "description": "8 bit sound.",
          "name": "8"
        }
      ]
    },
    "s_chat_custom": {
      "default": "1",
      "desc": "Controls usage of s_mm*, s_chat_*, s_otherchat_* and s_spec_* variables.",
      "group-id": "3",
      "type": "enum",
      "values": [
        {
          "description": "No chat sounds played.",
          "name": "0"
        },
        {
          "description": "Chat sounds played for mm1 & mm2.",
          "name": "1"
        },
        {
          "description": "Chat sounds played for mm2 only.",
          "name": "2"
        }
      ]
    },
    "s_desiredsamples": {
      "default": "0",
      "desc": "Indicates how large the audio buffer should be, in samples.\nIf 0, ezQuake will choose a sensible default, based on value of s_khz.",
      "group-id": "45",
      "remarks": "This is a suggestion only, the driver is free to choose a different value.\nSmaller buffer sizes generally result in lower latency, but higher CPU usage.",
      "type": "integer"
    },
    "s_device": {
      "desc": "Allows you to choose from multiple sound devices.",
      "group-id": "26",
      "remarks": "Linux only.\nUse s_restart after you change it.\n\nFor OSS you should use \"/dev/dsp\", \"/dev/dsp0\", \"/dev/dsp1\", etc.\nFor ALSA use \"default\", \"dmix\", etc.",
      "type": "string",
      "values": [
        {
          "description": "device name.",
          "name": "*"
        }
      ]
    },
    "s_driver": {
      "desc": "Specifices which sounddriver to use: ALSA/OSS or experimental Pulseaudio.",
      "group-id": "26",
      "type": "enum",
      "values": [
        {
          "description": "Will use ALSA drivers.",
          "name": "alsa"
        },
        {
          "description": "Will use OSS drivers.",
          "name": "oss"
        },
        {
          "description": "Will use experimental Pulseaudio drivers (note: have to be set in all loading configs before starting ezQuake to work!)",
          "name": "pulse"
        }
      ]
    },
    "s_khz": {
      "default": "11",
      "desc": "Sets the audio sampling rate.\nIn ezQuake, this introduces artifacts which give a \"crisper\"/\"grainy\" feel to some sounds, as the interpolation is not perfect. All the original sounds are 11k, except for shaft which is 22k and will sound different when setting s_khz over 11.",
      "group-id": "45",
      "remarks": "If you dislike the changes in sound, you can i.e. convert the shaft sounds down to 11k (and fail \"f_modified\" checks), go back to s_khz 11, or use s_linearresample for perfect resampling.",
      "type": "enum",
      "values": [
        {
          "description": "11kHz sound (default).",
          "name": "11"
        },
        {
          "description": "22kHz sound.",
          "name": "22"
        },
        {
          "description": "44kHz sound.",
          "name": "44"
        },
        {
          "description": "48kHz sound.",
          "name": "48"
        }
      ]
    },
    "s_linearresample": {
      "default": "0",
      "desc": "Controls whether to resample sounds to s_khz with perfect quality. This cleans up any artifacts resulting from the default interpolation.",
      "group-id": "45",
      "remarks": "Resampling takes place as the sounds are loaded.",
      "type": "enum",
      "values": [
        {
          "description": "No linear resampling.",
          "name": "0"
        },
        {
          "description": "Linear resampling when upsampling only.",
          "name": "1"
        },
        {
          "description": "Linear resampling when downsampling and upsampling.",
          "name": "2"
        }
      ]
    },
    "s_linearresample_stream": {
      "default": "0",
      "desc": "Same as s_linearresample, but specifically for VOIP audio streams.",
      "group-id": "45",
      "type": "integer"
    },
    "s_loadas8bit": {
      "default": "0",
      "desc": "Reduce sound samples down to 8-bit at load time, trading quality for lower memory usage.",
      "group-id": "45",
      "remarks": "This used to help with performance on systems with low memory.",
      "type": "boolean"
    },
    "s_mixahead": {
      "desc": "Only affects OSS and legacy ALSA:\n\nThis variable defines the delay time for sounds. How low you can set your sound mixahead depends on your FPS, when you set it too low, your sound will start crackling.\nGenerally, with 72 FPS you should be able to use a delay of 0.06 seconds.",
      "group-id": "26",
      "type": "float"
    },
    "s_mm1_file": {
      "default": "misc/talk.wav",
      "desc": "You can specify notification sound for messagemode1 (/messagemode or /say foo) messages.",
      "group-id": "45",
      "type": "string"
    },
    "s_mm1_volume": {
      "default": "1",
      "desc": "You can specify volume of notification sound for messagemode1 (/messagemode or /say foo) messages.",
      "group-id": "45",
      "type": "float"
    },
    "s_mm2_file": {
      "default": "misc/talk.wav",
      "desc": "You can specify notification sound for messagemode2 (/messagemode2 or /say_team foo) messages.",
      "group-id": "45",
      "type": "string"
    },
    "s_mm2_volume": {
      "default": "1",
      "desc": "You can specify volume of notification sound for messagemode2 (/messagemode2 or /say_team foo) messages.",
      "group-id": "45",
      "type": "float"
    },
    "s_noalsa": {
      "desc": "Determinates sound output for linux clients: ALSA or OSS.",
      "group-id": "26",
      "remarks": "If you don't know what is ALSA and OSS - leave it at the default value.",
      "type": "enum",
      "values": [
        {
          "description": "Use ALSA sound output.",
          "name": "0"
        },
        {
          "description": "Use OSS sound output.",
          "name": "1"
        }
      ]
    },
    "s_noextraupdate": {
      "group-id": "45",
      "type": "boolean",
      "values": [
        {
          "description": "Makes Quake update its sound buffers more often to avoid choppy sound when your fps is really low (20 or worse)",
          "name": "false"
        },
        {
          "description": "Don't use extra sound updates.\nGives a slight fps boost, but may lead to choppy sound on low-end machines.",
          "name": "true"
        }
      ]
    },
    "s_nosound": {
      "default": "0",
      "group-id": "45",
      "type": "boolean",
      "values": [
        {
          "description": "Enable the playback of sounds.",
          "name": "false"
        },
        {
          "description": "Disable the playback of sounds.\nNote that it effectively just resets sound volume to zero, but the sound engine still runs.\nIf you want disable sound in order to get more fps, use the -nosound command line option instead.",
          "name": "true"
        }
      ]
    },
    "s_oss_device": {
      "default": "/dev/dsp",
      "desc": "Specifies which device OSS will try to open.",
      "group-id": "26",
      "type": "string"
    },
    "s_otherchat_file": {
      "default": "misc/talk.wav",
      "desc": "You can specify notification sound for other messages (than messagemode, messagemode2 and from spectators).",
      "group-id": "45",
      "type": "string"
    },
    "s_otherchat_volume": {
      "default": "1",
      "desc": "You can specify volume of notification sound for other messages (than messagemode, messagemode2 and from spectators).",
      "group-id": "45",
      "type": "float"
    },
    "s_precache": {
      "default": "1",
      "group-id": "45",
      "type": "boolean",
      "values": [
        {
          "description": "Disable automatic sound caching.",
          "name": "false"
        },
        {
          "description": "Enable automatic sound caching.",
          "name": "true"
        }
      ]
    },
    "s_pulseaudio_latency": {
      "desc": "Specifies latency for Pulseaudio.\nIf you got distortion in sound, upper the value a bit.\nIf you experience delays, try lowering this value.",
      "group-id": "26",
      "type": "float"
    },
    "s_raw_volume": {
      "default": "1",
      "desc": "Controls volume of voice (voip) playback.",
      "group-id": "45",
      "remarks": "See cl_voip_play.",
      "type": "float"
    },
    "s_show": {
      "default": "0",
      "desc": "Toggles displaying how many and/or which sound files are currently being played.",
      "group-id": "45",
      "type": "enum",
      "values": [
        {
          "description": "Do not show anything.",
          "name": "0"
        },
        {
          "description": "Print the number of sounds playing.",
          "name": "1"
        },
        {
          "description": "Print the volume in left/right speakers, name of sound file playing, and number of sounds playing.",
          "name": "2"
        }
      ]
    },
    "s_silent_racing": {
      "default": "0",
      "desc": "Toggles whether or not you can hear other players when racing.",
      "group-id": "45",
      "type": "boolean"
    },
    "s_spec_file": {
      "default": "misc/talk.wav",
      "desc": "You can specify notification sound for spectator messages.",
      "group-id": "45",
      "type": "string"
    },
    "s_spec_volume": {
      "default": "1",
      "desc": "You can specify volume of notification sound for spectator messages.",
      "group-id": "45",
      "type": "float"
    },
    "s_stereo": {
      "desc": "Use stereo or mono sound.",
      "group-id": "26",
      "remarks": "Linux only.\nUse s_restart after you change it.",
      "type": "boolean",
      "values": [
        {
          "description": "Mono.",
          "name": "false"
        },
        {
          "description": "Stereo.",
          "name": "true"
        }
      ]
    },
    "s_swapstereo": {
      "default": "0",
      "description": "Swaps left and right sound channels.",
      "group-id": "45",
      "type": "boolean"
    },
    "s_uselegacydrivers": {
      "desc": "If you are having problems with the new ALSA/OSS drivers you can enable this to be able to use legacy sound drivers, as in the ones used before v2.1.",
      "group-id": "26",
      "remarks": "Linux/FreeBSD only.",
      "type": "enum",
      "values": [
        {
          "description": "Will use new sound drivers for ALSA/OSS.",
          "name": "0"
        },
        {
          "description": "Will use legacy drivers for ALSA/OSS (as used in versions before 2.1)",
          "name": "1"
        }
      ]
    },
    "samelevel": {
      "default": "1",
      "desc": "When enabled, the same level will be played once the match is over.\nOther mods use this value to store options.",
      "group-id": "43",
      "type": "float",
      "values": [
        {
          "description": "Advance to next map after intermission.",
          "name": "0"
        },
        {
          "description": "Play same map again.",
          "name": "1"
        }
      ]
    },
    "sb_autohide": {
      "default": "1",
      "desc": "This toggles in which cases the server browser should automatically hide itself when connecting to a server.",
      "group-id": "42",
      "type": "enum",
      "values": [
        {
          "description": "Never hide server browser.",
          "name": "0"
        },
        {
          "description": "This will cause the server browser to always hide after connecting.",
          "name": "1"
        },
        {
          "description": "This will cause the server browser to hide after connecting only if the connected server is not a qizmo proxy.\nUseful if you often connect to Qizmos only for rerouting features (with \"useproxy 1\")",
          "name": "2"
        }
      ]
    },
    "sb_autoupdate": {
      "default": "1",
      "desc": "Enabled auto-updates (pings & refreshes status) servers from actually marked server sources in Server Browser.",
      "group-id": "42",
      "remarks": "Usefull with sb_starttab 1 and '+cfg_load myconfig +menu_slist' in command-line.",
      "type": "boolean",
      "values": [
        {
          "description": "do not refresh server list automatically.",
          "name": "false"
        },
        {
          "description": "auto-refresh server list when first entering Server Browser menu.",
          "name": "true"
        }
      ]
    },
    "sb_findroutes": {
      "default": "0",
      "desc": "Enables automatic lookup of lowest ping path via proxies for connection to each server in the server browser.",
      "group-id": "42",
      "remarks": "Use with connectbr command.",
      "type": "boolean",
      "values": [
        {
          "description": "Lookup disabled.",
          "name": "false"
        },
        {
          "description": "Lookup will start after the \"getting infos\" phase.",
          "name": "true"
        }
      ]
    },
    "sb_hidedead": {
      "default": "1",
      "desc": "This toggles whether ezQuake should hide dead servers.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "don't hide dead servers.",
          "name": "false"
        },
        {
          "description": "hide dead servers.",
          "name": "true"
        }
      ]
    },
    "sb_hideempty": {
      "default": "1",
      "desc": "This toggles whether ezQuake should hide empty servers.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "don't hide empty servers.",
          "name": "false"
        },
        {
          "description": "hide empty servers.",
          "name": "true"
        }
      ]
    },
    "sb_hidefull": {
      "default": "0",
      "desc": "This toggles whether ezQuake should hide full servers.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "don't hide full servers.",
          "name": "false"
        },
        {
          "description": "hide full servers.",
          "name": "true"
        }
      ]
    },
    "sb_hidehighping": {
      "default": "0",
      "desc": "Remove servers with high ping from the server list and also exclude them from querying servers for details.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "sb_hidenotempty": {
      "default": "0",
      "desc": "This toggles whether ezQuake should hide empty servers.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "don't hide empty servers.",
          "name": "false"
        },
        {
          "description": "hide empty servers.",
          "name": "true"
        }
      ]
    },
    "sb_ignore_proxy": {
      "default": "",
      "group-id": "42",
      "type": "string"
    },
    "sb_info_filter": {
      "default": "",
      "desc": "Allows custom filters to be written based on the serverinfo strings\nFormat is [+|-]infokey=value with +/- being include/exclude.\nCan also specify +*/-* to include/exclude all, and +key/-key to include/exclude servers with any value for that key\nValues are regular expressions, if the server doesn't have that key specified then the rule is skipped",
      "group-id": "42",
      "remarks": "Default (if no rules match) is opposite of the last valid rule specified.\nRules should be separated by spaces\nExamples\n\n+ktxver               // pass any ktx server, hide others\n+*gamedir=fortress    // pass Team Fortress servers, hide others\n-*version=QTV*        // remove QTV servers\n-map=dm4              // fourier woz ere\n",
      "type": "string"
    },
    "sb_inforetries": {
      "default": "3",
      "desc": "This determines how often ezQuake should try to retrieve information from a server until it is considered to be not responding.",
      "group-id": "42",
      "type": "float"
    },
    "sb_infospersec": {
      "default": "100",
      "desc": "This determines how many serverinfos per second ezQuake should retrieve when scanning servers.\nWhen setting this value too high you will flood your line, causing you to not receive information from servers or lagging your connection to the server you are currently connected to.",
      "group-id": "42",
      "type": "float"
    },
    "sb_infotimeout": {
      "default": "1000",
      "desc": "This determines how long ezQuake will wait for a reply when trying to retrieve information from a server until the attempt times out.",
      "group-id": "42",
      "type": "float"
    },
    "sb_listcache": {
      "default": "0",
      "desc": "Cache the list of alive servers and load it on next startup of the client.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "sb_liveupdate": {
      "default": "2",
      "desc": "This will determine how often ezQuake should refresh the serverinfo window, the specified value sets the delay in seconds.\nSetting it to \"0\" will disable automatic refreshing.",
      "group-id": "42",
      "type": "float"
    },
    "sb_mastercache": {
      "default": "1",
      "desc": "This toggles whether ezQuake should cache the results of queries to master server (in directory qw/sb/cache).\nIf you restart ezQuake and don't update sources or if a master server is down, ezQuake will use the cache.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "don't use cache for master servers.",
          "name": "false"
        },
        {
          "description": "use the cache for master servers when they are down or haven't been refreshed.",
          "name": "true"
        }
      ]
    },
    "sb_masterretries": {
      "default": "3",
      "desc": "This determines how often ezQuake should try to retrieve information from a master server until it is considered to be not responding.",
      "group-id": "42",
      "type": "float"
    },
    "sb_mastertimeout": {
      "default": "1000",
      "desc": "This determines how long ezQuake will wait for a reply when trying to retrieve information from a master server until the attempt times out.",
      "group-id": "42",
      "type": "float"
    },
    "sb_nosockraw": {
      "default": "0",
      "desc": "Disable ICMP pinging in server browser and use UDP QW Ping packet to query servers for their ping (multithreaded).",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "sb_pinglimit": {
      "default": "80",
      "desc": "Limit ping for servers to be visible when sb_hidehighping is enabled.",
      "group-id": "42",
      "type": "integer"
    },
    "sb_pings": {
      "default": "3",
      "desc": "This determines how many pings ezQuake will send to a server when trying to determine your ping to it.\nA higher value will cause scanning servers to take longer, but the result may be more exact.\nA lower value obviously makes scanning faster, but pings may be inaccurate.",
      "group-id": "42",
      "type": "float"
    },
    "sb_pingspersec": {
      "default": "150",
      "desc": "This determines how many pings per second ezQuake should sent out when scanning servers.\nIf you set this value too high the result will be that the pings will not be accurate because you overloaded your line.\nIf you set it too low scanning servers will take very long especially when you have a large server list.",
      "group-id": "42",
      "type": "float"
    },
    "sb_pingtimeout": {
      "default": "1000",
      "desc": "This determines how long ezQuake will wait for a reply when trying to ping a server until the attempt times out.",
      "group-id": "42",
      "type": "float"
    },
    "sb_proxinfopersec": {
      "default": "10",
      "desc": "Number of proxies to contact per second.\nUsed when finding fastest path to a server.",
      "group-id": "42",
      "type": "float"
    },
    "sb_proxretries": {
      "default": "3",
      "desc": "Number of times to attempt contact with a proxy before giving up.",
      "group-id": "42",
      "type": "integer"
    },
    "sb_proxtimeout": {
      "default": "1000",
      "desc": "Timeout period (in ms) before a proxy connection times out.",
      "group-id": "42",
      "type": "integer"
    },
    "sb_showaddress": {
      "default": "0",
      "desc": "This toggles whether ezQuake should display the server IP column in the server list.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "do not show the server IP column.",
          "name": "false"
        },
        {
          "description": "show the server IP column.",
          "name": "true"
        }
      ]
    },
    "sb_showcounters": {
      "desc": "This toggles whether ezQuake should display the number of servers or players in the status line.",
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "do not show the server/player counter in the status line.",
          "name": "false"
        },
        {
          "description": "show the server/player counter in the status line.",
          "name": "true"
        }
      ]
    },
    "sb_showfraglimit": {
      "default": "0",
      "desc": "This toggles whether ezQuake should display the fraglimit column in the server list.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "do not show the fraglimit column.",
          "name": "false"
        },
        {
          "description": "show the fraglimit column.",
          "name": "true"
        }
      ]
    },
    "sb_showgamedir": {
      "default": "0",
      "desc": "This toggles whether ezQuake should display the gamedir column in the server list, for example to see which mod is being played.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "do not show the gamedir column.",
          "name": "false"
        },
        {
          "description": "show the gamedir column.",
          "name": "true"
        }
      ]
    },
    "sb_showmap": {
      "default": "1",
      "desc": "This toggles whether ezQuake should display the map column in the server list.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "do not show the map column.",
          "name": "false"
        },
        {
          "description": "show the map column.",
          "name": "true"
        }
      ]
    },
    "sb_showping": {
      "default": "1",
      "desc": "This toggles whether ezQuake should display the ping column in the server list.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "do not show the ping column.",
          "name": "false"
        },
        {
          "description": "show the ping column.",
          "name": "true"
        }
      ]
    },
    "sb_showplayers": {
      "default": "1",
      "desc": "This toggles whether ezQuake should display the players column in the server list that shows how many players are on the server as well as how many players are allowed.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "do not show the players column.",
          "name": "false"
        },
        {
          "description": "show the players column.",
          "name": "true"
        }
      ]
    },
    "sb_showproxies": {
      "default": "0",
      "desc": "Toggle display of proxy servers (QWFwd and Qizmo) in the Server Browser.",
      "group-id": "42",
      "type": "enum",
      "values": [
        {
          "description": "Hide proxies in the server browser.",
          "name": "0"
        },
        {
          "description": "Show proxies in the server browser.",
          "name": "1"
        },
        {
          "description": "Only show proxies in the server browser.",
          "name": "2"
        }
      ]
    },
    "sb_showtimelimit": {
      "default": "0",
      "desc": "This toggles whether ezQuake should display the timelimit column in the server list.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "do not show the timelimit column.",
          "name": "false"
        },
        {
          "description": "show the timelimit column.",
          "name": "true"
        }
      ]
    },
    "sb_sortplayers": {
      "default": "92",
      "desc": "This determines sort order in the players list. This uses the numbers from the description of the columns.\nCheck \"Columns available in servers/players list\" above for an explanation of each number.\nA \"-\" in front of the value reverses the sort order for that value from ascending to descending.\n\naddress (ip:port).",
      "group-id": "42",
      "type": "float"
    },
    "sb_sortservers": {
      "default": "32",
      "desc": "This determines sort order in the servers list. This uses the numbers from the description of the columns.\nCheck \"Columns available in servers/players list\"  above for an explanation of each number.\nA \"-\" in front of the value reverses the sort order for that value from ascending to descending.\n\nserver address (ip:port).",
      "group-id": "42",
      "type": "float"
    },
    "sb_sortsources": {
      "default": "3",
      "desc": "Ordering instructions for server browser sources list are stored in this variable.\nYou can order source server in Server browser by pressing Ctrl+1, Ctrl+2 and Ctrl+3.\nSequence of your desired combination will be stored in this variable, newest keys first.",
      "group-id": "42",
      "type": "string",
      "values": [
        {
          "description": "E.g.: 3-21 means you've pressed Ctrl+1, Ctrl+2, Ctrl+2 and Ctrl+3 so your sources are now ordered by server count, last update time and source name.",
          "name": "*"
        }
      ]
    },
    "sb_sourcevalidity": {
      "default": "30",
      "desc": "This sets the time of master servers validity in minutes.\nMaster servers that were updated within the specified time will not be refreshed when updating sources with [SPACE].",
      "group-id": "42",
      "type": "float"
    },
    "sb_status": {
      "default": "1",
      "desc": "This toggles whether the server status should be displayed in the two bottom lines of the server browser.",
      "group-id": "42",
      "type": "boolean",
      "values": [
        {
          "description": "do not display the status.",
          "name": "false"
        },
        {
          "description": "display the status.",
          "name": "true"
        }
      ]
    },
    "scr_allowsnap": {
      "default": "1",
      "group-id": "41",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Allow screenshot uploads to be requested by server.",
          "name": "true"
        }
      ]
    },
    "scr_autoid": {
      "default": "5",
      "desc": "Controls how names and other info are displayed above players, when spectating.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Do not show any player info.",
          "name": "0"
        },
        {
          "description": "Show name.",
          "name": "1"
        },
        {
          "description": "Name + health and armor bars.",
          "name": "2"
        },
        {
          "description": "2 + Show armor name/icon.",
          "name": "3"
        },
        {
          "description": "3 + Show if the user's best weapon is RL.",
          "name": "4"
        },
        {
          "description": "3 + Show the user's best weapon name/icon. Minimum best weapon set with scr_autoid_weapons.",
          "name": "5"
        }
      ]
    },
    "scr_autoid_armorbar_green_armor": {
      "default": "25 170 0 255",
      "desc": "Color of the autoID armor bar when a player has the Green armor.",
      "group-id": "40",
      "type": "string"
    },
    "scr_autoid_armorbar_red_armor": {
      "default": "255 0 0 255",
      "desc": "Color of the autoID armor bar when a player has the Red armor.",
      "group-id": "40",
      "type": "string"
    },
    "scr_autoid_armorbar_yellow_armor": {
      "default": "255 220 0 255",
      "desc": "Color of the autoID armor bar when a player has the Yellow armor.",
      "group-id": "40",
      "type": "string"
    },
    "scr_autoid_barlength": {
      "default": "16",
      "desc": "Sets a fixed length for health/armor bars in autoID.",
      "group-id": "40",
      "remarks": "If 0, length will be based on scr_autoid_namelength and/or length of individual player's name.",
      "type": "integer"
    },
    "scr_autoid_drawname": {
      "desc": "Shows player names when using autoID.",
      "group-id": "31",
      "type": "boolean",
      "values": [
        {
          "description": "Do not show player names.",
          "name": "false"
        },
        {
          "description": "Show player names.",
          "name": "true"
        }
      ]
    },
    "scr_autoid_healthbar_bg_color": {
      "default": "180 115 115 100",
      "desc": "Background color of the autoID health bar.",
      "group-id": "40",
      "type": "string"
    },
    "scr_autoid_healthbar_mega_color": {
      "default": "255 0 0 255",
      "desc": "Color of the autoID health bar when a player has a Megahealth.",
      "group-id": "40",
      "type": "string"
    },
    "scr_autoid_healthbar_normal_color": {
      "default": "80 0 0 255",
      "desc": "Default color of the autoID health bar.",
      "group-id": "40",
      "type": "string"
    },
    "scr_autoid_healthbar_two_mega_color": {
      "default": "255 100 0 255",
      "desc": "Color of the autoID health bar when a player has multiple Megahealths.",
      "group-id": "40",
      "type": "string"
    },
    "scr_autoid_healthbar_unnatural_color": {
      "default": "255 255 255 255",
      "desc": "Color of the autoID health bar for any unusual situation (i.e invincibility during warmup).",
      "group-id": "40",
      "type": "string"
    },
    "scr_autoid_namelength": {
      "default": "0",
      "desc": "Maximum number of characters for autoID player names.",
      "group-id": "40",
      "type": "integer"
    },
    "scr_autoid_proportional": {
      "default": "0",
      "desc": "Enable TrueType fonts on autoID text.",
      "group-id": "5",
      "type": "boolean"
    },
    "scr_autoid_scale": {
      "default": "1",
      "desc": "Sets relative size of scr_autoid display.",
      "group-id": "40",
      "type": "float"
    },
    "scr_autoid_weaponicon": {
      "default": "1",
      "desc": "Sets the style of player's weapons in autoID.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Player's weapon is indicated by text (RL, etc).",
          "name": "false"
        },
        {
          "description": "Player's weapon is indicated by an icon.",
          "name": "true"
        }
      ]
    },
    "scr_autoid_weapons": {
      "default": "2",
      "desc": "Determines the minimum best weapon to show for a player when scr_autoid > 4.",
      "group-id": "40",
      "remarks": "The order of 'best' weapon can be controlled via the 'tp_weapon_order' variable.",
      "type": "enum",
      "values": [
        {
          "description": "Shotgun or better.",
          "name": "1"
        },
        {
          "description": "Super shotgun or better.",
          "name": "2"
        },
        {
          "description": "Nailgun or better.",
          "name": "4"
        },
        {
          "description": "Super nailgun or better.",
          "name": "8"
        },
        {
          "description": "Grenade launcher or better.",
          "name": "16"
        },
        {
          "description": "Rocket launcher or better.",
          "name": "32"
        },
        {
          "description": "Lightning gun or better.",
          "name": "64"
        }
      ]
    },
    "scr_centerMenu": {
      "default": "1",
      "desc": "Centers the menu vertically (has no effect if you're playing in 320x200 mode, same applies to scr_centersbar).",
      "group-id": "17",
      "type": "boolean"
    },
    "scr_centerSbar": {
      "default": "1",
      "description": "Centers the status bar (classic HUD).",
      "group-id": "47",
      "type": "boolean"
    },
    "scr_centershift": {
      "default": "0",
      "desc": "Shifts all centerprints.\nIf you are playing in 1280x1024 and want to watch some demo recorded in 320x200 with +wp_stats (ktpro) or sbar_on (teamfortress) you can shift that text down.",
      "group-id": "40",
      "type": "integer",
      "values": [
        {
          "description": "Range -999 to 999.",
          "name": "*"
        }
      ]
    },
    "scr_centerspeed": {
      "default": "8",
      "desc": "This variable controls how fast the text is displayed at the end of the single player episodes.",
      "group-id": "5",
      "type": "float"
    },
    "scr_centertime": {
      "default": "2",
      "desc": "This variable sets the amount of time in seconds that centerprinted messages stay on the screen.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Do not display any centerprints.",
          "name": "0"
        },
        {
          "description": "Display centerprints for 1 second.",
          "name": "1"
        },
        {
          "description": "Display centerprints for 2 seconds.",
          "name": "2"
        }
      ]
    },
    "scr_coloredText": {
      "default": "1",
      "desc": "Allows colored text in scoreboard, console and notify area.",
      "group-id": "40",
      "remarks": "See Colored text manual page for more details.",
      "type": "enum",
      "values": [
        {
          "description": "Disable rainbow spectator text on the scoreboard.",
          "name": "0"
        },
        {
          "description": "Enable rainbow spectator text on the scoreboard.",
          "name": "1"
        },
        {
          "description": "Enable rainbow spectator text on the scoreboard plus parse colored console messages.",
          "name": "2"
        }
      ]
    },
    "scr_coloredfrags": {
      "default": "0",
      "desc": "Frag messages will be colored according to your teamcolor/enemycolor settings.",
      "group-id": "40",
      "remarks": "Needs scr_coloredText 1, cl_parsefrags 1, cl_loadfragfiles 1.",
      "type": "boolean",
      "values": [
        {
          "description": "Coloring off.",
          "name": "false"
        },
        {
          "description": "Coloring on.",
          "name": "true"
        }
      ]
    },
    "scr_compactHud": {
      "default": "0",
      "group-id": "47",
      "type": "enum",
      "values": [
        {
          "description": "Compact huds off.",
          "name": "0"
        },
        {
          "description": "Will display armour/health/ammo/weapons *very* compactly.",
          "name": "1"
        },
        {
          "description": "Will display armour/health/ammo *very* compactly.",
          "name": "2"
        },
        {
          "description": "Displays only health/armour.",
          "name": "3"
        },
        {
          "description": "Will display armour/health/ammo/weapons compactly with icons.",
          "name": "4"
        }
      ]
    },
    "scr_compactHudAlign": {
      "default": "0",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "determine ammo amounts are aligned to the left.",
          "name": "false"
        },
        {
          "description": "determine ammo amounts are aligned to the right.",
          "name": "true"
        }
      ]
    },
    "scr_conalpha": {
      "default": "0.8",
      "desc": "Opacity of the console background.",
      "group-id": "5",
      "type": "float",
      "values": [
        {
          "description": "Transparent.",
          "name": "0"
        },
        {
          "description": "Opaque.",
          "name": "1"
        }
      ]
    },
    "scr_conback": {
      "default": "1",
      "desc": "Allows display of map preview as a console background.",
      "group-id": "5",
      "type": "enum",
      "values": [
        {
          "description": "Never display map preview.",
          "name": "0"
        },
        {
          "description": "Display map preview on level loading process.",
          "name": "1"
        },
        {
          "description": "Always display map preview as a console background.",
          "name": "2"
        }
      ]
    },
    "scr_conpicture": {
      "default": "conback",
      "desc": "Console background image filename.",
      "group-id": "5",
      "remarks": "Put console images into id1/gfx or qw/gfx or ezquake/gfx.",
      "type": "string"
    },
    "scr_consize": {
      "default": "0.5",
      "desc": "Sets the height of the console during a game.",
      "group-id": "5",
      "type": "float",
      "values": [
        {
          "description": "Range 0 to 1.",
          "name": "*"
        }
      ]
    },
    "scr_conspeed": {
      "default": "9999",
      "desc": "This variable controls the speed at which the console screen scrolls up and down.",
      "group-id": "5",
      "type": "float"
    },
    "scr_cursor_alpha": {
      "default": "1",
      "desc": "Level of transparency of the cursor used in menus and HUD editor.",
      "group-id": "17",
      "type": "float"
    },
    "scr_cursor_iconoffset_x": {
      "default": "0",
      "desc": "Offset of the cursor image used in menus and HUD editor.",
      "group-id": "17",
      "type": "integer"
    },
    "scr_cursor_iconoffset_y": {
      "default": "0",
      "desc": "Offset of the cursor image used in menus and HUD editor.",
      "group-id": "17",
      "type": "integer"
    },
    "scr_cursor_scale": {
      "default": "0.2",
      "desc": "Size of the cursor image used in menus and HUD editor.",
      "group-id": "17",
      "type": "float"
    },
    "scr_cursor_sensitivity": {
      "default": "1",
      "desc": "Mouse sensitivity for the cursor used in menus and HUD editor.",
      "group-id": "17",
      "type": "float"
    },
    "scr_damage_floating": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "scr_damage_hitbeep": {
      "default": "0",
      "group-id": "0",
      "system-generated": true
    },
    "scr_damage_offset_ingame": {
      "default": "14",
      "group-id": "0",
      "system-generated": true
    },
    "scr_damage_offset_spectator": {
      "default": "28",
      "group-id": "0",
      "system-generated": true
    },
    "scr_damage_proportional": {
      "default": "0",
      "desc": "Enable TrueType fonts on damage text.",
      "group-id": "5",
      "type": "boolean"
    },
    "scr_damage_scale": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "scr_drawHFrags": {
      "default": "1",
      "desc": "Displays horizontal bar with frag stats (4 cells) in the old hud.",
      "group-id": "47",
      "remarks": "Required settings for this to work:\nscr_newhud 0 or 2, viewsize below 110, cl_sbar 1 or cl_sbar 0 but vid_conwidth below 512.\nif you migrated from FuhQuake and can't get this to work, check these settings, the feature should work the same as in FuhQuake.",
      "type": "enum",
      "values": [
        {
          "description": "Turns frag display off.",
          "name": "0"
        },
        {
          "description": "Individual frags.",
          "name": "1"
        },
        {
          "description": "Teamfrags in teamplay mode.",
          "name": "2"
        },
        {
          "description": "Teamfrags in teamplay mode, individual frags hidden.",
          "name": "3"
        }
      ]
    },
    "scr_drawVFrags": {
      "default": "1",
      "desc": "Shows vertical row with frag stats on the right side of the old hud.\nWhen teamplay mode is on, will display also frags per team.",
      "group-id": "47",
      "remarks": "Note: vid_conwidth must be at least 512, scr_centerSbar must be disabled.\nWorks only in deathmatch, not in cooperative.",
      "type": "enum",
      "values": [
        {
          "description": "Turns frag display off.",
          "name": "0"
        },
        {
          "description": "Individual frags.",
          "name": "1"
        },
        {
          "description": "Teamfrags in teamplay mode.",
          "name": "2"
        }
      ]
    },
    "scr_fovmode": {
      "default": "0",
      "desc": "Determines how to keep aspect ratio correct when viewsize is reduced.",
      "group-id": "53",
      "type": "enum",
      "values": [
        {
          "description": "Standard QWCL behaviour: reduce vertical fov, cropping image.",
          "name": "0"
        },
        {
          "description": "Reduce horizontal size, keeping aspect ratio correct.",
          "name": "1"
        }
      ]
    },
    "scr_menualpha": {
      "default": "0.7",
      "desc": "Opacity of the main menu's background.",
      "group-id": "40",
      "type": "float",
      "values": [
        {
          "description": "Transparent mainmenu.",
          "name": "0"
        },
        {
          "description": "Black mainmenu.",
          "name": "1"
        }
      ]
    },
    "scr_menudrawhud": {
      "default": "0",
      "desc": "Draw HUD elements/crosshair/etc in background of main menu.\nUseful when HUD distracting you in server browser.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Don't draw HUD elements when in menus.",
          "name": "false"
        },
        {
          "description": "Draw HUD elements when in menus.",
          "name": "true"
        }
      ]
    },
    "scr_newhud": {
      "default": "0",
      "group-id": "47",
      "type": "enum",
      "values": [
        {
          "description": "Old standard status bar.",
          "name": "0"
        },
        {
          "description": "New customizable status bar.",
          "name": "1"
        },
        {
          "description": "First draws old status bar and then renders new status bar on the top of it.",
          "name": "2"
        }
      ]
    },
    "scr_notifyalways": {
      "default": "0",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "The notify area is hidden during intermission (chat messages go to console but not to screen)",
          "name": "false"
        },
        {
          "description": "The notify area is always shown.",
          "name": "true"
        }
      ]
    },
    "scr_qtvbuffer": {
      "default": "0",
      "desc": "Enables display of the QTV buffer status.",
      "group-id": "40",
      "remarks": "Makes it able to check how much of the stream is buffered on the client side.",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "scr_qtvbuffer_x": {
      "default": "0",
      "desc": "Horizontal position of the qtvbuffer counter.",
      "group-id": "40",
      "type": "integer"
    },
    "scr_qtvbuffer_y": {
      "default": "-10",
      "desc": "Vertical position of the qtvbuffer counter.",
      "group-id": "40",
      "type": "integer"
    },
    "scr_sbar_drawammo": {
      "default": "1",
      "desc": "Turns drawing amount of ammo on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw ammo.",
          "name": "false"
        },
        {
          "description": "Draw ammo.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawammocounts": {
      "default": "1",
      "desc": "Turns drawing amounts of ammo on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw countrs of ammo.",
          "name": "false"
        },
        {
          "description": "Draw countrs of ammo.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawammoicon": {
      "default": "1",
      "desc": "Turns drawing of ammo icon on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw ammo icon.",
          "name": "false"
        },
        {
          "description": "Draw ammo icon.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawarmor": {
      "default": "1",
      "desc": "Turns drawing of armor count on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw armor count.",
          "name": "false"
        },
        {
          "description": "Draw armor count.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawarmor666": {
      "default": "1",
      "desc": "Turns on/off drawing of armor as 666 when holding pent.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw armor as 666 and instead draw current armor value.",
          "name": "false"
        },
        {
          "description": "Draw armor as 666.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawarmoricon": {
      "default": "1",
      "desc": "Turns drawing of armor icon on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw armor icon.",
          "name": "false"
        },
        {
          "description": "Draw armor icon.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawfaceicon": {
      "default": "1",
      "desc": "Turns drawing of face icon on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw face icon.",
          "name": "false"
        },
        {
          "description": "Draw face icon.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawguns": {
      "default": "1",
      "desc": "Turns drawing of available guns on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw available guns.",
          "name": "false"
        },
        {
          "description": "Draw avialable guns.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawhealth": {
      "default": "1",
      "desc": "Turns drawing of health amount on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw health amount.",
          "name": "false"
        },
        {
          "description": "Draw health amount.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawitems": {
      "default": "1",
      "desc": "Turns drawing of items (powerups and keys) in status bar on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw items in status bar.",
          "name": "false"
        },
        {
          "description": "Draw items in status bar.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_drawsigils": {
      "default": "1",
      "desc": "Turns drawing of sigils on/off.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "boolean",
      "values": [
        {
          "description": "Do not draw sigils.",
          "name": "false"
        },
        {
          "description": "Draw sigils.",
          "name": "true"
        }
      ]
    },
    "scr_sbar_lowammo": {
      "default": "5",
      "desc": "The ammo limit at which ammo numbers will start using the alternate text.",
      "group-id": "47",
      "remarks": "This variable applies for old HUD <= 'scr_newhud 0'.",
      "type": "integer"
    },
    "scr_scaleMenu": {
      "default": "2",
      "desc": "Scales the frontend menu.",
      "group-id": "17",
      "type": "float",
      "values": [
        {
          "description": "Disable scaling.",
          "name": "0"
        }
      ]
    },
    "scr_scoreboard_afk": {
      "default": "1",
      "desc": "If set, indicate players who are AFK (don't have Quake active)",
      "group-id": "47",
      "type": "boolean"
    },
    "scr_scoreboard_afk_style": {
      "default": "1",
      "desc": "Affects how a player being away from the game is reflected in scoreboard.",
      "group-id": "47",
      "type": "enum",
      "values": [
        {
          "description": "If user is AFK, time replaced with AFK.",
          "name": "1"
        },
        {
          "description": "If user is AFK, time value shown in red.",
          "name": "2"
        }
      ]
    },
    "scr_scoreboard_borderless": {
      "default": "1",
      "desc": "Disables the border around the scoreboard.",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Scoreboard will have a border.",
          "name": "false"
        },
        {
          "description": "Scoreboard will not have a border.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_centered": {
      "default": "1",
      "desc": "Controls X-position of scoreboard.",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Scoreboard will not be centered.",
          "name": "false"
        },
        {
          "description": "Scoreboard will be centered.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_classic": {
      "default": "0",
      "desc": "Toggle between the classic and modern look in the scoreboard.",
      "group-id": "47",
      "type": "enum",
      "values": [
        {
          "description": "Disable the classic look.",
          "name": "0"
        },
        {
          "description": "Enable the classic look.",
          "name": "1"
        },
        {
          "description": "Enable the true classic look, which was available in qwcl 1.50 and 1.55",
          "name": "2"
        }
      ]
    },
    "scr_scoreboard_drawtitle": {
      "default": "1",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Disable scoreboard title.",
          "name": "false"
        },
        {
          "description": "Enable scoreboard title.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_fadescreen": {
      "default": "0",
      "desc": "shadowing level, when scoreboard is displayed.",
      "group-id": "47",
      "type": "float",
      "values": [
        {
          "description": "[0...1] 0=transparent scoreboard 1=black scoreboard.",
          "name": "*"
        }
      ]
    },
    "scr_scoreboard_fillalpha": {
      "default": "0.7",
      "desc": "Change scoreboard fillalpha.",
      "group-id": "47",
      "type": "float"
    },
    "scr_scoreboard_fillcolored": {
      "default": "2",
      "desc": "Modify scoreboard fillcolor.",
      "group-id": "47",
      "type": "float"
    },
    "scr_scoreboard_forcecolors": {
      "default": "1",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "When you overwrite team/enemy color it will use only those colors for skins.",
          "name": "false"
        },
        {
          "description": "When you overwrite team/enemy color it will use only those colors for skins and scoreboard.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_highlightself": {
      "default": "1",
      "desc": "Toggle the highlighting of your own scores in the scoreboard.",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Disable highlight of your own scores in the scoreboard.",
          "name": "false"
        },
        {
          "description": "Enable highlight of your own scores in the scoreboard.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_login_color": {
      "default": "255 255 192",
      "group-id": "0",
      "system-generated": true
    },
    "scr_scoreboard_login_flagfile": {
      "default": "flags",
      "group-id": "0",
      "system-generated": true
    },
    "scr_scoreboard_login_indicator": {
      "default": "&cffc*&r",
      "group-id": "0",
      "system-generated": true
    },
    "scr_scoreboard_login_names": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "scr_scoreboard_posx": {
      "default": "0",
      "desc": "Controls the X-offset of the scoreboard.",
      "group-id": "47",
      "type": "integer",
      "values": [
        {
          "description": "If 0, scoreboard will be shown at the left of the screen (scr_scoreboard_centered 0) or middle (scr_scoreboard_centered 1).\nIf nonzero, the scoreboard will be shifted left (negative values) or right (positive values).",
          "name": "*"
        }
      ]
    },
    "scr_scoreboard_posy": {
      "default": "0",
      "desc": "Controls the Y-offset of the scoreboard.",
      "group-id": "47",
      "type": "integer",
      "values": [
        {
          "description": "If 0, scoreboard will be shown at the top of the screen.\nIf nonzero, the scoreboard will be shifted down.",
          "name": "*"
        }
      ]
    },
    "scr_scoreboard_proportional": {
      "default": "0",
      "desc": "Enable TrueType fonts on the scoreboard.",
      "group-id": "5",
      "type": "boolean"
    },
    "scr_scoreboard_qtv_name": {
      "desc": "This variable will change what qtv users are called in the scoreboard.\nWhen teamplay is not on, this variable is cut to 4 characters.\n&cRGB values are not accepted.",
      "group-id": "47",
      "type": "string"
    },
    "scr_scoreboard_showclock": {
      "default": "0",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Hide the clock on the scoreboard.",
          "name": "false"
        },
        {
          "description": "Show the clock on the scoreboard.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_showflagstats": {
      "default": "0",
      "desc": "This setting has no effect on TeamFortress which automatically enables flag stats",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Disable flag stats on the scoreboard.",
          "name": "false"
        },
        {
          "description": "Enable flag stats on the scoreboard.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_showfrags": {
      "default": "1",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Disable frags on the scoreboard.",
          "name": "false"
        },
        {
          "description": "Enable frags on the scoreboard.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_showmapname": {
      "default": "0",
      "group-id": "47",
      "type": "enum",
      "values": [
        {
          "description": "Don't display the level name",
          "name": "0"
        },
        {
          "description": "Full name, example: The Abandoned Base (dm3)",
          "name": "1"
        },
        {
          "description": "Level name, example: The Abandoned Base",
          "name": "2"
        },
        {
          "description": "Map name, example: dm3",
          "name": "3"
        }
      ]
    },
    "scr_scoreboard_showqtvusers": {
      "default": "1",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Disable QTV users in the scoreboard.",
          "name": "false"
        },
        {
          "description": "Enable QTV users in the scoreboard.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_spectator_name": {
      "desc": "This variable will change what spectators are called in the scoreboard.\nWhen teamplay is not on, this variable is cut to 4 characters.\n&cRGB values are not accepted.",
      "group-id": "47",
      "type": "string"
    },
    "scr_scoreboard_teamsort": {
      "default": "1",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Frag sort.",
          "name": "false"
        },
        {
          "description": "Team sort.",
          "name": "true"
        }
      ]
    },
    "scr_scoreboard_wipeout": {
      "default": "1",
      "group-id": "47",
      "type": "boolean",
      "values": [
        {
          "description": "Display normal scoreboard during clan arena or wipeout modes.",
          "name": "false"
        },
        {
          "description": "Display game-specific scoreboard during clan arena or wipeout modes.",
          "name": "true"
        }
      ]
    },
    "scr_showcrosshair": {
      "default": "1",
      "desc": "Allows you to force the display of the crosshair when in menus or in scoreboard.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "scr_shownick_frame_color": {
      "default": "10 0 0 120",
      "desc": "If using '/shownick 1' in KTX, this determines the color of the frame around the on-screen information.",
      "group-id": "40",
      "type": "string"
    },
    "scr_shownick_name_width": {
      "default": "6",
      "desc": "Maximum length of player's name when using '/shownick 1' in KTX.",
      "group-id": "40",
      "type": "integer"
    },
    "scr_shownick_order": {
      "default": "%p%n %a/%H %w",
      "desc": "Format string for results of '/shownick 1' in KTX.",
      "group-id": "40",
      "type": "string"
    },
    "scr_shownick_proportional": {
      "default": "0",
      "desc": "Enable TrueType fonts on shownick text.",
      "group-id": "5",
      "type": "boolean"
    },
    "scr_shownick_scale": {
      "default": "1",
      "desc": "Adjusts relative size of text when showing results of '/shownick 1' in KTX.",
      "group-id": "40",
      "type": "float"
    },
    "scr_shownick_show_ammo": {
      "default": "0",
      "desc": "Displays ammo count next to best weapon.",
      "group-id": "40",
      "type": "boolean"
    },
    "scr_shownick_time": {
      "default": "0.8",
      "desc": "Number of seconds to show results of '/shownick 1' command in KTX.",
      "group-id": "40",
      "type": "float"
    },
    "scr_shownick_x": {
      "default": "0",
      "desc": "Horizontal position of the shownick label.",
      "group-id": "40",
      "type": "integer"
    },
    "scr_shownick_y": {
      "default": "0",
      "desc": "Vertical position of the shownick label.",
      "group-id": "40",
      "type": "integer"
    },
    "scr_spectatorMessage": {
      "default": "1",
      "desc": "Switch on/off the text at the bottom of the screen when spectating in free mode:\n\"SPECTATOR MODE | PRESS [ATTACK] for AutoCamera\"",
      "group-id": "40",
      "type": "boolean"
    },
    "scr_teaminfo": {
      "default": "1",
      "desc": "Displays team info when you are spectating or watching mvd demo.",
      "group-id": "40",
      "remarks": "see scr_teaminfo_* for other options.",
      "type": "boolean",
      "values": [
        {
          "description": "No team info.",
          "name": "false"
        },
        {
          "description": "Display team info.",
          "name": "true"
        }
      ]
    },
    "scr_teaminfo_align_right": {
      "default": "1",
      "desc": "Aligns scr_teaminfo left or right.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Align scr_teaminfo left.",
          "name": "false"
        },
        {
          "description": "Align scr_teaminfo right.",
          "name": "true"
        }
      ]
    },
    "scr_teaminfo_armor_style": {
      "default": "3",
      "desc": "Changes %a to different styles.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Does not display teammates' armor.",
          "name": "0"
        },
        {
          "description": "Displays teammates' armor in white, prefixed by the icon of the armor they have.",
          "name": "1"
        },
        {
          "description": "Displays teammates' armor in white.",
          "name": "2"
        },
        {
          "description": "Displays teammates' armor in the color of the armor they have.",
          "name": "3"
        },
        {
          "description": "Displays teammates' armor in white, prefixed by g|y|r depending on type.",
          "name": "4"
        }
      ]
    },
    "scr_teaminfo_flag_style": {
      "default": "1",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Flag icons.",
          "name": "1"
        },
        {
          "description": "Colored text.",
          "name": "2"
        }
      ]
    },
    "scr_teaminfo_frame_color": {
      "default": "10 0 0 120",
      "desc": "Changes the color and transparency of scr_teaminfo's frame.",
      "group-id": "40",
      "type": "string",
      "values": [
        {
          "description": "R G B alpha, each 0-255.",
          "name": "*"
        }
      ]
    },
    "scr_teaminfo_loc_width": {
      "default": "5",
      "desc": "Sets the width for %l.",
      "group-id": "40",
      "type": "integer",
      "values": [
        {
          "description": "From 0 (no loc display) to 20.",
          "name": "*"
        }
      ]
    },
    "scr_teaminfo_low_health": {
      "default": "25",
      "desc": "Sets a minimum health value to display red.\nE.g. if scr_teaminfo_low_health is 20, and a teammate has 20 health or less, then their health will be displayed red.",
      "group-id": "40",
      "type": "float",
      "values": [
        {
          "description": "From 1 to 99.",
          "name": "*"
        }
      ]
    },
    "scr_teaminfo_name_width": {
      "default": "6",
      "desc": "Sets name width in scr_teaminfo.",
      "group-id": "40",
      "type": "integer",
      "values": [
        {
          "description": "From 0 (don't display name) to 20.",
          "name": "*"
        }
      ]
    },
    "scr_teaminfo_order": {
      "default": "%p%n $x10%l$x11 %a/%H %w",
      "desc": "Changes the order of displayed items in scr_teaminfo.",
      "group-id": "40",
      "remarks": "default: \"%p%n [%l] %h/%a %w\"",
      "type": "string",
      "values": [
        {
          "description": "Options: %p (powerup) %n (name) %h (health) %a (armor) %l (location) %w (weapon)",
          "name": "*"
        }
      ]
    },
    "scr_teaminfo_powerup_style": {
      "default": "1",
      "desc": "Controls how powerup indicators are displayed in scr_teaminfo.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Powerup icons.",
          "name": "1"
        },
        {
          "description": "Player face.",
          "name": "2"
        },
        {
          "description": "Colored text.",
          "name": "3"
        }
      ]
    },
    "scr_teaminfo_proportional": {
      "default": "0",
      "desc": "Enable TrueType fonts on teaminfo text.",
      "group-id": "5",
      "type": "boolean"
    },
    "scr_teaminfo_scale": {
      "default": "1",
      "desc": "Scales scr_teaminfo.",
      "group-id": "40",
      "type": "float",
      "values": [
        {
          "description": "From 0 (very small) to 10 (very big)",
          "name": "*"
        }
      ]
    },
    "scr_teaminfo_show_ammo": {
      "default": "0",
      "desc": "Will show ammo count next to best weapon in teaminfo table.",
      "group-id": "40",
      "remarks": "If disabled, ammo can still be displayed by adding %c to /scr_teaminfo_order",
      "type": "boolean",
      "values": [
        {
          "description": "Do not show ammo next to best weapon.",
          "name": "0"
        },
        {
          "description": "Show ammo next to best weapon.",
          "name": "1"
        }
      ]
    },
    "scr_teaminfo_show_countdown": {
      "default": "1",
      "desc": "Shows respawn time instead of powerups during wipeout mode.",
      "group-id": "40",
      "remarks": "If disabled, countdown can still be displayed by adding %r to /scr_teaminfo_order",
      "type": "boolean",
      "values": [
        {
          "description": "Do not show respawn time instead of powerups in wipeout mode",
          "name": "0"
        },
        {
          "description": "Show respawn time instead of powerups in wipeout mode",
          "name": "1"
        }
      ]
    },
    "scr_teaminfo_show_enemies": {
      "default": "0",
      "desc": "Will show enemy players in the teaminfo table.",
      "group-id": "40",
      "remarks": "Works only for MVD playback (servers do not send info about enemies to you anyway).",
      "type": "boolean",
      "values": [
        {
          "description": "Do not show enemy players status.",
          "name": "false"
        },
        {
          "description": "Show enemy players status in teaminfo table.",
          "name": "true"
        }
      ]
    },
    "scr_teaminfo_show_self": {
      "default": "2",
      "desc": "Will show row with the status of the current player in the teaminfo table.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Do not show tracked player status in the teaminfo table.",
          "name": "0"
        },
        {
          "description": "Show tracked player in the teaminfo table.",
          "name": "1"
        },
        {
          "description": "Show tracked player when watching demos/QTV only.",
          "name": "2"
        }
      ]
    },
    "scr_teaminfo_weapon_style": {
      "default": "1",
      "desc": "Changes %w to different styles.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Displays teammates' weapon as an icon.",
          "name": "false"
        },
        {
          "description": "Displays teammates' weapon as a word (rl, lg, etc..)",
          "name": "true"
        }
      ]
    },
    "scr_teaminfo_x": {
      "default": "0",
      "desc": "Moves scr_teaminfo in the x-direction.",
      "group-id": "40",
      "type": "integer",
      "values": [
        {
          "description": "From -255 to 255.",
          "name": "*"
        }
      ]
    },
    "scr_teaminfo_y": {
      "default": "0",
      "desc": "Moves scr_teaminfo in the y-direction.",
      "group-id": "40",
      "type": "integer",
      "values": [
        {
          "description": "From -255 to 255.",
          "name": "*"
        }
      ]
    },
    "scr_tracking": {
      "desc": "Changes the format of descriptive text displayed when you are tracking someone as spectator or watching a demo where you can see player's team and name.",
      "group-id": "40",
      "remarks": "This variable affects scr_newhud 0. To change same text in new HUD (scr_newhud 1) use /tracking format (hud_tracking_format) settings.",
      "type": "string",
      "values": [
        {
          "description": "Pattern %n will be replaced with tracked player's name, %t will be replaced with player's team.",
          "name": "*"
        }
      ]
    },
    "scr_weaponstats": {
      "desc": "Displays weapons stats on server that support it.",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "scr_weaponstats_align_right": {
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Displays weapon stats on the left hand side of the screen.",
          "name": "false"
        },
        {
          "description": "Displays weapon stats on the right hand side of the screen.",
          "name": "true"
        }
      ]
    },
    "scr_weaponstats_frame_color": {
      "desc": "Sets the color of the frame around scr_weaponstats display.",
      "group-id": "40",
      "type": "string"
    },
    "scr_weaponstats_order": {
      "desc": "Accept next tokens %1 %2 %3 ... %8 which expands in to weapons accuracy, %1 - axe, %2 - sg ... %8 - lg.\n\nBut, for axe accuracy is useless, so better use direct hits instead, for that you must use it like #1.\n\nUnrecognized tokens printed as-is, so for axe order will looks like \"axe: #1\" - that means print string \"axe: \" and axe hits.\n\nAlso variable supports ezquake color sequences.",
      "group-id": "40",
      "type": "string"
    },
    "scr_weaponstats_scale": {
      "desc": "Controls size of scr_weaponstats display.\n1 - Normal text size.",
      "group-id": "40",
      "type": "float"
    },
    "scr_weaponstats_x": {
      "desc": "Horizontal placement of the weapon stats table.",
      "group-id": "40",
      "type": "integer"
    },
    "scr_weaponstats_y": {
      "desc": "Vertical placement of the weapon stats table.",
      "group-id": "40",
      "type": "integer"
    },
    "sensitivity": {
      "default": "12",
      "desc": "This variable sets the sensitivity of the mouse, it is one of the most important variables in the whole game.",
      "group-id": "10",
      "type": "float"
    },
    "serverdemo": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "show_fps": {
      "default": "0",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Disables the display of the frames-per-second value.",
          "name": "false"
        },
        {
          "description": "Enables the display of the frames-per-second value.",
          "name": "true"
        }
      ]
    },
    "show_fps_x": {
      "default": "-5",
      "desc": "Determine where the show_fps is positioned on your screen on the X co-ordinate.",
      "group-id": "40",
      "type": "float"
    },
    "show_fps_y": {
      "default": "-1",
      "desc": "Determine where the show_fps is positioned on your screen on the Y co-ordinate.",
      "group-id": "40",
      "type": "float"
    },
    "show_speed": {
      "default": "0",
      "desc": "Displays a speed counter in the top right corner in the client's units (Horizontal velocity).\n\n320 - Normal walking speed.\n440 - Accel jump.\n450 - Bunnyhopping.",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Off.",
          "name": "0"
        },
        {
          "description": "More accurate counter (Best used when LPB).",
          "name": "1"
        },
        {
          "description": "Predicted speed (Less laggy when HPB).",
          "name": "2"
        }
      ]
    },
    "show_speed_x": {
      "default": "-1",
      "desc": "Determine where the show_speed is positioned on your screen on the X co-ordinate.",
      "group-id": "40",
      "type": "float"
    },
    "show_speed_y": {
      "default": "1",
      "desc": "Determine where the show_speed is positioned on your screen on the Y co-ordinate.",
      "group-id": "40",
      "type": "float"
    },
    "show_velocity_3d": {
      "default": "0",
      "desc": "Shows your velocity as 3d vector and its projections (*GL ONLY*).",
      "group-id": "40",
      "remarks": "See also show_velocity_3d_offset_forward, show_velocity_3d_offset_down.",
      "type": "enum",
      "values": [
        {
          "description": "off (default)",
          "name": "0"
        },
        {
          "description": "velocity and projections.",
          "name": "1"
        },
        {
          "description": "only horizontal velocity and projections.",
          "name": "2"
        }
      ]
    },
    "show_velocity_3d_offset_down": {
      "default": "5",
      "group-id": "40",
      "type": ""
    },
    "show_velocity_3d_offset_forward": {
      "default": "2.5",
      "group-id": "40",
      "type": "float"
    },
    "showdrop": {
      "default": "0",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Disable text dump printing dropped packets.",
          "name": "false"
        },
        {
          "description": "Enable text dump printing dropped packets.",
          "name": "true"
        }
      ]
    },
    "showpackets": {
      "default": "0",
      "description": "Dumps log of network activity to the console (from client's point of view)",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Do not display information about all network packets.",
          "name": "0"
        },
        {
          "description": "Display information about all network packets.",
          "name": "1"
        },
        {
          "description": "Display information about incoming network packets only.",
          "name": "2"
        },
        {
          "description": "Display information about outgoing network packets only.",
          "name": "3"
        }
      ]
    },
    "showpause": {
      "default": "1",
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Never display the pause icon.",
          "name": "false"
        },
        {
          "description": "Display that the pause icon is displayed when the game is paused.",
          "name": "true"
        }
      ]
    },
    "showram": {
      "group-id": "40",
      "type": "boolean",
      "values": [
        {
          "description": "Never display the ram icon.",
          "name": "false"
        },
        {
          "description": "Display the ram icon when running out of memory.",
          "name": "true"
        }
      ]
    },
    "showturtle": {
      "default": "0",
      "desc": "Sets the value at which the turtle icon will be displayed. For example, if showturtle is set to 70, the turtle will appear when the FPS drops to 70 or below.",
      "group-id": "40",
      "type": "float"
    },
    "skill": {
      "default": "1",
      "group-id": "43",
      "type": "enum",
      "values": [
        {
          "description": "easy level for singleplaying.",
          "name": "0"
        },
        {
          "description": "Normal level for singleplaying.",
          "name": "1"
        },
        {
          "description": "Hard level for singleplaying.",
          "name": "2"
        },
        {
          "description": "Nightmare level for singleplaying.",
          "name": "3"
        }
      ]
    },
    "skin": {
      "default": "",
      "desc": "Sets the skin name for the player.",
      "group-id": "37",
      "type": "string"
    },
    "skin_browser_democolor": {
      "desc": "Color of the demo entries in the skin browser.",
      "group-id": "25",
      "type": "string"
    },
    "skin_browser_dircolor": {
      "desc": "Color of the dir entries in the skin browser.",
      "group-id": "25",
      "type": "string"
    },
    "skin_browser_interline": {
      "desc": "Size of the space between entries in the skin browser.",
      "group-id": "25",
      "type": "integer"
    },
    "skin_browser_scrollnames": {
      "desc": "Toggle scrolling of the filenames in the skin browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "skin_browser_selectedcolor": {
      "desc": "Color of the selected entries in the skin browser.",
      "group-id": "25",
      "type": "string"
    },
    "skin_browser_showdate": {
      "desc": "Toggle the date column in the skin browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "skin_browser_showsize": {
      "desc": "Toggle the file size column in the skin browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "skin_browser_showstatus": {
      "desc": "Toggle the display of the status bar in the skin browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "skin_browser_showtime": {
      "desc": "Toggle the time column in the skin browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "skin_browser_sortmode": {
      "desc": "Sorting mode in the skin browser.\nEach number represents one column. Their order represents the priority of the sorting.",
      "group-id": "25",
      "type": "string"
    },
    "skin_browser_stripnames": {
      "desc": "Toggle stripping of the filenames in the skin browser.",
      "group-id": "25",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "skin_browser_zipcolor": {
      "desc": "Color of the zip entries in the skin browser.",
      "group-id": "25",
      "type": "string"
    },
    "spectator": {
      "default": "",
      "group-id": "37",
      "type": "boolean",
      "values": [
        {
          "description": "Join to server as player.",
          "name": "false"
        },
        {
          "description": "Join to server as spectator.",
          "name": "true"
        }
      ]
    },
    "spectator_password": {
      "default": "",
      "desc": "A password spectators must use to connect to local server.",
      "group-id": "43",
      "type": "string"
    },
    "sshot_autoname": {
      "default": "0",
      "desc": "Add the map name as screenshot filename prefix.",
      "group-id": "41",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "sshot_dir": {
      "default": "",
      "desc": "Change the screenshot directory.",
      "group-id": "41",
      "type": "string"
    },
    "sshot_format": {
      "default": "png",
      "desc": "File format used when saving screenshots.",
      "group-id": "41",
      "type": "string",
      "values": [
        {
          "description": "TGA screenshots (gl only)",
          "name": "tga"
        },
        {
          "description": "PNG screenshots",
          "name": "png"
        },
        {
          "description": "JPEG screenshots (gl only)",
          "name": "jpg"
        },
        {
          "description": "Pcx screenshots (software only)",
          "name": "pcx"
        }
      ]
    },
    "sv_accelerate": {
      "desc": "Sets the acceleration value for the player.",
      "group-id": "43",
      "type": "float"
    },
    "sv_admininfo": {
      "group-id": "43",
      "type": "string"
    },
    "sv_aim": {
      "desc": "Sets the value for auto-aiming leniency.",
      "group-id": "43",
      "type": "float"
    },
    "sv_airaccelerate": {
      "desc": "Sets how quickly the player accelerates in air.",
      "group-id": "43",
      "type": "float"
    },
    "sv_allowlastscores": {
      "group-id": "43",
      "type": ""
    },
    "sv_bigcoords": {
      "group-id": "43",
      "type": "string"
    },
    "sv_cheats": {
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable cheats.",
          "name": "false"
        },
        {
          "description": "Enable cheats. (need map realoading)",
          "name": "true"
        }
      ]
    },
    "sv_cpserver": {
      "group-id": "43",
      "type": ""
    },
    "sv_crypt_rcon": {
      "group-id": "43",
      "type": ""
    },
    "sv_cullentities": {
      "group-id": "43",
      "type": ""
    },
    "sv_default_name": {
      "group-id": "43",
      "type": "string"
    },
    "sv_demoClearOld": {
      "group-id": "43",
      "type": ""
    },
    "sv_demoDir": {
      "group-id": "43",
      "type": "string"
    },
    "sv_demoExtraNames": {
      "group-id": "43",
      "type": ""
    },
    "sv_demoIdlefps": {
      "group-id": "43",
      "type": ""
    },
    "sv_demoMaxDirSize": {
      "group-id": "43",
      "type": ""
    },
    "sv_demoMaxSize": {
      "group-id": "43",
      "type": ""
    },
    "sv_demoPrefix": {
      "group-id": "43",
      "type": "string"
    },
    "sv_demoRegexp": {
      "group-id": "43",
      "type": "string"
    },
    "sv_demoSuffix": {
      "group-id": "43",
      "type": "string"
    },
    "sv_demoUseCache": {
      "group-id": "43",
      "type": ""
    },
    "sv_demofps": {
      "group-id": "43",
      "type": ""
    },
    "sv_demonovis": {
      "group-id": "43",
      "type": ""
    },
    "sv_demopings": {
      "group-id": "43",
      "type": ""
    },
    "sv_demotxt": {
      "group-id": "43",
      "type": ""
    },
    "sv_downloadchunksperframe": {
      "desc": "Limits the speed of the chunked downloads.",
      "group-id": "43",
      "remarks": "Server-side.\nClients can set high amount of chunks per frame allowed and make your data eat connection traffic rapidly. Use this variable to prevent this.",
      "type": ""
    },
    "sv_enable_cmd_minping": {
      "group-id": "43",
      "type": ""
    },
    "sv_enableprofile": {
      "group-id": "43",
      "type": ""
    },
    "sv_fastconnect": {
      "desc": "actually no help.",
      "group-id": "43",
      "type": "float"
    },
    "sv_forcenick": {
      "group-id": "43",
      "type": ""
    },
    "sv_forcenqprogs": {
      "desc": "Force loading of NetQuake progs - if progs.dat (typically from Quake 1 sigle player / mods) is present in the gamedir, it will be preferred over qwprogs.dat and spprogs.dat (QW game mods).",
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "sv_forcespec_onfull": {
      "group-id": "43",
      "type": ""
    },
    "sv_friction": {
      "desc": "Sets the friction value for the player.",
      "group-id": "43",
      "type": "float"
    },
    "sv_getrealip": {
      "group-id": "43",
      "type": ""
    },
    "sv_gravity": {
      "desc": "Sets the global value for the amount of gravity.",
      "group-id": "43",
      "type": "float"
    },
    "sv_hashpasswords": {
      "group-id": "43",
      "type": ""
    },
    "sv_highchars": {
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Enable high character color names for players.",
          "name": "true"
        }
      ]
    },
    "sv_kicktop": {
      "group-id": "43",
      "type": ""
    },
    "sv_kickuserinfospamcount": {
      "group-id": "43",
      "type": ""
    },
    "sv_kickuserinfospamtime": {
      "group-id": "43",
      "type": ""
    },
    "sv_ktpro_mode": {
      "group-id": "43",
      "type": "string"
    },
    "sv_loadentfiles": {
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Enable custom map entity file support.",
          "name": "true"
        }
      ]
    },
    "sv_logdir": {
      "group-id": "43",
      "type": "string"
    },
    "sv_login": {
      "group-id": "43",
      "type": ""
    },
    "sv_mapcheck": {
      "group-id": "43",
      "remarks": "Note: A player who has edited his map files to cheat by removing textures from walls will not be able to join the server and play.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Enable map checksumming to check for players who edit maps to cheat.",
          "name": "true"
        }
      ]
    },
    "sv_maxdownloadrate": {
      "group-id": "43",
      "type": ""
    },
    "sv_maxlogsize": {
      "group-id": "43",
      "type": ""
    },
    "sv_maxpitch": {
      "desc": "server-side variable for setting maximum of view angles.",
      "group-id": "43",
      "remarks": "EZQuake and ZQuake (may be some other) clients understand this physics change.\nOld clients will be clamped at [-70~80] (quakeworld default) view angles.",
      "type": "integer",
      "values": [
        {
          "description": "By default, in quakeworld maximum viewangle is '80'. You can set for example '90' then you will be able look directly to sky. q3 players should like it.",
          "name": "*"
        }
      ]
    },
    "sv_maxrate": {
      "desc": "Maximum rate for clients.",
      "group-id": "43",
      "type": "float"
    },
    "sv_maxspeed": {
      "desc": "Sets the maximum speed a player can move.",
      "group-id": "43",
      "type": "float"
    },
    "sv_maxtic": {
      "desc": "The maximum amount of time in seconds before a client a receives an update from the server.",
      "group-id": "43",
      "type": "float"
    },
    "sv_maxuploadsize": {
      "group-id": "43",
      "type": ""
    },
    "sv_maxvelocity": {
      "desc": "Sets the maximum velocity an object can travel.",
      "group-id": "43",
      "type": "float"
    },
    "sv_minping": {
      "group-id": "43",
      "type": ""
    },
    "sv_minpitch": {
      "desc": "server-side variable for setting minimum of view angles.",
      "group-id": "43",
      "remarks": "EZQuake and ZQuake (may be some other) clients understand this physics change.\nOld clients will be clamped at [-70~80] (quakeworld default) view angles.",
      "type": "integer",
      "values": [
        {
          "description": "By default, in quakeworld minimum viewangle is '-70'. You can set for example '-90' then you will be able look directly to floor. q3 players should like it.",
          "name": "*"
        }
      ]
    },
    "sv_mintic": {
      "desc": "The minimum amount of time the server will wait before sending packets to a client.",
      "group-id": "43",
      "type": "float"
    },
    "sv_mod_msg_file": {
      "group-id": "43",
      "type": "string"
    },
    "sv_nailhack": {
      "group-id": "43",
      "remarks": "smoother and point in the right direction.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Allows nails in most cases to uses less bandwidth and to fly around.",
          "name": "true"
        }
      ]
    },
    "sv_onDemoRemove": {
      "group-id": "43",
      "type": "string"
    },
    "sv_onRecordFinish": {
      "group-id": "43",
      "type": "string"
    },
    "sv_paused": {
      "desc": "read-only variable that gives you current pause state (condition).",
      "group-id": "43",
      "type": "enum",
      "values": [
        {
          "description": "pause is off.",
          "name": "0"
        },
        {
          "description": "normal pause that can be set by 'pause' command.",
          "name": "1"
        },
        {
          "description": "auto pause (single player only) when going into menus.",
          "name": "2"
        },
        {
          "description": "both (normal pause + auto pause)",
          "name": "3"
        }
      ]
    },
    "sv_phs": {
      "group-id": "43",
      "remarks": "of the map.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Has something to do with the table which is build at the loading time.",
          "name": "true"
        }
      ]
    },
    "sv_progsname": {
      "group-id": "43",
      "type": "string"
    },
    "sv_progtype": {
      "group-id": "43",
      "type": ""
    },
    "sv_qwfwd_port": {
      "group-id": "43",
      "type": ""
    },
    "sv_rconlim": {
      "group-id": "43",
      "type": ""
    },
    "sv_reconnectlimit": {
      "group-id": "43",
      "type": ""
    },
    "sv_registrationinfo": {
      "group-id": "43",
      "type": "string"
    },
    "sv_sayteam_to_spec": {
      "group-id": "43",
      "type": ""
    },
    "sv_serverip": {
      "group-id": "43",
      "type": "string"
    },
    "sv_showpackets": {
      "description": "Dumps log of network activity to the console (from internal server's point of view)",
      "group-id": "40",
      "type": "enum",
      "values": [
        {
          "description": "Do not display information about all network packets.",
          "name": "0"
        },
        {
          "description": "Display information about all network packets.",
          "name": "1"
        },
        {
          "description": "Display information about incoming network packets only.",
          "name": "2"
        },
        {
          "description": "Display information about outgoing network packets only.",
          "name": "3"
        }
      ]
    },
    "sv_specprint": {
      "group-id": "43",
      "type": ""
    },
    "sv_spectalk": {
      "group-id": "43",
      "type": "boolean",
      "values": [
        {
          "description": "Players can't hear spectators.",
          "name": "false"
        },
        {
          "description": "Players can hear spectators.",
          "name": "true"
        }
      ]
    },
    "sv_spectatormaxspeed": {
      "desc": "Sets the maximum speed a spectator can move.",
      "group-id": "43",
      "type": "float"
    },
    "sv_speedcheck": {
      "group-id": "43",
      "type": ""
    },
    "sv_stopspeed": {
      "desc": "Sets the value that determines how fast the player should come to a complete stop.",
      "group-id": "43",
      "type": "float"
    },
    "sv_timeout": {
      "desc": "Sets the amount of time in seconds before a client is considered disconnected if the server does not receive a packet.",
      "group-id": "43",
      "type": "float"
    },
    "sv_timestamplen": {
      "group-id": "43",
      "type": ""
    },
    "sv_unfake": {
      "group-id": "43",
      "type": ""
    },
    "sv_use_dns": {
      "group-id": "43",
      "type": ""
    },
    "sv_use_internal_cmd_dl": {
      "group-id": "43",
      "type": ""
    },
    "sv_wateraccelerate": {
      "desc": "Sets the water acceleration value.",
      "group-id": "43",
      "type": "float"
    },
    "sv_waterfriction": {
      "desc": "Sets the water friction value.",
      "group-id": "43",
      "type": "float"
    },
    "sw_contrast": {
      "desc": "Change contrast.",
      "group-id": "30",
      "type": "float"
    },
    "sw_gamma": {
      "desc": "Change gamma.",
      "group-id": "30",
      "type": "float"
    },
    "sys_command_line": {
      "default": "",
      "group-id": "0",
      "system-generated": true
    },
    "sys_disableWinKeys": {
      "default": "0",
      "group-id": "48",
      "remarks": "Note: Windows keys are now bindable (LWINKEY, RWINKEY, WINKEY, POPUPMENU).\nObviously only useful on NT/2K/XP with sys_disableWinKeys 1 (and possibly useful in Linux too!).",
      "type": "integer",
      "values": [
        {
          "description": "Winkeys are processed by operating system.",
          "name": "0"
        },
        {
          "description": "Disable winkeys from alt-tabbing you (only works in NT/2K/XP, and only when the client is in focus).",
          "name": "1"
        },
        {
          "description": "Disable winkeys from alt-tabbing you, when fullscreen.",
          "name": "2"
        }
      ]
    },
    "sys_disable_alt_enter": {
      "default": "0",
      "group-id": "48",
      "type": "boolean",
      "values": [
        {
          "description": "alt-enter will toggle full-screen mode.",
          "name": "false"
        },
        {
          "description": "alt-enter ignored by ezquake.",
          "name": "true"
        }
      ]
    },
    "sys_highpriority": {
      "default": "0",
      "group-id": "48",
      "type": "enum",
      "values": [
        {
          "description": "Sets process to normal priority.",
          "name": "0"
        },
        {
          "description": "Sets process to high priority.",
          "name": "1"
        },
        {
          "description": "Sets process to low priority.",
          "name": "-1"
        }
      ]
    },
    "sys_inactivesleep": {
      "default": "1",
      "group-id": "48",
      "type": "boolean",
      "values": [
        {
          "description": "Prevent freeing of CPU when the client is minimized or not in focus.",
          "name": "false"
        },
        {
          "description": "Enable inactive sleeping.",
          "name": "true"
        }
      ]
    },
    "sys_inactivesound": {
      "default": "0",
      "desc": "Enables sounds when the application is not focused.",
      "group-id": "48",
      "type": "boolean",
      "values": [
        {
          "description": "",
          "name": "false"
        },
        {
          "description": "",
          "name": "true"
        }
      ]
    },
    "sys_restart_on_error": {
      "default": "0",
      "group-id": "23",
      "type": "boolean"
    },
    "sys_select_timeout": {
      "default": "10000",
      "group-id": "23",
      "type": ""
    },
    "sys_update_check": {
      "default": "1",
      "desc": "Checks if the the client is outdated. If a new version is found, this will be presented above the in-game menu. The version check performs a HTTP request to GitHub once per launch without introducing any application start delay. Any error querying the latest version assumes the current client is the latest.",
      "group-id": "48",
      "type": "boolean",
      "values": [
        {
          "description": "Deny update check.",
          "name": "false"
        },
        {
          "description": "Allow update check.",
          "name": "true"
        }
      ]
    },
    "sys_yieldcpu": {
      "default": "0",
      "desc": "Controls CPU sharing when client is waiting to draw a frame.\nWhen disabled, client will run a loop, actively waiting for the time to draw a new frame.\nWhen enabled, client will call system sleep function during the waiting, which will cause the thread to be deactivated for a while - leading to significantly lower CPU usage in most cases.",
      "group-id": "48",
      "type": "boolean",
      "values": [
        {
          "description": "Do not sleep between frames, use CPU as much as possible.",
          "name": "false"
        },
        {
          "description": "Sleep between frames, make CPU available for other processes.",
          "name": "true"
        }
      ]
    },
    "team": {
      "default": "",
      "desc": "Set the team name.",
      "group-id": "37",
      "type": "string"
    },
    "teambothskin": {
      "default": "",
      "desc": "Overrides the team quad pent skin so you can define the skin which applies to team quads pents.",
      "group-id": "44",
      "type": "string"
    },
    "teambottomcolor": {
      "default": "-1",
      "desc": "Determines the color of the pants of the teammates you see.\nOverrides player's skin settings.",
      "group-id": "44",
      "remarks": "To be able to use RGB 24bit colors, look for r_teamskincolor variable.",
      "type": "enum",
      "values": [
        {
          "description": "Disabled",
          "name": "-1"
        },
        {
          "description": "White",
          "name": "0"
        },
        {
          "description": "Brown",
          "name": "1"
        },
        {
          "description": "Lavender",
          "name": "2"
        },
        {
          "description": "Khaki",
          "name": "3"
        },
        {
          "description": "Red",
          "name": "4"
        },
        {
          "description": "Light Brown",
          "name": "5"
        },
        {
          "description": "Peach",
          "name": "6"
        },
        {
          "description": "Light Peach",
          "name": "7"
        },
        {
          "description": "Purple",
          "name": "8"
        },
        {
          "description": "Dark Purple",
          "name": "9"
        },
        {
          "description": "Tan",
          "name": "10"
        },
        {
          "description": "Green",
          "name": "11"
        },
        {
          "description": "Yellow",
          "name": "12"
        },
        {
          "description": "Blue",
          "name": "13"
        },
        {
          "description": "Orange.",
          "name": "14"
        },
        {
          "description": "Bright red.",
          "name": "15"
        },
        {
          "description": "Black.",
          "name": "16"
        }
      ]
    },
    "teamforceskins": {
      "default": "0",
      "desc": "Allows you to set different skin for every team player even if they all have same skin names set or use names of skins that you do not have in your Quake dir.",
      "group-id": "44",
      "remarks": "Read \"Player skins\" manual page for more info on skin rules.",
      "type": "enum",
      "values": [
        {
          "description": "Disabled.",
          "name": "0"
        },
        {
          "description": "Use player's name as the name of the skin to be used.",
          "name": "1"
        },
        {
          "description": "Use player's userid number (only useful for video capturing)",
          "name": "2"
        },
        {
          "description": "Assign skins \"t1\", \"t2\", \"t3\", etc. to your teammates.",
          "name": "3"
        }
      ]
    },
    "teamlock": {
      "default": "0",
      "desc": "Observing feature. Do not toggle enemy recognition when you switch players.\nOne team will always remain marked as enemy even if you spec their players.",
      "group-id": "44",
      "type": "string",
      "values": [
        {
          "description": "Do not lock team/enemy",
          "name": "0"
        },
        {
          "description": "Lock team/enemy",
          "name": "1"
        },
        {
          "description": "Lock the specified team name as \"team\"",
          "name": "*"
        }
      ]
    },
    "teampentskin": {
      "default": "",
      "desc": "Overrides the team pent skin so you can define the skin which applies to team pents.",
      "group-id": "44",
      "type": "string"
    },
    "teamplay": {
      "default": "0",
      "desc": "Teamplay mode.",
      "group-id": "43",
      "remarks": "Nowadays only value 2 is used.",
      "type": "integer",
      "values": [
        {
          "description": "No teamplay",
          "name": "0"
        },
        {
          "description": "Teamplay with no suicides or teamkills",
          "name": "1"
        },
        {
          "description": "Teamplay with teamkills",
          "name": "2"
        }
      ]
    },
    "teamquadskin": {
      "default": "",
      "desc": "Overrides the team quad skin so you can define the skin which applies to team quads.",
      "group-id": "44",
      "type": "string"
    },
    "teamskin": {
      "default": "",
      "desc": "Overrides the team skin so you can define the skin which applies to team mates.",
      "group-id": "44",
      "type": "string"
    },
    "teamtopcolor": {
      "default": "-1",
      "desc": "Determines the color of the shirt of the teammates you see.\nOverrides player's skin settings.",
      "group-id": "44",
      "remarks": "To be able to use RGB 24bit colors, look for r_teamskincolor variable.",
      "type": "enum",
      "values": [
        {
          "description": "Disabled",
          "name": "-1"
        },
        {
          "description": "White",
          "name": "0"
        },
        {
          "description": "Brown",
          "name": "1"
        },
        {
          "description": "Lavender",
          "name": "2"
        },
        {
          "description": "Khaki",
          "name": "3"
        },
        {
          "description": "Red",
          "name": "4"
        },
        {
          "description": "Light Brown",
          "name": "5"
        },
        {
          "description": "Peach",
          "name": "6"
        },
        {
          "description": "Light Peach",
          "name": "7"
        },
        {
          "description": "Purple",
          "name": "8"
        },
        {
          "description": "Dark Purple",
          "name": "9"
        },
        {
          "description": "Tan",
          "name": "10"
        },
        {
          "description": "Green",
          "name": "11"
        },
        {
          "description": "Yellow",
          "name": "12"
        },
        {
          "description": "Blue",
          "name": "13"
        },
        {
          "description": "Orange.",
          "name": "14"
        },
        {
          "description": "Bright red.",
          "name": "15"
        },
        {
          "description": "Black.",
          "name": "16"
        }
      ]
    },
    "telnet_log_level": {
      "default": "0",
      "group-id": "43",
      "type": ""
    },
    "telnet_password": {
      "desc": "Password for login via telnet.\nNot currently used.",
      "group-id": "43",
      "type": "string"
    },
    "timelimit": {
      "default": "0",
      "desc": "Number of minutes the match will take.",
      "group-id": "43",
      "type": "integer"
    },
    "timeout": {
      "default": "65",
      "group-id": "43",
      "type": ""
    },
    "topcolor": {
      "default": "",
      "desc": "Sets the shirt color.",
      "group-id": "37",
      "type": "enum",
      "values": [
        {
          "description": "White.",
          "name": "0"
        },
        {
          "description": "Brown.",
          "name": "1"
        },
        {
          "description": "Lavender.",
          "name": "2"
        },
        {
          "description": "Khaki.",
          "name": "3"
        },
        {
          "description": "Red.",
          "name": "4"
        },
        {
          "description": "Lt Brown.",
          "name": "5"
        },
        {
          "description": "Peach.",
          "name": "6"
        },
        {
          "description": "Lt Peach.",
          "name": "7"
        },
        {
          "description": "Purple.",
          "name": "8"
        },
        {
          "description": "Dk Purple.",
          "name": "9"
        },
        {
          "description": "Tan.",
          "name": "10"
        },
        {
          "description": "Green.",
          "name": "11"
        },
        {
          "description": "Yellow.",
          "name": "12"
        },
        {
          "description": "Blue.",
          "name": "13"
        },
        {
          "description": "Orange.",
          "name": "14"
        },
        {
          "description": "Bright red.",
          "name": "15"
        },
        {
          "description": "Black.",
          "name": "16"
        }
      ]
    },
    "tp_forceTriggers": {
      "default": "0",
      "desc": "Controls whether f_took, f_death etc are forced to execute even if the game isn't a team game.",
      "group-id": "49",
      "type": "boolean"
    },
    "tp_loadlocs": {
      "default": "1",
      "desc": "Controls whether to load locs for teamplay reporting.\nNote: The locs should be in your \"/id1/locs/\",\n\"/ezquake/locs\" or \"/qw/locs\" folder.",
      "group-id": "49",
      "type": "boolean"
    },
    "tp_msgtriggers": {
      "default": "1",
      "desc": "Switches on/off message triggers.",
      "group-id": "49",
      "remarks": "For ruleset 'Smackdown' message triggers always are off.",
      "type": "boolean"
    },
    "tp_name_armor": {
      "default": "armor",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_armortype_ga": {
      "default": "{&c0b0g&cfff}",
      "desc": "Customizes output of %A macro for green armor.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_armortype_ra": {
      "default": "{&cf00r&cfff}",
      "desc": "Customizes output of %A macro for red armor.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_armortype_ya": {
      "default": "{&cff0y&cfff}",
      "desc": "Customizes output of %A macro for yellow armor.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_at": {
      "default": "at",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_axe": {
      "default": "axe",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_backpack": {
      "default": "{&cf2apack&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_cells": {
      "default": "cells",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_disp": {
      "default": "dispenser",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_enemy": {
      "default": "{&cf00enemy&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_eyes": {
      "default": "{&cff0eyes&cfff}",
      "desc": "Sets the name for ring (invisibility) powerup for teamplay messages.",
      "group-id": "13",
      "type": "string",
      "values": [
        {
          "description": "common values are 'eyes' or 'ring'",
          "name": "*"
        }
      ]
    },
    "tp_name_filter": {
      "default": "",
      "desc": "TF only - added to end of tp_msgtfconced message/",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_flag": {
      "default": "flag",
      "desc": "Customizes item/",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_ga": {
      "default": "{&c0b0ga&cfff}",
      "desc": "Customizes item/",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_gl": {
      "default": "gl",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_health": {
      "default": "health",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_lg": {
      "default": "{&c2aalg&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_mh": {
      "default": "{&c0a0mega&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_nails": {
      "default": "nails",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_ng": {
      "default": "ng",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_none": {
      "default": "",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_nothing": {
      "default": "nothing",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_pent": {
      "default": "{&cf00pent&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_pented": {
      "default": "{&cf00pented&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_quad": {
      "default": "{&c05fquad&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_quaded": {
      "default": "{&c05fquaded&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_ra": {
      "default": "{&cf00ra&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_ring": {
      "default": "{&cff0ring&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_rl": {
      "default": "{&cf13rl&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_rlg": {
      "default": "{&cf13rl&cfff}{&c2aag&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_rockets": {
      "default": "rox",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_rune1": {
      "default": "{&c0f0resistance&cfff}",
      "desc": "Sets name of the first rune (Resistance Rune) used for teamplay messages.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_rune2": {
      "default": "{&cf00strength&cfff}",
      "desc": "Sets name of the second rune (Strength Rune) used for teamplay messages.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_rune3": {
      "default": "{&cff0haste&cfff}",
      "desc": "Sets name of the third rune (Haste Rune) used for teamplay messages.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_rune4": {
      "default": "{&c0ffregeneration&cfff}",
      "desc": "Sets name of the fourth rune (Regeneration Rune) used for teamplay messages.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_sentry": {
      "default": "sentry gun",
      "desc": "Sets the name for sentry tower in teamplay messages.",
      "group-id": "13",
      "type": "string",
      "values": [
        {
          "description": "common values are 'sentry' or 'sentry gun'.",
          "name": "*"
        }
      ]
    },
    "tp_name_separator": {
      "default": "/",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_sg": {
      "default": "sg",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_shells": {
      "default": "shells",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_sng": {
      "default": "sng",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_someplace": {
      "default": "someplace",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_ssg": {
      "default": "ssg",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_status_blue": {
      "default": "$B",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_status_green": {
      "default": "$G",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_status_red": {
      "default": "$R",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_status_white": {
      "default": "$W",
      "desc": "Currently unused.",
      "group-id": "13",
      "remarks": "tp_name_status_ cvars are used by the client when generating teamplay messages.",
      "type": "string"
    },
    "tp_name_status_yellow": {
      "default": "$Y",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_suit": {
      "default": "suit",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_teammate": {
      "default": "",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_weapon": {
      "default": "weapon",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_name_ya": {
      "default": "{&cff0ya&cfff}",
      "desc": "Customizes item.",
      "group-id": "13",
      "type": "string"
    },
    "tp_need_cells": {
      "default": "13",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_ga": {
      "default": "60",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_health": {
      "default": "50",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_nails": {
      "default": "0",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_ra": {
      "default": "120",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_rl": {
      "default": "1",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_rockets": {
      "default": "5",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_shells": {
      "default": "0",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_weapon": {
      "default": "87",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_need_ya": {
      "default": "80",
      "desc": "Customizes the %u macro.",
      "group-id": "14",
      "type": "float"
    },
    "tp_pointpriorities": {
      "default": "0",
      "desc": "You can choose the way the client decides what object you want to point with $point macro.",
      "group-id": "49",
      "remarks": "Priorities of object are given in tp_point command. You have to type all objects manually in tp_point command.\n\nExample: tp_point quad ra mh health\nIn this example, quad has the highest priority and $point will always return quad if quad ra mh are all in your view.\n\nExample: tp_point all\nYou never know what object will be pointed because all objects get the same priority.",
      "type": "boolean",
      "values": [
        {
          "description": "Original, default behavior. The closest object will be chosen.",
          "name": "false"
        },
        {
          "description": "Object with highest priority will be chosen. First items in tp_point have highest priorities.",
          "name": "true"
        }
      ]
    },
    "tp_tookpriorities": {
      "default": "0",
      "desc": "Controls whether the last item taken macro (%X or $took) uses the order of tp_took as item pickup priority.",
      "group-id": "49",
      "remarks": "When enabled, earlier items in tp_took have higher priority and can prevent lower priority pickups from replacing $took within tp_tooktimeout.\n\nExample:\ntp_took powerups rl lg ra ya ga mega pack gl sng ng ssg rockets cells nails shells health\ntp_tookpriorities 1",
      "type": "boolean",
      "values": [
        {
          "description": "Original, default behavior. The latest pickup replaces the previous one.",
          "name": "false"
        },
        {
          "description": "Use tp_took order as pickup priority.",
          "name": "true"
        }
      ]
    },
    "tp_pointtimeout": {
      "default": "15",
      "desc": "Time (in seconds) before the last pointed item (%j) is cleared.",
      "group-id": "49",
      "type": "float"
    },
    "tp_poweruptextstyle": {
      "default": "0",
      "desc": "Controls whether $tp_powerups (used in built-in binds) uses long or short-form powerup names.",
      "group-id": "14",
      "type": "boolean",
      "values": [
        {
          "description": "Long-form names (quad, pent, ring)",
          "name": "false"
        },
        {
          "description": "Short-form names (q, p, r)",
          "name": "true"
        }
      ]
    },
    "tp_soundtrigger": {
      "default": "~",
      "desc": "SoundTrigger like proxys.\nA SoundTrigger must be terminated by either a CR, LF or filter. The .wav extension is not required at the end.\nTrigger is a character before the sound file.\n\nExample:\nfilter #a\nsay_team I'm at %l ~location.wav\"\nsay_team ~location.wav$\\me: I'm at %l #a\"\nsay_team ~location$\\me: I'm at %l #a\"\nsay_team I'm at %l ~location #a\"",
      "group-id": "49",
      "type": "string"
    },
    "tp_tooktimeout": {
      "default": "15",
      "desc": "Time (in seconds) before the last item taken (%X) is cleared.",
      "group-id": "49",
      "type": "float"
    },
    "tp_triggers": {
      "default": "1",
      "group-id": "49",
      "type": "boolean",
      "values": [
        {
          "description": "Disable tp triggers.",
          "name": "false"
        },
        {
          "description": "Enable tp triggers.",
          "name": "true"
        }
      ]
    },
    "tp_weapon_order": {
      "default": "78654321",
      "desc": "This allows you to define the order from best to worst weapon.\nThe default value, \"78564321\", means that the Rocket Launcher is the best weapon (impulse 7), then Lightning Gun (impulse 8), Super Nailgun (impulse 5), Grenade Launcher (impulse 6), Nailgun (impulse 4), Super Shotgun (impulse 3), Shotgun (impulse 2), Axe (impulse 1).",
      "group-id": "49",
      "type": "string"
    },
    "userdir": {
      "desc": "userdir [dir [type]]\nAddition of the given directory to the list searched files.",
      "group-id": "33",
      "type": "enum",
      "values": [
        {
          "description": "<quake_dir>/<gamedir>/<dir>",
          "name": "0"
        },
        {
          "description": "<quake_dir>/<dir>/<gamedir>",
          "name": "1"
        },
        {
          "description": "<quake_dir>/qw/<dir>/<gamedir>",
          "name": "2"
        },
        {
          "description": "<quake_dir>/qw/<dir>",
          "name": "3"
        },
        {
          "description": "<quake_dir>/<dir>",
          "name": "4"
        },
        {
          "description": "$HOME/qw/<dir>",
          "name": "5"
        }
      ]
    },
    "v_centermove": {
      "default": "0.15",
      "desc": "This variable sets the distance that the player must move before the screen automatically centers itself when \"lookspring\" is set to \"1\".\nThis variable is only useful to people who only play with the keyboard, have \"lookspring\" set to \"1\" and do not have \"+klook\" or \"+mlook\" enabled at that time.\nWhen the player nmoves the distance specified in this variable the screen will pop back to the center position.",
      "group-id": "53",
      "type": "float"
    },
    "v_centerspeed": {
      "default": "500",
      "desc": "This variable sets how quickly your view returns to the center after looking up or down and moving after that and \"lookspring\" is set to \"1\".\nThis variable is only useful to people who only play with the keyboard, have \"lookspring\" set to \"1\" and do not have \"+klook\" or \"+mlook\" enabled at that time.\nWhen the player moves the distance specified in this variable the screen will pop back to the center position.",
      "group-id": "53",
      "type": "float"
    },
    "v_contentblend": {
      "default": "0.2",
      "desc": "Turning this variable on will temporarily change the hue of your screen when inside liquid (water/slime/lava) (requires gl_polyblend 1)",
      "group-id": "39",
      "remarks": "Specify a percentage value, between 0 and 1.  0 turns the effect off.",
      "type": "float"
    },
    "v_damagecshift": {
      "default": "0.2",
      "desc": "This variable (0..1) will temporarily add a red hue to your screen when you've taken damage. Needs gl_polyblend 1.",
      "group-id": "39",
      "type": "float"
    },
    "v_dlightcolor": {
      "default": "1",
      "desc": "Controls if the color of a light affects your view\nRequires gl_polyblend & gl_flashblend set",
      "group-id": "39",
      "type": "boolean"
    },
    "v_dlightcshift": {
      "default": "1",
      "desc": "Controls when palette will change when inside a light bubble.\nAlso need to set gl_flashblend 1.",
      "group-id": "39",
      "type": "enum",
      "values": [
        {
          "description": "Off.",
          "name": "0"
        },
        {
          "description": "On.",
          "name": "1"
        },
        {
          "description": "On, but excludes lights around players.",
          "name": "2"
        }
      ]
    },
    "v_dlightcshiftpercent": {
      "default": "0.5",
      "desc": "Strength of effect of v_dlightcshift, as a percentage",
      "group-id": "39",
      "type": "float"
    },
    "v_gunkick": {
      "default": "0",
      "desc": "Kickback effect when the weapon is fired.",
      "group-id": "53",
      "type": "float"
    },
    "v_idlescale": {
      "default": "0",
      "desc": "This variable controls the amount that the screen should sway automatically.\nWhen this variable is set to a value above \"0\" the screen will start swaying in all directions, similar as if the player was drunk of had a concussion.\nIf you want to have some real fun, set this variable to a value of \"100\" and run around some maps.\nThe larger the value for this variable the more the screen will sway from side to side.",
      "group-id": "53",
      "type": "integer"
    },
    "v_ipitch_cycle": {
      "default": "1",
      "desc": "This variable controls the speed at which the screen should sway up and down when \"v_idlescale\" is set to a value above \"0\".",
      "group-id": "53",
      "type": "float"
    },
    "v_ipitch_level": {
      "default": "0.3",
      "desc": "This variable controls the distance that the screen should sway up and down when \"v_idlescale\" is set to a value above \"0\".",
      "group-id": "53",
      "type": "float"
    },
    "v_iroll_cycle": {
      "default": "0.5",
      "desc": "This variable controls the speed at which the screen should roll clockwise and counter clockwise when \"v_idlescale\" is set to a value above \"0\".",
      "group-id": "53",
      "type": "float"
    },
    "v_iroll_level": {
      "default": "0.1",
      "desc": "This variable controls the distance the screen should roll clockwise and counter clockwise when \"v_idlescale\" is set to a value above \"0\".",
      "group-id": "53",
      "type": "float"
    },
    "v_iyaw_cycle": {
      "default": "2",
      "desc": "Sets how quickly you look left and right when v_idlescale is active.",
      "group-id": "53",
      "type": "float"
    },
    "v_iyaw_level": {
      "default": "0.3",
      "desc": "Sets how far you look left and right when v_idlescale is active.",
      "group-id": "53",
      "type": "float"
    },
    "v_kickpitch": {
      "default": "0.0",
      "desc": "This variable controls the distance that the screen should move up or down when the player is shot.\nMost players set this variable to \"0\" in order to remove the screen tilting effect when they are injured by a shot.\nThis allows them to keep a perfect aim while being fired upon.",
      "group-id": "53",
      "remarks": "v_kicktime must be >0 for this to take effect.",
      "type": "float"
    },
    "v_kickroll": {
      "default": "0.0",
      "desc": "This variable controls the distance that the screen should roll clockwise or counter clockwise when the player is shot.\nMost players set this variable to \"0\" in order to remove the screen tilting effect when they are injured by a shot.\nThis allows them to keep a perfect aim while being fired upon.",
      "group-id": "53",
      "remarks": "v_kicktime must be >0 for this to take effect.",
      "type": "float"
    },
    "v_kicktime": {
      "default": "0.0",
      "desc": "This variable controls the amount of time v_kickpitch and v_kickroll take effect.",
      "group-id": "53",
      "type": "float"
    },
    "v_pentcshift": {
      "default": "0.5",
      "desc": "This variable (0..1) will add a temporary red hue to your screen if you are carry the Pent powerup. Requires gl_polyblend 1.",
      "group-id": "39",
      "type": "float"
    },
    "v_quadcshift": {
      "default": "0.5",
      "desc": "This variable (0..1) will add a temporary blue hue to your screen if you are carry the Quad powerup. Requires gl_polyblend 1.",
      "group-id": "39",
      "type": "float"
    },
    "v_ringcshift": {
      "default": "0.5",
      "desc": "This variable (0..1) will add a temporary yellow hue to your screen if you are carry the Ring powerup. Requires gl_polyblend 1.",
      "group-id": "39",
      "type": "float"
    },
    "v_suitcshift": {
      "default": "0.5",
      "desc": "This variable (0..1) will add a temporary green hue to your screen if you are carry the Suit powerup. Requires gl_polyblend 1.",
      "group-id": "39",
      "type": "float"
    },
    "v_viewheight": {
      "default": "0",
      "desc": "New variable v_viewheight can be used to get the effect of negative/zero values \nof cl_bobcycle etc in qw 2.33.\nNegative values of v_viewheight = lower viewheight, \npositive = higher.\nCan't go below -7 or above 4 because that's the range you can get with qw 2.33 by exploiting the bob cycle bug.\n\nUsing v_viewheight automatically turns off weapon model bobbing (cl_bob*).",
      "group-id": "53",
      "type": "float",
      "values": [
        {
          "description": "Range -7 to 4.",
          "name": "*"
        }
      ]
    },
    "vid_24bit_depth": {
      "default": "1",
      "desc": "Requests a 24-bit depth-buffer if possible.",
      "group-id": "52",
      "remarks": "Visual artifacts may be visible if using a 16-bit depth-buffer (e.g. entities disappearing at a distance).",
      "type": "boolean",
      "values": [
        {
          "description": "Size of depth-buffer will be system default.",
          "name": "false"
        },
        {
          "description": "Request 24-bit depth-buffer.",
          "name": "true"
        }
      ]
    },
    "vid_colorbits": {
      "default": "0",
      "desc": "Determines the color mode.",
      "group-id": "52",
      "remarks": "Highest quality is \"24\"",
      "type": "integer"
    },
    "vid_conaspect": {
      "desc": "Keep the screen proportions to given aspect ratio.",
      "group-id": "52",
      "remarks": "Always changes vid_conheight when you change vid_conwidth.",
      "type": "string",
      "values": [
        {
          "description": "4:3 or 16:9 or 16:10 etc.",
          "name": "*"
        }
      ]
    },
    "vid_config_x": {
      "desc": "This variable sets the width of the vid_mode 2 window, the minimum possible value is \"640\".",
      "group-id": "31",
      "type": "float"
    },
    "vid_config_y": {
      "desc": "This variable sets the width of the vid_mode 2 window, the minimum possible value is \"400\"",
      "group-id": "31",
      "type": "float"
    },
    "vid_conheight": {
      "default": "0",
      "desc": "Height of the text layer.",
      "group-id": "52",
      "remarks": "Cannot be higher than the height of the current game resolution.",
      "type": "integer"
    },
    "vid_conscale": {
      "default": "2.0",
      "desc": "If vid_conwidth & vid_conheight are set to 0, vid_conheight will be scaled by the value of this variable.",
      "group-id": "52",
      "type": "float"
    },
    "vid_conwidth": {
      "default": "0",
      "desc": "Height of the text layer.",
      "group-id": "52",
      "remarks": "Cannot be higher than the height of the current game resolution.",
      "type": "integer"
    },
    "vid_customheight": {
      "desc": "Screen resolution width for custom screen mode.",
      "group-id": "52",
      "remarks": "vid_mode must be -1.",
      "type": "integer"
    },
    "vid_customwidth": {
      "desc": "Screen resolution height for custom screen mode.",
      "group-id": "52",
      "remarks": "vid_mode must be -1.",
      "type": "integer"
    },
    "vid_depthbits": {
      "group-id": "31",
      "type": ""
    },
    "vid_displayfrequency": {
      "default": "0",
      "desc": "Sets horizontal frequency for your monitor (in hertz - Hz).",
      "group-id": "52",
      "type": "integer"
    },
    "vid_displaynumber": {
      "default": "0",
      "desc": "Display/screen to use when in fullscreen mode.",
      "group-id": "52",
      "remarks": "Use vid_displaylist command to enumerate displays.",
      "type": "integer"
    },
    "vid_flashonactivity": {
      "default": "1",
      "desc": "When there is activity in the server, ezQuake's taskbar window will flash.\nActivity includes chat, high priority messages, disconnection from server.",
      "group-id": "52",
      "type": "float"
    },
    "vid_forcerestoregamma": {
      "desc": "Force restore gamma after returning to minimized application.",
      "group-id": "52",
      "remarks": "Might be usefull if you have ATI card.",
      "type": "boolean",
      "values": [
        {
          "description": "Old way of restoring gamma.",
          "name": "false"
        },
        {
          "description": "Force restore in 1 sec.",
          "name": "true"
        }
      ]
    },
    "vid_framebuffer": {
      "default": "0",
      "desc": "Enables rendering to custom Framebuffer Objects. ezQuake uses these FBOs for improved color, \"render scale\" control, and other post-processing effects.",
      "group-id": "52",
      "type": "enum",
      "values": [
        {
          "description": "Only uses the default framebuffer.",
          "name": "0"
        },
        {
          "description": "Render everything to a FBO.",
          "name": "1"
        },
        {
          "description": "Use separate FBOs for the 3D scene and HUD (allows scaling the two separately).",
          "name": "2"
        }
      ]
    },
    "vid_framebuffer_blit": {
      "default": "0",
      "desc": "Toggles blitting from the FBO to the front buffer instead of flipping buffers.",
      "group-id": "52",
      "remarks": "Only available with \"vid_framebuffer 1\" + \"vid_software_palette 0\" and a supported GPU.",
      "type": "boolean"
    },
    "vid_framebuffer_depthformat": {
      "default": "0",
      "desc": "Configures the depth-buffer precision for the framebuffer.",
      "group-id": "52",
      "type": "integer",
      "values": [
        {
          "description": "Use the best precision available (up to 32-bit float).",
          "name": "0"
        },
        {
          "description": "Use 16-bit float precision.",
          "name": "1"
        },
        {
          "description": "Use 24-bit float precision.",
          "name": "2"
        },
        {
          "description": "Use 32-bit precision.",
          "name": "3"
        },
        {
          "description": "Use 32-bit float precision.",
          "name": "4"
        }
      ]
    },
    "vid_framebuffer_fxaa": {
      "default": "0",
      "desc": "Fast Approximate Anti-Aliasing. Enable vid_framebuffer 2 to avoid filtering HUD. Typically between 1-6.",
      "group-id": "52",
      "type": "integer",
      "values": [
        {
          "description": "Disabled.",
          "name": "0"
        },
        {
          "description": "Medium dither, quality 1 (fastest).",
          "name": "1"
        },
        {
          "description": "Medium dither, quality 2.",
          "name": "2"
        },
        {
          "description": "Medium dither, quality 3.",
          "name": "3"
        },
        {
          "description": "Medium dither, quality 4.",
          "name": "4"
        },
        {
          "description": "Medium dither, quality 5.",
          "name": "5"
        },
        {
          "description": "Medium dither, quality 6 (highest quality).",
          "name": "6"
        },
        {
          "description": "Less dither, quality 1 (fastest).",
          "name": "7"
        },
        {
          "description": "Less dither, quality 2.",
          "name": "8"
        },
        {
          "description": "Less dither, quality 3.",
          "name": "9"
        },
        {
          "description": "Less dither, quality 4.",
          "name": "10"
        },
        {
          "description": "Less dither, quality 5.",
          "name": "11"
        },
        {
          "description": "Less dither, quality 6.",
          "name": "12"
        },
        {
          "description": "Less dither, quality 7.",
          "name": "13"
        },
        {
          "description": "Less dither, quality 8.",
          "name": "14"
        },
        {
          "description": "Less dither, quality 9.",
          "name": "15"
        },
        {
          "description": "Less dither, quality 10 (highest quality).",
          "name": "16"
        },
        {
          "description": "No dither (expensive).",
          "name": "17"
        }
      ]
    },
    "vid_framebuffer_hdr": {
      "default": "0",
      "desc": "Enables increased, 16-bit float HDR color precision for the framebuffer. This reduces color banding, and allows e.g. tone mapping in post-processing.",
      "group-id": "52",
      "type": "boolean"
    },
    "vid_framebuffer_hdr_tonemap": {
      "default": "0",
      "desc": "Toggles tone mapping in HDR mode.",
      "group-id": "52",
      "type": "boolean"
    },
    "vid_framebuffer_height": {
      "default": "0",
      "desc": "Sets a custom height for the FBO (200 pixels minimum).",
      "group-id": "52",
      "remarks": "Setting vid_framebuffer_scale overrides custom FBO width/height.",
      "type": "integer"
    },
    "vid_framebuffer_multisample": {
      "default": "0",
      "desc": "The number of samples used around each pixel for anti-aliasing when using custom FBOs.",
      "group-id": "52",
      "type": "integer",
      "values": [
        {
          "description": "Range 0 to 16.",
          "name": "*"
        }
      ]
    },
    "vid_framebuffer_scale": {
      "default": "1",
      "desc": "Scales the FBOs down/up to the screen resolution. Similar to \"render scale\" in other games if combined with vid_framebuffer 2.",
      "group-id": "52",
      "type": "float",
      "values": [
        {
          "description": "Custom scale with vid_framebuffer_scale_width/height.",
          "name": "0"
        },
        {
          "description": "Disable scaling.",
          "name": "1"
        },
        {
          "description": "Render to a larger FBO, then scale down.",
          "name": "0.25 to 1"
        },
        {
          "description": "Render to a smaller FBO, then scale up.",
          "name": "1.x+"
        }
      ]
    },
    "vid_framebuffer_smooth": {
      "default": "1",
      "desc": "Toggles filtering when scaling the framebuffer up/down to the screen resolution (with either the vid_framebuffer_scale or width+height properties).",
      "group-id": "52",
      "remarks": "Disable smoothing if you want to go for a chunky pixel look with FBO upscaling.",
      "type": "boolean",
      "values": [
        {
          "description": "Nearest filtering - blocky scaling.",
          "name": "false"
        },
        {
          "description": "Linear filtering - smooth scaling.",
          "name": "true"
        }
      ]
    },
    "vid_framebuffer_sshotmode": {
      "default": "0",
      "desc": "Controls screenshot resolution when using scaled framebuffers.",
      "group-id": "41",
      "type": "boolean",
      "values": [
        {
          "description": "Fullscreen/windowed resolution.",
          "name": "false"
        },
        {
          "description": "Framebuffer resolution.",
          "name": "true"
        }
      ]
    },
    "vid_framebuffer_width": {
      "default": "0",
      "desc": "Sets a custom width for the FBO (320 pixels minimum).",
      "group-id": "52",
      "remarks": "Setting vid_framebuffer_scale overrides custom FBO width/height.",
      "type": "integer"
    },
    "vid_fullscreen": {
      "default": "1",
      "desc": "Toggles between fullscreen and windowed mode.",
      "group-id": "52",
      "remarks": "alt + enter toggles the setting and applies the change without a vid_restart.",
      "type": "boolean",
      "values": [
        {
          "description": "Windowed mode.",
          "name": "false"
        },
        {
          "description": "Fullscreen mode.",
          "name": "true"
        }
      ]
    },
    "vid_fullscreen_mode": {
      "desc": "This variable sets the full screen video mode that the game will switch to when the \"vid_fullscreen\" command is executed.",
      "group-id": "31",
      "type": "float"
    },
    "vid_gammacorrection": {
      "default": "0",
      "group-id": "35",
      "type": "enum",
      "values": [
        {
          "description": "Do not use sRGB rendering context.",
          "name": "0"
        },
        {
          "description": "Request sRGB rendering context, use if possible.",
          "name": "1"
        },
        {
          "description": "Request sRGB rendering context, reject non-sRGB contexts.",
          "name": "2"
        }
      ]
    },
    "vid_gl_core_profile": {
      "default": "0",
      "desc": "Controls the level of backwards compatibility of the Classic Renderer with legacy OpenGL features.",
      "group-id": "52",
      "type": "boolean",
      "values": [
        {
          "description": "More backwards compatibility with older OpenGL.",
          "name": "false"
        },
        {
          "description": "Use the OpenGL Core profile, which drops older features. Disables immediate mode.",
          "name": "true"
        }
      ]
    },
    "vid_grab_keyboard": {
      "default": "0",
      "desc": "If set, grabs keyboard hotkeys.\nMay need to be enabled/disabled depending on your window manager.",
      "group-id": "9",
      "type": "boolean"
    },
    "vid_height": {
      "default": "0",
      "desc": "Determines width of screen resolution when in fullscreen mode.",
      "group-id": "52",
      "remarks": "This value is ignored if vid_usedesktopres is set.",
      "type": "integer"
    },
    "vid_hwgamma_fps": {
      "default": "60",
      "desc": "Controls the frequency of hardware gamma updates per second. These updates have a performance cost, so it is preferred to not update every frame when playing at thousands of FPS.",
      "group-id": "52",
      "remarks": "This can really hurt performance on screen flashing effects, i.e when taking damage - the worst moment to suffer framerate dips!",
      "type": "integer",
      "values": [
        {
          "description": "Update hardware gamma every frame.",
          "name": "0"
        },
        {
          "description": "Update hardware gamma at the specified frame rate.",
          "name": "*"
        }
      ]
    },
    "vid_hwgammacontrol": {
      "default": "0",
      "group-id": "52",
      "type": "enum",
      "values": [
        {
          "description": "Disables hwgamma control.",
          "name": "0"
        },
        {
          "description": "Enables hwgamma control for fullscreen mode.",
          "name": "1"
        },
        {
          "description": "Enables hwgamma control for fullscreen and windowed mode.",
          "name": "2"
        },
        {
          "description": "Enables hwgamma even when window focus is lost but not minimized (Xorg only).",
          "name": "3"
        }
      ]
    },
    "vid_minimize_on_focus_loss": {
      "default": "1",
      "desc": "If set, ezQuake will minimise when running in fullscreen mode and it loses focus (e.g. alt-tab).",
      "group-id": "52",
      "type": "boolean"
    },
    "vid_mode": {
      "desc": "This variables sets the next video mode to be used.\nAny change of this variable will cause the video mode to be changed immediately.",
      "group-id": "23",
      "type": "float"
    },
    "vid_nopageflip": {
      "desc": "This variable toggles the use of page-flipping during supported video modes.\nBy default the game will allow for page-flipping for video modes that support this feature.\nFor example if a given VESA mode can support page flipping, then it defaults to page-flipped operation.\nA VESA mode can be forced to non-page-flipped operation by setting the \"vid_nopageflip\" variable to \"1\", then setting the mode (note that \"vid_nopageflip\" takes operation on the next, not the current video mode, and note that it then stays in effect permanently, even when the client is exited and restarted, unless it is manually set back to \"0\").\nIf there is not enough memory for two pages in a VESA mode, or if the adapter doesn't support page flipping, then the mode will automatically be nnon-page-flipped.\n\nPage-flipping works by drawing multiple virtual game screens at the same time in the video memory and then switching among them to display the current gamescreen. Page-flipped modes thus use less system memory than non-page-flipped modes, but require more video memory.\nWhen using page-flipping, visual quality may be higher, but performance of the game can change to better or worse, depending on the graphics adapter and other hardware (see the discussion of the Pentium Pro below, for a discussion of why page flipping can be faster but is sometimes much slower on that processor). However in most cases the performance (and thus frame rate) will be increased, but for people with hardware that has problems with page-flipping \"vid_nopageflip 1\" may help.\nThe Pentium Pro is an example for such a hardware: it is an okay client platform (sniff!), but it has one weak spot, it is by default very slow on writes to video memory.\nThis means that in default hardware configurations, you are usually much better off setting \"vid_nopageflip\" to \"1\" if you use VESA modes, so drawing is done to system memory instead of to video memory.\nRemember that you must set the mode after setting \"vid_nopageflip\" to \"1\" in order to get \"vid_nopageflip\" to take effect. \"vid_nopageflip 1\" can sometimes be faster on a Pentium too, but not by nearly as much in general, and it's often slower.",
      "group-id": "23",
      "type": "float"
    },
    "vid_reload_auto": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "vid_renderer": {
      "default": "1",
      "desc": "Selects which rendering mode to use.",
      "group-id": "52",
      "remarks": "(variable only available if multiple renderers available)",
      "type": "enum",
      "values": [
        {
          "description": "OpenGL, classic.",
          "name": "0"
        },
        {
          "description": "OpenGL, GLSL-only (requires OpenGL 4.3 driver)",
          "name": "1"
        }
      ]
    },
    "vid_resetonswitch": {
      "group-id": "23",
      "remarks": "This is a workaround for the bug in some NVidia drivers, when you alt-tab out of ezQuake and the screen gets garbaged.\nWhen enabled, the client will reset your Windows video mode every time you press alt-tab. Note that some NVidia drivers lock up your system completely when you alt-tab: vid_resetonswitch will not help in this case (try starting ezQuake with -dibonly).",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Enable.",
          "name": "true"
        }
      ]
    },
    "vid_showextensions": {
      "default": "0",
      "desc": "If set, GL_EXTENSIONS string will be displayed when printing graphics info.",
      "group-id": "52",
      "type": "boolean"
    },
    "vid_software_palette": {
      "default": "1",
      "desc": "Controls whether to adjust gamma at the display level, or as a color correction rendering effect.",
      "group-id": "52",
      "type": "boolean",
      "values": [
        {
          "description": "Use hardware gamma (classic style).",
          "name": "false"
        },
        {
          "description": "Adjust gamma in post-processing.",
          "name": "true"
        }
      ]
    },
    "vid_stencilbits": {
      "group-id": "31",
      "type": ""
    },
    "vid_stretch_by_2": {
      "group-id": "23",
      "remarks": "This variable toggles whether in \"vid_mode 2\" the picture should be rendered at half-resolution in each direction and stretched up to the specified size.",
      "type": "boolean",
      "values": [
        {
          "description": "Disable.",
          "name": "false"
        },
        {
          "description": "Enable.",
          "name": "true"
        }
      ]
    },
    "vid_usedesktopres": {
      "default": "1",
      "desc": "If set, vid_width/vid_height are ignored, and desktop resolution is used instead.",
      "group-id": "52",
      "type": "boolean"
    },
    "vid_verbose": {
      "default": "0",
      "desc": "If set, display graphics info on every vid_restart.",
      "group-id": "52",
      "type": "boolean"
    },
    "vid_vsync": {
      "default": "0",
      "desc": "Syncs your FPS with your monitor's vertical refresh rate. This will override cl_maxfps.",
      "group-id": "52",
      "type": "boolean",
      "values": [
        {
          "description": "Disable vsync.",
          "name": "false"
        },
        {
          "description": "Enable vsync.",
          "name": "true"
        }
      ]
    },
    "vid_vsync_lag_fix": {
      "default": "0",
      "desc": "Enables experimental fix for a delay vertical synchronization mode.",
      "group-id": "52",
      "remarks": "When vid_vsync is set to 1, an artificial delay in the input can appear, enabling this should eliminate the delay.",
      "type": "boolean"
    },
    "vid_vsync_lag_tweak": {
      "default": "1.0",
      "desc": "Custom value for experimental vertical synchronization delay reduction.",
      "group-id": "52",
      "remarks": "Too low values (0.2 or lower) may significantly decrease FPS and make it not synced with display frequency.\nToo high values (10 and above) may turn off the effect of video lag fix completely.\nUse the lowest value that keeps stable FPS for you.",
      "type": "float"
    },
    "vid_wideaspect": {
      "desc": "Recalculates screen proportions so that they suit wide-screen displays.\nIf you toggle this variable from 0 to 1, it will recalculate your field of view (fov) and screen proportions (conwidth/conheight ratio) so that the resulting image looks similar on a 16:10 screen as it did on 4:3 screen.",
      "group-id": "52",
      "remarks": "The effect of the variable is only changing values of \"fov\" and \"vid_conheight\" variables when you toggle the value of this variable. The algorithm used to get resulting values is described in the QuakeWorld wiki.",
      "type": "boolean",
      "values": [
        {
          "description": "Keep the settings suitable for 4:3 screen.",
          "name": "false"
        },
        {
          "description": "Recalculate proportions to match 16:10 screens.",
          "name": "true"
        }
      ]
    },
    "vid_width": {
      "default": "0",
      "desc": "Determines width of screen resolution when in fullscreen mode.",
      "group-id": "52",
      "remarks": "This value is ignored if vid_usedesktopres is set.",
      "type": "integer"
    },
    "vid_win_borderless": {
      "default": "0",
      "desc": "Enables borderless windowed mode (no window title, frame...). Useful for multi-monitor setups, where it can provide a fullscreen window that does not pause when out of focus.",
      "group-id": "52",
      "type": "boolean",
      "values": [
        {
          "description": "Standard windowed mode.",
          "name": "false"
        },
        {
          "description": "Borderless windowed mode.",
          "name": "true"
        }
      ]
    },
    "vid_win_displaynumber": {
      "default": "0",
      "desc": "Display/screen to use when in windowed mode.",
      "group-id": "52",
      "remarks": "Use vid_displaylist command to enumerate displays.",
      "type": "integer"
    },
    "vid_win_height": {
      "default": "480",
      "desc": "Height of display when in windowed mode.",
      "group-id": "52",
      "type": "integer"
    },
    "vid_win_save_pos": {
      "default": "1",
      "desc": "If set, window position variables will be set as window moved around screen.",
      "group-id": "52",
      "type": "boolean"
    },
    "vid_win_save_size": {
      "default": "1",
      "desc": "If set, window size variables will be set as window resized.",
      "group-id": "52",
      "type": "boolean"
    },
    "vid_win_width": {
      "default": "640",
      "desc": "Width of display when in windowed mode.",
      "group-id": "52",
      "type": "integer"
    },
    "vid_window_x": {
      "desc": "This variable sets the x-axis location of the top left corner of the game window on the desktop.",
      "group-id": "31",
      "type": "float"
    },
    "vid_window_y": {
      "desc": "This variable sets the y-axis location of the top left corner of the game window on the desktop.",
      "group-id": "31",
      "type": "float"
    },
    "vid_windowed_mode": {
      "desc": "This variable sets the windowed video mode that the game will switch to when the \"vid_windowed\" command is executed.",
      "group-id": "31",
      "type": "float"
    },
    "vid_xpos": {
      "default": "3",
      "desc": "Horizontal position of the client window.",
      "group-id": "52",
      "type": "integer"
    },
    "vid_ypos": {
      "default": "39",
      "desc": "Vertical position of the client window.",
      "group-id": "52",
      "type": "integer"
    },
    "viewsize": {
      "default": "100",
      "desc": "This variable determines how large the viewable screen size is.",
      "group-id": "53",
      "remarks": "Range is 30-120.\nValues 100 & 110 are affected by cl_sbar.",
      "type": "enum",
      "values": [
        {
          "description": "Minimum screen size.",
          "name": "30"
        },
        {
          "description": "Normal screen size.",
          "name": "100"
        },
        {
          "description": "Large screen size, without the weapons status bar.",
          "name": "110"
        },
        {
          "description": "Maximum screen size, without any status bars.",
          "name": "120"
        }
      ]
    },
    "vip_password": {
      "default": "",
      "group-id": "43",
      "type": "string"
    },
    "vip_values": {
      "default": "",
      "group-id": "43",
      "type": "string"
    },
    "vm_rtChecks": {
      "default": "1",
      "group-id": "0",
      "system-generated": true
    },
    "volume": {
      "default": "0.7",
      "desc": "Sets sound volume.",
      "group-id": "45",
      "remarks": "This can go above 1, but sound will get more and more distorted.",
      "type": "float"
    },
    "w_switch": {
      "default": "",
      "desc": "This variable allows you to define the highest weapon that the client should switch to when picking it up.\nThe possible arguments of \"w_switch\" refer to the impulse that is used to switch to a certain weapon:",
      "group-id": "37",
      "type": "enum",
      "values": [
        {
          "description": "Axe.",
          "name": "1"
        },
        {
          "description": "Shotgun.",
          "name": "2"
        },
        {
          "description": "Double-Barreled Shotgun.",
          "name": "3"
        },
        {
          "description": "Nailgun.",
          "name": "4"
        },
        {
          "description": "Super Nailgun.",
          "name": "5"
        },
        {
          "description": "Grenade Launcher.",
          "name": "6"
        },
        {
          "description": "Rocket Launcher.",
          "name": "7"
        },
        {
          "description": "ThunderBolt.",
          "name": "8"
        }
      ]
    },
    "watervis": {
      "default": "0",
      "desc": "This server-side cvar is mirrored to serverinfo as a hint to clients on whether the server is using the so-called watervised maps.",
      "group-id": "34",
      "remarks": "It's a bad idea to use watervis 1 if the maps the server is using are not watervised.\nLiquids will appear 'transparent' but you won't be able to see any items/players/etc through it.\nIt is a bad idea anyway because Quake maps were not designed for transparent water (or other liquids); enabling it changes gameplay, decreases fps and produces more network traffic and puts non-GL players at a disadvantage because the software renderer doesn't support transparent water (yet).\nNot saved to config with cfg_save command.",
      "type": "boolean",
      "values": [
        {
          "description": "No watervis.",
          "name": "false"
        },
        {
          "description": "GLQuake users can see through liquids if they set gl_turbalpha to a value < 1.",
          "name": "true"
        }
      ]
    },
    "zombietime": {
      "default": "2",
      "desc": "The number of minutes that the server will keep the character of a player on the map who seems to have disconnected.",
      "group-id": "43",
      "type": "integer"
    }
  }
}


================================================
FILE: misc/appimage/appimage-manual_creation.sh
================================================
#!/bin/bash

set -e

SKIP_DEPS="${SKIP_DEPS:-0}"

ARCH=$(uname -m)
ARCHDASH=$(echo "$ARCH"|tr '_' '-')
APPIMAGETOOL="https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-${ARCH}.AppImage"

curl -Ls "$APPIMAGETOOL" > appimagetool
if [ $? -ne 0 ];then
	echo "failed to retrieve appimagetool.  bailing out."
	exit 1
fi
chmod -f +x appimagetool

#unused but must exist
DESKTOP_ENTRY='[Desktop Entry]
Comment=A modern QuakeWorld client focused on competitive online play
Name=ezQuake
Exec=ezquake-linux-'$ARCH'
Icon=io.github.ezQuake
Type=Application
StartupNotify=true
Terminal=false
Categories=Game;
Keywords=quake;first;person;shooter;multiplayer;'

TESTPROGRAM='
#include "curl/curl.h"
int main(){
	curl_easy_init();
	return 0;
}
'

QUAKE_SCRIPT='#!/usr/bin/env bash
export LD_LIBRARY_PATH="${APPIMAGE_LIBRARY_PATH}:${APPDIR}/usr/lib:${LD_LIBRARY_PATH}"
if [ ! -e "$OWD/id1" ];then
	cd "$(dirname "$APPIMAGE")"
else
	cd "$OWD"
fi
"${APPDIR}/usr/bin/test"  >/dev/null 2>&1 |:
FAIL=${PIPESTATUS[0]}
if [ $FAIL -eq 0 ];then
	echo "executing with native libc"
	"${APPDIR}/usr/bin/ezquake-linux-'$ARCH'" $*
else
	echo "executing with appimage libc"
	export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${APPDIR}/usr/lib-override"
	"${APPDIR}/usr/lib-override/ld-linux-'$ARCHDASH'.so.2" "${APPDIR}/usr/bin/ezquake-linux-'$ARCH'" $*
fi
exitstatus=$?
if [ $exitstatus -eq 0 ];then
	#fix qwurl association if set for appimage
	grep -q "^Exec=/tmp/.mount_" "${HOME}/.local/share/applications/qw-url-handler.desktop" >/dev/null 2>&1 && \
		sed -i "s|^Exec=.*|Exec=${APPIMAGE} +qwurl %u|g" "${HOME}/.local/share/applications/qw-url-handler.desktop"
fi
exit $exitstatus
'

unset CC
if [ "$ARCH" == "x86_64" ];then
	march="-march=nehalem"
fi
export CFLAGS="$march -O3 -pipe -flto=$(nproc)"
export LDFLAGS="$CFLAGS"

DIR="$(pwd)"

if [ -d AppDir ];then
	rm -rf AppDir
fi
mkdir -p "$DIR/AppDir/usr/bin" || exit 1
mkdir -p "$DIR/AppDir/usr/lib" || exit 1
mkdir -p "$DIR/AppDir/usr/lib-override" || exit 1

VERSION=$(sed -n 's/.*VERSION_NUMBER.*"\(.*\)".*/\1/p' src/version.h)
REVISION=$(git log -n 1|head -1|awk '{print $2}'|cut -c1-6)

#build ezquake unless executable set
if ! [[ -x "$EXECUTABLE" ]]; then
	export SKIP_DEPS
	chmod +x ./build-linux.sh && nice ./build-linux.sh || exit 3
	EXECUTABLE="build/ezquake-linux-$ARCH"
fi

#build test program
echo "$TESTPROGRAM" > "$DIR/test.c" || exit 2
gcc "$DIR/test.c" -o "$DIR/AppDir/usr/bin/test" -lcurl || exit 2
rm -f "$DIR/AppDir/test.c" || exit 2

cp -f $EXECUTABLE "$DIR/AppDir/usr/bin/." || exit 4
rm -f "$DIR/AppDir/AppRun"
echo "$QUAKE_SCRIPT" > "$DIR/AppDir/AppRun" || exit 4
chmod +x "$DIR/AppDir/AppRun" || exit 4
echo "$DESKTOP_ENTRY" > "$DIR/AppDir/io.github.ezQuake.desktop" || exit 4
cp "$DIR/dist/linux/io.github.ezQuake.128.png" "$DIR/AppDir/io.github.ezQuake.png"||true #copy over quake png if it exists
mkdir -p "$DIR/AppDir/usr/share/metainfo"
sed 's,EZQUAKE_VERSION,'$VERSION-$REVISION',g;s,EZQUAKE_DATE,'$(date +%F)',g' "$DIR/misc/appimage/ezquake.appdata.xml.template" > "$DIR/AppDir/usr/share/metainfo/ezquake.appdata.xml"
ldd "$DIR/AppDir/usr/bin/ezquake-linux-$ARCH" | \
	grep --color=never -v libGL| \
	grep --color=never -v libdrm.so | \
	grep --color=never -v libgbm.so | \
	awk '{print $3}'| \
	xargs -I% cp -Lf "%" "$DIR/AppDir/usr/lib/." || exit 5
strip -s "$DIR/AppDir/usr/lib/"* || exit 5
strip -s "$DIR/AppDir/usr/bin/"* || exit 5
mv -f "$DIR/AppDir/usr/lib/libc.so.6" "$DIR/AppDir/usr/lib-override/."
mv -f "$DIR/AppDir/usr/lib/libm.so.6" "$DIR/AppDir/usr/lib-override/."
cp -f "$(ldconfig -Np|grep --color=never libpthread.so.0$|grep --color=never $(uname -m)|awk '{print $NF}')" "$DIR/AppDir/usr/lib-override/."
cp -Lf "/lib64/ld-linux-${ARCHDASH}.so.2" "$DIR/AppDir/usr/lib-override/." || exit 6

cd "$DIR" || exit 5
./appimagetool AppDir ezQuake-$ARCH.AppImage || exit 7


================================================
FILE: misc/appimage/ezquake.appdata.xml.template
================================================
<?xml version="1.0" encoding="UTF-8"?>
<component type="desktop-application">
  <id>io.github.ezQuake</id>
  <name>ezQuake</name>
  <summary>a modern QuakeWorld client focused on competitive online play</summary>
  <metadata_license>CC0-1.0</metadata_license>
  <project_license>GPL-2.0</project_license>

  <developer_name>ezQuake team</developer_name>
  <update_contact>ezquake @ github</update_contact>

  <url type="homepage">https://ezquake.github.io/</url>
  <url type="bugtracker">https://github.com/ezQuake/ezquake-source</url>
  <url type="help">https://ezquake.github.io/manual.html</url>
  <url type="contact">https://www.quakeworld.nu/forum</url>

  <launchable type="desktop-id">io.github.ezQuake.desktop</launchable>

  <description>
    <p>
      Welcome to the home of ezQuake, a modern QuakeWorld client focused on competitive online play. Combining the features of modern QuakeWorld® clients, ezQuake makes QuakeWorld® easier to start and play. The immortal first person shooter Quake® in a brand new skin with superb graphics and extremely fast gameplay.                                                                                                                                                                                                                                     
    </p>
    <ul>
      <li>Modern Graphics: Particle explosions, shaft beam, gunshots, nails, rocket and grenade trails, blood, and others, MD3 models, fog, water effects, killing spree messages, rain</li>
      <li>Modern competitive gaming features: Fullbright skins, forcing team/enemy colors, advanced weapon handling, teamplay messages, auto game recording, automated screenshots and console logging</li>
      <li>Graphics customization: Customize your HUD, colors of walls and liquids, turn superfluous graphics effects off, change world textures, crosshair, sky picture, console background, game font</li>
      <li>Independent Physics: Get the smoothest experience possible without being limited by server or network settings</li>
      <li>Integrated Server Browser: Easy searching and filtering of online servers</li>
      <li>Enhanced demo/QTV playback: View recorded games from multiple points of view, watch action on radar, all player stats in a handy table, autotrack the strongest player</li>
    </ul>
    <p>
      Commercial data files are required to run the supported games. These can be aquired though a multitude of sources. See the manual for more info on this.
    </p>
  </description>

  <screenshots>
    <screenshot type="default">
      <image>https://ezquake.github.io/screenshots/armor_battle.png</image>
      <caption>Battle for armor</caption>
    </screenshot>
    <screenshot>
      <image>https://ezquake.github.io/screenshots/bloom.jpg</image>
      <caption>Bloom effect</caption>
    </screenshot>
    <screenshot>
      <image>https://ezquake.github.io/screenshots/shambler_cutf_bluefog.jpg</image>
      <caption>Special effects</caption>
    </screenshot>
  </screenshots>

  <releases>
    <release version="EZQUAKE_VERSION" date="EZQUAKE_DATE" />
  </releases>

  <content_rating type="oars-1.1">
    <content_attribute id="violence-realistic">moderate</content_attribute>
    <content_attribute id="violence-bloodshed">moderate</content_attribute>
    <content_attribute id="violence-desecration">moderate</content_attribute>
    <!-- Full multiplayer functionality with voicechat support -->
    <content_attribute id="social-chat">intense</content_attribute>
    <content_attribute id="social-audio">intense</content_attribute>
  </content_rating>
</component>



================================================
FILE: misc/cfg/cams.cfg
================================================
//
// Camera positions bookmarks 1.2
//
// Use [Ctrl]+[0], [1], ..., [9] to store cam positions
// Use [0], [1], ..., [9] to load stored camera positions
// Use [Shift]+[0], [1], ..., [9] to move smoothly to cam position
//   (will happen only during capturing)
//

// -- settings --
set cams_moveframes 50 // duration - how many frames will the movement take
// note: you set time here, not the distance nor the speed. distance is given by the two points of the movement, speed is given as distance/time (frames)

bind ctrl +cams_save_mode
bind shift +cams_move_mode


// -- print info --
echo "$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-"
echo "Camera bookmarks config"
echo "$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-$-"
echo "Use $[ctrl$]+$[num$] to save camera position, $[num$] to load it"
echo "Use $[shift$]+$[num$] to start camera movement to camera positions 1, 2, ..., num"

// -- code -- (don't touch this)

set cams_bindn 0
// in other words: for (i=0; i<10; i++) { bind i cams_go i }
alias cams_bindnext "cams_bindc; inc cams_bindn 1; if $cams_bindn < 10 cams_bindnext" 
alias cams_bindc "bind $cams_bindn cams_go $cams_bindn"
cams_bindnext

set cams_bindmode 0

alias +cams_save_mode "set cams_bindmode 1"
alias -cams_save_mode "set cams_bindmode 0"
alias +cams_move_mode "set cams_bindmode 2"
alias -cams_move_mode "set cams_bindmode 0"
 
alias cams_go "if $cams_bindmode == 0 cams_load %1 else if $cams_bindmode == 1 cams_save %1 else cams_move %1"
alias cams_load "cam_angles $cam_angles_saved%1; cam_pos $cam_pos_saved%1"
alias cams_save "set cam_angles_saved%1 $cam_angles; set cam_pos_saved%1 $cam_pos; cams_save_detailed %1"

// this saves each value to separated variable. it's being used in the move
alias cams_save_detailed "cams_save_detang %1; cams_save_detpos %1"
alias cams_save_detang "set cams_angles_saved_pitch%1 $cam_angles_pitch; set cams_angles_saved_yaw%1 $cam_angles_yaw; set cams_angles_saved_roll%1 $cam_angles_roll"
alias cams_save_detpos "set cams_pos_saved_x%1 $cam_pos_x; set cams_pos_saved_y%1 $cam_pos_y; set cams_pos_saved_z%1 $cam_pos_z"

// here we do the calculations for the smooth camera movement
// note: I really should have written this in TCL :)

alias cams_move "set cams_part_moves %1; set cams_part_curm 1; if $cams_part_moves >= 1 cams_move_partial $cams_part_curm"
alias cams_move_partial "cams_calc_steps %1; cams_store_alias; cams_replace_alias; set cams_cappedframes 0"
alias cams_store_alias "set_alias_str cams_stored_alias f_captureframe"
// alias cams_restore_alias "alias f_captureframe $cams_stored_alias"
alias cams_finish_move "inc cams_part_curm; if $cams_part_curm <= $cams_part_moves cams_move_partial $cams_part_curm else cams_restore_alias"
alias cams_restore_alias "alias f_captureframe" // yes, this will clear f_captureframe alias, not "clean" but better behavior than something else
alias cams_replace_alias "alias f_captureframe cams_moveframe"
alias cams_calc_steps "cams_calc_diffs %1; cams_calc_divs"
alias cams_calc_diffs "set_calc cams_step_x $cams_pos_saved_x%1 - $cam_pos_x; set_calc cams_step_y $cams_pos_saved_y%1 - $cam_pos_y; set_calc cams_step_z $cams_pos_saved_z%1 - $cam_pos_z; cams_calc_yaw_diff %1; set_calc cams_step_pitch $cams_angles_saved_pitch%1 - $cam_angles_pitch"

// will calculate the horizontal turn and check if it's bigger than 180 degrees
alias cams_calc_yaw_diff "set_calc cams_step_yaw $cams_angles_saved_yaw%1 - $cam_angles_yaw; if $cams_step_yaw > 180 cams_calc_yaw_complement; if $cams_step_yaw < -180 cams_calc_yaw_comp_neg" // get the shortest of the two possible ways: CW/CCW
// if the turn was bigger than 180 degrees, it will use 360 degrees complement
alias cams_calc_yaw_complement "set_calc cams_step_yaw $cams_step_yaw - 360"
alias cams_calc_yaw_comp_neg "set_calc cams_step_yaw $cams_step_yaw + 360"
alias cams_calc_divs "set_calc cams_step_x $cams_step_x / $cams_moveframes; set_calc cams_step_y $cams_step_y / $cams_moveframes; set_calc cams_step_z $cams_step_z / $cams_moveframes; set_calc cams_step_yaw $cams_step_yaw / $cams_moveframes; set_calc cams_step_pitch $cams_step_pitch / $cams_moveframes"
alias cams_moveframe "cams_move_pos; cams_move_ang; inc cams_cappedframes; if $cams_cappedframes >= $cams_moveframes cams_finish_move"
alias cams_move_pos "set_calc cams_tx $cam_pos_x + $cams_step_x; set_calc cams_ty $cam_pos_y + $cams_step_y; set_calc cams_tz $cam_pos_z + $cams_step_z; cam_pos $cams_tx $cams_ty $cams_tz"
alias cams_move_ang "set_calc cams_tw $cam_angles_yaw + $cams_step_yaw; set_calc cams_tp $cam_angles_pitch + $cams_step_pitch; cam_angles $cams_tp $cams_tw 0"


// 1) calculate 6 steps
// 2) save current f_captureframe alias
// 3) set new f_captureframe alias

alias cams_clear "unset_re cam_angles."


================================================
FILE: misc/cfg/cams.tcl
================================================
#
# Camera positions bookmarks 1.1
#
# Use [Ctrl]+[0], [1], ..., [9] to store cam positions
# Use [0], [1], ..., [9] to load stored camera positions
# Use [Shift]+[0], [1], ..., [9] to move smoothly to cam position
#   (will happen only during capturing)
#

# -- settings --
set cams_moveframes 50; # duration - how many frames will the movement take 

cmd bind ctrl +cams_save_mode
cmd bind shift +cams_move_mode


# -- code -- (don't touch this)

set cams_bindn 0

for {set i 0} {$i < 10} {incr i} {
    cmd bind $i cams_go $i
}

set cams_bindmode 0
set cams_totalmoves 0

alias +cams_save_mode {} {set ::cams_bindmode 1}
alias -cams_save_mode {} {set ::cams_bindmode 0}
alias +cams_move_mode {} {set ::cams_bindmode 2}
alias -cams_move_mode {} {set ::cams_bindmode 0}

#using globals sux in TCL (as everywhere), i'm new to TCL and perhaps i could use some namespaces here and there

# this one is bound to 0,1,2,...9 keys
alias cams_go {slot} {
    global cams_bindmode
    if {$cams_bindmode == 0} {
        cams_load $slot
    } elseif { $cams_bindmode == 1 } {
        cams_save $slot
    } else {
        cams_move $slot
    }
}

proc cams_load {slot} {
    global cam_angles_saved
    global cam_pos_saved
    cmd cam_angles $cam_angles_saved($slot)
    cmd cam_pos $cam_pos_saved($slot)
}

proc cams_save {slot} {
    global cam_angles_saved
    global cam_pos_saved
    global cam_angles
    set cam_angles_saved($slot) $::cam_angles
    set cam_pos_saved($slot) $::cam_pos
    cams_save_detailed $slot
}

# this saves each value to separated field. it's being used in the move
proc cams_save_detailed {slot} {
    global cams_saved_det

    set cams_saved_det($slot,pitch) $::cam_angles_pitch
    set cams_saved_det($slot,yaw) $::cam_angles_yaw
    set cams_saved_det($slot,roll) $::cam_angles_roll

    set cams_saved_det($slot,x) $::cam_pos_x
    set cams_saved_det($slot,y) $::cam_pos_y
    set cams_saved_det($slot,z) $::cam_pos_z
}

proc cams_move {part} {
    global cams_totalmoves
    set cams_totalmoves $part
    cams_move_partial 0
}

# calculate the differences between current and future position
proc cams_calc_diffs {slot} {
    global cams_step
    global cams_saved_det
    set cams_step(x) [expr {$cams_saved_det($slot,x) - $::cam_pos_x}]
    set cams_step(y) [expr {$cams_saved_det($slot,y) - $::cam_pos_y}]
    set cams_step(z) [expr {$cams_saved_det($slot,z) - $::cam_pos_z}]

    # get the shortest of the two possible ways: CW/CCW
    set cams_step(yaw) [expr {$cams_saved_det($slot,yaw) - $::cam_angles_yaw}]
    if {$cams_step(yaw) > 180} {
        set cams_step(yaw) [expr { $cams_step(yaw) - 360}]
    } elseif {$cams_step(yaw) < -180} {
        set cams_step(yaw) [expr { $cams_step(yaw) + 360}]
    }
    set cams_step(pitch) [expr {$cams_saved_det($slot,pitch) - $::cam_angles_pitch}]
    set cams_step(roll) [expr {$cams_saved_det($slot,roll) - $::cam_angles_roll}]
}

# cams_setp
proc cams_calc_divs {moveframes} {
    global cams_step
    set cams_step(x) [expr {$cams_step(x) / $moveframes}]
    set cams_step(y) [expr {$cams_step(y) / $moveframes}]
    set cams_step(z) [expr {$cams_step(z) / $moveframes}]
    set cams_step(yaw) [expr {$cams_step(yaw) / $moveframes}]
    set cams_step(pitch) [expr {$cams_step(pitch) / $moveframes}]
}

proc cams_move_partial {part} { ;# input: part = previous move number
    global cams_totalmoves   ;# how many moves we will take
    global cams_moveframes   ;# how many frames will the move take (todo)
    global cams_cappedframes ;# how many frames we have already passed
    incr part                ;# go to next move (this proc is first called with part = 0)
    
    if {$part > $cams_totalmoves} {
        cmd alias f_captureframe ""
    } else {
        cams_calc_diffs $part
        cams_calc_divs $cams_moveframes
        set cams_cappedframes 0
        cmd alias f_captureframe cams_moveframe $part
    }
}

# happens in each frame
alias cams_moveframe {part} {
    global cams_cappedframes ;# how many frames we have already captured on this move
    global cams_moveframes   ;# how many frames we should capture on this move
    global cams_step         ;# contains step info (x,y,z,pitch,yaw,roll)
    
    set cams_tx [expr {$::cam_pos_x + $cams_step(x)}]
    set cams_ty [expr {$::cam_pos_y + $cams_step(y)}]
    set cams_tz [expr {$::cam_pos_z + $cams_step(z)}]
    cmd cam_pos $cams_tx $cams_ty $cams_tz
    set cams_tw [expr {$::cam_angles_yaw + $cams_step(yaw)}]
    set cams_tp [expr {$::cam_angles_pitch + $cams_step(pitch)}]
    cmd cam_angles $cams_tp $cams_tw 0
    incr cams_cappedframes
    if {$cams_cappedframes > $cams_moveframes} {
        cams_move_partial $part
    }
}


proc cams_clear {} {
    cmd unset_re cam_angles.
}


================================================
FILE: misc/cfg/eq260.cfg
================================================

//---CREDITS-------------------------------------------------------------------------------------------------------------//
// THIS CONFIG FILE WAS MADE BY STRIFE WITH HELP FROM JEZAJA AND XANTOM. LAST UPDATED 05-03-28.
// WORKS ONLY WITH FUHQUAKE OR EZQUAKE, FOUND AT http://www.fuhquake.net AND http://ezquake.sourceforge.net/
// WORKS BEST WITH FLINTHEARTS FUHQUAKE LOC FILES, GET THEM AT http://maps.quakeworld.nu/locs
// PUT THEM IN QUAKE/QW/LOCS FOLDER.

//---HOW-TO-INSTALL------------------------------------------------------------------------------------------------------//
// THE ONLY TWO THINGS YOU HAVE TO CHANGE IN THIS CONFIG IS THE SET NICK ??? TO AN ABBREVATION OF YOUR NICK NAME.
// SECOND THING TO EDIT ARE ALL THE ? KEYS, WHICH BUTTON GOES TO WHAT TEAMSAYMESSAGE.
// WHEN THIS FILE IS EDITED AND SAVED PUT IT IN THE QUAKE/QW FOLDER, TYPE "exec eq260.cfg"
// AND THEN "cfg_save nameofyourcfg" WITHOUT THE "" IN THE CONSOLE.



//---EDIT-THIS-----------------------------------------------------------------------------------------------------------//

set nick ???          //Change "???" to the 3 first letters in your nickname. Example: set nick str

bind  a  "_report"    //Example: bind R "_report"
                      //Report that will show your powerups, health, armor, location and weapons.
                      //Weapon = RLG means you have the RocketLauncher AND the Lightning-Gun with at least 15 cells.

bind  shift  "_coming"    //Example: bind C "_coming"
                      //Simple "coming" report, will also show powerup if you have that. If you lack rocketlauncher and
                      //have more than 99 armor, it will show your armor amount aswell.

bind  z  "_took"      //Example: bind T "_took"
                      //This is to report "team powerup" and "took item [location]".
                      //If you have RL after taking a backpack, it will display "took rl-pack [location]"

bind  4  "_need"      //Example: bind H "_help"
                      //Reports "help [location]" everywhere except dm2-quad-low where it will report "help/trick".
                      //Help should also be used as swap, switch or whatever people like to have.

bind  x  "_safe"      //Example: bind F "_safe"
                      //Will show "safe [location]" with 2 green leds. This means that area is safe.
                      //If your best weapon is shotgun or nailgun, it will just do a regular _report.

bind  g  "_help"      //Example: bind E "_need"
                      //"need items [location]" amr = armor, hth = health, rox = rockets, wpn = weapon.
                      //If health is above 50, armor above 70, RL with 5 or more rockets it will display _safe instead.

bind  r  "_point"     //Example: bind Q "_point"
                      //Use to point items like ra/ya/ga/pack, also point players with powerups. It will also show what you 
                      //need if you are pointing powerup-item, like "str >> quad [quad] amr/rox" (needs armor and rockets)

bind  c  "_attack"    //Example: bind G "_attack"
                      //Use when you died vs weakened enemy-rl and need teammates to spam that area.
                      //Displays "sync" instead if you have weapon, this is good for coordinating attacks with teammates.

bind  v  "_lost"      //Example: bind Z "_lost"
                      //Will show "lost [location]" you died at with 2 red leds, use when you feel it is important.

bind  ctrl  "_rlpack"    //Example: bind 1 "_rlpack"
                      //Works like lost, but use when you think you dropped a rocketlauncher.

bind  3  "_qout"      //Example: bind 2 "_qout"
                      //"quad killed" if you dont have quad. "quad 30" if you do.

bind  1  "_getquad"   //Example: bind 3 "_getquad"
                      //Standard "get quad" report, use about 10 seconds before it spawns.

bind  2  "_getpent"   //Example: bind 4 "_getpent"
                      //Simply reports "get pent/ring", use about 20 seconds before pent spawns.

bind  w  "_enemyp"    //Example: bind V "_enemyp"
                      //Will report "enemy quad" by default, but if you have seen enemy pent, it will report that instead.
                      //Use this before you start shooting at someone with ring to see if it is enemy or teammate.
                      //If you are dead, [location] will also show. You can point enemy quad with it while dead.

bind  t  "_take"      //Example: bind 5 "_take"
                      //Will report "soon [location]" if you already have whatever item spawns in the area you are.
                      //If you need the item yourself, it will report "awaits [location]".
                      //If you point teammate when using this it will report "teammate take item [location]".

//-----------------------------------------------------------------------------------------------------------------------//
// NOW SAVE THE FILE TO YOUR /QUAKE/QW DIRECTORY, START QUAKE AND TYPE exec eq260.cfg
// DONE! DONT FORGET TO CFG_SAVE YOUR CONFIG IF IT WORKS LIKE YOU WANT IT TO.






















//----------------------------------------DO-NOT-EDIT-ANYTHING-BELOW-------------------------------------------------------//

alias .attack                  "say_team $\$nick $eq_red $tp_name_attack $dl %E"
alias .attacksync              "say_team $\$nick $eq_yellow $tp_name_sync $l %b"
alias .attacksync2             "say_team $\$nick $eq_yellow $tp_name_sync $l rlg:$rockets"
alias .attacksyncpowq             "say_team $\$nick $eq_yellow {q} $tp_name_sync $l"
alias .attacksyncpowp             "say_team $\$nick $eq_yellow {p} $tp_name_sync $l"
alias .attacksyncpowr             "say_team $\$nick $eq_yellow {r} $tp_name_sync $l"
alias .attacksyncpowqp            "say_team $\$nick $eq_yellow {qp} $tp_name_sync $l"
alias .attacksyncpowqr            "say_team $\$nick $eq_yellow {qr} $tp_name_sync $l"
alias .attacksyncpowpr            "say_team $\$nick $eq_yellow {pr} $tp_name_sync $l"
alias .attacksyncpowqpr           "say_team $\$nick $eq_yellow {qpr} $tp_name_sync $l"
alias .attacksyncpowwpnq             "say_team $\$nick $eq_yellow {q} $tp_name_sync $l %b"
alias .attacksyncpowwpnp             "say_team $\$nick $eq_yellow {p} $tp_name_sync $l %b"
alias .attacksyncpowwpnr             "say_team $\$nick $eq_yellow {r} $tp_name_sync $l %b"
alias .attacksyncpowwpnqp            "say_team $\$nick $eq_yellow {qp} $tp_name_sync $l %b"
alias .attacksyncpowwpnqr            "say_team $\$nick $eq_yellow {qr} $tp_name_sync $l %b"
alias .attacksyncpowwpnpr            "say_team $\$nick $eq_yellow {pr} $tp_name_sync $l %b"
alias .attacksyncpowwpnqpr           "say_team $\$nick $eq_yellow {qpr} $tp_name_sync $l %b"
alias .attacksyncpowrlgq             "say_team $\$nick $eq_yellow {q} $tp_name_sync $l rlg:$rockets"
alias .attacksyncpowrlgp             "say_team $\$nick $eq_yellow {p} $tp_name_sync $l rlg:$rockets"
alias .attacksyncpowrlgr             "say_team $\$nick $eq_yellow {r} $tp_name_sync $l rlg:$rockets"
alias .attacksyncpowrlgqp            "say_team $\$nick $eq_yellow {qp} $tp_name_sync $l rlg:$rockets"
alias .attacksyncpowrlgqr            "say_team $\$nick $eq_yellow {qr} $tp_name_sync $l rlg:$rockets"
alias .attacksyncpowrlgpr            "say_team $\$nick $eq_yellow {pr} $tp_name_sync $l rlg:$rockets"
alias .attacksyncpowrlgqpr           "say_team $\$nick $eq_yellow {qpr} $tp_name_sync $l rlg:$rockets"

alias .coming                  "say_team $\$nick $eq_green $tp_name_coming $l"
alias .coming2                 "say_team $\$nick $eq_green $tp_name_coming $l %A%a"
alias .comingpowq             "say_team $\$nick $eq_green {q} coming $l"
alias .comingpowp             "say_team $\$nick $eq_green {p} coming $l"
alias .comingpowr             "say_team $\$nick $eq_green {r} coming $l"
alias .comingpowqp            "say_team $\$nick $eq_green {qp} coming $l"
alias .comingpowqr            "say_team $\$nick $eq_green {qr} coming $l"
alias .comingpowpr            "say_team $\$nick $eq_green {pr} coming $l"
alias .comingpowqpr           "say_team $\$nick $eq_green {qpr} coming $l"
alias .comingamrpowq             "say_team $\$nick $eq_green {q} coming $l %A%a"
alias .comingamrpowp             "say_team $\$nick $eq_green {p} coming $l %A%a"
alias .comingamrpowr             "say_team $\$nick $eq_green {r} coming $l %A%a"
alias .comingamrpowqp            "say_team $\$nick $eq_green {qp} coming $l %A%a"
alias .comingamrpowqr            "say_team $\$nick $eq_green {qr} coming $l %A%a"
alias .comingamrpowpr            "say_team $\$nick $eq_green {pr} coming $l %A%a"
alias .comingamrpowqpr           "say_team $\$nick $eq_green {qpr} coming $l %A%a"

alias .enemyp                  "say_team $\$nick $eq_red enemy %q $eq_red"
alias .enemyp2                 "say_team $\$nick $eq_red enemy %q $l"
alias .enemyp3                 "say_team $\$nick $eq_red enemy %q $eq_left%y$eq_right"

alias .getpent                 "say_team $\$nick $eq_purple get $tp_name_pent/$tp_name_ring $eq_purple"
alias .getquad                 "say_team $\$nick $eq_purple get $tp_name_quad $eq_purple"
alias .getring                 "say_team $\$nick $eq_purple get $tp_name_ring $eq_purple"

alias .help                    "say_team $\$nick $eq_yellow help $l %E"

alias .lost                    "say_team $\$nick $eq_red lost $dl %E"

alias .need                    "say_team $\$nick $eq_white $tp_name_need %u $l"
alias .needq                   "say_team $\$nick $eq_white {q} $tp_name_need %u $l"
alias .needp                   "say_team $\$nick $eq_white {p} $tp_name_need %u $l"
alias .needr                   "say_team $\$nick $eq_white {r} $tp_name_need %u $l"
alias .needqp                  "say_team $\$nick $eq_white {qp} $tp_name_need %u $l"
alias .needqr                  "say_team $\$nick $eq_white {qr} $tp_name_need %u $l"
alias .needpr                  "say_team $\$nick $eq_white {pr} $tp_name_need %u $l"
alias .needqpr                 "say_team $\$nick $eq_white {qpr} $tp_name_need %u $l"

alias .point                   "say_team $\$nick $eq_arrows %x $eq_left%y$eq_right"
alias .point2                  "say_team $\$nick $eq_arrows %x $eq_left%y$eq_right need %u"
alias .point3                  "say_team $\$nick $eq_arrows %x $eq_left%y$eq_right"

alias .awaits                  "say_team $\$nick $eq_yellow awaits $l"
alias .soon                    "say_team $\$nick $eq_green $tp_name_soon $l"
alias .take_mate               "say_team $\$nick $eq_yellow %x take $l"

alias .qout                    "say_team $\$nick $eq_yellow $tp_name_quad killed $eq_yellow"
alias .qout2                   "say_team $\$nick $eq_yellow $tp_name_quad 30 $eq_yellow"

alias .report                  "say_team $\$nick $eq_blue %A%a/%h $l rlg:$rockets"
alias .report2                 "say_team $\$nick $eq_blue %A%a/%h $l %b"
alias .report3                 "say_team $\$nick $eq_blue %A%a/%h $l"
alias .reportpowq             "say_team $\$nick $eq_blue {q} %A%a/%h $l"
alias .reportpowp             "say_team $\$nick $eq_blue {p} %A%a/%h $l"
alias .reportpowr             "say_team $\$nick $eq_blue {r} %A%a/%h $l"
alias .reportpowqp            "say_team $\$nick $eq_blue {qp} %A%a/%h $l"
alias .reportpowqr            "say_team $\$nick $eq_blue {qr} %A%a/%h $l"
alias .reportpowpr            "say_team $\$nick $eq_blue {pr} %A%a/%h $l"
alias .reportpowqpr           "say_team $\$nick $eq_blue {qpr} %A%a/%h $l"
alias .reportpowwpnq             "say_team $\$nick $eq_blue {q} %A%a/%h $l %b"
alias .reportpowwpnp             "say_team $\$nick $eq_blue {p} %A%a/%h $l %b"
alias .reportpowwpnr             "say_team $\$nick $eq_blue {r} %A%a/%h $l %b"
alias .reportpowwpnqp            "say_team $\$nick $eq_blue {qp} %A%a/%h $l %b"
alias .reportpowwpnqr            "say_team $\$nick $eq_blue {qr} %A%a/%h $l %b"
alias .reportpowwpnpr            "say_team $\$nick $eq_blue {pr} %A%a/%h $l %b"
alias .reportpowwpnqpr           "say_team $\$nick $eq_blue {qpr} %A%a/%h $l %b"
alias .reportpowrlgq             "say_team $\$nick $eq_blue {q} %A%a/%h $l rlg:$rockets"
alias .reportpowrlgp             "say_team $\$nick $eq_blue {p} %A%a/%h $l rlg:$rockets"
alias .reportpowrlgr             "say_team $\$nick $eq_blue {r} %A%a/%h $l rlg:$rockets"
alias .reportpowrlgqp            "say_team $\$nick $eq_blue {qp} %A%a/%h $l rlg:$rockets"
alias .reportpowrlgqr            "say_team $\$nick $eq_blue {qr} %A%a/%h $l rlg:$rockets"
alias .reportpowrlgpr            "say_team $\$nick $eq_blue {pr} %A%a/%h $l rlg:$rockets"
alias .reportpowrlgqpr           "say_team $\$nick $eq_blue {qpr} %A%a/%h $l rlg:$rockets"

alias .rlpack                "say_team $\$nick $eq_red rl-pack $dl %E"

alias .safe                    "say_team $\$nick $eq_green safe $l rlg:$rockets"
alias .safe2                   "say_team $\$nick $eq_green safe $l %b"
alias .safe3                   "say_team $\$nick $eq_green safe $l"
alias .safepowwpnq             "say_team $\$nick $eq_green {q} safe $l %b"
alias .safepowwpnp             "say_team $\$nick $eq_green {p} safe $l %b"
alias .safepowwpnr             "say_team $\$nick $eq_green {r} safe $l %b"
alias .safepowwpnqp            "say_team $\$nick $eq_green {qp} safe $l %b"
alias .safepowwpnqr            "say_team $\$nick $eq_green {qr} safe $l %b"
alias .safepowwpnpr            "say_team $\$nick $eq_green {pr} safe $l %b"
alias .safepowwpnqpr           "say_team $\$nick $eq_green {qpr} safe $l %b"
alias .safepowrlgq             "say_team $\$nick $eq_green {q} safe $l rlg:$rockets"
alias .safepowrlgp             "say_team $\$nick $eq_green {p} safe $l rlg:$rockets"
alias .safepowrlgr             "say_team $\$nick $eq_green {r} safe $l rlg:$rockets"
alias .safepowrlgqp            "say_team $\$nick $eq_green {qp} safe $l rlg:$rockets"
alias .safepowrlgqr            "say_team $\$nick $eq_green {qr} safe $l rlg:$rockets"
alias .safepowrlgpr            "say_team $\$nick $eq_green {pr} safe $l rlg:$rockets"
alias .safepowrlgqpr           "say_team $\$nick $eq_green {qpr} safe $l rlg:$rockets"

alias .teamp                   "say_team $\$nick $eq_green $tp_name_teamp %p $eq_green need %u"
alias .teamp2                  "say_team $\$nick $eq_green $tp_name_teamp %p $eq_green"

alias .took                    "say_team $\$nick $eq_blue took %X $eq_left%Y$eq_right"
alias .tookrlpack              "say_team $\$nick $eq_blue took rl-pack $eq_left%Y$eq_right"

alias .trick                   "say_team $\$nick $eq_yellow $tp_name_help/$tp_name_trick $l"

//Teamplay Communications

tp_weapon_order              "78653241"

//Item Names
tp_name_axe                  "axe"
tp_name_sg                   "sg"
tp_name_ssg                  "ssg"
tp_name_ng                   "ng"
tp_name_sng                  "sng"
tp_name_gl                   "gl"
tp_name_rl                   "rl"
tp_name_lg                   "lg"
tp_name_ga                   "ga"
tp_name_ya                   "ya"
tp_name_ra                   "ra"
tp_name_armortype_ga         "g"
tp_name_armortype_ya         "y"
tp_name_armortype_ra         "r"
tp_name_shells               "shells"
tp_name_nails                "nails"
tp_name_rockets              "rox"
tp_name_cells                "cel"
tp_name_quad                 "quad"
tp_name_pent                 "pent"
tp_name_ring                 "ring"
tp_name_suit                 "suit"
tp_name_mh                   "mh"
tp_name_health               "hth"
tp_name_armor                "amr"
tp_name_weapon               "wpn"
tp_name_backpack             "pack"
tp_name_flag                 "flag"
tp_name_sentry               "sent"
tp_name_disp                 "disp"
tp_name_teammate             ""
tp_name_enemy                "nme"
tp_name_eyes                 "{r}"
tp_name_quaded               "{q}"
tp_name_pented               "{p}"
tp_name_status_green         "$G"
tp_name_status_yellow        "$Y"
tp_name_status_red           "$R"
tp_name_status_blue          "$B"
tp_name_someplace            "someplace"
tp_name_at                   " $eq_arrow "
tp_name_nothing              "--"
tp_name_none                 ""
tp_name_separator            "/"

//Item Need Amounts
tp_need_rl                   "1"
tp_need_weapon               "87"
tp_need_ga                   "70"
tp_need_ya                   "70"
tp_need_ra                   "70"
tp_need_shells               "0"
tp_need_nails                "0"
tp_need_rockets              "5"
tp_need_cells                "0"
tp_need_health               "50"

//User Created Variables
set l                       "{%l}"
set dl                      "{%d}"
set loc                     "{%l}"
set eq_arrow                ""
set eq_arrows               ""
set eq_awaitspoint          "powerups armor players mh lg rl gl sng ssg pack rockets cells"
set eq_blue                 ""
set eq_lightblue            ""
set eq_green                ""
set eq_green3               ""
set eq_left                 "{"
set eq_normalpoint          "powerups armor players mh lg rl gl sng ssg pack rockets"
set eq_purple               ""
set eq_red                  ""
set eq_red3                 ""
set eq_right                "}"
set eq_white                ""
set eq_white3               ""
set eq_yellow               ""
set loc_name_ga             "ga"
set loc_name_gl             "gl"
set loc_name_mh             "mega"
set loc_name_ng             "ng"
set loc_name_ra             "ra"
set loc_name_rl             "rl"
set loc_name_separator      "-"
set loc_name_sng            "sng"
set loc_name_ssg            "ssg"
set loc_name_ya             "ya"
set tp_name_attack          "attack"
set tp_name_coming          "coming"
set tp_name_dm2button       "low-rl/button"
set tp_name_dm2quadlow      "quad-low"
set tp_name_help            "help"
set tp_name_lgpack          "lg-pack"
set tp_name_need            "need"
set tp_name_powdead         "dead"
set tp_name_ratunnel        "ra-tunnel"
set tp_name_rlpack          "rl-pack"
set tp_name_soon            "soon"
set tp_name_sync            "sync"
set tp_name_teamp           "team"
set tp_name_trick           "trick"

// warn if prefix is default
if $qt$nick$qt = $qt???$qt then echo $eq_red Change your reports prefix using /set nick pfx

tp_pickup    powerups armor mh lg rl gl pack rockets
tp_took      powerups armor mh lg rl gl pack rockets
tp_point     powerups armor players mh lg rl gl sng ssg pack rockets

alias +aback                   "+back"
alias -aback                   "-back"
alias +aforward                "+forward"
alias -aforward                "-forward"
alias +ajump                   "+jump"
alias -ajump                   "-jump"
alias +amoveleft               "+moveleft"
alias -amoveleft               "-moveleft"
alias +amoveright              "+moveright"
alias -amoveright              "-moveright"

alias __awaitspoint            "tp_point $eq_awaitspoint"
alias __normalpoint            "tp_point $eq_normalpoint"

alias _attack                  "if $health < 1 then .attack else _attack2"
alias _attack2                 "if $qt$tp_name_quad$qt isin $qt$powerups$qt then _attacksyncp else _attack3"
alias _attack3                 "if $bestweapon isin $tp_name_rl|$tp_name_lg then _attacksync else .attack"
alias _attacksync              "if $tp_name_lg isin $qt$weapons$qt then _attacksync2 else _attacksync4"
alias _attacksync2             "if $cells > 14 then _attacksync3 else _attacksync4"
alias _attacksync3             "if $bestweapon = $qt$tp_name_lg$qt then _attacksync4 else _attacksync5"
alias _attacksync4             "if $qt$powerups$qt == $qt$tp_name_none$qt then .attacksync else _attacksyncpowwpn"
alias _attacksync5             "if $qt$powerups$qt == $qt$tp_name_none$qt then .attacksync2 else _attacksyncpowrlg"
alias _attacksyncp             "if $bestweapon isin $tp_name_sg|$tp_name_ng then _attacksyncpow else _attacksyncp1"
alias _attacksyncp1            "if $tp_name_lg isin $qt$weapons$qt then _attacksyncp2 else _attacksyncpowwpn"
alias _attacksyncp2            "if $cells > 14 then _attacksyncp3 else _attacksyncpowwpn"
alias _attacksyncp3            "if $bestweapon = $qt$tp_name_lg$qt then _attacksyncpowwpn else _attacksyncpowrlg"
alias _attacksyncpow                "if $qt$powerups$qt == $qt$tp_name_quad$qt then .attacksyncpowq else _attacksyncpow2"
alias _attacksyncpow2               "if $qt$powerups$qt == $qt$tp_name_pent$qt then .attacksyncpowp else _attacksyncpow3"
alias _attacksyncpow3               "if $qt$powerups$qt == $qt$tp_name_ring$qt then .attacksyncpowr else _attacksyncpow4"
alias _attacksyncpow4               "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .attacksyncpowpr else _attacksyncpow5"
alias _attacksyncpow5               "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .attacksyncpowqp else _attacksyncpow6"
alias _attacksyncpow6               "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .attacksyncpowqr else .attacksyncpowqpr"
alias _attacksyncpowwpn                   "if $qt$powerups$qt == $qt$tp_name_quad$qt then .attacksyncpowwpnq else _attacksyncpowwpn2"
alias _attacksyncpowwpn2                  "if $qt$powerups$qt == $qt$tp_name_pent$qt then .attacksyncpowwpnp else _attacksyncpowwpn3"
alias _attacksyncpowwpn3                  "if $qt$powerups$qt == $qt$tp_name_ring$qt then .attacksyncpowwpnr else _attacksyncpowwpn4"
alias _attacksyncpowwpn4                  "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .attacksyncpowwpnpr else _attacksyncpowwpn5"
alias _attacksyncpowwpn5                  "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .attacksyncpowwpnqp else _attacksyncpowwpn6"
alias _attacksyncpowwpn6                  "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .attacksyncpowwpnqr else .attacksyncpowwpnqpr"
alias _attacksyncpowrlg                   "if $qt$powerups$qt == $qt$tp_name_quad$qt then .attacksyncpowrlgq else _attacksyncpowrlg2"
alias _attacksyncpowrlg2                  "if $qt$powerups$qt == $qt$tp_name_pent$qt then .attacksyncpowrlgp else _attacksyncpowrlg3"
alias _attacksyncpowrlg3                  "if $qt$powerups$qt == $qt$tp_name_ring$qt then .attacksyncpowrlgr else _attacksyncpowrlg4"
alias _attacksyncpowrlg4                  "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .attacksyncpowrlgpr else _attacksyncpowrlg5"
alias _attacksyncpowrlg5                  "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .attacksyncpowrlgqp else _attacksyncpowrlg6"
alias _attacksyncpowrlg6                  "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .attacksyncpowrlgqr else .attacksyncpowrlgqpr"

alias _rlpack                ".rlpack"

alias _report   "if $health < 1 then _lost else _report1"
alias _report1  "if $qt$powerups$qt = $qt$tp_name_none$qt then _report2 else _reportp2"
alias _report2  "if $bestweapon isin $tp_name_sg|$tp_name_ng then .report3 else if $tp_name_lg isin $qt$weapons$qt then _report4 else .report2"
alias _report4  "if $cells > 14 then _report5 else .report2"
alias _report5  "if $bestweapon = $qt$tp_name_lg$qt then .report2 else .report"
alias _reportp2 "if $bestweapon isin $tp_name_sg|$tp_name_ng then _reportpow else if $tp_name_lg isin $qt$weapons$qt then _reportp4 else _reportpowwpn"
alias _reportp4 "if $cells > 14 then _reportp5 else _reportpowwpn"
alias _reportp5 "if $bestweapon = $qt$tp_name_lg$qt then _reportpowwpn else _reportpowrlg"
alias _reportpow                   "if $qt$powerups$qt == $qt$tp_name_quad$qt then .reportpowq else _reportpow2"
alias _reportpow2                  "if $qt$powerups$qt == $qt$tp_name_pent$qt then .reportpowp else _reportpow3"
alias _reportpow3                  "if $qt$powerups$qt == $qt$tp_name_ring$qt then .reportpowr else _reportpow4"
alias _reportpow4                  "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .reportpowpr else _reportpow5"
alias _reportpow5                  "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .reportpowqp else _reportpow6"
alias _reportpow6                  "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .reportpowqr else .reportpowqpr"
alias _reportpowwpn                   "if $qt$powerups$qt == $qt$tp_name_quad$qt then .reportpowwpnq else _reportpowwpn2"
alias _reportpowwpn2                  "if $qt$powerups$qt == $qt$tp_name_pent$qt then .reportpowwpnp else _reportpowwpn3"
alias _reportpowwpn3                  "if $qt$powerups$qt == $qt$tp_name_ring$qt then .reportpowwpnr else _reportpowwpn4"
alias _reportpowwpn4                  "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .reportpowwpnpr else _reportpowwpn5"
alias _reportpowwpn5                  "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .reportpowwpnqp else _reportpowwpn6"
alias _reportpowwpn6                  "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .reportpowwpnqr else .reportpowwpnqpr"
alias _reportpowrlg                   "if $qt$powerups$qt == $qt$tp_name_quad$qt then .reportpowrlgq else _reportpowrlg2"
alias _reportpowrlg2                  "if $qt$powerups$qt == $qt$tp_name_pent$qt then .reportpowrlgp else _reportpowrlg3"
alias _reportpowrlg3                  "if $qt$powerups$qt == $qt$tp_name_ring$qt then .reportpowrlgr else _reportpowrlg4"
alias _reportpowrlg4                  "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .reportpowrlgpr else _reportpowrlg5"
alias _reportpowrlg5                  "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .reportpowrlgqp else _reportpowrlg6"
alias _reportpowrlg6                  "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .reportpowrlgqr else .reportpowrlgqpr"

alias _coming                  "if $health < 1 then _lost else _coming1"
alias _coming1                 "if $qt$powerups$qt = $qt$tp_name_none$qt then _coming2 else _comingp"
alias _coming2                 "if $bestweapon != $qt$tp_name_rl$qt then _coming3 else .coming"
alias _coming3                 "if $armor > 99 then .coming2 else .coming"
alias _comingp                 "_comingp1"
alias _comingp1                "if $bestweapon != $qt$tp_name_rl$qt then _comingp2 else _comingpow"
alias _comingp2                "if $armor > 99 then _comingamrpow else _comingpow"
alias _comingamrpow          "if $qt$powerups$qt == $qt$tp_name_quad$qt then .comingamrpowq else _comingamrpow2"
alias _comingamrpow2         "if $qt$powerups$qt == $qt$tp_name_pent$qt then .comingamrpowp else _comingamrpow3"
alias _comingamrpow3         "if $qt$powerups$qt == $qt$tp_name_ring$qt then .comingamrpowr else _comingamrpow4"
alias _comingamrpow4         "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .comingamrpowpr else _comingamrpow5"
alias _comingamrpow5         "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .comingamrpowqp else _comingamrpow6"
alias _comingamrpow6         "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .comingamrpowqr else .comingamrpowqpr"
alias _comingpow            "if $qt$powerups$qt == $qt$tp_name_quad$qt then .comingpowq else _comingpow2"
alias _comingpow2           "if $qt$powerups$qt == $qt$tp_name_pent$qt then .comingpowp else _comingpow3"
alias _comingpow3           "if $qt$powerups$qt == $qt$tp_name_ring$qt then .comingpowr else _comingpow4"
alias _comingpow4           "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .comingpowpr else _comingpow5"
alias _comingpow5           "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .comingpowqp else _comingpow6"
alias _comingpow6           "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .comingpowqr else .comingpowqpr"

alias _enemyp                  "if $health < 1 then _enemyp2 else .enemyp"
alias _enemyp2                 "if $ledpoint = $tp_name_status_red then .enemyp3 else .enemyp2"

alias _getpent                 "if $qt$mapname$qt = $qtdm2$qt then else if $qt$mapname$qt = $qte1m2$qt then else _getpent1"
alias _getpent1                "if $qt$tp_name_pent$qt isin $qt$powerups$qt then _getring else .getpent"
alias _getquad                 "if $qt$tp_name_quad$qt isin $qt$powerups$qt then else .getquad"
alias _getring                 "if $qt$tp_name_ring$qt isin $qt$powerups$qt then else if $qt$tp_name_pent$qt isin $qt$powerups$qt then else .getring"

alias _help                    "if $health < 1 then _lost else _help_trick_maps"
alias _help_trick_dm2          "if $qt$tp_name_quad-low$qt isin $location then .trick else if $qtquad-button$qt isin $location then .trick else .help"
alias _help_trick_maps         "if $mapname = $qtdm2$qt then _help_trick_dm2 else .help"

alias _lost                    "if $health >= 1000 then _lost2 else _lost1"
alias _lost1                   "if $qtsomeplace$qt isin $deathloc then else _lost2"
alias _lost2                   "if $tp_name_rl = $droppedweapon then .rlpack else if $tp_name_lg = $droppedweapon then _lost3 else .lost"
alias _lost3                   "if $droppedammo > 13 then .lgpack else .lost"

alias _need                    "if $health < 1 then _lost else _need1"
alias _need1                   "if $qt$powerups$qt = $qt$tp_name_none$qt then _need2 else _needp"
alias _need2                   "if $need = $qt$tp_name_nothing$qt then _safe else .need"
alias _needp                   "if $need = $qt$tp_name_nothing$qt then _safe else _needp2"
alias _needp2                  "if $qt$powerups$qt == $qt$tp_name_quad$qt then .needq else _needp3"
alias _needp3                  "if $qt$powerups$qt == $qt$tp_name_pent$qt then .needp else _needp4"
alias _needp4                  "if $qt$powerups$qt == $qt$tp_name_ring$qt then .needr else _needp5"
alias _needp5                  "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .needpr else _needp6"
alias _needp6                  "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .needqp else _needp7"
alias _needp7                  "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .needqr else .needqpr"

alias _point                   "if $ledpoint = $tp_name_status_green then else _pointx"
alias _pointx                  "if $health > 1 then _point1 else if $qt$tp_name_backpack$qt isin $qt$point$qt then else _point1"
alias _point1                  "if $qt$point$qt = $qt$tp_name_nothing$qt then else _point2x"
alias _point2x                 "if $ledpoint = $tp_name_status_red then .point3 else _point5"
alias _point5                  "if $ledpoint = $tp_name_status_yellow then _point6 else .point"
alias _point6                  "if $need = $qt$tp_name_nothing$qt then .point else .point2"

alias _qout                    "if $qt$tp_name_quad$qt isin $qt$powerups$qt then .qout2 else .qout"

alias _safe                    "if $health < 1 then _lost else _safe1"
alias _safe1                   "if $qt$powerups$qt = $qt$tp_name_none$qt then _safe2 else _safep"
alias _safe2                   "if $bestweapon isin $tp_name_sg|$tp_name_ng then _report else _safe3"
alias _safe3                   "if $tp_name_lg isin $qt$weapons$qt then _safe4 else .safe2"
alias _safe4                   "if $cells > 14 then _safe5 else .safe2"
alias _safe5                   "if $bestweapon = $qt$tp_name_lg$qt then .safe2 else .safe"
alias _safep                   "if $health < 1 then _lost else _safep2"
alias _safep2                  "if $bestweapon isin $tp_name_sg|$tp_name_ng then _reportp2 else _safep3"
alias _safep3                  "if $tp_name_lg isin $qt$weapons$qt then _safep4 else _safepowwpn"
alias _safep4                  "if $cells > 14 then _safep5 else _safepowwpn"
alias _safep5                  "if $bestweapon = $qt$tp_name_lg$qt then _safepowwpn else _safepowrlg"
alias _safepowwpn                   "if $qt$powerups$qt == $qt$tp_name_quad$qt then .safepowwpnq else _safepowwpn2"
alias _safepowwpn2                  "if $qt$powerups$qt == $qt$tp_name_pent$qt then .safepowwpnp else _safepowwpn3"
alias _safepowwpn3                  "if $qt$powerups$qt == $qt$tp_name_ring$qt then .safepowwpnr else _safepowwpn4"
alias _safepowwpn4                  "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .safepowwpnpr else _safepowwpn5"
alias _safepowwpn5                  "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .safepowwpnqp else _safepowwpn6"
alias _safepowwpn6                  "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .safepowwpnqr else .safepowwpnqpr"
alias _safepowrlg                   "if $qt$powerups$qt == $qt$tp_name_quad$qt then .safepowrlgq else _safepowrlg2"
alias _safepowrlg2                  "if $qt$powerups$qt == $qt$tp_name_pent$qt then .safepowrlgp else _safepowrlg3"
alias _safepowrlg3                  "if $qt$powerups$qt == $qt$tp_name_ring$qt then .safepowrlgr else _safepowrlg4"
alias _safepowrlg4                  "if $qt$tp_name_quad$qt !isin $qt$powerups$qt then .safepowrlgpr else _safepowrlg5"
alias _safepowrlg5                  "if $qt$tp_name_ring$qt !isin $qt$powerups$qt then .safepowrlgqp else _safepowrlg6"
alias _safepowrlg6                  "if $qt$tp_name_pent$qt !isin $qt$powerups$qt then .safepowrlgqr else .safepowrlgqpr"

alias _take                    "if $health < 1 then _lost else _take_try"
alias _take_ga                 "if $armor < $tp_need_ga then .awaits else .soon"
alias _take_lg                 "if $bestweapon isin $tp_name_lg then .soon else _take_point_it"
alias _take_point "if $ledpoint = $tp_name_status_green then .take_mate else _take_point_1"
alias _take_point_1     "__normalpoint; if $qt$point$qt != $qtrl$qt then _take_point_2 else if $qtrl$qt isin $location then _point else _take_point_2"
alias _take_point_2     "if $qt$point$qt != $qtlg$qt then _take_point_3 else if $qtlg$qt isin $location then _point else _take_point_3"
alias _take_point_3     "if $qt$point$qt != $qtra$qt then _take_point_4 else if $qtra$qt isin $location then _point else _take_point_4"
alias _take_point_4     "if $qt$point$qt != $qtya$qt then _take_point_5 else if $qtya$qt isin $location then _point else _take_point_5"
alias _take_point_5     "if $qt$point$qt != $qtga$qt then _take_try_ra else if $qtga$gt isin $location then _point else _take_try_ra"
alias _take_point_c     "if $qt$point$qt != $qt$tp_name_cells$qt then .awaits else _point"
alias _take_point_it    "if $ledpoint = $tp_name_status_blue then _take_point_c else .awaits"
alias _take_ra                 "if $armor < $tp_need_ra then .awaits else .soon"
alias _take_rl                 "if $bestweapon isin $tp_name_rl then .soon else .awaits"
alias _take_try                "__awaitspoint;if $qt$point$qt != $tp_name_nothing then _take_point else _take_try_ra"
alias _take_try_dm2            "if $mapname != $qtdm2$qt then _take_try_ya else if $qtsecret$qt = $qt$location$qt then _take_ra else _take_try_ya"
alias _take_try_ga             "if $qtga$qt isin $location then _take_ga else _take_try_rl"
alias _take_try_lg             "if $qtlg$qt isin $location then _take_lg else _take_point_it"
alias _take_try_mega           "if $qtmega$qt isin $location then .awaits else _take_try_ga"
alias _take_try_ra             "__normalpoint; if $qtra$qt isin $location then _take_ra else _take_try_dm2"
alias _take_try_rl             "if $qtrl$qt isin $location then _take_rl else _take_try_lg"
alias _take_try_ya             "if $qtya$qt isin $location then _take_ya else _take_try_mega"
alias _take_ya                 "if $armor < $tp_need_ra then .awaits else .soon"

alias _teamp                   "if $need = $qt$tp_name_nothing$qt then _teamp2 else _teamp1"
alias _teamp1                  ".teamp;.teamp"
alias _teamp2                  ".teamp2;.teamp2"

alias _took                    "if $qt$took$qt isin $qt$tp_name_quad/$tp_name_ring/$tp_name_pent$qt then _teamp else _took_nopow"
alias _took_nopow              "if $qt$took$qt == $qt$tp_name_nothing$qt then else _took_rlpack"
alias _took_rlpack             "if $qt$took$qt == $qt$tp_name_backpack$qt then _took_rlpack2 else .took"
alias _took_rlpack2            "if $bestweapon isin $tp_name_rl then .tookrlpack else .took"


================================================
FILE: misc/cfg/ezhud.cfg
================================================
//
// ------------------- ezHUD --------------------
// Head Up Display configuration script
// Made by johnnycz 2006
//
// About:
// This script helps you customize your HUD.
// You select, move, resize, change the frame,
// show, hide and align the HUD elements using
// your keyboard.
// 
// Requirements:
// ezQuake 1517 or newer 
// [ http://ezquake.sourceforge.net/ ]
//
// Usage:
// 1) Place the script into <quake>/ezquake/cfg
// 2) Run ezQuake, go into the console and type: 
//    /exec cfg/ezhud
// 3) Follow the instructions on the screen
//
// ----------------------------------------------
//

// init
unset_re ezhud_.
unalias_re .ezhud_.
hud_planmode 1
if $scr_newhud == 0 scr_newhud 1
hud_recalculate
set ezhud_verbose 1

// store current binds
set ezhud_cfg_save_cmds $cfg_save_cmds
set ezhud_cfg_save_cmdline $cfg_save_cmdline
set ezhud_cfg_save_sysinfo $cfg_save_sysinfo
set ezhud_cfg_save_aliases $cfg_save_aliases
set ezhud_cfg_save_userinfo $cfg_save_userinfo
set ezhud_cfg_save_cvars $cfg_save_cvars
set ezhud_cfg_save_binds $cfg_save_binds
cfg_save_cmds 0
cfg_save_cmdline 0
cfg_save_sysinfo 0
cfg_save_aliases 0
cfg_save_cvars 0
cfg_save_binds 1
wait
echo dumping current bindings...
cfg_save _temp_ezhud_binds

// set binds
bind [ ezhud_sel_prev
bind ] ezhud_sel_next
bind pgdn ezhud_sel_nextmore
bind pgup ezhud_sel_prevmore
bind end ezhud_sel_last
bind home ezhud_sel_first
bind del ezhud_hide
bind ins ezhud_show

bind uparrow ezhud_move_up
bind downarrow ezhud_movedown
bind leftarrow ezhud_moveleft
bind rightarrow ezhud_moveright
bind space +ezhud_mark
bind enter ezhud_toggle
bind h ezhud_help

bind kp_1 "ezhud_align left bottom"
bind kp_2 "ezhud_align center bottom"
bind kp_3 "ezhud_align right bottom"
bind kp_4 "ezhud_align left center"
bind kp_5 "ezhud_align center center"
bind kp_6 "ezhud_align right center"
bind kp_7 "ezhud_align left top"
bind kp_8 "ezhud_align center top"
bind kp_9 "ezhud_align right top"

bind w "ezhud_align_rel_y before"
bind s "ezhud_align_rel_y after"
bind a "ezhud_align_rel_x before"
bind d "ezhud_align_rel_x after"

bind z ezhud_widthdown
bind x ezhud_widthup
bind c ezhud_heightdown
bind v ezhud_heightup

bind q "ezhud_showmore"
bind r "ezhud_resetpos"

bind shift +ezhud_bigchange
bind kp_plus ezhud_scaleup
bind kp_minus ezhud_scaledown
bind kp_slash ezhud_frameup
bind kp_star ezhud_framedown
bind , ezhud_styleup
bind . ezhud_styledown
bind kp_ins ezhud_place_sel
bind kp_enter ezhud_place_conf

bind 1 "ezhud_selplace 1"
bind 2 "ezhud_selplace 2"
bind 3 "ezhud_selplace 3"
bind 4 "ezhud_selplace 4"
bind 5 "ezhud_selplace 5"
bind 6 "ezhud_selplace 6"
bind 7 "ezhud_selplace 7"
bind 8 "ezhud_selplace 8"
bind 9 "ezhud_selplace 9"

bind u ezhud_finish

// instructions
echo "ezHud config loaded"
echo "press $[h$] for help"

// yeah, this sucks, TCL please! (this config is not made in TCL because I think most people would be too lazy to turn off smackdown ruleset to try it)
alias ezhud_help "ezhud_help1; ezhud_help2; ezhud_help3; ezhud_help4; ezhud_help4b; ezhud_help5; ezhud_help6; ezhud_help7; ezhud_help8; ezhud_help9; ezhud_help10; ezhud_help11"
alias ezhud_help1 "echo $[[$], $[]$], $[page up$], $[page down$], $[home$], $[end$] to select elements"
alias ezhud_help2 "echo $[Enter$], $[Del$], $[Ins$] to show/hide elements"
alias ezhud_help3 "echo $[Space$] to mark mark selected elements"
alias ezhud_help4 "echo arrows to move, keypad and w,a,s,d keys to align elements"
alias ezhud_help4b "echo $[r$] to reset element position"
alias ezhud_help5 "echo hold $[shift$] to move in larger steps"
alias ezhud_help6 "echo $[z$], $[x$], $[c$], $[v$] to change width and height"
alias ezhud_help7 "echo keypad plus/minus to scale up/down, slash/star to adjust frame"
alias ezhud_help8 "echo use $[,$] and $[.$] to change style of an element"
alias ezhud_help9 "echo use $[keypad 0$] to align elements to each other"
alias ezhud_help10 "echo press $[q$] to see all element properties"
alias ezhud_help11 "echo press $[u$] when you are done"

// code, etc...
set ezhud_elem_1 ammo
set ezhud_elem_2 ammo1
set ezhud_elem_3 ammo2
set ezhud_elem_4 ammo3
set ezhud_elem_5 ammo4
set ezhud_elem_6 armor
set ezhud_elem_7 armordamage
set ezhud_elem_8 clock
set ezhud_elem_9 cross
set ezhud_elem_10 democlock
set ezhud_elem_11 face
set ezhud_elem_12 fps
set ezhud_elem_13 frags
set ezhud_elem_14 gameclock
set ezhud_elem_15 group1
set ezhud_elem_16 group2
set ezhud_elem_17 group3
set ezhud_elem_18 group4
set ezhud_elem_19 group5
set ezhud_elem_20 group6
set ezhud_elem_21 group7
set ezhud_elem_22 group8
set ezhud_elem_23 group9
set ezhud_elem_24 gun
set ezhud_elem_25 gun2
set ezhud_elem_26 gun3
set ezhud_elem_27 gun4
set ezhud_elem_28 gun5
set ezhud_elem_29 gun6
set ezhud_elem_30 gun7
set ezhud_elem_31 gun8
set ezhud_elem_32 health
set ezhud_elem_33 healthdamage
set ezhud_elem_34 iammo
set ezhud_elem_35 iammo1
set ezhud_elem_36 iammo2
set ezhud_elem_37 iammo3
set ezhud_elem_38 iammo4
set ezhud_elem_39 iarmor
set ezhud_elem_40 key1
set ezhud_elem_41 key2
set ezhud_elem_42 mp3_time
set ezhud_elem_43 mp3_title
set ezhud_elem_44 net
set ezhud_elem_45 netgraph
set ezhud_elem_46 pent
set ezhud_elem_47 ping
set ezhud_elem_48 quad
set ezhud_elem_49 radar
set ezhud_elem_50 ring
set ezhud_elem_51 sigil1
set ezhud_elem_52 sigil2
set ezhud_elem_53 sigil3
set ezhud_elem_54 sigil4
set ezhud_elem_55 speed
set ezhud_elem_56 suit
set ezhud_elem_57 teamfrags
set ezhud_elem_58 teamholdbar
set ezhud_elem_59 tracking
set ezhud_max_elems 59
set ezhud_curnum 1
alias ezhud_curcheck "if $ezhud_curnum > $ezhud_max_elems set ezhud_curnum $ezhud_max_elems else if $ezhud_curnum < 1 set ezhud_curnum 1"
alias ezhud_setcur "ezhud_curcheck; set_ex ezhud_curelem $ezhud_elem_$ezhud_curnum"
alias ezhud_echocur "echo ($ezhud_curnum/$ezhud_max_elems) $ezhud_curelem selected"
ezhud_setcur

set ezhud_place_1 screen
set ezhud_place_2 view
set ezhud_place_3 top
set ezhud_place_4 sbar
set ezhud_place_5 ibar
set ezhud_place_6 hbar
set ezhud_place_7 sfree
set ezhud_place_8 ifree
set ezhud_place_9 hfree

alias ezhud_sel_next "inc ezhud_curnum 1; ezhud_setcur; ezhud_echocur"
alias ezhud_sel_prev "inc ezhud_curnum -1; ezhud_setcur; ezhud_echocur"
alias ezhud_sel_nextmore "inc ezhud_curnum $ezhud_bigchange; ezhud_setcur; ezhud_echocur"
alias ezhud_sel_prevmore "inc ezhud_curnum -$ezhud_bigchange; ezhud_setcur; ezhud_echocur"
alias ezhud_sel_first "set ezhud_curnum 1; ezhud_setcur; ezhud_echocur"
alias ezhud_sel_last "set ezhud_curnum $ezhud_max_elems; ezhud_setcur; ezhud_echocur"

alias ezhud_refresh "hud_recalculate"

set ezhud_smallchange 1
set ezhud_bigchange 8
alias +ezhud_bigchange "set ezhud_curchange $ezhud_bigchange"
alias -ezhud_bigchange "set ezhud_curchange $ezhud_smallchange"
-ezhud_bigchange

alias ezhud_move_up "inc hud_$ezhud_curelem_pos_y -$ezhud_curchange; ezhud_refresh"
alias ezhud_movedown "inc hud_$ezhud_curelem_pos_y $ezhud_curchange; ezhud_refresh"
alias ezhud_moveleft "inc hud_$ezhud_curelem_pos_x -$ezhud_curchange; ezhud_refresh"
alias ezhud_moveright "inc hud_$ezhud_curelem_pos_x $ezhud_curchange; ezhud_refresh"

alias ezhud_resetpos "move $ezhud_curelem 0 0"

alias +ezhud_mark "set_ex ezhud_tempframe $hud_$ezhud_curelem_frame; set_ex ezhud_tempshow $hud_$ezhud_curelem_show;set hud_$ezhud_curelem_frame 2; set hud_$ezhud_curelem_show 1"
alias -ezhud_mark "set hud_$ezhud_curelem_frame $ezhud_tempframe; set hud_$ezhud_curelem_show $ezhud_tempshow; ezhud_refresh"

alias ezhud_toggle "toggle hud_$ezhud_curelem_show"
alias ezhud_hide "hide $ezhud_curelem"
alias ezhud_show "show $ezhud_curelem"

alias ezhud_align "align $ezhud_curelem %1 %2; ezhud_refresh"

alias ezhud_align_rel_y "set hud_$ezhud_curelem_align_y %1; ezhud_refresh"
alias ezhud_align_rel_x "set hud_$ezhud_curelem_align_x %1; ezhud_refresh"

alias ezhud_echoscale "set_ex ezhud_curscale $hud_$ezhud_curelem_scale; set_calc ezhud_curscale $ezhud_curscale * 100; echo $ezhud_curelem size: $ezhud_curscale%"
alias ezhud_echoframe "set_ex ezhud_curframe $hud_$ezhud_curelem_frame; set_calc ezhud_curpframe $ezhud_curframe * 100; if $ezhud_curpframe <= 0 ezhud_echonoframe else if $ezhud_curpframe == 200 echo $ezhud_curelem bordered frame else echo $ezhud_curelem frame: $ezhud_curpframe%%"
alias ezhud_echonoframe "echo $ezhud_curelem frame removed"
alias ezhud_echostyle "set_ex ezhud_curstyle $hud_$ezhud_curelem_style; echo $ezhud_curelem style: $ezhud_curstyle"

alias ezhud_scalecheck "set_ex ezhud_curscale $hud_$ezhud_curelem_scale; if $ezhud_curscale < 0 set hud_$ezhud_curelem_scale 1"
alias ezhud_framecheck "set_ex ezhud_curframe $hud_$ezhud_curelem_frame; if $ezhud_curframe < 0 set hud_$ezhud_curelem_frame 0; if $ezhud_curframe > 1 ezhud_framecheck2"
alias ezhud_framecheck2 "if $ezhud_curframe < 1.5 set hud_$ezhud_curelem_frame 2 else set hud_$ezhud_curelem_frame 1"
alias ezhud_stylecheck "set_ex ezhud_curstyle $hud_$ezhud_curelem_style; if $ezhud_curstyle < 0 set hud_$ezhud_curelem_style 0"

alias ezhud_widthcheck "set_ex ezhud_curwidth $hud_$ezhud_curelem_width; if $ezhud_curwidth < 0 set hud_$ezhud_curelem_width 0"
alias ezhud_heightcheck "set_ex ezhud_curheight $hud_$ezhud_curelem_height; if $ezhud_curheight < 0 set hud_$ezhud_curelem_height 0"

alias ezhud_scaleup "inc hud_$ezhud_curelem_scale 0.1; ezhud_scalecheck; if $ezhud_verbose == 1 ezhud_echoscale"
alias ezhud_scaledown "inc hud_$ezhud_curelem_scale -0.1; ezhud_scalecheck; if $ezhud_verbose == 1 ezhud_echoscale"
alias ezhud_frameup "inc hud_$ezhud_curelem_frame 0.1; ezhud_framecheck; if $ezhud_verbose == 1 ezhud_echoframe"
alias ezhud_framedown "inc hud_$ezhud_curelem_frame -0.1; ezhud_framecheck; if $ezhud_verbose == 1 ezhud_echoframe"
alias ezhud_styleup "inc hud_$ezhud_curelem_style -1; ezhud_stylecheck; if $ezhud_verbose == 1 ezhud_echostyle"
alias ezhud_styledown "inc hud_$ezhud_curelem_style 1; ezhud_stylecheck; if $ezhud_verbose == 1 ezhud_echostyle"

alias ezhud_widthup "inc hud_$ezhud_curelem_width $ezhud_curchange; ezhud_widthcheck"
alias ezhud_widthdown "inc hud_$ezhud_curelem_width -$ezhud_curchange; ezhud_widthcheck"
alias ezhud_heightup "inc hud_$ezhud_curelem_height $ezhud_curchange; ezhud_heightcheck"
alias ezhud_heightdown "inc hud_$ezhud_curelem_height -$ezhud_curchange; ezhud_heightcheck"

alias ezhud_selplace "set ezhud_curelem $ezhud_place_%1; echo $ezhud_curelem selected as a target for alignment"

alias ezhud_place_sel "echo select which element '$ezhud_curelem' should be aligned to with 1-9 or [ & ] keys and press keypad Enter to confirm; set ezhud_align_what $ezhud_curelem"
alias ezhud_place_conf "place $ezhud_align_what $ezhud_curelem; set ezhud_curelem $ezhud_align_what"

alias ezhud_showmore "$ezhud_curelem"

// we will load bindings back and put back all cfg_save_* values
alias ezhud_clearbinds "echo unloading keyboard bindings...; exec configs/_temp_ezhud_binds; wait; set cfg_save_cmds $ezhud_cfg_save_cmds; set cfg_save_cmdline $ezhud_cfg_save_cmdline; set cfg_save_sysinfo $ezhud_cfg_save_sysinfo; set cfg_save_aliases $ezhud_cfg_save_aliases; set cfg_save_userinfo $ezhud_cfg_save_userinfo; set cfg_save_cvars $ezhud_cfg_save_cvars; set cfg_save_binds $ezhud_cfg_save_binds"

alias ezhud_finish "ezhud_clearbinds; unset_re ezhud_.; unalias_re ezhud_.; hud_planmode 0; hud_recalculate; hud_export ezhud_$name; echo your HUD configuration has been saved into ezquake/configs/ezhud_$name.cfg" 


================================================
FILE: misc/cfg/gfx_gl_eyecandy.cfg
================================================
//FPS and EyeCandy Settings
cl_deadbodyFilter            "1"
cl_gibFilter                 "1"
cl_hidenails                 "0"
cl_hiderockets               "0"
cl_model_bobbing             "0"
cl_muzzleflash               "0"
cl_r2g                       "0"
gl_detail                    "0"
gl_simpleitems               "0"
r_drawentities               "1"
r_drawflame                  "1"
r_explosionLight             "0"
r_explosionLightColor        "0"
r_explosionType              "1"
r_flagColor                  "0"
r_grenadeTrail               "12"
r_lerpframes                 "1"
r_lerpmuzzlehack             "1"
r_lgbloodColor               "225"
r_lightflicker               "1"
r_powerupGlow                "1"
r_rocketLight                "0"
r_rocketLightColor           "0"
r_rocketTrail                "3"

//Particle Effects
gl_bounceparticles           "1"
gl_clipparticles             "1"
gl_part_blobs                "0"
gl_part_blood                "1"
gl_part_explosions           "1"
gl_part_gunshots             "1"
gl_part_inferno              "0"
gl_part_lavasplash           "0"
gl_part_spikes               "0"
gl_part_telesplash           "1"
gl_part_trails               "1"
gl_particle_blobs            "0"
gl_particle_blood            "1"
gl_particle_blood_color      "0.001"
gl_particle_blood_type       "0"
gl_particle_deatheffect      "0"
gl_particle_explosions       "0"
gl_particle_fire             "1"
gl_particle_gibtrails        "1"
gl_particle_gunshots         "0"
gl_particle_gunshots_type    "0"
gl_particle_muzzleflash      "0"
gl_particle_shockwaves       "1"
gl_particle_shockwaves_flat  "0"
gl_particle_sparks           "1"
gl_particle_spikes           "0"
gl_particle_spikes_type      "2"
gl_particle_trail_detail     "75"
gl_particle_trail_length     "1"
gl_particle_trail_time       "1"
gl_particle_trail_type       "1"
gl_particle_trail_width      "3"
gl_squareparticles           "0"

//Lighting
gl_coronas                   "0"
gl_coronas_tele              "0"
gl_fb_bmodels                "1"
gl_fb_models                 "1"
gl_flashblend                "1"
gl_lighting_colour           "0"
gl_lighting_vertex           "0"
gl_lightmode                 "2"
gl_loadlitfiles              "1"
gl_shaftlight                "1"
r_dynamic                    "1"
r_fullbright                 "0"
r_shadows                    "0"

//Turbulency and Sky Settings
gl_caustics                  "0"
r_fx_fog                     "0"
r_fx_fog_end                 "800.0"
r_fx_fog_sky                 "1"
r_fx_fog_start               "50.0"
r_fx_fog_density             "1"
gl_surface_lava              "0"
gl_surface_slime             "0"
gl_turb_trails               "0"
gl_turbalpha                 "1"
gl_weather_rain              "0"
gl_weather_rain_fast         "0"
r_fastsky                    "0"
r_fastturb                   "0"
r_lavacolor                  "80 0 0"
r_novis                      "0"
r_skycolor                   "40 80 150"
r_skyname                    ""
r_slimecolor                 "10 60 10"
r_telecolor                  "255 60 60"
r_watercolor                 "10 50 80"

//Weapon View Model Settings
cl_bob                       "0"
cl_bobcycle                  "0.0"
cl_bobup                     "0"
cl_filterdrawviewmodel       "0"
r_drawviewmodel              "1"
r_viewmodelSize              "1"

//Texture Settings
gl_ext_texture_compression   "0"
gl_externalTextures_bmodels  "1"
gl_externalTextures_world    "1"
gl_lerpimages                "1"
gl_lumaTextures              "1"
gl_max_size                  "2048"
gl_miptexLevel               "0"
gl_picmip                    "0"
gl_playermip                 "0"
gl_scaleModelTextures        "0"
gl_scaleTurbTextures         "0"
gl_subdivide_size            "64"
gl_textureless               "0"
gl_texturemode               "gl_linear_mipmap_linear"
r_drawflat                   "0"
r_floorcolor                 "50 100 150"
r_wallcolor                  "255 255 255"

//OpenGL Rendering
gl_buildingsparks            "0"
gl_clear                     "0"
gl_clearColor                "0 0 0"
gl_cutf_tesla_effect         "0"
gl_detpacklights             "0"
gl_extratrails               "0"
gl_finish                    "0"
gl_inferno_speed             "1000"
gl_inferno_trail             "2"
gl_lightning                 "1"
gl_lightning_size            "0.1"
gl_lightning_sparks          "0"
gl_nailtrail                 "1"
gl_nailtrail_plasma          "0"
gl_nailtrail_turb            "0"
gl_smoothmodels              "1"
gl_triplebuffer              "1"
r_farclip                    "8192"
gl_colorlights               "1"

//Screen & Powerup Blends
cl_bonusflash                "0"
gl_cshiftpercent             "0"
gl_polyblend                 "1"
gl_powerupshells             "1"
v_contentblend               "0"
v_damagecshift               "1"
v_dlightcshift               "0"
v_pentcshift                 "0"
v_quadcshift                 "0"
v_ringcshift                 "0"
v_suitcshift                 "0"

//View Settings
cl_rollangle                 "1.0"
cl_rollspeed                 "250"
v_centermove                 "0.15"
v_centerspeed                "500"
v_gunkick                    "0"
v_idlescale                  "0"
v_ipitch_cycle               "1"
v_ipitch_level               "0.3"
v_iroll_cycle                "0.5"
v_iroll_level                "0.1"
v_iyaw_cycle                 "2"
v_iyaw_level                 "0.3"
v_kickpitch                  "0.01"
v_kickroll                   "0.01"
v_kicktime                   "0.05"
v_viewheight                 "0"


================================================
FILE: misc/cfg/gfx_gl_faithful.cfg
================================================
//FPS and EyeCandy Settings
cl_deadbodyFilter            "1"
cl_gibFilter                 "1"
cl_hidenails                 "0"
cl_hiderockets               "0"
cl_model_bobbing             "0"
cl_muzzleflash               "1"
cl_r2g                       "0"
gl_detail                    "0"
gl_simpleitems               "0"
r_drawentities               "1"
r_drawflame                  "1"
r_explosionLight             "1"
r_explosionLightColor        "0"
r_explosionType              "1"
r_flagColor                  "0"
r_grenadeTrail               "1"
r_lerpframes                 "1"
r_lerpmuzzlehack             "1"
r_lgbloodColor               "225"
r_lightflicker               "1"
r_powerupGlow                "1"
r_rocketLight                "1"
r_rocketLightColor           "0"
r_rocketTrail                "1"

//Particle Effects
gl_bounceparticles           "0"
gl_clipparticles             "0"
gl_part_blobs                "0"
gl_part_blood                "0"
gl_part_explosions           "0"
gl_part_gunshots             "0"
gl_part_inferno              "0"
gl_part_lavasplash           "0"
gl_part_spikes               "0"
gl_part_telesplash           "0"
gl_part_trails               "0"
gl_particle_blobs            "0"
gl_particle_blood            "0"
gl_particle_blood_color      "0"
gl_particle_blood_type       "0"
gl_particle_deatheffect      "0"
gl_particle_explosions       "0"
gl_particle_fire             "0"
gl_particle_gibtrails        "0"
gl_particle_gunshots         "0"
gl_particle_gunshots_type    "0"
gl_particle_muzzleflash      "0"
gl_particle_shockwaves       "0"
gl_particle_shockwaves_flat  "0"
gl_particle_sparks           "0"
gl_particle_spikes           "0"
gl_particle_spikes_type      "0"
gl_particle_trail_detail     "0"
gl_particle_trail_length     "0"
gl_particle_trail_time       "0"
gl_particle_trail_type       "0"
gl_particle_trail_width      "0"
gl_squareparticles           "1"

//Lighting
gl_coronas                   "0"
gl_coronas_tele              "0"
gl_fb_bmodels                "1"
gl_fb_models                 "1"
gl_flashblend                "0"
gl_lighting_colour           "1"
gl_lighting_vertex           "0"
gl_lightmode                 "2"
gl_loadlitfiles              "0"
gl_shaftlight                "1"
r_dynamic                    "1"
r_fullbright                 "0"
r_shadows                    "0"

//Turbulency and Sky Settings
gl_caustics                  "1"
r_fx_fog                     "0"
r_fx_fog_end                 "0"
r_fx_fog_sky                 "1"
r_fx_fog_start               "0"
r_fx_fog_density             "0"
gl_surface_lava              "0"
gl_surface_slime             "0"
gl_turb_trails               "0"
gl_turbalpha                 "1"
gl_weather_rain              "0"
gl_weather_rain_fast         "0"
r_fastsky                    "0"
r_fastturb                   "0"
r_lavacolor                  "80 0 0"
r_novis                      "0"
r_skycolor                   "40 80 150"
r_skyname                    ""
r_slimecolor                 "10 60 10"
r_telecolor                  "255 60 60"
r_watercolor                 "50 80 120"

//Weapon View Model Settings
cl_bob                       "0"
cl_bobcycle                  "0.0"
cl_bobup                     "0"
cl_filterdrawviewmodel       "0"
r_drawviewmodel              "1"
r_viewmodelSize              "1"

//Texture Settings
gl_ext_texture_compression   "0"
gl_externalTextures_bmodels  "1"
gl_externalTextures_world    "1"
gl_lerpimages                "1"
gl_lumaTextures              "1"
gl_max_size                  "2048"
gl_miptexLevel               "0"
gl_picmip                    "0"
gl_playermip                 "0"
gl_scaleModelTextures        "0"
gl_scaleTurbTextures         "1"
gl_subdivide_size            "64"
gl_textureless               "0"
gl_texturemode               "gl_linear_mipmap_nearest"
r_drawflat                   "0"
r_floorcolor                 "100 20 30"
r_wallcolor                  "192 100 20"

//OpenGL Rendering
gl_buildingsparks            "0"
gl_clear                     "0"
gl_clearColor                "0 0 0"
gl_cutf_tesla_effect         "0"
gl_detpacklights             "0"
gl_extratrails               "0"
gl_finish                    "0"
gl_inferno_speed             "0"
gl_inferno_trail             "0"
gl_lightning                 "0"
gl_lightning_size            "0"
gl_lightning_sparks          "0"
gl_nailtrail                 "0"
gl_nailtrail_plasma          "0"
gl_nailtrail_turb            "0"
gl_smoothmodels              "1"
gl_triplebuffer              "1"
r_farclip                    "4096"
gl_colorlights               "0"

//Screen & Powerup Blends
cl_bonusflash                "0"
gl_cshiftpercent             "100"
gl_polyblend                 "0"
gl_powerupshells             "0"
v_contentblend               "0.33"
v_damagecshift               "1"
v_dlightcshift               "1"
v_pentcshift                 "1"
v_quadcshift                 "1"
v_ringcshift                 "1"
v_suitcshift                 "1"

//View Settings
cl_rollangle                 "2.0"
cl_rollspeed                 "200"
v_centermove                 "0.15"
v_centerspeed                "500"
v_gunkick                    "0"
v_idlescale                  "0"
v_ipitch_cycle               "1"
v_ipitch_level               "0.3"
v_iroll_cycle                "0.5"
v_iroll_level                "0.1"
v_iyaw_cycle                 "2"
v_iyaw_level                 "0.3"
v_kickpitch                  "0.0"
v_kickroll                   "0.0"
v_kicktime                   "0.0"
v_viewheight                 "0"


================================================
FILE: misc/cfg/gfx_gl_fast.cfg
================================================
//FPS and EyeCandy Settings
cl_deadbodyFilter            "2"
cl_gibFilter                 "1"
cl_hidenails                 "0"
cl_hiderockets               "0"
cl_model_bobbing             "0"
cl_muzzleflash               "0"
cl_r2g                       "1"
gl_detail                    "0"
gl_simpleitems               "1"
r_drawentities               "1"
r_drawflame                  "0"
r_explosionLight             "0"
r_explosionLightColor        "0"
r_explosionType              "4"
r_flagColor                  "0"
r_grenadeTrail               "0"
r_lerpframes                 "1"
r_lerpmuzzlehack             "0"
r_lgbloodColor               "225"
r_lightflicker               "0"
r_powerupGlow                "0"
r_rocketLight                "0"
r_rocketLightColor           "0"
r_rocketTrail                "0"

//Particle Effects
gl_bounceparticles           "0"
gl_clipparticles             "0"
gl_part_blobs                "0"
gl_part_blood                "0"
gl_part_explosions           "0"
gl_part_gunshots             "0"
gl_part_inferno              "0"
gl_part_lavasplash           "0"
gl_part_spikes               "0"
gl_part_telesplash           "0"
gl_part_trails               "0"
gl_particle_blobs            "0"
gl_particle_blood            "0"
gl_particle_blood_color      "0"
gl_particle_blood_type       "0"
gl_particle_deatheffect      "0"
gl_particle_explosions       "0"
gl_particle_fire             "0"
gl_particle_gibtrails        "0"
gl_particle_gunshots         "0"
gl_particle_gunshots_type    "0"
gl_particle_muzzleflash      "0"
gl_particle_shockwaves       "0"
gl_particle_shockwaves_flat  "0"
gl_particle_sparks           "0"
gl_particle_spikes           "0"
gl_particle_spikes_type      "0"
gl_particle_trail_detail     "0"
gl_particle_trail_length     "0"
gl_particle_trail_time       "0"
gl_particle_trail_type       "0"
gl_particle_trail_width      "0"
gl_squareparticles           "1"

//Lighting
gl_coronas                   "0"
gl_coronas_tele              "0"
gl_fb_bmodels                "1"
gl_fb_models                 "1"
gl_flashblend                "0"
gl_lighting_colour           "0"
gl_lighting_vertex           "0"
gl_lightmode                 "2"
gl_loadlitfiles              "0"
gl_shaftlight                "0"
r_dynamic                    "0"
r_fullbright                 "0"
r_shadows                    "0"

//Turbulency and Sky Settings
gl_caustics                  "0"
r_fx_fog                     "0"
r_fx_fog_end                 "0"
r_fx_fog_sky                 "1"
r_fx_fog_start               "0"
r_fx_fog_density             "0"
gl_surface_lava              "0"
gl_surface_slime             "0"
gl_turb_trails               "0"
gl_turbalpha                 "1"
gl_weather_rain              "0"
gl_weather_rain_fast         "0"
r_fastsky                    "1"
r_fastturb                   "1"
r_lavacolor                  "80 0 0"
r_novis                      "0"
r_skycolor                   "40 80 150"
r_skyname                    ""
r_slimecolor                 "10 60 10"
r_telecolor                  "255 60 60"
r_watercolor                 "20 50 120"

//Weapon View Model Settings
cl_bob                       "0.0"
cl_bobcycle                  "0.0"
cl_bobup                     "0.0"
cl_filterdrawviewmodel       "0"
r_drawviewmodel              "0"
r_viewmodelSize              "0.3"

//Texture Settings
gl_ext_texture_compression   "0"
gl_externaltextures_bmodels  "0"
gl_externaltextures_world    "0"
gl_lerpimages                "0"
gl_lumaTextures              "0"
gl_max_size                  "2048"
gl_miptexLevel               "3"
gl_picmip                    "5"
gl_playermip                 "5"
gl_scaleModelTextures        "0"
gl_scaleTurbTextures         "1"
gl_subdivide_size            "512"
gl_textureless               "0"
gl_texturemode               "gl_nearest"
r_drawflat                   "1"
r_floorcolor                 "100 20 30"
r_wallcolor                  "192 100 20"

//OpenGL Rendering
gl_buildingsparks            "0"
gl_clear                     "0"
gl_clearColor                "0 0 0"
gl_cutf_tesla_effect         "0"
gl_detpacklights             "0"
gl_extratrails               "0"
gl_finish                    "0"
gl_inferno_speed             "0"
gl_inferno_trail             "0"
gl_lightning                 "0"
gl_lightning_size            "0"
gl_lightning_sparks          "0"
gl_nailtrail                 "0"
gl_nailtrail_plasma          "0"
gl_nailtrail_turb            "0"
gl_smoothmodels              "0"
gl_triplebuffer              "0"
r_farclip                    "4096"
gl_colorlights               "0"

//Screen & Powerup Blends
cl_bonusflash                "0"
gl_cshiftpercent             "100"
gl_polyblend                 "0"
gl_powerupshells             "0"
v_contentblend               "0"
v_damagecshift               "0"
v_dlightcshift               "1"
v_pentcshift                 "1"
v_quadcshift                 "1"
v_ringcshift                 "1"
v_suitcshift                 "1"

//View Settings
cl_rollangle                 "0"
cl_rollspeed                 "200"
v_centermove                 "0.15"
v_centerspeed                "500"
v_gunkick                    "0"
v_idlescale                  "0"
v_ipitch_cycle               "1"
v_ipitch_level               "0.3"
v_iroll_cycle                "0.5"
v_iroll_level                "0.1"
v_iyaw_cycle                 "2"
v_iyaw_level                 "0.3"
v_kickpitch                  "0"
v_kickroll                   "0"
v_kicktime                   "0"
v_viewheight                 "0"


================================================
FILE: misc/cfg/gfx_gl_higheyecandy.cfg
================================================
//FPS and EyeCandy Settings
cl_deadbodyFilter            "0"
cl_gibFilter                 "0"
cl_hidenails                 "0"
cl_hiderockets               "0"
cl_model_bobbing             "1"
cl_muzzleflash               "1"
cl_r2g                       "0"
gl_detail                    "0"
gl_simpleitems               "0"
r_drawentities               "1"
r_drawflame                  "1"
r_explosionLight             "1"
r_explosionLightColor        "0"
r_explosionType              "7"
r_flagColor                  "0"
r_grenadeTrail               "3"
r_lerpframes                 "1"
r_lerpmuzzlehack             "1"
r_lgbloodColor               "225"
r_lightflicker               "1"
r_powerupGlow                "1"
r_rocketLight                "1"
r_rocketLightColor           "0"
r_rocketTrail                "1"

//Particle Effects
gl_bounceparticles           "1"
gl_clipparticles             "1"
gl_part_blobs                "1"
gl_part_blood                "1"
gl_part_explosions           "1"
gl_part_gunshots             "1"
gl_part_inferno              "1"
gl_part_lavasplash           "1"
gl_part_spikes               "1"
gl_part_telesplash           "1"
gl_part_trails               "1"
gl_particle_blobs            "0.1"
gl_particle_blood            "1"
gl_particle_blood_color      "1"
gl_particle_blood_type       "1"
gl_particle_deatheffect      "1"
gl_particle_explosions       "0"
gl_particle_fire             "1"
gl_particle_gibtrails        "1"
gl_particle_gunshots         "0"
gl_particle_gunshots_type    "1"
gl_particle_muzzleflash      "0"
gl_particle_shockwaves       "1"
gl_particle_shockwaves_flat  "0"
gl_particle_sparks           "1"
gl_particle_spikes           "0.1"
gl_particle_spikes_type      "1"
gl_particle_trail_detail     "100"
gl_particle_trail_length     "1"
gl_particle_trail_time       "1"
gl_particle_trail_type       "1"
gl_particle_trail_width      "3"
gl_squareparticles           "0"

//Lighting
gl_coronas                   "1"
gl_coronas_tele              "0"
gl_fb_bmodels                "1"
gl_fb_models                 "1"
gl_flashblend                "0"
gl_lighting_colour           "1"
gl_lighting_vertex           "1"
gl_lightmode                 "2"
gl_loadlitfiles              "1"
gl_shaftlight                "1"
r_dynamic                    "1"
r_fullbright                 "0"
r_shadows                    "0"

//Turbulency and Sky Settings
gl_caustics                  "1"
r_fx_fog                     "0"
r_fx_fog_end                 "800.0"
r_fx_fog_sky                 "1"
r_fx_fog_start               "50.0"
r_fx_fog_density             "1"
gl_surface_lava              "0"
gl_surface_slime             "0"
gl_turb_trails               "1"
gl_turbalpha                 "1"
gl_weather_rain              "0"
gl_weather_rain_fast         "0"
r_fastsky                    "0"
r_fastturb                   "0"
r_lavacolor                  "80 0 0"
r_novis                      "0"
r_skycolor                   "40 80 150"
r_skyname                    ""
r_slimecolor                 "10 60 10"
r_telecolor                  "255 60 60"
r_watercolor                 "50 80 120"

//Weapon View Model Settings
cl_bob                       "0"
cl_bobcycle                  "0.0"
cl_bobup                     "0"
cl_filterdrawviewmodel       "0"
r_drawviewmodel              "1"
r_viewmodelSize              "1"

//Texture Settings
gl_ext_texture_compression   "0"
gl_externalTextures_bmodels  "1"
gl_externalTextures_world    "1"
gl_lerpimages                "1"
gl_lumaTextures              "1"
gl_max_size                  "2048"
gl_miptexLevel               "0"
gl_picmip                    "0"
gl_playermip                 "0"
gl_scaleModelTextures        "0"
gl_scaleTurbTextures         "1"
gl_subdivide_size            "64"
gl_textureless               "0"
gl_texturemode               "gl_linear_mipmap_nearest"
r_drawflat                   "0"
r_floorcolor                 "100 20 30"
r_wallcolor                  "192 100 20"

//OpenGL Rendering
gl_buildingsparks            "1"
gl_clear                     "0"
gl_clearColor                "0 0 0"
gl_cutf_tesla_effect         "1"
gl_detpacklights             "1"
gl_extratrails               "1"
gl_finish                    "0"
gl_inferno_speed             "1000"
gl_inferno_trail             "2"
gl_lightning                 "1"
gl_lightning_size            "3"
gl_lightning_sparks          "0.4"
gl_nailtrail                 "1"
gl_nailtrail_plasma          "0"
gl_nailtrail_turb            "0"
gl_smoothmodels              "1"
gl_triplebuffer              "1"
r_farclip                    "8192"
gl_colorlights               "1"

//Screen & Powerup Blends
cl_bonusflash                "0"
gl_cshiftpercent             "100"
gl_polyblend                 "0"
gl_powerupshells             "1"
v_contentblend               "1"
v_damagecshift               "1"
v_dlightcshift               "1"
v_pentcshift                 "1"
v_quadcshift                 "1"
v_ringcshift                 "1"
v_suitcshift                 "1"

//View Settings
cl_rollangle                 "2.0"
cl_rollspeed                 "200"
v_centermove                 "0.15"
v_centerspeed                "500"
v_gunkick                    "0"
v_idlescale                  "0"
v_ipitch_cycle               "1"
v_ipitch_level               "0.3"
v_iroll_cycle                "0.5"
v_iroll_level                "0.1"
v_iyaw_cycle                 "2"
v_iyaw_level                 "0.3"
v_kickpitch                  "0"
v_kickroll                   "0"
v_kicktime                   "0"
v_viewheight                 "0"


================================================
FILE: misc/cfg/gfx_sw_default.cfg
================================================
//FPS and EyeCandy Settings
cl_deadbodyFilter            "0"
cl_gibFilter                 "0"
cl_maxfps                    "0"
cl_model_bobbing             "1"
cl_muzzleflash               "1"
cl_nolerp                    "0"
cl_physfps                   "0"
cl_r2g                       "0"
cl_trueLightning             "0"
r_drawentities               "1"
r_drawflame                  "1"
r_explosionLight             "1"
r_explosionLightColor        "0"
r_explosionType              "7"
r_flagColor                  "0"
r_grenadeTrail               "3"
r_lerpframes                 "1"
r_lerpmuzzlehack             "1"
r_lgbloodColor               "225"
r_lightflicker               "1"
r_powerupGlow                "1"
r_rocketLight                "1"
r_rocketLightColor           "0"
r_rocketTrail                "9"

//Lighting
r_ambient                    "0"
r_fullbright                 "0"

//Turbulency and Sky Settings
r_fastsky                    "0"
r_fastturb                   "0"
r_lavacolor                  "73"
r_skycolor                   "172"
r_slimecolor                 "53"
r_telecolor                  "26"
r_turbwarp                   "1"
r_watercolor                 "36"

//Weapon View Model Settings
cl_bob                       "0.02"
cl_bobcycle                  "0.6"
cl_bobup                     "0.5"
cl_filterdrawviewmodel       "0"
r_drawviewmodel              "1"
r_viewmodelSize              "1"

//Texture Settings
d_mipcap                     "0"
d_mipscale                   "1"
d_subdiv16                   "1"
r_drawflat                   "0"
r_floorcolor                 "100 20 30"
r_max_size_1                 "0"
r_wallcolor                  "192 100 20"

//Software Rendering
cl_multiview                 "0"
cl_mvdisplayhud              "1"
cl_mvinset                   "0"
cl_mvinsetcrosshair          "1"
cl_mvinsethud                "1"
r_aliastransadj              "100"
r_aliastransbase             "200"
r_clearcolor                 "2"
r_draworder                  "0"
r_dspeeds                    "0"
r_graphheight                "15"
r_maxedges                   "0"
r_maxsurfs                   "0"
r_numedges                   "0"
r_numsurfs                   "0"
r_polymodelstats             "0"
r_reportedgeout              "0"
r_reportsurfout              "0"
r_speeds                     "0"
r_timegraph                  "0"
r_zgraph                     "0"

//Screen & Powerup Blends
cl_bonusflash                "0"
v_contentblend               "1"
v_damagecshift               "1"
v_pentcshift                 "1"
v_quadcshift                 "1"
v_ringcshift                 "1"
v_suitcshift                 "1"

//View Settings
cl_rollangle                 "2.0"
cl_rollspeed                 "200"
default_fov                  "0"
fov                          "90"
v_centermove                 "0.15"
v_centerspeed                "500"
v_gunkick                    "0"
v_idlescale                  "0"
v_ipitch_cycle               "1"
v_ipitch_level               "0.3"
v_iroll_cycle                "0.5"
v_iroll_level                "0.1"
v_iyaw_cycle                 "2"
v_iyaw_level                 "0.3"
v_kickpitch                  "0.6"
v_kickroll                   "0.6"
v_kicktime                   "0.5"
v_viewheight                 "0"
viewsize                     "100"


================================================
FILE: misc/cfg/gfx_sw_fast.cfg
================================================
//FPS and EyeCandy Settings
cl_deadbodyFilter            "2"
cl_gibFilter                 "1"
cl_maxfps                    "0"
cl_model_bobbing             "0"
cl_muzzleflash               "0"
cl_nolerp                    "0"
cl_physfps                   "0"
cl_r2g                       "1"
cl_trueLightning             "0"
r_drawentities               "1"
r_drawflame                  "0"
r_explosionLight             "0"
r_explosionLightColor        "0"
r_explosionType              "4"
r_flagColor                  "0"
r_grenadeTrail               "0"
r_lerpframes                 "1"
r_lerpmuzzlehack             "0"
r_lightflicker               "0"
r_lgbloodColor               "225"
r_powerupGlow                "0"
r_rocketLight                "0"
r_rocketLightColor           "0"
r_rocketTrail                "0"

//Lighting
r_ambient                    "0"
r_fullbright                 "0"

//Turbulency and Sky Settings
r_fastsky                    "1"
r_fastturb                   "1"
r_lavacolor                  "73"
r_skycolor                   "172"
r_slimecolor                 "53"
r_telecolor                  "26"
r_turbwarp                   "0"
r_watercolor                 "36"

//Weapon View Model Settings
cl_bob                       "0"
cl_bobcycle                  "0"
cl_bobup                     "0"
cl_filterdrawviewmodel       "0"
r_drawviewmodel              "0"
r_viewmodelSize              "0.3"

//Texture Settings
d_mipcap                     "5"
d_mipscale                   "5"
d_subdiv16                   "1"
r_drawflat                   "1"
r_floorcolor                 "100 20 30"
r_max_size_1                 "1"
r_wallcolor                  "192 100 20"

//Software Rendering
r_aliastransadj              "100"
r_aliastransbase             "200"
r_clearcolor                 "2"
r_draworder                  "0"
r_dspeeds                    "0"
r_graphheight                "15"
r_maxedges                   "0"
r_maxsurfs                   "0"
r_numedges                   "0"
r_numsurfs                   "0"
r_polymodelstats             "0"
r_reportedgeout              "0"
r_reportsurfout              "0"
r_speeds                     "0"
r_timegraph                  "0"
r_zgraph                     "0"

//Screen Settings
sw_contrast                  "1"
sw_gamma                     "1"

//Screen & Powerup Blends
cl_bonusflash                "0"
v_contentblend               "1"
v_damagecshift               "1"
v_pentcshift                 "1"
v_quadcshift                 "1"
v_ringcshift                 "1"
v_suitcshift                 "1"

//View Settings
cl_rollangle                 "0"
cl_rollspeed                 "0"
v_centermove                 "0.15"
v_centerspeed                "500"
v_gunkick                    "0"
v_idlescale                  "0"
v_ipitch_cycle               "1"
v_ipitch_level               "0.3"
v_iroll_cycle                "0.5"
v_iroll_level                "0.1"
v_iyaw_cycle                 "2"
v_iyaw_level                 "0.3"
v_kickpitch                  "0"
v_kickroll                   "0"
v_kicktime                   "0"
v_viewheight                 "0"
viewsize                     "110"


================================================
FILE: misc/cfg/how_to_use_these_files.txt
================================================
Configuration files (configs) stored in this folder contain variety
of scripts and settings of features.

You can execute these configs by typing e.g. "/exec cfg/movement.cfg"
into the console.

Configuration file movement.cfg contains some basic movement and weapons
keyboard binds, basic commands like ready/break and player tracking on numpad,
very basic screen setup and Qizmo proxy navigation keyboard binds. 
Configuration files teamplay.cfg and eq260.cfg contain keyboard binds for
teamplay communication messages.

Configs with the name starting with 'hud_*' are Head Up Display configuration
files. Some of them require specific 'conwidth' and 'conheight' settings (see
ezStart utility).


Advanced
---
Configuration file teamtime.cfg contains script that helps you time items
through teamplay messages with your teammates.

Configs with the name starting with 'gfx_*' are used by the game engine when
you choose different values for "Graphics settings" option in the Options menu.
Usually you don't care much what is in those files and you don't need to
customize them but you might wish to change something in them so the menu option
suits your needs.


================================================
FILE: misc/cfg/hud_aas.cfg
================================================
//
// Head Up Display Configuration Dump
//

scr_newhud                    "1"
hud_ammo1_align               "right"
hud_ammo1_align_x             "center"
hud_ammo1_align_y             "bottom"
hud_ammo1_digits              "3"
hud_ammo1_frame               "0"
hud_ammo1_frame_color         "0 0 0"
hud_ammo1_item_opacity        "0.99"
hud_ammo1_order               "5"
hud_ammo1_place               "group2"
hud_ammo1_pos_x               "0"
hud_ammo1_pos_y               "-2"
hud_ammo1_scale               "0.7"
hud_ammo1_show                "1"
hud_ammo1_style               "0"
hud_ammo2_align               "right"
hud_ammo2_align_x             "center"
hud_ammo2_align_y             "bottom"
hud_ammo2_digits              "3"
hud_ammo2_frame               "0"
hud_ammo2_frame_color         "0 0 0"
hud_ammo2_item_opacity        "0.99"
hud_ammo2_order               "6"
hud_ammo2_place               "group3"
hud_ammo2_pos_x               "0"
hud_ammo2_pos_y               "-2"
hud_ammo2_scale               "0.7"
hud_ammo2_show                "1"
hud_ammo2_style               "0"
hud_ammo3_align               "right"
hud_ammo3_align_x             "center"
hud_ammo3_align_y             "bottom"
hud_ammo3_digits              "3"
hud_ammo3_frame               "0"
hud_ammo3_frame_color         "0 0 0"
hud_ammo3_item_opacity        "0.99"
hud_ammo3_order               "7"
hud_ammo3_place               "group4"
hud_ammo3_pos_x               "0"
hud_ammo3_pos_y               "-2"
hud_ammo3_scale               "0.7"
hud_ammo3_show                "1"
hud_ammo3_style               "0"
hud_ammo4_align               "right"
hud_ammo4_align_x             "center"
hud_ammo4_align_y             "bottom"
hud_ammo4_digits              "3"
hud_ammo4_frame               "0"
hud_ammo4_frame_color         "0 0 0"
hud_ammo4_item_opacity        "0.99"
hud_ammo4_order               "8"
hud_ammo4_place               "group5"
hud_ammo4_pos_x               "0"
hud_ammo4_pos_y               "-2"
hud_ammo4_scale               "0.7"
hud_ammo4_show                "1"
hud_ammo4_style               "0"
hud_ammo_align                "right"
hud_ammo_align_x              "after"
hud_ammo_align_y              "center"
hud_ammo_digits               "3"
hud_ammo_frame                "0"
hud_ammo_frame_color          "0 0 0"
hud_ammo_item_opacity         "1.0"
hud_ammo_order                "1313"
hud_ammo_place                "health"
hud_ammo_pos_x                "32"
hud_ammo_pos_y                "0"
hud_ammo_scale                "1"
hud_ammo_show                 "0"
hud_ammo_style                "0"
hud_armor_align               "right"
hud_armor_align_x             "after"
hud_armor_align_y             "center"
hud_armor_digits              "3"
hud_armor_frame               "0"
hud_armor_frame_color         "0 0 0"
hud_armor_item_opacity        "0.99"
hud_armor_order               "2282"
hud_armor_pent_666            "0"
hud_armor_place               "iarmor"
hud_armor_pos_x               "0"
hud_armor_pos_y               "0"
hud_armor_scale               "1"
hud_armor_show                "1"
hud_armor_style               "0"
hud_armordamage_align         "left"
hud_armordamage_align_x       "center"
hud_armordamage_align_y       "after"
hud_armordamage_digits        "3"
hud_armordamage_duration      "1.2"
hud_armordamage_frame         "0.2"
hud_armordamage_frame_color   "0 0 50"
hud_armordamage_item_opacity  "0.5"
hud_armordamage_order         "2223"
hud_armordamage_place         "healthdamage"
hud_armordamage_pos_x         "0"
hud_armordamage_pos_y         "0"
hud_armordamage_scale         "2"
hud_armordamage_show          "1"
hud_armordamage_style         "1"
hud_clock_align_x             "right"
hud_clock_align_y             "after"
hud_clock_big                 "0"
hud_clock_blink               "0"
hud_clock_format              "0"
hud_clock_frame               "0"
hud_clock_frame_color         "0 0 0"
hud_clock_item_opacity        "1.0"
hud_clock_order               "12"
hud_clock_place               "fps"
hud_clock_pos_x               "0"
hud_clock_pos_y               "2"
hud_clock_scale               "1"
hud_clock_show                "1"
hud_clock_style               "1"
hud_democlock_align_x         "right"
hud_democlock_align_y         "after"
hud_democlock_big             "0"
hud_democlock_blink           "0"
hud_democlock_frame           "0"
hud_democlock_frame_color     "0 0 0"
hud_democlock_item_opacity    "1.0"
hud_democlock_order           "1315"
hud_democlock_place           "tracking"
hud_democlock_pos_x           "0"
hud_democlock_pos_y           "0"
hud_democlock_scale           "1"
hud_democlock_show            "1"
hud_democlock_style           "3"
hud_digits_trim               "1"
hud_editor_allowalign         "0"
hud_editor_allowmove          "0"
hud_editor_allowplace         "0"
hud_editor_allowresize        "0"
hud_face_align_x              "before"
hud_face_align_y              "center"
hud_face_frame                "0"
hud_face_frame_color          "0 0 0"
hud_face_item_opacity         "1.0"
hud_face_order                "1313"
hud_face_place                "health"
hud_face_pos_x                "0"
hud_face_pos_y                "0"
hud_face_scale                "1"
hud_face_show                 "1"
hud_fps_align_x               "right"
hud_fps_align_y               "after"
hud_fps_decimals              "0"
hud_fps_frame                 "0"
hud_fps_frame_color           "0 0 0"
hud_fps_item_opacity          "1.0"
hud_fps_order                 "11"
hud_fps_place                 "ping"
hud_fps_pos_x                 "0"
hud_fps_pos_y                 "2"
hud_fps_show                  "1"
hud_fps_show_min              "0"
hud_fps_style                 "1"
hud_fps_title                 "1"
hud_frags_align_x             "right"
hud_frags_align_y             "bottom"
hud_frags_bignum              "0"
hud_frags_cell_height         "8"
hud_frags_cell_width          "32"
hud_frags_colors_alpha        "1.0"
hud_frags_cols                "4"
hud_frags_extra_spec_info     "ALL"
hud_frags_fliptext            "0"
hud_frags_frame               "0"
hud_frags_frame_color         "0 0 0"
hud_frags_item_opacity        "1.0"
hud_frags_maxname             "16"
hud_frags_order               "0"
hud_frags_padtext             "1"
hud_frags_place               "top"
hud_frags_pos_x               "0"
hud_frags_pos_y               "0"
hud_frags_rows                "1"
hud_frags_show                "0"
hud_frags_shownames           "0"
hud_frags_showself_always     "1"
hud_frags_showteams           "0"
hud_frags_space_x             "1"
hud_frags_space_y             "1"
hud_frags_strip               "1"
hud_frags_style               "0"
hud_frags_teamsort            "0"
hud_frags_vertical            "0"
hud_gameclock_align_x         "center"
hud_gameclock_align_y         "before"
hud_gameclock_big             "1"
hud_gameclock_blink           "0"
hud_gameclock_countdown       "0"
hud_gameclock_frame           "0.1"
hud_gameclock_frame_color     "0 0 0"
hud_gameclock_item_opacity    "0.99"
hud_gameclock_offset          "0"
hud_gameclock_order           "10"
hud_gameclock_place           "teamfrags"
hud_gameclock_pos_x           "0"
hud_gameclock_pos_y           "-2"
hud_gameclock_scale           "1"
hud_gameclock_show            "1"
hud_gameclock_style           "0"
hud_group1_align_x            "center"
hud_group1_align_y            "bottom"
hud_group1_frame              "0.25"
hud_group1_frame_color        "0 0 0"
hud_group1_height             "32"
hud_group1_item_opacity       "1.0"
hud_group1_name               "group1"
hud_group1_order              "0"
hud_group1_pic_alpha          "0.5"
hud_group1_pic_scalemode      "2"
hud_group1_picture            ""
hud_group1_place              "screen"
hud_group1_pos_x              "0"
hud_group1_pos_y              "2"
hud_group1_show               "1"
hud_group1_width              "220"
hud_group2_align_x            "before"
hud_group2_align_y            "center"
hud_group2_frame              "0.25"
hud_group2_frame_color        "0 0 0"
hud_group2_height             "32"
hud_group2_item_opacity       "1.0"
hud_group2_name               "group2"
hud_group2_order              "2"
hud_group2_pic_alpha          "0.5"
hud_group2_pic_scalemode      "2"
hud_group2_picture            ""
hud_group2_place              "group3"
hud_group2_pos_x              "-5"
hud_group2_pos_y              "0"
hud_group2_show               "1"
hud_group2_width              "50"
hud_group3_align_x            "center"
hud_group3_align_y            "before"
hud_group3_frame              "0.25"
hud_group3_frame_color        "0 0 0"
hud_group3_height             "32"
hud_group3_item_opacity       "1"
hud_group3_name               "group3"
hud_group3_order              "1"
hud_group3_pic_alpha          "0.5"
hud_group3_pic_scalemode      "2"
hud_group3_picture            ""
hud_group3_place              "group1"
hud_group3_pos_x              "-30"
hud_group3_pos_y              "-4"
hud_group3_show               "1"
hud_group3_width              "50"
hud_group4_align_x            "center"
hud_group4_align_y            "before"
hud_group4_frame              "0.25"
hud_group4_frame_color        "0 0 0"
hud_group4_height             "32"
hud_group4_item_opacity       "1.0"
hud_group4_name               "group4"
hud_group4_order              "2"
hud_group4_pic_alpha          "0.5"
hud_group4_pic_scalemode      "2"
hud_group4_picture            ""
hud_group4_place              "group1"
hud_group4_pos_x              "30"
hud_group4_pos_y              "-4"
hud_group4_show               "1"
hud_group4_width              "50"
hud_group5_align_x            "after"
hud_group5_align_y            "center"
hud_group5_frame              "0.25"
hud_group5_frame_color        "0 0 0"
hud_group5_height             "32"
hud_group5_item_opacity       "1.0"
hud_group5_name               "group5"
hud_group5_order              "3"
hud_group5_pic_alpha          "0.5"
hud_group5_pic_scalemode      "2"
hud_group5_picture            ""
hud_group5_place              "group4"
hud_group5_pos_x              "5"
hud_group5_pos_y              "0"
hud_group5_show               "1"
hud_group5_width              "50"
hud_group6_align_x            "right"
hud_group6_align_y            "bottom"
hud_group6_frame              "0"
hud_group6_frame_color        "0 0 0"
hud_group6_height             "32"
hud_group6_item_opacity       "1.0"
hud_group6_name               "group6"
hud_group6_order              "1"
hud_group6_pic_alpha          "0.5"
hud_group6_pic_scalemode      "2"
hud_group6_picture            ""
hud_group6_place              "screen"
hud_group6_pos_x              "0"
hud_group6_pos_y              "0"
hud_group6_show               "1"
hud_group6_width              "88"
hud_group7_align_x            "center"
hud_group7_align_y            "center"
hud_group7_frame              "0.5"
hud_group7_frame_color        "255 0 0"
hud_group7_height             "384"
hud_group7_item_opacity       "1.0"
hud_group7_name               "group7"
hud_group7_order              "0"
hud_group7_pic_alpha          "1.0"
hud_group7_pic_scalemode      "0"
hud_group7_picture            ""
hud_group7_place              "screen"
hud_group7_pos_x              "1"
hud_group7_pos_y              "0"
hud_group7_show               "0"
hud_group7_width              "1"
hud_group8_align_x            "center"
hud_group8_align_y            "bottom"
hud_group8_frame              ".5"
hud_group8_frame_color        "0 0 0"
hud_group8_height             "64"
hud_group8_item_opacity       "1.0"
hud_group8_name               "group8"
hud_group8_order              "0"
hud_group8_pic_alpha          "1.0"
hud_group8_pic_scalemode      "0"
hud_group8_picture            ""
hud_group8_place              "screen"
hud_group8_pos_x              "0"
hud_group8_pos_y              "0"
hud_group8_show               "0"
hud_group8_width              "64"
hud_group9_align_x            "right"
hud_group9_align_y            "bottom"
hud_group9_frame              ".5"
hud_group9_frame_color        "0 0 0"
hud_group9_height             "64"
hud_group9_item_opacity       "1.0"
hud_group9_name               "group9"
hud_group9_order              "0"
hud_group9_pic_alpha          "1.0"
hud_group9_pic_scalemode      "0"
hud_group9_picture            ""
hud_group9_place              "screen"
hud_group9_pos_x              "0"
hud_group9_pos_y              "0"
hud_group9_show               "0"
hud_group9_width              "64"
hud_gun2_align_x              "left"
hud_gun2_align_y              "top"
hud_gun2_frame                "0"
hud_gun2_frame_color          "0 0 0"
hud_gun2_item_opacity         "1"
hud_gun2_order                "5"
hud_gun2_place                "group2"
hud_gun2_pos_x                "2"
hud_gun2_pos_y                "0"
hud_gun2_scale                "1"
hud_gun2_show                 "0"
hud_gun2_style                "0"
hud_gun3_align_x              "right"
hud_gun3_align_y              "top"
hud_gun3_frame                "0"
hud_gun3_frame_color          "0 0 0"
hud_gun3_item_opacity         "1.0"
hud_gun3_order                "6"
hud_gun3_place                "group2"
hud_gun3_pos_x                "-2"
hud_gun3_pos_y                "0"
hud_gun3_scale                "1"
hud_gun3_show                 "1"
hud_gun3_style                "0"
hud_gun4_align_x              "left"
hud_gun4_align_y              "top"
hud_gun4_frame                "0"
hud_gun4_frame_color          "0 0 0"
hud_gun4_item_opacity         "1.0"
hud_gun4_order                "7"
hud_gun4_place                "group3"
hud_gun4_pos_x                "0"
hud_gun4_pos_y                "0"
hud_gun4_scale                "1"
hud_gun4_show                 "1"
hud_gun4_style                "0"
hud_gun5_align_x              "right"
hud_gun5_align_y              "top"
hud_gun5_frame                "0"
hud_gun5_frame_color          "0 0 0"
hud_gun5_item_opacity         "1.0"
hud_gun5_order                "8"
hud_gun5_place                "group3"
hud_gun5_pos_x                "-2"
hud_gun5_pos_y                "0"
hud_gun5_scale                "1"
hud_gun5_show                 "1"
hud_gun5_style                "0"
hud_gun6_align_x              "left"
hud_gun6_align_y              "top"
hud_gun6_frame                "0"
hud_gun6_frame_color          "0 0 0"
hud_gun6_item_opacity         "1.0"
hud_gun6_order                "9"
hud_gun6_place                "group4"
hud_gun6_pos_x                "0"
hud_gun6_pos_y                "0"
hud_gun6_scale                "1"
hud_gun6_show                 "1"
hud_gun6_style                "0"
hud_gun7_align_x              "right"
hud_gun7_align_y              "top"
hud_gun7_frame                "0"
hud_gun7_frame_color          "0"
hud_gun7_item_opacity         "1.0"
hud_gun7_order                "10"
hud_gun7_place                "group4"
hud_gun7_pos_x                "-2"
hud_gun7_pos_y                "0"
hud_gun7_scale                "1"
hud_gun7_show                 "1"
hud_gun7_style                "0"
hud_gun8_align_x              "left"
hud_gun8_align_y              "top"
hud_gun8_frame                "0"
hud_gun8_frame_color          "0 0 0"
hud_gun8_item_opacity         "1.0"
hud_gun8_order                "11"
hud_gun8_place                "group5"
hud_gun8_pos_x                "2"
hud_gun8_pos_y                "0"
hud_gun8_scale                "1"
hud_gun8_show                 "1"
hud_gun8_style                "0"
hud_gun8_wide                 "0"
hud_gun_align_x               "center"
hud_gun_align_y               "bottom"
hud_gun_frame                 "0"
hud_gun_frame_color           "0 0 0"
hud_gun_item_opacity          "1.0"
hud_gun_order                 "0"
hud_gun_place                 "ibar"
hud_gun_pos_x                 "0"
hud_gun_pos_y                 "0"
hud_gun_scale                 "1"
hud_gun_show                  "0"
hud_gun_style                 "0"
hud_gun_wide                  "0"
hud_health_align              "right"
hud_health_align_x            "right"
hud_health_align_y            "center"
hud_health_digits             "3"
hud_health_frame              "0"
hud_health_frame_color        "0 0 0"
hud_health_item_opacity       "0.99"
hud_health_order              "1312"
hud_health_place              "group1"
hud_health_pos_x              "-5"
hud_health_pos_y              "0"
hud_health_scale              "1"
hud_health_show               "1"
hud_health_style              "0"
hud_healthdamage_align        "left"
hud_healthdamage_align_x      "left"
hud_healthdamage_align_y      "center"
hud_healthdamage_digits       "3"
hud_healthdamage_duration     "1.2"
hud_healthdamage_frame        "0.2"
hud_healthdamage_frame_color  "50 0 0"
hud_healthdamage_item_opacity "0.5"
hud_healthdamage_order        "1313"
hud_healthdamage_place        "screen"
hud_healthdamage_pos_x        "0"
hud_healthdamage_pos_y        "0"
hud_healthdamage_scale        "2"
hud_healthdamage_show         "1"
hud_healthdamage_style        "1"
hud_iammo1_align_x            "before"
hud_iammo1_align_y            "center"
hud_iammo1_frame              "0"
hud_iammo1_frame_color        "0 0 0"
hud_iammo1_item_opacity       "1"
hud_iammo1_order              "5"
hud_iammo1_place              "group2"
hud_iammo1_pos_x              "-2"
hud_iammo1_pos_y              "0"
hud_iammo1_scale              "1"
hud_iammo1_show               "0"
hud_iammo1_style              "0"
hud_iammo2_align_x            "before"
hud_iammo2_align_y            "center"
hud_iammo2_frame              "0"
hud_iammo2_frame_color        "0 0 0"
hud_iammo2_item_opacity       "1.0"
hud_iammo2_order              "6"
hud_iammo2_place              "group3"
hud_iammo2_pos_x              "-2"
hud_iammo2_pos_y              "0"
hud_iammo2_scale              "1"
hud_iammo2_show               "0"
hud_iammo2_style              "0"
hud_iammo3_align_x            "after"
hud_iammo3_align_y            "center"
hud_iammo3_frame              "0"
hud_iammo3_frame_color        "0 0 0"
hud_iammo3_item_opacity       "1.0"
hud_iammo3_order              "7"
hud_iammo3_place              "group4"
hud_iammo3_pos_x              "2"
hud_iammo3_pos_y              "0"
hud_iammo3_scale              "1"
hud_iammo3_show               "0"
hud_iammo3_style              "0"
hud_iammo4_align_x            "after"
hud_iammo4_align_y            "center"
hud_iammo4_frame              "0"
hud_iammo4_frame_color        "0 0 0"
hud_iammo4_item_opacity       "1.0"
hud_iammo4_order              "8"
hud_iammo4_place              "group5"
hud_iammo4_pos_x              "2"
hud_iammo4_pos_y              "0"
hud_iammo4_scale              "1"
hud_iammo4_show               "0"
hud_iammo4_style              "0"
hud_iammo_align_x             "before"
hud_iammo_align_y             "center"
hud_iammo_frame               "0"
hud_iammo_frame_color         "0 0 0"
hud_iammo_item_opacity        "1.0"
hud_iammo_order               "1314"
hud_iammo_place               "ammo"
hud_iammo_pos_x               "0"
hud_iammo_pos_y               "0"
hud_iammo_scale               "1"
hud_iammo_show                "0"
hud_iammo_style               "0"
hud_iarmor_align_x            "left"
hud_iarmor_align_y            "center"
hud_iarmor_frame              "0"
hud_iarmor_frame_color        "0 0 0"
hud_iarmor_item_opacity       "1.0"
hud_iarmor_order              "2281"
hud_iarmor_place              "group1"
hud_iarmor_pos_x              "5"
hud_iarmor_pos_y              "0"
hud_iarmor_scale              "1"
hud_iarmor_show               "1"
hud_iarmor_style              "0"
hud_inputlag_align_x          "center"
hud_inputlag_align_y          "center"
hud_inputlag_frame            "0"
hud_inputlag_frame_color      "0 0 0"
hud_inputlag_height           "60"
hud_inputlag_item_opacity     "1.0"
hud_inputlag_order            "1"
hud_inputlag_place            "screen"
hud_inputlag_pos_x            "0"
hud_inputlag_pos_y            "0"
hud_inputlag_show             "0"
hud_inputlag_style            "0"
hud_inputlag_width            "200"
hud_itemsclock_align_x        "left"
hud_itemsclock_align_y        "before"
hud_itemsclock_frame          "0"
hud_itemsclock_frame_color    "0 0 0"
hud_itemsclock_item_opacity   "1.0"
hud_itemsclock_order          "11"
hud_itemsclock_place          "gameclock"
hud_itemsclock_pos_x          "0"
hud_itemsclock_pos_y          "-4"
hud_itemsclock_show           "1"
hud_itemsclock_style          "1"
hud_itemsclock_timelimit      "20"
hud_key1_align_x              "before"
hud_key1_align_y              "bottom"
hud_key1_frame                "0"
hud_key1_frame_color          "0 0 0"
hud_key1_item_opacity         "1.0"
hud_key1_order                "93"
hud_key1_place                "key2"
hud_key1_pos_x                "0"
hud_key1_pos_y                "0"
hud_key1_scale                "1.5"
hud_key1_show                 "1"
hud_key1_style                "0"
hud_key2_align_x              "before"
hud_key2_align_y              "top"
hud_key2_frame                "0"
hud_key2_frame_color          "0 0 0"
hud_key2_item_opacity         "1.0"
hud_key2_order                "92"
hud_key2_place                "iammo1"
hud_key2_pos_x                "-4"
hud_key2_pos_y                "0"
hud_key2_scale                "1.5"
hud_key2_show                 "1"
hud_key2_style                "0"
hud_keys_align_x              "right"
hud_keys_align_y              "center"
hud_keys_frame                "0.5"
hud_keys_frame_color          "20 20 20"
hud_keys_item_opacity         "1.0"
hud_keys_order                "1"
hud_keys_place                "screen"
hud_keys_pos_x                "0"
hud_keys_pos_y                "0"
hud_keys_scale                "3"
hud_keys_show                 "0"
hud_mouserate_align_x         "after"
hud_mouserate_align_y         "center"
hud_mouserate_frame           "0.1"
hud_mouserate_frame_color     "0 0 0"
hud_mouserate_interval        "1"
hud_mouserate_item_opacity    "1.0"
hud_mouserate_order           "13"
hud_mouserate_place           "vidlag"
hud_mouserate_pos_x           "0"
hud_mouserate_pos_y           "0"
hud_mouserate_show            "1"
hud_mouserate_style           "1"
hud_mouserate_title           "1"
hud_mp3_time_align_x          "center"
hud_mp3_time_align_y          "before"
hud_mp3_time_frame            "0.7"
hud_mp3_time_frame_color      "50 0 0"
hud_mp3_time_item_opacity     "1.0"
hud_mp3_time_on_scoreboard    "1"
hud_mp3_time_order            "2"
hud_mp3_time_place            "mp3_title"
hud_mp3_time_pos_x            "0"
hud_mp3_time_pos_y            "0"
hud_mp3_time_show             "1"
hud_mp3_time_style            "0"
hud_mp3_title_align_x         "center"
hud_mp3_title_align_y         "bottom"
hud_mp3_title_frame           "0.5"
hud_mp3_title_frame_color     "0 0 0"
hud_mp3_title_height          "8"
hud_mp3_title_item_opacity    "1.0"
hud_mp3_title_on_scoreboard   "1"
hud_mp3_title_order           "1"
hud_mp3_title_place           "screen"
hud_mp3_title_pos_x           "0"
hud_mp3_title_pos_y           "32"
hud_mp3_title_scroll          "1"
hud_mp3_title_scroll_delay    "0.5"
hud_mp3_title_show            "1"
hud_mp3_title_style           "2"
hud_mp3_title_width           "640"
hud_mp3_title_wordwrap        "0"
hud_net_align_x               "left"
hud_net_align_y               "center"
hud_net_frame                 "0.2"
hud_net_frame_color           "0 0 0"
hud_net_item_opacity          "1.0"
hud_net_order                 "7"
hud_net_period                "1"
hud_net_place                 "top"
hud_net_pos_x                 "0"
hud_net_pos_y                 "0"
hud_net_show                  "0"
hud_netgraph_align_x          "after"
hud_netgraph_align_y          "bottom"
hud_netgraph_alpha            "1"
hud_netgraph_frame            "0"
hud_netgraph_frame_color      "0 0 0"
hud_netgraph_full             "0"
hud_netgraph_height           "32"
hud_netgraph_inframes         "0"
hud_netgraph_item_opacity     "1.0"
hud_netgraph_lostscale        "1"
hud_netgraph_order            "9"
hud_netgraph_place            "net"
hud_netgraph_ploss            "1"
hud_netgraph_pos_x            "0"
hud_netgraph_pos_y            "0"
hud_netgraph_scale            "256"
hud_netgraph_show             "0"
hud_netgraph_swap_x           "0"
hud_netgraph_swap_y           "0"
hud_netgraph_width            "256"
hud_netproblem_align_x        "left"
hud_netproblem_align_y        "top"
hud_netproblem_frame          "0"
hud_netproblem_frame_color    "0 0 0"
hud_netproblem_item_opacity   "1.0"
hud_netproblem_order          "0"
hud_netproblem_place          "top"
hud_netproblem_pos_x          "0"
hud_netproblem_pos_y          "0"
hud_netproblem_scale          "1"
hud_netproblem_show           "1"
hud_notify_align_x            "left"
hud_notify_align_y            "center"
hud_notify_cols               "50"
hud_notify_frame              "0"
hud_notify_frame_color        "0 0 0"
hud_notify_item_opacity       "0.99"
hud_notify_order              "8"
hud_notify_place              "screen"
hud_notify_pos_x              "0"
hud_notify_pos_y              "80"
hud_notify_rows               "10"
hud_notify_scale              "1.2"
hud_notify_show               "1"
hud_notify_time               "10"
hud_ownfrags_align_x          "center"
hud_ownfrags_align_y          "top"
hud_ownfrags_frame            "0.3"
hud_ownfrags_frame_color      "0 0 80"
hud_ownfrags_item_opacity     "1.0"
hud_ownfrags_order            "1"
hud_ownfrags_place            "screen"
hud_ownfrags_pos_x            "0"
hud_ownfrags_pos_y            "50"
hud_ownfrags_scale            "2"
hud_ownfrags_show             "1"
hud_ownfrags_timeout          "3"
hud_pent_align_x              "before"
hud_pent_align_y              "center"
hud_pent_frame                "0"
hud_pent_frame_color          "0 0 0"
hud_pent_item_opacity         "1.0"
hud_pent_order                "140"
hud_pent_place                "quad"
hud_pent_pos_x                "0"
hud_pent_pos_y                "0"
hud_pent_scale                "1"
hud_pent_show                 "1"
hud_pent_style                "0"
hud_ping_align_x              "right"
hud_ping_align_y              "top"
hud_ping_blink                "0"
hud_ping_frame                "0"
hud_ping_frame_color          "0 0 0"
hud_ping_item_opacity         "1.0"
hud_ping_order                "9"
hud_ping_period               "1"
hud_ping_place                "group6"
hud_ping_pos_x                "0"
hud_ping_pos_y                "0"
hud_ping_show                 "1"
hud_ping_show_dev             "0"
hud_ping_show_max             "0"
hud_ping_show_min             "0"
hud_ping_show_pl              "1"
hud_ping_style                "1"
hud_planmode                  "0"
hud_quad_align_x              "before"
hud_quad_align_y              "top"
hud_quad_frame                "0"
hud_quad_frame_color          "0 0 0"
hud_quad_item_opacity         "0.99"
hud_quad_order                "139"
hud_quad_place                "group1"
hud_quad_pos_x                "0"
hud_quad_pos_y                "0"
hud_quad_scale                "1"
hud_quad_show                 "0"
hud_quad_style                "0"
hud_radar_align_x             "left"
hud_radar_align_y             "top"
hud_radar_autosize            "0"
hud_radar_fade_players        "1"
hud_radar_frame               "0"
hud_radar_frame_color         "0 0 0"
hud_radar_height              "35%"
hud_radar_highlight           "0"
hud_radar_highlight_color     "yellow"
hud_radar_item_opacity        "1"
hud_radar_itemfilter          "backpack quad pent armor mega ring suit"
hud_radar_onlytp              "3"
hud_radar_opacity             "0.5"
hud_radar_order               "0"
hud_radar_otherfilter         "projectiles gibs explosions shotgun"
hud_radar_place               "screen"
hud_radar_player_size         "10"
hud_radar_pos_x               "0"
hud_radar_pos_y               "0"
hud_radar_show                "0"
hud_radar_show_height         "1"
hud_radar_show_hold           "0"
hud_radar_show_names          "0"
hud_radar_show_powerups       "1"
hud_radar_show_stats          "1"
hud_radar_weaponfilter        "gl rl lg"
hud_radar_width               "35%"
hud_ring_align_x              "before"
hud_ring_align_y              "yop"
hud_ring_frame                "0"
hud_ring_frame_color          "0 0 0"
hud_ring_item_opacity         "0.99"
hud_ring_order                "141"
hud_ring_place                "pent"
hud_ring_pos_x                "0"
hud_ring_pos_y                "0"
hud_ring_scale                "1"
hud_ring_show                 "1"
hud_ring_style                "0"
hud_sigil1_align_x            "left"
hud_sigil1_align_y            "bottom"
hud_sigil1_frame              "0"
hud_sigil1_frame_color        "0 0 0"
hud_sigil1_item_opacity       "0.5"
hud_sigil1_order              "13"
hud_sigil1_place              "screen"
hud_sigil1_pos_x              "0"
hud_sigil1_pos_y              "0"
hud_sigil1_scale              "2"
hud_sigil1_show               "0"
hud_sigil1_style              "0"
hud_sigil2_align_x            "after"
hud_sigil2_align_y            "top"
hud_sigil2_frame              "0"
hud_sigil2_frame_color        "0 0 0"
hud_sigil2_item_opacity       "0.5"
hud_sigil2_order              "14"
hud_sigil2_place              "sigil1"
hud_sigil2_pos_x              "0"
hud_sigil2_pos_y              "0"
hud_sigil2_scale              "2"
hud_sigil2_show               "1"
hud_sigil2_style              "0"
hud_sigil3_align_x            "after"
hud_sigil3_align_y            "top"
hud_sigil3_frame              "0"
hud_sigil3_frame_color        "0 0 0"
hud_sigil3_item_opacity       "0.5"
hud_sigil3_order              "15"
hud_sigil3_place              "sigil2"
hud_sigil3_pos_x              "0"
hud_sigil3_pos_y              "0"
hud_sigil3_scale              "2"
hud_sigil3_show               "1"
hud_sigil3_style              "0"
hud_sigil4_align_x            "after"
hud_sigil4_align_y            "top"
hud_sigil4_frame              "0"
hud_sigil4_frame_color        "0 0 0"
hud_sigil4_item_opacity       "0.5"
hud_sigil4_order              "16"
hud_sigil4_place              "sigil3"
hud_sigil4_pos_x              "0"
hud_sigil4_pos_y              "0"
hud_sigil4_scale              "2"
hud_sigil4_show               "1"
hud_sigil4_style              "0"
hud_speed2_align_x            "center"
hud_speed2_align_y            "center"
hud_speed2_color_fast         "72"
hud_speed2_color_fastest      "216"
hud_speed2_color_insane       "229"
hud_speed2_color_normal       "100"
hud_speed2_color_stopped      "52"
hud_speed2_frame              "0"
hud_speed2_frame_color        "0 0 0"
hud_speed2_item_opacity       "1.0"
hud_speed2_opacity            "1.0"
hud_speed2_order              "7"
hud_speed2_orientation        "0"
hud_speed2_place              "screen"
hud_speed2_pos_x              "0"
hud_speed2_pos_y              "0"
hud_speed2_radius             "50.0"
hud_speed2_show               "0"
hud_speed2_wrapspeed          "500"
hud_speed2_xyz                "0"
hud_speed_align_x             "center"
hud_speed_align_y             "center"
hud_speed_color_fast          "72"
hud_speed_color_fastest       "216"
hud_speed_color_insane        "229"
hud_speed_color_normal        "5"
hud_speed_color_stopped       "1"
hud_speed_frame               "0.2"
hud_speed_frame_color         "0 0 0"
hud_speed_height              "15"
hud_speed_item_opacity        "1.0"
hud_speed_opacity             "1.0"
hud_speed_order               "7"
hud_speed_place               "screen"
hud_speed_pos_x               "0"
hud_speed_pos_y               "20"
hud_speed_show                "0"
hud_speed_style               "0"
hud_speed_text_align          "3"
hud_speed_tick_spacing        "0.2"
hud_speed_vertical            "0"
hud_speed_vertical_text       "1"
hud_speed_width               "100"
hud_speed_xyz                 "0"
hud_suit_align_x              "before"
hud_suit_align_y              "center"
hud_suit_frame                "0"
hud_suit_frame_color          "0 0 0"
hud_suit_item_opacity         "1.0"
hud_suit_order                "142"
hud_suit_place                "ring"
hud_suit_pos_x                "0"
hud_suit_pos_y                "0"
hud_suit_scale                "1"
hud_suit_show                 "1"
hud_suit_style                "0"
hud_teamfrags_align_x         "center"
hud_teamfrags_align_y         "before"
hud_teamfrags_bignum          "0"
hud_teamfrags_cell_height     "8"
hud_teamfrags_cell_width      "38"
hud_teamfrags_colors_alpha    "1.0"
hud_teamfrags_cols            "2"
hud_teamfrags_extra_spec_info "0"
hud_teamfrags_fliptext        "1"
hud_teamfrags_frame           "0"
hud_teamfrags_frame_color     "0 0 0"
hud_teamfrags_item_opacity    "1.0"
hud_teamfrags_maxname         "16"
hud_teamfrags_onlytp          "0"
hud_teamfrags_order           "9"
hud_teamfrags_padtext         "1"
hud_teamfrags_place           "group1"
hud_teamfrags_pos_x           "0"
hud_teamfrags_pos_y           "-40"
hud_teamfrags_rows            "1"
hud_teamfrags_show            "1"
hud_teamfrags_shownames       "0"
hud_teamfrags_space_x         "2"
hud_teamfrags_space_y         "0"
hud_teamfrags_strip           "1"
hud_teamfrags_style           "0"
hud_teamfrags_vertical        "0"
hud_teamholdbar_align_x       "left"
hud_teamholdbar_align_y       "bottom"
hud_teamholdbar_frame         "0"
hud_teamholdbar_frame_color   "0 0 0"
hud_teamholdbar_height        "8"
hud_teamholdbar_item_opacity  "1.0"
hud_teamholdbar_onlytp        "0"
hud_teamholdbar_opacity       "0.8"
hud_teamholdbar_order         "0"
hud_teamholdbar_place         "top"
hud_teamholdbar_pos_x         "0"
hud_teamholdbar_pos_y         "0"
hud_teamholdbar_show          "0"
hud_teamholdbar_show_text     "1"
hud_teamholdbar_vertical      "0"
hud_teamholdbar_vertical_text "0"
hud_teamholdbar_width         "200"
hud_teamholdinfo_align_x      "left"
hud_teamholdinfo_align_y      "bottom"
hud_teamholdinfo_frame        "0"
hud_teamholdinfo_frame_color  "0 0 0"
hud_teamholdinfo_height       "8"
hud_teamholdinfo_item_opacity "1.0"
hud_teamholdinfo_itemfilter   "quad ra ya ga mega pent rl quad"
hud_teamholdinfo_onlytp       "0"
hud_teamholdinfo_opacity      "0.8"
hud_teamholdinfo_order        "0"
hud_teamholdinfo_place        "top"
hud_teamholdinfo_pos_x        "0"
hud_teamholdinfo_pos_y        "0"
hud_teamholdinfo_show         "0"
hud_teamholdinfo_style        "1"
hud_teamholdinfo_width        "200"
hud_teaminfo_align_right      "0"
hud_teaminfo_align_x          "right"
hud_teaminfo_align_y          "center"
hud_teaminfo_armor_style      "3"
hud_teaminfo_frame            "0.2"
hud_teaminfo_frame_color      "0 0 0"
hud_teaminfo_item_opacity     "1.0"
hud_teaminfo_layout           "%p%n $x10%l$x11 %a/%H %w"
hud_teaminfo_loc_width        "5"
hud_teaminfo_low_health       "25"
hud_teaminfo_name_width       "6"
hud_teaminfo_order            "0"
hud_teaminfo_place            "screen"
hud_teaminfo_pos_x            "0"
hud_teaminfo_pos_y            "0"
hud_teaminfo_scale            "1"
hud_teaminfo_show             "1"
hud_teaminfo_show_enemies     "0"
hud_teaminfo_show_self        "1"
hud_teaminfo_weapon_style     "1"
hud_tp_need                   "1"
hud_tracking_align_x          "after"
hud_tracking_align_y          "top"
hud_tracking_format           "%t  %n"
hud_tracking_frame            "0"
hud_tracking_frame_color      "0 0 0"
hud_tracking_item_opacity     "1.0"
hud_tracking_order            "1314"
hud_tracking_place            "gameclock"
hud_tracking_pos_x            "0"
hud_tracking_pos_y            "0"
hud_tracking_scale            "1"
hud_tracking_show             "1"
hud_vidlag_align_x            "after"
hud_vidlag_align_y            "center"
hud_vidlag_frame              "0.2"
hud_vidlag_frame_color        "0 0 0"
hud_vidlag_item_opacity       "1.0"
hud_vidlag_order              "12"
hud_vidlag_place              "fps"
hud_vidlag_pos_x              "0"
hud_vidlag_pos_y              "0"
hud_vidlag_show               "0"
hud_vidlag_style              "1"
hud_recalculate


================================================
FILE: misc/cfg/hud_berzerk.cfg
================================================
echo Berzerk's Head Up Display Configuration

scr_newhud                  "1"
hud_ammo1_align             "right"
hud_ammo1_align_x           "left"
hud_ammo1_align_y           "center"
hud_ammo1_digits            "3"
hud_ammo1_frame             "0"
hud_ammo1_place             "group4"
hud_ammo1_pos_x             "50"
hud_ammo1_pos_y             "0"
hud_ammo1_scale             "1"
hud_ammo1_show              "2"
hud_ammo1_style             "1"
hud_ammo2_align             "left"
hud_ammo2_align_x           "left"
hud_ammo2_align_y           "center"
hud_ammo2_digits            "3"
hud_ammo2_frame             "0"
hud_ammo2_place             "group4"
hud_ammo2_pos_x             "130"
hud_ammo2_pos_y             "0"
hud_ammo2_scale             "1"
hud_ammo2_show              "1"
hud_ammo2_style             "1"
hud_ammo3_align             "left"
hud_ammo3_align_x           "left"
hud_ammo3_align_y           "center"
hud_ammo3_digits            "3"
hud_ammo3_frame             "0"
hud_ammo3_place             "group4"
hud_ammo3_pos_x             "250"
hud_ammo3_pos_y             "0"
hud_ammo3_scale             "1"
hud_ammo3_show              "1"
hud_ammo3_style             "1"
hud_ammo4_align             "left"
hud_ammo4_align_x           "left"
hud_ammo4_align_y           "center"
hud_ammo4_digits            "3"
hud_ammo4_frame             "0"
hud_ammo4_place             "group4"
hud_ammo4_pos_x             "333"
hud_ammo4_pos_y             "0"
hud_ammo4_scale             "1"
hud_ammo4_show              "1"
hud_ammo4_style             "1"
hud_ammo_align              "center"
hud_ammo_align_x            "center"
hud_ammo_align_y            "center"
hud_ammo_digits             "2"
hud_ammo_frame              "0"
hud_ammo_place              "screen"
hud_ammo_pos_x              "0"
hud_ammo_pos_y              "11"
hud_ammo_scale              "1"
hud_ammo_show               "1"
hud_ammo_style              "1"
hud_armor_align             "right"
hud_armor_align_x           "center"
hud_armor_align_y           "center"
hud_armor_digits            "3"
hud_armor_frame             "0"
hud_armor_place             "screen"
hud_armor_pos_x             "-50"
hud_armor_pos_y             "0"
hud_armor_scale             "1"
hud_armor_show              "1"
hud_armor_style             "1"
hud_armordamage_align       "right"
hud_armordamage_align_x     "left"
hud_armordamage_align_y     "before"
hud_armordamage_digits      "3"
hud_armordamage_duration    "0.8"
hud_armordamage_frame       "0"
hud_armordamage_place       "armor"
hud_armordamage_pos_x       "0"
hud_armordamage_pos_y       "0"
hud_armordamage_scale       "1"
hud_armordamage_show        "0"
hud_armordamage_style       "1"
hud_clock_align_x           "right"
hud_clock_align_y           "center"
hud_clock_big               "0"
hud_clock_blink             "0"
hud_clock_frame             "0"
hud_clock_place             "@group3"
hud_clock_pos_x             "-5"
hud_clock_pos_y             "0"
hud_clock_scale             "1"
hud_clock_show              "1"
hud_clock_style             "2"
hud_face_align_x            "after"
hud_face_align_y            "center"
hud_face_frame              "0"
hud_face_place              "armor"
hud_face_pos_x              "10"
hud_face_pos_y              "0"
hud_face_scale              "1"
hud_face_show               "0"
hud_fps_align_x             "center"
hud_fps_align_y             "center"
hud_fps_decimals            "0"
hud_fps_frame               "0"
hud_fps_place               "@group3"
hud_fps_pos_x               "15"
hud_fps_pos_y               "0"
hud_fps_show                "1"
hud_fps_show_min            "0"
hud_fps_title               "1"
hud_frags_align_x           "left"
hud_frags_align_y           "bottom"
hud_frags_cell_height       "7"
hud_frags_cell_width        "28"
hud_frags_cols              "8"
hud_frags_fliptext          "0"
hud_frags_frame             "0"
hud_frags_padtext           "1"
hud_frags_place             "screen"
hud_frags_pos_x             "3"
hud_frags_pos_y             "-40"
hud_frags_rows              "8"
hud_frags_show              "0"
hud_frags_shownames         "0"
hud_frags_showself_always   "1"
hud_frags_showteams         "0"
hud_frags_space_x           "2"
hud_frags_space_y           "2"
hud_frags_strip             "1"
hud_frags_style             "0"
hud_frags_teamsort          "0"
hud_frags_vertical          "1"
hud_gameclock_align_x       "right"
hud_gameclock_align_y       "console"
hud_gameclock_big           "1"
hud_gameclock_blink         "1"
hud_gameclock_countdown     "0"
hud_gameclock_frame         "0"
hud_gameclock_place         "top"
hud_gameclock_pos_x         "0"
hud_gameclock_pos_y         "0"
hud_gameclock_scale         "1"
hud_gameclock_show          "0"
hud_gameclock_style         "0"
hud_group1_align_x          "center"
hud_group1_align_y          "center"
hud_group1_alpha            "1"
hud_group1_frame            ".5"
hud_group1_height           "480"
hud_group1_name             "group1"
hud_group1_picture          ""
hud_group1_place            "screen"
hud_group1_pos_x            "1"
hud_group1_pos_y            "0"
hud_group1_show             "1"
hud_group1_tile             "0"
hud_group1_width            "2"
hud_group2_align_x          "center"
hud_group2_align_y          "center"
hud_group2_alpha            "1"
hud_group2_frame            ".5"
hud_group2_height           "2"
hud_group2_name             "group2"
hud_group2_picture          ""
hud_group2_place            "screen"
hud_group2_pos_x            "0"
hud_group2_pos_y            "1"
hud_group2_show             "0"
hud_group2_tile             "0"
hud_group2_width            "640"
hud_group3_align_x          "right"
hud_group3_align_y          "bottom"
hud_group3_alpha            "1"
hud_group3_frame            ".25"
hud_group3_height           "10"
hud_group3_name             "group3"
hud_group3_picture          ""
hud_group3_place            "screen"
hud_group3_pos_x            "-25"
hud_group3_pos_y            "-5"
hud_group3_show             "1"
hud_group3_tile             "0"
hud_group3_width            "355"
hud_group4_align_x          "left"
hud_group4_align_y          "bottom"
hud_group4_alpha            "1"
hud_group4_frame            ".25"
hud_group4_height           "10"
hud_group4_name             "group4"
hud_group4_picture          ""
hud_group4_place            "screen"
hud_group4_pos_x            "20"
hud_group4_pos_y            "-20"
hud_group4_show             "1"
hud_group4_tile             "0"
hud_group4_width            "355"
hud_group5_align_x          "after"
hud_group5_align_y          "center"
hud_group5_alpha            "1"
hud_group5_frame            "0.25"
hud_group5_height           "10"
hud_group5_name             "group5"
hud_group5_picture          ""
hud_group5_place            "group4"
hud_group5_pos_x            "5"
hud_group5_pos_y            "0"
hud_group5_show             "0"
hud_group5_tile             "0"
hud_group5_width            "75"
hud_group6_align_x          "left"
hud_group6_align_y          "top"
hud_group6_alpha            "1"
hud_group6_frame            ".5"
hud_group6_height           "64"
hud_group6_name             "group6"
hud_group6_picture          ""
hud_group6_place            "screen"
hud_group6_pos_x            "0"
hud_group6_pos_y            "0"
hud_group6_show             "0"
hud_group6_tile             "0"
hud_group6_width            "64"
hud_group7_align_x          "left"
hud_group7_align_y          "top"
hud_group7_alpha            "1"
hud_group7_frame            ".5"
hud_group7_height           "64"
hud_group7_name             "group7"
hud_group7_picture          ""
hud_group7_place            "screen"
hud_group7_pos_x            "0"
hud_group7_pos_y            "0"
hud_group7_show             "0"
hud_group7_tile             "0"
hud_group7_width            "64"
hud_group8_align_x          "left"
hud_group8_align_y          "top"
hud_group8_alpha            "1"
hud_group8_frame            ".5"
hud_group8_height           "64"
hud_group8_name             "group8"
hud_group8_picture          ""
hud_group8_place            "screen"
hud_group8_pos_x            "0"
hud_group8_pos_y            "0"
hud_group8_show             "0"
hud_group8_tile             "0"
hud_group8_width            "64"
hud_group9_align_x          "left"
hud_group9_align_y          "top"
hud_group9_alpha            "1"
hud_group9_frame            ".5"
hud_group9_height           "64"
hud_group9_name             "group9"
hud_group9_picture          ""
hud_group9_place            "screen"
hud_group9_pos_x            "0"
hud_group9_pos_y            "0"
hud_group9_show             "0"
hud_group9_tile             "0"
hud_group9_width            "64"
hud_gun2_align_x            "center"
hud_gun2_align_y            "center"
hud_gun2_frame              "0"
hud_gun2_place              "screen"
hud_gun2_pos_x              "-60"
hud_gun2_pos_y              "110"
hud_gun2_scale              "1"
hud_gun2_show               "1"
hud_gun2_style              "1"
hud_gun3_align_x            "center"
hud_gun3_align_y            "center"
hud_gun3_frame              "0"
hud_gun3_place              "screen"
hud_gun3_pos_x              "-40"
hud_gun3_pos_y              "110"
hud_gun3_scale              "1"
hud_gun3_show               "1"
hud_gun3_style              "1"
hud_gun4_align_x            "center"
hud_gun4_align_y            "center"
hud_gun4_frame              "0"
hud_gun4_place              "screen"
hud_gun4_pos_x              "-20"
hud_gun4_pos_y              "110"
hud_gun4_scale              "1"
hud_gun4_show               "1"
hud_gun4_style              "1"
hud_gun5_align_x            "center"
hud_gun5_align_y            "center"
hud_gun5_frame              "0"
hud_gun5_place              "screen"
hud_gun5_pos_x              "0"
hud_gun5_pos_y              "110"
hud_gun5_scale              "1"
hud_gun5_show               "1"
hud_gun5_style              "1"
hud_gun6_align_x            "center"
hud_gun6_align_y            "center"
hud_gun6_frame              "0"
hud_gun6_place              "screen"
hud_gun6_pos_x              "20"
hud_gun6_pos_y              "110"
hud_gun6_scale              "1"
hud_gun6_show               "1"
hud_gun6_style              "1"
hud_gun7_align_x            "center"
hud_gun7_align_y            "center"
hud_gun7_frame              "0"
hud_gun7_place              "screen"
hud_gun7_pos_x              "40"
hud_gun7_pos_y              "110"
hud_gun7_scale              "1"
hud_gun7_show               "1"
hud_gun7_style              "1"
hud_gun8_align_x            "center"
hud_gun8_align_y            "center"
hud_gun8_frame              "0"
hud_gun8_place              "screen"
hud_gun8_pos_x              "60"
hud_gun8_pos_y              "110"
hud_gun8_scale              "1"
hud_gun8_show               "1"
hud_gun8_style              "1"
hud_gun8_wide               "0"
hud_gun_align_x             "center"
hud_gun_align_y             "bottom"
hud_gun_frame               "0"
hud_gun_place               "top"
hud_gun_pos_x               "0"
hud_gun_pos_y               "0"
hud_gun_scale               "1"
hud_gun_show                "0"
hud_gun_style               "0"
hud_gun_wide                "0"
hud_health_align            "left"
hud_health_align_x          "center"
hud_health_align_y          "center"
hud_health_digits           "3"
hud_health_frame            "0"
hud_health_place            "screen"
hud_health_pos_x            "50"
hud_health_pos_y            "0"
hud_health_scale            "1"
hud_health_show             "1"
hud_health_style            "1"
hud_healthdamage_align      "right"
hud_healthdamage_align_x    "left"
hud_healthdamage_align_y    "before"
hud_healthdamage_digits     "3"
hud_healthdamage_duration   "0.8"
hud_healthdamage_frame      "0"
hud_healthdamage_place      "health"
hud_healthdamage_pos_x      "0"
hud_healthdamage_pos_y      "0"
hud_healthdamage_scale      "1"
hud_healthdamage_show       "0"
hud_healthdamage_style      "1"
hud_iammo1_align_x          "center"
hud_iammo1_align_y          "center"
hud_iammo1_frame            "0"
hud_iammo1_place            "ammo1"
hud_iammo1_pos_x            "-35"
hud_iammo1_pos_y            "0"
hud_iammo1_scale            "0.75"
hud_iammo1_show             "1"
hud_iammo1_style            "0"
hud_iammo2_align_x          "center"
hud_iammo2_align_y          "center"
hud_iammo2_frame            "0"
hud_iammo2_place            "ammo2"
hud_iammo2_pos_x            "-35"
hud_iammo2_pos_y            "0"
hud_iammo2_scale            "0.75"
hud_iammo2_show             "1"
hud_iammo2_style            "0"
hud_iammo3_align_x          "center"
hud_iammo3_align_y          "center"
hud_iammo3_frame            "0"
hud_iammo3_place            "ammo3"
hud_iammo3_pos_x            "-35"
hud_iammo3_pos_y            "0"
hud_iammo3_scale            "0.75"
hud_iammo3_show             "1"
hud_iammo3_style            "0"
hud_iammo4_align_x          "center"
hud_iammo4_align_y          "center"
hud_iammo4_frame            "0"
hud_iammo4_place            "ammo4"
hud_iammo4_pos_x            "-30"
hud_iammo4_pos_y            "0"
hud_iammo4_scale            "0.75"
hud_iammo4_show             "1"
hud_iammo4_style            "0"
hud_iammo_align_x           "center"
hud_iammo_align_y           "top"
hud_iammo_frame             "0"
hud_iammo_place             "screen"
hud_iammo_pos_x             "0"
hud_iammo_pos_y             "0"
hud_iammo_scale             "1"
hud_iammo_show              "0"
hud_iammo_style             "1"
hud_iarmor_align_x          "center"
hud_iarmor_align_y          "center"
hud_iarmor_frame            "0"
hud_iarmor_place            "armor"
hud_iarmor_pos_x            "-16"
hud_iarmor_pos_y            "0"
hud_iarmor_scale            "1"
hud_iarmor_show             "1"
hud_iarmor_style            "1"
hud_key1_align_x            "top"
hud_key1_align_y            "left"
hud_key1_frame              "0"
hud_key1_place              "top"
hud_key1_pos_x              "0"
hud_key1_pos_y              "64"
hud_key1_scale              "1"
hud_key1_show               "0"
hud_key1_style              "0"
hud_key2_align_x            "left"
hud_key2_align_y            "after"
hud_key2_frame              "0"
hud_key2_place              "key1"
hud_key2_pos_x              "0"
hud_key2_pos_y              "0"
hud_key2_scale              "1"
hud_key2_show               "0"
hud_key2_style              "0"
hud_mp3_time_align_x        "left"
hud_mp3_time_align_y        "bottom"
hud_mp3_time_frame          "0"
hud_mp3_time_on_scoreboard  "0"
hud_mp3_time_place          "top"
hud_mp3_time_pos_x          "0"
hud_mp3_time_pos_y          "0"
hud_mp3_time_show           "0"
hud_mp3_time_style          "0"
hud_mp3_title_align_x       "right"
hud_mp3_title_align_y       "bottom"
hud_mp3_title_frame         "0"
hud_mp3_title_height        "8"
hud_mp3_title_on_scoreboard "0"
hud_mp3_title_place         "top"
hud_mp3_title_pos_x         "0"
hud_mp3_title_pos_y         "-10"
hud_mp3_title_scroll        "1"
hud_mp3_title_scroll_delay  "0.5"
hud_mp3_title_show          "0"
hud_mp3_title_style         "0"
hud_mp3_title_width         "512"
hud_mp3_title_wordwrap      "0"
hud_net_align_x             "left"
hud_net_align_y             "before"
hud_net_frame               "0.25"
hud_net_period              "1"
hud_net_place               "group2"
hud_net_pos_x               "0"
hud_net_pos_y               "-5"
hud_net_show                "0"
hud_netgraph_align_x        "after"
hud_netgraph_align_y        "bottom"
hud_netgraph_alpha          "0.1"
hud_netgraph_frame          "0.25"
hud_netgraph_full           "1"
hud_netgraph_height         "100"
hud_netgraph_inframes       "0"
hud_netgraph_lostscale      "0"
hud_netgraph_place          "group3"
hud_netgraph_ploss          "0"
hud_netgraph_pos_x          "5"
hud_netgraph_pos_y          "0"
hud_netgraph_scale          "160"
hud_netgraph_show           "0"
hud_netgraph_swap_x         "0"
hud_netgraph_swap_y         "0"
hud_netgraph_width          "45"
hud_pent_align_x            "left"
hud_pent_align_y            "center"
hud_pent_frame              "0"
hud_pent_place              "@group5"
hud_pent_pos_x              "20"
hud_pent_pos_y              "0"
hud_pent_scale              "1"
hud_pent_show               "1"
hud_pent_style              "1"
hud_ping_align_x            "left"
hud_ping_align_y            "center"
hud_ping_blink              "0"
hud_ping_frame              "0"
hud_ping_period             "1"
hud_ping_place              "@group3"
hud_ping_pos_x              "5"
hud_ping_pos_y              "0"
hud_ping_show               "1"
hud_ping_show_dev           "0"
hud_ping_show_max           "0"
hud_ping_show_min           "0"
hud_ping_show_pl            "1"
hud_quad_align_x            "left"
hud_quad_align_y            "center"
hud_quad_frame              "0"
hud_quad_place              "@group5"
hud_quad_pos_x              "5"
hud_quad_pos_y              "0"
hud_quad_scale              "1"
hud_quad_show               "1"
hud_quad_style              "1"
hud_ring_align_x            "right"
hud_ring_align_y            "center"
hud_ring_frame              "0"
hud_ring_place              "@group5"
hud_ring_pos_x              "-20"
hud_ring_pos_y              "0"
hud_ring_scale              "1"
hud_ring_show               "1"
hud_ring_style              "1"
hud_sigil1_align_x          "left"
hud_sigil1_align_y          "top"
hud_sigil1_frame            "0"
hud_sigil1_place            "screen"
hud_sigil1_pos_x            "0"
hud_sigil1_pos_y            "0"
hud_sigil1_scale            "1"
hud_sigil1_show             "0"
hud_sigil1_style            "0"
hud_sigil2_align_x          "after"
hud_sigil2_align_y          "top"
hud_sigil2_frame            "0"
hud_sigil2_place            "sigil1"
hud_sigil2_pos_x            "0"
hud_sigil2_pos_y            "0"
hud_sigil2_scale            "1"
hud_sigil2_show             "0"
hud_sigil2_style            "0"
hud_sigil3_align_x          "after"
hud_sigil3_align_y          "top"
hud_sigil3_frame            "0"
hud_sigil3_place            "sigil2"
hud_sigil3_pos_x            "0"
hud_sigil3_pos_y            "0"
hud_sigil3_scale            "1"
hud_sigil3_show             "0"
hud_sigil3_style            "0"
hud_sigil4_align_x          "after"
hud_sigil4_align_y          "top"
hud_sigil4_frame            "0"
hud_sigil4_place            "sigil3"
hud_sigil4_pos_x            "0"
hud_sigil4_pos_y            "0"
hud_sigil4_scale            "1"
hud_sigil4_show             "0"
hud_sigil4_style            "0"
hud_speed_align_x           "center"
hud_speed_align_y           "before"
hud_speed_frame             "0.25"
hud_speed_place             "group3"
hud_speed_pos_x             "0"
hud_speed_pos_y             "-5"
hud_speed_show              "0"
hud_speed_xyz               "0"
hud_suit_align_x            "right"
hud_suit_align_y            "center"
hud_suit_frame              "0"
hud_suit_place              "@group5"
hud_suit_pos_x              "-5"
hud_suit_pos_y              "0"
hud_suit_scale              "1"
hud_suit_show               "1"
hud_suit_style              "1"
hud_teamfrags_align_x       "left"
hud_teamfrags_align_y       "bottom"
hud_teamfrags_cell_height   "8"
hud_teamfrags_cell_width    "32"
hud_teamfrags_cols          "2"
hud_teamfrags_fliptext      "1"
hud_teamfrags_frame         "0"
hud_teamfrags_padtext       "1"
hud_teamfrags_place         "screen"
hud_teamfrags_pos_x         "320"
hud_teamfrags_pos_y         "-40"
hud_teamfrags_rows          "1"
hud_teamfrags_show          "1"
hud_teamfrags_shownames     "0"
hud_teamfrags_space_x       "1"
hud_teamfrags_space_y       "1"
hud_teamfrags_strip         "1"
hud_teamfrags_style         "0"
hud_teamfrags_vertical      "0"
hud_tracking_align_x        "left"
hud_tracking_align_y        "bottom"
hud_tracking_format         "Tracking %t %n, [JUMP] for next"
hud_tracking_frame          "0"
hud_tracking_place          "top"
hud_tracking_pos_x          "0"
hud_tracking_pos_y          "0"
hud_tracking_show           "0"
hud_recalculate


================================================
FILE: misc/cfg/hud_corner.cfg
================================================
echo ezQuake Cornered Head Up Configuration
echo Use with conwidth 512

//
// Head Up Display Configuration Dump
//

scr_newhud                  "1"
hud_ammo1_align             "right"
hud_ammo1_align_x           "left"
hud_ammo1_align_y           "top"
hud_ammo1_digits            "3"
hud_ammo1_frame             "0"
hud_ammo1_place             "iammo1"
hud_ammo1_pos_x             "28"
hud_ammo1_pos_y             "0"
hud_ammo1_scale             "1"
hud_ammo1_show              "1"
hud_ammo1_style             "0"
hud_ammo2_align             "right"
hud_ammo2_align_x           "left"
hud_ammo2_align_y           "top"
hud_ammo2_digits            "3"
hud_ammo2_frame             "0"
hud_ammo2_place             "iammo2"
hud_ammo2_pos_x             "28"
hud_ammo2_pos_y             "0"
hud_ammo2_scale             "1"
hud_ammo2_show              "1"
hud_ammo2_style             "0"
hud_ammo3_align             "right"
hud_ammo3_align_x           "left"
hud_ammo3_align_y           "top"
hud_ammo3_digits            "3"
hud_ammo3_frame             "0"
hud_ammo3_place             "iammo3"
hud_ammo3_pos_x             "28"
hud_ammo3_pos_y             "0"
hud_ammo3_scale             "1"
hud_ammo3_show              "1"
hud_ammo3_style             "0"
hud_ammo4_align             "right"
hud_ammo4_align_x           "left"
hud_ammo4_align_y           "top"
hud_ammo4_digits            "3"
hud_ammo4_frame             "0"
hud_ammo4_place             "iammo4"
hud_ammo4_pos_x             "28"
hud_ammo4_pos_y             "0"
hud_ammo4_scale             "1"
hud_ammo4_show              "1"
hud_ammo4_style             "0"
hud_ammo_align              "right"
hud_ammo_align_x            "left"
hud_ammo_align_y            "top"
hud_ammo_digits             "3"
hud_ammo_frame              "0"
hud_ammo_place              "screen"
hud_ammo_pos_x              "0"
hud_ammo_pos_y              "0"
hud_ammo_scale              "1"
hud_ammo_show               "0"
hud_ammo_style              "0"
hud_armor_align             "right"
hud_armor_align_x           "left"
hud_armor_align_y           "top"
hud_armor_digits            "3"
hud_armor_frame             "0"
hud_armor_place             "iarmor"
hud_armor_pos_x             "27"
hud_armor_pos_y             "0"
hud_armor_scale             "1"
hud_armor_show              "1"
hud_armor_style             "0"
hud_armordamage_align       "right"
hud_armordamage_align_x     "left"
hud_armordamage_align_y     "before"
hud_armordamage_digits      "3"
hud_armordamage_duration    "0.8"
hud_armordamage_frame       "0"
hud_armordamage_place       "armor"
hud_armordamage_pos_x       "0"
hud_armordamage_pos_y       "0"
hud_armordamage_scale       "1"
hud_armordamage_show        "0"
hud_armordamage_style       "0"
hud_clock_align_x           "right"
hud_clock_align_y           "before"
hud_clock_big               "0"
hud_clock_blink             "0"
hud_clock_frame             "0.5"
hud_clock_place             "group2"
hud_clock_pos_x             "-2"
hud_clock_pos_y             "-2"
hud_clock_scale             "1"
hud_clock_show              "0"
hud_clock_style             "0"
hud_face_align_x            "left"
hud_face_align_y            "bottom"
hud_face_frame              "0"
hud_face_place              "group1"
hud_face_pos_x              "112"
hud_face_pos_y              "-4"
hud_face_scale              "1"
hud_face_show               "1"
hud_fps_align_x             "right"
hud_fps_align_y             "center"
hud_fps_decimals            "0"
hud_fps_frame               "0"
hud_fps_place               "group4"
hud_fps_pos_x               "-8"
hud_fps_pos_y               "0"
hud_fps_show                "1"
hud_fps_show_min            "0"
hud_fps_title               "1"
hud_frags_align_x           "right"
hud_frags_align_y           "before"
hud_frags_cell_height       "8"
hud_frags_cell_width        "32"
hud_frags_cols              "4"
hud_frags_fliptext          "0"
hud_frags_frame             "0.5"
hud_frags_padtext           "1"
hud_frags_place             "group3"
hud_frags_pos_x             "0"
hud_frags_pos_y             "-2"
hud_frags_rows              "2"
hud_frags_show              "1"
hud_frags_shownames         "0"
hud_frags_showself_always   "1"
hud_frags_showteams         "0"
hud_frags_space_x           "1"
hud_frags_space_y           "1"
hud_frags_strip             "1"
hud_frags_style             "0"
hud_frags_teamsort          "0"
hud_frags_vertical          "0"
hud_gameclock_align_x       "left"
hud_gameclock_align_y       "before"
hud_gameclock_big           "1"
hud_gameclock_blink         "1"
hud_gameclock_countdown     "0"
hud_gameclock_frame         "0.5"
hud_gameclock_place         "group3"
hud_gameclock_pos_x         "0"
hud_gameclock_pos_y         "0"
hud_gameclock_scale         "0.5"
hud_gameclock_show          "1"
hud_gameclock_style         "0"
hud_group1_align_x          "left"
hud_group1_align_y          "bottom"
hud_group1_alpha            "1"
hud_group1_frame            "0.5"
hud_group1_height           "32"
hud_group1_name             "group1"
hud_group1_picture          ""
hud_group1_place            "screen"
hud_group1_pos_x            "0"
hud_group1_pos_y            "0"
hud_group1_show             "1"
hud_group1_tile             "0"
hud_group1_width            "216"
hud_group2_align_x          "right"
hud_group2_align_y          "bottom"
hud_group2_alpha            "1"
hud_group2_frame            ".5"
hud_group2_height           "116"
hud_group2_name             "group2"
hud_group2_picture          ""
hud_group2_place            "screen"
hud_group2_pos_x            "0"
hud_group2_pos_y            "0"
hud_group2_show             "1"
hud_group2_tile             "0"
hud_group2_width            "110"
hud_group3_align_x          "center"
hud_group3_align_y          "before"
hud_group3_alpha            "1"
hud_group3_frame            ".5"
hud_group3_height           "23"
hud_group3_name             "group3"
hud_group3_picture          ""
hud_group3_place            "group1"
hud_group3_pos_x            "0"
hud_group3_pos_y            "-2"
hud_group3_show             "1"
hud_group3_tile             "0"
hud_group3_width            "208"
hud_group4_align_x          "center"
hud_group4_align_y          "bottom"
hud_group4_alpha            "1"
hud_group4_frame            ".5"
hud_group4_height           "16"
hud_group4_name             "group4"
hud_group4_picture          ""
hud_group4_place            "screen"
hud_group4_pos_x            "53"
hud_group4_pos_y            "-3"
hud_group4_show             "1"
hud_group4_tile             "0"
hud_group4_width            "178"
hud_group5_align_x          "left"
hud_group5_align_y          "top"
hud_group5_alpha            "1"
hud_group5_frame            ".5"
hud_group5_height           "64"
hud_group5_name             "group5"
hud_group5_picture          ""
hud_group5_place            "screen"
hud_group5_pos_x            "0"
hud_group5_pos_y            "0"
hud_group5_show             "0"
hud_group5_tile             "0"
hud_group5_width            "64"
hud_group6_align_x          "left"
hud_group6_align_y          "top"
hud_group6_alpha            "1"
hud_group6_frame            ".5"
hud_group6_height           "64"
hud_group6_name             "group6"
hud_group6_picture          ""
hud_group6_place            "screen"
hud_group6_pos_x            "0"
hud_group6_pos_y            "0"
hud_group6_show             "0"
hud_group6_tile             "0"
hud_group6_width            "64"
hud_group7_align_x          "left"
hud_group7_align_y          "top"
hud_group7_alpha            "1"
hud_group7_frame            ".5"
hud_group7_height           "64"
hud_group7_name             "group7"
hud_group7_picture          ""
hud_group7_place            "screen"
hud_group7_pos_x            "0"
hud_group7_pos_y            "0"
hud_group7_show             "0"
hud_group7_tile             "0"
hud_group7_width            "64"
hud_group8_align_x          "left"
hud_group8_align_y          "top"
hud_group8_alpha            "1"
hud_group8_frame            ".5"
hud_group8_height           "64"
hud_group8_name             "group8"
hud_group8_picture          ""
hud_group8_place            "screen"
hud_group8_pos_x            "0"
hud_group8_pos_y            "0"
hud_group8_show             "0"
hud_group8_tile             "0"
hud_group8_width            "64"
hud_group9_align_x          "left"
hud_group9_align_y          "top"
hud_group9_alpha            "1"
hud_group9_frame            ".5"
hud_group9_height           "64"
hud_group9_name             "group9"
hud_group9_picture          ""
hud_group9_place            "screen"
hud_group9_pos_x            "0"
hud_group9_pos_y            "0"
hud_group9_show             "0"
hud_group9_tile             "0"
hud_group9_width            "64"
hud_gun2_align_x            "after"
hud_gun2_align_y            "top"
hud_gun2_frame              "0"
hud_gun2_place              "quad"
hud_gun2_pos_x              "4"
hud_gun2_pos_y              "0"
hud_gun2_scale              "1"
hud_gun2_show               "0"
hud_gun2_style              "0"
hud_gun3_align_x            "after"
hud_gun3_align_y            "center"
hud_gun3_frame              "0"
hud_gun3_place              "quad"
hud_gun3_pos_x              "2"
hud_gun3_pos_y              "0"
hud_gun3_scale              "1"
hud_gun3_show               "1"
hud_gun3_style              "0"
hud_gun4_align_x            "after"
hud_gun4_align_y            "center"
hud_gun4_frame              "0"
hud_gun4_place              "gun3"
hud_gun4_pos_x              "0"
hud_gun4_pos_y              "0"
hud_gun4_scale              "1"
hud_gun4_show               "0"
hud_gun4_style              "0"
hud_gun5_align_x            "after"
hud_gun5_align_y            "center"
hud_gun5_frame              "0"
hud_gun5_place              "gun3"
hud_gun5_pos_x              "-1"
hud_gun5_pos_y              "0"
hud_gun5_scale              "1"
hud_gun5_show               "1"
hud_gun5_style              "0"
hud_gun6_align_x            "after"
hud_gun6_align_y            "center"
hud_gun6_frame              "0"
hud_gun6_place              "gun5"
hud_gun6_pos_x              "-1"
hud_gun6_pos_y              "0"
hud_gun6_scale              "1"
hud_gun6_show               "1"
hud_gun6_style              "0"
hud_gun7_align_x            "after"
hud_gun7_align_y            "center"
hud_gun7_frame              "0"
hud_gun7_place              "gun6"
hud_gun7_pos_x              "-1"
hud_gun7_pos_y              "0"
hud_gun7_scale              "1"
hud_gun7_show               "1"
hud_gun7_style              "0"
hud_gun8_align_x            "after"
hud_gun8_align_y            "center"
hud_gun8_frame              "0"
hud_gun8_place              "gun7"
hud_gun8_pos_x              "-1"
hud_gun8_pos_y              "0"
hud_gun8_scale              "1"
hud_gun8_show               "1"
hud_gun8_style              "0"
hud_gun8_wide               "0"
hud_gun_align_x             "center"
hud_gun_align_y             "bottom"
hud_gun_frame               "0"
hud_gun_place               "top"
hud_gun_pos_x               "0"
hud_gun_pos_y               "0"
hud_gun_scale               "1"
hud_gun_show                "0"
hud_gun_style               "0"
hud_gun_wide                "0"
hud_health_align            "right"
hud_health_align_x          "left"
hud_health_align_y          "top"
hud_health_digits           "3"
hud_health_frame            "0"
hud_health_place            "face"
hud_health_pos_x            "26"
hud_health_pos_y            "0"
hud_health_scale            "1"
hud_health_show             "1"
hud_health_style            "0"
hud_healthdamage_align      "right"
hud_healthdamage_align_x    "left"
hud_healthdamage_align_y    "before"
hud_healthdamage_digits     "3"
hud_healthdamage_duration   "0.8"
hud_healthdamage_frame      "0"
hud_healthdamage_place      "health"
hud_healthdamage_pos_x      "0"
hud_healthdamage_pos_y      "0"
hud_healthdamage_scale      "1"
hud_healthdamage_show       "0"
hud_healthdamage_style      "0"
hud_iammo1_align_x          "left"
hud_iammo1_align_y          "top"
hud_iammo1_frame            "0"
hud_iammo1_place            "group2"
hud_iammo1_pos_x            "4"
hud_iammo1_pos_y            "4"
hud_iammo1_scale            "1"
hud_iammo1_show             "1"
hud_iammo1_style            "0"
hud_iammo2_align_x          "left"
hud_iammo2_align_y          "top"
hud_iammo2_frame            "0"
hud_iammo2_place            "iammo1"
hud_iammo2_pos_x            "0"
hud_iammo2_pos_y            "28"
hud_iammo2_scale            "1"
hud_iammo2_show             "1"
hud_iammo2_style            "0"
hud_iammo3_align_x          "left"
hud_iammo3_align_y          "top"
hud_iammo3_frame            "0"
hud_iammo3_place            "iammo2"
hud_iammo3_pos_x            "0"
hud_iammo3_pos_y            "28"
hud_iammo3_scale            "1"
hud_iammo3_show             "1"
hud_iammo3_style            "0"
hud_iammo4_align_x          "left"
hud_iammo4_align_y          "top"
hud_iammo4_frame            "0"
hud_iammo4_place            "iammo3"
hud_iammo4_pos_x            "0"
hud_iammo4_pos_y            "28"
hud_iammo4_scale            "1"
hud_iammo4_show             "1"
hud_iammo4_style            "0"
hud_iammo_align_x           "left"
hud_iammo_align_y           "top"
hud_iammo_frame             "0"
hud_iammo_place             "screen"
hud_iammo_pos_x             "0"
hud_iammo_pos_y             "0"
hud_iammo_scale             "1"
hud_iammo_show              "0"
hud_iammo_style             "0"
hud_iarmor_align_x          "left"
hud_iarmor_align_y          "top"
hud_iarmor_frame            "0"
hud_iarmor_place            "group1"
hud_iarmor_pos_x            "4"
hud_iarmor_pos_y            "4"
hud_iarmor_scale            "1"
hud_iarmor_show             "1"
hud_iarmor_style            "0"
hud_key1_align_x            "top"
hud_key1_align_y            "left"
hud_key1_frame              "0"
hud_key1_place              "group3"
hud_key1_pos_x              "4"
hud_key1_pos_y              "4"
hud_key1_scale              "1"
hud_key1_show               "1"
hud_key1_style              "0"
hud_key2_align_x            "after"
hud_key2_align_y            "top"
hud_key2_frame              "0"
hud_key2_place              "key1"
hud_key2_pos_x              "0"
hud_key2_pos_y              "0"
hud_key2_scale              "1"
hud_key2_show               "1"
hud_key2_style              "0"
hud_mp3_time_align_x        "left"
hud_mp3_time_align_y        "bottom"
hud_mp3_time_frame          "0"
hud_mp3_time_on_scoreboard  "0"
hud_mp3_time_place          "top"
hud_mp3_time_pos_x          "0"
hud_mp3_time_pos_y          "0"
hud_mp3_time_show           "0"
hud_mp3_time_style          "0"
hud_mp3_title_align_x       "center"
hud_mp3_title_align_y       "bottom"
hud_mp3_title_frame         "0"
hud_mp3_title_height        "8"
hud_mp3_title_on_scoreboard "0"
hud_mp3_title_place         "screen"
hud_mp3_title_pos_x         "0"
hud_mp3_title_pos_y         "0"
hud_mp3_title_scroll        "0"
hud_mp3_title_scroll_delay  "0.2"
hud_mp3_title_show          "0"
hud_mp3_title_style         "0"
hud_mp3_title_width         "256"
hud_mp3_title_wordwrap      "0"
hud_net_align_x             "left"
hud_net_align_y             "center"
hud_net_frame               "0.2"
hud_net_period              "1"
hud_net_place               "top"
hud_net_pos_x               "10"
hud_net_pos_y               "0"
hud_net_show                "0"
hud_netgraph_align_x        "center"
hud_netgraph_align_y        "before"
hud_netgraph_alpha          "1"
hud_netgraph_frame          "0.5"
hud_netgraph_full           "1"
hud_netgraph_height         "28"
hud_netgraph_inframes       "0"
hud_netgraph_lostscale      "1"
hud_netgraph_place          "group4"
hud_netgraph_ploss          "0"
hud_netgraph_pos_x          "0"
hud_netgraph_pos_y          "-2"
hud_netgraph_scale          "256"
hud_netgraph_show           "0"
hud_netgraph_swap_x         "0"
hud_netgraph_swap_y         "0"
hud_netgraph_width          "170"
hud_pent_align_x            "after"
hud_pent_align_y            "top"
hud_pent_frame              "0"
hud_pent_place              "ring"
hud_pent_pos_x              "0"
hud_pent_pos_y              "0"
hud_pent_scale              "1"
hud_pent_show               "1"
hud_pent_style              "0"
hud_ping_align_x            "left"
hud_ping_align_y            "center"
hud_ping_blink              "0"
hud_ping_frame              "0"
hud_ping_period             "1"
hud_ping_place              "group4"
hud_ping_pos_x              "4"
hud_ping_pos_y              "0"
hud_ping_show               "1"
hud_ping_show_dev           "0"
hud_ping_show_max           "0"
hud_ping_show_min           "0"
hud_ping_show_pl            "1"
hud_quad_align_x            "after"
hud_quad_align_y            "top"
hud_quad_frame              "0"
hud_quad_place              "pent"
hud_quad_pos_x              "0"
hud_quad_pos_y              "0"
hud_quad_scale              "1"
hud_quad_show               "1"
hud_quad_style              "0"
hud_ring_align_x            "after"
hud_ring_align_y            "top"
hud_ring_frame              "0"
hud_ring_place              "key2"
hud_ring_pos_x              "2"
hud_ring_pos_y              "0"
hud_ring_scale              "1"
hud_ring_show               "1"
hud_ring_style              "0"
hud_sigil1_align_x          "left"
hud_sigil1_align_y          "top"
hud_sigil1_frame            "0"
hud_sigil1_place            "screen"
hud_sigil1_pos_x            "0"
hud_sigil1_pos_y            "0"
hud_sigil1_scale            "1"
hud_sigil1_show             "0"
hud_sigil1_style            "0"
hud_sigil2_align_x          "after"
hud_sigil2_align_y          "top"
hud_sigil2_frame            "0"
hud_sigil2_place            "sigil1"
hud_sigil2_pos_x            "0"
hud_sigil2_pos_y            "0"
hud_sigil2_scale            "1"
hud_sigil2_show             "0"
hud_sigil2_style            "0"
hud_sigil3_align_x          "after"
hud_sigil3_align_y          "top"
hud_sigil3_frame            "0"
hud_sigil3_place            "sigil2"
hud_sigil3_pos_x            "0"
hud_sigil3_pos_y            "0"
hud_sigil3_scale            "1"
hud_sigil3_show             "0"
hud_sigil3_style            "0"
hud_sigil4_align_x          "after"
hud_sigil4_align_y          "top"
hud_sigil4_frame            "0"
hud_sigil4_place            "sigil3"
hud_sigil4_pos_x            "0"
hud_sigil4_pos_y            "0"
hud_sigil4_scale            "1"
hud_sigil4_show             "0"
hud_sigil4_style            "0"
hud_speed_align_x           "center"
hud_speed_align_y           "after"
hud_speed_frame             "0.5"
hud_speed_place             "group4"
hud_speed_pos_x             "0"
hud_speed_pos_y             "-79"
hud_speed_show              "0"
hud_speed_xyz               "1"
hud_suit_align_x            "after"
hud_suit_align_y            "top"
hud_suit_frame              "0"
hud_suit_place              "pent"
hud_suit_pos_x              "0"
hud_suit_pos_y              "0"
hud_suit_scale              "1"
hud_suit_show               "0"
hud_suit_style              "0"
hud_teamfrags_align_x       "after"
hud_teamfrags_align_y       "center"
hud_teamfrags_cell_height   "8"
hud_teamfrags_cell_width    "44"
hud_teamfrags_cols          "1"
hud_teamfrags_fliptext      "1"
hud_teamfrags_frame         "0"
hud_teamfrags_padtext       "1"
hud_teamfrags_place         "group2"
hud_teamfrags_pos_x         "4"
hud_teamfrags_pos_y         "0"
hud_teamfrags_rows          "2"
hud_teamfrags_show          "1"
hud_teamfrags_shownames     "1"
hud_teamfrags_space_x       "0"
hud_teamfrags_space_y       "1"
hud_teamfrags_strip         "1"
hud_teamfrags_style         "0"
hud_teamfrags_vertical      "1"
hud_tracking_align_x        "center"
hud_tracking_align_y        "before"
hud_tracking_format         "pov: %t %n"
hud_tracking_frame          "0"
hud_tracking_place          "frags"
hud_tracking_pos_x          "0"
hud_tracking_pos_y          "0"
hud_tracking_show           "1"
hud_recalculate


================================================
FILE: misc/cfg/hud_dobbz.cfg
================================================
echo Head Up Configuration by Dobbz
echo Use with conwidth 400 and higher

//
// Head Up Display Configuration Dump
//

scr_newhud                  "1"
hud_ammo1_align             "right"
hud_ammo1_align_x           "before"
hud_ammo1_align_y           "center"
hud_ammo1_digits            "3"
hud_ammo1_frame             "0"
hud_ammo1_place             "iammo1"
hud_ammo1_pos_x             "-2"
hud_ammo1_pos_y             "0"
hud_ammo1_scale             ".65"
hud_ammo1_show              "1"
hud_ammo1_style             "0"
hud_ammo2_align             "right"
hud_ammo2_align_x           "before"
hud_ammo2_align_y           "center"
hud_ammo2_digits            "3"
hud_ammo2_frame             "0"
hud_ammo2_place             "iammo2"
hud_ammo2_pos_x             "-2"
hud_ammo2_pos_y             "0"
hud_ammo2_scale             ".65"
hud_ammo2_show              "1"
hud_ammo2_style             "0"
hud_ammo3_align             "right"
hud_ammo3_align_x           "before"
hud_ammo3_align_y           "center"
hud_ammo3_digits            "3"
hud_ammo3_frame             "0"
hud_ammo3_place             "iammo3"
hud_ammo3_pos_x             "-2"
hud_ammo3_pos_y             "0"
hud_ammo3_scale             ".65"
hud_ammo3_show              "1"
hud_ammo3_style             "0"
hud_ammo4_align             "right"
hud_ammo4_align_x           "before"
hud_ammo4_align_y           "center"
hud_ammo4_digits            "3"
hud_ammo4_frame             "0"
hud_ammo4_place             "iammo4"
hud_ammo4_pos_x             "-2"
hud_ammo4_pos_y             "0"
hud_ammo4_scale             ".65"
hud_ammo4_show              "1"
hud_ammo4_style             "0"
hud_ammo_align              "right"
hud_ammo_align_x            "left"
hud_ammo_align_y            "top"
hud_ammo_digits             "3"
hud_ammo_frame              "0"
hud_ammo_place              "screen"
hud_ammo_pos_x              "0"
hud_ammo_pos_y              "0"
hud_ammo_scale              "1"
hud_ammo_show               "0"
hud_ammo_style              "0"
hud_armor_align             "left"
hud_armor_align_x           "after"
hud_armor_align_y           "center"
hud_armor_digits            "3"
hud_armor_frame             "0"
hud_armor_place             "iarmor"
hud_armor_pos_x             "3"
hud_armor_pos_y             "0"
hud_armor_scale             "1.25"
hud_armor_show              "1"
hud_armor_style             "0"
hud_armordamage_align       "right"
hud_armordamage_align_x     "left"
hud_armordamage_align_y     "before"
hud_armordamage_digits      "3"
hud_armordamage_duration    "0.8"
hud_armordamage_frame       "0"
hud_armordamage_place       "armor"
hud_armordamage_pos_x       "0"
hud_armordamage_pos_y       "0"
hud_armordamage_scale       "1"
hud_armordamage_show        "0"
hud_armordamage_style       "0"
hud_clock_align_x           "right"
hud_clock_align_y           "console"
hud_clock_big               "1"
hud_clock_blink             "1"
hud_clock_frame             "0"
hud_clock_place             "top"
hud_clock_pos_x             "0"
hud_clock_pos_y             "0"
hud_clock_scale             "1"
hud_clock_show              "0"
hud_clock_style             "0"
hud_face_align_x            "left"
hud_face_align_y            "bottom"
hud_face_frame              "0"
hud_face_place              "screen"
hud_face_pos_x              "2"
hud_face_pos_y              "-2"
hud_face_scale              "1.25"
hud_face_show               "1"
hud_fps_align_x             "right"
hud_fps_align_y             "bottom"
hud_fps_decimals            "0"
hud_fps_frame               "0"
hud_fps_place               "top"
hud_fps_pos_x               "0"
hud_fps_pos_y               "0"
hud_fps_show                "0"
hud_fps_show_min            "0"
hud_fps_title               "1"
hud_frags_align_x           "left"
hud_frags_align_y           "top"
hud_frags_cell_height       "8"
hud_frags_cell_width        "32"
hud_frags_cols              "4"
hud_frags_fliptext          "0"
hud_frags_frame             "0"
hud_frags_padtext           "1"
hud_frags_place             "screen"
hud_frags_pos_x             "0"
hud_frags_pos_y             "0"
hud_frags_rows              "1"
hud_frags_show              "0"
hud_frags_shownames         "0"
hud_frags_showself_always   "1"
hud_frags_showteams         "0"
hud_frags_space_x           "1"
hud_frags_space_y           "1"
hud_frags_strip             "1"
hud_frags_style             "0"
hud_frags_teamsort          "0"
hud_frags_vertical          "0"
hud_gameclock_align_x       "right"
hud_gameclock_align_y       "before"
hud_gameclock_big           "1"
hud_gameclock_blink         "1"
hud_gameclock_countdown     "0"
hud_gameclock_frame         "0"
hud_gameclock_place         "iammo1"
hud_gameclock_pos_x         "0"
hud_gameclock_pos_y         "0"
hud_gameclock_scale         "0.65"
hud_gameclock_show          "1"
hud_gameclock_style         "0"
hud_group1_align_x          "left"
hud_group1_align_y          "bottom"
hud_group1_alpha            ".2"
hud_group1_frame            ".5"
hud_group1_height           "64"
hud_group1_name             "group1"
hud_group1_picture          ""
hud_group1_place            "screen"
hud_group1_pos_x            "0"
hud_group1_pos_y            "0"
hud_group1_show             "0"
hud_group1_tile             "0"
hud_group1_width            "110"
hud_group2_align_x          "left"
hud_group2_align_y          "top"
hud_group2_alpha            "1"
hud_group2_frame            ".5"
hud_group2_height           "64"
hud_group2_name             "group2"
hud_group2_picture          ""
hud_group2_place            "screen"
hud_group2_pos_x            "0"
hud_group2_pos_y            "0"
hud_group2_show             "0"
hud_group2_tile             "0"
hud_group2_width            "64"
hud_group3_align_x          "left"
hud_group3_align_y          "top"
hud_group3_alpha            "1"
hud_group3_frame            ".5"
hud_group3_height           "64"
hud_group3_name             "group3"
hud_group3_picture          ""
hud_group3_place            "screen"
hud_group3_pos_x            "0"
hud_group3_pos_y            "0"
hud_group3_show             "0"
hud_group3_tile             "0"
hud_group3_width            "64"
hud_group4_align_x          "left"
hud_group4_align_y          "top"
hud_group4_alpha            "1"
hud_group4_frame            ".5"
hud_group4_height           "64"
hud_group4_name             "group4"
hud_group4_picture          ""
hud_group4_place            "screen"
hud_group4_pos_x            "0"
hud_group4_pos_y            "0"
hud_group4_show             "0"
hud_group4_tile             "0"
hud_group4_width            "64"
hud_group5_align_x          "left"
hud_group5_align_y          "top"
hud_group5_alpha            "1"
hud_group5_frame            ".5"
hud_group5_height           "64"
hud_group5_name             "group5"
hud_group5_picture          ""
hud_group5_place            "screen"
hud_group5_pos_x            "0"
hud_group5_pos_y            "0"
hud_group5_show             "0"
hud_group5_tile             "0"
hud_group5_width            "64"
hud_group6_align_x          "left"
hud_group6_align_y          "top"
hud_group6_alpha            "1"
hud_group6_frame            ".5"
hud_group6_height           "64"
hud_group6_name             "group6"
hud_group6_picture          ""
hud_group6_place            "screen"
hud_group6_pos_x            "0"
hud_group6_pos_y            "0"
hud_group6_show             "0"
hud_group6_tile             "0"
hud_group6_width            "64"
hud_group7_align_x          "left"
hud_group7_align_y          "top"
hud_group7_alpha            "1"
hud_group7_frame            ".5"
hud_group7_height           "64"
hud_group7_name             "group7"
hud_group7_picture          ""
hud_group7_place            "screen"
hud_group7_pos_x            "0"
hud_group7_pos_y            "0"
hud_group7_show             "0"
hud_group7_tile             "0"
hud_group7_width            "64"
hud_group8_align_x          "left"
hud_group8_align_y          "top"
hud_group8_alpha            "1"
hud_group8_frame            ".5"
hud_group8_height           "64"
hud_group8_name             "group8"
hud_group8_picture          ""
hud_group8_place            "screen"
hud_group8_pos_x            "0"
hud_group8_pos_y            "0"
hud_group8_show             "0"
hud_group8_tile             "0"
hud_group8_width            "64"
hud_group9_align_x          "left"
hud_group9_align_y          "top"
hud_group9_alpha            "1"
hud_group9_frame            ".5"
hud_group9_height           "64"
hud_group9_name             "group9"
hud_group9_picture          ""
hud_group9_place            "screen"
hud_group9_pos_x            "0"
hud_group9_pos_y            "0"
hud_group9_show             "0"
hud_group9_tile             "0"
hud_group9_width            "64"
hud_gun2_align_x            "left"
hud_gun2_align_y            "bottom"
hud_gun2_frame              "0"
hud_gun2_place              "top"
hud_gun2_pos_x              "0"
hud_gun2_pos_y              "0"
hud_gun2_scale              "1"
hud_gun2_show               "0"
hud_gun2_style              "0"
hud_gun3_align_x            "center"
hud_gun3_align_y            "bottom"
hud_gun3_frame              "0"
hud_gun3_place              "screen"
hud_gun3_pos_x              "41"
hud_gun3_pos_y              "0"
hud_gun3_scale              "1"
hud_gun3_show               "0"
hud_gun3_style              "0"
hud_gun4_align_x            "after"
hud_gun4_align_y            "center"
hud_gun4_frame              "0"
hud_gun4_place              "gun3"
hud_gun4_pos_x              "-14"
hud_gun4_pos_y              "0"
hud_gun4_scale              "1"
hud_gun4_show               "1"
hud_gun4_style              "0"
hud_gun5_align_x            "after"
hud_gun5_align_y            "center"
hud_gun5_frame              "0"
hud_gun5_place              "gun4"
hud_gun5_pos_x              "-14"
hud_gun5_pos_y              "0"
hud_gun5_scale              "1"
hud_gun5_show               "1"
hud_gun5_style              "0"
hud_gun6_align_x            "after"
hud_gun6_align_y            "center"
hud_gun6_frame              "0"
hud_gun6_place              "gun5"
hud_gun6_pos_x              "-14"
hud_gun6_pos_y              "0"
hud_gun6_scale              "1"
hud_gun6_show               "1"
hud_gun6_style              "0"
hud_gun7_align_x            "after"
hud_gun7_align_y            "center"
hud_gun7_frame              "0"
hud_gun7_place              "gun6"
hud_gun7_pos_x              "-14"
hud_gun7_pos_y              "0"
hud_gun7_scale              "1"
hud_gun7_show               "1"
hud_gun7_style              "0"
hud_gun8_align_x            "after"
hud_gun8_align_y            "center"
hud_gun8_frame              "0"
hud_gun8_place              "gun7"
hud_gun8_pos_x              "-14"
hud_gun8_pos_y              "0"
hud_gun8_scale              "1"
hud_gun8_show               "1"
hud_gun8_style              "0"
hud_gun8_wide               "0"
hud_gun_align_x             "center"
hud_gun_align_y             "bottom"
hud_gun_frame               "0"
hud_gun_place               "top"
hud_gun_pos_x               "0"
hud_gun_pos_y               "0"
hud_gun_scale               "1"
hud_gun_show                "0"
hud_gun_style               "0"
hud_gun_wide                "0"
hud_health_align            "bottom left"
hud_health_align_x          "after"
hud_health_align_y          "center"
hud_health_digits           "3"
hud_health_frame            "0"
hud_health_place            "face"
hud_health_pos_x            "3"
hud_health_pos_y            "0"
hud_health_scale            "1.25"
hud_health_show             "1"
hud_health_style            "0"
hud_healthdamage_align      "right"
hud_healthdamage_align_x    "left"
hud_healthdamage_align_y    "before"
hud_healthdamage_digits     "3"
hud_healthdamage_duration   "0.8"
hud_healthdamage_frame      "0"
hud_healthdamage_place      "health"
hud_healthdamage_pos_x      "0"
hud_healthdamage_pos_y      "0"
hud_healthdamage_scale      "1"
hud_healthdamage_show       "0"
hud_healthdamage_style      "0"
hud_iammo1_align_x          "center"
hud_iammo1_align_y          "before"
hud_iammo1_frame            "0"
hud_iammo1_place            "iammo2"
hud_iammo1_pos_x            "0"
hud_iammo1_pos_y            "-2"
hud_iammo1_scale            ".65"
hud_iammo1_show             "1"
hud_iammo1_style            "0"
hud_iammo2_align_x          "center"
hud_iammo2_align_y          "before"
hud_iammo2_frame            "0"
hud_iammo2_place            "iammo3"
hud_iammo2_pos_x            "0"
hud_iammo2_pos_y            "-2"
hud_iammo2_scale            ".65"
hud_iammo2_show             "1"
hud_iammo2_style            "0"
hud_iammo3_align_x          "center"
hud_iammo3_align_y          "before"
hud_iammo3_frame            "0"
hud_iammo3_place            "iammo4"
hud_iammo3_pos_x            "0"
hud_iammo3_pos_y            "-2"
hud_iammo3_scale            ".65"
hud_iammo3_show             "1"
hud_iammo3_style            "0"
hud_iammo4_align_x          "right"
hud_iammo4_align_y          "bottom"
hud_iammo4_frame            "0"
hud_iammo4_place            "screen"
hud_iammo4_pos_x            "-2"
hud_iammo4_pos_y            "-2"
hud_iammo4_scale            ".65"
hud_iammo4_show             "1"
hud_iammo4_style            "0"
hud_iammo_align_x           "left"
hud_iammo_align_y           "top"
hud_iammo_frame             "0"
hud_iammo_place             "screen"
hud_iammo_pos_x             "0"
hud_iammo_pos_y             "0"
hud_iammo_scale             "1"
hud_iammo_show              "0"
hud_iammo_style             "0"
hud_iarmor_align_x          "left"
hud_iarmor_align_y          "before"
hud_iarmor_frame            "0"
hud_iarmor_place            "face"
hud_iarmor_pos_x            "0"
hud_iarmor_pos_y            "-2"
hud_iarmor_scale            "1.25"
hud_iarmor_show             "1"
hud_iarmor_style            "0"
hud_key1_align_x            "top"
hud_key1_align_y            "left"
hud_key1_frame              "0"
hud_key1_place              "top"
hud_key1_pos_x              "0"
hud_key1_pos_y              "64"
hud_key1_scale              "1"
hud_key1_show               "0"
hud_key1_style              "0"
hud_key2_align_x            "left"
hud_key2_align_y            "after"
hud_key2_frame              "0"
hud_key2_place              "key1"
hud_key2_pos_x              "0"
hud_key2_pos_y              "0"
hud_key2_scale              "1"
hud_key2_show               "0"
hud_key2_style              "0"
hud_mp3_time_align_x        "left"
hud_mp3_time_align_y        "bottom"
hud_mp3_time_frame          "0"
hud_mp3_time_on_scoreboard  "0"
hud_mp3_time_place          "top"
hud_mp3_time_pos_x          "0"
hud_mp3_time_pos_y          "0"
hud_mp3_time_show           "0"
hud_mp3_time_style          "0"
hud_mp3_title_align_x       "center"
hud_mp3_title_align_y       "bottom"
hud_mp3_title_frame         "0"
hud_mp3_title_height        "8"
hud_mp3_title_on_scoreboard "0"
hud_mp3_title_place         "screen"
hud_mp3_title_pos_x         "0"
hud_mp3_title_pos_y         "0"
hud_mp3_title_scroll        "0"
hud_mp3_title_scroll_delay  "0.2"
hud_mp3_title_show          "0"
hud_mp3_title_style         "0"
hud_mp3_title_width         "256"
hud_mp3_title_wordwrap      "0"
hud_net_align_x             "left"
hud_net_align_y             "center"
hud_net_frame               "0.2"
hud_net_period              "1"
hud_net_place               "top"
hud_net_pos_x               "0"
hud_net_pos_y               "0"
hud_net_show                "0"
hud_netgraph_align_x        "left"
hud_netgraph_align_y        "bottom"
hud_netgraph_alpha          "1"
hud_netgraph_frame          "0"
hud_netgraph_full           "0"
hud_netgraph_height         "32"
hud_netgraph_inframes       "0"
hud_netgraph_lostscale      "1"
hud_netgraph_place          "top"
hud_netgraph_ploss          "1"
hud_netgraph_pos_x          "0"
hud_netgraph_pos_y          "0"
hud_netgraph_scale          "256"
hud_netgraph_show           "0"
hud_netgraph_swap_x         "0"
hud_netgraph_swap_y         "0"
hud_netgraph_width          "256"
hud_pent_align_x            "left"
hud_pent_align_y            "after"
hud_pent_frame              "0"
hud_pent_place              "ring"
hud_pent_pos_x              "0"
hud_pent_pos_y              "0"
hud_pent_scale              "1"
hud_pent_show               "0"
hud_pent_style              "0"
hud_ping_align_x            "center"
hud_ping_align_y            "bottom"
hud_ping_blink              "0"
hud_ping_frame              "0"
hud_ping_period             "1"
hud_ping_place              "screen"
hud_ping_pos_x              "0"
hud_ping_pos_y              "0"
hud_ping_show               "0"
hud_ping_show_dev           "0"
hud_ping_show_max           "0"
hud_ping_show_min           "0"
hud_ping_show_pl            "0"
hud_quad_align_x            "left"
hud_quad_align_y            "after"
hud_quad_frame              "0"
hud_quad_place              "suit"
hud_quad_pos_x              "0"
hud_quad_pos_y              "0"
hud_quad_scale              "1"
hud_quad_show               "0"
hud_quad_style              "0"
hud_ring_align_x            "left"
hud_ring_align_y            "after"
hud_ring_frame              "0"
hud_ring_place              "key2"
hud_ring_pos_x              "0"
hud_ring_pos_y              "0"
hud_ring_scale              "1"
hud_ring_show               "0"
hud_ring_style              "0"
hud_sigil1_align_x          "left"
hud_sigil1_align_y          "top"
hud_sigil1_frame            "0"
hud_sigil1_place            "screen"
hud_sigil1_pos_x            "0"
hud_sigil1_pos_y            "0"
hud_sigil1_scale            "1"
hud_sigil1_show             "0"
hud_sigil1_style            "0"
hud_sigil2_align_x          "after"
hud_sigil2_align_y          "top"
hud_sigil2_frame            "0"
hud_sigil2_place            "sigil1"
hud_sigil2_pos_x            "0"
hud_sigil2_pos_y            "0"
hud_sigil2_scale            "1"
hud_sigil2_show             "0"
hud_sigil2_style            "0"
hud_sigil3_align_x          "after"
hud_sigil3_align_y          "top"
hud_sigil3_frame            "0"
hud_sigil3_place            "sigil2"
hud_sigil3_pos_x            "0"
hud_sigil3_pos_y            "0"
hud_sigil3_scale            "1"
hud_sigil3_show             "0"
hud_sigil3_style            "0"
hud_sigil4_align_x          "after"
hud_sigil4_align_y          "top"
hud_sigil4_frame            "0"
hud_sigil4_place            "sigil3"
hud_sigil4_pos_x            "0"
hud_sigil4_pos_y            "0"
hud_sigil4_scale            "1"
hud_sigil4_show             "0"
hud_sigil4_style            "0"
hud_speed_align_x           "center"
hud_speed_align_y           "bottom"
hud_speed_frame             "0"
hud_speed_place             "top"
hud_speed_pos_x             "0"
hud_speed_pos_y             "-5"
hud_speed_show              "0"
hud_speed_xyz               "0"
hud_suit_align_x            "left"
hud_suit_align_y            "after"
hud_suit_frame              "0"
hud_suit_place              "pent"
hud_suit_pos_x              "0"
hud_suit_pos_y              "0"
hud_suit_scale              "1"
hud_suit_show               "0"
hud_suit_style              "0"
hud_teamfrags_align_x       "after"
hud_teamfrags_align_y       "center"
hud_teamfrags_cell_height   "8"
hud_teamfrags_cell_width    "44"
hud_teamfrags_cols          "1"
hud_teamfrags_fliptext      "1"
hud_teamfrags_frame         "0"
hud_teamfrags_padtext       "1"
hud_teamfrags_place         "group2"
hud_teamfrags_pos_x         "4"
hud_teamfrags_pos_y         "0"
hud_teamfrags_rows          "2"
hud_teamfrags_show          "1"
hud_teamfrags_shownames     "1"
hud_teamfrags_space_x       "0"
hud_teamfrags_space_y       "1"
hud_teamfrags_strip         "1"
hud_teamfrags_style         "0"
hud_teamfrags_vertical      "1"
hud_tracking_align_x        "center"
hud_tracking_align_y        "bottom"
hud_tracking_format         "pov: %t %n"
hud_tracking_frame          "0"
hud_tracking_place          "screen"
hud_tracking_pos_x          "0"
hud_tracking_pos_y          "0"
hud_tracking_show           "1"
hud_recalculate


================================================
FILE: misc/cfg/hud_empezar.cfg
================================================
echo Empezar's Head Up Display 

scr_newhud 1
cvar_reset_re hud_.
hide gameclock
hide mp3_title
show tracking
place tracking screen
align tracking center top
move tracking 0 0

//MQWCL HUD
hud_ammo1_align_x            "center"
hud_ammo1_align_y            "bottom"
hud_ammo1_pos_x              "-61"
hud_ammo1_pos_y              "-17"
hud_ammo1_show               "1"
hud_ammo1_style              "1"
hud_ammo2_align_x            "center"
hud_ammo2_align_y            "bottom"
hud_ammo2_pos_x              "-33"
hud_ammo2_pos_y              "-17"
hud_ammo2_show               "1"
hud_ammo2_style              "1"
hud_ammo3_align_x            "center"
hud_ammo3_align_y            "bottom"
hud_ammo3_pos_x              "32"
hud_ammo3_pos_y              "-17"
hud_ammo3_show               "1"
hud_ammo3_style              "1"
hud_ammo4_align_x            "center"
hud_ammo4_align_y            "bottom"
hud_ammo4_pos_x              "60"
hud_ammo4_pos_y              "-17"
hud_ammo4_show               "1"
hud_ammo4_style              "1"
hud_ammo_align               "center"
hud_ammo_align_x             "center"
hud_ammo_align_y             "bottom"
hud_ammo_pos_y               "-17"
hud_ammo_scale               "0.5"
hud_ammo_show                "1"
hud_armor_align              "left"
hud_armor_align_x            "center"
hud_armor_align_y            "bottom"
hud_armor_pos_x              "-56"
hud_armor_pos_y              "-25"
hud_armor_scale              "0.5"
hud_armor_show               "1"
hud_face_align_x             "center"
hud_face_align_y             "bottom"
hud_face_pos_x               "83"
hud_face_pos_y               "-25"
hud_face_scale               "0.5"
hud_face_show                "1"
hud_frags_align_x            "right"
hud_frags_align_y            "bottom"
hud_frags_cell_width         "28"
hud_frags_cols               "1"
hud_frags_rows               "8"
hud_frags_show               "1"
hud_frags_style              "2"
hud_gun2_align_x             "center"
hud_gun2_align_y             "bottom"
hud_gun2_place               "screen"
hud_gun2_pos_x               "-58"
hud_gun2_pos_y               "-7"
hud_gun2_scale               "0.7"
hud_gun2_show                "1"
hud_gun3_align_x             "center"
hud_gun3_align_y             "bottom"
hud_gun3_place               "screen"
hud_gun3_pos_x               "-57"
hud_gun3_scale               "0.7"
hud_gun3_show                "1"
hud_gun4_align_x             "center"
hud_gun4_align_y             "bottom"
hud_gun4_place               "screen"
hud_gun4_pos_x               "-29"
hud_gun4_pos_y               "-7"
hud_gun4_scale               "0.7"
hud_gun4_show                "1"
hud_gun5_align_x             "center"
hud_gun5_align_y             "bottom"
hud_gun5_place               "screen"
hud_gun5_pos_x               "-30"
hud_gun5_scale               "0.7"
hud_gun5_show                "1"
hud_gun6_align_x             "center"
hud_gun6_align_y             "bottom"
hud_gun6_place               "screen"
hud_gun6_pos_x               "35"
hud_gun6_pos_y               "-7"
hud_gun6_scale               "0.7"
hud_gun6_show                "1"
hud_gun7_align_x             "center"
hud_gun7_align_y             "bottom"
hud_gun7_place               "screen"
hud_gun7_pos_x               "35"
hud_gun7_scale               "0.7"
hud_gun7_show                "1"
hud_gun8_align_x             "center"
hud_gun8_align_y             "bottom"
hud_gun8_place               "screen"
hud_gun8_pos_x               "64"
hud_gun8_pos_y               "-6"
hud_gun8_scale               "0.7"
hud_gun8_show                "1"
hud_gun_place                "screen"
hud_gun_pos_y                "-26"
hud_gun_show                 "1"
hud_health_align_x           "center"
hud_health_align_y           "bottom"
hud_health_pos_x             "55"
hud_health_pos_y             "-25"
hud_health_scale             "0.5"
hud_health_show              "1"
hud_iarmor_align_x           "center"
hud_iarmor_align_y           "bottom"
hud_iarmor_pos_x             "-83"
hud_iarmor_pos_y             "-25"
hud_iarmor_scale             "0.5"
hud_iarmor_show              "1"
hud_pent_align_x             "center"
hud_pent_align_y             "bottom"
hud_pent_place               "screen"
hud_pent_pos_x               "33.7"
hud_pent_pos_y               "-42"
hud_pent_scale               "0.5"
hud_pent_show                "1"
hud_quad_align_x             "center"
hud_quad_align_y             "bottom"
hud_quad_place               "screen"
hud_quad_pos_x               "25"
hud_quad_pos_y               "-42"
hud_quad_scale               "0.5"
hud_quad_show                "1"
hud_ring_align_x             "center"
hud_ring_align_y             "bottom"
hud_ring_place               "screen"
hud_ring_pos_x               "41"
hud_ring_pos_y               "-42"
hud_ring_scale               "0.5"
hud_ring_show                "1"
hud_teamfrags_align_x        "right"
hud_teamfrags_align_y        "bottom"
hud_teamfrags_cols           "1"
hud_teamfrags_pos_x          "-29"
hud_teamfrags_rows           "2"
hud_teamfrags_show           "1"
hud_teamfrags_style          "2"

//Screen Settings
cl_gameclock                 "4"
cl_gameclock_x               "22.4"
cl_gameclock_y               "31.3"

hud_recalculate


================================================
FILE: misc/cfg/hud_murdoc.cfg
================================================
echo Murdoc's Head Up Display Configuration File
echo made for conwidth 512 conheigh 412

scr_newhud 1
cvar_reset_re hud_.

hud_ammo1_pos_x              "270"
hud_ammo1_pos_y              "395"
hud_ammo1_scale              "0.5"
hud_ammo1_show               "1"
hud_ammo2_pos_x              "330"
hud_ammo2_pos_y              "395"
hud_ammo2_scale              "0.5"
hud_ammo2_show               "1"
hud_ammo3_pos_x              "390"
hud_ammo3_pos_y              "395"
hud_ammo3_scale              "0.5"
hud_ammo3_show               "1"
hud_ammo4_pos_x              "450"
hud_ammo4_pos_y              "395"
hud_ammo4_scale              "0.5"
hud_ammo4_show               "1"
hud_ammo_pos_x               "430"
hud_ammo_pos_y               "385"
hud_armor_pos_x              "40"
hud_armor_pos_y              "385"
hud_armor_show               "1"
hud_face_pos_x               "130"
hud_face_pos_y               "386"
hud_face_show                "1"
hud_fps_pos_x                "-24"
hud_fps_pos_y                "-42"
hud_fps_show                 "1"
hud_fps_title                "0"
hud_gun2_pos_x               "279"
hud_gun2_pos_y               "-40"
hud_gun2_show                "1"
hud_gun3_pos_x               "-25"
hud_gun3_pos_y               "20"
hud_gun3_show                "1"
hud_gun4_pos_x               "35"
hud_gun4_pos_y               "-20"
hud_gun4_show                "1"
hud_gun5_pos_x               "-24"
hud_gun5_pos_y               "20"
hud_gun5_show                "1"
hud_gun6_pos_x               "36"
hud_gun6_pos_y               "-20"
hud_gun6_show                "1"
hud_gun7_pos_x               "-24"
hud_gun7_pos_y               "20"
hud_gun7_show                "1"
hud_gun8_pos_x               "35"
hud_gun8_show                "1"
hud_health_pos_x             "160"
hud_health_pos_y             "385"
hud_health_show              "1"
hud_iarmor_pos_x             "10"
hud_iarmor_pos_y             "387"
hud_iarmor_show              "1"

hud_recalculate


================================================
FILE: misc/cfg/hud_senft.cfg
================================================
scr_newhud                    "1"
hud_ammo1_align               "right"
hud_ammo1_align_x             "center"
hud_ammo1_align_y             "center"
hud_ammo1_digits              "3"
hud_ammo1_frame               "0"
hud_ammo1_frame_color         "0 0 0"
hud_ammo1_order               "2"
hud_ammo1_place               "group2"
hud_ammo1_pos_x               "0"
hud_ammo1_pos_y               "0"
hud_ammo1_scale               "0.65"
hud_ammo1_show                "1"
hud_ammo1_style               "0"
hud_ammo2_align               "right"
hud_ammo2_align_x             "center"
hud_ammo2_align_y             "center"
hud_ammo2_digits              "3"
hud_ammo2_frame               "0"
hud_ammo2_frame_color         "0 0 0"
hud_ammo2_order               "5"
hud_ammo2_place               "group4"
hud_ammo2_pos_x               "0"
hud_ammo2_pos_y               "0"
hud_ammo2_scale               "0.65"
hud_ammo2_show                "1"
hud_ammo2_style               "0"
hud_ammo3_align               "right"
hud_ammo3_align_x             "center"
hud_ammo3_align_y             "center"
hud_ammo3_digits              "3"
hud_ammo3_frame               "0"
hud_ammo3_frame_color         "0 0 0"
hud_ammo3_order               "4"
hud_ammo3_place               "group5"
hud_ammo3_pos_x               "0"
hud_ammo3_pos_y               "0"
hud_ammo3_scale               "0.65"
hud_ammo3_show                "1"
hud_ammo3_style               "0"
hud_ammo4_align               "right"
hud_ammo4_align_x             "center"
hud_ammo4_align_y             "bottom"
hud_ammo4_digits              "3"
hud_ammo4_frame               "0"
hud_ammo4_frame_color         "0 0 0"
hud_ammo4_order               "5"
hud_ammo4_place               "group6"
hud_ammo4_pos_x               "0"
hud_ammo4_pos_y               "-4"
hud_ammo4_scale               "0.65"
hud_ammo4_show                "1"
hud_ammo4_style               "0"
hud_ammo_align                "right"
hud_ammo_align_x              "center"
hud_ammo_align_y              "center"
hud_ammo_digits               "3"
hud_ammo_frame                "0"
hud_ammo_frame_color          "0 0 0"
hud_ammo_order                "2"
hud_ammo_place                "iammo"
hud_ammo_pos_x                "62"
hud_ammo_pos_y                "1"
hud_ammo_scale                "1.2"
hud_ammo_show                 "1"
hud_ammo_style                "0"
hud_armor_align               "right"
hud_armor_align_x             "right"
hud_armor_align_y             "top"
hud_armor_digits              "3"
hud_armor_frame               "0"
hud_armor_frame_color         "0 0 0"
hud_armor_order               "2"
hud_armor_place               "face"
hud_armor_pos_x               "88"
hud_armor_pos_y               "-1"
hud_armor_scale               "1.2"
hud_armor_show                "1"
hud_armor_style               "0"
hud_armordamage_align         "right"
hud_armordamage_align_x       "left"
hud_armordamage_align_y       "before"
hud_armordamage_digits        "3"
hud_armordamage_duration      "0.8"
hud_armordamage_frame         "0"
hud_armordamage_frame_color   "0 0 0"
hud_armordamage_order         "3"
hud_armordamage_place         "armor"
hud_armordamage_pos_x         "0"
hud_armordamage_pos_y         "0"
hud_armordamage_scale         "1"
hud_armordamage_show          "0"
hud_armordamage_style         "0"
hud_clock_align_x             "right"
hud_clock_align_y             "before"
hud_clock_big                 "0"
hud_clock_blink               "0"
hud_clock_frame               "0.5"
hud_clock_frame_color         "0 0 0"
hud_clock_order               "8"
hud_clock_place               "group2"
hud_clock_pos_x               "-2"
hud_clock_pos_y               "-2"
hud_clock_scale               "1"
hud_clock_show                "0"
hud_clock_style               "0"
hud_democlock_align_x         "right"
hud_democlock_align_y         "console"
hud_democlock_big             "0"
hud_democlock_blink           "0"
hud_democlock_frame           "0"
hud_democlock_frame_color     "0 0 0"
hud_democlock_order           "11"
hud_democlock_place           "tracking"
hud_democlock_pos_x           "-7"
hud_democlock_pos_y           "15"
hud_democlock_scale           "0.59"
hud_democlock_show            "0"
hud_democlock_style           "0"
hud_digits_trim               "1"
hud_editor_allowalign         "1"
hud_editor_allowmove          "1"
hud_editor_allowplace         "1"
hud_editor_allowresize        "1"
hud_face_align_x              "left"
hud_face_align_y              "bottom"
hud_face_frame                "0"
hud_face_frame_color          "0 0 0"
hud_face_order                "1"
hud_face_place                "screen"
hud_face_pos_x                "0"
hud_face_pos_y                "0"
hud_face_scale                "2.9"
hud_face_show                 "1"
hud_fps_align_x               "right"
hud_fps_align_y               "console"
hud_fps_decimals              "0"
hud_fps_frame                 "0"
hud_fps_frame_color           "0 0 0"
hud_fps_order                 "9"
hud_fps_place                 "screen"
hud_fps_pos_x                 "-2"
hud_fps_pos_y                 "2"
hud_fps_show                  "1"
hud_fps_show_min              "0"
hud_fps_title                 "1"
hud_frags_align_x             "right"
hud_frags_align_y             "bottom"
hud_frags_bignum              "0"
hud_frags_cell_height         "10"
hud_frags_cell_width          "26"
hud_frags_colors_alpha        "0.2"
hud_frags_cols                "1"
hud_frags_extra_spec_info     "0"
hud_frags_fliptext            "0"
hud_frags_frame               "0"
hud_frags_frame_color         "0 0 0"
hud_frags_maxname             "10"
hud_frags_order               "1"
hud_frags_padtext             "1"
hud_frags_place               "screen"
hud_frags_pos_x               "0"
hud_frags_pos_y               "0"
hud_frags_rows                "8"
hud_frags_show                "1"
hud_frags_shownames           "1"
hud_frags_showself_always     "1"
hud_frags_showteams           "1"
hud_frags_space_x             "0"
hud_frags_space_y             "2"
hud_frags_strip               "1"
hud_frags_style               "8"
hud_frags_teamsort            "1"
hud_frags_vertical            "0"
hud_gameclock_align_x         "center"
hud_gameclock_align_y         "center"
hud_gameclock_big             "1"
hud_gameclock_blink           "0"
hud_gameclock_countdown       "0"
hud_gameclock_frame           "0"
hud_gameclock_frame_color     "0 0 0"
hud_gameclock_order           "1"
hud_gameclock_place           "top"
hud_gameclock_pos_x           "0"
hud_gameclock_pos_y           "-67"
hud_gameclock_scale           "0.6"
hud_gameclock_show            "1"
hud_gameclock_style           "0"
hud_group1_align_x            "center"
hud_group1_align_y            "bottom"
hud_group1_frame              "0"
hud_group1_frame_color        "0 0 0"
hud_group1_height             "32"
hud_group1_name               "group1"
hud_group1_order              "0"
hud_group1_pic_alpha          "1.0"
hud_group1_pic_scalemode      "0"
hud_group1_picture            ""
hud_group1_place              "screen"
hud_group1_pos_x              "-22"
hud_group1_pos_y              "-11"
hud_group1_show               "0"
hud_group1_width              "172"
hud_group2_align_x            "left"
hud_group2_align_y            "center"
hud_group2_frame              ".5"
hud_group2_frame_color        "0 0 0"
hud_group2_height             "76"
hud_group2_name               "group2"
hud_group2_order              "0"
hud_group2_pic_alpha          "1.0"
hud_group2_pic_scalemode      "0"
hud_group2_picture            ""
hud_group2_place              "screen"
hud_group2_pos_x              "3"
hud_group2_pos_y              "-130"
hud_group2_show               "1"
hud_group2_width              "51"
hud_group3_align_x            "left"
hud_group3_align_y            "top"
hud_group3_frame              ".5"
hud_group3_frame_color        "0 0 0"
hud_group3_height             "23"
hud_group3_name               "group3"
hud_group3_order              "1"
hud_group3_pic_alpha          "1.0"
hud_group3_pic_scalemode      "0"
hud_group3_picture            ""
hud_group3_place              "group1"
hud_group3_pos_x              "0"
hud_group3_pos_y              "0"
hud_group3_show               "0"
hud_group3_width              "168"
hud_group4_align_x            "center"
hud_group4_align_y            "center"
hud_group4_frame              ".5"
hud_group4_frame_color        "0 0 0"
hud_group4_height             "76"
hud_group4_name               "group4"
hud_group4_order              "1"
hud_group4_pic_alpha          "1.0"
hud_group4_pic_scalemode      "0"
hud_group4_picture            ""
hud_group4_place              "group2"
hud_group4_pos_x              "0"
hud_group4_pos_y              "91"
hud_group4_show               "1"
hud_group4_width              "51"
hud_group5_align_x            "center"
hud_group5_align_y            "center"
hud_group5_frame              ".5"
hud_group5_frame_color        "0 0 0"
hud_group5_height             "76"
hud_group5_name               "group5"
hud_group5_order              "2"
hud_group5_pic_alpha          "1.0"
hud_group5_pic_scalemode      "0"
hud_group5_picture            ""
hud_group5_place              "group4"
hud_group5_pos_x              "0"
hud_group5_pos_y              "88"
hud_group5_show               "1"
hud_group5_width              "51"
hud_group6_align_x            "center"
hud_group6_align_y            "center"
hud_group6_frame              ".5"
hud_group6_frame_color        "0 0 0"
hud_group6_height             "48"
hud_group6_name               "group6"
hud_group6_order              "3"
hud_group6_pic_alpha          "1.0"
hud_group6_pic_scalemode      "0"
hud_group6_picture            ""
hud_group6_place              "group5"
hud_group6_pos_x              "0"
hud_group6_pos_y              "72"
hud_group6_show               "1"
hud_group6_width              "51"
hud_group7_align_x            "left"
hud_group7_align_y            "top"
hud_group7_frame              ".5"
hud_group7_frame_color        "0 0 0"
hud_group7_height             "64"
hud_group7_name               "group7"
hud_group7_order              "0"
hud_group7_pic_alpha          "1.0"
hud_group7_pic_scalemode      "0"
hud_group7_picture            ""
hud_group7_place              "screen"
hud_group7_pos_x              "0"
hud_group7_pos_y              "0"
hud_group7_show               "0"
hud_group7_width              "64"
hud_group8_align_x            "left"
hud_group8_align_y            "top"
hud_group8_frame              ".5"
hud_group8_frame_color        "0 0 0"
hud_group8_height             "64"
hud_group8_name               "group8"
hud_group8_order              "0"
hud_group8_pic_alpha          "1.0"
hud_group8_pic_scalemode      "0"
hud_group8_picture            ""
hud_group8_place              "screen"
hud_group8_pos_x              "0"
hud_group8_pos_y              "0"
hud_group8_show               "0"
hud_group8_width              "64"
hud_group9_align_x            "left"
hud_group9_align_y            "top"
hud_group9_frame              ".5"
hud_group9_frame_color        "0 0 0"
hud_group9_height             "64"
hud_group9_name               "group9"
hud_group9_order              "0"
hud_group9_pic_alpha          "1.0"
hud_group9_pic_scalemode      "0"
hud_group9_picture            ""
hud_group9_place              "screen"
hud_group9_pos_x              "0"
hud_group9_pos_y              "0"
hud_group9_show               "0"
hud_group9_width              "64"
hud_gun2_align_x              "center"
hud_gun2_align_y              "top"
hud_gun2_frame                "0"
hud_gun2_frame_color          "100 40 0"
hud_gun2_order                "2"
hud_gun2_place                "group2"
hud_gun2_pos_x                "13"
hud_gun2_pos_y                "5"
hud_gun2_scale                "1.7"
hud_gun2_show                 "1"
hud_gun2_style                "0"
hud_gun3_align_x              "center"
hud_gun3_align_y              "bottom"
hud_gun3_frame                "0"
hud_gun3_frame_color          "100 80 0"
hud_gun3_order                "3"
hud_gun3_place                "group2"
hud_gun3_pos_x                "9"
hud_gun3_pos_y                "4"
hud_gun3_scale                "1.7"
hud_gun3_show                 "1"
hud_gun3_style                "0"
hud_gun4_align_x              "center"
hud_gun4_align_y              "top"
hud_gun4_frame                "0"
hud_gun4_frame_color          "0 100 200"
hud_gun4_order                "3"
hud_gun4_place                "group4"
hud_gun4_pos_x                "12"
hud_gun4_pos_y                "11"
hud_gun4_scale                "1.7"
hud_gun4_show                 "1"
hud_gun4_style                "0"
hud_gun5_align_x              "center"
hud_gun5_align_y              "bottom"
hud_gun5_frame                "0"
hud_gun5_frame_color          "0 0 255"
hud_gun5_order                "4"
hud_gun5_place                "group4"
hud_gun5_pos_x                "11"
hud_gun5_pos_y                "4"
hud_gun5_scale                "1.7"
hud_gun5_show                 "1"
hud_gun5_style                "0"
hud_gun6_align_x              "center"
hud_gun6_align_y              "bottom"
hud_gun6_frame                "0"
hud_gun6_frame_color          "0 100 0"
hud_gun6_order                "4"
hud_gun6_place                "group5"
hud_gun6_pos_x                "13"
hud_gun6_pos_y                "4"
hud_gun6_scale                "1.7"
hud_gun6_show                 "1"
hud_gun6_style                "0"
hud_gun7_align_x              "center"
hud_gun7_align_y              "top"
hud_gun7_frame                "0"
hud_gun7_frame_color          "255 0 0"
hud_gun7_order                "3"
hud_gun7_place                "group5"
hud_gun7_pos_x                "8"
hud_gun7_pos_y                "2"
hud_gun7_scale                "1.7"
hud_gun7_show                 "1"
hud_gun7_style                "0"
hud_gun8_align_x              "center"
hud_gun8_align_y              "top"
hud_gun8_frame                "0"
hud_gun8_frame_color          "160 160 160"
hud_gun8_order                "4"
hud_gun8_place                "group6"
hud_gun8_pos_x                "13"
hud_gun8_pos_y                "5"
hud_gun8_scale                "1.7"
hud_gun8_show                 "1"
hud_gun8_style                "0"
hud_gun8_wide                 "0"
hud_gun_align_x               "center"
hud_gun_align_y               "bottom"
hud_gun_frame                 "0"
hud_gun_frame_color           "0 0 0"
hud_gun_order                 "0"
hud_gun_place                 "top"
hud_gun_pos_x                 "0"
hud_gun_pos_y                 "21"
hud_gun_scale                 "1"
hud_gun_show                  "0"
hud_gun_style                 "0"
hud_gun_wide                  "0"
hud_health_align              "right"
hud_health_align_x            "right"
hud_health_align_y            "bottom"
hud_health_digits             "3"
hud_health_frame              "0"
hud_health_frame_color        "0 0 0"
hud_health_order              "2"
hud_health_place              "face"
hud_health_pos_x              "116"
hud_health_pos_y              "-3"
hud_health_scale              "1.6"
hud_health_show               "1"
hud_health_style              "0"
hud_healthdamage_align        "right"
hud_healthdamage_align_x      "left"
hud_healthdamage_align_y      "before"
hud_healthdamage_digits       "3"
hud_healthdamage_duration     "0.8"
hud_healthdamage_frame        "0"
hud_healthdamage_frame_color  "0 0 0"
hud_healthdamage_order        "3"
hud_healthdamage_place        "health"
hud_healthdamage_pos_x        "0"
hud_healthdamage_pos_y        "0"
hud_healthdamage_scale        "1"
hud_healthdamage_show         "0"
hud_healthdamage_style        "0"
hud_iammo1_align_x            "center"
hud_iammo1_align_y            "center"
hud_iammo1_frame              "0"
hud_iammo1_frame_color        "0 0 0"
hud_iammo1_order              "3"
hud_iammo1_place              "ammo1"
hud_iammo1_pos_x              "30"
hud_iammo1_pos_y              "0"
hud_iammo1_scale              "0.55"
hud_iammo1_show               "0"
hud_iammo1_style              "0"
hud_iammo2_align_x            "center"
hud_iammo2_align_y            "center"
hud_iammo2_frame              "0"
hud_iammo2_frame_color        "0 0 0"
hud_iammo2_order              "6"
hud_iammo2_place              "ammo2"
hud_iammo2_pos_x              "30"
hud_iammo2_pos_y              "0"
hud_iammo2_scale              "0.55"
hud_iammo2_show               "0"
hud_iammo2_style              "0"
hud_iammo3_align_x            "center"
hud_iammo3_align_y            "center"
hud_iammo3_frame              "0"
hud_iammo3_frame_color        "0 0 0"
hud_iammo3_order              "5"
hud_iammo3_place              "ammo3"
hud_iammo3_pos_x              "30"
hud_iammo3_pos_y              "0"
hud_iammo3_scale              "0.55"
hud_iammo3_show               "0"
hud_iammo3_style              "0"
hud_iammo4_align_x            "center"
hud_iammo4_align_y            "center"
hud_iammo4_frame              "0"
hud_iammo4_frame_color        "0 0 0"
hud_iammo4_order              "6"
hud_iammo4_place              "ammo4"
hud_iammo4_pos_x              "30"
hud_iammo4_pos_y              "0"
hud_iammo4_scale              "0.55"
hud_iammo4_show               "0"
hud_iammo4_style              "0"
hud_iammo_align_x             "center"
hud_iammo_align_y             "center"
hud_iammo_frame               "0"
hud_iammo_frame_color         "0 0 0"
hud_iammo_order               "1"
hud_iammo_place               "screen"
hud_iammo_pos_x               "-124"
hud_iammo_pos_y               "223"
hud_iammo_scale               "1.44"
hud_iammo_show                "0"
hud_iammo_style               "0"
hud_iarmor_align_x            "center"
hud_iarmor_align_y            "center"
hud_iarmor_frame              "0"
hud_iarmor_frame_color        "0 0 0"
hud_iarmor_order              "3"
hud_iarmor_place              "armor"
hud_iarmor_pos_x              "54"
hud_iarmor_pos_y              "0"
hud_iarmor_scale              "1"
hud_iarmor_show               "1"
hud_iarmor_style              "0"
hud_key1_align_x              "left"
hud_key1_align_y              "top"
hud_key1_frame                "0"
hud_key1_frame_color          "0 0 0"
hud_key1_order                "4"
hud_key1_place                "frags"
hud_key1_pos_x                "0"
hud_key1_pos_y                "-25"
hud_key1_scale                "1.6"
hud_key1_show                 "1"
hud_key1_style                "0"
hud_key2_align_x              "after"
hud_key2_align_y              "top"
hud_key2_frame                "0"
hud_key2_frame_color          "0 0 0"
hud_key2_order                "5"
hud_key2_place                "key1"
hud_key2_pos_x                "0"
hud_key2_pos_y                "0"
hud_key2_scale                "1.6"
hud_key2_show                 "1"
hud_key2_style                "0"
hud_keys_align_x              "right"
hud_keys_align_y              "center"
hud_keys_frame                "0.5"
hud_keys_frame_color          "20 20 20"
hud_keys_order                "1"
hud_keys_place                "screen"
hud_keys_pos_x                "0"
hud_keys_pos_y                "0"
hud_keys_scale                "2"
hud_keys_show                 "0"
hud_mouserate_align_x         "left"
hud_mouserate_align_y         "bottom"
hud_mouserate_frame           "0"
hud_mouserate_frame_color     "0 0 0"
hud_mouserate_interval        "1"
hud_mouserate_order           "9"
hud_mouserate_place           "screen"
hud_mouserate_pos_x           "0"
hud_mouserate_pos_y           "0"
hud_mouserate_show            "0"
hud_mouserate_title           "1"
hud_mp3_time_align_x          "left"
hud_mp3_time_align_y          "bottom"
hud_mp3_time_frame            "0"
hud_mp3_time_frame_color      "0 0 0"
hud_mp3_time_on_scoreboard    "0"
hud_mp3_time_order            "0"
hud_mp3_time_place            "top"
hud_mp3_time_pos_x            "0"
hud_mp3_time_pos_y            "0"
hud_mp3_time_show             "0"
hud_mp3_time_style            "0"
hud_mp3_title_align_x         "center"
hud_mp3_title_align_y         "bottom"
hud_mp3_title_frame           "0"
hud_mp3_title_frame_color     "0 0 0"
hud_mp3_title_height          "8"
hud_mp3_title_on_scoreboard   "0"
hud_mp3_title_order           "0"
hud_mp3_title_place           "screen"
hud_mp3_title_pos_x           "0"
hud_mp3_title_pos_y           "0"
hud_mp3_title_scroll          "0"
hud_mp3_title_scroll_delay    "0.2"
hud_mp3_title_show            "0"
hud_mp3_title_style           "0"
hud_mp3_title_width           "256"
hud_mp3_title_wordwrap        "0"
hud_net_align_x               "left"
hud_net_align_y               "center"
hud_net_frame                 "0.2"
hud_net_frame_color           "0 0 0"
hud_net_order                 "7"
hud_net_period                "1"
hud_net_place                 "top"
hud_net_pos_x                 "10"
hud_net_pos_y                 "0"
hud_net_show                  "0"
hud_netgraph_align_x          "center"
hud_netgraph_align_y          "before"
hud_netgraph_alpha            "1"
hud_netgraph_frame            "0.5"
hud_netgraph_frame_color      "0 0 0"
hud_netgraph_full             "1"
hud_netgraph_height           "28"
hud_netgraph_inframes         "0"
hud_netgraph_lostscale        "1"
hud_netgraph_order            "2"
hud_netgraph_place            "group4"
hud_netgraph_ploss            "0"
hud_netgraph_pos_x            "0"
hud_netgraph_pos_y            "-2"
hud_netgraph_scale            "256"
hud_netgraph_show             "0"
hud_netgraph_swap_x           "0"
hud_netgraph_swap_y           "0"
hud_netgraph_width            "170"
hud_notify_align_x            "left"
hud_notify_align_y            "top"
hud_notify_cols               "30"
hud_notify_frame              "0"
hud_notify_frame_color        "0 0 0"
hud_notify_order              "8"
hud_notify_place              "top"
hud_notify_pos_x              "0"
hud_notify_pos_y              "0"
hud_notify_rows               "4"
hud_notify_scale              "1"
hud_notify_show               "0"
hud_notify_time               "4"
hud_offscreen                 "1"
hud_ownfrags_align_x          "center"
hud_ownfrags_align_y          "top"
hud_ownfrags_frame            "0.2"
hud_ownfrags_frame_color      "0 0 100"
hud_ownfrags_order            "1"
hud_ownfrags_place            "screen"
hud_ownfrags_pos_x            "0"
hud_ownfrags_pos_y            "50"
hud_ownfrags_scale            "1.5"
hud_ownfrags_show             "0"
hud_ownfrags_timeout          "3"
hud_pent_align_x              "after"
hud_pent_align_y              "top"
hud_pent_frame                "0"
hud_pent_frame_color          "0 0 0"
hud_pent_order                "2"
hud_pent_place                "ring"
hud_pent_pos_x                "-1"
hud_pent_pos_y                "0"
hud_pent_scale                "2"
hud_pent_show                 "0"
hud_pent_style                "0"
hud_ping_align_x              "left"
hud_ping_align_y              "center"
hud_ping_blink                "0"
hud_ping_frame                "0"
hud_ping_frame_color          "0 0 0"
hud_ping_order                "9"
hud_ping_period               "1"
hud_ping_place                "group4"
hud_ping_pos_x                "4"
hud_ping_pos_y                "0"
hud_ping_show                 "0"
hud_ping_show_dev             "0"
hud_ping_show_max             "0"
hud_ping_show_min             "0"
hud_ping_show_pl              "1"
hud_planmode                  "0"
hud_quad_align_x              "after"
hud_quad_align_y              "top"
hud_quad_frame                "0"
hud_quad_frame_color          "0 0 0"
hud_quad_order                "3"
hud_quad_place                "pent"
hud_quad_pos_x                "0"
hud_quad_pos_y                "0"
hud_quad_scale                "2"
hud_quad_show                 "0"
hud_quad_style                "0"
hud_radar_align_x             "left"
hud_radar_align_y             "bottom"
hud_radar_autosize            "0"
hud_radar_fade_players        "1"
hud_radar_frame               "0"
hud_radar_frame_color         "0 0 0"
hud_radar_height              "25%"
hud_radar_highlight           "0"
hud_radar_highlight_color     "255 255 0"
hud_radar_itemfilter          "backpack quad pent armor mega"
hud_radar_onlytp              "0"
hud_radar_opacity             "0.5"
hud_radar_order               "0"
hud_radar_otherfilter         "projectiles gibs explosions shotgun"
hud_radar_place               "top"
hud_radar_player_size         "10"
hud_radar_pos_x               "0"
hud_radar_pos_y               "0"
hud_radar_show                "0"
hud_radar_show_height         "1"
hud_radar_show_hold           "0"
hud_radar_show_names          "0"
hud_radar_show_powerups       "1"
hud_radar_show_stats          "1"
hud_radar_weaponfilter        "gl rl lg"
hud_radar_width               "30%"
hud_ring_align_x              "center"
hud_ring_align_y              "center"
hud_ring_frame                "0"
hud_ring_frame_color          "0 0 0"
hud_ring_order                "1"
hud_ring_place                "group1"
hud_ring_pos_x                "-61"
hud_ring_pos_y                "-39"
hud_ring_scale                "2"
hud_ring_show                 "0"
hud_ring_style                "0"
hud_sigil1_align_x            "left"
hud_sigil1_align_y            "top"
hud_sigil1_frame              "0"
hud_sigil1_frame_color        "0 0 0"
hud_sigil1_order              "0"
hud_sigil1_place              "screen"
hud_sigil1_pos_x              "0"
hud_sigil1_pos_y              "0"
hud_sigil1_scale              "1"
hud_sigil1_show               "0"
hud_sigil1_style              "0"
hud_sigil2_align_x            "after"
hud_sigil2_align_y            "top"
hud_sigil2_frame              "0"
hud_sigil2_frame_color        "0 0 0"
hud_sigil2_order              "1"
hud_sigil2_place              "sigil1"
hud_sigil2_pos_x              "0"
hud_sigil2_pos_y              "0"
hud_sigil2_scale              "1"
hud_sigil2_show               "0"
hud_sigil2_style              "0"
hud_sigil3_align_x            "after"
hud_sigil3_align_y            "top"
hud_sigil3_frame              "0"
hud_sigil3_frame_color        "0 0 0"
hud_sigil3_order              "2"
hud_sigil3_place              "sigil2"
hud_sigil3_pos_x              "0"
hud_sigil3_pos_y              "0"
hud_sigil3_scale              "1"
hud_sigil3_show               "0"
hud_sigil3_style              "0"
hud_sigil4_align_x            "after"
hud_sigil4_align_y            "top"
hud_sigil4_frame              "0"
hud_sigil4_frame_color        "0 0 0"
hud_sigil4_order              "3"
hud_sigil4_place              "sigil3"
hud_sigil4_pos_x              "0"
hud_sigil4_pos_y              "0"
hud_sigil4_scale              "1"
hud_sigil4_show               "0"
hud_sigil4_style              "0"
hud_speed2_align_x            "center"
hud_speed2_align_y            "bottom"
hud_speed2_color_fast         "72"
hud_speed2_color_fastest      "216"
hud_speed2_color_insane       "229"
hud_speed2_color_normal       "100"
hud_speed2_color_stopped      "52"
hud_speed2_frame              "0"
hud_speed2_frame_color        "0 0 0"
hud_speed2_opacity            "1.0"
hud_speed2_order              "7"
hud_speed2_orientation        "0"
hud_speed2_place              "top"
hud_speed2_pos_x              "0"
hud_speed2_pos_y              "0"
hud_speed2_radius             "50.0"
hud_speed2_show               "0"
hud_speed2_wrapspeed          "500"
hud_speed2_xyz                "0"
hud_speed_align_x             "center"
hud_speed_align_y             "after"
hud_speed_color_fast          "72"
hud_speed_color_fastest       "216"
hud_speed_color_insane        "229"
hud_speed_color_normal        "100"
hud_speed_color_stopped       "52"
hud_speed_frame               "0.5"
hud_speed_frame_color         "0 0 0"
hud_speed_height              "15"
hud_speed_opacity             "1.0"
hud_speed_order               "7"
hud_speed_place               "group4"
hud_speed_pos_x               "0"
hud_speed_pos_y               "-79"
hud_speed_show                "0"
hud_speed_text_align          "1"
hud_speed_tick_spacing        "0.2"
hud_speed_vertical            "0"
hud_speed_vertical_text       "1"
hud_speed_width               "160"
hud_speed_xyz                 "1"
hud_suit_align_x              "after"
hud_suit_align_y              "top"
hud_suit_frame                "0"
hud_suit_frame_color          "0 0 0"
hud_suit_order                "3"
hud_suit_place                "pent"
hud_suit_pos_x                "0"
hud_suit_pos_y                "0"
hud_suit_scale                "1"
hud_suit_show                 "0"
hud_suit_style                "0"
hud_teamfrags_align_x         "right"
hud_teamfrags_align_y         "top"
hud_teamfrags_bignum          "1"
hud_teamfrags_cell_height     "24"
hud_teamfrags_cell_width      "86"
hud_teamfrags_colors_alpha    "0.3"
hud_teamfrags_cols            "2"
hud_teamfrags_extra_spec_info "0"
hud_teamfrags_fliptext        "1"
hud_teamfrags_frame           "0"
hud_teamfrags_frame_color     "0 0 0"
hud_teamfrags_maxname         "16"
hud_teamfrags_onlytp          "1"
hud_teamfrags_order           "2"
hud_teamfrags_padtext         "0"
hud_teamfrags_place           "frags"
hud_teamfrags_pos_x           "0"
hud_teamfrags_pos_y           "-24"
hud_teamfrags_rows            "1"
hud_teamfrags_show            "1"
hud_teamfrags_shownames       "0"
hud_teamfrags_space_x         "0"
hud_teamfrags_space_y         "1"
hud_teamfrags_strip           "1"
hud_teamfrags_style           "8"
hud_teamfrags_vertical        "0"
hud_teamholdbar_align_x       "left"
hud_teamholdbar_align_y       "bottom"
hud_teamholdbar_frame         "0"
hud_teamholdbar_frame_color   "0 0 0"
hud_teamholdbar_height        "8"
hud_teamholdbar_onlytp        "0"
hud_teamholdbar_opacity       "0.8"
hud_teamholdbar_order         "0"
hud_teamholdbar_place         "top"
hud_teamholdbar_pos_x         "0"
hud_teamholdbar_pos_y         "0"
hud_teamholdbar_show          "0"
hud_teamholdbar_show_text     "1"
hud_teamholdbar_vertical      "0"
hud_teamholdbar_vertical_text "0"
hud_teamholdbar_width         "200"
hud_teamholdinfo_align_x      "left"
hud_teamholdinfo_align_y      "bottom"
hud_teamholdinfo_frame        "0"
hud_teamholdinfo_frame_color  "0 0 0"
hud_teamholdinfo_height       "8"
hud_teamholdinfo_itemfilter   "quad ra ya ga mega pent rl quad"
hud_teamholdinfo_onlytp       "0"
hud_teamholdinfo_opacity      "0.8"
hud_teamholdinfo_order        "0"
hud_teamholdinfo_place        "top"
hud_teamholdinfo_pos_x        "0"
hud_teamholdinfo_pos_y        "0"
hud_teamholdinfo_show         "0"
hud_teamholdinfo_style        "1"
hud_teamholdinfo_width        "200"
hud_tp_need                   "0"
hud_tracking_align_x          "center"
hud_tracking_align_y          "bottom"
hud_tracking_format           "pov: %t %n"
hud_tracking_frame            "0"
hud_tracking_frame_color      "0 0 0"
hud_tracking_order            "10"
hud_tracking_place            "screen"
hud_tracking_pos_x            "0"
hud_tracking_pos_y            "0"
hud_tracking_scale            "1"
hud_tracking_show             "1"
hud_recalculate


================================================
FILE: misc/cfg/hud_vleesh.cfg
================================================
echo Vleesh's Head Up Display Configuration
echo made for all console resolutions

scr_newhud                  "1"
hud_ammo1_align             "right"
hud_ammo1_align_x           "left"
hud_ammo1_align_y           "top"
hud_ammo1_digits            "3"
hud_ammo1_frame             "0"
hud_ammo1_place             "group2"
hud_ammo1_pos_x             "5"
hud_ammo1_pos_y             "45"
hud_ammo1_scale             "1"
hud_ammo1_show              "1"
hud_ammo1_style             "1"
hud_ammo2_align             "right"
hud_ammo2_align_x           "left"
hud_ammo2_align_y           "top"
hud_ammo2_digits            "3"
hud_ammo2_frame             "0"
hud_ammo2_place             "group2"
hud_ammo2_pos_x             "35"
hud_ammo2_pos_y             "45"
hud_ammo2_scale             "1"
hud_ammo2_show              "1"
hud_ammo2_style             "1"
hud_ammo3_align             "right"
hud_ammo3_align_x           "left"
hud_ammo3_align_y           "top"
hud_ammo3_digits            "3"
hud_ammo3_frame             "0"
hud_ammo3_place             "group2"
hud_ammo3_pos_x             "65"
hud_ammo3_pos_y             "45"
hud_ammo3_scale             "1"
hud_ammo3_show              "1"
hud_ammo3_style             "1"
hud_ammo4_align             "right"
hud_ammo4_align_x           "left"
hud_ammo4_align_y           "top"
hud_ammo4_digits            "3"
hud_ammo4_frame             "0"
hud_ammo4_place             "group2"
hud_ammo4_pos_x             "95"
hud_ammo4_pos_y             "45"
hud_ammo4_scale             "1"
hud_ammo4_show              "1"
hud_ammo4_style             "1"
hud_ammo_align              "right"
hud_ammo_align_x            "left"
hud_ammo_align_y            "top"
hud_ammo_digits             "3"
hud_ammo_frame              "0"
hud_ammo_place              "screen"
hud_ammo_pos_x              "0"
hud_ammo_pos_y              "0"
hud_ammo_scale              "1"
hud_ammo_show               "0"
hud_ammo_style              "0"
hud_armor_align             "right"
hud_armor_align_x           "left"
hud_armor_align_y           "top"
hud_armor_digits            "3"
hud_armor_frame             "0"
hud_armor_place             "group1"
hud_armor_pos_x             "18"
hud_armor_pos_y             "9"
hud_armor_scale             ".6"
hud_armor_show              "1"
hud_armor_style             "0"
hud_armordamage_align       "right"
hud_armordamage_align_x     "left"
hud_armordamage_align_y     "before"
hud_armordamage_digits      "3"
hud_armordamage_duration    "0.8"
hud_armordamage_frame       "0"
hud_armordamage_place       "armor"
hud_armordamage_pos_x       "0"
hud_armordamage_pos_y       "0"
hud_armordamage_scale       "1"
hud_armordamage_show        "0"
hud_armordamage_style       "0"
hud_clock_align_x           "right"
hud_clock_align_y           "console"
hud_clock_big               "1"
hud_clock_blink             "1"
hud_clock_frame             "0"
hud_clock_place             "top"
hud_clock_pos_x             "0"
hud_clock_pos_y             "0"
hud_clock_show              "0"
hud_clock_style             "0"
hud_face_align_x            "left"
hud_face_align_y            "top"
hud_face_frame              "0"
hud_face_place              "group1"
hud_face_pos_x              "65"
hud_face_pos_y              "2"
hud_face_scale              "1.2"
hud_face_show               "1"
hud_fps_align_x             "right"
hud_fps_align_y             "top"
hud_fps_frame               "0"
hud_fps_place               "screen"
hud_fps_pos_x               "0"
hud_fps_pos_y               "0"
hud_fps_show                "0"
hud_fps_show_min            "0"
hud_fps_title               "1"
hud_frags_align_x           "left"
hud_frags_align_y           "top"
hud_frags_cell_height       "8"
hud_frags_cell_width        "32"
hud_frags_cols              "4"
hud_frags_fliptext          "0"
hud_frags_frame             "0"
hud_frags_padtext           "1"
hud_frags_place             "screen"
hud_frags_pos_x             "0"
hud_frags_pos_y             "0"
hud_frags_rows              "1"
hud_frags_show              "0"
hud_frags_shownames         "0"
hud_frags_showself_always   "1"
hud_frags_showteams         "0"
hud_frags_space_x           "1"
hud_frags_space_y           "1"
hud_frags_strip             "1"
hud_frags_style             "0"
hud_frags_teamsort          "0"
hud_frags_vertical          "0"
hud_group1_align_x          "left"
hud_group1_align_y          "bottom"
hud_group1_alpha            "1"
hud_group1_frame            ".5"
hud_group1_height           "58"
hud_group1_name             "group1"
hud_group1_picture          ""
hud_group1_place            "screen"
hud_group1_pos_x            "0"
hud_group1_pos_y            "-8"
hud_group1_show             "1"
hud_group1_tile             "0"
hud_group1_width            "128"
hud_group2_align_x          "right"
hud_group2_align_y          "bottom"
hud_group2_alpha            "1"
hud_group2_frame            ".5"
hud_group2_height           "58"
hud_group2_name             "group2"
hud_group2_picture          ""
hud_group2_place            "screen"
hud_group2_pos_x            "0"
hud_group2_pos_y            "-8"
hud_group2_show             "1"
hud_group2_tile             "0"
hud_group2_width            "128"
hud_group3_align_x          "right"
hud_group3_align_y          "center"
hud_group3_alpha            "1"
hud_group3_frame            "1"
hud_group3_height           "32"
hud_group3_name             "group3"
hud_group3_picture          ""
hud_group3_place            "group1"
hud_group3_pos_x            "0"
hud_group3_pos_y            "0"
hud_group3_show             "1"
hud_group3_tile             "0"
hud_group3_width            "2"
hud_group4_align_x          "left"
hud_group4_align_y          "top"
hud_group4_alpha            "1"
hud_group4_frame            "1"
hud_group4_height           "2"
hud_group4_name             "group4"
hud_group4_picture          ""
hud_group4_place            "group1"
hud_group4_pos_x            "0"
hud_group4_pos_y            "0"
hud_group4_show             "1"
hud_group4_tile             "0"
hud_group4_width            "128"
hud_group5_align_x          "left"
hud_group5_align_y          "bottom"
hud_group5_alpha            "1"
hud_group5_frame            "1"
hud_group5_height           "2"
hud_group5_name             "group5"
hud_group5_picture          ""
hud_group5_place            "group1"
hud_group5_pos_x            "0"
hud_group5_pos_y            "0"
hud_group5_show             "1"
hud_group5_tile             "0"
hud_group5_width            "128"
hud_group6_align_x          "right"
hud_group6_align_y          "center"
hud_group6_alpha            "1"
hud_group6_frame            "1"
hud_group6_height           "2"
hud_group6_name             "group6"
hud_group6_picture          ""
hud_group6_place            "screen"
hud_group6_pos_x            "0"
hud_group6_pos_y            "0"
hud_group6_show             "0"
hud_group6_tile             "0"
hud_group6_width            "128"
hud_group7_align_x          "left"
hud_group7_align_y          "center"
hud_group7_alpha            "1"
hud_group7_frame            "1"
hud_group7_height           "58"
hud_group7_name             "group7"
hud_group7_picture          ""
hud_group7_place            "group2"
hud_group7_pos_x            "0"
hud_group7_pos_y            "0"
hud_group7_show             "1"
hud_group7_tile             "0"
hud_group7_width            "2"
hud_group8_align_x          "left"
hud_group8_align_y          "bottom"
hud_group8_alpha            "1"
hud_group8_frame            "1"
hud_group8_height           "2"
hud_group8_name             "group8"
hud_group8_picture          ""
hud_group8_place            "group2"
hud_group8_pos_x            "0"
hud_group8_pos_y            "0"
hud_group8_show             "1"
hud_group8_tile             "0"
hud_group8_width            "128"
hud_group9_align_x          "left"
hud_group9_align_y          "top"
hud_group9_alpha            "1"
hud_group9_frame            "1"
hud_group9_height           "2"
hud_group9_name             "group9"
hud_group9_picture          ""
hud_group9_place            "group2"
hud_group9_pos_x            "0"
hud_group9_pos_y            "0"
hud_group9_show             "1"
hud_group9_tile             "0"
hud_group9_width            "128"
hud_gun2_align_x            "left"
hud_gun2_align_y            "center"
hud_gun2_frame              "0"
hud_gun2_place              "group2"
hud_gun2_pos_x              "5"
hud_gun2_pos_y              "5"
hud_gun2_scale              "1"
hud_gun2_show               "1"
hud_gun2_style              "0"
hud_gun3_align_x            "left"
hud_gun3_align_y            "center"
hud_gun3_frame              "0"
hud_gun3_place              "group2"
hud_gun3_pos_x              "5"
hud_gun3_pos_y              "-15"
hud_gun3_scale              "1"
hud_gun3_show               "1"
hud_gun3_style              "0"
hud_gun4_align_x            "left"
hud_gun4_align_y            "center"
hud_gun4_frame              "0"
hud_gun4_place              "group2"
hud_gun4_pos_x              "35"
hud_gun4_pos_y              "5"
hud_gun4_scale              "1"
hud_gun4_show               "1"
hud_gun4_style              "0"
hud_gun5_align_x            "left"
hud_gun5_align_y            "center"
hud_gun5_frame              "0"
hud_gun5_place              "group2"
hud_gun5_pos_x              "35"
hud_gun5_pos_y              "-15"
hud_gun5_scale              "1"
hud_gun5_show               "1"
hud_gun5_style              "0"
hud_gun6_align_x            "left"
hud_gun6_align_y            "center"
hud_gun6_frame              "0"
hud_gun6_place              "group2"
hud_gun6_pos_x              "65"
hud_gun6_pos_y              "5"
hud_gun6_scale              "1"
hud_gun6_show               "1"
hud_gun6_style              "0"
hud_gun7_align_x            "left"
hud_gun7_align_y            "center"
hud_gun7_frame              "0"
hud_gun7_place              "group2"
hud_gun7_pos_x              "65"
hud_gun7_pos_y              "-15"
hud_gun7_scale              "1"
hud_gun7_show               "1"
hud_gun7_style              "0"
hud_gun8_align_x            "left"
hud_gun8_align_y            "center"
hud_gun8_frame              "0"
hud_gun8_place              "group2"
hud_gun8_pos_x              "95"
hud_gun8_pos_y              "5"
hud_gun8_scale              "1"
hud_gun8_show               "1"
hud_gun8_style              "0"
hud_gun8_wide               "0"
hud_gun_align_x             "center"
hud_gun_align_y             "bottom"
hud_gun_frame               "0"
hud_gun_place               "top"
hud_gun_pos_x               "0"
hud_gun_pos_y               "0"
hud_gun_scale               "1"
hud_gun_show                "0"
hud_gun_style               "0"
hud_gun_wide                "0"
hud_health_align            "right"
hud_health_align_x          "left"
hud_health_align_y          "top"
hud_health_digits           "3"
hud_health_frame            "0"
hud_health_place            "group1"
hud_health_pos_x            "80"
hud_health_pos_y            "9"
hud_health_scale            ".6"
hud_health_show             "1"
hud_health_style            "0"
hud_healthdamage_align      "right"
hud_healthdamage_align_x    "left"
hud_healthdamage_align_y    "before"
hud_healthdamage_digits     "3"
hud_healthdamage_duration   "0.8"
hud_healthdamage_frame      "0"
hud_healthdamage_place      "health"
hud_healthdamage_pos_x      "0"
hud_healthdamage_pos_y      "0"
hud_healthdamage_scale      "1"
hud_healthdamage_show       "0"
hud_healthdamage_style      "0"
hud_iammo1_align_x          "left"
hud_iammo1_align_y          "top"
hud_iammo1_frame            "0"
hud_iammo1_place            "group2"
hud_iammo1_pos_x            "0"
hud_iammo1_pos_y            "0"
hud_iammo1_scale            ".5"
hud_iammo1_show             "0"
hud_iammo1_style            "0"
hud_iammo2_align_x          "left"
hud_iammo2_align_y          "top"
hud_iammo2_frame            "0"
hud_iammo2_place            "group2"
hud_iammo2_pos_x            "0"
hud_iammo2_pos_y            "0"
hud_iammo2_scale            ".5"
hud_iammo2_show             "0"
hud_iammo2_style            "0"
hud_iammo3_align_x          "left"
hud_iammo3_align_y          "top"
hud_iammo3_frame            "0"
hud_iammo3_place            "group2"
hud_iammo3_pos_x            "0"
hud_iammo3_pos_y            "0"
hud_iammo3_scale            ".5"
hud_iammo3_show             "0"
hud_iammo3_style            "0"
hud_iammo4_align_x          "left"
hud_iammo4_align_y          "top"
hud_iammo4_frame            "0"
hud_iammo4_place            "group2"
hud_iammo4_pos_x            "0"
hud_iammo4_pos_y            "0"
hud_iammo4_scale            ".5"
hud_iammo4_show             "0"
hud_iammo4_style            "0"
hud_iammo_align_x           "left"
hud_iammo_align_y           "top"
hud_iammo_frame             "0"
hud_iammo_place             "screen"
hud_iammo_pos_x             "0"
hud_iammo_pos_y             "0"
hud_iammo_scale             "1"
hud_iammo_show              "0"
hud_iammo_style             "0"
hud_iarmor_align_x          "left"
hud_iarmor_align_y          "top"
hud_iarmor_frame            "0"
hud_iarmor_place            "group1"
hud_iarmor_pos_x            "3"
hud_iarmor_pos_y            "1"
hud_iarmor_scale            "1.2"
hud_iarmor_show             "1"
hud_iarmor_style            "0"
hud_key1_align_x            "top"
hud_key1_align_y            "left"
hud_key1_frame              "0"
hud_key1_place              "top"
hud_key1_pos_x              "0"
hud_key1_pos_y              "64"
hud_key1_scale              "1"
hud_key1_show               "0"
hud_key1_style              "0"
hud_key2_align_x            "left"
hud_key2_align_y            "after"
hud_key2_frame              "0"
hud_key2_place              "key1"
hud_key2_pos_x              "0"
hud_key2_pos_y              "0"
hud_key2_scale              "1"
hud_key2_show               "0"
hud_key2_style              "0"
hud_mp3_time_align_x        "left"
hud_mp3_time_align_y        "bottom"
hud_mp3_time_frame          "0"
hud_mp3_time_on_scoreboard  "0"
hud_mp3_time_place          "top"
hud_mp3_time_pos_x          "0"
hud_mp3_time_pos_y          "0"
hud_mp3_time_show           "0"
hud_mp3_time_style          "0"
hud_mp3_title_align_x       "right"
hud_mp3_title_align_y       "bottom"
hud_mp3_title_frame         "0"
hud_mp3_title_height        "8"
hud_mp3_title_on_scoreboard "0"
hud_mp3_title_place         "top"
hud_mp3_title_pos_x         "0"
hud_mp3_title_pos_y         "0"
hud_mp3_title_scroll        "1"
hud_mp3_title_scroll_delay  "0.5"
hud_mp3_title_show          "0"
hud_mp3_title_style         "2"
hud_mp3_title_width         "512"
hud_mp3_title_wordwrap      "0"
hud_net_align_x             "left"
hud_net_align_y             "center"
hud_net_frame               "0.2"
hud_net_period              "1"
hud_net_place               "top"
hud_net_pos_x               "0"
hud_net_pos_y               "0"
hud_net_show                "0"
hud_netgraph_align_x        "left"
hud_netgraph_align_y        "bottom"
hud_netgraph_alpha          "1"
hud_netgraph_frame          "0"
hud_netgraph_full           "0"
hud_netgraph_height         "32"
hud_netgraph_inframes       "0"
hud_netgraph_lostscale      "1"
hud_netgraph_place          "top"
hud_netgraph_ploss          "1"
hud_netgraph_pos_x          "0"
hud_netgraph_pos_y          "0"
hud_netgraph_scale          "256"
hud_netgraph_show           "0"
hud_netgraph_swap_x         "0"
hud_netgraph_swap_y         "0"
hud_netgraph_width          "256"
hud_pent_align_x            "left"
hud_pent_align_y            "after"
hud_pent_frame              "0"
hud_pent_place              "ring"
hud_pent_pos_x              "0"
hud_pent_pos_y              "0"
hud_pent_scale              "1"
hud_pent_show               "0"
hud_pent_style              "0"
hud_ping_align_x            "left"
hud_ping_align_y            "bottom"
hud_ping_blink              "0"
hud_ping_frame              "0"
hud_ping_period             "1"
hud_ping_place              "group1"
hud_ping_pos_x              "0"
hud_ping_pos_y              "-6"
hud_ping_show               "1"
hud_ping_show_dev           "0"
hud_ping_show_max           "0"
hud_ping_show_min           "0"
hud_ping_show_pl            "1"
hud_quad_align_x            "left"
hud_quad_align_y            "after"
hud_quad_frame              "0"
hud_quad_place              "suit"
hud_quad_pos_x              "0"
hud_quad_pos_y              "0"
hud_quad_scale              "1"
hud_quad_show               "0"
hud_quad_style              "0"
hud_ring_align_x            "left"
hud_ring_align_y            "after"
hud_ring_frame              "0"
hud_ring_place              "key2"
hud_ring_pos_x              "0"
hud_ring_pos_y              "0"
hud_ring_scale              "1"
hud_ring_show               "0"
hud_ring_style              "0"
hud_sigil1_align_x          "left"
hud_sigil1_align_y          "top"
hud_sigil1_frame            "0"
hud_sigil1_place            "screen"
hud_sigil1_pos_x            "0"
hud_sigil1_pos_y            "0"
hud_sigil1_scale            "1"
hud_sigil1_show             "0"
hud_sigil1_style            "0"
hud_sigil2_align_x          "after"
hud_sigil2_align_y          "top"
hud_sigil2_frame            "0"
hud_sigil2_place            "sigil1"
hud_sigil2_pos_x            "0"
hud_sigil2_pos_y            "0"
hud_sigil2_scale            "1"
hud_sigil2_show             "0"
hud_sigil2_style            "0"
hud_sigil3_align_x          "after"
hud_sigil3_align_y          "top"
hud_sigil3_frame            "0"
hud_sigil3_place            "sigil2"
hud_sigil3_pos_x            "0"
hud_sigil3_pos_y            "0"
hud_sigil3_scale            "1"
hud_sigil3_show             "0"
hud_sigil3_style            "0"
hud_sigil4_align_x          "after"
hud_sigil4_align_y          "top"
hud_sigil4_frame            "0"
hud_sigil4_place            "sigil3"
hud_sigil4_pos_x            "0"
hud_sigil4_pos_y            "0"
hud_sigil4_scale            "1"
hud_sigil4_show             "0"
hud_sigil4_style            "0"
hud_speed_align_x           "center"
hud_speed_align_y           "bottom"
hud_speed_frame             "0"
hud_speed_place             "top"
hud_speed_pos_x             "0"
hud_speed_pos_y             "-5"
hud_speed_show              "0"
hud_speed_xyz               "0"
hud_suit_align_x            "left"
hud_suit_align_y            "after"
hud_suit_frame              "0"
hud_suit_place              "pent"
hud_suit_pos_x              "0"
hud_suit_pos_y              "0"
hud_suit_scale              "1"
hud_suit_show               "0"
hud_suit_style              "0"
hud_teamfrags_align_x       "right"
hud_teamfrags_align_y       "bottom"
hud_teamfrags_cell_height   "8"
hud_teamfrags_cell_width    "32"
hud_teamfrags_cols          "1"
hud_teamfrags_fliptext      "1"
hud_teamfrags_frame         "0"
hud_teamfrags_padtext       "1"
hud_teamfrags_place         "group1"
hud_teamfrags_pos_x         "-5"
hud_teamfrags_pos_y         "-5"
hud_teamfrags_rows          "2"
hud_teamfrags_show          "1"
hud_teamfrags_shownames     "0"
hud_teamfrags_space_x       "1"
hud_teamfrags_space_y       "1"
hud_teamfrags_strip         "1"
hud_teamfrags_style         "0"
hud_teamfrags_vertical      "1"
hud_tracking_align_x        "center"
hud_tracking_align_y        "bottom"
hud_tracking_format         "Tracking %t %n"
hud_tracking_frame          "0"
hud_tracking_place          "screen"
hud_tracking_pos_x          "0"
hud_tracking_pos_y          "-8"
hud_tracking_show           "1"
hud_recalculate


================================================
FILE: misc/cfg/movement.cfg
================================================
//
// --- basic settings ---
//

bind  `             "toggleconsole"
bind  ~             "toggleconsole"
bind  TAB           "+showteamscores"
bind  SPACE         "+jump"
bind  ENTER         "messagemode"
bind  \             "messagemode2"
bind  d             "+moveleft"
bind  f             "+back"
bind  g             "+moveright"
bind  r             "+forward"
bind  MOUSE1        "+imp.7"
bind  MOUSE2        "+imp.6"
bind  MOUSE3        "+imp.8"
bind  MOUSE4        "+imp.5"
bind  MOUSE5        "+imp.2"
bind  MWHEELUP      ""
bind  MWHEELDOWN    ""

bind  KP_SLASH      "agree"
bind  KP_STAR       "addserver $lastip"
bind  KP_DEL        "toggle cl_useproxy; echo proxy usage: $cl_useproxy"
bind  KP_MINUS      "break"
bind  KP_PLUS       "ready"
bind  KP_HOME       "track #7"
bind  KP_UPARROW    "track #8"
bind  KP_LEFTARROW  "track #4"
bind  KP_5          "track #5"
bind  KP_RIGHTARROW "track #6"
bind  KP_END        "track #1"
bind  KP_DOWNARROW  "track #2"
bind  KP_PGDN       "track #3"

set viewmodelalpha           "0.3"
cl_maxfps                    "999"
fov                          "115"
m_forcewheel                 "1"

//
// -- advanced settings --
//

serverinfo maxfps 999
serverinfo watervis 1


//Input - Misc
freelook                     "1"
lookspring                   "0"
lookstrafe                   "0"

//Plus commands
-moveup
-movedown
-left
-right
-forward
-back
-lookup
-lookdown
-strafe
-moveleft
-moveright
+speed
-attack
-use
-jump
-klook
+mlook
-showscores
-showteamscores

//Aliases
alias  +imp.1              "impulse 1;wait;fire"
alias  -imp.1              "-attack;impulse 1;r_drawviewmodel 0"
alias  +imp.2              "impulse 2 1;fire"
alias  -imp.2              "-attack;impulse 1;r_drawviewmodel 0"
alias  +imp.3              "impulse 3 4 2 1;fire"
alias  -imp.3              "-attack;impulse 1;r_drawviewmodel 0"
alias  +imp.4              "impulse 4 2 1;fire"
alias  -imp.4              "-attack;impulse 1;r_drawviewmodel 0"
alias  +imp.5              "impulse 5 3 4 2 1;fire"
alias  -imp.5              "-attack;impulse 1;r_drawviewmodel 0"
alias  +imp.6              "impulse 6 2 1;fire"
alias  -imp.6              "-attack;impulse 1;r_drawviewmodel 0"
alias  +imp.7              "impulse 7 6 2 1;fire"
alias  -imp.7              "-attack;impulse 1;r_drawviewmodel 0"
alias  +imp.8              "impulse 8 5 3 4 2 1;fire"
alias  -imp.8              "-attack;impulse 1;r_drawviewmodel 0"
alias  +imp.9              "impulse 9;fire"
alias  -imp.9              "-attack;r_drawviewmodel 0"
alias  fire                "r_drawviewmodel $viewmodelalpha;+attack"
alias  respawner           "-attack;-jump;wait;+jump;wait;-jump;impulse 1"


bind  KP_HOME       "say proxy:menu back"
bind  KP_UPARROW    "say proxy:menu up"
bind  KP_PGUP       "say proxy:menu select"
bind  KP_LEFTARROW  "say proxy:menu left"
bind  KP_5          "say proxy:menu down"
bind  KP_RIGHTARROW "say proxy:menu right"
bind  KP_PLUS       "say proxy:menu pgdn"
bind  KP_DOWNARROW  "say proxy:menu down"
bind  KP_INS        "say proxy:menu"
bind  KP_MINUS      "say proxy:menu pgup"

bind  PGDN          "screenshot"
bind  PGUP          "menu_slist"


================================================
FILE: misc/cfg/mvdhud_1on1.cfg
================================================
// backup keyboard bindings
set_bind_str mvdhuddel del

echo "press $[Delete$] to remove 1on1 hud"

bind del "bind del $mvdhuddel; mvd_autohud 0; echo hud removed - use mvd_autohud 1 to turn it back"

cl_multiview 2
cl_mvinset 1
scr_autoid 1
cl_mvinsethud 1

hide group1


================================================
FILE: misc/cfg/mvdhud_2on2.cfg
================================================
exec cfg/mvdhud_base_del.cfg

cl_multiview 4

// Default radar group
set radar_group	2

exec cfg/mvdhud_base.cfg
exec cfg/mvdhud_base_4.cfg
exec cfg/mvdhud_base_other.cfg

frags cols 2

//
// ######################################## BINDS ##########################################
//

bind enter move_radar

================================================
FILE: misc/cfg/mvdhud_3on3.cfg
================================================
exec cfg/mvdhud_base_del.cfg

cl_multiview 3

// Default radar group
set radar_group	3

exec cfg/mvdhud_base.cfg
exec cfg/mvdhud_base_3.cfg
exec cfg/mvdhud_base_other.cfg

frags cols 3

//
// ######################################## BINDS ##########################################
//

bind enter move_radar

================================================
FILE: misc/cfg/mvdhud_4on4.cfg
================================================
exec cfg/mvdhud_base_del.cfg

cl_multiview 4

// Default radar group is #2 (top right corner)
set radar_group	2

exec cfg/mvdhud_base.cfg
exec cfg/mvdhud_base_4.cfg
exec cfg/mvdhud_base_other.cfg

frags cols 4

//
// ######################################## BINDS ##########################################
//

bind enter move_radar

================================================
FILE: misc/cfg/mvdhud_base.cfg
================================================
//
// ######################################## BASIC ALIASES #########################################
//

if $cl_multiview > 0 set max_group 5 else set_calc max_group $cl_multiview + 1

// Let the player move the radar around in the views.
alias next_radar_group	"if $radar_group == $max_group set radar_group 1 else set_calc radar_group $radar_group + 1"
alias move_radar	"group$radar_group frame 0;next_radar_group;place radar group$radar_group"

// Remove the frame of the group the radar is in when going into free fly mode.
alias f_freeflyspectate "group$radar_group frame 0"
alias f_trackspectate	"if $cl_multiview > 0 group$radar_group frame 1 else group$radar_group frame 0"

//
// ######################################## BASIC CONFIG ##########################################
//

// Track the first team to start with
trackteam		1

// Display the mini-huds gathered in the center of the screen.
cl_mvdisplayhud		4
cl_mvhudpos		gather 
cl_mvhudvertical	1

// Someone might be using scr_newhud > 1 so don't screw with their settings
if $scr_newhud == 0 scr_newhud 1

// Allow elements to be offscreen (only in GL).
hud_offscreen		0

// Make sure we're not in planmode.
hud_planmode		0

// Show RL's/armor/health name.
scr_autoid		4

// Get rid of all hud elements.
hide all


================================================
FILE: misc/cfg/mvdhud_base_2.cfg
================================================
//
// ########################################### VIEW GROUPS ########################################
//
cl_multiview 2

// Calculate the size of a view.
set_calc halfconh $conheight / 2

//
// One HUD group for each view.
//

// Top
show	group1
place	group1		screen
align	group1		left top
move	group1		0 0
group1	name		"Top"
group1	width		$conwidth
group1	height		$halfconh
group1	frame		0
group1	frame_color 	black

// Bottom 
show	group2
place	group2		screen
align	group2		left bottom
move	group2		0 0
group2	name		"Bottom"
group2	width		$conwidth
group2	height		$halfconh
group2	frame		0
group2	frame_color	black

hide group3
hide group4
hide group5

================================================
FILE: misc/cfg/mvdhud_base_3.cfg
================================================
//
// ########################################### VIEW GROUPS ########################################
//
cl_multiview 3

// Calculate the size of a view.
set_calc halfconw $conwidth / 2
set_calc halfconh $conheight / 2

//
// One HUD group for each view.
//

// Top
show	group1
place	group1		screen
align	group1		left top
move	group1		0 0
group1	name		"Top"
group1	width		$conwidth
group1	height		$halfconh
group1	frame		0
group1	frame_color 	black

// Bottom left
show	group2
place	group2		screen
align	group2		left bottom
move	group2		0 0
group2	name		"Bottom left"
group2	width		$halfconw
group2	height		$halfconh
group2	frame		0
group2	frame_color	black

// Bottom right
show	group3
place	group3		screen
align	group3		right bottom
move	group3		0 0
group3	name		"Bottom right"
group3	width		$halfconw
group3	height		$halfconh
group3	frame		0
group3	frame_color	black

hide group4
hide group5

================================================
FILE: misc/cfg/mvdhud_base_4.cfg
================================================
//
// ########################################### VIEW GROUPS ########################################
//
//cl_multiview 4

// Calculate the size of a view.
set_calc halfconw $conwidth / 2
set_calc halfconh $conheight / 2

//
// One HUD group for each view.
//

// Top left
show group1
place	group1		screen
align	group1		left top
move	group1		0 0
group1	name		"Top left"
group1	width		$halfconw
group1	height		$halfconh
group1	frame		0

// Top right - Radar group
show	group2
place	group2		screen
align	group2		right top
move	group2		0 0
group2	name		"Top right radar"
group2	width		$halfconw
group2	height		$halfconh
group2	frame		0
group2	frame_color 	black

// Bottom left
show	group3
place	group3		screen
align	group3		left bottom
move	group3		0 0
group3	name		"Bottom left"
group3	width		$halfconw
group3	height		$halfconh
group3	frame		0
group3	frame_color	black

// Bottom right
show	group4
place	group4		screen
align	group4		right bottom
move	group4		0 0
group4	name		"Bottom right"
group4	width		$halfconw
group4	height		$halfconh
group4	frame		0
group4	frame_color	black

hide group5

================================================
FILE: misc/cfg/mvdhud_base_del.cfg
================================================
// backup keyboard bindings
set_bind_str mvdhuddel del

echo "press $[Delete$] to remove auto mvdhud"

bind del "bind del $mvdhuddel; mvd_autohud 0; echo hud removed - use mvd_autohud 1 or 2 to turn it back on"

================================================
FILE: misc/cfg/mvdhud_base_other.cfg
================================================
//
// ########################################### OTHER HUD ELEMENTS ########################################
//

//
// Radar
//
set_calc radarw $halfconw - 15
set_calc radarh $halfconh - 15

show		radar
place		radar		group2
align		radar		center center
move		radar		0 0
radar		frame		0
radar		width		$radarw
radar		height		$radarh
radar		opacity		0.5
radar		itemfilter	"quad pent armor ring backpack"
radar		autosize	0
radar		show_height	1
radar		show_powerups	1
radar		show_stats	1
radar		weaponfilter	"rl lg gl"

//
// Frags
//
show		frags
place		frags		screen
align		frags		center bottom
move		frags		0 -8
frags		frame		0.02
frags		frame_color	white
frags		rows		8
frags		cols		$cl_multiview
frags		vertical	0
frags		extra_spec_info 1
frags		teamsort	1
frags		cell_width	16
frags		cell_height	8
frags		padtext		1
frags		shownames	1
frags		showteams	0
frags		space_x		1
frags		space_y		1
frags		teamsort	1

//
// Teamfrags
//
show		teamfrags
place		teamfrags	screen
align		teamfrags	center bottom
move		teamfrags	0 -35
teamfrags	frame		0.02
teamfrags	frame_color	white
teamfrags	rows		2
teamfrags	cols		1
teamfrags	fliptext	1
teamfrags	cell_width	32
teamfrags	cell_height	8
teamfrags	padtext		1
teamfrags	shownames	1
teamfrags	extra_spec_info	1
teamfrags	vertical	0

//
// Team hold bar
//
show		teamholdbar
place		teamholdbar	screen
align		teamholdbar	left bottom
move		teamholdbar	0 0
teamholdbar	width		$conwidth
teamholdbar	height		8
teamholdbar	frame		0
teamholdbar	vertical	0
teamholdbar	vertical_text	0
teamholdbar	show_text	1

//
// Team hold info
//
show		teamholdinfo
place		teamholdinfo	group4
align		teamholdinfo	right top
move		teamholdinfo	0 0
teamholdinfo	itemfilter	"quad rl ra ya pent"
teamholdinfo	height		48
teamholdinfo	width		100
teamholdinfo	style		0
teamholdinfo	opacity		0.8


================================================
FILE: misc/cfg/mvdhud_custom.cfg
================================================
exec cfg/mvdhud_base_del.cfg
exec cfg/mvdhud_4on4.cfg

//
// ######################################## ALIASES ##############################################
//

alias clear_groups	"group1 frame 0;group2 frame 0;group3 frame 0;group4 frame 0"
alias mv_1		"cl_multiview 0;exec cfg/mvdhud_base_4.cfg;clear_groups"
alias mv_2		"cl_multiview 2;exec cfg/mvdhud_base_2.cfg;clear_groups"
alias mv_3		"cl_multiview 3;exec cfg/mvdhud_base_3.cfg;clear_groups"
alias mv_4		"cl_multiview 4;exec cfg/mvdhud_base_4.cfg;clear_groups"
clear_groups
//
// ######################################## BINDS ##########################################
//

bind	enter	move_radar
bind	1	mv_1
bind	2	mv_2
bind	3	mv_3
bind	4	mv_4

================================================
FILE: misc/cfg/pingdump.cfg
================================================
echo "ping dump script by JohnNy_cz"

alias f_sbrefreshdone "log pingdump;sb_pingsdump;log stop;echo ping dumping to $log_dir/pingdump.log done"
alias f_sbupdatesourcesdone "sb_sourceunmarkall; sb_sourcemark quakeservers.net;sb_refresh"
cvar_reset_re sb_ping.*

echo "Refreshing servers list, this may take up to 30 seconds..."

sb_sourceadd quakeservers.net master.quakeservers.net master
sb_sourcesupdate


================================================
FILE: misc/cfg/teamplay.cfg
================================================
// shaman's ezQuake teamplay configuration file
// e-mail: post at o2 dot pl
// (C) Hugo Dworak 2000-2004

// LEDs:
// $x86 = green   - teammates, safe, u take, has, our, took, coming, camping, ok, don't kill, i take, my pack, soon, unlocked, powerup over, rl died 
// $x87 = red     - enemies, enemy powerups, death messages, negative, nmy coming from, nmy holds, breached, enemy rl, discharge warning, nmy took secret ra, lava opened, lag report
// $x89 = blue    - pointed items that are not: powerups (except the biosuit), eyes, enemies or teammates 
// $x8b = brown   - chat, questions, pointed eyes, orders without specified location
// $x88 = yellow  - ...everything else

// Magic LEDs:
// $ledpoint      - the type of object you point
// $ledstatus     - related to how much do you need




// prefix for teamplay reports
set nick                    "noob"

// bindings

bind mwheelup       "x_get"
bind mwheeldown     "x_need"

bind 1              "x_ringover"
bind 2              "x_trick"
bind 3              "x_statusra"
bind 4              "x_statusquad"

bind 5              "x_getquad"
bind 6              "x_quadover"
bind 7              "x_pentover"
bind 8              "x_nosorry"

bind q              "x_statusya"
bind w              "x_tele"
bind e              "x_coming"
bind i              "x_choose_best"

bind y              "x_report"
bind u              "x_attacklost"
bind 9              "x_iquad"
bind a              "x_lostpack"

bind s              "x_lost"
bind h              "x_took"
bind j              "x_call"
bind k              "x_already"

bind z              "x_rasecure"
bind x              "x_swap"
bind c              "x_safe"
bind v              "x_wait"

bind b              "x_enemy"
bind n              "x_call"
bind capslock       "x_cancel"
bind lwinkey        "x_yasecure"

bind lalt           "x_itemsoon"
bind lctrl          "x_cantyoutake"
bind lshift         "x_help"

bind rightarrow     "x_msg1"
bind leftarrow      "x_msg2"
bind uparrow        "x_msg3"
bind downarrow      "x_msg4"

bind f1             "x_msg5"
bind f2             "x_msg6"
bind f3             "x_pent30"
bind f4             "x_getpent"

bind f5             "x_scores"
bind f6             "x_itemsoon"
bind f7             "x_iquad"
bind f8             "x_hide"

bind f9             "x_msg7"
bind f10            "x_msg8"
bind f11            "x_msg9"
bind f12            "x_msg10"

// end of bindings











































// DON'T CHANGE ANYTHING BELOW

// basic variables
set loc_name_ga             "GA"
set loc_name_mh             "MEGA"
set loc_name_ra             "RA"
set loc_name_separator      "-"
set loc_name_ya             "YA"
set tp_name_ask_status      "status?"
set tp_name_attack          "attack"
set tp_name_get             "get"
set tp_name_go_secure       "go secure!"
set tp_name_now             "NOW!"
set tp_name_over            "over"
set tp_name_rush            "rush - attack NOW!"
set tp_name_seconds         "s"
set tp_need_ping            "89"
set tp_waymaps              "?dm2?dm3?dm4?dm5?dm6?e1m2?e1m6?e3m2?e3m3?e3m4?ukooldm4?"
set x_last_mega_location    ""
set x_mega_active           "0"
set x_mega_timer            "0"
set x_parsing               "1"
set x_funparsing            "1"

// those variables must not be empty
if $qt$tp_name_none$qt = $qt$qt then $qtset tp_name_none -$qt
if $qt$tp_name_separator$qt = $qt$qt then $qtset tp_name_separator $x0f$qt

// warn if prefix is default
if $qt$nick$qt = $qtnoob$qt then echo Change your reports prefix using /set nick pfx

// load location file
loadloc $mapname

// resets mega timer on map change
alias  on_enter                          "set x_last_mega_location $qt$qt;set x_mega_active 0"

// produces $x_lag
alias  x_recalculate_lag                 "set x_lag $qt$qt;if $latency > $tp_need_ping then $qtset x_lag $x20$x87$x87$x20{PING $latency}$qt"

// produces $x_bestweapon
alias  x_recalculate_weapons_cells       "set x_rl_lg_cells 0;if $qt$bestweapon$qt = $qt$tp_name_rl$qt then if $qt$tp_name_lg$qt isin $qt$weapons$qt then if $cells >= $tp_need_cells then set x_rl_lg_cells 1"
alias  x_recalculate_weapons_rl_lg       "set x_rl_lg 0;if $qt$bestweapon$qt = $qt$tp_name_rl$qt then if $qt$tp_name_lg$qt isin $qt$weapons$qt then set x_rl_lg 1"
alias  x_recalculate_weapons_sg          "set x_sg 0;if $qt$bestweapon$qt isin $qt$tp_name_none$tp_name_separator$tp_name_axe$tp_name_separator$tp_name_sg$tp_name_separator$tp_name_ng$qt then set x_sg 1"
alias  x_recalculate_weapons_rl          "if $rockets = 0 then $qtset x_rl $tp_name_rl$qt else set x_rl $tp_name_rl:$rockets"
alias  x_recalculate_weapons_ammo        "if $bestammo = 0 then $qtset x_bestweapon $bestweapon$qt else set x_bestweapon $bestweapon:$bestammo"
alias  x_recalculate_weapons_water       "if $qt$tp_name_sng$qt isin $qt$weapons$qt then if $qt$tp_name_sng$qt != $qt$bestweapon$qt $qtset x_bestweapon $x_bestweapon$tp_name_separator$tp_name_sng:$nails;if $qt$tp_name_sng$qt !isin $qt$weapons$qt then if $qt$tp_name_ssg$qt != $qt$bestweapon$qt then if $qt$tp_name_ssg$qt isin $qt$weapons$qt then set x_bestweapon $x_bestweapon$tp_name_separator$tp_name_ssg:$shells"
alias  x_recalculate_weapons             "x_recalculate_weapons_rl;x_recalculate_weapons_cells;x_recalculate_weapons_rl_lg;x_recalculate_weapons_sg;set x_bestweapon $qt$qt;if $x_rl_lg_cells = 1 then $qtset x_bestweapon $x_rl$tp_name_separator$tp_name_lg:$cells$qt else if $x_rl_lg = 1 then $qtset x_bestweapon $x_rl$tp_name_separator$tp_name_lg$qt else if $x_sg = 0 then x_recalculate_weapons_ammo;if $mapname != dm2 then if $qtwater$qt isin $qt$location$qt then x_recalculate_weapons_water;if $qt$x_bestweapon$qt != $qt$qt then set x_bestweapon $qt$x_bestweapon$x20$qt"

// produces $x_armor
alias  x_recalculate_armor               "set x_armor $qt$qt;if $qt$armortype$qt != $qt$tp_name_none$qt then if $armor > 0 then $qtset x_armor $armortype$armor$tp_name_separator$qt;if $qt$tp_name_pent$qt isin $qt$powerups$qt then set x_armor $qt$[{$tp_name_pent}$]$x20$qt"

// produces $x_health (white text might cover 201+ health)
alias  x_recalculate_health              "set x_health $qt$qt;if $health < 501 then if $qt$tp_name_pent$qt !isin $qt$powerups$qt then $qtset x_health $health$x20$qt;if $qt$armortype$qt = $qt$tp_name_none$qt then if $health < 501 then if $qt$tp_name_pent$qt !isin $qt$powerups$qt then $qtset x_health h$x_health$qt"

// produces $x_powerups (this is only for the report bind; the pent and the biosuit are not reported)
alias  x_recalculate_powerups_ring       "if $qt$tp_name_quad$qt isin $qt$powerups$qt then $qtset x_powerups QR$qt else $qtset x_powerups $tp_name_ring$qt"
alias  x_recalculate_powerups_quad       "if $qt$tp_name_quad$qt isin $qt$powerups$qt then $qtset x_powerups $tp_name_quad$qt"
alias  x_recalculate_powerups            "set x_powerups $qt$qt;if $qt$tp_name_ring$qt isin $qt$powerups$qt then x_recalculate_powerups_ring else x_recalculate_powerups_quad;if $qt$x_powerups$qt != $qt$qt then set x_powerups $qt$[{$x_powerups}$]$qt"

// produces $x_pows (the biosuit is not reported)
alias  x_recalculate_pows_two            "if $qt$tp_name_quad$qt isin $qt$powerups$qt then $qtset x_pows $x_powsQ$qt;if $qt$tp_name_pent$qt isin $qt$powerups$qt then $qtset x_pows $x_powsP$qt;if $qt$tp_name_ring$qt isin $qt$powerups$qt then $qtset x_pows $x_powsR$qt"
alias  x_recalculate_pows_short          "if $qt$tp_name_quad$tp_name_separator$tp_name_pent$tp_name_separator$tp_name_ring$qt isin $qt$powerups$qt then $qtset x_pows QPR$qt else x_recalculate_pows_two"
alias  x_recalculate_pows_single         "if $qt$tp_name_none$qt != $qt$powerups$qt then $qtset x_pows $powerups$qt"
alias  x_recalculate_pows                "set x_pows $qt$qt;if $qt$tp_name_separator$qt !isin $qt$powerups$qt then x_recalculate_pows_single else x_recalculate_pows_short;if $qt$x_pows$qt != $qt$qt then set x_pows $qt$[{$x_pows}$]$qt"

// should cover more than one megahealth taken
alias  x_mega_notify                     "playvol boss2/idle 5;if $qt$x_last_mega_location$qt != $qt$qt then say_team $\$nick$x89 $tp_name_mh soon {$x_last_mega_location}"
alias  x_mega_check                      "if $qt$x_mega_timer$qt = $qt1$qt then x_mega_notify"
alias  x_mega                            "x_mega_check;set x_mega_active 0"
alias  x_recalculate_mega                "if $x_mega_active = 1 then if $health < 101 then x_mega"

// report recalculation
alias  x_recalculate                     "x_recalculate_mega;x_recalculate_lag;x_recalculate_weapons;x_recalculate_armor;x_recalculate_health;x_recalculate_powerups;x_recalculate_pows"

// status
alias  x_status                          "x_recalculate;say_team $\$nick$ledstatus $x_armor$x_health$x_bestweapon{$location} $x_powerups$x_lag"

// lost
alias  x_lost_empty                      "if $qt$deathloc$qt != $qt$tp_name_someplace$qt then say_team $\$nick$x87 {$deathloc} lost %EE"
alias  x_lost_backpack                   "if $qt$deathloc$qt != $qt$tp_name_someplace$qt then say_team $\$nick$x87 died $tp_name_at {$deathloc} with $weapon:$ammo %EE"
alias  x_lost                            "x_recalculate_mega;if $qt$weapon$qt = $qt$tp_name_rl$qt then x_lost_backpack else if $qt$weapon$qt = $qt$tp_name_lg$qt then x_lost_backpack else x_lost_empty"

// status or lost
alias  x_report                          "if $health < 1 then x_lost else x_status"

// coming
alias  x_comingshort                     "say_team $\$nick$x86 coming $x_bestweapon{$location} $x_pows"
alias  x_comingway                       "say_team $\$nick$x86 coming $x_bestweapon{$location} to {%Z} $x_pows$x20"
alias  x_comingwaypoints                 "x_recalculate;if ?$mapname? !isin $qt$tp_waymaps$qt then x_comingshort else x_comingway"
alias  x_coming                          "x_recalculate;x_comingshort"

// need, has rl, has powerup, where help, what need
alias  x_needbind                        "say_team $\$nick$ledstatus need $need {$location}"
alias  x_hasweapon                       "if $tp_name_ring isin $qt$powerups$qt then $qtsay_team $\$nick$x86 has $[{$tp_name_ring}$] $ledstatus need $need$qt else $qtsay_team $\$nick$x86 has $bestweapon $ledstatus need $need$qt"
alias  x_haspowerup1                     "say_team $\$nick$x86 has $x_pows $ledstatus need $tp_name_weapon"
alias  x_haspowerup2                     "say_team $\$nick$x86 has $x_pows $ledstatus need $need"

alias  x_teamneed                        "say_team $\$nick$x8b what do u need? REPORT!"
alias  x_wherehelp                       "say_team $\$nick$x8b where is $x_pows help needed?"

alias  x_needpent                        "if $tp_name_weapon isin $qt$need$qt then x_haspowerup1 else x_wherehelp"
alias  x_needself                        "if $tp_name_quad isin $qt$powerups$qt then x_haspowerup2 else if $tp_name_pent isin $qt$powerups$qt then x_needpent else if $tp_name_weapon !isin $qt$need$qt x_hasweapon else x_needbind"
alias  x_needmates                       "if $tp_name_quad isin $qt$powerups$qt then x_wherehelp else if $tp_name_pent isin $qt$powerups$qt then x_wherehelp else x_teamneed"
alias  x_need_check_armor                "if $tp_name_pent isin $qt$powerups$qt then $qtif $need = $tp_name_armor then x_needmates$qt else x_needself"
alias  x_need                            "x_recalculate;if $ledstatus = $tp_name_status_green then x_needmates else x_need_check_armor"

// took, team powerup
alias  x_team                            "say_team $\$nick$x86 our $powerups $ledstatus need $need"
alias  x_took_set                        "set x_last_mega_location $tookloc;set x_mega_active 1"
alias  x_took_check                      "if $qt$tookloc$qt != $qt$tp_name_someplace$qt then x_took_set"
alias  x_took_item                       "if $qt$took$qt = $qt$tp_name_mh$qt then x_took_check;if $qt$cl_parseSay$qt = 0 then say_team $\$nick$x86 took %i else say_team $\$nick$x86 took $took $tp_name_at {$tookloc}"
alias  x_took                            "if $qt$took$qt = $qt$tp_name_nothing$qt then else if $qt$took$qt = $qt$tp_name_quad$qt then x_team else if $qt$took$qt = $qt$tp_name_pent$qt then x_team else if $qt$took$qt = $qt$tp_name_ring$qt then x_team else x_took_item"

// KTpro's shownick
alias  x_shownick                        "if $ledpoint isin $qt$tp_name_status_green$tp_name_status_red$qt then shownick"

// get, get pack
alias  x_parsing_save                    "set x_funparsing $qt$cl_parseFunChars$qt;set x_parsing $qt$cl_parseSay$qt"
alias  x_parsing_restore                 "cl_parseFunChars $qt$x_funparsing$qt;cl_parseSay $qt$x_parsing$qt"

alias  x_geteyesway                      "say_team $\$nick$x8b %x $tp_name_at {%y}! REPORT!"
alias  x_getenemybway                    "say_team $\$nick$x87 %x $tp_name_at {%y} %e"

alias  x_getpack                         "say_team $\$nick$x89 $tp_name_backpack {$location}"
alias  x_geteyes                         "shownick;if ?$mapname? !isin $qt$tp_waymaps$qt then say_team $\$nick$x8b %x $tp_name_at {%y}! REPORT!$x20 else x_getaskway"
alias  x_getenemyb                       "shownick;if ?$mapname? !isin $qt$tp_waymaps$qt then say_team $\$nick$x87 %x $tp_name_at {%y} %eE$x20 else x_getenemybway"
alias  x_getenemy                        "if $tp_name_eyes isin $qt$point$qt then x_geteyes else x_getenemyb"

alias  x_powerups_red                    "tp_name_eyes eyes;tp_name_quaded Quaded;tp_name_pented Penta"
alias  x_powerups_white                  "x_powerups_red" // "tp_name_eyes {eyes};tp_name_quaded {Quaded};tp_name_pented {Penta}"
alias  x_point_live                      "tp_point powerups armor players suit mh lg rl gl sng ssg pack rockets"
alias  x_point_dead                      "tp_point powerups armor players suit mh lg rl gl sng ssg rockets"

alias  x_getteammatep                    "wait;x_powerups_red;x_getask;x_powerups_white;shownick"
alias  x_getteammateb                    "shownick;x_getask"
alias  x_getteammate                     "if $qt $qt isin $qt$point$qt then x_getteammatep else x_getteammateb"
alias  x_getpower                        "say_team $\$nick$ledpoint $tp_name_get %x $tp_name_now"

alias  x_getb                            "say_team $\$nick$ledpoint %x $tp_name_at {%y}"
alias  x_getelse                         "if $qt$point$qt = $qt$tp_name_nothing$qt then else if $qtrune$qt isin $qt$point$qt then x_getpower else x_getb"
alias  x_getalive                        "if $ledpoint = $tp_name_status_yellow then x_getpower else if $ledpoint = $tp_name_status_red then x_getenemy else if $ledpoint = $tp_name_status_green then x_getteammate else x_getelse"
alias  x_getdeath                        "x_point_dead;if $ledpoint = $tp_name_status_green then else x_getalive;x_point_live"
alias  x_get                             "if $health > 0 then x_getalive else x_getdeath"

alias  x_getask                          "if ?$mapname? !isin $qt$tp_waymaps$qt then say_team $\$nick$x8b status %x $tp_name_at {%y}? else x_getaskway"
alias  x_getaskway                       "say_team $\$nick$x8b status %x $tp_name_at {%y}?"

x_powerups_white
x_point_live

// u take
alias  x_cantyoutakeb                    "say_team $\$nick$x8b can't/u take {$location}"
alias  x_cantyoutaken                    "say_team $\$nick$x86 %x take {$location};shownick"
alias  x_cantyoutakep                    "wait;x_powerups_red;say_team $\$nick$x86 %x take {$location};x_powerups_white;shownick"
alias  x_cantyoutaket                    "if $qt $qt isin $qt$point$qt then x_cantyoutakep else x_cantyoutaken"

alias  x_cantyoutake                     "if $ledpoint = $tp_name_status_green then x_cantyoutaket else x_cantyoutakeb"

// enemy powerup
alias  x_enemyl                          "say_team $\$nick$x87 $tp_name_enemy %q"
alias  x_enemyd                          "if $qt$deathloc$qt != $qt$tp_name_someplace$qt then say_team $\$nick$x87 killed by %q {$deathloc}"
alias  x_enemy                           "if $health < 1 then x_enemyd else x_enemyl"

// go secure
alias  x_gasecure                        "say_team $\$nick$x88 {$loc_name_ga} $tp_name_go_secure"
alias  x_megasecure                      "say_team $\$nick$x88 {$loc_name_mh} $tp_name_go_secure"
alias  x_200secure                       "say_team $\$nick$x88 {$loc_name_ra} $tp_name_go_secure"
alias  x_150secure                       "say_team $\$nick$x88 {$loc_name_ya} $tp_name_go_secure"
alias  x_telesecure                      "say_team $\$nick$x88 {tele} $tp_name_go_secure"
alias  x_yasecure                        "if $mapname = dm2 then x_telesecure else x_150secure"
alias  x_rasecure                        "if $mapname = e1m2 then x_megasecure else x_200secure"

// area status?
alias  x_statusarmor                     "say_team $\$nick$x8b $tp_name_armor $tp_name_ask_status"
alias  x_statusra                        "say_team $\$nick$x8b {$loc_name_ra} $tp_name_ask_status"
alias  x_status150                       "say_team $\$nick$x8b {$loc_name_ya} $tp_name_ask_status"
alias  x_statustele                      "say_team $\$nick$x8b {tele} $tp_name_ask_status"
alias  x_statusya                        "if $mapname = dm2 then x_statustele else x_status150"

// Euthanasia map binds

// - dm2 enemy rl binds
alias  x_dm2rlhigh                       "say_team $\$nick$x87 {high} $tp_name_enemy $tp_name_rl"
alias  x_dm2rlya-tele                    "say_team $\$nick$x87 {tele} $tp_name_enemy $tp_name_rl"
alias  x_dm2rllarge                      "say_team $\$nick$x87 {big} $tp_name_enemy $tp_name_rl"
alias  x_dm2rlra-mega                    "say_team $\$nick$x87 {$loc_name_ra$loc_name_separator$loc_name_mh} $tp_name_enemy $tp_name_rl"

// - dm3 enemy rl binds
alias  x_dm3rlsng                        "say_team $\$nick$x87 {$tp_name_sng} $tp_name_enemy $tp_name_rl"
alias  x_dm3rlpent                       "say_team $\$nick$x87 {lifts/$tp_name_pent} $tp_name_enemy $tp_name_rl"
alias  x_dm3rlya                         "say_team $\$nick$x87 {$loc_name_ya} $tp_name_enemy $tp_name_rl"
alias  x_dm3rlra                         "say_team $\$nick$x87 {$loc_name_ra} $tp_name_enemy $tp_name_rl"

// - e1m2 enemy rl binds
alias  x_e1m2rlya                        "say_team $\$nick$x87 {$loc_name_ya} $tp_name_enemy $tp_name_rl"
alias  x_e1m2rl+100                      "say_team $\$nick$x87 {$loc_name_mh} $tp_name_enemy $tp_name_rl"
alias  x_e1m2rlquad                      "say_team $\$nick$x87 {$tp_name_quad area} $tp_name_enemy $tp_name_rl"
alias  x_e1m2rlstart                     "say_team $\$nick$x87 {start} $tp_name_enemy $tp_name_rl"

// - dm2 attack orders
alias  x_dm2atthigh                      "say_team $\$nick$x88 $tp_name_attack {high}"
alias  x_dm2attya-tele                   "say_team $\$nick$x88 $tp_name_attack {tele}"
alias  x_dm2attlarge                     "say_team $\$nick$x88 $tp_name_attack {big}"
alias  x_dm2attra-mega                   "say_team $\$nick$x88 $tp_name_attack {$loc_name_ra$loc_name_separator$loc_name_mh}"

// - dm3 attack orders
alias  x_dm3attsng                       "say_team $\$nick$x88 $tp_name_attack {$tp_name_sng}"
alias  x_dm3attpent                      "say_team $\$nick$x88 $tp_name_attack {lifts/$tp_name_pent}"
alias  x_dm3attya                        "say_team $\$nick$x88 $tp_name_attack {$loc_name_ya}"
alias  x_dm3attra                        "say_team $\$nick$x88 $tp_name_attack {$loc_name_ra}"

// - e1m2 attack orders
alias  x_e1m2attya                       "say_team $\$nick$x88 $tp_name_attack {$loc_name_ya}"
alias  x_e1m2att+100                     "say_team $\$nick$x88 $tp_name_attack {$loc_name_mh}"
alias  x_e1m2attquad                     "say_team $\$nick$x88 $tp_name_attack {$tp_name_quad}"
alias  x_e1m2attstart                    "say_team $\$nick$x88 $tp_name_attack {start}"

// - ready to bind aliases
alias  x_msg1                            "if $mapname = dm2 then x_dm2rlra-mega else if $mapname = e1m2 then x_e1m2rlstart else x_dm3rlsng"
alias  x_msg2                            "if $mapname = dm2 then x_dm2rlya-tele else if $mapname = e1m2 then x_e1m2rlya else x_dm3rlpent"
alias  x_msg3                            "if $mapname = dm2 then x_dm2rlhigh else if $mapname = e1m2 then x_e1m2rlquad else x_dm3rlra"
alias  x_msg4                            "if $mapname = dm2 then x_dm2rllarge else if $mapname = e1m2 then x_e1m2rl+100 else x_dm3rlya"

alias  x_msg5                            "if $mapname = dm2 then x_dm2secret else x_delayedpent"
alias  x_msg6                            "if $mapname = dm2 then x_dm2lava else x_pent60"

alias  x_msg7                            "if $mapname = dm2 then x_dm2attra-mega else if $mapname = e1m2 then x_e1m2attstart else x_dm3attsng"
alias  x_msg8                            "if $mapname = dm2 then x_dm2attya-tele else if $mapname = e1m2 then x_e1m2attya else x_dm3attpent"
alias  x_msg9                            "if $mapname = dm2 then x_dm2atthigh else if $mapname = e1m2 then x_e1m2attquad else x_dm3attra"
alias  x_msg10                           "if $mapname = dm2 then x_dm2attlarge else if $mapname = e1m2 then x_e1m2att+100 else x_dm3attya"

// breached by cb2
alias  x_tele                            "if $qt$mapname$qt = $qtdm2$qt then x_brslipdm2 else if $qt$mapname$qt = $qtdm3$qt then x_brslipdm3 else if $qt$mapname$qt = $qte1m2$qt then x_brslipe1m2"
alias  x_brslipdm2                       "if $qtbig$qt isin $qt$location$qt then x_brerlhigh else if $qt$location$qt = $qtlow$loc_name_separatorrl/stairs$qt then x_brerlbig else if $qt$location$qt = $qt$loc_name_ra$loc_name_separator$loc_name_mh$qt then x_brerlbig else if $qt$location$qt = $qtlow$loc_name_separatorrl$qt then x_brerlsecret else if $qt$location$qt = $qtlow$loc_name_separatorrl/button$qt then x_brerlbig else if $qt$location$qt = $qttele$loc_name_separatorhigh$qt then x_brerlbig else if $qt$location$qt = $qthigh$loc_name_separatorrl$qt then x_brerlbig else if $qt$location$qt = $qtfloating$qt then x_brerlbig else if $qt$location$qt = $qtgl$qt then x_brerlbig else x_breslipped"
alias  x_brslipdm3                       "if $qt$loc_name_ya$qt isin $qt$location$qt then x_brerlwindow else if $qtpent$qt isin $qt$location$qt then x_brerlwindow else if $qtsng$qt isin $qt$location$qt then x_brerlra else if $qt$loc_name_ra$qt isin $qt$location$qt then x_brerlsng else if $qtwater$qt isin $qt$location$qt then x_brerlpent else if $qt$location$qt = $qtwindow$qt then x_brerlpent else if $qtrl$qt isin $qt$location$qt then x_brerlya else if $qt$location$qt = $qtring$qt then x_brerlra else if $qt$location$qt = $qtquad$qt then x_brerllifts else x_brerlsng"
alias  x_brslipe1m2                      "if $qt$location$qt = $qtssg$qt then x_brerlstart else if $qtspikes$qt isin $qt$location$qt then x_brerlya else if $loc_name_ga isin $qt$location$qt then x_brerlstart else if $qtgl$qt isin $qt$location$qt then x_brerlya else if $qt$location$qt = $qt$loc_name_ya$qt then x_brerlstart else if $qt$location$qt = $qt$loc_name_ya-top$qt then x_brerlstart else if $qtrl$qt isin $qt$location$qt then x_brerlstart else if $qt$location$qt = $qtbridge$qt then x_brerlstart else x_brerlmega"

alias  x_brerlbig                        "say_team $\$nick$x87 {big} $tp_name_enemy rl"
alias  x_brerlgl                         "say_team $\$nick$x87 {$tp_name_gl} $tp_name_enemy rl"
alias  x_brerlhigh                       "say_team $\$nick$x87 {high} $tp_name_enemy rl"
alias  x_brerllifts                      "say_team $\$nick$x87 {lifts} $tp_name_enemy rl"

alias  x_brerlmega                       "say_team $\$nick$x87 {$loc_name_mh} $tp_name_enemy rl"
alias  x_brerlpent                       "say_team $\$nick$x87 {$tp_name_pent} $tp_name_enemy rl"
alias  x_brerlra                         "say_team $\$nick$x87 {$loc_name_ra} $tp_name_enemy rl"
alias  x_brerlratnl                      "say_team $\$nick$x87 {$loc_name_ra-tunnel} $tp_name_enemy rl"

alias  x_brerlsecret                     "say_team $\$nick$x87 {secret} $tp_name_enemy rl"
alias  x_brerlsng                        "say_team $\$nick$x87 {$tp_name_sng} $tp_name_enemy rl"
alias  x_brerlstart                      "say_team $\$nick$x87 {start/$loc_name_ga} $tp_name_enemy rl"
alias  x_brerlwindow                     "say_team $\$nick$x87 {window} $tp_name_enemy rl"

alias  x_brerlya                         "say_team $\$nick$x87 {$loc_name_ya} $tp_name_enemy rl"
alias  x_breslipped                      "say_team $\$nick$x87 breached {$location}"

// trick by def
alias  x_dischargewb                     "say_team $\$nick$x87 {water} discharge warning! $tp_name_lg:$cells"
alias  x_dischargepb                     "say_team $\$nick$x87 {$tp_name_pent} discharge warning! $tp_name_lg:$cells"
alias  x_dischargew                      "if water isin $qt$location$qt then if $cells > 6 then if $tp_name_lg isin $weapons then x_dischargewb"
alias  x_dischargep                      "if water isin $qt$location$qt then if $cells > 6 then if $tp_name_lg isin $weapons then x_dischargepb"
alias  x_dischargeb                      "if bridge$loc_name_separatorlow isin $qt$location$qt then if $cells > 6 then if $tp_name_lg isin $weapons then x_dischargewb"

alias  x_shortcut                        "say_team $\$nick$ledstatus {$tp_name_quad} shortcut"
alias  x_opensecret                      "say_team $\$nick$ledstatus open {secret}"
alias  x_openramega                      "say_team $\$nick$ledstatus open {$loc_name_ra$loc_name_separator$loc_name_mh}"
alias  x_opentele                        "say_team $\$nick$ledstatus open {tele$loc_name_separator$loc_name_ya}"

alias  x_trickdm3w                       "if $qt$location$qt = $qtwater$qt then x_dischargew else if $qt$location$qt = $qtwater$loc_name_separatorammo$qt then x_dischargew else if $qt$location$qt = $qtwater$loc_name_separatorgl$qt then x_dischargew else if $qt$location$qt = $qtwater$loc_name_separatorlg$qt then x_dischargew else if $qt$location$qt = $qtwater$loc_name_separatortunnel$qt then x_dischargep else if $qt$location$qt = $qtpent$loc_name_separatorwater$qt then x_dischargep"
alias  x_trickdm2                        "if quad isin $qt$location$qt then x_shortcut else if $qt$location$qt = $qtwater$loc_name_separatorstairs$qt then x_opensecret else if $qt$location$qt = $qtwater$loc_name_separatorng$qt then x_opensecret else if $qt$location$qt = $qtwater$loc_name_separatormid$qt then x_opensecret else if $qt$location$qt = $qtsecret$qt then x_opensecret else if $qt$location$qt = $qtwater$qt then x_opensecret else if $qt$location$qt = $qtlow$loc_name_separatorrl/button$qt then x_openramega else if $qt$location$qt = $qttele$loc_name_separator$loc_name_ya$qt then x_opentele else if $qt$location$qt = $qttele$loc_name_separatorstairs$qt then x_opentele else if $qt$location$qt = $qttele$loc_name_separatorrox$qt then x_opentele else if $qt$location$qt = $qttele$qt then x_opentele else x_trickb"
alias  x_trickdm3                        "if water isin $qt$location$qt then x_trickdm3w else if $qt$location$qt = bridge$loc_name_separatorlow then x_dischargeb else x_trickb"
alias  x_trickb                          "if $qt$mapname$qt != $qtdm2$qt then x_tricka else if ?path? = $qt?$location?$qt then x_opensecret else x_tricka"
alias  x_tricka                          "say_team $\$nick$ledstatus {$location} trick"

alias  x_trick                           "if $qt$mapname$qt = $qtdm2$qt then x_trickdm2 else if $qt$mapname$qt = $qtdm3$qt then x_trickdm3 else x_trickb"

// powerups

// - powerup over
alias  x_quadover                        "say_team $\$nick$x86 $tp_name_quad $tp_name_over"
alias  x_pentover                        "say_team $\$nick$x86 $tp_name_pent $tp_name_over"
alias  x_ringover                        "say_team $\$nick$x86 $tp_name_ring $tp_name_over"
alias  x_suitover                        "say_team $\$nick$x86 $tp_name_suit $tp_name_over"

// - powerup status?
alias  x_statusquad                      "say_team $\$nick$x8b $tp_name_quad $tp_name_ask_status"
alias  x_statuspent                      "say_team $\$nick$x8b $tp_name_pent $tp_name_ask_status"
alias  x_statusring                      "say_team $\$nick$x8b $tp_name_ring $tp_name_ask_status"
alias  x_statussuit                      "say_team $\$nick$x8b $tp_name_suit $tp_name_ask_status"

// - get a powerup
alias  x_getquad                         "say_team $\$nick$x88 $tp_name_get $tp_name_quad"
alias  x_getpentb                        "say_team $\$nick$x88 $tp_name_get $tp_name_pent"
alias  x_getring                         "say_team $\$nick$x88 $tp_name_get $tp_name_ring"
alias  x_getsuit                         "say_team $\$nick$x88 $tp_name_get $tp_name_suit"

alias  x_getpent                         "if $tp_name_pent isin $qt$powerups$qt x_getring else x_getpentb"

// - quad/pent timing
alias  x_quad60                          "say_team $\$nick$x88 $tp_name_quad 60$tp_name_seconds"
alias  x_quad50                          "say_team $\$nick$x88 $tp_name_quad 50$tp_name_seconds"
alias  x_quad40                          "say_team $\$nick$x88 $tp_name_quad 40$tp_name_seconds"
alias  x_quad30                          "say_team $\$nick$x88 $tp_name_quad 30$tp_name_seconds"

alias  x_quad20                          "say_team $\$nick$x88 $tp_name_quad 20$tp_name_seconds"
alias  x_quad10                          "say_team $\$nick$x88 $tp_name_quad 10$tp_name_seconds"
alias  x_quad5                           "say_team $\$nick$x88 $tp_name_quad 5$tp_name_seconds"
alias  x_quadnow                         "say_team $\$nick$x88 $tp_name_get $tp_name_quad $tp_name_now"

alias  x_pent60                          "say_team $\$nick$x88 $tp_name_pent 60$tp_name_seconds"
alias  x_pent50                          "say_team $\$nick$x88 $tp_name_pent 50$tp_name_seconds"
alias  x_pent40                          "say_team $\$nick$x88 $tp_name_pent 40$tp_name_seconds"
alias  x_pent30                          "say_team $\$nick$x88 $tp_name_pent 30$tp_name_seconds"

alias  x_pent20                          "say_team $\$nick$x88 $tp_name_pent 20$tp_name_seconds"
alias  x_pent10                          "say_team $\$nick$x88 $tp_name_pent 10$tp_name_seconds"
alias  x_pent5                           "say_team $\$nick$x88 $tp_name_pent 5$tp_name_seconds"
alias  x_pentnow                         "say_team $\$nick$x88 $tp_name_get $tp_name_pent $tp_name_now"

// help, group
alias  x_helpb                           "say_team $\$nick$x88 help {$location} %eE"
alias  x_group                           "say_team $\$nick$x88 group {$location}"
alias  x_help                            "if $ledstatus != $tp_name_status_green then x_helpb else x_group"

// lost backpack, attack lost, nmy holds
alias  x_lostpack                        "if $qt$deathloc$qt != $qt$tp_name_someplace$qt then say_team $\$nick$x87 $tp_name_backpack lost $tp_name_at {$deathloc} %EE"
alias  x_attacklost                      "if $qt$deathloc$qt != $qt$tp_name_someplace$qt then say_team $\$nick$x87 attack {$deathloc}"
alias  x_holds                           "say_team $\$nick$x87 nmy holds {$location} %eE"

// group at pent, don't kill eyes, delayed pent, delayed ring
alias  x_grouppent                       "say_team $\$nick$x88 group at {$tp_name_pent}"
alias  x_dontkill                        "say_team $\$nick$x86 DON'T KILL $tp_name_eyes"
alias  x_delayedpent                     "say_team $\$nick$x88 $tp_name_pent delayed"
alias  x_delayedring                     "say_team $\$nick$x88 $tp_name_ring delayed"

// chat
alias  x_false                           "say_team $\$nick$x8b PUBLIC/VOICE MSG is FALSE!"
alias  x_cancel                          "say_team $\$nick$x8b cancel that"
alias  x_nosorry                         "say_team $\$nick$x8b no/sorry"
alias  x_yesok                           "say_team $\$nick$x86 yes/ok"

// self actions: i take, coming, enemy coming, attacking, awaiting, safe, camping
alias  x_iquad                           "x_recalculate;say_team $\$nick$x86 i take $tp_name_quad $x_bestweapon{$location} $x_pows"
alias  x_itakemypack                     "x_recalculate;say_team $\$nick$x86 i take/my $tp_name_backpack $x_bestweapon{$location} $x_pows"
alias  x_already                         "say_team $\$nick$x87 {$location} already guarded, bugger off!"

alias  x_nmycoming                       "if ?$mapname? isin $qt$tp_waymaps$qt then say_team $\$nick$x87 $tp_name_enemy coming from {%z}$x20"
alias  x_attacking                       "if ?$mapname? !isin $qt$tp_waymaps$qt then say_team $\$nick$x88 attacking from {$location} else say_team $\$nick$x87 attacking {%Z} from {$location}$x20"

alias  x_wait                            "x_recalculate;say_team $\$nick$x88 awaiting $x_bestweapon{$location} $x_pows"
alias  x_safe                            "x_recalculate;say_team $\$nick$x86 safe $x_bestweapon{$location} $x_pows"
alias  x_camping                         "x_recalculate;say_team $\$nick$x86 camping $x_bestweapon{$location} $x_pows"

// orders: call positions, hide, attack lost, swap, kill
alias  x_reportdeath                     "say_team $\$nick$x8b report death location!"
alias  x_call                            "say_team $\$nick$x8b call your positions!"
alias  x_hide                            "say_team $\$nick$x88 hide/spawn slowly!"

alias  x_swap                            "say_team $\$nick$x88 swap {$location} %eE"

alias  x_choose_best                     "impulse 7 8 5 6 4 3 2"
alias  x_killme                          "x_choose_best;say_team $\$nick$x86 kill me! $weapon {$location}"
alias  x_killyourself                    "say_team $\$nick$x88 kill yourself! {$location}"

// item soon, unlocked, KT' scores
alias  x_itemsoon                        "say_team $\$nick$x86 soon {$location}"
alias  x_unlocked                        "say_team $\$nick$x86 unlocked {$location}"
alias  x_scores                          "scores"

// dm2 specific
alias  x_dm2lava                         "if $mapname = dm2 then say_team $\$nick$x87 lava in {bigroom}"
alias  x_dm2secret                       "if $mapname = dm2 then say_team $\$nick$x87 $tp_name_enemy took {secret $loc_name_ra}"

// cooperative bindings
alias  x_tooksilver                      "say_team $\$nick$x86 took silver key $tp_name_at {$location}"
alias  x_tookgolden                      "say_team $\$nick$x86 took gold key $tp_name_at {$location}" 
alias  x_openedsilver                    "say_team $\$nick$x86 opened silver door $tp_name_at {$location}"
alias  x_openedgolden                    "say_team $\$nick$x86 opened golden door $tp_name_at {$location}" 

alias  x_axetrick                        "say_team $\$nick$x86 {$location} $tp_name_axe trick"
alias  x_secret                          "say_team $\$nick$x86 {$location} secret triggered"
alias  x_tookrune                        "say_team $\$nick$x86 our rune"
alias  x_checkplayername2                "if $qt?$pointloc?$qt != $qt?$tp_name_someplace?$qt then echo $point at $pointloc else echo $point"
alias  x_checkplayername                 "if $qt$ledpoint$qt = $qt$tp_name_status_green$qt then x_checkplayername2

// console aliases; not bound
alias  sync                              "say_team $\$nick$x88 sync attack from {$location}"

alias  yar                               "say_team $\$nick$x88 {$loc_name_ya} $tp_name_rush"
alias  rar                               "say_team $\$nick$x88 {$loc_name_ra} $tp_name_rush"
alias  qr                                "say_team $\$nick$x88 {$tp_name_quad} $tp_name_rush"
alias  pentr                             "say_team $\$nick$x88 {$tp_name_pent} $tp_name_rush"

alias  erl                               "say_team $\$nick$x87 $tp_name_enemy $tp_name_rl!"
alias  edied                             "say_team $\$nick$x86 $tp_name_rl died"
alias  gr                                "x_getring"
alias  ge                                "gr"

alias  yarush                            "yar"
alias  rarush                            "rar"
alias  quadrush                          "qr"
alias  pr                                "pentr"

alias  prush                             "pentr"
alias  pentrush                          "pentr"
alias  666rush                           "pentr"
alias  666r                              "pentr"

alias  66r                               "pentr"
alias  6r                                "pentr"
alias  yr                                "yar"
alias  rr                                "rar"

alias  km                                "x_killme;x_killme"
alias  ky                                "x_need;x_killyourself;x_killyourself"
alias  fal                               "x_false"

// end of file

================================================
FILE: misc/cfg/teamtime.cfg
================================================
// ***** BEGIN LICENSE BLOCK ***** 
// Version: MPL 1.1/GPL 2.0/LGPL 2.1 
// 
// The contents of this file are subject to the Mozilla Public License Version 
// 1.1 (the "License"); you may not use this file except in compliance with 
// the License. You may obtain a copy of the License at 
// http://www.mozilla.org/MPL/ 
// 
// Software distributed under the License is distributed on an "AS IS" basis, 
// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
// for the specific language governing rights and limitations under the 
// License. 
// 
// The Original Code is the toekk.org QuakeWorld timer script. 
// 
// The Initial Developer of the Original Code is 
// Alexander Ahern - toekk at toekk dot org. 
// Portions created by the Initial Developer are Copyright (C) 2005 
// the Initial Developer. All Rights Reserved. 
// 
// Contributor(s): 
// 
// Alternatively, the contents of this file may be used under the terms of 
// either the GNU General Public License Version 2 or later (the "GPL"), or 
// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), 
// in which case the provisions of the GPL or the LGPL are applicable instead 
// of those above. If you wish to allow use of your version of this file only 
// under the terms of either the GPL or the LGPL, and not to allow others to 
// use your version of this file under the terms of the MPL, indicate your 
// decision by deleting the provisions above and replace them with the notice 
// and other provisions required by the GPL or the LGPL. If you do not delete 
// the provisions above, a recipient may use your version of this file under 
// the terms of any one of the MPL, the GPL or the LGPL. 
// 
// ***** END LICENSE BLOCK ***** 

// $Id: teamtime.cfg,v 1.1 2006-04-20 18:49:00 johnnycz Exp $ 

// Bindings: 
// The variables "__kt_X" indicate the keys you should bind. 
// __kt_reset - resets the timer, if you make a mistake entering a time. 
// __kt_spam - tell your teammates the time on the currently selected timer. 
// __kt_nudgeup   - increment current item's time by 1. 
// __kt_nudgedown - you can guess! 
// __kt_zero/one... - typically these are the the numeric keypad. 

// Installation: 
// Put the timer.cfg in your quakeworld/id1 directory, and then place 
// "exec timer.cfg" in your config somewhere. This will bind all the 
// keys and set your timers to zero. The script will not be much use unless 
// you also set "cl_gameclock 1" in your config! 

// Usage: 
// At the moment, the timer only records quad, rl, pent, ra and ya times. 
// To enter a time, first select the item you wish to record: 
// 1: yellow armour 
// 2: red armour 
// 4: quad 
// 6: pent 
// 7: rocket launcher 
// Then type the time you took the item. As an example, suppose we collect rl 
// on 47 seconds. Type "7", "4", "7" and the script will report that the next 
// rl is on 17. 
// 
// (these instructions assume you have the standard numeric keypad bindings) 

// Customisation: 
// To change your message, the alias __kt_spam can be redefined. 

// Contact: 
// The author, toekk, can usually be found on QuakeNet IRC, 
// channel #knockback. 
// JohnNy_cz, 1.13->1.13j updater - #qw.cz

set __kt_reset      "kp_enter" 
set __kt_spam      "kp_star" 
set __kt_nudgeup    "kp_plus" 
set __kt_nudgedown    "kp_minus" 
set __kt_zero       "kp_0" 
set __kt_one       "kp_1" 
set __kt_two       "kp_2" 
set __kt_three       "kp_3" 
set __kt_four       "kp_4" 
set __kt_five       "kp_5" 
set __kt_six       "kp_6" 
set __kt_seven       "kp_7" 
set __kt_eight       "kp_8" 
set __kt_nine       "kp_9" 

set __t_quad       "00" 
set __t_rl       "00" 
set __t_pent       "00" 
set __t_ra      "00" 
set __t_ya      "00" 

set __t_tens      0 
set __t_units      0 
set __t_item      0 
set __t_tmp      0 

// Save the temporary time __t_tmp into the correct item's time 
alias _t_save      "if $qt,$__t_item,$qt isin $qt,quad,rl,pent,ya,ra,$qt then set __t_$__t_item $__t_tmp" 

// Load the selected item's time into the temporary time __t_tmp 
alias _t_load      "if $qt,$__t_item,$qt isin $qt,quad,rl,pent,ya,ra,$qt then _t_load$__t_item" 
alias _t_loadquad   "set __t_tmp $__t_quad" 
alias _t_loadrl      "set __t_tmp $__t_rl" 
alias _t_loadpent   "set __t_tmp $__t_pent" 
alias _t_loadra      "set __t_tmp $__t_ra" 
alias _t_loadya      "set __t_tmp $__t_ya" 

// Show the current time as an echo 
alias _t_echo      "echo $__t_item on $__t_tmp" 

// Spam the current time 
alias _t_spam      "say_team $\$nick $__t_item $__t_tmp; _t_bindselect" 

// Panic button to stop setting a time if you make a mistake 
alias _t_reset      "bf; echo reset - selection mode; _t_bindselect" 

// Select item to set/report it's time 
alias _ts_ya      "echo yellow selected; _t_save; set __t_item ya; _t_load; _t_bindtens;" 
alias _ts_ra      "echo red selected; _t_save; set __t_item ra; _t_load; _t_bindtens;" 
alias _ts_quad      "echo quad selected; _t_save; set __t_item quad; _t_load; _t_bindtens" 
alias _ts_rl      "echo rl selected; _t_save; set __t_item rl; _t_load; _t_bindtens" 
alias _ts_pent      "echo pent selected; _t_save; set __t_item pent; _t_load; _t_bindtens" 

// Bind all the keys to item selection 
alias _t_bindselect   "unbind $__kt_zero; bind $__kt_one _ts_ya; bind $__kt_two _ts_ra; unbind $__kt_three; bind $__kt_four _ts_quad; unbind $__kt_five; bind $__kt_six _ts_pent; bind $__kt_seven _ts_rl; unbind $__kt_eight; unbind $__kt_nine;" 

// Bind all the keys to unit selection 
alias _t_bindunits   "bind $__kt_zero _tu_zero; bind $__kt_one _tu_one; bind $__kt_two _tu_two; bind $__kt_three _tu_three; bind $__kt_four _tu_four; bind $__kt_five _tu_five; bind $__kt_six _tu_six; bind $__kt_seven _tu_seven; bind $__kt_eight _tu_eight; bind $__kt_nine _tu_nine" 

// Bind keys to tens selection 
alias _t_bindtens   "bind $__kt_zero _tt_zero; bind $__kt_one _tt_one; bind $__kt_two _tt_two; bind $__kt_three _tt_three; bind $__kt_four _tt_four; bind $__kt_five _tt_five; unbind $__kt_six; unbind $__kt_seven; unbind $__kt_eight; unbind $__kt_nine" 

// Take a weapon, this adds 30 seconds 
// this works for any gameclock settings the same - JohnNy_cz
alias _t_weapon    "inc __t_tmp 30; if $__t_tmp >= 60 then inc __t_tmp -60; _t_pad" 

// Take an armour, this adds 20 seconds 
// <JohnNy_cz>
alias _t_armour      "if $cl_gameclock == 1 _t_armour_cw else if $cl_gameclock == 3 _t_armour_cw else _t_armour_ccw"
alias _t_armour_cw      "inc __t_tmp 20; if $__t_tmp >= 60 then inc __t_tmp -60; _t_pad" 
alias _t_armour_ccw      "inc __t_tmp -20; if $__t_tmp < 0 then inc __t_tmp 60; _t_pad"
// </JohnNy_cz>

// Pad with leading zeros 
alias _t_pad      "if $__t_tmp < 10 then set __t_tmp 0$__t_tmp" 

// Set the time 
alias _t_settime   "set __t_tmp $qt$__t_tens$__t_units$qt; if $__t_item == rl then _t_weapon else if $qt,$__t_item,$qt isin $qt,ra,ya,$qt then _t_armour" 
alias _t_nudgeup   "inc __t_tmp; if $__t_tmp >= 60 then inc __t_tmp -60; _t_pad; _t_echo" 
alias _t_nudgedown   "inc __t_tmp -1; if $__t_tmp < 0 then inc __t_tmp 60; _t_pad; _t_echo" 

// Units 
alias _tu_zero      "set __t_units 0; _t_settime; _t_spam; _t_bindselect" 
alias _tu_one      "set __t_units 1; _t_settime; _t_spam; _t_bindselect" 
alias _tu_two      "set __t_units 2; _t_settime; _t_spam; _t_bindselect" 
alias _tu_three      "set __t_units 3; _t_settime; _t_spam; _t_bindselect" 
alias _tu_four      "set __t_units 4; _t_settime; _t_spam; _t_bindselect" 
alias _tu_five      "set __t_units 5; _t_settime; _t_spam; _t_bindselect" 
alias _tu_six      "set __t_units 6; _t_settime; _t_spam; _t_bindselect" 
alias _tu_seven      "set __t_units 7; _t_settime; _t_spam; _t_bindselect" 
alias _tu_eight      "set __t_units 8; _t_settime; _t_spam; _t_bindselect" 
alias _tu_nine      "set __t_units 9; _t_settime; _t_spam; _t_bindselect" 

// Tens 
alias _tt_zero      "echo 0...; set __t_tens 0; _t_bindunits" 
alias _tt_one      "echo 1...; set __t_tens 1; _t_bindunits" 
alias _tt_two      "echo 2...; set __t_tens 2; _t_bindunits" 
alias _tt_three      "echo 3...; set __t_tens 3; _t_bindunits" 
alias _tt_four      "echo 4...; set __t_tens 4; _t_bindunits" 
alias _tt_five      "echo 5...; set __t_tens 5; _t_bindunits" 

// Setup 

_t_bindselect 
bind $__kt_reset    "_t_reset" 
bind $__kt_spam      "_t_spam" 
bind $__kt_nudgeup   "_t_nudgeup" 
bind $__kt_nudgedown   "_t_nudgedown" 

echo "timer.cfg $Revision: 1.1 $"

================================================
FILE: misc/pak.lst
================================================
base.pk3
help.pk3
hud.pk3
progs.pk3
locs.pk3
levelshots.pk3


================================================
FILE: misc/sb/au-sv.txt
================================================
159.196.248.221:27600
103.195.53.179:28501
103.195.53.179:28502
103.195.53.179:28503
103.25.59.27:28000
103.25.59.27:28501
103.25.59.27:28502
103.25.59.27:28504
182.239.198.9:27500
103.25.59.27:30000
103.25.59.27:27501
103.25.59.27:27504
103.25.59.27:27505
103.25.59.27:27503
103.25.59.27:27502
103.151.65.19:27500
103.151.65.19:30000
16.50.174.37:27510
3.25.174.195:27501
3.25.174.195:27500
3.25.174.195:27502
3.25.174.195:30000
3.25.174.195:27510
3.25.174.195:27503
159.196.248.221:27601
210.54.39.19:28501
115.188.3.198:27500
103.151.65.11:28000
103.151.65.11:30000
103.151.65.11:28501
103.151.65.11:28502
163.47.21.45:28000
103.151.65.11:28503
103.151.65.11:28504
103.195.53.179:28000
223.165.64.141:27500
172.105.184.44:27501
203.29.243.177:28000
203.29.243.177:30000
203.29.243.177:28501
124.189.251.43:27666
124.189.251.43:28001
124.189.251.43:28002
124.189.251.43:28003
124.189.251.43:28000
124.189.251.43:30000
163.47.21.45:30000
103.25.59.27:28503


================================================
FILE: misc/sb/cache/empty
================================================


================================================
FILE: misc/sb/check_sources.sh
================================================
for source in *.txt; do
  cat $source | grep -v -E -e "^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+:[0-9]{5}$" 
done



================================================
FILE: misc/sb/ctf.txt
================================================
72.83.103.37:28505
54.94.165.196:30000
159.196.248.221:27601
98.144.80.46:27500
149.28.240.2:28507
45.76.23.209:28507
159.203.25.195:28507


================================================
FILE: misc/sb/eu-4on4.txt
================================================
144.24.188.96:28501
89.66.241.225:28501
209.38.242.238:28501
128.199.52.100:28502
128.199.52.100:28503
128.199.52.100:28504
194.38.96.52:28501
194.38.96.52:28502
194.38.96.52:28503
194.38.96.52:28504
80.241.209.47:28501
185.11.166.90:28501
185.11.166.90:28502
185.11.166.90:28503
139.162.245.4:28501
217.197.83.154:28501
217.197.83.154:28502
217.197.83.154:28503
217.197.83.154:28504
108.61.178.207:27501
108.61.178.207:27502
108.61.178.207:27503
108.61.178.207:27504
108.61.178.207:27505
108.61.178.207:27506
108.61.178.207:27507
108.61.178.207:28501
108.61.178.207:28502
108.61.178.207:28503
108.61.178.207:29501
82.102.20.226:27501
82.102.20.226:27502
82.102.20.226:27503
82.102.20.226:27504
82.102.20.226:27505
82.102.20.226:28501
82.102.20.226:28502
82.102.20.226:28503
82.102.20.226:28504
82.102.20.226:28505
185.73.44.100:28501
185.73.44.100:28502
185.73.44.100:28503
185.73.44.100:28504
185.73.44.100:28505
185.73.44.100:28506
163.172.90.127:28501
163.172.90.127:28502
163.172.90.127:28503
163.172.90.127:28504
195.201.133.22:27600
195.201.133.22:27700
195.201.133.22:27800
145.239.54.184:28501
35.158.239.193:28501
35.158.239.193:28502
35.158.239.193:28503
35.158.239.193:28504
91.206.14.17:27500
91.206.14.17:27501
91.206.14.17:27502
91.206.14.17:27503
91.206.14.17:27504
91.206.14.17:27505
91.206.14.17:27506
91.206.14.17:27507
91.206.14.17:27508
91.206.14.17:27509
20.13.149.88:28501
20.13.149.88:28502
136.243.174.101:27166
51.38.225.118:27500
193.108.113.153:28501
193.108.113.153:28502
193.108.113.153:28503
193.108.113.153:28504
5.9.82.79:27500
130.185.249.174:28501
130.185.249.174:28502
46.101.78.83:28502
46.101.78.83:28501
46.101.78.83:28502
46.101.78.83:28503
46.101.78.83:28504
188.166.0.137:28501
188.166.0.137:28502
188.166.0.137:28503
188.166.0.137:28504
108.61.117.210:27502
108.61.117.210:27503
108.61.117.210:28501
108.61.117.210:28502
108.61.117.210:28503
82.196.2.206:28502
82.196.2.206:28502
82.196.2.206:28503
82.196.2.206:28504
82.196.2.206:28504
82.196.2.206:28501
82.196.2.206:28502
82.196.2.206:28503
82.196.2.206:28504
82.196.2.206:28505
82.196.2.206:28506
80.211.201.216:28501
80.211.201.216:28502
80.211.201.216:28503
80.211.201.216:28504
37.221.215.47:28501
37.221.215.47:28502
193.42.36.145:28501
193.42.36.145:28502
137.74.7.185:27501
212.42.38.88:27501
212.42.38.88:27502
85.242.107.149:28501
188.40.66.105:28501
188.40.66.105:28503
46.227.68.148:28501
46.227.68.148:28502
46.227.68.148:28503
46.227.68.148:28504
46.227.68.148:28505
46.227.68.148:28506
46.227.68.148:28507
46.227.68.148:28508
46.227.68.148:28509
46.227.68.148:28510
95.216.202.86:28501
130.242.114.28:28501
130.242.114.28:28502
130.242.114.28:28503
130.242.114.28:28504
130.242.114.28:28505
130.242.114.28:28506
130.242.114.28:28507
130.242.114.28:28508
130.242.114.28:28509
130.242.114.28:28510
78.45.89.65:28501
78.45.89.65:28502
95.165.130.151:27501
95.165.130.151:27502
95.165.130.151:27503
51.210.10.181:28501
141.105.67.104:28000
141.105.67.104:28501
141.105.67.104:28502
176.210.100.6:28501
176.210.100.6:28502
168.119.172.182:28501
168.119.172.182:28502
168.119.172.182:28503
168.119.172.182:28504
13.49.243.223:28501
13.49.243.223:28502
13.49.243.223:28503
13.49.243.223:28504
185.189.48.45:28501
185.189.48.45:28502
185.189.48.45:28503
185.189.48.45:28504
185.189.48.45:28505
185.189.48.45:28506
78.45.93.104:27500
79.139.57.116:27500
213.164.209.174:28501
95.216.18.118:28001
95.216.18.118:28002
95.216.18.118:28003
217.215.138.225:27500
145.239.94.156:27500
145.239.94.156:27501
145.239.94.156:27502
145.239.94.156:27503
145.239.94.156:27504
45.147.98.159:28505
45.147.98.159:28506
45.147.98.159:28501
45.147.98.159:28501
45.147.98.159:28502
45.147.98.159:28502
45.147.98.159:28503
45.147.98.159:28503
45.147.98.159:28504
45.147.98.159:28504


================================================
FILE: misc/sb/eu-sv.txt
================================================
144.24.188.96:28501
89.66.241.225:30000
89.66.241.225:28501
185.73.44.100:27500
193.227.134.114:27500
193.227.134.114:27501
193.227.134.114:27502
193.227.134.114:27503
209.38.242.238:28501
128.199.52.100:28501
128.199.52.100:28502
128.199.52.100:28503
128.199.52.100:28504
194.38.96.52:27500
194.38.96.52:28000
194.38.96.52:30000
194.38.96.52:28501
194.38.96.52:28502
194.38.96.52:28503
194.38.96.52:28504
80.241.209.47:28501
95.94.59.73:27500
185.11.166.90:28501
185.11.166.90:28502
185.11.166.90:28503
139.162.245.4:28501
217.197.83.154:28000
217.197.83.154:30000
217.197.83.154:28501
217.197.83.154:28502
217.197.83.154:28503
217.197.83.154:28504
108.61.178.207:28000
108.61.178.207:30000
108.61.178.207:27501
108.61.178.207:27502
108.61.178.207:27503
108.61.178.207:27504
108.61.178.207:27505
108.61.178.207:27506
108.61.178.207:27507
108.61.178.207:28501
108.61.178.207:28502
108.61.178.207:28503
108.61.178.207:29501
108.61.178.207:29502
85.242.107.149:28000
85.242.107.149:30000
82.102.20.226:30000
82.102.20.226:27501
82.102.20.226:27502
82.102.20.226:27503
82.102.20.226:27504
82.102.20.226:27505
82.102.20.226:28501
82.102.20.226:28502
82.102.20.226:28503
82.102.20.226:28504
82.102.20.226:28505
185.73.44.100:28000
185.73.44.100:30000
185.73.44.100:28501
185.73.44.100:28502
185.73.44.100:28503
185.73.44.100:28504
185.73.44.100:28505
185.73.44.100:28506
163.172.90.127:28000
163.172.90.127:30000
163.172.90.127:28501
163.172.90.127:28502
163.172.90.127:28503
163.172.90.127:28504
195.201.133.22:27600
195.201.133.22:27700
195.201.133.22:27800
195.201.133.22:28000
195.201.133.22:30000
213.239.216.253:27500
141.105.67.104:27500
34.244.130.97:30000
34.244.130.97:27510
13.40.65.97:30000
13.40.65.97:27510
16.170.162.186:27501
16.170.162.186:27500
16.170.162.186:27502
16.170.162.186:30000
16.170.162.186:27510
16.170.162.186:27503
145.239.54.184:28000
145.239.54.184:30000
145.239.54.184:28501
35.158.239.193:28000
35.158.239.193:30000
35.158.239.193:28501
35.158.239.193:28502
35.158.239.193:28503
35.158.239.193:28504
91.206.14.17:27500
91.206.14.17:27501
91.206.14.17:27502
91.206.14.17:27503
91.206.14.17:27504
91.206.14.17:27505
91.206.14.17:27506
91.206.14.17:27507
91.206.14.17:27508
91.206.14.17:27509
91.206.14.17:28000
91.206.14.17:30000
20.13.149.88:28000
20.13.149.88:30000
20.13.149.88:28501
20.13.149.88:28502
136.243.174.101:27166
51.38.225.118:27500
193.108.113.153:28000
193.108.113.153:30000
193.108.113.153:28501
193.108.113.153:28502
193.108.113.153:28503
193.108.113.153:28504
78.45.89.65:30000
5.9.82.79:27500
130.185.249.174:28000
130.185.249.174:30000
130.185.249.174:28501
130.185.249.174:28502
46.101.78.83:28502
46.101.78.83:30000
46.101.78.83:28501
46.101.78.83:28502
46.101.78.83:28503
46.101.78.83:28504
141.105.67.104:27000
188.166.0.137:28000
188.166.0.137:28501
188.166.0.137:28502
188.166.0.137:28503
188.166.0.137:28504
108.61.117.210:28000
108.61.117.210:30000
108.61.117.210:27501
108.61.117.210:27502
108.61.117.210:27503
108.61.117.210:28501
108.61.117.210:28502
108.61.117.210:28503
82.196.2.206:28502
82.196.2.206:28502
82.196.2.206:28503
82.196.2.206:28504
82.196.2.206:28504
82.196.2.206:30000
82.196.2.206:28501
82.196.2.206:28502
82.196.2.206:28503
82.196.2.206:28504
82.196.2.206:28505
82.196.2.206:28506
146.90.114.169:27500
80.211.201.216:28501
80.211.201.216:28502
80.211.201.216:28503
80.211.201.216:28504
37.221.215.47:28501
37.221.215.47:28502
193.42.36.145:28000
193.42.36.145:30000
193.42.36.145:28501
193.42.36.145:28502
137.74.7.185:27520
137.74.7.185:27500
137.74.7.185:27501
137.74.7.185:27510
137.74.7.185:30000
212.42.38.88:30000
212.42.38.88:27500
212.42.38.88:27501
212.42.38.88:27502
85.242.107.149:28501
95.216.202.86:27666
188.40.66.105:28501
188.40.66.105:28503
91.66.2.91:27500
46.227.68.148:28000
46.227.68.148:30000
46.227.68.148:28501
46.227.68.148:28502
46.227.68.148:28503
46.227.68.148:28504
46.227.68.148:28505
46.227.68.148:28506
46.227.68.148:28507
46.227.68.148:28508
46.227.68.148:28509
46.227.68.148:28510
95.216.202.86:27500
95.216.202.86:28502
95.216.202.86:28501
95.216.202.86:28000
95.216.202.86:30000
95.216.202.86:28504
95.216.202.86:28503
130.242.114.28:28000
130.242.114.28:30000
130.242.114.28:28501
130.242.114.28:28502
130.242.114.28:28503
130.242.114.28:28504
130.242.114.28:28505
130.242.114.28:28506
130.242.114.28:28507
130.242.114.28:28508
130.242.114.28:28509
130.242.114.28:28510
78.45.89.65:28501
78.45.89.65:28502
78.45.89.65:28503
95.165.130.151:27500
95.165.130.151:27501
95.165.130.151:27502
95.165.130.151:27503
188.166.161.185:27501
188.166.161.185:30000
188.166.161.185:27502
188.166.161.185:27500
185.11.166.90:28000
185.11.166.90:30000
51.210.10.181:28000
51.210.10.181:28501
37.201.131.70:28000
37.201.131.70:30000
45.142.244.163:28501
141.105.67.104:28000
141.105.67.104:28501
141.105.67.104:28502
176.210.100.6:28501
176.210.100.6:28502
176.210.100.6:30000
13.53.75.0:27500
168.119.172.182:28000
168.119.172.182:30000
168.119.172.182:28501
168.119.172.182:28502
168.119.172.182:28503
168.119.172.182:28504
13.49.243.223:28000
13.49.243.223:30000
13.49.243.223:28501
13.49.243.223:28502
13.49.243.223:28503
13.49.243.223:28504
185.189.48.45:28501
185.189.48.45:28502
185.189.48.45:28503
185.189.48.45:28504
185.189.48.45:28505
185.189.48.45:28506
78.45.93.104:27500
79.139.57.116:27500
213.164.209.174:28501
37.201.131.70:28501
95.216.18.118:30000
95.216.18.118:28001
95.216.18.118:28002
95.216.18.118:28003
217.215.138.225:27500
82.196.2.206:30000
185.189.48.45:30000
139.162.245.4:30000
188.166.0.137:30000
145.239.94.156:28000
145.239.94.156:30000
145.239.94.156:27500
145.239.94.156:27501
145.239.94.156:27502
145.239.94.156:27503
145.239.94.156:27504
188.40.103.81:27600
45.147.98.159:28000
45.147.98.159:28505
45.147.98.159:28506
45.147.98.159:28501
45.147.98.159:28501
45.147.98.159:28502
45.147.98.159:28502
45.147.98.159:28503
45.147.98.159:28503
45.147.98.159:28504
45.147.98.159:28504


================================================
FILE: misc/sb/global.txt
================================================
177.71.158.196:27500
177.71.158.196:27502
144.22.145.206:27504
144.22.145.206:27506
144.22.145.206:27502
144.22.145.206:27508
144.22.145.206:30000
144.22.145.206:27510
130.162.236.198:28500
34.148.103.12:27500
71.69.230.224:27500
159.196.248.221:27600
103.195.53.179:28501
103.195.53.179:28502
103.195.53.179:28503
192.227.172.145:28000
192.227.172.145:30000
192.227.172.145:28501
192.227.172.145:28502
3.76.38.12:28501
144.24.188.96:28501
54.232.250.209:28000
54.232.250.209:30000
54.232.250.209:28501
54.232.250.209:28502
54.232.250.209:28503
54.232.250.209:28504
129.148.54.225:26000
129.148.54.225:27500
23.227.170.222:26666
103.25.59.27:28000
103.25.59.27:28501
103.25.59.27:28502
103.25.59.27:28504
89.66.241.225:30000
89.66.241.225:28501
185.73.44.100:27500
193.227.134.114:27500
193.227.134.114:27501
193.227.134.114:27502
193.227.134.114:27503
209.38.242.238:28501
182.239.198.9:27500
128.199.52.100:28501
128.199.52.100:28502
128.199.52.100:28503
128.199.52.100:28504
194.38.96.52:27500
194.38.96.52:28000
194.38.96.52:30000
194.38.96.52:28501
194.38.96.52:28502
194.38.96.52:28503
194.38.96.52:28504
80.241.209.47:28501
174.138.43.249:28502
174.138.43.249:28501
99.72.255.45:28501
99.72.255.45:28504
99.72.255.45:28507
114.35.54.116:30000
114.35.54.116:28501
95.94.59.73:27500
185.11.166.90:28501
185.11.166.90:28502
185.11.166.90:28503
162.248.94.117:30000
72.83.103.37:27504
20.221.237.152:26000
72.18.132.133:26000
72.83.103.37:28505
139.162.245.4:28501
155.138.247.213:28000
155.138.247.213:30000
155.138.247.213:28501
155.138.247.213:28502
155.138.247.213:28503
155.138.247.213:28504
217.197.83.154:28000
217.197.83.154:30000
217.197.83.154:28501
217.197.83.154:28502
217.197.83.154:28503
217.197.83.154:28504
108.61.242.130:27500
108.61.178.207:28000
108.61.178.207:30000
108.61.178.207:27501
108.61.178.207:27502
108.61.178.207:27503
108.61.178.207:27504
108.61.178.207:27505
108.61.178.207:27506
108.61.178.207:27507
108.61.178.207:28501
108.61.178.207:28502
108.61.178.207:28503
108.61.178.207:29501
108.61.178.207:29502
64.227.18.147:28501
85.242.107.149:28000
85.242.107.149:30000
82.102.20.226:30000
82.102.20.226:27501
82.102.20.226:27502
82.102.20.226:27503
82.102.20.226:27504
82.102.20.226:27505
82.102.20.226:28501
82.102.20.226:28502
82.102.20.226:28503
82.102.20.226:28504
82.102.20.226:28505
185.73.44.100:28000
185.73.44.100:30000
185.73.44.100:28501
185.73.44.100:28502
185.73.44.100:28503
185.73.44.100:28504
185.73.44.100:28505
185.73.44.100:28506
103.25.59.27:30000
103.25.59.27:27501
103.25.59.27:27504
103.25.59.27:27505
103.25.59.27:27503
103.25.59.27:27502
163.172.90.127:28000
163.172.90.127:30000
163.172.90.127:28501
163.172.90.127:28502
163.172.90.127:28503
163.172.90.127:28504
195.201.133.22:27600
195.201.133.22:27700
195.201.133.22:27800
195.201.133.22:28000
195.201.133.22:30000
18.144.19.16:27500
103.72.77.220:30000
103.72.77.220:28501
103.72.77.220:28502
103.72.77.220:28503
103.72.77.220:28504
72.83.103.37:27500
213.239.216.253:27500
141.105.67.104:27500
104.207.135.230:28008
104.207.135.230:28000
104.207.135.230:30000
104.207.135.230:28001
104.207.135.230:28002
104.207.135.230:28003
104.207.135.230:28004
104.207.135.230:28005
74.91.120.206:28000
74.91.120.206:30000
74.91.120.206:28501
74.91.120.206:28502
162.248.93.195:28000
162.248.93.195:30000
162.248.93.195:28501
162.248.93.195:28502
162.248.93.195:28503
162.248.93.195:28504
20.125.113.83:30000
20.245.213.126:30000
54.177.92.188:27501
54.177.92.188:30000
54.177.92.188:27510
54.177.92.188:27503
50.116.27.42:30000
103.151.65.19:27500
103.151.65.19:30000
34.244.130.97:30000
34.244.130.97:27510
13.40.65.97:30000
13.40.65.97:27510
16.50.174.37:30000
16.50.174.37:27510
144.202.33.70:30000
144.202.33.70:27510
3.108.227.32:27501
3.108.227.32:27500
3.108.227.32:27502
3.108.227.32:30000
3.108.227.32:27510
3.108.227.32:27503
18.228.39.185:27501
18.228.39.185:27502
18.228.39.185:30000
18.228.39.185:27510
18.228.39.185:27503
16.170.162.186:27501
16.170.162.186:27500
16.170.162.186:27502
16.170.162.186:30000
16.170.162.186:27510
16.170.162.186:27503
3.25.174.195:27501
3.25.174.195:27500
3.25.174.195:27502
3.25.174.195:30000
3.25.174.195:27510
3.25.174.195:27503
18.177.140.83:30000
18.208.156.115:27501
18.208.156.115:27502
18.208.156.115:30000
18.208.156.115:27510
18.208.156.115:27503
144.202.59.41:28501
145.239.54.184:28000
145.239.54.184:30000
145.239.54.184:28501
35.158.239.193:28000
35.158.239.193:30000
35.158.239.193:28501
35.158.239.193:28502
35.158.239.193:28503
35.158.239.193:28504
66.85.80.160:28501
66.85.80.160:28000
152.67.110.136:28501
152.67.110.136:28502
152.67.110.136:28503
152.67.110.136:28000
152.67.110.136:30000
54.94.165.196:28501
54.94.165.196:28502
54.94.165.196:30000
54.94.165.196:27700
54.94.165.196:27500
54.94.165.196:27600
91.206.14.17:27500
91.206.14.17:27501
91.206.14.17:27502
91.206.14.17:27503
91.206.14.17:27504
91.206.14.17:27505
91.206.14.17:27506
91.206.14.17:27507
91.206.14.17:27508
91.206.14.17:27509
91.206.14.17:28000
91.206.14.17:30000
162.248.92.183:30000
162.248.92.183:28501
167.71.142.56:28501
167.71.142.56:28502
167.71.142.56:28503
167.71.142.56:28504
191.223.251.197:27500
156.247.189.2:27502
44.210.138.174:26000
174.164.173.71:28000
174.164.173.71:28501
174.164.173.71:28502
174.164.173.71:28503
174.164.173.71:28504
45.32.196.50:28501
45.32.196.50:27500
20.13.149.88:28000
20.13.149.88:30000
20.13.149.88:28501
20.13.149.88:28502
20.241.104.145:28000
20.241.104.145:30000
20.241.104.145:28501
139.84.135.106:28000
139.84.135.106:30000
139.84.135.106:28501
139.84.135.106:28502
20.193.138.18:28000
20.193.138.18:30000
20.193.138.18:28501
20.193.138.18:28502
20.106.48.249:28000
20.106.48.249:30000
20.106.48.249:28501
20.106.48.249:28502
136.243.174.101:27166
20.243.122.16:28000
20.243.122.16:30000
20.243.122.16:28501
51.38.225.118:27500
148.135.104.18:27020
72.83.103.37:27501
72.83.103.37:27502
72.83.103.37:27503
193.108.113.153:28000
193.108.113.153:30000
193.108.113.153:28501
193.108.113.153:28502
193.108.113.153:28503
193.108.113.153:28504
72.83.103.37:666
45.32.75.169:30000
45.32.75.169:28501
45.32.75.169:28502
45.32.75.169:28503
45.32.75.169:28504
78.45.89.65:30000
69.247.38.137:27500
135.181.96.161:27500
5.9.82.79:27500
130.185.249.174:28000
130.185.249.174:30000
130.185.249.174:28501
130.185.249.174:28502
46.101.78.83:28502
46.101.78.83:30000
46.101.78.83:28501
46.101.78.83:28502
46.101.78.83:28503
46.101.78.83:28504
159.196.248.221:27601
141.105.67.104:27000
52.67.74.216:27500
72.83.103.37:28000
188.166.0.137:28000
188.166.0.137:28501
188.166.0.137:28502
188.166.0.137:28503
188.166.0.137:28504
108.61.117.210:28000
108.61.117.210:30000
108.61.117.210:27501
108.61.117.210:27502
108.61.117.210:27503
108.61.117.210:28501
108.61.117.210:28502
108.61.117.210:28503
82.196.2.206:28502
82.196.2.206:28502
82.196.2.206:28503
82.196.2.206:28504
82.196.2.206:28504
82.196.2.206:30000
82.196.2.206:28501
82.196.2.206:28502
82.196.2.206:28503
82.196.2.206:28504
82.196.2.206:28505
82.196.2.206:28506
146.90.114.169:27500
80.211.201.216:28501
80.211.201.216:28502
80.211.201.216:28503
80.211.201.216:28504
149.28.62.121:30000
149.28.62.121:28501
149.28.62.121:28502
149.28.62.121:28504
210.54.39.19:28501
115.188.3.198:27500
164.152.62.160:28000
164.152.62.160:30000
18.228.199.156:28500
18.228.199.156:28501
18.228.199.156:28502
18.228.199.156:28503
18.228.199.156:28504
103.151.65.11:28000
103.151.65.11:30000
103.151.65.11:28501
103.151.65.11:28502
37.221.215.47:28501
37.221.215.47:28502
23.22.56.152:28501
23.22.56.152:28502
23.22.56.152:28503
23.22.56.152:28504
193.42.36.145:28000
193.42.36.145:30000
193.42.36.145:28501
193.42.36.145:28502
137.74.7.185:27520
137.74.7.185:27500
137.74.7.185:27501
137.74.7.185:27510
137.74.7.185:30000
212.42.38.88:30000
212.42.38.88:27500
212.42.38.88:27501
212.42.38.88:27502
150.136.70.158:27500
139.162.45.192:30000
85.242.107.149:28501
64.227.18.147:28502
64.227.18.147:28503
64.227.18.147:28504
24.87.1.123:26000
95.216.202.86:27666
163.47.21.45:28000
188.40.66.105:28501
188.40.66.105:28503
91.66.2.91:27500
46.227.68.148:28000
46.227.68.148:30000
46.227.68.148:28501
46.227.68.148:28502
46.227.68.148:28503
46.227.68.148:28504
46.227.68.148:28505
46.227.68.148:28506
46.227.68.148:28507
46.227.68.148:28508
46.227.68.148:28509
46.227.68.148:28510
45.56.70.87:28501
45.56.70.87:28502
45.56.70.87:28503
45.56.70.87:28504
170.239.85.110:28000
170.239.85.110:30000
170.239.85.110:28501
170.239.85.110:28502
170.239.85.110:28503
170.239.85.110:28504
170.239.85.110:28505
103.151.65.11:28503
103.151.65.11:28504
103.195.53.179:28000
95.216.202.86:27500
95.216.202.86:28502
95.216.202.86:28501
95.216.202.86:28000
95.216.202.86:30000
95.216.202.86:28504
95.216.202.86:28503
130.242.114.28:28000
130.242.114.28:30000
130.242.114.28:28501
130.242.114.28:28502
130.242.114.28:28503
130.242.114.28:28504
130.242.114.28:28505
130.242.114.28:28506
130.242.114.28:28507
130.242.114.28:28508
130.242.114.28:28509
130.242.114.28:28510
78.45.89.65:28501
78.45.89.65:28502
78.45.89.65:28503
164.152.62.160:28501
164.152.62.160:28502
164.152.62.160:28503
164.152.62.160:28504
95.165.130.151:27500
95.165.130.151:27501
95.165.130.151:27502
95.165.130.151:27503
160.16.101.168:30000
72.83.103.37:30000
138.197.111.29:28501
188.166.161.185:27501
188.166.161.185:30000
188.166.161.185:27502
188.166.161.185:27500
156.247.189.2:27506
223.165.64.141:27500
72.94.86.54:27500
52.89.197.170:26000
52.89.197.170:26001
185.11.166.90:28000
185.11.166.90:30000
206.51.245.84:27500
45.76.56.39:28000
45.76.56.39:30000
45.76.56.39:28001
45.76.56.39:28002
45.76.56.39:28003
45.76.56.39:28004
45.76.56.39:28005
70.34.202.147:30000
70.34.202.147:28501
70.34.202.147:28502
70.34.202.147:28503
70.34.202.147:28504
70.34.202.147:29501
172.105.184.44:27501
20.245.6.70:28000
20.245.6.70:30000
35.185.44.174:27502
75.102.17.203:28501
75.102.17.203:28502
75.102.17.203:28503
75.102.17.203:28504
75.102.17.203:28000
75.102.17.203:30000
51.210.10.181:28000
51.210.10.181:28501
37.201.131.70:28000
37.201.131.70:30000
170.39.226.130:28501
45.142.244.163:28501
141.105.67.104:28000
141.105.67.104:28501
141.105.67.104:28502
176.210.100.6:28501
176.210.100.6:28502
176.210.100.6:30000
13.53.75.0:27500
168.119.172.182:28000
168.119.172.182:30000
168.119.172.182:28501
168.119.172.182:28502
168.119.172.182:28503
168.119.172.182:28504
13.49.243.223:28000
13.49.243.223:30000
13.49.243.223:28501
13.49.243.223:28502
13.49.243.223:28503
13.49.243.223:28504
185.189.48.45:28501
185.189.48.45:28502
185.189.48.45:28503
185.189.48.45:28504
185.189.48.45:28505
185.189.48.45:28506
98.144.80.46:27500
78.45.93.104:27500
79.139.57.116:27500
177.76.50.14:27501
177.76.50.14:27502
177.76.50.14:27503
177.76.50.14:27504
177.76.50.14:28000
177.76.50.14:27506
177.76.50.14:27505
23.227.170.216:27502
23.227.170.216:27500
23.227.170.216:27501
23.227.170.216:27507
23.227.170.216:27505
23.227.170.216:27506
213.164.209.174:28501
37.201.131.70:28501
203.29.243.177:28000
203.29.243.177:30000
203.29.243.177:28501
124.189.251.43:27666
124.189.251.43:28001
124.189.251.43:28002
124.189.251.43:28003
124.189.251.43:28000
124.189.251.43:30000
95.216.18.118:30000
95.216.18.118:28001
95.216.18.118:28002
95.216.18.118:28003
217.215.138.225:27500
72.83.103.37:27505
144.22.145.206:27500
102.37.98.187:27500
50.116.17.172:28501
163.47.21.45:30000
82.196.2.206:30000
185.189.48.45:30000
66.85.80.160:30000
139.162.245.4:30000
188.166.0.137:30000
149.28.240.2:28000
149.28.240.2:30000
45.76.23.209:28000
45.76.23.209:30000
159.203.25.195:28000
159.203.25.195:30000
207.148.5.167:28502
207.148.5.167:28501
207.148.5.167:28000
207.148.5.167:30000
149.28.240.2:28507
149.28.240.2:28505
149.28.240.2:28503
149.28.240.2:28501
149.28.240.2:28506
149.28.240.2:28502
149.28.240.2:28504
45.76.23.209:28507
45.76.23.209:28505
45.76.23.209:28503
45.76.23.209:28501
45.76.23.209:28506
45.76.23.209:28502
45.76.23.209:28504
159.65.230.186:27505
159.65.230.186:27502
159.65.230.186:27500
159.65.230.186:27504
159.65.230.186:28000
159.65.230.186:30000
159.65.230.186:27501
159.65.230.186:27503
159.203.25.195:28507
159.203.25.195:28505
159.203.25.195:28503
159.203.25.195:28501
159.203.25.195:28506
159.203.25.195:28502
159.203.25.195:28504
5.161.189.133:27600
138.68.21.116:30000
138.68.21.116:28000
138.68.21.116:28501
138.68.21.116:28502
20.51.107.74:28000
20.51.107.74:30000
20.51.107.74:28501
20.51.107.74:28502
20.69.57.161:28000
20.69.57.161:30000
20.69.57.161:28501
20.69.57.161:28502
13.245.119.116:28000
13.245.119.116:27500
13.245.119.116:28501
13.245.119.116:28502
145.239.94.156:28000
145.239.94.156:30000
145.239.94.156:27500
145.239.94.156:27501
145.239.94.156:27502
145.239.94.156:27503
145.239.94.156:27504
188.40.103.81:27600
103.25.59.27:28503
35.185.44.174:27500
45.147.98.159:28000
45.147.98.159:28505
45.147.98.159:28506
45.147.98.159:28501
45.147.98.159:28501
45.147.98.159:28502
45.147.98.159:28502
45.147.98.159:28503
45.147.98.159:28503
45.147.98.159:28504
45.147.98.159:28504
52.240.58.168:27503
52.240.58.168:27515
208.77.22.94:27501


================================================
FILE: misc/sb/na-sv.txt
================================================
130.162.236.198:28500
34.148.103.12:27500
71.69.230.224:27500
192.227.172.145:28000
192.227.172.145:30000
192.227.172.145:28501
192.227.172.145:28502
3.76.38.12:28501
23.227.170.222:26666
174.138.43.249:28502
174.138.43.249:28501
99.72.255.45:28501
99.72.255.45:28504
99.72.255.45:28507
162.248.94.117:30000
72.83.103.37:27504
20.221.237.152:26000
72.18.132.133:26000
72.83.103.37:28505
155.138.247.213:28000
155.138.247.213:30000
155.138.247.213:28501
155.138.247.213:28502
155.138.247.213:28503
155.138.247.213:28504
108.61.242.130:27500
64.227.18.147:28501
18.144.19.16:27500
103.72.77.220:30000
103.72.77.220:28501
103.72.77.220:28502
103.72.77.220:28503
103.72.77.220:28504
72.83.103.37:27500
104.207.135.230:28008
104.207.135.230:28000
104.207.135.230:30000
104.207.135.230:28001
104.207.135.230:28002
104.207.135.230:28003
104.207.135.230:28004
104.207.135.230:28005
74.91.120.206:28000
74.91.120.206:30000
74.91.120.206:28501
74.91.120.206:28502
162.248.93.195:28000
162.248.93.195:30000
162.248.93.195:28501
162.248.93.195:28502
162.248.93.195:28503
162.248.93.195:28504
20.125.113.83:30000
20.245.213.126:30000
54.177.92.188:27501
54.177.92.188:30000
54.177.92.188:27510
54.177.92.188:27503
50.116.27.42:30000
16.50.174.37:30000
144.202.33.70:30000
144.202.33.70:27510
18.208.156.115:27501
18.208.156.115:27502
18.208.156.115:30000
18.208.156.115:27510
18.208.156.115:27503
144.202.59.41:28501
66.85.80.160:28501
66.85.80.160:28000
152.67.110.136:28501
152.67.110.136:28502
152.67.110.136:28503
152.67.110.136:28000
152.67.110.136:30000
162.248.92.183:30000
162.248.92.183:28501
167.71.142.56:28501
167.71.142.56:28502
167.71.142.56:28503
167.71.142.56:28504
44.210.138.174:26000
174.164.173.71:28000
174.164.173.71:28501
174.164.173.71:28502
174.164.173.71:28503
174.164.173.71:28504
45.32.196.50:28501
45.32.196.50:27500
20.241.104.145:28000
20.241.104.145:30000
20.241.104.145:28501
20.106.48.249:28000
20.106.48.249:30000
20.106.48.249:28501
20.106.48.249:28502
148.135.104.18:27020
72.83.103.37:27501
72.83.103.37:27502
72.83.103.37:27503
72.83.103.37:666
45.32.75.169:30000
45.32.75.169:28501
45.32.75.169:28502
45.32.75.169:28503
45.32.75.169:28504
69.247.38.137:27500
135.181.96.161:27500
52.67.74.216:27500
72.83.103.37:28000
149.28.62.121:30000
149.28.62.121:28501
149.28.62.121:28502
149.28.62.121:28504
23.22.56.152:28501
23.22.56.152:28502
23.22.56.152:28503
23.22.56.152:28504
150.136.70.158:27500
64.227.18.147:28502
64.227.18.147:28503
64.227.18.147:28504
24.87.1.123:26000
45.56.70.87:28501
45.56.70.87:28502
45.56.70.87:28503
45.56.70.87:28504
72.83.103.37:30000
138.197.111.29:28501
72.94.86.54:27500
52.89.197.170:26000
52.89.197.170:26001
206.51.245.84:27500
45.76.56.39:28000
45.76.56.39:30000
45.76.56.39:28001
45.76.56.39:28002
45.76.56.39:28003
45.76.56.39:28004
45.76.56.39:28005
70.34.202.147:30000
70.34.202.147:28501
70.34.202.147:28502
70.34.202.147:28503
70.34.202.147:28504
70.34.202.147:29501
20.245.6.70:28000
20.245.6.70:30000
35.185.44.174:27502
75.102.17.203:28501
75.102.17.203:28502
75.102.17.203:28503
75.102.17.203:28504
75.102.17.203:28000
75.102.17.203:30000
170.39.226.130:28501
98.144.80.46:27500
23.227.170.216:27502
23.227.170.216:27500
23.227.170.216:27501
23.227.170.216:27507
23.227.170.216:27505
23.227.170.216:27506
72.83.103.37:27505
50.116.17.172:28501
66.85.80.160:30000
149.28.240.2:28000
149.28.240.2:30000
45.76.23.209:28000
45.76.23.209:30000
159.203.25.195:28000
159.203.25.195:30000
207.148.5.167:28502
207.148.5.167:28501
207.148.5.167:28000
207.148.5.167:30000
149.28.240.2:28507
149.28.240.2:28505
149.28.240.2:28503
149.28.240.2:28501
149.28.240.2:28506
149.28.240.2:28502
149.28.240.2:28504
45.76.23.209:28507
45.76.23.209:28505
45.76.23.209:28503
45.76.23.209:28501
45.76.23.209:28506
45.76.23.209:28502
45.76.23.209:28504
159.65.230.186:27505
159.65.230.186:27502
159.65.230.186:27500
159.65.230.186:27504
159.65.230.186:28000
159.65.230.186:30000
159.65.230.186:27501
159.65.230.186:27503
159.203.25.195:28507
159.203.25.195:28505
159.203.25.195:28503
159.203.25.195:28501
159.203.25.195:28506
159.203.25.195:28502
159.203.25.195:28504
5.161.189.133:27600
138.68.21.116:30000
138.68.21.116:28000
138.68.21.116:28501
138.68.21.116:28502
20.51.107.74:28000
20.51.107.74:30000
20.51.107.74:28501
20.51.107.74:28502
20.69.57.161:28000
20.69.57.161:30000
20.69.57.161:28501
20.69.57.161:28502
35.185.44.174:27500
52.240.58.168:27503
52.240.58.168:27515
208.77.22.94:27501


================================================
FILE: misc/sb/qizmo.txt
================================================
95.216.202.86:27666
124.189.251.43:27666


================================================
FILE: misc/sb/sa-sv.txt
================================================
177.71.158.196:27500
177.71.158.196:27502
144.22.145.206:27504
144.22.145.206:27506
144.22.145.206:27502
144.22.145.206:27508
144.22.145.206:30000
144.22.145.206:27510
54.232.250.209:28000
54.232.250.209:30000
54.232.250.209:28501
54.232.250.209:28502
54.232.250.209:28503
54.232.250.209:28504
129.148.54.225:26000
129.148.54.225:27500
18.228.39.185:27501
18.228.39.185:27502
18.228.39.185:30000
18.228.39.185:27510
18.228.39.185:27503
54.94.165.196:28501
54.94.165.196:28502
54.94.165.196:30000
54.94.165.196:27700
54.94.165.196:27500
54.94.165.196:27600
191.223.251.197:27500
164.152.62.160:28000
164.152.62.160:30000
18.228.199.156:28500
18.228.199.156:28501
18.228.199.156:28502
18.228.199.156:28503
18.228.199.156:28504
170.239.85.110:28000
170.239.85.110:30000
170.239.85.110:28501
170.239.85.110:28502
170.239.85.110:28503
170.239.85.110:28504
170.239.85.110:28505
164.152.62.160:28501
164.152.62.160:28502
164.152.62.160:28503
164.152.62.160:28504
177.76.50.14:27501
177.76.50.14:27502
177.76.50.14:27503
177.76.50.14:27504
177.76.50.14:28000
177.76.50.14:27506
177.76.50.14:27505
144.22.145.206:27500


================================================
FILE: misc/sb/sources.txt
================================================
url "QuakeServers URL" http://www.quakeservers.net/lists/servers/global.txt
master "QuakeServers.net" master.quakeservers.net:27000
master "Asgaard" qwmaster.fodquake.net:27000
file "Global" global.txt
master "Poland" 217.153.59.106:27000
file "European Servers" eu-sv.txt
file "Europe 4on4" eu-4on4.txt
file "Australian Servers" au-sv.txt
file "Capture The Flag" ctf.txt
file "North America Servers" na-sv.txt
file "South America Servers" sa-sv.txt
file "Team Fortress" tf.txt
file "World Qizmos" qizmo.txt


================================================
FILE: misc/sb/tf.txt
================================================
177.71.158.196:27500
177.71.158.196:27502
144.22.145.206:27504
144.22.145.206:27506
144.22.145.206:27502
144.22.145.206:27508
144.22.145.206:27510
71.69.230.224:27500
23.227.170.222:26666
193.227.134.114:27500
193.227.134.114:27501
193.227.134.114:27502
193.227.134.114:27503
103.25.59.27:27501
103.25.59.27:27504
103.25.59.27:27505
103.25.59.27:27503
103.25.59.27:27502
54.177.92.188:27501
54.177.92.188:27510
54.177.92.188:27503
103.151.65.19:27500
34.244.130.97:27510
13.40.65.97:27510
16.50.174.37:27510
144.202.33.70:27510
3.108.227.32:27501
3.108.227.32:27500
3.108.227.32:27502
3.108.227.32:27510
3.108.227.32:27503
18.228.39.185:27501
18.228.39.185:27502
18.228.39.185:27510
18.228.39.185:27503
16.170.162.186:27501
16.170.162.186:27500
16.170.162.186:27502
16.170.162.186:27510
16.170.162.186:27503
3.25.174.195:27501
3.25.174.195:27500
3.25.174.195:27502
3.25.174.195:27510
3.25.174.195:27503
18.208.156.115:27501
18.208.156.115:27502
18.208.156.115:27510
18.208.156.115:27503
95.216.202.86:28504
95.216.202.86:28503
35.185.44.174:27502
23.227.170.216:27502
23.227.170.216:27500
23.227.170.216:27501
23.227.170.216:27507
23.227.170.216:27505
23.227.170.216:27506
144.22.145.206:27500
188.40.103.81:27600
35.185.44.174:27500


================================================
FILE: misc/sb/update_sources.bat
================================================
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/australia/au-sv.txt
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/ctf/ctf.txt
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/europe/eu-sv.txt
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/servers/global.txt
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/north_america/na-sv.txt
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/qizmo/qizmo.txt
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/south_america/sa-sv.txt
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/tf/tf.txt
wget -m -nd --no-if-modified-since https://www.quakeservers.net/lists/4on4_eu/eu-4on4.txt


================================================
FILE: src/Ctrl.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "utils.h"
#include "Ctrl.h"

cvar_t     menu_marked_bgcolor = {"menu_marked_bgcolor", "20 20 20 128", CVAR_COLOR};
cvar_t     menu_marked_fade = {"menu_marked_fade", "4"};

#define SLIDER_RANGE 12

void UI_DrawCharacter (int cx, int line, int num)
{
	Draw_Character ( cx, line, num);
}

void UI_Print (int cx, int cy, const char *str, int red)
{
	// We want to draw the charset red, if colored text is turned on
	// Draw_ColoredString will only draw white chars and color them.
	if (red)
	{
		while (*str) 
		{
			UI_DrawCharacter (cx, cy, (*str) | (red ? 128 : 0));
			str++;
			cx += 8;
		}
	}
	else
	{
		Draw_ColoredString (cx, cy, str, red, false);
	}
}

int UI_DrawSlider (int x, int y, float range) {
	int    i;

	range = bound(0, range, 1);
	UI_DrawCharacter (x-8, y, 128);
	for (i=0 ; i<SLIDER_RANGE ; i++)
		UI_DrawCharacter (x + i*8, y, 129);
	UI_DrawCharacter (x+i*8, y, 130);
	UI_DrawCharacter (x + (SLIDER_RANGE-1)*8 * range, y, 131);
	return x+(i+1)*8;
}

int UI_SliderWidth(void) { return (SLIDER_RANGE+1)*LETTERWIDTH; }

void UI_Print3 (int cx, int cy, const char *str, clrinfo_t *clr, int clr_cnt, int red)
{
	if (red)
	{
		while (*str) 
		{
			UI_DrawCharacter (cx, cy, (*str) | (red ? 128 : 0));
			str++;
			cx += 8;
		}
	}
	else
	{
		Draw_ColoredString3 (cx, cy, str, clr, clr_cnt, red);
	}
}

void UI_Print_Center (int cx, int cy, int w, const char *str, int red)
{
	// UH!!! wtf.... if I do:
	// UI_Print(cx + (w - 8 * strlen(str)) / 2, cy, str, red);
	// The call to UI_Print will get the first argument all fucked up (-217309285) instead of 192 in one instance.
	// making the line that should be drawn to dissapear?!?!? ...... If I moved the strlen(str) outside of the
	// function call like below it works fine.
	int text_length = strlen(str);
	UI_Print(cx + (w - 8 * text_length) / 2, cy, str, red);
}

void UI_Print_Center3 (int cx, int cy, int w, char *str, clrinfo_t *clr, int clr_cnt, int red)
{
	int text_length = strlen(str);
	UI_Print3(cx + (w - 8 * text_length) / 2, cy, str, clr, clr_cnt, red);
}

void UI_MakeLine(char *buf, int w)
{
	buf[0] = '\x1d';
	memset(buf+1, '\x1e', w-2);
	buf[w-1] = '\x1f';
	buf[w] = 0;
}

void UI_MakeLine2(char *buf, int w)
{
	buf[0] = '\x80';
	memset(buf+1, '\x81', w-2);
	buf[w-1] = '\x82';
	buf[w] = 0;
}

void UI_DrawColoredAlphaBox(int x, int y, int w, int h, color_t color)
{
	Draw_AlphaFillRGB(x, y, w, h, color);
}

void UI_DrawGrayBox(int x, int y, int w, int h)
{	// ridiculous function, eh?
	byte c[4];
	float fade = 1;

	memcpy(c, menu_marked_bgcolor.color, sizeof(byte) * 4);
	if (menu_marked_fade.value) 
	{
		fade = 0.5 * (1.0 + sin(menu_marked_fade.value * Sys_DoubleTime())); // this give us sinusoid from 0 to 1
		fade = 0.5 + (1.0 - 0.5) * fade ; // this give us sinusoid from 0.5 to 1, so no zero alpha
		fade = bound(0, fade, 1); // guarantee sanity if we mess somewhere
	}

	UI_DrawColoredAlphaBox(x, y, w, h, RGBA_TO_COLOR((fade * c[0]), (fade * c[1]), (fade * c[2]), c[3]));
}

void UI_DrawBox(int x, int y, int w, int h)
{
	Draw_TextBox(x, y, w / 8 - 1, h / 8 - 1);
}

qbool UI_PrintTextBlock(int x, int y, int w, int h, const char* text, qbool red)
{
	int letters_per_line = w / 8;	// Letters per line.
	int lines = h / 8;				// Lines in the text block.
	int linelen = 0;				// Current line length.
	int linecount = 0;				// Current line.
	char buf[1024];

	const char *start = text, *end, *wordend;

	while (*start && linecount < lines) 
	{
		wordend = start;
		end = wordend;
		linelen = 0;

		// Read the next line.
		while (linelen < letters_per_line && *wordend) 
		{
			end = wordend;

			// Read the next word.
			do 
			{
				wordend++;
				linelen++;
			}
			while (*wordend && *wordend != ' ' && *wordend != '\n');
			
			// Make sure we didn't find a word that was too long and
			// caused us to go outside of the line boundary.
			if(linelen >= letters_per_line)
			{
				// Try to find the last word boundary (whis
				do
				{
					wordend--;
					linelen--;
				}
				while(*wordend && *wordend != ' ' && linelen > 0);

				// Check if failed to find a word boundary. 
				// If that's the case just break the line at the max letters allowed for a line.
				// Otherwise break at the last word boundary.
				end = (linelen == 0) ? (end + letters_per_line - 1) : wordend;
				break;
			}

			// Check if it's time for a new line.
			if (*wordend == '\n') 
			{
				end = wordend; 
				break; 
			}
		}
		
		// End of string found.
		if (!*wordend && linelen < letters_per_line)
		{
			end = wordend;
		}

		// Break the line after the word, not after the next whitespace
		// so the next line won't start with that whitespace.
		while (*end && *end == ' ')
		{
			end++;
		}

		// Make sure we consume any newline character before printing.
		if(*start && *start == '\n')
		{
			start++;
		}

		strlcpy(buf, start, end - start + 1);
		UI_Print(x, y + (linecount * 8), buf, red);
		linecount++;
		start = end;
	}

	// If the text didn't fit in there, *start won't be zero.
	return !(*start);
}


================================================
FILE: src/Ctrl.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
//    $Id: Ctrl.h,v 1.14 2007-07-10 21:20:11 cokeman1982 Exp $

#ifndef __CTRL_H__
#define __CTRL_H__

#include "keys.h"

// this can be used to determine text block proportions
#define LETTERWIDTH 8
#define LETTERHEIGHT 8

//
// common GUI drawing methods
//
void UI_DrawCharacter (int cx, int line, int num);
void UI_Print (int cx, int cy, const char *str, int red);
int UI_DrawSlider (int x, int y, float range);
int UI_SliderWidth(void);
void UI_Print3 (int cx, int cy, const char *str, clrinfo_t *clr, int clr_cnt, int red);
void UI_Print_Center (int cx, int cy, int w, const char *str, int red);
void UI_Print_Center3 (int cx, int cy, int w, char *str, clrinfo_t *clr, int clr_cnt, int red);
void UI_DrawTextBox (int x, int y, int width, int lines);
void UI_MakeLine(char *buf, int w);
void UI_MakeLine2(char *buf, int w);
void UI_DrawColoredAlphaBox(int x, int y, int w, int h, color_t color);
void UI_DrawGrayBox(int x, int y, int w, int h);
void UI_DrawBox(int x, int y, int w, int h);

// prints the text into a box given by the area definitions (x,y, width, height)
// returned value determines, if the text did fit in the box
qbool UI_PrintTextBlock(int x, int y, int w, int h, const char* text, qbool red);

//
// <scrollbar>
// if this part gets too big, it might be moved to own header (Ctrl_*.h)
//

void ScrollBars_Init(void);

typedef void (*ScrollPos_setter) (double);

typedef struct ScrollBar_s {
    // current scrolling position in percentage 0-100%
    double curpos;                      

    // a function to which the scrollbar should report new scroll position
    ScrollPos_setter    scroll_fnc;     

    // should the scrollbar grab the mouse?
    // used to be able to scroll even if the mouse is a bit off
    qbool mouselocked;

    // scrollbar width and height
    int width, height;
} ScrollBar, *PScrollBar;

// scrollbar constructor
// 1st parameter: a function it should call, can be NULL
PScrollBar ScrollBar_Create(ScrollPos_setter, const char* name);

// scrollbar destructor
void ScrollBar_Delete(PScrollBar);

// mouse event handler
// returns true if scrollbar changed it's position
qbool ScrollBar_MouseEvent(PScrollBar, const mouse_state_t*);

// scrollbar draw - starting point (x,y) and scrollbar's height (width is given internally)
void ScrollBar_Draw(PScrollBar, int x, int y, int h);

//
// </scrollbar>
//


#endif // __CTRL_H__


================================================
FILE: src/Ctrl_EditBox.c
================================================
/*
Copyright (C) 2011 azazello

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "utils.h"
#include "Ctrl_EditBox.h"
#include "keys.h"


char buf[MAX_EDITTEXT+1];

void CEditBox_Init(CEditBox *e, int width, int max)
{
	e->width = width;
	e->max = max;
	e->pos = 0;
	e->disp = 0;
	e->text[0] = 0;
}

void CEditBox_Draw(CEditBox *e, int x, int y, qbool active)
{
	while (e->pos > e->disp + e->width - 1)
		e->disp ++;
	if (e->disp  >  e->pos)
		e->disp = e->pos;
	if (e->disp  >  strlen(e->text) - e->width + 1)
		e->disp = strlen(e->text) - e->width + 1;
//	if (e->disp  <  0)
//		e->disp = 0;

	snprintf(buf, sizeof (buf), "%-*.*s", e->width, e->width, active ? e->text+e->disp : e->text);
	Draw_String(x, y, buf);

	if (active)
		Draw_Character(x+8*(e->pos-e->disp), y, 10+((int)(cls.realtime*4)&1));
}

void CEditBox_Key(CEditBox *e, int key, wchar unichar)
{

	switch (key) {
			case K_LEFTARROW:
				if (e->pos != 0) {
					e->pos--;
				}
				break;
			case K_RIGHTARROW:
				e->pos++;
				break;
			case K_HOME:
				e->pos = 0;
				break;
			case K_END:
				e->pos = strlen(e->text);
				break;
			case K_DEL:
				if (e->pos < strlen(e->text))
					memmove(e->text + e->pos,
						e->text + e->pos + 1,
						strlen(e->text + e->pos + 1) + 1);
				break;
			case K_BACKSPACE:
				if (e->pos > 0) {
					memmove(e->text + e->pos - 1,
						e->text + e->pos,
						strlen(e->text + e->pos) + 1);
					e->pos --;
				}
			break;
			case 'v':
			case 'V':
				if (keydown[K_CTRL]) {
					int len;
					char *clip = ReadFromClipboard();
					len = min(strlen(clip), e->max - strlen(e->text));
	
					if (len > 0) {
						memmove(e->text + e->pos + len,
							e->text + e->pos,
							strlen(e->text + e->pos) + 1);
						memcpy(e->text + e->pos, clip, len);
						e->pos += len;
					}
				}
			break;
	}

	e->pos = max(e->pos, 0);
	e->pos = min(e->pos, strlen(e->text));

	if (!keydown[K_CTRL] &&
		key >= ' '  &&  key <= '}' &&
		strlen(e->text) < e->max)
	{
		memmove(e->text + e->pos + 1,
			e->text + e->pos,
			strlen(e->text + e->pos) + 1);

		e->text[e->pos] = unichar;

		e->pos++;
	}
}


================================================
FILE: src/Ctrl_EditBox.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
 * EditBox functions
 *
 *    $Id: Ctrl_EditBox.h,v 1.4 2006-05-13 07:31:57 disconn3ct Exp $
 */

#ifndef __CTRL_EDITBOX_H__
#define __CTRL_EDITBOX_H__

#define MAX_EDITTEXT 255

typedef struct CEditBox_s
{
	char text[MAX_EDITTEXT+1];
	unsigned int width;
	unsigned int max;
	unsigned int pos;
	unsigned int disp;
} CEditBox;

void CEditBox_Init(CEditBox *e, int width, int max);
void CEditBox_Draw(CEditBox *e, int x, int y, qbool active);
void CEditBox_Key(CEditBox *e, int key, wchar unichar);

#endif // __CTRL_EDITBOX_H__


================================================
FILE: src/Ctrl_PageViewer.c
================================================
/*
Copyright (C) 2011 azazello

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "Ctrl.h"
#include <expat.h>
#include "xsd.h"
#include "document_rendering.h"
#include "Ctrl_PageViewer.h"
#include "keys.h"


static void LeaveNavigationMode(CPageViewer_t *viewer)
{
    if (viewer->navigation_mode)
    {
        Q_free(viewer->current_links);
        viewer->current_link_index = 0;
        viewer->current_links_total = 0;
        viewer->navigation_mode = false;
    }
}

static void EnterNavigationMode(CPageViewer_t *viewer)
{
    int i;
    document_rendered_link_t *from, *to;
    int screen_start, screen_end;

    if (viewer->navigation_mode)
        LeaveNavigationMode(viewer);

    screen_start = viewer->page->current_line * viewer->page->width;
    screen_end = (viewer->page->current_line + viewer->page->last_height) * viewer->page->width;

    from = viewer->page->rendered.links;
    while (from)
    {
        if (from->start >= screen_start  ||  from->end >= screen_start)
            break;
        from = from->next;
    }

    if (from == NULL)
        return; // no navigation

    viewer->current_links_total = 0;
    to = from;
    while (to)
    {
        if (to->start >= screen_end)
            break;

        viewer->current_links_total++;
        to = to->next;
    }

    if (viewer->current_links_total == 0)
        return;

    // make links table
    viewer->current_links = (document_rendered_link_t **)
        Q_malloc(viewer->current_links_total*sizeof(document_rendered_link_t *));
    i = 0;
    while (from != to)
    {
        viewer->current_links[i++] = from;
        from = from->next;
    }
    viewer->navigation_mode = true;
    if (keydown[K_SHIFT])
        viewer->current_link_index = viewer->current_links_total - 1;
    else
        viewer->current_link_index = 0;
}

static void MakeString(char *buf, byte *mem, int len)
{
    int i;
    for (i=0; i < len; i++)
        buf[i] = mem[i] == 0 ? ' ' : mem[i];
    buf[len] = 0;
}

static void FreePageRendered(CPageViewer_page_t *page)
{
    XSD_RenderClear(&page->rendered);
}

static void FreePage(CPageViewer_page_t *page)
{
    FreePageRendered(page);
    if (page->url)
        Q_free(page->url);
    if (page->doc)
        XSD_FreeDocument((xml_t *)page->doc);
    Q_free(page);
    return;
}

static void RenderDocument(CPageViewer_t *viewer, int width)
{
    // int lines;
    xml_document_t *doc;

    LeaveNavigationMode(viewer);
    FreePageRendered(viewer->page);

    viewer->page->current_line = 0;
    viewer->page->width = width;
    viewer->page->should_render = false;

    // load document
    if (!viewer->page->doc)
        viewer->page->doc = XSD_LoadDocumentWithXsl(viewer->page->url);

    if (!viewer->page->doc)
        goto error;

    doc = viewer->page->doc;

    if (!XSD_RenderDocument(&viewer->page->rendered, doc, width))
        goto error;

    return;

error:

    viewer->page->rendered.title = (char *) Q_malloc(viewer->page->width);
    memset(viewer->page->rendered.title, 0, width);
    memcpy(viewer->page->rendered.title, "Document loading error!", strlen("Document loading error!"));
    viewer->page->rendered.title_lines = 1;
    return;
}

static void AddPage(CPageViewer_t *viewer)
{
    CPageViewer_page_t *page = (CPageViewer_page_t *) Q_malloc(sizeof(CPageViewer_page_t));
    memset(page, 0, sizeof(CPageViewer_page_t));

    page->next = viewer->page;
    viewer->page = page;
}

void CPageViewer_Init(CPageViewer_t *viewer)
{
    memset(viewer, 0, sizeof(CPageViewer_t));

    viewer->show_status = true;
    viewer->show_title = true;
}

CPageViewer_t * CPageViewer_New(void)
{
    CPageViewer_t *viewer = (CPageViewer_t *) Q_malloc(sizeof(CPageViewer_t));

    CPageViewer_Init(viewer);
    return viewer;
}

// load document by url
void CPageViewer_GoUrl(CPageViewer_t *viewer, char *url)
{
    AddPage(viewer);

    viewer->page->url = Q_strdup(url);
    viewer->page->should_render = true;
}

// load document by xml_document_t
void CPageViewer_Go(CPageViewer_t *viewer, char *url, xml_document_t *doc)
{
    AddPage(viewer);

    viewer->page->url = Q_strdup(url);
    viewer->page->doc = doc;
    viewer->page->should_render = true;
}

void CPageViewer_Draw(CPageViewer_t *viewer, int x, int y, int w, int h)
{
    int i;
    document_rendered_link_t *link;
    int line;
    char buf[512];
    int sx, sy, sh;

    // change x, y, w, h
    x = x + (w - 8*(w/8)) /2;
    w = w/8;
    y = y + (h - 8*(h/8)) /2;
    h = h/8;

    if (w < 20  ||  h < 10)
        return;

    if (viewer->page == NULL)
        return;

    sx = x;
    sy = y;
    sh = h;

    if (viewer->page->width != w)
        viewer->page->should_render = true;

    if (viewer->page->should_render)
        RenderDocument(viewer, w);

    // current link, if in navigation mode
    link = viewer->navigation_mode ? viewer->current_links[viewer->current_link_index] : NULL;

    // draw title bar
    /*
    if (viewer->page->rendered.title  &&  viewer->show_title)
    {
        for (line = 0; line < viewer->page->rendered.title_lines; line++)
        {
            MakeString(buf, viewer->page->rendered.title + line*viewer->page->width, viewer->page->width);
            UI_Print(x, y + line*8, buf, false);
        }

        UI_MakeLine(buf, viewer->page->width/2);
        UI_Print_Center(x, y + line*8, viewer->page->width*8, buf, false);

        sh -= line + 1;
        sy += (line + 1) * 8;
    }
    */

    // calculate scrollable area yet
    if (viewer->show_status)
        sh -= 2;
    if (viewer->page->rendered.text_lines - viewer->page->current_line < sh)
        viewer->page->current_line -= sh - (viewer->page->rendered.text_lines - viewer->page->current_line);
    if (viewer->page->current_line < 0)
        viewer->page->current_line = 0;

    // draw status bar
    if (viewer->show_status)
    {
        if (viewer->navigation_mode)
        {
            if (strlen (link->tag->href) > w)
            {
                strlcpy (buf, link->tag->href, min (sizeof (buf), w-3));
                strlcat (buf, "...", sizeof (buf));
            }
            else
            {
                int offset = (w - strlen(link->tag->href)) / 2;
                memset(buf, ' ', offset);
                strlcpy (buf + offset, link->tag->href, sizeof (buf) - offset);
            }
            UI_Print(x, y + (h-1)*8, buf, false);
        }
        else
        {
            snprintf(buf, sizeof (buf), "%d lines  ", viewer->page->rendered.text_lines);
            if (sh >= viewer->page->rendered.text_lines)
                strlcat(buf, "[full]", sizeof (buf));
            else if (viewer->page->current_line == 0)
                strlcat(buf, "[top]", sizeof (buf));
            else if (viewer->page->current_line + sh == viewer->page->rendered.text_lines)
                strlcat(buf, "[bottom]", sizeof (buf));
            else
            {
                int percent = (100*(viewer->page->current_line + sh)) / viewer->page->rendered.text_lines;
                strlcat(buf, va("[%d%%]", percent), sizeof (buf));
            }

            UI_Print(x+8*(w-strlen(buf)-1), y + (h-1)*8, buf, false);

            if (viewer->page->doc  &&  viewer->page->doc->title)
            {
                int l = w - strlen(buf) - 3;
                if (strlen(viewer->page->doc->title) <= l)
                {
                    UI_Print(x+8, y + (h-1)*8, viewer->page->doc->title, false);
                }
                else
                {
                    strlcpy(buf, viewer->page->doc->title, min (sizeof (buf), l-3));
                    strlcat(buf, "...", sizeof (buf));
                    UI_Print(x+8, y + (h-1)*8, buf, false);
                }
            }
        }
        UI_MakeLine(buf, w);
        UI_Print_Center(x, y + (h-2)*8, w*8, buf, false);
    }

    // process with scrollable area
    for (line = 0;  line < min(sh, viewer->page->rendered.text_lines - viewer->page->current_line); line++)
    {
        int start, end;
	MakeString(buf, (byte *) viewer->page->rendered.text + (line+viewer->page->current_line)*viewer->page->width, viewer->page->width);

        if (link)
        {
            start = max(link->start, (viewer->page->current_line + line) * viewer->page->width);
            end = min(link->end, (viewer->page->current_line + line + 1) * viewer->page->width);
            if (end > start)
            {
                start -= (viewer->page->current_line + line) * viewer->page->width;
                end -= (viewer->page->current_line + line) * viewer->page->width;
                for (i=start; i < end; i++)
                    buf[i] ^= 128;
            }
        }

        UI_Print(sx, sy + line*8, buf, false);
    }
    viewer->page->last_height = sh;
}

qbool CPageViewer_Key(CPageViewer_t *viewer, int key, wchar unichar)
{
    qbool ret = false;

    if (viewer->page == NULL)
        return 0;

    if (viewer->navigation_mode)
    {
        char *href;
        switch (key)
        {
        case K_TAB:
            viewer->current_link_index += keydown[K_SHIFT] ? -1 : 1;
            viewer->current_link_index = (viewer->current_link_index +
                viewer->current_links_total) % viewer->current_links_total;
            ret = true;
            break;
        case K_ENTER:
            href = viewer->current_links[viewer->current_link_index]->tag->href;            if (href)
            {
                LeaveNavigationMode(viewer);
                CPageViewer_GoUrl(viewer, href);
            }            ret = true;
            break;
        case K_SHIFT:
            break;
        default:
            LeaveNavigationMode(viewer);
            ret = true;
            break;
        }
    }

    if (!viewer->navigation_mode)
    {
        switch (key)
        {
        case K_UPARROW:
		case K_MWHEELUP:
            viewer->page->current_line--;
            ret = true;
            break;
        case K_DOWNARROW:
		case K_MWHEELDOWN:
            viewer->page->current_line++;
            ret = true;
            break;
        case K_PGUP:
            viewer->page->current_line -= viewer->page->last_height-1;
            ret = true;
            break;
        case K_PGDN:
            viewer->page->current_line += viewer->page->last_height-1;
            ret = true;
            break;
        case K_HOME:
            viewer->page->current_line = 0;
            ret = true;
            break;
        case K_END:
            viewer->page->current_line = viewer->page->rendered.text_lines;
            ret = true;
            break;
        case K_BACKSPACE:
            CPageViewer_Back(viewer, 1);
            ret = true;
            break;
        case K_TAB:
            EnterNavigationMode(viewer);
            ret = true;
            break;
        }
    }
    return ret;
}

// go back
void CPageViewer_Back(CPageViewer_t *viewer, int level)
{
    if (viewer->page == NULL)
        return;

    while (viewer->page->next && level--)
    {
        CPageViewer_page_t *page = viewer->page->next;

        FreePage(viewer->page);
        viewer->page = page;
    }
}

void CPageViewer_Clear(CPageViewer_t *viewer)
{
    CPageViewer_page_t *next;

    LeaveNavigationMode(viewer);

    // free all pages
    while (viewer->page)
    {
        next = viewer->page->next;

        FreePage(viewer->page);
        viewer->page = next;
    }

    // clear
    CPageViewer_Init(viewer);
}

void CPageViewer_Free(CPageViewer_t *viewer)
{
    // clear all data
    CPageViewer_Clear(viewer);
}


================================================
FILE: src/Ctrl_PageViewer.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
 * EditBox functions
 *
 */

#ifndef __CTRL_PAGEVIEWER_H__
#define __CTRL_PAGEVIEWER_H__



typedef struct CPageViewer_page_s
{
    char *url;
    xml_document_t *doc;

    document_rendered_t rendered;

    int current_line;
    int width;
    qbool should_render;

    // current settings
    int last_height;

    // previous page in history
    struct CPageViewer_page_s *next;
}
CPageViewer_page_t;

typedef struct CPageViewer_s
{
    CPageViewer_page_t *page;

    // options
    qbool show_title;
    qbool show_status;

    // navigation mode
    qbool navigation_mode;
    document_rendered_link_t **current_links;
    int current_link_index;
    int current_links_total;
}
CPageViewer_t;

// initialize CPageViewer control
void CPageViewer_Init(CPageViewer_t *);

// create new viewer
CPageViewer_t * CPageViewer_New(void);

// load document by url
void CPageViewer_GoUrl(CPageViewer_t *viewer, char *url);

// load document by xml_document_t
void CPageViewer_Go(CPageViewer_t *viewer, char *url, xml_document_t *doc);

// go back
void CPageViewer_Back(CPageViewer_t *viewer, int level);

// draw control
void CPageViewer_Draw(CPageViewer_t *viewer, int x, int y, int w, int h);

// handle keyboard
qbool CPageViewer_Key(CPageViewer_t *viewer, int key, wchar unichar);

// clear control
void CPageViewer_Clear(CPageViewer_t *viewer);

// delete control
void CPageViewer_Free(CPageViewer_t *viewer);

#endif // __CTRL_PAGEVIEWER_H__


================================================
FILE: src/Ctrl_ScrollBar.c
================================================
/*
Copyright (C) 2011 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
    GUI Control: ScrollBar

    Include and read Ctrl.h to use scrollbars

    made by:
        johnnycz, Mar 2007
    last edit:
        $Id: Ctrl_ScrollBar.c,v 1.7 2007-07-19 19:12:00 cokeman1982 Exp $

*/

#include "quakedef.h"
#include "keys.h"
#include "Ctrl.h"

#define SCRBARSCALE 0.33

// PNG scrollbar images
static mpic_t *scrbar_up, *scrbar_down, *scrbar_bg, *scrbar_slider;
int scrollbar_width;
int slider_height;

void ScrollBars_Init(void)
{
	scrbar_bg = Draw_CachePicSafe("textures/scrollbars/slidebg", false, true);
	scrbar_up = Draw_CachePicSafe("textures/scrollbars/arrow_up", false, true);
	scrbar_down = Draw_CachePicSafe("textures/scrollbars/arrow_down", false, true);
    scrbar_slider = Draw_CachePicSafe("textures/scrollbars/slider", false, true);
    if (scrbar_slider) 
	{
        scrollbar_width = scrbar_slider->width * SCRBARSCALE;
        slider_height = scrbar_slider->height * SCRBARSCALE;
    } 
	else
    {
        scrollbar_width = 8;
        slider_height = 8;
    }
}

PScrollBar ScrollBar_Create(ScrollPos_setter pos_setter, const char* name)
{
    PScrollBar scb_new = Q_malloc_named(sizeof(ScrollBar), name);

    if (!scb_new) {
        return NULL;
    }

    scb_new->curpos = 0;
    scb_new->mouselocked = false;
    scb_new->scroll_fnc = pos_setter;
    scb_new->width = scrollbar_width;
    return scb_new;
}

// scrollbar destructor
void ScrollBar_Delete(PScrollBar scrbar)
{
    Q_free (scrbar);
}

// mouse event handler
qbool ScrollBar_MouseEvent(PScrollBar scrbar, const mouse_state_t *ms)
{
    // check if there is some reason to react on this event
    if (!ms->button_down && !ms->button_up && !ms->buttons[1])
        return false;   

    if (ms->button_up)
    {
        scrbar->mouselocked = false;
    }
    else // button_down or mousemove
    {
        double y = ms->y - scrollbar_width - slider_height/2;
        double ah = scrbar->height - scrollbar_width*2 - slider_height; 

        scrbar->mouselocked = true;
        y = bound(0, y, ah);
        scrbar->curpos = y / ah;
        scrbar->curpos = bound(0, scrbar->curpos, 1);
    }

    if (scrbar->scroll_fnc)
        scrbar->scroll_fnc(scrbar->curpos);

    return true;
}

static void SCRB_DrawPics(PScrollBar scrbar, int x, int y, int h)
{
    int w = scrollbar_width;

    // Height of one background image.
    int sh = max(1, (scrbar_bg->height) * SCRBARSCALE);
   
	// How many complete background images fit in here
    int compl_bgs = h / sh;    

    // Height of the part of the last background image.
    int rest_bgh = (h - compl_bgs * sh) / SCRBARSCALE;
    int i;
    
    for (i = 0; i < compl_bgs; i++)
        Draw_SPic(x, y + i * sh, scrbar_bg, SCRBARSCALE);

    // Add the last part to fill the whole background.
    Draw_SSubPic(x, y + i * sh, scrbar_bg, 0, 0, scrbar_bg->width, rest_bgh, SCRBARSCALE);
    
    // Draw the remaining parts of the scrollbar.
    Draw_SPic(x, y, scrbar_up, SCRBARSCALE);
    Draw_SPic(x, y + h - w, scrbar_down, SCRBARSCALE);
    Draw_SPic(x, y + w + (h - 2 * w - slider_height) * scrbar->curpos, scrbar_slider, SCRBARSCALE);
}


static void SCRB_DrawNoPics(PScrollBar scrbar, int x, int y, int h)
{
	#define SCROLLBAR_QCOLOR		4
	#define SCROLLBAR_BUTTON_QCOLOR	72
	#define SCROLLBAR_SLIDER_QCOLOR	40
    int w = scrollbar_width;

    Draw_Fill(x, y, w, h, SCROLLBAR_QCOLOR);
    Draw_Fill(x, y, w, w, SCROLLBAR_BUTTON_QCOLOR);
    Draw_Fill(x, y + h - w, w, w, SCROLLBAR_BUTTON_QCOLOR);
    Draw_Fill(x, y + w + (h - 3 * w) * scrbar->curpos, w, w, SCROLLBAR_SLIDER_QCOLOR);
}

void ScrollBar_Draw(PScrollBar scrbar, int x, int y, int h)
{
    scrbar->height = h;

	if (scrbar_up && scrbar_bg && scrbar_down && scrbar_slider)
		SCRB_DrawPics(scrbar, x, y, h);
	else
		SCRB_DrawNoPics(scrbar, x, y, h);
}


================================================
FILE: src/Ctrl_Tab.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "Ctrl.h"
#include "Ctrl_Tab.h"
#include "keys.h"
#include "qsound.h"

// initialize control
void CTab_Init(CTab_t *tab)
{
	memset(tab, 0, sizeof(CTab_t));
	tab->lastViewedPage = -1;
	tab->hoveredPage = -1;
}


// clear control
void CTab_Clear(CTab_t *tab)
{
	// no dynamic data, just clear it
	CTab_Init(tab);
}


// create new control
CTab_t * CTab_New(void)
{
	CTab_t *tab = (CTab_t *) Q_malloc(sizeof(CTab_t));
	CTab_Init(tab);
	return tab;
}


// free control
void CTab_Free(CTab_t *tab)
{
	CTab_Clear(tab);
	Q_free(tab);
}


// add tab
void CTab_AddPage(CTab_t *tab, const char *name, int id, const CTabPage_Handlers_t *handlers)
{
	int i;
	CTabPage_t *page;

	if (tab->nPages >= TAB_MAX_TABS)
	{
		Sys_Error("CTab_AddPage: Maximum page number reached "
				"while adding %s", name);
		return;
	}

	for (i=0; i < tab->nPages; i++)
	{
		if (tab->pages[i].id == id)
			Sys_Error("CTab_AddPage: such id already exist");
		if (!strcmp(tab->pages[i].name, name))
			Sys_Error("CTab_AddPage: such name already exist");
	}

	page = &tab->pages[tab->nPages++];

	// set name
	strlcpy (page->name, name, sizeof (page->name));

	// set id
	page->id = id;

	// set handlers
	memcpy(&page->handlers, handlers, sizeof(CTabPage_Handlers_t));
}

// will draw tab navigation bar, remember labels positions
// and will return the width of the navigation bar
static int CTab_Draw_PageLinks(CTab_t *tab, int x, int y, int w, int h)
{
	char buf[TAB_MAX_NAME_LENGTH+3];
	int i, cx, cy, ww, wh;          // current x/y, word width/height
	qbool ap, hp;                   // active page / hovered page

	cx = 0; cy = 0;
	for (i = 0; i < tab->nPages; i++)
	{
		*buf = 0;
		ap = tab->activePage == i;
		hp = tab->hoveredPage == i;

		// add leading space/brace
		strlcat (buf, ap ? "\x10" : " ", sizeof (buf));

		// adds white or red variant of the page name to the buf string
		strlcat (buf, tab->pages[i].name, sizeof (buf));

		// add closing space/brace
		strlcat (buf, ap ? "\x11" : " ", sizeof (buf));

		ww = strlen(buf) * LETTERWIDTH;
		wh = LETTERHEIGHT;

		// this is not the first word we are printing and we don't fit on the line anymore
		if (cx && (cx + ww > w)) {
			// so wrap the line already
			cx = 0;
			cy += LETTERHEIGHT;
		}

		UI_Print(x + cx, y + cy, buf, ap || hp);

		// remember where the text was so we can point to it with the mouse later
		tab->navi_boxes[i].x = cx;
		tab->navi_boxes[i].y = cy;
		tab->navi_boxes[i].x2 = cx+ww-LETTERWIDTH;
		tab->navi_boxes[i].y2 = cy+wh;

		// we substract 1 letter here and above because we want only one (common) space
		// between the labels, not two (one for each)
		cx += ww - LETTERWIDTH;
	}

	return cy + LETTERHEIGHT;
}

// draw control
void CTab_Draw(CTab_t *tab, int x, int y, int w, int h)
{
	char line[1024];
	int nav_height;

	if (tab->activePage != tab->lastViewedPage && tab->activePage < tab->nPages)
	{
		CTabPage_OnShowType onshowFnc = tab->pages[tab->activePage].handlers.onshow;
		if (onshowFnc != NULL) onshowFnc();
		tab->lastViewedPage = tab->activePage;
	}

	tab->width = w;
	tab->height = h;

	nav_height = CTab_Draw_PageLinks(tab, x, y, w, h);

	// draw separator
	memset(line, '\x1E', w/8);
	line[w/8] = 0;
	line[w/8-1] = '\x1F';
	line[0] = '\x1D';
	// memcpy(line + 2, " \x10shift\x11+\x10tab\x11 ", min((w/8)-3, 15));
	// memcpy(line + w/8 - 2 - 7, " \x10tab\x11 ", 7);
	UI_Print_Center(x, y + nav_height, w, line, false);
	nav_height += 8;

	// draw page
	if (tab->pages[tab->activePage].handlers.draw != NULL)
		tab->pages[tab->activePage].handlers.draw(x, y + nav_height, w, h- nav_height, tab, &tab->pages[tab->activePage]);
}


// process key
int CTab_Key(CTab_t *tab, int key, wchar unichar)
{
	int handled;

	if (tab->hoveredPage >= 0 && key == K_MOUSE1)
	{
		tab->activePage = tab->hoveredPage;
		return true;
	}

	// we first call tabs handlers, because they might override
	// default tab keys for modal dialogs
	// tabs are responsible for not using "our" keys for other
	// purposes
	handled = false;
	if (tab->pages[tab->activePage].handlers.key != NULL)
		handled = tab->pages[tab->activePage].handlers.key(key, unichar, tab, &tab->pages[tab->activePage]);

	// then try our handlers
	if (!handled)
	{
		switch (key)
		{
			case K_PGUP:
			case K_MOUSE4:
				S_LocalSound ("misc/menu1.wav");
				tab->activePage--;
				handled = true;
				break;

			case K_PGDN:
			case K_MOUSE5:
				S_LocalSound ("misc/menu1.wav");
				tab->activePage++;
				handled = true;
				break;

			case K_LEFTARROW:
				S_LocalSound ("misc/menu1.wav");
				tab->activePage--;
				handled = true;
				break;

			case K_RIGHTARROW:
				S_LocalSound ("misc/menu1.wav");
				tab->activePage++;
				handled = true;
				break;

			case K_TAB:
				S_LocalSound ("misc/menu1.wav");
				if (keydown[K_SHIFT]) tab->activePage--; else tab->activePage++;
				handled = true;
				break;
		}

		if (handled)
			tab->activePage = (tab->activePage + tab->nPages) % tab->nPages;
	}

	// return handled status
	return handled;
}

static qbool CTab_Navi_Mouse_Event (CTab_t *tab, const mouse_state_t *ms) 
{
	int i;
	if (!tab->width) return false;

	if (ms->button_up == 1) {
		CTab_Key(tab, K_MOUSE1, 0);
		return true;
	} else if (ms->button_up == 2) {
		CTab_Key(tab, K_MOUSE2, 0);
		return true;
	}

	for (i = 0; i < tab->nPages; i++)
	{
		if (!(tab->navi_boxes[i].x > ms->x || tab->navi_boxes[i].y > ms->y || tab->navi_boxes[i].x2 < ms->x || tab->navi_boxes[i].y2 < ms->y))
		{   // pointer is within the bounds
			tab->hoveredPage = i;
			return true;
		}
	}
	return false;
}

qbool CTab_Mouse_Event(CTab_t *tab, const mouse_state_t *ms)
{
	int nav_height = tab->navi_boxes[tab->nPages-1].y2;

	if (ms->x < 0 || ms->x > tab->width || ms->y < 0 || ms->y > tab->height)
		return false;

	if (ms->y <= nav_height)
	{   // pointer is in the navigation area
		return CTab_Navi_Mouse_Event(tab, ms);
	}
	else if (ms->y >= nav_height + LETTERHEIGHT) 
	{   // pointer is in the main area
		CTabPage_MouseMoveType mmf;
		mouse_state_t lms = *ms;

		lms.y -= nav_height + LETTERHEIGHT;
		tab->hoveredPage = -1;

		mmf = tab->pages[tab->activePage].handlers.mousemove;
		if (mmf)
			return mmf(&lms);
	}

	return false;
}

// get current page
CTabPage_t * CTab_GetCurrent(CTab_t *tab)
{
	return &tab->pages[tab->activePage];
}


// get current page id
int CTab_GetCurrentId(CTab_t *tab)
{
	return tab->pages[tab->activePage].id;
}


// get current page name
char * CTab_GetCurrentPage(CTab_t *tab)
{
	return tab->pages[tab->activePage].name;
}


// set current page by ID
void CTab_SetCurrentId(CTab_t *tab, int id)
{
	int i;
	for (i=0; i < tab->nPages; i++)
	{
		if (tab->pages[i].id == id)
		{
			tab->activePage = i;
			return;
		}
	}
	Sys_Error("CTab_SetCurrentId: id not found");
}


// set current page by string
void SetCurrentPage(CTab_t *tab, char *name)
{
	int i;
	for (i=0; i < tab->nPages; i++)
	{
		if (!strcmp(tab->pages[i].name, name))
		{
			tab->activePage = i;
			return;
		}
	}
	Sys_Error("CTab_SetCurrentName: name not found");
}



================================================
FILE: src/Ctrl_Tab.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
// Tab Control

#ifndef __CTRL_TAB_H__
#define __CTRL_TAB_H__

#include "keys.h"

#define TAB_MAX_NAME_LENGTH     15
#define TAB_MAX_TABS            16


struct CTab_s;
struct CTabPage_s;

typedef void (*CTabPage_OnShowType) (void);
typedef void (*CTabPage_DrawType)(int x, int y, int w, int h, struct CTab_s *, struct CTabPage_s *);
typedef int  (*CTabPage_KeyType)(int key, wchar unichar, struct CTab_s *, struct CTabPage_s *);
typedef qbool (*CTabPage_MouseMoveType) (const mouse_state_t * ms);

typedef struct CTabPage_Handlers_s
{
    CTabPage_DrawType   draw;
    CTabPage_KeyType    key;
    CTabPage_OnShowType onshow;
	CTabPage_MouseMoveType mousemove;
}
CTabPage_Handlers_t;

typedef struct CTabPage_s
{
    char    name[TAB_MAX_NAME_LENGTH+1];
    int     id;
	CTabPage_Handlers_t handlers;
}
CTabPage_t;

typedef struct CTab_s
{
    CTabPage_t  pages[TAB_MAX_TABS];
    int         nPages;
    int         activePage;
	int			lastViewedPage;
	int			hoveredPage;
	int			width;
	int			height;
    struct { int x, y, x2, y2; } navi_boxes[TAB_MAX_TABS];
    void *tag;
}
CTab_t;


// initialize control
void CTab_Init(CTab_t *);

// clear control
void CTab_Clear(CTab_t *);

// create new control
CTab_t * CTab_New(void);

// free control
void CTab_Free(CTab_t *);

// add tab
void CTab_AddPage(CTab_t *, const char *name, int id, const CTabPage_Handlers_t *handlers);
// draw control
void CTab_Draw(CTab_t *, int x, int y, int w, int h);

// process key
int CTab_Key(CTab_t *, int key, wchar unichar);

// process mouse move event
qbool CTab_Mouse_Event(CTab_t *, const mouse_state_t *ms);

// get current page
CTabPage_t * CTab_GetCurrent(CTab_t *);

// get current page id
int CTab_GetCurrentId(CTab_t *);

// get current page name
char * CTab_GetCurrentPage(CTab_t *);

// set current page by ID
void CTab_SetCurrentId(CTab_t *, int);

// set current page by string
void CTab_SetCurrentPage(CTab_t *, char *);



#endif // __CTRL_TAB_H__


================================================
FILE: src/EX_FileList.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
 * File List
 *
 * display directory contents, allows for changing dir,
 * drive etc..
 *
 * meant for use by MP3 player, mayby demo player too
 *
 * FileList have four colums:
 *  - file name (with ext)
 *  - size
 *  - date (last modification)
 *  - time (last modification)
 *
 * and allows to display different sets of columns
 * also do sorting
 *
 */

#include "quakedef.h"
#include "localtime.h"
#include "Ctrl.h"
#include "EX_FileList.h"
#include "utils.h"
#include "keys.h"
#include "hash.h"
#include "fs.h"
#include "vfs.h"


// column width
#define COL_SIZE        4
#define COL_DATE        8
#define COL_TIME        5

#define FL_SEARCH_TIMEOUT	2.0
static double last_search_enter_time = 0.0;


static void OnChange_file_browser_sort_mode(cvar_t *var, char *string, qbool *cancel);

static cvar_t  file_browser_show_size       = {"file_browser_show_size",      "1"};
static cvar_t  file_browser_show_date       = {"file_browser_show_date",      "1"};
static cvar_t  file_browser_show_time       = {"file_browser_show_time",      "0"};
static cvar_t  file_browser_sort_mode       = {"file_browser_sort_mode",      "1",	CVAR_NONE, OnChange_file_browser_sort_mode};
static cvar_t  file_browser_show_status     = {"file_browser_show_status",    "1"};
static cvar_t  file_browser_strip_names     = {"file_browser_strip_names",    "1"};
static cvar_t  file_browser_interline       = {"file_browser_interline",      "0"};
static cvar_t  file_browser_scrollnames     = {"file_browser_scrollnames" ,   "1"};
static cvar_t  file_browser_selected_color  = {"file_browser_selected_color", "0 150 235 255", CVAR_COLOR};
static cvar_t  file_browser_file_color      = {"file_browser_file_color",     "255 255 255 255", CVAR_COLOR};
static cvar_t  file_browser_dir_color       = {"file_browser_dir_color",      "170 80 0 255", CVAR_COLOR};
static cvar_t  file_browser_archive_color   = {"file_browser_archive_color",  "255 170 0 255", CVAR_COLOR};
static cvar_t  file_browser_sort_archives   = {"file_browser_sort_archives",  "0",	CVAR_NONE, OnChange_file_browser_sort_mode };

void EX_FileList_Init(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_MENU);
	Cvar_Register(&file_browser_show_size);
	Cvar_Register(&file_browser_show_date);
	Cvar_Register(&file_browser_show_time);
	Cvar_Register(&file_browser_sort_mode);
	Cvar_Register(&file_browser_show_status);
	Cvar_Register(&file_browser_strip_names);
	Cvar_Register(&file_browser_interline);
	Cvar_Register(&file_browser_scrollnames);
	Cvar_Register(&file_browser_file_color);
	Cvar_Register(&file_browser_selected_color);
	Cvar_Register(&file_browser_dir_color);
	Cvar_Register(&file_browser_archive_color);
	Cvar_Register(&file_browser_sort_archives);
	Cvar_ResetCurrentGroup();
}

//
// Create list
//
void FL_Init(filelist_t	*fl, char *initdir)
{
	Sys_getcwd(fl->current_dir, MAX_PATH);
	FL_SetCurrentDir(fl, initdir);
	fl->error = false;
	fl->need_refresh = true;
	fl->num_entries = 0;
	fl->current_entry = 0;
	fl->num_filetypes = 0;

	fl->search_string[0] = 0;
	fl->last_page_size = 0;

	fl->search_valid = false;
	fl->cdup_find = false;

	fl->show_dirup = true;
	fl->show_dirs = true;

	fl->scrollbar = ScrollBar_Create(NULL, fl->current_dir);

#ifdef WITH_ZIP
	fl->current_archive[0] = 0;
	fl->in_archive = false;
#endif // WITH_ZIP
}

void FL_Shutdown(filelist_t* fl)
{
	Q_free(fl->scrollbar);
}

//
// Set directory
//
void FL_SetCurrentDir(filelist_t *fl, const char *dir)
{
	char buf[MAX_PATH+1];

	if (Sys_fullpath(buf, dir, sizeof(buf)) == NULL) {
		return;
	}

	if (strlen(buf) > MAX_PATH) {
		// Should never fail in this
		return;
	}

	// Try changing directory, block if this fails
	{
		char olddir[MAX_PATH + 1];

		// Save the current directory. (we want to restore this later)
		if (Sys_getcwd(olddir, MAX_PATH + 1) == NULL) {
			return;
		}

		// Change to the new dir.
		if (!Sys_chdir(buf)) {
			return;
		}

		// restore
		Sys_chdir(olddir);
	}

	strlcpy(fl->current_dir, buf, sizeof(fl->current_dir));
	fl->need_refresh = true;
}

//
// Get current directory
//
char *FL_GetCurrentDir(filelist_t *fl)
{
	return fl->current_dir;
}

//
// add new file type (.qwd, .qwz, .mp3)
//
void FL_AddFileType(filelist_t *fl, int id, char *ext)
{
	int num = fl->num_filetypes;

	if (num >= MAX_FILELIST_TYPES)
		return;

	if (strlen(ext) > MAX_EXTENSION_LENGTH)
		return;

	strlcpy (fl->filetypes[num].extension, ext, sizeof (fl->filetypes[num].extension));
	fl->filetypes[num].id = id;

	fl->num_filetypes ++;
}

//
// hides the ".." option to traverse in the dirs hierarchy
//
void FL_SetDirUpOption(filelist_t *fl, qbool show)
{
	fl->show_dirup = show;
}


//
// hides the ".." option to traverse in the dirs hierarchy
//
void FL_SetDirsOption(filelist_t *fl, qbool show)
{
	fl->show_dirs = show;
}


//
// get current entry
//
filedesc_t * FL_GetCurrentEntry(filelist_t *fl)
{
	if (fl->num_entries <= 0)
		return NULL;

	return &fl->entries[fl->current_entry];
}

//
// get current path
//
char *FL_GetCurrentPath(filelist_t *fl)
{
	if (fl->num_entries <= 0)
		return NULL;

	return fl->entries[fl->current_entry].name;
}

//
// get current display
//
char *FL_GetCurrentDisplay(filelist_t *fl)
{
	if (fl->num_entries <= 0)
		return NULL;

	return fl->entries[fl->current_entry].display;
}

//
// get current entry type
//
int FL_GetCurrentEntryType(filelist_t *fl)
{
	if (fl->num_entries <= 0)
		return -1;

	return fl->filetypes[fl->entries[fl->current_entry].type_index].id;
}

//
// is current entry a dir ?
//
qbool FL_IsCurrentDir(filelist_t *fl)
{
	if (fl->num_entries <= 0)
		return true;    // we can handle that

	return fl->entries[fl->current_entry].is_directory;
}

#ifdef WITH_ZIP
//
// Is current entry a zip file?
//
qbool FL_IsCurrentArchive(filelist_t *fl)
{
	if (fl->num_entries <= 0)
	{
		return true;
	}

	return fl->entries[fl->current_entry].is_archive;
}
#endif // WITH_ZIP

void FL_StripFileName(filelist_t *fl, filedesc_t *f)
{
	int i;
	char namebuf[_MAX_FNAME] = {0};
	char extbuf[_MAX_EXT] = {0};
	char *t;

	// Don't try to strip this.
	if (!strcmp(f->name, ".."))
	{
		strlcpy (f->display, "/..", sizeof(f->display));
		return;
	}

	// Common for dir/file, get name without path but with ext
	strlcpy (namebuf, COM_SkipPath (f->name), sizeof (namebuf));

	// File specific.
	if (!f->is_directory)
	{
		// Get extension.
		snprintf (extbuf, sizeof(extbuf), ".%s", COM_FileExtension (namebuf));

		// If the extension is only a . it means we have no extension.
		if (strlen (extbuf) == 1)
		{
			extbuf[0] = '\0';
		}

		// Remove extension from the name.
		COM_StripExtension(namebuf, namebuf, sizeof(namebuf));
	}

	if (file_browser_strip_names.value && !f->is_directory)
	{
		char *s;

		for (i=0; i < strlen(namebuf); i++)
			if (namebuf[i] == '_')
				namebuf[i] = ' ';

		// Remove spaces from the beginning
		s = namebuf;
		while (*s == ' ')
			s++;
		memmove(namebuf, s, strlen(s) + 1);

		// Remove spaces from the end
		s = namebuf + strlen(namebuf);
		while (s > namebuf  &&  *(s-1) == ' ')
			s--;
		*s = 0;

		// Remove few spaces in a row
		s = namebuf;
		while (s < namebuf + strlen(namebuf))
		{
			if (*s == ' ')
			{
				char *q = s+1;
				while (*q == ' ')
					q++;

				if (q > s+1)
					memmove(s+1, q, strlen(q)+1);
			}
			s++;
		}

		if (namebuf[0] == 0)
			strlcpy (namebuf, "_", sizeof (namebuf));
	}

	// Replace all non-standard characters with '_'
	for (i=0; i < strlen(namebuf); i++)
	{
		if (namebuf[i] < ' '  ||  namebuf[i] > '~')
			namebuf[i] = '_';
	}

	f->display[0] = 0;
	t = f->display;
	// Add a slash before a dir.
	if (f->is_directory)
		*t++ = '/';

	// Add the name and extension to the final buffer.
	for (i=0; i < strlen(namebuf)  &&  (t - f->display) < MAX_PATH; i++)
		*t++ = namebuf[i];
	for (i=0; i < strlen(extbuf)  &&  (t - f->display) < MAX_PATH; i++)
		*t++ = extbuf[i];
	*t = 0;
}

//
// Goto specific file by its name
//
void FL_GotoFile(filelist_t *fl, char *name)
{
	int i;

	fl->current_entry = 0;
	if (!name[0])
		return;

	for (i=0; i < fl->num_entries; i++)
	{
		if (!strcmp(name, fl->entries[i].name))
		{
			fl->current_entry = i;
			return;
		}
	}

	return;
}

//
// file compare func
// set FL_CompareFunc_FileList before calling..
//
filelist_t * FL_CompareFunc_FileList;    // global
int FL_CompareFunc(const void * p_d1, const void * p_d2)
{
	extern int  SYSTEMTIMEcmp(const SYSTEMTIME *, const SYSTEMTIME *);
	int reverse = 0;
	filelist_t *fl = FL_CompareFunc_FileList;
	char *sort_string = file_browser_sort_mode.string;
	const filedesc_t *d1 = (filedesc_t *)p_d1;
	const filedesc_t *d2 = (filedesc_t *)p_d2;

	// Directories always first.
	if (d1->is_directory &&  !d2->is_directory)
		return -1;
	if (d2->is_directory  && !d1->is_directory)
		return 1;

	// Directories sorted always by name, ascending
	if (d1->is_directory && d2->is_directory)
		return strcasecmp(d1->name, d2->name);

#ifdef WITH_ZIP
	// Zips after directories.
	if (d1->is_archive && !d2->is_archive)
		return -1;
	if (d2->is_archive  && !d1->is_archive)
		return 1;
	if (!file_browser_sort_archives.integer && d1->is_archive && d2->is_archive)
		return strcasecmp(d1->name, d2->name);
#endif // WITH_ZIP

	while (true)
	{
		long int d;  // difference
		char c = *sort_string++;

		if (c & 128)
		{
			reverse = 1;
			c -= 128;
		}

		switch (c)
		{
			case '1':   // name
				d = strcasecmp(d1->name, d2->name); break;
			case '2':   // size
				d = d1->size - d2->size;
				break;
			case '3':   // date / time
				d = SYSTEMTIMEcmp(&(d1->time), &(d2->time));
				break;
			case '4':   // type
				{
					char *ext1 = fl->filetypes[d1->type_index].extension;
					char *ext2 = fl->filetypes[d2->type_index].extension;
					d = strcasecmp(ext1, ext2);
					break;
				}
			default:
				d = d1 - d2;
		}

		if (d)
			return reverse ? -d : d;
	}
}

//
// sort directory
//
void FL_SortDir (filelist_t *fl)
{
	char name[MAX_PATH+1] = "";

	if (fl->num_entries <= 0  ||
			file_browser_sort_mode.string == NULL  ||
			file_browser_sort_mode.string[0] == 0)
		return;

	FL_CompareFunc_FileList = fl;
	if (fl->current_entry >= 0 && fl->current_entry < fl->num_entries)
		strlcpy (name, fl->entries[fl->current_entry].name, sizeof (name));

	qsort (fl->entries, fl->num_entries, sizeof(filedesc_t), FL_CompareFunc);

	FL_GotoFile (fl, name);

	fl->need_resort = false;
}

//
// Find out if a given directory entry is a registered file type and
// if so, returns the index of the file type. Otherwise -1 is returned.
//
static int FL_FindRegisteredType(filelist_t *fl, sys_dirent *ent)
{
	int i = 0;
	int result = -1;

	if (!ent->directory)
	{
		for (i=0; i < fl->num_filetypes; i++)
		{
			char ext[_MAX_EXT];

			snprintf (ext, sizeof(ext), ".%s", COM_FileExtension (ent->fname));

			if (!strcasecmp(fl->filetypes[i].extension, ext))
			{
				result = i;
				break;
			}
		}
	}

	return result;
}

//
// Finds which entry to highlight after doing "cd up".
//
static void FL_FindHighlightEntry (filelist_t *fl)
{
	int i = 0;

	// Look for what we have to highlight when listing the files in the
	// parent directory. If we're in c:\quake\qw\some_directory\ and do a cdup ".."
	// we want to highlight (move the cursor to) "some_directory" in the file list
	// of c:\quake\qw\ so that it's obvious which directory we just left.
	if (fl->cdup_find)
	{
		int uplen = strlen (fl->cdup_name);
		fl->cdup_find = false;
		for (i=0; i < fl->num_entries; i++)
		{
			int clen = strlen (fl->entries[i].name);

			if (uplen > clen)
			{
				continue;
			}

			if (strcmp(fl->cdup_name, fl->entries[i].name + clen - uplen))
			{
				continue;
			}

			fl->current_entry = i;
			break;
		}
	}
}

#ifdef WITH_ZIP
//
// Read the ZIP file.
//
void FL_ReadArchive (filelist_t *fl)
{
	int temp = 0;
	unzFile zip_file;
	sys_dirent ent;
	SYSTEMTIME archive_time;

	// Save the file modification time of the current archive
	archive_time = fl->entries[fl->current_entry].time;

	fl->error = true;
	fl->need_refresh = false;
	fl->display_entry = 0;
	fl->num_entries = 0;
	fl->current_entry = 0;

	// Open the zip file.
	if (fl->current_archive[0])
	{
		zip_file = FS_ZipUnpackOpenFile (fl->current_archive);
	}
	else
	{
		return;
	}

	if (zip_file == NULL)
	{
		return;
	}

	// Get the first file from the zip file.
	if (!FS_ZipGetFirst (zip_file, &ent))
	{
		goto finish;
	}

	fl->error = false;

	// Make sure we don't have some garbage left from the previous dir.
	// This caused a bug where some files inside of a zip would be
	// regarded as zip files, since the files with the same index
	// in the parent directory were zip files.
	memset(fl->entries, 0, sizeof(fl->entries));

	// Add ".." entry to allow navigating out of archive if setting says so.
	if (fl->show_dirup)
	{
		// Pointer to the current file entry.
		filedesc_t *f = &fl->entries[fl->num_entries];

		// Populate the file descriptor
		f->type_index = -1;
		f->is_directory = true;
		snprintf(f->name, sizeof(f->name), "..");
		f->size = 0;
		f->time = archive_time;

		// Find friendly name.
		FL_StripFileName(fl, f);

		// Increase counter of how many files have been found.
		fl->num_entries++;
		if (fl->num_entries >= MAX_FILELIST_ENTRIES)
		{
			goto finish;
		}
	}

	do
	{
		// Pointer to the current file entry.
		filedesc_t *f = &fl->entries[fl->num_entries];
		f->type_index = -1;

		// Skip current/above dir and hidden files.
		if (!strcmp(ent.fname, ".") || !strcmp(ent.fname, "..") || ent.hidden)
		{
			goto skip;
		}

		// Find registered type if it's not a directory.
		f->type_index = FL_FindRegisteredType (fl, &ent);

		// We're not interested in this file type since it wasn't registered.
		if (!ent.directory && f->type_index < 0)
		{
			goto skip;
		}

		// We found a file that we're interested in so save the info about it
		// in the file description structure.
		f->is_directory = ent.directory;

		// Get the full path for the file.
		snprintf (f->name, sizeof(f->name), "%s%s%s", fl->current_archive, PATH_SEPARATOR, ent.fname);

		f->size = ent.size;
		memcpy(&f->time, &ent.time, sizeof(f->time));

		// Find friendly name.
		FL_StripFileName(fl, f);

		// Increase counter of how many files have been found.
		fl->num_entries++;
		if (fl->num_entries >= MAX_FILELIST_ENTRIES)
		{
			break;
		}
skip:
		// Get next filesystem entry
		temp = FS_ZipGetNextFile (zip_file, &ent);
	}
	while (temp > 0);

	fl->need_resort = true;

finish:
	// Close the zip file.
	FS_ZipUnpackCloseFile (zip_file);

	// Re-sort the file list if needed.
	if (fl->need_resort)
	{
		FL_SortDir (fl);
	}

	// Resort might have changed this.
	fl->current_entry = 0;

	// Find which item to highlight in the list.
	FL_FindHighlightEntry(fl);
}
#endif // WITH_ZIP

//
// read directory
//
void FL_ReadDir(filelist_t *fl)
{
	sys_dirent ent;
	SysDirEnumHandle search;
	int temp;
	char  olddir[MAX_PATH+1];

	fl->error = true;
	fl->need_refresh = false;
	fl->display_entry = 0;

	// Save the current directory. (we want to restore this later)
	if (Sys_getcwd(olddir, MAX_PATH+1) == NULL)
	{
		return;
	}

	// Change to the new dir.
	if (!Sys_chdir(fl->current_dir))
	{
		// Set the current dir.
		return;
	}

	fl->num_entries = 0;
	fl->current_entry = 0;
	fl->error = false;

	// Get the first entry in the dir.
	search = Sys_ReadDirFirst(&ent);
	if (!search)
	{
		goto finish;
	}

	do
	{
		// Pointer to the current file entry.
		filedesc_t *f = &fl->entries[fl->num_entries];
		memset (f, 0, sizeof(filedesc_t));
		f->type_index = -1;

		// Skip current/above dir and hidden files.
		if (!strcmp(ent.fname, ".") || ent.hidden)
		{
			goto skip;
		}

		// Skip the "up one level" option if setting says so
		if (!strcmp(ent.fname, "..") && !fl->show_dirup)
		{
			goto skip;
		}

		// Skip directories, if settings say so
		if (ent.directory && !fl->show_dirs)
		{
			goto skip;
		}

		// Find registered type if it's not a directory.
		f->type_index = FL_FindRegisteredType (fl, &ent);

#ifdef WITH_ZIP
		if (FS_IsArchive (ent.fname))
		{
			f->is_archive = true;
		}
#endif

		// We're not interested in this file type since it wasn't registered.
		if (!ent.directory && f->type_index < 0
#ifdef WITH_ZIP
				// Or isn't a zip.
				&& !f->is_archive
#endif
		   )
		{
			goto skip;
		}

		// We found a file that we're interested in so save the info about it
		// in the file description structure.
		{
			f->is_directory = ent.directory;

			if (!strcmp(ent.fname, ".."))
			{
				// Don't get the full path for the ".." (parent) dir, that's just confusing.
				strlcpy (f->name, ent.fname, sizeof (f->name));
			}
			else
			{
				// Get full path for normal files/dirs.
				Sys_fullpath(f->name, ent.fname, sizeof(f->name));
			}

			f->size = ent.size;
			memcpy(&f->time, &ent.time, sizeof(f->time));
		}

		// Find friendly name.
		FL_StripFileName(fl, f);

		// Increase counter of how many files have been found.
		fl->num_entries++;
		if (fl->num_entries >= MAX_FILELIST_ENTRIES)
		{
			break;
		}
skip:
		memset (&ent, 0, sizeof(ent));

		// Get next filesystem entry
		temp = Sys_ReadDirNext(search, &ent);
	}
	while (temp > 0);

	// Close the handle for the directory.
	Sys_ReadDirClose(search);

	fl->need_resort = true;

finish:
	// Change the current dir back to what it was.
	Sys_chdir (olddir);

	// Re-sort the file list if needed.
	if (fl->need_resort)
	{
		FL_SortDir (fl);
	}

	// Resort might have changed this.
	fl->current_entry = 0;

	// Find which item to highlight in the list.
	FL_FindHighlightEntry(fl);

	return;
}

//
// Search by name for next item.
//
qbool FL_Search(filelist_t *fl)
{
	int start = fl->current_entry;
	int stop = fl->num_entries;
	int i = 0;
	char *s = NULL;
	char tmp[512];

	fl->search_dirty = false;

search :

	// First search at the beginning of the string (like when you type in a window in explorer).
	for (i = start; i < stop; i++)
	{
		strlcpy (tmp, fl->entries[i].display, sizeof (tmp));
		s = tmp;

		// Get rid of slashes for dirs.
		while (s && (*s) == '/')
		{
			s++;
		}

		if (!strncasecmp (s, fl->search_string, strlen (fl->search_string)))
		{
			fl->current_entry = i;
			return true;
		}
	}

	// Nothing found, so search in any part of the string.
	for (i = start; i < stop; i++)
	{
		strlcpy (tmp, fl->entries[i].display, sizeof (tmp));
		FunToSort (tmp);

		if (strstr(tmp, fl->search_string))
		{
			fl->current_entry = i;
			return true;
		}
	}

	// Try to search from the start if we didn't find it below the
	// current position of the cursor.
	if (start > 0)
	{
		start = 0;
		stop = fl->current_entry; // No idea searching anything below this again (we just did that).
		goto search;
	}

	// We couldn't find anything.
	fl->search_error = true;
	return false;
}

//
// FL_ChangeZip - enter a zip file
//
void FL_ChangeArchive(filelist_t *fl, char *archive)
{
	strlcpy (fl->current_archive, archive, sizeof(fl->current_archive));
	fl->in_archive = true;

	fl->need_refresh = true;
}

//
// FL_ChangeDirUp - cd ..
//
void FL_ChangeDirUp(filelist_t *fl)
{
	// No point doing anything.
	if (strlen(fl->current_dir) < 2)
	{
		return;
	}

	// Get the name of the directory we're leaving, so that we can highlight it
	// in the file list of it's parent. (makes it easier keep track of where you are)
	{
		fl->cdup_find = true;

#ifdef WITH_ZIP
		if (fl->in_archive)
		{
			strlcpy (fl->cdup_name, COM_SkipPath(fl->current_archive), sizeof(fl->cdup_name));
		}
		else
#endif // WITH_ZIP
		{
			strlcpy (fl->cdup_name, COM_SkipPath(fl->current_dir), sizeof(fl->cdup_name));
		}

		// fl->cdup_name will be:
		// the_directory_were_leaving
		// If the full path was:
		// c:\quake\qw\the_directory_were_leaving
	}
}

//
// FL_ChangeDir - changes directory
//
void FL_ChangeDir(filelist_t *fl, char *newdir)
{
	char olddir[MAX_PATH+1];

	// Get the current dir from the OS and save it.
	if (Sys_getcwd(olddir, MAX_PATH+1) == NULL)
	{
		return;
	}

	// Check if changing to parent directory or leaving archive
	if (newdir != NULL && strcmp(newdir, "..") == 0)
	{
		FL_ChangeDirUp(fl);

#ifdef WITH_ZIP
		if (fl->in_archive)
		{
			// Leaving a zip file.
			fl->current_archive[0] = 0;
			fl->in_archive = false;
			fl->need_refresh = true;

			return;
		}
#endif // WITH_ZIP
	}

	// Change to the current dir that we're in (might be different from the OS's).
	// If we're changing dirs in a relative fashion ".." for instance we need to
	// be in this dir, and not the dir that the OS is in.
	if (Sys_chdir(fl->current_dir) == 0)
	{
		// Normal directory.
		return;
	}

	// Change to the new dir requested.
	Sys_chdir (newdir);

	// Save the current dir we just changed to.
	Sys_getcwd (fl->current_dir, MAX_PATH+1);

	// Go back to where the OS wants to be.
	Sys_chdir (olddir);

	fl->need_refresh = true;

#ifdef WITH_ZIP
	// Since we just changed to a new directory we can't be in a zip file.
	fl->current_archive[0] = 0;
	fl->in_archive = false;
#endif // WITH_ZIP
}

//
// check current position
//
void FL_CheckPosition(filelist_t *fl)
{
	if (fl->current_entry < 0)
		fl->current_entry = 0;
	if (fl->current_entry >= fl->num_entries)
		fl->current_entry = fl->num_entries - 1;
	if (fl->scrollbar && fl->num_entries > fl->displayed_entries_count) {
		fl->scrollbar->curpos = fl->display_entry * 1.0f / (fl->num_entries - fl->displayed_entries_count);
	}
}

#ifdef WITH_ZIP
void FL_CompressFile (filelist_t *fl)
{
	char *file_path = FL_GetCurrentPath(fl);

	// Remember where we were.
	int ce = fl->current_entry;	 

	// Compress the file
	int ret = FS_GZipPack(file_path, va("%s.gz", file_path), false); 

	if (ret)
	{
		unlink(file_path);
	}
	else
	{
		Com_Printf("Failed compressing file to GZip.");
	}

	FL_ReadDir(fl);				// Reload dir.
	fl->current_entry = ce;		// Set previous position.
	FL_CheckPosition(fl);
}

void FL_DecompressFile (filelist_t *fl)
{
	int ret = 0;

	// Remember where we were.
	int ce = fl->current_entry;	 
	char *gzip_path = FL_GetCurrentPath(fl);
	char file_path[MAX_PATH];

	COM_StripExtension(gzip_path, file_path, sizeof(file_path));

	ret = FS_GZipUnpack(gzip_path, file_path, false); 

	if (ret)
	{
		unlink(gzip_path);
	}
	else
	{
		Com_Printf("Failed decompressing file from GZip.");
	}

	FL_ReadDir(fl);				// Reload dir.
	fl->current_entry = ce;		// Set previous position.
	FL_CheckPosition(fl);
}
#endif // WITH_ZIP

//
// Delete the current file.
//
void FL_DeleteFile(filelist_t *fl)
{
	int ce = fl->current_entry;		// Remember where we were.
	unlink(FL_GetCurrentPath(fl));	// Delete.
	FL_ReadDir(fl);					// Reload dir.
	fl->current_entry = ce;
	FL_CheckPosition(fl);
}

//
// Check display position
//
void FL_CheckDisplayPosition(filelist_t *fl)
{
	int lines = fl->displayed_entries_count;

	if (fl->current_entry < 0) fl->current_entry = 0;

	// FIXME: move list earlier..
	if (fl->current_entry > fl->display_entry + lines - 1)
		fl->display_entry = fl->current_entry - lines + 1;

	if (fl->display_entry > fl->num_entries - lines)
		fl->display_entry = max(fl->num_entries - lines, 0);

	if (fl->current_entry < fl->display_entry)
		fl->display_entry = fl->current_entry;

	FL_CheckPosition(fl);
}

//
// keys handling
// returns: true if processed, false if ignored
//
qbool FL_Key(filelist_t *fl, int key)
{
	if (fl->mode != FL_MODE_NORMAL)
	{
		switch(key) 
		{
			case 'y':
			case 'Y':
			case K_ENTER:
				if (!FL_IsCurrentDir(fl))
				{
					if (fl->mode == FL_MODE_DELETE)
					{
						FL_DeleteFile(fl);
					}
#ifdef WITH_ZIP
					else if (fl->mode == FL_MODE_COMPRESS)
					{
						FL_CompressFile(fl); // Compress file.
					}
					else if (fl->mode == FL_MODE_DECOMPRESS)
					{
						FL_DecompressFile(fl); // Decompress file.
					}
#endif // WITH_ZIP
				}

				fl->mode = FL_MODE_NORMAL;
				return true;
			case 'n':
			case 'N':
			case K_ESCAPE:
				fl->mode = FL_MODE_NORMAL;
				return true;
		}

		return false;
	}

	// Check for search
	if ((key >= ' ' && key <= '~') && (fl->search_valid || (!keydown[K_ALT] && !keydown[K_CTRL] && !keydown[K_SHIFT])))
	{
		int len;

		if (!fl->search_valid)
		{
			// Start searching
			fl->search_valid = true;
			fl->search_error = false;
			fl->search_string[0] = 0;
		}

		len = strlen(fl->search_string);

		if (len < MAX_SEARCH_STRING && !fl->search_error)
		{
			fl->search_string[len] = key;
			fl->search_string[len+1] = 0;
			fl->search_dirty = true;

			// Save the last time the user entered a char in the
			// search term, so that we know when to timeout the search prompt.
			// (See beginning of FL_Draw)
			last_search_enter_time = Sys_DoubleTime();
		}

		return true;    // handled
	}
	else
	{
		fl->search_valid = false;   // finish search mode
	}

	// sorting mode / displaying columns
	if (key >= '1' && key <= '4') {
		if (keydown[K_CTRL] && !keydown[K_ALT] && !keydown[K_SHIFT])
		{
			switch (key)
			{
				case '2':
					Cvar_Toggle(&file_browser_show_size); break;
				case '3':
					Cvar_Toggle(&file_browser_show_date); break;
				case '4':
					Cvar_Toggle(&file_browser_show_time); break;
				default:
					break;
			}
			return true;
		}
		else if (!keydown[K_CTRL] && keydown[K_ALT] && !keydown[K_SHIFT])
		{
			char buf[128];

			strlcpy(buf, file_browser_sort_mode.string, 32); // WTF?
			if (key  ==  buf[0])
			{
				// reverse order
				buf[0] ^= 128;
			}
			else
			{
				// add new
				memmove(buf+1, buf, strlen(buf)+1);
				buf[0] = key;
			}
			buf[8] = 0;
			Cvar_Set(&file_browser_sort_mode, buf);

			fl->need_resort = true;
			return true;
		}
	}

	// change drive
#ifdef _WIN32
	if (keydown[K_ALT]  &&  keydown[K_CTRL]  &&
			tolower(key) >= 'a'  &&  tolower(key) <= 'z')
	{
		char newdir[MAX_PATH+1];
		char olddir[MAX_PATH+1];

		snprintf(newdir, sizeof (newdir), "%c:\\", tolower(key));

		// validate
		if (Sys_getcwd(olddir, MAX_PATH+1) == 0)
			return true;
		if (Sys_chdir(newdir) == 0)
			return true;
		Sys_chdir(olddir);

		// and set
		FL_SetCurrentDir(fl, newdir);
		fl->need_refresh = true;

		return true;
	}
#endif

	if (key == '\\'  ||  key == '/')
	{
		FL_ChangeDir(fl, PATH_SEPARATOR);
		return true;
	}

	if (key == K_ENTER || key == K_MOUSE1)
	{
		if (FL_IsCurrentDir(fl))
		{
			FL_ChangeDir(fl, FL_GetCurrentPath(fl));
			return true;
		}
#ifdef WITH_ZIP
		else if (FL_IsCurrentArchive(fl))
		{
			FL_ChangeArchive(fl, FL_GetCurrentPath(fl));
			return true;
		}
#endif //WITH_ZIP
		else
		{
			return false;
		}
	}

	if (key == K_BACKSPACE)
	{
		if (fl->show_dirup)
			FL_ChangeDir(fl, "..");
		return true;
	}

	if (key == K_UPARROW || key == K_MWHEELUP)
	{
		fl->current_entry--;
		FL_CheckDisplayPosition(fl);
		return true;
	}

	if (key == K_DOWNARROW || key == K_MWHEELDOWN)
	{
		fl->current_entry++;
		FL_CheckDisplayPosition(fl);
		return true;
	}

	if (key == K_PGUP)
	{
		fl->current_entry -= fl->last_page_size;
		FL_CheckDisplayPosition(fl);
		return true;
	}

	if (key == K_PGDN)
	{
		fl->current_entry += fl->last_page_size;
		FL_CheckDisplayPosition(fl);
		return true;
	}

	if (key == K_HOME)
	{
		fl->current_entry = 0;
		FL_CheckDisplayPosition(fl);
		return true;
	}

	if (key == K_END)
	{
		fl->current_entry = fl->num_entries - 1;
		FL_CheckDisplayPosition(fl);
		return true;
	}

#ifdef WITH_ZIP
	//
	// Compress the current file.
	//
	if ((key == 'c' || key == 'C') && keydown[K_ALT])
	{
		if (!FL_IsCurrentDir(fl))
		{
			if (keydown[K_SHIFT])
			{
				// Alt + shift + c == Compress without confirming.
				FL_CompressFile(fl);
			}
			else
			{
				// Alt + c == Confirm before compressing.
				fl->mode = FL_MODE_COMPRESS;
			}
		}
		return true;
	}

	//
	// Decompress the current file.
	//
	if ((key == 'd' || key == 'D') && keydown[K_ALT])
	{
		if (!strcmp(COM_FileExtension(FL_GetCurrentPath(fl)), "gz"))
		{
			FL_DecompressFile(fl);
		}
	}
#endif // WITH_ZIP

	//
	// Delete the current file.
	//
	if (key == K_DEL)
	{
		if (!FL_IsCurrentDir(fl)) 
		{
			if (keydown[K_SHIFT])
			{
				// Shift + del == Delete without confirming.
				FL_DeleteFile(fl);
			}
			else
			{
				// Del == Confirm before deleting.
				fl->mode = FL_MODE_DELETE;
			}
		}
		return true;
	}

	return false;
}

qbool FL_Mouse_Event(filelist_t *fl, const mouse_state_t *ms)
{
	int entry;

	if (fl->scrollbar->mouselocked || 
			((ms->x > fl->list_width) && (ms->x <= (fl->list_width + fl->scrollbar->width))))
	{   // catch the scrollbar mouse event

		if (ScrollBar_MouseEvent(fl->scrollbar, ms))
		{
			if (fl->num_entries > fl->displayed_entries_count) {
				fl->display_entry = (fl->num_entries - fl->displayed_entries_count) * fl->scrollbar->curpos;
			}
		}

		return true;
	}

	// we don't handle mouse clicks, that's up to the module above us
	if (ms->button_down || ms->button_up) return false;

	// no other area then the list interests us
	if (ms->x > fl->list_width || ms->y >= (fl->list_y_offset + fl->list_height) || ms->y <= fl->list_y_offset)
		return false;

	// we presume that each line is 8 px high

	entry = (int) ms->y / 8 - 2;
	fl->current_entry = fl->display_entry + entry;
	FL_CheckPosition(fl);

	return true;
}

//
// This is used only in FL_Draw below, EX_browser.c has Add_Column2
//
static void Add_Column(char *line, int *pos, char *t, int w)
{
	// Adds columns starting from the right.

	// If we're too far to the left we can't fit a column
	// of this width.
	if ((*pos) - w - 1  <=  1)
	{
		return;
	}

	// Move the position to the left by the width of the column.
	(*pos) -= w;

	// Copy the contents into the column.
	memcpy(line + (*pos), t, min(w, strlen(t)));

	// Create a space for the next column.
	(*pos)--;
	line[*pos] = ' ';
}

//
// FileList drawing func
//
void FL_Draw(filelist_t *fl, int x, int y, int w, int h)
{
	int i;
	int listsize, pos, interline, inter_up, inter_dn, rowh;
	char line[1024];
	char sname[MAX_PATH] = {0}, ssize[COL_SIZE+1] = {0}, sdate[COL_DATE+1] = {0}, stime[COL_TIME+1] = {0};

	// Check if it's time for us to reset the search.
	// (FL_SEARCH_TIMEOUT seconds after the user entered the last char in the search term)
	if (Sys_DoubleTime() - last_search_enter_time >= FL_SEARCH_TIMEOUT)
	{
		fl->search_valid = false;
		fl->search_string[0] = 0;
	}

	if (fl->mode == FL_MODE_DELETE)
	{
		UI_Print_Center(x, y + 8,  w, "Are you sure you want to delete this file?", true);
		UI_Print_Center(x, y + 24, w, FL_GetCurrentDisplay(fl), false);
		UI_Print_Center(x, y + 40, w, "(Y/N)", true);
		return;
	}
#ifdef WITH_ZIP
	else if (fl->mode == FL_MODE_COMPRESS)
	{
		UI_Print_Center(x, y + 8,  w, "Are you sure you want to compress this file?", true);
		UI_Print_Center(x, y + 24, w, FL_GetCurrentDisplay(fl), false);
		UI_Print_Center(x, y + 40, w, "(Y/N)", true);
		return;
	}
	else if (fl->mode == FL_MODE_DECOMPRESS)
	{
		UI_Print_Center(x, y + 8,  w, "Are you sure you want to decompress this file?", true);
		UI_Print_Center(x, y + 24, w, FL_GetCurrentDisplay(fl), false);
		UI_Print_Center(x, y + 40, w, "(Y/N)", true);
		return;
	}
#endif // WITH_ZIP

	fl->last_page_size = 0;

	w -= fl->scrollbar->width;

	// Calculate interline (The space between each row)
	interline = file_browser_interline.value;
	interline = max(interline, 0);
	interline = min(interline, 6);
	inter_up = interline / 2;
	inter_dn = interline - inter_up;
	rowh = 8 + inter_up + inter_dn;
	listsize = h / rowh;

	// Check screen boundaries and mimnimum size
	if (w < 160 || h < 80)
		return;
	if (x < 0 || y < 0 || x + w > vid.width || y + h > vid.height)
		return;

	if (fl->need_refresh)
	{
#ifdef WITH_ZIP
		if (fl->in_archive)
		{
			FL_ReadArchive (fl);
		}
		else
#endif // WITH_ZIP
		{
			FL_ReadDir(fl);
		}
	}

	if (fl->need_resort)
	{
		FL_SortDir(fl);
	}

	if (fl->search_dirty)
	{
		FL_Search(fl);
	}

	// Print the current path.
	{
		char *curr_path = NULL;

#ifdef WITH_ZIP
		if (fl->in_archive)
		{
			curr_path = fl->current_archive;
		}
		else
#endif // WITH_ZIP
		{
			curr_path = fl->current_dir;
		}

		// Make the path fit on screen "c:\quake\bla\bla\bla" => "c:\quake...la\bla".
		COM_FitPath (line, sizeof(line), curr_path, w/8);
	}

	line[w/8] = 0;
	UI_Print(x, y + inter_up, line, true);
	listsize--;

	// Draw column titles.
	pos = w/8;
	memset(line, ' ', pos);
	line[pos] = 0;

	if (file_browser_show_time.value)
		Add_Column(line, &pos, "time", COL_TIME);
	if (file_browser_show_date.value)
		Add_Column(line, &pos, "date", COL_DATE);
	if (file_browser_show_size.value)
		Add_Column(line, &pos, "  kb", COL_SIZE);

	memcpy(line, "name", min(pos, 4));
	line[w/8] = 0;
	UI_Print_Center(x, y + rowh + inter_dn, w, line, true);
	listsize--;

	// Nothing to show.
	if (fl->num_entries <= 0)
	{
		UI_Print_Center(x, y + 2 * rowh + inter_dn + 4, w, "directory empty", false);
		return;
	}

	// Something went wrong when processing the directory.
	if (fl->error)
	{
		UI_Print_Center(x, y + 2 * rowh + inter_dn + 4, w, "error reading directory", false);
		return;
	}

	// If we're showing the status bar we have less room for the file list.
	if (file_browser_show_status.value)
	{
		listsize -= 3;
	}

	fl->list_width = w;
	fl->list_height = listsize*rowh;
	fl->list_y_offset = 2 * rowh;
	fl->last_page_size = listsize;  // Remember for PGUP/PGDN
	fl->displayed_entries_count = listsize;
	FL_CheckPosition(fl);

	if (fl->displayed_entries_count < fl->num_entries) {
		ScrollBar_Draw(fl->scrollbar, x + fl->list_width, y + fl->list_y_offset, fl->list_height);
	}

	for (i = 0; i < listsize; i++)
	{
		filedesc_t *entry;
		unsigned long dwsize;
		char size[COL_SIZE+1], date[COL_DATE+1], time[COL_TIME+1];
		char name[MAX_PATH];
		int filenum = fl->display_entry + i;
		clrinfo_t clr[2]; // here we use _one_ color, at begining of the string
		static char	last_name[sizeof(name)]	= {0}; // this is for scroll, can't put it inside scroll code

		clr[0].c = COLOR_WHITE;
		clr[0].i = 0; // begin of the string

		if (filenum >= fl->num_entries)
			break;

		entry = &fl->entries[filenum];

		// Extract date & time.
		snprintf(date, sizeof(date), "%02d-%02d-%02d", entry->time.wYear % 100, entry->time.wMonth, entry->time.wDay);
		snprintf(time, sizeof(time), "%2d:%02d", entry->time.wHour, entry->time.wMinute);

		// Extract size.
		if (entry->is_directory)
		{
			strlcpy(size, "<-->", sizeof(size));
			if (filenum == fl->current_entry)
				strlcpy(ssize, "dir", sizeof(ssize));
		}
		else
		{
			dwsize = entry->size / 1024;
			if (dwsize > 9999)
			{
				dwsize /= 1024;
				dwsize = min(dwsize, 999);
				snprintf(size, sizeof(size), "%3lum", dwsize);
				if (filenum == fl->current_entry) {
					snprintf(ssize, sizeof(ssize), "%lu mb", dwsize);
				}
			}
			else
			{
				snprintf(size, sizeof(size), "%4lu", dwsize);
				if (filenum == fl->current_entry) {
					snprintf(ssize, sizeof(ssize), "%lu kb", dwsize);
				}
			}
		}

		// Add the columns to the current row (starting from the right).
		pos = w/8;

		// Clear the line.
		memset(line, ' ', pos);
		line[pos] = 0;

		// Add columns.
		if (file_browser_show_time.value)
			Add_Column(line, &pos, time, COL_TIME);
		if (file_browser_show_date.value)
			Add_Column(line, &pos, date, COL_DATE);
		if (file_browser_show_size.value)
			Add_Column(line, &pos, size, COL_SIZE);

		// End of name, switch to white.
		clr[1].c = COLOR_WHITE;
		clr[1].i = pos;

		// Set the name.
		// (Add a space infront so that the cursor for the currently
		// selected file can fit infront)
		snprintf (name, sizeof(name) - 1, " %s", entry->display);

		//
		// Copy the display name of the entry into the space that's left on the row.
		//
		if (filenum == fl->current_entry && file_browser_scrollnames.value && strlen(name) > pos)
		{
			// We need to scroll the text since it doesn't fit.
#define SCROLL_RIGHT	1
#define SCROLL_LEFT		0

			double			t					= 0;
			static double	t_last_scroll		= 0;
			static qbool	wait				= false;
			static int		scroll_position		= 0;
			static int		scroll_direction	= SCROLL_RIGHT;
			static int		last_text_length	= 0;
			int				text_length			= strlen(name);
			float			scroll_delay		= 0.1;

			// If the text has changed since last time we scrolled
			// the scroll data will be invalid so reset it.
			if (last_text_length != text_length || !last_name[0] || strncmp(name, last_name, sizeof(last_name)))
			{
				strlcpy(last_name, name, sizeof(last_name));
				scroll_position = 0;
				scroll_direction = SCROLL_RIGHT;
				last_text_length = text_length;

				// Wait a second before start scroll plz.
				wait = true;
				t_last_scroll = Sys_DoubleTime();
			}

			// Get the current time.
			t = Sys_DoubleTime();

			// Time to scroll.
			if (!wait && (t - t_last_scroll) > scroll_delay)
			{
				// Save the current time as the last time we scrolled
				// and change the scroll position depending on what direction we're scrolling.
				t_last_scroll = t;
				scroll_position = (scroll_direction == SCROLL_RIGHT) ? scroll_position + 1 : scroll_position - 1;
			}

			// Set the scroll direction.
			if (text_length - scroll_position == pos)
			{
				// We've reached the end, go back.
				scroll_direction = SCROLL_LEFT;
				wait = true;
			}
			else if (scroll_position == 0)
			{
				// At the beginning, start over.
				scroll_direction = SCROLL_RIGHT;
				wait = true;
			}

			// Wait a second when changing direction.
			if (wait && (t - t_last_scroll) > 1.0)
			{
				wait = false;
			}

			memcpy(line, name + scroll_position, min(pos, text_length + scroll_position));
		}
		else
		{
			//
			// Fits in the name column, no need to scroll (or the user doesn't want us to scroll :~<)
			//

			// Did we just select a new entry? In that case reset the scrolling.
			if (filenum == fl->current_entry)
			{
				last_name[0] = 0;
			}

			// If it's not the selected directory/zip color it so that it stands out.
			if (filenum != fl->current_entry)
			{
				if (entry->is_directory)
				{
					// Set directory color.
					clr[0].c = RGBAVECT_TO_COLOR(file_browser_dir_color.color);
				}
#ifdef WITH_ZIP
				else if (entry->is_archive)
				{
					// Set zip color.
					clr[0].c = RGBAVECT_TO_COLOR(file_browser_archive_color.color);
				}
#endif // WITH_ZIP
				else
				{
					clr[0].c = RGBAVECT_TO_COLOR(file_browser_file_color.color);
				}
			}

			memcpy(line, name, min(pos, strlen(name)));
		}

		// Draw a cursor character at the start of the line.
		if (filenum == fl->current_entry)
		{
			line[0] = (char)141;
			UI_DrawGrayBox(x, y + rowh * (i + 2) + inter_dn, w, rowh);
		}

		// Max amount of characters that fits on a line.
		line[w/8] = 0;

		// Color the selected entry.
		if (filenum == fl->current_entry)
		{
			clr[0].c = RGBAVECT_TO_COLOR(file_browser_selected_color.color);
			clr[0].i = 1; // Don't color the cursor (index 0).
		}

		// Print the line for the directory entry.
		UI_Print_Center3(x, y + rowh * (i + 2) + inter_dn, w, line, clr, 2, 0);

		// Remember the currently selected file for dispalying in the status bar
		if (filenum == fl->current_entry)
		{
			strlcpy (sname, line + 1, min(pos, sizeof(sname)));
			strlcpy (stime, time, sizeof(stime));
			snprintf (sdate, sizeof(sdate), "%02d-%02d-%02d", entry->time.wYear % 100, entry->time.wMonth, entry->time.wDay);
		}
	}

	// Show a statusbar displaying the currently selected entry.
	if (file_browser_show_status.value)
	{
		// Print a line to part the status bar from the file list.
		memset(line, '\x1E', w/8);
		line[0] = '\x1D';
		line[w/8 - 1] = '\x1F';
		line[w/8] = 0;
		UI_Print(x, y + h - 3 * rowh - inter_up, line, false);

		// Print the name.
		UI_Print_Center(x, y + h - 2 * rowh - inter_up, w, sname, false);

		if (fl->search_valid)
		{
			// Some weird but nice-looking string in Quake font perhaps
			strlcpy(line, "search for: ", sizeof(line));   // seach for:
			if (fl->search_error)
			{
				strlcat(line, "not found", sizeof(line));
				UI_Print_Center(x, y + h - rowh - inter_up, w, line, false);
			}
			else
			{
				strlcat(line, fl->search_string, sizeof(line));
				UI_Print_Center(x, y + h - rowh - inter_up, w, line, true);
			}
		}
		else
		{
			snprintf(line, sizeof(line), "%s \x8f modified: %s %s", ssize, sdate, stime);
			UI_Print_Center(x, y + h - rowh - inter_up, w, line, false);
		}
	}
}

// make ../backspace work fine (ala demoplayer)
// do not show hidden files

static void OnChange_file_browser_sort_mode(cvar_t *var, char *string, qbool *cancel)
{
	extern qbool host_everything_loaded;
	extern filelist_t demo_filelist;
	extern filelist_t help_index_fl;
	extern filelist_t help_tutorials_fl;
	extern filelist_t configs_filelist;
	extern filelist_t skins_filelist;

	if (host_everything_loaded) {
		demo_filelist.need_resort		= true;
		help_index_fl.need_resort		= true;
		help_tutorials_fl.need_resort	= true;
		configs_filelist.need_resort	= true;
		skins_filelist.need_resort		= true;
	}
}



================================================
FILE: src/EX_FileList.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
 * File List
 *
 * display directory contents, allows for changing dir,
 * drive etc..
 *
 * meant for use by MP3 player, mayby demo player too
 *
 * FileList have four colums:
 *  - file name (with ext)
 *  - size
 *  - date (last modification)
 *  - time (last modification)
 *
 * and allows to display different sets of columns
 * also do sorting
 *
 */

#ifndef __EX_FILELIST_H__
#define __EX_FILELIST_H__

#include "keys.h"
#include "Ctrl.h"

//
// maximum-s
//
#define  MAX_FILELIST_ENTRIES  1024
#define  MAX_FILELIST_TYPES    16
#define  MAX_FILELIST_DISPLAY  80
#define  MAX_EXTENSION_LENGTH  15
#define  MAX_SEARCH_STRING     64

//
// entry (file) type strucy
//
typedef struct filetype_s
{
    int         id;
    char        extension [MAX_EXTENSION_LENGTH+1];
}
filetype_t;


//
// file entry structure
//
typedef struct filedesc_s
{
    qbool			is_directory;
	
	#ifdef WITH_ZIP
	qbool			is_archive;
	#endif
    
	char            name[MAX_PATH+1];
    char            display[MAX_PATH+1];
    unsigned long   size;
    SYSTEMTIME      time;
    int             type_index;
}
filedesc_t;

#define FL_MODE_NORMAL		0
#define FL_MODE_DELETE		1
#define FL_MODE_COMPRESS	2
#define FL_MODE_DECOMPRESS	3

//
// Filelist structure
//
typedef struct filelist_s
{
    char			current_dir[MAX_PATH+1];
	char			current_archive[MAX_PATH+1];
	qbool			in_archive;
    qbool			error;          // Error reading dir
    qbool			need_refresh;   // Dir is reread in draw func
    qbool			need_resort;    // Dir is sorted in draw func

    filedesc_t		entries[MAX_FILELIST_ENTRIES];
    int				num_entries;
    int				current_entry;
    int				display_entry;  // First item displayed
    int             displayed_entries_count;    // ammount of entries that fit on the screen

    filetype_t		filetypes[MAX_FILELIST_TYPES];
    int				num_filetypes;

	qbool			show_dirup;
	qbool			show_dirs;

    // For PGUP/PGDN, filled by drawing func
    int				last_page_size;

    // For searching
    char			search_string[MAX_SEARCH_STRING+1];
    qbool			search_valid;   // If is in search mode
    qbool			search_dirty;   // If should research
    qbool			search_error;   // Not found
	int				mode;			// Are we deleting/compressing a file?

    // For cd ..
    char            cdup_name[MAX_PATH+1];
    qbool			cdup_find;

	// for mouse navigation
    int             list_y_offset;
	int				list_width;
	int				list_height;

    // associated scrollbar GUI element
    PScrollBar      scrollbar;
}
filelist_t;


//
// Drawing routine
//
void FL_Draw(filelist_t *, int x, int y, int w, int h);


//
// Send key to list
// returns: true if processed, false if ignored
//
qbool FL_Key(filelist_t *, int key);


//
// Send Mouse Move event to the list
// returns: true if processed, false if mouse pointed somewhere else
//
qbool FL_Mouse_Event(filelist_t *, const mouse_state_t *ms);

//
// Create file list
//
void FL_Init(filelist_t	*fl, char *initdir);

void FL_Shutdown(filelist_t* fl);

//
// Add new file type (.qwd, .qwz, .mp3).
//
void FL_AddFileType(filelist_t *, int id, char *ext);


//
// Set current directory (and drive).
//
void FL_SetCurrentDir(filelist_t *, const char *dir);


//
// hides the ".." option to traverse in the dirs hierarchy
//
void FL_SetDirUpOption(filelist_t *fl, qbool show);


//
// hides the ".." option to traverse in the dirs hierarchy
//
void FL_SetDirsOption(filelist_t *fl, qbool show);


//
// Get current directory.
//
char *FL_GetCurrentDir(filelist_t *);


//
// Get current entry.
//
filedesc_t * FL_GetCurrentEntry(filelist_t *);


//
// Get current path.
//
char *FL_GetCurrentPath(filelist_t *);


//
// Get current display.
//
char *FL_GetCurrentDisplay(filelist_t *fl);


//
// Get current entry type.
//
int FL_GetCurrentEntryType(filelist_t *);


//
// Is current entry a dir ?
//
qbool FL_IsCurrentDir(filelist_t *);

#endif // __EX_FILELIST_H__


================================================
FILE: src/EX_browser.c
================================================
/*
Copyright (C) 2011-2015 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "fs.h"
#include "gl_model.h"
#ifndef _WIN32
#include <netinet/in.h>
#include <unistd.h>
#endif

#include "keys.h"
#include "EX_browser.h"
#include "EX_qtvlist.h"
#include "Ctrl_EditBox.h"
#include "settings.h"
#include "settings_page.h"
#include "Ctrl.h"
#include "Ctrl_Tab.h"
#include "menu.h"
#include "utils.h"
#include "menu_multiplayer.h"
#include "qsound.h"
#include "teamplay.h"

int source_unique = 0;

typedef struct info_filter_s {
	char name[MAX_INFO_KEY];
	pcre2_code* regex;
	qbool pass;
	qbool exec;
} info_filter_t;

static info_filter_t* SB_InfoFilter_Parse(int* count);
static qbool SB_InfoFilter_Exec(info_filter_t* info_filters, int info_filter_count, server_data* s);
static void SB_InfoFilter_Free(info_filter_t* info_filters, int info_filter_count);

// searching
#define MAX_SEARCH 20
#define SEARCH_TIME 3
double searchtime = -10;

#define MWHEEL_SCROLL_STEP 4

enum {
	search_none = 0,
	search_server,
	search_player
} searchtype = search_none;

char searchstring[MAX_SEARCH+1];

// add source
CEditBox edit1, edit2;
int adding_source = 0;
sb_source_type_t newsource_type; // 0 = file
int newsource_pos;

// add server
int adding_server = 0;
int newserver_pos;

serverbrowser_window_t Browser_window;

// must correspond to server_occupancy enum values
static const char* occupancy_colors[] = { "00f", "0f0", "f00" };

cvar_t  sb_status        =  {"sb_status", 			"1"}; // Shows Server status at the bottom

// columns
cvar_t  sb_showping      = {"sb_showping",         "1"};
cvar_t  sb_showaddress   = {"sb_showaddress",      "0"};
cvar_t  sb_showmap       = {"sb_showmap",          "1"};
cvar_t  sb_showgamedir   = {"sb_showgamedir",      "0"};
cvar_t  sb_showplayers   = {"sb_showplayers",      "1"};
cvar_t  sb_showfraglimit = {"sb_showfraglimit",    "0"};
cvar_t  sb_showtimelimit = {"sb_showtimelimit",    "0"};

cvar_t  sb_pingtimeout   = {"sb_pingtimeout",   "1000"};
cvar_t  sb_infotimeout   = {"sb_infotimeout",   "1000"};
cvar_t  sb_pingspersec   = {"sb_pingspersec",    "150"}; // Pings per second
cvar_t  sb_pings         = {"sb_pings",            "3"}; // Number of times to ping a server
cvar_t  sb_inforetries   = {"sb_inforetries",      "3"};
cvar_t  sb_infospersec   = {"sb_infospersec",    "100"};
cvar_t  sb_proxinfopersec= {"sb_proxinfopersec",  "10"};
cvar_t  sb_proxretries   = {"sb_proxretries",      "3"};
cvar_t  sb_proxtimeout   = {"sb_proxtimeout",   "1000"};
cvar_t  sb_mastertimeout = {"sb_mastertimeout", "1000"};
cvar_t  sb_masterretries = {"sb_masterretries",    "3"};
cvar_t  sb_nosockraw     = {"sb_nosockraw",        "0"}; // when enabled, forces "new ping" (udp qw query packet, multithreaded) to be used

cvar_t  sb_liveupdate    = {"sb_liveupdate",       "2"}; // not in menu

cvar_t  sb_sortservers   = {"sb_sortservers",     "32"}; // not in new menu
cvar_t  sb_sortplayers   = {"sb_sortplayers",     "92"}; // not in new menu
cvar_t  sb_sortsources   = {"sb_sortsources",      "3"}; // not in new menu

cvar_t  sb_autohide      = {"sb_autohide",         "1"}; // not in menu
cvar_t  sb_findroutes    = {"sb_findroutes",       "0"};
cvar_t  sb_ignore_proxy  = {"sb_ignore_proxy",     ""};

// filters
static void sb_trigger_resort(cvar_t* var, char* value, qbool* cancel)
{
	resort_servers = 1;
}

cvar_t  sb_hideempty     = {"sb_hideempty",        "1", 0, sb_trigger_resort };
cvar_t  sb_hidenotempty  = {"sb_hidenotempty",     "0", 0, sb_trigger_resort };
cvar_t  sb_hidefull      = {"sb_hidefull",         "0", 0, sb_trigger_resort };
cvar_t  sb_hidedead      = {"sb_hidedead",         "1", 0, sb_trigger_resort };
cvar_t  sb_hidehighping  = {"sb_hidehighping",     "0", 0, sb_trigger_resort };
cvar_t  sb_pinglimit     = {"sb_pinglimit",       "80", 0, sb_trigger_resort };
cvar_t  sb_showproxies   = {"sb_showproxies",      "0", 0, sb_trigger_resort };
cvar_t  sb_info_filter   = {"sb_info_filter",       "", 0, sb_trigger_resort };

cvar_t  sb_sourcevalidity  = {"sb_sourcevalidity", "30"}; // not in menu
cvar_t  sb_mastercache     = {"sb_mastercache",    "1"};  // not in menu
cvar_t  sb_autoupdate      = {"sb_autoupdate",     "1"};  // not in menu
cvar_t  sb_listcache       = {"sb_listcache",      "0"};

// servers table
server_data *servers[MAX_SERVERS];
int serversn;
int serversn_passed;

// all players table
player_host ** all_players = NULL;
int all_players_n = 0;

/// when 1, in the next frame in which the list is drawn also sorting will be done
int resort_servers = 1; 
int resort_sources = 1;
void Sort_Servers (void);

int testing_connection = 0;
int ping_phase = 0;
double ping_pos;
int abort_ping;

// allow background threads to fire triggers
int sb_queuedtriggers = 0;

// mouse and server list columns
static qbool mouse_in_header_row = false;
static int mouse_header_pos_y = 0;
static unsigned int mouse_hovered_column;

extern cvar_t cl_proxyaddr;

static SDL_mutex* serverlist_mutex = NULL;
sem_t serverinfo_semaphore;

typedef struct sb_column_t {
	const char *name;
	unsigned int width;
	cvar_t *showvar;
} sb_column_t;

sb_column_t sb_columns[] = {
	{ "name", COL_NAME, NULL },
	{ "address", COL_IP, &sb_showaddress },
	{ "png", COL_PING, &sb_showping },
	{ "gamedir", COL_GAMEDIR, &sb_showgamedir },
	{ "map", COL_MAP, &sb_showmap },
	{ "plyrs", COL_PLAYERS, &sb_showplayers },
	{ "fl", COL_FRAGLIMIT, &sb_showfraglimit },
	{ "tl", COL_TIMELIMIT, &sb_showtimelimit }
};

static const unsigned int sb_columns_size = sizeof(sb_columns) / sizeof(sb_column_t);

void Serverinfo_Stop(void);

void SB_ServerList_Lock(void)
{
	SDL_LockMutex(serverlist_mutex);
}

void SB_ServerList_Unlock(void)
{
	SDL_UnlockMutex(serverlist_mutex);
}

static qbool SB_Is_Selected_Proxy(const server_data *s)
{
	return (strstr(cl_proxyaddr.string, s->display.ip) != NULL);
}

// removes given proxy from the proxyaddr list
// if cl_proxyaddr "a:b:c" and s->ip = "b" then it changes cl_proxyaddr to "a:c"
static void SB_Proxy_Unselect(const server_data *s)
{
	const char *start = strstr(cl_proxyaddr.string, s->display.ip);
	const char *end;
	char *buf = (char *) Q_malloc(strlen(cl_proxyaddr.string) + 1);
	char *bufstart = buf;
	const char *cur;

	if (start == NULL) {
		Q_free(buf);
		return; // invalid call, proxy is not selected
	}

	for (cur = cl_proxyaddr.string; cur < start - 1;) {
		*buf++ = *cur++;
	}
	*buf = '\0';

	end = strchr(start, '@');
	if (end != NULL) {
		cur = end;
		if (*bufstart == '\0') cur++; // don't copy the '@' sign
		while (*cur) *buf++ = *cur++;
		*buf++ = '\0';
	}

	Cvar_Set(&cl_proxyaddr, bufstart);

	Q_free(bufstart);
}

// adds selected proxy to the end of the proxies list
static void SB_Proxy_Select(const server_data *s)
{
	size_t len = strlen(s->display.ip) + strlen(cl_proxyaddr.string) + 2;
	char *buf = (char *) Q_malloc(len);

	*buf = '\0';
	strlcat(buf, cl_proxyaddr.string, len);
	if (*buf) {
		strlcat(buf, "@", len);
	}
	strlcat(buf, s->display.ip, len);

	Cvar_Set(&cl_proxyaddr, buf);

	Q_free(buf);
}

static void SB_Select_QWfwd(server_data *s)
{
	if (SB_Is_Selected_Proxy(s)) {
		SB_Proxy_Unselect(s);
	}
	else {
		SB_Proxy_Select(s);
	}
	S_LocalSound ("misc/menu2.wav");
	Serverinfo_Stop();
}

static const char* SB_Source_Type_Name(sb_source_type_t type)
{
	switch (type) {
		case type_master: return "master";
		case type_file: return "file  ";
		case type_url: return "url   ";
		case type_dummy: return "dummy ";
		default:
				 Sys_Error("SB_Source_Type_Name(): Invalid sb_source_type_t type");
				 return "ERROR";
	}
}

static void SB_Browser_Hide(const server_data *s)
{
	if (sb_autohide.value)
	{
		if (sb_autohide.value > 1  ||  strcmp(s->display.gamedir, "qizmo")) {
			key_dest = key_game;
			m_state = m_none;
			M_Draw();
		}
	}
}

static void Join_Server (server_data *s)
{
	if (sb_findroutes.integer) {
		Cbuf_AddText("spectator 0\n");
		SB_PingTree_ConnectBestPath(&s->address);
	} else {
		Cbuf_AddText ("join ");
		Cbuf_AddText (s->display.ip);
		Cbuf_AddText ("\n");
	}

	SB_Browser_Hide(s);
}

static void Join_Server_Direct(server_data *s)
{
	Cvar_Set(&cl_proxyaddr, "");
	Cbuf_AddText ("join ");
	Cbuf_AddText (s->display.ip);
	Cbuf_AddText ("\n");
	SB_Browser_Hide(s);
}

static void Observe_Server (server_data *s)
{
	if (sb_findroutes.integer) {
		Cbuf_AddText("spectator 1\n");
		SB_PingTree_ConnectBestPath(&s->address);
	} else {
		Cbuf_AddText ("observe ");
		Cbuf_AddText (s->display.ip);
		Cbuf_AddText ("\n");
	}
	SB_Browser_Hide(s);
}

static void CopyServerToClipboard (server_data *s)
{
	char buf[2048];

	if (keydown[K_CTRL] || s->display.name[0] == 0)
		strlcpy (buf, s->display.ip, sizeof(buf));
	else
		snprintf (buf, sizeof (buf), "%s (%s)",
				s->display.name,
				s->display.ip);

	CopyToClipboard(buf);
}

static void PasteServerToConsole (server_data *s)
{
	char buf[2048];

	snprintf(buf, sizeof (buf), "%s (%s)",
			s->display.name,
			s->display.ip);

	Cbuf_AddText (keydown[K_CTRL] ? "say_team " :  "say ");
	Cbuf_AddText (buf);
	Cbuf_AddText ("\n");
}


//
// browser routines
//


server_data * Create_Server (char *ip)
{
	server_data *s;

	s = (server_data *) Q_malloc (sizeof(server_data));
	memset (s, 0, sizeof(server_data));

	s->ping = -1;

	if (!NET_StringToAdr (ip, &(s->address)))
	{
		Q_free(s);
		return NULL;
	}

	if (!strchr(ip, ':'))
		s->address.port = htons(27500);

	snprintf (s->display.ip, sizeof (s->display.ip), "%d.%d.%d.%d:%d",
			s->address.ip[0], s->address.ip[1], s->address.ip[2], s->address.ip[3],
			ntohs(s->address.port));

	return s;
}

server_data* Clone_Server(server_data* source)
{
	int i = 0;

	server_data* new_server = Create_Server2(source->address);

	new_server->bestping = source->bestping;
	memcpy(&new_server->display, &source->display, sizeof(source->display));
	new_server->keysn = source->keysn;
	for (i = 0; i < new_server->keysn; ++i) {
		new_server->keys[i] = Q_strdup(source->keys[i]);
		new_server->values[i] = Q_strdup(source->values[i]);
	}
	new_server->occupancy = source->occupancy;
	new_server->passed_filters = source->passed_filters;
	new_server->ping = source->ping;

	new_server->playersn = source->playersn;
	for (i = 0; i < sizeof(source->players) / sizeof(source->players[0]); ++i) {
		if (source->players[i]) {
			new_server->players[i] = Q_malloc(sizeof(playerinfo));

			memcpy(new_server->players[i], source->players[i], sizeof(playerinfo));
		}
	}

	new_server->qizmo = source->qizmo;
	new_server->qwfwd = source->qwfwd;
	new_server->spectatorsn = source->spectatorsn;
	new_server->support_teams = source->support_teams;

	return new_server;
}

server_data * Create_Server2 (netadr_t n)
{
	server_data *s;

	s = (server_data *) Q_malloc (sizeof (server_data));
	memset (s, 0, sizeof(server_data));

	memcpy (&(s->address), &n, sizeof (netadr_t));
	strlcpy (s->display.ip, NET_AdrToString(n), sizeof (s->display.ip));

	s->ping = -1;

	return s;
}

void Reset_Server (server_data *s)
{
	int i;

	for (i = 0; i < s->keysn; i++)
	{
		Q_free(s->keys[i]);
		if (s->values[i]) {
			// fixme: this was causing a crash so a check for not-null-ness was added
			Q_free(s->values[i]);
		}
	}

	s->keysn = 0;

	for (i = 0; i < s->playersn + s->spectatorsn; i++)
		Q_free(s->players[i]);

	s->playersn = 0;
	s->spectatorsn = 0;
	s->support_teams = false;

	rebuild_all_players = 1; // rebuild all-players list
}

void Delete_Server (server_data *s)
{
	Reset_Server(s);
	Q_free(s);
}


char confirm_text[64];
qbool confirmation;
void (*confirm_func)(void);

void SB_Confirmation (const char *text, void (*func)(void))
{
	strlcpy (confirm_text, text, sizeof (confirm_text));
	confirm_func = func;
	confirmation = 1;
}

void SB_Confirmation_Draw (void)
{
	int x, y, w, h;

#define CONFIRM_TEXT_DEFAULT "Are you sure? <y/n>"

	w = 32 + 8 * max (strlen (confirm_text), strlen (CONFIRM_TEXT_DEFAULT));
	h = 24;

	x = (vid.width - w) / 2;
	y = (vid.height - h) / 2;
	x = (x / 8) * 8;
	y = (y / 8) * 8;

	Draw_TextBox (x - 16, y - 16, w / 8 + 1, h / 8 + 2);

	UI_Print_Center (x, y, w, confirm_text, false);
	UI_Print_Center (x, y+16, w, CONFIRM_TEXT_DEFAULT, true);
}

void SB_Confirmation_Key (int key)
{
	switch (key)
	{
		case K_BACKSPACE:
		case K_ESCAPE:
		case 'n':
		case 'N':
			confirmation = 0;
			break;
		case 'y':
		case 'Y':
			confirmation = 0;
			confirm_func();
	}
}

/* Menu drawing */

int Servers_pos;
int Sources_pos;
int Players_pos;
int Options_pos;

server_data * show_serverinfo;
int serverinfo_pos;

int Servers_disp;   // server# at the top of the list
int Sources_disp;   // source# at the top of the list
int Players_disp;   // player# at the top of the list

void Serverinfo_Draw (void);
void Serverinfo_Players_Draw(int x, int y, int w, int h);
void Serverinfo_Rules_Draw(int x, int y, int w, int h);
void Serverinfo_Sources_Draw(int x, int y, int w, int h);
void Serverinfo_Key (int key);
void Serverinfo_Players_Key(int key);
void Serverinfo_Rules_Key(int key);
void Serverinfo_Sources_Key(int key);

//
// serverinfo
//

int sourcesn_updated = 0;

int Sources_Compare_Func (const void * p_s1, const void * p_s2)
{
	int reverse = 0;
	char *sort_string = sb_sortsources.string;
	const source_data *s1 = *((source_data **)p_s1);
	const source_data *s2 = *((source_data **)p_s2);

	if (show_serverinfo)
	{
		if (!(s1->last_update.wYear)  &&  s2->last_update.wYear)
			return 1;
		if (!s2->last_update.wYear  &&  s1->last_update.wYear)
			return -1;
		if (!s1->last_update.wYear  &&  !s2->last_update.wYear)
			return s1 - s2;
	}

	while (true)
	{
		int d;  // difference

		if (*sort_string == '-')
		{
			reverse = 1;
			sort_string++;
			continue;
		}

		switch (*sort_string++)
		{
			case '1':
				d = s1->type - s2->type; break;
			case '2':
				d = funcmp(s1->name, s2->name); break;
			case '3':
				d = s1->unique - s2->unique; break;
			default:
				d = s1 - s2;
		}

		if (d)
			return reverse ? -d : d;
	}
}
void Sort_Sources (void)
{
	int i;

	qsort (sources+1, sourcesn-1, sizeof(sources[0]), Sources_Compare_Func);

	sourcesn_updated = 1;

	for (i = 1; i < sourcesn; i++)
		if (sources[i]->last_update.wYear)
			sourcesn_updated ++;
}


int serverinfo_players_pos;
int serverinfo_sources_pos;
int serverinfo_sources_disp;
extern int autoupdate_serverinfo; // declared in EX_browser_net.c

void Serverinfo_Stop(void)
{
	show_serverinfo = NULL;
	autoupdate_serverinfo = 0;
	Sys_SemDestroy(&serverinfo_semaphore);
}

void Serverinfo_Start (server_data *s)
{
	if (show_serverinfo)
		Serverinfo_Stop();

	serverinfo_players_pos = 0;
	serverinfo_sources_pos = 0;

	autoupdate_serverinfo = 1;
	show_serverinfo = s;

	Sys_SemInit(&serverinfo_semaphore, 1, 1);

	// sort for eliminating ot-updated
	Sort_Sources();
	resort_sources = 1; // and mark for resort on next sources draw

	Start_Autoupdate(s);

	// testing connection
	if (testing_connection)
	{
		char buf[256];
		snprintf(buf, sizeof (buf), "%d.%d.%d.%d",
				show_serverinfo->address.ip[0],
				show_serverinfo->address.ip[1],
				show_serverinfo->address.ip[2],
				show_serverinfo->address.ip[3]);
		SB_Test_Init(buf);
		testing_connection = 1;
	}
}

void Serverinfo_Change (server_data *s)
{
	Alter_Autoupdate(s);
	show_serverinfo = s;

	// testing connection
	if (testing_connection)
	{
		char buf[256];
		snprintf (buf, sizeof (buf), "%d.%d.%d.%d",
				show_serverinfo->address.ip[0],
				show_serverinfo->address.ip[1],
				show_serverinfo->address.ip[2],
				show_serverinfo->address.ip[3]);
		SB_Test_Change(buf);
		testing_connection = 1;
	}
}

// --

qbool AddUnboundServer(char *addr)
{
	int i;
	server_data *s;
	qbool existed = false;

	if (sources[0]->serversn >= MAX_UNBOUND)
		return false;
	s = Create_Server(addr);
	if (s == NULL)
		return false;

	for (i=0; i < sources[0]->serversn; i++)
		if (!memcmp(&s->address, &sources[0]->servers[i]->address, sizeof(netadr_t)))
		{
			Q_free(s);
			s = sources[0]->servers[i];
			existed = true;
			break;
		}
	if (!existed)  // not found
	{
		sources[0]->servers[sources[0]->serversn] = s;
		(sources[0]->serversn) ++;
		rebuild_servers_list = true;
	}

	// start menu
	key_dest = key_menu;
	Mark_Source(sources[0]);
	Menu_MultiPlayer_SwitchToServersTab();
	GetServerPing(s);
	GetServerInfo(s);
	Serverinfo_Start(s);
	// M_Menu_ServerList_f();
	return true;
}

void AddServer_f(void)
{
	if (Cmd_Argc() != 2)
	{
		Com_Printf("Usage: addserver <addr>\n");
		return;
	}

	if (!AddUnboundServer(Cmd_Argv(1)))
	{
		if (sources[0]->serversn >= MAX_UNBOUND)
			Com_Printf("Error: maximum unbound servers number reached\n");
		else
			Com_Printf("Error: couldn't resolve\n");
	}
}

void SB_PingsDump_f(void)
{
	extern qbool useNewPing;
	int i;

	Com_Printf("// server ping dump\n// format: ip ping\n// protocol: %s\n", useNewPing ? "UDP" : "ICMP");
	for (i = 0; i < serversn; i++) {
		int ping = servers[i]->ping;

		if (ping >= 0 && ping < 999) {
			Com_Printf("%s %d\n", NET_AdrToString(servers[i]->address), ping);
		}
	}
}

//
// drawing routines
//

void Add_ColumnColored(int x, int y, int *pos, const char *t, int w, const char* color)
{
	char buf[128];
	if ((*pos) - w - 1  <=  5)
		return;

	snprintf (buf, sizeof(buf), "&c%s%s", color, t);

	(*pos) -= w;
	UI_Print_Center(x + (*pos)*8, y, 8*(w+5), buf, false);
	(*pos)--;
}

void Add_Column2(int x, int y, int *pos, const char *t, int w, int red)
{
	if ((*pos) - w - 1  <=  5)
		return;

	(*pos) -= w;
	UI_Print_Center(x + (*pos)*8, y, 8*w, t, red);
	(*pos)--;
}

void Draw_Server_Statusbar(int x, int y, int w, int h, server_data *s, int count, int total)
{
	int i;
	int d_gamedir, d_map;
	char buf[1024], line[1024];

	memset(line, '\x1E', w/8);
	line[w/8] = 0;
	line[w/8-1] = '\x1F';
	line[0] = '\x1D';
	if (total > 0)
	{
		snprintf(buf, sizeof (buf), "%d/%d", count+1, total);
		memset(line+w/8-3-strlen(buf), ' ', strlen(buf)+1);
	}
	UI_Print(x, y+h-24, line, false);
	if (total > 0)
		UI_Print(x+w-8*(3+strlen(buf))+4, y+h-24, buf, true);

	// line 1
	strlcpy (line, s->display.name[1] ? s->display.name : s->display.ip, sizeof (line));
	line[w/8] = 0;
	UI_Print_Center(x, y+h-16, w, line, false);

	// line 2
	if (searchtype)
	{
		int i;
		snprintf(line, sizeof (line), "search for: %-7s", searchstring);
		line[w/8] = 0;
		for (i=0; i < strlen(line); i++)
			line[i] ^= 128;
		UI_Print_Center(x, y+h-8, w, line, false);
	}
	else
	{
		d_gamedir = d_map = 1;
		if (ValueForKey(s, "map") == NULL)
			d_map = 0;
		if (ValueForKey(s, "*gamedir") == NULL)
			d_gamedir = 0;

		line[0] = 0;

		if (d_gamedir)
		{
			memset(buf, 0, 10);
			strlcpy(buf, ValueForKey(s, "*gamedir"), sizeof(buf));
			buf[8] = 0;
			strlcat (line, buf, sizeof (line));
			strlcat (line, "\xa0 ", sizeof (line));
		}

		if (d_map)
		{
			memset(buf, 0, 10);
			strlcpy(buf, ValueForKey(s, "map"), sizeof(buf));
			buf[8] = 0;
			strlcat (line, buf, sizeof (line));
			strlcat (line, "\xa0 ", sizeof (line));
		}

		//if (d_players)
		{
			char buf[10], *max;
			max =  ValueForKey(s, "maxclients");
			snprintf(buf, sizeof(buf), "%d/%s", s->playersn, max==NULL ? "??" : max);
			strlcat (line, buf, sizeof (line));
			max =  ValueForKey(s, "maxspectators");
			snprintf(buf, sizeof(buf), "-%d/%s", s->spectatorsn, max==NULL ? "??" : max);
			strlcat (line, buf, sizeof(line));
		}

		if (ValueForKey(s, "status") == NULL)
		{
			char *dm, *fl, *tl;
			char buf[200];
			dm = ValueForKey(s, "deathmatch");
			fl = ValueForKey(s, "fraglimit");
			tl = ValueForKey(s, "timelimit");

			if (dm  &&  strlen(line) + 7 <= w/8)
			{
				snprintf(buf, sizeof(buf), "\xa0 dmm%s", dm);
				strlcat(line, buf, sizeof(line));
			}

			if (fl  &&  strlen(line) + 8 <= w/8)
			{
				snprintf(buf, sizeof(buf), "\xa0 fl:%s", fl);
				strlcat(line, buf, sizeof(line));
			}

			if (tl  &&  strlen(line) + 7 <= w/8)
			{
				snprintf(buf, sizeof(buf), "\xa0 tl:%s", tl);
				strlcat(line, buf, sizeof(line));
			}
		}
		else
		{
			char buf[200];
			snprintf(buf, sizeof(buf), "\xa0 %s", ValueForKey(s, "status"));
			strlcat(line, buf, sizeof(line));
		}

		// draw line
		line[w/8] = 0;
		UI_Print_Center(x, y+h-8, w, line, false);
		// and dots  --  shifted by 4 pixels
		for (i=0; i < strlen(line); i++)
			line[i] = (line[i]=='\xa0' ? '\x85' : ' ');
		UI_Print_Center(x+4, y+h-8, w, line, false);
	}
}

void Add_Server_Draw(void)
{
	int x, y, w, h;
	w = 176;
	h = 56;
	x = (vid.width - w)/2;
	y = (vid.height - h)/2;
	x = (x/8) * 8;
	y = (y/8) * 8;

	Draw_TextBox (x-16, y-16, w/8+1, h/8+2);

	x-=4;
	y-=4;
	w+=8;
	h+=8;

	UI_Print_Center(x, y+4, w, "Create new server", true);

	UI_Print(x+4, y + 20, "Address:", newserver_pos==0);
	CEditBox_Draw(&edit1, x+70, y+20, newserver_pos==0);

	UI_Print_Center(x+4, y+40, w, "accept", newserver_pos==1);
	if (newserver_pos == 1)
		Draw_Character (x+59, y+40, 13);

	UI_Print_Center(x+4, y+50, w, "cancel", newserver_pos==2);
	if (newserver_pos == 2)
		Draw_Character (x+59, y+50, 13);
}

void SB_Servers_OnShow (void)
{
	static qbool updated = false;

	if (sb_autoupdate.value && !updated) {

		GetServerPingsAndInfos(true);
		updated = true;
	}

	resort_servers = 1;
}

static const char *SB_Ping_Color(int ping)
{
	double frame_duration = 1000.0/77.0;
	int frames = ping / frame_duration;

	switch (frames) {
		case 0: return "1f0"; // 13
		case 1: return "3d0"; // 26
		case 2: return "790"; // 39
		case 3: return "880"; // 51
		case 4: return "a60"; // 65
		case 5: 
		case 6: 
		case 7: 
		case 8:
		case 9: return "d30"; // 70-116
		default: return "f00"; // 116+
	}
}

static unsigned int SB_Servers_Hovered_Column(int w)
{
	int w_from = w, w_to = w;
	int col;

	for (col = sb_columns_size - 1; col > 0; col--) {
		if (sb_columns[col].showvar->integer) {
			w_to = w_from;
			w_from -= sb_columns[col].width * LETTERWIDTH + LETTERWIDTH;
			if (w_from <= mouse_header_pos_y && mouse_header_pos_y < w_to) {
				return col;
			}
		}
	}
	return 0;
}

// returns the horizontal offset of the second shown column in characters
int SB_Servers_Draw_ColumnHeaders(int x, int y, int w)
{
	int pos = w/8;
	char line[1024];
	unsigned int colidx;
	qbool hovered;

	mouse_hovered_column = SB_Servers_Hovered_Column(w);
	memset(line, ' ', pos);
	line[pos] = 0;

	UI_DrawColoredAlphaBox(x, y, w, 8, RGBA_TO_COLOR(10, 10, 10, 200));

	for (colidx = sb_columns_size - 1; colidx > 0; colidx--) {
		sb_column_t *col = &sb_columns[colidx];
		hovered = mouse_in_header_row && mouse_hovered_column == colidx;

		if (col->showvar->integer) {
			if (mouse_in_header_row && hovered) {
				UI_DrawColoredAlphaBox(x + pos * LETTERWIDTH - col->width * LETTERWIDTH - LETTERWIDTH,
						y, col->width * LETTERWIDTH + LETTERWIDTH, 8, RGBA_TO_COLOR(30, 30, 30, 200));
			}
			Add_Column2(x, y, &pos, col->name, col->width, !hovered);
		}
	}
	// name is always displayed
	hovered = mouse_in_header_row && mouse_hovered_column == colidx;
	if (hovered) {
		UI_DrawColoredAlphaBox(x, y, pos * LETTERWIDTH + LETTERWIDTH, 8, RGBA_TO_COLOR(30, 30, 30, 200));
	}
	UI_Print(x, y, "name", !(mouse_in_header_row && mouse_hovered_column == 0));

	return pos;
}

void SB_Servers_Draw (int x, int y, int w, int h)
{
	char line[1024];
	int i, pos, listsize;

	if (updating_sources) {
		UI_Print_Center(x, y + 8, w, "Updating, please wait", false);
		return;
	}

	if (rebuild_servers_list)
		Rebuild_Servers_List();

	if (searchtype != search_server  ||  searchtime + SEARCH_TIME < cls.realtime)
		searchtype = search_none;

	if (resort_servers)
	{
		Sort_Servers();
		resort_servers = 0;
	}

	if (serversn_passed > 0)
	{
		SB_ServerList_Lock();

		Servers_pos = max(Servers_pos, 0);
		Servers_pos = min(Servers_pos, serversn_passed-1);

		listsize = (int)(h/8) - (sb_status.value ? 3 : 0);

		listsize--;     // column titles

		pos = SB_Servers_Draw_ColumnHeaders(x, y, w);

		if (Servers_disp < 0)
			Servers_disp = 0;
		if (Servers_pos > Servers_disp + listsize - 1)
			Servers_disp = Servers_pos - listsize + 1;
		if (Servers_disp > serversn_passed - listsize)
			Servers_disp = max(serversn_passed - listsize, 0);
		if (Servers_pos < Servers_disp)
			Servers_disp = Servers_pos;

		if (updating_sources) {
			SB_ServerList_Unlock();
			return;
		}

		for (i = 0; i < listsize; i++)
		{
			int servnum = Servers_disp + i;
			if (servnum >= serversn_passed)
				break;

			if (servnum==Servers_pos) {
				UI_DrawGrayBox(x, y+8*(i+1), w, 8);
				UI_DrawCharacter(x + 8*pos, y+8*(i+1), FLASHINGARROW());
			} else if (servers[servnum]->qizmo) {
				UI_DrawColoredAlphaBox(x, y+8*(i+1), w, 8, RGBA_TO_COLOR(25, 25, 75, 255));
			} else if (servers[servnum]->qwfwd) {
				if (SB_Is_Selected_Proxy(servers[servnum])) {
					UI_DrawColoredAlphaBox(x, y+8*(i+1), w, 8, RGBA_TO_COLOR(25, 120, 40, 255));
				} else {
					UI_DrawColoredAlphaBox(x, y+8*(i+1), w, 8, RGBA_TO_COLOR(25, 50, 25, 255));
				}
			} else if (servnum % 2) {
				UI_DrawColoredAlphaBox(x, y+8*(i+1), w, 8, RGBA_TO_COLOR(25, 25, 25, 125));
			} else {
				UI_DrawColoredAlphaBox(x, y+8*(i+1), w, 8, RGBA_TO_COLOR(50, 50, 50, 125));
			}

			// Display server
			pos = w/8;
			memset(line, ' ', 1000);

			if (sb_showtimelimit.value)
				Add_Column2(x, y+8*(i+1), &pos, servers[servnum]->display.timelimit, COL_TIMELIMIT, servnum==Servers_pos);
			if (sb_showfraglimit.value)
				Add_Column2(x, y+8*(i+1), &pos, servers[servnum]->display.fraglimit, COL_FRAGLIMIT, servnum==Servers_pos);
			if (sb_showplayers.value)
				Add_ColumnColored(x, y+8*(i+1), &pos, servers[servnum]->display.players, COL_PLAYERS, occupancy_colors[servers[servnum]->occupancy]);

			if (sb_showmap.value)
				Add_Column2(x, y+8*(i+1), &pos, servers[servnum]->display.map, COL_MAP, servnum==Servers_pos);
			if (sb_showgamedir.value)
				Add_Column2(x, y+8*(i+1), &pos, servers[servnum]->display.gamedir, COL_GAMEDIR, servnum==Servers_pos);
			if (sb_showping.value) {
				const char *ping = (servers[servnum]->bestping >= 0) ? servers[servnum]->display.bestping : servers[servnum]->display.ping;
				const char *color = SB_Ping_Color((servers[servnum]->bestping >= 0) ? servers[servnum]->bestping : servers[servnum]->ping);
				Add_ColumnColored(x, y+8*(i+1), &pos, ping, COL_PING, color);
			}
			if (sb_showaddress.value)
				Add_Column2(x, y+8*(i+1), &pos, servers[servnum]->display.ip, COL_IP, servnum==Servers_pos);

			// 'name' column
			if (servers[servnum]->qwfwd) {
				if (servers[servnum]->display.name[0]) {
					snprintf(line, sizeof(line), "proxy %s", servers[servnum]->display.name);
				}
				else {
					snprintf(line, sizeof(line), "proxy %s", servers[servnum]->display.ip);
				}
			}
			else if (servers[servnum]->display.name[0]) {
				snprintf(line, sizeof(line), "%s", servers[servnum]->display.name);
			}
			else {
				snprintf(line, sizeof(line), "%s", servers[servnum]->display.ip);
			}

			// display only as much as fits into the column
			line[min(pos, sizeof(line)-1)] = '\0';

			UI_Print(x, y+8*(i+1), line, servnum==Servers_pos);
		}


		//
		// status line
		//
		if (sb_status.value  &&  serversn_passed > 0)
		{
			// Semaphore lock
			if(show_serverinfo)
			{
				Sys_SemWait(&serverinfo_semaphore);
				Draw_Server_Statusbar(x, y, w, h, servers[Servers_pos], Servers_pos, serversn_passed);
				Sys_SemPost(&serverinfo_semaphore);
			}
			else
			{
				Draw_Server_Statusbar(x, y, w, h, servers[Servers_pos], Servers_pos, serversn_passed);
			}
		}
		SB_ServerList_Unlock();
	} else if (!adding_server) {
		UI_Print_Center(x, y+8, w, "No servers filtered", false);
		UI_Print_Center(x, y+24, w, "Press [space] to refresh the list", true);
		UI_Print_Center(x, y+40, w, "Mark some sources on the next tab", false);
		UI_Print_Center(x, y+48, w, "or press [Insert] to add a server", false);

		if (strlen(searchstring)) {
			char line[1024];
			snprintf(line, sizeof (line), "search for: %-7s", searchstring);
			UI_Print_Center(x, y+h-8, w, line, true);
		}
	}

	// adding server
	if (adding_server)
		Add_Server_Draw();
}

void PingPhase_Draw(void)
{
	int x, y, w, h;
	w = 144;
	h = 24;
	x = (vid.width - w)/2;
	y = (vid.height - h)/2;
	x = (x/8) * 8;
	y = (y/8) * 8;

	Draw_TextBox (x-16, y-16, w/8+1, h/8+2);

	UI_Print_Center(x, y, w,
			ping_phase==1 ? "Pinging Servers" : "Getting Infos",
			false);
	if (abort_ping)
		UI_Print_Center(x, y+16, w, "cancelled", true);
	else
	{
		UI_Print(x, y+16,
				"\x80\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x82",
				false);
		UI_DrawCharacter(x+8+(int)(ping_pos*15*8), y+16, '\x83');
	}
}

void UpdatingSources_Draw(void)
{
	int x, y, w, h;
	w = 144;
	h = 24;
	x = (vid.width - w)/2;
	y = (vid.height - h)/2;
	x = (x/8) * 8;
	y = (y/8) * 8;

	Draw_TextBox (x-16, y-16, w/8+1, h/8+2);

	UI_Print_Center(x, y, w, "Updating Sources", false);

	if (abort_ping)
		UI_Print_Center(x, y+16, w, "cancelled", true);
	else
	{
		UI_Print(x, y+16,
				"\x80\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x81\x82",
				false);
		UI_DrawCharacter(x+8+(int)(ping_pos*15*8), y+16, '\x83');
	}
}

void Serverinfo_Help_Draw(int x, int y, int wPixels)
{
	int wLetters = wPixels / 8;

	if (vid.conheight < 216 || vid.conwidth < 384) {
		return;
	}

	// make it wider
	x -= LETTERWIDTH * 4;
	wLetters += 8;

	Draw_TextBox (x, y, wLetters, sb_findroutes.integer > 0 ? 4 : 3);
	x += LETTERWIDTH * 2;
	y += LETTERWIDTH;
	UI_Print(x, y,  "\xDBj\xDD join \xDBo\xDD observe \xDBq\xDD QuakeTV obs.", false);
	y += LETTERWIDTH;
	UI_Print(x, y, "\xDB" "c\xDD copy to clipboard \xDBv\xDD say in chat", false);
	y += LETTERWIDTH;
	UI_Print(x, y, "\xDB" "ctrl+c\xDD copy addr. \xDB" "ctrl+v\xDD say team", false);

	if (sb_findroutes.integer > 0) {
		int pathlen = SB_PingTree_GetPathLen(&show_serverinfo->address);
		y += LETTERWIDTH;
		if (pathlen < 0) {
			UI_Print(x, y, "Route: No route found", false);
		}
		else if (pathlen == 0) {
			UI_Print(x, y, "Route: Direct route is best", false);
		}
		else if (pathlen == 1) {
			UI_Print(x, y, "Route: 1 hop " "\xDB" "n\xDD direct connect", false);
		}
		else if (pathlen > 1) {
			char tmp[64];
			snprintf(&tmp[0], sizeof(tmp), "Route: %d hops, " "\xDB" "n\xDD direct connect", pathlen);
			UI_Print(x, y, tmp, false);
		}
	}
}

void Serverinfo_Draw (void)
{
	extern int server_during_update;
	char buf[512];

	int x, y, w, h;
	w = 200 + 40;
	h = 112;

	if (vid.height >= 200 + 40)
		h += 8*5;

	x = (vid.width - w)/2;
	y = (vid.height - h)/2;

	x = (x/8) * 8;
	y = (y/8) * 8;

	Draw_TextBox (x-16, y-16, w/8+1, h/8+2);

	x-=4;
	y-=4;
	w+=8;
	h+=8;

	while (server_during_update)
		Sys_MSleep(5);

	strlcpy(buf, show_serverinfo->display.name, sizeof(buf));
	buf[w/8] = 0;
	UI_Print_Center(x, y, w, buf, false);
	strlcpy(buf, show_serverinfo->display.ip, sizeof(buf));
	buf[w/8] = 0;
	UI_Print_Center(x, y+10, w, buf, false);

	strlcpy(buf, " players serverinfo sources ", sizeof(buf));
	if (serverinfo_pos == 0)
		memcpy (buf, "\x10\xF0\xEC\xE1\xF9\xE5\xF2\xF3\x11", 9);
	if (serverinfo_pos == 1)
		memcpy (buf + 8, "\x10\xF3\xE5\xF2\xF6\xE5\xF2\xE9\xEE\xE6\xEF\x11", 12); // FIXME: non-ascii chars
	if (serverinfo_pos == 2)
		memcpy (buf + 19, "\x10\xF3\xEF\xF5\xF2\xE3\xE5\xF3\x11", 9); // FIXME: non-ascii chars

	UI_Print_Center(x, y+24, w, buf, false);

	memset(buf, '\x1E', w/8);
	buf[w/8] = 0;
	buf[w/8-1] = '\x1F';
	buf[0] = '\x1D';
	UI_Print(x, y+32, buf, false);

	if (testing_connection)
		h -= 5*8;

	Sys_SemWait(&serverinfo_semaphore);
	switch (serverinfo_pos)
	{
		case 0: // players
			Serverinfo_Players_Draw(x, y+40, w, h-40); break;
		case 1: // serverinfo / rules
			Serverinfo_Rules_Draw(x, y+40, w, h-40); break;
		case 2: // sources
			Serverinfo_Sources_Draw(x, y+40, w, h-40); break;
		default:
			;
	}
	Sys_SemPost(&serverinfo_semaphore);

	Serverinfo_Help_Draw(x - 16, y + h + LETTERWIDTH, w);

	if (testing_connection)
		SB_Test_Frame();
}

void Serverinfo_Players_Draw(int x, int y, int w, int h)
{
	server_data *s = show_serverinfo; // shortcut
	char *tp = (ValueForKey(s, "teamplay") ? ValueForKey(s, "teamplay") : ""); // tp at least "" not NULL
	qbool support_tp = s->support_teams && strcmp(tp, "0"); // is server support team info per player and teamplay != 0

	int i;
	int listsize;
	int match = 0;
	int top1=0, bottom1=0, frags1=0;
	int top2=0, bottom2=0, frags2=0;
	char *t1 = "", *t2 = "";
	int qizmo = 0;

	if (s == NULL  ||  s->playersn + s->spectatorsn <= 0)
		return;

	if (!strcmp(s->display.gamedir, "qizmo"))
		qizmo = 1;

	// check if this is a teamplay (2 teams) match
	if (!qizmo && s->playersn > 2 && strcmp(tp, "0")) // at least 3 players
	{
		top1 = bottom1 = top2 = bottom2 = -1;
		frags1 = frags2 = 0;
		match = 1;

		for (i = 0; i < s->playersn + s->spectatorsn; i++)
		{
			if (s->players[i]->spec)
				continue; // ignore spec

			if (top1 < 0) // ok, we found member from first team, save colors/team
			{
				top1	= s->players[i]->top;
				bottom1	= s->players[i]->bottom;
				t1		= s->players[i]->team;
			}

			// we now can sort teams by two way: colors, and actual teams

			if (    ( support_tp && !strncmp(t1, s->players[i]->team, sizeof(s->players[0]->team) - 1)) // teams matched
					|| (!support_tp && s->players[i]->top == top1 && s->players[i]->bottom == bottom1) // colors matched
			   )
			{
				frags1 += s->players[i]->frags;
				continue;
			}

			if (top2 < 0) // ok, we found member from second team, save colors/team
			{
				top2	= s->players[i]->top;
				bottom2	= s->players[i]->bottom;
				t2		= s->players[i]->team;
			}

			if (    ( support_tp && !strncmp(t2, s->players[i]->team, sizeof(s->players[0]->team) - 1)) // teams matched
					|| (!support_tp && s->players[i]->top == top2 && s->players[i]->bottom == bottom2) // colors matched
			   )
			{
				frags2 += s->players[i]->frags;
				continue;
			}

			// found member from third team, we does't support such case
			match = 0;
			break;
		}

		if (top1 < 0 || top2 < 0)
			match = 0; // we does't have two teams

		if (match  &&  frags2 > frags1)
		{
			int swap;
			swap = frags2;   frags2  = frags1;   frags1  = swap;
			swap = top2;     top2    = top1;     top1    = swap;
			swap = bottom2;  bottom2 = bottom1;  bottom1 = swap;
		}
	}

	listsize = h/8-1 - match;

	if (serverinfo_players_pos > s->playersn + s->spectatorsn - listsize)
		serverinfo_players_pos = s->playersn + s->spectatorsn - listsize;
	if (serverinfo_players_pos < 0)
		serverinfo_players_pos = 0;

	UI_Print(x, y, support_tp ? "png tm frgs team name" : "png tm frgs name", true);
	for (i=0; i < listsize; i++)
	{
		char buf[100], fragsbuf[100] = {0};
		int top, bottom;

		if (serverinfo_players_pos + i >= s->playersn + s->spectatorsn)
			break;

		if (!s->players[serverinfo_players_pos+i]->spec) {
			int frags_tmp = bound(-99, s->players[serverinfo_players_pos+i]->frags, 9999);
			snprintf(fragsbuf, sizeof(fragsbuf), "%3d%s", frags_tmp, frags_tmp < 1000 ? " " : ""); // "centering" frags as much as possible
		}

		if (support_tp)
			snprintf(buf, sizeof(buf), "%3d %2d %4.4s %4.4s %s", // frags column fixed to 4 symbols
					max(min(s->players[serverinfo_players_pos+i]->ping, 999), 0),
					max(min(s->players[serverinfo_players_pos+i]->time, 99), 0),
					s->players[serverinfo_players_pos+i]->spec ? "spec" : fragsbuf,
					s->players[serverinfo_players_pos+i]->team,
					s->players[serverinfo_players_pos+i]->name);
		else
			snprintf(buf, sizeof(buf), "%3d %2d %4.4s %s", // frags column fixed to 4 symbols
					max(min(s->players[serverinfo_players_pos+i]->ping, 999), 0),
					max(min(s->players[serverinfo_players_pos+i]->time, 99), 0),
					s->players[serverinfo_players_pos+i]->spec ? "spec" : fragsbuf,
					s->players[serverinfo_players_pos+i]->name);

		buf[w/8] = 0;

		if (!s->players[serverinfo_players_pos+i]->spec) {
			top		= s->players[serverinfo_players_pos+i]->top;
			bottom	= s->players[serverinfo_players_pos+i]->bottom;

			if (support_tp && match) // force players have same colors in same team, in such case
			{
				if (!strncmp(t1, s->players[serverinfo_players_pos+i]->team, sizeof(s->players[0]->team) - 1))
				{
					top		= top1;
					bottom	= bottom1;
				}
				else if (!strncmp(t2, s->players[serverinfo_players_pos+i]->team, sizeof(s->players[0]->team) - 1))
				{
					top		= top2;
					bottom	= bottom2;
				}
			}

			Draw_Fill (x+7*8-2, y+i*8+8   +1, 34, 4, top);
			Draw_Fill (x+7*8-2, y+i*8+8+4 +1, 34, 3, bottom);
		}

		UI_Print(x, y+i*8+8, buf, false);
	}

	if (match)
	{
		char buf[100];
		Draw_Fill (x+13*8, y+listsize*8+8   +1, 40, 4, top1);
		Draw_Fill (x+13*8, y+listsize*8+8+4 +1, 40, 4, bottom1);
		Draw_Fill (x+21*8, y+listsize*8+8   +1, 40, 4, top2);
		Draw_Fill (x+21*8, y+listsize*8+8+4 +1, 40, 4, bottom2);

		snprintf(buf, sizeof (buf), "      score:  %3d  -  %3d", frags1, frags2);
		UI_Print(x, y+listsize*8+8, buf, false);
	}
}

int serverinfo_rules_pos = 0;

void Serverinfo_Rules_Draw(int x, int y, int w, int h)
{
	int i;
	int listsize = h/8;
	server_data *s = show_serverinfo;

	if (serverinfo_rules_pos > s->keysn - listsize)
		serverinfo_rules_pos = s->keysn - listsize;
	if (serverinfo_rules_pos < 0)
		serverinfo_rules_pos = 0;

	for (i=0; i < listsize; i++)
	{
		char buf[128];

		if (serverinfo_rules_pos + i >= s->keysn)
			break;
		snprintf(buf, sizeof (buf), "%-13.13s %-*s",
				s->keys[serverinfo_rules_pos+i],
				w/8-1-13,
				s->values[serverinfo_rules_pos+i]);

		buf[w/8] = 0;

		UI_Print(x, y+i*8, buf, false);
	}
}

int IsInSource(source_data *source, server_data *serv)
{
	int i;
	for (i=0; i < source->serversn; i++)
		if (!memcmp(&source->servers[i]->address, &serv->address, sizeof(netadr_t)))
			return i+1;
	return false;
}

void Serverinfo_Sources_Draw(int x, int y, int w, int h)
{
	int i;
	int listsize;

	server_data *s = show_serverinfo;

	if (s == NULL  ||  sourcesn_updated <= 0)
		return;

	listsize = h/8-1;

	if (serverinfo_sources_pos > serverinfo_sources_disp + listsize - 1)
		serverinfo_sources_disp = serverinfo_sources_pos - listsize + 1;
	if (serverinfo_sources_disp > sourcesn_updated - listsize)
		serverinfo_sources_disp = max(sourcesn_updated - listsize, 0);
	if (serverinfo_sources_pos < serverinfo_sources_disp)
		serverinfo_sources_disp = serverinfo_sources_pos;

	UI_Print(x, y, " type    name", true);
	for (i=0; i < listsize; i++)
	{
		char buf[128], buf2[16];

		if (serverinfo_sources_disp + i >= sourcesn_updated)
			break;

		strlcpy(buf2, SB_Source_Type_Name(sources[serverinfo_sources_disp+i]->type), sizeof (buf2));

		snprintf(buf, sizeof (buf), "%s   %s", buf2, sources[serverinfo_sources_disp+i]->name);
		buf[w/8] = 0;

		UI_Print(x, y+i*8+8, buf,
				IsInSource(sources[serverinfo_sources_disp+i], s));

		if (serverinfo_sources_pos == serverinfo_sources_disp+i)
			UI_DrawCharacter(x+8*7, y+i*8+8, '\x8D');
	}
}

const char *SB_Source_Type_Location_Name(sb_source_type_t type)
{
	switch (type) {
		case type_master: return "addr";
		case type_file: return "file";
		case type_url: return "url";
		case type_dummy: return "dummy";
		default:
				 Sys_Error("SB_Source_Type_Location_Name(): Invalid sb_source_type_t type");
				 return "ERROR";
	}
}

void Add_Source_Draw(void)
{
	int x, y, w, h;
	w = 176;
	h = 72;
	x = (vid.width - w)/2;
	y = (vid.height - h)/2;
	x = (x/8) * 8;
	y = (y/8) * 8;

	Draw_TextBox (x-16, y-16, w/8+1, h/8+2);

	x-=4;
	y-=4;
	w+=8;
	h+=8;

	UI_Print_Center(x, y+4, w, "Create new source", true);

	UI_Print(x+4, y + 20, "type", newsource_pos==0);
	UI_Print(x+54, y + 20, SB_Source_Type_Name(newsource_type), newsource_pos==0);
	if (newsource_pos == 0)
		Draw_Character (x+42, y+20, 13);

	UI_Print(x+4, y + 30, "name", newsource_pos==1);
	CEditBox_Draw(&edit1, x+54, y+30, newsource_pos==1);
	if (newsource_pos == 1)
		Draw_Character (x+42, y+30, 13);

	UI_Print(x+4, y + 40, SB_Source_Type_Location_Name(newsource_type), newsource_pos==2);
	CEditBox_Draw(&edit2, x+54, y+40, newsource_pos==2);
	if (newsource_pos == 2)
		Draw_Character (x+42, y+40, 13);

	UI_Print_Center(x+4, y+60, w, "accept", newsource_pos==3);
	if (newsource_pos == 3)
		Draw_Character (x+59, y+60, 13);

	UI_Print_Center(x+4, y+70, w, "cancel", newsource_pos==4);
	if (newsource_pos == 4)
		Draw_Character (x+59, y+70, 13);
}


void SB_Sources_Draw (int x, int y, int w, int h)
{
	int i, listsize;
	char line[1024];
	SYSTEMTIME curtime;

	if (sourcesn <= 0)
		return;

	GetLocalTime(&curtime);

	if (resort_sources)
	{
		Sort_Sources();
		resort_sources = 0;
	}

	listsize = (int)(h/8) - (sb_status.value ? 3 : 0);

	UI_Print_Center(x, y, w, " type   name             servs updated", true);

	listsize--;     // subtract one line (column titles)

	if (Sources_pos > Sources_disp + listsize - 1)
		Sources_disp = Sources_pos - listsize + 1;
	if (Sources_disp > sourcesn - listsize)
		Sources_disp = max(sourcesn - listsize, 0);
	if (Sources_pos < Sources_disp)
		Sources_disp = Sources_pos;

	for (i = 0; i < listsize; i++)
	{
		char type[10], time[10];
		source_data *s = sources[Sources_disp + i];

		int sourcenum = Sources_disp + i;
		if (sourcenum >= sourcesn)
			break;

		strlcpy(type, SB_Source_Type_Name(s->type), sizeof (type));

		if (s->type == type_dummy)
			strlcpy (time, " n/a ", sizeof (time));
		else
			if (s->last_update.wYear)
			{
				if (s->last_update.wYear != curtime.wYear)
					snprintf(time, sizeof (time), "%4dy", s->last_update.wYear);
				else if (s->last_update.wMonth != curtime.wMonth ||
						s->last_update.wDay != curtime.wDay)
					snprintf(time, sizeof (time),  "%02d-%02d", s->last_update.wMonth, s->last_update.wDay);
				else
					snprintf(time, sizeof (time),  "%2d:%02d",
							s->last_update.wHour,
							s->last_update.wMinute);
			}
			else
				strlcpy (time, "never", sizeof (time));

		snprintf(line, sizeof (line), "%s %c%-17.17s %4d  %s ", type,
				sourcenum==Sources_pos ? 141 : ' ',
				s->name, s->serversn, time);

		UI_Print_Center(x, y+8*(i+1), w, line, s->checked);
	}

	//
	// status line
	//
	if (sb_status.value)
	{
		int total_servers = 0;
		int sel_servers = 0, sel_sources = 0;

		memset(line, '\x1E', w/8);
		line[w/8] = 0;
		line[w/8-1] = '\x1F';
		line[0] = '\x1D';
		UI_Print(x, y+h-24, line, false);

		// get stats
		for (i=0; i < sourcesn; i++)
		{
			total_servers += sources[i]->serversn;
			if (sources[i]->checked)
			{
				sel_servers += sources[i]->serversn;
				sel_sources ++;
			}
		}

		snprintf(line, sizeof (line), "%d sources selected (%d servers)", sel_sources, sel_servers);
		UI_Print_Center(x, y+h-16, w, line, false);

		snprintf(line, sizeof (line), "of %d total (%d servers)", sourcesn, total_servers);
		UI_Print_Center(x, y+h-8, w, line, false);
	}

	// adding source
	if (adding_source)
		Add_Source_Draw();
}


void SB_Players_Draw (int x, int y, int w, int h)
{
	int i, listsize;
	char line[2048];
	int hw = min(w/8 - 16, 60) -4; // hostname width (in chars)

	if (ping_phase)
		return;

	if (searchtype != search_player  ||  searchtime + SEARCH_TIME < cls.realtime)
		searchtype = search_none;

	if (rebuild_servers_list)
		Rebuild_Servers_List();

	if (rebuild_all_players  &&  show_serverinfo == NULL)
		Rebuild_All_Players();

	if (resort_all_players)
	{
		Sort_All_Players();
		resort_all_players = 0;
	}

	if (all_players_n <= 0)
		return;

	Players_pos = max(Players_pos, 0);
	Players_pos = min(Players_pos, all_players_n-1);

	listsize = (int)(h/8) - (sb_status.value ? 3 : 0);

	//UI_Print_Center(x, y, w, "name            server              ", true);
	snprintf(line, sizeof (line), "name            %-*s png", hw, "server");
	UI_Print_Center(x, y, w, line, true);

	listsize--;     // subtract one line (column titles)

	if (Players_pos > Players_disp + listsize - 1)
		Players_disp = Players_pos - listsize + 1;
	if (Players_disp > all_players_n - listsize)
		Players_disp = max(all_players_n - listsize, 0);
	if (Players_pos < Players_disp)
		Players_disp = Players_pos;

	for (i = 0; i < listsize; i++)
	{
		player_host *s = all_players[Players_disp + i];

		int num = Players_disp + i;
		if (num >= all_players_n)
			break;

		snprintf(line, sizeof (line), "%-15s%c%-*.*s %3s",
				s->name, num==Players_pos ? 141 : ' ',
				hw, hw, strlen(s->serv->display.name) > 0 ? s->serv->display.name : s->serv->display.ip, s->serv->display.ping);

		UI_Print_Center(x, y+8*(i+1), w, line, num == Players_pos);
	}

	//
	// status line
	//
	if (sb_status.value  &&  all_players_n > 0)
		Draw_Server_Statusbar(x, y, w, h, all_players[Players_pos]->serv, Players_pos, all_players_n);
}

void SB_SourceUnmarkAll(void)
{
	int i;
	for (i=0; i < sourcesn; i++)
		Unmark_Source(sources[i]);
}

void SB_SourceMark(void)
{
	int i;

	if (Cmd_Argc() != 2)
	{
		Com_Printf("usage:  sb_sourcemark <source-name>\n");
		return;
	}

	for (i=0; i < sourcesn; i++)
		if (!strcmp(sources[i]->name, Cmd_Argv(1)))
		{
			Mark_Source(sources[i]);
			break;
		}
}

void MarkDefaultSources(void) {
	int i;
	for (i=0; i < sourcesn; i++)
	{
		if (!strcmp(sources[i]->name, "id limbo") || 
				!strcmp(sources[i]->name, "Global") ||
				!strcmp(sources[i]->name, "QuakeServers.net") ||
				!strcmp(sources[i]->name, "Asgaard")
		   )
			sources[i]->checked = 1;
	}
}


void WriteSourcesConfiguration(FILE *f)
{
	int i;
	fprintf(f, "sb_sourceunmarkall\n");
	for (i=0; i < sourcesn; i++)
		if (sources[i]->checked)
			fprintf(f, "sb_sourcemark \"%s\"\n", sources[i]->name);
}

void SB_Source_Add_f(void)
{
	sb_source_type_t type = type_dummy;

	if (Cmd_Argc() != 4) {
		Com_Printf("Usage: %s <name> <address/filename> <master|file>\n", Cmd_Argv(0));
		if (Cmd_Argc() != 1) {
			Com_Printf("You supplied incorrect amount of arguments\n");
		}
		return;
	}

	if (strcmp(Cmd_Argv(3), "master") == 0) {
		type = type_master;
	}
	else if (strcmp(Cmd_Argv(3), "file") == 0) {
		type = type_file;
	}
	else if (strcmp(Cmd_Argv(3), "url") == 0) {
		type = type_url;
	}
	else {
		Com_Printf("Usage: %s <name> <address/filename> <master|file>\n", Cmd_Argv(0));
		Com_Printf("Last argument must be 'master' or 'file'\n");
		return;
	}

	SB_Source_Add(Cmd_Argv(1), Cmd_Argv(2), type);
}

static void SB_NewSource_Shift(void)
{
	// excluding dummy, presuming dummy is last
	newsource_type = (newsource_type + 1) % (type_dummy);
}

void Add_Source_Key(int key, wchar unichar)
{
	switch (key)
	{
		case K_HOME:
			if (keydown[K_CTRL])
				newsource_pos = 0;
			break;
		case K_END:
			if (keydown[K_CTRL])
				newsource_pos = 4;
			break;
		case K_UPARROW:
		case K_MWHEELUP:
			newsource_pos--;
			break;
		case K_TAB:
			keydown[K_SHIFT]?newsource_pos--:newsource_pos++;
			break;
		case K_DOWNARROW:
		case K_MWHEELDOWN:
			newsource_pos++;
			break;
		case K_ENTER:
		case '+':
		case '=':
		case '-':
			switch (newsource_pos)
			{
				case 0:
					SB_NewSource_Shift();
					break;
				case 2:
				case 3:
					if (key == K_ENTER)
					{
						int newpos;

						newpos = SB_Source_Add(edit1.text, edit2.text, newsource_type);
						if (newpos >= 0) {
							Sources_pos = newpos;
						}

						adding_source = 0;
					}
					break;
				case 4: // cancel
					if (key == K_ENTER)
						adding_source = 0;
					break;
			}
			break;
		case K_ESCAPE:
			adding_source = 0;
			break;
		case K_BACKSPACE:
			if (newsource_pos != 1  &&  newsource_pos != 2)
				adding_source = 0;
			break;
	}

	if ((!keydown[K_CTRL] || tolower(key)=='v') && !keydown[K_ALT])
	{
		if (newsource_pos == 1)
			CEditBox_Key(&edit1, key, unichar);
		if (newsource_pos == 2)
			CEditBox_Key(&edit2, key, unichar);
	}

	// Make sure value stays within limits and enable field wrapping 0..4->0
	newsource_pos = (newsource_pos + 5) % 5;
}

void Add_Server_Key(int key, wchar unichar)
{
	switch (key)
	{
		case K_HOME:
			if (keydown[K_CTRL])
				newserver_pos = 0;
			break;
		case K_END:
			if (keydown[K_CTRL])
				newserver_pos = 4;
			break;
		case K_UPARROW:
		case K_MWHEELUP:
			newserver_pos--;
			break;
		case K_TAB:
			keydown[K_SHIFT] ? newserver_pos-- : newserver_pos++;
			break;
		case K_DOWNARROW:
		case K_MWHEELDOWN:
			newserver_pos++;
			break;
		case K_ENTER:
		case '+':
		case '=':
		case '-':
			switch (newserver_pos)
			{
				case 0:
				case 1: // accept
					if (key == K_ENTER)
					{
						if (strlen(edit1.text) > 0)
						{
							AddUnboundServer(edit1.text);
						}
						adding_server = 0;
					}
					break;
				case 2: // cancel
					if (key == K_ENTER)
						adding_server = 0;
					break;
			}
			break;
		case K_ESCAPE:
			adding_server = 0;
			break;
		case K_BACKSPACE:
			if (newserver_pos != 0)
				adding_server = 0;
			break;
	}

	if ((!keydown[K_CTRL] || tolower(key)=='v') && !keydown[K_ALT])
	{
		if (newserver_pos == 0)
			CEditBox_Key(&edit1, key, unichar);
	}

	// Make sure value stays within limits and enable field wrapping 0..2->0
	newserver_pos = (newserver_pos + 3) % 3;
}

qbool SearchNextServer (int pos)
{
	int i;
	char tmp[1024];

	for (i = pos; i < serversn_passed; i++) {
		strlcpy (tmp, servers[i]->display.name, sizeof (tmp));
		FunToSort (tmp);

		if (strstr (tmp, searchstring)) {
			Servers_pos = i;
			return true;
		}
	}

	return false;
}

static void SB_Servers_Toggle_Column_Show(int colidx)
{
	if (colidx > 0 && colidx < sb_columns_size) {
		Cvar_Toggle(sb_columns[colidx].showvar);
	}
}

static void SB_Servers_Toggle_Column_Sort(char key)
{
	char buf[32];
	if ((sb_sortservers.string[0] == '-' && sb_sortservers.string[1] == key)
			|| sb_sortservers.string[0] == key)
	{
		if (sb_sortservers.string[0] == '-')
		{
			strlcpy (buf, sb_sortservers.string + 1, sizeof (buf));
		}
		else
		{
			buf[0] = '-';
			strlcpy (buf + 1, sb_sortservers.string, sizeof (buf) - 1);
		}
	} else {
		buf[0] = key;
		strlcpy (buf + 1, sb_sortservers.string, sizeof (buf) - 1);
	}

	Cvar_Set(&sb_sortservers, buf);
	resort_servers = 1;
}

int SB_Servers_Key(int key)
{
	if (serversn_passed <= 0 && key == K_BACKSPACE) {
		searchstring[0] = '\0';
		searchtype = search_none;
		resort_servers = 1;
	}

	if (serversn_passed <= 0  &&  (key != K_SPACE || keydown[K_ALT])
			&& tolower(key) != 'n'  && key != K_INS)
		return false;

	if (key == K_SPACE) {
		GetServerPingsAndInfos(keydown[K_CTRL]);
		return true;
	}

	if (!keydown[K_CTRL] && !keydown[K_ALT] && key > ' ' && key <= '}')  // search
	{
		int len;
		char c = tolower(key);
		if (searchtype != search_server) {
			searchtype = search_server;
			searchstring[0] = 0;
		}
		searchtime = cls.realtime;

		len = strlen(searchstring);
		if (len < MAX_SEARCH) {
			searchstring[len] = c;
			searchstring[len+1] = 0;
			resort_servers = 1;
		}

		return true;
	} else {
		searchtype = search_none;
		switch (key)
		{
			case K_BACKSPACE:
				searchstring[0] = '\0';
				resort_servers = 1;
				break;
			case K_INS:
			case 'n':	// new server
				newserver_pos = 0;
				CEditBox_Init(&edit1, 14, 64);
				adding_server = 1;
				break;
			case 'j':
			case 'p':
				Join_Server(servers[Servers_pos]);
				break;
			case 'o':
			case 's':
				Observe_Server(servers[Servers_pos]);
				break;
			case 'r':
				GetServerInfo(servers[Servers_pos]);
				break;
			case K_UPARROW:
				Servers_pos--;
				break;
			case K_MWHEELUP:
				Servers_disp -= MWHEEL_SCROLL_STEP;
				Servers_pos -= MWHEEL_SCROLL_STEP;
				break;

			case K_DOWNARROW:
				Servers_pos++;
				break;
			case K_MWHEELDOWN:
				Servers_disp += MWHEEL_SCROLL_STEP;
				Servers_pos += MWHEEL_SCROLL_STEP;
				break;

			case K_HOME:
				Servers_pos = 0;
				break;
			case K_END:
				Servers_pos = serversn_passed-1;
				break;
			case K_PGUP:
				Servers_pos -= 10;
				break;
			case K_PGDN:
				Servers_pos += 10;
				break;
			case K_MOUSE1:
			case K_ENTER:
				Serverinfo_Start(servers[Servers_pos]);
				break;
			case K_SPACE:
				GetServerPingsAndInfos(keydown[K_CTRL]);
				break;
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':   // sorting mode
				if (keydown[K_ALT]) // fixme
				{
					SB_Servers_Toggle_Column_Sort(key);
				} else if (keydown[K_CTRL]) {
					SB_Servers_Toggle_Column_Show(key - '1');
				}
				break;
			case 'c':	// copy server to clipboard
				CopyServerToClipboard(servers[Servers_pos]);
				break;
			case 'v':	// past server into console
				PasteServerToConsole(servers[Servers_pos]);
				break;
			default: return false;
		}
	}

	Servers_pos = max(Servers_pos, 0);
	Servers_pos = min(Servers_pos, serversn-1);
	return true;
}

void Serverinfo_Key(int key)
{
	switch (key)
	{
		case K_MOUSE1:
		case 'x': // x was once used for best route connection
		case K_ENTER:
			if (serverinfo_pos != 2)
			{
				if (show_serverinfo->qwfwd) {
					SB_Select_QWfwd(show_serverinfo);
				} else if (keydown[K_CTRL]) {
					Observe_Server(show_serverinfo);
				} else {
					Join_Server(show_serverinfo);
				}
			}
			else
				Serverinfo_Sources_Key(key);
			break;
		case K_MOUSE2:
		case K_ESCAPE:
		case K_BACKSPACE:
			Serverinfo_Stop();
			break;
		case K_TAB:
			if (keydown[K_SHIFT]) {
				serverinfo_pos--;
			}
			else {
				serverinfo_pos++;
			}
			break;
		case K_LEFTARROW:
			serverinfo_pos--;
			break;
		case K_RIGHTARROW:
			serverinfo_pos++;
			break;
		case 'q':
			Cbuf_AddText("observeqtv ");
			Cbuf_AddText(NET_AdrToString(show_serverinfo->address));
			Cbuf_AddText("\n");
			break;
		case 'j':
		case 'p':
			Join_Server(show_serverinfo);
			break;
		case 'n':
			Join_Server_Direct(show_serverinfo);
			break;
		case 'o':
		case 's':
			Observe_Server(show_serverinfo);
			break;
		case 't':
			{
				if (!testing_connection)
				{
					char buf[256];
					snprintf(buf, sizeof (buf), "%d.%d.%d.%d",
							show_serverinfo->address.ip[0],
							show_serverinfo->address.ip[1],
							show_serverinfo->address.ip[2],
							show_serverinfo->address.ip[3]);
					SB_Test_Init(buf);
					testing_connection = 1;
				} else {
					testing_connection = 0;
				}
				break;
			}
		case 'c':   // copy server to clipboard
			CopyServerToClipboard(show_serverinfo);
			break;
		case 'v':   // past server into console
			PasteServerToConsole(show_serverinfo);
			break;
		case 'i':
			SB_PingTree_DumpPath(&show_serverinfo->address);
			break;
		case K_MWHEELUP:
	        case K_UPARROW:
	        case K_PGUP:
	          if (!keydown[K_CTRL]) {
		    Servers_pos--;
		    Servers_pos = max(0, Servers_pos);
		    Serverinfo_Change(servers[Servers_pos]);
		    break;
	          }
	        case K_MWHEELDOWN:
	        case K_DOWNARROW:
	        case K_PGDN:
	          if (!keydown[K_CTRL]) {
		    Servers_pos++;
		    Servers_pos = min(serversn_passed - 1, Servers_pos);
		    Serverinfo_Change(servers[Servers_pos]);
	          }
		default:
			switch (serverinfo_pos)
			{
				case 0: // players list
					Serverinfo_Players_Key(key);
					break;
				case 1: // serverinfo / rules
					Serverinfo_Rules_Key(key);
					break;
				case 2: // sources
					Serverinfo_Sources_Key(key);
					break;
				default:
					;
			}
	}

	serverinfo_pos = (serverinfo_pos + 3) % 3;
}

void Serverinfo_Players_Key(int key)
{
	switch (key)
	{
		case K_UPARROW:
		case K_MWHEELUP:
			serverinfo_players_pos--;
			break;
		case K_DOWNARROW:
		case K_MWHEELDOWN:
			serverinfo_players_pos++;
			break;
		case K_HOME:
			serverinfo_players_pos = 0;
			break;
		case K_END:
			serverinfo_players_pos = 999;
			break;
		default:
			;
	}
}

void Serverinfo_Rules_Key(int key)
{
	switch (key)
	{
		case K_UPARROW:
		case K_MWHEELUP:
			serverinfo_rules_pos--;
			break;
		case K_DOWNARROW:
		case K_MWHEELDOWN:
			serverinfo_rules_pos++;
			break;
		case K_HOME:
			serverinfo_rules_pos = 0;
			break;
		case K_END:
			serverinfo_rules_pos = 999;
			break;
		default:
			;
	}
}

void Serverinfo_Sources_Key(int key)
{
	switch (key)
	{
		case K_UPARROW:
		case K_MWHEELUP:
			serverinfo_sources_pos--;
			break;
		case K_DOWNARROW:
		case K_MWHEELDOWN:
			serverinfo_sources_pos++;
			break;
		case K_HOME:
			serverinfo_sources_pos = 0;
			break;
		case K_END:
			serverinfo_sources_pos = 999;
			break;
		case K_INS:
			if (!IsInSource(sources[serverinfo_sources_pos], show_serverinfo))
				AddToFileSource(sources[serverinfo_sources_pos], show_serverinfo);
			break;
		case K_DEL:
			if (IsInSource(sources[serverinfo_sources_pos], show_serverinfo))
				RemoveFromFileSource(sources[serverinfo_sources_pos], show_serverinfo);
			break;
		case K_ENTER:
			if (IsInSource(sources[serverinfo_sources_pos], show_serverinfo))
				RemoveFromFileSource(sources[serverinfo_sources_pos], show_serverinfo);
			else
				AddToFileSource(sources[serverinfo_sources_pos], show_serverinfo);
		default:
			;
	}

	serverinfo_sources_pos = max(serverinfo_sources_pos, 0);
	serverinfo_sources_pos = min(serverinfo_sources_pos, sourcesn_updated-1);
}

void SB_RemoveSourceProc(void)
{
	SB_Source_Remove(Sources_pos);

	if (Sources_pos >= sourcesn) {
		Sources_pos = sourcesn - 1;
	}
}

int SB_Sources_Key(int key)
{
	int i;

	if (sourcesn <= 0)
		return false;

	switch (key)
	{
		case K_INS:
		case 'n':       // new source
			newsource_pos = 0;
			newsource_type = type_file;
			CEditBox_Init(&edit1, 16, 25);
			CEditBox_Init(&edit2, 16, 100);
			adding_source = 1;
			break;
		case K_DEL:
		case 'd':       // remove source
			if (sources[Sources_pos]->type != type_dummy) {
				char tmp[64];
				snprintf(&tmp[0], sizeof(tmp), "Remove %-.20s", sources[Sources_pos]->name);
				SB_Confirmation(tmp, SB_RemoveSourceProc);
			}
			break;
		case 'u':
			Update_Source(sources[Sources_pos]); 
			break;
		case K_UPARROW:
		case K_MWHEELUP:
			Sources_pos--;
			break;
		case K_DOWNARROW:
		case K_MWHEELDOWN:
			Sources_pos++;
			break;
		case K_HOME:
			Sources_pos = 0;
			break;
		case K_END:
			Sources_pos = sourcesn-1;
			break;
		case K_PGUP:
			Sources_pos -= 10;
			break;
		case K_PGDN:
			Sources_pos += 10;
			break;
		case K_MOUSE1:
		case K_ENTER:
			Toggle_Source(sources[Sources_pos++]);
			break;
		case ']':
			Toggle_Source(sources[Sources_pos]);
			break;
		case K_SPACE:
			SB_Sources_Update_Begin(keydown[K_CTRL]);
			break;
		case '=':
		case '+':   // select all sources
			for (i=0; i < sourcesn; i++)
				Mark_Source(sources[i]);
			break;
		case '-':   // select none
			for (i=0; i < sourcesn; i++)
				Unmark_Source(sources[i]);
			break;
		case '*':   // invert selection
			for (i=0; i < sourcesn; i++)
				Toggle_Source(sources[i]);
			break;
		case '1':
		case '2':
		case '3':   // sorting mode
			if ((sb_sortsources.string[0] == '-' && sb_sortsources.string[1] == key)
					|| sb_sortsources.string[0] == key)
			{
				char buf[32];
				if (sb_sortsources.string[0] == '-')
					strlcpy(buf, sb_sortsources.string+1, sizeof (buf));
				else
				{
					buf[0] = '-';
					strlcpy(buf+1, sb_sortsources.string, sizeof (buf)-1);
				}
				Cvar_Set(&sb_sortsources, buf);
			}
			else
			{
				char buf[32];
				buf[0] = key;
				strlcpy(buf+1, sb_sortsources.string, sizeof (buf)-1);
				Cvar_Set(&sb_sortsources, buf);
			}
			resort_sources = 1;
			break;
		default: return false;
	}

	Sources_pos = max(Sources_pos, 0);
	Sources_pos = min(Sources_pos, sourcesn-1);
	return true;
}

qbool SearchNextPlayer(int pos)
{
	int i;
	char tmp[1024];

	for (i = pos; i < all_players_n; i++) {
		strlcpy (tmp, all_players[i]->name, sizeof (tmp));
		FunToSort (tmp);

		if (strstr (tmp, searchstring)) {
			Players_pos = i;
			return true;
		}
	}

	return false;
}

int SB_Players_Key(int key)
{
	int i;

	if (all_players_n <= 0  &&  key != K_SPACE)
		return false;

	if ((keydown[K_ALT]  ||  searchtype == search_player)  &&
			key >= ' '  &&  key <= '}')  // search
	{
		int len;
		char c = tolower(key);
		if (searchtype != search_player)
		{
			searchtype = search_player;
			searchstring[0] = 0;
		}
		searchtime = cls.realtime;

		len = strlen(searchstring);
		if (len < MAX_SEARCH)
		{
			searchstring[len] = c;
			searchstring[len+1] = 0;

			if (!SearchNextPlayer(Players_pos))
				if (!SearchNextPlayer(0))
					strlcpy (searchstring, "not found", sizeof (searchstring));  // not found
		}
		return true;
	}
	else
	{
		searchtype = search_none;
		switch (key)
		{
			case 'j':
			case 'p':
				Join_Server(all_players[Players_pos]->serv);
				break;
			case 'o':
			case 's':
				Observe_Server(all_players[Players_pos]->serv);
				break;
			case K_SPACE:
				GetServerPingsAndInfos(keydown[K_CTRL]);
				break;

			case K_INS: // go to servers -- locate
				Servers_pos = 0;
				for (i=0; i < serversn_passed; i++)
				{
					if (servers[i] == all_players[Players_pos]->serv)
					{
						Servers_pos = i;
						break;
					}
				}
				CTab_SetCurrentId(&sb_tab, SBPG_SERVERS);
				break;

			case K_UPARROW:
			case K_MWHEELUP:
				Players_pos--;
				break;
			case K_DOWNARROW:
			case K_MWHEELDOWN:
				Players_pos++;
				break;
			case K_HOME:
				Players_pos = 0;
				break;
			case K_END:
				Players_pos = all_players_n-1;
				break;
			case K_PGUP:
				Players_pos -= 10;
				break;
			case K_PGDN:
				Players_pos += 10;
				break;
			case K_MOUSE1:
			case K_ENTER:
				Serverinfo_Start(all_players[Players_pos]->serv);
				break;
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':   // sorting mode
				if ((sb_sortplayers.string[0] == '-' && sb_sortplayers.string[1] == key)
						|| sb_sortplayers.string[0] == key)
				{
					char buf[32];
					if (sb_sortplayers.string[0] == '-')
						strlcpy(buf, sb_sortplayers.string+1, sizeof (buf));
					else
					{
						buf[0] = '-';
						strlcpy(buf+1, sb_sortplayers.string, sizeof (buf)-1);
					}
					Cvar_Set(&sb_sortplayers, buf);
				}
				else
				{
					char buf[32];
					buf[0] = key;
					strlcpy(buf+1, sb_sortplayers.string, sizeof (buf)-1);
					Cvar_Set(&sb_sortplayers, buf);
				}
				resort_all_players = 1;
				break;
			case 'c':
				CopyServerToClipboard(all_players[Players_pos]->serv);
				break;
			case 'v':   // past server into console
				PasteServerToConsole(all_players[Players_pos]->serv);
				break;
			default: return false;
		}
	}

	Players_pos = max(Players_pos, 0);
	Players_pos = min(Players_pos, all_players_n-1);
	return true;
}

qbool SB_Servers_Mouse_Event(const mouse_state_t *ms)
{
	if (show_serverinfo) {
	}
	else if (ms->button_up == 1) {
		if (mouse_in_header_row) {
			SB_Servers_Toggle_Column_Sort('0' + mouse_hovered_column + 1);
		}
		else {
			SB_Servers_Key(K_MOUSE1);
		}
	}
	else {
		double mouse_row = ms->y / 8.0 - 1.0;
		if (mouse_row < 0.0) {
			mouse_in_header_row = true;
			mouse_header_pos_y = ms->x;
		}
		else {
			mouse_in_header_row = false;
			Servers_pos = Servers_disp + (int) mouse_row;
			Servers_pos = bound(0, Servers_pos, serversn - 1);
		}
	}
	return true;
}

qbool SB_Sources_Mouse_Event(const mouse_state_t *ms)
{
	if (show_serverinfo) return false;

	if (ms->button_up == 1)
	{
		SB_Sources_Key(K_MOUSE1);
		return true;
	}
	Sources_pos = Sources_disp + ms->y / 8 - 1;
	Sources_pos = bound(0, Sources_pos, sourcesn - 1);
	return true;
}

qbool SB_Players_Mouse_Event(const mouse_state_t *ms)
{
	if (show_serverinfo) return false;

	Players_pos = Players_disp + ms->y / 8 - 1;
	Players_pos = bound(0, Players_pos, all_players_n - 1);
	return true;
}

void SB_Specials_Draw(void)
{
	if (show_serverinfo) Serverinfo_Draw();
	if (ping_phase) PingPhase_Draw();
	if (updating_sources) UpdatingSources_Draw();
	if (confirmation) SB_Confirmation_Draw();
}

qbool SB_Specials_Key(int key, wchar unichar)
{
	if (confirmation)
	{
		SB_Confirmation_Key(key);
		return true;
	}

	if ((ping_phase || updating_sources) && (key == '`' || key == '~' || key == 'm')) {
		M_LeaveMenus();
		// Con_ToggleConsole_f ();
		return true;
	}

	if ((key == K_ESCAPE || key == K_MOUSE2)  &&
			show_serverinfo == NULL  &&
			!adding_source  &&
			!adding_server  &&
			ping_phase == 0  &&
			!updating_sources)  // exit from browser to main menu
	{
		M_Menu_Main_f();
		return true;
	}

	if (show_serverinfo)
	{
		Serverinfo_Key(key);
		return true;
	}

	if (adding_source)
	{
		Add_Source_Key(key, unichar);
		return true;
	}

	if (adding_server)
	{
		Add_Server_Key(key, unichar);
		return true;
	}

	if (ping_phase || updating_sources)  // no keys when pinging
	{
		if (!abort_ping  &&  (key == K_ESCAPE || key == K_BACKSPACE))
			abort_ping = 1;
		return true;
	}

	return false;
}

//
// sorting routines
//

static int Servers_Compare_Ping_Func(const server_data *s1, const server_data *s2)
{
	int p1 = (sb_findroutes.integer && s1->bestping > 0) ? s1->bestping : s1->ping;
	int p2 = (sb_findroutes.integer && s2->bestping > 0) ? s2->bestping : s2->ping;
	int diff = p1 - p2;

	return diff;
}

static int Servers_Occupancy_Sort_Rating(server_occupancy oc) {
	if (oc == SERVER_EMPTY) {
		return 0;
	}
	else if (oc == SERVER_FULL) {
		return 1;
	}
	else if (oc == SERVER_NONEMPTY) {
		return 2;
	}
	else {
		Com_DPrintf("Illegal server occupancy %d\n", oc);
		return -1;
	}
}

static int Servers_Compare_Natural(const server_data *s1, const server_data *s2) {
	if (s1->occupancy != s2->occupancy) {
		int o1 = Servers_Occupancy_Sort_Rating(s1->occupancy);
		int o2 = Servers_Occupancy_Sort_Rating(s2->occupancy);
		return o2 - o1;
	}
	else {
		server_occupancy oc = s1->occupancy;
		switch (oc) {
			case SERVER_NONEMPTY:
				return Servers_Compare_Ping_Func(s1, s2);
			case SERVER_FULL:
				return s2->playersn - s1->playersn;
			case SERVER_EMPTY:
				return Servers_Compare_Ping_Func(s1, s2);
			default:
				return 0;
		}
	}
}

int Servers_Compare_Func(const void * p_s1, const void * p_s2)
{
	int reverse = 0;
	char *sort_string = sb_sortservers.string;
	const server_data *s1 = *((server_data **)p_s1);
	const server_data *s2 = *((server_data **)p_s2);

	if (s1->ping < 0  &&  s2->ping >= 0)
		return 1;
	if (s2->ping < 0  &&  s1->ping >= 0)
		return -1;

	if (!s1->passed_filters  &&  s2->passed_filters)
		return 1;
	if (!s2->passed_filters  &&  s1->passed_filters)
		return -1;
	if (!s1->passed_filters  &&  !s2->passed_filters)
		return s1 - s2;

	if (sort_string[0] == '\0') {
		return Servers_Compare_Natural(s1, s2);
	}

	while (true)
	{
		int d;  // difference

		if (*sort_string == '-')
		{
			reverse = 1;
			sort_string++;
			continue;
		}

		switch (*sort_string++)
		{
			case '1':
				d = funcmp(s1->display.name, s2->display.name);
				break;
			case '2':
				d = memcmp(&(s1->address.ip), &(s2->address.ip), 4);
				if (!d)
					d = ntohs(s1->address.port) - ntohs(s2->address.port);
				break;
			case '3':
				d = Servers_Compare_Ping_Func(s1, s2);
				break;
			case '4':
				d = Q_strcmp2(s1->display.gamedir, s2->display.gamedir);
				break;
			case '5':
				d = Q_strcmp2(s1->display.map, s2->display.map);
				break;
			case '6':
				d = s1->playersn - s2->playersn;
				break;
			case '7':
				d = Q_strcmp2(s1->display.fraglimit, s2->display.fraglimit);
				break;
			case '8':
				d = Q_strcmp2(s1->display.timelimit, s2->display.timelimit);
				 break;
			default:
				d = s1 - s2;
		}

		if (d)
			return reverse ? -d : d;
	}
}

void Filter_Servers(void)
{
	int i, info_filter_count;
	info_filter_t* info_filters = SB_InfoFilter_Parse(&info_filter_count);

	serversn_passed = 0;
	for (i=0; i < serversn; i++)
	{
		char *tmp;
		server_data *s = servers[i];
		s->passed_filters = 0;

		if (searchstring[0] && !strstri(s->display.name, searchstring)) {
			continue;
		}

		if (sb_showproxies.integer == 0 && (s->qwfwd || s->qizmo))
			continue; // hide

		if (sb_showproxies.integer == 2 && !(s->qwfwd || s->qizmo))
			continue; // exclusive

		if (sb_hidedead.value  &&  s->ping < 0)
			continue;

		if (!s->qizmo && !s->qwfwd) {
			if (sb_hideempty.value  &&  s->playersn + s->spectatorsn <= 0)
				continue;

			if (sb_hidenotempty.value  &&  s->playersn + s->spectatorsn > 0)
				continue;
		}

		if (sb_hidehighping.integer && s->ping > sb_pinglimit.integer)
			continue;

		tmp = ValueForKey(s, "maxclients");
		if (sb_hidefull.value  &&  s->playersn >= (tmp ? atoi(tmp) : 255))
			continue;

		if (!SB_InfoFilter_Exec(info_filters, info_filter_count, s)) {
			continue;
		}

		s->passed_filters = 1;  // passed
		serversn_passed++;
	}

	SB_InfoFilter_Free(info_filters, info_filter_count);

	return;
}

void Sort_Servers (void)
{
	SB_ServerList_Lock();
	Filter_Servers();
	qsort(servers, serversn, sizeof(servers[0]), Servers_Compare_Func);
	SB_ServerList_Unlock();
}


//
// build all players list
//

int rebuild_all_players = 0;
int resort_all_players = 0;

int All_Players_Compare_Func(const void * p_p1, const void * p_p2)
{
	int reverse = 0;
	char *sort_string = sb_sortplayers.string;
	const player_host *p1 = *((player_host **)p_p1);
	const player_host *p2 = *((player_host **)p_p2);
	server_data *s1 = p1->serv;
	server_data *s2 = p2->serv;

	if (s1->ping < 0  &&  s2->ping >= 0)
		return 1;
	if (s2->ping < 0  &&  s1->ping >= 0)
		return -1;

	while (true)
	{
		int d;  // difference

		if (*sort_string == '-')
		{
			reverse = 1;
			sort_string++;
			continue;
		}

		switch (*sort_string++)
		{
			case '1':
				d = funcmp(s1->display.name, s2->display.name);
				break;
			case '2':
				d = memcmp(&(s1->address.ip), &(s2->address.ip), 4);
				if (!d)
					d = ntohs(s1->address.port) - ntohs(s2->address.port);
				break;
			case '3':
				d = s1->ping - s2->ping;
				break;
			case '4':
				d = Q_strcmp2(s1->display.gamedir, s2->display.gamedir);
				break;
			case '5':
				d = Q_strcmp2(s1->display.map, s2->display.map);
				break;
			case '6':
				d = s1->playersn - s2->playersn;
				break;
			case '7':
				d = Q_strcmp2(s1->display.fraglimit, s2->display.fraglimit);
				break;
			case '8':
				d = Q_strcmp2(s1->display.timelimit, s2->display.timelimit);
				break;
			case '9':
				d = funcmp(p1->name, p2->name);
				break;
			default:
				d = p1 - p2;
		}

		reverse = 0;

		if (d)
			return reverse ? -d : d;
	}
}

void Sort_All_Players(void)
{
	qsort(all_players, all_players_n, sizeof(all_players[0]), All_Players_Compare_Func);
}

void Rebuild_All_Players(void)
{
	int i, j, players = 0;

	// clear
	if (all_players != NULL)
	{
		for (i = 0; i < all_players_n; i++)
			Q_free(all_players[i]);

		Q_free(all_players);
	}

	// count players
	for (i = 0; i < serversn; i++)
		players += servers[i]->playersn + servers[i]->spectatorsn;

	// alloc memory
	all_players = (player_host **) Q_malloc (players * sizeof (player_host *));

	// make players
	all_players_n = 0;
	for (i = 0; i < serversn; i++)
	{
		for (j = 0; j < servers[i]->playersn + servers[i]->spectatorsn; j++)
		{
			all_players[all_players_n] = (player_host *) Q_malloc (sizeof (player_host));
			strlcpy (all_players[all_players_n]->name,
					servers[i]->players[j]->name,
					sizeof (all_players[all_players_n]->name));
			all_players[all_players_n]->serv = servers[i];
			all_players_n++;
		}
	}

	resort_all_players = 1;
	rebuild_all_players = 0;
	//Players_pos = 0;
}

void SB_Sources_Update_f(void)
{
	SB_Sources_Update_Begin(true);
}

// Server list serialization.
// When user set sb_listcache 1, the server list will be saved to his home dir after each update
// so that next time the client is started the list is immediately full of servers
// and it's not necessary to do full refresh, just get infos from alive servers is enough
// (which is significantly faster than full refresh).
// Of course users should do full-update of their list after some time so that 
// new servers have a chance to appear.
#define SERIALIZE_FILE_VERSION 1003
void SB_Serverlist_Serialize(FILE *f)
{
	int version = SERIALIZE_FILE_VERSION;
	size_t server_data_size = sizeof(server_data);
	int i;

	// header
	// - version
	fwrite(&version, sizeof(int), 1, f);
	// - server_data struct size
	fwrite(&server_data_size, sizeof(size_t), 1, f);
	// - number of servers
	fwrite(&serversn, sizeof(int), 1, f);
	// - number of filtered servers
	fwrite(&serversn_passed, sizeof(int), 1, f);

	// body
	for (i = 0; i < serversn; i++) {
		server_data t = *servers[i];
		t.keysn = 0; // we don't store the keys
		fwrite(&t, sizeof(server_data), 1, f);
	}
}

int SB_Serverlist_Unserialize(FILE *f)
{
	size_t server_data_size;
	int i;
	int version;
	int serversn_buffer, serversn_passed_buffer;

	if (fread(&version, sizeof(int), 1, f) != 1)
		return -3;
	if (version != SERIALIZE_FILE_VERSION)
		return -1;

	if (fread(&server_data_size, sizeof(size_t), 1, f) != 1)
		return -3;
	if (server_data_size != sizeof(server_data))
		return -1;

	if (fread(&serversn_buffer, sizeof(int), 1, f) != 1)
		return -3;
	if (serversn_buffer > MAX_SERVERS)
		return -2;

	if (fread(&serversn_passed_buffer, sizeof(int), 1, f) != 1)
		return -3;
	if (serversn_passed_buffer > MAX_SERVERS)
		return -2;

	serversn = serversn_buffer;
	serversn_passed = serversn_passed_buffer;

	for (i = 0; i < serversn; i++) {
		server_data *s = (server_data *) Q_malloc(sizeof(server_data));
		int j;

		if (fread(s, sizeof(server_data), 1, f) != 1 ||
				s->playersn < 0 || s->playersn > MAX_CLIENTS || s->spectatorsn < 0 || s->spectatorsn > MAX_CLIENTS) {
			// naive check for corrupted data
			serversn = 0;
			serversn_passed = 0;
			Q_free(s);
			for (j = 0; j < i; j++) {
				Q_free(servers[j]);
			}
			return -3;
		}

		servers[i] = s;

		// Create empty entries because
		// serialized playersn and spectatorsn is not zero, that's needed
		// to not get empty list on "hide empty". Empty list leads to full refresh
		// which makes the un/serialization stuff useless.
		for (j = 0; j < s->playersn + s->spectatorsn; j++) {
			servers[i]->players[j] = Q_calloc(1, sizeof(playerinfo));
		}
	}

	rebuild_servers_list = 0;

	return serversn;
}

void SB_Serverlist_Serialize_f(void)
{
	FILE *f;
	char filename[MAX_OSPATH] = {0};

	snprintf(&filename[0], sizeof(filename), "%s/%s", com_homedir, "servers_data");

	if (!(f	= fopen	(filename, "wb"))) {
		FS_CreatePath(filename);
		if (!(f	= fopen	(filename, "wb"))) {
			Com_Printf ("Couldn't write	%s.\n",	filename);
			return;
		}
	}

	SB_Serverlist_Serialize(f);
	Com_Printf("Wrote server list contents to disk\n");
	fclose(f);
	filesystemchanged = true;
}

void SB_Serverlist_Unserialize_f(void)
{
	FILE *f;
	int err;
	char filename[MAX_OSPATH] = {0};

	snprintf(&filename[0], sizeof(filename), "%s/%s", com_homedir, "servers_data");

	if (!(f	= fopen	(filename, "rb"))) {
		Com_Printf ("Couldn't read %s.\n", filename);
		return;
	}

	err = SB_Serverlist_Unserialize(f);
	if (err > 0) {
		Com_Printf("Successfully read %d servers\n", err);
	}
	else if (err == -1) {
		Com_Printf("Format didn't match\n");
	}
	else if (err == -2) {
		Com_Printf("Format error (servers number too big)\n");
	}
	else if (err == -3) {
		Com_Printf("Corrupted data\n");
	}
	else { // err == 0
		Com_Printf("No servers read\n");
	}

	fclose(f);
}

void SB_ProxyDumpPing(netadr_t adr, short dist)
{
	Com_Printf("%3d.%3d.%3d.%3d:%5d   %d\n",
			adr.ip[0], adr.ip[1], adr.ip[2], adr.ip[3], (int) adr.port, dist);
}

void SB_ProxyGetPings_f(void)
{
	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: %s <ip>\n", Cmd_Argv(0));
		return;
	}
	else {
		netadr_t adr;

		if (!NET_StringToAdr(Cmd_Argv(1), &adr)) {
			Com_Printf("Invalid address\n");
			return;
		}
		Com_Printf("List:\n");
		SB_Proxy_QueryForPingList(&adr, SB_ProxyDumpPing);
		Com_Printf("End of list.\n");
	}
}

void SB_Shutdown(void)
{
	int i;

	SB_PingTree_Shutdown();

	// FIXME - this probably never worked
	// Serverinfo_Stop();
	// Sys_MSleep(150);     // wait for thread to terminate

	for (i = 0; i < sourcesn; ++i) {
		Reset_Source(sources[i]);
		Q_free(sources[i]);
	}

	// delete servers[0...serversn) ?
}

void Browser_Init (void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SERVER_BROWSER);
	Cvar_Register(&sb_status);
	Cvar_Register(&sb_showping);
	Cvar_Register(&sb_showaddress);
	Cvar_Register(&sb_showmap);
	Cvar_Register(&sb_showgamedir);
	Cvar_Register(&sb_showplayers);
	Cvar_Register(&sb_showfraglimit);
	Cvar_Register(&sb_showtimelimit);
	Cvar_Register(&sb_pingtimeout);
	Cvar_Register(&sb_infotimeout);
	Cvar_Register(&sb_pings);
	Cvar_Register(&sb_pingspersec);
	Cvar_Register(&sb_inforetries);
	Cvar_Register(&sb_infospersec);
	Cvar_Register(&sb_proxinfopersec);
	Cvar_Register(&sb_proxretries);
	Cvar_Register(&sb_proxtimeout);
	Cvar_Register(&sb_liveupdate);
	Cvar_Register(&sb_mastertimeout);
	Cvar_Register(&sb_masterretries);
	Cvar_Register(&sb_nosockraw);
	Cvar_Register(&sb_sortservers);
	Cvar_Register(&sb_sortplayers);
	Cvar_Register(&sb_sortsources);
	Cvar_Register(&sb_autohide);
	Cvar_Register(&sb_hideempty);
	Cvar_Register(&sb_hidenotempty);
	Cvar_Register(&sb_hidefull);
	Cvar_Register(&sb_hidedead);
	Cvar_Register(&sb_hidehighping);
	Cvar_Register(&sb_pinglimit);
	Cvar_Register(&sb_showproxies);
	Cvar_Register(&sb_sourcevalidity);
	Cvar_Register(&sb_mastercache);
	Cvar_Register(&sb_autoupdate);
	Cvar_Register(&sb_listcache);
	Cvar_Register(&sb_findroutes);
	Cvar_Register(&sb_ignore_proxy);
	Cvar_Register(&sb_info_filter);
	Cvar_ResetCurrentGroup();

	Cmd_AddCommand("addserver", AddServer_f);
	Cmd_AddCommand("sb_refresh", GetServerPingsAndInfos_f);
	Cmd_AddCommand("sb_pingsdump", SB_PingsDump_f);
	Cmd_AddCommand("sb_sourceadd", SB_Source_Add_f);
	Cmd_AddCommand("sb_sourcesupdate", SB_Sources_Update_f);
	Cmd_AddCommand("sb_buildpingtree", SB_PingTree_Build);
	Cmd_AddCommand("sb_proxygetpings", SB_ProxyGetPings_f);

	if (sb_listcache.integer) {
		SB_Serverlist_Unserialize_f();
		SB_Proxylist_Unserialize_f();
	}

	qtvlist_init();
}

void Browser_Init2 (void)
{
	int i;

	Servers_pos = 0;
	Sources_pos = 0;
	Servers_disp = 0;
	show_serverinfo = NULL;
	serverinfo_pos = 0;

	for (i=0; i < MAX_SERVERS; i++)
		servers[i] = NULL;

	serversn = serversn_passed = 0;
	sourcesn = 0;

	serverlist_mutex = SDL_CreateMutex();
	SB_PingTree_Init();

	// read sources from SOURCES_PATH
	Reload_Sources();
	MarkDefaultSources();
}

void SB_ExecuteQueuedTriggers(void) {
	if (sb_queuedtriggers & SB_TRIGGER_REFRESHDONE) {
		TP_ExecTrigger("f_sbrefreshdone");
		sb_queuedtriggers &= ~SB_TRIGGER_REFRESHDONE;
	}

	if (sb_queuedtriggers & SB_TRIGGER_SOURCESUPDATED) {
		TP_ExecTrigger("f_sbupdatesourcesdone");
		sb_queuedtriggers &= ~SB_TRIGGER_SOURCESUPDATED;
	}

	if (sb_queuedtriggers & SB_TRIGGER_NOTIFY_PINGTREE) {
		Com_Printf("Ping tree has been created\n");
		sb_queuedtriggers &= ~SB_TRIGGER_NOTIFY_PINGTREE;
	}
}

static qbool SB_InfoFilter_Exec(info_filter_t* info_filters, int info_filter_count, server_data* s)
{
	int j;
	qbool default_pass = true;

	for (j = 0; j < info_filter_count; ++j) {
		info_filter_t* filter = &info_filters[j];
		const char* value;

		if (!filter->exec) {
			// Invalid definition
			continue;
		}

		// if any filters were valid then block the remaining
		default_pass = !filter->pass;

		// shorthand for "rest"
		if (filter->name[0] == '*' && filter->name[1] == '\0') {
			return filter->pass;
		}

		value = ValueForKey(s, filter->name);
		if (!value) {
			// if server doesn't specify key then we move on to next (hmm)
			continue;
		}

		if (!filter->regex) {
			// Any value will do
			if (value != NULL && value[0]) {
				return filter->pass;
			}
		}
		else {
			// Rule specified, check it matches the regex
			pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(filter->regex, NULL);
			if (pcre2_match(filter->regex, (PCRE2_SPTR)value, strlen(value), 0, 0, match_data, NULL) >= 0) {
				pcre2_match_data_free (match_data);
				return filter->pass;
			}
			pcre2_match_data_free (match_data);
		}
	}

	// run out of rules - default 
	return default_pass;
}

static info_filter_t* SB_InfoFilter_Parse(int* count)
{
	int i;
	tokenizecontext_t info_filter_ctx;
	int info_filter_count;
	info_filter_t* info_filters;
	char definition[MAX_MACRO_STRING];

	Cmd_TokenizeStringEx(&info_filter_ctx, sb_info_filter.string);
	*count = info_filter_count = Cmd_ArgcEx(&info_filter_ctx);

	info_filters = Q_malloc(info_filter_count * sizeof(info_filter_t));
	for (i = 0; i < info_filter_count; ++i) {
		char* split;
		int error;
		PCRE2_SIZE error_offset;
		info_filter_t* filter = &info_filters[i];

		// filters must be +x=y or -x=y
		strlcpy(definition, Cmd_ArgvEx(&info_filter_ctx, i), sizeof(definition));
		if (definition[0] != '-' && definition[0] != '+') {
			Con_Printf("Invalid info-filter: bad syntax (%s)\n", definition);
			continue;
		}
		filter->pass = (definition[0] == '+');

		// Copy the serverinfo key name
		split = strchr(definition, '=');
		if (split != NULL) {
			split[0] = '\0';
		}
		strlcpy(filter->name, definition + 1, sizeof(filter->name));
		if (!filter->name[0]) {
			// empty key name is invalid...
			Con_Printf("Invalid info-filter: bad syntax (%s)\n", definition);
			continue;
		}

		if (split != NULL && split[1] && split[1] != '*') {
			// no regex is fine
			filter->regex = pcre2_compile((PCRE2_SPTR)(split + 1), PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &error, &error_offset, NULL);
			if (filter->regex == NULL) {
				PCRE2_UCHAR error_str[256];
				pcre2_get_error_message(error, error_str, sizeof(error_str));
				Con_Printf("Invalid rule definition: %s\n", error_str);
				continue;
			}
		}

		filter->exec = true;
	}

	return info_filters;
}

static void SB_InfoFilter_Free(info_filter_t* info_filters, int info_filter_count)
{
	int i;

	for (i = 0; i < info_filter_count; ++i) {
		if (info_filters[i].regex) {
			pcre2_code_free(info_filters[i].regex);
		}
	}

	Q_free(info_filters);
}


================================================
FILE: src/EX_browser.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __EX_BROWSER__H__
#define __EX_BROWSER__H__

#include "localtime.h"
#include "keys.h"

#define MAX_UNBOUND 200

#define MAX_SOURCES 200
#define MAX_SERVERS 1000

#define MAX_KEYS    100
#define MAX_PLAYERS 128

// column width
#define COL_PING        3
#define COL_IP          21
#define COL_NAME        60  // max
#define COL_MAP         8
#define COL_GAMEDIR     8
#define COL_PLAYERS     5
#define COL_FRAGLIMIT   2
#define COL_TIMELIMIT   2


extern cvar_t  sb_status;           // show status-bar

extern cvar_t  sb_showping;         // show ping column
extern cvar_t  sb_showaddress;      // show address colums
extern cvar_t  sb_showmap;          // show map column
extern cvar_t  sb_showgamedir;      // show gamedir column
extern cvar_t  sb_showplayers;      // show players column
extern cvar_t  sb_showfraglimit;    // show fraglimit column
extern cvar_t  sb_showtimelimit;    // show timelimit column

extern cvar_t  sb_pingtimeout;      // ping server timeout
extern cvar_t  sb_pings;            // number of pings
extern cvar_t  sb_pingspersec;      // pings per second

extern cvar_t  sb_infotimeout;      // get serverinfo timeout
extern cvar_t  sb_inforetries;      // max serverinfo retries
extern cvar_t  sb_infospersec;      // serverinfos per second

extern cvar_t  sb_mastertimeout;    // master server server timeout
extern cvar_t  sb_masterretries;    // max master-server retries
extern cvar_t  sb_nosockraw;        // when enabled, forces "new ping" (udp qw query packet, multithreaded) to be used

extern cvar_t  sb_liveupdate;       // serveinfo window update interval (0 = off)

extern cvar_t  sb_sortplayers;      // sorting mode in players list
extern cvar_t  sb_sortservers;      // sorting mode in servers list

extern cvar_t  sb_autohide;         // hide browser after connect

extern cvar_t  sb_findroutes;       // look for best available route automatically
extern cvar_t  sb_ignore_proxy;     // list of proxies excluded from the best route lookup

extern cvar_t  sb_sourcevalidity;   // source validity in minutes
extern cvar_t  sb_mastercache;      // if cache master query results

extern cvar_t  sb_hideempty;
extern cvar_t  sb_hidenotempty;
extern cvar_t  sb_hidefull;
extern cvar_t  sb_hidedead;
extern cvar_t  sb_hidehighping;
extern cvar_t  sb_pinglimit;
extern cvar_t  sb_showproxies;

typedef struct column_s
{
    char ping [COL_PING + 1];
	char bestping [COL_PING + 1];
    char ip [COL_IP + 1];
    char name [COL_NAME + 1];
    char map [COL_MAP + 1];
    char gamedir [COL_GAMEDIR + 1];
    char players [COL_PLAYERS + 1];
    char fraglimit [COL_FRAGLIMIT + 1];
    char timelimit [COL_TIMELIMIT + 1];
} columns;


typedef struct playerinfo_s
{
    int id;
    int frags;
    int time;
    int ping;
    char name[21];
    char skin[21];
    char team[21];
    int top;
    int bottom;
	qbool spec; // flag: is spectator or player
} playerinfo;

typedef enum {
	SERVER_EMPTY = 0, SERVER_NONEMPTY = 1, SERVER_FULL = 2
} server_occupancy;

typedef struct server_data_s
{
    int passed_filters;
    int ping;
	int bestping;
    netadr_t    address;
    columns     display;
    char *keys[MAX_KEYS], *values[MAX_KEYS];
    int keysn;

    playerinfo *players[MAX_PLAYERS];
    int playersn;
	server_occupancy	occupancy;
    int spectatorsn;
	qbool qizmo;
	qbool qwfwd;
	qbool support_teams; // is server support team per player
} server_data;


#define MAX_SOURCE_NAME 25

typedef enum sb_source_type_e {
	type_master,
	type_file,
	type_url,
	type_dummy
} sb_source_type_t;

typedef struct source_data_s
{
	sb_source_type_t type;           // source type
	union
	{
		netadr_t    address;            // IP for master type
		char        filename[200];      // filename for file type
		char        url[512];           // URL with the list of servers
	} address;

	char name[MAX_SOURCE_NAME+1];       // source name
	SYSTEMTIME last_update;             // last update time

	server_data **servers;              // servers list
	int serversn;                       // servers no
	int servers_allocated;              // allocated size of servers array

	int checked;                        // 1 if use this source
	int unique;                         // order in file (for sorting)
} source_data;

typedef struct player_host_s
{
    char name[21];
    server_data *serv;
} player_host;

typedef struct serverbrowser_window_s {
	int x, y, w, h;
} serverbrowser_window_t;
extern serverbrowser_window_t Browser_window;

extern server_data * show_serverinfo;

extern int resort_servers;
extern int rebuild_servers_list;
extern int resort_all_players;
extern int rebuild_all_players;
extern int ping_phase;
extern double ping_pos;
extern int updating_sources;
extern int abort_ping;
extern int source_full_update;

// sources table
extern source_data *sources[MAX_SOURCES];
extern int sourcesn;

// servers table
extern server_data *servers[MAX_SERVERS];
extern int serversn;
extern int serversn_passed;
extern int Servers_pos;
extern int resort_sources;
extern int source_unique;


// servers
server_data * Create_Server(char *ip);
server_data * Clone_Server(server_data* source);
server_data * Create_Server2(netadr_t n);
void Reset_Server(server_data *s);
void Delete_Server(server_data *s);
source_data * Create_Source(void);
void Reset_Source(source_data *s);
void Delete_Source(source_data *s);
void Update_Source(source_data *s);
void Reload_Sources(void);
void Rebuild_Servers_List(void);
void Toggle_Source(source_data *);
void Mark_Source(source_data *s);
void Unmark_Source(source_data *s);
void MarkDefaultSources(void);
void WriteSourcesConfiguration(FILE *f);
void Rebuild_All_Players(void);
void Sort_All_Players(void);
void DumpSource(source_data *s);
void RemoveFromFileSource(source_data *source, server_data *serv);
void AddToFileSource(source_data *source, server_data *serv);
int IsInSource(source_data *source, server_data *serv);

char * next_space(char *s);
char * next_nonspace(char *s);
char * next_quote(char *s);

void SB_ServerList_Lock(void);
void SB_ServerList_Unlock(void);

// sources
qbool SB_Sources_Dump(void);
int SB_Source_Add(const char* name, const char* address, sb_source_type_t type);
// asynchronous sources update (in new thread)
void SB_Sources_Update_Begin(qbool full);
// synchronous sources update
void SB_Sources_Update(qbool full);
void SB_Source_Remove(int i);


// net
void GetServerInfo(server_data *serv);
void GetServerPing(server_data *serv);
void GetServerPingsAndInfos(int full);
void GetServerPingsAndInfos_f(void);
void Start_Autoupdate(server_data *s);
void Alter_Autoupdate(server_data *s);

char *ValueForKey(server_data *s, char *k);

void SetPing999(server_data *s);
void SetPing(server_data *s, int ping);
void SB_Server_SetBestPing(server_data *s, int bestping);

void SB_Shutdown(void);
void SB_RootInit(void);    // must be called as root

// connection tester
void SB_Test_Init(char *address);
void SB_Test_Change(char *address);
void SB_Test_Frame(void);

void Browser_Init(void);
void Browser_Init2(void);

void SB_Servers_Draw (int x, int y, int w, int h);
int SB_Servers_Key(int key);
qbool SB_Servers_Mouse_Event(const mouse_state_t *ms);
void SB_Servers_OnShow (void);

void SB_Sources_Draw (int x, int y, int w, int h);
int SB_Sources_Key(int key);
qbool SB_Sources_Mouse_Event(const mouse_state_t *ms);

void SB_Players_Draw (int x, int y, int w, int h);
int SB_Players_Key(int key);
qbool SB_Players_Mouse_Event(const mouse_state_t *ms);

void SB_Specials_Draw(void);
qbool SB_Specials_Key(int key, wchar unichar);

// EX_browser_pathfind
typedef void (* proxy_ping_report_callback) (netadr_t adr, short dist);

void SB_PingTree_Init(void);
void SB_PingTree_Shutdown(void);

qbool SB_PingTree_Built(void);
void SB_PingTree_Build(void);
qbool SB_PingTree_IsBuilding(void);
void SB_PingTree_DumpPath(const netadr_t *addr);
void SB_Proxy_QueryForPingList(const netadr_t *address, proxy_ping_report_callback callback);
void SB_PingTree_ConnectBestPath(const netadr_t *addr);
int SB_PingTree_GetPathLen(const netadr_t *addr);
void SB_Proxylist_Unserialize_f(void);

#define SB_TRIGGER_REFRESHDONE        1
#define SB_TRIGGER_SOURCESUPDATED     2
#define SB_TRIGGER_NOTIFY_PINGTREE    4
extern int sb_queuedtriggers;

#endif  // __EX_BROWSER__H__


================================================
FILE: src/EX_browser_net.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#ifndef _WIN32
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#endif
#include "menu.h"
#include "EX_browser.h"
#include "sbar.h"
#include "keys.h"

extern qbool useNewPing;
int oldPingHost(char *host_to_ping, int count);
int oldPingHosts(server_data *servs[], int servsn, int count);
int PingHost(char *host_to_ping, unsigned short port, int count, int time_out);
int PingHosts(server_data *servs[], int servsn, int count);

extern sem_t serverinfo_semaphore;
// To prevent several Serverinfo threads to be started at the same time
static int serverinfo_lock;

typedef struct infohost_s
{
    double lastsenttime;
    int phase;
} infohost;

int autoupdate_serverinfo = 0;

server_data *autoupdate_server;

static const char senddata[] = {255, 255, 255, 255, 's','t','a','t','u','s',' ','2','3','\n'};

int server_during_update = 0;

int ReadInt (char *playerinfo, int *i)
{
    int s = 0, d = 0;
    char buf[100];
    while (playerinfo[s] == ' ')
        s++;
    while (playerinfo[s] != ' '  &&  playerinfo[s] != '\n'  &&  s < 99)
        buf[d++] = playerinfo[s++];

    buf[d] = 0;
    *i = atoi(buf);
    return s;
}


int ReadString (char *playerinfo, char *str)
{
    int s = 0, d = 0;
    while (playerinfo[s] == ' ')
        s++;
    if (playerinfo[s] == '\"') {
        s++;
        while (playerinfo[s] != '\"'  &&  playerinfo[s] != '\n'  &&   s < 99)
            str[d++] = playerinfo[s++];
        if (playerinfo[s] == '\"')
            s++;
    }

    str[d] = 0;
    return s;
}

char *ValueForKey(server_data *s, char *k)
{
    int i;
    for (i=0; i < s->keysn; i++)
        if (s->keys[i] && !strcmp(k, s->keys[i]))
            return s->values[i];

    return NULL;
}

void SetPing(server_data *s, int ping)
{
    if (ping < 0)
        strlcpy (s->display.ping, "n/a", sizeof (s->display.ping));
    else
        snprintf (s->display.ping, sizeof (s->display.ping), "%3d", ping > 999 ? 999 : ping);

    s->ping = ping;
	
	SB_Server_SetBestPing(s, -1);
}

void SB_Server_SetBestPing(server_data *s, int bestping)
{
    if (bestping < 0)
        strlcpy (s->display.bestping, "n/a", sizeof (s->display.bestping));
    else
        snprintf (s->display.bestping, sizeof (s->display.bestping), "%3d", bestping > 999 ? 999 : bestping);

    s->bestping = bestping;
}

qbool SB_AllServersDead(void)
{
	int i;
	
	for (i = 0; i < serversn; i++) {
		if (servers[i]->ping != -1) {
			return false;
		}
	}
	
	return true;
}

qbool SB_IsServerQWfwd(server_data *s)
{
	char *ident_match = "qwfwd";
	size_t match_len = strlen(ident_match);
	char *ident_value = ValueForKey(s, "*version");
	
	if (ident_value) {
		return strncmp(ident_value, ident_match, match_len) == 0;
	}
	else
	{
		return false;
	}
}

void Parse_Serverinfo(server_data *s, char *info)
{
    int i, j;
    char *pinfo;
    char *tmp;

    s->passed_filters = 1;
    s->support_teams = false; // by default server does't support team info per player

    if (strncmp(info, "\xFF\xFF\xFF\xFFn", 5))
    {
        SetPing(s, -1);
        return;
    }

    pinfo = strchr(info, '\n');
    if (pinfo != NULL)
        *(pinfo++) = 0;

    info += 5;

    while (*info == '\\'  &&  s->keysn < MAX_KEYS)
    {
        char *i2, *i3;
        i2 = strchr(info+1, '\\');
        if (i2 == NULL)
            break;
        i3 = strchr(i2+1, '\\');
        if (i3 == NULL)
            i3 = info + strlen(info);

        s->keys[s->keysn] = (char *) Q_malloc(i2-info);
        strlcpy(s->keys[s->keysn], info+1, i2-info);

        s->values[s->keysn] = (char *) Q_malloc(i3-i2);
        strlcpy(s->values[s->keysn], i2+1, i3-i2);

        s->keysn++;

        info = i3;
    }

    // read players

    for (i = s->spectatorsn = s->playersn = 0; pinfo  &&  strchr(pinfo, '\n'); i++)
    {
        qbool spec;
        int id, frags, time, ping, slen;
        char name[100], skin[100], team[100];
        char *nameptr = name;
        int top, bottom;
        int pos;

        if (s->playersn + s->spectatorsn >= MAX_PLAYERS)
            break;  // man

        pos = 0;
        pos += ReadInt(pinfo+pos, &id);
        pos += ReadInt(pinfo+pos, &frags);
        pos += ReadInt(pinfo+pos, &time);
        pos += ReadInt(pinfo+pos, &ping);
        pos += ReadString(pinfo+pos, name);
        pos += ReadString(pinfo+pos, skin);
        pos += ReadInt(pinfo+pos, &top);
        pos += ReadInt(pinfo+pos, &bottom);
        pos += ReadString(pinfo+pos, team);

        if (team[0])
            s->support_teams = true; // seems server support team info per player

        if (ping > 0) { // seems player if relay on ping
            spec = false;
            s->playersn++;
        }
        else // spec
        {
            spec = true;
            slen = strlen(name);
            s->spectatorsn++;
            ping = -ping;

            if (name[0] == '\\' && name[1] == 's' && name[2] == '\\')
                nameptr = name+3; // strip \s\<name>
            else if (slen > 3 && name[slen-3] == '(' && name[slen-2] == 's' && name[slen-1] == ')')
                name[slen-3] = 0; // strip <name>(s) for old servers
        }

        s->players[i] = (playerinfo *)Q_malloc(sizeof(playerinfo));
        s->players[i]->id = id;
        s->players[i]->frags = frags;
        s->players[i]->time = time;
        s->players[i]->ping = ping;
        s->players[i]->spec = spec;

        s->players[i]->top = Sbar_ColorForMap(top);
        s->players[i]->bottom = Sbar_ColorForMap(bottom);

        strlcpy(s->players[i]->name, nameptr, sizeof(s->players[0]->name));
        strlcpy(s->players[i]->skin, skin, sizeof(s->players[0]->skin));
        strlcpy(s->players[i]->team, team, sizeof(s->players[0]->team));

        pinfo = strchr(pinfo, '\n') + 1;
    }

    {
    void *swap;
    int n;
    // sort players by frags
    n = s->playersn + s->spectatorsn - 2;
    for (i = 0; i <= n; i++)
        for (j = n; j >= i; j--)
            if (s->players[j] && s->players[j+1] && s->players[j]->frags < s->players[j+1]->frags)
            {
                swap = (void*)s->players[j];
                s->players[j] = s->players[j+1];
                s->players[j+1] = (playerinfo*)swap;
            }
    // sort keys
    n = s->keysn - 2;
    for (i = 0; i <= n; i++)
        for (j = n; j >= i; j--)
            if (strcasecmp(s->keys[j], s->keys[j+1]) > 0)
            {
                swap = (void*)s->keys[j];
                s->keys[j] = s->keys[j+1];
                s->keys[j+1] = (char*)swap;
                swap = (void*)s->values[j];
                s->values[j] = s->values[j+1];
                s->values[j+1] = (char*)swap;
            }
    }

    // fill-in display
	s->qwfwd = SB_IsServerQWfwd(s);

    tmp = ValueForKey(s, "hostname");
    if (tmp != NULL)
        snprintf (s->display.name, sizeof (s->display.name),"%-.*s", COL_NAME, tmp);
    else
        return;

    tmp = ValueForKey(s, "fraglimit");
    if (tmp != NULL)
        snprintf(s->display.fraglimit, sizeof (s->display.fraglimit), "%*.*s", COL_FRAGLIMIT, COL_FRAGLIMIT, strlen(tmp) > COL_FRAGLIMIT ? "999" : tmp);

    tmp = ValueForKey(s, "timelimit");
    if (tmp != NULL)
        snprintf(s->display.timelimit, sizeof (s->display.timelimit), "%*.*s", COL_TIMELIMIT, COL_TIMELIMIT, strlen(tmp) > COL_TIMELIMIT ? "99" : tmp);

    tmp = ValueForKey(s, "*gamedir");
    s->qizmo = false;
    if (tmp != NULL)
        snprintf(s->display.gamedir, sizeof (s->display.gamedir) ,"%.*s", COL_GAMEDIR, tmp==NULL ? "" : tmp);
    else
    {
        tmp = ValueForKey(s, "*progs");
        if (tmp != NULL  &&  !strcmp(tmp, "666"))
        {
            snprintf(s->display.gamedir, sizeof (s->display.gamedir), "qizmo");
            s->qizmo = true;
        }
    }

    tmp = ValueForKey(s, "map");
    if (tmp != NULL)
        snprintf(s->display.map, sizeof (s->display.map), "%-.*s", COL_MAP, tmp==NULL ? "" : tmp);

    tmp = ValueForKey(s, "maxclients");
    if (!tmp || strlen(tmp) > 2)
        tmp = "99";
    i = s->playersn > 99 ? 99 : s->playersn;
    if (i < 1) { s->occupancy = SERVER_EMPTY; }
    else if (i > 0 && i < atoi(tmp)) { s->occupancy = SERVER_NONEMPTY; }
    else { s->occupancy = SERVER_FULL; }
    if (tmp != NULL)
        snprintf(s->display.players, sizeof (s->display.players), "%2d/%-2s", i, tmp==NULL ? "" : tmp);
}

void GetServerInfo(server_data *serv)
{
    socket_t newsocket;
    struct sockaddr_storage server;
    int ret;
    char answer[5000];
    fd_set fd;
    struct timeval tv;

    // so we have a socket
    newsocket = UDP_OpenSocket(PORT_ANY);
    NetadrToSockadr (&(serv->address), &server);

    // send status request
    ret = sendto (newsocket, senddata, sizeof(senddata), 0,
                  (struct sockaddr *)&server, sizeof(server) );

    if (ret == -1)
        return;

    //fd.fd_count = 1;
    //fd.fd_array[0] = newsocket;
    FD_ZERO(&fd);
    FD_SET(newsocket, &fd);
    tv.tv_sec = 0;
    tv.tv_usec = 1000 * 1.5 * sb_infotimeout.value; // multiply timeout by 1.5
    ret = select(newsocket+1, &fd, NULL, NULL, &tv);

    // get answer
    if (ret > 0)
        ret = recvfrom (newsocket, answer, 5000, 0, NULL, NULL);

    if (ret > 0  &&  ret < 5000)
    {
        answer[ret] = 0;
        server_during_update = 1;
        Reset_Server(serv);
        Parse_Serverinfo(serv, answer);
        server_during_update = 0;
    }
    closesocket(newsocket);
}

//
// Gets multiple server info simultaneously
//

int GetServerInfosProc(void * lpParameter)
{
    infohost *hosts;   // 0 if not sent yet, -1 if data read
    double interval, lastsenttime;

    socket_t newsocket;
    struct sockaddr_storage dest;
    int ret, i;
    fd_set fd;
    struct timeval timeout;

    if (abort_ping)
        return 0;

    // so we have a socket
    newsocket = UDP_OpenSocket(PORT_ANY);

    hosts = (infohost *) Q_malloc (serversn * sizeof(infohost));
    for (i=0; i < serversn; i++)
    {
        hosts[i].phase = 0;
        hosts[i].lastsenttime = -1000;
        Reset_Server(servers[i]);

        // do not update dead servers
		if (servers[i]->ping < 0) {
            hosts[i].phase = -1;//(int)sb_inforetries.value;
		}
		// do not update too distant servers
		else if (sb_hidehighping.integer && servers[i]->ping > sb_pinglimit.integer) {
			hosts[i].phase = -1;
		}
    }

    interval = (1000.0 / sb_infospersec.value) / 1000;
    lastsenttime = Sys_DoubleTime() - interval;
    timeout.tv_sec = 0;
    timeout.tv_usec = (long)(interval * 1000.0 * 1000.0 / 2);

    ping_pos = 0;

    while (1  &&  !abort_ping)
    {
        int index = -1;
        double time = Sys_DoubleTime();

        // if it is time to send next request
        if (time > lastsenttime + interval)
        {
            int finished = 0;
            int to_ask = 0;
            int phase = (int)(sb_inforetries.value);

            // find next server to ask
            for (i=0; i < serversn; i++)
            {
                if (hosts[i].phase < phase  &&  hosts[i].phase >= 0  &&
                    time > hosts[i].lastsenttime + (sb_infotimeout.value / 1000))
                {
                    index = i;
                    phase = hosts[i].phase;
                }

                if (hosts[i].phase >= (int)sb_inforetries.value)
                    finished++;
                else
                    if (hosts[i].phase >= 0)
                        to_ask++;
            }
            //ping_pos = finished / (double)serversn;
            ping_pos = (finished+to_ask <= 0) ? 0 :
            finished / (double)(finished+to_ask);
        }

        // check if we should finish
        if (index < 0)
            if (time > lastsenttime + 1.2 * (sb_infotimeout.value / 1000))
                break;

        // send status request
        if (index >= 0)
        {
            hosts[index].phase ++;
            hosts[index].lastsenttime = time;
            lastsenttime = time;

            NetadrToSockadr (&(servers[index]->address), &dest);

            ret = sendto (newsocket, senddata, sizeof(senddata), 0,
                          (struct sockaddr *)&dest, sizeof(*(struct sockaddr *)&dest));
            if(ret < 0)
            {
                Com_DPrintf("sendto() gave errno = %d : %s\n", errno, strerror(errno));
            }
            if (ret == -1)
                ;//return;

            // requests_sent++;
            // ping_pos = requests_total <= 0 ? 0 : requests_sent / (double)requests_total;
        }

        // check if answer arrived and decode it
        //fd.fd_count = 1;
        //fd.fd_array[0] = newsocket;
        FD_ZERO(&fd);
        FD_SET(newsocket, &fd);

        ret = select(newsocket+1, &fd, NULL, NULL, &timeout);
        if (ret < 1)
        {
            Com_DPrintf("select() gave errno = %d : %s\n", errno, strerror(errno));
        }

        if (FD_ISSET(newsocket, &fd))
        {
            struct sockaddr_storage hostaddr;
            netadr_t from;
            int i;
            char answer[5000];
            answer[0] = 0;

            i = sizeof(hostaddr);
            ret = recvfrom (newsocket, answer, 5000, 0, (struct sockaddr *)&hostaddr, (socklen_t *)&i);
            answer[max(0, min(ret, 4999))] = 0;

            if (ret > 0)
            {
                SockadrToNetadr (&hostaddr, &from);

                for (i=0; i < serversn; i++)
                    if (from.ip[0] == servers[i]->address.ip[0] &&
                        from.ip[1] == servers[i]->address.ip[1] &&
                        from.ip[2] == servers[i]->address.ip[2] &&
                        from.ip[3] == servers[i]->address.ip[3] &&
                        from.port == servers[i]->address.port)
                    {
                        hosts[i].phase = (int)sb_inforetries.value;
                        Parse_Serverinfo(servers[i], answer);
                        break;
                    }
            }
        }
    }

    // reset pings to 999 if server didn't answer
    for (i=0; i < serversn; i++)
        if (servers[i]->keysn <= 0)
            SetPing(servers[i], -1);

    closesocket(newsocket);
    Q_free(hosts);

    return 0;
}

void GetServerPing(server_data *serv)
{
    int p;
    char buf[32];
    snprintf (buf, sizeof (buf), "%d.%d.%d.%d",
        serv->address.ip[0],
        serv->address.ip[1],
        serv->address.ip[2],
        serv->address.ip[3]);

    p = useNewPing
			// new ping = UPD QW Packet
			? PingHost(buf, serv->address.port, (int)max(1, min(sb_pings.value, 10)), sb_pingtimeout.value)
			// old ping = ICMP PING Packet
			: oldPingHost(buf, (int)max(1, min(sb_pings.value, 10)));
    
	if (p)
        SetPing(serv, p-1);
    else
        SetPing(serv, p-1);
}

int GetServerPingsAndInfosProc(void * lpParameter)
{
	unsigned int SB_Sources_Marked_Count(void);
	extern cvar_t sb_listcache;
	extern void SB_Serverlist_Serialize_f(void);

	int full = (int)(uintptr_t)lpParameter;
    abort_ping = 0;

	if (full || serversn_passed == 0) {
		if (SB_Sources_Marked_Count() == 0) {
			// ensure some sources are marked, otherwise the refresh makes no sense
			MarkDefaultSources();
		}

		SB_Sources_Update(true);
		if (useNewPing) {
			// New Ping = UPD QW Packet ping using 2 threads (sender and receiver)
			PingHosts(servers, serversn, sb_pings.integer);
		}
		else {
			// Old Ping = ICMP PING Packet using single thread
			oldPingHosts(servers, serversn, sb_pings.integer );	
		}
	}

    if (!abort_ping)
    {
        ping_phase = 2;
        GetServerInfosProc(NULL);
    }

    /*
	if (abort_ping)
        Sys_MSleep(500);    // let the packets end the road
	*/

    resort_servers = 1;
    rebuild_all_players = 1;
    ping_phase = 0;

	sb_queuedtriggers |= SB_TRIGGER_REFRESHDONE;

	if (sb_listcache.integer) {
		SB_Serverlist_Serialize_f();
	}

	if (sb_findroutes.integer && (full || !SB_PingTree_Built())) {
		SB_PingTree_Build();
	}

	serverinfo_lock = 0;
    return 0;
}

void GetServerPingsAndInfos(int full)
{
	if (serverinfo_lock || SB_PingTree_IsBuilding()) {
		Com_Printf("Server list refresh is still pending\n");
		return;
	}

	serverinfo_lock = 1;

	if (rebuild_servers_list)
		Rebuild_Servers_List();

	if (rebuild_all_players  &&  show_serverinfo == NULL)
		Rebuild_All_Players();

	if (serversn <= 0 || (sb_hidedead.integer == 0 && SB_AllServersDead())) {
		// there's a possibility that sources hasn't been queried yet
		// so let's do a full update, that ensures sources are updated
		full = true;
	}

	ping_phase = 1;
	ping_pos = 0;

	if (Sys_CreateDetachedThread (GetServerPingsAndInfosProc, (void *)(uintptr_t)full) < 0) {
		Com_Printf("Failed to create GetServerPingsAndInfosProc thread\n");
	}
}

void GetServerPingsAndInfos_f(void)
{
	qbool full = true;
	if (Cmd_Argc() > 0 && strcmp(Cmd_Argv(1), "info") == 0) {
		full = false;
	}
	GetServerPingsAndInfos(full);
}

//
// autoupdate serverinfo
//

int AutoupdateProc(void * lpParameter)
{
    double lastupdatetime = -1;

    while (autoupdate_serverinfo)
    {
        double time = Sys_DoubleTime();

        if ((sb_liveupdate.integer > 0)  &&
            time >= lastupdatetime + sb_liveupdate.integer  &&
            key_dest == key_menu /* todo: add "on server list tab" condition here */)
        {
            server_data *serv;
			
			Sys_SemWait(&serverinfo_semaphore);
			serv = autoupdate_server;
			if (serv != NULL)
            {
                GetServerInfo(serv);
                lastupdatetime = time;
            }
			Sys_SemPost(&serverinfo_semaphore);
		}
		
		Sys_MSleep(1000); // we don't need nor allow updates faster than 1 second anyway
    }
    return 0;
}

void Start_Autoupdate(server_data *s)
{
    autoupdate_server = s;
    if (Sys_CreateDetachedThread(AutoupdateProc, (void *) s) < 0) {
	    Com_Printf("Failed to create AutoupdateProc thread\n");
    }
}

void Alter_Autoupdate(server_data *s)
{
    autoupdate_server = s;
}


================================================
FILE: src/EX_browser_pathfind.c
================================================
/*
Copyright (C) 2011 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
	\file

	\brief
	Module for finding best connection to a server, ping-wise.

	\author johnnycz
**/

#include "quakedef.h"
#include <limits.h>
#ifndef _WIN32
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#endif
#include "EX_browser.h"

// declared in EX_browser.c
extern cvar_t sb_proxinfopersec;
extern cvar_t sb_proxretries;
extern cvar_t sb_proxtimeout;
extern cvar_t sb_listcache;

// non-leaf = proxy (or users computer) = has more than 1 neighbour
// at the time of writing this code there were 10 active proxies around the world
#define MAX_NONLEAVES 40

#define PROXY_PINGLIST_QUERY "\xff\xff\xff\xffpingstatus"
#define PROXY_PINGLIST_QUERY_LEN (sizeof(PROXY_PINGLIST_QUERY)-1)
#define PROXY_REPLY_ENTRY_LEN 8
#define PROXY_REPLY_BUFFER_SIZE (PROXY_REPLY_ENTRY_LEN*MAX_SERVERS)

// current amount of qw servers ~ 300... but neighbour count means MAX_SERVERS*MAX_NONLEAVES
#define INVALID_NODE (-1)
typedef int nodeid_t;

// only pings 0-999 are in our interest; and -1 for invalid ping
#define DIST_INFINITY SHRT_MAX
typedef short dist_t;

// trick around language limits - allows to copy 4 bytes with "="
typedef struct ipaddr_t {
	byte data[4];
} ipaddr_t;

typedef struct ping_node_t {
	ipaddr_t ipaddr;
	nodeid_t prev;           // previous node on the shortest path
	nodeid_t nlist_start;    // index of the first neighbour
	nodeid_t nlist_end;      // index of the last neighbour + 1
	dist_t dist;              // distance (= ping)
	qbool visited;
	unsigned short proxport; // if there's a proxy on this address,
	                         // this is the port it's running on
	                         // and it is already in the network format
} ping_node_t;

typedef struct ping_neighbour_t {
	nodeid_t id;
	dist_t dist;
} ping_neighbour_t;

typedef struct proxy_query_request_t {
	socket_t sock;
	nodeid_t nodeid;
	qbool done;
} proxy_query_request_t;

typedef struct proxy_request_queue_t {
	proxy_query_request_t *data;
	size_t items;
	qbool sending_done; // sending thread ended
	qbool allrecved;	// all proxies have been successfully scanned
} proxy_request_queue;

static ping_node_t ping_nodes[MAX_SERVERS];
static nodeid_t ping_nodes_count = 0;
#define MAX_SERVERS_BLOCKSIZE (MAX_SERVERS*MAX_NONLEAVES)
static ping_neighbour_t* ping_neighbours;
static unsigned long ping_neighbours_max;
static nodeid_t ping_neighbours_count = 0;

static nodeid_t startnode_id = 0;

static qbool building_pingtree = false; // when true, the pingtree build thread is still working
static qbool pingtree_built = false;

static sem_t phase2thread_lock;

static void SB_PingTree_Assertions(void)
{
	if (ping_nodes_count >= MAX_SERVERS) {
		Sys_Error("EX_Browser_pathfind: max nodes count reached");
	}

	if (ping_neighbours_count >= ping_neighbours_max) {
		while (ping_neighbours_count >= ping_neighbours_max)
			ping_neighbours_max += MAX_SERVERS_BLOCKSIZE;
		ping_neighbours = Q_realloc(ping_neighbours, ping_neighbours_max * sizeof(ping_neighbour_t));
		if (!ping_neighbours) {
			Sys_Error("EX_Browser_pathfind: max neighbours count reached");
		}
	}

	if (startnode_id != 0) {
		// a bit paranoid check, startnode is always the first node
		Sys_Error("EX_browser_pathfind: startnode_id != 0");
	}
}

static int SB_PingTree_FindIp(ipaddr_t ipaddr)
{
	int i;

	// xxx make the lookup faster than linear
	for (i = 0; i < ping_nodes_count; i++) {
		if (memcmp(&ping_nodes[i].ipaddr, &ipaddr, sizeof(ipaddr_t)) == 0) {
			return i;
		}
	}

	return INVALID_NODE;
}

static int SB_PingTree_AddNode(ipaddr_t ipaddr, unsigned short proxport)
{
	int id = SB_PingTree_FindIp(ipaddr);

	if (id != INVALID_NODE) {
		if (proxport && !ping_nodes[id].proxport) {
			ping_nodes[id].proxport = proxport;
		}
		return id;
	}

	id = ping_nodes_count++;

	SB_PingTree_Assertions();
	ping_nodes[id].ipaddr = ipaddr;
	ping_nodes[id].prev = INVALID_NODE;
	ping_nodes[id].nlist_start = INVALID_NODE;
	ping_nodes[id].nlist_end = INVALID_NODE;
	ping_nodes[id].dist = DIST_INFINITY;
	ping_nodes[id].proxport = proxport;
	ping_nodes[id].visited = false;
	SB_PingTree_Assertions();

	return id;
}

static int SB_PingTree_AddNeighbour(nodeid_t neighbour_id, dist_t dist)
{
	int id = ping_neighbours_count++;

	SB_PingTree_Assertions();
	ping_neighbours[id].id = neighbour_id;
	ping_neighbours[id].dist = dist;
	SB_PingTree_Assertions();

	return id;
}

static ipaddr_t SB_DummyIpAddr(void)
{
	ipaddr_t dummy = {{0, 0, 0, 0}};
	return dummy;
}

static void SB_PingTree_AddSelf(void)
{
	startnode_id = SB_PingTree_AddNode(SB_DummyIpAddr(), 0);
}

static void SB_PingTree_Clear(void)
{
	ping_nodes_count = 0;
	ping_neighbours_count = 0;
	SB_PingTree_AddSelf();
}

static ipaddr_t SB_Netaddr2Ipaddr(const netadr_t *netadr)
{
	ipaddr_t retval;
	memcpy(retval.data, &netadr->ip, 4);
	return retval;
}

static qbool SB_PingTree_IsServerDead(const server_data *data)
{
	return data->ping < 0;
}

static qbool SB_PingTree_IsProxyFiltered(const server_data *data)
{
	if (!data->qwfwd) {
		return false;
	}
	else if (sb_ignore_proxy.string[0] == '\0') {
		return false;
	}
	else {
		char ip_str[32];
		const byte *ip = data->address.ip;
		int port = (int) ntohs(data->address.port);
		
		snprintf(&ip_str[0], sizeof(ip_str), "%d.%d.%d.%d:%d", ip[0], ip[1], ip[2], ip[3], port);

		return strstr(sb_ignore_proxy.string, ip_str) != NULL;
	}
}

static nodeid_t SB_PingTree_AddServer(const server_data *data)
{
	nodeid_t node_id = INVALID_NODE;

	if (!SB_PingTree_IsServerDead(data) && !SB_PingTree_IsProxyFiltered(data)) {
			node_id = SB_PingTree_AddNode(SB_Netaddr2Ipaddr(&data->address),
				data->qwfwd ? data->address.port : 0);

		SB_PingTree_AddNeighbour(node_id, data->ping);
	}
	
	return node_id;
}

static void SB_PingTree_AddProxyPing(netadr_t adr, dist_t dist)
{
	nodeid_t id_neighbour;
	ipaddr_t ip = SB_Netaddr2Ipaddr(&adr);

	id_neighbour = SB_PingTree_FindIp(ip); // most of the servers should be found
	if (id_neighbour == INVALID_NODE) {
		// strange - there is no direct route to this server, but a proxy can reach it (!)
		id_neighbour = SB_PingTree_AddNode(ip, 0);
	}
	
	SB_PingTree_AddNeighbour(id_neighbour, dist);
}

static void SB_Proxy_ParseReply(const byte *buf, size_t buflen, proxy_ping_report_callback callback)
{
	size_t entries = buflen / PROXY_REPLY_ENTRY_LEN;
	int i;

	Com_DPrintf("Reading %d entries from a proxy reply\n", entries);

	for (i = 0; i < entries; i++) {
		netadr_t adr;
		dist_t dist = 0;

		adr.type = NA_IP;
		memcpy(adr.ip, buf, 4);
		buf += 4;
		
		adr.port = 0;
		adr.port |= 0x00FF & *buf++;
		adr.port |= 0xFF00 & (*buf++ << 8);

		dist |= 0x00FF & *buf++;
		dist |= 0xFF00 & (*buf++ << 8);

		if (dist >= 0) {
			// "server not reachable" is reported as 65536, in our case -1
			callback(adr, dist);
		}
	}
}

void SB_Proxy_QueryForPingList(const netadr_t *address, proxy_ping_report_callback callback)
{
	byte buf[PROXY_REPLY_BUFFER_SIZE];
	char packet[] = PROXY_PINGLIST_QUERY;
	char adrstr[32];
	struct sockaddr_in addr_to, addr_from;
	struct timeval timeout;
	fd_set fd;
	socket_t sock;
	int i, ret;
	socklen_t inaddrlen;

	snprintf(&adrstr[0], sizeof(adrstr), "%d.%d.%d.%d", (int) address->ip[0], (int) address->ip[1], (int) address->ip[2], (int) address->ip[3]);

	addr_to.sin_addr.s_addr = inet_addr((const char *)adrstr);
	if (addr_to.sin_addr.s_addr == INADDR_NONE) {
		return;
	}
	addr_to.sin_family = AF_INET;
	addr_to.sin_port = address->port;

	sock = UDP_OpenSocket(PORT_ANY);
	for (i = 0; i < sb_proxretries.integer; i++) {
		ret = sendto(sock, packet, strlen(packet), 0, (struct sockaddr *)&addr_to, sizeof(struct sockaddr));
		if (ret == -1) // failure, try again
			continue;

_select:
		FD_ZERO(&fd);
		FD_SET(sock, &fd);
		timeout.tv_sec = 0;
		timeout.tv_usec = sb_proxtimeout.integer * 1000;
		ret = select(sock+1, &fd, NULL, NULL, &timeout);
		if (ret <= 0) { // timed out or error
			Com_DPrintf("select() gave errno = %d : %s\n", errno, strerror(errno));
			continue;
		}

		inaddrlen = sizeof(struct sockaddr_in);
		ret = recvfrom(sock, (char *) buf, sizeof(buf), 0, (struct sockaddr *)&addr_from, &inaddrlen);

		if (ret == -1) // failure, try again
			continue;
		if (addr_from.sin_addr.s_addr != addr_to.sin_addr.s_addr) // martian, discard and see if a valid response came in after it
			goto _select;
		if (strncmp("\xff\xff\xff\xffn", (char *) buf, 5) == 0)
			SB_Proxy_ParseReply(buf+5, ret-5, callback);

		break;
	}
	closesocket(sock);
}

static void SB_PingTree_AddNodes(void)
{
	int i;
	
	// add our neighbours - servers we directly ping
	SB_ServerList_Lock();
	ping_nodes[startnode_id].nlist_start = ping_neighbours_count;
	for (i = 0; i < serversn; i++) {
		SB_PingTree_AddServer(servers[i]);
	}
	ping_nodes[startnode_id].nlist_end = ping_neighbours_count;
	SB_ServerList_Unlock();
}

static netadr_t SB_NodeNetadr_Get(nodeid_t id)
{
	netadr_t ret;
	ret.type = NA_IP;
	ret.port = ping_nodes[id].proxport;
	memcpy(&ret.ip, ping_nodes[id].ipaddr.data, 4);
	return ret;
}

int SB_PingTree_SendQueryThread(void *thread_arg)
{
	proxy_request_queue *queue = (proxy_request_queue *) thread_arg;
	int i, ret;
	double interval_ms;
#ifdef _WIN32
	timerresolution_session_t timersession = {0, 0};
#endif

	// Null check for queue
	if (!queue) {
		Com_DPrintf("SB_PingTree_SendQueryThread: queue is NULL\n");
		return -1;
	}

	// Null check for queue data
	if (!queue->data) {
		Com_DPrintf("SB_PingTree_SendQueryThread: queue->data is NULL\n");
		return -1;
	}

	interval_ms = (1.0 / sb_proxinfopersec.value) * 1000.0;

	Sys_TimerResolution_InitSession(&timersession);
	Sys_TimerResolution_RequestMinimum(&timersession);

	for (i = 0; i < queue->items; i++) {
		if (!queue->data[i].done) {
			struct sockaddr_storage addr_to;
			netadr_t netadr;

			// Validate nodeid
			if (queue->data[i].nodeid < 0 || queue->data[i].nodeid >= ping_nodes_count) {
				Com_DPrintf("SB_PingTree_SendQueryThread: invalid nodeid %d\n", queue->data[i].nodeid);
				continue;
			}

			netadr = SB_NodeNetadr_Get(queue->data[i].nodeid);

			NetadrToSockadr(&netadr, &addr_to);
			ret = sendto(queue->data[i].sock,
				PROXY_PINGLIST_QUERY, PROXY_PINGLIST_QUERY_LEN, 0,
				(struct sockaddr *) &addr_to, sizeof (struct sockaddr));
			if (ret < 0) {
				Com_DPrintf("SB_PingTree_SendQueryThread sendto returned %d\n", ret);
			}
			Sys_MSleep(interval_ms);
		}

		if (queue->allrecved) break;
	}

	Sys_TimerResolution_Clear(&timersession);

	queue->sending_done = true;

	return 0;
}

#define PROXY_SERIALIZE_FILE_VERSION 1
void SB_Proxylist_Serialize_Start(FILE *f)
{
	int version = PROXY_SERIALIZE_FILE_VERSION;

	// header
	// - version
	fwrite(&version, sizeof(int), 1, f);
}

void SB_Proxylist_Serialize_Reply(FILE *f, netadr_t proxy, void *buf, size_t buflen)
{
	fwrite(&proxy, sizeof(netadr_t), 1, f);
	fwrite(&buflen, sizeof(size_t), 1, f);
	fwrite(buf, buflen, 1, f);
}

void SB_Proxylist_Serialize_End(FILE *f)
{
	netadr_t invalid;

	invalid.type = NA_INVALID;
	fwrite(&invalid, sizeof(netadr_t), 1, f);
}

static qbool SB_PingTree_RecvQuery(proxy_request_queue *queue, FILE *f)
{
	qbool last_cycle = false;
	fd_set recvset;
	int maxsock = 0;
	int i, ret;
	struct timeval timeout;
	qbool allrecved = false;

	timeout.tv_sec = 0;
	timeout.tv_usec = sb_proxtimeout.integer * 1000;

	for (;;) {
		if (queue->sending_done) {
			last_cycle = true;
		}
		
		allrecved = true;
		FD_ZERO(&recvset);
		for (i = 0; i < queue->items; i++) {
			if (!queue->data[i].done) {
				socket_t sock = queue->data[i].sock;
				FD_SET(sock, &recvset);
				if ((int) sock > maxsock) {
					maxsock = (int) sock;
				}
				allrecved = false;
			}
		}
		if (allrecved) {
			queue->allrecved = true;
			break;
		}

		ret = select((maxsock + 1), &recvset, NULL, NULL, &timeout);

		if (ret == 0 && last_cycle == true) {
			break; // ret = 0 means we got timeout
		}

		if (ret == 0) {
			continue; // not all proxies were queried yet
		}

		if (ret < 0) {
			Com_DPrintf("select returned %d\n", ret);
			break;
		}

		for (i = 0; i < queue->items; i++) {
			if (!queue->data[i].done && FD_ISSET(queue->data[i].sock, &recvset)) {
				byte buf[PROXY_REPLY_BUFFER_SIZE];
				struct sockaddr_storage addr_from;
				socklen_t addr_from_len = sizeof(struct sockaddr_in);

				ret = recvfrom(queue->data[i].sock, (char *) buf, PROXY_REPLY_BUFFER_SIZE, 0, (struct sockaddr *) &addr_from, &addr_from_len);
				if (ret == -1) {
					Com_DPrintf("SB_PingTree_RecvQuery recvfrom failed\n");
					continue;
				}

				if (strncmp("\xff\xff\xff\xffn", (char *) buf, 5) == 0) {
					nodeid_t id = queue->data[i].nodeid;
					queue->data[i].done = true;
					ping_nodes[id].nlist_start = ping_neighbours_count;
					if (f && ret > 5)
							SB_Proxylist_Serialize_Reply(f, SB_NodeNetadr_Get(id), buf+5, ret-5);
					SB_Proxy_ParseReply(buf+5, ret-5, SB_PingTree_AddProxyPing);
					ping_nodes[id].nlist_end = ping_neighbours_count;
				}
				else {
					Com_DPrintf("Invalid reply received\n");
				}
			}
		}
	}

	return allrecved;
}

static void SB_PingTree_ScanProxies(void)
{
	int i;
	proxy_request_queue *queue = NULL;
	size_t request = 0;
	FILE *f = NULL;

	// Allocate queue on heap
	queue = (proxy_request_queue *) Q_malloc(sizeof(proxy_request_queue));
	if (!queue) {
		Com_Printf("Failed to allocate memory for proxy request queue\n");
		return;
	}

	// Initialize queue fields
	queue->data = NULL;
	queue->items = 0;
	queue->sending_done = false;
	queue->allrecved = false;

	for (i = 0; i < ping_nodes_count; i++) {
		if (ping_nodes[i].proxport) {
			queue->items++;
		}
	}

	if (!queue->items) {
		Q_free(queue);
		return;
	}

	queue->data = (proxy_query_request_t *) Q_malloc(sizeof(proxy_query_request_t) * queue->items);
	if (!queue->data) {
		Com_Printf("Failed to allocate memory for proxy request data\n");
		Q_free(queue);
		return;
	}

	for (i = 0; i < ping_nodes_count; i++) {
		if (ping_nodes[i].proxport) {
			queue->data[request].done = false;
			queue->data[request].nodeid = i;
			queue->data[request].sock = UDP_OpenSocket(PORT_ANY);
			request++;
		}
	}

	if (sb_listcache.value) {
		char prx_data_path[MAX_OSPATH] = {0};

		snprintf(&prx_data_path[0], sizeof(prx_data_path), "%s/%s", com_homedir, "proxies_data");
		f = fopen(prx_data_path, "wb");
		if (f)
			SB_Proxylist_Serialize_Start(f);
	}

	for (i = 0; i < sb_proxretries.integer; i++) {
		queue->sending_done = false;
		if (Sys_CreateDetachedThread(SB_PingTree_SendQueryThread, (void *) queue) < 0) {
			Com_Printf("Failed to create SB_PingTree_SendQueryThread thread\n");
			// If thread creation fails, don't continue with this retry
			continue;
		}
		SB_PingTree_RecvQuery(queue, f);
		
		// Wait for the sending thread to complete before next retry
		while (!queue->sending_done) {
			Sys_MSleep(10);
		}
		
		if (queue->allrecved) {
			break;
		}
	}

	if (f) {
		SB_Proxylist_Serialize_End(f);
		fclose(f);
	}

	for (i = 0; i < queue->items; i++) {
		closesocket(queue->data[i].sock);
	}

	Q_free(queue->data);
	Q_free(queue);
}

static nodeid_t SB_PingTree_NearestNodeGet(void)
{
	// XXX: implement using binary/fibonacci heap...
	int i;
	nodeid_t ret = INVALID_NODE;
	dist_t minimum = DIST_INFINITY;

	for (i = 0; i < ping_nodes_count; i++) {
		if (!ping_nodes[i].visited && ping_nodes[i].dist < minimum) {
			ret = i;
			minimum = ping_nodes[i].dist;
		}
	}

	return ret;
}

static void SB_PingTree_Dijkstra(void)
{
	int i;

	ping_nodes[startnode_id].dist = 0;

	for (;;) {
		nodeid_t cur = SB_PingTree_NearestNodeGet();
		if (cur == INVALID_NODE) break;

		ping_nodes[cur].visited = true;
		for (i = ping_nodes[cur].nlist_start; i < ping_nodes[cur].nlist_end; i++) {
			dist_t altdist = ping_nodes[cur].dist + ping_neighbours[i].dist;
			if (altdist < ping_nodes[ping_neighbours[i].id].dist) {
				// so-called Relax()
				ping_nodes[ping_neighbours[i].id].dist = altdist;
				ping_nodes[ping_neighbours[i].id].prev = cur;
			}
		}
	}
}

static void SB_PingTree_Phase1(void)
{
	SB_PingTree_Clear();
	SB_PingTree_AddNodes();
}

static void SB_PingTree_UpdateServerList(void)
{
	int i;

	SB_ServerList_Lock();

	for (i = 0; i < serversn; i++) {
		nodeid_t id = SB_PingTree_FindIp(SB_Netaddr2Ipaddr(&servers[i]->address));
		if (id == INVALID_NODE || ping_nodes[id].prev == INVALID_NODE || ping_nodes[id].prev == startnode_id) continue;

		SB_Server_SetBestPing(servers[i], ping_nodes[id].dist);
	}

	SB_ServerList_Unlock();
}

int SB_PingTree_Phase2(void *ignored_arg)
{
	SB_PingTree_ScanProxies();
	SB_PingTree_Dijkstra();
	SB_PingTree_UpdateServerList();

	sb_queuedtriggers |= SB_TRIGGER_NOTIFY_PINGTREE;
	Sys_SemPost(&phase2thread_lock);
	building_pingtree = false;
	pingtree_built = true;
	return 0;
}

/// Has the Ping Tree been already built?
qbool SB_PingTree_Built(void)
{
	return ping_nodes_count > 0;
}

/// Creates whole graph structure for looking up shortest paths to servers (ping-wise).
///
/// Grabs data from the server browser and then from the proxies.
void SB_PingTree_Build(void)
{
	if (building_pingtree) {
		Com_Printf("Ping Tree is still being built...\n");
		return;
	}
	// no race condition here, as this must always get executed by the main thread
	building_pingtree = true;
	Com_Printf("Building the Ping Tree...\n");

	// first quick phase is initialization + quick read of data from the server browser
	SB_PingTree_Phase1();
	// second longer phase is querying the proxies for their ping data + dijkstra algo
	Sys_SemWait(&phase2thread_lock);
	if (Sys_CreateDetachedThread(SB_PingTree_Phase2, NULL) < 0) {
		Com_Printf("Failed to create SB_PingTree_Phase2 thread\n");
	}
}

/// Prints the shortest path to given IP address
void SB_PingTree_DumpPath(const netadr_t *addr)
{
	nodeid_t target = SB_PingTree_FindIp(SB_Netaddr2Ipaddr(addr));

	if (target == INVALID_NODE) {
		Com_Printf("No route found to given host\n");
	}
	else {
		nodeid_t current = target;

		Com_Printf("Shortest path length: %d ms\nRoute: \n", ping_nodes[current].dist);
		while (current != startnode_id && current != INVALID_NODE) {
			byte *ip = ping_nodes[current].ipaddr.data;
			Com_Printf("%4d ms  %d.%d.%d.%d:%d\n", ping_nodes[current].dist, 
				ip[0], ip[1], ip[2], ip[3],	ntohs(ping_nodes[current].proxport));
			current = ping_nodes[current].prev;
		}
		Com_Printf("%4d ms  localhost (your machine)\n", 0);
	}
}

int SB_PingTree_GetPathLen(const netadr_t *addr)
{
	nodeid_t target = SB_PingTree_FindIp(SB_Netaddr2Ipaddr(addr));

	if (target == INVALID_NODE || ping_nodes[target].prev == INVALID_NODE) {
		return -1;
	}
	else if (ping_nodes[target].prev == startnode_id) {
		return 0;
	}
	else {
		nodeid_t current = ping_nodes[target].prev;
		int proxies = 0;

		while (current != startnode_id && current != INVALID_NODE) {
			proxies++;
			current = ping_nodes[current].prev;
		}

		return proxies;
	}
}

/// Connects to given QW server using the best available route
void SB_PingTree_ConnectBestPath(const netadr_t *addr)
{
	extern cvar_t cl_proxyaddr;
	nodeid_t target = SB_PingTree_FindIp(SB_Netaddr2Ipaddr(addr));

	if (target == INVALID_NODE || ping_nodes[target].prev == INVALID_NODE) {
		Com_Printf("No route found, trying to connect directly...\n");
		Cvar_Set(&cl_proxyaddr, "");
	}
	else if (ping_nodes[target].prev == startnode_id) {
		Com_Printf("Direct route is the best route, connecting directly...\n");
		Cvar_Set(&cl_proxyaddr, "");
	}
	else {
		char proxylist_buf[32*MAX_NONLEAVES] = "";
		nodeid_t current = ping_nodes[target].prev;
		int proxies = 0;

		while (current != startnode_id && current != INVALID_NODE) {
			byte *ip = ping_nodes[current].ipaddr.data;
			char newval[2048]; /* va() used 2048b buffer..*/

			snprintf(&newval[0], sizeof(newval), "%d.%d.%d.%d:%d%s%s", (int) ip[0], (int) ip[1], (int) ip[2],
				(int) ip[3], (int) ntohs(ping_nodes[current].proxport), *proxylist_buf ? "@" : "", proxylist_buf);
			strlcpy(proxylist_buf, newval, 32*MAX_NONLEAVES);

			proxies++;
			current = ping_nodes[current].prev;
		}
		
		Com_Printf("Connecting using %d %s with best ping %d ms\n",
			proxies, ((proxies == 1) ? "proxy" : "proxies"), ping_nodes[target].dist);
		Cvar_Set(&cl_proxyaddr, proxylist_buf);
	}

	/* FIXME: Create a Cbuf_AddTextFmt? */
	Cbuf_AddText("connect ");
	Cbuf_AddText(NET_AdrToString(*addr));
	Cbuf_AddText("\n");
}

int SB_Proxylist_Unserialize(FILE *f)
{
	int version, count = 0;

	if (fread(&version, sizeof(int), 1, f) != 1)
		return -1;
	if (version != PROXY_SERIALIZE_FILE_VERSION)
		return -1;

	while (!ferror(f) && !feof(f)) {
		netadr_t proxy;
		size_t buflen;
		byte buf[PROXY_REPLY_BUFFER_SIZE];
		nodeid_t id;

		if (fread(&proxy, sizeof(netadr_t), 1, f) != 1)
			return -3;

		if (proxy.type == NA_INVALID)
			break;

		if (fread(&buflen, sizeof(size_t), 1, f) != 1)
			return -3;
		if (buflen > PROXY_REPLY_BUFFER_SIZE)
			return -3;
		if (fread(buf, buflen, 1, f) != 1)
			return -3;

		id = SB_PingTree_FindIp(SB_Netaddr2Ipaddr(&proxy));
		if (id == INVALID_NODE)
			return -3;

		ping_nodes[id].nlist_start = ping_neighbours_count;
		SB_Proxy_ParseReply(buf, buflen, SB_PingTree_AddProxyPing);
		ping_nodes[id].nlist_end = ping_neighbours_count;

		count++;
	}

	return count;
}

void SB_Proxylist_Unserialize_f(void)
{
	char filename[MAX_OSPATH] = {0};
	FILE *f;
	int err;
	
	snprintf(&filename[0], sizeof(filename), "%s/%s", com_homedir, "proxies_data");

	if (!(f	= fopen(filename, "rb"))) {
		Com_Printf("Couldn't read %s.\n", filename);
		return;
	}

	building_pingtree = true;
	SB_PingTree_Phase1();
	err = SB_Proxylist_Unserialize(f);
	if (err > 0) {
		Com_Printf("Successfully read %d proxies\n", err);
		SB_PingTree_Dijkstra();
		SB_PingTree_UpdateServerList();
		pingtree_built = true;
	}
	else if (err == -1) {
		Com_Printf("Format didn't match\n");
	}
	else if (err == -3) {
		Com_Printf("Corrupted data\n");
	}
	else { // err == 0
		Com_Printf("No proxies read\n");
	}
	building_pingtree = false;

	fclose(f);
}

qbool SB_PingTree_IsBuilding(void)
{
	return building_pingtree;
}

void SB_PingTree_Init(void)
{
	Sys_SemInit(&phase2thread_lock, 1, 1);
}

void SB_PingTree_Shutdown(void)
{
	Sys_SemWait(&phase2thread_lock);
	Sys_SemDestroy(&phase2thread_lock);
}


================================================
FILE: src/EX_browser_ping.c
================================================
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: EX_browser_ping.c,v 1.40 2007-10-27 08:51:12 dkure Exp $
*/

#ifdef _WIN32

#include <winsock2.h>
#include "quakedef.h"

#else

#include "quakedef.h"
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <semaphore.h>

#define SO_DONTLINGER 0 	 
#define GetCurrentProcessId getpid

#define ioctlsocket ioctl

#endif // _WIN32

#include "hud.h"
#include "hud_common.h"
#include "EX_browser.h"

// =============================================================================
//  Constants
// =============================================================================

#define ICMP_ECHO       8
#define ICMP_ECHOREPLY  0 	 
  	 
#define ICMP_MIN 8 // minimum 8 byte icmp packet (just header) 	 

#define STATUS_FAILED    0xFFFF
#define DEF_PACKET_SIZE  0
#define MAX_PACKET       1024

#define PING_PACKET_DATA "\xff\xff\xff\xffk\n"

// =============================================================================
//  Local Types
// =============================================================================

/* The IP header */
typedef struct IP_header_s
{
    unsigned int   h_len:4;        // length of the header
    unsigned int   version:4;      // Version of IP
    unsigned char  tos;            // Type of service
    unsigned short total_len;      // total length of the packet
    unsigned short ident;          // unique identifier
    unsigned short frag_and_flags; // flags
    unsigned char  ttl; 
    unsigned char  proto;          // protocol (TCP, UDP etc)
    unsigned short checksum;       // IP checksum

    unsigned int sourceIP;
    unsigned int destIP;
} IP_header_t;
 
typedef struct ICMP_header_s
{
    byte i_type;
    byte i_code; /* type sub code */
    unsigned short i_cksum;
    unsigned short i_id;
    unsigned short i_seq;
    /* This is not the std header, but we reserve space for our needs */
    double timestamp;
    u_int id;   // ip
    int index;  // server num
    int phase;  // ping phase
    int randomizer;
} ICMP_header_t; 

/* Packets */
typedef union IP_Packet_u {
	IP_header_t hdr;
	byte data[MAX_PACKET];
} IP_packet_t;

typedef union ICMP_Packet_u {
	ICMP_header_t hdr;
	byte data[MAX_PACKET];
} ICMP_packet_t;

/* Struct for storing ping reponses */
typedef struct pinghost_s
{
    int ip;
    unsigned short port;
    int recv, send;
    int phase;
	double ping;
    double stime[6];
} pinghost_t;

typedef struct {
	pinghost_t *hosts;
	int nelms;
} pinghost_list_t;

// =============================================================================
//  Function Prototypes
// =============================================================================

// =============================================================================
//  Global variables
// =============================================================================
qbool useNewPing = false; // New Ping = UDP QW Packet multithreaded ping

socket_t sock;
socket_t ping_sock;

/* Used for thread syncronisation */
static qbool ping_finished = false;
static sem_t ping_semaphore;

// =============================================================================
//  Local Functions
// =============================================================================
/**
 * Given a string of the form "ip:port", gets the addr, port in integer format
 */
static int ParseServerIp(char *server_port, int *addr, unsigned short *port) 
{
	char server_ip[50];
	char *port_divide;

	strlcpy (server_ip, server_port, sizeof(server_ip));

	/* Break the ip at the port */
	if ((port_divide = strchr(server_ip, ':')))
		*port_divide = 0;

	if (addr) {
		*addr = inet_addr(server_ip);
		if (*addr == INADDR_NONE)
			return 1;
	}

	if (port) 
	{
		if (port_divide != NULL)
			*port = (unsigned short) Q_atoi(port_divide+1);
		else
			*port = 27500;
	}

	return 0;
}

/**
 * Given a servs list, parse and create a pinghost_t list from it
 */
static pinghost_t *ParseServerList(server_data *servs[], int servsn, int *host_nelms) 
{
	pinghost_t *phosts;
	int nelms;
	int i, j;

	phosts = (pinghost_t *)Q_malloc(sizeof(pinghost_t) * servsn);
	nelms = 0;
	for (i=0; i < servsn; i++) 
	{
		int addr;
		unsigned short port;

		if (ParseServerIp(servs[i]->display.ip, &addr, &port)) 
		{
			continue;
		}

		/* Make sure it is unique */
		for (j = 0; j < nelms; j++) 
		{
			if (phosts[j].ip == addr && phosts[j].port == port) 
			{
				break;
			}
		}

		if (j == nelms) 
		{
			phosts[nelms].recv = 0;
			phosts[nelms].send = 0;
			phosts[nelms].ping = 0;
			phosts[nelms].ip = addr;
			phosts[nelms].port = port;
			nelms++;
		}
	}

	*host_nelms = nelms;
	return phosts;
}

/**
 * Given a ping host array takes the average ping and fills the display for
 * the servs array
 */
static void FillServerListPings(server_data *servs[], int servsn, 
							pinghost_t *phosts, int host_nelms) {
	int i, j;

	for (i = 0; i < host_nelms; i++) {
		int ping;
		int addr;
		unsigned short port;

		/* Take the average of the recieved pings */
		if (phosts[i].recv > 0)
			ping = (int)((phosts[i].ping / phosts[i].recv) * 1000);
		else
			ping = -1;

		/* Find the server from the host */
		for (j = 0; j < servsn; j++) 
		{
			if (ParseServerIp(servs[j]->display.ip, &addr, &port)) 
			{
				continue;
			}

			if (addr == phosts[i].ip && port == phosts[i].port) 
			{
				SetPing(servs[j], ping); // 10
			}
		}
	}
}

/**
 * Decode an IP packet and return the underlying ICMP header
 */
static ICMP_header_t *IP_DecodePacket(IP_packet_t *ip_packet, int bytes,
								struct sockaddr_in *from, u_int ip)
{
    ICMP_packet_t *icmp_packet;
    unsigned short iphdrlen;

    iphdrlen = ip_packet->hdr.h_len * 4 ; // number of 32-bit words *4 = bytes

    if (bytes  < iphdrlen + ICMP_MIN)
    {
        return NULL;
    }

    icmp_packet = (ICMP_packet_t *)(ip_packet->data + iphdrlen);

    if (icmp_packet->hdr.i_type != ICMP_ECHOREPLY)
	{
        return NULL;
    }
    if (icmp_packet->hdr.i_id != (unsigned short)GetCurrentProcessId())
	{
        return NULL;
    }

    return &icmp_packet->hdr;
} 

/** 
 * Decode an ICMP packet and calculate the total return trip time (RTT) is ms
 */
static int ICMP_GetEchoResponseTime(ICMP_header_t *icmp_hdr)
{
    return 1 + (int)((Sys_DoubleTime() - icmp_hdr->timestamp)*1000);
}

/**
 * Calculate the ICMP checksum which includes the header and data
 */
static unsigned short ICMP_Checksum(ICMP_packet_t *packet, int size)
{
  unsigned int cksum=0;
  unsigned short *buffer = (unsigned short *)packet->data;

	while(size >1)
	{
    cksum+=*buffer++;
    size -=sizeof(unsigned short);
  }
  
	if (size)
	{
    cksum += *(byte *)buffer;
  }

  cksum = (cksum >> 16) + (cksum & 0xffff);
  cksum += (cksum >>16);
  return (unsigned short)(~cksum);
}


/**
 * Helper function to fill in various stuff in our ICMP request.
 */
static void ICMP_FillData(ICMP_packet_t *packet, int datasize)
{
  packet->hdr.i_type = ICMP_ECHO;
  packet->hdr.i_code = 0;
  packet->hdr.i_id = (unsigned short)GetCurrentProcessId();
  packet->hdr.i_cksum = 0;
  packet->hdr.i_seq = 0;
  
  //
  // Place some junk in the buffer.
  //
  memset(packet->data + sizeof(packet->hdr), 'E', datasize);
}

// =============================================================================
//  Global Functions
// =============================================================================
void SB_RootInit(void)
{
    useNewPing = true;
} 

/**
 * Pings a single host up to count attempts, each attemp we send the request
 * and wait for the reply. The total return trip time (RTT) in ms is returned.
 */
int oldPingHost(char *host_to_ping, int count)
{
    struct sockaddr_in dest, from;
    int fromlen = sizeof(from);
    int bread, datasize;
    ICMP_packet_t icmp_packet;

	IP_packet_t   ip_recv_packet;
	ICMP_header_t *icmp_recv_header;

    int attempts, rtt;
    struct timeval timeout;
    fd_set fd_set_struct;

    unsigned int addr=0;
    unsigned short seq_no = 0;

    if (sock < 0)
        return 0;

    addr = inet_addr(host_to_ping);
    if (addr == INADDR_NONE)
        return 0;

    memset(&dest, 0, sizeof(dest));
    dest.sin_addr.s_addr = addr;
    dest.sin_family = AF_INET;

    memset(icmp_packet.data, 0, sizeof(icmp_packet.data));
    datasize = DEF_PACKET_SIZE;
    datasize += sizeof(icmp_packet.hdr);  
    ICMP_FillData(&icmp_packet, datasize);

    attempts = 0;
	rtt = 0;
    while (attempts < count)
    {
        int bwrote;
		int ret;

        attempts++;
    
		/* Prepare the packet */
        icmp_packet.hdr.i_cksum = 0;
        icmp_packet.hdr.timestamp = Sys_DoubleTime();
        icmp_packet.hdr.id = addr;

        icmp_packet.hdr.i_seq = seq_no++;
        icmp_packet.hdr.i_cksum = ICMP_Checksum(&icmp_packet, datasize);

		/* Prepare for response */
        FD_ZERO(&fd_set_struct);
        FD_SET(sock, &fd_set_struct);
        timeout.tv_sec = 0;
        timeout.tv_usec = sb_pingtimeout.value * 1000;

        ret = select(sock+1, NULL, (fd_set *) &fd_set_struct, NULL, &timeout);
        if (ret <= 0)
            continue;

		/* Send ping request */
        bwrote = sendto(sock, (char *) icmp_packet.data,datasize,0,
				(struct sockaddr*)&dest, sizeof(dest));
        if (bwrote <= 0 || bwrote < datasize)
            continue;

		/* Wait for response */
        FD_ZERO(&fd_set_struct);
        FD_SET(sock, &fd_set_struct);

        ret = select(sock+1, (fd_set *) &fd_set_struct, NULL, NULL, &timeout);

        if (ret <= 0)
            continue;

        bread = recvfrom(sock, (char *) ip_recv_packet.data, MAX_PACKET, 0,
				(struct sockaddr*)&from, (socklen_t *)&fromlen);
        if (bread <= 0)
            continue;

		/* Look for the RTT */
		icmp_recv_header = IP_DecodePacket(&ip_recv_packet, bread, &from, addr);
		if (icmp_recv_header) {
			if (!(rtt = ICMP_GetEchoResponseTime(icmp_recv_header))) {
				continue;
			}
		}

        break;
    }

    return rtt;
} 

/**
 * Ping multiple hosts listed by servs, ping each host count times
 */
int oldPingHosts(server_data *servs[], int servsn, int count)
{
    double interval;
    double lastsenttime;
    int ping_number;
    int randomizer;

	pinghost_list_t host_list;
    struct sockaddr_in dest,from;
    int bread,datasize;
    int fromlen = sizeof(from);
    ICMP_packet_t icmp_packet;
	IP_packet_t   ip_packet;

    int success;
    struct timeval timeout;
    fd_set fd_set_struct;

    unsigned int addr=0;
    unsigned short seq_no = 0;

    if (sock < 0)
        return 0;
	
    datasize = DEF_PACKET_SIZE;
    datasize += sizeof(icmp_packet.hdr);

	// FIXME: The datasize only sizeof(IcmpHeader) here so fill_icmp_data won't set any of the data "to junk", it will all be 0.
    memset(icmp_packet.data, 0, MAX_PACKET);
    ICMP_FillData(&icmp_packet, datasize);

    success = 0;
	host_list.hosts = ParseServerList(servs, servsn, &host_list.nelms);

    interval = (1000.0 / sb_pingspersec.value) / 1000;
    lastsenttime = Sys_DoubleTime() - interval;
    timeout.tv_sec = 0;
    timeout.tv_usec = (long)(interval * 1000.0 * 1000.0);
    ping_number = 0;
    randomizer = (int)(Sys_DoubleTime() * 10);

	// Ping all addresses in the host list we just created.
    while (!abort_ping)
    {
        int bwrote;
        double time = Sys_DoubleTime();

        if (time > (lastsenttime + 1.2 * (sb_pingtimeout.value / 1000)))
		{
            // No answers, no pings - finish.
            break;
		}

		// Send a ping request to the current host.
        if ((time > (lastsenttime + interval)) 
				&& (ping_number < (host_list.nelms * sb_pings.value)))
        {
            // Send next ping.
            pinghost_t * host = &host_list.hosts[ping_number % host_list.nelms];

            if (host->ping >= 0)
            {
                icmp_packet.hdr.i_cksum = 0;
                icmp_packet.hdr.timestamp = time;

                icmp_packet.hdr.id = host->ip;
                icmp_packet.hdr.index = ping_number % host_list.nelms;
                icmp_packet.hdr.phase = ping_number;
                icmp_packet.hdr.randomizer = randomizer;

                icmp_packet.hdr.i_seq = seq_no++;
                icmp_packet.hdr.i_cksum = ICMP_Checksum(&icmp_packet, datasize);

                memset(&dest, 0, sizeof(dest));
                dest.sin_addr.s_addr = host->ip;
                dest.sin_family = AF_INET;

                bwrote = sendto(sock, (char *) icmp_packet.data, datasize, 0,
								(struct sockaddr*)&dest, sizeof(dest));

                if (bwrote <= 0 || bwrote < datasize)
                    host->ping = -1;

                lastsenttime = time;
            }

            ping_number++;
            ping_pos = min(1, ping_number 
					/ (double)(host_list.nelms * sb_pings.value));
        }

		// Wait for an answer.
        while (!abort_ping)
        {
			int myvar;
            ICMP_header_t *icmp_answer;

            FD_ZERO(&fd_set_struct);
            FD_SET(sock, &fd_set_struct);

			myvar = select(sock+1, (fd_set *) &fd_set_struct, NULL, 
							NULL, &timeout);

			if (myvar <= 0)
                break;

            // there's an answer - get it!
            bread = recvfrom(sock, (char *) ip_packet.data, sizeof(ip_packet.data), 0,
							(struct sockaddr *)&from, (socklen_t *)&fromlen);
           
			if (bread <= 0)
                continue;

            icmp_answer = IP_DecodePacket(&ip_packet, bread, &from, addr);

			// Make sure the reply is ok.
            if (icmp_answer && (randomizer == icmp_answer->randomizer))
            {
                int index;
                int fromhost;

                fromhost = icmp_answer->id;
                index    = icmp_answer->index;
                if ((host_list.hosts[index].ip == fromhost)
						&& (host_list.hosts[index].ping >= 0))
                {
                    host_list.hosts[index].ping 
								= (host_list.hosts[index].ping 
									* host_list.hosts[index].phase
                                    + (Sys_DoubleTime()-icmp_answer->timestamp))
                                    / (host_list.hosts[index].phase + 1);
                    host_list.hosts[index].phase++;

					// Remove averaging that would occur in FillServerListPings
					host_list.hosts[index].recv = 1;
                }
            }
        }
    }

    // update pings in our servz
	if (!abort_ping) {
		FillServerListPings(servs, servsn, host_list.hosts, host_list.nelms);
	}

    Q_free(host_list.hosts);

    return success;
}

/**
 * Pings multiple hosts in parrallel, each host is pingged count times
 */
void PingSendParrallelMultiHosts(pinghost_t *phosts, int nelms, int count) {
	struct sockaddr_in to;
	int interval; 
	int i, j;
	int ret;
	timerresolution_session_t timer_session;
	
	memset(&timer_session, 0, sizeof(timer_session));

	count = bound(1, count, 6);
	interval = 1000.0 / sb_pingspersec.integer;

	Sys_TimerResolution_InitSession(&timer_session);
	Sys_TimerResolution_RequestMinimum(&timer_session);

	for (i = 0; i < count && !abort_ping; i++) {
		for (j = 0; j < nelms && !abort_ping; j++) {
			char *packet = PING_PACKET_DATA;

			ping_pos = min(1, (j / (double)(nelms * count))) + (i / (double)count);

			to.sin_family = AF_INET;
			to.sin_port = htons(phosts[j].port);
			to.sin_addr.s_addr = phosts[j].ip;

			ret = sendto(ping_sock, packet, strlen(packet), 0, (struct sockaddr *)&to, sizeof(struct sockaddr));

			if (ret == -1) {
				continue;
			}

			phosts[j].stime[phosts[j].send] = Sys_DoubleTime();
			phosts[j].send++;

			Sys_MSleep(interval);

		}
	}

	Sys_TimerResolution_Clear(&timer_session);
}

/**
 * Thread entry point for parrallel recving of ping responses
 */
int PingRecvProc(void *lpParameter)
{
	socklen_t inaddrlen;
	struct sockaddr_in from;
	fd_set fd;
	int k, ret;
	struct timeval timeout;
	pinghost_list_t *host_list = (pinghost_list_t *)lpParameter;

	while (!ping_finished && !abort_ping) {
		FD_ZERO(&fd);
		FD_SET(ping_sock, &fd);
		timeout.tv_sec = 0;
		timeout.tv_usec = 100 * 1000;

		ret = select(ping_sock+1, &fd, NULL, NULL, &timeout);
		if (ret <= 0) // error or timeout
			continue;

		while (1) {
			char buf[16];

			inaddrlen = sizeof(struct sockaddr_in);
			ret = recvfrom(ping_sock, buf, sizeof(buf), 0, (struct sockaddr *)&from, &inaddrlen);
			if (ret <= 0) // socket is asynch, so most likely this means there is no data to read
				break;
			if (buf[0] != 'l') // not A2A_ACK
				continue;
	
			for (k = 0; k < host_list->nelms; k++) {
				if (host_list->hosts[k].ip == (int) from.sin_addr.s_addr &&
				    host_list->hosts[k].port == ntohs(from.sin_port)) {
					host_list->hosts[k].ping += Sys_DoubleTime() 
									- host_list->hosts[k]
											.stime[host_list->hosts[k].recv];
					host_list->hosts[k].recv++;
					break;
				}
			}
		}
	}

	Sys_SemPost(&ping_semaphore);

	return 0;
}

/**
 * Ping a single host count times, returns the average of the responses
 */
int PingHost(char *host_to_ping, unsigned short port, int count, int time_out)
{
	socket_t sock;
	int i, ret, pings;
	struct sockaddr_in addr_to, addr_from;
	struct timeval timeout;
	fd_set fd;
	char *packet = "\xff\xff\xff\xffk\n", buf[16]; // A2A_PING, should return A2A_ACK
	socklen_t inaddrlen;
	double ping, t1;

	addr_to.sin_addr.s_addr = inet_addr(host_to_ping);
	if (addr_to.sin_addr.s_addr == INADDR_NONE)
		return 0;
	addr_to.sin_family = AF_INET;
	addr_to.sin_port = htons(port);

	sock = UDP_OpenSocket(PORT_ANY);
	pings = ping = 0;
	for (i = 0; i < count; i++) {
		ret = sendto(sock, packet, strlen(packet), 0, (struct sockaddr *)&addr_to, sizeof(struct sockaddr));
		if (ret == -1) // failure, try again
			continue;
		t1 = Sys_DoubleTime();

_select:
		FD_ZERO(&fd);
		FD_SET(sock, &fd);
		timeout.tv_sec = 0;
		timeout.tv_usec = 1000 * time_out;
		ret = select(sock+1, &fd, NULL, NULL, &timeout);
		if (ret <= 0) // timed out or error
			continue;

		inaddrlen = sizeof(struct sockaddr_in);
		ret = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *)&addr_from, &inaddrlen);
		if (ret == -1) // failure, try again
			continue;
		if (addr_from.sin_addr.s_addr != addr_to.sin_addr.s_addr) // martian, discard and see if a valid response came in after it
			goto _select;
		if (buf[0] != 'l') // not A2A_ACK, discard and see if a valid response came in after it
			goto _select;

		ping += Sys_DoubleTime() - t1;
		pings++;
	}

	closesocket(sock);
	return pings ? (int)((ping * 1000) / pings) : 0;
}

/**
 * Send several ping requests at once, start another thread to recieve
 * the responses.
 * FIXME: error handling is in rly bad shape
 */
int PingHosts(server_data *servs[], int servsn, int count)
{
	u_int arg;
	pinghost_list_t host_list;

	host_list.hosts = ParseServerList(servs, servsn, &host_list.nelms);
	ping_finished = false;

	ping_sock = UDP_OpenSocket(PORT_ANY);

#ifndef _WIN32
	if ((fcntl (ping_sock, F_SETFL, O_NONBLOCK)) == -1) { // O'Rly?! @@@
		Com_Printf ("TCP_OpenStream: fcntl: (%i): %s\n", qerrno, strerror(qerrno));
		//closesocket(ping_sock);
	}
#endif

	arg = 1;
	if (ioctlsocket (ping_sock, FIONBIO, (u_long *)&arg) == -1) { // make asynchronous
		Com_Printf ("PingHosts: ioctl: (%i): %s\n", qerrno, strerror(qerrno));
		//closesocket(newsocket);
	}

	Sys_SemInit(&ping_semaphore, 0, 1);

	if (Sys_CreateDetachedThread(PingRecvProc, (void *)&host_list) < 0) {
		Com_Printf("Failed to create Ping receiver thread\n");
	}

	PingSendParrallelMultiHosts(host_list.hosts, host_list.nelms, count);

	Sys_MSleep(500); // Wait for slow pings

	ping_finished = true; // let thread know we are done
	Sys_SemWait(&ping_semaphore);
	Sys_SemDestroy(&ping_semaphore);
	closesocket(ping_sock);

	if (!abort_ping) {
		FillServerListPings(servs, servsn, host_list.hosts, host_list.nelms);
	}

	Q_free(host_list.hosts);

	return 1;
}

//
// ----------------------------------------------
//  connection test
//  netgraph + ping stats
//
//

int sb_test_starttime;
int sb_test_incoming_sequence, sb_test_outgoing_sequence;
int sb_test_packet_latency[NET_TIMINGS];
double sent_time[NET_TIMINGS];
double received_time[NET_TIMINGS];
int    sequence_latency[NET_TIMINGS];
unsigned int sb_test_addr;
int sb_test_pl;
int sb_test_min, sb_test_max, sb_test_avg, sb_test_dev;
double last_stats_time;

server_data *sb_test_server = NULL;

void SB_Test_GetPackets(void)
{
    struct sockaddr_in dest,from;
    int bread;
    int fromlen = sizeof(from);
    IP_packet_t ip_packet;
//    int bwrote;

//    u_long arg;
//    int arg2, success;
//    struct timeval timeout;
//    fd_set fd_set_struct;

    unsigned int addr=0;
//    unsigned short seq_no = 0;

    if (sock < 0)
        return;

    memset(&dest, 0, sizeof(dest));

    addr = sb_test_addr;

    if (addr == INADDR_NONE)
        return;

    dest.sin_addr.s_addr = addr;
    dest.sin_family = AF_INET;

    while (1)
    {
//        int success;
        ICMP_header_t *icmp_answer;
        int seq;

        bread = recvfrom(sock, (char *) ip_packet.data, sizeof(ip_packet.data), 0,
						(struct sockaddr*)&from, (socklen_t *) &fromlen);
        if (bread <= 0)
            break;

        icmp_answer = IP_DecodePacket(&ip_packet, bread, &from, addr);

        if (!icmp_answer || icmp_answer->phase != sb_test_starttime)
            continue;

        seq = icmp_answer->i_seq;
        if (seq > sb_test_incoming_sequence)
        {
            received_time[seq%NET_TIMINGS] = cls.realtime;
            sequence_latency[seq%NET_TIMINGS] = sb_test_outgoing_sequence - seq;
            sb_test_incoming_sequence = seq;
        }
    }

}

void SB_Test_SendPacket(void)
{
    struct sockaddr_in dest/*,from*/;
//    int bread,
    int datasize;
//   int fromlen = sizeof(from);
	ICMP_packet_t icmp_packet;
//    int ret;

    //u_long arg;
    //int arg2, success;
    //struct timeval timeout;
    //fd_set fd_set_struct;

    unsigned int addr=0;
//    unsigned short seq_no = 0;

    sent_time[sb_test_outgoing_sequence%NET_TIMINGS] = cls.realtime;
    received_time[sb_test_outgoing_sequence%NET_TIMINGS] = -1;  // no answer yet

    if (sock < 0)
        return ;

    memset(&dest, 0, sizeof(dest));

    addr = sb_test_addr;

    if (addr == INADDR_NONE)
        return;

    dest.sin_addr.s_addr = addr;
    dest.sin_family = AF_INET;
    datasize = DEF_PACKET_SIZE;
    datasize += sizeof(icmp_packet.hdr);  

    memset(icmp_packet.data, 0, MAX_PACKET);
    ICMP_FillData(&icmp_packet, datasize);

    icmp_packet.hdr.phase = sb_test_starttime;

    icmp_packet.hdr.i_cksum = 0;
    icmp_packet.hdr.timestamp = cls.realtime;
    icmp_packet.hdr.id = addr;

    icmp_packet.hdr.i_seq = sb_test_outgoing_sequence++;
    icmp_packet.hdr.i_cksum = ICMP_Checksum(&icmp_packet, datasize);

    sendto(sock, (char *) icmp_packet.data,datasize,0,(struct sockaddr*)&dest,
                    sizeof(dest));
}

void SB_Test_CalcNet(void)
{
    int i, a;

    extern hud_t * hud_netgraph;
    cvar_t *netgraph_inframes = HUD_FindVar(hud_netgraph, "inframes");

    for (i=0; i < NET_TIMINGS; i++)
    {
        if (received_time[i] == -1)
            sb_test_packet_latency[i] = 9999;   // dropped
        else
        {
            double l;
            if (netgraph_inframes->value)      // [frames]
                l = 2*(sequence_latency[i]);
            else                                // [miliseconds]
                l = min((received_time[i] - sent_time[i])*1000, 1000);

            sb_test_packet_latency[i] = (int)l;
        }
    }

    if (last_stats_time +1 < cls.realtime)
    {
        int count;
        double sum;
        double avg;
        int i;

        last_stats_time = cls.realtime;

        // recalculate statistics
        sb_test_min = 9999999;
        sb_test_max = 0;
        sum = 0;
        count = 0;

        for (i=sb_test_outgoing_sequence-NET_TIMINGS; i < sb_test_incoming_sequence; i++)
        {
            int a = i % NET_TIMINGS;
            double ping;

            if (i < 0)
                continue;

            if (received_time[a] == -1)
                continue;

            ping = (received_time[a] - sent_time[a]) * 1000;

            if (ping < sb_test_min)
                sb_test_min = ping;

            if (ping > sb_test_max)
                sb_test_max = ping;

            sum += ping;
            count++;
        }

        if (count > 0)
        {
            avg = (sum / count);
            sb_test_avg = (int)(avg + 0.5);

            // standard deviation
            sum = 0;
            for (i=sb_test_outgoing_sequence-NET_TIMINGS; i < sb_test_incoming_sequence; i++)
            {
                int a = i % NET_TIMINGS;
                double ping;

                if (i < 0)
                    continue;

                if (received_time[a] == -1)
                    continue;

                ping = (received_time[a] - sent_time[a]) * 1000;

                sum += (ping - avg) * (ping - avg);
            }
            sb_test_dev = (int)(sqrt(sum / count) + 0.5);
        }
        else
            sb_test_min = sb_test_max = sb_test_avg = sb_test_dev = 0;

        // pl
        sb_test_pl = 0;
        for (a=0 ; a<NET_TIMINGS ; a++)
        {
            i = (sb_test_outgoing_sequence-a) & NET_TIMINGSMASK;
            if (sb_test_packet_latency[i] == 9999)
                sb_test_pl++;
        }
        sb_test_pl =  sb_test_pl * 100 / NET_TIMINGS;
    }

    sb_test_min = min(sb_test_min, 999);
    sb_test_max = min(sb_test_max, 999);
    sb_test_avg = min(sb_test_avg, 999);
    sb_test_dev = min(sb_test_dev, 99);
}

void SB_Test_Draw(void)
{
    int x, y, w, h;

	extern void R_MQW_NetGraph(int outgoing_sequence, int incoming_sequence, int *packet_latency, int lost, int minping, int avgping, int maxping, int devping, int posx, int posy, int width, int height, int revx, int revy);

    w = 240;
    h = 112;

    x = (vid.width - w)/2;
    y = (vid.height - h)/2;
    x -= 8;
    y += 76;

    if (vid.height >= 240)
        y += 20;

    R_MQW_NetGraph(sb_test_outgoing_sequence, sb_test_incoming_sequence,
               sb_test_packet_latency, sb_test_pl,
               sb_test_min, sb_test_avg, sb_test_max, sb_test_dev,
               x, y, -1, -1, 0, 0);
}

void SB_Test_Init(char *address)
{
    int i;

    sb_test_incoming_sequence = 0;
    sb_test_outgoing_sequence = 0;

    sb_test_addr = inet_addr(address);

    for (i=0; i < NET_TIMINGS; i++)
    {
        sb_test_packet_latency[i] = 0;
        received_time[i] = 0;
        sent_time[i] = 0;
        sequence_latency[i] = 0;
    }

    last_stats_time = -999;
    sb_test_starttime = cls.realtime*1000;
}

void SB_Test_Change(char *address)
{
    unsigned int addr = inet_addr(address);

    if (addr != sb_test_addr)
    {
        sb_test_incoming_sequence = sb_test_outgoing_sequence;
        sb_test_addr = inet_addr(address);

        last_stats_time = -999;
        sb_test_starttime = cls.realtime*1000;
    }
}

void SB_Test_Frame(void)
{
    // receive answers
    SB_Test_GetPackets();

    // send command
    SB_Test_SendPacket();

    // update stats
    SB_Test_CalcNet();

    // draw statistics
    SB_Test_Draw();
}


================================================
FILE: src/EX_browser_qtvlist.c
================================================
/*
Copyright (C) 2010       ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "utils.h"
#include "expat.h"
#include <curl/curl.h>

#define QTVLIST_CACHE_FILE_DIR "ezquake/sb/cache"
#define QTVLIST_CACHE_FILE "qtvcache"
#define CHARACTERDATA_BUFFERSIZE 256
#define MAX_QTV_ENTRY_TEXTLEN CHARACTERDATA_BUFFERSIZE

cvar_t sb_qtvlist_url = { "sb_qtvlist_url", "http://qtv.quakeworld.nu/?rss" };

typedef struct sb_qtvplayer_s {
	struct sb_qtvplayer_s *next; // next item in the linked list of players

	char name[MAX_SCOREBOARDNAME];
	char team[MAX_SCOREBOARDNAME];
	int frags;
	int ping;
	int pl;
	int topcolor;
	int bottomcolor;
} sb_qtvplayer_t;

typedef struct sb_qtventry_s {
	struct sb_qtventry_s *next; // next item in the linked list of entries

	char title[MAX_QTV_ENTRY_TEXTLEN];
	char link[MAX_QTV_ENTRY_TEXTLEN];
	char hostname[MAX_QTV_ENTRY_TEXTLEN];
	int port;
	netadr_t addr;
	int observercount;
	sb_qtvplayer_t *players; // first item of a linked list
} sb_qtventry_t;

typedef enum {
	QTVLIST_INITIAL,
	QTVLIST_ITEM,
	QTVLIST_PLAYER,
} sb_qtvlist_parse_position_t;

typedef enum {
	QTVLIST_INIT,
	QTVLIST_PROCESSING,
	QTVLIST_DOWNLOADING,
	QTVLIST_PARSING,
	QTVLIST_RESOLVING,
	QTVLIST_PRINTING,
	QTVLIST_READY
} sb_qtvlist_status_t;

typedef struct sb_qtvlist_parse_state_s {
	char chardata_buffer[CHARACTERDATA_BUFFERSIZE];
	sb_qtventry_t *list;
	sb_qtvlist_parse_position_t position;
} sb_qtvlist_parse_state_t;

typedef struct sb_qtvlist_cache_s {
	sb_qtventry_t *sb_qtventries;
	sb_qtvlist_status_t status;
} sb_qtvlist_cache_t;

static sb_qtvlist_cache_t sb_qtvlist_cache = { NULL, QTVLIST_INIT };

static sb_qtventry_t *QTVList_New_Entry(void)
{
	sb_qtventry_t *ret;

	ret = Q_calloc(sizeof (sb_qtventry_t), 1);

	return ret;
}

static sb_qtvplayer_t *QTVList_New_Player(void)
{
	sb_qtvplayer_t *ret;

	ret = Q_calloc(sizeof (sb_qtvplayer_t), 1);

	return ret;
}

static void QTVList_Parse_StartElement(void *userData, const XML_Char *name,
	const XML_Char **atts)
{
	sb_qtvlist_parse_state_t *sb_qtvparse = (sb_qtvlist_parse_state_t *) userData;

	if (sb_qtvparse->position == QTVLIST_INITIAL) {
		if (strcmp(name, "item") == 0) {
			sb_qtventry_t *current = sb_qtvparse->list;
			sb_qtventry_t *newentry = QTVList_New_Entry();

			newentry->next = current;
			sb_qtvparse->list = newentry;
			sb_qtvparse->position = QTVLIST_ITEM;
		}
		else {
		}
	}
	else if (sb_qtvparse->position == QTVLIST_ITEM) {
		if (strcmp(name, "player") == 0) {
			sb_qtvplayer_t *current = sb_qtvparse->list->players;
			sb_qtvplayer_t *newplayer = QTVList_New_Player();

			newplayer->next = current;
			sb_qtvparse->list->players = newplayer;

			sb_qtvparse->position = QTVLIST_PLAYER;
		}
	}
	else if (sb_qtvparse->position == QTVLIST_PLAYER) {
	}
	else {
		Sys_Error("QTVList_Parse_StartElement(): invalid position");
	}
}

void QTVList_Parse_CharacterData(void *userData, const XML_Char *s, int len)
{
	sb_qtvlist_parse_state_t *sb_qtvparse = (sb_qtvlist_parse_state_t *) userData;

	size_t copied;
	size_t n;

	copied = strlen(sb_qtvparse->chardata_buffer);
	n = 0;

	while (copied + 1 < CHARACTERDATA_BUFFERSIZE && n < len) {
		sb_qtvparse->chardata_buffer[copied++] = s[n++];
	}

	sb_qtvparse->chardata_buffer[copied] = '\0';
}

void QTVList_Parse_EndElement(void *userData, const XML_Char *name)
{
	sb_qtvlist_parse_state_t *sb_qtvparse = (sb_qtvlist_parse_state_t *) userData;
	char *buf = str_trim(sb_qtvparse->chardata_buffer);

	if (sb_qtvparse->position == QTVLIST_INITIAL) {
	}
	else if (sb_qtvparse->position == QTVLIST_ITEM) {
		if (strcmp(name, "hostname") == 0) {
			strlcpy(sb_qtvparse->list->hostname, buf, MAX_QTV_ENTRY_TEXTLEN);
		}
		else if (strcmp(name, "port") == 0) {
			sb_qtvparse->list->port = Q_atoi(buf);
		}
		else if (strcmp(name, "observercount") == 0) {
			sb_qtvparse->list->observercount = Q_atoi(buf);
		}
		else if (strcmp(name, "title") == 0) {
			strlcpy(sb_qtvparse->list->title, buf, MAX_QTV_ENTRY_TEXTLEN);
		}
		else if (strcmp(name, "link") == 0) {
			strlcpy(sb_qtvparse->list->link, buf, MAX_QTV_ENTRY_TEXTLEN);
		}
		else if (strcmp(name, "item") == 0) {
			sb_qtvparse->position = QTVLIST_INITIAL; // go up
		}
		else if (strcmp(name, "player") == 0) {
			sb_qtvparse->position = QTVLIST_PLAYER; // go down
		}
	}
	else if (sb_qtvparse->position == QTVLIST_PLAYER) {
		if (strcmp(name, "name") == 0) {
			strlcpy(sb_qtvparse->list->players->name, buf, MAX_SCOREBOARDNAME);
		}
		else if (strcmp(name, "team") == 0) {
			strlcpy(sb_qtvparse->list->players->team, buf, MAX_SCOREBOARDNAME);
		}
		else if (strcmp(name, "frags") == 0) {
			sb_qtvparse->list->players->frags = Q_atoi(buf);
		}
		else if (strcmp(name, "ping") == 0) {
			sb_qtvparse->list->players->ping = Q_atoi(buf);
		}
		else if (strcmp(name, "pl") == 0) {
			sb_qtvparse->list->players->pl = Q_atoi(buf);
		}
		else if (strcmp(name, "topcolor") == 0) {
			sb_qtvparse->list->players->topcolor = Q_atoi(buf);
		}
		else if (strcmp(name, "bottomcolor") == 0) {
			sb_qtvparse->list->players->bottomcolor = Q_atoi(buf);
		}
		else if (strcmp(name, "player") == 0) {
			sb_qtvparse->position = QTVLIST_ITEM;
		}
	}

	buf[0] = '\0';
}

sb_qtvlist_parse_state_t *QTVList_Parse_Init(void)
{
	sb_qtvlist_parse_state_t *ret = Q_malloc(sizeof (sb_qtvlist_parse_state_t));
	ret->chardata_buffer[0] = '\0';
	ret->list = NULL;
	ret->position = QTVLIST_INITIAL;

	return ret;
}

void QTVList_Entry_Destroy(sb_qtventry_t *entry)
{
	while (entry->players) {
		sb_qtvplayer_t *next = entry->players->next;
		Q_free(entry->players);
		entry->players = next;
	}

	Q_free(entry);
}

void QTVList_Parse_Destroy(sb_qtvlist_parse_state_t *parse)
{
	while (parse->list) {
		sb_qtventry_t *next = parse->list->next;

		QTVList_Entry_Destroy(parse->list);
		parse->list = next;
	}
}

void QTVList_Process_Full_List(vfsfile_t *f, sb_qtvlist_parse_state_t *sb_qtvparse)
{
	XML_Parser parser = NULL;
	int len;
	enum XML_Status status;
	char buf[4096];
	vfserrno_t err;

    // initialize XML parser
    parser = XML_ParserCreate(NULL);
	if (parser == NULL) {
		Com_Printf("Couldn't initialize XML parser\n");
        return;
	}
    XML_SetStartElementHandler(parser, QTVList_Parse_StartElement);
	XML_SetCharacterDataHandler(parser, QTVList_Parse_CharacterData);
	XML_SetEndElementHandler(parser, QTVList_Parse_EndElement);
    XML_SetUserData(parser, (void *) sb_qtvparse);

    while ((len = VFS_READ(f, buf, 4096, &err)) > 0)
    {
		if ((status = XML_Parse(parser, buf, len, 0)) != XML_STATUS_OK) {
			enum XML_Error err = XML_GetErrorCode(parser);
			Com_Printf("XML parser error.\n%s\n", status, XML_ErrorString(err));
			break;
		}
    }

    XML_ParserFree(parser);
}

void QTVList_Cache_File_Download(void)
{
	CURL *curl;
	CURLcode res;
	FILE *f;

	curl = curl_easy_init();
	if (curl) {
		curl_easy_setopt(curl, CURLOPT_URL, sb_qtvlist_url.string);
	}
	else {
		Com_Printf_State(PRINT_FAIL, "QTVList_List_f() Can't init cURL\n");
		return;
	}

	if (!FS_FCreateFile(QTVLIST_CACHE_FILE, &f, QTVLIST_CACHE_FILE_DIR, "wb+")) {
		Com_Printf_State(PRINT_FAIL, "Can't create QTVList cache file\n");
        return;
	}

	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NULL);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, f);

	res = curl_easy_perform(curl);
    curl_easy_cleanup(curl);
	fclose(f);

	if (res != CURLE_OK) {
		Com_Printf_State(PRINT_FAIL, "Couldn't download QTV list");
		return;
	}
}

static vfsfile_t *QTVList_Cache_File_Open(char *mode)
{
	return FS_OpenVFS(QTVLIST_CACHE_FILE_DIR "/" QTVLIST_CACHE_FILE, mode, FS_BASE);
}

static void QTVList_Resolve_Hostnames(void)
{
	sb_qtventry_t *cur = sb_qtvlist_cache.sb_qtventries;

	while (cur) {
		char fulladdr[MAX_QTV_ENTRY_TEXTLEN+6]; /* :xxxxx */

		snprintf(&fulladdr[0], sizeof(fulladdr), "%s:%d", cur->hostname, cur->port);
		NET_StringToAdr(fulladdr, &cur->addr);
		cur->addr.type = NA_IP;
		cur = cur->next;
	}
}

static qbool QTVList_Cache_File_Is_Old(void)
{
	char cache_path[MAX_OSPATH] = {0};
	SYSTEMTIME cache_time;
	SYSTEMTIME min_time; // minimum required time
	int diff;

	snprintf(&cache_path[0], sizeof(cache_path), "%s/%s/%s", com_basedir, QTVLIST_CACHE_FILE_DIR, QTVLIST_CACHE_FILE);
	GetFileLocalTime(cache_path, &cache_time);

	GetLocalTime(&min_time);

	// subtract 7 days
	if (min_time.wDay > 7) {
		min_time.wDay -= 7;
	}
	else {
		// approximately 7 days in this case
		// let's not bother if a month has 28, 29, 30 or 31 days
		if (min_time.wMonth > 1) {
			min_time.wMonth -= 1;
			min_time.wDay += 22;
		}
		else {
			min_time.wYear -= 1;
			min_time.wMonth = 12;
			min_time.wDay += 22;
		}
	}

	diff = SYSTEMTIMEcmp(&cache_time, &min_time);
	return diff < 0;
}

void QTVList_Refresh_Cache(qbool force_redownload)
{
	char cache_dir[MAX_OSPATH] = {0};
	vfsfile_t *cache_file;
	sb_qtvlist_parse_state_t *sb_qtvparse;

	snprintf(&cache_dir[0], sizeof(cache_dir), "%s/" QTVLIST_CACHE_FILE_DIR, com_basedir);
	Sys_mkdir(cache_dir);

	if (force_redownload
		|| !(cache_file = QTVList_Cache_File_Open("rb"))
		|| QTVList_Cache_File_Is_Old())
	{
		sb_qtvlist_cache.status = QTVLIST_DOWNLOADING;
		QTVList_Cache_File_Download();

			cache_file = QTVList_Cache_File_Open("rb");
		if (!cache_file) {
			Com_Printf("Can't open QTV cache file\n");
			return;
		}
	}

	sb_qtvlist_cache.status = QTVLIST_PARSING;
	
	sb_qtvparse = QTVList_Parse_Init();
	QTVList_Process_Full_List(cache_file, sb_qtvparse);
	VFS_CLOSE(cache_file);
	sb_qtvlist_cache.sb_qtventries = sb_qtvparse->list;
	Q_free(sb_qtvparse);
	
	sb_qtvlist_cache.status = QTVLIST_RESOLVING;
	QTVList_Resolve_Hostnames();
}

static size_t QTVList_Length(const sb_qtventry_t *first)
{
	size_t ret = 0;
	const sb_qtventry_t *cur = first;

	while (cur) {
		ret++;
		cur = cur->next;
	}

	return ret;
}

static size_t QTVList_Player_Count(const sb_qtventry_t *entry)
{
	const sb_qtvplayer_t *cur = entry->players;
	size_t ret = 0;

	while (cur) {
		ret++;
		cur = cur->next;
	}

	return ret;
}

int QTVList_Entry_Cmp(const void *a_v, const void *b_v)
{
	sb_qtventry_t *entry_a = (sb_qtventry_t *) a_v;
	sb_qtventry_t *entry_b = (sb_qtventry_t *) b_v;

	if (entry_a->observercount > entry_b->observercount) {
		return -1;
	}
	else if (entry_a->observercount == entry_b->observercount) {
		return 0;
	}
	else {
		return 1;
	}
}

static void QTVList_Print(void)
{
	size_t len = QTVList_Length(sb_qtvlist_cache.sb_qtventries);
	sb_qtventry_t *entries_array;
	sb_qtventry_t *cur;
	int i;
	size_t players;
	sb_qtvplayer_t *player;

	entries_array = Q_malloc(len * sizeof (sb_qtventry_t));

	cur = sb_qtvlist_cache.sb_qtventries;

	i = 0;
	while (cur) {
		memcpy(&entries_array[i++], cur, sizeof (sb_qtventry_t));
		cur = cur->next;
	}

	qsort(entries_array, len, sizeof (sb_qtventry_t), QTVList_Entry_Cmp);

	for (i = 0; i < len; i++) {
		cur = &entries_array[i];
		players = QTVList_Player_Count(cur);

		if (players == 0) {
			continue;
		}

		Com_Printf("--- %3d %3u %30s ---\n",
			cur->observercount, players, cur->title);

		player = cur->players;
		while (player) {
			Com_Printf("      %4d [%4s] %s\n", player->frags, player->team, player->name);
			player = player->next;
		}
	}
}

int QTVList_Refresh_Cache_Thread(void *userData)
{
	QTVList_Refresh_Cache((qbool) userData);
	sb_qtvlist_cache.status = QTVLIST_READY;
	return 0;
}

int QTVList_Download_And_Print_Thread(void *userData)
{
	Com_Printf("QuakeTV list downloading...\n");
	QTVList_Refresh_Cache(true);
	sb_qtvlist_cache.status = QTVLIST_PRINTING;
	QTVList_Print();
	sb_qtvlist_cache.status = QTVLIST_READY;

	return 0;
}

void QTVList_Print_Global(void)
{
	if (sb_qtvlist_cache.status != QTVLIST_READY && sb_qtvlist_cache.status != QTVLIST_INIT) {
		Com_Printf("QTV cache is still being rebuilt\n");
		return;
	}

	sb_qtvlist_cache.status = QTVLIST_PROCESSING;
	if (Sys_CreateDetachedThread(QTVList_Download_And_Print_Thread, NULL) < 0) {
		Com_Printf("Failed to create QTVList Download_And_Print thread\n");
	}
}

void QTVList_Initialize_Streammap(void)
{
	if (sb_qtvlist_cache.status != QTVLIST_READY && sb_qtvlist_cache.status != QTVLIST_INIT) {
		Com_Printf("QTV cache is still being rebuilt\n");
		return;
	}

	sb_qtvlist_cache.status = QTVLIST_PROCESSING;
	if (Sys_CreateDetachedThread(QTVList_Refresh_Cache_Thread, NULL) < 0) {
		Com_Printf("Failed to create QTVList Refresh_Cache thread\n");
	}
}

static netadr_t QTVList_Current_IP(void)
{
	netadr_t adr;
	char *prx = Info_ValueForKey(cls.userinfo, "prx");

	if (prx && *prx) {
		char *lastsep = strrchr(prx, '@');
		lastsep = lastsep ? lastsep + 1 : prx;
		
		NET_StringToAdr(lastsep, &adr);
		return adr;
	}
	else {
		return cls.server_adr;
	}
}

void QTVList_Observeqtv_f(void)
{
	netadr_t addr;
	sb_qtventry_t *cur;

	if (sb_qtvlist_cache.status != QTVLIST_READY) {
		Com_Printf("QTV cache is still being rebuilt\n");
		return;
	}
	
	if (Cmd_Argc() < 2) {
		addr = QTVList_Current_IP();
	}
	else {
		NET_StringToAdr(Cmd_Argv(1), &addr);
	}

	if (addr.type == NA_IP) {
		cur = sb_qtvlist_cache.sb_qtventries;

		while (cur) {
			if (cur->addr.port == addr.port && memcmp(cur->addr.ip, addr.ip, sizeof (addr.ip)) == 0) {
				Cbuf_AddText("qtvplay ");
				Cbuf_AddText(cur->link);
				Cbuf_AddText("\n");
				return;
			}

			cur = cur->next;
		}

		Com_Printf("Cannot find current server on any QTV\n");
	}
	else {
		Com_Printf("Can't observe current server via QTV\n");
	}
}

void QTVList_Init(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SERVER_BROWSER);

	Cvar_Register(&sb_qtvlist_url);

	Cvar_ResetCurrentGroup();

	Cmd_AddCommand("observeqtv", QTVList_Observeqtv_f);

	QTVList_Initialize_Streammap();
}


================================================
FILE: src/EX_browser_sources.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "fs.h"

#ifndef _WIN32
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#endif
#include <curl/curl.h>

#include "EX_browser.h"

#define SOURCES_LIST_FILENAME "sb/sources.txt"

// Used by curl to read server lists from the web
struct curl_buf
{
	char *ptr;
	size_t len;
};

// sources table
source_data *sources[MAX_SOURCES];
int sourcesn;

source_data * Create_Source(void)
{
	source_data *s;
	s = (source_data *) Q_malloc(sizeof(source_data));
	s->serversn = 0;
	s->servers_allocated = 0;
	s->last_update.wYear = 0;
	s->name[0] = 0;
	s->checked = 0;
	s->servers = NULL;
	s->unique = source_unique++;
	return s;
}

void Reset_Source(source_data *s)
{
    int i;
	if (s->servers != NULL)
    {
        for (i=0; i < s->serversn; i++)
            Q_free(s->servers[i]);
        Q_free(s->servers);
    }
	s->serversn = 0;
	s->servers_allocated = 0;
	s->last_update.wYear = 0;
    //s->name[0] = 0;
}

// used only for list re-loading
void Delete_Source(source_data *s)
{
    Reset_Source(s);
    Q_free(s);
}

// returns true, if there were some problems (like domain-name addresses)
// which require the source to be dumped to file in corrected form
qbool Update_Source_From_File(source_data *s, char *fname, server_data **servers, int *pserversn)
{
	vfsfile_t *f;
	char line[2048];
    qbool should_dump = false;

    //length = COM_FileOpenRead (fname, &f);
	f = FS_OpenVFS(fname, "rb", FS_ANY);

    if (f) {
		while (VFS_GETS(f, line, sizeof(line)))
		{
			netadr_t addr;

			if (!strchr(line, ':'))
				strlcat (line, ":27000", sizeof (line));
			if (!NET_StringToAdr(line, &addr))
				continue;

			servers[(*pserversn)++] = Create_Server2(addr);
			if (line[0] <= '0'  ||  line[0] >= '9')
				should_dump = true;
		}
		VFS_CLOSE(f);
    } else {
        //Com_Printf ("Updating %15.15s failed: file not found\n", s->name);
        // ?????? should_dump = true;
	}

    return should_dump;
}

static size_t SB_URL_to_FileName(const char *str, char *dest, size_t size)
{
	size_t written = 0;
	char *hexa = "0123456789abcdef";
	
	while (*str != '\0' && written + 1 < size) {
		if (isalnum(*str) || *str == '.') {
			*dest++ = *str++;
			written++;
		}
		else {
			if (written + 1 < size) {
				int curchar = *str++;
				written += 3;

				*dest++ = '_';
				*dest++ = hexa[curchar / 16];
				*dest++ = hexa[curchar % 16];
			}
			else {
				break;
			}
		}
	}
	*dest = '\0';

	return written;
}

static size_t SB_URL_To_Filename_Length(const char *s)
{
	return strlen(s)*3+1;
}

static void Precache_Source(source_data *s)
{
    int i;
    char name[1024];
    server_data *servers[MAX_SERVERS];
    int serversn = 0;

	if (s->type == type_url) {
		char *filename;
		size_t filename_size = SB_URL_To_Filename_Length(s->address.url);

		filename = Q_malloc(filename_size);
		SB_URL_to_FileName(s->address.url, filename, filename_size);
		snprintf(name, sizeof (name), "sb/cache/%s", filename);
		Q_free(filename);
	}
	else if (s->type == type_master) {
		snprintf(name, sizeof (name), "sb/cache/%d_%d_%d_%d_[%d].txt",
				s->address.address.ip[0], s->address.address.ip[1],
				s->address.address.ip[2], s->address.address.ip[3],
				ntohs(s->address.address.port));
	}
	else {
		return;
	}

	Update_Source_From_File(s, name, servers, &serversn);

	if (serversn > 0)
	{
		SYSTEMTIME tm;
		char tmp_path[MAX_OSPATH] = {0};

		snprintf(&tmp_path[0], sizeof(tmp_path), "%s/ezquake/%s", com_basedir, name);
		if (GetFileLocalTime(tmp_path, &tm))
		{
			Reset_Source(s);
			s->servers = (server_data **) Q_malloc(serversn * sizeof(server_data *));
			for (i=0; i < serversn; i++)
				s->servers[i] = servers[i];
			s->serversn = serversn;
			s->servers_allocated = serversn;

			if (s->checked)
				rebuild_servers_list = 1;

			memcpy(&s->last_update, &tm, sizeof(SYSTEMTIME));
		}
	}
}

static void SB_Process_URL_Buffer(const struct curl_buf *curl_buf, server_data *servers[], int *serversn)
{
	netadr_t addr;
	char *buf, *p0, *p1;

	// Don't modify curl_buf as it might be used to create cache file
	buf = Q_malloc(sizeof(char) * curl_buf->len);
	memcpy(buf, curl_buf->ptr, sizeof(char) * curl_buf->len);

	// Not using strtok as it's not thread safe
	for (p0 = buf, p1 = buf; p1 < buf + curl_buf->len; p1++) {
		if (*p1 == '\n') {
			*p1 = '\0';
			NET_StringToAdr(p0, &addr);
			servers[(*serversn)++] = Create_Server2(addr);
			p0 = p1 + 1;
		}
	}

	Q_free(buf);
}

static struct curl_buf *curl_buf_init(void)
{
	// Q_malloc handles errors and exits on failure
	struct curl_buf *curl_buf = Q_malloc(sizeof(struct curl_buf));
	curl_buf->len = 0;
	curl_buf->ptr = Q_malloc(curl_buf->len + 1);
	return curl_buf;
}

static void curl_buf_deinit(struct curl_buf *curl_buf)
{
	Q_free(curl_buf->ptr);
	Q_free(curl_buf);
}

static size_t curl_write_func( void *ptr, size_t size, size_t nmemb, void* buf_)
{
	struct curl_buf * buf = (struct curl_buf *)buf_;
	size_t new_len = buf->len + size * nmemb;

	// not checking for realloc errors since Q_realloc will exit on failure
	buf->ptr = Q_realloc(buf->ptr, new_len + 1);

	memcpy(buf->ptr + buf->len, ptr, size * nmemb);
	buf->ptr[new_len] = '\0';
	buf->len = new_len;

	return size * nmemb;
}

int SB_Cache_Source(const source_data *s, const struct curl_buf *curl_buf)
{
	size_t filename_buf_len;
	char *filename;
	FILE *f;

	filename_buf_len = SB_URL_To_Filename_Length(s->address.url);
	filename = Q_malloc(filename_buf_len);
	SB_URL_to_FileName(s->address.url, filename, filename_buf_len);
	if (!FS_FCreateFile(filename, &f, "ezquake/sb/cache", "wb+")) {
		Com_Printf_State(PRINT_FAIL, "SB_Cache_Source() Can't create cache file");
		Q_free(filename);
		return 0;
	}

	fwrite(curl_buf->ptr, sizeof(char), curl_buf->len, f);

	fclose(f);
	Q_free(filename);
	return 1;
}

struct curl_buf *SB_Retrieve_Data(const source_data *s)
{
	CURL *curl;
	CURLcode res;
	struct curl_buf *curl_buf;

	curl = curl_easy_init();
	if (curl) {
		curl_easy_setopt(curl, CURLOPT_URL, s->address.url);
		curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
	}
	else {
		Com_Printf_State(PRINT_FAIL, "SB_Retrieve_Data() Can't init cURL\n");
		return NULL;
	}

	curl_buf = curl_buf_init();
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_func);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl_buf);

	res = curl_easy_perform(curl);
	if (res != CURLE_OK) {
		Com_Printf("SB_Retrieve_Data(): Could not read URL %s\n", s->address.url);
		curl_easy_cleanup(curl);
		curl_buf_deinit(curl_buf);
		return NULL;
	}

	curl_easy_cleanup(curl);
	return curl_buf;
}

static void SB_Update_Source_From_URL(const source_data *s, server_data *servers[],
	int *serversn)
{
	struct curl_buf *curl_buf;

	if (s->type != type_url) {
		Com_Printf_State(PRINT_FAIL, "SB_Update_Source_From_URL() Invalid argument\n");
		return;
	}

	// Retrieve servers
	curl_buf = SB_Retrieve_Data(s);
	if (curl_buf == NULL) {
		// SB_Retrieve_Data will print meaningful error message
		return;
	}

	// Update servers variable
	SB_Process_URL_Buffer(curl_buf, servers, serversn);

	// Cache servers (file)
	// No need to check for errors since we cleanup anyways
	SB_Cache_Source(s, curl_buf);

	curl_buf_deinit(curl_buf);
}

void Update_Source(source_data *s)
{
	int i;
	qbool should_dump = false;
	server_data *servers[MAX_SERVERS];
	int serversn = 0;

	if (s->type == type_dummy)
		return;

	if (s->type == type_file)
	{
		// read servers from file
		char name[1024];
		snprintf(name, sizeof (name), "sb/%s", s->address.filename);
		should_dump = Update_Source_From_File(s, name, servers, &serversn);
		GetLocalTime(&(s->last_update));
	}

	if (s->type == type_url)
	{	
		SB_Update_Source_From_URL(s, servers, &serversn);
	}

	if (s->type == type_master)
	{
		// get servers from master server
		char request[] = {'c', '\n', '\0'};

		socket_t newsocket;
		struct sockaddr_storage server;
		int ret = 0, i;
		unsigned char answer[10000];
		fd_set fd;
		struct timeval tv;
		int trynum;
		int timeout;

		newsocket = UDP_OpenSocket(PORT_ANY);
		// so we have a socket

		// send status request

		for (trynum=0; trynum < sb_masterretries.value; trynum++) {
			NetadrToSockadr (&(s->address.address), &server);
			ret = sendto (newsocket, request, sizeof(request), 0,
					(struct sockaddr *)&server, sizeof(server) );
		}

		if (ret < 0)
			return;

		timeout = Sys_DoubleTime() + (sb_mastertimeout.value / 1000.0);
		while (Sys_DoubleTime() < timeout) {
			//fd.fd_count = 1;
			//fd.fd_array[0] = newsocket;
			FD_ZERO(&fd);
			FD_SET(newsocket, &fd);
			tv.tv_sec = 0;
			tv.tv_usec = 1000 * 1.5 * sb_mastertimeout.value; // multiply timeout by 1.5
			ret = select(newsocket+1, &fd, NULL, NULL, &tv);

			// get answer
			if (ret > 0)
				ret = recvfrom (newsocket, (char *) answer, 10000, 0, NULL, NULL);

			if (ret > 0  &&  ret < 10000)
			{
				answer[ret] = 0;

				if (memcmp(answer, "\xff\xff\xff\xff\x64\x0a", 6))
				{
					closesocket(newsocket);
					return;
				}

				// create servers avoiding duplicates
				for (i=6; i+5 < ret; i+=6)
				{
					char buf[32];
					server_data* server;
					qbool exists = false;
					int j;

					snprintf(buf, sizeof (buf), "%u.%u.%u.%u:%u",
							(int)answer[i+0], (int)answer[i+1],
							(int)answer[i+2], (int)answer[i+3],
							256 * (int)answer[i+4] + (int)answer[i+5]);

					server = Create_Server(buf);
					for (j=0; j<serversn; j++) {
						if (NET_CompareAdr(servers[j]->address, server->address)) {
							exists = true;
							break;
						}
					}

					if (!exists)
						servers[serversn++] = server;
					else
						Delete_Server(server);
				}
			}
		}

		closesocket(newsocket);

	}

	SB_ServerList_Lock();
	// copy all servers to source list
	if (serversn > 0)
	{
		Reset_Source(s);
		s->servers = Q_malloc((serversn + (s->type==type_file ? MAX_UNBOUND : 0)) * sizeof(server_data *));
		for (i=0; i < serversn; i++)
			s->servers[i] = servers[i];
		s->serversn = serversn;
		s->servers_allocated = serversn + (s->type == type_file ? MAX_UNBOUND : 0);

		if (s->checked)
			rebuild_servers_list = 1;

		if (sb_mastercache.value)
		{
			DumpSource(s);
			should_dump = false;
		}
		GetLocalTime(&(s->last_update));
	}
	else {
		if (s->type == type_file)
		{
			Reset_Source(s);
			s->servers = Q_malloc(MAX_UNBOUND * sizeof(server_data *));
		}
	}

	SB_ServerList_Unlock();
	if (should_dump)
		DumpSource(s);
	//Com_Printf ("Updating %15.15s: %d servers\n", s->name, serversn);
}

int updating_sources = 0;
int source_full_update = 0;

typedef struct infohost_s
{
    double lastsenttime;
    int phase;
} infohost;

source_data **psources;
int psourcesn;

int Update_Multiple_Sources_Proc(void * lpParameter)
{
    // get servers from master server
    SYSTEMTIME lt;
    char request[] = {'c', '\n', '\0'};

    socket_t newsocket;
	struct sockaddr_storage server;
    int ret = 0, i, sourcenum;
    unsigned char answer[10000];
    fd_set fd;
    struct timeval tv;
    int total_masters = 0;
    int updated = 0;
    int d1, d2;

    GetLocalTime(&lt);
    d1 = lt.wSecond + 60*(lt.wMinute + 60*(lt.wHour + 24*(lt.wDay)));
    // update file sources - this should be a flash
    for (sourcenum = 0; sourcenum < psourcesn; sourcenum++)
        if (psources[sourcenum]->checked)
        {
            if (psources[sourcenum]->type == type_file)
                Update_Source(psources[sourcenum]);
			if (psources[sourcenum]->type == type_url)
				Update_Source(psources[sourcenum]); // todo cache this too
            else if (psources[sourcenum]->type == type_master)
            {
                source_data *s = psources[sourcenum];
                if (s->last_update.wYear != 0  &&  !source_full_update)
                {
                    d2 = s->last_update.wSecond + 60*(s->last_update.wMinute + 60*(s->last_update.wHour + 24*(s->last_update.wDay)));

                    if (d1 > d2  &&  d1 < d2 + sb_sourcevalidity.value*60)
                    continue;
                }
                total_masters++;
            }
        }
	
    // update master sources
    newsocket = UDP_OpenSocket(PORT_ANY);

    for (sourcenum = 0; sourcenum < psourcesn  &&  !abort_ping; sourcenum++)
    {
        server_data *servers[MAX_SERVERS];
        int serversn = 0;
        int trynum = 0;
        source_data *s = psources[sourcenum];
		double timeout;

        if (psources[sourcenum]->type != type_master  ||  !psources[sourcenum]->checked)
            continue;

        if (s->last_update.wYear != 0  &&  !source_full_update)
        {
            d2 = s->last_update.wSecond + 60*(s->last_update.wMinute + 60*(s->last_update.wHour + 24*(s->last_update.wDay)));

            if (d1 > d2  &&  d1 < d2 + sb_sourcevalidity.value*60)
                continue;
        }

		// send trynum queries to master server
        for (trynum=0; trynum < sb_masterretries.value; trynum++)
        {
			NetadrToSockadr (&(s->address.address), &server);
            ret = sendto (newsocket, request, sizeof(request), 0,
                          (struct sockaddr *)&server, sizeof(server) );
		}

		if (ret <= 0)
			continue;

		timeout = Sys_DoubleTime() + (sb_mastertimeout.value / 1000.0);
		while (Sys_DoubleTime() < timeout) {
			struct sockaddr_storage hostaddr;
            netadr_t from;

            //fd.fd_count = 1;
            //fd.fd_array[0] = newsocket;
			FD_ZERO(&fd);
			FD_SET(newsocket, &fd);
            tv.tv_sec = 0;
            tv.tv_usec = 1000 * sb_mastertimeout.value;
            ret = select(newsocket+1, &fd, NULL, NULL, &tv);

            // get answer
            i = sizeof(hostaddr);
            if (ret > 0)
                ret = recvfrom (newsocket, (char *) answer, 10000, 0,
				(struct sockaddr *)&hostaddr, (socklen_t *)&i);

            if (ret > 0  &&  ret < 10000)
            {
                SockadrToNetadr (&hostaddr, &from);

                if (from.ip[0] == s->address.address.ip[0] &&
                    from.ip[1] == s->address.address.ip[1] &&
                    from.ip[2] == s->address.address.ip[2] &&
                    from.ip[3] == s->address.address.ip[3] &&
                    from.port == s->address.address.port)
                {
                    answer[ret] = 0;

                    if (memcmp(answer, "\xff\xff\xff\xff\x64\x0a", 6))
                    {
                        continue;
                    }

                    // create servers avoiding duplicates
					for (i=6; i+5 < ret; i+=6)
					{
						char buf[32];
						server_data* server;
						qbool exists = false;
						int j;

						snprintf(buf, sizeof (buf), "%u.%u.%u.%u:%u",
							(int)answer[i+0], (int)answer[i+1],
							(int)answer[i+2], (int)answer[i+3],
							256 * (int)answer[i+4] + (int)answer[i+5]);

						server = Create_Server(buf);
						for (j=0; j<serversn; j++) {
							if (NET_CompareAdr(servers[j]->address, server->address)) {
								exists = true;
								break;
							}
						}
						
						if (!exists)
							servers[serversn++] = server;
						else
							Delete_Server(server);
					}
                }
            }
		}

        // copy all servers to source list
        if (serversn > 0)
        {
			updated++;

			SB_ServerList_Lock();

            Reset_Source(s);
            s->servers = (server_data **) Q_malloc(serversn * sizeof(server_data *));
            for (i=0; i < serversn; i++)
                s->servers[i] = servers[i];
            s->serversn = serversn;
			s->servers_allocated = serversn;
            if (s->checked)
                rebuild_servers_list = 1;
            GetLocalTime(&(s->last_update));

			SB_ServerList_Unlock();

            if (sb_mastercache.value)
                DumpSource(s);
        }

        ping_pos = updated / (double)total_masters;
    }

    closesocket(newsocket);

	// Not having this here leads to crash almost always when some
	// other action with servers list happens right after this function.
	// Even 1 ms delay was enough during the tests, previously 500 ms was used.
    //Sys_MSleep(100);

    updating_sources = 0;
	sb_queuedtriggers |= SB_TRIGGER_SOURCESUPDATED;
    return 0;
}

void Update_Init(source_data *s[], int sn)
{
    psources = s;
    psourcesn = sn;

    abort_ping = 0;
    updating_sources = 1;
    ping_pos = 0;
}

// starts asynchronous sources update
void Update_Multiple_Sources_Begin(source_data *s[], int sn)
{
	Update_Init(s, sn);
	if (Sys_CreateDetachedThread(Update_Multiple_Sources_Proc, NULL) < 0) {
		Com_Printf("Failed to create Update_Multiple_Sources_Proc thread\n");
	}
}

// starts synchronous sources update
void Update_Multiple_Sources(source_data *s[], int sn)
{
	Update_Init(s, sn);
    Update_Multiple_Sources_Proc(NULL);
}

void SB_Sources_Update(qbool full)
{
	source_full_update = full;
	Update_Multiple_Sources(sources, sourcesn);
    if (rebuild_servers_list)
        Rebuild_Servers_List();
}

void SB_Sources_Update_Begin(qbool full)
{
	source_full_update = full;
	Update_Multiple_Sources_Begin(sources, sourcesn);
}

unsigned int SB_Sources_Marked_Count(void)
{
	int i;
	unsigned int ret = 0;

	for (i = 0; i < sourcesn; i++) {
		if (sources[i]->checked == 1) {
			ret++;
		}
	}

	return ret;
}

void Toggle_Source(source_data *s)
{
    s->checked = !(s->checked);
    rebuild_servers_list = 1;
}

void Mark_Source(source_data *s)
{
    if (!s->checked)
    {
        s->checked = 1;
        rebuild_servers_list = 1;
    }
}

void Unmark_Source(source_data *s)
{
    if (s->checked)
    {
        s->checked = 0;
        rebuild_servers_list = 1;
    }
}

char * next_space(char *s)
{
    char *ret = s;
    while (*ret  &&  !isspace2(*ret))
        ret++;
    return ret;
}

char * next_nonspace(char *s)
{
    char *ret = s;
    while (*ret  &&  isspace2(*ret))
        ret++;
    return ret;
}

char * next_quote(char *s)
{
    char *ret = s;
    while (*ret  &&  *ret != '\"')
        ret++;
    return ret;
}

qbool SB_Sources_Dump(void)
{
	FILE *f;
	int i;

	if (!FS_FCreateFile(SOURCES_LIST_FILENAME, &f, "ezquake", "wt")) {
		return false;
	}
 
	for (i = 0; i < sourcesn; i++) {
		sb_source_type_t type = sources[i]->type;

		if (type == type_master || type == type_file || type == type_url) {
			const char *typestr;
			const char *name = sources[i]->name;
			const char *loc;

			if (type == type_master) {
				typestr = "master";
				loc = NET_AdrToString(sources[i]->address.address);
			}
			else if (type == type_url) {
				typestr = "url";
				loc = sources[i]->address.url;
			}
			else {
				typestr = "file";
				loc = sources[i]->address.filename;
			}
			
			fprintf(f, "%s \"%s\" %s\n", typestr, name, loc);
		}
	}

	fclose(f);

	return true;
}

int SB_Source_Add(const char* name, const char* address, sb_source_type_t type)
{
	source_data *s;
	char addr[512];
	int pos;

	if (strlen(name) <= 0  ||  strlen(address) <= 0)
		return -1;

	// create new source
	s = Create_Source();
	s->type = type;
	strlcpy (s->name, name, sizeof (s->name));
	strlcpy (addr, address, sizeof (addr));

	if (s->type == type_file) {
		strlcpy (s->address.filename, address, sizeof (s->address.filename));
	}
	else if (s->type == type_url) {
		strlcpy(s->address.url, address, sizeof(s->address.url));
	}
	else {
		if (!strchr(addr, ':')) {
			strlcat (addr, ":27000", sizeof (addr));
		}
		if (!NET_StringToAdr(addr, &(s->address.address))) {
			return -1;
		}
	}

	pos = sourcesn++;
	sources[pos] = s;
	Mark_Source(sources[pos]);
	Update_Source(sources[pos]);

	SB_Sources_Dump();

	return pos;
}

void SB_Source_Remove(int i)
{
    source_data *s;

	if (i < 0 || i >= MAX_SOURCES) {
		return;
	}

	s = sources[i];
    if (s->type == type_dummy)
        return;

	Q_free(sources[i]);

    // remove from SB
    if (i < sourcesn - 1)
    {
		memmove(sources+i,
                sources+i + 1,
                (sourcesn-i-1)*sizeof(*sources));
    }
    sourcesn--;

	SB_Sources_Dump();
}

void Reload_Sources(void)
{
    int i;
	vfsfile_t *f;
	char ln[2048];
    source_data *s;

	SB_ServerList_Lock();
    for (i=0; i < sourcesn; i++)
        Delete_Source(sources[i]);
    sourcesn = 0;

    // create dummy unbound source
    sources[0] = Create_Source();
    sources[0]->type = type_dummy;
    strlcpy (sources[0]->name, "Unbound", sizeof (sources[0]->name));
    sources[0]->servers = (server_data **) Q_malloc(MAX_UNBOUND*sizeof(server_data *));
	sources[0]->serversn = 0;
	sources[0]->servers_allocated = MAX_UNBOUND;

	sourcesn = 1;

	f = FS_OpenVFS(SOURCES_LIST_FILENAME, "rb", FS_ANY);
	if (!f) 
	{
        //Com_Printf ("sources file not found: %s\n", SOURCES_PATH);
		SB_ServerList_Unlock();
		return;
	}

    s = Create_Source();
    while (VFS_GETS(f, ln, sizeof(ln)))
    {
		char line[2048];
        char *p, *q;

        if (sscanf(ln, "%[ -~	]s", line) != 1) {
			continue;
		}

        p = next_nonspace(line);
        if (*p == '/')
            continue;   // comment
        q = next_space(p);

		if (!strncmp(p, "master", q-p)) {
            s->type = type_master;
		}
		else if (!strncmp(p, "file", q-p)) {
			s->type = type_file;
		}
		else if (!strncmp(p, "url", q-p)) {
			s->type = type_url;
		}
		else {
			continue;
		}

        p = next_nonspace(q);
        q = (*p == '\"') ? next_quote(++p) : next_space(p);

        if (q-p <= 0)
            continue;

        strlcpy (s->name, p, min(q-p+1, MAX_SOURCE_NAME+1));

        p = next_nonspace(q+1);
        q = next_space(p);
        *q = 0;

        if (q-p <= 0)
            continue;

        if (s->type == type_file)
            strlcpy (s->address.filename, p, sizeof (s->address.filename));
		else if (s->type == type_url)
			strlcpy (s->address.url, p, sizeof (s->address.url));
        else
            if (!NET_StringToAdr(p, &(s->address.address)))
                continue;

        sources[sourcesn] = Create_Source();
        i = sources[sourcesn]->unique;
        memcpy(sources[sourcesn], s, sizeof(source_data));
        sources[sourcesn]->unique = i;
        sourcesn++;
    }

    Delete_Source(s);
	VFS_CLOSE(f);

    //Com_Printf("Read %d sources for Server Browser\n", sourcesn);

    // update all file sources
    for (i=0; i < sourcesn; i++)
        if (sources[i]->type == type_file)
            Update_Source(sources[i]);
        else if (sources[i]->type == type_master || sources[i]->type == type_url)
            Precache_Source(sources[i]);

    rebuild_servers_list = 1;
    resort_sources = 1;
	SB_ServerList_Unlock();
}

int rebuild_servers_list = 0;

void Rebuild_Servers_List(void)
{
    int i;
    int server_limit = sizeof(servers) / sizeof(servers[0]);
    serversn = 0;
	
    rebuild_servers_list = 0;
	SB_ServerList_Lock();

    for (i=0; i < sourcesn; i++)
    {
        if (sources[i]->checked)
        {
            int j;
            for (j=0; j < sources[i]->serversn; j++)
            {
                int k;
                qbool found_duplicate = false;

				if (sources[i]->servers[j] == NULL)
					continue;

                // Try and find a matching address
                for (k = 0; k < serversn && k < server_limit; k++) {
                    if (!memcmp(&(servers[k]->address), &(sources[i]->servers[j]->address), sizeof(netadr_t))) {
                        found_duplicate = true;
                        break;
                    }
                }

                if (! found_duplicate) {
                    // if not on list yet
                    if (serversn < server_limit) {
                        servers[serversn++] = sources[i]->servers[j];
                    }
                }
            }
        }
    }

    resort_servers = 1;
    rebuild_all_players = 1;
    Servers_pos = 0;
    serversn_passed = serversn;

	SB_ServerList_Unlock();
}

void DumpSource(source_data *s)
{
    FILE *f;
    int i;
    char buf[1024];

    if (s->type == type_file)
        snprintf(buf, sizeof (buf), "sb/%s", s->address.filename);
    else if (s->type == type_master)
    {
        Sys_mkdir("sb/cache");
        snprintf(buf, sizeof (buf), "sb/cache/%d_%d_%d_%d_[%d].txt",
                s->address.address.ip[0], s->address.address.ip[1],
                s->address.address.ip[2], s->address.address.ip[3],
                ntohs(s->address.address.port));
    }
    else
        return;

//    f = fopen(buf, "wt");
//    if (f == NULL)
//        return;
    if (!FS_FCreateFile(buf, &f, "ezquake", "wt"))
        return;

    for (i=0; i < s->serversn; i++)
        fprintf(f, "%d.%d.%d.%d:%d\n",
        s->servers[i]->address.ip[0], s->servers[i]->address.ip[1],
        s->servers[i]->address.ip[2], s->servers[i]->address.ip[3],
        ntohs(s->servers[i]->address.port));

    fclose(f);
}

static void AddUnbound(server_data *s)
{
    if (sources[0]->serversn >= MAX_UNBOUND)
        return;

    if (IsInSource(sources[0], s))
        return;

    sources[0]->servers[sources[0]->serversn] = s;
    (sources[0]->serversn) ++;
    rebuild_servers_list = true;
}

void RemoveFromFileSource(source_data *source, server_data *serv)
{
    int i;
    
    if (source->serversn <= 0)
        return;

    for (i=0; i < source->serversn; i++)
        if (!memcmp(&source->servers[i]->address, &serv->address, 6))
        {
			// Only add to unbound if not in any other sources...
			int j = 0;
			qbool in_other_source = false;
			for (j = 0; j < sourcesn; ++j) {
				if (source != sources[j]) {
					in_other_source |= IsInSource(sources[j], serv);
				}
			}

            // remove from source
            if (i != source->serversn - 1)
            {
                memmove(source->servers+i,
                        source->servers+i+1,
                        (source->serversn - i - 1) * sizeof(source_data *));
            }
            --source->serversn;
            DumpSource(source);
			if (!in_other_source) {
				// add to unbound
				AddUnbound(serv);
				Mark_Source(sources[0]);
			}
            return;
        }
}

void AddToFileSource(source_data *source, server_data *serv)
{
	if (IsInSource(source, serv))
		return;

	SB_ServerList_Lock();

    // reallocate buffer if we've run out of space
	if (source->serversn >= source->servers_allocated) {
		int new_size = source->servers_allocated + 4;
		server_data** newlist = Q_malloc(new_size * sizeof(server_data*));

		memcpy(newlist, source->servers, sizeof(server_data*) * source->servers_allocated);
		Q_free(source->servers);
		source->servers = newlist;
		source->servers_allocated = new_size;
	}

	source->servers[source->serversn++] = Clone_Server(serv);
	rebuild_servers_list = true;

	SB_ServerList_Unlock();

	DumpSource(source);
	Mark_Source(sources[0]);
}


================================================
FILE: src/EX_qtvlist.c
================================================
/*
Copyright (C) 2015 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include <curl/curl.h>
#include <jansson.h>
#include <SDL_thread.h>
#include "quakedef.h"
#include "EX_qtvlist.h"

cvar_t qtv_api_url = {"qtv_api_url", "http://qtvapi.quakeworld.nu/api/v1/servers"};

static json_t *root;
static SDL_mutex *qtvlist_mutex;

extern char *CL_QTV_GetCurrentStream(void);

static size_t qtvlist_curl_callback(char *content, size_t size, size_t nmemb, void *userp)
{
	size_t realsize = nmemb * size;
	struct str_buf *buf = (struct str_buf *)userp;
	char *tmpstr = NULL;

	if (buf->len > (4*1024*1024)) { /* Some sort of sanity check */
		Com_Printf("error: file too big\n");
		return -1;
	}

	tmpstr = Q_realloc(buf->str, buf->len + realsize + 1);
	if (tmpstr == NULL) {
		Com_Printf("error: Out of memory (realloc returned NULL)\n");
		return 0;
	}
	else {
		buf->str = tmpstr;
	}

	memcpy(&(buf->str[buf->len]), content, realsize);
	buf->len += realsize;
	buf->str[buf->len] = 0;

	return realsize;
}

/* Caller must free */
static char* qtvlist_get_jsondata(void)
{
	CURL *handle;
	struct str_buf buf;
	int res = 0;

	memset(&buf, 0, sizeof(buf));

	if ((handle = curl_easy_init()) == NULL) {
		Com_Printf("error: failed to init curl\n");
		return NULL;
	}

	buf.str = Q_calloc(1, 128); /*  Initially set to 128 bytes, will grow if necessary */

	res += curl_easy_setopt(handle, CURLOPT_URL, qtv_api_url.string);
	res += curl_easy_setopt(handle, CURLOPT_WRITEDATA, (void*)&buf);
	res += curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, qtvlist_curl_callback);

	res += curl_easy_perform(handle);

	if (res != CURLE_OK) {
		Com_Printf("error: Failed to fetch qtv list JSON data\n");
		Q_free(buf.str); /* Will set to NULL */
	}
	
	curl_easy_cleanup(handle);
	return buf.str;
}

static void qtvlist_json_load_and_verify_string(const char *input)
{
	json_t *server_array = NULL;
	json_t *server_count = NULL;
	json_t *player_count = NULL;
	json_t *observ_count = NULL;
	json_error_t error;

	if (root != NULL) {
		json_decref(root);
		root = NULL;
	}

	root = json_loads(input, 0, &error);
	if (root == NULL) {
		Com_Printf("error: JSON error on line %d: %s\n", error.line, error.text);
		goto err;
	}

	if (!json_is_object(root)) {
		Com_Printf("error: invalid JSON, root is not an object\n");
		goto err;
	}

	server_array = json_object_get(root, "Servers");
	server_count = json_object_get(root, "ServerCount");
	player_count = json_object_get(root, "PlayerCount");
	observ_count = json_object_get(root, "ObserverCount");

	if (!json_is_array(server_array)  || !json_is_number(server_count) ||
	    !json_is_number(player_count) || !json_is_number(observ_count)) {
		Com_Printf("error: invalid JSON, unsupported format\n");
		goto err;
	}

	return;
err:
	if (root != NULL) {
		json_decref(root);
		root = NULL;
	}
}

#if 0
/* FIXME Verify JSON entries before printing + mutex lock it */
static void qtvlist_print_server_and_qtvaddress_list(void)
{
	int i, j;
	json_t *server_array, *server_entry, *gs_array, *gs_entry;

	server_array = json_object_get(root, "Servers");
	
	for (i = 0; i < json_array_size(server_array); i++) {
		server_entry = json_array_get(server_array, i);
		gs_array = json_object_get(server_entry, "GameStates");

		for (j = 0; j < json_array_size(gs_array); j++) {
			gs_entry = json_array_get(gs_array, j);
			Com_Printf("%s:%" JSON_INTEGER_FORMAT " %s\n", json_string_value(json_object_get(gs_entry, "Hostname")),
						json_integer_value(json_object_get(gs_entry, "Port")),
						json_string_value(json_object_get(gs_entry, "Link")));
		}
	}
}
#endif

static const char *qtvlist_get_qtvaddress(const char *qwserver, short port)
{
	int i, j;
	json_t *server_array, *server_entry, *gs_array, *gs_entry;
	const char *hostname, *ipaddress;

	if (qwserver == NULL) {
		return NULL;
	}

	if (root == NULL) {
		Com_Printf("error: qtv list data not initialized\n");
		return NULL;
	}

	server_array = json_object_get(root, "Servers");
	
	for (i = 0; i < json_array_size(server_array); i++) {
		server_entry = json_array_get(server_array, i);
		gs_array = json_object_get(server_entry, "GameStates");

		for (j = 0; j < json_array_size(gs_array); j++) {
			gs_entry = json_array_get(gs_array, j);
			if (gs_entry == NULL) {
				continue;
			}

			hostname = json_string_value(json_object_get(gs_entry, "Hostname"));
			ipaddress = json_string_value(json_object_get(gs_entry, "IpAddress"));
			if (hostname == NULL || ipaddress == NULL) {
				continue;
			}

			if (strcmp(qwserver, hostname) == 0 || strcmp(qwserver, ipaddress) == 0) {
				if ((short)json_integer_value(json_object_get(gs_entry, "Port")) == port) {
					return json_string_value(json_object_get(gs_entry, "Link"));
				}
			}
		}
	}

	return NULL;
}

static void qtvlist_find_player(const char *name, qbool list_all)
{
	json_t *server_array, *server_entry, *gs_array, *gs_entry;
	json_t *players_array, *player_entry;
	const char *player_name;
	int i,j,k;
	unsigned short found = 0;

	
	if (name == NULL) {
		return;
	}

	if (root == NULL) {
		Com_Printf("error: qtvlist data not initialized\n");
		return;
	}

	server_array = json_object_get(root, "Servers");

	if (server_array == NULL) {
		Com_Printf("error: invalid qtvlist json data\n");
		return;
	}

	for (i = 0; i < json_array_size(server_array); i++) {
		server_entry = json_array_get(server_array, i);
		if (server_entry == NULL) {
			Com_Printf("error: invalid qtvlist json data\n");
			return;
		}

		gs_array = json_object_get(server_entry, "GameStates");
		if (gs_array == NULL || !json_is_array(gs_array)) {
			Com_Printf("error: malformed qtvlist json data\n"); /* FIXME: Make better error prints */
			return;
		}

		for (j = 0; j < json_array_size(gs_array); j++) {
			gs_entry = json_array_get(gs_array, j);
			if (gs_entry == NULL) {
				continue;
			}

			players_array = json_object_get(gs_entry, "Players");
			if (players_array == NULL || !json_is_array(players_array)) {
				continue;
				/* FIXME: Print some debug stuff atleast ?? */
			}

			for (k = 0; k < json_array_size(players_array); k++) {
				player_entry = json_array_get(players_array, k);
				if (player_entry == NULL) {
					continue;
				}

				player_name = json_string_value(json_object_get(player_entry, "Name"));
				if (player_name) {
					if (list_all || strstri(player_name, name) != NULL) {
						found++;
						Com_Printf("&cff4%15s&r - %s:%" JSON_INTEGER_FORMAT "\n", player_name, json_string_value(json_object_get(gs_entry, "Hostname")), json_integer_value(json_object_get(gs_entry, "Port")));
					}
				}
			}
		}
	}

	if (list_all) {
		Com_Printf("Listing all players\n");
	} else if (found == 0) {
		Com_Printf("Found no players matching: \"%s\"\n", name);
	}
}

static void qtvlist_find_and_follow_player(const char *name)
{
	json_t *server_array, *server_entry, *gs_array, *gs_entry;
	json_t *players_array, *player_entry;
	const char *player_name, *hostname;
	int i,j,k, port;
	unsigned short found = 0;


	if (name == NULL) {
		return;
	}

	if (root == NULL) {
		Com_Printf("error: qtvlist data not initialized\n");
		return;
	}

	server_array = json_object_get(root, "Servers");

	if (server_array == NULL) {
		Com_Printf("error: invalid qtvlist json data\n");
		return;
	}

	for (i = 0; i < json_array_size(server_array); i++) {
		server_entry = json_array_get(server_array, i);
		if (server_entry == NULL) {
			Com_Printf("error: invalid qtvlist json data\n");
			return;
		}

		gs_array = json_object_get(server_entry, "GameStates");
		if (gs_array == NULL || !json_is_array(gs_array)) {
			Com_Printf("error: malformed qtvlist json data\n"); /* FIXME: Make better error prints */
			return;
		}

		for (j = 0; j < json_array_size(gs_array); j++) {
			gs_entry = json_array_get(gs_array, j);
			if (gs_entry == NULL) {
				continue;
			}

			players_array = json_object_get(gs_entry, "Players");
			if (players_array == NULL || !json_is_array(players_array)) {
				continue;
				/* FIXME: Print some debug stuff atleast ?? */
			}

			for (k = 0; k < json_array_size(players_array); k++) {
				player_entry = json_array_get(players_array, k);
				if (player_entry == NULL) {
					continue;
				}

				player_name = json_string_value(json_object_get(player_entry, "Name"));
				if (strcmp(player_name, name) == 0) {
					found++;
					hostname = json_string_value(json_object_get(gs_entry, "Hostname"));
					port = json_integer_value(json_object_get(gs_entry, "Port"));
					Cbuf_AddText(va("connect %s:%d\n", hostname, port));
					return;
				}
			}
		}
	}
	if (found == 0) {
		Com_Printf("Found no players matching: \"%s\"\n", name);
	}

}

static void qtvlist_get_gameaddress(const char *qtvaddress, char *out_addr, size_t out_addr_len)
{
	int i, j;
	json_t *server_array, *server_entry, *gs_array, *gs_entry;
	const char *ipaddress, *link;
	json_int_t port;

	if (qtvaddress == NULL) {
		goto err;
	}

	if (root == NULL) {
		Com_Printf("error: qtv list data not initialized\n");
		goto err;
	}

	server_array = json_object_get(root, "Servers");

	if (server_array == NULL) {
		Com_Printf("error: invalid qtvlist json data\n");
		goto err;
	}
	
	for (i = 0; i < json_array_size(server_array); i++) {
		server_entry = json_array_get(server_array, i);
		gs_array = json_object_get(server_entry, "GameStates");

		for (j = 0; j < json_array_size(gs_array); j++) {
			gs_entry = json_array_get(gs_array, j);
			if (gs_entry == NULL) {
				continue;
			}

			link = json_string_value(json_object_get(gs_entry, "Link"));
			if (link == NULL) {
				continue;
			}

			if (strcmp(link, qtvaddress) == 0) {
				ipaddress = json_string_value(json_object_get(gs_entry, "IpAddress"));
				if (ipaddress == NULL) {
					continue;
				}

				port = json_integer_value(json_object_get(gs_entry, "Port"));

				snprintf(out_addr, out_addr_len, "%s:%" JSON_INTEGER_FORMAT, ipaddress, port);
				return;
			}
		}
	}
err:
	*out_addr = 0;
}

static void qtvlist_qtv_cmd(void)
{
	char tmp[256] = {0};
	char *port;
	const char *qtvaddress;
	extern qbool connected_via_proxy;

	if (qtvlist_mutex == NULL) {
		Com_Printf("error: cannot read QTV list, mutex not initialized\n");
		return;
	}

	if (Cmd_Argc() < 2) {
		/* No argument, use current connected server ip:port */
		if (cls.state < ca_connected) {
			Com_Printf("error: not connected to a server\n");
			return;
		}

		/* FIXME: It's pretty ugly, refactor all this so that we can for sure
		 * keep track of where we are connected, what kind of endpoint it is and
		 * also which server we asked the proxy to connect to...
		 */
		if (connected_via_proxy) {
			/* If connected through proxy, the target server is 
			 * hopefully still in userinfo/prx
			 */
			char *prx = Info_ValueForKey(cls.userinfo, "prx");
			char *srv = strrchr(prx, '@');
			if (srv) {
				srv++;
			} else {
				srv = prx;
			}

			if (!prx[0]) {
				Com_Printf("error: connected through proxy but missing 'prx' userinfo, can't find QTV stream\n");
				return;
			}
			strlcpy(&tmp[0], srv, sizeof(tmp));
		} else {
			strlcpy(&tmp[0], NET_AdrToString(cls.server_adr), sizeof(tmp));
		}
	} else if (Cmd_Argc() == 2) {
		/* User provided which qwserver to find a QTV stream address for */
		strlcpy(&tmp[0], Cmd_Argv(1), sizeof(tmp));
	} else {
		Com_Printf("usage: %s [qwserver:port]\n", Cmd_Argv(0));
		return;
	}

	port = strchr(&tmp[0], ':');
	if (port == NULL) {
		port = "27500";
	} else {
		*port = 0;
		port++;
	}

	if (SDL_TryLockMutex(qtvlist_mutex) != 0) {
		Com_Printf("QTV list is being updated, please try again soon\n");
		return;
	}

	qtvaddress = qtvlist_get_qtvaddress((const char*)&tmp[0], Q_atoi(port));

	if (qtvaddress != NULL) {
		Cbuf_AddText("qtvplay ");
		Cbuf_AddText(qtvaddress);
		Cbuf_AddText("\n");
	} else {
		Com_Printf("No QTV stream address found for '%s:%s'\n", &tmp[0], port);
	}

	SDL_UnlockMutex(qtvlist_mutex);
}

static int qtvlist_update(void *unused)
{
	char *jsondata = NULL;
	int ret = -1;
	int res;
	(void)unused;

	res = SDL_TryLockMutex(qtvlist_mutex);

	if (res == SDL_MUTEX_TIMEDOUT) {
		Com_Printf("The qtvlist is already in the process of being updated\n");
		goto out;
	} else if (res < 0) {
		Com_Printf("error: mutex lock failed (SDL2): %s\n", SDL_GetError());
		goto out;
	}

	jsondata = qtvlist_get_jsondata();
	if (jsondata == NULL) {
		goto out;
	}

	qtvlist_json_load_and_verify_string(jsondata);
	Q_free(jsondata);

	if (root == NULL) {
		goto out;
	}

	ret = 0;
out:
	if (res == 0) {
		SDL_UnlockMutex(qtvlist_mutex);
	}
	return ret;
}

static void qtvlist_find_player_cmd(void)
{
	qbool list_all = false;

	if (qtvlist_mutex == NULL) {
		Com_Printf("error: cannot read QTV list, mutex not initialized\n");
		return;
	}

	if (Cmd_Argc() == 1) {
		list_all = true;
	} else if (Cmd_Argc() > 2) {
		Com_Printf("usage: find [nickname] (empty arg lists all)\n");
		return;
	}

	if (SDL_TryLockMutex(qtvlist_mutex) != 0) {
		Com_Printf("Player list is being updated, please try again soon\n");
		return;
	}

	if (list_all) {
		qtvlist_find_player("", true);
	} else {
		qtvlist_find_player(Cmd_Argv(1), false);
	}

	SDL_UnlockMutex(qtvlist_mutex);
}

static void qtvlist_find_and_follow_player_cmd(void)
{
	if (qtvlist_mutex == NULL) {
		Com_Printf("error: cannot read QTV list, mutex not initialized\n");
		return;
	}

	if (Cmd_Argc() == 1) {
		Com_Printf("usage: find_and_follow [nickname]\n");
		return;
	}

	if (SDL_TryLockMutex(qtvlist_mutex) != 0) {
		Com_Printf("Player list is being updated, please try again soon\n");
		return;
	}

	qtvlist_find_and_follow_player(Cmd_Argv(1));

	SDL_UnlockMutex(qtvlist_mutex);

}

static void qtvlist_spawn_updater(void)
{
	SDL_Thread *qtvlist_thread;

	if (qtvlist_mutex == NULL) {
		Com_Printf("error: cannot update QTV list, mutex not initialized\n");
		return;
	}

	qtvlist_thread = SDL_CreateThread(qtvlist_update, "qtvupdater", (void*)NULL);
	if (qtvlist_thread == NULL) {
		Com_Printf("error: failed to initialize qtvlist thread\n");
		Com_Printf("error: qtv/observeqtv commands may not work...\n");
		return;
	}

	SDL_DetachThread(qtvlist_thread);
}

void qtvlist_joinfromqtv_cmd(void)
{
	/* FIXME: Make this prettier */
	char addr[512];
	char httpaddr[512];
	char gameaddress[512];
	char *currstream, *server;

	currstream = CL_QTV_GetCurrentStream();
	if (currstream == NULL) {
		Com_Printf("Not connected to a QTV, can't join\n");
		return;
	}

	strlcpy(&addr[0], currstream, sizeof(addr));
	/* Bleh, transformation of id@server:port to http://server:port/watch.qtv?sid=id */
	server = strchr(&addr[0], '@');
	if (server == NULL) {
		Com_Printf("error: wrong format on input\n");
		return;
	}
	*server++ = 0;
	
	snprintf(&httpaddr[0], sizeof(httpaddr), "http://%s/watch.qtv?sid=%s", server, &addr[0]);

	if (SDL_TryLockMutex(qtvlist_mutex) != 0) {
		Com_Printf("qtvlist is being updated, please try again soon\n");
		return;
	}
	qtvlist_get_gameaddress((const char*)&httpaddr[0], &gameaddress[0], sizeof(gameaddress));
	SDL_UnlockMutex(qtvlist_mutex);

	if (gameaddress[0] != 0) {
		Cbuf_AddText(va("connect %s\n", &gameaddress[0]));
	} else {
		Com_Printf("No game address found for this QTV stream\n");
	}
}

void qtvlist_init(void)
{
	Cmd_AddCommand("qtv", qtvlist_qtv_cmd);
	Cmd_AddCommand("find", qtvlist_find_player_cmd);
	Cmd_AddCommand("find_and_follow", qtvlist_find_and_follow_player_cmd);
	Cmd_AddCommand("find_update", qtvlist_spawn_updater);
	Cmd_AddCommand("observeqtv", qtvlist_qtv_cmd); /* For backwards compat */
	Cmd_AddCommand("qtv_update", qtvlist_spawn_updater);

	Cvar_SetCurrentGroup(CVAR_GROUP_QTV);
	Cvar_Register(&qtv_api_url);
	Cvar_ResetCurrentGroup();

	qtvlist_mutex = SDL_CreateMutex();
	if (qtvlist_mutex == NULL) {
		Com_Printf("error: failed to initialize qtvlist mutex\n");
		Com_Printf("error: qtv/observeqtv commands won't work...\n");
		return;
	}

	/* Initialize by running the updater at startup */
	qtvlist_spawn_updater();
}

void qtvlist_deinit(void)
{
	if (root != NULL) {
		json_decref(root);
		root = NULL;
	}

	if (qtvlist_mutex != NULL) {
		SDL_UnlockMutex(qtvlist_mutex);
		SDL_DestroyMutex(qtvlist_mutex);
	}
}




================================================
FILE: src/EX_qtvlist.h
================================================
/*
Copyright (C) 2015 dimman

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include <stddef.h>

struct str_buf {
	size_t len; /* len not size, basically strlen(str) so 1 byte less than actual size */
	char *str; /* NULL terminated */
};

void qtvlist_init(void);
void qtvlist_deinit(void);
void qtvlist_joinfromqtv_cmd(void);



================================================
FILE: src/anorm_dots.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
{
{156,164,186,171,197,216,174,174,201,203,227,250,239,244,226,130,99,136,50,70,75,103,109,145,141,49,54,79,79,65,100,88,127,153,117,188,165,199,108,136,144,203,204,178,174,217,226,226,244,252,241,212,216,236,203,212,226,236,244,252,250,183,154,188,97,123,123,156,154,183,188,79,82,112,89,117,150,52,26,50,3,9,14,27,37,67,56,9,26,27,79,52,79,50,82,89,56,108,144,112,178,150,117,100,127,136,174,153,188,165,199,204,174,65,54,88,50,49,75,79,109,145,117,70,99,103,130,164,136,171,174,141,197,244,226,227,201,203,217,241,226,41,65,37,97,41,65,27,17,9,27,17,9,1,1,3,27,12,36,36,12,27},
{156,162,186,167,195,216,166,168,195,198,222,250,239,242,224,129,96,132,46,67,70,98,102,137,135,43,47,72,72,58,92,80,118,145,109,180,156,192,100,127,136,198,198,171,166,211,221,221,241,250,237,209,216,234,207,214,229,237,246,253,250,178,151,186,97,122,124,155,157,186,189,72,77,106,86,113,145,46,22,45,3,7,14,24,37,67,53,11,31,29,87,58,85,55,86,91,58,116,151,118,183,155,121,108,135,144,181,161,195,173,206,210,181,73,61,97,55,55,82,87,117,153,126,75,102,108,131,167,140,176,181,147,200,246,229,231,207,208,223,245,231,39,64,37,98,44,67,24,16,7,32,19,12,0,3,3,22,8,30,42,16,32},
{157,161,186,163,193,216,159,162,188,194,218,249,238,239,222,128,95,129,42,64,65,94,96,130,130,38,41,65,64,51,83,72,109,136,101,172,148,184,93,118,129,192,191,164,158,205,216,215,237,248,233,205,215,231,211,216,232,237,248,253,249,173,147,184,96,120,125,154,158,189,190,66,72,99,84,109,139,40,18,41,4,6,15,22,37,67,51,14,35,31,94,65,91,59,90,92,60,123,157,123,188,159,124,117,144,152,189,170,202,181,212,215,188,81,69,105,61,62,89,95,124,160,135,80,106,114,133,169,144,181,187,154,202,247,231,235,213,212,229,248,236,37,63,38,99,48,69,21,16,5,37,22,16,0,5,4,17,5,24,48,20,38},
{158,160,187,160,191,216,152,156,182,189,213,248,238,236,219,128,94,127,40,62,60,90,90,123,125,34,35,59,57,44,75,65,100,128,94,164,139,176,85,110,121,186,184,157,150,198,211,209,233,246,228,201,212,228,213,216,234,236,249,253,247,168,143,180,95,117,125,152,159,191,189,59,67,92,81,104,132,34,14,36,5,5,15,20,37,66,48,17,40,34,101,71,97,64,93,93,62,130,163,128,193,163,126,125,153,159,196,178,209,188,218,219,194,89,77,114,67,69,96,103,132,168,143,85,110,121,136,172,149,186,194,161,205,248,233,239,219,217,234,250,239,37,64,41,101,52,73,19,17,4,42,25,20,0,7,6,14,3,19,55,25,44},
{159,159,188,156,189,216,144,151,175,185,208,247,237,233,216,129,94,125,38,61,57,87,85,117,120,30,29,54,50,37,67,57,92,120,87,156,130,168,77,101,112,179,176,149,141,191,204,202,228,242,222,196,209,223,215,216,235,235,249,252,244,162,138,176,94,114,124,150,159,192,187,53,62,85,77,99,125,28,11,32,6,4,16,19,37,65,46,20,45,37,109,78,102,68,97,94,64,136,168,133,196,166,128,133,161,166,203,186,216,196,224,223,199,97,85,123,74,77,104,112,141,176,152,91,115,128,139,176,154,191,200,168,207,249,234,242,225,221,238,252,242,37,66,44,103,57,77,18,18,4,49,30,25,1,11,9,11,1,15,62,31,51},
{161,159,189,154,188,216,138,146,169,181,202,245,236,229,214,131,94,124,37,61,54,85,80,111,116,28,25,49,43,31,60,51,84,113,80,149,122,160,69,92,104,172,168,141,132,184,198,194,222,239,217,190,206,219,216,215,235,232,249,251,241,155,133,171,92,110,122,147,159,192,185,47,57,78,74,93,118,23,8,28,8,4,17,17,37,64,43,24,51,39,115,84,107,72,99,94,65,142,173,137,199,168,129,140,169,173,210,193,222,202,228,225,204,104,93,131,81,85,112,121,149,184,161,98,120,135,143,179,160,196,206,175,210,249,236,245,230,225,242,253,244,38,68,47,106,63,82,18,21,4,55,34,31,2,14,12,9,0,11,69,36,59},
{164,159,190,151,187,216,131,141,163,177,197,242,234,225,211,133,96,123,37,61,52,84,77,105,113,26,21,45,37,26,52,45,77,105,74,141,113,151,61,84,96,164,159,133,123,177,190,187,216,234,211,183,201,213,216,213,235,229,247,249,237,147,127,166,89,106,120,143,157,192,182,41,52,71,70,87,110,19,6,24,11,4,19,16,37,63,40,28,56,42,122,90,112,76,102,94,66,148,176,140,201,169,130,148,176,179,216,201,227,208,232,227,208,112,102,140,89,94,120,130,157,192,169,106,126,143,147,183,166,201,212,182,213,249,237,247,234,229,245,253,245,40,71,52,110,70,87,18,24,6,63,40,37,4,19,16,8,0,8,76,42,66},
{166,160,192,149,186,216,125,137,157,173,192,239,233,221,208,135,98,123,37,63,51,83,73,100,111,25,18,42,31,21,46,39,70,99,69,134,105,143,54,76,87,156,151,124,115,170,183,179,210,230,205,176,196,207,216,210,233,225,245,247,233,140,120,160,87,101,118,138,155,190,178,35,47,64,66,81,103,14,4,20,14,5,20,15,37,61,37,32,61,45,128,96,116,80,104,93,67,153,180,142,202,170,130,154,183,184,222,207,232,214,235,228,211,119,110,148,97,102,129,138,166,199,177,113,133,150,152,187,172,206,218,189,216,248,238,249,239,233,248,253,246,43,75,57,115,77,93,20,28,8,70,46,43,6,23,20,7,0,5,83,48,74},
{170,161,194,148,185,216,120,133,152,170,187,236,231,217,206,138,100,124,39,65,51,84,71,96,109,24,16,39,25,17,39,35,63,92,64,127,97,135,47,68,79,147,142,115,106,163,175,171,203,225,199,168,190,200,214,206,231,221,242,244,228,132,113,153,83,96,115,133,153,188,174,29,42,57,62,75,95,10,2,17,17,6,22,14,37,59,35,36,66,47,133,101,120,83,105,92,68,157,182,144,202,169,129,161,190,189,228,214,236,218,237,229,214,126,118,156,106,111,138,147,174,206,185,121,140,158,157,191,178,211,224,196,218,247,239,251,243,236,250,253,246,47,79,63,120,85,100,22,32,11,78,53,50,9,28,25,7,0,3,90,54,82},
{173,162,195,147,184,216,115,130,146,166,182,233,229,213,203,142,104,125,42,68,52,85,70,93,107,25,14,37,20,13,34,31,57,87,60,120,90,127,40,61,71,138,133,107,97,156,166,163,196,219,192,160,183,193,211,201,228,216,239,240,222,124,106,146,80,91,111,128,149,185,168,24,37,50,58,69,87,7,2,14,20,7,24,14,37,58,32,40,71,50,138,107,123,87,106,91,69,160,183,146,201,168,128,166,196,193,233,219,240,222,239,228,216,133,126,163,115,120,146,156,182,213,192,129,147,166,162,195,184,216,229,203,221,246,239,251,246,239,251,251,245,52,85,70,125,93,107,25,37,14,87,60,57,13,34,31,8,2,2,97,61,90},
{177,164,198,146,184,216,110,127,142,164,177,229,227,208,200,146,108,127,45,72,53,86,69,90,107,27,13,37,16,10,29,28,52,82,57,114,83,119,34,54,63,130,125,98,89,149,158,155,189,214,186,152,176,185,208,196,224,210,235,236,216,115,99,138,76,85,107,122,145,181,162,19,32,44,53,62,79,4,1,11,24,9,26,13,37,55,30,45,76,53,143,111,126,89,107,89,69,163,184,146,200,167,126,171,201,196,237,224,243,225,240,226,216,139,134,170,123,128,155,164,190,219,199,138,154,174,168,200,191,221,234,209,223,244,240,252,249,242,252,249,243,57,91,77,131,101,115,29,43,18,95,68,64,17,39,37,10,4,1,104,67,98},
{181,166,200,146,184,216,106,125,137,161,173,225,225,204,198,150,113,130,49,76,55,89,69,88,107,29,14,37,12,8,24,25,47,77,55,108,77,111,28,48,56,121,116,90,81,143,149,147,181,208,179,144,169,178,204,190,220,203,230,231,210,107,91,130,72,79,103,115,140,177,156,15,27,37,49,56,71,2,1,8,28,11,28,13,37,53,27,49,80,55,147,116,128,92,107,87,69,165,184,146,198,164,123,176,206,198,241,229,245,228,239,224,216,145,142,176,132,137,163,172,197,225,205,146,162,182,174,204,197,226,238,216,226,242,240,252,251,245,252,247,240,63,97,84,138,109,123,33,50,23,104,75,72,22,45,43,13,6,1,110,74,106},
{185,169,202,147,185,216,103,123,133,159,168,221,222,200,196,155,118,133,54,82,59,92,70,86,108,32,14,38,9,7,21,24,44,74,53,103,71,104,23,42,49,112,108,81,74,137,141,140,174,202,173,135,161,169,199,184,214,196,225,227,203,98,84,122,68,73,98,109,135,171,149,11,23,31,44,50,63,1,2,6,32,14,31,14,37,51,25,53,85,57,150,120,130,94,106,84,68,167,183,145,194,161,120,179,209,200,244,232,246,229,239,221,215,150,149,182,141,145,172,179,204,230,211,155,169,190,180,209,203,230,242,222,228,239,239,251,252,247,251,244,237,69,104,92,144,118,131,39,57,28,112,84,79,26,51,50,16,9,2,116,80,113},
{189,172,205,148,185,216,101,122,130,158,164,217,220,195,194,160,124,136,59,87,62,96,72,86,109,36,16,40,6,6,18,23,41,71,53,98,66,98,19,37,42,103,100,73,67,131,132,132,166,196,167,126,153,161,194,177,209,189,219,221,196,90,76,114,64,67,93,101,129,166,142,8,19,26,40,43,56,0,3,5,36,17,33,14,37,48,23,58,89,59,152,123,131,95,105,81,68,167,181,144,191,157,117,182,212,200,247,235,247,230,237,217,213,155,155,187,150,153,180,186,211,234,216,163,177,197,186,213,210,234,245,227,230,236,239,250,253,248,250,240,233,76,111,100,152,127,139,44,64,34,121,92,87,32,57,57,20,13,3,122,86,121},
{194,175,207,150,186,216,99,122,127,157,161,212,217,191,192,166,130,141,65,94,67,101,74,86,111,41,19,42,4,6,16,24,38,69,53,94,62,92,15,33,36,95,92,66,61,126,124,125,158,190,161,117,144,152,188,169,202,181,213,216,189,81,69,105,59,61,87,94,123,159,134,5,15,21,36,38,49,0,4,4,41,20,36,15,37,46,21,62,92,61,154,126,131,96,103,78,67,167,179,142,186,152,112,184,215,200,249,237,247,229,234,212,211,159,161,191,158,161,187,192,217,238,220,172,184,204,192,217,215,238,248,232,232,233,238,249,253,249,247,236,229,84,119,109,159,136,148,51,72,40,129,101,95,37,63,64,24,17,6,127,92,128},
{198,179,210,152,187,216,98,122,125,156,157,208,215,187,190,172,137,145,72,101,73,106,78,87,114,46,22,46,3,7,15,25,37,68,54,91,58,86,12,29,31,87,85,59,55,122,116,118,151,184,155,109,135,144,181,161,195,173,206,210,181,73,61,97,55,55,81,87,116,152,126,3,12,16,31,32,42,0,6,3,45,24,38,16,37,43,19,66,96,63,155,128,131,97,101,74,66,166,175,139,180,147,108,185,216,199,250,238,246,228,231,207,207,162,167,195,166,168,194,198,222,241,224,180,192,211,198,222,221,241,250,237,234,229,237,247,253,250,245,231,223,92,127,118,166,144,156,58,80,47,137,109,102,43,69,72,30,22,8,131,98,135},
{203,183,212,154,188,216,97,123,123,156,154,203,212,183,188,178,144,150,79,108,79,112,82,89,117,52,26,50,3,9,14,27,37,67,56,89,56,82,9,27,26,79,79,52,50,117,108,112,144,178,150,100,126,136,174,153,188,165,199,204,174,65,54,88,50,49,75,79,109,145,117,1,9,12,27,27,36,1,9,3,50,27,41,17,37,41,17,70,99,65,156,130,130,97,99,70,65,164,171,136,174,141,103,186,216,197,250,239,244,226,227,201,203,164,171,197,174,174,201,203,227,244,226,188,199,217,204,226,226,244,252,241,236,226,236,244,252,250,241,226,217,100,136,127,174,153,165,65,88,54,145,117,109,49,75,79,36,27,12,136,103,141},
{208,187,215,157,190,216,98,125,122,156,152,198,210,179,187,184,151,155,87,116,85,118,86,91,122,59,31,55,3,12,15,29,37,68,58,87,54,78,7,25,22,72,73,46,46,114,101,106,137,172,145,92,118,127,166,144,180,156,192,198,166,58,47,80,45,43,69,72,102,137,109,0,6,8,24,22,30,3,12,3,55,31,43,19,37,38,16,74,101,66,155,131,128,97,96,66,63,162,167,131,168,135,98,185,216,195,250,238,241,224,222,194,198,166,175,199,181,180,207,207,231,246,228,195,206,223,210,229,231,247,253,245,237,222,234,241,250,250,237,221,211,109,144,135,181,161,173,73,97,61,152,126,116,55,81,87,42,32,16,139,108,147},
{212,191,217,161,192,216,99,127,122,157,150,194,207,175,186,190,158,161,95,124,92,125,92,94,126,66,36,61,4,15,16,33,38,69,62,86,53,74,6,24,19,65,67,41,42,111,94,101,130,166,141,84,109,119,158,136,172,148,184,192,159,51,40,72,41,37,63,64,95,129,101,0,4,6,20,17,24,5,15,4,59,36,46,21,37,36,15,78,103,67,154,131,126,96,92,62,61,159,161,127,161,128,92,184,215,191,249,237,238,220,217,187,192,167,179,200,188,186,212,211,234,247,229,202,213,229,216,233,236,249,253,247,238,217,232,238,248,249,232,215,204,117,152,144,189,169,181,81,105,69,159,134,123,61,87,94,49,38,21,142,112,152},
{217,195,220,164,194,216,101,130,122,158,148,189,205,172,185,196,166,167,103,132,100,132,98,98,131,73,42,67,6,19,18,37,41,71,66,86,53,72,6,23,16,59,62,36,40,109,87,96,124,160,136,76,100,111,150,127,163,139,177,186,152,44,34,64,36,32,57,57,87,121,92,0,3,3,17,13,20,8,19,5,64,40,48,23,37,33,14,81,105,68,152,131,123,95,89,58,59,155,155,122,153,121,86,182,212,187,247,235,234,216,211,180,186,167,181,200,194,191,217,213,237,247,230,209,219,233,221,236,240,250,253,250,239,213,230,234,245,248,227,210,197,126,161,153,196,177,189,90,114,76,166,142,129,67,93,101,56,43,26,144,117,157},
{221,200,222,168,196,216,103,133,123,159,147,185,202,169,185,202,174,173,112,141,108,140,104,103,137,81,49,74,9,23,21,42,44,74,71,86,53,70,7,24,14,54,59,32,38,108,82,92,118,155,133,69,92,104,141,118,155,131,169,180,144,39,28,57,32,26,51,50,79,112,84,1,2,2,14,9,16,11,23,6,68,44,51,25,37,31,14,84,106,68,150,130,120,94,85,53,57,150,149,116,145,113,80,179,209,182,244,232,230,211,204,172,179,167,183,200,199,194,221,215,239,246,229,214,225,237,227,239,244,251,252,251,239,209,228,230,242,247,222,203,190,135,169,161,203,184,196,98,122,84,171,149,135,73,98,109,63,50,31,145,120,161},
{225,204,225,173,198,216,106,137,125,161,146,181,200,166,184,208,181,179,121,149,116,147,111,108,143,90,56,81,12,28,24,48,47,77,77,88,55,69,8,25,14,49,55,29,37,107,76,89,113,150,130,63,84,97,132,109,146,123,162,174,138,33,23,50,28,22,45,43,72,104,75,2,1,1,11,6,13,15,27,8,72,49,53,27,37,28,13,87,107,69,147,128,116,92,80,49,55,145,142,110,137,106,74,176,206,176,241,229,225,205,197,163,172,165,184,198,204,198,224,216,239,245,228,220,230,240,231,242,247,252,251,252,240,204,226,226,238,245,216,197,182,144,178,169,210,190,203,107,130,91,177,156,140,79,103,115,71,56,37,146,123,164},
{229,208,227,177,200,216,110,142,127,164,146,177,198,164,184,214,189,186,130,158,125,155,119,114,149,98,63,89,16,34,29,54,52,82,83,90,57,69,10,28,13,45,53,27,37,107,72,86,108,146,127,57,77,91,123,101,138,115,154,168,131,29,18,43,24,17,39,37,64,95,68,4,1,1,9,4,10,19,32,11,76,53,55,30,37,26,13,89,107,69,143,126,111,89,76,45,53,139,134,104,128,98,67,171,201,170,237,224,219,199,190,155,164,163,184,196,208,200,226,216,240,243,225,224,235,243,236,244,249,252,249,252,240,200,223,221,234,242,209,191,174,152,185,176,216,196,210,115,138,99,181,162,145,85,107,122,79,62,44,146,126,167},
{233,213,229,182,203,216,115,146,130,166,147,173,195,162,184,219,196,192,138,166,133,163,127,120,156,107,71,97,20,40,34,61,57,87,90,93,60,70,13,31,14,42,52,25,37,107,68,85,104,142,125,52,70,85,115,93,129,107,147,162,125,25,14,37,20,13,34,31,57,87,60,7,2,2,7,2,8,24,37,14,80,58,58,32,37,24,14,91,106,69,138,123,107,87,71,40,50,133,126,97,120,90,61,166,196,163,233,219,213,192,182,146,156,160,183,193,211,201,228,216,239,240,222,228,239,245,240,246,251,251,246,251,239,195,221,216,229,239,203,184,166,160,193,183,222,201,216,124,146,106,185,168,149,91,111,128,87,69,50,146,128,168},
{236,217,231,187,206,216,120,152,133,170,148,170,194,161,185,225,203,199,147,175,142,171,135,127,163,115,79,106,25,47,39,68,63,92,97,96,64,71,17,35,16,39,51,24,39,109,65,84,100,138,124,47,63,79,106,85,121,100,140,157,120,22,11,32,17,9,28,25,50,78,53,10,2,3,6,0,7,29,42,17,83,62,59,35,37,22,14,92,105,68,133,120,101,83,66,36,47,126,118,90,111,82,54,161,190,156,228,214,206,185,174,138,147,157,182,189,214,202,229,214,237,236,218,231,242,246,244,247,253,251,243,250,239,191,218,211,224,236,196,178,158,168,200,190,228,206,221,132,153,113,188,174,153,96,115,133,95,75,57,144,129,169},
{239,221,233,192,208,216,125,157,137,173,149,166,192,160,186,230,210,205,156,183,151,179,143,134,170,124,87,115,31,54,46,76,70,99,105,100,69,73,21,39,18,37,51,25,42,111,63,83,98,135,123,43,57,75,97,77,113,93,133,152,115,20,8,28,14,6,23,20,43,70,46,14,4,5,5,0,7,35,47,20,87,66,61,37,37,20,15,93,104,67,128,116,96,80,61,32,45,119,110,83,102,74,48,154,183,148,222,207,199,177,166,129,138,153,180,184,216,202,228,211,235,232,214,233,245,246,247,248,253,249,239,248,238,187,216,206,218,233,189,172,150,176,207,196,233,210,225,140,160,120,190,178,155,101,118,138,103,81,64,142,130,170},
{242,225,234,197,211,216,131,163,141,177,151,164,190,159,187,234,216,211,164,190,159,187,151,141,177,133,96,123,37,61,52,84,77,105,113,105,74,77,26,45,21,37,52,26,45,113,61,84,96,133,123,40,52,71,89,70,106,87,126,147,110,18,6,24,11,4,19,16,37,63,40,19,6,8,4,0,8,41,52,24,89,70,63,40,37,19,16,94,102,66,122,112,90,76,56,28,42,112,102,76,94,66,42,148,176,140,216,201,192,169,157,120,130,148,176,179,216,201,227,208,232,227,208,235,247,245,249,249,253,247,234,245,237,183,213,201,212,229,182,166,143,183,213,201,237,213,229,147,166,127,192,182,157,106,120,143,110,87,71,140,130,169},
{245,229,236,202,214,216,138,169,146,181,154,161,189,159,188,239,222,217,172,198,168,194,160,149,184,141,104,132,43,69,60,92,84,113,122,111,80,80,31,51,25,37,54,28,49,116,61,85,94,131,124,38,47,68,81,63,98,82,120,143,106,18,4,21,8,2,14,12,31,55,34,23,8,11,4,0,9,47,57,28,92,74,64,43,37,17,17,94,99,65,115,107,84,72,51,24,39,104,93,69,85,59,36,140,169,131,210,193,184,161,149,112,121,142,173,173,216,199,225,204,228,222,202,235,249,244,251,249,253,245,230,242,236,179,210,196,206,225,175,160,135,190,219,206,241,215,232,155,171,133,192,185,159,110,122,147,118,93,78,137,129,168},
{247,233,237,208,216,216,144,175,151,185,156,159,188,159,189,242,228,222,179,204,176,202,168,156,191,149,112,141,50,77,67,101,92,120,130,117,87,85,37,57,29,38,57,30,54,120,61,87,94,129,125,37,44,66,74,57,91,77,115,139,103,18,4,18,6,1,11,9,25,49,30,28,11,15,4,1,11,53,62,32,94,77,65,46,37,16,19,94,97,64,109,102,78,68,45,20,37,97,85,62,77,51,31,133,161,123,203,186,176,152,141,104,112,136,168,166,215,196,223,199,224,216,196,235,249,242,252,249,252,242,225,238,234,176,207,191,200,221,168,154,128,196,223,209,244,216,235,162,176,138,192,187,159,114,124,150,125,99,85,133,128,166},
{248,236,238,213,219,216,152,182,156,189,160,158,187,160,191,246,233,228,186,211,184,209,176,164,198,157,121,150,57,85,75,110,100,128,139,123,94,90,44,65,35,40,60,34,59,125,62,90,94,128,127,37,41,64,67,52,85,73,110,136,101,19,4,17,5,0,7,6,20,42,25,34,14,19,5,3,14,59,67,36,95,81,66,48,37,15,20,93,93,62,101,97,71,64,40,17,34,89,77,55,69,44,25,125,153,114,196,178,168,143,132,96,103,130,163,159,213,193,219,194,218,209,188,234,249,239,253,248,250,239,219,234,233,172,205,186,194,217,161,149,121,201,228,212,247,216,236,168,180,143,191,189,159,117,125,152,132,104,92,128,126,163},
{249,239,238,218,222,216,159,188,162,194,163,157,186,161,193,248,237,233,192,216,191,215,184,172,205,164,129,158,64,93,83,118,109,136,148,130,101,96,51,72,41,42,65,38,65,130,64,94,95,128,129,37,38,63,61,48,80,69,106,133,99,21,5,16,4,0,5,4,16,37,22,40,18,24,6,5,17,66,72,41,96,84,67,51,37,15,22,92,90,60,94,91,65,59,35,14,31,81,69,48,62,38,20,117,144,105,189,170,160,135,124,89,95,123,157,152,211,188,215,188,212,202,181,232,248,236,253,247,248,235,213,229,231,169,202,181,187,212,154,144,114,205,231,215,249,216,237,173,184,147,189,190,158,120,125,154,139,109,99,123,124,159},
{250,242,239,222,224,216,166,195,168,198,167,156,186,162,195,250,241,237,198,221,198,221,192,180,211,171,136,166,72,100,92,127,118,145,156,137,109,102,58,80,47,46,70,43,72,135,67,98,96,129,132,39,37,64,55,44,75,67,102,131,98,24,7,16,3,0,3,3,12,32,19,46,22,30,7,8,22,72,77,45,97,86,67,53,37,14,24,91,86,58,87,85,58,55,31,11,29,73,61,42,55,32,16,108,135,97,181,161,153,126,117,82,87,116,151,144,207,183,210,181,206,195,173,229,246,231,253,246,245,231,207,223,229,167,200,176,181,208,147,140,108,209,234,216,250,214,237,178,186,151,186,189,157,122,124,155,145,113,106,118,121,155},
{250,244,239,227,226,216,174,201,174,203,171,156,186,164,197,252,244,241,203,226,204,226,199,188,217,178,144,174,79,108,100,136,127,153,165,145,117,109,65,88,54,50,75,49,79,141,70,103,99,130,136,41,37,65,50,41,70,65,99,130,97,27,9,17,3,1,1,3,9,27,17,52,26,36,9,12,27,79,82,50,97,89,67,56,37,14,27,89,82,56,79,79,52,50,26,9,27,65,54,36,49,27,12,100,126,88,174,153,145,117,109,75,79,108,144,136,203,178,204,174,199,188,165,226,244,226,252,244,241,227,201,217,226,164,197,171,174,203,141,136,103,212,236,216,250,212,236,183,188,154,183,188,154,123,123,156,150,117,112,112,117,150},
{250,246,239,231,229,216,181,207,181,208,176,156,186,167,200,253,246,245,207,229,210,231,206,195,223,183,151,181,87,116,108,144,135,161,173,153,126,117,73,97,61,55,82,55,87,147,75,108,102,131,140,44,37,67,46,39,67,64,96,129,98,32,12,19,3,3,0,3,7,24,16,58,31,42,11,16,32,85,86,55,97,91,67,58,37,14,29,86,77,53,72,72,46,45,22,7,24,58,47,30,43,22,8,92,118,80,166,145,137,109,102,70,72,100,136,127,198,171,198,166,192,180,156,221,241,221,250,242,237,222,195,211,224,162,195,167,168,198,135,132,98,214,237,216,250,209,234,186,189,157,178,186,151,124,122,155,155,121,118,106,113,145},
{249,247,238,235,231,216,189,213,187,212,181,157,186,169,202,253,248,248,211,232,215,236,212,202,229,188,157,188,94,123,117,152,144,170,181,160,135,124,81,105,69,61,89,62,95,154,80,114,106,133,144,48,38,69,42,37,64,63,95,128,99,37,16,22,4,5,0,4,5,21,16,65,35,48,14,20,38,91,90,59,96,92,67,60,37,15,31,84,72,51,64,66,40,41,18,6,22,51,41,24,38,17,5,83,109,72,159,136,130,101,96,65,65,93,129,118,192,164,191,158,184,172,148,216,237,215,248,239,233,218,188,205,222,161,193,163,162,194,130,129,94,216,237,215,249,205,231,189,190,158,173,184,147,125,120,154,159,124,123,99,109,139},
{248,248,238,239,233,216,196,219,194,217,186,158,187,172,205,253,249,250,213,234,219,239,218,209,234,193,163,194,101,130,125,159,153,178,188,168,143,132,89,114,77,67,96,69,103,161,85,121,110,136,149,52,41,73,40,37,62,64,94,128,101,42,20,25,5,7,0,6,4,19,17,71,40,55,17,25,44,97,93,64,95,93,66,62,37,15,34,81,67,48,57,59,34,36,14,5,20,44,35,19,34,14,3,75,100,65,152,128,123,94,90,60,59,85,121,110,186,157,184,150,176,164,139,211,233,209,246,236,228,213,182,198,219,160,191,160,156,189,125,127,90,216,236,212,247,201,228,191,189,159,168,180,143,125,117,152,163,126,128,92,104,132},
{247,249,237,242,234,216,203,225,200,221,191,159,188,176,207,252,249,252,215,235,223,242,224,216,238,196,168,199,109,136,133,166,161,186,196,176,152,141,97,123,85,74,104,77,112,168,91,128,115,139,154,57,44,77,38,37,61,66,94,129,103,49,25,30,6,11,1,9,4,18,18,78,45,62,20,31,51,102,97,68,94,94,65,64,37,16,37,77,62,46,50,53,28,32,11,4,19,37,29,15,30,11,1,67,92,57,144,120,117,87,85,57,54,77,112,101,179,149,176,141,168,156,130,204,228,202,242,233,222,208,175,191,216,159,189,156,151,185,120,125,87,216,235,209,244,196,223,192,187,159,162,176,138,124,114,150,166,128,133,85,99,125},
{245,249,236,245,236,216,210,230,206,225,196,161,189,179,210,251,249,253,216,235,225,244,228,222,242,199,173,204,115,142,140,173,169,193,202,184,161,149,104,131,93,81,112,85,121,175,98,135,120,143,160,63,47,82,37,38,61,68,94,131,106,55,31,34,8,14,2,12,4,18,21,84,51,69,24,36,59,107,99,72,92,94,64,65,37,17,39,74,57,43,43,47,23,28,8,4,17,31,25,11,28,9,0,60,84,51,138,113,111,80,80,54,49,69,104,92,172,141,168,132,160,149,122,198,222,194,239,229,217,202,169,184,214,159,188,154,146,181,116,124,85,215,232,206,241,190,219,192,185,159,155,171,133,122,110,147,168,129,137,78,93,118},
{242,249,234,247,237,216,216,234,212,229,201,164,190,183,213,249,247,253,216,235,227,245,232,227,245,201,176,208,122,148,148,179,176,201,208,192,169,157,112,140,102,89,120,94,130,182,106,143,126,147,166,70,52,87,37,40,61,71,96,133,110,63,37,40,11,19,4,16,6,18,24,90,56,76,28,42,66,112,102,76,89,94,63,66,37,19,42,70,52,40,37,41,19,24,6,4,16,26,21,8,26,8,0,52,77,45,131,105,105,74,77,52,45,61,96,84,164,133,159,123,151,141,113,190,216,187,234,225,211,197,163,177,211,159,187,151,141,177,113,123,84,213,229,201,237,183,213,192,182,157,147,166,127,120,106,143,169,130,140,71,87,110},
{239,248,233,249,238,216,222,239,218,233,206,166,192,187,216,247,245,253,216,233,228,246,235,232,248,202,180,211,128,153,154,184,183,207,214,199,177,166,119,148,110,97,129,102,138,189,113,150,133,152,172,77,57,93,37,43,63,75,98,135,115,70,43,46,14,23,6,20,8,20,28,96,61,83,32,48,74,116,104,80,87,93,61,67,37,20,45,66,47,37,31,35,14,20,4,5,15,21,18,5,25,7,0,46,70,39,125,99,100,69,73,51,42,54,87,76,156,124,151,115,143,134,105,183,210,179,230,221,205,192,157,170,208,160,186,149,137,173,111,123,83,210,225,196,233,176,207,190,178,155,140,160,120,118,101,138,170,130,142,64,81,103},
{236,247,231,251,239,216,228,243,224,236,211,170,194,191,218,244,242,253,214,231,229,246,237,236,250,202,182,214,133,157,161,189,190,214,218,206,185,174,126,156,118,106,138,111,147,196,121,158,140,157,178,85,63,100,39,47,65,79,100,138,120,78,50,53,17,28,9,25,11,22,32,101,66,90,36,54,82,120,105,83,83,92,59,68,37,22,47,62,42,35,25,29,10,17,2,6,14,17,16,3,24,7,0,39,63,35,120,92,96,64,71,51,39,47,79,68,147,115,142,106,135,127,97,175,203,171,225,217,199,187,152,163,206,161,185,148,133,170,109,124,84,206,221,190,228,168,200,188,174,153,132,153,113,115,96,133,169,129,144,57,75,95},
{233,246,229,251,239,216,233,246,229,239,216,173,195,195,221,240,239,251,211,228,228,245,239,240,251,201,183,216,138,160,166,193,196,219,222,213,192,182,133,163,126,115,146,120,156,203,129,166,147,162,184,93,70,107,42,52,68,85,104,142,125,87,57,60,20,34,13,31,14,25,37,107,71,97,40,61,90,123,106,87,80,91,58,69,37,24,50,58,37,32,20,24,7,14,2,7,14,13,14,2,25,8,2,34,57,31,115,87,93,60,70,52,37,40,71,61,138,107,133,97,127,120,90,166,196,163,219,213,192,182,146,156,203,162,184,147,130,166,107,125,85,201,216,183,222,160,193,185,168,149,124,146,106,111,91,128,168,128,146,50,69,87},
{229,244,227,252,240,216,237,249,234,242,221,177,198,200,223,236,235,249,208,224,226,243,240,243,252,200,184,216,143,163,171,196,201,224,225,219,199,190,139,170,134,123,155,128,164,209,138,174,154,168,191,101,77,115,45,57,72,91,108,146,131,95,64,68,24,39,17,37,18,29,43,111,76,104,45,67,98,126,107,89,76,89,55,69,37,26,53,53,32,30,16,19,4,11,1,9,13,10,13,1,27,10,4,29,52,28,110,82,90,57,69,53,37,34,63,54,130,98,125,89,119,114,83,158,189,155,214,208,186,177,142,149,200,164,184,146,127,164,107,127,86,196,210,176,216,152,185,181,162,145,115,138,99,107,85,122,167,126,146,44,62,79},
{225,242,225,252,240,216,241,251,238,245,226,181,200,204,226,231,230,247,204,220,224,240,239,245,252,198,184,216,147,165,176,198,206,229,228,225,205,197,145,176,142,132,163,137,172,216,146,182,162,174,197,109,84,123,49,63,76,97,113,150,138,104,72,75,28,45,22,43,23,33,50,116,80,110,49,74,106,128,107,92,72,87,53,69,37,28,55,49,27,27,12,15,2,8,1,11,13,8,14,1,29,13,6,24,47,25,106,77,88,55,69,55,37,28,56,48,121,90,116,81,111,108,77,149,181,147,208,204,179,173,137,143,198,166,184,146,125,161,107,130,89,190,203,169,210,144,178,177,156,140,107,130,91,103,79,115,164,123,146,37,56,71},
{221,239,222,251,239,216,244,252,242,247,230,185,202,209,228,227,225,244,199,214,221,237,239,246,251,194,183,215,150,167,179,200,209,232,229,230,211,204,150,182,149,141,172,145,179,222,155,190,169,180,203,118,92,131,54,69,82,104,118,155,144,112,79,84,32,51,26,50,28,39,57,120,85,116,53,80,113,130,106,94,68,84,51,68,37,31,57,44,23,25,9,11,1,6,2,14,14,7,14,2,32,16,9,21,44,24,103,74,86,53,70,59,38,23,49,42,112,81,108,74,104,103,71,141,174,140,202,200,173,168,133,137,196,169,185,147,123,159,108,133,92,184,196,161,203,135,169,171,149,135,98,122,84,98,73,109,161,120,145,31,50,63},
{217,236,220,250,239,216,247,253,245,248,234,189,205,213,230,221,219,240,194,209,217,233,237,247,250,191,181,213,152,167,182,200,212,235,230,234,216,211,155,187,155,150,180,153,186,227,163,197,177,186,210,127,100,139,59,76,87,111,124,160,152,121,87,92,36,57,32,57,34,44,64,123,89,122,58,86,121,131,105,95,64,81,48,68,37,33,59,40,19,23,6,8,0,5,3,17,14,6,16,3,36,20,13,18,41,23,101,71,86,53,72,62,40,19,42,37,103,73,100,67,98,98,66,132,166,132,196,195,167,164,130,131,194,172,185,148,122,158,109,136,96,177,189,153,196,126,161,166,142,129,90,114,76,93,67,101,157,117,144,26,43,56},
{212,233,217,249,238,216,249,253,248,249,238,194,207,217,232,216,213,236,188,202,212,229,234,247,247,186,179,211,154,167,184,200,215,237,229,238,220,217,159,191,161,158,187,161,192,232,172,204,184,192,215,136,109,148,65,84,94,119,130,166,159,129,95,101,41,63,37,64,40,51,72,126,92,127,62,92,128,131,103,96,59,78,46,67,37,36,61,36,15,21,4,5,0,4,4,20,15,6,19,6,41,24,17,16,38,24,99,69,86,53,74,67,42,15,36,33,95,66,92,61,92,94,62,124,158,125,190,191,161,161,127,126,192,175,186,150,122,157,111,141,101,169,181,144,189,117,152,159,134,123,81,105,69,87,61,94,152,112,142,21,38,49},
{208,229,215,247,237,216,250,253,250,250,241,198,210,222,234,210,206,231,181,195,207,223,231,246,245,180,175,207,155,166,185,199,216,238,228,241,224,222,162,195,167,166,194,168,198,237,180,211,192,198,221,144,118,156,72,92,101,127,137,172,166,137,102,109,45,69,43,72,47,58,80,128,96,131,66,98,135,131,101,97,55,74,43,66,37,38,63,31,12,19,3,3,0,3,6,24,16,7,22,8,46,30,22,15,37,25,98,68,87,54,78,73,46,12,31,29,87,59,85,55,86,91,58,116,151,118,184,187,155,157,125,122,190,179,187,152,122,156,114,145,106,161,173,135,181,109,144,152,126,116,73,97,61,81,55,87,147,108,139,16,32,42},
{203,226,212,244,236,216,250,252,252,250,244,203,212,226,236,204,199,226,174,188,201,217,227,244,241,174,171,203,156,164,186,197,216,239,226,244,226,227,164,197,171,174,201,174,203,241,188,217,199,204,226,153,127,165,79,100,108,136,144,178,174,145,109,117,50,75,49,79,54,65,88,130,99,136,70,103,141,130,99,97,50,70,41,65,37,41,65,27,9,17,3,1,1,3,9,27,17,9,26,12,52,36,27,14,37,27,97,67,89,56,82,79,50,9,26,27,79,52,79,50,82,89,56,108,144,112,178,183,150,154,123,117,188,183,188,154,123,156,117,150,112,153,165,127,174,100,136,145,117,109,65,88,54,75,49,79,141,103,136,12,27,36},
{198,222,210,241,234,216,250,250,253,250,247,208,215,229,237,198,192,221,166,180,194,211,222,241,237,168,167,198,155,162,185,195,216,238,224,246,228,231,166,199,175,181,207,180,207,245,195,223,206,210,231,161,135,173,87,109,116,144,151,184,181,152,116,126,55,81,55,87,61,73,97,131,101,139,74,108,147,128,96,97,45,66,38,63,37,43,66,24,6,16,3,0,3,3,12,31,19,12,31,16,59,42,32,15,37,29,98,68,91,58,86,85,55,7,22,25,72,46,73,46,78,87,54,101,137,106,172,179,145,152,122,114,187,187,190,157,125,156,122,155,118,144,156,118,166,92,127,137,109,102,58,80,47,69,43,72,135,98,131,8,22,30},
{194,217,207,238,232,216,249,248,253,249,249,212,217,233,238,192,184,215,158,172,187,204,217,238,232,161,161,192,154,159,184,191,215,237,220,247,229,234,167,200,179,188,212,186,211,247,202,229,213,216,236,169,144,181,95,117,124,152,158,190,189,159,123,134,59,87,61,94,69,81,105,131,103,142,78,112,152,126,92,96,41,62,36,61,37,46,67,20,4,15,4,0,5,4,15,36,21,15,36,21,66,49,38,16,38,33,99,69,94,62,92,92,61,6,19,24,65,41,67,42,74,86,53,94,130,101,166,175,141,150,122,111,186,191,192,161,127,157,126,161,125,136,148,109,159,84,119,129,101,95,51,72,40,63,37,64,128,92,127,6,17,24},
{189,213,205,234,230,216,247,245,253,248,250,217,220,236,239,186,177,210,150,163,180,197,211,234,227,153,155,186,152,155,182,187,212,235,216,247,230,237,167,200,181,194,217,191,213,250,209,233,219,221,240,177,153,189,103,126,132,161,166,196,196,166,129,142,64,93,67,101,76,90,114,131,105,144,81,117,157,123,89,95,36,58,33,59,37,48,68,17,3,14,6,0,8,5,19,40,23,19,42,26,73,56,43,18,41,37,101,71,98,66,98,100,67,6,16,23,59,36,62,40,72,86,53,87,124,96,160,172,136,148,122,109,185,195,194,164,130,158,131,167,132,127,139,100,152,76,111,121,92,87,44,64,34,57,32,57,121,86,122,3,13,20},
{185,209,202,230,228,216,244,242,252,247,251,221,222,239,239,180,169,203,141,155,172,190,204,230,222,145,149,179,150,150,179,182,209,232,211,246,229,239,167,200,183,199,221,194,215,251,214,237,225,227,244,184,161,196,112,135,141,169,174,202,203,171,135,149,68,98,73,109,84,98,122,130,106,145,84,120,161,120,85,94,32,53,31,57,37,51,68,14,2,14,9,1,11,6,23,44,25,23,49,31,81,63,50,21,44,42,103,74,103,71,104,108,74,7,14,24,54,32,59,38,70,86,53,82,118,92,155,169,133,147,123,108,185,200,196,168,133,159,137,173,140,118,131,92,144,69,104,112,84,79,39,57,28,51,26,50,113,80,116,2,9,16},
{181,204,200,226,226,216,241,238,251,245,252,225,225,242,240,174,162,197,132,146,163,182,197,225,216,137,142,172,147,145,176,176,206,229,205,245,228,239,165,198,184,204,224,198,216,252,220,240,230,231,247,190,169,203,121,144,149,178,181,208,210,177,140,156,72,103,79,115,91,107,130,128,107,146,87,123,164,116,80,92,28,49,28,55,37,53,69,11,1,13,12,2,15,8,27,49,27,28,56,37,90,71,56,24,47,48,106,77,108,77,111,116,81,8,14,25,49,29,55,37,69,88,55,76,113,89,150,166,130,146,125,107,184,204,198,173,137,161,143,179,147,109,123,84,138,63,97,104,75,72,33,50,23,45,22,43,106,74,110,1,6,13},
{177,200,198,221,223,216,237,234,249,242,252,229,227,244,240,168,154,191,123,138,155,174,190,219,209,128,134,164,143,139,171,170,201,224,199,243,225,240,163,196,184,208,226,200,216,252,224,243,235,236,249,196,176,210,130,152,158,185,189,214,216,181,145,162,76,107,85,122,99,115,138,126,107,146,89,126,167,111,76,89,24,45,26,53,37,55,69,9,1,13,16,4,19,11,32,53,30,34,63,44,98,79,62,29,52,54,110,82,114,83,119,125,89,10,13,28,45,27,53,37,69,90,57,72,108,86,146,164,127,146,127,107,184,208,200,177,142,164,149,186,155,101,115,77,131,57,91,95,68,64,29,43,18,39,17,37,98,67,104,1,4,10},
{173,195,195,216,221,216,233,229,246,239,251,233,229,246,239,162,147,184,115,129,146,166,182,213,203,120,126,156,138,133,166,163,196,219,192,240,222,239,160,193,183,211,228,201,216,251,228,245,239,240,251,201,183,216,138,160,166,193,196,219,222,185,149,168,80,111,91,128,106,124,146,123,106,146,91,128,168,107,71,87,20,40,24,50,37,58,69,7,2,14,20,7,24,14,37,58,32,40,71,50,107,87,69,34,57,61,115,87,120,90,127,133,97,13,14,31,42,25,52,37,70,93,60,68,104,85,142,162,125,147,130,107,184,213,203,182,146,166,156,192,163,93,107,70,125,52,85,87,60,57,25,37,14,34,13,31,90,61,97,2,2,8},
{170,191,194,211,218,216,228,224,243,236,251,236,231,247,239,157,140,178,106,121,138,158,174,206,196,111,118,147,133,126,161,156,190,214,185,236,218,237,157,189,182,214,229,202,214,250,231,246,242,244,253,206,190,221,147,168,175,200,203,225,228,188,153,174,83,115,96,133,113,132,153,120,105,144,92,129,169,101,66,83,17,36,22,47,37,59,68,6,2,14,25,10,29,17,42,62,35,47,79,57,115,95,75,39,63,68,120,92,127,97,135,142,106,17,16,35,39,24,51,39,71,96,64,65,100,84,138,161,124,148,133,109,185,217,206,187,152,170,163,199,171,85,100,63,120,47,79,78,53,50,22,32,11,28,9,25,82,54,90,3,0,7},
{166,187,192,206,216,216,222,218,239,233,249,239,233,248,238,152,133,172,97,113,129,150,166,199,189,102,110,138,128,119,154,148,183,207,177,232,214,235,153,184,180,216,228,202,211,248,233,246,245,247,253,210,196,225,156,176,183,207,210,230,233,190,155,178,87,118,101,138,120,140,160,116,104,142,93,130,170,96,61,80,14,32,20,45,37,61,67,5,4,15,31,14,35,20,47,66,37,54,87,64,124,103,81,46,70,76,125,99,134,105,143,151,115,21,18,39,37,25,51,42,73,100,69,63,98,83,135,160,123,149,137,111,186,221,208,192,157,173,170,205,179,77,93,57,115,43,75,70,46,43,20,28,8,23,6,20,74,48,83,5,0,7},
{164,183,190,201,213,216,216,212,234,229,247,242,234,249,237,147,126,166,89,106,120,143,157,192,182,94,102,130,122,112,148,140,176,201,169,227,208,232,148,179,176,216,227,201,208,245,235,245,247,249,253,213,201,229,164,183,190,213,216,234,237,192,157,182,89,120,106,143,127,147,166,112,102,140,94,130,169,90,56,76,11,28,19,42,37,63,66,4,6,16,37,19,41,24,52,70,40,61,96,71,133,110,87,52,77,84,131,105,141,113,151,159,123,26,21,45,37,26,52,45,77,105,74,61,96,84,133,159,123,151,141,113,187,225,211,197,163,177,177,211,187,70,87,52,110,40,71,63,40,37,18,24,6,19,4,16,66,42,76,8,0,8},
{161,179,189,196,210,216,210,206,230,225,245,245,236,249,236,143,120,160,81,98,112,135,149,184,175,85,93,121,115,104,140,131,169,193,161,222,202,228,142,173,173,216,225,199,204,242,235,244,249,251,253,215,206,232,172,190,198,219,222,239,241,192,159,185,92,122,110,147,133,155,171,107,99,137,94,129,168,84,51,72,8,24,17,39,37,64,65,4,8,17,43,23,47,28,57,74,43,69,104,78,141,118,93,60,84,92,138,113,149,122,160,168,132,31,25,51,37,28,54,49,80,111,80,61,94,85,131,159,124,154,146,116,188,229,214,202,169,181,184,217,194,63,82,47,106,38,68,55,34,31,18,21,4,14,2,12,59,36,69,11,0,9},
{159,176,188,191,207,216,203,200,225,221,242,247,237,249,234,139,115,154,74,91,104,128,141,176,168,77,85,112,109,97,133,123,161,186,152,216,196,224,136,166,168,215,223,196,199,238,235,242,249,252,252,216,209,235,179,196,204,223,228,242,244,192,159,187,94,124,114,150,138,162,176,102,97,133,94,128,166,78,45,68,6,20,16,37,37,65,64,4,11,19,50,28,53,32,62,77,46,77,112,85,149,125,99,67,92,101,144,120,156,130,168,176,141,37,29,57,38,30,57,54,85,117,87,61,94,87,129,159,125,156,151,120,189,233,216,208,175,185,191,222,202,57,77,44,103,37,66,49,30,25,18,18,4,11,1,9,51,31,62,15,1,11},
{158,172,187,186,205,216,196,194,219,217,239,248,238,248,233,136,110,149,67,85,96,121,132,168,161,69,77,103,101,89,125,114,153,178,143,209,188,218,130,159,163,213,219,193,194,234,234,239,249,253,250,216,212,236,186,201,211,228,233,246,247,191,159,189,95,125,117,152,143,168,180,97,93,128,93,126,163,71,40,64,5,17,15,34,37,66,62,5,14,20,57,34,59,36,67,81,48,85,121,92,157,132,104,75,100,110,152,128,164,139,176,184,150,44,35,65,40,34,60,59,90,123,94,62,94,90,128,160,127,160,156,125,191,236,219,213,182,189,198,228,209,52,73,41,101,37,64,42,25,20,19,17,4,7,0,6,44,25,55,19,3,14},
{157,169,186,181,202,216,189,187,213,212,235,249,238,247,231,133,106,144,61,80,89,114,124,160,154,62,69,95,94,81,117,105,144,170,135,202,181,212,123,152,157,211,215,188,188,229,232,236,248,253,248,216,215,237,192,205,216,231,237,248,249,189,158,190,96,125,120,154,147,173,184,91,90,123,92,124,159,65,35,59,4,14,15,31,37,67,60,6,18,22,64,40,66,41,72,84,51,93,129,99,164,139,109,83,109,118,159,136,172,148,184,191,158,51,41,72,42,38,65,65,96,130,101,64,95,94,128,161,129,163,162,130,193,239,222,218,188,194,205,233,215,48,69,38,99,37,63,37,22,16,21,16,5,5,0,4,38,20,48,24,5,17},
{156,167,186,176,200,216,181,181,207,208,231,250,239,246,229,131,102,140,55,75,82,108,117,153,147,55,61,87,87,73,108,97,135,161,126,195,173,206,116,144,151,207,210,183,181,223,229,231,246,253,245,214,216,237,198,209,221,234,241,250,250,186,157,189,97,124,122,155,151,178,186,85,86,118,91,121,155,58,31,55,3,11,14,29,37,67,58,7,22,24,72,46,72,45,77,86,53,100,136,106,171,145,113,92,118,127,166,145,180,156,192,198,166,58,47,80,46,43,70,72,102,137,109,67,96,98,129,162,132,167,168,135,195,242,224,222,195,198,211,237,221,44,67,37,98,39,64,32,19,12,24,16,7,3,0,3,32,16,42,30,8,22}
}


================================================
FILE: src/anorms.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
{-0.525731, 0.000000, 0.850651}, 
{-0.442863, 0.238856, 0.864188}, 
{-0.295242, 0.000000, 0.955423}, 
{-0.309017, 0.500000, 0.809017}, 
{-0.162460, 0.262866, 0.951056}, 
{0.000000, 0.000000, 1.000000}, 
{0.000000, 0.850651, 0.525731}, 
{-0.147621, 0.716567, 0.681718}, 
{0.147621, 0.716567, 0.681718}, 
{0.000000, 0.525731, 0.850651}, 
{0.309017, 0.500000, 0.809017}, 
{0.525731, 0.000000, 0.850651}, 
{0.295242, 0.000000, 0.955423}, 
{0.442863, 0.238856, 0.864188}, 
{0.162460, 0.262866, 0.951056}, 
{-0.681718, 0.147621, 0.716567}, 
{-0.809017, 0.309017, 0.500000}, 
{-0.587785, 0.425325, 0.688191}, 
{-0.850651, 0.525731, 0.000000}, 
{-0.864188, 0.442863, 0.238856}, 
{-0.716567, 0.681718, 0.147621}, 
{-0.688191, 0.587785, 0.425325}, 
{-0.500000, 0.809017, 0.309017}, 
{-0.238856, 0.864188, 0.442863}, 
{-0.425325, 0.688191, 0.587785}, 
{-0.716567, 0.681718, -0.147621}, 
{-0.500000, 0.809017, -0.309017}, 
{-0.525731, 0.850651, 0.000000}, 
{0.000000, 0.850651, -0.525731}, 
{-0.238856, 0.864188, -0.442863}, 
{0.000000, 0.955423, -0.295242}, 
{-0.262866, 0.951056, -0.162460}, 
{0.000000, 1.000000, 0.000000}, 
{0.000000, 0.955423, 0.295242}, 
{-0.262866, 0.951056, 0.162460}, 
{0.238856, 0.864188, 0.442863}, 
{0.262866, 0.951056, 0.162460}, 
{0.500000, 0.809017, 0.309017}, 
{0.238856, 0.864188, -0.442863}, 
{0.262866, 0.951056, -0.162460}, 
{0.500000, 0.809017, -0.309017}, 
{0.850651, 0.525731, 0.000000}, 
{0.716567, 0.681718, 0.147621}, 
{0.716567, 0.681718, -0.147621}, 
{0.525731, 0.850651, 0.000000}, 
{0.425325, 0.688191, 0.587785}, 
{0.864188, 0.442863, 0.238856}, 
{0.688191, 0.587785, 0.425325}, 
{0.809017, 0.309017, 0.500000}, 
{0.681718, 0.147621, 0.716567}, 
{0.587785, 0.425325, 0.688191}, 
{0.955423, 0.295242, 0.000000}, 
{1.000000, 0.000000, 0.000000}, 
{0.951056, 0.162460, 0.262866}, 
{0.850651, -0.525731, 0.000000}, 
{0.955423, -0.295242, 0.000000}, 
{0.864188, -0.442863, 0.238856}, 
{0.951056, -0.162460, 0.262866}, 
{0.809017, -0.309017, 0.500000}, 
{0.681718, -0.147621, 0.716567}, 
{0.850651, 0.000000, 0.525731}, 
{0.864188, 0.442863, -0.238856}, 
{0.809017, 0.309017, -0.500000}, 
{0.951056, 0.162460, -0.262866}, 
{0.525731, 0.000000, -0.850651}, 
{0.681718, 0.147621, -0.716567}, 
{0.681718, -0.147621, -0.716567}, 
{0.850651, 0.000000, -0.525731}, 
{0.809017, -0.309017, -0.500000}, 
{0.864188, -0.442863, -0.238856}, 
{0.951056, -0.162460, -0.262866}, 
{0.147621, 0.716567, -0.681718}, 
{0.309017, 0.500000, -0.809017}, 
{0.425325, 0.688191, -0.587785}, 
{0.442863, 0.238856, -0.864188}, 
{0.587785, 0.425325, -0.688191}, 
{0.688191, 0.587785, -0.425325}, 
{-0.147621, 0.716567, -0.681718}, 
{-0.309017, 0.500000, -0.809017}, 
{0.000000, 0.525731, -0.850651}, 
{-0.525731, 0.000000, -0.850651}, 
{-0.442863, 0.238856, -0.864188}, 
{-0.295242, 0.000000, -0.955423}, 
{-0.162460, 0.262866, -0.951056}, 
{0.000000, 0.000000, -1.000000}, 
{0.295242, 0.000000, -0.955423}, 
{0.162460, 0.262866, -0.951056}, 
{-0.442863, -0.238856, -0.864188}, 
{-0.309017, -0.500000, -0.809017}, 
{-0.162460, -0.262866, -0.951056}, 
{0.000000, -0.850651, -0.525731}, 
{-0.147621, -0.716567, -0.681718}, 
{0.147621, -0.716567, -0.681718}, 
{0.000000, -0.525731, -0.850651}, 
{0.309017, -0.500000, -0.809017}, 
{0.442863, -0.238856, -0.864188}, 
{0.162460, -0.262866, -0.951056}, 
{0.238856, -0.864188, -0.442863}, 
{0.500000, -0.809017, -0.309017}, 
{0.425325, -0.688191, -0.587785}, 
{0.716567, -0.681718, -0.147621}, 
{0.688191, -0.587785, -0.425325}, 
{0.587785, -0.425325, -0.688191}, 
{0.000000, -0.955423, -0.295242}, 
{0.000000, -1.000000, 0.000000}, 
{0.262866, -0.951056, -0.162460}, 
{0.000000, -0.850651, 0.525731}, 
{0.000000, -0.955423, 0.295242}, 
{0.238856, -0.864188, 0.442863}, 
{0.262866, -0.951056, 0.162460}, 
{0.500000, -0.809017, 0.309017}, 
{0.716567, -0.681718, 0.147621}, 
{0.525731, -0.850651, 0.000000}, 
{-0.238856, -0.864188, -0.442863}, 
{-0.500000, -0.809017, -0.309017}, 
{-0.262866, -0.951056, -0.162460}, 
{-0.850651, -0.525731, 0.000000}, 
{-0.716567, -0.681718, -0.147621}, 
{-0.716567, -0.681718, 0.147621}, 
{-0.525731, -0.850651, 0.000000}, 
{-0.500000, -0.809017, 0.309017}, 
{-0.238856, -0.864188, 0.442863}, 
{-0.262866, -0.951056, 0.162460}, 
{-0.864188, -0.442863, 0.238856}, 
{-0.809017, -0.309017, 0.500000}, 
{-0.688191, -0.587785, 0.425325}, 
{-0.681718, -0.147621, 0.716567}, 
{-0.442863, -0.238856, 0.864188}, 
{-0.587785, -0.425325, 0.688191}, 
{-0.309017, -0.500000, 0.809017}, 
{-0.147621, -0.716567, 0.681718}, 
{-0.425325, -0.688191, 0.587785}, 
{-0.162460, -0.262866, 0.951056}, 
{0.442863, -0.238856, 0.864188}, 
{0.162460, -0.262866, 0.951056}, 
{0.309017, -0.500000, 0.809017}, 
{0.147621, -0.716567, 0.681718}, 
{0.000000, -0.525731, 0.850651}, 
{0.425325, -0.688191, 0.587785}, 
{0.587785, -0.425325, 0.688191}, 
{0.688191, -0.587785, 0.425325}, 
{-0.955423, 0.295242, 0.000000}, 
{-0.951056, 0.162460, 0.262866}, 
{-1.000000, 0.000000, 0.000000}, 
{-0.850651, 0.000000, 0.525731}, 
{-0.955423, -0.295242, 0.000000}, 
{-0.951056, -0.162460, 0.262866}, 
{-0.864188, 0.442863, -0.238856}, 
{-0.951056, 0.162460, -0.262866}, 
{-0.809017, 0.309017, -0.500000}, 
{-0.864188, -0.442863, -0.238856}, 
{-0.951056, -0.162460, -0.262866}, 
{-0.809017, -0.309017, -0.500000}, 
{-0.681718, 0.147621, -0.716567}, 
{-0.681718, -0.147621, -0.716567}, 
{-0.850651, 0.000000, -0.525731}, 
{-0.688191, 0.587785, -0.425325}, 
{-0.587785, 0.425325, -0.688191}, 
{-0.425325, 0.688191, -0.587785}, 
{-0.425325, -0.688191, -0.587785}, 
{-0.587785, -0.425325, -0.688191}, 
{-0.688191, -0.587785, -0.425325}, 


================================================
FILE: src/bspfile.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef __BSPFILE_H__
#define __BSPFILE_H__

// upper design bounds

#define	MAX_MAP_HULLS		4

#define	MAX_MAP_MODELS		4096
#define	MAX_MAP_BRUSHES		4096
#define	MAX_MAP_ENTITIES	1024
#define	MAX_MAP_ENTSTRING	65536

#define	MAX_MAP_PLANES		8192
#define	MAX_MAP_NODES		32767		// because negative shorts are contents
#define	MAX_MAP_CLIPNODES	32767		//
#define	MAX_MAP_LEAFS		32767		// 
#define	MAX_MAP_VERTS		65535
#define	MAX_MAP_FACES		65535
#define	MAX_MAP_MARKSURFACES 65535
#define	MAX_MAP_TEXINFO		4096
#define	MAX_MAP_EDGES		256000
#define	MAX_MAP_SURFEDGES	512000
#define	MAX_MAP_MIPTEX		0x200000
#define	MAX_MAP_LIGHTING	0x100000
#define	MAX_MAP_VISIBILITY	0x100000

// key / value pair sizes

#define	MAX_KEY		32
#define	MAX_VALUE	1024


//=============================================================================


#define Q1_BSPVERSION     29
#define HL_BSPVERSION     30
#define Q1_BSPVERSION29a  (('2') + ('P' << 8) + ('S' << 16) + ('B' << 24))
#define Q1_BSPVERSION2    (('B') + ('S' << 8) + ('P' << 16) + ('2' << 24))

typedef struct
{
	int		fileofs, filelen;
} lump_t;

#define	LUMP_ENTITIES	0
#define	LUMP_PLANES		1
#define	LUMP_TEXTURES	2
#define	LUMP_VERTEXES	3
#define	LUMP_VISIBILITY	4
#define	LUMP_NODES		5
#define	LUMP_TEXINFO	6
#define	LUMP_FACES		7
#define	LUMP_LIGHTING	8
#define	LUMP_CLIPNODES	9
#define	LUMP_LEAFS		10
#define	LUMP_MARKSURFACES 11
#define	LUMP_EDGES		12
#define	LUMP_SURFEDGES	13
#define	LUMP_MODELS		14

#define	HEADER_LUMPS	15

#if defined(_MSC_VER) && !defined(__attribute__)
#define __attribute__(A) /**/
#endif

typedef struct
{
	float       mins[3], maxs[3];
	float       origin[3];
	int	        headnode[MAX_MAP_HULLS];
	int         visleafs;                    // not including the solid leaf 0
	int         firstface, numfaces;
} dmodel_t __attribute__((aligned(1)));


typedef struct
{
	int         version;
	lump_t      lumps[HEADER_LUMPS];
} dheader_t;

typedef struct
{
	int         nummiptex;
	int         dataofs[4];                  // [nummiptex]
} dmiptexlump_t;

#define	MIPLEVELS	4
typedef struct miptex_s
{
	char        name[16];
	unsigned    width, height;
	unsigned    offsets[MIPLEVELS];		// four mip maps stored
} miptex_t;


typedef struct
{
	float       point[3];
} dvertex_t;


// 0-2 are axial planes
#define	PLANE_X			0
#define	PLANE_Y			1
#define	PLANE_Z			2

// 3-5 are non-axial planes snapped to the nearest
#define	PLANE_ANYX		3
#define	PLANE_ANYY		4
#define	PLANE_ANYZ		5

typedef struct
{
	float       normal[3];
	float       dist;
	int         type;             // PLANE_X - PLANE_ANYZ ?remove? trivial to regenerate
} dplane_t;



#define	CONTENTS_EMPTY		-1
#define	CONTENTS_SOLID		-2
#define	CONTENTS_WATER		-3
#define	CONTENTS_SLIME		-4
#define	CONTENTS_LAVA		-5
#define	CONTENTS_SKY		-6

typedef struct
{
	int             planenum;
	short           children[2];	// negative numbers are -(leafs+1), not nodes
	short           mins[3];        // for sphere culling
	short           maxs[3];
	unsigned short  firstface;
	unsigned short  numfaces;       // counting both sides
} dnode_t;

typedef struct
{
	int             planenum;
	int             children[2];    // negative numbers are -(leafs+1), not nodes
	short           mins[3];        // for sphere culling
	short           maxs[3];
	unsigned int    firstface;
	unsigned int    numfaces;       // counting both sides
} dnode29a_t;

typedef struct
{
	int             planenum;
	int             children[2];    // negative numbers are -(leafs+1), not nodes
	float           mins[3];        // for sphere culling
	float           maxs[3];
	unsigned int    firstface;
	unsigned int    numfaces;       // counting both sides
} dnode_bsp2_t;

typedef struct
{
	int         planenum;
	short       children[2];        // negative numbers are contents
} dclipnode_t;

typedef struct
{
	int         planenum;
	int         children[2];        // negative numbers are contents
} dclipnode29a_t;

typedef struct
{
	int         planenum;
	int         children[2];        // negative numbers are contents
} mclipnode_t;

typedef struct texinfo_s
{
	float		vecs[2][4];         // [s/t][xyz offset]
	int			miptex;
	int			flags;
} texinfo_t;
#define	TEX_SPECIAL		1           // sky or slime, no lightmap or 256 subdivision

// note that edge 0 is never used, because negative edge nums are used for
// counterclockwise use of the edge in a face
typedef struct {
	unsigned short	v[2];           // vertex numbers
} dedge_t;

typedef struct {
	unsigned int	v[2];           // vertex numbers
} dedge29a_t;

#define	MAXLIGHTMAPS	4
typedef struct {
	short       planenum;
	short       side;

	int         firstedge;      // we must support > 64k edges
	short       numedges;	
	short       texinfo;

	// lighting info
	byte        styles[MAXLIGHTMAPS];
	int         lightofs;       // start of [numstyles*surfsize] samples
} dface_t;

typedef struct {
	int         planenum;
	int         side;

	int         firstedge;      // we must support > 64k edges
	int         numedges;
	int         texinfo;

	// lighting info
	byte        styles[MAXLIGHTMAPS];
	int         lightofs;       // start of [numstyles*surfsize] samples
} dface29a_t;

#define	AMBIENT_WATER   0
#define	AMBIENT_SKY     1
#define	AMBIENT_SLIME   2
#define	AMBIENT_LAVA    3

#define	NUM_AMBIENTS    4       // automatic ambient sounds

// leaf 0 is the generic CONTENTS_SOLID leaf, used for all solid areas
// all other leafs need visibility info
typedef struct {
	int            contents;
	int            visofs;          // -1 = no visibility info

	short          mins[3];         // for frustum culling
	short          maxs[3];

	unsigned short firstmarksurface;
	unsigned short nummarksurfaces;

	byte           ambient_level[NUM_AMBIENTS];
} dleaf_t;

typedef struct {
	int            contents;
	int            visofs;          // -1 = no visibility info

	short          mins[3];         // for frustum culling
	short          maxs[3];

	unsigned int   firstmarksurface;
	unsigned int   nummarksurfaces;

	byte           ambient_level[NUM_AMBIENTS];
} dleaf29a_t;

typedef struct {
	int            contents;
	int            visofs;          // -1 = no visibility info

	float          mins[3];         // for frustum culling
	float          maxs[3];

	unsigned int   firstmarksurface;
	unsigned int   nummarksurfaces;

	byte           ambient_level[NUM_AMBIENTS];
} dleaf_bsp2_t;

typedef struct {
	unsigned short lmwidth;
	unsigned short lmheight;
	int            lightofs;
	float          vecs[2][4];
} dlminfo_t;

#endif /* !__BSPFILE_H__ */


================================================
FILE: src/cd_linux.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: cd_linux.c,v 1.9 2007-10-04 13:48:11 dkure Exp $
*/
// cd_linux.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/file.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#ifdef __FreeBSD__
#include <sys/cdio.h>
#else
#include <linux/cdrom.h>
#endif

#include "quakedef.h"
#include "cdaudio.h"
#include "qsound.h"

static qbool cdValid = false;
static qbool	playing = false;
static qbool	wasPlaying = false;
static qbool	initialized = false;
static qbool	enabled = true;
static qbool playLooping = false;
static float	cdvolume;
static byte 	remap[100];
static byte		playTrack;
static byte		maxTrack;

static int cdfile = -1;
static char cd_dev[64] = "/dev/cdrom";

static void CDAudio_Eject(void)
{
	if (cdfile == -1 || !enabled)
		return; // no cd init'd

#ifdef __FreeBSD__
	if (ioctl(cdfile, CDIOCEJECT) == -1)
		Com_DPrintf ("ioctl cdioceject failed\n");
#else
	if ( ioctl(cdfile, CDROMEJECT) == -1 )
		Com_DPrintf ("ioctl cdromeject failed\n");
#endif
}


static void CDAudio_CloseDoor(void)
{
	if (cdfile == -1 || !enabled)
		return; // no cd init'd

#ifdef __FreeBSD__
	if (ioctl(cdfile, CDIOCCLOSE) == -1)
		Com_DPrintf ("ioctl cdiocclose failed\n");
#else
	if ( ioctl(cdfile, CDROMCLOSETRAY) == -1 )
		Com_DPrintf ("ioctl cdromclosetray failed\n");
#endif
}

static int CDAudio_GetAudioDiskInfo(void)
{
#ifdef __FreeBSD__
	struct ioc_toc_header tochdr;
#else
	struct cdrom_tochdr tochdr;
#endif

	cdValid = false;

#ifdef __FreeBSD__
	if (ioctl(cdfile, CDIOREADTOCHEADER, &tochdr) == -1)
	{
		Com_DPrintf ("ioctl cdioreadtocheader failed\n");
#else
	if ( ioctl(cdfile, CDROMREADTOCHDR, &tochdr) == -1 )
    {
      Com_DPrintf ("ioctl cdromreadtochdr failed\n");
#endif
	  return -1;
    }

#ifdef __FreeBSD__
	if (tochdr.starting_track < 1)
#else
	if (tochdr.cdth_trk0 < 1)
#endif
	{
		Com_DPrintf ("CDAudio: no music tracks\n");
		return -1;
	}

	cdValid = true;
#ifdef __FreeBSD__
	maxTrack = tochdr.ending_track;
#else
	maxTrack = tochdr.cdth_trk1;
#endif

	return 0;
}


void CDAudio_Play(byte track, qbool looping)
{
#ifdef __FreeBSD__
	struct ioc_read_toc_entry entry;
	struct cd_toc_entry toc_buffer;
	struct ioc_play_track ti;
#else
	struct cdrom_tocentry entry;
	struct cdrom_ti ti;
#endif

	if (cdfile == -1 || !enabled)
		return;

	if (!cdValid)
	{
		CDAudio_GetAudioDiskInfo();
		if (!cdValid)
			return;
	}

	track = remap[track];

	if (track < 1 || track > maxTrack)
	{
		Com_DPrintf ("CDAudio: Bad track number %u.\n", track);
		return;
	}

#ifdef __FreeBSD__
	#define CDROM_DATA_TRACK 4
	bzero((char *)&toc_buffer, sizeof(toc_buffer));
	entry.data_len = sizeof(toc_buffer);
	entry.data = &toc_buffer;
	// don't try to play a non-audio track
	entry.starting_track = track;
	entry.address_format = CD_MSF_FORMAT;
    if ( ioctl(cdfile, CDIOREADTOCENTRYS, &entry) == -1 )
	{
		Com_DPrintf("ioctl cdromreadtocentry failed\n");
		return;
	}
	if (toc_buffer.control == CDROM_DATA_TRACK)
#else
	// don't try to play a non-audio track
	entry.cdte_track = track;
	entry.cdte_format = CDROM_MSF;
    if ( ioctl(cdfile, CDROMREADTOCENTRY, &entry) == -1 )
	{
		Com_DPrintf ("ioctl cdromreadtocentry failed\n");
		return;
	}
	if (entry.cdte_ctrl == CDROM_DATA_TRACK)
#endif
	{
		Com_Printf ("CDAudio: track %i is not audio\n", track);
		return;
	}

	if (playing)
	{
		if (playTrack == track)
			return;
		CDAudio_Stop();
	}

#ifdef __FreeBSD__
	ti.start_track = track;
	ti.end_track = track;
	ti.start_index = 1;
	ti.end_index = 99;
#else
	ti.cdti_trk0 = track;
	ti.cdti_trk1 = track;
	ti.cdti_ind0 = 1;
	ti.cdti_ind1 = 99;
#endif

#ifdef __FreeBSD__
	if (ioctl(cdfile, CDIOCPLAYTRACKS, &ti) == -1)
	{
		Com_DPrintf ("ioctl cdiocplaytracks failed\n");
#else
	if ( ioctl(cdfile, CDROMPLAYTRKIND, &ti) == -1 )
    {
		Com_DPrintf ("ioctl cdromplaytrkind failed\n");
#endif
		return;
    }

#ifdef __FreeBSD__
	if (ioctl(cdfile, CDIOCRESUME) == -1)
		Com_DPrintf ("ioctl cdiocresume failed\n");
#else
	if ( ioctl(cdfile, CDROMRESUME) == -1 )
		Com_DPrintf ("ioctl cdromresume failed\n");
#endif

	playLooping = looping;
	playTrack = track;
	playing = true;

	if (cdvolume == 0.0)
		CDAudio_Pause ();
}


void CDAudio_Stop(void)
{
	if (cdfile == -1 || !enabled)
		return;

	if (!playing)
		return;

#ifdef __FreeBSD__
	if (ioctl(cdfile, CDIOCSTOP) == -1)
		Com_DPrintf ("ioctl cdiocstop failed (%d)\n", errno);
#else
	if ( ioctl(cdfile, CDROMSTOP) == -1 )
		Com_DPrintf ("ioctl cdromstop failed (%d)\n", errno);
#endif

	wasPlaying = false;
	playing = false;
}

void CDAudio_Pause(void)
{
	if (cdfile == -1 || !enabled)
		return;

	if (!playing)
		return;

#ifdef __FreeBSD__
	if (ioctl(cdfile, CDIOCPAUSE) == -1)
		Com_DPrintf ("ioctl cdiocpause failed\n");
#else
	if ( ioctl(cdfile, CDROMPAUSE) == -1 )
		Com_DPrintf ("ioctl cdrompause failed\n");
#endif

	wasPlaying = playing;
	playing = false;
}


void CDAudio_Resume(void)
{
	if (cdfile == -1 || !enabled)
		return;

	if (!cdValid)
		return;

	if (!wasPlaying)
		return;

#ifdef __FreeBSD__
	if (ioctl(cdfile, CDIOCRESUME) == -1)
		Com_DPrintf ("ioctl cdiocresume failed\n");
#else
	if ( ioctl(cdfile, CDROMRESUME) == -1 )
		Com_DPrintf ("ioctl cdromresume failed\n");
#endif
	playing = true;
}

#define CHECK_CD_ARGS(x)		\
	if (Cmd_Argc() != x) {		\
	Com_Printf("Usage: %s <on|off|reset|remap|close|play|loop|stop|pause|resume|eject|info>\n", Cmd_Argv(0));	\
	return;					\
	}

void CD_f (void) {
	char *command;
	int ret, n;

	if (Cmd_Argc() < 2) {
		Com_Printf("Usage: %s <on|off|reset|remap|close|play|loop|stop|pause|resume|eject|info>\n", Cmd_Argv(0));
		return;
	}

	command = Cmd_Argv (1);

	if (!strcasecmp(command, "on")) {
		CHECK_CD_ARGS(2);
		enabled = true;
		return;
	} else if (!strcasecmp(command, "off")) {
		CHECK_CD_ARGS(2);
		CDAudio_Stop();
		enabled = false;
		return;
	} else if (!strcasecmp(command, "reset")) {
		CHECK_CD_ARGS(2);
		enabled = true;
		CDAudio_Stop();
		for (n = 0; n < 100; n++)
			remap[n] = n;
		CDAudio_GetAudioDiskInfo();
		return;
	} else if (!strcasecmp(command, "remap")) {
		ret = Cmd_Argc() - 2;
		if (!ret) {
			for (n = 1; n < 100; n++)
				if (remap[n] != n)
					Com_Printf ("  %u -> %u\n", n, remap[n]);
		} else {
			for (n = 1; n <= ret; n++)
				remap[n] = Q_atoi(Cmd_Argv (n + 1));
		}
		return;
	} else if (!strcasecmp(command, "close")) {
		CHECK_CD_ARGS(2);
		CDAudio_CloseDoor();
		return;
	}

	if (!cdValid) {
		CDAudio_GetAudioDiskInfo();
		if (!cdValid) {
			Com_Printf ("No CD in player.\n");
			return;
		}
	}

	if (!strcasecmp(command, "play"))	{
		CHECK_CD_ARGS(3);
		CDAudio_Play((byte) Q_atoi(Cmd_Argv(2)), false);
	} else if (!strcasecmp(command, "loop"))	{
		CHECK_CD_ARGS(3);
		CDAudio_Play((byte) Q_atoi(Cmd_Argv(2)), true);
	} else if (!strcasecmp(command, "stop"))	{
		CHECK_CD_ARGS(2);
		CDAudio_Stop();
	} else if (!strcasecmp(command, "pause")) {
		CHECK_CD_ARGS(2);
		CDAudio_Pause();
	} else if (!strcasecmp(command, "resume")) {
		CHECK_CD_ARGS(2);
		CDAudio_Resume();
	} else if (!strcasecmp(command, "eject")) {
		CHECK_CD_ARGS(2);
		CDAudio_Stop();
		CDAudio_Eject();
		cdValid = false;
	} else if (!strcasecmp(command, "info"))	{
		CHECK_CD_ARGS(2);
		Com_Printf ("%u tracks\n", maxTrack);
		if (playing)
			Com_Printf ("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
		else if (wasPlaying)
			Com_Printf ("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
		Com_Printf ("Volume is %f\n", cdvolume);
	}
}

void CDAudio_Update(void)
{
#ifdef __FreeBSD__
	struct ioc_read_subchannel subchnl;
	struct cd_sub_channel_info data;
#else
	struct cdrom_subchnl subchnl;
#endif
	static time_t lastchk;

	if (!enabled)
		return;

	if (bgmvolume.value != cdvolume)
	{
		if (cdvolume)
		{
			Cvar_SetValue (&bgmvolume, 0.0);
			cdvolume = bgmvolume.value;
			CDAudio_Pause ();
		}
		else
		{
			Cvar_SetValue (&bgmvolume, 1.0);
			cdvolume = bgmvolume.value;
			CDAudio_Resume ();
		}
	}

	if (playing && lastchk < time(NULL)) {
		lastchk = time(NULL) + 2; //two seconds between chks
#if defined(__FreeBSD__)
		subchnl.address_format = CD_MSF_FORMAT;
		subchnl.data_format = CD_CURRENT_POSITION;
		subchnl.data_len = sizeof(data);
		subchnl.track = playTrack;
		subchnl.data = &data;
		if (ioctl(cdfile, CDIOCREADSUBCHANNEL, &subchnl) == -1 ) {
			Com_DPrintf("ioctl cdiocreadsubchannel failed\n");
			playing = false;
			return;
		}
		if (subchnl.data->header.audio_status != CD_AS_PLAY_IN_PROGRESS &&
			subchnl.data->header.audio_status != CD_AS_PLAY_PAUSED) {
			playing = false;
			if (playLooping)
				CDAudio_Play(playTrack, true);
		}
#else
		subchnl.cdsc_format = CDROM_MSF;
		if (ioctl(cdfile, CDROMSUBCHNL, &subchnl) == -1 ) {
			Com_DPrintf ("ioctl cdromsubchnl failed\n");
			playing = false;
			return;
		}
		if (subchnl.cdsc_audiostatus != CDROM_AUDIO_PLAY &&
			subchnl.cdsc_audiostatus != CDROM_AUDIO_PAUSED) {
			playing = false;
			if (playLooping)
				CDAudio_Play(playTrack, true);
		}
#endif
	}
}

int CDAudio_Init(void)
{
	int i;

	if (!COM_CheckParm(cmdline_param_client_cd_audio))
		return -1;

	if ((i = COM_CheckParm(cmdline_param_client_cd_device)) != 0 && i < COM_Argc() - 1)
		strlcpy (cd_dev, COM_Argv(i + 1), sizeof(cd_dev));

	if ((cdfile = open(cd_dev, O_RDONLY)) == -1) {
		Com_Printf ("CDAudio_Init: open of \"%s\" failed (%i)\n", cd_dev, errno);
		cdfile = -1;
		return -1;
	}

	for (i = 0; i < 100; i++)
		remap[i] = i;
	initialized = true;
	enabled = true;

	if (CDAudio_GetAudioDiskInfo())
	{
		Com_Printf ("CDAudio_Init: No CD in player.\n");
		cdValid = false;
	}

	Cmd_AddCommand ("cd", CD_f);

	Com_Printf ("CD Audio Initialized\n");

	return 0;
}


void CDAudio_Shutdown(void)
{
	if (!initialized)
		return;
	CDAudio_Stop();
	close(cdfile);
	cdfile = -1;
}


================================================
FILE: src/cd_null.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "quakedef.h"

void CDAudio_Play(byte track, qbool looping)
{
}

void CDAudio_Stop(void)
{
}

void CDAudio_Pause(void)
{
}

void CDAudio_Resume(void)
{
}

void CD_f (void) {
}

void CDAudio_Update(void)
{
}

int CDAudio_Init(void)
{
	return 0;
}

void CDAudio_Shutdown(void)
{
}

================================================
FILE: src/cd_win.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// Quake is a trademark of Id Software, Inc., (c) 1996 Id Software, Inc. All
// rights reserved.

#include "quakedef.h"
#include "cdaudio.h"

extern	HWND	mainwindow;
extern	cvar_t	bgmvolume;

static qbool cdValid = false;
static qbool	playing = false;
static qbool	wasPlaying = false;
static qbool	initialized = false;
static qbool	enabled = false;
static qbool playLooping = false;
static float	cdvolume;
static byte 	remap[100];
static byte		playTrack;
static byte		maxTrack;

UINT	wDeviceID;


static void CDAudio_Eject(void)
{
	DWORD	dwReturn = mciSendCommand(wDeviceID, MCI_SET, MCI_SET_DOOR_OPEN, (DWORD)NULL);

    if (dwReturn)
		Com_DPrintf ("MCI_SET_DOOR_OPEN failed (%i)\n", dwReturn);
}


static void CDAudio_CloseDoor(void)
{
	DWORD	dwReturn = mciSendCommand(wDeviceID, MCI_SET, MCI_SET_DOOR_CLOSED, (DWORD)NULL);

    if (dwReturn)
		Com_DPrintf ("MCI_SET_DOOR_CLOSED failed (%i)\n", dwReturn);
}


static int CDAudio_GetAudioDiskInfo(void)
{
	DWORD				dwReturn;
	MCI_STATUS_PARMS	mciStatusParms;


	cdValid = false;

	mciStatusParms.dwItem = MCI_STATUS_READY;
    dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_WAIT, (DWORD) (LPVOID) &mciStatusParms);
	if (dwReturn)
	{
		Com_DPrintf ("CDAudio: drive ready test - get status failed\n");
		return -1;
	}
	if (!mciStatusParms.dwReturn)
	{
		Com_DPrintf ("CDAudio: drive not ready\n");
		return -1;
	}

	mciStatusParms.dwItem = MCI_STATUS_NUMBER_OF_TRACKS;
    dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_WAIT, (DWORD) (LPVOID) &mciStatusParms);
	if (dwReturn)
	{
		Com_DPrintf ("CDAudio: get tracks - status failed\n");
		return -1;
	}
	if (mciStatusParms.dwReturn < 1)
	{
		Com_DPrintf ("CDAudio: no music tracks\n");
		return -1;
	}

	cdValid = true;
	maxTrack = mciStatusParms.dwReturn;

	return 0;
}


void CDAudio_Play(byte track, qbool looping)
{
	DWORD				dwReturn;
    MCI_PLAY_PARMS		mciPlayParms;
	MCI_STATUS_PARMS	mciStatusParms;

	if (!enabled)
		return;
	
	if (!cdValid)
	{
		CDAudio_GetAudioDiskInfo();
		if (!cdValid)
			return;
	}

	track = remap[track];

	if (track < 1 || track > maxTrack)
	{
		Com_DPrintf ("CDAudio: Bad track number %u.\n", track);
		return;
	}

	// don't try to play a non-audio track
	mciStatusParms.dwItem = MCI_CDA_STATUS_TYPE_TRACK;
	mciStatusParms.dwTrack = track;
    dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT, (DWORD) (LPVOID) &mciStatusParms);
	if (dwReturn)
	{
		Com_DPrintf ("MCI_STATUS failed (%i)\n", dwReturn);
		return;
	}
	if (mciStatusParms.dwReturn != MCI_CDA_TRACK_AUDIO)
	{
		Com_Printf ("CDAudio: track %i is not audio\n", track);
		return;
	}

	// get the length of the track to be played
	mciStatusParms.dwItem = MCI_STATUS_LENGTH;
	mciStatusParms.dwTrack = track;
    dwReturn = mciSendCommand(wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_TRACK | MCI_WAIT, (DWORD) (LPVOID) &mciStatusParms);
	if (dwReturn)
	{
		Com_DPrintf ("MCI_STATUS failed (%i)\n", dwReturn);
		return;
	}

	if (playing)
	{
		if (playTrack == track)
			return;
		CDAudio_Stop();
	}

    mciPlayParms.dwFrom = MCI_MAKE_TMSF(track, 0, 0, 0);
	mciPlayParms.dwTo = (mciStatusParms.dwReturn << 8) | track;
    mciPlayParms.dwCallback = (DWORD)mainwindow;
    dwReturn = mciSendCommand(wDeviceID, MCI_PLAY, MCI_NOTIFY | MCI_FROM | MCI_TO, (DWORD)(LPVOID) &mciPlayParms);
	if (dwReturn)
	{
		Com_DPrintf ("CDAudio: MCI_PLAY failed (%i)\n", dwReturn);
		return;
	}

	playLooping = looping;
	playTrack = track;
	playing = true;

	if (cdvolume == 0.0)
		CDAudio_Pause ();
}


void CDAudio_Stop(void)
{
	DWORD	dwReturn;

	if (!enabled)
		return;
	
	if (!playing)
		return;

	dwReturn = mciSendCommand(wDeviceID, MCI_STOP, 0, (DWORD)NULL);
    if (dwReturn)
		Com_DPrintf ("MCI_STOP failed (%i)", dwReturn);

	wasPlaying = false;
	playing = false;
}


void CDAudio_Pause(void)
{
	DWORD				dwReturn;
	MCI_GENERIC_PARMS	mciGenericParms;

	if (!enabled)
		return;

	if (!playing)
		return;

	mciGenericParms.dwCallback = (DWORD)mainwindow;
    if ((dwReturn = mciSendCommand(wDeviceID, MCI_PAUSE, 0, (DWORD)(LPVOID) &mciGenericParms)))
		Com_DPrintf ("MCI_PAUSE failed (%i)", dwReturn);

	wasPlaying = playing;
	playing = false;
}


void CDAudio_Resume(void)
{
	DWORD			dwReturn;
    MCI_PLAY_PARMS	mciPlayParms;

	if (!enabled)
		return;
	
	if (!cdValid)
		return;

	if (!wasPlaying)
		return;
	
    mciPlayParms.dwFrom = MCI_MAKE_TMSF(playTrack, 0, 0, 0);
    mciPlayParms.dwTo = MCI_MAKE_TMSF(playTrack + 1, 0, 0, 0);
    mciPlayParms.dwCallback = (DWORD)mainwindow;
    dwReturn = mciSendCommand(wDeviceID, MCI_PLAY, MCI_TO | MCI_NOTIFY, (DWORD)(LPVOID) &mciPlayParms);
	if (dwReturn)
	{
		Com_DPrintf ("CDAudio: MCI_PLAY failed (%i)\n", dwReturn);
		return;
	}
	playing = true;
}

#define CHECK_CD_ARGS(x)		\
	if (Cmd_Argc() != x) {		\
		Com_Printf("Usage: %s <on|off|reset|remap|close|play|loop|stop|pause|resume|eject|info>\n", Cmd_Argv(0));	\
		return;					\
	}


void CD_f (void) {
	char *command;
	int ret, n;

	if (Cmd_Argc() < 2) {
		Com_Printf("Usage: %s <on|off|reset|remap|close|play|loop|stop|pause|resume|eject|info>\n", Cmd_Argv(0));
		return;
	}

	command = Cmd_Argv (1);

	if (!strcasecmp(command, "on")) {
		CHECK_CD_ARGS(2);
		enabled = true;
		return;
	} else if (!strcasecmp(command, "off")) {
		CHECK_CD_ARGS(2);
		CDAudio_Stop();
		enabled = false;
		return;
	} else if (!strcasecmp(command, "reset")) {
		CHECK_CD_ARGS(2);
		enabled = true;
		CDAudio_Stop();
		for (n = 0; n < 100; n++)
			remap[n] = n;
		CDAudio_GetAudioDiskInfo();
		return;
	} else if (!strcasecmp(command, "remap")) {
		ret = Cmd_Argc() - 2;
		if (!ret) {
			for (n = 1; n < 100; n++)
				if (remap[n] != n)
					Com_Printf ("  %u -> %u\n", n, remap[n]);
		} else {
			for (n = 1; n <= ret; n++)
				remap[n] = Q_atoi(Cmd_Argv (n + 1));
		}
		return;
	} else if (!strcasecmp(command, "close")) {
		CHECK_CD_ARGS(2);
		CDAudio_CloseDoor();
		return;
	}

	if (!cdValid) {
		CDAudio_GetAudioDiskInfo();
		if (!cdValid) {
			Com_Printf ("No CD in player.\n");
			return;
		}
	}

	if (!strcasecmp(command, "play"))	{
		CHECK_CD_ARGS(3);
		CDAudio_Play((byte) Q_atoi(Cmd_Argv(2)), false);
	} else if (!strcasecmp(command, "loop"))	{
		CHECK_CD_ARGS(3);
		CDAudio_Play((byte) Q_atoi(Cmd_Argv(2)), true);
	} else if (!strcasecmp(command, "stop"))	{
		CHECK_CD_ARGS(2);
		CDAudio_Stop();
	} else if (!strcasecmp(command, "pause")) {
		CHECK_CD_ARGS(2);
		CDAudio_Pause();
	} else if (!strcasecmp(command, "resume")) {
		CHECK_CD_ARGS(2);
		CDAudio_Resume();
	} else if (!strcasecmp(command, "eject")) {
		CHECK_CD_ARGS(2);
		CDAudio_Stop();
		CDAudio_Eject();
		cdValid = false;
	} else if (!strcasecmp(command, "info"))	{
		CHECK_CD_ARGS(2);
		Com_Printf ("%u tracks\n", maxTrack);
		if (playing)
			Com_Printf ("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
		else if (wasPlaying)
			Com_Printf ("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
		Com_Printf ("Volume is %f\n", cdvolume);
	}
}


LONG CDAudio_MessageHandler(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if ((UINT) lParam != wDeviceID)
		return 1;

	switch (wParam)
	{
		case MCI_NOTIFY_SUCCESSFUL:
			if (playing)
			{
				playing = false;
				if (playLooping)
					CDAudio_Play(playTrack, true);
			}
			break;

		case MCI_NOTIFY_ABORTED:
		case MCI_NOTIFY_SUPERSEDED:
			break;

		case MCI_NOTIFY_FAILURE:
			Com_DPrintf ("MCI_NOTIFY_FAILURE\n");
			CDAudio_Stop ();
			cdValid = false;
			break;

		default:
			Com_DPrintf ("Unexpected MM_MCINOTIFY type (%i)\n", wParam);
			return 1;
	}

	return 0;
}


void CDAudio_Update(void)
{
	if (!enabled)
		return;

	if (bgmvolume.value != cdvolume)
	{
		if (cdvolume)
		{
			Cvar_SetValue (&bgmvolume, 0.0);
			cdvolume = bgmvolume.value;
			CDAudio_Pause ();
		}
		else
		{
			Cvar_SetValue (&bgmvolume, 1.0);
			cdvolume = bgmvolume.value;
			CDAudio_Resume ();
		}
	}
}


int CDAudio_Init(void)
{
	DWORD	dwReturn;
	MCI_OPEN_PARMS	mciOpenParms;
    MCI_SET_PARMS	mciSetParms;
	int				n;

	if (!COM_CheckParm("-cdaudio"))
		return -1;

	mciOpenParms.lpstrDeviceType = "cdaudio";
	dwReturn = mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_SHAREABLE, (DWORD) (LPVOID) &mciOpenParms);
	if (dwReturn)
	{
		Com_Printf ("CDAudio_Init: MCI_OPEN failed (%i)\n", dwReturn);
		return -1;
	}
	wDeviceID = mciOpenParms.wDeviceID;

    // Set the time format to track/minute/second/frame (TMSF).
    mciSetParms.dwTimeFormat = MCI_FORMAT_TMSF;
    dwReturn = mciSendCommand(wDeviceID, MCI_SET, MCI_SET_TIME_FORMAT, (DWORD)(LPVOID) &mciSetParms);
    if (dwReturn)
    {
		Com_Printf ("MCI_SET_TIME_FORMAT failed (%i)\n", dwReturn);
        mciSendCommand(wDeviceID, MCI_CLOSE, 0, (DWORD)NULL);
		return -1;
    }

	for (n = 0; n < 100; n++)
		remap[n] = n;
	initialized = true;
	enabled = true;

	if (CDAudio_GetAudioDiskInfo())
	{
		Com_Printf ("CDAudio_Init: No CD in player.\n");
		cdValid = false;
		enabled = false;
	}

	Cmd_AddCommand ("cd", CD_f);

//	Com_Printf ("CD Audio Initialized\n");

	return 0;
}


void CDAudio_Shutdown(void)
{
	if (!initialized)
		return;
	CDAudio_Stop();
	if (mciSendCommand(wDeviceID, MCI_CLOSE, MCI_WAIT, (DWORD)NULL))
		Com_DPrintf ("CDAudio_Shutdown: MCI_CLOSE failed\n");
}


================================================
FILE: src/cdaudio.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

int CDAudio_Init(void);
void CDAudio_Play(byte track, qbool looping);
void CDAudio_Stop(void);
void CDAudio_Pause(void);
void CDAudio_Resume(void);
void CDAudio_Shutdown(void);
void CDAudio_Update(void);


================================================
FILE: src/central.c
================================================

// central.c - communication with central server

#include "qwsvdef.h"
#include <curl/curl.h>
#ifndef SERVER_ONLY
#include "quakedef.h"
#endif

#define GENERATE_CHALLENGE_PATH     "Authentication/GenerateChallenge"
#define CHALLENGETEXT_RESPONSE_PATH "Authentication/GenerateResponse"
#define VERIFY_RESPONSE_PATH        "Authentication/VerifyResponse"
#define CHECKIN_PATH                "ServerApi/Checkin"
#define MIN_CHECKIN_PERIOD          60

#ifdef _WIN32
#ifdef SERVER_ONLY
#pragma comment(lib, "libcurld.lib")
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "wldap32.lib")
#endif
#endif

#ifndef SERVER_ONLY
// Have set this to read-only to stop this accidentally on-purpose being set to another site by someone else's config
static cvar_t cl_www_address = { "cl_www_address", "https://badplace.eu/", CVAR_ROM };
#else
static cvar_t sv_www_address = { "sv_www_address", "" };
static cvar_t sv_www_authkey = { "sv_www_authkey", "" };
static cvar_t sv_www_checkin_period = { "sv_www_checkin_period", "60" };

static void Web_ConstructServerURL(char* url, const char* path, int sizeof_url);
static void Web_SubmitRequestFormServer(const char* url, struct curl_httppost* first_form_ptr, struct curl_httppost* last_form_ptr, web_response_func_t callback, const char* requestId, void* internal_data);
#endif

static CURLM* curl_handle = NULL;

static double last_checkin_time;

#define MAX_RESPONSE_LENGTH    (4096*2)

struct web_request_data_s;

typedef void(*web_response_func_t)(struct web_request_data_s* req, qbool valid);

typedef struct web_request_data_s {
	CURL*               handle;
	double              time_sent;

	// response from server
	char                response[MAX_RESPONSE_LENGTH];
	size_t              response_length;

	// form data
	struct curl_httppost *first_form_ptr;
	struct curl_httppost *last_form_ptr;

	// called when response complete
	web_response_func_t onCompleteCallback;
	void*               internal_data;
	char*               request_id;                 // if set, content will be passed to game-mod. will be Q_free()'d

	struct web_request_data_s* next;
} web_request_data_t;

static web_request_data_t* web_requests;

static size_t Web_StandardTokenWrite(void* buffer, size_t size, size_t nmemb, void* userp)
{
	web_request_data_t* data = (web_request_data_t*)userp;
	size_t available = sizeof(data->response) - data->response_length;
	if (size * nmemb > available) {
		Con_DPrintf("WWW: Response too large, size*nmemb = %d, available %d\n", size * nmemb, available);
		return 0;
	}
	else if (size * nmemb > 0) {
		Con_DPrintf("WWW: response received, writing %d bytes\n", size * nmemb);
		memcpy(data->response + data->response_length, buffer, size * nmemb);
		data->response_length += size * nmemb;
		Con_DPrintf("WWW: response_length now %d bytes\n", data->response_length);
	}
	return size * nmemb;
}

static void Web_SubmitRequestFormGeneric(const char* url, struct curl_httppost* first_form_ptr, struct curl_httppost* last_form_ptr, web_response_func_t callback, const char* requestId, void* internal_data)
{
	CURL* req = curl_easy_init();
	web_request_data_t* data = (web_request_data_t*)Q_malloc(sizeof(web_request_data_t));

	data->onCompleteCallback = callback;
	data->time_sent = curtime;
	data->internal_data = internal_data;
	data->handle = req;
	data->request_id = requestId && requestId[0] ? Q_strdup(requestId) : NULL;
	data->first_form_ptr = first_form_ptr;

	curl_easy_setopt(req, CURLOPT_URL, url);
	curl_easy_setopt(req, CURLOPT_WRITEDATA, data);
	curl_easy_setopt(req, CURLOPT_WRITEFUNCTION, Web_StandardTokenWrite);
	if (first_form_ptr) {
		curl_easy_setopt(req, CURLOPT_POST, 1);
		curl_easy_setopt(req, CURLOPT_HTTPPOST, first_form_ptr);
	}

	curl_multi_add_handle(curl_handle, req);
	data->next = web_requests;
	web_requests = data;
}


typedef struct response_field_s {
	const char* name;
	const char** value;
} response_field_t;

static int ProcessWebResponse(web_request_data_t* req, response_field_t* fields, int field_count)
{
	char* colon, *newline;
	char* start = req->response;
	int i;
	int total_fields = 0;

	// Response should be multiple lines, <Key>:<Value>\n
	// For multi-line values, prefix end of line with $
	req->response[req->response_length] = '\0';
	while ((colon = strchr(start, ':'))) {
		newline = strchr(colon, '\n');
		if (newline) {
			while (newline && newline != colon + 1 && *(newline - 1) == '$') {
				*(newline - 1) = ' ';
				newline = strchr(newline + 1, '\n');
			}
			if (newline) {
				*newline = '\0';
			}
		}

		*colon = '\0';
		for (i = 0; i < field_count; ++i) {
			if (!strcmp(start, fields[i].name)) {
				*fields[i].value = colon + 1;
			}
		}

		if (newline == NULL) {
			break;
		}

		start = newline + 1;
		while (*start && (*start == 10 || *start == 13)) {
			++start;
		}
		++total_fields;
	}

	return total_fields;
}

#ifdef SERVER_ONLY
static int utf8Encode(char in, char* out1, char* out2) {
	if (in <= 0x7F) {
		// <= 127 is encoded as single byte, no translation
		*out1 = in;
		return 1;
	}
	else {
		// Two byte characters... 5 bits then 6
		*out1 = 0xC0 | ((in >> 6) & 0x1F);
		*out2 = 0x80 | (in & 0x3F);
		return 2;
	}
}

static void Auth_GenerateChallengeResponse(web_request_data_t* req, qbool valid)
{
	client_t* client = (client_t*) req->internal_data;
	const char* response = NULL;
	const char* challenge = NULL;
	const char* message = NULL;
	response_field_t fields[] = {
		{ "Result", &response },
		{ "Challenge", &challenge },
		{ "Message", &message }
	};

	if (client->login_request_time != req->time_sent) {
		// Ignore result, subsequent request sent
		return;
	}

	req->internal_data = NULL;
	ProcessWebResponse(req, fields, sizeof(fields) / sizeof(fields[0]));

	if (response && !strcmp(response, "Success") && challenge) {
		char buffer[128];
		strlcpy(buffer, "//challenge ", sizeof(buffer));
		strlcat(buffer, challenge, sizeof(buffer));
		strlcat(buffer, "\n", sizeof(buffer));

		strlcpy(client->challenge, challenge, sizeof(client->challenge));
		SV_ClientPrintf2(client, PRINT_HIGH, "Challenge stored...\n", message);

		ClientReliableWrite_Begin (client, svc_stufftext, 2+strlen(buffer));
		ClientReliableWrite_String (client, buffer);
	}
	else if (message) {
		SV_ClientPrintf2(client, PRINT_HIGH, "Error: %s\n", message);
	}
	else {
		// Maybe add CURLOPT_ERRORBUFFER?
		SV_ClientPrintf2(client, PRINT_HIGH, "Error: unknown error\n");
	}
}

// Initial stage of login: ask server to create challenge/response pair
// Connected client to supply the response in order to prove identity
void Central_GenerateChallenge(client_t* client, const char* username, qbool during_login)
{
	char url[512];
	struct curl_httppost* first_form_ptr = NULL;
	struct curl_httppost* last_form_ptr = NULL;
	CURLFORMcode code;

	if (!sv_www_address.string[0]) {
		SV_ClientPrintf2(client, PRINT_HIGH, "Remote logins not supported on this server\n");
		return;
	}

	Web_ConstructServerURL(url, GENERATE_CHALLENGE_PATH, sizeof(url));

	code = curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "userName",
		CURLFORM_COPYCONTENTS, username,
		CURLFORM_END
	);

	if (code != CURL_FORMADD_OK) {
		SV_ClientPrintf2(client, PRINT_HIGH, "Failed to generate challenge (0: %u)\n", code);
		return;
	}

	code = curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "status",
		CURLFORM_COPYCONTENTS, during_login ? 0 : 1,
		CURLFORM_END
	);

	if (code != CURL_FORMADD_OK) {
		SV_ClientPrintf2(client, PRINT_HIGH, "Failed to generate challenge (1: %u)\n", code);
		return;
	}

	client->login_request_time = curtime;
	Web_SubmitRequestFormServer(url, first_form_ptr, last_form_ptr, Auth_GenerateChallengeResponse, NULL, client);
}

// Final stage of login: verify challenge/response with central server
void Auth_ProcessLoginAttempt(web_request_data_t* req, qbool valid)
{
	client_t* client = (client_t*) req->internal_data;
	const char* response = NULL;
	const char* login = NULL;
	const char* preferred_alias = NULL;
	const char* message = NULL;
	const char* flag = NULL;
	response_field_t fields[] = {
		{ "Result", &response },
		{ "Alias", &preferred_alias },
		{ "Login", &login },
		{ "Message", &message },
		{ "Flag", &flag }
	};

	req->internal_data = NULL;
	if (client->login_request_time != req->time_sent) {
		// Ignore result, subsequent request sent
		return;
	}

	ProcessWebResponse(req, fields, sizeof(fields) / sizeof(fields[0]));

	if (response && !strcmp(response, "Success")) {
		if (login) {
			char oldval[MAX_EXT_INFO_STRING];

			strlcpy(oldval, Info_Get(&client->_userinfo_ctx_, "*auth"), sizeof(oldval));
			strlcpy(client->login, login, sizeof(client->login));

			Info_SetStar(&client->_userinfo_ctx_, "*auth", login);
			ProcessUserInfoChange(client, "*auth", oldval);
		}

		flag = (flag ? flag : "");
		strlcpy(client->login_flag, flag, sizeof(client->login_flag));
		Info_SetStar(&client->_userinfo_ctx_, "*flag", flag);
		ProcessUserInfoChange(client, "*flag", flag);

		preferred_alias = preferred_alias ? preferred_alias : login;
		if (preferred_alias) {
			strlcpy(client->login_alias, preferred_alias, sizeof(client->login_alias));
		}
		client->logged_in_via_web = true;

		SV_LoginWebCheck(client);
	}
	else if (message) {
		SV_ClientPrintf2(client, PRINT_HIGH, "Error: %s\n", message);
		SV_LoginWebFailed(client);
	}
	else {
		// Maybe add CURLOPT_ERRORBUFFER?
		SV_ClientPrintf2(client, PRINT_HIGH, "Error: unknown error (invalid response from server)\n");
		SV_LoginWebFailed(client);
	}
}

// Final stage of login: client has supplied response to challenge, now check with central server
void Central_VerifyChallengeResponse(client_t* client, const char* challenge, const char* response)
{
	char url[512];
	struct curl_httppost* first_form_ptr = NULL;
	struct curl_httppost* last_form_ptr = NULL;
	CURLFORMcode code;

	if (!sv_www_address.string[0]) {
		SV_ClientPrintf2(client, PRINT_HIGH, "Remote logins not supported on this server\n");
		return;
	}

	code = curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "challenge",
		CURLFORM_COPYCONTENTS, challenge,
		CURLFORM_END
	);

	if (code != CURL_FORMADD_OK) {
		SV_ClientPrintf2(client, PRINT_HIGH, "Failed to generate request (1: %u)\n", code);
		return;
	}

	code = curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "response",
		CURLFORM_COPYCONTENTS, response,
		CURLFORM_END
	);

	if (code != CURL_FORMADD_OK) {
		SV_ClientPrintf2(client, PRINT_HIGH, "Failed to generate request (2: %u)\n", code);
		return;
	}

	Web_ConstructServerURL(url, VERIFY_RESPONSE_PATH, sizeof(url));

	client->login_request_time = curtime;
	Web_SubmitRequestFormServer(url, first_form_ptr, last_form_ptr, Auth_ProcessLoginAttempt, NULL, client);
}

static qbool CheckFileExists(const char* path)
{
	FILE* f;
	if (!(f = fopen(path, "rb"))) {
		return false;
	}
	fclose(f);
	return true;
}

void Web_PostResponse(web_request_data_t* req, qbool valid)
{
	if (valid) {
		const char* broadcast = NULL;
		const char* upload = NULL;
		const char* uploadPath = NULL;

		response_field_t fields[] = {
			{ "Broadcast", &broadcast },
			{ "UploadPath", &uploadPath },
			{ "Upload", &upload }
		};

		req->response[req->response_length] = '\0';

		Con_DPrintf("Response from web server:\n");
		Con_DPrintf(req->response);

		ProcessWebResponse(req, fields, sizeof(fields) / sizeof(fields[0]));

		if (broadcast) {
			// Server is making announcement
			SV_BroadcastPrintfEx(PRINT_HIGH, 0, "%s\n", broadcast);
		}
		if (upload && uploadPath) {
			if (strstr(uploadPath, "//") || FS_UnsafeFilename(upload)) {
				Con_Printf("Upload request deemed unsafe, ignoring...\n");
			}
			else {
				if (!strncmp(upload, "demos/", 6)) {
					// Ok - could be demo_dir, or full path
					char demoName[MAX_OSPATH];

					if (sv_demoDir.string[0]) {
						char url[512];
						struct curl_httppost *first_form_ptr = NULL;
						struct curl_httppost *last_form_ptr = NULL;

						snprintf(demoName, sizeof(demoName), "%s/%s/%s", fs_gamedir, sv_demoDir.string, upload + 6);
						if (!CheckFileExists(demoName) && sv_demoDirAlt.string[0]) {
							snprintf(demoName, sizeof(demoName), "%s/%s/%s", fs_gamedir, sv_demoDirAlt.string, upload + 6);
						}

						if (CheckFileExists(demoName)) {
							Web_ConstructServerURL(url, uploadPath, sizeof(url));

							curl_formadd(&first_form_ptr, &last_form_ptr,
								CURLFORM_PTRNAME, "file",
								CURLFORM_FILE, demoName,
								CURLFORM_END
							);

							curl_formadd(&first_form_ptr, &last_form_ptr,
								CURLFORM_COPYNAME, "localPath",
								CURLFORM_COPYCONTENTS, upload,
								CURLFORM_END
							);

							Web_SubmitRequestFormServer(url, first_form_ptr, last_form_ptr, Web_PostResponse, "upload", NULL);
							Con_Printf("Uploading %s...\n", demoName);
						}
						else {
							Con_Printf("Couldn't find file %s, ignoring...\n", demoName);
						}
					}
				}
				else {
					Con_Printf("Upload request folder not authorised, ignoring...\n");
				}
			}
		}
	}
	else {
		Con_Printf("Failure contacting central server.\n");
	}

	if (req->internal_data) {
		Q_free(req->internal_data);
	}
}

static void Web_SubmitRequestFormServer(const char* url, struct curl_httppost *first_form_ptr, struct curl_httppost *last_form_ptr, web_response_func_t callback, const char* requestId, void* internal_data)
{
	curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "authKey",
		CURLFORM_COPYCONTENTS, sv_www_authkey.string,
		CURLFORM_END
	);

	Web_SubmitRequestFormGeneric(url, first_form_ptr, last_form_ptr, callback, requestId, internal_data);
}

static void Web_ConstructServerURL(char* url, const char* path, int sizeof_url)
{
	Web_ConstructGenericURL(sv_www_address.string, url, path, sizeof_url);
}

static void Web_SendRequest(qbool post)
{
	struct curl_httppost* first_form_ptr = NULL;
	struct curl_httppost* last_form_ptr = NULL;
	char url[512];
	char* requestId = NULL;
	int i;

	if (!sv_www_address.string[0]) {
		Con_Printf("Address not set - functionality disabled\n");
		return;
	}

	if (Cmd_Argc() < 3) {
		Con_Printf("Usage: %s <url> <request-id> (<key> <value>)*\n", Cmd_Argv(0));
		return;
	}

	Web_ConstructServerURL(url, Cmd_Argv(1), sizeof(url));

	requestId = Cmd_Argv(2);

	for (i = 3; i < Cmd_Argc() - 1; i += 2) {
		char encoded_value[128];
		int encoded_length = 0;
		int j;
		char* name;
		char* value;
		CURLFORMcode code;

		name = Cmd_Argv(i);
		value = Cmd_Argv(i + 1);
		for (j = 0; j < strlen(value) && encoded_length < sizeof(encoded_value) - 2; ++j) {
			encoded_length += utf8Encode(value[j], &encoded_value[encoded_length], &encoded_value[encoded_length + 1]);
		}
		encoded_value[encoded_length] = '\0';

		code = curl_formadd(&first_form_ptr, &last_form_ptr,
			CURLFORM_COPYNAME, name,
			CURLFORM_COPYCONTENTS, encoded_value,
			CURLFORM_END
		);

		if (code != CURL_FORMADD_OK) {
			curl_formfree(first_form_ptr);
			Con_Printf("Request failed\n");
			return;
		}
	}

	Web_SubmitRequestFormServer(url, first_form_ptr, last_form_ptr, Web_PostResponse, requestId, NULL);
}

static void Web_GetRequest_f(void)
{
	Web_SendRequest(false);
}

static void Web_PostRequest_f(void)
{
	Web_SendRequest(true);
}

static void Web_PostFileRequest_f(void)
{
	struct curl_httppost* first_form_ptr = NULL;
	struct curl_httppost* last_form_ptr = NULL;
	char* requestId = NULL;
	char url[512];
	char path[MAX_OSPATH];
	CURLFORMcode code = CURL_FORMADD_OK;
	const char* specified = Cmd_Argv(3);

	if (!sv_www_address.string[0]) {
		Con_Printf("Address not set - functionality disabled\n");
		return;
	}

	if (specified[0] == '*' && specified[1] == '\0') {
		const char* demoname = SV_MVDDemoName();

		if (!sv.mvdrecording || !demoname) {
			Con_Printf("Not recording demo!\n");
			return;
		}

		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, SV_MVDName2Txt(demoname));
	}
	else {
		if (strstr(specified, ".cfg") || !strchr(specified, '/')) {
			Con_Printf("Filename invalid\n");
			return;
		}

		snprintf(path, MAX_OSPATH, "%s/%s", fs_gamedir, specified);
	}

	if (Cmd_Argc() < 4) {
		Con_Printf("Usage: %s <url> <request-id> <file> (<key> <value>)*\n", Cmd_Argv(0));
		return;
	}

	if (FS_UnsafeFilename(path)) {
		Con_Printf("Filename invalid\n");
		return;
	}

	Web_ConstructServerURL(url, Cmd_Argv(1), sizeof(url));

	requestId = Cmd_Argv(2);

	if (!CheckFileExists(path)) {
		Con_Printf("Failed to open file\n");
		return;
	}

	code = curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "file",
		CURLFORM_FILE, path,
		CURLFORM_END
	);

	if (code != CURL_FORMADD_OK) {
		Con_Printf("Failed to generate form (0: %u)\n", code);
		return;
	}

	Web_SubmitRequestFormServer(url, first_form_ptr, last_form_ptr, Web_PostResponse, requestId, NULL);
}

static void Web_PeriodicCheck(qbool server_busy)
{
	if (sv_www_address.string[0] && !server_busy && curtime - last_checkin_time > max(MIN_CHECKIN_PERIOD, sv_www_checkin_period.value)) {
		char url[512];

		Web_ConstructServerURL(url, CHECKIN_PATH, sizeof(url));

		Web_SubmitRequestFormServer(url, NULL, NULL, Web_PostResponse, NULL, NULL);

		last_checkin_time = curtime;
	}
	else if (server_busy) {
		last_checkin_time = curtime;
	}
}
#else
#define Web_PeriodicCheck(...)
#endif // SERVER_ONLY

static void Web_ConstructGenericURL(const char* base_url, char* url, const char* path, int sizeof_url)
{
	strlcpy(url, base_url, sizeof_url);
	if (url[strlen(url) - 1] != '/') {
		strlcat(url, "/", sizeof_url);
	}
	while (*path == '/') {
		++path;
	}
	strlcat(url, path, sizeof_url);
}

void Central_ProcessResponses(void)
{
	CURLMsg* msg;
	int running_handles = 0;
	int messages_in_queue = 0;

	if (!last_checkin_time) {
		last_checkin_time = curtime;
		return;
	}

	curl_multi_perform(curl_handle, &running_handles);

	while ((msg = curl_multi_info_read(curl_handle, &messages_in_queue))) {
		if (msg->msg == CURLMSG_DONE) {
			CURL* handle = msg->easy_handle;
			CURLcode result = msg->data.result;
			web_request_data_t** list_pointer = &web_requests;

			curl_multi_remove_handle(curl_handle, handle);

			while (*list_pointer) {
				web_request_data_t* this = *list_pointer;

				if (this->handle == handle) {
					// Remove from queue immediately
					*list_pointer = this->next;

					if (this->onCompleteCallback) {
						if (result == CURLE_OK) {
							this->onCompleteCallback(this, true);
						}
						else {
							Con_DPrintf("ERROR: %s\n", curl_easy_strerror(result));
							this->onCompleteCallback(this, false);
						}
					}
					else {
						if (result != CURLE_OK) {
							Con_DPrintf("ERROR: %s\n", curl_easy_strerror(result));
						}
						else {
							Con_DPrintf("WEB OK, no callback\n");
						}
					}

					// free memory
					curl_formfree(this->first_form_ptr);
					Q_free(this->request_id);
					Q_free(this);

					break;
				}

				list_pointer = &this->next;
			}

			curl_easy_cleanup(handle);
		}
	}

	// Periodically check in when idle
	Web_PeriodicCheck(running_handles || GameStarted());
}

void Central_Shutdown(void)
{
	if (curl_handle) {
		curl_multi_cleanup(curl_handle);
		curl_handle = NULL;
	}
}

void Central_Init(void)
{
// TODO: client-only version
#ifdef SERVER_ONLY
	Cvar_Register(&sv_www_address);
	Cvar_Register(&sv_www_authkey);
	Cvar_Register(&sv_www_checkin_period);
#endif
#ifndef SERVER_ONLY
	Cvar_Register(&cl_www_address);
#endif

	curl_handle = curl_multi_init();

#ifdef SERVER_ONLY
	if (curl_handle) {
		Cmd_AddCommand("sv_web_get", Web_GetRequest_f);
		Cmd_AddCommand("sv_web_post", Web_PostRequest_f);
		Cmd_AddCommand("sv_web_postfile", Web_PostFileRequest_f);
	}
#endif
}

#ifndef SERVER_ONLY
static void Web_ConstructClientURL(char* url, const char* path, int sizeof_url)
{
	Web_ConstructGenericURL(cl_www_address.string, url, path, sizeof_url);
}

// Web response to client asking for challenge response text
void Auth_FindChallengeResponse(web_request_data_t* req, qbool valid)
{
	const char* challengeText = req->request_id;
	const char* result = NULL;
	const char* responseText = NULL;
	const char* message = NULL;
	response_field_t fields[] = {
		{ "Result", &result },
		{ "Response", &responseText },
		{ "Message", &message }
	};

	if (strcmp(cl.auth_challenge, challengeText)) {
		// Ignore result, subsequent request sent
		return;
	}

	req->internal_data = NULL;
	ProcessWebResponse(req, fields, sizeof(fields) / sizeof(fields[0]));

	if (result && !strcmp(result, "Success") && responseText) {
		char buffer[256];

		strlcpy(buffer, "cmd login-response ", sizeof(buffer));
		strlcat(buffer, responseText, sizeof(buffer));
		strlcat(buffer, "\n", sizeof(buffer));

		Com_Printf("Responding to challenge...\n");

		Cbuf_AddTextEx(&cbuf_main, buffer);
	}
	else if (message) {
		Com_Printf("Error receiving challenge response: %s\n", message);
	}
	else {
		// Maybe add CURLOPT_ERRORBUFFER?
		Com_Printf("Error receiving challenge response: unknown error\n");
	}
}

// Called when //challenge received from server
void Central_FindChallengeResponse(const char* token, const char* challengeText)
{
	char url[512];
	struct curl_httppost* first_form_ptr = NULL;
	struct curl_httppost* last_form_ptr = NULL;
	CURLFORMcode code;
	SHA1_CTX context;
	unsigned char hash[DIGEST_SIZE];
	char hash_buffer[128] = { 0 };

	if (!cl_www_address.string[0]) {
		Com_Printf("cl_www_address not configured: please authenticate manually\n");
		return;
	}

	// FIXME: something stronger
	SHA1Init(&context);
	SHA1Update(&context, (unsigned char*)challengeText, strlen(challengeText));
	SHA1Update(&context, (unsigned char*)"^", 1);
	SHA1Update(&context, (unsigned char*)token, strlen(token));
	SHA1Final(hash, &context);

	strlcpy(hash_buffer, bin2hex(hash), sizeof(hash_buffer));

	code = curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "hashalg",
		CURLFORM_COPYCONTENTS, "sha1",
		CURLFORM_END
	);
	if (code != CURL_FORMADD_OK) {
		curl_formfree(first_form_ptr);
		Con_Printf("Failed to generate form (0: %u)\n", code);
		return;
	}

	code = curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "authKey",
		CURLFORM_COPYCONTENTS, hash_buffer,
		CURLFORM_END
	);
	if (code != CURL_FORMADD_OK) {
		curl_formfree(first_form_ptr);
		Con_Printf("Failed to generate form (0: %u)\n", code);
		return;
	}

	code = curl_formadd(&first_form_ptr, &last_form_ptr,
		CURLFORM_PTRNAME, "challenge",
		CURLFORM_COPYCONTENTS, challengeText,
		CURLFORM_END
	);
	if (code != CURL_FORMADD_OK) {
		curl_formfree(first_form_ptr);
		Con_Printf("Failed to generate form (0: %u)\n", code);
		return;
	}

	Web_ConstructClientURL(url, CHALLENGETEXT_RESPONSE_PATH, sizeof(url));

	Web_SubmitRequestFormGeneric(url, first_form_ptr, last_form_ptr, Auth_FindChallengeResponse, challengeText, NULL);
}
#endif


================================================
FILE: src/central.h
================================================

#ifndef CENTRAL_H
#define CENTRAL_H

#include "server.h"

void Central_Init(void);
void Central_Shutdown(void);
void Central_ProcessResponses(void);
// void Central_SubmitGame(const char* path);

// Creates a challenge/response on the web server after user claims to be 'username'
void Central_GenerateChallenge(client_t* client, const char* username, qbool during_login);

// Checks with the server if a client's response to a challenge is correct
void Central_VerifyChallengeResponse(client_t* client, const char* challenge, const char* response);

#ifndef SERVER_ONLY
// 
void Central_FindChallengeResponse(const char* token, const char* challengeText);
#endif

#endif // !CENTRAL_H


================================================
FILE: src/cl_cam.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
/* ZOID
 *
 * Player camera tracking in Spectator mode
 *
 * This takes over player controls for spectator automatic camera.
 * Player moves as a spectator, but the camera tracks and enemy player
 */

#include "quakedef.h"
#include "gl_model.h"
#include "teamplay.h"
#include "pmove.h"
#include "utils.h"
#include "sbar.h"
#include "qtv.h"

static int Cam_MainTrackNum(void);

static vec3_t desired_position; // where the camera wants to be.
static int oldbuttons;
static qbool cmddown, olddown;
extern cvar_t cam_thirdperson, cl_camera_tpp;

cvar_t cl_hightrack = {"cl_hightrack", "0" };	// track high fragger 
cvar_t cl_chasecam = {"cl_chasecam", "1"};		// "through the eyes" view

vec3_t cam_viewangles;
double cam_lastviewtime;

void CL_TrackMV1_f(void);
void CL_TrackMV2_f(void);
void CL_TrackMV3_f(void);
void CL_TrackMV4_f(void);
void CL_TrackTeam_f(void); 

void CL_Track_f(void);
void CL_Trackkiller_f(void);
void CL_Autotrack_f(void);

double last_lock = 0;			// Last time Cam_Lock() successful

static int	killer = -1;		// id of the player who killed the player we are now tracking

void CL_Cam_SetKiller(int killernum, int victimnum) {
	if (victimnum != cl.viewplayernum) return;
	if (killernum < 0 || killernum >= MAX_CLIENTS) return;

	killer = killernum;
}

void vectoangles(vec3_t vec, vec3_t ang) {
	float forward, yaw, pitch;
	
	if (vec[1] == 0 && vec[0] == 0) {
		yaw = 0;
		pitch = (vec[2] > 0) ? 90 : 270;
	} else {
		yaw = /*(int)*/ (atan2(vec[1], vec[0]) * 180 / M_PI);
		if (yaw < 0)
			yaw += 360;

		forward = sqrt (vec[0]*vec[0] + vec[1]*vec[1]);
		pitch = /*(int)*/ (atan2(vec[2], forward) * 180 / M_PI);
		if (pitch < 0)
			pitch += 360;
	}

	ang[0] = pitch;
	ang[1] = yaw;
	ang[2] = 0;
}

void Cam_SetViewPlayer (void)
{
	int new_track;

	if (cl.spectator && cl.autocam && cl.spec_locked && cl_chasecam.value) {
		new_track = cl.spec_track;
	}
	else {
		new_track = cl.playernum;
	}

	if (new_track != cl.viewplayernum) {
		memset(cl.antilag_positions, 0, sizeof(cl.antilag_positions));
	}
	cl.viewplayernum = new_track;
}

// returns true if weapon model should be drawn in camera mode
qbool Cam_DrawViewModel(void) {
	if (!cl.spectator)
		return true;

	if (cl.autocam && cl.spec_locked && cl_chasecam.value)
		return true;
	return false;
}

static qbool Cam_FirstPersonMode(void)
{
	return cl_chasecam.value && !cam_thirdperson.integer && !cl_camera_tpp.integer;
}

// returns true if we should draw this player, we don't if we are chase camming
qbool Cam_DrawPlayer(int playernum)
{
	if (cl.spectator && cl.autocam && cl.spec_locked && cl.spec_track == playernum && Cam_FirstPersonMode())
		return false;
	return true;
}

void Cam_Unlock(void) 
{
	if (Cmd_FindAlias("f_freeflyspectate"))
	{
		Cbuf_AddTextEx (&cbuf_main, "f_freeflyspectate\n");
	}

	if (!cl.autocam) {
		return;
	}

	if (cls.mvdplayback == QTV_PLAYBACK)
	{
		// its not setinfo extension, but adding new extension just for this is stupid IMO
		QTV_Cmd_Printf(QTV_EZQUAKE_EXT_SETINFO, "ptrack");
	}
	else
	{
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		MSG_WriteString (&cls.netchan.message, "ptrack");
	}

	cl.autocam = CAM_NONE;
	cl.spec_locked = false;
	Sbar_Changed();

	if (cls.mvdplayback && cl.teamfortress) 
	{
		V_TF_ClearGrenadeEffects ();
	}

	if (TP_NeedRefreshSkins())
	{
		TP_RefreshSkins();
	}
}

void Cam_Lock(int playernum) 
{
	char st[32];

	if (Cmd_FindAlias("f_trackspectate")) {
		Cbuf_AddTextEx (&cbuf_main, "f_trackspectate\n");
	}

	snprintf(st, sizeof (st), "ptrack %i", playernum);
	if (cls.mvdplayback == QTV_PLAYBACK) {
		// its not setinfo extension, but adding new extension just for this is stupid IMO
		QTV_Cmd_Printf(QTV_EZQUAKE_EXT_SETINFO, st);
	}
	else {
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		MSG_WriteString (&cls.netchan.message, st);
	}

	if (CL_MultiviewEnabled ()) {
		CL_MultiviewSetTrackSlot (-1, playernum);
		if (!cls.findtrack) {
			return;
		}
	}

	if (cls.mvdplayback) {
		memcpy(cl.stats, cl.players[playernum].stats, sizeof(cl.stats));
		cl.ideal_track = playernum;
		cl.mvd_time_offset = 0;
	}
	last_lock = cls.realtime;

	cl.spec_track = playernum;
	cl.spec_locked = false;
	Sbar_Changed();

	if (TP_NeedRefreshSkins())
		TP_RefreshSkins();
}

trace_t Cam_DoTrace(vec3_t vec1, vec3_t vec2) {
	VectorCopy (vec1, pmove.origin);
	return PM_PlayerTrace(pmove.origin, vec2);
}
	
// Returns distance or 9999 if invalid for some reason
static float Cam_TryFlyby(player_state_t *self, player_state_t *player, vec3_t vec, qbool checkvis) {
	vec3_t v;
	trace_t trace;
	float len;

	vectoangles(vec, v);
	VectorCopy (v, pmove.angles);
	VectorNormalizeFast(vec);
	VectorMA(player->origin, 800, vec, v);
	// v is endpos
	// fake a player move
	trace = Cam_DoTrace(player->origin, v);
	if (trace.inwater)
		return 9999;
	VectorCopy(trace.endpos, vec);
	VectorSubtract(trace.endpos, player->origin, v);
	len = VectorLength(v);
	if (len < 32 || len > 800)
		return 9999;
	if (checkvis) {
		VectorSubtract(trace.endpos, self->origin, v);
		len = VectorLength(v);

		trace = Cam_DoTrace(self->origin, vec);
		if (trace.fraction != 1 || trace.inwater)
			return 9999;
	}
	return len;
}

// Is player visible?
static qbool Cam_IsVisible(player_state_t *player, vec3_t vec) {
	trace_t trace;
	vec3_t v;

	trace = Cam_DoTrace(player->origin, vec);
	if (trace.fraction != 1 || /*trace.inopen ||*/ trace.inwater)
		return false;
	// check distance, don't let the player get too far away or too close
	VectorSubtract(player->origin, vec, v);

	return ((v[0]*v[0]+v[1]*v[1]+v[2]*v[2]) >= 256);
}

static qbool InitFlyby(player_state_t *self, player_state_t *player, int checkvis) {
    float f, max;
    vec3_t vec, vec2;
	vec3_t forward, right, up;

	VectorCopy(player->viewangles, vec);
    vec[0] = 0;
	AngleVectors (vec, forward, right, up);

    max = 1000;
	VectorAdd(forward, up, vec2);
	VectorAdd(vec2, right, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorAdd(forward, up, vec2);
	VectorSubtract(vec2, right, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorAdd(forward, right, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorSubtract(forward, right, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorAdd(forward, up, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorSubtract(forward, up, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorAdd(up, right, vec2);
	VectorSubtract(vec2, forward, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorSubtract(up, right, vec2);
	VectorSubtract(vec2, forward, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	// invert
	VectorSubtract(vec3_origin, forward, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorCopy(forward, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	// invert
	VectorSubtract(vec3_origin, right, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }
	VectorCopy(right, vec2);
    if ((f = Cam_TryFlyby(self, player, vec2, checkvis)) < max) {
        max = f;
		VectorCopy(vec2, vec);
    }

	// ack, can't find him
    if (max >= 1000)
		return false;
	cl.spec_locked = true;
	VectorCopy(vec, desired_position); 
	return true;
}

// cl_hightrack 
static void Cam_CheckHighTarget(void)
{
	int i, j, max;
	player_info_t	*s;

	j = -1;
	for (i = 0, max = -9999; i < MAX_CLIENTS; i++) {
		s = &cl.players[i];
		if (s->name[0] && !s->spectator && s->frags > max) {
			max = s->frags;
			j = i;
		}
	}
	if (j >= 0) {
		if (!cl.spec_locked || cl.players[j].frags > cl.players[cl.spec_track].frags) {
			Cam_Lock(j);
			cl.ideal_track = cl.spec_track;
		}
	} else
		Cam_Unlock();
} 

// Take over the user controls and track a player.
// We find a nice position to watch the player and move there
void Cam_Track(usercmd_t *cmd) 
{
	player_state_t *player, *self;
	frame_t *frame;
	vec3_t vec;

	if (!cl.spectator) {
		return;
	}

	// hack: save +movedown command
	cmddown = cmd->upmove < 0;

	// cl_hightrack 
	if (cl_hightrack.value && !cl.spec_locked)
	{
		Cam_CheckHighTarget(); 
	}
	
	if (!cl.autocam || cls.state != ca_active)
	{
		return;
	}

	if (cl.spec_locked && (!cl.players[cl.spec_track].name[0] || cl.players[cl.spec_track].spectator))
	{
		cl.spec_locked = false;

		// cl_hightrack 
		if (cl_hightrack.value)
		{
			Cam_CheckHighTarget();
		}
		else 
		{
			Cam_Unlock();
		}
		return;
	}

	frame = &cl.frames[cl.validsequence & UPDATE_MASK];

	if (cl.autocam && cls.mvdplayback) {
		if (cl.ideal_track != cl.spec_track && cls.realtime - last_lock > 0.1 && frame->playerstate[cl.ideal_track].messagenum == cl.parsecount) {
			Cam_Lock(cl.ideal_track);
		}

		if ((frame->playerstate[cl.spec_track].messagenum != cl.parsecount && frame->playerstate[cl.spec_track].messagenum != cl.oldparsecount) || Cam_MainTrackNum() != cl.ideal_track) {
			int i;

			for (i = 0; i < MAX_CLIENTS - 1; i++) {
				if ((frame->playerstate[i].messagenum == cl.parsecount || frame->playerstate[i].messagenum == cl.oldparsecount)) {
					break;
				}
			}

			Cam_Lock(i);
			cls.findtrack = (i >= MAX_CLIENTS - 1);
		}
	}

	player = frame->playerstate + cl.spec_track;
	self = frame->playerstate + cl.playernum;

	if (!cl.spec_locked || !Cam_IsVisible(player, desired_position))
	{
		if (!cl.spec_locked || cls.realtime - cam_lastviewtime > 0.1)
		{
			if (!InitFlyby(self, player, true))
				InitFlyby(self, player, false);
			cam_lastviewtime = cls.realtime;
		}
	} 
	else 
	{
		cam_lastviewtime = cls.realtime;
	}
	
	// couldn't track for some reason
	if (!cl.spec_locked || !cl.autocam)
		return;

	if (cl_chasecam.value) 
	{
		cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;

		#ifdef JSS_CAM
		if (!cam_thirdperson.integer)
		#endif
		{
			VectorCopy(player->viewangles, cl.viewangles);
		}
		VectorCopy(player->origin, desired_position);
		if (memcmp(&desired_position, &self->origin, sizeof(desired_position)) != 0) {
			MSG_WriteByte (&cls.netchan.message, clc_tmove);
			MSG_WriteCoord (&cls.netchan.message, desired_position[0]);
			MSG_WriteCoord (&cls.netchan.message, desired_position[1]);
			MSG_WriteCoord (&cls.netchan.message, desired_position[2]);
			// move there locally immediately
			VectorCopy(desired_position, self->origin);
		}
	} 
	else 
	{
		// Ok, move to our desired position and set our angles to view
		// the player
		VectorSubtract(desired_position, self->origin, vec);
		cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
		if (VectorLength(vec) > 16) 
		{ 
			// close enough?
			MSG_WriteByte (&cls.netchan.message, clc_tmove);
			MSG_WriteCoord (&cls.netchan.message, desired_position[0]);
			MSG_WriteCoord (&cls.netchan.message, desired_position[1]);
			MSG_WriteCoord (&cls.netchan.message, desired_position[2]);
		}

		// move there locally immediately
		VectorCopy(desired_position, self->origin);
										 
		VectorSubtract(player->origin, desired_position, vec);
		vectoangles(vec, cl.viewangles);
		cl.viewangles[0] = -cl.viewangles[0];
	}
}

// Returns true if last new button command was jump
qbool Cam_JumpCheck(usercmd_t *cmd)
{
	if ((cmd->buttons & BUTTON_JUMP) && (oldbuttons & BUTTON_JUMP))
		return false;		// don't pogo stick

	if (!(cmd->buttons & BUTTON_JUMP))
	{
		oldbuttons &= ~BUTTON_JUMP;
		return false;
	}
	oldbuttons |= BUTTON_JUMP;	// don't jump again until released

	return true;
}

// Returns true if last new button command was jump
qbool Cam_MoveDownCheck(usercmd_t *cmd)
{
	if (cmddown && olddown)
		return false;

	if (!cmddown)
	{
		olddown = false;
		return false;
	}
	olddown = true;

	return true;
}

void Cam_FinishMove(usercmd_t *cmd) 
{
	int i, end, inc;
	player_info_t *s;

	if (cls.state != ca_active)
		return;

	if (!cl.spectator) // only in spectator mode
		return;

	if (cmd->buttons & BUTTON_ATTACK) {
		if (!(oldbuttons & BUTTON_ATTACK)) {

			oldbuttons |= BUTTON_ATTACK;
			cl.autocam++;

			if (cl.autocam > CAM_TRACK) {
				Cam_Unlock();
				VectorCopy(cl.viewangles, cmd->angles);
				return;
			}
		} else
			return;
	} else {
		oldbuttons &= ~BUTTON_ATTACK;
		if (!cl.autocam)
			return;
	}

	// cl_hightrack 
	if (cl.autocam && cl_hightrack.value)
	{
		Cam_CheckHighTarget();
		if (Cam_JumpCheck(cmd))
		{
			Com_Printf_State(PRINT_FAIL,"cl_hightrack enabled. Unable to switch POV.\n");
		}
		return;
	}

	if (Cam_MoveDownCheck(cmd)) {
		inc = -1;
	} else {
		inc = 1;
	}

	if (cl.spec_locked) {
		if (!Cam_JumpCheck(cmd) && inc == 1) {
			return;
		}
		// Swap the Multiview mvinset/main view pov when jump button is pressed.
		CL_MultiviewTrackingAdjustment (inc);
	}

	
	if (cl.spec_locked && cl.autocam) {
		end = (cl.ideal_track + MAX_CLIENTS + inc) % MAX_CLIENTS;
	}
	else {
		end = cl.ideal_track;
	}

	i = end;
	do {
		s = &cl.players[i];
		if (s->name[0] && !s->spectator && (!cls.mvdplayback || cl.frames[cl.parsecount & UPDATE_MASK].playerstate[i].messagenum == cl.parsecount)) {
			if (cls.mvdplayback && cl.teamfortress) {
				V_TF_ClearGrenadeEffects(); // BorisU
			}
			Cam_Lock(i);
			cl.ideal_track = i;
			return;
		}
		i = (i + MAX_CLIENTS + inc) % MAX_CLIENTS;
	} while (i != end);

	// stay on same guy?
	i = cl.ideal_track;
	s = &cl.players[i];
	if (s->name[0] && !s->spectator) {
		Cam_Lock(i);
		return;
	}
	Com_Printf ("No target found ...\n");
	cl.autocam = cl.spec_locked = false;
}

void Cam_Reset(void)
{
	cl.autocam = CAM_NONE;
	cl.spec_track = 0;
	cl.ideal_track = 0;
	cl.spec_locked = false;
}

//Fixes spectator chasecam demos
void Cam_TryLock (void) {
	int i, j, old_autocam, old_spec_track;
	player_state_t *state;
	static float cam_lastlocktime;

	if (!cl.validsequence)
		return;

	if (!cl.autocam)
		cam_lastlocktime = 0;

	old_autocam = cl.autocam;
	old_spec_track = cl.spec_track;

	state = cl.frames[cl.validsequence & UPDATE_MASK].playerstate;
	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator ||
			state[i].messagenum != cl.parsecount)
			continue;
		if (fabs(state[i].command.angles[0] - cl.viewangles[0]) < 2 && fabs(state[i].command.angles[1] - cl.viewangles[1]) < 2) {
			for (j = 0; j < 3; j++)
				if (fabs(state[i].origin[j] - state[cl.playernum].origin[j]) > 200)
					break;	// too far
			if (j < 3)
				continue;
			cl.autocam = CAM_TRACK;
			cl.spec_track = i;
			cl.spec_locked = true;
			cam_lastlocktime = cls.realtime;
			break;
		}
	}

	if (cls.realtime - cam_lastlocktime > 0.3) {
		// Couldn't lock to any player for 0.3 seconds, so assume
		// the spectator switched to free spectator mode
		cl.autocam = CAM_NONE;
		cl.spec_track = 0;
		cl.spec_locked = false;
	}

	if (cl.autocam != old_autocam || cl.spec_track != old_spec_track) {
		Sbar_Changed ();

		if (TP_NeedRefreshSkins())
			TP_RefreshSkins();
	}
}


#ifdef JSS_CAM
static char *myftos (float f)
{
#define MAX_VAL 128
	static char buf[4][MAX_VAL];
	static char idx = 0;
	char *val;
	int	i;

	if (!cls.demoplayback && !cl.spectator)
		return "?";

	val = buf[(idx++) & 3];

	snprintf (val, MAX_VAL, "%f", f);

	// strip trailing zeroes
	for (i = strlen(val) - 1; i > 0 && val[i] == '0'; i--)
		val[i] = 0;
	if (val[i] == '.')
		val[i] = 0;
		
	return val;
}

void Cam_Pos_Set(float x, float y, float z)
{
	extern qbool clpred_newpos;

	cl.simorg[0] = x;
	cl.simorg[1] = y;
	cl.simorg[2] = z;
	clpred_newpos = true;
	
	VectorCopy (cl.simorg, cl.frames[cl.validsequence & UPDATE_MASK].playerstate[cl.playernum].origin);
	
	if (cls.state >= ca_active && !cls.demoplayback) {
		MSG_WriteByte (&cls.netchan.message, clc_tmove);
		MSG_WriteCoord (&cls.netchan.message, cl.simorg[0]);
		MSG_WriteCoord (&cls.netchan.message, cl.simorg[1]);
		MSG_WriteCoord (&cls.netchan.message, cl.simorg[2]);
	}
}

static void Cam_Pos_f (void)
{
	if (Cmd_Argc() == 1)
	{
		Com_Printf ("\"%s %s %s\"\n", myftos(cl.simorg[0]), myftos(cl.simorg[1]), myftos(cl.simorg[2]));
		return;
	}

	if (Cmd_Argc() == 2) {
		// cam_pos "x y z"  -->  cam_pos x y z
		Cmd_TokenizeString (va("cam_pos %s", Cmd_Argv(1)));
	}

	if (Cmd_Argc() != 4) {
		Com_Printf("usage:\n"
			"cam_pos - show current coordinates\n"
			"cam pos x y z - set new coordinates\n");
		return;
	}

	if (!cls.demoplayback && !cl.spectator)
		return;

	Cam_Reset();
	Cam_Pos_Set(Q_atof(Cmd_Argv(1)), Q_atof(Cmd_Argv(2)), Q_atof(Cmd_Argv(3)));
}

void Cam_Angles_Set(float pitch, float yaw, float roll)
{
	cl.simangles[0] = pitch;
	cl.simangles[1] = yaw;
	cl.simangles[2] = roll;
	VectorCopy (cl.simangles, cl.viewangles);
}

static void Cam_Angles_f (void)
{
	if (Cmd_Argc() == 1)
	{
		Com_Printf ("\"%s %s %s\"\n", myftos(cl.viewangles[0]), myftos(cl.viewangles[1]), myftos(cl.viewangles[2]));
		return;
	}

	if (Cmd_Argc() == 2) {
		// cam_angles "pitch yaw roll"  -->  cam_pos pitch yaw roll
		Cmd_TokenizeString (va("cam_angles %s", Cmd_Argv(1)));
	}

	if (Cmd_Argc() != 4 && Cmd_Argc() != 3) {
		Com_Printf("usage:\n"
			"cam_pos - show current angles\n"
			"cam pos pitch yaw [roll] - set new angles\n");
		return;
	}
	
	if (!cls.demoplayback && !cl.spectator)
		return;

	Cam_Angles_Set(Q_atof(Cmd_Argv(1)), Q_atof(Cmd_Argv(2)), Q_atof(Cmd_Argv(3)));
}

static char *Macro_Cam_Pos_X (void) { return myftos(cl.simorg[0]); }
static char *Macro_Cam_Pos_Y (void) { return myftos(cl.simorg[1]); }
static char *Macro_Cam_Pos_Z (void) { return myftos(cl.simorg[2]); }
static char *Macro_Cam_Pos (void) {	return va("\"%s %s %s\"", myftos(cl.simorg[0]), myftos(cl.simorg[1]), myftos(cl.simorg[2])); }

static char *Macro_Cam_Angles_Pitch (void) { return myftos(cl.viewangles[0]); }
static char *Macro_Cam_Angles_Yaw (void) { return myftos(cl.viewangles[1]); }
static char *Macro_Cam_Angles_Roll (void) { return myftos(cl.viewangles[2]); }
static char *Macro_Cam_Angles (void) { return va("\"%s %s %s\"", myftos(cl.viewangles[0]), myftos(cl.viewangles[1]), myftos(cl.viewangles[2])); }
#endif // JSS_CAM


void CL_InitCam(void) 
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SPECTATOR);

	// cl_hightrack 
	Cvar_Register (&cl_hightrack); 

	Cvar_Register (&cl_chasecam);

	Cvar_ResetCurrentGroup();
	Cmd_AddCommand ("track", CL_Track_f);
	Cmd_AddCommand ("autotrack", CL_Autotrack_f);
	Cmd_AddCommand ("trackkiller", CL_Trackkiller_f);

	// Multivew tracking.
	Cmd_AddCommand ("track1", CL_TrackMV1_f);	
	Cmd_AddCommand ("track2", CL_TrackMV2_f);	
	Cmd_AddCommand ("track3", CL_TrackMV3_f);	
	Cmd_AddCommand ("track4", CL_TrackMV4_f);
	Cmd_AddCommand ("trackteam", CL_TrackTeam_f);	
 
 #ifdef JSS_CAM
	Cmd_AddCommand ("cam_pos", Cam_Pos_f);
	Cmd_AddCommand ("cam_angles", Cam_Angles_f);
	Cmd_AddMacro (macro_cam_pos_x, Macro_Cam_Pos_X);
	Cmd_AddMacro (macro_cam_pos_y, Macro_Cam_Pos_Y);
	Cmd_AddMacro (macro_cam_pos_z, Macro_Cam_Pos_Z);
	Cmd_AddMacro (macro_cam_pos, Macro_Cam_Pos);
	Cmd_AddMacro (macro_cam_angles_pitch, Macro_Cam_Angles_Pitch);
	Cmd_AddMacro (macro_cam_angles_yaw, Macro_Cam_Angles_Yaw);
	Cmd_AddMacro (macro_cam_angles_roll, Macro_Cam_Angles_Roll);
	Cmd_AddMacro (macro_cam_angles, Macro_Cam_Angles);
 #endif
 
	// Multiview tracking.	
	CL_MultiviewInitialise ();
}

static int Cam_MainTrackNum(void)
{
	if (CL_MultiviewInsetEnabled()) {
		return CL_MultiviewMainView();
	}
	return Cam_TrackNum();
}

//
// Change what player we are tracking.
//
// trackview:
// - Should be < 0 if we're in normal mode.
// - Between 0-3 if we're in multiview.
//
void CL_Track (int trackview)
{
	int slot;
	char *arg;

	if (cls.state < ca_connected) 
	{
		Com_Printf("You must be connected to track\n", Cmd_Argv(0));
		return;
	}

	if (!cl.spectator) 
	{
		Com_Printf("You can only track in spectator mode\n", Cmd_Argv(0));
		return;
	}

	// Don't go outside of the mv_trackslots array bounds.
	trackview = min(trackview, 3);

	// Allow resetting to default tracking for multiview.
	if (trackview >= 0 && !strcmp(Cmd_Args(), "off")) 
	{
		Com_Printf("Track %d resetting to default\n", trackview);
		CL_MultiviewSetTrackSlot (trackview, -1);
		return;
	}

	if (Cmd_Argc() != 2) 
	{
		if (trackview < 0)
		{
			// Normal track.
			Com_Printf("Usage: %s <userid> | <name>\n", Cmd_Argv(0));
		}
		else
		{
			// Multiview track.
			Com_Printf("Usage: %s <userid> | <name> | <off>\n", Cmd_Argv(0));
		}
		return;
	}

	slot = Player_GetSlot(arg = Cmd_Argv(1), true);

	//
	// The specified player wasn't found.
	//
	if (slot == PLAYER_NAME_NOMATCH) 
	{
		Com_Printf("%s : no such player %s\n", Cmd_Argv(0), arg);
		return;
	} 
	else if (slot == PLAYER_ID_NOMATCH) 
	{
		Com_Printf("%s : no player with userid %d\n", Cmd_Argv(0), Q_atoi(arg));
		return;
	} 
	else if (slot < 0 || slot >= MAX_CLIENTS) 
	{	
		// PLAYER_NUM_MISMATCH covered by this
		Com_Printf("%s : no such player\n", Cmd_Argv(0));
		return;
	}

	// A player has been found that we want to track.
	if (cl.players[slot].spectator) 
	{
		Com_Printf("You cannot track a spectator\n", Cmd_Argv(0));
	} 
	else if (Cam_MainTrackNum() != slot || trackview >= 0)
	{
		// If we're not already tracking the found slot
		// set the camera to track mode and lock it to the selected slot.
		// (Locked as in "not free flying", not "cannot change tracked player")
		cl.autocam = CAM_TRACK;
		Cam_Lock(slot);
		cl.ideal_track = slot;
		
		// Multiview tracking:
		// Set the specified track view to track the specified player.
		CL_MultiviewSetTrackSlot(trackview, slot);

		cl.spec_locked = true;

		if (cls.mvdplayback && cl.teamfortress)
		{
			V_TF_ClearGrenadeEffects();
		}
	}
}

void CL_Track_f(void) 
{
	CL_Track(-1);	
}

void CL_Trackkiller_f(void)
{
	if (killer >= 0 && killer < MAX_CLIENTS) {
		char buf[16];
		snprintf(buf, sizeof(buf), "track %d\n", cl.players[killer].userid);
		Cbuf_AddText(buf);
	}
}

// auto-tracking is a feature implemented in three different places in QW
// - server side, client side (for a demo), recorded in a demo
// this command will choose which feature is available
// at the moment and will toggle it (on/off)
void CL_Autotrack_f(void)
{
	cmd_alias_t* at;
	extern cvar_t mvd_autotrack;
	extern cvar_t demo_autotrack;
	qbool mvda = mvd_autotrack.integer ? true : false;
	qbool demoa = demo_autotrack.integer ? true : false;

	if (cls.demoplayback) {
		if (cls.mvdplayback) {
			if (cl_hightrack.integer) {
				Cvar_SetValue(&cl_hightrack, 0);
			}

			if (!mvda && !demoa) {
				// we will turn on both features but if demo_autotrack info is found
				// it will turn off mvd_autotrack
				Cvar_SetValue(&mvd_autotrack, 4);
				Cvar_SetValue(&demo_autotrack, 1);
				Com_Printf("MVD Autotracking on\n");
			} else if (mvda && !demoa) {
				Com_Printf("MVD Autotracking off\n");
				Cvar_SetValue(&mvd_autotrack, 0);
			} else if (!mvda && demoa) {
				Com_Printf("Demo Autotracking off\n");
				Cvar_SetValue(&demo_autotrack, 0);
			} else { // mvda && demoa
				Com_Printf("Autotracking off\n");
				Cvar_SetValue(&mvd_autotrack, 0);
				Cvar_SetValue(&demo_autotrack, 0);
			}
		} else {
			Com_Printf("Only one point of view is recorded in this demo\n");
		}
	}
	else { // not playing a demo
		if (cl.spectator) {
			if ((at = Cmd_FindAlias("autotrack")) != NULL) {
				// not very "clean" way to execute an alias, but sufficient for this purpose
				Cbuf_AddText(va("%s\n", at->value)); // note KTX this is cmd 154, but we want to be compatible with other mods/versions

				/* Bugfix: When setting autotrack ON, make sure to set cl_hightrack 0.
				If player hits autotrack bind before KTX had a chance to stuff the impulse, then ezQuake would set cl_hightrack to 1.
				Then, if player hits autotrack again after KTX has finished stuffing, both autotrack and cl_hightrack would be on, creating chaos.
				
				HOWEVER, this creates a different, albeit less frustrating bug: if you have autotrack on first, then set cl_hightrack 1, then turn off autotrack, cl_hightrack gets set to 0.
				Currently there is no better way to solve this as autotrack is simply a command sent to the server.*/				
				if (cl_hightrack.integer) {
					Cvar_SetValue(&cl_hightrack, 0);
					Com_Printf("Hightrack off\n");
				}		

			}
			else {
				if (!cl_hightrack.integer) {
					Com_Printf("Autotrack not supported here, tracking top fragger (Hightrack on)\n");
					Cvar_SetValue(&cl_hightrack, 1);
				}
				else {
					Com_Printf("Hightrack off\n");
					Cvar_SetValue(&cl_hightrack, 0);
				}
			}
		}
	}
}

//
// Returns the player id of the currently tracked player (not free flying).
//
int Cam_TrackNum(void) 
{
	static int mvlatch;

	// If we're free-flying, temporarily turn cl_multiview off
	if (cl_multiview.value && !cl.spec_locked)
	{
		mvlatch = cl_multiview.value;
		cl_multiview.value = 0;
	}
	else if (!cl_multiview.value && mvlatch && cl.spec_locked)
	{
		cl_multiview.value = mvlatch;
		mvlatch = 0;
	}

	if (!cl.autocam) {
		return -1;
	}
	
	return cl.spec_track;
}

int WhoIsSpectated (void)
{
	if (cl.spectator && cl.autocam == CAM_TRACK && cl.players[cl.spec_track].name[0]) {
		return cl.spec_track;
	}

    return -1;
}


================================================
FILE: src/cl_cmd.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: cl_cmd.c,v 1.58 2007-10-11 05:55:47 dkure Exp $
*/

#include <time.h>
#include "quakedef.h"
#include "sha1.h"
#include "gl_model.h"
#include "teamplay.h"
#include "config_manager.h"
#include "rulesets.h"
#include "version.h"
#include "utils.h"
#include "menu.h"
#include "qtv.h"
#include "fs.h"

/*time type to be used for rcon encryption*/
#define __qtime_t uint64_t

void SCR_RSShot_f (void);
void CL_ProcessServerInfo(void);
void SV_Serverinfo_f(void);
void S_StopAllSounds(void);


cvar_t cl_sayfilter_coloredtext = {"cl_sayfilter_coloredtext", "0"};
typedef enum coloredtextfilterlevel_e
{
	coltextfilter_none = 0,
	coltextfilter_color = 1,
	coltextfilter_colorwhite = 2
} coloredtextfilterlevel_e;
#define SAYSTRING_UNCOLORED_FILTERMARK	"#u"
#define SAYSTRING_COLORED_FILTERMARK	"#c"

cvar_t cl_sayfilter_sendboth = {"cl_sayfilter_sendboth", "0"};

//adds the current command line as a clc_stringcmd to the client message.
//things like kill, say, etc, are commands directed to the server,
//so when they are typed in at the console, they will need to be forwarded.
void Cmd_ForwardToServer (void) {
	char *s;

	if (cls.mvdplayback == QTV_PLAYBACK) {
		QTV_Cmd_ForwardToServer();
		return;
	}

	if (cls.state == ca_disconnected) {
		Com_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
		return;
	}

	MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
	// lowercase command
	for (s = Cmd_Argv(0); *s; s++)
		*s = (char) tolower(*s);
	SZ_Print (&cls.netchan.message, Cmd_Argv(0));
	if (Cmd_Argc() > 1) {
		SZ_Print (&cls.netchan.message, " ");
		SZ_Print (&cls.netchan.message, Cmd_Args());
	}
}

// don't forward the first argument
void CL_ForwardToServer_f (void) {
// Added by VVD {
	char* server_string;
	char client_time_str[sizeof(__qtime_t) * 2 + 1] = { 0 };
	int i, server_string_len;
	extern cvar_t cl_crypt_rcon;
	__qtime_t client_time = 0;
// Added by VVD }

	if (cls.mvdplayback == QTV_PLAYBACK) {
		QTV_Cl_ForwardToServer_f();
		return;
	}

	if (cls.state == ca_disconnected) {
		Com_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
		return;
	}

	if (cls.demoplayback)
		return;		// not really connected

	if (Cmd_Argc() > 1) {
		if (strcasecmp(Cmd_Argv(1), "snap") == 0) {
			SCR_RSShot_f ();
			return;
		}

//bliP ->
		if (strcasecmp(Cmd_Argv(1), "fileul") == 0) {
			CL_StartFileUpload ();
			return;
		}
//<-
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
/* johnnycz: disabled due to security reasons -- fixme
		if (strcasecmp(Cmd_Argv(1), "download") == 0 && Cmd_Argc() > 2)
		{
			strlcpy(cls.downloadname, Cmd_Argv(2), sizeof(cls.downloadname));
			COM_StripExtension(cls.downloadname, cls.downloadtempname);
			strlcat(cls.downloadtempname, ".tmp", sizeof(cls.downloadtempname));
			cls.downloadtype = dl_single;
			//snprintf (cls.downloadname, sizeof(cls.downloadname), "%s", Cmd_Argv(2));
			//strlcpy (cls.downloadtempname, cls.downloadname, sizeof(cls.downloadtempname));
		}
*/
// Added by VVD {
		if (cl_crypt_rcon.value && strcasecmp(Cmd_Argv(1), "techlogin") == 0 && Cmd_Argc() > 2)
		{
			time((time_t *)&client_time);
			for (client_time_str[0] = i = 0; i < sizeof(client_time); i++) {
				char tmp[3];
				snprintf(tmp, sizeof(tmp), "%02X", (unsigned int)((client_time >> (i * 8)) & 0xFF));
				strlcat(client_time_str, tmp, sizeof(client_time_str));
			}

			server_string_len = Cmd_Argc() + strlen(Cmd_Argv(1)) + DIGEST_SIZE * 2 + 16;
			for (i = 3; i < Cmd_Argc(); ++i)
				server_string_len += strlen(Cmd_Argv(i));
			server_string = (char *) Q_malloc(server_string_len);

			SHA1_Init();
			SHA1_Update((unsigned char *)Cmd_Argv(1));
			SHA1_Update((unsigned char *)" ");
			SHA1_Update((unsigned char *)Cmd_Argv(2));
			SHA1_Update((unsigned char *)client_time_str);
			SHA1_Update((unsigned char *)" ");
			for (i = 3; i < Cmd_Argc(); ++i)
			{
				SHA1_Update((unsigned char *)Cmd_Argv(i));
				SHA1_Update((unsigned char *)" ");
			}

			snprintf(server_string, server_string_len, "%s %s%s ",
				Cmd_Argv(1), SHA1_Final(), client_time_str);
			for (i = 3; i < Cmd_Argc(); ++i)
			{
				strlcat(server_string, Cmd_Argv(i), server_string_len);
				strlcat(server_string, " ", server_string_len);
			}
			SZ_Print (&cls.netchan.message, server_string);
			Q_free(server_string);
		}
		else
// Added by VVD }
			SZ_Print (&cls.netchan.message, Cmd_Args());
	}
}

/// filters white markup chars from the string
static void CL_Cmd_SayString_FilterWhite(char *s)
{
	char *rp = s;	// read pointer
	char *wp = s;	// write pointer
	char c;			// current char

	while ((c = *rp++)) {
		if (c == '{' || c == '}') continue;
		*wp++ = c;
	}

	*wp = '\0';
}

/// filters '&cfa5'-like colored markup from the string
static void CL_Cmd_SayString_FilterColoredText(char *s)
{
	char *rp = s;	// read pointer
	char *wp = s;	// write pointer
	char c;			// current char

	while ((c = *rp++)) {
		if (c == '&' && *rp == 'c') {
			rp++;	// skip 'c'
			if (*rp) rp++; else break;	// skip red value
			if (*rp) rp++; else break;	// skip green value
			if (*rp) rp++; else break;	// skip blue value
			continue;
		}
		*wp++ = c;
	}

	*wp = '\0';
}

// applies colored text filters on the string
static void CL_Cmd_SayString_ApplyFilters(char *s)
{
	if (cl_sayfilter_coloredtext.integer != coltextfilter_none) {
		CL_Cmd_SayString_FilterColoredText(s);
	}
	if (cl_sayfilter_coloredtext.integer == coltextfilter_colorwhite) {
		CL_Cmd_SayString_FilterWhite(s);
	}
}

// inserts an appendix to the string
// if there already is an appendix (starting with #), it will be overwritten
// if the string is enclosed in quotes ("), they will be kept
static void CL_Cmd_SayString_InsertAppendix(char *s, char *appendix)
{
	char *p = strchr(s, '#');
	size_t l = strlen(s);
	qbool endquote = s[l-1] == '\"';

	if (!p) p = s + l - 1;

	while ((*p++ = *appendix++)) {}
	p--;
	if (endquote)
		*p++ = '\"';
	*p = '\0';
}

// sends saystring with optional appendix
static void CL_Cmd_SayString_SendBase(char *s, char *appendix)
{
	if (*s && *s < 32) {
		SZ_Print (&cls.netchan.message, "\"");
		if (appendix) {
			CL_Cmd_SayString_InsertAppendix(s, appendix);
		}
		SZ_Print (&cls.netchan.message, s);
		SZ_Print (&cls.netchan.message, "\"");
	} else {
		if (appendix) {
			CL_Cmd_SayString_InsertAppendix(s, appendix);
		}
		SZ_Print (&cls.netchan.message, s);
	}
}

/// returns true if there is a color markup in the string
static qbool CL_Cmd_SayString_IsColored(char *s)
{
	while(*s) {
		if (*s == '&' && s[1] == 'c') return true;
		s++;
	}
	return false;
}

// this function presumes there's at least two more bytes available memory
// after the end of the string
static void CL_Cmd_SayString_Send(char *s)
{
	if (cl_sayfilter_sendboth.integer && cl_sayfilter_coloredtext.integer
		&& !strcmp("say_team", Cmd_Argv(0)) && CL_Cmd_SayString_IsColored(s)) {
		CL_Cmd_SayString_SendBase(s, SAYSTRING_COLORED_FILTERMARK);
		CL_Cmd_SayString_ApplyFilters(s);
		
		// send header again
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		SZ_Print (&cls.netchan.message, Cmd_Argv(0));
		SZ_Print (&cls.netchan.message, " ");
		
		CL_Cmd_SayString_SendBase(s, SAYSTRING_UNCOLORED_FILTERMARK);
	} else {
		CL_Cmd_SayString_ApplyFilters(s);
		CL_Cmd_SayString_SendBase(s, NULL);
	}
}

//Handles both say and say_team
void CL_Say_f (void) {
	char *s, msg[1024], qmsg[1024];
	int tmp;
	qbool qizmo = false;
	extern cvar_t cl_fakename;
	extern cvar_t cl_fakename_suffix;

	if (cls.mvdplayback == QTV_PLAYBACK) {
		QTV_Say_f();
		return;
	}

	if (Cmd_Argc() < 2)
		return;

	if (cls.state == ca_disconnected) {
		Com_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
		return;
	}

	MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
	// lowercase command
	for (s = Cmd_Argv(0); *s; s++)
		*s = (char) tolower(*s);
	SZ_Print (&cls.netchan.message, Cmd_Argv(0));

	if (CL_ConnectedToProxy()) {	
		for (s = Cmd_Argv(1); *s == ' '; s++)
			;
		if (!strncmp(s, ".stuff", 6) || !strncmp(s, ",stuff", 6) || strstr(s, ":stuff"))
			return;		

		qizmo = (!strncmp(s, "proxy:", 6) || s[0] == ',' || s[0] == '.');
	}

	
	if (!qizmo && cl_floodprot.value && cl_fp_messages.value > 0 && cl_fp_persecond.value > 0) {
		tmp = cl.whensaidhead - min(cl_fp_messages.value, 10) + 1;
		if (tmp < 0)
			tmp += 10;
		if (cl.whensaid[tmp] && (cls.realtime - cl.whensaid[tmp]) < (1.02 * cl_fp_persecond.value)) {
			Com_Printf("Flood Protection\n");
			return;
		}
	}
	

	SZ_Print (&cls.netchan.message, " ");

	s = TP_ParseMacroString (Cmd_Args());
	s = TP_ParseFunChars (s, true);

    /* The string in 's' can be both wrapped in quotes or without wrapper quotes,
       but to make cl_fakename works properly, we need it to be always wrapped in quotes.
       messagemode/messagemode2 commands send text in quotes,
       say/say_team typed in the console sends text without quotes
       So if quotes are missing, we add them.
    */
    // first char isn't quote, last char isn't quote or string is shorter then 2 chars
    if (s[0] != '\"' || s[strlen(s)-1] != '\"' || s[1] == '\0')
    {
        snprintf(qmsg, sizeof(qmsg), "\"%s\"", s);
        s = qmsg;
    }

    // if team message mode and teamname is set and message is not custom mm2 message...
	if (!strcasecmp(Cmd_Argv(0), "say_team") && !cl.spectator && cl_fakename.string[0] && !strchr(s, '\x0d'))
	{
		char c_fn[1024], c_fna[1024], c_msg[1024];
        size_t len = strlen(s) - 1; // cut the trailing quote (")

        len = bound(0, len, sizeof(c_fn));

		// TP_ParseFunChars wants a string < 1024 chars (fix it?)
        strlcpy (c_fn, cl_fakename.string, sizeof(c_fn));
        strlcpy (c_fna, cl_fakename_suffix.string, sizeof(c_fna));
		
        // 1) save the message text, because TP_ParseFunChars will overwrite the temp memory
        // 2) cut the leading quote (+1) and also the trailing quote (len is 1 char shorter)
        strlcpy (c_msg, s+1, len);

		snprintf (msg, sizeof(msg), "\x0d%s%s", TP_ParseFunChars(strcat(c_fn, c_fna), true), c_msg);

		s = msg;
	}

	CL_Cmd_SayString_Send(s);
	
	if (!qizmo) {
		cl.whensaidhead++;
		if (cl.whensaidhead > 9)
			cl.whensaidhead = 0;
		cl.whensaid[cl.whensaidhead] = cls.realtime;
	}
	
}

void CL_Pause_f (void) {
	if (cls.demoplayback)
		cl.paused ^= PAUSED_DEMO;
	else
		Cmd_ForwardToServer();
}

//packet <destination> <contents>
//Contents allows \n escape character
void CL_Packet_f(void) {
// TCPCONNECT -->
	int tcpsock;
// <--TCPCONNECT
	netadr_t adr;
	char send[2048], *in, *out;

	if (Cmd_Argc() != 3) {
		Com_Printf("packet <destination> <contents>\n");
		return;
	}

	if (cbuf_current && cbuf_current != &cbuf_svc && Rulesets_RestrictPacket()) {
		Com_Printf("Packet command is disabled during match\n");
		return;
	}

	if (!NET_StringToAdr(Cmd_Argv(1), &adr)) {
		Com_Printf("Bad address\n");
		return;
	}

	if (adr.port == 0)
		adr.port = BigShort(PORT_SERVER);

	send[0] = send[1] = send[2] = send[3] = 0xFF;

	in = Cmd_Argv(2);
	out = send + 4;

	while (*in && out - send < sizeof(send) - 2) {
		if (in[0] == '\\' && in[1]) {
			switch(in[1]) {
				case 'n' : *out++ = '\n'; break;
				case 't' : *out++ = '\t'; break;
				case '\\' : *out++ = '\\'; break;
				default : *out++ = in[0]; *out++ = in[1]; break;
			}
			in += 2;
		} else {
			*out++ = *in++;
		}
	}
	*out = 0;

// TCPCONNECT -->
	//extra code to stop the packet command from sending to the server via tcp
	tcpsock = cls.sockettcp;
	cls.sockettcp = -1;
	NET_SendPacket (NS_CLIENT, out-send, send, adr);
	cls.sockettcp = tcpsock;
// <--TCPCONNECT
}


void CL_PrintQStatReply (char *s) {
	char *p;
	int n, numplayers;
	int userid, frags, time, ping, topcolor, bottomcolor;
	char name[33], skin[17];

	Com_Printf ("\n");
	Com_Printf ("-------------------------------------\n");

	con_ormask = 128;
	Com_Printf ("qstat %s:\n", NET_AdrToString(net_from));
	con_ormask = 0;

	// count players
	numplayers = -1;
	p = s;
	while (*p) if (*p++ == '\n') numplayers++;

	// extract serverinfo string
	s = strtok (s, "\n");

	Com_Printf ("hostname   %s\n", Info_ValueForKey(s, "hostname"));
	if (*(p = Info_ValueForKey(s, "*gamedir")) && strcmp(p, "qw"))
		Com_Printf ("gamedir    %s\n", p);
	Com_Printf ("map        %s\n", Info_ValueForKey(s, "map"));
	if (*(p = Info_ValueForKey(s, "status")))
		Com_Printf ("status     %s\n", p);
	Com_Printf ("deathmatch %s\n", Info_ValueForKey(s, "deathmatch"));
	Com_Printf ("teamplay   %s\n", Info_ValueForKey(s, "teamplay"));
	Com_Printf ("timelimit  %s\n", Info_ValueForKey(s, "timelimit"));
	Com_Printf ("fraglimit  %s\n", Info_ValueForKey(s, "fraglimit"));
	if ((n = Q_atoi(Info_ValueForKey(s, "needpass")) & 3) != 0)
		Com_Printf ("needpass   %s%s%s\n", n & 1 ? "player" : "",
			n == 3 ? ", " : "", n & 2 ? "spectator" : "");
	if (Q_atoi(Info_ValueForKey(s, "needpass")) & 1)
		Com_Printf ("player password required\n");
	if (Q_atoi(Info_ValueForKey(s, "needpass")) & 2)
		Com_Printf ("spectator password required\n");

	Com_Printf ("players    %i/%s\n", numplayers, Info_ValueForKey(s, "maxclients"));

	p = strtok (NULL, "\n");

	if (p)
	{
		con_ormask = 128;
		Com_Printf ("\nping time frags name\n");
		con_ormask = 0;
		Com_Printf ("-------------------------------------\n");

		while (p)
		{
			sscanf (p, "%d %d %d %d \"%32[^\"]\" \"%16[^\"]\" %d %d",
				&userid, &frags, &time, &ping, (char *)&name, (char *)&skin, &topcolor, &bottomcolor);
			Com_Printf("%4d %4d %4d  %-16.16s\n", ping, time, frags, name);
			p = strtok (NULL, "\n");
		}
		Com_Printf ("-------------------------------------\n");
	}

	Com_Printf ("\n");
}

/*
====================
CL_QStat_f

qstat <destination>
====================
*/
double	qstat_senttime = 0;

void CL_QStat_f (void)
{
	char	send[10] = {0xff, 0xff, 0xff, 0xff, 's', 't', 'a', 't', 'u', 's'};
	netadr_t	adr;

	if (Cmd_Argc() < 2)
	{
		Com_Printf ("usage: qstat <server>\n");
		return;
	}

	if (!NET_StringToAdr (Cmd_Argv(1), &adr))
	{
		Com_Printf ("Bad address\n");
		return;
	}

	if (adr.port == 0)
		adr.port = BigShort (PORT_SERVER);

	NET_SendPacket (NS_CLIENT, 10, send, adr);

	qstat_senttime = curtime;
}


//Send the rest of the command line over as an unconnected command.
void CL_Rcon_f (void) {

	char message[1024];
	char client_time_str[sizeof(__qtime_t) * 2 + 1];
	int i, i_from;
	netadr_t to;
	extern cvar_t rcon_password, rcon_address, cl_crypt_rcon;
	__qtime_t client_time = 0;

	message[0] = (char)255;
	message[1] = (char)255;
	message[2] = (char)255;
	message[3] = (char)255;
	message[4] = 0;
	strlcat (message, "rcon ", sizeof(message));

// Added by VVD {
	if (cl_crypt_rcon.value)
	{
		time((time_t *)&client_time);
		for (client_time_str[0] = i = 0; i < sizeof(client_time); i++) {
			char tmp[3];
			snprintf(tmp, sizeof(tmp), "%02X", (unsigned int)((client_time >> (i * 8)) & 0xFF));
			strlcat(client_time_str, tmp, sizeof(client_time_str));
		}
		
		SHA1_Init();
		SHA1_Update((unsigned char *)"rcon ");
		if (rcon_password.string[0])
		{
			SHA1_Update((unsigned char *)rcon_password.string);
			SHA1_Update((unsigned char *)client_time_str);
			i_from = 1;
		}
		else // first arg must be pass in such case, so handle this
		{
			SHA1_Update((unsigned char *)Cmd_Argv(1));
			SHA1_Update((unsigned char *)client_time_str);
			i_from = 2;
		}
		SHA1_Update((unsigned char *)" ");
		for (i = i_from; i < Cmd_Argc(); i++)
		{
			SHA1_Update((unsigned char *)Cmd_Argv(i));
			SHA1_Update((unsigned char *)" ");
		}
		strlcat (message, SHA1_Final(), sizeof(message));
		strlcat (message, client_time_str, sizeof(message));
		strlcat (message, " ", sizeof(message));
	}
	else {
		i_from = 1;
 		if (rcon_password.string[0]) {
			strlcat (message, rcon_password.string, sizeof(message));
			strlcat (message, " ", sizeof(message));
		}
	}
	for (i = i_from; i < Cmd_Argc(); i++)
	{
		strlcat (message, Cmd_Argv(i), sizeof(message));
		strlcat (message, " ", sizeof(message));
	}
// } Added by VVD

	if (cls.state >= ca_connected) {
		to = cls.netchan.remote_address;
	} else {
		if (!strlen(rcon_address.string)) {
			Com_Printf ("You must either be connected or set 'rcon_address' to issue rcon commands\n");
			return;
		}
		NET_StringToAdr (rcon_address.string, &to);
		if (to.port == 0)
			to.port = BigShort (PORT_SERVER);
	}

	NET_SendPacket (NS_CLIENT, strlen(message)+1, message, to);
}

qbool CL_Download_Accept(const char *filename)
{
	if (strstr(filename, "..") || !strcmp(filename, "") || filename[0] == '/' || strchr(filename, '\\') || strchr(filename, ':') || strstr(filename, "//")) {
		Com_Printf("Warning: Invalid characters in filename \"%s\"\n", filename);
		return false;
	}

	if (!CL_IsDownloadableFileExtension(filename)) {
		Com_Printf("Warning: Non-allowed file \"%s\" skipped. Add \"%s\" to cl_allow_downloads to allow the file to be downloaded\n", filename, COM_FileExtension(filename));
		return false;
	}

	vfsfile_t *f = FS_OpenVFS(filename, "rb", FS_ANY);
	if (f) {
		VFS_CLOSE(f);
		return false;
	}

	return true;
}

void CL_Download_f (void){
	char *dir; // we save to demo_dir or gamedir
	char *filename; // which file to dl, will be sent to server
	char ondiskname[sizeof(cls.downloadname)]; // hack, save file to "right" place
	extern char *CL_DemoDirectory(void);

	if (cls.state == ca_disconnected) {
		Com_Printf ("Must be connected.\n");
		return;
	}

	filename = Cmd_Argv(1);
	strlcpy(ondiskname, filename, sizeof(ondiskname)); // in most cases this is same as filename

	if (Cmd_Argc() != 2 || !filename[0] || !CL_Download_Accept(filename)) {
		Com_Printf ("Usage: %s <datafile>\n", Cmd_Argv(0));
		return;
	}

	// hack: save demos in demo_dir
	if (
				    Utils_RegExpMatch("\\.mvd(\\.(gz|bz2|rar|zip))?$", filename)
				 || Utils_RegExpMatch("\\.(qwd|qwz|dem)$", filename)
			) {
		dir = CL_DemoDirectory(); // seems filename is a demo
		// so, we save file in /dir/<demo_dir> instead of /dir/<demo_dir>/demos
		strlcpy(ondiskname, COM_SkipPath(filename), sizeof(ondiskname));
	}
	else
		dir = cls.gamedir; // not a demo

	// download to a temp name, and only rename
	// to the real name when done, so if interrupted
	// a runt file wont be left

	cls.downloadtype      = dl_single;
	cls.downloadmethod    = DL_QW; // by default its DL_QW, if server support DL_QWCHUNKED it will be changed.
	cls.downloadstarttime = Sys_DoubleTime();

	snprintf(cls.downloadname, sizeof(cls.downloadname), "%s/%s", dir, ondiskname);
	COM_StripExtension(cls.downloadname, cls.downloadtempname, sizeof(cls.downloadtempname));
	strlcat(cls.downloadtempname, ".tmp", sizeof(cls.downloadtempname));

	if (cls.mvdplayback == QTV_PLAYBACK)
	{
		QTV_Cmd_Printf(QTV_EZQUAKE_EXT_DOWNLOAD, "download \"%s\"", filename);
	}
	else
	{
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		SZ_Print (&cls.netchan.message, va("download \"%s\"", filename));
	}
}

void CL_User_f (void) {
	int uid, i;

	if (Cmd_Argc() != 2) {
		Com_Printf ("Usage: %s <username / userid>\n", Cmd_Argv(0));
		return;
	}

	uid = atoi(Cmd_Argv(1));

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0])
			continue;
		if (cl.players[i].userid == uid	|| !strcmp(cl.players[i].name, Cmd_Argv(1)) ) {
			Info_Print (cl.players[i].userinfo);
			return;
		}
	}
	Com_Printf ("User not in server.\n");
}

void CL_Users_f (void) {
	int i, c;

	c = 0;
	Com_Printf ("userid frags name\n");
	Com_Printf ("------ ----- ----\n");
	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0]) {
			Com_Printf ("%6i %4i %s\n", cl.players[i].userid, cl.players[i].frags, cl.players[i].name);
			c++;
		}
	}

	Com_Printf ("%i total users\n", c);
}

void CL_Color_f (void) {
	extern cvar_t topcolor, bottomcolor;
	int top, bottom;

	switch (Cmd_Argc())
	{
		case 1:
			Com_Printf ("\"color\" is \"%s %s\"\n",
				Info_ValueForKey (cls.userinfo, "topcolor"),
				Info_ValueForKey (cls.userinfo, "bottomcolor") );
			Com_Printf ("color <0-16> [0-16]\n");
			return;
		case 2:
			top = bottom = Q_atoi(Cmd_Argv(1));
			break;
		default:
			top = Q_atoi(Cmd_Argv(1));
			bottom = Q_atoi(Cmd_Argv(2));
	}

	Cvar_SetValue (&topcolor, bound(0, top, 16));
	Cvar_SetValue (&bottomcolor, bound(0, bottom, 16));
}

//usage: fullinfo \name\unnamed\topcolor\0\bottomcolor\1, etc
void CL_FullInfo_f (void) {
	char key[512], value[512], *o, *s;

	if (Cmd_Argc() != 2) {
		Com_Printf ("fullinfo <complete info string>\n");
		return;
	}

	s = Cmd_Argv(1);
	if (*s == '\\')
		s++;
	while (*s) {
		o = key;
		while (*s && *s != '\\')
			*o++ = *s++;
		*o = 0;

		if (!*s) {
			Com_Printf ("MISSING VALUE\n");
			return;
		}

		o = value;
		s++;
		while (*s && *s != '\\')
			*o++ = *s++;
		*o = 0;

		if (*s)
			s++;

		if (!strcasecmp(key, pmodel_name) || !strcasecmp(key, emodel_name))
			continue;

		Info_SetValueForKey (cls.userinfo, key, value, MAX_INFO_STRING);
	}
}

//Allow clients to change userinfo
void CL_SetInfo_f (void) {
	if (Cmd_Argc() == 1) {
		Info_Print (cls.userinfo);
		Com_Printf ("[%i/196]\n", strlen(cls.userinfo));
		return;
	}
	if (Cmd_Argc() != 3) {
		Com_Printf ("Usage: %s [ <key> <value> ]\n", Cmd_Argv(0));
		return;
	}
	if (!strcasecmp(Cmd_Argv(1), pmodel_name) || !strcmp(Cmd_Argv(1), emodel_name))
		return;

	Info_SetValueForKey (cls.userinfo, Cmd_Argv(1), Cmd_Argv(2), MAX_INFO_STRING);
	if (cls.state >= ca_connected)
		Cmd_ForwardToServer ();
}


void CL_UserInfo_f (void) {
	if (Cmd_Argc() != 1) {
		Com_Printf("%s : no arguments expected\n", Cmd_Argv(0));
		return;
	}
	Info_Print (cls.userinfo);
}

void CL_Quit_f (void) {
	extern cvar_t cl_confirmquit;

	if (cl_confirmquit.value)
		M_Menu_Quit_f ();
	else
		Host_Quit ();
}

// QW262 -->
/*
============
CL_Userdir_f

============
*/
void CL_Userdir_f (void)
{
	if (cls.state > ca_disconnected || Cmd_Argc() == 1) {
		Com_Printf("Current userdir: %s\n", userdirfile);
	} else {
		int u = Q_atoi(Cmd_Argv(2));
		if (u < 0 || u > 5)
			Com_Printf("Invalid userdir type\n");
		else
			FS_SetUserDirectory (Cmd_Argv(1), Cmd_Argv(2));
	}
}
// <-- QW262

void CL_Serverinfo_f (void) 
{
	#ifndef CLIENTONLY
	if (cls.state < ca_connected || com_serveractive) 
	{
		SV_Serverinfo_f();
		return;
	}
	#endif // CLIENTONLY

	if (cls.state >= ca_onserver && cl.serverinfo[0])
		Info_Print (cl.serverinfo);
	else		
		Com_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
}

//============================================================================

typedef struct
{
	const char	*name;
	int			bit;
} z_ext_map_t;

static z_ext_map_t z_map[] =
{
	{ "PM_TYPE",		Z_EXT_PM_TYPE },
	{ "PM_TYPE_NEW",	Z_EXT_PM_TYPE_NEW },
	{ "VIEWHEIGHT",		Z_EXT_VIEWHEIGHT },
	{ "SERVERTIME",		Z_EXT_SERVERTIME },
	{ "PITCHLIMITS",	Z_EXT_PITCHLIMITS },
	{ "JOIN_OBSERVE",	Z_EXT_JOIN_OBSERVE },
	{ "PF_ONGROUND",	Z_EXT_PF_ONGROUND },
	{ "VWEP",			Z_EXT_VWEP },
	{ "PF_SOLID",		Z_EXT_PF_SOLID },
};

static int z_map_cnt = sizeof(z_map)/sizeof(z_map[0]);

int get_z_ext_list(int bits, char *buf, int bufsize)
{
	int i, cnt;

	buf[0] = 0; // hope buf size at least one byte

	for (i = cnt = 0; i < z_map_cnt; i++)
	{
		if (!z_map[i].bit || z_map[i].bit != (z_map[i].bit & bits))
			continue; // not match

		if (cnt)
			strlcat(buf, " ", bufsize);
		strlcat(buf, z_map[i].name, bufsize);
		cnt++;
	}

	return cnt;
}

void CL_Z_Ext_List_f (void)
{
	char buf[1024] = {0};

	Com_Printf("ZQuake protocol extensions:\n");
	Com_Printf("%s\n", get_z_ext_list(cl.z_ext, buf, sizeof(buf)) ? buf : "NONE");
}

//============================================================================

void CL_InitCommands (void) {
	// general commands
	Cmd_AddCommand ("cmd", CL_ForwardToServer_f);
	Cmd_AddCommand ("download", CL_Download_f);
	Cmd_AddCommand ("qstat", CL_QStat_f);
	Cmd_AddCommand ("packet", CL_Packet_f);
	Cmd_AddCommand ("rcon", CL_Rcon_f);
	Cmd_AddCommand ("pause", CL_Pause_f);
	Cmd_AddCommand ("quit", CL_Quit_f);
	Cmd_AddCommand ("say", CL_Say_f);
	Cmd_AddCommand ("say_team", CL_Say_f);
	Cmd_AddCommand ("serverinfo", CL_Serverinfo_f);
	Cmd_AddCommand ("skins", Skin_Skins_f);
	Cmd_AddCommand ("showskins", Skin_ShowSkins_f);
	Cmd_AddCommand ("user", CL_User_f);
	Cmd_AddCommand ("users", CL_Users_f);
	Cmd_AddCommand ("version", CL_Version_f);

	// client info setting
	Cmd_AddCommand ("color", CL_Color_f);
	Cmd_AddCommand ("fullinfo", CL_FullInfo_f);
	Cmd_AddCommand ("setinfo", CL_SetInfo_f);
	Cmd_AddCommand ("userinfo", CL_UserInfo_f);
// QW262 -->
	Cmd_AddCommand ("userdir", CL_Userdir_f);
// <-- QW262
	// forward to server commands
	Cmd_AddCommand ("kill", NULL);
	Cmd_AddCommand ("god", NULL);
	Cmd_AddCommand ("give", NULL);
	Cmd_AddCommand ("noclip", NULL);
	Cmd_AddCommand ("fly", NULL);

	//  Windows commands
	Cmd_AddCommand ("windows", VID_Minimize);

	Cmd_AddCommand ("z_ext_list", CL_Z_Ext_List_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_COMMUNICATION);
	Cvar_Register(&cl_sayfilter_coloredtext);
	Cvar_Register(&cl_sayfilter_sendboth);
	Cvar_ResetCurrentGroup();
}

/*
==============================================================================
SERVER COMMANDS

Server commands are commands stuffed by server into client's cbuf
We use a separate command buffer for them -- there are several
reasons for that:
1. So that partially stuffed commands are always executed properly
2. Not to let players cheat in TF (v_cshift etc don't work in console)
3. To hide some commands the user doesn't need to know about, like
changing, fullserverinfo, nextul, stopul
==============================================================================
*/

//Just sent as a hint to the client that they should drop to full console
void CL_Changing_f (void) {
	cl.intermission = 0;

	// don't change when downloading
	if (cls.download) {
		// we were on server
		if (cls.state == ca_active) {
			// drop to full console
			// not active anymore, but not disconnected
			cls.state = ca_connected;
#ifdef DEBUG_MEMORY_ALLOCATIONS
			Sys_Printf("\nevent,active(changing)\n");
#endif

			if (!com_serveractive) {
				// notice mapname not valid yet
				Cvar_ForceSet(&host_mapname, "");
			}
		}
		return;
	}

	S_StopAllSounds();

	// MVDs starting during map change can have /changing from the previous map
	if (!(cls.mvdplayback && cls.state == ca_onserver)) {
		// not active anymore, but not disconnected
		cls.state = ca_connected;
	}

	if (!com_serveractive) {
		Cvar_ForceSet(&host_mapname, ""); // notice mapname not valid yet
	}

	Com_Printf ("\nChanging map...\n");
}

//Sent by server when serverinfo changes
void CL_FullServerinfo_f (void) {
	char *p;

	if (Cmd_Argc() != 2)
		return;

	strlcpy (cl.serverinfo, Cmd_Argv(1), sizeof(cl.serverinfo));

	p = Info_ValueForKey (cl.serverinfo, "*cheats");
	if (*p)
		Com_Printf ("== Cheats are enabled ==\n");

	CL_ProcessServerInfo ();
}

void CL_R_DrawViewModel_f (void) {
	extern cvar_t cl_filterdrawviewmodel;

	if (cl_filterdrawviewmodel.value)
		return;
	Cvar_Command ();
}

typedef struct {
	char	*name;
	void	(*func) (void);
} svcmd_t;

svcmd_t svcmds[] = {
	{"changing", CL_Changing_f},
	{"fullserverinfo", CL_FullServerinfo_f},
	{"nextul", CL_NextUpload},
	{"stopul", CL_StopUpload},
//	{"fov", CL_Fov_f},
	{"r_drawviewmodel", CL_R_DrawViewModel_f},
	{"fileul", CL_StartFileUpload}, //bliP
	{NULL, NULL}
};

//Called by Cmd_ExecuteString if cbuf_current == &cbuf_svc
qbool CL_CheckServerCommand (void) {
	svcmd_t	*cmd;
	char *s;

	s = Cmd_Argv (0);
	for (cmd = svcmds; cmd->name; cmd++) {
		if (!strcmp (s, cmd->name) ) {
			cmd->func();
			return true;
		}
	}

	return false;
}

usermainbuttons_t CL_GetLastCmd(int player_slot)
{
	usercmd_t cmd = { 0 };
	usermainbuttons_t ret;
	static int last_impulse;
	static double impulse_time;

	extern void MVD_FlushUserCommands (void);

	if (cls.mvdplayback && cl.mvd_time_offset) {
		memset (&ret, 0, sizeof (ret));

		// Check for latest
		MVD_FlushUserCommands ();

		ret.attack = (cl.mvd_user_cmd[0] & 1);
		ret.jump = (cl.mvd_user_cmd[0] & 2);
		ret.forward = (cl.mvd_user_cmd[0] & 4);
		ret.back = (cl.mvd_user_cmd[0] & 8);
		ret.right = (cl.mvd_user_cmd[0] & 16);
		ret.left = (cl.mvd_user_cmd[0] & 32);
		ret.up = (cl.mvd_user_cmd[0] & 64);
		ret.down = (cl.mvd_user_cmd[0] & 128);
		return ret;
	}

	if (player_slot >= 0 && player_slot < MAX_CLIENTS) {
		frame_t* frame = &cl.frames[cl.validsequence & UPDATE_MASK];
		if (frame->playerstate[player_slot].messagenum == cl.parsecount) {
			cmd = frame->playerstate[player_slot].command;
		}
	}
	else {
		cmd = cl.frames[(cls.netchan.outgoing_sequence - 1) & UPDATE_MASK].cmd;
	}

	ret.attack = cmd.buttons & BUTTON_ATTACK;
	ret.jump = cmd.buttons & BUTTON_JUMP;
	ret.up = cmd.upmove > 0;
	ret.down = cmd.upmove < 0;
	ret.forward = cmd.forwardmove > 0;
	ret.back = cmd.forwardmove < 0;
	ret.left = cmd.sidemove < 0;
	ret.right = cmd.sidemove > 0;

	if (cmd.impulse) {
		last_impulse = cmd.impulse;
		impulse_time = cls.realtime;
	}
	if (!(last_impulse && cls.realtime >= impulse_time &&
		cls.realtime <= impulse_time + 0.2))
		last_impulse = 0;
	return ret;
}


================================================
FILE: src/cl_demo.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 2007-2015 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include <time.h>
#include "quakedef.h"
#include "movie.h"
#include "menu_demo.h"
#include "qtv.h"
#include "gl_model.h"
#include "tr_types.h"
#include "teamplay.h"
#include "pmove.h"
#include "fs.h"
#include "hash.h"
#include "vfs.h"
#include "utils.h"
#include "crc.h"
#include "logging.h"
#include "version.h"
#include "demo_controls.h"
#include "mvd_utils.h"
#include "r_trace.h"
#include "sha3.h"
#ifndef CLIENTONLY
#include "server.h"
#endif
#ifndef _WIN32
#include <sys/types.h>
#include <sys/wait.h>
#endif

/* FIXME Move these to a proper header file and included that */
void Cam_Unlock(void);

// TODO: Create states for demo_recording, demo_playback, and so on and put all related vars into these.
// Right now with global vars for everything is a mess. Also renaming some of the time vars to be less
// confusing is probably good. demotime, olddemotime, nextdemotime, prevtime...
/*
typedef struct demo_state_s
{
	float		olddemotime;
	float		nextdemotime;

	double		bufferingtime;

	sizebuf_t	democache;
	qbool		democache_available;

	qbool		qwz_unpacking;
	qbool		qwz_playback;
	qbool		qwz_packing;
	char		tempqwd_name[256];
} demo_state_t;
*/
double olddemotime, nextdemotime; // TODO: Put in a demo struct.

double bufferingtime; // if we stream from QTV, this is non zero when we trying fill our buffer

// playback buffer
vfsfile_t* playbackfile = NULL;           // The demo file used for playback.
float demo_time_length = 0;               // The length of the demo.

unsigned char stream_buffer[1024 * 256];  // Playback buffer (qtv only).
int     stream_buffer_cnt = 0;            // How many bytes we've have in playback buffer.
qbool   stream_buffer_eof = false;        // Have we reached the end of the playback buffer?

//
// Vars related to QIZMO compressed demos.
// (Only available in Win32 since we need to use an external app)
//
typedef enum {
	qizmo_not_running,
	qizmo_still_active,
	qizmo_terminated_ok,
	qizmo_terminated_unexpected,
	qizmo_terminated_failure
} qizmo_status_t;

static void CL_Demo_RemoveQWD(void);
static void CL_Demo_GetCompressedName(char* cdemo_name);
static void CL_Demo_RemoveCompressed(void);
static void StopQWZPlayback(void);
static void PlayQWZDemo(const char* name);
static qbool CL_Demo_Compress(char* qwdname);
static void CL_DemoStartPlayback(const char* name);

static qbool	qwz_unpacking = false;
static qbool	qwz_playback = false;
static qbool	qwz_packing = false;

#define QWZ_DECOMPRESSION_TIMEOUT_MS	10000

static void		OnChange_demo_format(cvar_t*, char*, qbool*);
cvar_t			demo_format = {"demo_format", "qwz", 0, OnChange_demo_format};

static char tempqwd_name[MAX_PATH] = { 0 }; // This file must be deleted after playback is finished.
static char tempqwz_name[MAX_PATH] = { 0 };

static vfsfile_t *CL_Open_Demo_File(const char *name, qbool searchpaks, char **fullpath);
static void OnChange_demo_dir(cvar_t *var, char *string, qbool *cancel);
cvar_t demo_dir = {"demo_dir", "", 0, OnChange_demo_dir};
cvar_t demo_benchmarkdumps = {"demo_benchmarkdumps", "1"};
cvar_t cl_startupdemo = {"cl_startupdemo", ""};
cvar_t demo_jump_rewind = { "demo_jump_rewind", "-10" };
cvar_t cl_demo_qwd_delta = { "cl_demo_qwd_delta", "1" };
cvar_t demo_jump_skip_messages = { "demo_jump_skip_messages", "1" };

// Used to save track status when rewinding.
static vec3_t rewind_angle;
static vec3_t rewind_pos;
static double qtv_demospeed = 1;
static int rewind_spec_track = 0;

char Demos_Get_Trackname(void);
static void CL_DemoPlaybackInit(void);
void CL_ProcessUserInfo(int slot, player_info_t *player, char *key);

char *CL_DemoDirectory(void);
void CL_Demo_Jump_Status_Check (void);

//=============================================================================
//								DEMO WRITING
//=============================================================================

static FILE *recordfile = NULL;		// File used for recording demos. // TODO: Put in a demo struct.
static float playback_recordtime;	// Time when in demo playback and recording. // TODO: Put in a demo struct.

#define DEMORECORDTIME	((float) (cls.demoplayback ? playback_recordtime : cls.realtime))
#define DEMOCACHE_MINSIZE	(2 * 1024 * 1024)
#define DEMOCACHE_FLUSHSIZE	(1024 * 1024)

static sizebuf_t democache; // TODO: Put in a demo struct.
static qbool democache_available = false;	// Has the user opted to use a demo cache? // TODO: Put in a demo struct.

//
// Opens a demo for writing.
//
static qbool CL_Demo_Open(char *name)
{
	// Clear the demo cache and open the demo file for writing.
	if (democache_available)
		SZ_Clear(&democache);
	recordfile = fopen (name, "wb");
	return recordfile ? true : false;
}

//
// Closes a demo.
//
static void CL_Demo_Close(void)
{
	// Flush the demo cache and close the demo file.
	if (democache_available)
		fwrite(democache.data, democache.cursize, 1, recordfile);
	fclose(recordfile);
	recordfile = NULL;
}

//
// Writes a chunk of data to the currently opened demo record file.
//
static void CL_Demo_Write(const void *data, int size)
{
	if (democache_available)
	{
		//
		// Write to the demo cache.
		//
		if (size > democache.maxsize)
		{
			// The size of the data to be written is bigger than the demo cache, fatal error.
			Sys_Error("CL_Demo_Write: size > democache.maxsize");
		}
		else if (size > democache.maxsize - democache.cursize)
		{
			//
			// Flushes part of the demo cache (enough to fit the new data) if it has been overflowed.
			//
			int overflow_size = size - (democache.maxsize - democache.cursize);

			Com_Printf("Warning: democache overflow...flushing\n");

			if (overflow_size <= DEMOCACHE_FLUSHSIZE)
				overflow_size = min(DEMOCACHE_FLUSHSIZE, democache.cursize);

			// Write as much data as overflowed from the current
			// contents of the demo cache to the demo file.
			fwrite(democache.data, overflow_size, 1, recordfile);

			// Shift the cache contents (remove what was just written).
			memmove(democache.data, democache.data + overflow_size, democache.cursize - overflow_size);
			democache.cursize -= overflow_size;

			// Write the new data to the demo cache.
			SZ_Write(&democache, data, size);
		}
		else
		{
			// Write to the demo cache.
			SZ_Write(&democache, data, size);
		}
	}
	else
	{
		//
		// Write directly to the file.
		//
		fwrite (data, size, 1, recordfile);
	}
}

//
// Writes a user cmd to the open demo file.
//
void CL_WriteDemoCmd (usercmd_t *pcmd)
{
	int i;
	float fl, t[3];
	byte c;
	usercmd_t cmd;

	// Write the current time.
	fl = LittleFloat(DEMORECORDTIME);
	CL_Demo_Write(&fl, sizeof(fl));

	// Write the message type. A user cmd (movement and such).
	c = dem_cmd;
	CL_Demo_Write(&c, sizeof(c));

	// Correct for byte order, bytes don't matter.
	cmd = *pcmd;

	// Convert the movement angles / vectors to the correct byte order.
	for (i = 0; i < 3; i++)
		cmd.angles[i] = LittleFloat(cmd.angles[i]);
	cmd.forwardmove = LittleShort(cmd.forwardmove);
	cmd.sidemove    = LittleShort(cmd.sidemove);
	cmd.upmove      = LittleShort(cmd.upmove);

	// Write the actual user command to the demo.
	CL_Demo_Write(&cmd, sizeof(cmd));

	// Write the view angles with the correct byte order.
	t[0] = LittleFloat (cl.viewangles[0]);
	t[1] = LittleFloat (cl.viewangles[1]);
	t[2] = LittleFloat (cl.viewangles[2]);
	CL_Demo_Write(t, sizeof(t));
}

//
// Dumps the current net message, prefixed by the length and view angles
//
void CL_WriteDemoMessage (sizebuf_t *msg)
{
	int len;
	float fl;
	byte c;

	// Write time of cmd.
	fl = LittleFloat(DEMORECORDTIME);
	CL_Demo_Write(&fl, sizeof(fl));

	// Write the message type. Net message.
	c = dem_read;
	CL_Demo_Write(&c, sizeof(c));

	// Write the length of the data.
	len = LittleLong (msg->cursize);
	CL_Demo_Write(&len, 4);

	// Write the data.
	CL_Demo_Write(msg->data, msg->cursize);

	// Request pings from the net chan if the user has set it.
    {
        extern void Request_Pings(void);
        extern cvar_t demo_getpings;

        if (demo_getpings.value)
            Request_Pings();
    }
}


//
// Writes the entities list to a demo.
//
void CL_WriteDemoEntities (void)
{
	int ent_index, ent_total;
	entity_state_t *ent;
	
	// Write the ID byte for a delta entity operation to the demo.
	MSG_WriteByte (&cls.demomessage, svc_packetentities);

	// Get the entities list from the frame.
	ent = cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].packet_entities.entities;
	ent_total = cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].packet_entities.num_entities;

	// Write all the entity changes since last packet entity message.
	for (ent_index = 0; ent_index < ent_total; ent_index++, ent++) {
		MSG_WriteDeltaEntity(&cl_entities[ent->number].baseline, ent, &cls.demomessage, true, cls.fteprotocolextensions, cls.mvdprotocolextensions1);
	}

	// End of packetentities.
	MSG_WriteShort (&cls.demomessage, 0);
}

//
// Writes a startup demo message to the demo being recorded.
//
static void CL_WriteStartupDemoMessage (sizebuf_t *msg, int seq)
{
	int len, i;
	float fl;
	byte c;

	// Don't write, we're not recording.
	if (!cls.demorecording)
		return;

	// Write the time.
	fl = LittleFloat(DEMORECORDTIME);
	CL_Demo_Write(&fl, sizeof(fl));

	// Message type = net message.
	c = dem_read;
	CL_Demo_Write(&c, sizeof(c));

	// Write the length of the message.
	len = LittleLong (msg->cursize + 8);
	CL_Demo_Write(&len, 4);

	// Write the sequence number twice. Why?
	i = LittleLong(seq);
	CL_Demo_Write(&i, 4);
	CL_Demo_Write(&i, 4);

	// Write the actual message data to the demo.
	CL_Demo_Write(msg->data, msg->cursize);
}

//
// Writes a set demo message. The outgoing / incoming sequence at the start of the demo.
// This is only written once at startup.
//
static void CL_WriteSetDemoMessage (void)
{
	int len;
	float fl;
	byte c;

	// We're not recording.
	if (!cls.demorecording)
		return;

	// Write the demo time.
	fl = LittleFloat(DEMORECORDTIME);
	CL_Demo_Write(&fl, sizeof(fl));

	// Write the message type.
	c = dem_set;
	CL_Demo_Write(&c, sizeof(c));

	// Write the outgoing / incoming sequence.
	len = LittleLong(cls.netchan.outgoing_sequence);
	CL_Demo_Write(&len, 4);
	len = LittleLong(cls.netchan.incoming_sequence);
	CL_Demo_Write(&len, 4);
}

// FIXME: same as in sv_user.c. Move to common.c?
static char *TrimModelName (const char *full)
{
	static char shortn[MAX_QPATH];
	int len;

	if (!strncmp(full, "progs/", 6) && !strchr(full + 6, '/'))
		strlcpy (shortn, full + 6, sizeof(shortn));		// strip progs/
	else
		strlcpy (shortn, full, sizeof(shortn));

	len = strlen(shortn);
	if (len > 4 && !strcmp(shortn + len - 4, ".mdl")
		&& strchr(shortn, '.') == shortn + len - 4)
	{	// strip .mdl
		shortn[len - 4] = '\0';
	}

	return shortn;
}

void CL_WriteServerdata (sizebuf_t *msg)
{
	int ignore_extensions;

	MSG_WriteByte (msg, svc_serverdata);

	// Maintain demo compatibility.
	ignore_extensions = 0;
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	// this is OK, since download data skipped anyway
	ignore_extensions |= FTE_PEXT_CHUNKEDDOWNLOADS;
#endif
#ifdef FTE_PEXT_256PACKETENTITIES
	// this is probably OK, since engine should ignore more than 64 entities if not supported.
	ignore_extensions |= FTE_PEXT_256PACKETENTITIES;
#endif

	#ifdef PROTOCOL_VERSION_FTE
	if (cls.fteprotocolextensions &~ ignore_extensions)
	{
		MSG_WriteLong (msg, PROTOCOL_VERSION_FTE);
		MSG_WriteLong (msg, cls.fteprotocolextensions);
	}
	#endif // PROTOCOL_VERSION_FTE

	// Maintain demo pseudo-compatibility,
	ignore_extensions = 0;

	#ifdef PROTOCOL_VERSION_FTE2
	if (cls.fteprotocolextensions2 & ~ignore_extensions)
	{
		MSG_WriteLong (msg, PROTOCOL_VERSION_FTE2);
		MSG_WriteLong (msg, cls.fteprotocolextensions2);
	}
	#endif // PROTOCOL_VERSION_FTE2

	// Maintain demo pseudo-compatibility,
	ignore_extensions = 0;

#ifdef PROTOCOL_VERSION_MVD1
	if (cls.mvdprotocolextensions1 & ~ignore_extensions)
	{
		MSG_WriteLong (msg, PROTOCOL_VERSION_MVD1);
		MSG_WriteLong (msg, cls.mvdprotocolextensions1);
	}
#endif // PROTOCOL_VERSION_MVD1

	MSG_WriteLong (msg, PROTOCOL_VERSION);
	MSG_WriteLong (msg, cl.servercount);
	MSG_WriteString (msg, cls.gamedirfile);

	// Write if we're a spectator or not.
	if (cl.spectator)
		MSG_WriteByte (msg, cl.playernum | 128);
	else
		MSG_WriteByte (msg, cl.playernum);

	// Send full levelname.
	MSG_WriteString (msg, cl.levelname);

	// Send the movevars.
	MSG_WriteFloat(msg, movevars.gravity);
	MSG_WriteFloat(msg, movevars.stopspeed);
	MSG_WriteFloat(msg, cl.maxspeed);
	MSG_WriteFloat(msg, movevars.spectatormaxspeed);
	MSG_WriteFloat(msg, movevars.accelerate);
	MSG_WriteFloat(msg, movevars.airaccelerate);
	MSG_WriteFloat(msg, movevars.wateraccelerate);
	MSG_WriteFloat(msg, movevars.friction);
	MSG_WriteFloat(msg, movevars.waterfriction);
	MSG_WriteFloat(msg, cl.entgravity);
}

//
// Write startup data to demo (called when demo started and cls.state == ca_active)
//
static void CL_WriteStartupData (void)
{
	sizebuf_t buf;
	char buf_data[MAX_MSGLEN * 2], *s;
	int n, i, j, seq = 1;
	entity_t *ent;
	entity_state_t *es, blankes;
	player_info_t *player;

	//
	// Serverdata
	// Send the info about the new client to all connected clients.
	//

	// Init a buffer that we write to before writing to the file.
	SZ_Init (&buf, (byte *) buf_data, sizeof(buf_data));

	//
	// Send the serverdata.
	//
	CL_WriteServerdata (&buf);

	// Send music.
	MSG_WriteByte (&buf, svc_cdtrack);
	MSG_WriteByte (&buf, 0); // None in demos

	// Send server info string.
	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, va("fullserverinfo \"%s\"\n", cl.serverinfo));

	// Flush the buffer to the demo file and then clear it.
	CL_WriteStartupDemoMessage (&buf, seq++);
	SZ_Clear (&buf);

	//
	// Write the soundlist.
	//
	MSG_WriteByte (&buf, svc_soundlist);
	MSG_WriteByte (&buf, 0);

	// Loop through all sounds and write them to the demo.
	n = 0;
	s = cl.sound_name[n + 1];
	while (*s)
	{
		// Write the sound name to the buffer.
		MSG_WriteString (&buf, s);

		// If the buffer is half full, flush it.
		if (buf.cursize > MAX_MSGLEN / 2)
		{
			// End of the partial sound list.
			MSG_WriteByte (&buf, 0);

			// Write how many sounds we've listed so far.
			MSG_WriteByte (&buf, n);

			// Flush the buffer to the demo file and clear the buffer.
			CL_WriteStartupDemoMessage (&buf, seq++);
			SZ_Clear (&buf);

			// Start on a new sound list and continue writing the
			// remaining sounds.
			MSG_WriteByte (&buf, svc_soundlist);
			MSG_WriteByte (&buf, n + 1);
		}

		n++;
		s = cl.sound_name[n+1];
	}

	// If the buffer isn't empty flush and clear it.
	if (buf.cursize)
	{
		MSG_WriteByte (&buf, 0);
		MSG_WriteByte (&buf, 0);
		CL_WriteStartupDemoMessage (&buf, seq++);
		SZ_Clear (&buf);
	}

	// Vwep modellist
	if (cl.vwep_enabled && cl.vw_model_name[0][0]) 
	{
		// Send VWep precaches
		// pray we don't overflow
		char ss[1024] = "//vwep ";
		for (i = 0; i < MAX_VWEP_MODELS; i++) {
			s = cl.vw_model_name[i];
			if (!*s)
				break;
			if (i > 0)
				strlcat (ss, " ", sizeof(ss));
			strlcat (ss, TrimModelName(s), sizeof(ss));
		}
		strlcat (ss, "\n", sizeof(ss));
		if (strlen(ss) < sizeof(ss)-1)		// Didn't overflow?
		{
			MSG_WriteByte (&buf, svc_stufftext);
			MSG_WriteString (&buf, ss);
		}
	}
	// Don't bother flushing, the vwep list is not that large (I hope).

	//
	// Modellist.
	//
	MSG_WriteByte (&buf, svc_modellist);
	MSG_WriteByte (&buf, 0);

	// Loop through the models
	n = 0;
	s = cl.model_name[n + 1];
	while (*s)
	{
		// Write the model name to the buffer.
		MSG_WriteString (&buf, s);

		// If the buffer is half full, flush it.
		if (buf.cursize	> MAX_MSGLEN / 2)
		{
			// End of partial model list.
			MSG_WriteByte (&buf, 0);

			// Write how many models we've written so far.
			MSG_WriteByte (&buf, n);

			// Flush the model list to the demo file and clear the buffer.
			CL_WriteStartupDemoMessage (&buf, seq++);
			SZ_Clear (&buf);

			// Start on a new partial model list and continue.
			MSG_WriteByte (&buf, svc_modellist);
			MSG_WriteByte (&buf, n + 1);
		}
		n++;
		s = cl.model_name[n + 1];
	}

	// Flush the buffer if it's not empty.
	if (buf.cursize)
	{
		MSG_WriteByte (&buf, 0);
		MSG_WriteByte (&buf, 0);
		CL_WriteStartupDemoMessage (&buf, seq++);
		SZ_Clear (&buf);
	}

	//
	// Write static entities.
	//
	for (i = 0; i < cl.num_statics; i++)
	{
		// Get the next static entity.
		ent = cl_static_entities + i;

		// Write ID for static entities.
		MSG_WriteByte (&buf, svc_spawnstatic);

		// Find if the model is precached or not.
		for (j = 1; j < MAX_MODELS; j++)
		{
			if (ent->model == cl.model_precache[j])
				break;
		}

		// Write if the model is precached.
		if (j == MAX_MODELS)
			MSG_WriteByte (&buf, 0);
		else
			MSG_WriteByte (&buf, j);

		// Write the entities frame and skin number.
		MSG_WriteByte (&buf, ent->frame);
		MSG_WriteByte (&buf, 0);
		MSG_WriteByte (&buf, ent->skinnum);

		// Write the coordinate and angles.
		for (j = 0; j < 3; j++)
		{
			MSG_WriteCoord (&buf, ent->origin[j]);
			MSG_WriteAngle (&buf, ent->angles[j]);
		}

		// Flush the buffer if it's half full.
		if (buf.cursize > MAX_MSGLEN / 2)
		{
			CL_WriteStartupDemoMessage (&buf, seq++);
			SZ_Clear (&buf);
		}
	}

	// spawnstaticsound
	for (i = 0; i < cl.num_static_sounds; i++) 
	{
		static_sound_t *ss = &cl.static_sounds[i];
		MSG_WriteByte (&buf, svc_spawnstaticsound);
		for (j = 0; j < 3; j++)
			MSG_WriteCoord (&buf, ss->org[j]);
		MSG_WriteByte (&buf, ss->sound_num);
		MSG_WriteByte (&buf, ss->vol);
		MSG_WriteByte (&buf, ss->atten);

		if (buf.cursize > MAX_MSGLEN/2) 
		{
			CL_WriteStartupDemoMessage (&buf, seq++);
			SZ_Clear (&buf);
		}
	}

	//
	// Write entity baselines.
	//
	memset(&blankes, 0, sizeof(blankes));
	for (i = 0; i < CL_MAX_EDICTS; i++)
	{
		es = &cl_entities[i].baseline;

		//
		// If the entity state isn't blank write it to the buffer.
		//
		if (memcmp(es, &blankes, sizeof(blankes)))
		{
			// Write ID.
			MSG_WriteByte (&buf, svc_spawnbaseline);
			MSG_WriteShort (&buf, i);

			// Write model info.
			MSG_WriteByte (&buf, es->modelindex);
			MSG_WriteByte (&buf, es->frame);
			MSG_WriteByte (&buf, es->colormap);
			MSG_WriteByte (&buf, es->skinnum);

			// Write coordinates and angles.
			for (j = 0; j < 3; j++)
			{
				MSG_WriteCoord(&buf, es->origin[j]);
				MSG_WriteAngle(&buf, es->angles[j]);
			}

			// Flush to demo file if buffer is half full.
			if (buf.cursize > MAX_MSGLEN / 2)
			{
				CL_WriteStartupDemoMessage (&buf, seq++);
				SZ_Clear (&buf);
			}
		}
	}

	// Write spawn information into the clients console buffer.
	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, va("cmd spawn %i 0\n", cl.servercount));

	// Flush buffer to demo file.
	if (buf.cursize)
	{
		CL_WriteStartupDemoMessage (&buf, seq++);
		SZ_Clear (&buf);
	}

	//
	// Send current status of all other players.
	//
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		player = cl.players + i;

		// Frags.
		MSG_WriteByte (&buf, svc_updatefrags);
		MSG_WriteByte (&buf, i);
		MSG_WriteShort (&buf, player->frags);

		// Ping.
		MSG_WriteByte (&buf, svc_updateping);
		MSG_WriteByte (&buf, i);
		MSG_WriteShort (&buf, player->ping);

		// Packet loss.
		MSG_WriteByte (&buf, svc_updatepl);
		MSG_WriteByte (&buf, i);
		MSG_WriteByte (&buf, player->pl);

		// Entertime.
		MSG_WriteByte (&buf, svc_updateentertime);
		MSG_WriteByte (&buf, i);
		MSG_WriteFloat (&buf, cls.realtime - player->entertime);

		// User ID and user info.
		MSG_WriteByte (&buf, svc_updateuserinfo);
		MSG_WriteByte (&buf, i);
		MSG_WriteLong (&buf, player->userid);
		MSG_WriteString (&buf, player->userinfo);

		// Flush buffer to demo file.
		if (buf.cursize > MAX_MSGLEN / 2)
		{
			CL_WriteStartupDemoMessage (&buf, seq++);
			SZ_Clear (&buf);
		}
	}

	// Send all current light styles.
	for (i = 0; i < MAX_LIGHTSTYLES; i++)
	{
		// Don't send empty lightstyle strings.
		if (!cl_lightstyle[i].length)
			continue;

		MSG_WriteByte (&buf, svc_lightstyle);
		MSG_WriteByte (&buf, (char)i);
		MSG_WriteString (&buf, cl_lightstyle[i].map);
	}

	for (i = 0; i < MAX_CL_STATS; i++)
	{
		// No need to send zero values.
		if (!cl.stats[i])
			continue;

		// Write the current players user stats.
		if (cl.stats[i] >= 0 && cl.stats[i] <= 255)
		{
			MSG_WriteByte (&buf, svc_updatestat);
			MSG_WriteByte (&buf, i);
			MSG_WriteByte (&buf, cl.stats[i]);
		}
		else
		{
			MSG_WriteByte (&buf, svc_updatestatlong);
			MSG_WriteByte (&buf, i);
			MSG_WriteLong (&buf, cl.stats[i]);
		}

		// Flush buffer to demo file.
		if (buf.cursize > MAX_MSGLEN / 2)
		{
			CL_WriteStartupDemoMessage (&buf, seq++);
			SZ_Clear (&buf);
		}
	}

	// Get the client to check and download skins
	// when that is completed, a begin command will be issued.
	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, va("skins\n"));

	CL_WriteStartupDemoMessage (&buf, seq++);

	CL_WriteSetDemoMessage();

	for (i = 0; i < sizeof(cl.frames) / sizeof(cl.frames[0]); ++i) {
		cl.frames[i].in_qwd = false;
	}
}

//=========================================================
// MVD demo writing
//=========================================================

static FILE *mvdrecordfile = NULL;
static char mvddemoname[2 * MAX_OSPATH] = {0};

static void CL_MVD_DemoWrite (void *data, int len)
{
	if (!mvdrecordfile)
		return;

	fwrite(data, len, 1, mvdrecordfile);
}

// ====================
// CL_WriteRecordMVDMessage
// ====================
static void CL_WriteRecordMVDMessage (sizebuf_t *msg)
{
	int len;
	byte c;

	if (!cls.mvdrecording)
		return;

	if (!msg->cursize)
		return;

	c = 0;
	CL_MVD_DemoWrite (&c, sizeof(c));

	c = dem_all;
	CL_MVD_DemoWrite (&c, sizeof(c));

	len = LittleLong (msg->cursize);
	CL_MVD_DemoWrite (&len, 4);

	CL_MVD_DemoWrite (msg->data, msg->cursize);
}

// ====================
// CL_WriteRecordMVDStatsMessage
// ====================
static void CL_WriteRecordMVDStatsMessage (sizebuf_t *msg, int client)
{
	int len;
	byte c;

	if (!cls.mvdrecording)
		return;

	if (!msg->cursize)
		return;

	if (client < 0 || client >= MAX_CLIENTS)
		return;

	c = 0;
	CL_MVD_DemoWrite (&c, sizeof(c));

	c = dem_stats | (client << 3) ; // msg "type" and "to" incapsulated in one byte
	CL_MVD_DemoWrite (&c, sizeof(c));

	len = LittleLong (msg->cursize);
	CL_MVD_DemoWrite (&len, 4);

	CL_MVD_DemoWrite (msg->data, msg->cursize);
}

// TODO: Split this up?
void CL_WriteMVDStartupData(void)
{
	sizebuf_t	buf;
	unsigned char buf_data[MAX_MSGLEN * 4];
	player_info_t *player;
	entity_state_t *es, blankes;
	entity_t *ent;
	int i, j, n;
	char *s;

	// Serverdata
	// send the info about the new client to all connected clients
	SZ_Init (&buf, buf_data, sizeof(buf_data));

	// send the serverdata

	MSG_WriteByte (&buf, svc_serverdata);

	#ifdef PROTOCOL_VERSION_FTE
	if (cls.fteprotocolextensions)
	{
		MSG_WriteLong (&buf, PROTOCOL_VERSION_FTE);
		MSG_WriteLong (&buf, cls.fteprotocolextensions);
	}
	#endif // PROTOCOL_VERSION_FTE

	#ifdef PROTOCOL_VERSION_FTE2
	if (cls.fteprotocolextensions2)
	{
		MSG_WriteLong (&buf, PROTOCOL_VERSION_FTE2);
		MSG_WriteLong (&buf, cls.fteprotocolextensions2);
	}
	#endif // PROTOCOL_VERSION_FTE2

	MSG_WriteLong (&buf, PROTOCOL_VERSION);
	MSG_WriteLong (&buf, cl.servercount);

	//
	// Gamedir.
	//

	s = cls.gamedirfile; // FIXME: or do we need to take a look in serverinfo?
	if (!s[0])
		s = "qw"; // If empty use "qw" gamedir

	MSG_WriteString (&buf, s);

	MSG_WriteFloat (&buf, cls.demotime); // FIXME: not sure

	// Send full levelname.
	MSG_WriteString (&buf, cl.levelname);

	// Send the movevars.
	MSG_WriteFloat(&buf, movevars.gravity);
	MSG_WriteFloat(&buf, movevars.stopspeed);
	MSG_WriteFloat(&buf, movevars.maxspeed);
	MSG_WriteFloat(&buf, movevars.spectatormaxspeed);
	MSG_WriteFloat(&buf, movevars.accelerate);
	MSG_WriteFloat(&buf, movevars.airaccelerate);
	MSG_WriteFloat(&buf, movevars.wateraccelerate);
	MSG_WriteFloat(&buf, movevars.friction);
	MSG_WriteFloat(&buf, movevars.waterfriction);
	MSG_WriteFloat(&buf, movevars.entgravity);

	// Send music.
	MSG_WriteByte (&buf, svc_cdtrack);
	MSG_WriteByte (&buf, 0); // None in demos.

	// Send server info string.
	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, va("fullserverinfo \"%s\"\n", cl.serverinfo));

	// Flush packet.
	CL_WriteRecordMVDMessage (&buf);
	SZ_Clear (&buf);

	//
	// Soundlist.
	//
	MSG_WriteByte (&buf, svc_soundlist);
	MSG_WriteByte (&buf, 0);

	n = 0;
	s = cl.sound_name[n + 1];
	while (*s)
	{
		MSG_WriteString (&buf, s);
		if (buf.cursize > MAX_MSGLEN/2)
		{
			MSG_WriteByte (&buf, 0);
			MSG_WriteByte (&buf, n);
			CL_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
			MSG_WriteByte (&buf, svc_soundlist);
			MSG_WriteByte (&buf, n + 1);
		}
		n++;
		s = cl.sound_name[n + 1];
	}

	if (buf.cursize)
	{
		MSG_WriteByte (&buf, 0);
		MSG_WriteByte (&buf, 0);
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	//
	// Modellist.
	//
	MSG_WriteByte (&buf, svc_modellist);
	MSG_WriteByte (&buf, 0);

	n = 0;
	s = cl.model_name[n+1];
	while (*s)
	{
		MSG_WriteString (&buf, s);
		if (buf.cursize > MAX_MSGLEN/2)
		{
			MSG_WriteByte (&buf, 0);
			MSG_WriteByte (&buf, n);
			CL_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
			MSG_WriteByte (&buf, svc_modellist);
			MSG_WriteByte (&buf, n + 1);
		}
		n++;
		s = cl.model_name[n+1];
	}

	if (buf.cursize)
	{
		MSG_WriteByte (&buf, 0);
		MSG_WriteByte (&buf, 0);
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	//
	// Write static entities.
	//
	for (i = 0; i < cl.num_statics; i++)
	{
		// Get the next static entity.
		ent = cl_static_entities + i;

		// Write ID for static entities.
		MSG_WriteByte (&buf, svc_spawnstatic);

		// Find if the model is precached or not.
		for (j = 1; j < MAX_MODELS; j++)
		{
			if (ent->model == cl.model_precache[j])
				break;
		}

		// Write if the model is precached.
		if (j == MAX_MODELS)
			MSG_WriteByte (&buf, 0);
		else
			MSG_WriteByte (&buf, j);

		// Write the entities frame and skin number.
		MSG_WriteByte (&buf, ent->frame);
		MSG_WriteByte (&buf, 0);
		MSG_WriteByte (&buf, ent->skinnum);

		// Write the coordinate and angles.
		for (j = 0; j < 3; j++)
		{
			MSG_WriteCoord (&buf, ent->origin[j]);
			MSG_WriteAngle (&buf, ent->angles[j]);
		}

		// Flush the buffer if it's half full.
		if (buf.cursize > MAX_MSGLEN / 2)
		{
			CL_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
		}
	}

	if (buf.cursize)
	{
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	//
	// Write static sounds
	//
	for (i = 0; i < cl.num_static_sounds; i++)
	{
		static_sound_t *ss = &cl.static_sounds[i];

		MSG_WriteByte (&buf, svc_spawnstaticsound);

		for (j = 0; j < 3; j++)
			MSG_WriteCoord (&buf, ss->org[j]);

		MSG_WriteByte (&buf, ss->sound_num);
		MSG_WriteByte (&buf, ss->vol);
		MSG_WriteByte (&buf, ss->atten);

		if (buf.cursize > MAX_MSGLEN/2)
		{
			CL_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
		}
	}

	if (buf.cursize)
	{
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	//
	// Write entity baselines.
	//
	memset(&blankes, 0, sizeof(blankes));

	for (i = 0; i < CL_MAX_EDICTS; i++)
	{
		es = &cl_entities[i].baseline;

		//
		// If the entity state isn't blank write it to the buffer.
		//
		if (memcmp(es, &blankes, sizeof(blankes)))
		{
			// Write ID.
			MSG_WriteByte (&buf, svc_spawnbaseline);
			MSG_WriteShort (&buf, i);

			// Write model info.
			MSG_WriteByte (&buf, es->modelindex);
			MSG_WriteByte (&buf, es->frame);
			MSG_WriteByte (&buf, es->colormap);
			MSG_WriteByte (&buf, es->skinnum);

			// Write coordinates and angles.
			for (j = 0; j < 3; j++)
			{
				MSG_WriteCoord(&buf, es->origin[j]);
				MSG_WriteAngle(&buf, es->angles[j]);
			}

			// Flush to demo file if buffer is half full.
			if (buf.cursize > MAX_MSGLEN / 2)
			{
				CL_WriteRecordMVDMessage (&buf);
				SZ_Clear (&buf);
			}
		}
	}

	if (buf.cursize)
	{
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	//
	// Send all current light styles.
	//
	for (i = 0; i < MAX_LIGHTSTYLES; i++)
	{
		// Don't send empty lightstyle strings.
		if (!cl_lightstyle[i].length)
			continue;

		MSG_WriteByte (&buf, svc_lightstyle);
		MSG_WriteByte (&buf, (char)i);
		MSG_WriteString (&buf, cl_lightstyle[i].map);

		// Flush to demo file if buffer is half full.
		if (buf.cursize > MAX_MSGLEN / 2)
		{
			CL_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
		}
	}

	if (buf.cursize)
	{
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, va("cmd spawn %i 0\n", cl.servercount));

	if (buf.cursize)
	{
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	//
	// Send current status of all other players: frags, ping, pl, enter time, userinfo, player id.
	//
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		player = cl.players + i;

		// Do NOT ignore spectators here, since we need at least userinfo.

		// Frags.
		MSG_WriteByte (&buf, svc_updatefrags);
		MSG_WriteByte (&buf, i);
		MSG_WriteShort (&buf, player->frags);

		// Ping.
		MSG_WriteByte (&buf, svc_updateping);
		MSG_WriteByte (&buf, i);
		MSG_WriteShort (&buf, player->ping);

		// Packet loss.
		MSG_WriteByte (&buf, svc_updatepl);
		MSG_WriteByte (&buf, i);
		MSG_WriteByte (&buf, player->pl);

		// Entertime.
		MSG_WriteByte (&buf, svc_updateentertime);
		MSG_WriteByte (&buf, i);
		MSG_WriteFloat (&buf, cls.realtime - player->entertime);

		// User ID and user info.
		MSG_WriteByte (&buf, svc_updateuserinfo);
		MSG_WriteByte (&buf, i);
		MSG_WriteLong (&buf, player->userid);
		MSG_WriteString (&buf, player->userinfo);

		// Flush buffer to demo file.
		if (buf.cursize > MAX_MSGLEN / 2)
		{
			CL_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
		}
	}

	if (buf.cursize)
	{
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	//
	// This set proper model, origin, angles etc for players.
	//
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		vec3_t origin, angles;
		int j, flags;
		player_state_t *state;

		player = cl.players + i;

		state = cl.frames[cl.validsequence & UPDATE_MASK].playerstate + i;

		if (!player->name[0])
			continue;

		if (player->spectator)
			continue; // Ignore spectators.

		flags =   (DF_ORIGIN << 0) | (DF_ORIGIN << 1) | (DF_ORIGIN << 2)
				| (DF_ANGLES << 0) | (DF_ANGLES << 1) | (DF_ANGLES << 2)
				| DF_EFFECTS | DF_SKINNUM 
				| ((state->flags & PF_DEAD) ? DF_DEAD : 0)
				| ((state->flags & PF_GIB)  ? DF_GIB  : 0)
				| DF_WEAPONFRAME | DF_MODEL;

		VectorCopy(state->origin, origin);
		VectorCopy(state->viewangles, angles);

		MSG_WriteByte (&buf, svc_playerinfo);
		MSG_WriteByte (&buf, i);
		MSG_WriteShort (&buf, flags);

		MSG_WriteByte (&buf, state->frame);

		for (j = 0 ; j < 3 ; j++)
			if (flags & (DF_ORIGIN << j))
				MSG_WriteCoord (&buf, origin[j]);

		for (j = 0 ; j < 3 ; j++)
			if (flags & (DF_ANGLES << j))
				MSG_WriteAngle16 (&buf, angles[j]);

		if (flags & DF_MODEL)
			MSG_WriteByte (&buf, state->modelindex);

		if (flags & DF_SKINNUM)
			MSG_WriteByte (&buf, state->skinnum);

		if (flags & DF_EFFECTS)
			MSG_WriteByte (&buf, state->effects);

		if (flags & DF_WEAPONFRAME)
			MSG_WriteByte (&buf, state->weaponframe);

		if (buf.cursize > MAX_MSGLEN/2)
		{
			CL_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
		}
	}

	// we really need clear buffer before sending stats
	if (buf.cursize)
	{
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	// send stats
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		int		*stats;
		int		j;

		player = cl.players + i;

		if (!player->name[0])
			continue;

		if (player->spectator)
			continue; // Ignore spectators.

		stats = cl.players[i].stats;

		for (j = 0; j < MAX_CL_STATS; j++)
		{
			if (stats[j] >= 0 && stats[j] <= 255)
			{
				MSG_WriteByte(&buf, svc_updatestat);
				MSG_WriteByte(&buf, j);
				MSG_WriteByte(&buf, stats[j]);
			}
			else
			{
				MSG_WriteByte(&buf, svc_updatestatlong);
				MSG_WriteByte(&buf, j);
				MSG_WriteLong(&buf, stats[j]);
			}
		}

		if (buf.cursize)
		{
			CL_WriteRecordMVDStatsMessage(&buf, i);
			SZ_Clear (&buf);
		}
	}

	// Above stats writing must clear buffer.
	if (buf.cursize)
	{
		Sys_Error("CL_WriteMVDStartupData: buf.cursize %d", buf.cursize);
	}

	// 
	// Send packetentities.
	//
	{
		int ent_index, ent_total;
		entity_state_t *ent_state;

		// Write the ID byte for a delta entity operation to the demo.
		MSG_WriteByte (&buf, svc_packetentities);

		// Get the entities list from the frame.
		ent_state = cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].packet_entities.entities;
		ent_total = cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].packet_entities.num_entities;

		// Write all the entity changes since last packet entity message.
		for (ent_index = 0; ent_index < ent_total; ent_index++, ent_state++) {
			MSG_WriteDeltaEntity(&cl_entities[ent_state->number].baseline, ent_state, &buf, true, cls.fteprotocolextensions, cls.mvdprotocolextensions1);
		}

		// End of packetentities.
		MSG_WriteShort (&buf, 0);
	}

	if (buf.cursize)
	{
		CL_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	// Get the client to check and download skins
	// when that is completed, a begin command will be issued.
	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, "skins\n");

	CL_WriteRecordMVDMessage (&buf);
}

// ==============
// Commands
// ==============

void CL_StopMvd_f(void)
{
	if (!cls.mvdrecording && !mvdrecordfile)
	{
		Com_Printf ("Not recording a demo\n");
		return;
	}

	if (mvdrecordfile)
	{
		sizebuf_t	buf;
		unsigned char buf_data[MAX_MSGLEN];

		SZ_Init (&buf, buf_data, sizeof(buf_data));

		// Print offensive message.
#ifdef EZ_MVD_SIGNOFF
		MSG_WriteByte(&buf, svc_print);
		MSG_WriteByte(&buf, 2);
		MSG_WriteString(&buf, EZ_MVD_SIGNOFF);
#endif

		// Add disconnect.
		MSG_WriteByte (&buf, svc_disconnect);
		MSG_WriteString (&buf, "EndOfDemo");

		CL_WriteRecordMVDMessage (&buf);

		fclose(mvdrecordfile);
		mvdrecordfile = NULL;

		Com_Printf ("Completed demo\n");
	}
	else
	{
		Com_Printf ("BUG: Demo alredy completed or something\n");
	}

	cls.mvdrecording = false;
}

void CL_RecordMvd_f(void)
{
	char nameext[MAX_OSPATH * 2], name[MAX_OSPATH * 2];

	switch(Cmd_Argc())
	{
		case 1:
		//
		// Just show if anything is being recorded.
		//
		{
			if (cls.mvdrecording)
				Com_Printf("Recording to %s\n", mvddemoname);
			else
				Com_Printf("Not recording\n");
			break;
		}
		case 2:
		//
		// Start recording to the specified demo name.
		//
		{
			if (cls.state != ca_active && cls.state != ca_disconnected)
			{
				Com_Printf ("Cannot record whilst connecting\n");
				return;
			}

			// Stop any recording in progress.
			if (cls.mvdrecording)
				CL_StopMvd_f();

			// Make sure the filename doesn't contain any invalid characters.
			if (!Util_Is_Valid_Filename(Cmd_Argv(1)))
			{
				Com_Printf(Util_Invalid_Filename_Msg(Cmd_Argv(1)));
				return;
			}

			// Open the demo file for writing.
			strlcpy(nameext, Cmd_Argv(1), sizeof(nameext));
			COM_ForceExtensionEx (nameext, ".mvd", sizeof (nameext));

			// Get the path for the demo and try opening the file for writing.
			snprintf (name, sizeof(name), "%s/%s", CL_DemoDirectory(), nameext);

			mvdrecordfile = fopen(name, "wb");

			if (!mvdrecordfile)
			{
				Com_Printf ("Error: Couldn't record to %s. Make sure path exists.\n", name);
				return;
			}

			// Demo starting has begun.
			cls.mvdrecording = true;

			// Save the demoname for later use.
			strlcpy(mvddemoname, name, sizeof(mvddemoname));

			// If we're active, write startup data right away.
			if (cls.state == ca_active)
				CL_WriteMVDStartupData();

			Com_Printf ("Recording to %s\n", nameext);
			break;
		}
		default:
		{
			Com_Printf("Usage: %s [demoname]\n", Cmd_Argv(0));
			break;
		}
	}
}

//=============================================================================
//								DEMO READING
//=============================================================================

//
// Inits the demo playback buffer.
// If we do QTV demo playback, we read data ahead while parsing QTV connection headers,
// so we may have demo data in qtvrequestbuffer[], so we move data from qtvrequestbuffer[] to pb_buf[] with this function.
//
void CL_Demo_PB_Init(void *buf, int buflen)
{
	// The length of the buffer is out of bounds.
	if (FSMMAP_IsMemoryMapped(playbackfile)) {
		stream_buffer_cnt = 0;
		stream_buffer_eof = false;
	}
	else {
		if (buflen < 0 || (size_t)buflen > sizeof(stream_buffer)) {
			Sys_Error("CL_Demo_PB_Init: buflen out of bounds.");
		}

		// Copy the specified init data into the playback buffer.
		memcpy(stream_buffer, buf, buflen);

		// Reset any associated playback buffers.
		stream_buffer_cnt = buflen;
		stream_buffer_eof = false;
	}
}

static int CL_StreamRead(void* buf, int size, qbool peek)
{
	int need = max(0, min(stream_buffer_cnt, size));
	memcpy(buf, stream_buffer, need);

	if (!peek) {
		// We are not peeking, so move along buffer.
		stream_buffer_cnt -= need;
		memmove(stream_buffer, stream_buffer + need, stream_buffer_cnt);

		// We get some data from playback file or qtv stream, dump it to file right now.
		if (need > 0 && cls.mvdplayback && cls.mvdrecording) {
			CL_MVD_DemoWrite(buf, need);
		}
	}

	return need;
}

//
// This is memory reading(not from file or socket), we just copy data from stream buffer to caller buffer,
// if we're not peeking we decrease move data along buffer so next packet is always at position 0
// If using a memory mapped file this is avoided and we just use standard READ/SEEK etc
//
int CL_Demo_Read(void *buf, int size, qbool peek)
{
	int need;

	// Size can't be negative.
	if (size < 0) {
		Host_Error("pb_read: size < 0");
	}

	if (FSMMAP_IsMemoryMapped(playbackfile)) {
		vfserrno_t err;
		unsigned long pos = VFS_TELL(playbackfile);

		need = VFS_READ(playbackfile, buf, size, &err);

		if (peek) {
			VFS_SEEK(playbackfile, pos, SEEK_SET);
		}
	}
	else {
		need = CL_StreamRead(buf, size, peek);
	}

	if (need != size) {
		Host_Error("Unexpected end of demo");
	}

	return need;
}

//
// Reads a chunk of data from the playback file and returns the number of bytes read.
//
static int pb_raw_read(void *buf, int size)
{
	if (playbackfile && FSMMAP_IsMemoryMapped(playbackfile)) {
		return VFS_GETLEN(playbackfile) - (int)VFS_TELL(playbackfile); // FIXME: _TELL is unsigned long but _GETLEN is int?
	}
	else {
		vfserrno_t err;
		int r = VFS_READ(playbackfile, buf, size, &err);

		// Size > 0 mean detect EOF only if we actually trying read some data.
		stream_buffer_eof |= (size > 0 && !r && err == VFSERR_EOF);

		return r;
	}
}

//
// Ensure we have enough data to parse, it not then return false.
// Function was introduced with QTV. If you read a demo from file and you run out of data
// that's critical, but when streaming an MVD using QTV and don't receive enough data from 
// the network it isn't critical, we just freeze the client for some time while filling
// the playback buffer.
//
qbool pb_ensure(void)
{
	// Try to fill the entire buffer with demo data.
	if (FSMMAP_IsMemoryMapped(playbackfile)) {
		return VFS_TELL(playbackfile) < VFS_GETLEN(playbackfile);
	}
	else {
		// Increase internal TCP buffer by faking a read to it.
		pb_raw_read(NULL, 0);

		// Show how much we've read.
		if (cl_shownet.value == 3) {
			Com_Printf(" %d", stream_buffer_cnt);
		}

		stream_buffer_cnt += pb_raw_read(stream_buffer + stream_buffer_cnt, max(0, (int)sizeof(stream_buffer) - stream_buffer_cnt));

		if (stream_buffer_cnt == (int)sizeof(stream_buffer) || stream_buffer_eof) {
			return true; // Return true if we have full buffer or get EOF.
		}

		// Probably not enough data in buffer, check do we have at least one message in buffer.
		if (cls.mvdplayback && stream_buffer_cnt) {
			// Only care if there's a single packet...
			if (ConsistantMVDData((unsigned char*)stream_buffer, stream_buffer_cnt, 1)) {
				return true;
			}
		}
	}

	// Set the buffering time if it hasn't been set already.
	if (cls.mvdplayback == QTV_PLAYBACK && !bufferingtime && !cls.qtv_donotbuffer)
	{
		double prebufferseconds = QTVPREBUFFERTIME;

		bufferingtime = Sys_DoubleTime() + prebufferseconds;

		if (developer.integer >= 2) {
			Com_DPrintf("&cF00" "qtv: not enough buffered, buffering for %.1fs\n" "&r", prebufferseconds); // print some annoying message
		}
	}

	return false;
}

//
// Peeks the demo time.
//
static double CL_PeekDemoTime(void)
{
	double demotime = 0.0;

	if (cls.mvdplayback)
	{
		byte mvd_time = 0; // Number of miliseconds since last frame. Can be between 0-255. MVD Only.

		// Peek inside, but don't read.
		// (Since it might not be time to continue reading in the demo
		// we want to be able to check this again later if that's the case).
		CL_Demo_Read(&mvd_time, sizeof(mvd_time), true);

		// Calculate the demo time.
		// (The time in an MVD is saved as a byte with number of miliseconds since the last cmd
		// so we need to multiply it by 0.001 to get it in seconds like normal quake time).
		demotime = cls.demopackettime + (mvd_time * 0.001);

		if ((cls.demotime - nextdemotime) > 0.001 && (nextdemotime != demotime))
		{
			olddemotime = nextdemotime;
			cls.netchan.incoming_sequence++;
			cls.netchan.incoming_acknowledged++;
			cls.netchan.frame_latency = 0;
			cls.netchan.last_received = cls.demotime; // Make timeout check happy.
			nextdemotime = demotime;
		}
	}
	else 
	{
		float floatTime;

		// Peek inside, but don't read.
		// (Since it might not be time to continue reading in the demo
		// we want to be able to check this again later if that's the case).
		CL_Demo_Read(&floatTime, sizeof(floatTime), true);
		demotime = LittleFloat(floatTime);

		if (demotime < cls.demotime)
		{
			olddemotime = nextdemotime;

			nextdemotime = demotime;
		}
	}

	return demotime;
}

//
// Consume the demo time.
//
static void CL_ConsumeDemoTime(void)
{
	if (cls.mvdplayback)
	{
		byte dummy_newtime;
		CL_Demo_Read(&dummy_newtime, sizeof(dummy_newtime), false);
	}
	else
	{
		float dummy_demotime;
		CL_Demo_Read(&dummy_demotime, sizeof(dummy_demotime), false);
	}
}

//
// Reads a dem_cmd message from an demo.
//
static void CL_DemoReadDemCmd(void)
{			
	// User cmd read.
	extern int cmdtime_msec;

	// Get which frame we should read the cmd into from the demo.
	int i = cls.netchan.outgoing_sequence & UPDATE_MASK;
	int s = cls.netchan.outgoing_sequence & NETWORK_STATS_MASK;
	int j;

	// Read the user cmd from the demo.
	usercmd_t *pcmd = &cl.frames[i].cmd;
	CL_Demo_Read(pcmd, sizeof(*pcmd), false);

	// Convert the angles/movement vectors into the correct byte order.
	for (j = 0; j < 3; j++)
		pcmd->angles[j] = LittleFloat(pcmd->angles[j]);
	pcmd->forwardmove = LittleShort(pcmd->forwardmove);
	pcmd->sidemove = LittleShort(pcmd->sidemove);
	pcmd->upmove = LittleShort(pcmd->upmove);
	cmdtime_msec += pcmd->msec;

	// Set the time time this cmd was sent and increase
	// how many net messages have been sent.
	cl.frames[i].senttime = cls.demopackettime;
	cl.frames[i].receivedtime = -1;		// We haven't gotten a reply yet.
	cl.frames[i].delta_sequence = cl.delta_sequence;
	network_stats[s].senttime = cls.realtime;
	network_stats[s].sentsize = sizeof(*pcmd) + 12; // complete lie, compared to the original
	cls.netchan.outgoing_sequence++;

	// Read the viewangles from the demo and convert them to correct byte order.
	CL_Demo_Read(cl.viewangles, 12, false);
	for (j = 0; j < 3; j++)
		cl.viewangles[j] = LittleFloat (cl.viewangles[j]);

	// Calculate the player fps based on the cmd.
	CL_CalcPlayerFPS(&cl.players[cl.playernum], pcmd->msec);

	// Try locking on to a player.
	if (cl.spectator)
		Cam_TryLock();

	// Write the demo to the record file if we're recording.
	if (cls.demorecording)
		CL_WriteDemoCmd(pcmd);
}

//
// Reads a dem_read message from a demo. Returns true if we should continue reading messages.
//
static qbool CL_DemoReadDemRead(void)
{
	// Read the size of next net message in the demo file
	// and convert it into the correct byte order.
	CL_Demo_Read(&net_message.cursize, 4, false);
	net_message.cursize = LittleLong(net_message.cursize);

	// The message was too big, stop playback.
	if (net_message.cursize > net_message.maxsize)
	{
		Com_DPrintf("CL_GetDemoMessage: net_message.cursize > net_message.maxsize");
		Host_EndGame();
		Host_Abort();
	}

	// Read the net message from the demo.
	CL_Demo_Read(net_message.data, net_message.cursize, false);

	// Skip over any dem_multiple packets sent to no-one
	if (cls.mvdplayback && cls.lasttype == dem_multiple && cls.lastto == 0) {
#ifdef MVD_PEXT1_HIDDEN_MESSAGES
		// Don't skip these if they're in parseable format
		if (cls.mvdprotocolextensions1 & MVD_PEXT1_HIDDEN_MESSAGES) {
			return false;
		}
#endif
		return true;
	}

	return false;
}

//
// Reads a dem_set message from a demo.
//
static void CL_DemoReadDemSet(void)
{
	int i;

	CL_Demo_Read(&i, sizeof(i), false);
	cls.netchan.outgoing_sequence = LittleLong(i);

	CL_Demo_Read(&i, sizeof(i), false);
	cls.netchan.incoming_sequence = LittleLong(i);

	if (cls.mvdplayback)
		cls.netchan.incoming_acknowledged = cls.netchan.incoming_sequence;
}

//
// Returns true if it's time to read the next message, false otherwise.
//
static qbool CL_DemoShouldWeReadNextMessage(double demotime)
{
	if (cls.timedemo)
	{
		// Timedemo playback, grab the next message as quickly as possible.

		if (cls.td_lastframe < 0)
		{
			// This is the first frame of the timedemo.
			cls.td_lastframe = demotime;
		}
		else if (demotime > cls.td_lastframe)
		{
			// We've already read this frame's message so skip it.
			cls.td_lastframe = demotime;
			return false;
		}

		// Did we just start the time demo?
		if (!cls.td_starttime && (cls.state == ca_active))
		{
			// Save the start time (real world time) and current frame number
			// so that we will know how long it took to go through it all
			// and calculate the framerate when it's done.
			cls.td_starttime = Sys_DoubleTime();
			cls.td_startframe = cls.framecount;
			R_TraceAPI("[timedemo] first-frame");
			key_dest = key_game;
		}

		if (cls.timedemo == TIMEDEMO_CLASSIC || (cls.state != ca_active)) {
			// Warp - will render as many frames as there are in the demo
			cl.gametime += (demotime - cls.demotime);
			cls.demotime = demotime;
		}
		else if (nextdemotime >= demotime) {
			// No warping, fixed fps
			return true;
		}
		else {
			return false;
		}
	}
	else if (!(cl.paused & PAUSED_SERVER) && (cls.state == ca_active)) // Always grab until fully connected.
	{
		// Not paused and active.

		if (cls.mvdplayback)
		{
			if (nextdemotime < demotime)
			{
				return false; // Don't need another message yet.
			}
		}
		else
		{
			if (cls.demotime < demotime)
			{
				// Don't need another message yet.

				// Adjust the demotime to match what's read from file.
				if (cls.demotime + 1.0 < demotime)
					cls.demotime = demotime - 1.0;

				return false;
			}
		}
	}
	else
	{
		cls.demotime = demotime; // We're warping.
	}

	return true;
}

//
// When a demo is playing back, all NET_SendMessages are skipped, and NET_GetMessages are read from the demo file.
// Whenever cl.time gets past the last received message, another message is read from the demo file.
//
// Summary:
//
// 1. MVD - Make sure we're not more than 1 second behind the next demo time.
// 2. Get the time of the next demo message by peeking at it.
// 3. Is it time to get the next demo message yet? (Always for timedemo) Return false if not.
// 4. Read the time of the next message from the demo (consume it).
// 5. MVD - Save the current time so we have it for the next frame
//    (we need it to calculate the demo time. Time in MVDs is saved
//     as the number of miliseconds since last frame).
// 6. Read the message type from the demo, only the first 3 bits are significant.
//    There are 3 basic message types used by all demos:
//    dem_set = Only appears once at start of demo. Contains sequence numbers for the netchan.
//    dem_cmd = A user movement cmd.
//    dem_Read = An arbitrary network message.
//
//    MVDs also use:
//    dem_multiple, dem_single, dem_stats and dem_all to direct certain messages to
//    specific clients only, and to update stats.
//
// 7. Parse the specific demo messages.
//
qbool CL_GetDemoMessage (void)
{
	double demotime;
	byte c;
	byte message_type;

	// Don't try to play while QWZ is being unpacked.
	if (qwz_unpacking) {
		return false;
	}

	// Demo paused, don't read anything.
	if (cl.paused & PAUSED_DEMO) {
		pb_ensure();	// Make sure we keep the QTV connection alive by reading from the socket.
		return false;
	}

	// We're not ready to parse since we're buffering for QTV.
	if (bufferingtime && (bufferingtime > Sys_DoubleTime())) {
		extern qbool	host_skipframe;

		pb_ensure();			// Fill the buffer for QTV.
		host_skipframe = true;	// This will force not update cls.demotime.

		return false;
	}

	bufferingtime = 0;

	// DEMO REWIND.
	if (!cls.mvdplayback || cls.mvdplayback != QTV_PLAYBACK) {
		CL_Demo_Check_For_Rewind(nextdemotime);
	}

	// Adjust the time for MVD playback.
	if (cls.mvdplayback)
	{
		// Reset the previous time.
		if (cls.demopackettime < nextdemotime) {
			cls.demopackettime = nextdemotime;
		}

		// Always be within one second from the next demo time.
		if (cls.demotime + 1.0 < nextdemotime) {
			cls.demotime = nextdemotime - 1.0;
		}
	}

	// Check if we need to get more messages for now and if so read it
	// from the demo file and pass it on to the net channel.
	while (true)
	{
		// Make sure we have enough data in the buffer.
		if (!pb_ensure()) {
 			return false;
		}

		// Read the time of the next message in the demo.
		demotime = CL_PeekDemoTime();

		// Keep gameclock up-to-date if we are seeking
		if (cls.demoseeking && demotime > cls.demopackettime) {
			cl.gametime += demotime - cls.demopackettime;
		}

		// Keep MVD features such as itemsclock up-to-date during seeking
		if (cls.demoseeking && cls.mvdplayback) {
			double tmp = cls.demotime;
			cls.demotime = demotime;
			MVD_Interpolate();
			MVD_Mainhook();
			cls.demotime = tmp;
		}

		if (cls.demoseeking == DST_SEEKING_STATUS) {
			CL_Demo_Jump_Status_Check();
		}

		// If we found demomark, we should stop seeking, so reset time to the proper value.
		if (cls.demoseeking == DST_SEEKING_FOUND || cls.demoseeking == DST_SEEKING_FOUND_NOREWIND) {
			cls.demotime = demotime; // this will trigger seeking stop

			if (cls.demoseeking == DST_SEEKING_FOUND_NOREWIND) {
				// Pause instead of rewinding
				Cvar_SetValue(&cl_demospeed, 0.0f);
			}
			else if (demo_jump_rewind.value < 0) {
				CL_Demo_Jump(-demo_jump_rewind.value, -1, DST_SEEKING_NORMAL);
				return false;
			}
		}

		// If we've reached our seek goal, stop seeking.
		if (cls.demoseeking && cls.demotime <= demotime && cls.state >= ca_active)
		{
			cls.demoseeking = DST_SEEKING_NONE;

			if (cls.demorewinding)
			{
				CL_Demo_Stop_Rewinding();
			}
		}

		playback_recordtime = demotime;

		// Decide if it is time to grab the next message from the demo yet.
		if (!CL_DemoShouldWeReadNextMessage(demotime)) {
			return false;
		}
		
		// Read the time from the packet (we peaked at it earlier),
		// we're ready to get the next message.
		CL_ConsumeDemoTime();

		// Save the previous time for MVD playback (for the next message),
		// it is needed to calculate the demotime since in mvd's the time is
		// saved as the number of miliseconds since last frame message.
		// This is also used when seeking in qwds to keep the gameclock in time.
		cls.demopackettime = demotime;

		// Get the msg type.
		CL_Demo_Read(&c, sizeof(c), false);
		message_type = (c & 7);

		// QWD Only.
		if (message_type == dem_cmd)
		{
			CL_DemoReadDemCmd();
			
			continue; // Get next message.
		}

		// MVD Only. These message types tells to which players the message is directed to.
		if ((message_type >= dem_multiple) && (message_type <= dem_all))
		{
			switch (message_type)
			{
				case dem_multiple:
				//
				// This message should be sent to more than one player, get which players.
				//
				{
					// Read the player bit mask from the demo and convert to the correct byte order.
					// Each bit in this number represents a player, 32-bits, 32 players.
					int i;
					CL_Demo_Read(&i, 4, false);
					cls.lastto = LittleLong(i);
					cls.lasttype = dem_multiple;
					break;
				}
				case dem_stats:
				//
				// The stats for a player has changed. Get the player number of that player.
				//
				case dem_single:
				//
				// Only a single player should receive this message. Get the player number of that player.
				//
				{
					// The first 3 bits contain the message type (so remove that part), the rest contains
					// a 5-bit number which contains the player number of the affected player.
					cls.lastto = (c >> 3);
					cls.lasttype = message_type;
					break;
				}
				case dem_all:
				//
				// This message is directed to all players.
				//
				{
					cls.lastto = 0;
					cls.lasttype = dem_all;
					break;
				}
				default:
				{
					Host_Error("This can't happen (unknown command type) %c.\n", message_type);
				}
			}

			// Fall through to dem_read after we've gotten the affected players.
			message_type = dem_read;
		}

		// Get the next net message from the demo file.
		if (message_type == dem_read)
		{
			if (CL_DemoReadDemRead())
			{
				continue; // Continue reading messages.
			}
			
			return true; // We just read something.
		}

		// Gets the sequence numbers for the netchan at the start of the demo.
		if (message_type == dem_set)
		{
			CL_DemoReadDemSet();
			
			continue;
		}

		// We should never get this far if the demo is ok.
		Host_Error("Corrupted demo");
		return false;
	}
}

//=============================================================================
//								DEMO RECORDING
//=============================================================================

static char demoname[2 * MAX_OSPATH];
static char fulldemoname[MAX_PATH];
static qbool autorecording = false;
static qbool easyrecording = false;

void CL_AutoRecord_StopMatch(void);
void CL_AutoRecord_CancelMatch(void);

static void OnChange_demo_dir(cvar_t *var, char *string, qbool *cancel)
{
	if (!string[0])
		return;

	// Replace \ with /.
	Util_Process_FilenameEx(string, cl_mediaroot.integer == 2);

	// Make sure the filename doesn't have any invalid chars in it.
	if (!Util_Is_Valid_FilenameEx(string, cl_mediaroot.integer == 2))
	{
		Com_Printf(Util_Invalid_Filename_Msg(var->name));
		*cancel = true;
		return;
	}

	// Change to the new folder in the demo browser.
	if (cl_mediaroot.integer == 2) {
		Menu_Demo_NewHome(string);
	}
	else {
		char buf[MAX_OSPATH];

		strlcpy(buf, com_basedir, sizeof(buf));
		strlcat(buf, "/", sizeof(buf));
		strlcat(buf, string, sizeof(buf));

		Menu_Demo_NewHome(buf);
	}
}

static void OnChange_demo_format(cvar_t *var, char *string, qbool *cancel)
{
	char* allowed_formats[5] = { "qwd", "qwz", "mvd", "mvd.gz", "qwd.gz" };
	int i;

	for (i = 0; i < 5; i++)
		if (!strcmp(allowed_formats[i], string))
			return;

	Com_Printf("Not valid demo format. Allowed values are: ");
	for (i = 0; i < 5; i++)
	{
		if (i)
			Com_Printf(", ");
		Com_Printf(allowed_formats[i]);
	}
	Com_Printf(".\n");

	*cancel = true;
}

//
// Writes a "pimp message" for ezQuake at the end of a demo.
//
static void CL_WriteDemoPimpMessage(void)
{
	if (cls.demoplayback) {
		return;
	}

	SZ_Clear(&net_message);
	MSG_WriteLong(&net_message, cls.netchan.incoming_sequence + 1);
	MSG_WriteLong(&net_message, cls.netchan.incoming_acknowledged | (cls.netchan.incoming_reliable_acknowledged << 31));
	MSG_WriteByte(&net_message, svc_print);
	MSG_WriteByte(&net_message, PRINT_HIGH);
	MSG_WriteString(&net_message, EZ_QWD_SIGNOFF);
	CL_WriteDemoMessage(&net_message);
}

//
// Stop recording a demo.
//
static void CL_StopRecording (void)
{
	// Nothing to stop.
	if (!cls.demorecording)
		return;

	// Write a pimp message to the demo.
	CL_WriteDemoPimpMessage();

	// Write a disconnect message to the demo file.
	SZ_Clear (&net_message);
	MSG_WriteLong (&net_message, -1);	// -1 sequence means out of band
	MSG_WriteByte (&net_message, svc_disconnect);
	MSG_WriteString (&net_message, "EndOfDemo");
	CL_WriteDemoMessage (&net_message);

	// Finish up by closing the demo file.
	CL_Demo_Close();
	cls.demorecording = false;
}

//
// Stop recording a demo.
//
void CL_Stop_f (void)
{
#ifndef CLIENTONLY
	if (com_serveractive && strcmp(Cmd_Argv(0), "stop") == 0)
	{
		SV_MVDStop_f();
		return;
	}
#endif

	if (cls.mvdplayback && cls.mvdrecording) {
		CL_StopMvd_f();
		return;
	}

	if (!cls.demorecording)
	{
		Com_Printf ("Not recording a demo\n");
		return;
	}
	if (autorecording)
	{
		CL_AutoRecord_StopMatch();
	}
	else if (easyrecording)
	{
		CL_StopRecording();
		CL_Demo_Compress(fulldemoname);
		easyrecording = false;
	}
	else
	{
		CL_StopRecording();
		Com_Printf ("Completed demo\n");
	}
}

//
// Returns the Demo directory. If the user hasn't set the demo_dir var, the gamedir is returned.
//
extern char *CL_DemoDirectory(void)
{
	static char dir[MAX_PATH];

	strlcpy(dir, FS_LegacyDir(demo_dir.string), sizeof(dir));
	return dir;
}

//
// Start recording a demo.
//
void CL_Record_f (void)
{
	char nameext[MAX_OSPATH * 2], name[MAX_OSPATH * 2];

#ifndef CLIENTONLY
	if (com_serveractive && strcmp(Cmd_Argv(0), "record") == 0)
	{
		SV_MVD_Record_f();
		return;
	}
#endif

	if (cls.mvdplayback) {
		CL_RecordMvd_f();
		return;
	}

#if defined(PROTOCOL_VERSION_FTE) || defined(PROTOCOL_VERSION_FTE2)
	if (cls.fteprotocolextensions &~ (FTE_PEXT_CHUNKEDDOWNLOADS|FTE_PEXT_256PACKETENTITIES))
	{
		extern cvar_t cl_pext_warndemos;

		if (cl_pext_warndemos.value) {
			Com_Printf("WARNING: FTE protocol extensions enabled; this demo most likely will be unplayable in older clients. "
				"Use cl_pext 0 for 100%% compatible demos. But do NOT forget set it to 1 later or you will lack useful features!\n");
		}
	}
#endif

	switch(Cmd_Argc())
	{
		case 1:
		//
		// Just show if anything is being recorded.
		//
		{
			if (autorecording)
				Com_Printf("Auto demo recording is in progress\n");
			else if (cls.demorecording)
				Com_Printf("Recording to %s\n", demoname);
			else
				Com_Printf("Not recording\n");
			break;
		}
		case 2:
		//
		// Start recording to the specified demo name.
		//
		{
			if (cls.state != ca_active && cls.state != ca_disconnected)
			{
				Com_Printf ("Cannot record whilst connecting\n");
				return;
			}

			if (autorecording)
			{
				Com_Printf("Auto demo recording must be stopped first!\n");
				return;
			}

			// Stop any recording in progress.
			if (cls.demorecording) {
				CL_Stop_f();
			}

			// Make sure the filename doesn't contain any invalid characters.
			if (!Util_Is_Valid_Filename(Cmd_Argv(1)))
			{
				Com_Printf(Util_Invalid_Filename_Msg(Cmd_Argv(1)));
				return;
			}

			// Open the demo file for writing.
			strlcpy(nameext, Cmd_Argv(1), sizeof(nameext));
			COM_ForceExtensionEx (nameext, ".qwd", sizeof (nameext));

			// Get the path for the demo and try opening the file for writing.
			snprintf (name, sizeof(name), "%s/%s", CL_DemoDirectory(), nameext);
			if (!CL_Demo_Open(name))
			{
				Com_Printf ("Error: Couldn't record to %s. Make sure path exists.\n", name);
				return;
			}

			// Demo starting has begun.
			cls.demorecording = true;

			// If we're active, write startup data right away.
			if (cls.state == ca_active) {
				CL_WriteStartupData();
			}

			// Save the demoname for later use.
			strlcpy(demoname, nameext, sizeof(demoname));

			Com_Printf ("Recording to %s\n", nameext);

			break;
		}
		default:
		{
			Com_Printf("Usage: %s [demoname]\n", Cmd_Argv(0));
			break;
		}
	}
}

//
// Starts recording a demo using autorecord or easyrecord.
//
static qbool CL_MatchRecordDemo(char *dir, char *name, qbool autorecord)
{
	char extendedname[MAX_PATH];
	char strippedname[MAX_PATH];
	char *fullname;
	char *exts[] = {"qwd", "qwz", "mvd", NULL};
	int num;

	if (cls.state != ca_active)
	{
		Com_Printf ("You must be connected before using easyrecord\n");
		return false;
	}

	if (cls.mvdplayback)
	{
		Com_Printf ("Cannot record during mvd playback\n");
		return false;
	}

	if (autorecording)
	{
		Com_Printf("Auto demo recording must be stopped first!\n");
		return false;
	}

	// Stop any old recordings.
	if (cls.demorecording)
		CL_Stop_f();

	// Make sure we don't have any invalid chars in the demo name.
	if (!Util_Is_Valid_Filename(name))
	{
		Com_Printf(Util_Invalid_Filename_Msg(name));
		return false;
	}

	// We always record to qwd. If the user has set some other demo format
	// we convert to that later on.
	COM_ForceExtension(name, ".qwd");

	if (autorecord)
	{
		// Save the final demo name.
		strlcpy (extendedname, name, sizeof(extendedname));
	}
	else
	{
		//
		// Easy recording, file is saved using match_* settings.
		//

		// Get rid of the extension again.
		COM_StripExtension(name, strippedname, sizeof(strippedname));
		fullname = va("%s/%s", dir, strippedname);

		// Find a unique filename in the specified dir.
		if ((num = Util_Extend_Filename(fullname, exts)) == -1)
		{
			Com_Printf("Error: no available filenames\n");
			return false;
		}

		// Save the demo name..
		snprintf (extendedname, sizeof(extendedname), "%s_%03i.qwd", strippedname, num);
	}

	// Get dir + final demo name.
	fullname = va("%s/%s", dir, extendedname);

	// Open the demo file for writing.
	if (!CL_Demo_Open(fullname))
	{
		// Failed to open the file, make sure it exists and try again.
		FS_CreatePath(fullname);
		if (!CL_Demo_Open(fullname))
		{
			Com_Printf("Error: Couldn't open %s\n", fullname);
			return false;
		}
	}

	// Write the demo startup stuff.
	cls.demorecording = true;
	CL_WriteStartupData ();

	// Echo the name of the demo if we're easy recording
	// and save the demo name for later use.
	if (!autorecord)
	{
		Com_Printf ("Recording to %s\n", extendedname);
		strlcpy(demoname, extendedname, sizeof(demoname));		// Just demo name.
		strlcpy(fulldemoname, fullname, sizeof(fulldemoname));  // Demo name including path.
	}

	return true;
}

//
// Starts recording a demo and names it according to your match_ settings.
//
void CL_EasyRecord_f (void)
{
	char *name;

#ifndef CLIENTONLY
	if ( com_serveractive )
	{
		SV_MVDEasyRecord_f();
		return;
	}
#endif

	if (cls.state != ca_active)
	{
		Com_Printf("You must be connected to easyrecord\n");
		return;
	}

	switch(Cmd_Argc())
	{
		case 1:
		{
			// No name specified by the user, get it from match tools instead.
			name = MT_MatchName();
			break;
		}
		case 2:
		{
			// User specified a demo name, use it.
			name = Cmd_Argv(1);
			break;
		}
		default:
		{
			Com_Printf("Usage: %s [demoname]\n", Cmd_Argv(0));
			return;
		}
	}

	easyrecording = CL_MatchRecordDemo(CL_DemoDirectory(), name, false);
}

//=============================================================================
//							DEMO AUTO RECORDING
//=============================================================================

static char	auto_matchname[MAX_PATH];	// Demoname when recording auto match demo.
static qbool temp_demo_ready = false;	// Indicates if the autorecorded match demo is done recording.
static float auto_starttime;

char *MT_TempDemoDirectory(void);

extern cvar_t match_auto_record, match_auto_minlength;

#define TEMP_DEMO_NAME "_!_temp_!_.qwd"

#define DEMO_MATCH_NORECORD		0 // No autorecord.
#define DEMO_MATCH_MANUALSAVE	1 // Demo will be recorded but requires manuall saving.
#define DEMO_MATCH_AUTOSAVE		2 // Automatically saves the demo after the match is completed.

//
// Stops auto recording of a match.
//
void CL_AutoRecord_StopMatch(void)
{
	// Not doing anything.
	if (!autorecording)
		return;

	// Stop the recording and write end of demo stuff.
	autorecording = false;
	CL_StopRecording();
	temp_demo_ready = true;

	// Automatically save the demo after the match is completed.
	if (match_auto_record.value == DEMO_MATCH_AUTOSAVE)
	{
		CL_AutoRecord_SaveMatch();
		Com_Printf ("Auto record ok\n");
	}
	else
	{
		Com_Printf ("Auto demo recording completed\n");
	}
}

//
// Cancels the match.
//
void CL_AutoRecord_CancelMatch(void)
{
	// Not recording.
	if (!autorecording)
		return;

	// Stop the recording and write end of demo stuff.
	autorecording = false;
	CL_StopRecording();
	temp_demo_ready = true;

	if (match_auto_record.value == DEMO_MATCH_AUTOSAVE)
	{
		// Only save the demo if it's longer than the specified minimum length
		if (cls.realtime - auto_starttime > match_auto_minlength.value)
			CL_AutoRecord_SaveMatch();
		else
			Com_Printf("Auto demo recording cancelled\n");
	}
	else
	{
		Com_Printf ("Auto demo recording completed\n");
	}
}

//
// Starts autorecording a match.
//
void CL_AutoRecord_StartMatch(char *demoname)
{
	temp_demo_ready = false;

	// No autorecording is set.
	if (!match_auto_record.value)
		return;

	// Don't start autorecording if the
	// user already is recording a demo.
	if (cls.demorecording)
	{
		// We're autorecording since before, it's
		// ok to restart the recording then.
		if (autorecording)
		{
			autorecording = false;
			CL_StopRecording();
		}
		else
		{
			Com_Printf("Auto demo recording skipped (already recording)\n");
			return;
		}
	}

	// Save the name of the auto recorded demo for later.
	strlcpy(auto_matchname, demoname, sizeof(auto_matchname));

	// Try starting to record the demo.
	if (!CL_MatchRecordDemo(MT_TempDemoDirectory(), TEMP_DEMO_NAME, true))
	{
		Com_Printf ("Auto demo recording failed to start!\n");
		return;
	}

	// We're now in business.
	autorecording = true;
	auto_starttime = cls.realtime;
	Com_Printf ("Auto demo recording commenced\n");
}

//
//
//
qbool CL_AutoRecord_Status(void)
{
	return temp_demo_ready ? 2 : autorecording ? 1 : 0;
}

//
// Saves an autorecorded demo.
//
void CL_AutoRecord_SaveMatch(void)
{
	//
	// All demos are first recorded in .qwd, and will then be converted to .mvd/.qwz afterwards
	// if those formats are chosen.
	//
	int error, num;
	FILE *f;
	char *dir, *tempname, savedname[MAX_PATH], *fullsavedname, *exts[] = {"qwd", "qwz", "mvd", NULL};

	// The auto recorded demo hasn't finished recording, can't do this yet.
	if (!temp_demo_ready)
		return;

	// Don't try to save it again.
	temp_demo_ready = false;

	// Get the demo dir.
	dir = CL_DemoDirectory();

	// Get the temp name of the file we've recorded.
	tempname = va("%s/%s", MT_TempDemoDirectory(), TEMP_DEMO_NAME);

	// Get the final name where we'll save the final product.
	fullsavedname = va("%s/%s", dir, auto_matchname);

	// Find a unique filename in the final location.
	if ((num = Util_Extend_Filename(fullsavedname, exts)) == -1)
	{
		Com_Printf("Error: no available filenames\n");
		return;
	}

	// Get the final full path where we'll save the demo. (This is the final name for real now)
	snprintf (savedname, sizeof(savedname), "%s_%03i.qwd", auto_matchname, num);
	fullsavedname = va("%s/%s", dir, savedname);

	// Try opening the temp file to make sure we can read it.
	if (!(f = fopen(tempname, "rb")))
		return;
	fclose(f);

	// Move the temp file to the final location.
	if ((error = rename(tempname, fullsavedname)))
	{
		// Failed to move, make sure the path exists and try again.
		FS_CreatePath(fullsavedname);
		error = rename(tempname, fullsavedname);
	}

	// If the file type is not QWD we need to conver it using external apps.
	if (!strcmp(demo_format.string, "qwz") || !strcmp(demo_format.string, "mvd")) {
		Com_Printf("Converting QWD to %s format.\n", demo_format.string);

		// Convert the file to either MVD or QWZ.
		if (CL_Demo_Compress(fullsavedname)) {
			return;
		}

		qwz_packing = false;
	}

	if (!error) {
		Com_Printf("Match demo saved to %s\n", savedname);
	}
}

//=============================================================================
//							QIZMO COMPRESSION
//=============================================================================

#ifdef _WIN32
#define QIZMO_EXECUTABLE_NAME       "qizmo.exe"
#define QWDTOOLS_EXECUTABLE_NAME    "qwdtools.exe"
static HANDLE hQizmoProcess = NULL;
static HANDLE hQizmoThread = NULL;

qbool Sys_QizmoRunning(void)
{
	return hQizmoProcess != NULL;
}

qbool Sys_LaunchExternalDemoProcess(const char* cmdline, const char* path)
{
	STARTUPINFO si;
	PROCESS_INFORMATION	pi;
	char cmdline_[MAX_OSPATH];
	DWORD dwCreationFlags = GetPriorityClass(GetCurrentProcess());

	strlcpy(cmdline_, cmdline, sizeof(cmdline_));

	memset(&si, 0, sizeof(si));
	si.cb = sizeof(si);
	si.wShowWindow = SW_SHOWMINNOACTIVE;
	si.dwFlags = STARTF_USESHOWWINDOW;

	if (!CreateProcess(NULL, cmdline_, NULL, NULL, FALSE, dwCreationFlags, NULL, path, &si, &pi)) {
		return false;
	}

	// Might not actually be Qizmo (could be demotools)...
	hQizmoProcess = pi.hProcess;
	hQizmoThread = pi.hThread;

	return true;
}

qizmo_status_t Sys_QizmoStatus(void)
{
	DWORD ExitCode;
	if (hQizmoProcess == NULL) {
		return qizmo_not_running;
	}

	if (!GetExitCodeProcess(hQizmoProcess, &ExitCode)) {
		hQizmoProcess = NULL;
		return qizmo_terminated_unexpected;
	}

	if (ExitCode == STILL_ACTIVE) {
		return qizmo_still_active;
	}

	CloseHandle(hQizmoThread);
	CloseHandle(hQizmoProcess);
	hQizmoThread = NULL;
	hQizmoProcess = NULL;

	if (ExitCode == 0) {
		return qizmo_terminated_ok;
	}

	return qizmo_terminated_failure;
}
#elif defined(__linux__)
#define QIZMO_EXECUTABLE_NAME       "qizmo"
#define QWDTOOLS_EXECUTABLE_NAME    "qwdtools"

static pid_t qizmo_process_id = 0;

qbool Sys_QizmoRunning(void)
{
	return qizmo_process_id != 0;
}

static qbool Sys_LaunchExternalDemoProcess(const char* cmdline, const char* path)
{
	int child;

	child = fork();
	if (child == -1) {
		Con_Printf("Failed to create sub-process\n");
		return false;
	}

	if (child == 0) {
		// TODO: can we redirect stdout for the system() call?

		// child process: change to qizmo dir so it can find compress.dat
		if (chdir(path) != 0) {
			_exit(EXIT_FAILURE);
		}

		// execute & terminate with success/failure
		if (system(cmdline) == 0) {
			_exit(EXIT_SUCCESS);
		}
		_exit(EXIT_FAILURE);
	}

	// parent process, store and check back later
	qizmo_process_id = child;
	return true;
}

qizmo_status_t Sys_QizmoStatus(void)
{
	int wait_result;
	int status = 0;

	if (qizmo_process_id == 0) {
		return qizmo_not_running;
	}

	wait_result = waitpid(qizmo_process_id, &status, WNOHANG);
	if (wait_result == 0) {
		// child exists but hasn't changed state
		return qizmo_still_active;
	}
	else if (wait_result < 0) {
		// child no longer exists...
		qizmo_process_id = 0;
		return qizmo_terminated_unexpected;
	}
	else {
		// status has changed
		if (WIFEXITED(status)) {
			qizmo_process_id = 0;
			return WEXITSTATUS(status) == 0 ? qizmo_terminated_ok : qizmo_terminated_failure;
		}
		else {
			Con_Printf("Unknown status: %d\n", status);
			return qizmo_still_active;
		}
	}
}
#else
// Other operating systems - not supported yet
#define QIZMO_EXECUTABLE_NAME       "qizmo"
#define QWDTOOLS_EXECUTABLE_NAME    "qwdtools"

qbool Sys_QizmoRunning(void)
{
	return false;
}

static qbool Sys_LaunchExternalDemoProcess(const char* cmdline, const char* path)
{
	Con_Printf("Not supported on this system.");
	return false;
}

qizmo_status_t Sys_QizmoStatus(void)
{
	return qizmo_not_running;
}
#endif

static qbool CL_CompressExternally(const char* qwdname)
{
	char cmdline[MAX_OSPATH];
	char workingDirectory[MAX_OSPATH];
	extern cvar_t qizmo_dir, qwdtools_dir;
	const char* appname = NULL;
	const char* shortname = NULL;
	const char* parameters = NULL;
	const char* path = NULL;
	char outputpath[MAX_OSPATH];

	if (!strcmp(demo_format.string, "qwz")) {
		appname = QIZMO_EXECUTABLE_NAME;
		shortname = "qizmo";
		parameters = "-q -C";
		path = qizmo_dir.string;
		outputpath[0] = 0;
	}
	else if (!strcmp(demo_format.string, "mvd")) {
		appname = QWDTOOLS_EXECUTABLE_NAME;
		shortname = "qwdtools";
		parameters = "-c -o * -od";
		path = qwdtools_dir.string;
		strlcpy(outputpath, qwdname, COM_SkipPath(qwdname) - qwdname);
	}
	else {
		Com_Printf("%s demo format not yet supported.\n", demo_format.string);
		return false;
	}

	strlcpy(workingDirectory, va("%s/%s", com_basedir, path), sizeof(workingDirectory));
	strlcpy(cmdline, va("\"%s/%s/%s\" %s \"%s\" \"%s\"", com_basedir, path, appname, parameters, outputpath, qwdname), sizeof(cmdline));
	Com_Printf("&cf00%s&r: %s\n", shortname, cmdline);

	return Sys_LaunchExternalDemoProcess(cmdline, workingDirectory);
}

// Qizmo only
static qbool CL_DecompressExternally(const char* qwz_name)
{
	char cmdline[MAX_OSPATH];
	char workingDirectory[MAX_OSPATH];
	extern cvar_t qizmo_dir;

	strlcpy(workingDirectory, va("%s/%s", com_basedir, qizmo_dir.string), sizeof(workingDirectory));
	strlcpy(cmdline, va("%s/%s/%s -q -u -3 -D \"%s\"", com_basedir, qizmo_dir.string, QIZMO_EXECUTABLE_NAME, qwz_name), sizeof(cmdline));

	Com_Printf("&cf00qizmo&r: %s\n", cmdline);

	return Sys_LaunchExternalDemoProcess(cmdline, workingDirectory);
}

//
//
//
static void CL_Demo_RemoveQWD(void)
{
	Sys_remove(tempqwd_name);
}

//
// cdemo_name is assumed to be 255 chars long
//
static void CL_Demo_GetCompressedName(char* cdemo_name)
{
	size_t namelen = strlen(tempqwd_name);

	if (strlen(demo_format.string) && namelen) {
		strlcpy(cdemo_name, tempqwd_name, 255);
		strlcpy(cdemo_name + namelen - 3, demo_format.string, 255 - namelen + 3);
	}
}

//
//
//
static void CL_Demo_RemoveCompressed(void)
{
	char cdemo_name[255];
	CL_Demo_GetCompressedName(cdemo_name);
	Sys_remove(cdemo_name);
}

//
//
//
static void StopQWZPlayback (void)
{
	if (!Sys_QizmoRunning() && tempqwd_name[0]) {
		if (Sys_remove(tempqwd_name) != 0) {
			Com_Printf("Error: Couldn't delete %s\n", tempqwd_name);
		}
		tempqwd_name[0] = 0;
	}
	qwz_playback = false;
	qwz_unpacking = false;
}

//
//
//
void CL_CheckQizmoCompletion(void)
{
	qizmo_status_t state = Sys_QizmoStatus();

	if (state == qizmo_not_running) {
		return;
	}

	if (state == qizmo_terminated_unexpected) {
		Com_Printf ("WARNING: CL_CheckQizmoCompletion: unexpected termination\n");
		if (qwz_unpacking) {
			qwz_unpacking = false;
			qwz_playback = false;
			cls.demoplayback = cls.timedemo = false;
			StopQWZPlayback();
		}
		else if (qwz_packing) {
			qwz_packing = false;
			CL_Demo_RemoveCompressed();
		}
		return;
	}

	if (state == qizmo_still_active) {
		return;
	}

	if (!qwz_packing && !qwz_unpacking) {
		StopQWZPlayback();
		return;
	}

	if (qwz_unpacking) {
		byte* data = NULL;
		int length = 0;

		qwz_unpacking = false;

		Sys_remove(tempqwz_name);
		tempqwz_name[0] = 0;

		data = FS_LoadHeapFile(tempqwd_name, &length);
		if (data == NULL) {
			Com_Printf("Error: Couldn't open %s\n", tempqwd_name);
			qwz_playback = false;
			cls.demoplayback = cls.timedemo = false;
			tempqwd_name[0] = 0;
			return;
		}

		playbackfile = FSMMAP_OpenVFS(data, length);
		Com_Printf("Decompression complete...\n");

		CL_DemoStartPlayback(tempqwd_name);

		Sys_remove(tempqwd_name);
		tempqwd_name[0] = 0;
		qwz_playback = false;
	}
	else if (qwz_packing) {
		FILE* tempfile;
		char newname[255];

		CL_Demo_GetCompressedName(newname);
		qwz_packing = false;

		if ((tempfile = fopen(newname, "rb")) && (FS_FileLength(tempfile) > 0) && fclose(tempfile) != EOF) {
			Com_Printf("Demo saved to %s\n", newname + strlen(com_basedir));
			CL_Demo_RemoveQWD();
		}
		else {
			Com_Printf("Compression failed, demo saved as QWD.\n");
		}
	}
}

//
//
//
static void PlayQWZDemo(const char* name)
{
	char qwz_name[MAX_PATH], *p;

	if (Sys_QizmoRunning()) {
		Com_Printf ("Cannot unpack -- Qizmo still running!\n");
		return;
	}

	//
	char* initialName = NULL;
	memset(tempqwz_name, 0, sizeof(tempqwz_name));
	if (playbackfile) {
		COM_WriteToUniqueTempFileVFS(qwz_name, sizeof(qwz_name), ".qwz", playbackfile);

		// Store the temporary path here so we can delete it when decompression is finished
		strlcpy(tempqwz_name, qwz_name, sizeof(tempqwz_name));
	}
	else {
		// Try opening direct from disk
		if (!(playbackfile = CL_Open_Demo_File(name, false, &initialName))) {
			Com_Printf("Error: Couldn't open %s\n", name);
			return;
		}

		// Convert to system path
		Sys_fullpath(qwz_name, initialName, sizeof(qwz_name));
	}

	VFS_CLOSE(playbackfile);
	playbackfile = NULL;

	strlcpy(tempqwd_name, qwz_name, sizeof(tempqwd_name) - 4);

	// the way Qizmo does it, sigh
	if (!(p = strstr(tempqwd_name, ".qwz"))) {
		p = strstr(tempqwd_name, ".QWZ");
	}
	if (!p) {
		p = tempqwd_name + strlen(tempqwd_name);
	}
	strcpy(p, ".qwd");

	// If .qwd already exists, just play it.
	if ((playbackfile = FS_OpenVFS(tempqwd_name, "rb", FS_NONE_OS))) {
		return;
	}

	Com_Printf("Unpacking %s...\n", COM_SkipPath(name));

	// Start Qizmo to unpack the demo.
	if (!CL_DecompressExternally(qwz_name)) {
		return;
	}

	qwz_unpacking = true;
	qwz_playback = true;
}

//
//
//
static qbool CL_Demo_Compress(char* qwdname)
{
	if (Sys_QizmoRunning()) {
		Com_Printf("Cannot compress -- Qizmo still running!\n");
		return false;
	}

	if (!CL_CompressExternally(qwdname)) {
		Com_Printf("Failed to compress %s\n", qwdname);
		return false;
	}

	strlcpy(tempqwd_name, qwdname, sizeof(tempqwd_name));
	qwz_packing = true;
	return true;
}

//=============================================================================
//							DEMO PLAYBACK
//=============================================================================

double		demostarttime;

#ifdef WITH_ZIP
//
// [IN]		play_path = The compressed demo file that needs to be extracted to play it.
// [RETURN]	The open file handle, or NULL on failure.
//
static qbool CL_UnpackAndOpenDemo(char *play_path, char* unpacked_path, int unpacked_path_length)
{
	//
	// Check if the demo is in a zip file and if so, try to extract it before playing.
	//
	char archive_path[MAX_PATH];
	char inzip_path[MAX_PATH];

	//
	// Is it a GZip file?
	//
	if (!strcmp(COM_FileExtension(play_path), "gz"))
	{
		// Unpack to memory and open file
		size_t unpacked_length;
		void* unpacked_bytes = FS_GZipUnpackToMemory(play_path, &unpacked_length);

		if (unpacked_bytes) {
			playbackfile = FSMMAP_OpenVFS(unpacked_bytes, unpacked_length);
			COM_StripExtension(play_path, unpacked_path, unpacked_path_length);
			// If it doesn't have an extension, default to .mvd
			if (!COM_FileExtension(unpacked_path)[0]) {
				COM_ForceExtensionEx(unpacked_path, ".mvd", unpacked_path_length);
			}
			return true;
		}

		return false;
	}

	//
	// Check if the path is in the format "c:\quake\bla\demo.zip\some_demo.mvd" and split it up.
	//
	if (FS_ZipBreakupArchivePath("zip", play_path, archive_path, sizeof(archive_path), inzip_path, sizeof(inzip_path)) < 0) {
		return false;
	}

	//
	// Extract the ZIP file.
	//
	{
		void* unpacked_bytes = NULL;
		size_t unpacked_length = 0;
		// Open the zip file.
		unzFile zip_file = FS_ZipUnpackOpenFile(archive_path);

		// Try extracting the zip file.
		unpacked_bytes = FS_ZipUnpackOneFileToMemory(zip_file, inzip_path, false, false, NULL, &unpacked_length);

		strlcpy(unpacked_path, COM_SkipPath(inzip_path), unpacked_path_length);

		// Close the zip file.
		FS_ZipUnpackCloseFile(zip_file);

		if (unpacked_bytes != NULL) {
			playbackfile = FSMMAP_OpenVFS(unpacked_bytes, unpacked_length);

			// Successfully unpacked the demo.
			return true;
		}

		Com_Printf("Failed to unpack the demo file \"%s\" to memory\n", inzip_path);
		return false;
	}
}
#endif // WITH_ZIP

void CL_Demo_DumpBenchmarkResult(int frames, float timet)
{
	char logfile[MAX_PATH];
	char datebuf[32];
	FILE* f;
	time_t t = time(&t);
	struct tm *ptm = localtime(&t);
	int width = 0, height = 0; 

	snprintf(logfile, sizeof(logfile), "%s/timedemo.log", FS_LegacyDir(log_dir.string));
	f = fopen(logfile, "a");
	if (!f) {
		Com_Printf("Can't open %s to dump timedemo result\n", logfile);
		return;
	}

	fputs("<timedemo date=\"", f);
	if (ptm)
		strftime (datebuf, sizeof(datebuf) - 1, "%Y-%m-%dT%H:%M:%S", ptm);
	else
		*datebuf = '\0';
	fputs(datebuf, f); fputs("\">\n", f);

	fputs(va("\t<system>\n\t\t<os>%s</os>\n\t\t<hardware>%s</hardware>\n\t</system>\n", QW_PLATFORM, SYSINFO_GetString()), f);

	fputs(va("\t<client>\n\t\t<name>ezQuake</name><version>%s</version>\n"
		"\t\t<configuration>%s</configuration><rendering>%s</rendering>\n\t</client>\n",
		VersionString(), QW_CONFIGURATION, QW_RENDERER), f);
//FIXME width/height doesnt get set, remove vid_mode/r_mode... Is this function used??
	if (width)
		fputs(va("\t<screen width=\"%d\" height=\"%d\"/>\n", width, height), f);

	fputs(va("\t<demo><name>%s</name></demo>\n", cls.demoname), f);

	fputs(va("\t<result frames=\"%i\" time=\"PT%fS\" fps=\"%f\"/>\n", frames, timet, frames/timet), f);
	
	fputs("</timedemo>\n", f);

	fclose(f);
}

//
// Stops demo playback.
//
void CL_StopPlayback(void)
{
	// Nothing to stop.
	if (!cls.demoplayback) {
		return;
	}

	// Capturing to avi/images, stop that.
	if (Movie_IsCapturing()) {
		Movie_Stop(false);
	}

	// Close the playback file.
	if (playbackfile) {
		VFS_CLOSE(playbackfile);
	}

	// Reset demo playback vars.
	playbackfile = NULL;
	cls.mvdplayback = cls.demoplayback = cls.nqdemoplayback = false;
	cl.paused &= ~PAUSED_DEMO;

	cls.qtv_svversion = 0;
	cls.qtv_ezquake_ext = 0;
	cls.qtv_donotbuffer = false;

	// Stop Qizmo demo playback.
	#ifdef WIN32
	if (qwz_playback) {
		StopQWZPlayback();
	}
	#endif

	//
	// Stop timedemo and show the result.
	//
	if (cls.timedemo)
	{
		int frames, i, frames2, worst_ms_count = 0;
		double stddev = 0;
		double renderTime = 0;
		float time, worst_ms = 0;
		double avg_ms = 0;

		//
		// Calculate the time it took to render the frames.
		//
		R_TraceAPI("[timedemo] finished");
		frames = cls.framecount - cls.td_startframe - 1;
		time = Sys_DoubleTime() - cls.td_starttime;
		if (time <= 0) {
			time = 1;
		}
		if (frames <= 0) {
			frames = 1;
		}
		avg_ms = (time * 1000.0) / frames;
		Com_Printf("%i frames %5.1f seconds %5.1f fps\n", frames, time, frames / time);
		if (cls.timedemo == TIMEDEMO_FIXEDFPS && cls.td_frametime > 0) {
			Com_Printf("  simulated @ %5.1f fps\n", 1.0 / cls.td_frametime);
		}
		if (cls.td_frametime_max) {
			Com_Printf("Worst frametime %dms @ frame %d\n", cls.td_frametime_max, cls.td_frametime_max_frame);
		}

		frames2 = 0;
		for (i = 0; i < sizeof(cls.td_frametime_stats) / sizeof(cls.td_frametime_stats[0]); ++i) {
			if (cls.td_frametime_stats[i]) {
				stddev += cls.td_frametime_stats[i] * (i / 10.0 - avg_ms) * (i / 10.0 - avg_ms);
				worst_ms = i / 10.0;
				worst_ms_count = cls.td_frametime_stats[i];
				frames2 += cls.td_frametime_stats[i];
				renderTime += cls.td_frametime_stats[i] * (i / 10000.0);
			}
		}
		stddev = sqrt(stddev / frames2);
		Com_Printf("... avg frametime %0.3fms, std dev %0.3fms\n", avg_ms, stddev);
		Com_Printf("... %d frames vs %d\n", frames2, frames);
		Com_Printf("... %5.1fs vs %5.1fs\n", renderTime, time);
		Com_Printf("... non-rendering time %5.1fs\n", cls.td_nonrendering);
		if (worst_ms) {
			Com_Printf("... worst frametime %0.3fms, %0.1ffps (%d frames)\n", worst_ms, 1 / (worst_ms / 1000.0f), worst_ms_count);
		}
		// Create bins
		{
#define TIMEDEMO_BIN_COUNT 10
#define TIMEDEMO_BIN_OFFSET (TIMEDEMO_BIN_COUNT - 4)
			double bin_percentages[TIMEDEMO_BIN_COUNT] = { 0.0 };
			unsigned long bin_thresholds[TIMEDEMO_BIN_COUNT] = { 0 };
			double total_samples = 0;
			unsigned long bin_ms[TIMEDEMO_BIN_COUNT] = { 0 };
			int j;

			for (i = 0; i < TIMEDEMO_BIN_COUNT; ++i) {
				bin_percentages[i] = 1.0 - pow(2, TIMEDEMO_BIN_OFFSET - i) * 0.01;
				bin_thresholds[i] = bin_percentages[i] * frames2;
			}
			bin_percentages[TIMEDEMO_BIN_COUNT - 1] = 1.0;

			for (i = 0; i < sizeof(cls.td_frametime_stats) / sizeof(cls.td_frametime_stats[0]); ++i) {
				total_samples += cls.td_frametime_stats[i];

				for (j = 0; j < sizeof(bin_percentages) / sizeof(bin_percentages[0]); ++j) {
					if (total_samples <= bin_thresholds[j]) {
						bin_ms[j] = i;
					}
				}
			}
			bin_ms[TIMEDEMO_BIN_COUNT - 1] = worst_ms * 10.0;

			for (j = 0; j < TIMEDEMO_BIN_COUNT; ++j) {
				Con_Printf("  %6.3f%: %4.1fms\n", bin_percentages[j], (bin_ms[j] / 10.0));
			}
		}
		cls.timedemo = false;
		if (demo_benchmarkdumps.integer) {
			CL_Demo_DumpBenchmarkResult(frames, time);
		}
	}

	// Go to the next demo in the demo playlist.
	CL_Demo_NextInPlaylist();

	// Reset demoseeking and such.
	cls.demoseeking = DST_SEEKING_NONE;
	cls.demorewinding = false;

	TP_ExecTrigger("f_demoend");
}

//
// Returns the demo length.
//
float CL_GetDemoLength(void)
{
	return demo_time_length;
}

typedef enum demoprobe_parse_type_e
{
	READ_MVD_TIME	= 1,
	READ_QWD_TIME	= 2,
	TRY_READ_MVD	= 3
} demoprobe_parse_type_t;

//
// Validates a demo probe read.
//
#define DEMOPROBE_VALIDATE_READ(bytes_expected, bytes_read, message)		\
	if (bytes_expected != bytes_read)										\
	{																		\
		Com_DPrintf("CL_ProbeDemo: Unexpected end of demo. "message"\n");	\
		abort = true;														\
		break;																\
	}

//
// Seek the specified length and fail/abort if it fails.
//
#define DEMOPROBE_SEEK(file, length, message)								\
	if (VFS_SEEK(file, length, SEEK_CUR) == -1)								\
	{																		\
		Com_DPrintf("CL_ProbeDemo: Unexpected end of demo. "message"\n");	\
		abort = true;														\
		break;																\
	}

//
// Probe a demo in different ways.
//
qbool CL_ProbeDemo(vfsfile_t *demfile, demoprobe_parse_type_t probetype, float *demotime)
{
	#define PARSE_AS_MVD()			((probetype == READ_MVD_TIME) || (probetype == TRY_READ_MVD))
	#define REGARD_AS_MVD_COUNT		4		// Regard this to be an MVD when this count has been reached.

	vfserrno_t err;
	
	float qwd_time				= 0.0;		// QWD Time = Time since start of demo in seconds.
	byte mvd_time				= 0;		// MVD Time = Time in miliseconds since last time stamp.
	unsigned int total_mvd_time = 0;		// Total MVD time in miliseconds.
	
	byte command				= 0;		// Holds the command code.
	unsigned int multiple		= 0;		// Read dem_multiple data into this.
	unsigned int size			= 0;		// The size of the demo packet (follows dem_multiple, _single, _stats, _all and _read).

	int message_count			= 0;		// The total amount of demo messages.
	int len						= 0;		// Length of what's been read
	qbool is_mvd				= false;	// Is this an MVD. (Used when guessing if this is an MVD).
	int mvd_only_count			= 0;		// Try to figure out if this is a MVD by looking for commands only present in MVDs.
	qbool abort					= false;	// Something bad happened when reading the demo.

	while (!abort)
	{
		// Read the time.
		if (PARSE_AS_MVD())
		{
			// MVD time.
			len = VFS_READ(demfile, &mvd_time, 1, &err);
		}
		else
		{
			// QWD time.
			len = VFS_READ(demfile, &qwd_time, 4, &err);
			qwd_time = LittleFloat(qwd_time);
		}
		
		// Any well formed demo should only end at an expected time stamp.
		if ((len == 0) || (err == VFSERR_EOF))
		{
			Com_DPrintf("CL_ProbeDemo: End of file. All good!\n");
			break;
		}

		// Read the command.
		len = VFS_READ(demfile, &command, 1, &err);
		DEMOPROBE_VALIDATE_READ(1, len, "when reading command");

		size = 0;

		// The first 3 bits contains the command code.
		// The 5 other bits are:
		// dem_stats, 
		// dem_single	= Player number for the player affected.
		// dem_all		= Nothing, directed to all players.
		// dem_multiple = Nothing.
		switch (command & 0x7)
		{
			case dem_multiple :
			{
				// Only MVD.

				// Read a 32-bit number containing a bitmask for which the affected players are.
				// 32-bits, 32 players.
				len = VFS_READ(demfile, &multiple, 4, &err);

				if (err == VFSERR_EOF)
				{
					Com_Printf("Unexpected end of demo when reading multiple.\n");
					abort = true;
					break;
				}
			}
			case dem_single :		// Only MVD.
			case dem_all :			// Only MVD.
				mvd_only_count++;	// Count the number of MVD-only commands we find to determine if this is an MVD or not.
			case dem_stats : 
			case dem_read :
			{
				// Read the size of the packet, we'll need it to seek past it.
				len = VFS_READ(demfile, &size, 4, &err);
				DEMOPROBE_VALIDATE_READ(4, len, "when reading size");
				size = LittleLong(size);
				break;
			}
			case dem_set :
			{
				DEMOPROBE_SEEK(demfile, 4, "when reading incoming sequence number"); // 32-bit int.
				DEMOPROBE_SEEK(demfile, 4, "when reading outgoing sequence number"); // 32-bit int.
				break;
			}
			case dem_cmd :
			{
				// Only QWD.
				DEMOPROBE_SEEK(demfile, sizeof(usercmd_t), "when reading user movement cmd.");
				DEMOPROBE_SEEK(demfile, 12, "when reading user viewangles cmd."); // 3 * 32-bit floats.
				break;
			}
			default :
			{
				Com_DPrintf("CL_ProbeDemo: Unsupported command type %d!\n", (command & 0x7));
				abort = true;
				break;
			}
		}

		// We're just trying to find out if this is an MVD so break if it is.
		if ((probetype == TRY_READ_MVD) && (mvd_only_count >= REGARD_AS_MVD_COUNT))
		{
			is_mvd = true;
			break;
		}

		if (abort)
			break;

		// Read any specified data if needed.
		DEMOPROBE_SEEK(demfile, size, "when reading size bytes of message");

		// MVD time is saved as the time since last frame,
		// so we need to keep track of the total seperatly.
		if (probetype == READ_MVD_TIME)
		{
			total_mvd_time += mvd_time;
		}

		message_count++;
	}

	// Return to the start of the file.
	VFS_SEEK(demfile, 0, SEEK_SET);

	if (demotime)
	{
		if (probetype == READ_MVD_TIME)
		{
			// Convert mvd time to seconds.
			*demotime = total_mvd_time * 0.001;
		}
		else if (probetype == READ_QWD_TIME)
		{
			*demotime = qwd_time;
		}

		Com_DPrintf("CL_DemoProbe: Time: %f\n", *demotime);
	}

	// Is this a really short MVD, that doesn't contain our threshold of MVD only messages
	// but still enough for it to likely be one.
	if (!is_mvd 
		&& (probetype == TRY_READ_MVD)
		&& (message_count > 0) 
		&& (((float)mvd_only_count / message_count) >= 0.1))
	{
		is_mvd = true;
	}

	return is_mvd;
}

//
// Try to guess if this is an MVD by trying to parse it as one.
//
qbool CL_GetIsMVD(vfsfile_t *demfile)
{
	return CL_ProbeDemo(demfile, TRY_READ_MVD, NULL);
}

//
// Try to calculate the time of a demo.
//
float CL_CalculateDemoTime(vfsfile_t *demfile)
{
	float demotime = 0.0;

	CL_ProbeDemo(demfile, (cls.mvdplayback ? READ_MVD_TIME : READ_QWD_TIME), &demotime);

	return demotime;
}

//
// Returns true if the specified filename has a demo extension.
//
qbool CL_IsDemoExtension(const char *filename)
{
	char *ext = COM_FileExtension(filename);

	return (!strncasecmp(ext, "mvd", sizeof("mvd"))
		 || !strncasecmp(ext, "qwd", sizeof("qwd"))
		 || !strncasecmp(ext, "dem", sizeof("dem"))
		 || !strncasecmp(ext, "qwz", sizeof("qwz")));
}

//
// Resets various states for beginning playback.
//
static void CL_DemoPlaybackInit(void)
{	
	cls.demoplayback	= true;	

	// Set demoplayback vars depending on the demo type.
	// CL_GetIsMVD(playbackfile); 
	// TODO : Add a similar check for QWD also (or DEM), so that we can distinguish if it's a DEM or not playing also
	// TODO : Make a working check if a demo really is an mvd by its contents that also works on short demos.
	cls.mvdplayback		= !strcasecmp(COM_FileExtension(cls.demoname), "mvd"); 
	cls.nqdemoplayback	= !strcasecmp(COM_FileExtension(cls.demoname), "dem");

	 // Init some buffers for reading.
	CL_Demo_PB_Init(NULL, 0);

	// NetQuake demo support.
	if (cls.nqdemoplayback)
	{
		NQD_StartPlayback();
		demo_time_length = -1.0;
	}
	else
	{
		// Calculate the demo time.
		double start = Sys_DoubleTime();
		demo_time_length = CL_CalculateDemoTime(playbackfile);
		Com_DPrintf("Demo probe took %f seconds.\n", Sys_DoubleTime() - start);
	}

	// Setup the netchan and state.
	Netchan_Setup(NS_CLIENT, &cls.netchan, net_from, 0, 0);
	cls.state		= ca_demostart;
	cls.demotime	= 0;
	demostarttime	= -1.0;
	olddemotime		= 0;
	nextdemotime	= 0;
	cls.findtrack	= true;
	bufferingtime	= 0;

	// Used for knowing who messages is directed to in MVD's.
	cls.lastto		= 0;
	cls.lasttype	= 0;

	CL_ClearPredict();

	// Recording not allowed during mvdplayback.
	if (cls.mvdplayback && cls.demorecording) {
		CL_Stop_f();
	}
	MVD_Initialise();
}

char *CL_Macro_DemoName_f (void)
{
	static char macrobuf[128];

	if (cls.demoplayback) {
		COM_StripExtension (COM_SkipPath (cls.demoname), macrobuf, sizeof (macrobuf));
	}
	else {
		macrobuf[0] = '\0';
	}
	return macrobuf;
}

char *CL_Macro_DemoLength_f (void)
{
	static char macrobuf[64];

	snprintf (macrobuf, sizeof (macrobuf), "%d", (cls.demoplayback ? (int) ceil(CL_GetDemoLength()) : 0));

	return macrobuf;
}

static void CL_StartDemoCommand(void)
{
	keydest_t failure_dest = KeyDestStartupDemo(key_dest) ? key_console : key_dest;

	char *real_name;
	char name[MAX_OSPATH];

	if (Cmd_Argc() < 2) {
		return; // internal error
	}

	// Save the name the user specified.
	real_name = Cmd_Argv(1);

	// Quick check for buffer overrun on COM_StripExtension below...
	if (strlen (real_name) > MAX_OSPATH - 4) {
		Com_Printf ("Path is too long (%d characters, max is %d)\n", strlen (real_name), MAX_OSPATH - 4);
		key_dest = failure_dest;
		return;
	}

	// Disconnect any current game.
	Host_EndGame();

	// VFS-FIXME: This will affect playing qwz inside a zip
	#ifdef WITH_ZIP
	{
		//
		// Unpack the demo if it's zipped or gzipped. And get the path to the unpacked demo file.
		//
		char unpacked_path[MAX_OSPATH];
		if (CL_UnpackAndOpenDemo(Cmd_Argv(1), unpacked_path, sizeof(unpacked_path))) {
			real_name = unpacked_path;
		}
	}
	#endif // WITH_ZIP

	strlcpy(name, real_name, sizeof(name));

	//
	// Decompress QWZ demos to QWD before playing it (using an external app).
	//
	if (strlen(name) > 4 && !strcasecmp(COM_FileExtension(name), "qwz"))
	{
		int length = 0;
		byte* data;

		PlayQWZDemo(Cmd_Argv(1));

		// We failed to extract the QWZ demo.
		if (!playbackfile && !qwz_playback) {
			key_dest = failure_dest;
			return;
		}

		data = FS_LoadHeapFile(tempqwd_name, &length);
		if (data) {
			playbackfile = FSMMAP_OpenVFS(data, length);
		}
		else if (qwz_playback) {
			Com_Printf("Decompression in progress...\n");
			return;
		}
	}
	else if (!playbackfile) {
		int i;
		static char* demo_file_extensions[] = { "qwd", "mvd", "dem" };

		//
		// Find the demo path, trying different extensions if needed.
		//

		// If they specified a valid extension, try that first
		for (i = 0; playbackfile == NULL && i < sizeof(demo_file_extensions) / sizeof(demo_file_extensions[0]); ++i) {
			if (!strcasecmp(COM_FileExtension(name), demo_file_extensions[i])) {
				playbackfile = CL_Open_Demo_File(name, true, NULL);
			}
		}

		for (i = 0; playbackfile == NULL && i < sizeof(demo_file_extensions) / sizeof(demo_file_extensions[0]); ++i) {
			// Strip the extension from the specified filename and append
			// the one we're currently checking for.
			COM_StripExtension(name, name, sizeof(name));
			strlcat(name, ".", sizeof(name));
			strlcat(name, demo_file_extensions[i], sizeof(name));

			playbackfile = CL_Open_Demo_File(name, true, NULL);
		}
	}

	// Read the file completely into memory
	if (playbackfile && !FSMMAP_IsMemoryMapped(playbackfile)) {
		unsigned long len;
		void *buf;
		vfsfile_t *mmap_file;

		len = VFS_GETLEN(playbackfile);
		buf = Q_malloc(len);

		VFS_READ(playbackfile, buf, len, NULL);
		if (!(mmap_file = FSMMAP_OpenVFS(buf, len))) 
		{
			// Couldn't create the memory file, just remove the buffer
			Q_free(buf);
		}
		else 
		{
			// Close the file on disk now that we have read the file into memory
			VFS_CLOSE(playbackfile);
			playbackfile = mmap_file;
		}
	}

	// Failed to open the demo from any path :(
	if (!playbackfile) {
		Com_Printf ("Error: Couldn't open %s\n", Cmd_Argv(1));
		key_dest = failure_dest;
		return;
	}

	CL_DemoStartPlayback(name);
}

static void CL_DemoStartPlayback(const char* name)
{
	strlcpy(cls.demoname, name, sizeof(cls.demoname));

	// Reset multiview track slots.
	CL_MultiviewDemoStart ();

	// Reset stuff so demo rewinding works.
	cls.demoseeking		= DST_SEEKING_NONE;
	cls.demorewinding	= false;
	cls.demo_rewindtime = 0;

	CL_DemoPlaybackInit();
	TP_ExecTrigger("f_demostart");

	Com_Printf("Playing demo from %s\n", COM_SkipPath(name));
}

qbool CL_DemoExtensionMatch(const char* path)
{
	const char* file_ext = COM_FileExtension(path);
	const char* demo_file_extensions[] = {
		"qwd", "mvd", "dem", "qwz"
	};
	int i;

	for (i = 0; i < sizeof(demo_file_extensions) / sizeof(demo_file_extensions[0]); ++i) {
		if (!strcasecmp(file_ext, demo_file_extensions[i])) {
			return true;
		}
	}
	return false;
}

//
// Starts playback of a demo.
//
static void CL_Play_f(void)
{
	// Show usage.
	if (Cmd_Argc() != 2)
	{
		keydest_t failure_dest = KeyDestStartupDemo(key_dest) ? key_console : key_dest;

		Com_Printf("Usage: %s <demoname>\n", Cmd_Argv(0));
		key_dest = failure_dest;
		return;
	}

	CL_StartDemoCommand();
}

static vfsfile_t* CL_Open_Demo_File(const char* name, qbool searchpaks, char** fullPath)
{
	static char fullname[MAX_OSPATH];
	vfsfile_t *file = NULL;

	memset(fullname, 0, sizeof(fullname));
	if (fullPath != NULL)
		*fullPath = fullname;

	// Look for the file in the above directory if it has ../ prepended to the filename.
	if (!strncmp(name, "../", 3) || !strncmp(name, "..\\", 3))
	{
		snprintf(fullname, MAX_OSPATH, "%s/%s", com_basedir, name + 3);
		file = FS_OpenVFS(fullname, "rb", FS_NONE_OS);
	}
	else if (searchpaks)
	{
		// Search demo on quake file system, even in paks.
		strlcpy(fullname, name, sizeof(fullname));
		file = FS_OpenVFS(name, "rb", FS_ANY);
	}

	// Look in the demo dir (user specified).
	if (!file)
	{
		snprintf(fullname, MAX_OSPATH, "%s/%s", CL_DemoDirectory(), name);
		file = FS_OpenVFS(fullname, "rb", FS_NONE_OS);
	}

	// Check the full system path (Run a demo anywhere on the file system).
	if (!file)
	{
		strlcpy(fullname, name, sizeof(fullname));
		file = FS_OpenVFS(name, "rb", FS_NONE_OS);
	}

	return file;
}

//
// Renders a demo as quickly as possible.
//
void CL_TimeDemo_f(void)
{
	const char* command = Cmd_Argv(0);
	qbool classic = !strcasecmp(command, "timedemo");

	if (classic && Cmd_Argc() != 2)
	{
		Com_Printf("%s <demoname> : gets demo speeds\n", Cmd_Argv(0));
		return;
	}
	else if (!classic)
	{
		int desired_fps = TIMEDEMO_FIXEDFPS_DEFAULT;

		if (Cmd_Argc() < 2) {
			Com_Printf("%s <demoname> [<fps>]: gets demo speeds (default fps %d) \n", Cmd_Argv(0), desired_fps);
			return;
		}

		if (Cmd_Argc() >= 3) {
			desired_fps = atoi(Cmd_Argv(2));
			if (desired_fps < TIMEDEMO_FIXEDFPS_MINIMUM || desired_fps > TIMEDEMO_FIXEDFPS_MAXIMUM) {
				Com_Printf("Desired FPS must be between %d and %d\n", TIMEDEMO_FIXEDFPS_MINIMUM, TIMEDEMO_FIXEDFPS_MAXIMUM);
				return;
			}
		}

		cls.td_frametime = 1.0 / desired_fps;
	}

	CL_StartDemoCommand();

	// We failed to start demoplayback.
	if (cls.state != ca_demostart) {
		return;
	}

	// cls.td_starttime will be grabbed at the second frame of the demo,
	// so all the loading time doesn't get counted.

	cls.timedemo = (classic ? TIMEDEMO_CLASSIC : TIMEDEMO_FIXEDFPS);
	cls.td_starttime = 0;
	cls.td_startframe = cls.framecount;
	cls.td_lastframe = -1;		// Get a new message this frame.
	cls.td_nonrendering = 0;
	cls.td_frametime_max_frame = cls.td_frametime_max = 0;
	memset(cls.td_frametime_stats, 0, sizeof(cls.td_frametime_stats));
}

void CL_QTVPlay (vfsfile_t *newf, void *buf, int buflen);

char qtvrequestbuffer[512 * 1024] = {0}; // mmm, demo list may be pretty long
int  qtvrequestsize = 0;

char qtvpassword[128] = {0};

vfsfile_t *qtvrequest = NULL;

//
// Closes a QTV request.
//
void QTV_CloseRequest(qbool warn)
{
	if (qtvrequest)
	{
		if (warn)
			Com_Printf("Closing qtv request file\n");

		VFS_CLOSE(qtvrequest);
		qtvrequest = NULL;
	}

	qtvrequestsize = 0;
}

//
// Polls a QTV proxy. (Called on each frame to see if we have a new QTV request available)
//
void CL_QTVPoll (void)
{
	char QTVSV[] = "QTVSV ";
	int	 QTVSVLEN = sizeof(QTVSV)-1;

	char hash[512] = {0};
	char challenge[128] = {0};
	char authmethod[128] = {0};
	vfserrno_t err;
	char *start, *end, *colon;
	int len, need, chunk_size;
	qbool streamavailable = false;
	qbool saidheader = false;
	float svversion = 0;
	int qtv_ezquake_ext = 0;

	// We're not playing any QTV stream.
	if (!qtvrequest)
		return;

	//
	// Calculate how much we need to read from the buffer.
	//
	need = sizeof(qtvrequestbuffer); // Read the entire buffer
	need -= 1;						// For null terminator.
	need -= qtvrequestsize;			// We probably already have something, so don't re-read something we already read.
	need = max(0, need);			// Don't cause a crash by trying to read a negative value.

	len = VFS_READ(qtvrequest, qtvrequestbuffer + qtvrequestsize, need, &err);

	// EOF, end of polling.
	if (!len && err == VFSERR_EOF)
	{
		QTV_CloseRequest(true);
		return;
	}

	// Increase how much we've read.
	qtvrequestsize += len;
	qtvrequestbuffer[qtvrequestsize] = '\0';

	// QTVSV not seen yet, abort.
	if (qtvrequestsize < QTVSVLEN)
		return;

	if (strncmp(qtvrequestbuffer, QTVSV, QTVSVLEN))
	{
		Com_Printf("Server is not a QTV server (or is incompatible)\n");
		QTV_CloseRequest(true);
		return;
	}

	// Make sure it's a complete chunk. "\n\n" specifies the end of a message.
	for (start = qtvrequestbuffer; *start; start++)
	{
		if (start[0] == '\n' && start[1] == '\n')
			break;
	}

	// We've reached the end and didn't find "\n\n" so the chunk is incomplete.
	if (!*start)
		return;

	svversion = atof(qtvrequestbuffer + QTVSVLEN);

	// server sent float version, but we compare only major version number here
	if ((int)svversion != (int)QTV_VERSION)
	{
		Com_Printf("QTV server doesn't support a compatible protocol version, returned %.2f, need %.2f\n", svversion, QTV_VERSION);
		QTV_CloseRequest(true);
		return;
	}

	start = qtvrequestbuffer;

	//
	// Loop through the request buffer line by line.
	//
	for (end = start; *end; )
	{
		// Found a new line.
		if (*end == '\n')
		{
			// Don't parse it again.
			*end = '\0';

			// Find the first colon in the string.
			colon = strchr(start, ':');

			// We found a request.
			if (colon)
			{
				// Remove the colon.
				*colon++ = '\0';

				while (*colon == ' ')
					colon++;

				//
				// Check the request type. Might be an error.
				//
				if (!strcmp(start, "PERROR"))
				{
					Com_Printf("QTV Error:\n%s\n", colon);
				}
				else if (!strcmp(start, "PRINT"))
				{
					Com_Printf("QTV:\n%s\n", colon);
				}
				else if (!strcmp(start, "TERROR"))
				{
					Com_Printf("QTV Error:\n%s\n", colon);
				}
				else if (!strcmp(start, "ADEMO"))
				{
					//
					// Print demos.
					//

					if (!saidheader)
					{
						saidheader = true;
						Com_Printf("Available Demos:\n");
					}

					Com_Printf("%s\n", colon);
				}
				else if (!strcmp(start, "ASOURCE"))
				{
					//
					// Print sources.
					//

					if (!saidheader)
					{
						saidheader = true;
						Com_Printf("Available Sources:\n");
					}

					Com_Printf("%s\n", colon);
				}
				else if (!strcmp(start, "AUTH"))
				{
					strlcpy(authmethod, colon, sizeof(authmethod));
				}
				else if (!strcmp(start, "CHALLENGE"))
				{
					strlcpy(challenge, colon, sizeof(challenge));
				}
				else if (!strcmp(start, "BEGIN"))
				{
					streamavailable = true;
				}
				else if (!strcmp(start, QTV_EZQUAKE_EXT))
				{
					qtv_ezquake_ext = atoi(colon);
				}
			}
			else
			{
				// What follows this is a stream.
				if (!strcmp(start, "BEGIN"))
				{
					streamavailable = true;
				}
				else if (!strncmp(start, "QTVSV ", 6))
				{
//					Com_Printf("QTVSV HEADER: %s\n", start);
				}
			}

			// From start to end, we have a line.
			start = end + 1;
		}

		end++;
	}

	// Get the size of the stream chunk.
	chunk_size = qtvrequestsize - (end - qtvrequestbuffer);

	if (chunk_size < 0)
	{
		Com_Printf("Error while parsing qtv request\n");
		QTV_CloseRequest(true);
		return;
	}

	// drop header
	qtvrequestsize = chunk_size;
	memmove(qtvrequestbuffer, end, qtvrequestsize);

//	Com_Printf("memmove: %d\n", qtvrequestsize);

	// We found a stream.
	if (streamavailable)
	{
		// Start playing the QTV stream.
		CL_QTVPlay(qtvrequest, qtvrequestbuffer, qtvrequestsize);
		cls.qtv_svversion = svversion;
		cls.qtv_ezquake_ext = qtv_ezquake_ext;
		qtvrequest = NULL;

		return;
	}

	// we need send auth now
	if (authmethod[0])
	{
		char connrequest[2048];

		if (!strcmp(authmethod, "PLAIN"))
		{
			strlcpy(connrequest, QTV_CL_HEADER(QTV_VERSION, QTV_EZQUAKE_EXT_NUM), sizeof(connrequest));
			strlcat(connrequest, "AUTH: PLAIN\nPASSWORD: \"", sizeof(connrequest));
			strlcat(connrequest, qtvpassword, sizeof(connrequest));
			strlcat(connrequest, "\"\n", sizeof(connrequest));
			strlcat(connrequest, cls.qtv_source, sizeof(connrequest));
			strlcat(connrequest, "\n", sizeof(connrequest));

			VFS_WRITE(qtvrequest, connrequest, strlen(connrequest));

			return;
		}
		else if (!strcmp(authmethod, "SHA3_512"))
		{
			if (strlen(challenge)>=63)
			{
				sha3_context c;
				const uint8_t *byte_hash;

				sha3_Init512(&c);
				sha3_Update(&c, challenge, strlen(challenge));
				sha3_Update(&c, qtvpassword, strlen(qtvpassword));
				byte_hash = sha3_Finalize(&c);
				sha3_512_ByteToHex(hash, byte_hash);
				snprintf(connrequest, sizeof(connrequest),
					"%s" "AUTH: SHA3_512\nPASSWORD: \"%s\"\n\n", QTV_CL_HEADER(QTV_VERSION, QTV_EZQUAKE_EXT_NUM), hash);

				VFS_WRITE(qtvrequest, connrequest, strlen(connrequest));

				return;
			}

			Com_Printf("Wrong challenge for AUTH: %s\n", authmethod);
		}
		else if (!strcmp(authmethod, "CCITT"))
		{
			if (strlen(challenge)>=32)
			{
				unsigned short crcvalue;

				snprintf(hash, sizeof(hash), "%s%s", challenge, qtvpassword);
				crcvalue = CRC_Block((byte *)hash, strlen(hash));
				snprintf(hash, sizeof(hash), "0x%X", (unsigned int)CRC_Value(crcvalue));
				snprintf(connrequest, sizeof(connrequest), 
					"%s" "AUTH: CCITT\nPASSWORD: \"%s\"\n\n", QTV_CL_HEADER(QTV_VERSION, QTV_EZQUAKE_EXT_NUM), hash);

				VFS_WRITE(qtvrequest, connrequest, strlen(connrequest));

				return;
			}

			Com_Printf("Wrong challenge for AUTH: %s\n", authmethod);
		}
		else if (!strcmp(authmethod, "MD4"))
		{
			if (strlen(challenge)>=8)
			{
				unsigned int md4sum[4];

				snprintf(hash, sizeof(hash), "%s%s", challenge, qtvpassword);
				Com_BlockFullChecksum (hash, strlen(hash), (unsigned char*)md4sum);
				snprintf(hash, sizeof(hash), "%X%X%X%X", md4sum[0], md4sum[1], md4sum[2], md4sum[3]);
				snprintf(connrequest, sizeof(connrequest), 
					"%s" "AUTH: MD4\nPASSWORD: \"%s\"\n\n", QTV_CL_HEADER(QTV_VERSION, QTV_EZQUAKE_EXT_NUM), hash);

				VFS_WRITE(qtvrequest, connrequest, strlen(connrequest));

				return;
			}

			Com_Printf("Wrong challenge for AUTH: %s\n", authmethod);
		}
		else if (!strcmp(authmethod, "NONE"))
		{
			snprintf(connrequest, sizeof(connrequest),
					"%s" "AUTH: NONE\nPASSWORD: \n\n", QTV_CL_HEADER(QTV_VERSION, QTV_EZQUAKE_EXT_NUM));

			VFS_WRITE(qtvrequest, connrequest, strlen(connrequest));

			return;
		}
		else
		{
			Com_Printf("Unknown auth method %s\n", authmethod);
		}
	}

	QTV_CloseRequest(true);
}

/*
 * Queries a QTV proxy for a list of available stream sources or demos
 * This function is used for both for qtvlist and qtvdemolist
 */
void CL_QTVList_f (void)
{
	char *connrequest;
	vfsfile_t *newf;
	qbool qtvlist = !strcmp("qtv_query_sourcelist", Cmd_Argv(0));

	if (Cmd_Argc() < 2) {
		Com_Printf("Usage: %s hostname[:port] [password]\n", Cmd_Argv(0));
		return;
	}

	// Open the TCP connection to the QTV proxy.
	newf = FS_OpenTCP(Cmd_Argv(1));
	if (newf == NULL) {
		Com_Printf("Couldn't connect to proxy\n");
		return;
	}

	strlcpy(qtvpassword, Cmd_Argv(2), sizeof(qtvpassword));

	// Send the version of QTV the client supports.
	connrequest = QTV_CL_HEADER(QTV_VERSION, QTV_EZQUAKE_EXT_NUM);
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	// Get a source list from the server.
	connrequest = qtvlist ? "SOURCELIST\n" : "DEMOLIST\n";
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	// Send our userinfo
	connrequest = "USERINFO: ";
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	connrequest = cls.userinfo;
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	connrequest =	"\n";
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	/* if we use pass, then send our supported auth methods */
	if (qtvpassword[0]) {
		connrequest = "AUTH: SHA3_512\n" "AUTH: MD4\n" "AUTH: CCITT\n" "AUTH: PLAIN\n" "AUTH: NONE\n";
		VFS_WRITE(newf, connrequest, strlen(connrequest));
	}

	/* "\n\n" will end the session */
	connrequest = "\n";
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	/* Close any old request that might still be open */
	QTV_CloseRequest(true);

	/* Set the current connection to be the QTVRequest to be used later */
	qtvrequest = newf;
}

//
// Plays a QTV stream.
//
void CL_QTVPlay (vfsfile_t *newf, void *buf, int buflen)
{
	// End any current game.
	Host_EndGame();

	// Close the old playback file just in case, and
	// open the "network file" for QTV playback.
	if (playbackfile)
		VFS_CLOSE(playbackfile);
	playbackfile = newf;

	// Reset multiview track slots
	CL_MultiviewDemoStart ();

	// We're now playing a demo.
	cls.demoplayback	= true;
	cls.mvdplayback		= QTV_PLAYBACK;
	cls.nqdemoplayback	= false;

	// Init playback buffers.
	CL_Demo_PB_Init(buf, buflen);

	// NetQuake demo support.
	if (cls.nqdemoplayback)
	{
		NQD_StartPlayback (); // Maybe some day QTV will stream NQ demos too...
	}

	// Setup demo playback for the netchan.
	cls.state = ca_demostart;
	Netchan_Setup (NS_CLIENT, &cls.netchan, net_from, 0, 0);
	cls.demotime = 0;
	demostarttime = -1.0;
	olddemotime = nextdemotime = 0;
	cls.findtrack = true;

	cls.qtv_donotbuffer = true; // do not try buffering before "skins" not received

	bufferingtime = 0; // with eztv it correct, since eztv do not send data before we complete connection, so prebuffering is pointless

	// Used for knowing who messages is directed to in MVD's.
	cls.lastto = cls.lasttype = 0;

	CL_ClearPredict();

	// Recording not allowed during mvdplayback.
	if (cls.mvdplayback && cls.demorecording) {
		CL_Stop_f();
	}

	MVD_Initialise();
	TP_ExecTrigger ("f_demostart");

	Com_Printf("Attempting to stream QTV data, buffer is %.1fs\n", (double)(QTVBUFFERTIME));
}

static char prev_qtv_connrequest[512]; /* FIXME: Stupid name, it might as well be ACTUAL streaming address */
static char prev_qtv_password[128];

char *CL_QTV_GetCurrentStream(void)
{
	if (cls.mvdplayback == QTV_PLAYBACK) {
		if (prev_qtv_connrequest[0]) {
			return &prev_qtv_connrequest[0];
		}
	}
	/* Not connected to QTV, no address then */
	return NULL;
}

//
// Reconnects to the previous QTV.
//
void CL_QTVReconnect_f (void)
{
	if (!prev_qtv_connrequest[0])
	{
		Com_Printf("No previous QTV proxy available to connect to.\n");
		return;
	}

	Cbuf_AddText(va("qtvplay %s %s\n", prev_qtv_connrequest, prev_qtv_password));
}

// checks if the argument is of the form http://quakeworld.fi:28000/watch.qtv?sid=8
// if so, issue a new qtvplay command with stream@hostname:port format
static qbool CL_QTVPlay_URL_format(void)
{
	const char *prefix = strstr(Cmd_Argv(1), "http://");
	const char *docpart = strstr(Cmd_Argv(1), "/watch.qtv?sid=");

	if (prefix && docpart && prefix == Cmd_Argv(1) && prefix < docpart) {
		int streamid = Q_atoi(docpart + strlen("/watch.qtv?sid="));
		int hostnamelen = docpart - prefix - strlen("http://");
		Cbuf_AddText(va("qtvplay %d@%.*s\n", streamid, hostnamelen, Cmd_Argv(1) + strlen("http://")));
		return true;
	}
	else {
		return false;
	}
}

//
// Start playback of a QTV stream.
//
void CL_QTVPlay_f (void)
{
	char *connrequest;
	vfsfile_t *newf;
	char stream_host[1024] = {0}, *stream, *host;

	// Show usage.
	if (Cmd_Argc() < 2) {
		Com_Printf("Usage: qtvplay [stream@]hostname[:port] [password]\n");
		return;
	}

	if (CL_QTVPlay_URL_format()) {
		return;
	}

	strlcpy(qtvpassword, Cmd_Argv(2), sizeof(qtvpassword));

	// The stream address.
	connrequest = Cmd_Argv(1);

	// We've succesfully connected to a QTV proxy, save the connrequest string so we can use it to reconnect.
	strlcpy(prev_qtv_connrequest, connrequest, sizeof(prev_qtv_connrequest));
	strlcpy(prev_qtv_password, qtvpassword, sizeof(prev_qtv_password));

	//
	// If a "#" is at the beginning of the given address it refers to a .qtv file.
	//
	if (*connrequest == '#')
	{
		#define QTV_FILE_STREAM     1
		#define QTV_FILE_JOIN       2
		#define QTV_FILE_OBSERVE    3
		#define QTV_FILE_CHALLENGE  4
		int match = 0;

		char buffer[1024];
		char *s;
		FILE *f;

		// Try to open the .qtv file.
		f = fopen(connrequest + 1, "rt");
		if (!f)
		{
			Com_Printf("qtvplay: can't open file %s\n", connrequest + 1);
			return;
		}

		//
		// Read the entire .qtv file and execute the approriate commands
		// Stream, join or observe.
		//
		while (!feof(f))
		{
			if (fgets(buffer, sizeof(buffer) - 1, f) == NULL) {
				Com_Printf("Error reading the QTV file.\n");
				break;
			}

			if (!strncmp(buffer, "Stream=", 7) || !strncmp(buffer, "Stream:", 7))
			{
				match = QTV_FILE_STREAM;
			}

			if (!strncmp(buffer, "Join=", 5) || !strncmp(buffer, "Join:", 5))
			{
				match = QTV_FILE_JOIN;
			}

			if (!strncmp(buffer, "Observe=", 8) || !strncmp(buffer, "Observe:", 8))
			{
				match = QTV_FILE_OBSERVE;
			}

			if (!strncmp(buffer, "Challenge=", 10) || !strncmp(buffer, "Challenge:", 10))
			{
				match = QTV_FILE_CHALLENGE;
			}

			// We found a match in the .qtv file.
			if (match)
			{
				// Strip new line chars.
				for (s = buffer + strlen(buffer)-1; s >= buffer; s--)
				{
					if (*s == '\r' || *s == '\n')
					{
						*s = 0;
					}
					else
					{
						break;
					}
				}

				// Skip the title part.
				s = buffer;
				while(*s && *s != ':' && *s != '=') {
					s++;
				}
				if (*s) {
					s++;
				}

				// Remove any leading white spaces.
				while(*s && *s <= ' ')
				{
					s++;
				}

				// Call the appropriate commands based on the match.
				switch (match)
				{
					case QTV_FILE_STREAM :
						Cbuf_AddText(va("qtvplay \"%s\"\n", s));
						break;
					case QTV_FILE_JOIN :
						Cbuf_AddText(va("join \"%s\"\n", s));
						break;
					case QTV_FILE_OBSERVE :
						Cbuf_AddText(va("observe \"%s\"\n", s));
						break;
					case QTV_FILE_CHALLENGE:
						// URL is passed in, it needs to be further processed by the qwurl command
						Cbuf_AddText(va("qwurl \"%s\"\n", s));
						break;
				}

				// Break the while-loop we found what we want.
				break;
			}
		}

		// Close the file.
		fclose(f);
		return;
	}

	// The argument is the host address for the QTV server.

	// Find the position of the last @ char in the connection string,
	// this is when the user specifies a specific stream # on the QTV proxy
	// that he wants to stream. Default is to stream the first one.
	// [stream@]hostname[:port]
	// (QTV proxies can be chained, so we must get the last @)
	// In other words split stream and host part

	strlcpy(stream_host, connrequest, sizeof(stream_host));

	connrequest = strchrrev(stream_host, '@');
	if (connrequest)
	{
		stream = stream_host;		// Stream part.
		connrequest[0] = 0;			// Truncate.
		host   = connrequest + 1;	// Host part.
	}
	else
	{
		stream = "";				// Use default stream, user not specifie stream part.
		host   = stream_host;		// Arg is just host.
	}

	// Open a TCP socket to the specified host.
	CL_StopPlayback();
	newf = FS_OpenTCP(host);

	// Failed to open the connection.
	if (!newf)
	{
		Com_Printf("Couldn't connect to proxy %s\n", host);
		return;
	}

	// Send a QTV request to the proxy.
	connrequest = QTV_CL_HEADER(QTV_VERSION, QTV_EZQUAKE_EXT_NUM);
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	// If the user specified a specific stream such as "5@hostname:port"
	// we need to send a SOURCE request.
	if (stream[0]) {
		strlcpy(cls.qtv_source, "SOURCE: ", sizeof(cls.qtv_source));
		strlcat(cls.qtv_source, stream, sizeof(cls.qtv_source));
		strlcat(cls.qtv_source, "\n", sizeof(cls.qtv_source));

		VFS_WRITE(newf, cls.qtv_source, strlen(cls.qtv_source));
	}
	else {
		memset(cls.qtv_source, 0, sizeof(cls.qtv_source));
	}

	// Send our userinfo
	connrequest = "USERINFO: ";
	VFS_WRITE(newf, connrequest, strlen(connrequest));
	connrequest = cls.userinfo;
	VFS_WRITE(newf, connrequest, strlen(connrequest));
	connrequest =	"\n";
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	// if we use pass, then send our supported auth methods
	if (qtvpassword[0])
	{
		connrequest =
						"AUTH: SHA3_512\n"
						"AUTH: MD4\n"
						"AUTH: CCITT\n"
						"AUTH: PLAIN\n"
						"AUTH: NONE\n";

		VFS_WRITE(newf, connrequest, strlen(connrequest));
	}

	// Two \n\n tells the server we're done.
	connrequest =	"\n";
	VFS_WRITE(newf, connrequest, strlen(connrequest));

	// We're finished requesting, but not done yet so save the
	// socket for the actual streaming :)
	QTV_CloseRequest(false);
	qtvrequest = newf;
}


//=============================================================================
//								DEMO TOOLS
//=============================================================================

//
// Sets the playback speed of a demo.
//
void CL_Demo_SetSpeed_f (void)
{
	extern cvar_t cl_demospeed;

	if (Cmd_Argc() != 2)
	{
		Com_Printf("Usage: %s [speed %%]\n", Cmd_Argv(0));
		return;
	}

	Cvar_SetValue(&cl_demospeed, atof(Cmd_Argv(1)) / 100.0);
}

//
// Cleans up after demo has been rewound to the correct point
//
void CL_Demo_Stop_Rewinding(void) 
{
	// Make sure we keep our tracked players after rewinding.
	CL_MultiviewDemoStopRewind ();

	if (rewind_spec_track >= 0) 
	{
		Cam_Lock(rewind_spec_track);
	}
	else 
	{
		// Switch to free-floating camera and restore view
		Cam_Unlock();
		Cam_Pos_Set(rewind_pos[0], rewind_pos[1], rewind_pos[2]);
		Cam_Angles_Set(rewind_angle[0], rewind_angle[1], rewind_angle[2]);
	}
	cls.findtrack		= false;

	R_ClearParticles();
	cls.demorewinding   = false;
}

// 
// Checks if demo needs to be rewound to previous point in time
//
void CL_Demo_Check_For_Rewind(float nextdemotime)
{
	// If we're seeking and our seek destination is in the past we need to rewind.
	if (cls.demoseeking && !cls.demorewinding && (cls.demotime < nextdemotime))
	{
		// Restart playback from the start of the file and then demo seek to the rewind spot.
		VFS_SEEK(playbackfile, 0, SEEK_SET);

		// We need to save track information.
		CL_MultiviewDemoStartRewind ();
		rewind_spec_track = WhoIsSpectated(); //spec_track;

		cls.findtrack = false;
		VectorCopy(cl.viewangles, rewind_angle);
		VectorCopy(cl.simorg, rewind_pos);

		// Restart the demo from scratch.
		CL_DemoPlaybackInit();

		cls.demopackettime  = 0.0;
		cls.demorewinding   = true;
	}
	
	if (cls.demorewinding)
	{
		// If we've reached active state, we can set the new demotime
		// to trigger the demo seek to the desired location.
		// Before we're active, cl.demotime will just get overwritten.
		if (cls.state >= ca_active)
		{
			cls.demotime = demostarttime + cls.demo_rewindtime;
			cls.demoseeking = DST_SEEKING_NORMAL;
			//cls.demorewinding = false;

			// We have now finished restarting the demo and will now seek
			// to the new demotime just like we do when seeking forward.
		}
	}
}

//
// Jumps to a specified time in a demo.
//
void CL_Demo_Jump_f (void)
{
    int seconds = 0, seen_col, relative = 0;
    char *text, *s;
	static char *usage_message = "Usage: %s [+|-][m:]<s> (seconds)\n";

	// Cannot jump without playing demo.
	if (!cls.demoplayback)
	{
		Com_Printf("Error: not playing a demo\n");
        return;
	}

	if (cls.mvdplayback == QTV_PLAYBACK)
	{
		Com_Printf("Error: cannot jump during QTV playback.\n");
		return;
	}

	// Must be active to jump.
	if (cls.state < ca_active)
	{
		Com_Printf("Error: demo must be active first\n");
		return;
	}

	// Show usage.
    if (Cmd_Argc() != 2)
	{
        Com_Printf(usage_message, Cmd_Argv(0));
        return;
    }

	// Get the jump string.
    text = Cmd_Argv(1);

	//
	// Parse which direction we're jumping in if
	// we're jumping relativly based on the current time.
	//
	if (text[0] == '-')
	{
		// Jumping backwards.
		text++;
		relative = -1;
	}
	else if (text[0] == '+')
	{
		// Jumping forward.
		text++;
		relative = 1;
	}
	else if (!isdigit(text[0]))
	{
		// Incorrect input, show usage message.
        Com_Printf(usage_message, Cmd_Argv(0));
        return;
	}

	// Find the number of colons (max 2 allowed) and make sure
	// we only have digits in the string.
	for (seen_col = 0, s = text; *s; s++)
	{
		if (*s == ':')
		{
			seen_col++;
		}
		else if (!isdigit(*s))
		{
			// Not a digit, show usage message.
			Com_Printf(usage_message, Cmd_Argv(0));
			return;
		}

		if (seen_col >= 2)
		{
			// More than two colons found, show usage message.
			Com_Printf(usage_message, Cmd_Argv(0));
			return;
		}
	}

	// If there's at least 1 colon we know everything
	// before it is minutes, so add it them to our jump time.
    if (strchr(text, ':'))
	{
        seconds += 60 * atoi(text);
        text = strchr(text, ':') + 1;
    }

	// The numbers after the first colon will be seconds.
    seconds += atoi(text);

	CL_Demo_Jump(seconds, relative, DST_SEEKING_NORMAL);
}

//
// Jumps to a specified time in a demo.
//
void CL_Demo_Jump_Mark_f (void)
{
	int seconds = 99999; // as far as possible, we have NO idea about time, we search MARK

	// Cannot jump without playing demo.
	if (!cls.demoplayback)
	{
		Com_Printf("Error: not playing a demo\n");
        return;
	}

	// Must be active to jump.
	if (cls.state < ca_active)
	{
		Com_Printf("Error: demo must be active first\n");
		return;
	}

	CL_Demo_Jump(seconds, 0, DST_SEEKING_DEMOMARK);
}

void CL_Demo_Jump_End_f(void)
{
	int target_time;

	// Cannot jump without playing demo.
	if (!cls.demoplayback) {
		Com_Printf("Error: not playing a demo\n");
		return;
	}

	// Must be active to jump.
	if (cls.state < ca_active) {
		Com_Printf("Error: demo must be active first\n");
		return;
	}

	target_time = (cls.demoplayback ? (int)ceil(CL_GetDemoLength()) - 2 : 0);
	if (target_time - (cls.demotime - demostarttime) < (cl.intermission ? 10 : 2)) {
		Com_Printf("Error: too close to end of demo\n");
		return;
	}

	CL_Demo_Jump(target_time, 0, DST_SEEKING_END);
}

static void CL_Demo_Jump_Status_Free (demoseekingstatus_condition_t *condition)
{
	if (condition == NULL)
		return;

	CL_Demo_Jump_Status_Free(condition->or);
	CL_Demo_Jump_Status_Free(condition->and);

	Q_free(condition);
}

static demoseekingstatus_condition_t *CL_Demo_Jump_Status_Condition_New (demoseekingstatus_matchtype_t type, int stat, int value)
{
	demoseekingstatus_condition_t *condition = Q_malloc(sizeof(demoseekingstatus_condition_t));

	condition->type = type;
	condition->stat = stat;
	condition->value = value;
	condition->or = NULL;
	condition->and = NULL;

	return condition;
}

static void CL_Demo_Jump_Status_Condition_Negate (demoseekingstatus_condition_t *condition)
{
	switch (condition->type) {
		case DEMOSEEKINGSTATUS_MATCH_EQUAL:
			condition->type = DEMOSEEKINGSTATUS_MATCH_NOT_EQUAL;
			break;
		case DEMOSEEKINGSTATUS_MATCH_NOT_EQUAL:
			condition->type = DEMOSEEKINGSTATUS_MATCH_EQUAL;
			break;
		case DEMOSEEKINGSTATUS_MATCH_LESS_THAN:
			condition->type = DEMOSEEKINGSTATUS_MATCH_GREATER_THAN;
			condition->value -= 1;
			break;
		case DEMOSEEKINGSTATUS_MATCH_GREATER_THAN:
			condition->type = DEMOSEEKINGSTATUS_MATCH_LESS_THAN;
			condition->value += 1;
			break;
		case DEMOSEEKINGSTATUS_MATCH_BIT_ON:
			condition->type = DEMOSEEKINGSTATUS_MATCH_BIT_OFF;
			break;
		case DEMOSEEKINGSTATUS_MATCH_BIT_OFF:
			condition->type = DEMOSEEKINGSTATUS_MATCH_BIT_ON;
			break;
		default:
			assert(false);
			break;
	}
}

static qbool CL_Demo_Jump_Status_Match (demoseekingstatus_condition_t *condition)
{
	if (condition->or && CL_Demo_Jump_Status_Match(condition->or))
		return true;

	switch (condition->type) {
		case DEMOSEEKINGSTATUS_MATCH_EQUAL:
			if (cl.stats[condition->stat] != condition->value)
				return false;
			break;
		case DEMOSEEKINGSTATUS_MATCH_NOT_EQUAL:
			if (cl.stats[condition->stat] == condition->value)
				return false;
			break;
		case DEMOSEEKINGSTATUS_MATCH_LESS_THAN:
			if (cl.stats[condition->stat] >= condition->value)
				return false;
			break;
		case DEMOSEEKINGSTATUS_MATCH_GREATER_THAN:
			if (cl.stats[condition->stat] <= condition->value)
				return false;
			break;
		case DEMOSEEKINGSTATUS_MATCH_BIT_ON:
			if (!(cl.stats[condition->stat] & condition->value))
				return false;
			break;
		case DEMOSEEKINGSTATUS_MATCH_BIT_OFF:
			if (cl.stats[condition->stat] & condition->value)
				return false;
			break;
		default:
			assert(false);
			return false;
	}

	if (condition->and != NULL) {
		return CL_Demo_Jump_Status_Match(condition->and);
	} else {
		return true;
	}
}

void CL_Demo_Jump_Status_Check (void)
{
	if (CL_Demo_Jump_Status_Match(cls.demoseekingstatus.conditions)) {
		if (cls.demoseekingstatus.non_matching_found) {
			CL_Demo_Jump_Status_Free(cls.demoseekingstatus.conditions);
			cls.demoseekingstatus.conditions = NULL;
			cls.demoseeking = DST_SEEKING_FOUND;
		}
	} else if (!cls.demoseekingstatus.non_matching_found) {
		cls.demoseekingstatus.non_matching_found = true;
	}
}

static int CL_Demo_Jump_Status_Parse_Weapon (const char *arg)
{
	if (!strcasecmp("axe", arg)) {
		return IT_AXE;
	} else if (!strcasecmp("sg", arg)) {
		return IT_SHOTGUN;
	} else if (!strcasecmp("ssg", arg)) {
		return IT_SUPER_SHOTGUN;
	} else if (!strcasecmp("ng", arg)) {
		return IT_NAILGUN;
	} else if (!strcasecmp("sng", arg)) {
		return IT_SUPER_NAILGUN;
	} else if (!strcasecmp("gl", arg)) {
		return IT_GRENADE_LAUNCHER;
	} else if (!strcasecmp("rl", arg)) {
		return IT_ROCKET_LAUNCHER;
	} else if (!strcasecmp("lg", arg)) {
		return IT_LIGHTNING;
	} else {
		return 0;
	}
}

static int CL_Demo_Jump_Status_Parse_Constraint (const char *arg, int *value)
{
	if (strlen(arg) < 2)
		return -1;

	*value = Q_atoi(arg+1);

	switch (arg[0]) {
		case '=':
			return DEMOSEEKINGSTATUS_MATCH_EQUAL;
		case '<':
			return DEMOSEEKINGSTATUS_MATCH_LESS_THAN;
		case '>':
			return DEMOSEEKINGSTATUS_MATCH_GREATER_THAN;
		default:
			return -1;
	}
}

//
// Jumps to a point in demo based on the status of player in POV
//
static void CL_Demo_Jump_Status_f (void)
{
	int i;
	qbool or = false;
	demoseekingstatus_condition_t *parent = NULL;

	if (Cmd_Argc() < 2) {
		Com_Printf("Usage: %s <conditions>\n", Cmd_Argv(0));
		Com_Printf("\n");
		Com_Printf("Skip forward in the demo until the conditions based on the player in POV are met.\n");
		Com_Printf("\n");
		Com_Printf("Valid conditions are:\n");
		Com_Printf("  Weapon, armor and powerup names (rl, ya, quad etc.), for items held\n");
		Com_Printf("  Weapon names with + in front (+rl), for the weapon in hand\n");
		Com_Printf("  Constraints on health, armor and ammo held with syntax id=value, id<value or id>value\n");
		Com_Printf("    The id can be h for health, a for armor, s for shells, n for nails, r for rockets or c for cells\n");
		Com_Printf("  All the conditions can be negated by inserting a ! character in front\n");
		Com_Printf("  Special value \"or\" can be used to connect two conditions requiring only one of them to be true\n");
		Com_Printf("\n");
		Com_Printf("Example: %s h<1 +rl or +lg\n", Cmd_Argv(0));
		Com_Printf("  Skip to the next position where player in the POV drops a RL or LG pack\n");
		return;
	}

	// Cannot jump without playing demo.
	if (!cls.demoplayback) {
		Com_Printf("Error: not playing a demo\n");
		return;
	}

	// Must be active to jump.
	if (cls.state < ca_active) {
		Com_Printf("Error: demo must be active first\n");
		return;
	}

	cls.demoseekingstatus.non_matching_found = false;
	CL_Demo_Jump_Status_Free(cls.demoseekingstatus.conditions);
	cls.demoseekingstatus.conditions = NULL;

	for (i = 1; i < Cmd_Argc(); i++) {
		demoseekingstatus_condition_t *condition = NULL;
		qbool neg = false;
		char *arg = Cmd_Argv(i);
		int weapon, value;
		int type;

		if (!strcasecmp("or", arg)) {
			if (cls.demoseekingstatus.conditions == NULL) {
				Com_Printf("Error: or can't be the first argument\n");
				return;
			}
			or = true;
			continue;
		}

		if (arg[0] == '!') {
			neg = true;
			arg++;
		}

		if ((weapon = CL_Demo_Jump_Status_Parse_Weapon(arg)) != 0) {
			condition = CL_Demo_Jump_Status_Condition_New(DEMOSEEKINGSTATUS_MATCH_BIT_ON, STAT_ITEMS, weapon);
		} else if (arg[0] == '+' && (weapon = CL_Demo_Jump_Status_Parse_Weapon(arg+1)) != 0) {
			condition = CL_Demo_Jump_Status_Condition_New(DEMOSEEKINGSTATUS_MATCH_EQUAL, STAT_ACTIVEWEAPON, weapon);
		} else if (arg[0] == 'h' && (type = CL_Demo_Jump_Status_Parse_Constraint(arg+1, &value)) >= 0) {
			condition = CL_Demo_Jump_Status_Condition_New(type, STAT_HEALTH, value);
		} else if (arg[0] == 'a' && (type = CL_Demo_Jump_Status_Parse_Constraint(arg+1, &value)) >= 0) {
			condition = CL_Demo_Jump_Status_Condition_New(type, STAT_ARMOR, value);
		} else if (arg[0] == 's' && (type = CL_Demo_Jump_Status_Parse_Constraint(arg+1, &value)) >= 0) {
			condition = CL_Demo_Jump_Status_Condition_New(type, STAT_SHELLS, value);
		} else if (arg[0] == 'n' && (type = CL_Demo_Jump_Status_Parse_Constraint(arg+1, &value)) >= 0) {
			condition = CL_Demo_Jump_Status_Condition_New(type, STAT_NAILS, value);
		} else if (arg[0] == 'r' && (type = CL_Demo_Jump_Status_Parse_Constraint(arg+1, &value)) >= 0) {
			condition = CL_Demo_Jump_Status_Condition_New(type, STAT_ROCKETS, value);
		} else if (arg[0] == 'c' && (type = CL_Demo_Jump_Status_Parse_Constraint(arg+1, &value)) >= 0) {
			condition = CL_Demo_Jump_Status_Condition_New(type, STAT_CELLS, value);
		} else if (!strcasecmp("ga", arg)) {
			condition = CL_Demo_Jump_Status_Condition_New(DEMOSEEKINGSTATUS_MATCH_BIT_ON, STAT_ITEMS, IT_ARMOR1);
		} else if (!strcasecmp("ya", arg)) {
			condition = CL_Demo_Jump_Status_Condition_New(DEMOSEEKINGSTATUS_MATCH_BIT_ON, STAT_ITEMS, IT_ARMOR2);
		} else if (!strcasecmp("ra", arg)) {
			condition = CL_Demo_Jump_Status_Condition_New(DEMOSEEKINGSTATUS_MATCH_BIT_ON, STAT_ITEMS, IT_ARMOR3);
		} else if (!strcasecmp("quad", arg)) {
			condition = CL_Demo_Jump_Status_Condition_New(DEMOSEEKINGSTATUS_MATCH_BIT_ON, STAT_ITEMS, IT_QUAD);
		} else if (!strcasecmp("ring", arg)) {
			condition = CL_Demo_Jump_Status_Condition_New(DEMOSEEKINGSTATUS_MATCH_BIT_ON, STAT_ITEMS, IT_INVISIBILITY);
		} else if (!strcasecmp("pent", arg)) {
			condition = CL_Demo_Jump_Status_Condition_New(DEMOSEEKINGSTATUS_MATCH_BIT_ON, STAT_ITEMS, IT_INVULNERABILITY);
		} else {
			Com_Printf("Error: unknown condition: %s\n", Cmd_Argv(i));
			CL_Demo_Jump_Status_Free(cls.demoseekingstatus.conditions);
			cls.demoseekingstatus.conditions = NULL;
			return;
		}

		if (neg)
			CL_Demo_Jump_Status_Condition_Negate(condition);

		if (parent != NULL) {
			if (or) {
				parent->or = condition;
			} else {
				parent->and = condition;
			}
		} else {
			cls.demoseekingstatus.conditions = condition;
		}
		parent = condition;
		or = false;
	}

	CL_Demo_Jump(99999, 0, DST_SEEKING_STATUS);
}


//
// Jumps to a specified time in a demo. Time specified in seconds.
//
void CL_Demo_Jump(double seconds, int relative, demoseekingtype_t seeking)
{
	// Calculate the new demo time we want to jump to.
	double initialtime = (cls.nqdemoplayback ? cl.servertime : cls.demotime);
	double newdemotime = relative ? (initialtime + (relative * seconds)) : (demostarttime + seconds);

	// We need to rewind.
	if (newdemotime < initialtime)
	{
		cls.demo_rewindtime = newdemotime - demostarttime;
	}

	// Set the new demotime.	
	cls.demotime = newdemotime;

	cls.demoseeking = seeking;
	Con_ClearNotify ();
}

double Demo_GetSpeed(void)
{
	if (cls.mvdplayback == QTV_PLAYBACK) {
		return qtv_demospeed;
	}

	return bound(0, cl_demospeed.value, 20);
}

qbool qtv_playback_paused;

void Demo_AdjustSpeed(void)
{
	if (cls.mvdplayback == QTV_PLAYBACK) {
		if (qtv_playback_paused) {
			qtv_demospeed = 0;
			return;
		}

		if (qtv_adjustbuffer.integer) {
			int				ms;
			double			demospeed, desired, current;

			Demo_BufferSize(&ms);

			desired = max(0.5, QTVBUFFERTIME); // well, we need some reserve for adjusting
			current = 0.001 * ms;

			// adjustbuffer 1 (original): adjustments are made based on % of buffer filled
			if (qtv_adjustbuffer.integer != 2) {
				// qqshka: this is linear version
				demospeed = current / desired;

				// if you unwilling constant speed change, then you can set range with qtv_adjustlowstart and qtv_adjusthighstart
				if (demospeed > bound(0, qtv_adjustlowstart.value, 1) && demospeed < max(1, qtv_adjusthighstart.value)) {
					demospeed = 1;
				}
			}
			else {
				// adjustments made to keep within 0.5 seconds of target buffertime
				float minimum = max(0.5, desired - 0.5);
				float maximum = minimum + 1.0;
				float diff;

				current = bound(minimum, current, maximum);

				// Smootherstep
				if (current < desired) {
					// Slow down
					diff = desired - current;
					diff = diff * diff * diff * (diff * (diff * 6 - 15) + 10);
					demospeed = 1 - diff;
				}
				else {
					// Speed up
					diff = current - desired;
					diff = diff * diff * diff * (diff * (diff * 6 - 15) + 10);
					demospeed = 1 + diff;
				}
			}

			// bound demospeed
			demospeed = bound(qtv_adjustminspeed.value, demospeed, qtv_adjustmaxspeed.value);

			qtv_demospeed = demospeed;
			return;
		}

		if (!qtv_allow_pause.value) {
			qtv_demospeed = 1;
			return;
		}
	}
	
	qtv_demospeed = bound(0, cl_demospeed.value, 20);
}

// 
void CL_QTVFixUser_f(void) {
	int uid, i;
	char newuserinfo[MAX_INFO_STRING] = { 0 };
	char* newName = NULL;
	char* newTeam = NULL;
	int topcolor = 0;
	int bottomcolor = 0;
	qbool isSpectator = (Cmd_Argc() >= 3 && !strcmp(Cmd_Argv(2), "spectator"));
	qbool isPlayer = (Cmd_Argc() >= 3 && !strcmp(Cmd_Argv(2), "player"));

	if (!cls.demoplayback || cls.mvdplayback != QTV_PLAYBACK) {
		Com_Printf("Only valid when viewing QTV streams.", Cmd_Argv(0));
		return;
	}

	if (Cmd_Argc() <= 3 || !(isSpectator || isPlayer)) {
		Com_Printf("Usage: %s <userid> <spectator | player> <name> [team] [topcolor] [bottomcolor]\n", Cmd_Argv(0));
		Com_Printf("This allows you to directly set user info fields on bugged QTV streams.\n");
		Com_Printf("------ ----- ----\n");
		Com_Printf("userid frags name\n");
		Com_Printf("------ ----- ----\n");
		for (i = 0; i < MAX_CLIENTS; i++) {
			if (cl.players[i].name[0] || cl.players[i].userinfo[0] || cl.players[i].frags) {
				Com_Printf("%6i %4i %s\n", cl.players[i].userid, cl.players[i].frags, cl.players[i].name);
			}
		}
		return;
	}

	uid = atoi(Cmd_Argv(1));
	newName = Cmd_Argv(3);
	newTeam = Cmd_Argc() <= 4 ? "" : Cmd_Argv(4);
	topcolor = Cmd_Argc() <= 5 ? 0 : atoi(Cmd_Argv(5));
	bottomcolor = Cmd_Argc() <= 6 ? topcolor : atoi(Cmd_Argv(6));

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] && !cl.players[i].userinfo[0] && !cl.players[i].frags)
			continue;

		if (cl.players[i].userid == uid) {
			player_info_t* player = &cl.players[i];

			strcpy(newuserinfo, "\\*client\\QTVBug");
			strlcat(newuserinfo, "\\name\\", MAX_INFO_STRING);
			strlcat(newuserinfo, newName, MAX_INFO_STRING);

			if (isSpectator) {
				strlcat(newuserinfo, "\\*spectator\\1", MAX_INFO_STRING);
			}

			if (*newTeam) {
				strlcat(newuserinfo, "\\team\\", MAX_INFO_STRING);
				strlcat(newuserinfo, newTeam, MAX_INFO_STRING);
			}

			strlcat(newuserinfo, "\\topcolor\\", MAX_INFO_STRING);
			strlcat(newuserinfo, va("%d", topcolor), MAX_INFO_STRING);
			strlcat(newuserinfo, "\\bottomcolor\\", MAX_INFO_STRING);
			strlcat(newuserinfo, va("%d", bottomcolor), MAX_INFO_STRING);

			// Our scoreboard will set spectators to -999 frags for sorting, so reset and wait for server update
			if (player->spectator && player->frags == -999 && isPlayer)
				player->frags = 0;

			memset(player->userinfo, 0, sizeof(player->userinfo));
			strlcpy(player->userinfo, newuserinfo, MAX_INFO_STRING);
			CL_ProcessUserInfo(i, player, NULL);
			return;
		}
	}
	Com_Printf("User not in server.\n");
}

//
// Inits the demo cache and adds demo commands.
//
void CL_Demo_Init(void)
{
	int parm, democache_size;
	byte *democache_buffer;

	//
	// Init the demo cache if the user specified to use one.
	//
	democache_available = false;
	if ((parm = COM_CheckParm(cmdline_param_client_democache)) && parm + 1 < COM_Argc())
	{
		democache_size = Q_atoi(COM_Argv(parm + 1)) * 1024;
		democache_size = max(democache_size, DEMOCACHE_MINSIZE);
		if ((democache_buffer = (byte *) malloc (democache_size)))
		{
			Com_Printf_State (PRINT_OK, "Democache initialized (%.1f MB)\n", (float) (democache_size) / (1024 * 1024));
			SZ_Init(&democache, democache_buffer, democache_size);
			democache_available = true;
		}
		else
		{
			Com_Printf_State (PRINT_FAIL, "Democache allocation failed\n");
		}
	}

	//
	// Add demo commands.
	//
	Cmd_AddCommand ("record", CL_Record_f);
	Cmd_AddCommand ("recordqwd", CL_Record_f);
	Cmd_AddCommand ("stop", CL_Stop_f);
	Cmd_AddCommand ("stopqwd", CL_Stop_f);
	Cmd_AddCommand ("playdemo", CL_Play_f);
	Cmd_AddCommand ("timedemo", CL_TimeDemo_f);
	Cmd_AddCommand ("timedemo2", CL_TimeDemo_f);
	Cmd_AddCommand ("easyrecord", CL_EasyRecord_f);

	Cmd_AddCommand("demo_setspeed", CL_Demo_SetSpeed_f);
	Cmd_AddCommand("demo_jump", CL_Demo_Jump_f);
	Cmd_AddCommand("demo_jump_mark", CL_Demo_Jump_Mark_f);
	Cmd_AddCommand("demo_jump_status", CL_Demo_Jump_Status_f);
	Cmd_AddCommand("demo_jump_end", CL_Demo_Jump_End_f);
	Cmd_AddCommand("demo_controls", DemoControls_f);

	//
	// mvd "recording"
	//
	Cmd_AddCommand("mvdrecord", CL_RecordMvd_f);
	Cmd_AddCommand("mvdstop", CL_StopMvd_f);

	//
	// QTV commands.
	//
	Cmd_AddCommand ("qtvplay", CL_QTVPlay_f);
	Cmd_AddCommand ("qtv_query_sourcelist", CL_QTVList_f);
	Cmd_AddCommand ("qtv_query_demolist", CL_QTVList_f);
	Cmd_AddCommand ("qtvreconnect", CL_QTVReconnect_f);
	Cmd_AddCommand ("qtv_fixuser", CL_QTVFixUser_f);

	// Macros
	Cmd_AddMacro (macro_demoname, CL_Macro_DemoName_f);
	Cmd_AddMacro (macro_demolength, CL_Macro_DemoLength_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_DEMO);
	Cvar_Register(&demo_format);
	Cvar_Register(&demo_dir);
	Cvar_Register(&demo_benchmarkdumps);
	Cvar_Register(&cl_startupdemo);
	Cvar_Register(&demo_jump_rewind);
	Cvar_Register(&cl_demo_qwd_delta);
	Cvar_Register(&demo_jump_skip_messages);

	Cvar_ResetCurrentGroup();
}

qbool CL_Demo_NotForTrackedPlayer(void)
{
	int tracknum = Cam_TrackNum();

	if (cls.lasttype == dem_multiple && ((tracknum == -1) || !(cls.lastto & (1 << tracknum))))
		return true;
	if (cls.lasttype == dem_single && ((tracknum == -1) || (cls.lastto != cl.spec_track)))
		return true;

	return false;
}

qbool CL_Demo_SkipMessage (qbool skip_if_seeking)
{
	if (!cls.demoplayback)
		return false;
	if (skip_if_seeking && cls.demoseeking)
		return true;
	if (!cls.mvdplayback)
		return false;

	return CL_Demo_NotForTrackedPlayer();
}

qbool SCR_QTVBufferToBeDrawn(int options)
{
	return (options == 1 && cls.mvdplayback == QTV_PLAYBACK) || (options > 1 && cls.mvdplayback && !FSMMAP_IsMemoryMapped(playbackfile));
}

int Demo_BufferSize(int* ms)
{
	return ConsistantMVDDataEx(stream_buffer, stream_buffer_cnt, ms, 0);
}


================================================
FILE: src/cl_ents.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "vx_stuff.h"
#include "pmove.h"
#include "utils.h"
#include "qmb_particles.h"
#include "rulesets.h"
#include "teamplay.h"

static int MVD_TranslateFlags(int src);
void TP_ParsePlayerInfo(player_state_t *, player_state_t *, player_info_t *info);	

extern cvar_t cl_predict_players, cl_solid_players, cl_rocket2grenade;
extern cvar_t cl_predict_half;
extern cvar_t cl_model_bobbing;		
extern cvar_t cl_nolerp, cl_lerp_monsters, cl_newlerp;
extern cvar_t r_drawvweps;		
extern  unsigned int     cl_dlight_active[MAX_DLIGHTS/32];       

static struct predicted_player {
	int flags;
	qbool active;
	vec3_t origin;	// predicted origin

	qbool predict;
	vec3_t	oldo;
	vec3_t	olda;
	vec3_t	oldv;
	player_state_t *oldstate;

	qbool drawn;
	vec3_t drawn_origin;
	int msec;
	float paused_sec;
} predicted_players[MAX_CLIENTS];

char *cl_modelnames[cl_num_modelindices];
int cl_modelindices[cl_num_modelindices];

void CL_InitEnts(void) {
	int i;

	memset(cl_modelnames, 0, sizeof(cl_modelnames));

	cl_modelnames[mi_spike] = "progs/spike.mdl";
	cl_modelnames[mi_player] = "progs/player.mdl";
	cl_modelnames[mi_eyes] = "progs/eyes.mdl";
	cl_modelnames[mi_flag] = "progs/flag.mdl";
	cl_modelnames[mi_tf_flag] = "progs/tf_flag.mdl";
	cl_modelnames[mi_tf_stan] = "progs/tf_stan.mdl";
	cl_modelnames[mi_stag] = "progs/stag.mdl";
	cl_modelnames[mi_basrkey] = "progs/basrkey.bsp";
	cl_modelnames[mi_basbkey] = "progs/basbkey.bsp";
	cl_modelnames[mi_w_s_key] = "progs/w_s_key.mdl";
	cl_modelnames[mi_w_g_key] = "progs/w_g_key.mdl";
	cl_modelnames[mi_b_g_key] = "progs/b_g_key.mdl";
	cl_modelnames[mi_b_s_key] = "progs/b_s_key.mdl";
	cl_modelnames[mi_ff_flag] = "progs/ff_flag.mdl";
	cl_modelnames[mi_harbflag] = "progs/harbflag.mdl";
	cl_modelnames[mi_princess] = "progs/princess.mdl";
	cl_modelnames[mi_explod1] = "progs/s_explod.spr";
	cl_modelnames[mi_explod2] = "progs/s_expl.spr";
	cl_modelnames[mi_h_player] = "progs/h_player.mdl";
	cl_modelnames[mi_gib1] = "progs/gib1.mdl";
	cl_modelnames[mi_gib2] = "progs/gib2.mdl";
	cl_modelnames[mi_gib3] = "progs/gib3.mdl";
	cl_modelnames[mi_rocket] = "progs/missile.mdl";
	cl_modelnames[mi_grenade] = "progs/grenade.mdl";
	cl_modelnames[mi_bubble] = "progs/s_bubble.spr";
	cl_modelnames[mi_flame] = "progs/flame.mdl";	//joe

	// carried weapon models (drawviewmodel)
	cl_modelnames[mi_weapon1] = "progs/v_axe.mdl";
	cl_modelnames[mi_weapon2] = "progs/v_shot.mdl";
	cl_modelnames[mi_weapon3] = "progs/v_shot2.mdl";
	cl_modelnames[mi_weapon4] = "progs/v_nail.mdl";
	cl_modelnames[mi_weapon5] = "progs/v_nail2.mdl";
	cl_modelnames[mi_weapon6] = "progs/v_rock.mdl";
	cl_modelnames[mi_weapon7] = "progs/v_rock2.mdl";
	cl_modelnames[mi_weapon8] = "progs/v_light.mdl";

	cl_modelnames[mi_vaxe] = "progs/v_axe.mdl";
	cl_modelnames[mi_vbio] = "progs/v_bio.mdl";
	cl_modelnames[mi_vgrap] = "progs/v_grap.mdl";
	cl_modelnames[mi_vknife] = "progs/v_knife.mdl";
	cl_modelnames[mi_vknife2] = "progs/v_knife2.mdl";
	cl_modelnames[mi_vmedi] = "progs/v_medi.mdl";
	cl_modelnames[mi_vspan] = "progs/v_span.mdl";
	// monsters
	cl_modelnames[mi_monster1] = "progs/soldier.mdl";
	cl_modelnames[mi_m2] = "progs/dog.mdl";
	cl_modelnames[mi_m3] = "progs/demon.mdl";
	cl_modelnames[mi_m4] = "progs/ogre.mdl";
	cl_modelnames[mi_m5] = "progs/shambler.mdl";
	cl_modelnames[mi_m6] = "progs/knight.mdl";
	cl_modelnames[mi_m7] = "progs/zombie.mdl";
	cl_modelnames[mi_m8] = "progs/wizard.mdl";
	cl_modelnames[mi_m9] = "progs/enforcer.mdl";
	cl_modelnames[mi_m10] = "progs/fish.mdl";
	cl_modelnames[mi_m11] = "progs/hknight.mdl";
	cl_modelnames[mi_m12] = "progs/shalrath.mdl";
	cl_modelnames[mi_m13] = "progs/tarbaby";
	// hipnotic monsters
	cl_modelnames[mi_m14] = "progs/armabody.mdl";
	cl_modelnames[mi_m15] = "progs/armalegs.mdl";
	cl_modelnames[mi_m16] = "progs/grem.mdl";
	cl_modelnames[mi_m17] = "progs/scor.mdl";

	// Item sprites.
	// FIXME : 32-bit sprites not working properly.
	#if 0
	cl_modelnames[mi_2dshells]		= "sprites/s_shells.spr";
	cl_modelnames[mi_2dcells]		= "sprites/s_cells.spr";
	cl_modelnames[mi_2drockets]		= "sprites/s_rockets.spr";
	cl_modelnames[mi_2dnails]		= "sprites/s_nails.spr";
	cl_modelnames[mi_2dmega]		= "sprites/s_mega.spr";
	cl_modelnames[mi_2dpent]		= "sprites/s_invuln.spr";
	cl_modelnames[mi_2dquad]		= "sprites/s_quad.spr";
	cl_modelnames[mi_2dring]		= "sprites/s_invis.spr";
	cl_modelnames[mi_2dsuit]		= "sprites/s_suit.spr";
	cl_modelnames[mi_2darmor1]		= "sprites/s_armor1.spr";
	cl_modelnames[mi_2darmor2]		= "sprites/s_armor2.spr";
	cl_modelnames[mi_2darmor3]		= "sprites/s_armor3.spr";
	cl_modelnames[mi_2dbackpack]	= "sprites/s_backpack.spr";
	cl_modelnames[mi_2dhealth10]	= "sprites/s_health10.spr";
	cl_modelnames[mi_2dhealth25]	= "sprites/s_health25.spr";
	#endif

	for (i = 0; i < cl_num_modelindices; i++) {
		if (!cl_modelnames[i]) {
			Sys_Error("cl_modelnames[%d] not initialized", i);
		}
	}

	CL_ClearScene();
}

static qbool is_monster (int modelindex)
{
	int i;
	if (!cl_lerp_monsters.value)
		return false;
	for (i = 1; i < 17; i++)
		if (modelindex == cl_modelindices[mi_monster1 + i - 1])
			return true;
	return false;
}

void CL_ClearScene(void) {
	if (cl_visents.count > 0)
	{
		memset(cl_visents.list, 0, sizeof(cl_visents.list[0]) * cl_visents.count);
	}
	memset(cl_visents.typecount, 0, sizeof(cl_visents.typecount));
	cl_visents.count = 0;
}

void CL_AddEntityToList(visentlist_t* list, visentlist_entrytype_t vistype, entity_t* ent, modtype_t type, qbool shell)
{
	extern cvar_t gl_outline;

	if (list->count < sizeof(list->list) / sizeof(list->list[0])) {
		list->list[cl_visents.count].ent = *ent;

		ent = &list->list[cl_visents.count].ent;
		list->list[cl_visents.count].type = type;
		if (vistype == visent_alpha) {
			// Sort transparent entities based on closest point for stable back-to-front rendering.
			vec3_t distance;
			int i;
			for (i = 0; i < 3; i++) {
				distance[i] = r_refdef.vieworg[i] - ent->origin[i];
				distance[i] -= bound(ent->model->mins[i], distance[i], ent->model->maxs[i]);
			}
			list->list[cl_visents.count].distance = DotProduct(distance, distance);
		} else {
			list->list[cl_visents.count].distance = VectorDistanceQuick(cl.simorg, ent->origin);
		}
		list->list[cl_visents.count].draw[vistype] = true;

		ent->outlineScale = 0.5f * (r_refdef2.outlineBase + DotProduct(ent->origin, r_refdef2.outline_vpn));
		ent->outlineScale = bound(ent->outlineScale, 0, 2);

		++list->typecount[vistype];
		if (shell) {
			list->list[cl_visents.count].draw[visent_shells] = true;
			++list->typecount[visent_shells];
		}
		// Check for outline on models.
		// We don't support outline for transparent models,
		// and we also check for ruleset, since we don't want outline on eyes.
		if (((gl_outline.integer & 1) && !RuleSets_DisallowModelOutline(ent->model))) {
			list->list[cl_visents.count].draw[visent_outlines] = true;
			++list->typecount[visent_outlines];
		}

		++list->count;
	}
}

void CL_AddEntity(entity_t *ent)
{
	extern qbool R_CanDrawSimpleItem(entity_t* ent);
	visentlist_entrytype_t vistype;
	modtype_t type = ent->model->type;
	qbool shell = false;
	extern cvar_t gl_powerupshells;

	if ((ent->effects & (EF_BLUE | EF_RED | EF_GREEN)) && bound(0, gl_powerupshells.value, 1)) {
		if (R_CanDrawSimpleItem(ent)) {
			vistype = visent_alpha;
			type = mod_sprite;
		}
		else {
			vistype = visent_normal;
			shell = true;
		}
	}
	else if (ent->renderfx & RF_NORMALENT) {
		vistype = visent_normal;
	}
	else if (ent->model->type == mod_sprite || R_CanDrawSimpleItem(ent)) {
		vistype = visent_alpha;
		type = mod_sprite;
	}
	else if (ent->model->modhint == MOD_PLAYER || ent->model->modhint == MOD_EYES || ent->renderfx & RF_PLAYERMODEL) {
		vistype = visent_firstpass;
		ent->renderfx |= RF_NOSHADOW;
	}
	else if (ent->alpha > 0.0f && ent->alpha < 1.0f) {
		vistype = visent_alpha;
	}
	else {
		vistype = visent_normal;
	}

	CL_AddEntityToList(&cl_visents, vistype, ent, type, shell);
}

// NUM_DLIGHTTYPES - this constant not used here, but help u find dynamic light related code if u change something
static dlighttype_t dl_colors[] = {lt_red, lt_blue, lt_redblue, lt_green, lt_redgreen, lt_bluegreen, lt_white};
static int dl_colors_cnt = sizeof(dl_colors) / sizeof(dl_colors[0]);

dlighttype_t dlightColor(float f, dlighttype_t def, qbool random) {

	if ((int) f >= 1 && (int) f <= dl_colors_cnt)
		return dl_colors[(int) f - 1];
	else if (((int) f == dl_colors_cnt + 1) && random)
		return dl_colors[rand() % dl_colors_cnt];
	else
		return def;
}

// if we have color in "r g b" format use it overwise use pre defined colors
customlight_t *dlightColorEx(float f, char *str, dlighttype_t def, qbool random, customlight_t *l) 
{
	// TODO : Ok to use this in software also?
	byte color[4];
	int i;

	i = StringToRGB_W(str, color);

	if (i > 1)
		l->type = lt_custom; // we got at least two params so treat this as custom color
	else
		l->type = dlightColor(f, def, random); // this may set lt_custom too

	if (l->type == lt_custom)
		for (i = 0; i < 3; i++)
			l->color[i] = min(128, color[i]); // i've seen color set in float form to 0.5 maximum and to 128 in byte form, so keep this tradition even i'm do not understand why they do so
	l->alpha = color[3];

	return l;
}

dlight_t *CL_AllocDlight(int key)
{
	unsigned int i;
	unsigned int j;
	dlight_t *dl;

	// first look for an exact key match
	if (key) {
		dl = cl_dlights;
		for (i = 0; i < MAX_DLIGHTS; i++, dl++) {
			if (dl->key == key) {
				memset (dl, 0, sizeof(*dl));
				dl->key = key;
				cl_dlight_active[i/32] |= (1<<(i%32));
				return dl;
			}
		}
	}

	// then look for anything else
	for (i = 0; i < MAX_DLIGHTS/32; i++) {
		if (cl_dlight_active[i] != 0xffffffff) {
			for (j = 0; j < 32; j++) {
				if (!(cl_dlight_active[i] & (1<<j)) && i*32+j < MAX_DLIGHTS) {
					dl = cl_dlights + i * 32 + j;
					memset(dl, 0, sizeof(*dl));
					dl->key = key;
					cl_dlight_active[i] |= 1<<j;
					return dl;
				}
			}
		}
	}

	dl = &cl_dlights[0];
	memset (dl, 0, sizeof(*dl));
	dl->key = key;
	cl_dlight_active[0] |= 1;

	return dl;
}


void CL_NewDlight (int key, vec3_t origin, float radius, float time, dlighttype_t type, int bubble) {
	dlight_t *dl;

	dl = CL_AllocDlight (key);
	VectorCopy (origin, dl->origin);
	dl->radius = radius;
	dl->die = cl.time + time;
	dl->type = type;
	dl->bubble = bubble;		
}

void CL_NewDlightEx (int key, vec3_t origin, float radius, float time, customlight_t *l, int bubble) {
// same as CL_NewDlight {
	dlight_t *dl;

	dl = CL_AllocDlight (key);
	VectorCopy (origin, dl->origin);
	dl->radius = radius;
	dl->die = cl.time + time;
	dl->type = l->type; // <= only here difference
	dl->bubble = bubble;
// }

	// and GL addon for custom color
	if (dl->type == lt_custom)
		VectorCopy(l->color, dl->color);
}

void CL_DecayLights(void)
{
	unsigned int i;
	unsigned int j;
	dlight_t *dl;
	extern cvar_t r_lightdecayrate;

	if (cls.state < ca_active) {
		return;
	}

	for (i = 0; i < MAX_DLIGHTS/32; i++) {
		if (cl_dlight_active[i]) {
			for (j = 0; j < 32; j++) {
				if ((cl_dlight_active[i]&(1<<j)) && i*32+j < MAX_DLIGHTS) {
					dl = cl_dlights + i*32 + j;

					if (dl->die < cl.time) {
						cl_dlight_active[i] &= ~(1 << j);
						dl->radius = 0;
						continue;
					}

					dl->radius -= max(r_lightdecayrate.value, 1) * cls.frametime * dl->decay;

					if (dl->radius <= 0) {
						cl_dlight_active[i] &= ~(1 << j);
						dl->radius = 0;
						continue;
					}
				}
			}
		}
	}
}

qbool NewLerp_AbleModel(int idx)
{
	return !cls.demoplayback && cl_newlerp.value && 
			(idx == cl_modelindices[mi_rocket] || idx == cl_modelindices[mi_grenade] || idx == cl_modelindices[mi_spike]);
}

void CL_SetupPacketEntity (int number, entity_state_t *state, qbool changed) {
	centity_t *cent;
	int t;

	cent = &cl_entities[number];

	if (!cl.oldvalidsequence || cl.oldvalidsequence != cent->sequence ||
		state->modelindex != cent->current.modelindex ||
		!VectorL2Compare(state->origin, cent->current.origin, 200)
	) {
		cent->startlerp = cl.time;
		cent->deltalerp = -1;
		cent->frametime = -1;
		cent->oldsequence = 0;
		cent->trail_number = (cent->trail_number + 1) % 1000;
		for (t = 0; t < sizeof(cent->trails) / sizeof(cent->trails[0]); ++t) {
			cent->trails[t].lasttime = 0;
			VectorCopy(state->origin, cent->trails[t].stop);
		}
	}
	else {
		cent->oldsequence = cent->sequence;
		
		if (state->frame != cent->current.frame) {
			cent->frametime = cl.time;
			cent->oldframe = cent->current.frame;
		}
		
		if (changed) {
			if (!VectorCompare(state->origin, cent->current.origin) || !VectorCompare(state->angles, cent->current.angles)) {
			    if (NewLerp_AbleModel(state->modelindex)) {
			    	float s  = (cls.mvdplayback ? nextdemotime - olddemotime : cl.time - cent->startlerp); // time delta
			    	float s2 = 1.0 / (s ? s : 1); // here no function which divide vector by X value, so we multiplay vector by 1/X
			    	vec3_t tmp, tmp2;
					VectorSubtract(state->origin, cent->current.origin, tmp); // origin delta, also move direction
					VectorScale(tmp, s2, tmp2); // we divide origin delta by time delta, that velocity in other words

					if (cent->deltalerp == -1) {
						VectorCopy(tmp2, cent->velocity); // we got first velocity for our enitity, just save it
					}
					else {
						VectorAdd(tmp2, cent->velocity, cent->velocity);
						VectorScale(cent->velocity, 0.5, cent->velocity); // (previous velocity + current) / 2, we got average velocity
					}

//					Com_Printf("v: %6.1f %6.1f %6.1f %f %f\n", VectorLength(tmp), VectorLength(tmp2), VectorLength(cent->velocity), s2, s);

					if (cent->deltalerp == -1) { // seems we get second update for enitity from server, just save some vectors
						VectorCopy(cent->current.origin, cent->old_origin);
						VectorCopy(cent->current.origin, cent->lerp_origin);
					}
					else {
						// its correction due to round/interploation, we have our own vision where object, and server vision,
						// use 90% of our vision and 10% of server, that make things smooth and somehow accurate
						VectorInterpolate(cent->lerp_origin, cl_newlerp.value, cent->current.origin, cent->old_origin);
					}
			    }
				else 
				{
					VectorCopy(cent->current.origin, cent->old_origin);
				}

				VectorCopy(cent->current.angles, cent->old_angles);
				if (cls.mvdplayback) {
					cent->deltalerp = nextdemotime - olddemotime;
					cent->startlerp = cls.demotime;
				} else {
					cent->deltalerp = cl.time - cent->startlerp;
					cent->startlerp = cl.time;
				}
			}
		}
	}
 
	cent->current = *state;
	cent->sequence = cl.validsequence;
}

//Can go from either a baseline or a previous packet_entity
void CL_ParseDelta (entity_state_t *from, entity_state_t *to, int bits) {
	int i;
#ifdef PROTOCOL_VERSION_FTE
	int morebits;
#endif

	// set everything to the state we are delta'ing from
	*to = *from;

	to->number = bits & 511;
	bits &= ~511;

	if (bits & U_MOREBITS) {	// read in the low order bits
		i = MSG_ReadByte ();
		bits |= i;
	}

#ifdef PROTOCOL_VERSION_FTE
	if (bits & U_FTE_EVENMORE && cls.fteprotocolextensions) {
		morebits = MSG_ReadByte ();
		if (morebits & U_FTE_YETMORE)
			morebits |= MSG_ReadByte()<<8;
	} else {
		morebits = 0;
	}
#endif

	to->flags = bits;
	if (bits & U_MODEL) {
		to->modelindex = MSG_ReadByte();
#ifdef FTE_PEXT_MODELDBL
		if (morebits & U_FTE_MODELDBL) {
			to->modelindex += 256;
		}
	} else if (morebits & U_FTE_MODELDBL) {
		to->modelindex = MSG_ReadShort();
#endif
	}

	if (bits & U_FRAME)
		to->frame = MSG_ReadByte ();

	if (bits & U_COLORMAP)
		to->colormap = MSG_ReadByte();

	if (bits & U_SKIN)
		to->skinnum = MSG_ReadByte();

	if (bits & U_EFFECTS)
		to->effects = MSG_ReadByte();

	if (bits & U_ORIGIN1) {
		if (cls.mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
			to->origin[0] = MSG_ReadFloatCoord();
		}
		else {
			to->origin[0] = MSG_ReadCoord();
		}
	}

	if (bits & U_ANGLE1)
		to->angles[0] = MSG_ReadAngle();

	if (bits & U_ORIGIN2) {
		if (cls.mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
			to->origin[1] = MSG_ReadFloatCoord();
		}
		else {
			to->origin[1] = MSG_ReadCoord();
		}
	}

	if (bits & U_ANGLE2)
		to->angles[1] = MSG_ReadAngle();

	if (bits & U_ORIGIN3) {
		if (cls.mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
			to->origin[2] = MSG_ReadFloatCoord();
		}
		else {
			to->origin[2] = MSG_ReadCoord();
		}
	}

	if (bits & U_ANGLE3)
		to->angles[2] = MSG_ReadAngle();

	if (bits & U_SOLID) {
		// FIXME
	}

#ifdef PROTOCOL_VERSION_FTE
#ifdef FTE_PEXT_TRANS
	if (morebits & U_FTE_TRANS && cls.fteprotocolextensions & FTE_PEXT_TRANS) {
		to->trans = MSG_ReadByte();
	}
#endif

#ifdef FTE_PEXT_COLOURMOD
	if ((morebits & U_FTE_COLOURMOD) && (cls.fteprotocolextensions & FTE_PEXT_COLOURMOD))
	{
		to->colourmod[0] = MSG_ReadByte();
		to->colourmod[1] = MSG_ReadByte();
		to->colourmod[2] = MSG_ReadByte();
	}
#endif

#ifdef FTE_PEXT_ENTITYDBL
	if (morebits & U_FTE_ENTITYDBL) {
		to->number += 512;
	}
#endif
#ifdef FTE_PEXT_ENTITYDBL2
	if (morebits & U_FTE_ENTITYDBL2) {
		to->number += 1024;
	}
#endif
#endif
}

void FlushEntityPacket (void) {
	int word;
	entity_state_t olde, newe;

	Com_DPrintf ("FlushEntityPacket\n");

	memset (&olde, 0, sizeof(olde));

	cl.delta_sequence = 0;
	cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].invalid = true;

	// read it all, but ignore it
	while (1) {
		word = (unsigned short) MSG_ReadShort ();
		if (msg_badread) {	// something didn't parse right...
			Host_Error ("msg_badread in packetentities");
			return;
		}

		if (!word)
			break;	// done

		CL_ParseDelta (&olde, &newe, word);
	}
}

// An svc_packetentities has just been parsed, deal with the rest of the data stream.
void CL_ParsePacketEntities (qbool delta) 
{
	int oldpacket, newpacket, oldindex, newindex, word, newnum, oldnum;
	packet_entities_t *oldp, *newp, dummy;
	qbool full;
	byte from;
	int maxentities = MAX_MVD_PACKET_ENTITIES; // allow as many as we can handle
	qbool copy = (cls.netchan.incoming_sequence == 0 && cls.mvdplayback);

	newpacket = cls.netchan.incoming_sequence & UPDATE_MASK;
	newp = &cl.frames[newpacket].packet_entities;
	cl.frames[newpacket].invalid = false;
	cl.frames[newpacket].in_qwd = false;

	if (delta) 
	{
		from = MSG_ReadByte ();

		oldpacket = cl.frames[newpacket].delta_sequence;
		if (cls.mvdplayback) {
			from = oldpacket = cls.netchan.incoming_sequence - 1;
		}

		if (cls.netchan.outgoing_sequence - cls.netchan.incoming_sequence >= UPDATE_BACKUP - 1) 
		{
			// There are no valid frames left, so drop it.
			FlushEntityPacket();
			cl.validsequence = 0;
			return;
		}

		if ((from & UPDATE_MASK) != (oldpacket & UPDATE_MASK)) 
		{
			Com_DPrintf ("WARNING: from mismatch (%d vs %d, %d vs %d)\n", (from & UPDATE_MASK), (oldpacket & UPDATE_MASK), from, oldpacket);
			FlushEntityPacket();
			cl.validsequence = 0;
			return;
		}

		if (cls.netchan.outgoing_sequence - oldpacket >= UPDATE_BACKUP - 1) 
		{
			// We can't use this, it is too old.
			FlushEntityPacket ();
			// Don't clear cl.validsequence, so that frames can still be rendered;
			// it is possible that a fresh packet will be received before
			// (outgoing_sequence - incoming_sequence) exceeds UPDATE_BACKUP - 1
			return;
		}

		oldp = &cl.frames[oldpacket & UPDATE_MASK].packet_entities;
		full = false;
	} 
	else 
	{
		// This is a full update that we can start delta compressing from now.
		oldp = &dummy;
		dummy.num_entities = 0;
		full = true;
	}

	cl.oldvalidsequence = cl.validsequence;
	cl.validsequence = cls.netchan.incoming_sequence;
	cl.delta_sequence = cl.validsequence;

	oldindex = 0;
	newindex = 0;
	newp->num_entities = 0;

	while (1) 
	{
		word = (unsigned short) MSG_ReadShort ();
		if (msg_badread)
		{
			// something didn't parse right...
			Host_Error ("msg_badread in packetentities");
			return;
		}

		if (!word) 
		{
			while (oldindex < oldp->num_entities) 
			{
				// Copy all the rest of the entities from the old packet
				
				if (newindex >= maxentities)
					Host_Error ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");

				newp->entities[newindex] = oldp->entities[oldindex];
				CL_SetupPacketEntity(newp->entities[newindex].number, &newp->entities[newindex], false);
				newindex++;
				oldindex++;
			}
			break;
		}

		newnum = word & 511;
	
		#ifdef PROTOCOL_VERSION_FTE
		if (word & U_MOREBITS && (cls.fteprotocolextensions & FTE_PEXT_ENTITYDBL))
		{
			// Fte extensions for huge entity counts
			int oldpos = msg_readcount;
			int excessive;
			excessive = MSG_ReadByte();
			
			if (excessive & U_FTE_EVENMORE) 
			{
				excessive = MSG_ReadByte();
				#ifdef FTE_PEXT_ENTITYDBL
				if (excessive & U_FTE_ENTITYDBL)
					newnum += 512;
				#endif // FTE_PEXT_ENTITYDBL
				
				#ifdef FTE_PEXT_ENTITYDBL2
				if (excessive & U_FTE_ENTITYDBL2)
					newnum += 1024;
				#endif // FTE_PEXT_ENTITYDBL2
			}

			msg_readcount = oldpos; // undo the read...
		}
		#endif // PROTOCOL_VERSION_FTE

		oldnum = oldindex >= oldp->num_entities ? 9999 : oldp->entities[oldindex].number;

		while (newnum > oldnum)
		{
			if (full) 
			{
				Com_Printf ("WARNING: oldcopy on full update");
				FlushEntityPacket ();
				cl.validsequence = 0;	// can't render a frame
				return;
			}

			// Copy one of the old entities over to the new packet unchanged
			if (newindex >= maxentities)
				Host_Error ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");

			newp->entities[newindex] = oldp->entities[oldindex];
			CL_SetupPacketEntity(oldnum, &newp->entities[newindex], word > 511);
			newindex++;
			oldindex++;
			oldnum = oldindex >= oldp->num_entities ? 9999 : oldp->entities[oldindex].number;
		}

		if (newnum < oldnum) 
		{
			// New from baseline

			if (word & U_REMOVE) 
			{
				#ifdef PROTOCOL_VERSION_FTE
				if (word & U_MOREBITS && (cls.fteprotocolextensions & FTE_PEXT_ENTITYDBL))
				{
					if (MSG_ReadByte() & U_FTE_EVENMORE)
						MSG_ReadByte();
				}
				#endif // PROTOCOL_VERSION_FTE

				if (full) 
				{
					Com_Printf ("WARNING: U_REMOVE on full update\n");
					FlushEntityPacket ();
					cl.validsequence = 0;	// can't render a frame
					return;
				}
				continue;
			}

			if (newindex >= maxentities)
				Host_Error ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");

			CL_ParseDelta (&cl_entities[newnum].baseline, &newp->entities[newindex], word);
			CL_SetupPacketEntity (newnum, &newp->entities[newindex], word > 511); 
			newindex++;
			continue;
		}

		if (newnum == oldnum) 
		{
			// Delta from previous
			if (full) 
			{
				cl.validsequence = 0;
				cl.delta_sequence = 0;
				Com_Printf ("WARNING: delta on full update");
			}
			
			if (word & U_REMOVE) 
			{
				#ifdef PROTOCOL_VERSION_FTE
				if (word & U_MOREBITS && (cls.fteprotocolextensions & FTE_PEXT_ENTITYDBL))
				{
					if (MSG_ReadByte() & U_FTE_EVENMORE)
						MSG_ReadByte();
				}
				#endif // PROTOCOL_VERSION_FTE
				oldindex++;
				continue;
			}

			CL_ParseDelta (&oldp->entities[oldindex], &newp->entities[newindex], word);
			CL_SetupPacketEntity (newnum, &newp->entities[newindex], word > 511);
			newindex++;
			oldindex++;
		}
	}

	newp->num_entities = newindex;
	if (copy) {
		// do this incase it's FTE demo...
		memcpy(&cl.frames[1], &cl.frames[0], sizeof(cl.frames[1]));
	}

	if (cls.state == ca_onserver) {
		// we can now render a frame
		CL_MakeActive();
	}
}

static qbool CL_SetAlphaByDistance(entity_t* ent)
{
	vec3_t diff;
	float distance;

	VectorSubtract(ent->origin, cl.simorg, diff);
	distance = VectorLength(diff);

	// If too close to player, just hide entirely
	if (distance < KTX_RACING_PLAYER_MIN_DISTANCE)
		return false;

	ent->alpha = min(distance, KTX_RACING_PLAYER_MAX_DISTANCE) / KTX_RACING_PLAYER_ALPHA_SCALE;
	ent->renderfx |= RF_NORMALENT;
	return true;
}

// TODO: OMG SPLIT THIS UP!
void CL_LinkPacketEntities(void) 
{
	entity_t ent;
	centity_t *cent;
	packet_entities_t *pack;
	entity_state_t *state;
	model_t *model;
	double time;
	float autorotate, lerp;
	int i, pnum, flicker;
	customlight_t cst_lt = {0};
	extern qbool cl_nolerp_on_entity_flag;

	pack = &cl.frames[cl.validsequence & UPDATE_MASK].packet_entities;

	autorotate = anglemod(100 * cl.time);

	memset(&ent, 0, sizeof(ent));

	for (pnum = 0; pnum < pack->num_entities; pnum++) 
	{
		state = &pack->entities[pnum];
		cent = &cl_entities[state->number];

		// Control powerup glow for bots.
		if (state->modelindex != cl_modelindices[mi_player] || r_powerupglow.value) 
		{
			flicker = r_lightflicker.value ? (rand() & 31) : 0;
			
			// Spawn light flashes, even ones coming from invisible objects.
			if ((state->effects & (EF_BLUE | EF_RED | EF_GREEN)) == (EF_BLUE | EF_RED | EF_GREEN)) 
			{
				CL_NewDlight (state->number, state->origin, 200 + flicker, 0.1, lt_white, 0);
			} 
			else if ((state->effects & (EF_BLUE | EF_RED)) == (EF_BLUE | EF_RED)) 
			{
				CL_NewDlight (state->number, state->origin, 200 + flicker, 0.1, lt_redblue, 0);
			} 
			else if ((state->effects & (EF_BLUE | EF_GREEN)) == (EF_BLUE | EF_GREEN)) 
			{
				CL_NewDlight (state->number, state->origin, 200 + flicker, 0.1, lt_bluegreen, 0);
			}
			else if ((state->effects & (EF_RED | EF_GREEN)) == (EF_RED | EF_GREEN)) 
			{
				CL_NewDlight (state->number, state->origin, 200 + flicker, 0.1, lt_redgreen, 0);
			} 
			else if (state->effects & EF_BLUE)
			{
				CL_NewDlight (state->number, state->origin, 200 + flicker, 0.1, lt_blue, 0);
			} 
			else if (state->effects & EF_RED) 
			{
				CL_NewDlight (state->number, state->origin, 200 + flicker, 0.1, lt_red, 0);
			}
			else if (state->effects & EF_GREEN) 
			{
				CL_NewDlight (state->number, state->origin, 200 + flicker, 0.1, lt_green, 0);
			}
			else if (state->effects & EF_BRIGHTLIGHT) 
			{
				vec3_t	tmp;
				VectorCopy (state->origin, tmp);
				tmp[2] += 16;
				CL_NewDlight (state->number, tmp, 400 + flicker, 0.1, lt_default, 0);
			}
			else if (state->effects & EF_DIMLIGHT)
			{
				qbool flagcolor = false;

				if (cl.teamfortress && (state->modelindex == cl_modelindices[mi_tf_flag] || 
										state->modelindex == cl_modelindices[mi_tf_stan] || 
										state->modelindex == cl_modelindices[mi_stag] || 
										state->modelindex == cl_modelindices[mi_basrkey] || 
										state->modelindex == cl_modelindices[mi_basbkey] || 
										state->modelindex == cl_modelindices[mi_w_s_key] ||
										state->modelindex == cl_modelindices[mi_w_g_key] ||
										state->modelindex == cl_modelindices[mi_b_g_key] ||
										state->modelindex == cl_modelindices[mi_b_s_key] ||
										state->modelindex == cl_modelindices[mi_ff_flag] ||
										state->modelindex == cl_modelindices[mi_harbflag] ||
										state->modelindex == cl_modelindices[mi_princess]))
					flagcolor = true;
				else if (state->modelindex == cl_modelindices[mi_flag])
					flagcolor = true;

				if (flagcolor)
				{
					dlightColorEx(r_flagcolor.value, r_flagcolor.string, lt_default, false, &cst_lt);
					CL_NewDlightEx(state->number, state->origin, 200 + flicker, 0.1, &cst_lt, 0);
				}
				else
				{
					CL_NewDlight(state->number, state->origin, 200 + flicker, 0.1, lt_default, 0);
				}
			}
		}

		if (!state->modelindex)		// If set to invisible, skip
			continue;

		ent.effects = state->effects; // Electro - added for shells

		if (state->modelindex == cl_modelindices[mi_player]) 
		{
			i = state->frame;

			if ((cl_deadbodyfilter.value == 3) & !cl.teamfortress)
			{ // will instantly filter dead bodies unless gamedir is fortress (because in TF you probably want to see dead bodies as they may be feigned spies)
					if (ISDEAD(i))
						continue;
			}
			if (cl_deadbodyfilter.value == 2)
			{
				if (ISDEAD(i))
					continue;
			}
			else if (cl_deadbodyfilter.value == 1) 
			{
				// These indices are the last animation of a death sequence in the player.mdl
				//49=axdeth9, 60=deatha11, 69=deathb9, 84=deathc15, 93=deathd9, 102=deathe9
				if (i == 49 || i == 60 || i == 69 || i == 84 || i == 93 || i == 102)
					continue;
			}
		}

		if (cl_gibfilter.value &&
			(state->modelindex == cl_modelindices[mi_h_player]
			|| state->modelindex == cl_modelindices[mi_gib1]
			|| state->modelindex == cl_modelindices[mi_gib2]
			|| state->modelindex == cl_modelindices[mi_gib3]))
			continue;

		if (!(model = cl.model_precache[state->modelindex]))
		{
			Host_Error ("CL_LinkPacketEntities: bad modelindex");
		}

		ent.model = model;

		if (state->modelindex == cl_modelindices[mi_rocket]) 
		{
			if (cl_rocket2grenade.value && cl_modelindices[mi_grenade] != -1)
				ent.model = cl.model_precache[cl_modelindices[mi_grenade]];
		}

		ent.skinnum = state->skinnum;

		if (ent.model->modhint == MOD_BACKPACK && cl_backpackfilter.value) 
		{
			continue;
		}

		ent.frame = state->frame;
		if (cent->frametime >= 0 && cent->frametime <= cl.time)
		{
			ent.oldframe = cent->oldframe;
			ent.framelerp = (cl.time - cent->frametime) * 10;
		} 
		else 
		{
			ent.oldframe = ent.frame;
			ent.framelerp = -1;
		}

		if (state->colormap >=1 && state->colormap <= MAX_CLIENTS
		&& (ent.model->modhint == MOD_PLAYER || (ent.renderfx & RF_PLAYERMODEL)))
		{
			ent.colormap = cl.players[state->colormap - 1].translations;
			ent.scoreboard = &cl.players[state->colormap - 1];
		}
		else
		{
			ent.colormap = vid.colormap;
			ent.scoreboard = NULL;
		}
	
		if (((cl_nolerp.value || cl_nolerp_on_entity_flag) && !cls.mvdplayback && !is_monster(state->modelindex))
			|| cent->deltalerp <= 0)
		{
			lerp = -1;
			VectorCopy(cent->current.origin, ent.origin);
		} 
		else 
		{
			time = cls.mvdplayback ? cls.demotime : cl.time;
			lerp = (time - cent->startlerp) / (cent->deltalerp);
			lerp = min(lerp, 1);

			if (NewLerp_AbleModel(cent->current.modelindex))
			{
				float d = time - cent->startlerp;

				if (d >= 2 * cent->deltalerp) // Seems enitity stopped move.
					VectorCopy(cent->lerp_origin, ent.origin);
				else // interpolate
					VectorMA(cent->old_origin, d, cent->velocity, ent.origin);
			}
			else
			{
				VectorInterpolate(cent->old_origin, lerp, cent->current.origin, ent.origin);
			}
		}
#if defined(FTE_PEXT_TRANS)
		// set trans, 0 and 255 are both opaque, represented by alpha 0.
		ent.alpha = state->trans == 255 ? 0.0f : (float)state->trans / 254.0f;
#endif
#if defined(FTE_PEXT_COLOURMOD)
		// colourmod 0 is unset, 32 (1.0) incurs no color change
		if ((state->colourmod[0] > 0 || state->colourmod[1] > 0 || state->colourmod[2] > 0) &&
			!(state->colourmod[0] == 32 && state->colourmod[1] == 32 && state->colourmod[2] == 32))
		{
			ent.r_modelcolor[0] = ((float) state->colourmod[0] * 8.0f) / 256.0f;
			ent.r_modelcolor[1] = ((float) state->colourmod[1] * 8.0f) / 256.0f;
			ent.r_modelcolor[2] = ((float) state->colourmod[2] * 8.0f) / 256.0f;
			ent.renderfx |= RF_FORCECOLOURMOD;
		}
		else
		{
			ent.renderfx &= ~RF_FORCECOLOURMOD;
		}
#endif

		if (ent.model->flags & EF_ROTATE)
		{
			ent.angles[0] = ent.angles[2] = 0;
			ent.angles[1] = autorotate;
			if (cl_model_bobbing.value)
				ent.origin[2] += sin(autorotate / 90 * M_PI) * 5 + 5;
		} 
		else 
		{
			if (lerp != -1) 
			{
				AngleInterpolate(cent->old_angles, lerp, cent->current.angles, ent.angles);
			}
			else 
			{
				VectorCopy(cent->current.angles, ent.angles);
			}
		}

		if (qmb_initialized) 
		{
			if (state->modelindex == cl_modelindices[mi_explod1] || state->modelindex == cl_modelindices[mi_explod2]) 
			{
				extern cvar_t gl_part_inferno;

				if (gl_part_inferno.value) 
				{
					QMB_InfernoFlame (ent.origin);
					continue;
				}
			}

			if (state->modelindex == cl_modelindices[mi_bubble]) 
			{
				extern cvar_t gl_part_bubble;

				if (gl_part_bubble.value) {
					QMB_StaticBubble(&ent);
					continue;
				}
			}
		}

		// Add trails
		VectorCopy(ent.origin, cent->lerp_origin);
		if ((model->flags & ~EF_ROTATE) || model->modhint) {
			CL_AddParticleTrail(&ent, cent, &cst_lt, state);
		}

		if ((!cls.mvdplayback || Cam_TrackNum() >= 0) && cl.racing && cl.race_pacemaker_ent == state->number && !CL_SetAlphaByDistance(&ent)) {
			continue;
		}

		ent.renderfx &= ~(RF_BACKPACK_FLAGS);
		if (cls.mvdplayback && model->modhint == MOD_BACKPACK) {
			if (cent->contents == IT_ROCKET_LAUNCHER) {
				ent.renderfx |= RF_ROCKETPACK;
			}
			else if (cent->contents == IT_LIGHTNING) {
				ent.renderfx |= RF_LGPACK;
			}
		}

		CL_AddEntity (&ent);
	}
}



typedef struct 
{
	int		modelindex;
	vec3_t	origin;
	vec3_t	angles;
	int		num;	
} projectile_t;

projectile_t	cl_projectiles[MAX_PROJECTILES];
int				cl_num_projectiles;

projectile_t	cl_oldprojectiles[MAX_PROJECTILES];		
int				cl_num_oldprojectiles;					

void CL_ClearProjectiles (void) 
{
	if (cls.mvdplayback) 
	{
		static int parsecount = 0;

		if (parsecount == cl.parsecount)
			return;

		parsecount = cl.parsecount;
		memset(cl.int_projectiles, 0, sizeof(cl.int_projectiles));
		cl_num_oldprojectiles = cl_num_projectiles;
		memcpy(cl_oldprojectiles, cl_projectiles, sizeof(cl_projectiles));
	}

	cl_num_projectiles = 0;
}

// Nails are passed as efficient temporary entities
void CL_ParseProjectiles (qbool indexed) 
{
	int i, c, j, num;
	byte bits[6];
	projectile_t *pr;
	interpolate_t *int_projectile;	

	c = MSG_ReadByte ();
	for (i = 0; i < c; i++) 
	{
		num = indexed ? MSG_ReadByte() : 0;	

		for (j = 0 ; j < 6 ; j++)
			bits[j] = MSG_ReadByte ();

		if (cl_num_projectiles == MAX_PROJECTILES)
			continue;

		pr = &cl_projectiles[cl_num_projectiles];
		int_projectile = &cl.int_projectiles[cl_num_projectiles];	
		cl_num_projectiles++;

		pr->modelindex = cl_modelindices[mi_spike];
		pr->origin[0] = (( bits[0] + ((bits[1] & 15) << 8)) << 1) - 4096;
		pr->origin[1] = (((bits[1] >> 4) + (bits[2] << 4)) << 1) - 4096;
		pr->origin[2] = ((bits[3] + ((bits[4] & 15) << 8)) << 1) - 4096;
		pr->angles[0] = 360 * (bits[4] >> 4) / 16;
		pr->angles[1] = 360 * bits[5] / 256;

		if (!(pr->num = num))
			continue;

		for (j = 0; j < cl_num_oldprojectiles; j++) 
		{
			if (cl_oldprojectiles[j].num == num)
			{
				int_projectile->interpolate = true;
				int_projectile->oldindex = j;
				VectorCopy(pr->origin, int_projectile->origin);
				break;
			}
		}		
	}	
}

void CL_LinkProjectiles (void) 
{
	int i;
	projectile_t *pr;
	entity_t ent;

	memset(&ent, 0, sizeof(entity_t));
	ent.colormap = vid.colormap;

	for (i = 0, pr = cl_projectiles; i < cl_num_projectiles; i++, pr++)	
	{
		if (pr->modelindex < 1)
			continue;
		ent.model = cl.model_precache[pr->modelindex];
		VectorCopy(pr->origin, ent.origin);
		VectorCopy(pr->angles, ent.angles);
		CL_AddEntity(&ent);
	}
}

void SetupPlayerEntity(int num, player_state_t *state) 
{
	centity_t *cent;

	cent = &cl_entities[num];

	if (!cl.oldparsecount || cl.oldparsecount != cent->sequence ||
		state->modelindex != cent->current.modelindex ||
		!VectorL2Compare(state->origin, cent->current.origin, 200)) 
	{
		cent->startlerp = cl.time;
		cent->deltalerp = -1;
		cent->frametime = -1;
	} 
	else 
	{
		
		if (state->frame != cent->current.frame) 
		{
			cent->frametime = cl.time;
			cent->oldframe = cent->current.frame;
			if (state->vw_index == cent->old_vw_index)
				cent->old_vw_frame = cent->oldframe;
			else
				cent->old_vw_frame = state->frame;	// no lerping if vwep model changed
		}

		if (!VectorCompare(state->origin, cent->current.origin) || !VectorCompare(state->viewangles, cent->current.angles)) {
			VectorCopy(cent->current.origin, cent->old_origin);
			VectorCopy(cent->current.angles, cent->old_angles);
			if (cls.mvdplayback) 
			{
				cent->deltalerp = nextdemotime - olddemotime;
				cent->startlerp = cls.demotime;
			} 
			else
			{
				cent->deltalerp = cl.time - cent->startlerp;
				cent->startlerp = cl.time;
			}
		}
	}

	VectorCopy(state->origin, cent->current.origin);
	VectorCopy(state->viewangles, cent->current.angles);
	cent->current.frame = state->frame;
	cent->sequence = state->messagenum;	
	cent->current.modelindex = state->modelindex;
	cent->old_vw_index = state->vw_index;
}

player_state_t oldplayerstates[MAX_CLIENTS];	

static int MVD_WeaponModelNumber (int cweapon)
{
	int i;

	for (i = 0; i < 8; i++)
	{
		if (cweapon == cl_modelindices[mi_weapon1 + i])
			return i + 1;
	}

	return 0;
}

void CL_ParsePlayerinfo (void) 
{
	extern cvar_t cl_fix_mvd;
	int	msec=0, flags, pm_code;
	centity_t *cent;
	player_info_t *info;
	player_state_t *state;

	player_state_t *prevstate, dummy;
	int num, i;

	extern void TP_ParsePlayerInfo(player_state_t *, player_state_t *, player_info_t *info);

	num = MSG_ReadByte ();
	if (num >= MAX_CLIENTS)
		Host_Error ("CL_ParsePlayerinfo: num >= MAX_CLIENTS");

	info = &cl.players[num];
	state = &cl.frames[cl.parsecountmod].playerstate[num];
	cent = &cl_entities[num + 1];

	if (cls.mvdplayback)
	{
		if (!cl.parsecount || cent->sequence > cl.parsecount || cl.parsecount - cent->sequence >= UPDATE_BACKUP - 1)
	 	{
			memset(&dummy, 0, sizeof(dummy));
			dummy.pm_type = PM_SPECTATOR; // so camera able to fly
			prevstate = &dummy;
		}
		else
		{
			prevstate = &cl.frames[cent->sequence & UPDATE_MASK].playerstate[num];
		}

		memcpy(state, prevstate, sizeof(player_state_t));

		if (cls.findtrack && info->name[0] && !info->spectator)
		{
			cl.autocam = CAM_TRACK;
			Cam_Lock(num);
			cl.ideal_track = num;
			cls.findtrack = false;
		}

		flags = MSG_ReadShort ();
		state->flags = MVD_TranslateFlags(flags);

		state->messagenum = cl.parsecount;

		state->frame = MSG_ReadByte ();

		state->state_time = cl.parsecounttime;
		state->command.msec = 0;

		for (i = 0; i < 3; i++) 
		{
			if (flags & (DF_ORIGIN << i)) {
				state->origin[i] = MSG_ReadCoord();
			}
		}

		for (i = 0; i < 3; i++) 
		{
			if (flags & (DF_ANGLES << i))
				state->command.angles[i] = MSG_ReadAngle16 ();
		}

		if (flags & DF_MODEL) {
			state->modelindex = MSG_ReadByte();
		}
		else if (cl_fix_mvd.integer && !state->modelindex && !cl.players[num].spectator && cl_modelindices[mi_player] != -1) {
			// old bug in mvd/qtv
			state->modelindex = cl_modelindices[mi_player];
		}

		if (flags & DF_SKINNUM) {
			state->skinnum = MSG_ReadByte();

			if (cls.fteprotocolextensions & FTE_PEXT_MODELDBL) {
				if ((state->skinnum & (1 << 7)) && (flags & DF_MODEL)) {
					state->skinnum &= ~(1 << 7);
					state->modelindex += 256;
				}
				else if (cl.model_precache[state->modelindex] != NULL && cl.model_precache[state->modelindex]->type == mod_brush && state->modelindex + 256 == cl_modelindices[mi_player]) {
					// Temporary hack to detect demos where the modelindex needs to be +256, but not encoded in the skin field
					state->modelindex = cl_modelindices[mi_player];
				}
			}

		}

		if (flags & DF_EFFECTS)
			state->effects = MSG_ReadByte ();

		if (flags & DF_WEAPONFRAME)
			state->weaponframe = MSG_ReadByte ();

		if (cl.vwep_enabled && !(state->flags & PF_GIB) && state->modelindex == cl_modelindices[mi_player] /* no vweps for ring! */) {
			state->vw_index = MVD_WeaponModelNumber(info->stats[STAT_WEAPON]);
		}
		else {
			state->vw_index = 0;
		}
	} 
	else 
	{
#ifdef FTE_PEXT_TRANS
		flags = (unsigned short) MSG_ReadShort ();
		if (cls.fteprotocolextensions & FTE_PEXT_TRANS)
		{
			if (flags & PF_EXTRA_PFS)
				flags |= MSG_ReadByte() << 16;
		}
		else
		{
			// Without PEXT_TRANS there's no PF_EXTRA_PFS, move
			// PF_ONGROUND and PF_SOLID to their expected offsets.
			flags = (flags & 0x3fff) | (flags & 0xc000) << 8;
		}
		state->flags = flags;
#else
		state->flags = flags = MSG_ReadShort ();
#endif

		state->messagenum = cl.parsecount;
		if (cls.mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
			state->origin[0] = MSG_ReadFloatCoord();
			state->origin[1] = MSG_ReadFloatCoord();
			state->origin[2] = MSG_ReadFloatCoord();
		}
		else {
			state->origin[0] = MSG_ReadCoord();
			state->origin[1] = MSG_ReadCoord();
			state->origin[2] = MSG_ReadCoord();
		}
		state->frame = MSG_ReadByte ();

		// the other player's last move was likely some time before the packet was sent out,
		// so accurately track the exact time it was valid at
		if (flags & PF_MSEC) 
		{
			msec = MSG_ReadByte ();
			state->state_time = cl.parsecounttime - msec * 0.001;
		} 
		else
		{
			state->state_time = cl.parsecounttime;
		}

		if (flags & PF_COMMAND) 
		{
			MSG_ReadDeltaUsercmd (&nullcmd, &state->command, cl.protoversion);
			CL_CalcPlayerFPS(info, state->command.msec);
		}
		else
		{
			if (num != cl.playernum)	
				info->fps = -1;
		}

		if (cl.z_ext & Z_EXT_VWEP && !(state->flags & PF_GIB))
			state->vw_index = state->command.impulse;
		else
			state->vw_index = 0;

		for (i = 0; i < 3; i++)
		{
			if (flags & (PF_VELOCITY1 << i) )
				state->velocity[i] = MSG_ReadShort();
			else
				state->velocity[i] = 0;
		}
		if (flags & PF_MODEL) {
			state->modelindex = MSG_ReadByte();
		}
		else {
			state->modelindex = cl_modelindices[mi_player];
		}

		if (flags & PF_SKINNUM) {
			state->skinnum = MSG_ReadByte();
			if (state->skinnum & (1<<7) && (flags & PF_MODEL)) {
				state->modelindex += 256;
				state->skinnum -= (1<<7);
			}
		}
		else {
			state->skinnum = 0;
		}

		if (flags & PF_EFFECTS)
			state->effects = MSG_ReadByte ();
		else
			state->effects = 0;

		if (flags & PF_WEAPONFRAME)
			state->weaponframe = MSG_ReadByte ();
		else
			state->weaponframe = 0;


#ifdef FTE_PEXT_TRANS
		if (flags & PF_TRANS_Z && cls.fteprotocolextensions & FTE_PEXT_TRANS)
			state->alpha = MSG_ReadByte();
#endif

		if (cl.z_ext & Z_EXT_PM_TYPE)
		{
			pm_code = (flags >> PF_PMC_SHIFT) & PF_PMC_MASK;
			if (pm_code == PMC_NORMAL || pm_code == PMC_NORMAL_JUMP_HELD)
			{
				if (flags & PF_DEAD)
				{
					state->pm_type = PM_DEAD;
				}
				else
				{
					state->pm_type = PM_NORMAL;
					state->jump_held = (pm_code == PMC_NORMAL_JUMP_HELD);
				}
			}
			else
				if (pm_code == PMC_OLD_SPECTATOR)
					state->pm_type = PM_OLD_SPECTATOR;
				else
				{
					if (cl.z_ext & Z_EXT_PM_TYPE_NEW)
					{
						switch (pm_code)
						{
							case PMC_SPECTATOR:
								state->pm_type = PM_SPECTATOR;
								break;
							case PMC_FLY:
								state->pm_type = PM_FLY;
								break;
							case PMC_NONE:
								state->pm_type = PM_NONE;
								break;
							case PMC_LOCK:
								state->pm_type = PM_LOCK;
								break;
							default:
								// future extension?
								goto guess_pm_type;
						}
					}
					else
					{
						// future extension?
						goto guess_pm_type;
					}
				}
		}
		else
		{
guess_pm_type:
			if (cl.players[num].spectator)
				state->pm_type = PM_OLD_SPECTATOR;
			else if (flags & PF_DEAD)
				state->pm_type = PM_DEAD;
			else
				state->pm_type = PM_NORMAL;
		}

		if (cls.demorecording)
		{
			// Write out here - generally packets are copied, but flags for userdelta were changed
			//   in protocol 27 - we always write out in new format
			MSG_WriteByte(&cls.demomessage, num);
#if defined(FTE_PEXT_TRANS)
			if (cls.fteprotocolextensions & FTE_PEXT_TRANS)
			{
				if (flags & 0xff0000)
				{
					flags |= PF_EXTRA_PFS;
				}
				MSG_WriteShort (&cls.demomessage, flags & 0xffff);
				if (flags & PF_EXTRA_PFS)
				{
					MSG_WriteByte(&cls.demomessage, (flags & 0xff0000) >> 16);
				}
			}
			else
			{
				// Without PEXT_TRANS there's no PF_EXTRA_PFS, move
				// PF_ONGROUND and PF_SOLID to their expected offsets.
				MSG_WriteShort (&cls.demomessage, flags & 0x3fff | (flags & 0xc00000) >> 8);
			}
#else
			MSG_WriteShort(&cls.demomessage, flags);
#endif

			if (cls.mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
				MSG_WriteLongCoord(&cls.demomessage, state->origin[0]);
				MSG_WriteLongCoord(&cls.demomessage, state->origin[1]);
				MSG_WriteLongCoord(&cls.demomessage, state->origin[2]);
			}
			else {
				MSG_WriteCoord(&cls.demomessage, state->origin[0]);
				MSG_WriteCoord(&cls.demomessage, state->origin[1]);
				MSG_WriteCoord(&cls.demomessage, state->origin[2]);
			}
			MSG_WriteByte(&cls.demomessage, state->frame);
			if (flags & PF_MSEC)
				MSG_WriteByte(&cls.demomessage, msec);
			if (flags & PF_COMMAND)
				MSG_WriteDeltaUsercmd(&cls.demomessage, &nullcmd, &state->command, 0);
			for (i = 0; i < 3; i++)
				if (flags & (PF_VELOCITY1 << i) )
					MSG_WriteShort(&cls.demomessage, state->velocity[i]);
			if (flags & PF_MODEL)
				MSG_WriteByte(&cls.demomessage, state->modelindex);
			if (flags & PF_SKINNUM)
				MSG_WriteByte(&cls.demomessage, state->skinnum);
			if (flags & PF_EFFECTS)
				MSG_WriteByte(&cls.demomessage, state->effects);
			if (flags & PF_WEAPONFRAME)
				MSG_WriteByte(&cls.demomessage, state->weaponframe);
#ifdef FTE_PEXT_TRANS
			if (flags & PF_TRANS_Z && cls.fteprotocolextensions & FTE_PEXT_TRANS)
				MSG_WriteByte(&cls.demomessage, state->alpha);		
#endif
		}
	}

	if (cl.z_ext & Z_EXT_PF_ONGROUND)
		state->onground = (flags & PF_ONGROUND) != 0;
	else
		state->onground = false;

	if (!(cl.z_ext & Z_EXT_PF_SOLID))
	{	// the PF_SOLID bit is unsupported, use our best guess
		if (cl.players[num].spectator || (state->flags & PF_DEAD))
			state->flags &= ~PF_SOLID;
		else
			state->flags |= PF_SOLID;
	}

	VectorCopy (state->command.angles, state->viewangles);
	
	TP_ParsePlayerInfo(&oldplayerstates[num], state, info);
	oldplayerstates[num] = *state;
	
	SetupPlayerEntity(num + 1, state);
}

// Called when the CTF flags are set
void CL_AddFlagModels (entity_t *ent, int team) 
{
	int i;
	float f;
	vec3_t v_forward, v_right;
	entity_t newent;

	if (cl_modelindices[mi_flag] == -1)
		return;

	f = 14;
	if (ent->frame >= 29 && ent->frame <= 40) {
		if (ent->frame >= 29 && ent->frame <= 34) { //axpain
			if      (ent->frame == 29) f = f + 2; 
			else if (ent->frame == 30) f = f + 8;
			else if (ent->frame == 31) f = f + 12;
			else if (ent->frame == 32) f = f + 11;
			else if (ent->frame == 33) f = f + 10;
			else if (ent->frame == 34) f = f + 4;
		} else if (ent->frame >= 35 && ent->frame <= 40) { // pain
			if      (ent->frame == 35) f = f + 2; 
			else if (ent->frame == 36) f = f + 10;
			else if (ent->frame == 37) f = f + 10;
			else if (ent->frame == 38) f = f + 8;
			else if (ent->frame == 39) f = f + 4;
			else if (ent->frame == 40) f = f + 2;
		}
	} else if (ent->frame >= 103 && ent->frame <= 118) {
		if      (ent->frame >= 103 && ent->frame <= 104) f = f + 6;  //nailattack
		else if (ent->frame >= 105 && ent->frame <= 106) f = f + 6;  //light 
		else if (ent->frame >= 107 && ent->frame <= 112) f = f + 7;  //rocketattack
		else if (ent->frame >= 112 && ent->frame <= 118) f = f + 7;  //shotattack
	}

	memset (&newent, 0, sizeof(entity_t));
	newent.model = cl.model_precache[cl_modelindices[mi_flag]];
	newent.skinnum = team;
	newent.colormap = vid.colormap;

	AngleVectors (ent->angles, v_forward, v_right, NULL);
	v_forward[2] = -v_forward[2]; // reverse z component
	for (i = 0; i < 3; i++)
		newent.origin[i] = ent->origin[i] - f * v_forward[i] + 22 * v_right[i];
	newent.origin[2] -= 16;

	VectorCopy (ent->angles, newent.angles);
	newent.angles[2] -= 45;

	CL_AddEntity (&newent);
}

/*
================
CL_AddVWepModel
================
*/
static qbool CL_AddVWepModel (entity_t *ent, int vw_index, int old_vw_frame)
{
	entity_t	newent;

	if ((unsigned)vw_index >= MAX_VWEP_MODELS)
		return false;

	if (cl.vw_model_name[vw_index][0] == '-')
		return true;	// empty vwep model

	if (!cl.vw_model_precache[vw_index])
		return false;	// vwep model not present - draw default player.mdl

	// build the weapon entity
	memset (&newent, 0, sizeof(entity_t));
	VectorCopy (ent->origin, newent.origin);
	VectorCopy (ent->angles, newent.angles);
	newent.model = cl.vw_model_precache[vw_index];
	newent.frame = ent->frame;
	newent.oldframe = old_vw_frame;
	newent.framelerp = ent->framelerp;
	newent.skinnum = 0;
	newent.colormap = vid.colormap;
	newent.renderfx |= RF_PLAYERMODEL;	// not really, but use same lighting rules
	newent.renderfx |= RF_VWEPMODEL;
	if(ent->renderfx & RF_BEHINDWALL)
		newent.renderfx |= RF_BEHINDWALL;
	newent.effects = ent->effects; // Electro - added for shells
	newent.scoreboard = ent->scoreboard; // for team color in gl_outline

	if ((!cls.mvdplayback || Cam_TrackNum() >= 0) && cl.racing && !CL_SetAlphaByDistance(&newent)) {
		return false;
	}

	CL_AddEntity (&newent);
	return true;
}

static double CL_PlayerTime (void)
{
	double current_time = (cls.demoplayback && !cls.mvdplayback) ? cls.demotime : cls.realtime;
	double playertime = current_time - cls.latency + 0.02;

	return min(playertime, current_time);
}

void CL_StorePausePredictionLocations(void)
{
	int i;
	frame_t* frame = &cl.frames[cl.parsecount & UPDATE_MASK];
	double playertime = CL_PlayerTime();

	for (i = 0; i < MAX_CLIENTS; ++i) {
		predicted_players[i].paused_sec = playertime - frame->playerstate[i].state_time;
	}
}

// Create visible entities in the correct position for all current players
static void CL_LinkPlayers(void)
{
	int j, msec, i, flicker, oldphysent;
	float *org, distance;
	vec3_t tmp, end, diff;
	double playertime = CL_PlayerTime();
	player_info_t *info;
	player_state_t *state, exact;
	entity_t ent;
	centity_t *cent;
	frame_t *frame;
	trace_t trace;
	customlight_t cst_lt = {0};
	extern cvar_t cl_debug_antilag_ghost, cl_debug_antilag_view;
	extern cvar_t gl_spec_xray, gl_spec_xray_distance;

	frame = &cl.frames[cl.parsecount & UPDATE_MASK];
	memset (&ent, 0, sizeof(entity_t));

	for (j = 0; j < MAX_CLIENTS; j++, info++, state++) 
	{
		info = &cl.players[j];
		state = &frame->playerstate[j];
		cent = &cl_entities[j + 1];

		predicted_players[j].drawn = false;

		if (state->messagenum != cl.parsecount)
			continue;	// not present this frame

		// spawn light flashes, even ones coming from invisible objects
		if (r_powerupglow.value && !(r_powerupglow.value == 2 && j == cl.viewplayernum)) 
		{
			org = (j == cl.playernum) ? cl.simorg : state->origin;
			flicker = r_lightflicker.value ? (rand() & 31) : 0;

			if ((state->effects & (EF_BLUE | EF_RED | EF_GREEN)) == (EF_BLUE | EF_RED | EF_GREEN)) 
			{
				CL_NewDlight (j + 1, org, 200 + flicker, 0.1, lt_white, 0);
			} 
			else if ((state->effects & (EF_BLUE | EF_RED)) == (EF_BLUE | EF_RED)) 
			{
				CL_NewDlight (j + 1, org, 200 + flicker, 0.1, lt_redblue, 0);
			}
			else if ((state->effects & (EF_BLUE | EF_GREEN)) == (EF_BLUE | EF_GREEN)) 
			{
				CL_NewDlight (j + 1, org, 200 + flicker, 0.1, lt_bluegreen, 0);
			} 
			else if ((state->effects & (EF_RED | EF_GREEN)) == (EF_RED | EF_GREEN)) 
			{
				CL_NewDlight (j + 1, org, 200 + flicker, 0.1, lt_redgreen, 0);
			} 
			else if (state->effects & EF_BLUE) 
			{
				CL_NewDlight (j + 1, org, 200 + flicker, 0.1, lt_blue, 0);
			}
			else if (state->effects & EF_RED) 
			{
				CL_NewDlight (j + 1, org, 200 + flicker, 0.1, lt_red, 0);
			}
			else if (state->effects & EF_GREEN) 
			{
				CL_NewDlight (j + 1, org, 200 + flicker, 0.1, lt_green, 0);
			} 
			else if (state->effects & EF_BRIGHTLIGHT) 
			{
				VectorCopy (org, tmp);
				tmp[2] += 16;
				CL_NewDlight (j + 1, tmp, 400 + flicker, 0.1, lt_default, 0);
			}
			else if (state->effects & EF_DIMLIGHT)
			{
				qbool flagcolor = false;
				if (cl.teamfortress)	
					flagcolor = true;
				else if (state->effects & (EF_FLAG1|EF_FLAG2))
					flagcolor = true;

				if (flagcolor) {
					dlightColorEx(r_flagcolor.value, r_flagcolor.string, lt_default, false, &cst_lt);
					CL_NewDlightEx(j + 1, org, 200 + flicker, 0.1, &cst_lt, 0);
				}
				else
					CL_NewDlight(j + 1, org, 200 + flicker, 0.1, lt_default, 0);
			}
		}

		// VULT MOTION TRAILS
		ent.alpha = 0;
		// The player object never gets added.
		if (j == cl.playernum) {
			// VULT CAMERAS
			if (cameratype != C_NORMAL && !cl.spectator) {
				ent.alpha = -1;
			}
			else {
				continue;
			}
		}

		if (!Cam_DrawPlayer(j)) {
			continue;
		}

		if (!state->modelindex)
			continue;

		if (cl_gibfilter.value && state->modelindex == cl_modelindices[mi_h_player]) {
			continue;
		}

		if (state->modelindex == cl_modelindices[mi_player])
		{
			i = state->frame;

			if (cl_deadbodyfilter.value == 3 && !cl.teamfortress) {
				// will instantly filter dead bodies unless gamedir is fortress (in TF they may be feigned spies)
				if (ISDEAD(i))
					continue;
			}
			else if (cl_deadbodyfilter.value == 2)  {
				if (ISDEAD(i))
					continue;
			} 
			else if (cl_deadbodyfilter.value == 1) 
			{
				// These indices are the last animation of a death sequence in the player.mdl
				//49=axdeth9, 60=deatha11, 69=deathb9, 84=deathc15, 93=deathd9, 102=deathe9
				if (i == 49 || i == 60 || i == 69 || i == 84 || i == 93 || i == 102)
					continue;
			}
		}

		if (!(ent.model = cl.model_precache[state->modelindex]))
		{
			Host_Error ("CL_LinkPlayers: bad modelindex");
		}
		else if (state->modelindex == cl_modelindices[mi_player] && ISDEAD(state->frame)
				&& cl.vw_model_precache[0] && r_drawvweps.value
				&& cls.mvdplayback) // For non-mvd, let the server decide 
		{
			ent.model = cl.vw_model_precache[0];
			ent.renderfx |= RF_PLAYERMODEL;
		}

		ent.skinnum = state->skinnum;
		ent.colormap = info->translations;
		ent.scoreboard = (state->modelindex == cl_modelindices[mi_player]) ? info : NULL;
		ent.frame = state->frame;
		ent.effects = state->effects; // Electro - added for shells

		if (cent->frametime >= 0 && cent->frametime <= cl.time) 
		{
			ent.oldframe = cent->oldframe;
			ent.framelerp = (cl.time - cent->frametime) * 10;
		} 
		else 
		{
			ent.oldframe = ent.frame;
			ent.framelerp = -1;
		}

		// angles
		ent.angles[PITCH] = -state->viewangles[PITCH] / 3;
		ent.angles[YAW] = state->viewangles[YAW];
		ent.angles[ROLL] = 0;
		ent.angles[ROLL] = 4 * V_CalcRoll (ent.angles, state->velocity);

		// only predict half the move to minimize overruns
		msec = (cl_predict_half.value ? 500 : 1000) * (cl.paused ? predicted_players[j].paused_sec : (playertime - state->state_time));
		if (msec <= 0 || !cl_predict_players.value || cls.mvdplayback) {
			VectorCopy (state->origin, ent.origin);
			VectorCopy(ent.origin, predicted_players[j].drawn_origin);
			predicted_players[j].msec = 0;
			predicted_players[j].drawn = true;
		}
		else {
			// predict players movement
			msec = min(msec, 255);
			state->command.msec = msec;

			oldphysent = pmove.numphysent;
			CL_SetSolidPlayers(j);
			CL_PredictUsercmd(state, &exact, &state->command);
			pmove.numphysent = oldphysent;
			VectorCopy(exact.origin, ent.origin);
			VectorCopy(exact.origin, predicted_players[j].drawn_origin);
			predicted_players[j].msec = msec;
			predicted_players[j].drawn = true;
		}

		if (state->effects & (EF_FLAG1|EF_FLAG2))
			CL_AddFlagModels (&ent, !!(state->effects & EF_FLAG2));

		// VULT CAMERAS
		if (j == cl.playernum)
		{
			if (cl.stats[STAT_HEALTH] <= 0)
			{
				VectorCopy(state->viewangles, ent.angles);
				//This doesn't work... But no one has noticed yet :D
			}
			else
				VectorCopy(cl.simangles, ent.angles);
			ent.angles[0] = state->viewangles[0];
			VectorCopy (cl.simorg, ent.origin);
		}

		// Set alpha after origin determined
		if ((!cls.mvdplayback || Cam_TrackNum() >= 0) && cl.racing && !CL_SetAlphaByDistance(&ent)) {
			continue;
		}

		// Add mvd ghost
		if (cls.mvdplayback && cl_debug_antilag_ghost.integer != cl_debug_antilag_view.integer) {
			vec3_t temp;
			float old_alpha;

			VectorCopy(ent.origin, temp);
			old_alpha = ent.alpha;

			ent.alpha = 0.2f;
			switch (cl_debug_antilag_ghost.integer) {
			case 0:
				if (state->antilag_flags & dbg_antilag_position_set) {
					VectorCopy(state->current_origin, ent.origin);
					CL_AddEntity(&ent);
				}
				break;
			case 1:
				if (state->antilag_flags & dbg_antilag_rewind_present) {
					VectorCopy(state->rewind_origin, ent.origin);
					CL_AddEntity(&ent);
				}
				break;
			case 2:
				if (state->antilag_flags & dbg_antilag_client_present) {
					VectorCopy(state->client_origin, ent.origin);
					CL_AddEntity(&ent);
				}
				break;
			}

			VectorCopy(temp, ent.origin);
			ent.alpha = old_alpha;
		}

		VectorCopy (ent.origin, cent->lerp_origin);

		// VULT DEATH EFFECT
		if (amf_part_deatheffect.value)
		{
			if (ISDEAD(state->frame) && amf_part_deatheffect.value == 2)
			{
				if (info->dead == false) //dead effect not played yet
				{
					//deatheffect
					VX_DeathEffect (state->origin);
					info->dead = true;
				}
			}
			else if (state->modelindex == cl_modelindices[mi_h_player])
			{
				if (info->dead == false)
				{
					//gibeffect
					VX_GibEffect (state->origin);
					info->dead = true;
				}
			}
			else
			{
				info->dead = false;
			}
		}

		if (gl_spec_xray.value && (cls.demoplayback || cls.mvdplayback))
		{
			VectorCopy(cent->lerp_origin, end);
			end[2] += 12;
			trace = PM_TraceLine(r_refdef.vieworg, end);

			if (trace.fraction != 1) {
				VectorSubtract(cent->lerp_origin, r_refdef.vieworg, diff);
				distance = VectorLength(diff);

				if(distance > gl_spec_xray_distance.value)
					continue;
				else
					ent.renderfx |= RF_BEHINDWALL;
			} else
				ent.renderfx &= ~RF_BEHINDWALL;
		}

		ent.renderfx |= RF_PLAYERMODEL;

		if ((cl.vwep_enabled && r_drawvweps.value && state->vw_index) && (state->modelindex != cl_modelindices[mi_eyes]))
		{
			qbool vwep;
			vwep = CL_AddVWepModel (&ent, state->vw_index, cent->old_vw_frame);
			if (vwep)
			{
				if (cl.vw_model_name[0][0] != '-') 
				{
					ent.model = cl.vw_model_precache[0];
					if (Cam_TrackNum() >= 0 && cl.racing) {
						CL_SetAlphaByDistance(&ent);
					}
					CL_AddEntity (&ent);
				}
				else 
				{
					// server said don't add vwep player model
				}
			}
			else {
				CL_AddEntity(&ent);
			}
		}
		else {
			CL_AddEntity(&ent);
		}
	}
}

// Builds all the pmove physents for the current frame
void CL_SetSolidEntities (void)
{
	int i;
	frame_t	*frame;
	packet_entities_t *pak;
	entity_state_t *state;

	pmove.physents[0].model = cl.clipmodels[1];
	VectorClear (pmove.physents[0].origin);
	pmove.physents[0].info = 0;
	pmove.numphysent = 1;

	frame = &cl.frames[cl.parsecountmod];
	pak = &frame->packet_entities;

	for (i = 0; i < pak->num_entities; i++) 
	{
		state = &pak->entities[i];

		if (!state->modelindex)
			continue;

		if (cl.clipmodels[state->modelindex])
		{
			if (pmove.numphysent == MAX_PHYSENTS)
				break;

			pmove.physents[pmove.numphysent].model = cl.clipmodels[state->modelindex];
#if defined(FTE_PEXT_TRANS)
			pmove.physents[pmove.numphysent].is_transparent =
				state->trans > 0 && state->trans < 255 ? true : false;
#endif
			VectorCopy (state->origin, pmove.physents[pmove.numphysent].origin);
			pmove.numphysent++;
		}
	}
}

// Calculate the new position of players, without other player clipping
//
// We do this to set up real player prediction.
// Players are predicted twice, first without clipping other players,
// then with clipping against them.
// This sets up the first phase.
void CL_SetUpPlayerPrediction(qbool dopred)
{
	int j, msec;
	player_state_t *state, exact;
	double playertime = CL_PlayerTime();
	frame_t *frame;
	struct predicted_player *pplayer;

#ifdef EXPERIMENTAL_SHOW_ACCELERATION
	extern qbool flag_player_pmove;
#endif

	frame = &cl.frames[cl.parsecount & UPDATE_MASK];

	for (j = 0; j < MAX_CLIENTS; j++) 
	{
		pplayer = &predicted_players[j];
		state = &frame->playerstate[j];

		pplayer->active = false;

		if (state->messagenum != cl.parsecount)
			continue;	// not present this frame

		if (!state->modelindex)
			continue;

		pplayer->active = true;
		pplayer->flags = state->flags;

#ifdef EXPERIMENTAL_SHOW_ACCELERATION
		flag_player_pmove = (j == cl.playernum);
#endif
		// note that the local player is special, since he moves locally we use his last predicted postition
		if (j == cl.playernum) 
		{
			VectorCopy(cl.frames[cls.netchan.outgoing_sequence & UPDATE_MASK].playerstate[cl.playernum].origin, pplayer->origin);
		} 
		else 
		{
			msec = (cl_predict_half.value ? 500 : 1000) * (playertime - state->state_time);
			if (msec <= 0 || !cl_predict_players.value || !dopred || cls.mvdplayback) 
			{ 
				VectorCopy (state->origin, pplayer->origin);
			} 
			else 
			{
				// Predict players movement
				if (msec > 255)
					msec = 255;
				state->command.msec = msec;

				CL_PredictUsercmd (state, &exact, &state->command);
				VectorCopy (exact.origin, pplayer->origin);
			}
		}
	}
}

// Builds all the pmove physents for the current frame.
// Note that CL_SetUpPlayerPrediction() must be called first!
// pmove must be setup with world and solid entity hulls before calling (via CL_PredictMove)
void CL_SetSolidPlayers (int playernum)
{
	int j;
	struct predicted_player *pplayer;
	physent_t *pent;
	extern vec3_t player_mins, player_maxs;

	if (!cl_solid_players.value)
		return;

	pent = pmove.physents + pmove.numphysent;

	for (j = 0; j < MAX_CLIENTS; j++) 
	{
		pplayer = &predicted_players[j];
	
		if (pmove.numphysent == MAX_PHYSENTS)
			break;

		if (!pplayer->active)
			continue;	// not present this frame

		// the player object never gets added
		if (j == playernum)
			continue;

		if (!(pplayer->flags & PF_SOLID))
			continue;

		pent->model = 0;
		VectorCopy(pplayer->origin, pent->origin);
		VectorCopy(player_mins, pent->mins);
		VectorCopy(player_maxs, pent->maxs);
		pmove.numphysent++;
		pent++;
	}
}

// Builds the visedicts array for cl.time
// Made up of: clients, packet_entities, nails, and tents
void CL_EmitEntities (void) 
{
	if (cls.state != ca_active)
		return;

	if (cls.demoseeking)
		return;

	if (!cl.validsequence && !cls.nqdemoplayback)
		return;

	CL_ClearScene ();

	if (cls.nqdemoplayback) {
		NQD_LinkEntities();
	}
	else {
		CL_LinkPlayers();
		CL_LinkPacketEntities();
		CL_LinkProjectiles();
	}

	CL_UpdateTEnts();
}

int	mvd_fixangle;

static int MVD_TranslateFlags(int src) 
{
	int dst = 0;

	if (src & DF_EFFECTS)
		dst |= PF_EFFECTS;
	if (src & DF_SKINNUM)
		dst |= PF_SKINNUM;
	if (src & DF_DEAD)
		dst |= PF_DEAD;
	if (src & DF_GIB)
		dst |= PF_GIB;
	if (src & DF_WEAPONFRAME)
		dst |= PF_WEAPONFRAME;
	if (src & DF_MODEL)
		dst |= PF_MODEL;

	return dst;
}

static float MVD_AdjustAngle(float current, float ideal, float fraction) {
	float move;

	move = ideal - current;
	if (move >= 180)
		move -= 360;
	else if (move <= -180)
		move += 360;

	return current + fraction * move;
}

static void MVD_InitInterpolation(void) {
	player_state_t *state, *oldstate;
	qbool dead_body, was_dead_body;
	int i, tracknum;
	frame_t	*frame, *oldframe;
	vec3_t dist;
	struct predicted_player *pplayer;

	if (!cl.validsequence)
		 return;

	if (nextdemotime <= olddemotime)
		return;

	frame = &cl.frames[cl.parsecount & UPDATE_MASK];
	oldframe = &cl.frames[cl.oldparsecount & UPDATE_MASK];

	// clients
	for (i = 0; i < MAX_CLIENTS; i++) {
		pplayer = &predicted_players[i];
		state = &frame->playerstate[i];
		oldstate = &oldframe->playerstate[i];

		if (pplayer->predict) {
			VectorCopy(pplayer->oldo, oldstate->origin);
			VectorCopy(pplayer->olda, oldstate->command.angles);
			VectorCopy(pplayer->oldv, oldstate->velocity);
		}

		pplayer->predict = false;

		tracknum = Cam_TrackNum();
		if (mvd_fixangle & (1 << i)) {
			if (i == tracknum) {
				VectorCopy(cl.viewangles, state->command.angles);
				VectorCopy(cl.viewangles, state->viewangles);
			}

			// no angle interpolation
			VectorCopy(state->command.angles, oldstate->command.angles);

			mvd_fixangle &= ~(1 << i);
		}

		// we dont interpolate ourself if we are spectating
		if (i == cl.playernum && cl.spectator)
			continue;

		memset(state->velocity, 0, sizeof(state->velocity));

		if (state->messagenum != cl.parsecount)
			continue;	// not present this frame

		if (oldstate->messagenum != cl.oldparsecount || !oldstate->messagenum)
			continue;	// not present last frame

		// Identify dead bodies
		dead_body = (state->modelindex == cl_modelindices[mi_player] && ISDEAD(state->frame)) || state->modelindex == cl_modelindices[mi_h_player];
		was_dead_body = (oldstate->modelindex == cl_modelindices[mi_player] && ISDEAD(oldstate->frame)) || oldstate->modelindex == cl_modelindices[mi_h_player];

		// Don't lerp if respawning
		if (!dead_body && was_dead_body) {
			continue;
		}

		// Don't lerp if first frame being gibbed
		if (state->modelindex == cl_modelindices[mi_h_player] && !was_dead_body) {
			continue;
		}

		VectorSubtract(state->origin, oldstate->origin, dist);
		if (DotProduct(dist, dist) > 22500)
			continue;

		VectorScale(dist, 1 / (nextdemotime - olddemotime), pplayer->oldv);

		VectorCopy(state->origin, pplayer->oldo);
		VectorCopy(state->command.angles, pplayer->olda);

		pplayer->oldstate = oldstate;
		pplayer->predict = true;
	}

	// nails
	for (i = 0; i < cl_num_projectiles; i++) {
		if (!cl.int_projectiles[i].interpolate)
			continue;

		VectorCopy(cl.int_projectiles[i].origin, cl_projectiles[i].origin);
	}
}

void MVD_Interpolate(void)
{
	int i, j;
	float f;
	frame_t	*frame, *oldframe;
	player_state_t *state, *oldstate, *self, *oldself;
	struct predicted_player *pplayer;
	static double old;

	self = &cl.frames[cl.parsecount & UPDATE_MASK].playerstate[cl.playernum];
	oldself = &cl.frames[(cls.netchan.outgoing_sequence - 1) & UPDATE_MASK].playerstate[cl.playernum];

	self->messagenum = cl.parsecount;

	VectorCopy(oldself->origin, self->origin);
	VectorCopy(oldself->velocity, self->velocity);
	VectorCopy(oldself->viewangles, self->viewangles);

	if (old != nextdemotime) {
		old = nextdemotime;
		MVD_InitInterpolation();
	}

	CL_ParseClientdata();

	cls.netchan.outgoing_sequence = cl.parsecount + 1;

	if (!cl.validsequence)
		return;

	if (nextdemotime <= olddemotime)
		return;

	frame = &cl.frames[cl.parsecount & UPDATE_MASK];
	oldframe = &cl.frames[cl.oldparsecount & UPDATE_MASK];

	f = bound(0, (cls.demotime - olddemotime) / (nextdemotime - olddemotime), 1);

	// interpolate nails
	for (i = 0; i < cl_num_projectiles; i++)	{
		if (!cl.int_projectiles[i].interpolate)
			continue;

		for (j = 0; j < 3; j++) {
			cl_projectiles[i].origin[j] = cl_oldprojectiles[cl.int_projectiles[i].oldindex].origin[j] +
				f * (cl.int_projectiles[i].origin[j] - cl_oldprojectiles[cl.int_projectiles[i].oldindex].origin[j]);
		}
	}

	// interpolate clients
	for (i = 0; i < MAX_CLIENTS; i++) {
		extern cvar_t cl_debug_antilag_view;
		extern cvar_t cl_debug_antilag_ghost;
		extern cvar_t cl_debug_antilag_self;

		pplayer = &predicted_players[i];
		state = &frame->playerstate[i];
		oldstate = &oldframe->playerstate[i];

		if (pplayer->predict) {
			for (j = 0; j < 3; j++) {
				state->viewangles[j] = MVD_AdjustAngle(oldstate->command.angles[j], pplayer->olda[j], f);
				state->origin[j] = oldstate->origin[j] + f * (pplayer->oldo[j] - oldstate->origin[j]);
				state->velocity[j] = oldstate->velocity[j] + f * (pplayer->oldv[j] - oldstate->velocity[j]);
			}
		}

		// copy the antilag values for currently viewed client
		VectorCopy(state->origin, state->current_origin);
		VectorCopy(cl.antilag_positions[i].pos, state->rewind_origin);
		VectorCopy(cl.antilag_positions[i].clientpos, state->client_origin);
		state->antilag_flags = (cl.antilag_positions[i].present ? dbg_antilag_rewind_present : 0) | (cl.antilag_positions[i].clientpresent ? dbg_antilag_client_present : 0);

		if (i == cl.viewplayernum && !cl_debug_antilag_self.integer) {
			// only move the other players, not the current view
			continue;
		}

		// show the antilagged positions from the current player's point of view
		if (cl_debug_antilag_view.integer && cl.spectator == cl.autocam) {
			if (cl_debug_antilag_view.integer == 1) {
				if (cl.antilag_positions[i].present) {
					VectorCopy(cl.antilag_positions[i].pos, state->origin);
					state->antilag_flags |= dbg_antilag_position_set;
				}
			}
			else if (cl_debug_antilag_view.integer == 2) {
				if (cl.antilag_positions[i].clientpresent) {
					VectorCopy(cl.antilag_positions[i].clientpos, state->origin);
					state->antilag_flags |= dbg_antilag_position_set;
				}
			}
		}
	}
}

void CL_ClearPredict(void) {
	memset(predicted_players, 0, sizeof(predicted_players));
	mvd_fixangle = 0;
}

void CL_CalcPlayerFPS(player_info_t *info, int msec)
{
    info->fps_msec += msec;
    info->fps_frames++;
    if (info->fps < 0  ||  cls.realtime - info->fps_measure_time > 2  ||  cls.realtime < info->fps_measure_time)
    {
        info->fps_measure_time = cls.realtime;
        info->fps_frames = 0;
        info->fps_msec = 0;
        info->fps = 0;
    }

    if (cls.realtime - info->fps_measure_time >= 1)
    {
        if (info->fps_msec  &&  info->fps_frames)
        {
            info->fps = (int)(1000.0/(info->fps_msec/(double)info->fps_frames));
            info->last_fps = info->fps;
        }
        else
			info->fps = 0;
		info->fps_msec = 0;
		info->fps_frames = 0;
		info->fps_measure_time += 1.0;
    }
}

qbool CL_DrawnPlayerPosition(int player_num, float* pos, int* msec)
{
	if (pos) {
		VectorCopy(predicted_players[player_num].drawn_origin, pos);
	}
	if (msec) {
		*msec = predicted_players[player_num].msec;
	}
	return predicted_players[player_num].drawn;
}


================================================
FILE: src/cl_input.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
// cl.input.c  -- builds an intended movement command to send to the server

#include "quakedef.h"
#include "movie.h"
#include "gl_model.h"
#include "teamplay.h"
#include "input.h"
#include "pmove.h"		// PM_FLY etc
#include "rulesets.h"

static void IN_AttackUp_CommonHide(void);

cvar_t cl_anglespeedkey = { "cl_anglespeedkey","1.5" };
cvar_t cl_backspeed = { "cl_backspeed","400" };
cvar_t cl_c2spps = { "cl_c2spps","0" };
cvar_t cl_c2sImpulseBackup = { "cl_c2sImpulseBackup","3" };
cvar_t cl_c2sdupe = { "cl_c2sdupe", "0" };
cvar_t cl_forwardspeed = { "cl_forwardspeed","400" };
cvar_t cl_smartjump = { "cl_smartjump", "1" };
cvar_t cl_iDrive = { "cl_iDrive", "0", 0, Rulesets_OnChange_cl_iDrive };
cvar_t cl_movespeedkey = { "cl_movespeedkey","2.0" };
cvar_t cl_nodelta = { "cl_nodelta","0" };
cvar_t cl_pitchspeed = { "cl_pitchspeed","150" };
cvar_t cl_upspeed = { "cl_upspeed","400" };
cvar_t cl_safestrafe = {"cl_safestrafe", "0"};
cvar_t cl_sidespeed = { "cl_sidespeed","400" };
cvar_t cl_yawspeed = { "cl_yawspeed","140" };
cvar_t cl_weaponhide = { "cl_weaponhide", "0" };
cvar_t cl_weaponpreselect = { "cl_weaponpreselect", "0" };
cvar_t cl_weaponforgetorder = { "cl_weaponforgetorder", "0" };
cvar_t cl_weaponhide_axe = { "cl_weaponhide_axe", "0" };
cvar_t freelook = { "freelook","1" };
cvar_t lookspring = { "lookspring","0" };
cvar_t lookstrafe = { "lookstrafe","0" };

cvar_t sensitivity = { "sensitivity","12" };
cvar_t cursor_sensitivity = { "scr_cursor_sensitivity", "1" };
cvar_t m_pitch = { "m_pitch","0.022" };
cvar_t m_yaw = { "m_yaw","0.022" };
cvar_t m_forward = { "m_forward","1" };
cvar_t m_side = { "m_side","0.8" };
cvar_t m_accel = { "m_accel", "0" };
cvar_t m_accel_offset = { "m_accel_offset", "0" };
cvar_t m_accel_power = { "m_accel_power", "2" };
cvar_t m_accel_senscap = { "m_accel_senscap", "0" };

#ifdef JSS_CAM
cvar_t cam_zoomspeed = { "cam_zoomspeed", "300" };
cvar_t cam_zoomaccel = { "cam_zoomaccel", "2000" };
#endif

extern cvar_t cl_independentPhysics;
extern qbool physframe;
extern double physframetime;

#define CL_INPUT_WEAPONHIDE() ((cl_weaponhide.integer == 1) \
	|| ((cl_weaponhide.integer == 2) && (cl.deathmatch == 1)))

/*
===============================================================================
KEY BUTTONS
Continuous button event tracking is complicated by the fact that two different
input sources (say, mouse button 1 and the control key) can both press the
same button, but the button should only be released when both of the
pressing key have been released.
When a key event issues a button command (+forward, +attack, etc), it appends
its key number as a parameter to the command so it can be matched up with
the release.
state bit 0 is the current state of the key
state bit 1 is edge triggered on the up to down transition
state bit 2 is edge triggered on the down to up transition
===============================================================================
*/

kbutton_t in_mlook, in_klook;
kbutton_t in_left, in_right, in_forward, in_back;
kbutton_t in_lookup, in_lookdown, in_moveleft, in_moveright;
kbutton_t in_strafe, in_speed, in_use, in_jump, in_attack, in_attack2;
kbutton_t in_up, in_down;

int in_impulse;

#define VOID_KEY (-1)
#define NULL_KEY (-2)

void KeyDown_common(kbutton_t* b, int k)
{
	if (k != NULL_KEY) {
		if (k == b->down[0] || k == b->down[1])
			return;		// repeating key

		if (!b->down[0]) {
			b->down[0] = k;
		}
		else if (!b->down[1]) {
			b->down[1] = k;
		}
		else {
			Com_Printf("Three keys down for a button!\n");
			return;
		}
	}

	if (b->state & 1)
		return;		// still down
	b->state |= 1 + 2;	// down + impulse down
	b->downtime = curtime;
}

qbool KeyUp_common(kbutton_t* b, int k)
{
	if (k == VOID_KEY || k == NULL_KEY) { // typed manually at the console, assume for unsticking, so clear all
		b->down[0] = b->down[1] = 0;
		b->state &= ~1;		// now up
		b->state |= 4; 		// impulse up
		b->uptime = curtime;
		return true;
	}

	if (b->down[0] == k)
		b->down[0] = 0;
	else if (b->down[1] == k)
		b->down[1] = 0;
	else
		return true;		// key up without coresponding down (menu pass through)

	if (b->down[0] || b->down[1])
		return false;		// some other key is still holding it down

	if (!(b->state & 1))
		return true;		// still up (this should not happen)
	b->state &= ~1;		// now up
	b->state |= 4; 		// impulse up
	b->uptime = curtime;
	return true;
}

void KeyDown(kbutton_t* b)
{
	int k = VOID_KEY;
	char* c = Cmd_Argv(1);
	if (*c) {
		k = atoi(c);
	}

	KeyDown_common(b, k);
}

// returns whether the button is now up, will not be if other key is holding it down
qbool KeyUp(kbutton_t* b)
{
	int k = VOID_KEY;
	char* c = Cmd_Argv(1);
	if (*c) {
		k = atoi(c);
	}

	return KeyUp_common(b, k);
}


void IN_KLookDown(void)
{
	KeyDown(&in_klook);
}
void IN_KLookUp(void)
{
	KeyUp(&in_klook);
}

void IN_MLookDown(void)
{
	KeyDown(&in_mlook);
}
void IN_MLookUp(void)
{
	if (concussioned) {
		return;
	}

	KeyUp(&in_mlook);

	if (!mlook_active && lookspring.value) {
		V_StartPitchDrift();
	}
}

#define PROTECTEDKEY()                                 \
	if (allow_scripts.integer == 0) {                  \
		Com_Printf("Movement scripts are disabled\n"); \
		return;                                        \
	}

void IN_UpDown(void) { PROTECTEDKEY(); KeyDown(&in_up); }
void IN_UpUp(void) { PROTECTEDKEY(); KeyUp(&in_up); }
void IN_DownDown(void) { PROTECTEDKEY(); KeyDown(&in_down); }
void IN_DownUp(void) { PROTECTEDKEY(); KeyUp(&in_down); }
void IN_LeftDown(void) { PROTECTEDKEY(); KeyDown(&in_left); }
void IN_LeftUp(void) { PROTECTEDKEY(); KeyUp(&in_left); }
void IN_RightDown(void) { PROTECTEDKEY(); KeyDown(&in_right); }
void IN_RightUp(void) { PROTECTEDKEY(); KeyUp(&in_right); }
void IN_ForwardDown(void) { PROTECTEDKEY(); KeyDown(&in_forward); }
void IN_ForwardUp(void) { PROTECTEDKEY(); KeyUp(&in_forward); }
void IN_BackDown(void) { PROTECTEDKEY(); KeyDown(&in_back); }
void IN_BackUp(void) { PROTECTEDKEY(); KeyUp(&in_back); }
void IN_LookupDown(void) { PROTECTEDKEY(); KeyDown(&in_lookup); }
void IN_LookupUp(void) { PROTECTEDKEY(); KeyUp(&in_lookup); }
void IN_LookdownDown(void) { PROTECTEDKEY(); KeyDown(&in_lookdown); }
void IN_LookdownUp(void) { PROTECTEDKEY(); KeyUp(&in_lookdown); }
void IN_MoveleftDown(void) { PROTECTEDKEY(); KeyDown(&in_moveleft); }
void IN_MoveleftUp(void) { PROTECTEDKEY(); KeyUp(&in_moveleft); }
void IN_MoverightDown(void) { PROTECTEDKEY(); KeyDown(&in_moveright); }
void IN_MoverightUp(void) { PROTECTEDKEY(); KeyUp(&in_moveright); }

void IN_SpeedDown(void) { KeyDown(&in_speed); }
void IN_SpeedUp(void) { KeyUp(&in_speed); }
void IN_StrafeDown(void) { KeyDown(&in_strafe); }
void IN_StrafeUp(void) { KeyUp(&in_strafe); }

// Returns true if given command is a protected movement command and was executed successfully
qbool Key_TryMovementProtected(const char* cmd, qbool down, int key)
{
	typedef void (*KeyPress_fnc) (kbutton_t* b, int key);
	KeyPress_fnc f = down ? KeyDown_common : (KeyPress_fnc)KeyUp_common;
	kbutton_t* b = NULL;

	if (strcmp(cmd, "+forward") == 0) b = &in_forward;
	else if (strcmp(cmd, "+back") == 0) b = &in_back;
	else if (strcmp(cmd, "+moveleft") == 0) b = &in_moveleft;
	else if (strcmp(cmd, "+moveright") == 0) b = &in_moveright;
	else if (strcmp(cmd, "+left") == 0) b = &in_left;
	else if (strcmp(cmd, "+right") == 0) b = &in_right;
	else if (strcmp(cmd, "+lookup") == 0) b = &in_lookup;
	else if (strcmp(cmd, "+lookdown") == 0) b = &in_lookdown;
	else if (strcmp(cmd, "+moveup") == 0) b = &in_up;
	else if (strcmp(cmd, "+movedown") == 0) b = &in_down;

	if (b) {
		f(b, key);
		return true;
	}
	else {
		return false;
	}
}

void IN_AttackDown(void)
{
	int best;
	if (cl_weaponpreselect.value && (best = IN_BestWeapon(false)))
		in_impulse = best;

	KeyDown(&in_attack);
}

// Checks if we have a keycode at the end, e.g. +fire 8 5 3 120
// if it's >= 32, treat is as keycodes, otherwise an impulse
static qbool IN_IsLastArgKeyCode(void)
{
	return atoi(Cmd_Argv(Cmd_Argc() - 1)) >= 32;
}

static void IN_AntiRolloverFireKeyDown(int key_code)
{
	// Actual firing has already happened in +fire_ar handler, so just store here...

	if (key_code) {
		int i;

		// shouldn't happen, but prevent duplicates
		for (i = 0; i < cl.ar_count; ++i) {
			if (cl.ar_keycodes[i] == key_code) {
				return;
			}
		}

		// add to the stack
		if (cl.ar_count < sizeof(cl.ar_keycodes) / sizeof(cl.ar_keycodes[0])) {
			cl.ar_keycodes[cl.ar_count] = key_code;
			memcpy(cl.ar_weapon_orders[cl.ar_count], cl.weapon_order, sizeof(cl.ar_weapon_orders[cl.ar_count]));
			++cl.ar_count;
		}
	}
}

static void IN_AntiRolloverFireKeyUp(int key_code)
{
	int i;

	if (cl.ar_count > 0 && cl.ar_keycodes[cl.ar_count - 1] == key_code) {
		// Found in most recent position: use weaponlist from previously pressed button
		--cl.ar_count;

		if (cl.ar_count > 0) {
			int prev = cl.ar_count - 1;

			memcpy(cl.weapon_order, cl.ar_weapon_orders[prev], sizeof(cl.weapon_order));
			in_impulse = IN_BestWeapon(false);
			KeyDown_common(&in_attack, NULL_KEY);
		}
		else {
			KeyUp_common(&in_attack, NULL_KEY);
			IN_AttackUp_CommonHide();
		}
	}
	else {
		// Not the most recent, so just remove from the list silently
		for (i = 0; i < cl.ar_count - 1; ++i) {
			if (cl.ar_keycodes[i] == key_code) {
				memcpy(&cl.ar_keycodes[i], &cl.ar_keycodes[i + 1], sizeof(cl.ar_keycodes[0]) * (cl.ar_count - 1 - i));
				memcpy(&cl.ar_weapon_orders[i], &cl.ar_weapon_orders[i + 1], sizeof(cl.ar_weapon_orders[0]) * (cl.ar_count - 1 - i));
				--i;
				--cl.ar_count;
			}
		}
	}
}

void IN_FireDown(void)
{
	int key_code = VOID_KEY;
	int last_arg_idx = Cmd_Argc() - 1;
	int i;
	qbool anti_rollover = !strcasecmp(Cmd_Argv(0), "+fire_ar");

	if (Cmd_Argc() < 2) {
		Com_Printf("Usage: %s <weapon number>\n", Cmd_Argv(0));
		return;
	}

	if (IN_IsLastArgKeyCode()) {
		key_code = Q_atoi(Cmd_Argv(last_arg_idx));
		last_arg_idx--;
	}

	for (i = 1; i <= last_arg_idx && i <= MAXWEAPONS; i++) {
		int desired_impulse = Q_atoi(Cmd_Argv(i));
		cl.weapon_order[i - 1] = desired_impulse;
	}

	for (; i <= MAXWEAPONS; i++) {
		cl.weapon_order[i - 1] = 0;
	}

	in_impulse = IN_BestWeapon(false);

	if (anti_rollover && key_code) {
		KeyDown_common(&in_attack, NULL_KEY);
		IN_AntiRolloverFireKeyDown(key_code);
	}
	else {
		KeyDown_common(&in_attack, key_code);
	}
}

static void IN_AttackUp_CommonHide(void)
{
	if (CL_INPUT_WEAPONHIDE()) 	{
		if (cl_weaponhide_axe.integer) 		{
			// always switch to axe because user wants to
			in_impulse = 1;
		}
		else 		{
			// performs "weapon 2 1"
			// that means: if player has shotgun and shells, select shotgun, otherwise select axe
			in_impulse = ((cl.stats[STAT_ITEMS] & IT_SHOTGUN) && cl.stats[STAT_SHELLS] >= 1) ? 2 : 1;
		}
	}
}

void IN_FireUp(void)
{
	int key_code = VOID_KEY;
	qbool anti_rollover = !strcasecmp(Cmd_Argv(0), "-fire_ar");

	if (IN_IsLastArgKeyCode()) {
		key_code = Q_atoi(Cmd_Argv(Cmd_Argc() - 1));
	}

	if (key_code && anti_rollover) {
		IN_AntiRolloverFireKeyUp(key_code);
	}
	else if (KeyUp_common(&in_attack, key_code)) {
		IN_AttackUp_CommonHide();
	}
}


void IN_AttackUp(void)
{
	qbool up = KeyUp(&in_attack);
	if (up) {
		IN_AttackUp_CommonHide();
	}
}

void IN_UseDown(void) { KeyDown(&in_use); }
void IN_UseUp(void) { KeyUp(&in_use); }
void IN_Attack2Down(void) { KeyDown(&in_attack2); }
void IN_Attack2Up(void) { KeyUp(&in_attack2); }


void IN_JumpDown(void)
{
	qbool up;
	int pmt;

	if (cls.state != ca_active || !cl_smartjump.value)
		up = false;
	else if (cls.demoplayback && !cls.mvdplayback)
		up = false; // use jump instead of up in demos unless its MVD and I have no idea why QWD have this restriction.
	else if (cl.spectator)
		up = (Cam_TrackNum() == -1); // NOTE: cl.spectator is non false during MVD playback, so this code executed.
	else if (cl.stats[STAT_HEALTH] <= 0)
		up = false;
	else if (cl.validsequence && (
		((pmt = cl.frames[cl.validsequence & UPDATE_MASK].playerstate[cl.playernum].pm_type) == PM_FLY)
		|| pmt == PM_SPECTATOR || pmt == PM_OLD_SPECTATOR))
		up = true;
	else if (cl.waterlevel >= 2 && !(cl.teamfortress && (in_forward.state & 1)))
		up = true;
	else
		up = false;

	KeyDown(up ? &in_up : &in_jump);
}
void IN_JumpUp(void)
{
	if (cl_smartjump.value)
		KeyUp(&in_up);
	KeyUp(&in_jump);
}

// called within 'impulse' or 'weapon' commands, remembers it's first 10 (MAXWEAPONS) arguments
void IN_RememberWpOrder(void)
{
	int i, c;
	c = Cmd_Argc() - 1;

	for (i = 0; i < MAXWEAPONS; i++)
		cl.weapon_order[i] = (i < c) ? Q_atoi(Cmd_Argv(i + 1)) : 0;
}

static int IN_BestWeapon_Common(int implicit, int* weapon_order, qbool persist, qbool rendering_only);

// picks the best available (carried & having some ammunition) weapon according to users current preference
// or if the intersection (whished * carried) is empty
// select the top wished weapon
int IN_BestWeapon(qbool rendering_only)
{
	return IN_BestWeapon_Common(cl.weapon_order[0], cl.weapon_order, cl_weaponforgetorder.integer != 1, rendering_only);
}

// picks the best available (carried & having some ammunition) weapon according to users current preference
// or if the intersection (whished * carried) is empty
// select the current weapon
int IN_BestWeaponReal(qbool rendering_only)
{
	return IN_BestWeapon_Common(in_impulse, cl.weapon_order, cl_weaponforgetorder.integer != 1, rendering_only);
}

// finds the best weapon from the carried weapons; if none is found, returns implicit
static int IN_BestWeapon_Common(int implicit, int* weapon_order, qbool persist, qbool rendering_only)
{
	int i, imp, items;
	int best = implicit;

	items = cl.stats[STAT_ITEMS];

	for (i = MAXWEAPONS - 1; i >= 0; i--) 	{
		imp = weapon_order[i];
		if (imp < 1 || imp > 8)
			continue;

		switch (imp) 		{
		case 1:
			if (items & IT_AXE)
				best = 1;
			break;
		case 2:
			if (items & IT_SHOTGUN && cl.stats[STAT_SHELLS] >= 1)
				best = 2;
			break;
		case 3:
			if (items & IT_SUPER_SHOTGUN && cl.stats[STAT_SHELLS] >= 2)
				best = 3;
			break;
		case 4:
			if (items & IT_NAILGUN && cl.stats[STAT_NAILS] >= 1)
				best = 4;
			break;
		case 5:
			if (items & IT_SUPER_NAILGUN && cl.stats[STAT_NAILS] >= 2)
				best = 5;
			break;
		case 6:
			if (items & IT_GRENADE_LAUNCHER && cl.stats[STAT_ROCKETS] >= 1)
				best = 6;
			break;
		case 7:
			if (items & IT_ROCKET_LAUNCHER && cl.stats[STAT_ROCKETS] >= 1)
				best = 7;
			break;
		case 8:
			if (items & IT_LIGHTNING && cl.stats[STAT_CELLS] >= 1)
				best = 8;
		}
	}

	if (!rendering_only) {
		/* If weapon order shouldn't persist, set the first element
		 * of the order to the most recently selected weapon
		 */
		if (!persist) {
			weapon_order[0] = best;
			weapon_order[1] = (cl_weaponhide_axe.integer || best == 2 ? 1 : 2);
			weapon_order[2] = (weapon_order[1] == 1 ? 0 : 1);
			weapon_order[3] = 0;
		}
	}

	return best;
}

void IN_Impulse(void)
{
	int best;

	in_impulse = Q_atoi(Cmd_Argv(1));

	if (Cmd_Argc() <= 2)
		return;

	// If more than one argument, select immediately the best weapon.
	IN_RememberWpOrder();
	if ((best = IN_BestWeapon(false))) {
		in_impulse = best;
	}
}

// This is the same command as impulse but cl_weaponpreselect can be used in here, while for impulses cannot be used.
void IN_Weapon(void)
{
	int c, best, mode, first;

	if ((c = Cmd_Argc() - 1) < 1) {
		Com_Printf("Usage: %s w1 [w2 [w3..]]\nWill pre-select best available weapon from given sequence.\n", Cmd_Argv(0));
		return;
	}

	first = Q_atoi(Cmd_Argv(1));
	if (first == 10) {
		int best_temp = IN_BestWeapon(false);
		int temp_order[10] = {
			best_temp % 8 + 1,
			(best_temp + 1) % 8 + 1,
			(best_temp + 2) % 8 + 1,
			(best_temp + 3) % 8 + 1,
			(best_temp + 4) % 8 + 1,
			(best_temp + 5) % 8 + 1,
			(best_temp + 6) % 8 + 1,
			(best_temp + 7) % 8 + 1,
			0,
			0
		};

		cl.weapon_order[0] = best = IN_BestWeapon_Common(1, temp_order, false, false);
	}
	else if (first == 12) {
		int best_temp = IN_BestWeapon(false);
		int temp_order[10] = {
			8 - ((8 - best_temp + 1) % 8),
			8 - ((8 - best_temp + 2) % 8),
			8 - ((8 - best_temp + 3) % 8),
			8 - ((8 - best_temp + 4) % 8),
			8 - ((8 - best_temp + 5) % 8),
			8 - ((8 - best_temp + 6) % 8),
			8 - ((8 - best_temp + 7) % 8),
			8 - ((8 - best_temp + 8) % 8),
			0,
			0
		};

		cl.weapon_order[0] = best = IN_BestWeapon_Common(1, temp_order, false, false);
	}
	else {
		// read user input
		IN_RememberWpOrder();

		best = IN_BestWeapon(false);
	}

	mode = (int)cl_weaponpreselect.value;

	// cl_weaponpreselect behaviour:
	// 0: select best weapon right now
	// 1: always only pre-select; switch to it on +attack
	// 2: user is holding +attack -> select, otherwise just pre-select
	// 3: same like 1, but only in deathmatch 1
	// 4: same like 2, but only in deathmatch 1
	if (mode == 3) {
		mode = (cl.deathmatch == 1) ? 1 : 0;
	}
	else if (mode == 4) {
		mode = (cl.deathmatch == 1) ? 2 : 0;
	}

	switch (mode) 	{
	case 2:
		if ((in_attack.state & 3) && best) // user is holding +attack and there is some weapon available
			in_impulse = best;
		break;
	case 1: break;	// don't select weapon immediately
	default: case 0:	// no pre-selection
		if (best)
			in_impulse = best;

		break;
	}
}

/*
Returns 0.25 if a key was pressed and released during the frame,
0.5 if it was pressed and held
0 if held then released, and
1.0 if held for the entire time
*/
float CL_KeyState(kbutton_t* key, qbool lookbutton)
{
	float val;
	qbool impulsedown, impulseup, down;

	impulsedown = key->state & 2;
	impulseup = key->state & 4;
	down = key->state & 1;
	val = 0.0;

	if (impulsedown && !impulseup) 	{
		if (down)
			val = lookbutton ? 0.5 : 1.0;	// pressed and held this frame
		else
			val = 0;	// I_Error ();
	}
	if (impulseup && !impulsedown) 	{
		if (down)
			val = 0.0;	// I_Error ();
		else
			val = 0.0;	// released this frame
	}
	if (!impulsedown && !impulseup) 	{
		if (down)
			val = 1.0;	// held the entire frame
		else
			val = 0.0;	// up the entire frame
	}
	if (impulsedown && impulseup) 	{
		if (down)
			val = 0.75;	// released and re-pressed this frame
		else
			val = 0.25;	// pressed and released this frame
	}

	key->state &= 1;	// clear impulses

	return val;
}

//==========================================================================

void CL_Rotate_f(void)
{
	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: %s <degrees>\n", Cmd_Argv(0));
		return;
	}

	if ((cl.fpd & FPD_LIMIT_YAW) || allow_scripts.value < 2) {
		return;
	}

	cl.viewangles[YAW] += atof(Cmd_Argv(1));
	cl.viewangles[YAW] = anglemod(cl.viewangles[YAW]);
}

// Moves the local angle positions.
void CL_AdjustAngles(void)
{
	float basespeed, speed, up, down, frametime;

	frametime = (cl_independentPhysics.value == 0 ? cls.trueframetime : physframetime);
	if (Movie_IsCapturing()) {
		frametime = Movie_InputFrametime();
	}

	basespeed = ((in_speed.state & 1) ? cl_anglespeedkey.value : 1);

	if (!(in_strafe.state & 1)) {
		speed = basespeed * cl_yawspeed.value;
		if ((cl.fpd & FPD_LIMIT_YAW) || allow_scripts.value < 2)
			speed = bound(-900, speed, 900);
		speed *= frametime;
		cl.viewangles[YAW] -= speed * CL_KeyState(&in_right, true);
		cl.viewangles[YAW] += speed * CL_KeyState(&in_left, true);
		if (cl.viewangles[YAW] < 0)
			cl.viewangles[YAW] += 360.0;
		else if (cl.viewangles[YAW] > 360)
			cl.viewangles[YAW] -= 360.0;
	}

	speed = basespeed * cl_pitchspeed.value;
	if ((cl.fpd & FPD_LIMIT_PITCH) || allow_scripts.value == 0)
		speed = bound(-700, speed, 700);
	speed *= frametime;
	if (in_klook.state & 1) 	{
		V_StopPitchDrift();
		cl.viewangles[PITCH] -= speed * CL_KeyState(&in_forward, true);
		cl.viewangles[PITCH] += speed * CL_KeyState(&in_back, true);
	}


	up = CL_KeyState(&in_lookup, true);
	down = CL_KeyState(&in_lookdown, true);
	cl.viewangles[PITCH] -= speed * up;
	cl.viewangles[PITCH] += speed * down;
	if (up || down)
		V_StopPitchDrift();

	if (cl.viewangles[PITCH] > cl.maxpitch)
		cl.viewangles[PITCH] = cl.maxpitch;
	if (cl.viewangles[PITCH] < cl.minpitch)
		cl.viewangles[PITCH] = cl.minpitch;

	//cl.viewangles[PITCH] = bound(cl.min!pitch, cl.viewangles[PITCH], cl.ma!xpitch);
	cl.viewangles[ROLL] = bound(-50, cl.viewangles[ROLL], 50);
}

// Send the intended movement message to the server.
void CL_BaseMove(usercmd_t* cmd)
{
	float sidespeed = (float)fabs(cl_sidespeed.value);
	float upspeed = (float)fabs(cl_upspeed.value);
	float forwardspeed = (float)fabs(cl_forwardspeed.value);
	float backspeed = (float)fabs(cl_backspeed.value);
	float speedmodifier = (float)fabs(cl_movespeedkey.value);

	CL_AdjustAngles();

	memset(cmd, 0, sizeof(*cmd));

	VectorCopy(cl.viewangles, cmd->angles);

	if (cl_iDrive.integer) {
		float s1, s2;

		if (in_strafe.state & 1) {
			s1 = CL_KeyState(&in_right, false);
			s2 = CL_KeyState(&in_left, false);

			if (s1 && s2) {
				if (in_right.downtime > in_left.downtime)
					s2 = 0;
				if (in_right.downtime < in_left.downtime)
					s1 = 0;
			}

			cmd->sidemove += sidespeed * s1;
			cmd->sidemove -= sidespeed * s2;
		}

		s1 = CL_KeyState(&in_moveright, false);
		s2 = CL_KeyState(&in_moveleft, false);

		if (s1 && s2) {
			if (in_moveright.downtime > in_moveleft.downtime)
				s2 = 0;
			if (in_moveright.downtime < in_moveleft.downtime)
				s1 = 0;
		}

		cmd->sidemove += sidespeed * s1;
		cmd->sidemove -= sidespeed * s2;

		s1 = CL_KeyState(&in_up, false);
		s2 = CL_KeyState(&in_down, false);

		if (s1 && s2) {
			if (in_up.downtime > in_down.downtime)
				s2 = 0;
			if (in_up.downtime < in_down.downtime)
				s1 = 0;
		}

		cmd->upmove += upspeed * s1;
		cmd->upmove -= upspeed * s2;

		if (!(in_klook.state & 1)) {
			s1 = CL_KeyState(&in_forward, false);
			s2 = CL_KeyState(&in_back, false);

			if (s1 && s2) 			{
				if (in_forward.downtime > in_back.downtime)
					s2 = 0;
				if (in_forward.downtime < in_back.downtime)
					s1 = 0;
			}

			cmd->forwardmove += forwardspeed * s1;
			cmd->forwardmove -= backspeed * s2;
		}
	}
	else {
		if (in_strafe.state & 1) {
			cmd->sidemove += sidespeed * CL_KeyState(&in_right, false);
			cmd->sidemove -= sidespeed * CL_KeyState(&in_left, false);
		}

		cmd->sidemove += sidespeed * CL_KeyState(&in_moveright, false);
		cmd->sidemove -= sidespeed * CL_KeyState(&in_moveleft, false);

		cmd->upmove += upspeed * CL_KeyState(&in_up, false);
		cmd->upmove -= upspeed * CL_KeyState(&in_down, false);

		if (!(in_klook.state & 1)) {
			cmd->forwardmove += forwardspeed * CL_KeyState(&in_forward, false);
			cmd->forwardmove -= backspeed * CL_KeyState(&in_back, false);
		}
	}

	// adjust for speed key
	if (in_speed.state & 1) {
		cmd->forwardmove *= speedmodifier;
		cmd->sidemove *= speedmodifier;
		cmd->upmove *= speedmodifier;
	}

#ifdef JSS_CAM
	{
		static float zoomspeed = 0;
		extern cvar_t cam_thirdperson, cam_lockpos;

		if ((cls.demoplayback || cl.spectator) && cam_thirdperson.integer && !cam_lockpos.integer) {
			zoomspeed -= CL_KeyState(&in_forward, false) * cls.trueframetime * cam_zoomaccel.value;
			zoomspeed += CL_KeyState(&in_back, false) * cls.trueframetime * cam_zoomaccel.value;
			if (!CL_KeyState(&in_forward, false) && !CL_KeyState(&in_back, false)) {
				if (zoomspeed > 0) {
					zoomspeed -= cls.trueframetime * cam_zoomaccel.value;
					if (zoomspeed < 0)
						zoomspeed = 0;
				}
				else if (zoomspeed < 0) {
					zoomspeed += cls.trueframetime * cam_zoomaccel.value;
					if (zoomspeed > 0)
						zoomspeed = 0;
				}
			}
			zoomspeed = bound(-cam_zoomspeed.value, zoomspeed, cam_zoomspeed.value);

			if (zoomspeed) {
				extern cvar_t cam_dist;
				float dist = cam_dist.value;

				dist += cls.trueframetime * zoomspeed;
				if (dist < 0) {
					dist = 0;
				}
				Cvar_SetValue(&cam_dist, dist);
			}
		}
	}
#endif // JSS_CAM
}

int MakeChar(int i)
{
	i &= ~3;
	if (i < -127 * 4)
		i = -127 * 4;
	if (i > 127 * 4)
		i = 127 * 4;
	return i;
}

void CL_FinishMove(usercmd_t* cmd)
{
	int i, ms;
	float frametime;
	static double extramsec = 0;
	extern cvar_t allow_scripts;

	frametime = cls.trueframetime;
	if (Movie_IsCapturing()) {
		frametime = Movie_InputFrametime();
	}

	// figure button bits
	if (in_attack.state & 3)
		cmd->buttons |= 1;
	in_attack.state &= ~2;

	if (in_jump.state & 3)
		cmd->buttons |= 2;
	in_jump.state &= ~2;

	if (in_use.state & 3)
		cmd->buttons |= 4;
	in_use.state &= ~2;

	if (in_attack2.state & 3)
		cmd->buttons |= 8;
	in_attack2.state &= ~2;

	// send milliseconds of time to apply the move
	//#fps	extramsec += cls.frametime * 1000;
	extramsec += (cl_independentPhysics.value == 0 ? frametime : physframetime) * 1000;	//#fps
	ms = extramsec;
	extramsec -= ms;

	if (ms > 250) {
		ms = 100;		// time was unreasonable
	}

	cmd->msec = ms;

	VectorCopy(cl.viewangles, cmd->angles);

	// shaman RFE 1030281 {
	// KTPro's KFJump == impulse 156
	// KTPro's KRJump == impulse 164
	if (*Info_ValueForKey(cl.serverinfo, "kmod") && (
		((in_impulse == 156) && (cl.fpd & FPD_LIMIT_YAW || allow_scripts.value < 2)) ||
		((in_impulse == 164) && (cl.fpd & FPD_LIMIT_PITCH || allow_scripts.value == 0))
		)
		) {
		cmd->impulse = 0;
	}
	else {
		cmd->impulse = in_impulse;
	}
	// } shaman RFE 1030281
	in_impulse = 0;

	// chop down so no extra bits are kept that the server wouldn't get
	cmd->forwardmove = MakeChar(cmd->forwardmove);
	cmd->sidemove = MakeChar(cmd->sidemove);
	cmd->upmove = MakeChar(cmd->upmove);

	for (i = 0; i < 3; i++) {
		cmd->angles[i] = (Q_rint(cmd->angles[i] * 65536.0 / 360.0) & 65535) * (360.0 / 65536.0);
	}
}

void CL_SendClientCommand(qbool reliable, char* format, ...)
{
	va_list		argptr;
	char		string[2048];

	if (cls.demoplayback || cls.state == ca_disconnected) {
		return;	// no point.
	}

	va_start(argptr, format);
	vsnprintf(string, sizeof(string), format, argptr);
	va_end(argptr);

	if (reliable) {
		MSG_WriteByte(&cls.netchan.message, clc_stringcmd);
		MSG_WriteString(&cls.netchan.message, string);
	}
	else {
		MSG_WriteByte(&cls.cmdmsg, clc_stringcmd);
		MSG_WriteString(&cls.cmdmsg, string);
	}
}

int cmdtime_msec = 0;

void CL_ApplySafestrafe(usercmd_t *cmd)
{
	int required_frames = max(movevars.safestrafe, cl_safestrafe.value);

	if (required_frames <= 0)
		return;
	
	float current_move = cmd->sidemove;
	
	// Handle pending stop frames
	if (cl.safestrafe.pending_frames > 0) {
		cmd->sidemove = 0;
		cl.safestrafe.pending_frames--;
		cl.safestrafe.stop_frames++;
		cl.safestrafe.last_sidemove = 0;
		return;
	}
	
	// Determine directions
	int current_dir = (current_move > 0) - (current_move < 0);
	int previous_dir = (cl.safestrafe.last_sidemove > 0) - 
	                   (cl.safestrafe.last_sidemove < 0);
	
	// Check for direction change
	if (current_dir != 0 && previous_dir != 0 && 
	    current_dir != previous_dir) {
		// Direct direction change - enforce stop frames
		cl.safestrafe.pending_frames = required_frames;
		cl.safestrafe.pending_direction = current_move;
		cl.safestrafe.stop_frames = 1;
		cmd->sidemove = 0;
	}
	else if (current_dir != 0 && previous_dir == 0) {
		// Starting movement after stop
		if (cl.safestrafe.stop_frames < required_frames) {
			// Not enough stop frames
			cl.safestrafe.pending_frames = 
				required_frames - cl.safestrafe.stop_frames;
			cl.safestrafe.pending_direction = current_move;
			cl.safestrafe.stop_frames++;
			cmd->sidemove = 0;
		}
		else {
			// Enough stop frames - allow movement
			cl.safestrafe.stop_frames = 0;
		}
	}
	else if (current_dir == 0) {
		// Currently stopped
		cl.safestrafe.stop_frames++;
	}
	
	// Update last move
	cl.safestrafe.last_sidemove = cmd->sidemove;
}

void CL_SendCmd(void)
{
	sizebuf_t buf;
	byte data[1024];
	usercmd_t* cmd, * oldcmd;
	int i, checksumIndex, lost;
	qbool dontdrop;
	static float pps_balance = 0;
	static int dropcount = 0;

	if (cls.demoplayback && !cls.mvdplayback) {
		CL_CalcNet();
		return; // sendcmds come from the demo
	}

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	CL_SendChunkDownloadReq();
#endif

	// save this command off for prediction
	i = cls.netchan.outgoing_sequence & UPDATE_MASK;
	cmd = &cl.frames[i].cmd;
	cl.frames[i].senttime = cls.realtime;
	cl.frames[i].receivedtime = -1;		// we haven't gotten a reply yet

	// update network stats table
	i = cls.netchan.outgoing_sequence & NETWORK_STATS_MASK;
	network_stats[i].delta = 0;     // filled-in later
	network_stats[i].sentsize = 0;  // filled-in later
	network_stats[i].senttime = cls.realtime;
	network_stats[i].receivedtime = -1;

	// get basic movement from keyboard
	CL_BaseMove(cmd);

	// allow mice or other external controllers to add to the move

	if (cl_independentPhysics.value == 0 || (physframe && cl_independentPhysics.value != 0)) {
		IN_Move(cmd);
	}

	// if we are spectator, try autocam
	if (cl.spectator) {
		Cam_Track(cmd);
	}

	// Apply safestrafe if enabled on server
	if ((movevars.safestrafe > 0 || cl_safestrafe.value > 0) && !cl.spectator) {
		CL_ApplySafestrafe(cmd);
	}

	CL_FinishMove(cmd);
	cmdtime_msec += cmd->msec;

	Cam_FinishMove(cmd);

	if (cls.mvdplayback) {
		CL_CalcPlayerFPS(&cl.players[cl.playernum], cmd->msec);
		cls.netchan.outgoing_sequence++;
		return;
	}

	SZ_Init(&buf, data, sizeof(data));

	SZ_Write(&buf, cls.cmdmsg.data, cls.cmdmsg.cursize);

	if (cls.cmdmsg.overflowed) {
		Com_DPrintf("cls.cmdmsg overflowed\n");
	}

	SZ_Clear(&cls.cmdmsg);

	// begin a client move command
	MSG_WriteByte(&buf, clc_move);

	// save the position for a checksum byte
	checksumIndex = buf.cursize;
	MSG_WriteByte(&buf, 0);

	// write our lossage percentage
	lost = CL_CalcNet();
	MSG_WriteByte(&buf, (byte)lost);

	// send this and the previous two cmds in the message, so if the last packet was dropped, it can be recovered
	dontdrop = false;

	i = (cls.netchan.outgoing_sequence - 2) & UPDATE_MASK;
	cmd = &cl.frames[i].cmd;

	if (cl_c2sImpulseBackup.value >= 2) {
		dontdrop = dontdrop || cmd->impulse;
	}

	MSG_WriteDeltaUsercmd(&buf, &nullcmd, cmd, cls.mvdprotocolextensions1);
	oldcmd = cmd;

	i = (cls.netchan.outgoing_sequence - 1) & UPDATE_MASK;
	cmd = &cl.frames[i].cmd;

	if (cl_c2sImpulseBackup.value >= 3) {
		dontdrop = dontdrop || cmd->impulse;
	}

	MSG_WriteDeltaUsercmd(&buf, oldcmd, cmd, cls.mvdprotocolextensions1);
	oldcmd = cmd;

	i = (cls.netchan.outgoing_sequence) & UPDATE_MASK;
	cmd = &cl.frames[i].cmd;
	if (cl_c2sImpulseBackup.value >= 1)
		dontdrop = dontdrop || cmd->impulse;
	MSG_WriteDeltaUsercmd(&buf, oldcmd, cmd, cls.mvdprotocolextensions1);

	// calculate a checksum over the move commands
	buf.data[checksumIndex] = COM_BlockSequenceCRCByte(
		buf.data + checksumIndex + 1, buf.cursize - checksumIndex - 1,
		cls.netchan.outgoing_sequence);

	// request delta compression of entities
	if (cls.netchan.outgoing_sequence - cl.validsequence >= UPDATE_BACKUP - 1) {
		cl.validsequence = 0;
		cl.delta_sequence = 0;
	}

	if (cl.delta_sequence && !cl_nodelta.value && cls.state == ca_active) {
		cl.frames[cls.netchan.outgoing_sequence & UPDATE_MASK].delta_sequence = cl.delta_sequence;
		MSG_WriteByte(&buf, clc_delta);
		MSG_WriteByte(&buf, cl.delta_sequence & 255);

		// network stats table
		network_stats[cls.netchan.outgoing_sequence & NETWORK_STATS_MASK].delta = 1;
	}
	else {
		cl.frames[cls.netchan.outgoing_sequence & UPDATE_MASK].delta_sequence = -1;
	}

	if (cls.demorecording) {
		CL_WriteDemoCmd(cmd);
	}

	if (cl_c2spps.value) {
		pps_balance += cls.frametime;
		// never drop more than 2 messages in a row -- that'll cause PL
		// and don't drop if one of the last two movemessages have an impulse
		if (pps_balance > 0 || dropcount >= 2 || dontdrop) {
			float	pps;
			pps = cl_c2spps.value;
			if (pps < 10) pps = 10;
			if (pps > 72) pps = 72;
			pps_balance -= 1 / pps;
			// bound pps_balance. FIXME: is there a better way?
			if (pps_balance > 0.1) pps_balance = 0.1;
			if (pps_balance < -0.1) pps_balance = -0.1;
			dropcount = 0;
		}
		else {
			// don't count this message when calculating PL
			cl.frames[i].receivedtime = -3;
			// drop this message
			cls.netchan.outgoing_sequence++;
			dropcount++;
			return;
		}
	}
	else {
		pps_balance = 0;
		dropcount = 0;
	}

#ifdef FTE_PEXT2_VOICECHAT
	S_Voip_Transmit(clc_voicechat, &buf);
#endif

	cl.frames[cls.netchan.outgoing_sequence & UPDATE_MASK].sentsize = buf.cursize + 8;    // 8 = PACKET_HEADER
	// network stats table
	network_stats[cls.netchan.outgoing_sequence & NETWORK_STATS_MASK].sentsize = buf.cursize + 8;

	//send duplicated packets, if set
	cls.netchan.dupe = bound(0, cl_c2sdupe.value, MAX_DUPLICATE_PACKETS);

	// deliver the message
	Netchan_Transmit(&cls.netchan, buf.cursize, buf.data);
}

void CL_InitInput(void)
{
	Cmd_AddCommand("+moveup", IN_UpDown);
	Cmd_AddCommand("-moveup", IN_UpUp);
	Cmd_AddCommand("+movedown", IN_DownDown);
	Cmd_AddCommand("-movedown", IN_DownUp);
	Cmd_AddCommand("+left", IN_LeftDown);
	Cmd_AddCommand("-left", IN_LeftUp);
	Cmd_AddCommand("+right", IN_RightDown);
	Cmd_AddCommand("-right", IN_RightUp);
	Cmd_AddCommand("+forward", IN_ForwardDown);
	Cmd_AddCommand("-forward", IN_ForwardUp);
	Cmd_AddCommand("+back", IN_BackDown);
	Cmd_AddCommand("-back", IN_BackUp);
	Cmd_AddCommand("+lookup", IN_LookupDown);
	Cmd_AddCommand("-lookup", IN_LookupUp);
	Cmd_AddCommand("+lookdown", IN_LookdownDown);
	Cmd_AddCommand("-lookdown", IN_LookdownUp);
	Cmd_AddCommand("+strafe", IN_StrafeDown);
	Cmd_AddCommand("-strafe", IN_StrafeUp);
	Cmd_AddCommand("+moveleft", IN_MoveleftDown);
	Cmd_AddCommand("-moveleft", IN_MoveleftUp);
	Cmd_AddCommand("+moveright", IN_MoverightDown);
	Cmd_AddCommand("-moveright", IN_MoverightUp);
	Cmd_AddCommand("+speed", IN_SpeedDown);
	Cmd_AddCommand("-speed", IN_SpeedUp);
	Cmd_AddCommand("+attack", IN_AttackDown);
	Cmd_AddCommand("-attack", IN_AttackUp);
	Cmd_AddCommand("+fire", IN_FireDown);
	Cmd_AddCommand("-fire", IN_FireUp);
	Cmd_AddCommand("+fire_ar", IN_FireDown);
	Cmd_AddCommand("-fire_ar", IN_FireUp);
	Cmd_AddCommand("+attack2", IN_Attack2Down);
	Cmd_AddCommand("-attack2", IN_Attack2Up);
	Cmd_AddCommand("+use", IN_UseDown);
	Cmd_AddCommand("-use", IN_UseUp);
	Cmd_AddCommand("+jump", IN_JumpDown);
	Cmd_AddCommand("-jump", IN_JumpUp);
	Cmd_AddCommand("impulse", IN_Impulse);
	Cmd_AddCommand("weapon", IN_Weapon);
	Cmd_AddCommand("+klook", IN_KLookDown);
	Cmd_AddCommand("-klook", IN_KLookUp);
	Cmd_AddCommand("+mlook", IN_MLookDown);
	Cmd_AddCommand("-mlook", IN_MLookUp);
	Cmd_AddCommand("rotate", CL_Rotate_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_INPUT_KEYBOARD);

	Cvar_Register(&cl_smartjump);
	Cvar_Register(&cl_weaponhide);
	Cvar_Register(&cl_weaponpreselect);
	Cvar_Register(&cl_weaponforgetorder);
	Cvar_Register(&cl_weaponhide_axe);
	Cvar_Register(&cl_upspeed);
	Cvar_Register(&cl_forwardspeed);
	Cvar_Register(&cl_backspeed);
	Cvar_Register(&cl_safestrafe);
	Cvar_Register(&cl_sidespeed);
	Cvar_Register(&cl_movespeedkey);
	Cvar_Register(&cl_yawspeed);
	Cvar_Register(&cl_pitchspeed);
	Cvar_Register(&cl_anglespeedkey);
	Cvar_Register(&cl_iDrive);

	Cvar_SetCurrentGroup(CVAR_GROUP_INPUT_MISC);
	Cvar_Register(&lookspring);
	Cvar_Register(&lookstrafe);
	Cvar_Register(&sensitivity);
	Cvar_Register(&freelook);

	Cvar_SetCurrentGroup(CVAR_GROUP_MENU);
	Cvar_Register(&cursor_sensitivity);

	Cvar_SetCurrentGroup(CVAR_GROUP_INPUT_MOUSE);
	Cvar_Register(&m_pitch);
	Cvar_Register(&m_yaw);
	Cvar_Register(&m_forward);
	Cvar_Register(&m_side);
	Cvar_Register(&m_accel);
	Cvar_Register(&m_accel_power);
	Cvar_Register(&m_accel_offset);
	Cvar_Register(&m_accel_senscap);

	Cvar_SetCurrentGroup(CVAR_GROUP_NETWORK);
	Cvar_Register(&cl_nodelta);
	Cvar_Register(&cl_c2sImpulseBackup);
	Cvar_Register(&cl_c2spps);
	Cvar_Register(&cl_c2sdupe);
	Cvar_ResetCurrentGroup();

#ifdef JSS_CAM
	Cvar_SetCurrentGroup(CVAR_GROUP_SPECTATOR);
	Cvar_Register(&cam_zoomspeed);
	Cvar_Register(&cam_zoomaccel);
	Cvar_ResetCurrentGroup();
#endif // JSS_CAM
}

void IN_ClearProtectedKeys(void)
{
	// Pretend the user entered -moveleft etc at the console
	KeyUp_common(&in_up, VOID_KEY);
	KeyUp_common(&in_down, VOID_KEY);
	KeyUp_common(&in_left, VOID_KEY);
	KeyUp_common(&in_right, VOID_KEY);
	KeyUp_common(&in_forward, VOID_KEY);
	KeyUp_common(&in_back, VOID_KEY);
	KeyUp_common(&in_lookup, VOID_KEY);
	KeyUp_common(&in_lookdown, VOID_KEY);
	KeyUp_common(&in_moveleft, VOID_KEY);
	KeyUp_common(&in_moveright, VOID_KEY);
}


================================================
FILE: src/cl_main.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
// cl_main.c  -- client main loop

#include "quakedef.h"
#include "cdaudio.h"
#include "cl_slist.h"
#include "movie.h"
#include "logging.h"
#include "ignore.h"
#include "fchecks.h"
#include "config_manager.h"
#include "mvd_utils.h"
#include "EX_browser.h"
#include "EX_qtvlist.h"
#include "qtv.h"
#include "keys.h"
#include "hud.h"
#include "hud_common.h"
#include "hud_editor.h"
#include "input.h"
#include "gl_model.h"
#include "tr_types.h"
#include "teamplay.h"
#include "tp_triggers.h"
#include "rulesets.h"
#include "version.h"
#include "stats_grid.h"
#include "fmod.h"
#include "sbar.h"
#include "utils.h"
#include "qsound.h"
#include "menu.h"
#include "image.h"
#ifndef _WIN32
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif
#ifndef CLIENTONLY
#include "server.h"
#endif
#include "fs.h"
#include "help.h"
#include "irc.h"
#ifdef _DEBUG
#include "parser.h"
#endif
#include "pmove.h"
#include "vx_tracker.h"
#include "menu_demo.h"
#include "r_local.h"
#include "r_renderer.h"
#include "r_performance.h"
#include "r_program.h"
#include "demo_spawnwarn.h"

extern qbool ActiveApp, Minimized;

#ifndef CLIENTONLY
static void Dev_PhysicsNormalSet(void);
static void Dev_PhysicsNormalSave(void);
static void Dev_PhysicsNormalShow(void);
#endif

static void Cl_Reset_Min_fps_f(void);
void CL_QWURL_ProcessChallenge(const char *parameters);

// cl_input.c
void onchange_pext_serversideweapon(cvar_t* var, char* value, qbool* cancel);
void onchange_hud_performance_average(cvar_t* var, char* value, qbool* cancel);

#ifdef MVD_PEXT1_HIDDEN_MESSAGES
// cl_parse.c
void CL_ParseHiddenDataMessage(void);
#endif

static void AuthUsernameChanged(cvar_t* var, char* value, qbool* cancel);

cvar_t	allow_scripts = {"allow_scripts", "2", 0, Rulesets_OnChange_allow_scripts};
cvar_t	rcon_password = {"rcon_password", ""};
cvar_t	rcon_address = {"rcon_address", ""};
cvar_t	cl_crypt_rcon = {"cl_crypt_rcon", "1"};

cvar_t	cl_timeout = {"cl_timeout", "60"};

cvar_t	cl_delay_packet = {"cl_delay_packet", "0", 0, Rulesets_OnChange_cl_delay_packet};
cvar_t  cl_delay_packet_target = { "cl_delay_packet_target", "0", 0, Rulesets_OnChange_cl_delay_packet };
cvar_t  cl_delay_packet_dev = { "cl_delay_packet_deviation", "0", 0, Rulesets_OnChange_cl_delay_packet };

cvar_t	cl_shownet = {"cl_shownet", "0"};	// can be 0, 1, or 2
#if defined(PROTOCOL_VERSION_FTE) || defined(PROTOCOL_VERSION_FTE2) || defined(PROTOCOL_VERSION_MVD1)
cvar_t  cl_pext = {"cl_pext", "1"};					// allow/disallow protocol extensions at all.
													// some extensions can be explicitly controlled.
cvar_t  cl_pext_limits = { "cl_pext_limits", "1" }; // enhanced protocol limits
cvar_t  cl_pext_other = {"cl_pext_other", "0"};		// extensions which does not have own variables should be controlled by this variable.
cvar_t  cl_pext_warndemos = { "cl_pext_warndemos", "1" }; // if set, user will be warned when saving demos that are not backwards compatible
cvar_t  cl_pext_lagteleport = { "cl_pext_lagteleport", "1" }; // server-side adjustment of yaw angle through teleports
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
cvar_t  cl_pext_serversideweapon = { "cl_pext_serversideweapon", "0", 0, onchange_pext_serversideweapon }; // server-side weapon selection
#endif
#endif
#ifdef FTE_PEXT_256PACKETENTITIES
cvar_t	cl_pext_256packetentities = {"cl_pext_256packetentities", "1"};
#endif
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
cvar_t  cl_pext_chunkeddownloads  = {"cl_pext_chunkeddownloads", "1"};
cvar_t  cl_chunksperframe  = {"cl_chunksperframe", "30"};
#endif

#ifdef FTE_PEXT_FLOATCOORDS
cvar_t  cl_pext_floatcoords  = {"cl_pext_floatcoords", "1"};
#endif

#ifdef FTE_PEXT_TRANS
cvar_t cl_pext_alpha = {"cl_pext_alpha", "1"};
#endif

#ifdef FTE_PEXT_COLOURMOD
cvar_t cl_pext_colourmod = {"cl_pext_colourmod", "1"};
#endif

#ifdef CLIENTONLY
#define PROCESS_SERVERPACKETS_IMMEDIATELY (0)
#else
static cvar_t cl_sv_packetsync = { "cl_sv_packetsync", "1" };
#define PROCESS_SERVERPACKETS_IMMEDIATELY (cl_sv_packetsync.integer)
#endif


cvar_t	cl_sbar		= {"cl_sbar", "0"};
cvar_t	cl_hudswap	= {"cl_hudswap", "0"};
cvar_t	cl_maxfps	= {"cl_maxfps", "0"};
cvar_t	cl_maxfps_menu	= {"cl_maxfps_menu", "0"};
cvar_t	cl_physfps	= {"cl_physfps", "0"};	//#fps
cvar_t	cl_physfps_spectator = {"cl_physfps_spectator", "77"};
cvar_t  cl_independentPhysics = {"cl_independentPhysics", "1", 0, Rulesets_OnChange_indphys};

cvar_t	cl_predict_players = {"cl_predict_players", "1"};
cvar_t	cl_solid_players = {"cl_solid_players", "1"};
cvar_t	cl_predict_half = {"cl_predict_half", "0"};

cvar_t	hud_fps_min_reset_interval = {"hud_fps_min_reset_interval", "30"};
cvar_t  hud_frametime_max_reset_interval = { "hud_frametime_max_reset_interval", "30" };
cvar_t  hud_performance_average = { "hud_performance_average", "1", 0, onchange_hud_performance_average };

cvar_t  localid = {"localid", ""};

static qbool allowremotecmd = true;

cvar_t	cl_deadbodyfilter = {"cl_deadbodyFilter", "0"};
cvar_t	cl_gibfilter = {"cl_gibFilter", "0"};
cvar_t	cl_backpackfilter = {"cl_backpackfilter", "0"};
cvar_t	cl_muzzleflash = {"cl_muzzleflash", "1"};
cvar_t	cl_rocket2grenade = {"cl_r2g", "0"};
cvar_t	cl_demospeed = {"cl_demospeed", "1"};
cvar_t	cl_staticsounds = {"cl_staticSounds", "1"};
cvar_t	cl_fakeshaft = {"cl_fakeshaft", "1", 0, Rulesets_OnChange_cl_fakeshaft};
cvar_t	cl_fakeshaft_extra_updates = {"cl_fakeshaft_extra_updates", "1"};
cvar_t	cl_parseWhiteText = {"cl_parseWhiteText", "1"};
cvar_t	cl_filterdrawviewmodel = {"cl_filterdrawviewmodel", "0"};
cvar_t	cl_demoPingInterval = {"cl_demoPingInterval", "5"};
cvar_t  demo_getpings      = {"demo_getpings",    "1"};
cvar_t	cl_chatsound = {"s_chat_custom", "1"};
cvar_t	cl_confirmquit = {"cl_confirmquit", "0"}; // , CVAR_INIT
cvar_t	cl_fakename = {"cl_fakename", ""};
cvar_t	cl_fakename_suffix = {"cl_fakename_suffix", ": "};
cvar_t	qizmo_dir = {"qizmo_dir", "qizmo"};
cvar_t	qwdtools_dir = {"qwdtools_dir", "qwdtools"};
void OnChangeColorForcing (cvar_t *var, char *value, qbool *cancel);
void OnChangeDemoTeamplay (cvar_t *var, char *value, qbool *cancel);
cvar_t  cl_demoteamplay = {"cl_demoteamplay", "0", 0, OnChangeDemoTeamplay};	// for NQ demos where we need to say it is teamplay rather than FFA

cvar_t	cl_earlypackets = {"cl_earlypackets", "1"};

cvar_t	cl_restrictions = {"cl_restrictions", "0"}; // 1 is FuhQuake and QW262 defaults

cvar_t cl_floodprot			= {"cl_floodprot", "0"};
cvar_t cl_fp_messages		= {"cl_fp_messages", "4"};
cvar_t cl_fp_persecond		= {"cl_fp_persecond", "4"};
cvar_t cl_cmdline			= {"cl_cmdline", "", CVAR_ROM};
cvar_t cl_useproxy			= {"cl_useproxy", "0"};
cvar_t cl_proxyaddr         = {"cl_proxyaddr", ""};
cvar_t cl_window_caption	= {"cl_window_caption", "1"};
cvar_t cl_window_caption_delimiter = {"cl_window_caption_delimiter", " | "};

cvar_t cl_model_bobbing		= {"cl_model_bobbing", "1"};
cvar_t cl_nolerp			= {"cl_nolerp", "0"}; // 0 is good for indep-phys, 1 is good for old-phys

//this var has effect only if cl_nolerp is 1 and indep-phys enabled
//setting it to 0 removes jerking when standing on platforms
cvar_t cl_nolerp_on_entity	= {"cl_nolerp_on_entity", "0"};

cvar_t cl_newlerp				= {"cl_newlerp", "0"};
cvar_t cl_lerp_monsters			= {"cl_lerp_monsters", "1"};
cvar_t cl_fix_mvd				= {"cl_fix_mvd", "0"};

cvar_t r_rocketlight            = {"r_rocketLight", "1"};
cvar_t r_rocketlightcolor       = {"r_rocketLightColor", "0"};
cvar_t r_explosionlightcolor    = {"r_explosionLightColor", "0"};
cvar_t r_explosionlight         = {"r_explosionLight", "1"};
cvar_t r_flagcolor              = {"r_flagColor", "0"};
cvar_t r_lightflicker           = {"r_lightflicker", "1"};
cvar_t r_powerupglow            = {"r_powerupGlow", "1"};
cvar_t cl_novweps               = {"cl_novweps", "0"};
cvar_t r_drawvweps              = {"r_drawvweps", "1"};
cvar_t r_rockettrail            = {"r_rocketTrail", "1"}; // 9
cvar_t r_grenadetrail           = {"r_grenadeTrail", "1"}; // 3
cvar_t r_railtrail              = {"r_railTrail", "1"};
cvar_t r_instagibtrail          = {"r_instagibTrail", "1"};
cvar_t r_explosiontype          = {"r_explosionType", "1"}; // 7
cvar_t r_telesplash             = {"r_telesplash", "1"}; // disconnect
cvar_t r_shaftalpha             = {"r_shaftalpha", "1"};
cvar_t r_lightdecayrate         = {"r_lightdecayrate", "2"}; // default 2, as CL_DecayLights() used to get called twice per frame
cvar_t r_lightmap_lateupload    = {"r_lightmap_lateupload", "0"};
cvar_t r_lightmap_packbytexture = {"r_lightmap_packbytexture", "2"};

// info mirrors
cvar_t  password                = {"password", "", CVAR_USERINFO};
cvar_t  spectator               = {"spectator", "", CVAR_USERINFO_NO_CFG_RESET };
void CL_OnChange_name_validate(cvar_t *var, char *val, qbool *cancel);
cvar_t  name                    = {"name", "player", CVAR_USERINFO, CL_OnChange_name_validate};
cvar_t  team                    = {"team", "", CVAR_USERINFO_NO_CFG_RESET };
cvar_t  topcolor                = {"topcolor","", CVAR_USERINFO_NO_CFG_RESET };
cvar_t  bottomcolor             = {"bottomcolor","", CVAR_USERINFO_NO_CFG_RESET };
cvar_t  skin                    = {"skin", "", CVAR_USERINFO_NO_CFG_RESET };
cvar_t  rate                    = {"rate", "25000", CVAR_USERINFO};
void OnChange_AppliedAfterReconnect (cvar_t *var, char *value, qbool *cancel);
cvar_t  mtu                     = {"mtu", "", CVAR_USERINFO, OnChange_AppliedAfterReconnect};
cvar_t  msg                     = {"msg", "1", CVAR_USERINFO};
cvar_t  noaim                   = {"noaim", "1", CVAR_USERINFO};
cvar_t  w_switch                = {"w_switch", "", CVAR_USERINFO};
cvar_t  b_switch                = {"b_switch", "", CVAR_USERINFO};
cvar_t  railcolor               = {"railcolor", "", CVAR_USERINFO};
cvar_t  gender                  = {"gender", "", CVAR_USERINFO};

cvar_t  cl_mediaroot            = {"cl_mediaroot", "0"};

cvar_t  msg_filter              = {"msg_filter", "0"};

cvar_t  cl_onload               = {"cl_onload", "menu"};

#ifdef WIN32
cvar_t cl_verify_qwprotocol     = {"cl_verify_qwprotocol", "1"};
#endif // WIN32

cvar_t demo_autotrack           = {"demo_autotrack", "0"}; // use or not autotrack info from mvd demos

// Authentication
cvar_t cl_username              = {"cl_username", "", CVAR_QUEUED_TRIGGER, AuthUsernameChanged};
static void CL_Authenticate_f(void);

// antilag debugging
cvar_t cl_debug_antilag_view    = { "cl_debug_antilag_view", "0" };
cvar_t cl_debug_antilag_ghost   = { "cl_debug_antilag_ghost", "0" };
cvar_t cl_debug_antilag_self    = { "cl_debug_antilag_self", "0" };
cvar_t cl_debug_antilag_lines   = { "cl_debug_antilag_lines", "0" };
cvar_t cl_debug_antilag_send    = { "cl_debug_antilag_send", "0" };

// weapon-switching debugging
cvar_t cl_debug_weapon_view     = { "cl_debug_weapon_view", "0" };

/// persistent client state
clientPersistent_t	cls;

/// client state
clientState_t		cl;

centity_t       cl_entities[CL_MAX_EDICTS];
entity_t		cl_static_entities[MAX_STATIC_ENTITIES];
lightstyle_t	cl_lightstyle[MAX_LIGHTSTYLES];
dlight_t		cl_dlights[MAX_DLIGHTS];
unsigned int cl_dlight_active[MAX_DLIGHTS/32];

// refresh list
visentlist_t    cl_visents;

double		connect_time = 0;		// for connection retransmits
qbool		connected_via_proxy = false;

qbool	host_skipframe;			// used in demo playback

byte		*host_basepal = NULL;
byte		*host_colormap = NULL;

qbool physframe;
double physframetime;

// emodel and pmodel are encrypted to prevent llamas from easily hacking them
char emodel_name[] = { 'e'^0xe5, 'm'^0xe5, 'o'^0xe5, 'd'^0xe5, 'e'^0xe5, 'l'^0xe5, 0 };
char pmodel_name[] = { 'p'^0xe5, 'm'^0xe5, 'o'^0xe5, 'd'^0xe5, 'e'^0xe5, 'l'^0xe5, 0 };

static void simple_crypt (char *buf, int len) {
	while (len--)
		*buf++ ^= 0xe5;
}

static void CL_FixupModelNames (void) {
	simple_crypt (emodel_name, sizeof(emodel_name) - 1);
	simple_crypt (pmodel_name, sizeof(pmodel_name) - 1);
}

void OnChange_AppliedAfterReconnect (cvar_t *var, char *value, qbool *cancel)
{
	if (cls.state != ca_disconnected)
	{
		Com_Printf ("%s change will be applied after reconnect!\n", var->name);
	}
}

char *CL_Macro_ConnectionType(void) 
{
	char *s;
	static char macrobuf[16];

	s = (cls.state < ca_connected) ? "disconnected" : cl.spectator ? "spectator" : "player";
	strlcpy(macrobuf, s, sizeof(macrobuf));
	return macrobuf;
}

char *CL_Macro_Demoplayback(void) 
{
	char *s;
	static char macrobuf[16];

	s = cls.mvdplayback ? "mvdplayback" : cls.demoplayback ? "qwdplayback" : "0";
	strlcpy(macrobuf, s, sizeof(macrobuf));
	return macrobuf;
}

char *CL_Macro_Demotime(void)
{   
	// Intended for scripted & timed camera movement
	static char macrobuf[16];

	snprintf(macrobuf, sizeof(macrobuf), "%f", (float) cls.demotime);
	return macrobuf;
}

char *CL_Macro_Rand(void)
{
	// Returns a number in range <0..1)
	static char macrobuf[16];

	snprintf(macrobuf, sizeof(macrobuf), "%f", (double) rand() / RAND_MAX);
	return macrobuf;
}

char *CL_Macro_Serverstatus(void)
{
	char *s;
	static char macrobuf[16];

	s = (cls.state < ca_connected) ? "disconnected" : cl.standby ? "standby" : "normal";
	strlcpy(macrobuf, s, sizeof(macrobuf));
	return macrobuf;
}

char *CL_Macro_ServerIp(void) 
{
	return NET_AdrToString(cls.server_adr);
}

char *CL_Macro_Conwidth(void) 
{
	static char macrobuf[16];
	snprintf(macrobuf, sizeof(macrobuf), "%i", vid.conwidth);
	return macrobuf;
}

char *CL_Macro_Conheight(void)
{
	static char macrobuf[16];
	snprintf(macrobuf, sizeof(macrobuf), "%i", vid.conheight);
	return macrobuf;
}

int CL_ClientState (void)
{
	return cls.state;
}

void CL_MakeActive(void) 
{
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nevent,active (map=%s)\n", host_mapname.string);
#endif
	// last chance
	CachePics_AtlasFrame();
	// compile all programs
	if (GL_Supported(R_SUPPORT_RENDERING_SHADERS)) {
		R_ProgramCompileAll();
	}

	cls.state = ca_active;
	if (cls.demoplayback) 
	{
		host_skipframe = true;
		demostarttime = cls.demotime;
	}

	if (key_dest == key_startupdemo_game) {
		key_dest = key_game;
	}

	if (!cls.demoseeking) {
		Con_ClearNotify ();
	}
	
	// Reset safestrafe state on spawn
	memset(&cl.safestrafe, 0, sizeof(cl.safestrafe));
	
	TP_ExecTrigger("f_spawn");
}

// Cvar system calls this when a CVAR_USERINFO cvar changes
void CL_UserinfoChanged (char *key, char *string) 
{
	char *s;

	s = TP_ParseFunChars (string, false);

	if (strcmp(s, Info_ValueForKey (cls.userinfo, key))) 
	{
		Info_SetValueForKey (cls.userinfo, key, s, MAX_INFO_STRING);

		if (cls.state >= ca_connected)
		{
			if (cls.mvdplayback == QTV_PLAYBACK)
			{
				QTV_Cmd_Printf(QTV_EZQUAKE_EXT_SETINFO, "setinfo \"%s\" \"%s\"", key, s);
			}
			else
			{
				MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
				SZ_Print (&cls.netchan.message, va("setinfo \"%s\" \"%s\"", key, s));
			}
		}
	}
}

#ifdef PROTOCOL_VERSION_FTE
unsigned int CL_SupportedFTEExtensions (void)
{
	unsigned int fteprotextsupported = 0;

	if (!cl_pext.value)
		return 0;

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	if (cl_pext_chunkeddownloads.value)
		fteprotextsupported |= FTE_PEXT_CHUNKEDDOWNLOADS;
#endif

#ifdef FTE_PEXT_256PACKETENTITIES
	if (cl_pext_256packetentities.value)
		fteprotextsupported |= FTE_PEXT_256PACKETENTITIES;
#endif

#ifdef FTE_PEXT_FLOATCOORDS
	if (cl_pext_floatcoords.value)
		fteprotextsupported |= FTE_PEXT_FLOATCOORDS;
#endif

#ifdef FTE_PEXT_TRANS
	if (cl_pext_alpha.value)
		fteprotextsupported |= FTE_PEXT_TRANS;
#endif
#ifdef FTE_PEXT_COLOURMOD
	if (cl_pext_colourmod.value)
		fteprotextsupported |= FTE_PEXT_COLOURMOD;
#endif

	if (cl_pext_limits.value) {
#ifdef FTE_PEXT_MODELDBL
		fteprotextsupported |= FTE_PEXT_MODELDBL;
#endif
#ifdef FTE_PEXT_ENTITYDBL
		fteprotextsupported |= FTE_PEXT_ENTITYDBL;
#endif
#ifdef FTE_PEXT_ENTITYDBL2
		fteprotextsupported |= FTE_PEXT_ENTITYDBL2;
#endif
#ifdef FTE_PEXT_SPAWNSTATIC2
		fteprotextsupported |= FTE_PEXT_SPAWNSTATIC2;
#endif
	}

	if (cl_pext_other.value)
	{
#ifdef FTE_PEXT_ACCURATETIMINGS
		fteprotextsupported |= FTE_PEXT_ACCURATETIMINGS;
#endif
#ifdef FTE_PEXT_HLBSP
		fteprotextsupported |= FTE_PEXT_HLBSP;
#endif
	}

	return fteprotextsupported;
}
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
unsigned int CL_SupportedFTEExtensions2 (void)
{
	unsigned int fteprotextsupported2 = 0
#ifdef FTE_PEXT2_VOICECHAT
		| FTE_PEXT2_VOICECHAT
#endif
		;

	if (!cl_pext.value)
		return 0;

	return fteprotextsupported2;
}
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
unsigned int CL_SupportedMVDExtensions1(void)
{
	unsigned int extensions_supported = 0;

	if (!cl_pext.value) {
		return 0;
	}

#ifdef MVD_PEXT1_FLOATCOORDS
	if (cl_pext_floatcoords.value) {
		extensions_supported |= MVD_PEXT1_FLOATCOORDS;
	}
#endif

#ifdef MVD_PEXT1_HIGHLAGTELEPORT
	if (cl_pext_lagteleport.integer & 1) {
		extensions_supported |= MVD_PEXT1_HIGHLAGTELEPORT;
	}
#endif

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	if (cl_pext_serversideweapon.integer) {
		extensions_supported |= MVD_PEXT1_SERVERSIDEWEAPON;
	}
#endif

#ifdef MVD_PEXT1_DEBUG_ANTILAG
	if (cl_debug_antilag_send.integer) {
		extensions_supported |= MVD_PEXT1_DEBUG_ANTILAG;
	}
#endif

	return extensions_supported;
}
#endif

// Called by CL_Connect_f and CL_CheckResend
static void CL_SendConnectPacket(
#ifdef PROTOCOL_VERSION_FTE
	unsigned int ftepext
#ifdef PROTOCOL_VERSION_FTE2
	,
#endif // PROTOCOL_VERSION_FTE2
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_FTE2
	unsigned int ftepext2
#ifdef PROTOCOL_VERSION_MVD1
	,
#endif
#endif // PROTOCOL_VERSION_FTE2
#ifdef PROTOCOL_VERSION_MVD1
	unsigned int mvdpext1
#endif
								) 
{
	char data[2048];
	char biguserinfo[MAX_INFO_STRING + 32];
	int extensions;
	extern cvar_t cl_novweps;

	if (cls.state != ca_disconnected)
		return;

#ifdef PROTOCOL_VERSION_FTE
	cls.fteprotocolextensions  = (ftepext & CL_SupportedFTEExtensions());
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_FTE2
	cls.fteprotocolextensions2  = (ftepext2 & CL_SupportedFTEExtensions2());
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_MVD1
	cls.mvdprotocolextensions1 = (mvdpext1 & CL_SupportedMVDExtensions1());
#endif

	connect_time = cls.realtime; // For retransmit requests
	cls.qport = Cvar_Value("qport");

	// Let the server know what extensions we support.
	strlcpy (biguserinfo, cls.userinfo, sizeof (biguserinfo));
	extensions = CLIENT_EXTENSIONS &~ (cl_novweps.value ? Z_EXT_VWEP : 0);
	Info_SetValueForStarKey (biguserinfo, "*z_ext", va("%i", extensions), sizeof(biguserinfo));

	snprintf(data, sizeof(data), "\xff\xff\xff\xff" "connect %i %i %i \"%s\"\n", PROTOCOL_VERSION, cls.qport, cls.challenge, biguserinfo);

#ifdef PROTOCOL_VERSION_FTE
	if (cls.fteprotocolextensions) 
	{
		char tmp[128];
		snprintf(tmp, sizeof(tmp), "0x%x 0x%x\n", PROTOCOL_VERSION_FTE, cls.fteprotocolextensions);
		Com_Printf_State(PRINT_DBG, "0x%x is fte protocol ver and 0x%x is fteprotocolextensions\n", PROTOCOL_VERSION_FTE, cls.fteprotocolextensions);
		strlcat(data, tmp, sizeof(data));
	}
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
	if (cls.fteprotocolextensions2) 
	{
		char tmp[128];
		snprintf(tmp, sizeof(tmp), "0x%x 0x%x\n", PROTOCOL_VERSION_FTE2, cls.fteprotocolextensions2);
		Com_Printf_State(PRINT_DBG, "0x%x is fte protocol ver and 0x%x is fteprotocolextensions2\n", PROTOCOL_VERSION_FTE2, cls.fteprotocolextensions2);
		strlcat(data, tmp, sizeof(data));
	}
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
	if (cls.mvdprotocolextensions1) {
		char tmp[128];
		snprintf(tmp, sizeof(tmp), "0x%x 0x%x\n", PROTOCOL_VERSION_MVD1, cls.mvdprotocolextensions1);
		Com_Printf_State(PRINT_DBG, "0x%x is mvd protocol ver and 0x%x is mvdprotocolextensions1\n", PROTOCOL_VERSION_MVD1, cls.mvdprotocolextensions1);
		strlcat(data, tmp, sizeof(data));
	}
#endif

	NET_SendPacket(NS_CLIENT, strlen(data), data, cls.server_adr);
}

// Resend a connect message if the last one has timed out
void CL_CheckForResend (void) 
{
	char data[2048];
	double t1, t2;

#ifndef CLIENTONLY
	if (cls.state == ca_disconnected && com_serveractive) 
	{
		// if the local server is running and we are not, then connect
		strlcpy (cls.servername, "local", sizeof(cls.servername));
		NET_StringToAdr("local", &cls.server_adr);

		// We don't need a challenge on the local server.
		CL_SendConnectPacket(
#ifdef PROTOCOL_VERSION_FTE
				svs.fteprotocolextensions
	#ifdef PROTOCOL_VERSION_FTE2
				,
	#endif // PROTOCOL_VERSION_FTE2
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_FTE2
				svs.fteprotocolextensions2
	#ifdef PROTOCOL_VERSION_MVD1
                ,
	#endif
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_MVD1
                svs.mvdprotocolextension1
#endif
		);
		
		// FIXME: cls.state = ca_connecting so that we don't send the packet twice?
		return;
	}
#endif

	if (cls.state != ca_disconnected || !connect_time)
		return;
	if (cls.realtime - connect_time < 5.0)
		return;

	t1 = Sys_DoubleTime();
	if (!NET_StringToAdr(cls.servername, &cls.server_adr)) 
	{
		Com_Printf("Bad server address\n");
		connect_time = 0;
		return;
	}

	t2 = Sys_DoubleTime();
	connect_time = cls.realtime + t2 - t1;	// for retransmit requests

	if (cls.server_adr.port == 0)
		cls.server_adr.port = BigShort(PORT_SERVER);

	Com_Printf("&cf11connect:&r %s...\n", cls.servername);
	snprintf(data, sizeof(data), "\xff\xff\xff\xff" "getchallenge\n");
	NET_SendPacket(NS_CLIENT, strlen(data), data, cls.server_adr);
}

void CL_BeginServerConnect(void) 
{
	connect_time = -999;	// CL_CheckForResend() will fire immediately
	CL_CheckForResend();
}

//
// Parses a QW-URL of the following format 
// (this can be associated with ezquake in windows by setting some reg info):
// qw://server:port/command
//
// Supported commands:
// - join/connect
// - spectate/observe
// - qtv
//
void CL_QWURL_f (void)
{
	char *connection_str = NULL;
	char *command = NULL;

	if (Cmd_Argc() != 2) 
	{
		Com_Printf ("Usage: %s <qw-url>\n", Cmd_Argv(0));
		return;
	}

	// Ensure someone isn't trying to concatenate commands.
	if (strchr(Cmd_Argv(1), ';') != NULL)
	{
		Com_Printf("%s: The QW-URL \"%s\" contains illegal characters\n",
			Cmd_Argv(0), Cmd_Argv(1));
		return;
	}

	// Strip the leading qw:// first.
	{
		char qws_str[] = "qw://";
		int qws_len	= sizeof(qws_str) - 1;

		connection_str = Cmd_Argv(1);

		if (!strncasecmp(qws_str, connection_str, qws_len))
		{
			connection_str += qws_len;
		}
		else
		{
			Com_Printf("%s: The QW-URL must start with qw://\n", Cmd_Argv(0));
			return;
		}
	}

	// Find the first "/" and treat what's after it as the command.	
	if ((command = strchr(connection_str, '/')))
	{
		// Null terminate the server name string.
		*command = 0;
		command++;
	}
	else
	{
		// No command given.
		command = "";
	}

	// Default to connecting.
	if (!strcmp(command, "") || !strncasecmp(command, "join", 4) || !strncasecmp(command, "connect", 7))
	{
		Cbuf_AddText(va("join %s\n", connection_str));
	}
	else if (!strncmp(command, "challenge?", 10))
	{
		CL_QWURL_ProcessChallenge(command + 9);
		Cbuf_AddText(va("connect %s\n", connection_str));
	}
	else if (!strncasecmp(command, "spectate", 8) || !strncasecmp(command, "observe", 7))
	{
		Cbuf_AddText(va("observe %s\n", connection_str));
	}
	else if (!strncasecmp(command, "qtv", 3))
	{
		char *password = command + 3;

		if (*password == '/') {
			*password = ' ';
		}
		else {
			*password = '\0';
		}

		Cbuf_AddText(va("qtvplay %s%s\n", connection_str, password));
	}
	else
	{
		Com_Printf("%s: Illegal command %s\n", Cmd_Argv(0), command);
	}
}

void CL_Connect_f (void) 
{
	qbool proxy;
	char *connect_addr = NULL;
	char *server_buf = NULL;
	portpingprobe_status_t status;

	if (Cmd_Argc() != 2) 
	{
		Com_Printf ("Usage: %s <server>\n", Cmd_Argv(0));
		return;
	}

	// It's not possible to change the source port when connected to a
	// server. Terminate the current connection before proceeding.
	if (IsPortPingProbeEnabled() && cls.state != ca_disconnected)
	{
		Host_EndGame();
	}

	// The user has already initiated a port ping probe, so we'll abort that
	// and wait for the worker thread to stop before we proceed.
	if (IsPortPingProbeEnabled() && (status = NET_GetPortPingProbeStatus()) == PORTPINGPROBE_PROBING)
	{
		NET_SetPortPingProbeStatus(PORTPINGPROBE_ABORT);
		while ((status = NET_GetPortPingProbeStatus()) != PORTPINGPROBE_READY)
		{
			Sys_MSleep(10);
		}
	}

	// in this part proxy means QWFWD proxy
	if (cl_proxyaddr.string[0]) {
		char *secondproxy;
		if ((secondproxy = strchr(cl_proxyaddr.string, '@'))) {
			size_t prx_buf_len = strlen(cl_proxyaddr.string) + strlen(Cmd_Argv(1)) + 2;
			char *prx_buf = (char *) Q_malloc(prx_buf_len);
			server_buf = (char *) Q_malloc(strlen(cl_proxyaddr.string) + 1); // much more than needed

			strlcpy(server_buf, cl_proxyaddr.string, secondproxy - cl_proxyaddr.string + 1);
			connect_addr = server_buf;
			
			strlcpy(prx_buf, secondproxy + 1, prx_buf_len);
			strlcat(prx_buf, "@", prx_buf_len);
			strlcat(prx_buf, Cmd_Argv(1), prx_buf_len);
			Info_SetValueForKeyEx(cls.userinfo, "prx", prx_buf, MAX_INFO_STRING, false);
			Q_free(prx_buf);
		}
		else {
			Info_SetValueForKey (cls.userinfo, "prx", Cmd_Argv(1), MAX_INFO_STRING);
#if 0 // FIXME: qqshka: disabled untill one explain that it does and why.
			if (cls.state >= ca_connected) {
				Cmd_ForwardToServer ();
			}
#endif
			connect_addr = cl_proxyaddr.string;
		}
		connected_via_proxy = true;
	}
	else
	{
		connect_addr = Cmd_Argv(1);
		connected_via_proxy = false;
	}

	if (IsPortPingProbeEnabled())
	{
		if (status == PORTPINGPROBE_READY)
		{
			NET_PortPingProbe(connect_addr, Cmd_Argv(1));
			return;
		}
		else if (status == PORTPINGPROBE_COMPLETED)
		{
			NET_SetPortPingProbeStatus(PORTPINGPROBE_READY);
		}
	}

	// in this part proxy means Qizmo proxy
	proxy = cl_useproxy.value && CL_ConnectedToProxy();

	if (proxy)
	{
		Cbuf_AddText(va("say ,connect %s\n", connect_addr));
	} 
	else
	{
		Host_EndGame();
		strlcpy(cls.servername, connect_addr, sizeof(cls.servername));
		CL_BeginServerConnect();
	}

	if (server_buf) Q_free(server_buf);
}

void CL_Connect_BestRoute_f(void)
{
	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: %s <address>\nConnects to given server via fastest available path (ping-wise).\n", Cmd_Argv(0));
		Com_Printf("Requires Server Browser refreshed with sb_findroutes 1\n");
		return;
	}
	else {
		netadr_t adr;
		if (!NET_StringToAdr(Cmd_Argv(1), &adr)) {
			Com_Printf("Invalid address\n");
			return;
		}

		if (adr.port == 0)
			adr.port = htons(27500);

		SB_PingTree_DumpPath(&adr);
		SB_PingTree_ConnectBestPath(&adr);
	}
}

void CL_TCPConnect_f (void)
{
	char buffer[6] = {'q', 'i', 'z', 'm', 'o', '\n'};
	int newsocket;
	int _true = true;

	float giveuptime;

	if (Cmd_Argc() != 2) {
		Com_Printf ("Usage: %s <server>\n", Cmd_Argv(0));
		return;
	}

	Host_EndGame (); // CL_Disconnect_f();

	strlcpy(cls.servername, Cmd_Argv (1), sizeof(cls.servername));

	NET_StringToAdr(cls.servername, &cls.sockettcpdest);

	if (cls.sockettcp != INVALID_SOCKET)
		closesocket(cls.sockettcp);

	cls.sockettcp = INVALID_SOCKET;
	cls.tcpinlen = 0;

	newsocket = TCP_OpenStream(cls.sockettcpdest);
	if (newsocket == INVALID_SOCKET)
	{
		// Failed
		Com_Printf("Failed to connect, server is either down, firewalled, or on a different port\n");
		return;
	}

	Com_Printf("Waiting for confirmation of server (10 secs)\n");

	giveuptime = Sys_DoubleTime() + 10;

#if 1 // qqshka: qizmo sends "qizmo\n" then expects reply, unfortunatelly that does not work for mvdsv
	// that how MVDSV expects, should work with qizmo too
	send(newsocket, buffer, sizeof(buffer), 0);
	memset(buffer, 0, sizeof(buffer));
#endif

	while(giveuptime > Sys_DoubleTime())
	{
		recv(newsocket, buffer, sizeof(buffer), 0);
		if (!strncmp(buffer, "qizmo\n", 6))
		{
			cls.sockettcp = newsocket;
			break;
		}
		SCR_UpdateScreen();
	}

	if (cls.sockettcp == INVALID_SOCKET)
	{
		Com_Printf("Timeout - wrong server type\n");
		closesocket(newsocket);
		return;
	}

	Com_Printf("Confirmed\n");

#if 0 // qqshka: qizmo sends "qizmo\n" then expects reply, unfortunatelly that does not work for mvdsv
	// that how qizmo expects, does not work with MVDSV
	send(cls.sockettcp, buffer, sizeof(buffer), 0);
#endif

	if (setsockopt(cls.sockettcp, IPPROTO_TCP, TCP_NODELAY, (char *)&_true, sizeof(_true)) == -1) {
		Com_Printf ("CL_TCPConnect_f: setsockopt: (%i): %s\n", qerrno, strerror(qerrno));
	}

	CL_BeginServerConnect();
}

qbool CL_ConnectedToProxy(void)
{
	cmd_alias_t *alias = NULL;
	qbool found = true;
	char **s;
	char *qizmo_aliases[] = {	"ezcomp", "ezcomp2", "ezcomp3",
									"f_sens", "f_fps", "f_tj", "f_ta", NULL};
	char *fteqtv_aliases[] = { "+proxleft", "+proxright", NULL }; // who would need more?

	if (cls.state < ca_active)
		return false;

	for (s = qizmo_aliases; *s; s++) 
	{
		if (!(alias = Cmd_FindAlias(*s)) || !(alias->flags & ALIAS_SERVER)) 
		{
			found = false; 
			break;
		}
	}

	if (found)
		return true;

	found = true;
	for (s = fteqtv_aliases; *s; s++) 
	{
		if (!(alias = Cmd_FindAlias(*s)) || !(alias->flags & ALIAS_SERVER)) 
		{
			found = false; break;
		}
	}

	return found;
}

void CL_Join_f (void) 
{
	qbool proxy;

	proxy = cl_useproxy.value && CL_ConnectedToProxy();

	if (Cmd_Argc() > 2) 
	{
		Com_Printf ("Usage: %s [server]\n", Cmd_Argv(0));
		return;
	}

	Cvar_Set(&spectator, "");

	if (Cmd_Argc() == 2) 
	{
		// A server name was given, connect directly or through Qizmo
		Cvar_Set(&spectator, "");
		Cbuf_AddText(va("%s %s\n", proxy ? "say ,connect" : "connect", Cmd_Argv(1)));
		return;
	}

	if (cls.mvdplayback == QTV_PLAYBACK) {
		qtvlist_joinfromqtv_cmd();
		return;
	}

	if (!cls.demoplayback && (cl.z_ext & Z_EXT_JOIN_OBSERVE)) 
	{
		// Server supports the 'join' command, good
		Cmd_ExecuteString("cmd join");
		return;
	}

	Cbuf_AddText(va("%s\n", proxy ? "say ,reconnect" : "reconnect"));
}

void CL_Observe_f (void) 
{
	qbool proxy;

	proxy = cl_useproxy.value && CL_ConnectedToProxy();

	if (Cmd_Argc() > 2) 
	{
		Com_Printf ("Usage: %s [server]\n", Cmd_Argv(0));
		return;
	}

	Cvar_SetValue(&spectator, 1);

	if (Cmd_Argc() == 2) 
	{
		// A server name was given, connect directly or through Qizmo
		Cbuf_AddText(va("%s %s\n", proxy ? "say ,connect" : "connect", Cmd_Argv(1)));
		return;
	}

	if (!cls.demoplayback && (cl.z_ext & Z_EXT_JOIN_OBSERVE))
	{
		// Server supports the 'join' command, good
		Cmd_ExecuteString("cmd observe");
		return;
	}

	Cbuf_AddText(va("%s\n", proxy ? "say ,reconnect" : "reconnect"));
}


void CL_Observe_BestRoute_f(void)
{
	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: %s <address>\nConnects to given server via fastest available path (ping-wise).\n", Cmd_Argv(0));
		Com_Printf("Requires Server Browser refreshed with sb_findroutes 1\n");
		return;
	}
	else {
		netadr_t adr;
		if (!NET_StringToAdr(Cmd_Argv(1), &adr)) {
			Com_Printf("Invalid address\n");
			return;
		}

		if (adr.port == 0)
			adr.port = htons(27500);

		Cvar_SetValue(&spectator, 1);


		SB_PingTree_DumpPath(&adr);
		SB_PingTree_ConnectBestPath(&adr);
	}
}

// Just toggle mode between spec and player.
void Cl_ToggleSpec_f (void)
{
	if (spectator.string[0])
		CL_Join_f();
	else
		CL_Observe_f();
}

void CL_Hash_f(void)
{
	if (Cmd_Argc() != 2)
	{
		Com_Printf("Usage: %s <string to hash>\n", Cmd_Argv(0));
		return;
	}

	Com_Printf("%u\n", Com_HashKey(Cmd_Argv(1)));
}

void CL_DNS_f(void) 
{
	char address[128], *s;
	struct hostent *h;
	struct in_addr addr;

	if (Cmd_Argc() != 2) 
	{
		Com_Printf("Usage: %s <address>\n", Cmd_Argv(0));
		return;
	}
	
	strlcpy(address, Cmd_Argv(1), sizeof(address));
	if ((s = strchr(address, ':')))
		*s = 0;
	addr.s_addr = inet_addr(address);
	
	if (inet_addr(address) == INADDR_NONE) 
	{
		// Forward lookup
		if (!(h = gethostbyname(address))) 
		{
			Com_Printf("Couldn't resolve %s\n", address);
		} 
		else 
		{
			addr.s_addr = *(int *) h->h_addr_list[0];
			Com_Printf("Resolved %s to %s\n", address, inet_ntoa(addr));
		}
		return;
	}

	// Reverse lookup ip address
	if (!(h = gethostbyaddr((char *) &addr, sizeof(addr), AF_INET)))
		Com_Printf("Couldn't resolve %s\n", address);
	else
		Com_Printf("Resolved %s to %s\n", address, h->h_name);
}

void SCR_ClearShownick(void);
void SCR_ClearTeamInfo(void);
void SCR_ClearWeaponStats(void);

void CL_ClearState (void) 
{
	int i;
	extern cshift_t	cshift_empty;
	extern void CL_ProcessServerInfo (void);

	S_StopAllSounds();

	Com_DPrintf ("Clearing memory\n");

	if (!com_serveractive) {
		Host_ClearMemory();
	}

	CL_ClearTEnts ();
	CL_ClearScene ();

	CL_ClearPredict();

	if (cls.state == ca_active) {
		int ideal_track = cl.ideal_track;
		int autocam = cl.autocam;

		// Wipe the entire cl structure.
		memset(&cl, 0, sizeof(cl));

		cl.ideal_track = ideal_track;
		cl.autocam = autocam;
	}
	else {
		// Wipe the entire cl structure.
		memset(&cl, 0, sizeof(cl));
	}

	// default weapon selection if nothing else replaces it
	cl.weapon_order[0] = 2;
	cl.weapon_order[1] = 1;
	cl.weapon_order[2] = 0;

	SZ_Clear (&cls.netchan.message);

	// Clear other arrays.
	memset(cl_dlight_active, 0, sizeof(cl_dlight_active));
	memset(cl_lightstyle, 0, sizeof(cl_lightstyle));
	memset(cl_entities, 0, sizeof(cl_entities));
	memset(cl_static_entities, 0, sizeof(cl_static_entities));
	CL_SpawnWarn_ClearPoints();

	// Set entnum for all entity baselines
	for (i = 0; i < sizeof(cl_entities) / sizeof(cl_entities[0]); ++i) {
		cl_entities[i].baseline.number = i;
	}

	// Set default viewheight for mvd, we copy cl.players[].stats[] to cl_stats[] in Cam_Lock() when pov changes.
	for (i = 0; i < MAX_CLIENTS; i++)
		cl.players[i].stats[STAT_VIEWHEIGHT] = DEFAULT_VIEWHEIGHT;
	// Set default viewheight for normal game/current pov.
	cl.stats[STAT_VIEWHEIGHT] = DEFAULT_VIEWHEIGHT;

	R_Init_EFrags();

	memset(&cshift_empty, 0, sizeof(cshift_empty));

	// Clear shownick structs
	SCR_ClearShownick();

	// Clear teaminfo structs
	SCR_ClearTeamInfo();

	// Clear weapon stats structs
	SCR_ClearWeaponStats();

	SCR_CenterPrint_Clear();

	if (!com_serveractive)
		Cvar_ForceSet (&host_mapname, ""); // Notice mapname not valid yet.

	cl.fakeshaft_policy = 1;

	// Default teamnames for TF
	strlcpy(cl.fixed_team_names[0], "blue", sizeof(cl.fixed_team_names[0]));
	strlcpy(cl.fixed_team_names[1], "red", sizeof(cl.fixed_team_names[1]));
	strlcpy(cl.fixed_team_names[2], "yell", sizeof(cl.fixed_team_names[2]));
	strlcpy(cl.fixed_team_names[3], "gren", sizeof(cl.fixed_team_names[3]));

	CL_ProcessServerInfo(); // Force set some default variables, because server may not sent fullserverinfo.
}

// Sends a disconnect message to the server
// This is also called on Host_Error, so it shouldn't cause any errors
void CL_Disconnect (void) 
{
	byte final[10];

	connect_time = 0;
	con_addtimestamp = true;

	if (cl.teamfortress)
		V_TF_ClearGrenadeEffects();
	cl.teamfortress = false;

	// Reset values changed by Multiview.
	CL_MultiviewResetCvars ();

	// Stop sounds (especially looping!)
	S_StopAllSounds();

	MT_Disconnect();

	//
	R_OnDisconnect();

	if (cls.demorecording && cls.state != ca_disconnected) {
		CL_Stop_f();
	}

	if (cls.mvdrecording && cls.state != ca_disconnected) {
		extern void CL_StopMvd_f(void);

		CL_StopMvd_f();
	}

	if (cls.demoplayback) {
		CL_StopPlayback();
	} 
	else if (cls.state != ca_disconnected) {
		final[0] = clc_stringcmd;
		strlcpy ((char *)(final + 1), "drop", sizeof (final) - 1);
		Netchan_Transmit (&cls.netchan, 6, final);
		Netchan_Transmit (&cls.netchan, 6, final);
		Netchan_Transmit (&cls.netchan, 6, final);

		CL_UnqueOutputPacket(true);

		// TCP connect, that gives TCP a chance to transfer data to the server...
		if (cls.sockettcp != INVALID_SOCKET) {
			Sys_MSleep(1000);
		}
	}

	memset(&cls.netchan, 0, sizeof(cls.netchan));
	memset(&cls.server_adr, 0, sizeof(cls.server_adr));
	cls.state = ca_disconnected;
	cls.fteprotocolextensions = cls.fteprotocolextensions2 = cls.mvdprotocolextensions1 = 0;
	connect_time = 0;

	Cam_Reset();

	if (cls.download) {
		CL_FinishDownload();
	}
	else {
		/* Just to make sure it's not in an ambigious state */
		cls.downloadmethod = DL_NONE;
		cls.downloadnumber = 0;
		cls.downloadpercent = 0;
		cls.downloadtype = dl_none;
	}

	CL_StopUpload();
	DeleteServerAliases();
	CL_RE_Trigger_ResetLasttime();

	// TCP connect.
	if (cls.sockettcp != INVALID_SOCKET) {
		closesocket(cls.sockettcp);
		cls.sockettcp = INVALID_SOCKET;
	}

	cls.qport++; // A hack I picked up from qizmo.

	SZ_Clear(&cls.cmdmsg);

	// So join/observe not confused
	Info_SetValueForStarKey(cl.serverinfo, "*z_ext", "", sizeof(cl.serverinfo));
	cl.z_ext = 0;

	// well, we need free qtv users before new connection
	QTV_FreeUserList();

	Cvar_ForceSet(&host_mapname, ""); // Notice mapname not valid yet
}

void CL_Disconnect_f (void) 
{
	portpingprobe_status_t status;

	cl.intermission = 0;
	CL_Demo_Disconnected();

	if (IsPortPingProbeEnabled() && (status = NET_GetPortPingProbeStatus()) == PORTPINGPROBE_PROBING)
	{
		NET_SetPortPingProbeStatus(PORTPINGPROBE_ABORT);
		while ((status = NET_GetPortPingProbeStatus()) != PORTPINGPROBE_READY)
		{
			Sys_MSleep(10);
		}
	}

	Host_EndGame();
}

// The server is changing levels.
void CL_Reconnect_f (void) 
{
	if (cls.download)
		return; // Don't change when downloading.

	S_StopAllSounds();

	if (cls.mvdplayback) {
		return; // Change map during qtv playback.
	}

	if (cls.state == ca_connected) 
	{
		Com_Printf ("reconnecting...\n");
		MSG_WriteChar (&cls.netchan.message, clc_stringcmd);
		MSG_WriteString (&cls.netchan.message, "new");
		return;
	}

	if (!*cls.servername) 
	{
		Com_Printf ("No server to reconnect to.\n");
		return;
	}

	if (connected_via_proxy) {
		// we were connected via a proxy
		// the target server is (hopefully still) in userinfo/prx
		char *prx = Info_ValueForKey(cls.userinfo, "prx");
		char *lastnode = strrchr(prx, '@');
		if (lastnode) {
			lastnode++;
		}
		else {
			lastnode = prx;
		}
		
		Cbuf_AddText(va("connect %s\n", lastnode));
	}
	else if (!connected_via_proxy && cl_proxyaddr.string[0]) {
		// switch the stuff
		Cbuf_AddText(va("connect %s\n", cls.servername));
	}
	else if (IsPortPingProbeEnabled()) {
		Cbuf_AddText(va("connect %s\n", cls.servername));
	}
	else {
		// good old reconnect, no need to do anything special
		Host_EndGame();
		CL_BeginServerConnect();
	}

	// remember what's the type of this new connection
	connected_via_proxy = cl_proxyaddr.string[0] ? true : false;
}

extern double qstat_senttime;
extern void CL_PrintQStatReply (char *s);

// Responses to broadcasts, etc
void CL_ConnectionlessPacket (void) 
{
	int c;
	char *s, cmdtext[2048];
	
	#ifdef PROTOCOL_VERSION_FTE
	unsigned int pext = 0;
	#endif // PROTOCOL_VERSION_FTE
	#ifdef PROTOCOL_VERSION_FTE2
	unsigned int pext2 = 0;
	#endif // PROTOCOL_VERSION_FTE2
	#ifdef PROTOCOL_VERSION_MVD1
	unsigned int pext_mvd1 = 0;
	#endif

    MSG_BeginReading();
    MSG_ReadLong();	// Skip the -1

	c = MSG_ReadByte();

	if (msg_badread)
		return;	// Runt packet

	switch(c) 
	{
		case S2C_CHALLENGE :
		{
			if (!NET_CompareAdr(net_from, cls.server_adr))
			{
				Com_DPrintf("S2C_CHALLENGE rejected\n");
				Com_DPrintf("net_from       %s\n", NET_AdrToString(net_from));
				Com_DPrintf("cls.server_adr %s\n", NET_AdrToString(cls.server_adr));
				return;
			}
			Com_Printf("&cf55challenge:&r %s\n", NET_AdrToString(net_from));
			cls.challenge = atoi(MSG_ReadString());

			for(;;)
			{
				c = MSG_ReadLong();
				if (msg_badread)
					break;

#ifdef PROTOCOL_VERSION_FTE
				if (c == PROTOCOL_VERSION_FTE)
					pext = MSG_ReadLong();
				else
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_FTE2
				if (c == PROTOCOL_VERSION_FTE2)
					pext2 = MSG_ReadLong();
				else
#endif // PROTOCOL_VERSION_FTE2
#ifdef PROTOCOL_VERSION_MVD1
				if (c == PROTOCOL_VERSION_MVD1)
					pext_mvd1 = MSG_ReadLong();
				else
#endif
					MSG_ReadLong();
			}

			CL_SendConnectPacket(
#ifdef PROTOCOL_VERSION_FTE
				pext
	#ifdef PROTOCOL_VERSION_FTE2
				,
	#endif // PROTOCOL_VERSION_FTE2
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_FTE2
				pext2
#ifdef PROTOCOL_VERSION_MVD1
				,
#endif
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_MVD1
				pext_mvd1
#endif
				);

			break;
		}
		case S2C_CONNECTION :
		{
			if (!NET_CompareAdr(net_from, cls.server_adr))
				return;
			if ((!com_serveractive || developer.value) && !cls.demoplayback)
				Com_Printf("&cff5connection:&r %s\n", NET_AdrToString(net_from));

			if (cls.state >= ca_connected) 
			{
				if (!cls.demoplayback)
					Com_Printf("Dup connect received.  Ignored.\n");
				break;
			}
			Netchan_Setup(NS_CLIENT, &cls.netchan, net_from, cls.qport, 0);
			MSG_WriteChar (&cls.netchan.message, clc_stringcmd);
			MSG_WriteString (&cls.netchan.message, "new");
			cls.state = ca_connected;
#ifdef DEBUG_MEMORY_ALLOCATIONS
			Sys_Printf("\nevent,connected...\n");
#endif
			if ((!com_serveractive || developer.value) && !cls.demoplayback)
				Com_Printf("&c1f1connected!&r\n");
			allowremotecmd = false; // localid required now for remote cmds
			break;
		}
		case A2C_CLIENT_COMMAND : 
		{
			// Remote command from gui front end
			Com_Printf ("%s: client command\n", NET_AdrToString (net_from));

			if (net_from.type != net_local_cl_ipadr.type
				|| ((*(unsigned *)net_from.ip != *(unsigned *)net_local_cl_ipadr.ip)
				&& (*(unsigned *)net_from.ip != htonl(INADDR_LOOPBACK))))
			{
				Com_Printf ("Command packet from remote host.  Ignored.\n");
				return;
			}

                        VID_Restore();
			
			s = MSG_ReadString ();
			strlcpy (cmdtext, s, sizeof(cmdtext));
			s = MSG_ReadString ();

			while (*s && isspace(*s))
				s++;
			while (*s && isspace(s[strlen(s) - 1]))
				s[strlen(s) - 1] = 0;

			if (!allowremotecmd && (!*localid.string || strcmp(localid.string, s))) 
			{
				if (!*localid.string) 
				{
					Com_Printf ("===========================\n");
					Com_Printf ("Command packet received from local host, but no "
						"localid has been set.  You may need to upgrade your server "
						"browser.\n");
					Com_Printf ("===========================\n");
				}
				else 
				{
					Com_Printf ("===========================\n");
					Com_Printf ("Invalid localid on command packet received from local host. "
						"\n|%s| != |%s|\n"
						"You may need to reload your server browser and ezQuake.\n",
						s, localid.string);
					Com_Printf ("===========================\n");
					Cvar_Set(&localid, "");
				}
			} 
			else 
			{
				if (KeyDestStartupDemo(key_dest)) {
					key_dest = key_console;
				}

				Cbuf_AddText (cmdtext);
				Cbuf_AddText ("\n");
				allowremotecmd = false;
			}
			break;
		}
		case A2C_PRINT:		
		{
			// Print command from somewhere.
			
			#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
			if (net_message.cursize > 100 && !strncmp((char *)net_message.data + 5, "\\chunk", sizeof("\\chunk")-1)) 
			{
				CL_Parse_OOB_ChunkedDownload();
				return;
			}
			#endif // FTE_PEXT_CHUNKEDDOWNLOADS

			if (net_message.data[msg_readcount] == '\\') 
			{
				if (qstat_senttime && curtime - qstat_senttime < 10)
				{
					CL_PrintQStatReply (MSG_ReadString());
					return;
				}
			}

			Com_Printf("%s: print\n", NET_AdrToString(net_from));
			Com_Printf("%s", MSG_ReadString());
			break;
		}
		case svc_disconnect :
		{
			if (cls.demoplayback)
			{
				Com_Printf("\n======== End of demo ========\n\n");
				Host_EndGame();
				Host_Abort();
			}
			break;
		}
	}
}

// Handles playback of demos, on top of NET_ code
qbool CL_GetMessage (void) 
{
	CL_CheckQizmoCompletion ();

	if (cls.demoplayback)
		return CL_GetDemoMessage();

	if (!NET_GetPacket(NS_CLIENT))
		return false;

	return true;
}

static void CL_ReadPackets(void)
{
	if (cls.nqdemoplayback) 
	{
		NQD_ReadPackets();
		return;
	}

	while (CL_GetMessage()) 
	{
		// Remote command packet.
		if (*(int *)net_message.data == -1)	
		{
			CL_ConnectionlessPacket();
			Com_DPrintf("Connectionless packet\n");
			continue;
		}

		if (!cls.mvdplayback && (net_message.cursize < 8)) 
		{
			Com_DPrintf("%s: Runt packet\n", NET_AdrToString(net_from));
			continue;
		}

		// Packet from server.
		if (!cls.demoplayback && !NET_CompareAdr(net_from, cls.netchan.remote_address)) 
		{
			Com_DPrintf("%s: sequenced packet without connection\n", NET_AdrToString(net_from));
			continue;
		}

		if (cls.mvdplayback) 
		{
			MSG_BeginReading();
		}
		else 
		{
			if (!Netchan_Process(&cls.netchan))
				continue; // Wasn't accepted for some reason.
		}

		if (cls.lastto == 0 && cls.lasttype == dem_multiple) {
#ifdef MVD_PEXT1_HIDDEN_MESSAGES
			if (cls.mvdprotocolextensions1 & MVD_PEXT1_HIDDEN_MESSAGES) {
				CL_ParseHiddenDataMessage();
			}
#endif
			continue;
		}

		CL_ParseServerMessage();
	}

	// Check timeout.
	if (!cls.demoplayback && cls.state >= ca_connected ) 
	{
		if (curtime - cls.netchan.last_received > (cl_timeout.value > 0 ? cl_timeout.value : 60)) 
		{
			Com_Printf("\nServer connection timed out.\n");
			Host_EndGame();
			return;
		}
	}
}

void CL_SendToServer (void) 
{
	// When recording demos, request new ping times every cl_demoPingInterval.value seconds.
	if (cls.demorecording && !cls.demoplayback && cls.state == ca_active && cl_demoPingInterval.value > 0) 
	{
		if (cls.realtime - cl.last_ping_request > cl_demoPingInterval.value) 
		{
			cl.last_ping_request = cls.realtime;
			MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
			SZ_Print (&cls.netchan.message, "pings");
		}
	}

	// Send intentions now. Resend a connection request if necessary.
	if (cls.state == ca_disconnected)
		CL_CheckForResend ();
	else
		CL_SendCmd ();
}

void CL_OnChange_name_validate(cvar_t *var, char *val, qbool *cancel)
{
	char *clrpart;

	// check for &r
	if (strstr(val, "&r")) {
		*cancel = true;
		Com_Printf("Using color codes in your name is not allowed\n");
		return;
	}
	
	// check for &cRGB
	// RGB has to be a valid hexadecimal number, otherwise it's ok
	clrpart = val;
	do {
		clrpart = strstr(clrpart, "&c");
		if (clrpart) {
			clrpart += 2;
			if (clrpart[0] && clrpart[1] && clrpart[2]) {
				if (HexToInt(clrpart[0]) >= 0 && HexToInt(clrpart[1]) >= 0 && HexToInt(clrpart[2]) >= 0) {
					*cancel = true;
					Com_Printf("Using color codes in your name is not allowed\n");
				}
			}
		}
	} while (clrpart);
}
//=============================================================================

void CL_InitCommands (void);

static void CL_InitLocal(void)
{
	char st[256];

	extern void Cl_Messages_Init(void);

	Cl_Messages_Init();

	Cvar_SetCurrentGroup(CVAR_GROUP_CHAT);
	Cvar_Register(&cl_parseWhiteText);
	Cvar_Register(&cl_chatsound);
	Cvar_Register(&cl_fakename);
	Cvar_Register(&cl_fakename_suffix);

	Cvar_Register(&cl_restrictions);

	Cvar_Register(&cl_floodprot);
	Cvar_Register(&cl_fp_messages);
	Cvar_Register(&cl_fp_persecond);

	Cvar_Register(&msg_filter);

	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register(&cl_shownet);
	Cvar_Register(&cl_confirmquit);
	Cvar_Register(&cl_window_caption);
	Cvar_Register(&cl_window_caption_delimiter);
	Cvar_Register(&cl_onload);

#ifdef WIN32
	Cvar_Register(&cl_verify_qwprotocol);
#endif // WIN32

	Cvar_SetCurrentGroup(CVAR_GROUP_SBAR);
	Cvar_Register(&cl_sbar);
	Cvar_Register(&cl_hudswap);

	Cvar_SetCurrentGroup(CVAR_GROUP_VIEWMODEL);
	Cvar_Register(&cl_filterdrawviewmodel);

	Cvar_SetCurrentGroup(CVAR_GROUP_EYECANDY);
	Cvar_Register(&cl_model_bobbing);
	Cvar_Register(&cl_nolerp);
	Cvar_Register(&cl_nolerp_on_entity);
	Cvar_Register(&cl_newlerp);
	Cvar_Register(&cl_lerp_monsters);
	Cvar_Register(&demo_spawnwarn);
	Cvar_Register(&demo_spawnwarn_text);
	Cvar_Register(&cl_maxfps);
	Cvar_Register(&cl_maxfps_menu);
	Cvar_Register(&cl_physfps);
	Cvar_Register(&hud_fps_min_reset_interval);
	Cvar_Register(&hud_frametime_max_reset_interval);
	Cvar_Register(&hud_performance_average);
	Cvar_Register(&cl_physfps_spectator);
	Cvar_Register(&cl_independentPhysics);
	Cvar_Register(&cl_deadbodyfilter);
	Cvar_Register(&cl_gibfilter);
	Cvar_Register(&cl_backpackfilter);
	Cvar_Register(&cl_muzzleflash);
	Cvar_Register(&cl_rocket2grenade);
	Cvar_Register(&r_explosiontype);
	Cvar_Register(&r_lightflicker);
	Cvar_Register(&r_lightmap_lateupload);
	Cvar_Register(&r_lightmap_packbytexture);
	Cvar_Register(&r_rockettrail);
	Cvar_Register(&r_grenadetrail);
	Cvar_Register(&r_railtrail);
	Cvar_Register(&r_instagibtrail);
	Cvar_Register(&r_powerupglow);
	Cvar_Register(&cl_novweps);
	Cvar_Register(&r_drawvweps);
	Cvar_Register(&r_rocketlight);
	Cvar_Register(&r_explosionlight);
	Cvar_Register(&r_rocketlightcolor);
	Cvar_Register(&r_explosionlightcolor);
	Cvar_Register(&r_flagcolor);
	Cvar_Register(&cl_fakeshaft);
	Cvar_Register(&cl_fakeshaft_extra_updates);
	Cvar_Register(&r_telesplash);
	Cvar_Register(&r_shaftalpha);
	Cvar_Register(&r_lightdecayrate);

	Skin_RegisterCvars();

	Cvar_SetCurrentGroup(CVAR_GROUP_DEMO);
	Cvar_Register(&cl_demospeed);
	Cvar_Register(&cl_demoPingInterval);
	Cvar_Register(&qizmo_dir);
	Cvar_Register(&qwdtools_dir);
	Cvar_Register(&demo_getpings);
	Cvar_Register(&demo_autotrack);
	Cvar_Register(&cl_demoteamplay);

	Cvar_SetCurrentGroup(CVAR_GROUP_SOUND);
	Cvar_Register(&cl_staticsounds);

	Cvar_SetCurrentGroup(CVAR_GROUP_USERINFO);
	Cvar_Register(&team);
	Cvar_Register(&spectator);
	Cvar_Register(&skin);
	Cvar_Register(&rate);
	Cvar_Register(&mtu);
	Cvar_Register(&name);
	Cvar_Register(&msg);
	Cvar_Register(&noaim);
	Cvar_Register(&topcolor);
	Cvar_Register(&bottomcolor);
	Cvar_Register(&w_switch);
	Cvar_Register(&b_switch);
	Cvar_Register(&railcolor);
	Cvar_Register(&gender);

	Cvar_SetCurrentGroup(CVAR_GROUP_NETWORK);
	Cvar_Register(&cl_predict_players);
	Cvar_Register(&cl_solid_players);
	Cvar_Register(&cl_predict_half);
	Cvar_Register(&cl_timeout);
	Cvar_Register(&cl_useproxy);
	Cvar_Register(&cl_proxyaddr);
	Cvar_Register(&cl_crypt_rcon);
	Cvar_Register(&cl_fix_mvd);

	Cvar_Register(&cl_delay_packet);
	Cvar_Register(&cl_delay_packet_target);
	Cvar_Register(&cl_delay_packet_dev);
	Cvar_Register(&cl_earlypackets);

#if defined(PROTOCOL_VERSION_FTE) || defined(PROTOCOL_VERSION_FTE2) || defined(PROTOCOL_VERSION_MVD1)
	Cvar_Register(&cl_pext);
	Cvar_Register(&cl_pext_limits);
	Cvar_Register(&cl_pext_other);
	Cvar_Register(&cl_pext_warndemos);
#ifdef MVD_PEXT1_HIGHLAGTELEPORT
	Cvar_Register(&cl_pext_lagteleport);
#endif
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	Cvar_Register(&cl_pext_serversideweapon);
#endif
#endif // PROTOCOL_VERSION_FTE
#ifdef FTE_PEXT_256PACKETENTITIES
	Cvar_Register(&cl_pext_256packetentities);
#endif
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	Cvar_Register(&cl_pext_chunkeddownloads);
	Cvar_Register(&cl_chunksperframe);
#endif

#ifdef FTE_PEXT_FLOATCOORDS
	Cvar_Register(&cl_pext_floatcoords);
#endif

#ifdef FTE_PEXT_TRANS
	Cvar_Register(&cl_pext_alpha);
#endif
#ifdef FTE_PEXT_COLOURMOD
	Cvar_Register(&cl_pext_colourmod);
#endif

	Cvar_SetCurrentGroup(CVAR_GROUP_INPUT_KEYBOARD);
	Cvar_Register(&allow_scripts);

	Cvar_SetCurrentGroup(CVAR_GROUP_SYSTEM_SETTINGS);
	Cvar_Register(&cl_mediaroot);

#ifndef CLIENTONLY
	Cvar_SetCurrentGroup(CVAR_GROUP_COMMUNICATION);
	Cvar_Register(&cl_sv_packetsync);
#endif

	Cvar_SetCurrentGroup(CVAR_GROUP_NO_GROUP);
	Cvar_Register (&password);
	Cvar_Register (&rcon_password);
	Cvar_Register (&rcon_address);
	Cvar_Register (&localid);
	Cvar_Register (&cl_warncmd);
	Cvar_Register (&cl_cmdline);
	Cvar_ForceSet (&cl_cmdline, com_args_original);
	Cvar_ResetCurrentGroup();

	Cvar_Register (&cl_username);
	Cmd_AddCommand("authenticate", CL_Authenticate_f);

	// debugging antilag
	Cvar_Register(&cl_debug_antilag_view);
	Cvar_Register(&cl_debug_antilag_ghost);
	Cvar_Register(&cl_debug_antilag_self);
	Cvar_Register(&cl_debug_antilag_lines);
	Cvar_Register(&cl_debug_antilag_send);

	// debugging weapons
	Cvar_Register(&cl_debug_weapon_view);

	snprintf(st, sizeof(st), "ezQuake %i", REVISION);

	if (COM_CheckParm (cmdline_param_client_norjscripts) || COM_CheckParm (cmdline_param_client_noscripts))
		Cvar_SetValue (&allow_scripts, 0);

 	Info_SetValueForStarKey (cls.userinfo, "*client", st, MAX_INFO_STRING);

	snprintf(st, sizeof(st), "ezQuake v%s %s", VERSION_NUMBER, VERSION);
	Info_SetValueForStarKey(cls.userinfo, "*ver", st, MAX_INFO_STRING);

	if (COM_CheckParm(cmdline_param_client_noindphys))
	{
		Cvar_SetValue(&cl_independentPhysics, 0);
		Cvar_SetValue(&cl_nolerp, 1);
	}

	CL_InitCommands ();

	Cmd_AddCommand ("disconnect", CL_Disconnect_f);
	Cmd_AddCommand ("connect", CL_Connect_f);
	Cmd_AddCommand ("connectbr", CL_Connect_BestRoute_f);

	Cmd_AddCommand ("qwurl", CL_QWURL_f);

	Cmd_AddCommand ("tcpconnect", CL_TCPConnect_f);

	Cmd_AddCommand ("join", CL_Join_f);
	Cmd_AddCommand ("observe", CL_Observe_f);
	Cmd_AddCommand ("observebr", CL_Observe_BestRoute_f);
	Cmd_AddCommand ("togglespec", Cl_ToggleSpec_f);

	Cmd_AddCommand ("hud_fps_min_reset", Cl_Reset_Min_fps_f);

	#if defined WIN32 || defined __linux__
	Cmd_AddCommand ("register_qwurl_protocol", Sys_RegisterQWURLProtocol_f);
	#endif // WIN32 or linux

	Cmd_AddCommand ("dns", CL_DNS_f);
	Cmd_AddCommand ("hash", CL_Hash_f);
	Cmd_AddCommand ("reconnect", CL_Reconnect_f);

	Cmd_AddMacro(macro_connectiontype, CL_Macro_ConnectionType);
	Cmd_AddMacro(macro_demoplayback, CL_Macro_Demoplayback);
	Cmd_AddMacro(macro_demotime, CL_Macro_Demotime);
	Cmd_AddMacro(macro_rand, CL_Macro_Rand);
	Cmd_AddMacro(macro_matchstatus, CL_Macro_Serverstatus);
	Cmd_AddMacro(macro_serverip, CL_Macro_ServerIp);
	Cmd_AddMacro(macro_conwidth, CL_Macro_Conwidth);
	Cmd_AddMacro(macro_conheight, CL_Macro_Conheight);

#ifdef WITH_RENDERING_TRACE
	if (R_DebugProfileContext()) {
		Cmd_AddCommand("dev_gfxtrace", Dev_VidFrameTrace);
		Cmd_AddCommand("dev_gfxtexturedump", Dev_VidTextureDump);
		Cmd_AddCommand("dev_gfxtexturelist", Dev_TextureList);
	}
#endif

#ifndef CLIENTONLY
	if (IsDeveloperMode()) {
		Cmd_AddCommand("dev_physicsnormalset", Dev_PhysicsNormalSet);
		Cmd_AddCommand("dev_physicsnormalshow", Dev_PhysicsNormalShow);
		Cmd_AddCommand("dev_physicsnormalsave", Dev_PhysicsNormalSave);
	}
#endif

	{
		extern void GL_BenchmarkLightmapFormats(void);

		Cmd_AddCommand("dev_gfxbenchmarklightmaps", GL_BenchmarkLightmapFormats);
	}
}

void GFX_Init (void) 
{
	Draw_Init();
	SCR_Init();
	R_Init();
	Sbar_Init();
	HUD_Editor_Init();	// Need to reload some textures.
	VX_TrackerInit();

	CachePics_CreateAtlas();
}

void ReloadPaletteAndColormap(void)
{
	int filesize;

	// free

	Q_free(host_basepal);
	Q_free(host_colormap);

	// load

	host_basepal = (byte *) FS_LoadHeapFile ("gfx/palette.lmp", &filesize);
	if (!host_basepal)
		Sys_Error("Couldn't load gfx/palette.lmp\n\nThis is typically caused by being unable to locate pak0.pak.\nCopy pak0.pak into 'id1' folder, in same directory as executable.");
	FMod_CheckModel("gfx/palette.lmp", host_basepal, filesize);

	host_colormap = (byte *) FS_LoadHeapFile ("gfx/colormap.lmp", &filesize);
	if (!host_colormap)
		Sys_Error ("Couldn't load gfx/colormap.lmp");
	FMod_CheckModel("gfx/colormap.lmp", host_colormap, filesize);
}

void EX_FileList_Init(void);

void CL_Init (void) 
{
	// When ezquake was launched via a webpage (qtv) the working directory wasn't properly
	// set. Changing the directory makes sure it starts out in the directory where ezquake 
	// is located.
	Sys_chdir(com_basedir);

	cls.state = ca_disconnected;
	cls.min_fps = 999999;
	cls.max_frametime = 1;

	SZ_Init(&cls.cmdmsg, cls.cmdmsg_data, sizeof(cls.cmdmsg_data));
	cls.cmdmsg.allowoverflow = true;

	strlcpy (cls.gamedirfile, com_gamedirfile, sizeof (cls.gamedirfile));
	strlcpy (cls.gamedir, com_gamedir, sizeof (cls.gamedir));

	FChecks_Init();

	ReloadPaletteAndColormap();

	Sys_mkdir(va("%s/qw", com_basedir));
	Sys_mkdir(va("%s/ezquake", com_basedir));

	SDL_SetHint(SDL_HINT_APP_NAME, "ezQuake");

	History_Init();
	V_Init ();
	MVD_Utils_Init ();

	VID_Init(host_basepal);
	IN_Init();

	Image_Init();

	GFX_Init ();

	S_Init ();

	CDAudio_Init ();

	CL_InitLocal ();
	CL_FixupModelNames ();
	CL_InitInput ();
	CL_InitEnts ();
	CL_InitTEnts ();
	CL_InitTEntsCvar();
	CL_InitPrediction ();
	CL_InitCam ();
	TP_Init ();
	Hud_262Init();
	HUD_Init();
	Help_Init();
	M_Init ();
	EX_FileList_Init();

	SList_Init ();
	SList_Load ();

	MT_Init();
	CL_Demo_Init();
	Ignore_Init();
	Log_Init();
	Movie_Init();

#ifdef _DEBUG
	if (Expr_Run_Unit_Tests() != 0) {
		Sys_Error("One of the expression parser unit tests failed");
	}
#endif

	// moved to host.c:Host_Init()
	//ConfigManager_Init();
	Stats_Init();
	SB_RootInit();
#ifdef WITH_IRC	
	IRC_Init();
#endif

	QTV_Init();

	Sys_InitIPC();

	Rulesets_Init();
}

//============================================================================

void CL_BeginLocalConnection (void) 
{
	S_StopAllSounds();

	// make sure we're not connected to an external server,
	// and demo playback is stopped
	if (!com_serveractive)
		CL_Disconnect ();

	cl.worldmodel = NULL;

	if (cls.state == ca_active)
		cls.state = ca_connected;
}

// automatically pause the game when going into the menus in single player
static void CL_CheckAutoPause (void) 
{
	#ifndef CLIENTONLY

	extern cvar_t maxclients;

	if (com_serveractive && cls.state == ca_active && !cl.deathmatch && maxclients.value == 1
		&& (key_dest == key_menu /*|| key_dest == key_console*/))
	{
		if (!(sv.paused & 2))
			SV_TogglePause (NULL, 2);
	}
	else 
	{
		if (sv.paused & 2)
			SV_TogglePause (NULL, 2);
	}
	#endif // CLIENTONLY
}


static double CL_MinFrameTime (void) 
{
	double fps, fpscap;

	if (cls.timedemo || Movie_IsCapturing())
		return 0;

	if ((cls.state == ca_disconnected) || (Minimized && !cls.download))
		if (cl_maxfps_menu.value >= 30)
			return 1 / cl_maxfps_menu.value;
		else
			return 1 / (r_displayRefresh.autoString ? atoi(r_displayRefresh.autoString) : 30.0);

	if (cls.demoplayback)
	{
		if (!cl_maxfps.value)
			return 0;

		// Multiview.
		fps = max(30.0, cl_maxfps.value);
	}
	else
	{
		if (cl_independentPhysics.value == 0)
		{
			fpscap = cl.maxfps ? max (30.0, cl.maxfps) : Rulesets_MaxFPS();
			fps = cl_maxfps.value ? bound (30.0, cl_maxfps.value, fpscap) : com_serveractive ? fpscap : bound (30.0, rate.value / 80.0, fpscap);
		}
		else
			fps = cl_maxfps.value ? max(cl_maxfps.value, 30) : 99999; //#fps:
	}

	return 1 / fps;
}

static double MinPhysFrameTime (void)
{
	// Server policy
	float fpscap = (cl.maxfps ? cl.maxfps : 72.0);
	// Use either cl_physfps_spectator or cl_physfps
	float physfps = ((cl.spectator && !cls.demoplayback) ? cl_physfps_spectator.value : cl_physfps.value);

	// this makes things smooth in mvd demo play back, since mvd interpolation applied each frame
	if (cls.demoplayback)
		return 0;

	// the user can lower it for testing (or really shit connection)
	if (physfps)
		fpscap = min(fpscap, physfps);

	// not less than this no matter what
	fpscap = max(fpscap, 10);

	return 1 / fpscap;
}

void onchange_hud_performance_average(cvar_t* var, char* value, qbool* cancel)
{
	// Reset on change
	if (strcmp(var->string, value)) {
		Cl_Reset_Min_fps_f();
	}
}

void CL_CalcFPS(void)
{
	double t = Sys_DoubleTime();
	perfinfo_t* stats = &cls.fps_stats;
	double frametime = stats->last_run_time == 0 ? 0 : t - stats->last_run_time;
	double time_since_snapshot = (t - stats->last_snapshot_time);
	stats->last_run_time = t;

	// Average over previous second
	if (time_since_snapshot >= 1.0)
	{
		stats->lastfps_value = (double)stats->fps_count / time_since_snapshot;
		stats->lastframetime_value = time_since_snapshot / max(stats->fps_count, 1);
		stats->fps_count = 0;
		stats->last_snapshot_time = t;
	}

	cls.fps = stats->lastfps_value;
	cls.avg_frametime = stats->lastframetime_value;

	if (hud_performance_average.integer) {
		// update min_fps if last fps is less than our lowest accepted minfps (10.0) or greater than min_reset_interval
		if ((stats->lastfps_value > 10.0 && stats->lastfps_value < cls.min_fps) || ((t - stats->time_of_last_minfps_update) > hud_fps_min_reset_interval.value)) {
			cls.min_fps = stats->lastfps_value;
			stats->time_of_last_minfps_update = t;
		}
		if ((stats->lastframetime_value < 2.0f && stats->lastframetime_value > cls.max_frametime) || ((t - stats->time_of_last_maxframetime_update) > hud_frametime_max_reset_interval.value)) {
			cls.max_frametime = stats->lastframetime_value;
			stats->time_of_last_maxframetime_update = t;
		}
	}
	else if (frametime > 0) {
		// update min_fps if last fps is less than our lowest accepted minfps (10.0) or greater than min_reset_interval
		if (stats->lastfps_value < cls.min_fps || ((t - stats->time_of_last_minfps_update) > hud_fps_min_reset_interval.value)) {
			cls.min_fps = stats->lastfps_value;
			stats->time_of_last_minfps_update = t;
		}
		if (frametime > cls.max_frametime || ((t - stats->time_of_last_maxframetime_update) > hud_frametime_max_reset_interval.value)) {
			cls.max_frametime = frametime;
			stats->time_of_last_maxframetime_update = t;
		}
	}
}

void Cl_Reset_Min_fps_f(void)
{
	cls.min_fps = 9999.0f;
	cls.max_frametime = 0.0f;

	CL_CalcFPS();
}

void CL_QTVPoll (void);
void SB_ExecuteQueuedTriggers (void);

void CL_LinkEntities (void)
{
	if (cls.state >= ca_onserver)
	{
		// actually it should be curtime == cls.netchan.last_received but that did not work on float values...
		qbool recent_packet = (curtime - cls.netchan.last_received < 0.00001);
		qbool setup_player_prediction = ((physframe && cl_independentPhysics.value != 0) || cl_independentPhysics.value == 0);
		setup_player_prediction |= recent_packet && !cls.demoplayback && cl_earlypackets.integer;

		Cam_SetViewPlayer();

		if (setup_player_prediction) {
			// Set up prediction for other players
			CL_SetUpPlayerPrediction(false);
			CL_PredictMove(true);
			CL_SetUpPlayerPrediction(true);
		}
		else {
			// Do client side motion prediction
			CL_PredictMove(false);
		}

		// build a refresh entity list
		CL_EmitEntities();
	}
}

void CL_SoundFrame (void)
{
	if (cls.state == ca_active)
	{
		if (!ISPAUSED) {
			S_Update (r_origin, vpn, vright, vup);
		}
		else {
			// do not play loop sounds (lifts etc.) when paused
#ifndef INFINITY
			float temp = 1.0;
			float infinity = temp / (temp - 1.0);
			vec3_t hax = { infinity, infinity, infinity };
#else
			vec3_t hax = { INFINITY, INFINITY, INFINITY };
#endif
			S_Update(hax, vec3_origin, vec3_origin, vec3_origin);
		}
	}
	else
	{
		S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin);
	}
}

static void CL_ServerFrame(double frametime)
{
#ifndef CLIENTONLY
	if (com_serveractive) {
		playermove_t oldmove;

		memcpy(&oldmove, &pmove, sizeof(playermove_t));

		SV_Frame(frametime);

		memcpy(&pmove, &oldmove, sizeof(playermove_t));
	}
#endif
}

void CL_Frame(double time)
{
	static double extratime = 0.001;
	double minframetime;
	static double	extraphysframetime;	//#fps
	qbool need_server_frame = false;

	extratime += time;
	minframetime = CL_MinFrameTime();
	CL_MultiviewFrameStart ();

	if (extratime < minframetime) {
		extern cvar_t sys_yieldcpu;
		if (sys_yieldcpu.integer || Minimized) {
			#ifdef _WIN32
			Sys_MSleep(0);
			#else
			usleep( (minframetime - extratime) * 1000 * 1000 );
			#endif
		}

		if (cl_delay_packet.integer || cl_delay_packet_target.integer) {
			CL_QueInputPacket();
			need_server_frame = CL_UnqueOutputPacket(false);
		}

		if (need_server_frame && PROCESS_SERVERPACKETS_IMMEDIATELY) {
			CL_ServerFrame(0);
		}

		return;
	}

	if (cl_delay_packet.integer || cl_delay_packet_target.integer) {
		CL_QueInputPacket();
		need_server_frame = CL_UnqueOutputPacket(false);
	}

	if (VID_VSyncLagFix()) {
		if (need_server_frame && PROCESS_SERVERPACKETS_IMMEDIATELY) {
			CL_ServerFrame(0);
		}
		return;
	}

	cls.trueframetime = extratime - 0.001;
	cls.trueframetime = max(cls.trueframetime, minframetime);
	extratime -= cls.trueframetime;

	if (Movie_IsCapturing()) {
		Movie_StartFrame();
		cls.frametime = Movie_Frametime();
	}
	else {
		cls.frametime = min(0.2, cls.trueframetime);
	}
	
	if (cl_independentPhysics.value != 0)
	{
		double minphysframetime = MinPhysFrameTime();

		extraphysframetime += cls.frametime;
		if (extraphysframetime < minphysframetime) {
			physframe = false;
		}
		else {
			physframe = true;

			// FIXME: this is for the case when actual fps is too low.  Dunno how to do it right
			if (extraphysframetime > minphysframetime * 2) {
				physframetime = extraphysframetime;
			}
			else {
				physframetime = minphysframetime;
			}
			extraphysframetime -= physframetime;
		}
	} 
	else {
		// this vars SHOULD NOT be used in case of cl_independentPhysics == 0, so we just reset it for sanity
		physframetime = extraphysframetime = 0;
		// this var actually used
		physframe = true;
	}

	if (cls.demoplayback) {
		Demo_AdjustSpeed();

		if (cl.paused & PAUSED_DEMO) {
			cls.frametime = 0;
		}
		else if (!cls.timedemo) {
			cls.frametime *= Demo_GetSpeed();
		}
		else if (cls.timedemo == TIMEDEMO_FIXEDFPS) {
			cls.frametime = cls.td_frametime;
		}

		if (!host_skipframe) {
			cls.demotime += cls.frametime;
		}
		host_skipframe = false;
	}

	cls.realtime += cls.frametime;

	if (!ISPAUSED) 
	{
		cl.time += cls.frametime;
		cl.servertime += cls.frametime;
		cl.stats[STAT_TIME] = (int) (cl.servertime * 1000);
		if (cls.demoplayback)
			cl.gametime += cls.frametime;
		else
			cl.gametime = Sys_DoubleTime() - cl.gamestarttime - cl.gamepausetime;
	}
	else
	{
		// We hope here, that pause doesn't take long so we don't get too much de-synced
		// if pause takes too much, we can get into usual clock sync-problems as we did before
		cl.gamepausetime += cls.frametime;
	}

	r_refdef2.time = cl.time;

	// get new key events
	if (cl_independentPhysics.value == 0)
	{
		Sys_SendKeyEvents();

		// allow mice or other external controllers to add commands
		IN_Commands();

		// process console commands
		Cbuf_Execute();
		CL_CheckAutoPause();

#ifndef CLIENTONLY
		CL_ServerFrame(cls.frametime);
#endif

		// fetch results from server
		CL_ReadPackets();

		TP_UpdateSkins();

		if (cls.mvdplayback && !cls.demoseeking)
		{
			MVD_Interpolate();
			MVD_Mainhook();

			if (!cl.standby && physframe) {
				StatsGrid_Gather();
			}
		}

		// process stuffed commands
		Cbuf_ExecuteEx(&cbuf_svc);

		CL_SendToServer();

		// We need to move the mouse also when disconnected
		// to get the cursor working properly.
		if (cls.state == ca_disconnected) {
			usercmd_t dummy;
			IN_Move(&dummy);
		}

		Sys_SendDeferredKeyEvents();
	}
	else 
	{
		if (physframe) {
			Sys_SendKeyEvents();

			// allow mice or other external controllers to add commands
			IN_Commands();

			// process console commands
			Cbuf_Execute();
			CL_CheckAutoPause ();

#ifndef CLIENTONLY
			CL_ServerFrame(physframetime);
#endif

			// Fetch results from server
			CL_ReadPackets();

			TP_UpdateSkins();

			// Gather MVD stats and interpolate.
			if (cls.mvdplayback && !cls.demoseeking)
			{
				MVD_Interpolate();
				MVD_Mainhook();

				if (!cl.standby && physframe) {
					StatsGrid_Gather();
				}
			}

			// process stuffed commands
			Cbuf_ExecuteEx(&cbuf_svc);

			CL_SendToServer();

			// We need to move the mouse also when disconnected
			if (cls.state == ca_disconnected) {
				usercmd_t dummy;
				IN_Move(&dummy);
			}

			Sys_SendDeferredKeyEvents();
		}
		else {
			if (need_server_frame && PROCESS_SERVERPACKETS_IMMEDIATELY) {
				CL_ServerFrame(0);
			}

			if (!cls.demoplayback && cl_earlypackets.integer) {
				CL_ReadPackets(); // read packets ASAP
			}

			if (   (!cls.demoplayback && !cl.spectator) // not demo playback and not a spec
				|| (!cls.demoplayback && cl.spectator && Cam_TrackNum() == -1) // not demo, spec free fly
				|| ( cls.demoplayback && cls.mvdplayback && Cam_TrackNum() == -1) // mvd demo and free fly
				|| cls.state == ca_disconnected // We need to move the mouse also when disconnected
				) 
			{
				usercmd_t dummy;
				Sys_SendKeyEvents();
				IN_Move(&dummy);
			}
		}
	}

	{
		// chat icons
		int cif_flags = 0;

		// add chat flag if in console, menus, mm1, mm2 etc...
		cif_flags |= (key_dest != key_game ? CIF_CHAT : 0);

		// add AFK flag if app minimized, or not the focus
		// TODO: may be add afk flag on idle? if no user input in 45 seconds for example?
		cif_flags |= (!ActiveApp || Minimized ? CIF_AFK : 0);

		if (cif_flags != cl.cif_flags) {
			char char_flags[64] = {0};

			if (cif_flags && cls.state >= ca_connected) {
				// put key in userinfo only then we are connected, remove key if we not connected yet
				snprintf(char_flags, sizeof(char_flags), "%d", cif_flags);
			}

			CL_UserinfoChanged("chat", char_flags);
			cl.cif_flags = cif_flags;
		}
	}

	VID_ReloadCheck();

	R_ParticleFrame();

	buffers.StartFrame();

	CachePics_AtlasFrame();

	CL_MultiviewPreUpdateScreen();

	// update video
	if (CL_MultiviewEnabled()) {
		qbool draw_next_view = true;
		qbool first_view = true;

		R_PerformanceBeginFrame();
		if (SCR_UpdateScreenPrePlayerView()) {
			qbool two_pass_rendering = GL_FramebufferEnabled2D();
			renderer.ScreenDrawStart();

			while (draw_next_view) {
				draw_next_view = CL_MultiviewAdvanceView();
				if (!first_view) {
					buffers.EndFrame();
					buffers.StartFrame();
				}
				first_view = false;

				CL_LinkEntities();
				CL_SpawnWarn_UpdateWarning();

				SCR_CalcRefdef();

				SCR_UpdateScreenPlayerView((draw_next_view ? 0 : UPDATESCREEN_POSTPROCESS) | (two_pass_rendering ? UPDATESCREEN_3D_ONLY : 0));

				if (!two_pass_rendering) {
					SCR_DrawMultiviewIndividualElements();
				}
				else {
					SCR_SaveAutoID();
				}

				if (CL_MultiviewCurrentView() == 2 || (CL_MultiviewCurrentView() == 1 && CL_MultiviewActiveViews() == 1)) {
					CL_SoundFrame();
				}

				// Multiview: advance to next player
				CL_MultiviewFrameFinish();
			}

			if (two_pass_rendering) {
				buffers.EndFrame();

				draw_next_view = true;
				while (draw_next_view) {
					draw_next_view = CL_MultiviewAdvanceView();

					// Need to call this again to keep autoid correct
					SCR_RestoreAutoID();

					SCR_UpdateScreenPlayerView(UPDATESCREEN_2D_ONLY);
					SCR_DrawMultiviewIndividualElements();

					// Multiview: advance to next player
					CL_MultiviewFrameFinish();
				}
			}

			SCR_UpdateScreenPostPlayerView();
		}
		else {
			VID_RenderFrameEnd();
		}
		R_PerformanceEndFrame();
	}
	else {
		CL_LinkEntities();
		CL_SpawnWarn_UpdateWarning();

		R_PerformanceBeginFrame();
		SCR_UpdateScreen();
		R_PerformanceEndFrame();

		CL_SoundFrame();
	}

	CL_DecayLights();

	CDAudio_Update();

	MT_Frame();

	if (Movie_IsCapturing()) {
		Movie_FinishFrame();
	}

	cls.framecount++;
	cls.fps_stats.fps_count++;
	CL_CalcFPS();

	VFS_TICK(); // VFS hook for updating some systems

	Sys_ReadIPC();

	CL_QTVPoll();
#ifdef WITH_IRC
	IRC_Update();
#endif

	SB_ExecuteQueuedTriggers();

	R_ParticleEndFrame();

	CL_UpdateCaption(false);
}

//============================================================================

void CL_Shutdown (void) 
{
	CL_Disconnect();
	SList_Shutdown();
	CDAudio_Shutdown();
	S_Shutdown();
	IN_Shutdown ();
	Log_Shutdown();
	if (host_basepal) {
		VID_Shutdown(false);
	}
	History_Shutdown();
	Sys_CloseIPC();
	SB_Shutdown();
	MT_Shutdown();
	Help_Shutdown();
	HUD_Shutdown();
	Cmd_Shutdown();
	Key_Shutdown();
	TP_Shutdown();
	M_Shutdown();
	Stats_Shutdown();
	Draw_Shutdown();
	Cache_Flush();
	Q_free(host_basepal);
	Q_free(host_colormap);
}

void CL_UpdateCaption(qbool force)
{
	static char caption[512] = { 0 };
	char str[512] = { 0 };

	if (!cl_window_caption.value) {
		if (!cls.demoplayback && (cls.state == ca_active)) {
			snprintf(str, sizeof(str), "ezQuake: %s", cls.servername);
		}
		else {
			snprintf(str, sizeof(str), "ezQuake");
		}
	}
	else if (cl_window_caption.integer == 1) {
		snprintf(str, sizeof(str), "%s - %s", CL_Macro_Serverstatus(), MT_ShortStatus());
	}
	else if (cl_window_caption.integer == 2) {
		snprintf(str, sizeof(str), "ezQuake");
	}
	else if (cl_window_caption.integer == 3) {
		if (cls.state < ca_connected) {
			snprintf(str, sizeof(str), "ezQuake v%s", VERSION_NUMBER);
		}
		else {
			snprintf(str, sizeof(str), "%d/%d%s%s",
				TP_CountPlayers(),
				Q_atoi(Info_ValueForKey(cl.serverinfo, "maxclients")),
				cl_window_caption_delimiter.string,
				TP_MapName());
		}
	}

	if (force || strcmp(str, caption)) {
		VID_SetCaption(str);
		strlcpy(caption, str, sizeof(caption));
	}
}

void OnChangeDemoTeamplay (cvar_t *var, char *value, qbool *cancel)
{
	if (cls.nqdemoplayback) 
	{
		cl.teamplay = (*value != '0');

		NQD_SetSpectatorFlags();

		OnChangeColorForcing(var, value, cancel);
	}
}



#ifndef CLIENTONLY

void Dev_PhysicsNormalShow(void)
{
	vec3_t point = { cl.simorg[0], cl.simorg[1], cl.simorg[2] - 1 };
	trace_t trace;
	mphysicsnormal_t physicsnormal;

	if (cls.demoplayback || cls.state != ca_active || !r_refdef2.allow_cheats) {
		// it's not actually a cheat, but using these functions would screw with prediction
		Con_Printf("Not available outwith /devmap\n");
		return;
	}

	trace = PM_PlayerTrace(pmove.origin, point);
	if (trace.fraction == 1 || trace.plane.normal[2] < MIN_STEP_NORMAL) {
		Con_Printf("Not on ground\n");
	}
	else {
		physicsnormal = CM_PhysicsNormal(trace.physicsnormal);

		Con_Printf("Plane normal  : %+f %+f %+f\n", trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2]);
		if (!(physicsnormal.flags & PHYSICSNORMAL_SET)) {
			Con_Printf("No custom physics plane found\n");
		}
		else {
			const char* flipx = physicsnormal.flags & PHYSICSNORMAL_FLIPX ? "&cff0" : "&r";
			const char* flipy = physicsnormal.flags & PHYSICSNORMAL_FLIPY ? "&cff0" : "&r";
			const char* flipz = physicsnormal.flags & PHYSICSNORMAL_FLIPZ ? "&cff0" : "&r";

			Con_Printf("Physics normal: %s%+f %s%+f %s%+f&r\n", flipx, physicsnormal.normal[0], flipy, physicsnormal.normal[1], flipz, physicsnormal.normal[2]);
		}
	}
}

void Dev_PhysicsNormalSet(void)
{
	vec3_t point = { cl.simorg[0], cl.simorg[1], cl.simorg[2] - 1 };
	trace_t trace;
	mphysicsnormal_t physicsnormal;
	vec3_t newnormal;
	int newflags = PHYSICSNORMAL_SET;

	if (cls.demoplayback || cls.state != ca_active || !r_refdef2.allow_cheats) {
		// it's not actually a cheat, but using these functions would screw with prediction
		Con_Printf("Not available outwith /devmap\n");
		return;
	}

	if (Cmd_Argc() < 5) {
		Com_Printf("Usage: %s <x> <y> <z> <flags(xyzn)>\n", Cmd_Argv(0));
		return;
	}

	{
		int i;
		const char* flags = Cmd_Argv(4);

		newnormal[0] = atof(Cmd_Argv(1));
		newnormal[1] = atof(Cmd_Argv(2));
		newnormal[2] = atof(Cmd_Argv(3));
		for (i = 0; i < strlen(flags); ++i) {
			if (flags[i] == 'x') {
				newflags |= PHYSICSNORMAL_FLIPX;
			}
			else if (flags[i] == 'y') {
				newflags |= PHYSICSNORMAL_FLIPY;
			}
			else if (flags[i] == 'z') {
				newflags |= PHYSICSNORMAL_FLIPZ;
			}
			else if (flags[i] != 'n') {
				Com_Printf("Unknown flag %c\n", flags[i]);
			}
		}
	}

	if (newnormal[0] || newnormal[1] || newnormal[2]) {
		VectorNormalize(newnormal);
		if (VectorLength(newnormal) != 1) {
			Com_Printf("Error: failed to normalize, found %f %f %f\n", newnormal[0], newnormal[1], newnormal[2]);
			return;
		}
	}

	trace = PM_PlayerTrace(pmove.origin, point);
	if (trace.fraction == 1 || trace.plane.normal[2] < MIN_STEP_NORMAL) {
		Con_Printf("Not on ground\n");
	}
	else {
		physicsnormal = CM_PhysicsNormal(trace.physicsnormal);
		if (!(physicsnormal.flags & PHYSICSNORMAL_SET)) {
			Con_Printf("Unable to determine ground normal\n");
		}
		else {
			CM_PhysicsNormalSet(trace.physicsnormal, newnormal[0], newnormal[1], newnormal[2], newflags);
			Dev_PhysicsNormalShow();
		}
	}
}

void Dev_PhysicsNormalSave(void)
{
	char filename[MAX_OSPATH];
	FILE* out;
	extern cvar_t pm_rampjump;

	if (cls.demoplayback || cls.state != ca_active || !r_refdef2.allow_cheats) {
		// it's not actually a cheat, but using these functions would screw with prediction
		Con_Printf("Not available outwith /devmap\n");
		return;
	}

	snprintf(filename, sizeof(filename), "qw/%s.qpn", host_mapname.string);
	if (!(out = fopen(filename, "wb"))) {
		Con_Printf("Failed: unable to open %s\n", filename);
		return;
	}

	CM_PhysicsNormalDump(out, pm_rampjump.value, 0);
	fclose(out);

	Con_Printf("Wrote %s\n", filename);
}

#endif // !CLIENTONLY

void Cache_Flush(void)
{
	Skin_Clear(false);
	Mod_FreeAllCachedData();
}

static void AuthUsernameChanged(cvar_t* var, char* value, qbool* cancel)
{
	char path[MAX_PATH];
	char filename[MAX_PATH];
	byte* auth_token;
	int auth_token_length;
	int len = strlen(value);
	int i;

	// Don't validate if no changes
	if (!strcmp(var->string, value)) {
		return;
	}

	// Validate new name
	for (i = 0; i < len; ++i) {
		if (isalpha(value[i]) || isdigit(value[i]))
			continue;
		if (value[i] == '_' || value[i] == '[' || value[i] == ']' || value[i] == '(' || value[i] == ')' || value[i] == '.' || value[i] == '-')
			continue;
		// TODO: others

		// Illegal
		Com_Printf("Illegal character %c in username\n", value[i]);
		*cancel = true;
		return;
	}

	if (!value[0]) {
		// Logging out...
		if (cls.state == ca_active && cl.players[cl.playernum].loginname[0]) {
			Cbuf_AddTextEx(&cbuf_main, "cmd logout\n");
		}
		memset(cls.auth_logintoken, 0, sizeof(cls.auth_logintoken));
		return;
	}
	
	// FIXME: server-side, treat new login request as logout?
	if (cls.state == ca_active && cl.players[cl.playernum].loginname[0]) {
		Com_Printf("You are logged in to the server & must logout first\n");
		*cancel = true;
		return;
	}

	// Try and load login token
	strlcpy(filename, value, sizeof(filename));
	COM_ForceExtensionEx(filename, ".apikey", sizeof(filename));

	Cfg_GetConfigPath(path, sizeof(path), filename);

	auth_token = FS_LoadTempFile(path, &auth_token_length);
	if (auth_token == 0) {
		Com_Printf("Unable to load authentication token for '%s'\n", value);
		*cancel = true;
		return;
	}
	else {
		strlcpy(cls.auth_logintoken, (const char*)auth_token, sizeof(cls.auth_logintoken));
		memset(cl.auth_challenge, 0, sizeof(cl.auth_challenge));
		if (cls.state == ca_active) {
			Cbuf_AddTextEx(&cbuf_main, va("cmd login %s\n", value));
		}
	}
}

static void CL_Authenticate_f(void)
{
	if (!cls.auth_logintoken[0] || !cl_username.string[0]) {
		Com_Printf("You must load a login token by setting cl_username first.\n");
		Com_Printf("Login tokens must be located in your configuration directory\n");
		return;
	}

	if (cls.state != ca_active) {
		Com_Printf("Cannot authenticate, not connected\n");
		return;
	}

	if (cl.players[cl.playernum].loginname[0]) {
		Com_Printf("Logging out...\n");
		Cbuf_AddTextEx(&cbuf_main, "cmd logout\n");
		return;
	}

	Com_Printf("Starting authentication process...\n");
	Cbuf_AddTextEx(&cbuf_main, va("cmd login \"%s\"\n", cl_username.string));
}


================================================
FILE: src/cl_multiview.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// Multiview code
#include "quakedef.h"
#include "utils.h"          // Reg expressions
#include "draw.h"           // RGBA macros
#include "teamplay.h"       // FPD_NO_FORCE_COLOR

// meag: for switching back to 3d resolution to draw the multiview outlines
#include "r_matrix.h"
#include "mvd_utils.h"

extern int glx, gly, glwidth, glheight;

#define	MV_VIEW1 0
#define	MV_VIEW2 1
#define	MV_VIEW3 2
#define	MV_VIEW4 3

static int      CURRVIEW;					// The current view being drawn in multiview mode.
static qbool    bExitmultiview;				// Used when saving effect values on each frame.
static int      nNumViews;					// The number of views in multiview mode.
static int      nPlayernum;
static int      mv_trackslots[MV_VIEWS];    // The different track slots for each view.
static char     currteam[MAX_INFO_STRING];	// The name of the current team being tracked in multiview mode.
static int      nSwapPov;					// Change in POV positive for next, negative for previous.
static int      nTrack1duel;				// When cl_multiview = 2 and mvinset is on this is the tracking slot for the main view.
static int      nTrack2duel;				// When cl_multiview = 2 and mvinset is on this is the tracking slot for the mvinset view.

// temporary storage (essentially caching OpenGL viewport state, can get rid of this in 3.5)
static int inset_x;
static int inset_y;
static int inset_width;
static int inset_height;

// Temporary storage so we keep same settings during demo rewind
static int rewind_trackslots[4];
static int rewind_duel_track1 = 0;
static int rewind_duel_track2 = 0;

static int next_spec_track = -1;
extern cvar_t gl_polyblend;
extern cvar_t gl_clear;

extern cvar_t scr_autoid_healthbar_bg_color;
extern cvar_t scr_autoid_healthbar_normal_color;
extern cvar_t scr_autoid_healthbar_mega_color;
extern cvar_t scr_autoid_healthbar_two_mega_color;
extern cvar_t scr_autoid_healthbar_unnatural_color;

extern cvar_t scr_autoid_armorbar_green_armor;
extern cvar_t scr_autoid_armorbar_yellow_armor;
extern cvar_t scr_autoid_armorbar_red_armor;

extern cvar_t cl_multiview_inset_offset_x, cl_multiview_inset_offset_y;
extern cvar_t cl_multiview_inset_size_x, cl_multiview_inset_size_y;
extern cvar_t cl_multiview_inset_top, cl_multiview_inset_right;

#define ALPHA_COLOR(x, y) RGBA_TO_COLOR((x)[0],(x)[1],(x)[2],(y))

typedef struct mv_viewrect_s
{
	int x;
	int y;
	int width;
	int height;
} mv_viewrect_t;

#define MV_HUD_POS_BOTTOM_CENTER	1
#define MV_HUD_POS_BOTTOM_LEFT		2
#define MV_HUD_POS_BOTTOM_RIGHT		3
#define MV_HUD_POS_TOP_CENTER		4
#define MV_HUD_POS_TOP_LEFT			5
#define MV_HUD_POS_TOP_RIGHT		6
#define MV_HUD_POS_GATHERED_CENTER	7

#define MV_HUDPOS(regexp, input, position, cvar) if(Utils_RegExpMatch(regexp, input)) { mv_hudpos = position; found = true; }

// true if the player in given slot is an existing player
#define VALID_PLAYER(i) (cl.players[i].name[0] && !cl.players[i].spectator)

int mv_hudpos = MV_HUD_POS_BOTTOM_CENTER;

mpic_t* SCR_GetWeaponIconByFlag (int flag);
void R_TranslatePlayerSkin (int playernum);
void CL_Track (int trackview);
static void CL_MultiviewOverrideValues (void);

static int CL_IncrLoop(int cview, int max)
{
	return (cview >= max) ? 1 : ++cview;
}

int CL_NextPlayer(int plr)
{
	do
	{
		plr++;
	} while ((plr < MAX_CLIENTS) && (cl.players[plr].spectator || !cl.players[plr].name[0]));

	if (plr >= MAX_CLIENTS)
	{
		plr = -1;

		do
		{
			plr++;
		} while ((plr < MAX_CLIENTS) && (cl.players[plr].spectator || !cl.players[plr].name[0]));
	}

	if (plr >= MAX_CLIENTS)
	{
		plr = 0;
	}

	return plr;
}

int CL_PrevPlayer(int plr)
{
	do
	{
		plr--;
	} while ((plr >= 0) && (cl.players[plr].spectator || !cl.players[plr].name[0]));

	if (plr < 0)
	{
		plr = MAX_CLIENTS;

		do
		{
			plr--;
		} while ((plr >= 0) && (cl.players[plr].spectator || !cl.players[plr].name[0]));
	}

	if (plr < 0)
	{
		plr = 0;
	}

	return plr;
}

void SCR_OnChangeMVHudPos (cvar_t *var, char *newval, qbool *cancel)
{
	qbool found = false;

	MV_HUDPOS ("(top\\s*left|tl)", newval, MV_HUD_POS_TOP_LEFT, var);
	MV_HUDPOS ("(top\\s*right|tr)", newval, MV_HUD_POS_TOP_RIGHT, var);
	MV_HUDPOS ("(top\\s*center|tc)", newval, MV_HUD_POS_TOP_CENTER, var);
	MV_HUDPOS ("(bottom\\s*left|bl)", newval, MV_HUD_POS_BOTTOM_LEFT, var);
	MV_HUDPOS ("(bottom\\s*right|br)", newval, MV_HUD_POS_BOTTOM_RIGHT, var);
	MV_HUDPOS ("(bottom\\s*center|bc)", newval, MV_HUD_POS_BOTTOM_CENTER, var);
	MV_HUDPOS ("(gather|g)", newval, MV_HUD_POS_GATHERED_CENTER, var);

	if (found) {
		Cvar_Set (var, newval);
	}

	*cancel = found;
}

// SCR_SetMVStatusPosition calls SCR_SetMVStatusGatheredPosition and vice versa.
void SCR_SetMVStatusGatheredPosition (mv_viewrect_t *view, int hud_width, int hud_height, int *x, int *y);

void SCR_SetMVStatusPosition (int position, mv_viewrect_t *view, int hud_width, int hud_height, int *x, int *y)
{
	switch (position) {
	case MV_HUD_POS_BOTTOM_LEFT:
	{
		(*x) = 0;
		(*y) = max (0, (view->height - hud_height));
		break;
	}
	case MV_HUD_POS_BOTTOM_RIGHT:
	{
		(*x) = max (0, (view->width - hud_width));
		(*y) = max (0, (view->height - hud_height));
		break;
	}
	case MV_HUD_POS_TOP_CENTER:
	{
		(*x) = max (0, (view->width - hud_width) / 2);
		(*y) = 0;
		break;
	}
	case MV_HUD_POS_TOP_LEFT:
	{
		(*x) = 0;
		(*y) = 0;
		break;
	}
	case MV_HUD_POS_TOP_RIGHT:
	{
		(*x) = max (0, view->width - hud_width);
		(*y) = 0;
		break;
	}
	case MV_HUD_POS_GATHERED_CENTER:
	{
		SCR_SetMVStatusGatheredPosition (view, hud_width, hud_height, &(*x), &(*y));
		break;
	}
	case MV_HUD_POS_BOTTOM_CENTER:
	default:
	{
		(*x) = max (0, (view->width - hud_width) / 2);
		(*y) = max (0, (view->height - hud_height));
		break;
	}
	}
}

void SCR_SetMVStatusGatheredPosition (mv_viewrect_t *view, int hud_width, int hud_height, int *x, int *y)
{
	//
	// Position the huds towards the center of the screen for the different views
	// so that all the HUD's are close to each other on the screen.
	//

	if (cl_multiview.value == 2) {
		if (!cl_mvinset.value) {
			if (CURRVIEW == 2) {
				// Top view. (Put the hud at the bottom)
				SCR_SetMVStatusPosition (MV_HUD_POS_BOTTOM_CENTER, view, hud_width, hud_height, x, y);
			}
			else if (CURRVIEW == 1) {
				// Bottom view. (Put the hud at the top)
				SCR_SetMVStatusPosition (MV_HUD_POS_TOP_CENTER, view, hud_width, hud_height, x, y);
			}
		}
	}
	else if (cl_multiview.value == 3) {
		if (CURRVIEW == 2) {
			// Top view. (Put the hud at the bottom)
			SCR_SetMVStatusPosition (MV_HUD_POS_BOTTOM_CENTER, view, hud_width, hud_height, x, y);
		}
		else if (CURRVIEW == 3) {
			// Bottom left view. (Put the hud at the top right)
			SCR_SetMVStatusPosition (MV_HUD_POS_TOP_RIGHT, view, hud_width, hud_height, x, y);
		}
		else if (CURRVIEW == 1) {
			// Bottom right view. (Put the hud at the top left)
			SCR_SetMVStatusPosition (MV_HUD_POS_TOP_LEFT, view, hud_width, hud_height, x, y);
		}
	}
	else if (cl_multiview.value == 4) {
		if (CURRVIEW == 2) {
			// Top left view. (Put the hud at the bottom right)
			SCR_SetMVStatusPosition (MV_HUD_POS_BOTTOM_RIGHT, view, hud_width, hud_height, x, y);
		}
		else if (CURRVIEW == 3) {
			// Top right view. (Put the hud at the bottom left)
			SCR_SetMVStatusPosition (MV_HUD_POS_BOTTOM_LEFT, view, hud_width, hud_height, x, y);
		}
		else if (CURRVIEW == 4) {
			// Bottom left view. (Put the hud at the top right)
			SCR_SetMVStatusPosition (MV_HUD_POS_TOP_RIGHT, view, hud_width, hud_height, x, y);
		}
		else if (CURRVIEW == 1) {
			// Bottom right view. (Put the hud at the top left)
			SCR_SetMVStatusPosition (MV_HUD_POS_TOP_LEFT, view, hud_width, hud_height, x, y);
		}
	}
}

#define MV_HUD_ARMOR_WIDTH		(5*8)
#define MV_HUD_HEALTH_WIDTH		(5*8)
#define MV_HUD_CURRAMMO_WIDTH	(5*8)
#define MV_HUD_CURRWEAP_WIDTH	(3*8)
#define MV_HUD_POWERUPS_WIDTH	(2*8)
#define MV_HUD_POWERUPS_HEIGHT	(2*8)

#define MV_HUD_STYLE_ONLY_NAME	2
#define MV_HUD_STYLE_ALL		3
#define MV_HUD_STYLE_ALL_TEXT	4
#define MV_HUD_STYLE_ALL_FILL	5

void SCR_MV_SetBoundValue (int *var, int val)
{
	if (var != NULL) {
		(*var) = val;
	}
}

void SCR_MV_DrawName (int x, int y, int *width, int *height)
{
	char *name = cl.players[nPlayernum].name;
	SCR_MV_SetBoundValue (width, 8 * (strlen (name) + 1));
	SCR_MV_SetBoundValue (height, 8);

	Draw_String (x, y, name);
}

void SCR_MV_DrawArmor (int x, int y, int *width, int *height, int style)
{
	char armor_color_code[6] = "";
	int armor_amount_width = 0;

	byte armor_color[4] = { 0, 0, 0, 75 };	// RGBA.

											//
											// Set the armor text color based on what armor the player has.
											//
	if (cl.stats[STAT_ITEMS] & IT_ARMOR1) {
		// Green armor.
		strlcpy (armor_color_code, "&c0f0", sizeof (armor_color_code));
		armor_amount_width = Q_rint (MV_HUD_ARMOR_WIDTH * cl.stats[STAT_ARMOR] / 100.0);

		armor_color[0] = 80;
		armor_color[1] = 190;
		armor_color[2] = 80;
	}
	else if (cl.stats[STAT_ITEMS] & IT_ARMOR2) {
		// Yellow armor.
		strlcpy (armor_color_code, "&cff0", sizeof (armor_color_code));
		armor_amount_width = Q_rint (MV_HUD_ARMOR_WIDTH * cl.stats[STAT_ARMOR] / 150.0);

		armor_color[0] = 250;
		armor_color[1] = 230;
		armor_color[2] = 0;
	}
	else if (cl.stats[STAT_ITEMS] & IT_ARMOR3) {
		// Red armor.
		strlcpy (armor_color_code, "&cf00", sizeof (armor_color_code));
		armor_amount_width = Q_rint (MV_HUD_ARMOR_WIDTH * cl.stats[STAT_ARMOR] / 200.0);

		armor_color[0] = 190;
		armor_color[1] = 50;
		armor_color[2] = 0;
	}

	if (cl.stats[STAT_ARMOR] > 0) {
		//
		// Background fill for armor.
		//
		Draw_AlphaFillRGB (x, y, armor_amount_width, 8, RGBA_TO_COLOR (armor_color[0], armor_color[1], armor_color[2], armor_color[3]));

		// Armor value.
		if (style >= MV_HUD_STYLE_ALL_TEXT) {
			Draw_ColoredString (x, y, va ("%s%4d", armor_color_code, cl.stats[STAT_ARMOR]), 0, false);
		}
	}

	SCR_MV_SetBoundValue (width, MV_HUD_ARMOR_WIDTH);
	SCR_MV_SetBoundValue (height, 8);
}

void SCR_MV_DrawHealth (int x, int y, int *width, int *height, int style)
{
#define MV_HEALTH_OPACITY 75
	int health = cl.stats[STAT_HEALTH];

	int health_amount_width = 0;

	health = min (100, health);
	health_amount_width = Q_rint (fabs((MV_HUD_HEALTH_WIDTH * health) / 100.0f));

	if (health > 0) {
		Draw_AlphaFillRGB (x, y, health_amount_width, 8, ALPHA_COLOR (scr_autoid_healthbar_normal_color.color, 2 * MV_HEALTH_OPACITY));
	}

	health = cl.stats[STAT_HEALTH];

	if (health > 100 && health <= 200) {
		// Mega health.
		health_amount_width = Q_rint ((MV_HUD_HEALTH_WIDTH / 100.0f) * (health - 100));

		Draw_AlphaFillRGB (x, y, health_amount_width, 8, ALPHA_COLOR (scr_autoid_healthbar_mega_color.color, MV_HEALTH_OPACITY));
	}
	else if (health > 200 && health <= 250) {
		// Super health.
		health_amount_width = Q_rint ((MV_HUD_HEALTH_WIDTH / 100.0f) * (health - 200));

		Draw_AlphaFillRGB (x, y, MV_HUD_HEALTH_WIDTH, 8, ALPHA_COLOR (scr_autoid_healthbar_mega_color.color, MV_HEALTH_OPACITY));
		Draw_AlphaFillRGB (x, y, health_amount_width, 8, ALPHA_COLOR (scr_autoid_healthbar_two_mega_color.color, MV_HEALTH_OPACITY));
	}
	else if (health > 250) {
		// Crazy health.
		Draw_AlphaFillRGB (x, y, MV_HUD_HEALTH_WIDTH, 8, ALPHA_COLOR (scr_autoid_healthbar_unnatural_color.color, MV_HEALTH_OPACITY));

	}

	// No powerup.
	if (style >= MV_HUD_STYLE_ALL_TEXT && !(cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)) {
		Draw_String (x, y, va ("%4d", health));
	}

	SCR_MV_SetBoundValue (width, MV_HUD_HEALTH_WIDTH);
	SCR_MV_SetBoundValue (height, 8);
}

void SCR_MV_DrawPowerups (int x, int y)
{
	extern mpic_t  *sb_face_invis;
	extern mpic_t  *sb_face_quad;
	extern mpic_t  *sb_face_invuln;
	extern mpic_t  *sb_face_invis_invuln;

	if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY
		&& cl.stats[STAT_ITEMS] & IT_INVISIBILITY) {
		// Pentagram + Ring.
		Draw_AlphaPic (x + (MV_HUD_HEALTH_WIDTH - sb_face_invis_invuln->width) / 2,
			y - sb_face_invis_invuln->height / 2,
			sb_face_invis_invuln, 0.4);
	}
	else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) {
		// Pentagram.
		Draw_AlphaPic (x + (MV_HUD_HEALTH_WIDTH - sb_face_invuln->width) / 2,
			y - sb_face_invuln->height / 2,
			sb_face_invuln, 0.4);
	}
	else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) {
		// Ring.
		Draw_AlphaPic (x + (MV_HUD_HEALTH_WIDTH - sb_face_invis->width) / 2,
			y - sb_face_invis->height / 2,
			sb_face_invis, 0.4);
	}

	if (cl.stats[STAT_ITEMS] & IT_QUAD) {
		// Ring.
		Draw_AlphaPic (x + (MV_HUD_HEALTH_WIDTH - sb_face_quad->width) / 2,
			y - sb_face_quad->height / 2,
			sb_face_quad, 0.4);
	}
}

static mpic_t *SCR_GetActiveWeaponIcon (void)
{
	return SCR_GetWeaponIconByFlag (cl.stats[STAT_ACTIVEWEAPON]);
}

static void SCR_MV_DrawCurrentWeapon (int x, int y, int *width, int *height)
{
	mpic_t *current_weapon = NULL;
	current_weapon = SCR_GetActiveWeaponIcon ();

	if (current_weapon) {
		Draw_Pic (x,
			y - (current_weapon->height / 4),
			current_weapon);
	}

	SCR_MV_SetBoundValue (width, MV_HUD_CURRWEAP_WIDTH);
	SCR_MV_SetBoundValue (height, 8);
}

void SCR_MV_DrawCurrentAmmo (int x, int y, int *width, int *height)
{
	// Draw the ammo count in blue/greyish color.
	Draw_ColoredString (x, y, va ("&c5CE%4d", cl.stats[STAT_AMMO]), 0, false);
	SCR_MV_SetBoundValue (width, MV_HUD_CURRAMMO_WIDTH);
	SCR_MV_SetBoundValue (height, 8);
}

mpic_t *SCR_GetWeaponIconByWeaponNumber (int num)
{
	extern mpic_t *sb_weapons[7][8];  // sbar.c Weapon pictures.

	num -= 2;

	if (num >= 0 && num < 8) {
		return sb_weapons[0][num];
	}

	return NULL;
}

void SCR_MV_DrawWeapons (int x, int y, int *width, int *height, int hud_width, int hud_height, qbool vertical)
{
#define WEAPON_COUNT 8
	mpic_t *weapon_pic = NULL;
	int weapon = 0;
	int weapon_flag = 0;
	int weapon_x = 0;
	int weapon_y = 0;

	// Draw the weapons the user has.
	for (weapon = 0; weapon < WEAPON_COUNT; weapon++) {
		weapon_flag = IT_SHOTGUN << weapon;

		if (cl.stats[STAT_ITEMS] & weapon_flag) {
			// Get the weapon picture and draw it.
			weapon_pic = SCR_GetWeaponIconByWeaponNumber (weapon + 2);
			Draw_Pic (x + weapon_x, y + weapon_y, weapon_pic);
		}

		// Evenly distribute the weapons.
		if (!vertical) {
			weapon_x += Q_rint ((float)hud_width / WEAPON_COUNT);
		}
		else {
			weapon_y += Q_rint ((float)hud_height / WEAPON_COUNT);
		}
	}
}

void SCR_DrawMVStatusView (mv_viewrect_t *view, int style, int position, qbool flip, qbool vertical)
{
	int hud_x = 0;
	int hud_y = 0;
	int hud_width = 0;
	int hud_height = 0;

	char *name = cl.players[nPlayernum].name;

	if (style == MV_HUD_STYLE_ONLY_NAME) {
		// Only draw the players name.

		hud_height = 2 * 8;
		hud_width = 8 * (strlen (name) + 1);

		//
		// Get the position we should draw the hud at.
		//
		SCR_SetMVStatusPosition (position, view, hud_width, hud_height, &hud_x, &hud_y);

		Draw_String (view->x + hud_x, view->y + hud_y, name);
	}
	else if (style >= MV_HUD_STYLE_ALL) {
#define MV_HUD_VERTICAL_GAP	4

		int name_width = 0;
		int name_height = 0;
		int armor_width = 0;
		int armor_height = 0;
		int health_width = 0;
		int health_height = 0;
		int currweap_width = 0;
		int currweap_height = 0;
		int currammo_width = 0;
		int currammo_height = 0;

		//
		// Calculate the total width and height of the hud.
		//
		if (!vertical) {
			hud_height = 3 * 8;
			hud_width =
				8 * (strlen (name)) +				// Name.
				MV_HUD_ARMOR_WIDTH + 				// Armor + space.
				MV_HUD_HEALTH_WIDTH + 				// Health.
				MV_HUD_CURRWEAP_WIDTH +				// Current weapon.
				MV_HUD_CURRAMMO_WIDTH;				// Current weapon ammo count.

		}
		else {
			// Vertical.
			hud_height = 5 * (8 + MV_HUD_VERTICAL_GAP);
			hud_width = max (8 * strlen (name), MV_HUD_ARMOR_WIDTH) + MV_HUD_ARMOR_WIDTH;
		}

		//
		// Get the position we should draw the hud at.
		//
		SCR_SetMVStatusPosition (position, view, hud_width, hud_height, &hud_x, &hud_y);

		//
		// Draw a fill background.
		//
		if (style >= MV_HUD_STYLE_ALL_FILL) {
			Draw_AlphaFill (view->x + hud_x, view->y + hud_y, hud_width, hud_height, 0, 0.5);
		}

		// Draw powerups in the middle background of the hud.
		SCR_MV_DrawPowerups (view->x + hud_x + (hud_width / 2), view->y + hud_y + (hud_height / 2));

		// Draw the elements vertically? (Add a small gap between the items when
		// drawing them vertically, otherwise they're too close together).
#define MV_FLIP(W,H) if(vertical) { hud_y += (H) + MV_HUD_VERTICAL_GAP; } else { hud_x += (W); }

		if (!flip) {
			// Name.
			SCR_MV_DrawName (view->x + hud_x, view->y + hud_y, &name_width, &name_height);
			MV_FLIP (name_width, name_height);

			// Armor.
			SCR_MV_DrawArmor (view->x + hud_x, view->y + hud_y, &armor_width, &armor_height, style);
			MV_FLIP (armor_width, armor_height);

			// Health.
			SCR_MV_DrawHealth (view->x + hud_x, view->y + hud_y, &health_width, &health_height, style);
			MV_FLIP (health_width, health_height);

			// Current weapon.
			SCR_MV_DrawCurrentWeapon (view->x + hud_x, view->y + hud_y, &currweap_width, &currweap_height);
			MV_FLIP (currweap_width, currweap_height);

			// Ammo for current weapon.
			SCR_MV_DrawCurrentAmmo (view->x + hud_x, view->y + hud_y, &currammo_width, &currammo_height);
			MV_FLIP (currammo_width, currammo_height);
		}
		else {
			//
			// Flipped horizontally.
			//

			// Ammo for current weapon.
			SCR_MV_DrawCurrentAmmo (view->x + hud_x, view->y + hud_y, &currammo_width, &currammo_height);
			MV_FLIP (currammo_width, currammo_height);

			// Current weapon.
			SCR_MV_DrawCurrentWeapon (view->x + hud_x, view->y + hud_y, &currweap_width, &currweap_height);
			MV_FLIP (currweap_width, currweap_height);

			// Health.
			SCR_MV_DrawHealth (view->x + hud_x, view->y + hud_y, &health_width, &health_height, style);
			MV_FLIP (health_width, health_height);

			// Armor.
			SCR_MV_DrawArmor (view->x + hud_x, view->y + hud_y, &armor_width, &armor_height, style);
			MV_FLIP (armor_width, armor_height);

			// Name.
			SCR_MV_DrawName (view->x + hud_x, view->y + hud_y, &name_width, &name_height);
			MV_FLIP (name_width, name_height);
		}

		if (vertical) {
			// Start in the next column.
			hud_x += max (8 * strlen (name), MV_HUD_ARMOR_WIDTH);
			hud_y -= hud_height;
		}
		else {
			// Start on the next row.
			hud_x -= hud_width;
			hud_y += hud_height / 2;
		}

		// Weapons.
		SCR_MV_DrawWeapons (view->x + hud_x, view->y + hud_y, NULL, NULL, hud_width, hud_height, vertical);
	}
}

void SCR_SetMVStatusTwoViewRect (mv_viewrect_t *view)
{
	if (CURRVIEW == 2) {
		// Top.
		view->x = 0;
		view->y = 0;
		view->width = vid.width;
		view->height = vid.height / 2;
	}
	else if (CURRVIEW == 1) {
		// Bottom.
		view->x = 0;
		view->y = vid.height / 2;
		view->width = vid.width;
		view->height = vid.height / 2;
	}
}

void SCR_SetMVStatusTwoInsetViewRect(mv_viewrect_t *view)
{
	if (CURRVIEW == 2) {
		// Main.
		view->x = 0;
		view->y = 0;
		view->width = vid.width;
		view->height = vid.height;
	}
	else if (CURRVIEW == 1) {
		float ratio_x = (vid.width * 1.0f) / glwidth;
		float ratio_y = (vid.height * 1.0f) / glheight;

		// inset window
		view->x = inset_x * ratio_x;
		view->y = (glheight - (inset_y + inset_height)) * ratio_y; // reversed for 2d/3d rendering
		view->width = ceil(inset_width * ratio_x);
		view->height = ceil(inset_height * ratio_y);
	}
}

void SCR_SetMVStatusThreeViewRect (mv_viewrect_t *view)
{
	if (CURRVIEW == 2) {
		// Top.
		view->x = 0;
		view->y = 0;
		view->width = vid.width;
		view->height = vid.height / 2;
	}
	else if (CURRVIEW == 3) {
		// Bottom left.
		view->x = 0;
		view->y = vid.height / 2;
		view->width = vid.width / 2;
		view->height = vid.height / 2;
	}
	else if (CURRVIEW == 1) {
		// Bottom right.
		view->x = vid.width / 2;
		view->y = vid.height / 2;
		view->width = vid.width / 2;
		view->height = vid.height / 2;
	}
}

void SCR_SetMVStatusFourViewRect (mv_viewrect_t *view)
{
	if (CURRVIEW == 2) {
		// Top left.
		view->x = 0;
		view->y = 0;
		view->width = vid.width / 2;
		view->height = vid.height / 2;
	}
	else if (CURRVIEW == 3) {
		// Top right.
		view->x = vid.width / 2;
		view->y = 0;
		view->width = vid.width / 2;
		view->height = vid.height / 2;
	}
	else if (CURRVIEW == 4) {
		// Bottom left.
		view->x = 0;
		view->y = vid.height / 2;
		view->width = vid.width / 2;
		view->height = vid.height / 2;
	}
	else if (CURRVIEW == 1) {
		// Bottom right.
		view->x = vid.width / 2;
		view->y = vid.height / 2;
		view->width = vid.width / 2;
		view->height = vid.height / 2;
	}
}

void SCR_DrawMVStatus (void)
{
	mv_viewrect_t view;

	// Only draw mini hud when there are more than 1 views.
	if (cl_multiview.value <= 1 || !cls.mvdplayback) {
		return;
	}

	// Reset the view.
	memset (&view, -1, sizeof (view));

	//
	// Get the view rect to draw the hud within based on the current
	// multiview mode, and what view that is being drawn.
	//
	if (cl_multiview.value == 2) {
		if (cl_mvinset.value) {
			// Only draw the mini hud for the inset, 
			// since we probably want the full size hud 
			// for the main view.
			if (CURRVIEW == 2) {
				return;
			}

			SCR_SetMVStatusTwoInsetViewRect(&view);
		}
		else {
			SCR_SetMVStatusTwoViewRect (&view);
		}
	}
	else if (cl_multiview.value == 3) {
		SCR_SetMVStatusThreeViewRect (&view);
	}
	else if (cl_multiview.value == 4) {
		SCR_SetMVStatusFourViewRect (&view);
	}

	// Only draw if we the view rect was set properly.
	if (view.x != -1) {
		SCR_DrawMVStatusView (&view,
			cl_mvdisplayhud.integer,
			mv_hudpos,
			(qbool)cl_mvhudflip.value,
			(qbool)cl_mvhudvertical.value);
	}
}

void SCR_DrawMVStatusStrings (void)
{
	int xb = 0, yb = 0, xd = 0, yd = 0;
	char strng[80];
	char weapons[40];
	char weapon[3];
	char sAmmo[3];
	char pups[4];
	char armor;
	char name[16];

	int i;

	// Only in MVD.
	if (!cl_multiview.value || !cls.mvdplayback) {
		return;
	}

	//
	// Get the current weapon.
	//
	if (cl.stats[STAT_ACTIVEWEAPON] & IT_LIGHTNING || cl.stats[STAT_ACTIVEWEAPON] & IT_SUPER_LIGHTNING) {
		strlcpy (weapon, "lg", sizeof (weapon));
	}
	else if (cl.stats[STAT_ACTIVEWEAPON] & IT_ROCKET_LAUNCHER) {
		strlcpy (weapon, "rl", sizeof (weapon));
	}
	else if (cl.stats[STAT_ACTIVEWEAPON] & IT_GRENADE_LAUNCHER) {
		strlcpy (weapon, "gl", sizeof (weapon));
	}
	else if (cl.stats[STAT_ACTIVEWEAPON] & IT_SUPER_NAILGUN) {
		strlcpy (weapon, "sn", sizeof (weapon));
	}
	else if (cl.stats[STAT_ACTIVEWEAPON] & IT_NAILGUN) {
		strlcpy (weapon, "ng", sizeof (weapon));
	}
	else if (cl.stats[STAT_ACTIVEWEAPON] & IT_SUPER_SHOTGUN) {
		strlcpy (weapon, "ss", sizeof (weapon));
	}
	else if (cl.stats[STAT_ACTIVEWEAPON] & IT_SHOTGUN) {
		strlcpy (weapon, "sg", sizeof (weapon));
	}
	else if (cl.stats[STAT_ACTIVEWEAPON] & IT_AXE) {
		strlcpy (weapon, "ax", sizeof (weapon));
	}
	else {
		strlcpy (weapon, "??", sizeof (weapon));
	}
	weapon[0] |= 128;
	weapon[1] |= 128;

	//
	// Get current powerups.
	//
	pups[0] = pups[1] = pups[2] = ' ';
	pups[3] = '\0';

	if (cl.stats[STAT_ITEMS] & IT_QUAD) {
		pups[0] = 'Q';
		pups[0] |= 128;
	}

	if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) {
		pups[1] = 'R';
		pups[1] |= 128;
	}

	if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) {
		pups[2] = 'P';
		pups[2] |= 128;
	}

	strng[0] = '\0';

	for (i = 0; i < 8; i++) {
		weapons[i] = ' ';
		weapons[8] = '\0';
	}

	if (cl.stats[STAT_ITEMS] & IT_AXE) {
		weapons[0] = '1' - '0' + 0x12;
	}
	if (cl.stats[STAT_ITEMS] & IT_SHOTGUN) {
		weapons[1] = '2' - '0' + 0x12;
	}
	if (cl.stats[STAT_ITEMS] & IT_SUPER_SHOTGUN) {
		weapons[2] = '3' - '0' + 0x12;
	}
	if (cl.stats[STAT_ITEMS] & IT_NAILGUN) {
		weapons[3] = '4' - '0' + 0x12;
	}
	if (cl.stats[STAT_ITEMS] & IT_SUPER_NAILGUN) {
		weapons[4] = '5' - '0' + 0x12;
	}
	if (cl.stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER) {
		weapons[5] = '6' - '0' + 0x12;
	}
	if (cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER) {
		weapons[6] = '7' - '0' + 0x12;
	}
	if (cl.stats[STAT_ITEMS] & IT_SUPER_LIGHTNING || cl.stats[STAT_ITEMS] & IT_LIGHTNING) {
		weapons[7] = '8' - '0' + 0x12;
	}

	armor = ' ';
	if (cl.stats[STAT_ITEMS] & IT_ARMOR1) {
		armor = 'g';
		armor |= 128;
	}
	else if (cl.stats[STAT_ITEMS] & IT_ARMOR2) {
		armor = 'y';
		armor |= 128;
	}
	else if (cl.stats[STAT_ITEMS] & IT_ARMOR3) {
		armor = 'r';
		armor |= 128;
	}

	//
	// Get the player's name.
	//
	strlcpy (name, cl.players[nPlayernum].name, sizeof (name));

	if (strcmp (cl.players[nPlayernum].name, "") && !cl.players[nPlayernum].spectator) {
		if ((cl.players[nPlayernum].stats[STAT_HEALTH] <= 0) && (cl_multiview.value == 2) && cl_mvinset.integer) {
			// mvinset and dead
			snprintf (sAmmo, sizeof (sAmmo), "%02d", cl.players[nPlayernum].stats[STAT_AMMO]);
			snprintf (strng, sizeof (strng), "%.5s   %s %s:%-3s", name,
				"dead   ",
				weapon,
				sAmmo);
		}
		else if ((cl.players[nPlayernum].stats[STAT_HEALTH] <= 0) && (vid.width <= 400)) {
			// Resolution width <= 400 and dead
			snprintf (sAmmo, sizeof (sAmmo), "%02d", cl.players[nPlayernum].stats[STAT_AMMO]);
			snprintf (strng, sizeof (strng), "%.4s  %s %s:%-3s", name,
				"dead   ",
				weapon,
				sAmmo);
		}
		else if (cl.players[nPlayernum].stats[STAT_HEALTH] <= 0) {
			// > 512 and dead
			snprintf (sAmmo, sizeof (sAmmo), "%02d", cl.players[nPlayernum].stats[STAT_AMMO]);
			snprintf (strng, sizeof (strng), "%s   %s %s:%-3s", name,
				"dead   ",
				weapon,
				sAmmo);
		}

		else if ((cl_multiview.integer == 2) && cl_mvinset.integer && (CURRVIEW == 1)) {
			// mvinset
			snprintf (sAmmo, sizeof (sAmmo), "%02d", cl.players[nPlayernum].stats[STAT_AMMO]);
			snprintf (strng, sizeof (strng), "%s %.5s  %c%03d %03d %s:%-3s", pups,
				name,
				armor,
				cl.players[nPlayernum].stats[STAT_ARMOR],
				cl.players[nPlayernum].stats[STAT_HEALTH],
				weapon,
				sAmmo);
		}
		else if (cl_multiview.value && vid.width <= 400) {
			// <= 400 and alive
			snprintf (sAmmo, sizeof (sAmmo), "%02d", cl.players[nPlayernum].stats[STAT_AMMO]);
			snprintf (strng, sizeof (strng), "%s %.4s %c%03d %03d %s:%-3s", pups,
				name,
				armor,
				cl.players[nPlayernum].stats[STAT_ARMOR],
				cl.players[nPlayernum].stats[STAT_HEALTH],
				weapon,
				sAmmo);
		}
		else {
			snprintf (sAmmo, sizeof (sAmmo), "%02d", cl.players[nPlayernum].stats[STAT_AMMO]); // > 512 and alive
			snprintf (strng, sizeof (strng), "%s %s  %c%03d %03d %s:%-3s", pups,
				name,
				armor,
				cl.players[nPlayernum].stats[STAT_ARMOR],
				cl.players[nPlayernum].stats[STAT_HEALTH],
				weapon,
				sAmmo);
		}
	}

	//
	// Powerup cam stuff: (don't display links if we're using fixed camera position)
	//
	if (MVD_PowerupCam_Enabled()) {
		sAmmo[0] = strng[0] = weapons[0] = '\0';
	}

	//
	// Placement.
	//
	if (cl_multiview.value == 1) {
		xb = vid.width - strlen (strng) * 8 - 12;
		yb = vid.height - sb_lines - 16;
		xd = vid.width - strlen (weapons) * 8 - 84;
		yd = vid.height - sb_lines - 8;
	}
	else if (cl_multiview.value == 2) {
		if (!cl_mvinset.value) {
			if (CURRVIEW == 2) {
				// Top
				xb = vid.width - strlen (strng) * 8 - 12;
				yb = vid.height / 2 - sb_lines - 16;
				xd = vid.width - strlen (weapons) * 8 - 84;
				yd = vid.height / 2 - sb_lines - 8;
			}
			else if (CURRVIEW == 1) {
				// Bottom
				xb = vid.width - strlen (strng) * 8 - 12;
				yb = vid.height - sb_lines - 16;
				xd = vid.width - strlen (weapons) * 8 - 84;
				yd = vid.height - sb_lines - 8;
			}
		}
		else if (cl_mvinset.value) {
			if (CURRVIEW == 2) {
				// Main
				xb = vid.width - strlen (strng) * 8 - 12;
				yb = vid.height / 2 - sb_lines - 16;
				xd = vid.width - strlen (weapons) * 8 - 84;
				yd = vid.height / 2 - sb_lines - 8;
			}
			else if (CURRVIEW == 1) {
				mv_viewrect_t view;

				SCR_SetMVStatusTwoInsetViewRect(&view);

				xb = (view.x + view.width) - strlen (strng) * 8; // hud
				yb = (view.y + view.height) - 16;
				xd = (view.x + view.width) - strlen (weapons) * 8 - 70; // weapons
				yd = (view.y + view.height) - 8;
			}
		}
	}
	else if (cl_multiview.value == 3) {
		if (CURRVIEW == 2) {
			// top
			xb = vid.width - strlen (strng) * 8 - 12;
			yb = vid.height / 2 - sb_lines - 16;
			xd = vid.width - strlen (weapons) * 8 - 84;
			yd = vid.height / 2 - sb_lines - 8;
		}
		else if (CURRVIEW == 3) {
			// Bottom left
			xb = vid.width - (vid.width / 2) - strlen (strng) * 8 - 12;
			yb = vid.height - sb_lines - 16;
			xd = vid.width - (vid.width / 2) - strlen (weapons) * 8 - 84;
			yd = vid.height - sb_lines - 8;
		}
		else if (CURRVIEW == 1) {
			// Bottom right
			xb = vid.width - strlen (strng) * 8 - 12;
			yb = vid.height - sb_lines - 16;
			xd = vid.width - strlen (weapons) * 8 - 84;
			yd = vid.height - sb_lines - 8;
		}
	}
	else if (cl_multiview.value == 4) {
		if (CURRVIEW == 2) {
			// Top left
			xb = vid.width - (vid.width / 2) - strlen (strng) * 8 - 12;
			yb = vid.height / 2 - sb_lines - 16;
			xd = vid.width - (vid.width / 2) - strlen (weapons) * 8 - 84;
			yd = vid.height / 2 - sb_lines - 8;
		}
		else if (CURRVIEW == 3) {
			// Top right
			xb = vid.width - strlen (strng) * 8 - 12;
			yb = vid.height / 2 - sb_lines - 16;
			xd = vid.width - strlen (weapons) * 8 - 84;
			yd = vid.height / 2 - sb_lines - 8;
		}
		else if (CURRVIEW == 4) {
			// Bottom left
			xb = vid.width - (vid.width / 2) - strlen (strng) * 8 - 12;
			yb = vid.height - sb_lines - 16;
			xd = vid.width - (vid.width / 2) - strlen (weapons) * 8 - 84;
			yd = vid.height - sb_lines - 8;
		}
		else {
			// Bottom right
			xb = vid.width - strlen (strng) * 8 - 12;
			yb = vid.height - sb_lines - 16;
			xd = vid.width - strlen (weapons) * 8 - 84;
			yd = vid.height - sb_lines - 8;
		}
	}

	// Hud info
	if ((cl_mvdisplayhud.value && !cl_mvinset.value && cl_multiview.value == 2)
		|| (cl_mvdisplayhud.value && cl_multiview.value != 2)) {
		Draw_String (xb, yb, strng);
	}
	else if (cl_multiview.value == 2 && cl_mvdisplayhud.value && CURRVIEW == 1 && cl_mvinsethud.value) {
		if (vid.width > 512) {
			Draw_String (xb, yb, strng);
		}
		else {
			// <= 512 mvinset, just draw the name
			int var, limit;
			char namestr[16];
			mv_viewrect_t view;

			SCR_SetMVStatusTwoInsetViewRect(&view);

			var = ((view.x + view.width) - 320) * 0.05;
			var--;
			var |= (var >> 1);
			var |= (var >> 2);
			var |= (var >> 4);
			var |= (var >> 8);
			var |= (var >> 16);
			var++;

			limit = bound(0, view.width / 8.0f, sizeof(namestr));
			strlcpy(namestr, name, limit);

			Draw_String((view.x + view.width) - strlen(namestr) * 8 - var - 2, yb + (cl_sbar.integer ? 1 : 4), namestr);
		}
	}

	// Weapons
	if ((cl_mvdisplayhud.value && !cl_mvinset.value && cl_multiview.value == 2)
		|| (cl_mvdisplayhud.value && cl_multiview.value != 2)) {
		Draw_String (xd, yd, weapons);
	}
	else if (cl_multiview.value == 2 && cl_mvdisplayhud.value && CURRVIEW == 1 && vid.width > 512 && cl_mvinsethud.value) {
		Draw_String (xd, yd, weapons);
	}
}






// cl_main.c
static void CL_Multiview (void)
{
	static int playernum = 0;

	if (!cls.mvdplayback) {
		return;
	}

	nNumViews = cl_multiview.value;

	/*
	// Only refresh skins once (to start with), I think this is the best solution for multiview
	// eg when viewing 4 players in a 2v2.
	// Also refresh them when the player changes what team to track.
	if ((!CURRVIEW && cls.state >= ca_connected) || nSwapPov) {
		TP_RefreshSkins ();
	}*/

	CL_MultiviewOverrideValues ();

	nPlayernum = playernum;

	// Copy the stats for the player we're about to draw in the next
	// view to the client state, so that the correct stats are drawn
	// in the multiview mini-HUD.
	memcpy (cl.stats, cl.players[playernum].stats, sizeof (cl.stats));

	//
	// Increase the current view being rendered.
	//
	CURRVIEW = CL_IncrLoop (CURRVIEW, cl_multiview.integer);

	if (cl_mvinset.value && cl_multiview.value == 2) {
		//
		// Special case for mvinset and tracking 2 people
		// this is meant for spectating duels primarily.
		// Lets the user swap which player is shown in the
		// main view and the mvinset by pressing jump.
		//

		// If both the mvinset and main view is set to show
		// the same player, pick the first player for the main view
		// and the next after that for the mvinset.
		if (nTrack1duel == nTrack2duel) {
			nTrack1duel = CL_NextPlayer (-1);
			nTrack2duel = CL_NextPlayer (nTrack1duel);
		}

		// The user pressed jump so we need to swap the pov.
		if (nSwapPov) {
			if (nSwapPov > 0) {
				nTrack1duel = CL_NextPlayer (nTrack1duel);
				nTrack2duel = CL_NextPlayer (nTrack2duel);
			}
			else {
				nTrack1duel = CL_PrevPlayer (nTrack1duel);
				nTrack2duel = CL_PrevPlayer (nTrack2duel);
			}
			nSwapPov = false;
		}
		else {
			// Set the playernum based on if we're drawing the mvinset
			// or the main view
			// (nTrack1duel = main view)
			// (nTrack2duel = mvinset)
			playernum = (CURRVIEW == 1) ? nTrack1duel : nTrack2duel;
		}
	}
	else {
		//
		// Normal multiview.
		//

		// Start from the first player on each new frame.
		playernum = ((CURRVIEW == 1) ? 0 : playernum);

		//
		// The player pressed jump and wants to change what team is spectated.
		//
		if (nSwapPov && cl_multiview.value >= 2 && cl.teamplay) {
			int j;
			int team_slot_count = 0;
			int last_mv_trackslots[4];

			// Save the old track values and reset them.
			memcpy (last_mv_trackslots, mv_trackslots, sizeof (last_mv_trackslots));
			memset (mv_trackslots, -1, sizeof (mv_trackslots));

			// Find the new team.
			for (j = 0; j < MAX_CLIENTS; j++) {
				if (!cl.players[j].spectator && cl.players[j].name[0]) {
					// Find the opposite team from the one we are tracking now.
					if (!currteam[0] || strcmp (currteam, cl.players[j].team)) {
						strlcpy (currteam, cl.players[j].team, sizeof (currteam));
						break;
					}
				}
			}

			// Find the team members.
			for (j = 0; j < MAX_CLIENTS; j++) {
				if (!cl.players[j].spectator
					&& cl.players[j].name[0]
					&& !strcmp (currteam, cl.players[j].team)) {
					// Find the player slot to track.
					mv_trackslots[team_slot_count] = Player_StringtoSlot (cl.players[j].name, false, false);
					team_slot_count++;
				}

				Com_DPrintf ("New trackslots: %i %i %i %i\n", mv_trackslots[0], mv_trackslots[1], mv_trackslots[2], mv_trackslots[3]);

				// Don't go out of bounds in the mv_trackslots array.
				if (team_slot_count == 4) {
					break;
				}
			}

			if (cl_multiview.value == 2 && team_slot_count == 2) {
				// Switch between 2on2 teams.
			}
			else if (cl_multiview.value < team_slot_count || team_slot_count >= 3) {
				// We don't want to show all from one team and then one of the enemies...
				cl_multiview.value = team_slot_count;
			}
			else if (team_slot_count == 2) {
				// 2on2... one team on top, on on the bottom
				// Swap the teams between the top and bottom in a 4 view setup.
				cl_multiview.value = 4;
				mv_trackslots[MV_VIEW3] = last_mv_trackslots[MV_VIEW1];
				mv_trackslots[MV_VIEW4] = last_mv_trackslots[MV_VIEW2];

				Com_DPrintf ("Team on top/bottom trackslots: %i %i %i %i\n",
					mv_trackslots[0], mv_trackslots[1], mv_trackslots[2], mv_trackslots[3]);
			}
		}
		else {
			// Check if the track* values have been set by the user,
			// otherwise show the first 4 players.

			if (CURRVIEW >= 1 && CURRVIEW <= 4) {
				// If the value of mv_trackslots[i] is negative, it means that view
				// doesn't have any track value set so we need to find someone to track using CL_NextPlayer().
				playernum = ((mv_trackslots[CURRVIEW - 1] < 0) ? CL_NextPlayer (playernum) : mv_trackslots[CURRVIEW - 1]);
			}
		}
	}

	// BUGFIX - Make sure the player we're tracking is still left, might have disconnected since
	// we picked him for tracking (This would result in being thrown into freefly mode and not being able
	// to go back into tracking mode when a player disconnected).
	if (!nSwapPov && (cl.players[playernum].spectator || !cl.players[playernum].name[0])) {
		mv_trackslots[CURRVIEW - 1] = -1;
	}

	if (nSwapPov) {
		Com_DPrintf ("Final trackslots: %i %i %i %i\n", mv_trackslots[0], mv_trackslots[1], mv_trackslots[2], mv_trackslots[3]);
	}

	nSwapPov = false;

	// Set the current player we're tracking for the next view to be drawn.
	// BUGFIX: Only change the spec_track if the new track target is a player.
	if (!cl.players[playernum].spectator && cl.players[playernum].name[0]) {
		next_spec_track = playernum;
	}

	// Make sure we reset variables we suppressed during multiview drawing.
	bExitmultiview = true;
}

typedef struct mv_temp_cvar_s {
	cvar_t* cvar;
	float   value;
} mv_temp_cvar_t;

static mv_temp_cvar_t multiviewCvars[] = {
	{ &scr_viewsize,      100.0f },
	{ &cl_fakeshaft,        0.0f },
	{ &gl_polyblend,        1.0f },
	{ &gl_clear,            0.0f },
};
#define MV_CVAR_VIEWSIZE 0                 // we reference saved value when cl_mvinset specified

void CL_MultiviewSaveValues (void)
{
	int i = 0;

	for (i = 0; i < sizeof (multiviewCvars) / sizeof (multiviewCvars[0]); ++i) {
		multiviewCvars[i].value = multiviewCvars[i].cvar->value;
	}
}

void CL_MultiviewRestoreValues (void)
{
	int i = 0;

	for (i = 0; i < sizeof (multiviewCvars) / sizeof (multiviewCvars[0]); ++i) {
		Cvar_SetValue(multiviewCvars[i].cvar, multiviewCvars[i].value);
	}

	bExitmultiview = false;
}

static void CL_MultiviewOverrideValues (void)
{
	// contrast was disabled for OpenGL build with the note "blanks all but 1 view"
	// this was due to gl_ztrick in R_Clear(void) that would clear these. FIXED
	// v_contrast.value = 1;

	// stop fakeshaft as it lerps with the other views
	if (cl_fakeshaft.value < 1 && cl_fakeshaft.value > 0) {
		Cvar_SetValue(&cl_fakeshaft, 0);
	}

	// allow mvinset 1 to use viewsize value
	scr_viewsize.value = multiviewCvars[MV_CVAR_VIEWSIZE].value;
	if ((!cl_mvinset.value && cl_multiview.value == 2) || cl_multiview.value != 2) {
		Cvar_SetValue(&scr_viewsize, 120);
	}

	// stop small screens
	if (cl_mvinset.value && cl_multiview.value == 2 && scr_viewsize.value < 100) {
		Cvar_SetValue(&scr_viewsize, 100);
	}

	Cvar_SetValue(&gl_polyblend, 0);
	Cvar_SetValue(&gl_clear, 0);
}

static qbool CL_MultiviewCvarResetRequired (void)
{
	return bExitmultiview;
}

// Can be used during rendering to find out what the next spec track will be
//   (especially useful when CURRVIEW == 1 after CL_Multiview() to report who tracked in main view)
int CL_MultiviewNextPlayer (void)
{
	if (next_spec_track >= 0) {
		return next_spec_track;
	}
	return cl.spec_track;
}

int CL_MultiviewCurrentView (void)
{
	return CURRVIEW;
}

int CL_MultiviewNumberViews (void)
{
	return nNumViews;
}

void CL_MultiviewResetCvars (void)
{
	if (CL_MultiviewCvarResetRequired ()) {
		CL_MultiviewRestoreValues ();
		nTrack1duel = nTrack2duel = 0;
		CURRVIEW = 0;
	}
}

qbool CL_MultiviewEnabled (void)
{
	if (cl_multiview.integer > 0 && cls.mvdplayback && !cl.intermission) {
		if (!MVD_PowerupCams_Enabled()) {
			int first_player = CL_NextPlayer(-1);
			int next_player = CL_NextPlayer(first_player);

			if (first_player == next_player) {
				return false;
			}
		}

		return true;
	}

	return false;
}

qbool CL_MultiviewInsetEnabled (void)
{
	return cl_multiview.value == 2 && cls.mvdplayback && cl_mvinset.value;
}

qbool CL_MultiviewInsetView (void)
{
	return CL_MultiviewInsetEnabled() && CURRVIEW == 1;
}

int CL_MultiviewActiveViews (void)
{
	if (cls.mvdplayback) {
		return bound(1, cl_multiview.integer, 4);
	}
	return 1;
}





// Events called during game loop

void CL_MultiviewFrameStart (void)
{
	next_spec_track = -1;
}

void CL_MultiviewFrameFinish (void)
{
	if (next_spec_track >= 0) {
		cl.spec_track = next_spec_track;
	}
}

void CL_MultiviewDemoStart (void)
{
	memset (mv_trackslots, -1, sizeof (mv_trackslots));
	nTrack1duel = 0;
	nTrack2duel = 0;
}

void CL_MultiviewDemoFinish (void)
{
}

void CL_MultiviewDemoStopRewind (void)
{
	memcpy (mv_trackslots, rewind_trackslots, sizeof (mv_trackslots));
	nTrack1duel = rewind_duel_track1;
	nTrack2duel = rewind_duel_track2;
}

void CL_MultiviewDemoStartRewind (void)
{
	memcpy (rewind_trackslots, mv_trackslots, sizeof (rewind_trackslots));
	rewind_duel_track1 = nTrack1duel;
	rewind_duel_track2 = nTrack2duel;
}

void CL_MultiviewTrackingAdjustment (int adjustment)
{
	nSwapPov = adjustment;
}

void CL_MultiviewInitialise (void)
{
	memset (mv_trackslots, -1, sizeof (mv_trackslots));
}

void CL_TrackMV1_f (void)
{
	CL_Track (MV_VIEW1);
}

void CL_TrackMV2_f (void)
{
	CL_Track (MV_VIEW2);
}
void CL_TrackMV3_f (void)
{
	CL_Track (MV_VIEW3);
}
void CL_TrackMV4_f (void)
{
	CL_Track (MV_VIEW4);
}

void CL_TrackTeam_f (void)
{
	int i, teamchoice, team_slot_count = 0;

	if (cls.state < ca_connected) {
		Com_Printf ("You must be connected to track\n", Cmd_Argv (0));
		return;
	}

	if (!cl.spectator) {
		Com_Printf ("You can only track in spectator mode\n", Cmd_Argv (0));
		return;
	}

	if (Cmd_Argc () != 2) {
		Com_Printf ("Usage: %s < 1 | 2 >\n", Cmd_Argv (0));
		return;
	}

	// Get the team.
	teamchoice = atoi (Cmd_Args ());

	if (!currteam[0]) {
		// Find the the first team.
		for (i = 0; i < MAX_CLIENTS; i++) {
			if (VALID_PLAYER (i) && strcmp (currteam, cl.players[i].team) != 0) {
				strlcpy (currteam, cl.players[i].team, sizeof (currteam));
				break;
			}
		}
	}

	// Find the team members.
	for (i = 0; i < MAX_CLIENTS; i++) {
		// Find the player slot to track.
		if (!cl.players[i].spectator && strcmp (cl.players[i].name, "")
			&& teamchoice == 1 && !strcmp (currteam, cl.players[i].team)) {
			mv_trackslots[team_slot_count] = Player_StringtoSlot (cl.players[i].name, false, false);
			team_slot_count++;
		}
		else if (!cl.players[i].spectator && strcmp (cl.players[i].name, "")
			&& teamchoice == 2 && strcmp (currteam, cl.players[i].team)) {
			mv_trackslots[team_slot_count] = Player_StringtoSlot (cl.players[i].name, false, false);
			team_slot_count++;
		}

		// Don't go out of bounds in the mv_trackslots array.
		if (team_slot_count == 4) {
			break;
		}
	}

	cl_multiview.value = team_slot_count;
}

void CL_MultiviewSetTrackSlot (int trackSlot, int player)
{
	if (trackSlot >= 0 && trackSlot < sizeof (mv_trackslots) / sizeof (mv_trackslots[0])) {
		mv_trackslots[trackSlot] = player;
	}
	else {
		nTrack1duel = player;
		nTrack2duel = CL_NextPlayer (player);
	}
}

void CL_MultiviewPreUpdateScreen (void)
{
	if (!CL_MultiviewCvarResetRequired ()) {
		CL_MultiviewSaveValues ();
	}
	if (CL_MultiviewCvarResetRequired () && !cl_multiview.value) {
		CL_MultiviewRestoreValues ();
	}
}

qbool CL_MultiviewAdvanceView (void)
{
	CL_Multiview ();

	return CURRVIEW > 1;
}

int CL_MultiviewMainView (void)
{
	return nTrack1duel;
}

int CL_MultiviewAutotrackSlot (void)
{
	return CL_MultiviewInsetEnabled () ? nTrack1duel : cl.viewplayernum;
}

qbool CL_MultiviewGetCrosshairCoordinates(qbool use_screen_coords, float* cross_x, float* cross_y, qbool* half_size)
{
	extern vrect_t scr_vrect;

	float x, y;
	float min_x = scr_vrect.x;
	float width = scr_vrect.width;
	float min_y = scr_vrect.y;
	float height = scr_vrect.height;

	if (use_screen_coords) {
		min_x = min_y = 0;
		width = VID_RenderWidth2D();
		height = VID_RenderHeight2D();

		min_y += scr_vrect.y * ((float)height / vid.height);
		height -= (vid.height - scr_vrect.height) * ((float)height / vid.height);
	}

	x = min_x + 0.5 * width;
	y = min_y + 0.5 * height;
	*half_size = false;

	if (CL_MultiviewEnabled()) {
		int active_views = CL_MultiviewActiveViews();

		if (active_views == 2) {
			if (CL_MultiviewInsetEnabled()) {
				// inset
				if (CL_MultiviewInsetView()) {
					if (!cl_mvinsetcrosshair.value) {
						return false;
					}

					x = inset_x + inset_width / 2.0f;
					y = inset_y + inset_height / 2.0f;

					// y is flipped in 2d world...
					y = VID_RenderHeight2D() - y;

					*half_size = true;
				}
			}
			else {
				if (CL_MultiviewCurrentView() == 1)
				{
					x = min_x + width / 2;
					y = min_y + height * 3.0f / 4.0f;
				}
				else if (CL_MultiviewCurrentView() == 2)
				{
					// top cv2
					x = min_x + width / 2;
					y = min_y + height * 1.0f / 4.0f;
				}
				*half_size = true;
			}
		}
		else if (active_views == 3) {
			if (CL_MultiviewCurrentView() == 2) {
				// top
				x = min_x + width / 2;
				y = min_y + height / 4.0f;
			}
			else if (CL_MultiviewCurrentView() == 3) {
				// bl
				x = min_x + width / 4.0f;
				y = min_y + height * 3.0f / 4.0f;
			}
			else {
				// br
				x = min_x + width * 3.0f / 4.0f;
				y = min_y + height * 3.0f / 4.0f;
			}
			*half_size = true;
		}
		else if (active_views >= 4) {
			if (CL_MultiviewCurrentView() == 2) {
				// tl
				x = min_x + width / 4.0f;
				y = min_y + height / 4.0f;
			}
			else if (CL_MultiviewCurrentView() == 3) {
				// tr
				x = min_x + width * 3.0f / 4.0f;
				y = min_y + height / 4.0f;
			}
			else if (CL_MultiviewCurrentView() == 4) {
				// bl
				x = min_x + width / 4.0f;
				y = min_y + height * 3.0f / 4.0f;
			}
			else if (CL_MultiviewCurrentView() == 1) {
				// br
				x = min_x + width * 3.0f / 4.0f;
				y = min_y + height * 3.0f / 4.0f;
			}
			*half_size = true;
		}
	}

	*cross_x = x;
	*cross_y = y;
	return true;
}

void SCR_DrawMultiviewBorders(void)
{
	//
	// Draw black borders around the views.
	//
	if (cl_multiview.integer == 2 && !cl_mvinset.integer) {
		Draw_Fill(0, vid.height / 2, vid.width - 1, 1, 0);
	}
	else if (cl_multiview.integer == 2 && cl_mvinset.integer) {
		extern byte color_black[4];

		R_OrthographicProjection(0, glwidth, 0, glheight, -99999, 99999);
		Draw_AlphaRectangleRGB(inset_x, inset_y, inset_width, inset_height, 1.0f, false, RGBAVECT_TO_COLOR(color_black));
		R_OrthographicProjection(0, vid.width, vid.height, 0, -99999, 99999);
	}
	else if (cl_multiview.integer == 3) {
		Draw_Fill(vid.width / 2, vid.height / 2, 1, vid.height / 2, 0);
		Draw_Fill(0, vid.height / 2, vid.width, 1, 0);
	}
	else if (cl_multiview.integer == 4) {
		Draw_Fill(vid.width / 2, 0, 1, vid.height, 0);
		Draw_Fill(0, vid.height / 2, vid.width, 1, 0);
	}
}

void CL_MultiviewInsetSetScreenCoordinates(int x, int y, int width, int height)
{
	inset_x = x;
	inset_y = y;
	inset_width = width;
	inset_height = height;
}

centity_t* CL_WeaponModelForView(void)
{
	int view = bound(0, CURRVIEW - 1, MV_VIEWS - 1);

	return &cl.viewent[view];
}

void CL_MultiviewInsetRestoreStats(void)
{
	if (cl_multiview.value == 2 && cl_mvinset.integer) {
		memcpy(cl.stats, cl.players[nTrack1duel].stats, sizeof(cl.stats));
	}
}


================================================
FILE: src/cl_nqdemo.c
================================================
/*
Copyright (C) 2011 tonik

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "cdaudio.h"
#include "stats_grid.h"
#include "sbar.h"
#include "qsound.h"
#include "hud.h"
#include "hud_common.h"
#include "vx_stuff.h"
#include "settings.h"
#include "teamplay.h"
#ifdef _WIN32
#include "movie.h"
#endif

#define MAX_BIG_MSGLEN 8000
int CL_Demo_Read(void *buf, int size, qbool peek);
#define SCR_EndLoadingPlaque()
int cl_entframecount;
#define CL_EntityParticles(a)
extern cvar_t cl_rocket2grenade;
#define R_ModelFlags(model) model->flags

void CL_FindModelNumbers (void);
void TP_NewMap (void);
void CL_ParseBaseline (entity_state_t *es);
void CL_ParseStatic (qbool extended);
void CL_ParseStaticSound (void);

#define	NQ_PROTOCOL_VERSION	15

#define	NQ_MAX_CLIENTS	16
#define NQ_SIGNONS		4

#define	NQ_MAX_EDICTS	600			// Must be <= MAX_CL_EDICTS!

// if the high bit of the servercmd is set, the low bits are fast update flags:
#define	NQ_U_MOREBITS	(1<<0)
#define	NQ_U_ORIGIN1	(1<<1)
#define	NQ_U_ORIGIN2	(1<<2)
#define	NQ_U_ORIGIN3	(1<<3)
#define	NQ_U_ANGLE2		(1<<4)
#define	NQ_U_NOLERP		(1<<5)		// don't interpolate movement
#define	NQ_U_FRAME		(1<<6)
#define NQ_U_SIGNAL		(1<<7)		// just differentiates from other updates
#define	NQ_U_ANGLE1		(1<<8)
#define	NQ_U_ANGLE3		(1<<9)
#define	NQ_U_MODEL		(1<<10)
#define	NQ_U_COLORMAP	(1<<11)
#define	NQ_U_SKIN		(1<<12)
#define	NQ_U_EFFECTS	(1<<13)
#define	NQ_U_LONGENTITY	(1<<14)

#define	SU_VIEWHEIGHT	(1<<0)
#define	SU_IDEALPITCH	(1<<1)
#define	SU_PUNCH1		(1<<2)
#define	SU_PUNCH2		(1<<3)
#define	SU_PUNCH3		(1<<4)
#define	SU_VELOCITY1	(1<<5)
#define	SU_VELOCITY2	(1<<6)
#define	SU_VELOCITY3	(1<<7)
//define	SU_AIMENT		(1<<8)  AVAILABLE BIT
#define	SU_ITEMS		(1<<9)
#define	SU_ONGROUND		(1<<10)		// no data follows, the bit is it
#define	SU_INWATER		(1<<11)		// no data follows, the bit is it
#define	SU_WEAPONFRAME	(1<<12)
#define	SU_ARMOR		(1<<13)
#define	SU_WEAPON		(1<<14)

// a sound with no channel is a local only sound
#define	NQ_SND_VOLUME		(1<<0)		// a byte
#define	NQ_SND_ATTENUATION	(1<<1)		// a byte
#define	NQ_SND_LOOPING		(1<<2)		// a long


//=========================================================================================

qbool	nq_drawpings;	// for sbar code

static qbool	nq_player_teleported;	// hacky

static vec3_t	nq_last_fixangle;

static int		nq_num_entities;
static int		nq_viewentity;
static int		nq_forcecdtrack;
static int		nq_signon;
static int		nq_maxclients;
static float	nq_mtime[2];
static vec3_t	nq_mvelocity[2];
static vec3_t	nq_mviewangles[2];
static vec3_t	nq_mviewangles_temp;
static qbool	standard_quake = true;
static demoseekingtype_t nq_lastseektype = DST_SEEKING_NONE;

static void CL_CheckForNQDSeekPointFound(void) 
{
	float demotime = nq_mtime[0];

	// Check for rewind only the first time we want to seek through the demo 
	if (cls.demoseeking != nq_lastseektype)
		CL_Demo_Check_For_Rewind(nq_mtime[0]);
	nq_lastseektype = cls.demoseeking;
		
	if (cls.demoseeking == DST_SEEKING_STATUS)
		CL_Demo_Jump_Status_Check();

	// If we found demomark, we should stop seeking, so reset time to the proper value.
	if (cls.demoseeking == DST_SEEKING_FOUND) 
	{
		extern cvar_t demo_jump_rewind;

		cls.demotime = demotime; // this will trigger seeking stop

		if (demo_jump_rewind.value < 0) {
			CL_Demo_Jump (-demo_jump_rewind.value, -1, DST_SEEKING_NORMAL);
		}
	}

	// If we've reached our seek goal, stop seeking.
	if (cls.demoseeking && cls.demotime <= demotime && cls.state >= ca_active)
	{
		cls.demoseeking = DST_SEEKING_NONE;
		cls.demotime = demotime; 

		if (cls.demorewinding)
		{
			CL_Demo_Stop_Rewinding();
		}
	}
}

static qbool CL_GetNQDemoMessage (void)
{
	int i;
	float f;
	extern qbool pb_ensure(void);

	if(!pb_ensure())
		return false;

	// decide if it is time to grab the next message		
	if (cls.state == ca_active				// always grab until fully connected
		&& !(cl.paused & PAUSED_SERVER))	// or if the game was paused by server
	{
		if (cls.timedemo)
		{
			if (cls.framecount == cls.td_lastframe)
				return false;		// already read this frame's message
			cls.td_lastframe = cls.framecount;
			// if this is the second frame, grab the real td_starttime
			// so the bogus time on the first frame doesn't count
			if (cls.framecount == cls.td_startframe + 1) {
				cls.td_starttime = Sys_DoubleTime();
				key_dest = key_game;
			}
		}
		else if (cl.time <= nq_mtime[0] && ! cls.demoseeking)
			return false;		// don't need another message yet
	}

	// get the next message
	CL_Demo_Read(&net_message.cursize, 4, false);
	for (i=0 ; i<3 ; i++) {
		CL_Demo_Read(&f, 4, false);
		nq_mviewangles_temp[i] = LittleFloat (f);
	}

	net_message.cursize = LittleLong (net_message.cursize);
	if (net_message.cursize > MAX_BIG_MSGLEN)
		Host_Error ("Demo message > MAX_BIG_MSGLEN");

	CL_Demo_Read(net_message.data, net_message.cursize, false);
	return true;
}


static void NQD_BumpEntityCount (int num)
{
	if (num >= nq_num_entities)
		nq_num_entities = num + 1;
}


static void NQD_ParseClientdata (int bits)
{
	int		i, j;
	extern player_state_t view_message;

	if (bits & SU_VIEWHEIGHT)
		cl.stats[STAT_VIEWHEIGHT] = MSG_ReadChar ();
	else
		cl.stats[STAT_VIEWHEIGHT] = DEFAULT_VIEWHEIGHT;

	if (bits & SU_IDEALPITCH)
		MSG_ReadChar ();		// ignore
	
	VectorCopy (nq_mvelocity[0], nq_mvelocity[1]);
	for (i=0 ; i<3 ; i++)
	{
		if (bits & (SU_PUNCH1<<i) ) {
			if (i == 0)
				cl.punchangle = MSG_ReadChar ();
			else
				MSG_ReadChar();			// ignore
		}
		if (bits & (SU_VELOCITY1<<i) )
			nq_mvelocity[0][i] = MSG_ReadChar()*16;
		else
			nq_mvelocity[0][i] = 0;
	}

// [always sent]	if (bits & SU_ITEMS)
	i = MSG_ReadLong ();			// FIXME, check SU_ITEMS anyway? -- Tonik

	if (cl.stats[STAT_ITEMS] != i)
	{	// set flash times
		Sbar_Changed ();
		for (j=0 ; j<32 ; j++)
			if ( (i & (1<<j)) && !(cl.stats[STAT_ITEMS] & (1<<j)))
				cl.item_gettime[j] = cl.time;
		cl.stats[STAT_ITEMS] = i;
	}
		
	cl.onground = (bits & SU_ONGROUND) != 0;
//	cl.inwater = (bits & SU_INWATER) != 0;

	if (bits & SU_WEAPONFRAME)
		view_message.weaponframe = MSG_ReadByte ();
	else
		view_message.weaponframe = 0;

	if (bits & SU_ARMOR)
		i = MSG_ReadByte ();
	else
		i = 0;
	if (cl.stats[STAT_ARMOR] != i)
	{
		cl.stats[STAT_ARMOR] = i;
		Sbar_Changed ();
	}

	if (bits & SU_WEAPON)
		i = MSG_ReadByte ();
	else
		i = 0;
	if (cl.stats[STAT_WEAPON] != i)
	{
		cl.stats[STAT_WEAPON] = i;
		Sbar_Changed ();
	}
	
	i = MSG_ReadShort ();
	if (cl.stats[STAT_HEALTH] != i)
	{
		cl.stats[STAT_HEALTH] = i;
		Sbar_Changed ();
	}

	i = MSG_ReadByte ();
	if (cl.stats[STAT_AMMO] != i)
	{
		cl.stats[STAT_AMMO] = i;
		Sbar_Changed ();
	}

	for (i=0 ; i<4 ; i++)
	{
		j = MSG_ReadByte ();
		if (cl.stats[STAT_SHELLS+i] != j)
		{
			cl.stats[STAT_SHELLS+i] = j;
			Sbar_Changed ();
		}
	}

	i = MSG_ReadByte ();

	if (standard_quake)
	{
		if (cl.stats[STAT_ACTIVEWEAPON] != i)
		{
			cl.stats[STAT_ACTIVEWEAPON] = i;
			Sbar_Changed ();
		}
	}
	else
	{
		if (cl.stats[STAT_ACTIVEWEAPON] != (1<<i))
		{
			cl.stats[STAT_ACTIVEWEAPON] = (1<<i);
			Sbar_Changed ();
		}
	}
}

static void NQD_SetSpectatorFlag(player_info_t* player)
{
	player->spectator = (cl.teamplay && player->name[0] && player->real_topcolor == 0 && player->real_bottomcolor == 0 && player->frags <= -99);
}

void NQD_SetSpectatorFlags(void)
{
	int i;

	for (i = 0; i < sizeof(cl.players) / sizeof(cl.players[0]); ++i)
		NQD_SetSpectatorFlag(&cl.players[i]);
}

/*
==================
NQD_ParseUpdatecolors
==================
*/
static void NQD_ParseUpdatecolors (void)
{
	int	i, colors;
	int top, bottom;
	qbool client_team_changed = false;
	qbool player_skin_changed = false;

	i = MSG_ReadByte ();
	if (i >= nq_maxclients)
		Host_Error ("CL_ParseServerMessage: svc_updatecolors > NQ_MAX_CLIENTS");
	colors = MSG_ReadByte ();

	// fill in userinfo values
	top = min(colors & 15, 13);
	bottom = min((colors >> 4) & 15, 13);

	client_team_changed = (cl.playernum == i && bottom != cl.players[i].real_bottomcolor);
	player_skin_changed = (top != cl.players[i].real_topcolor || bottom != cl.players[i].real_bottomcolor);

	Info_SetValueForKey (cl.players[i].userinfo, "topcolor", va("%i", top), MAX_INFO_KEY);
	Info_SetValueForKey (cl.players[i].userinfo, "bottomcolor", va("%i", bottom), MAX_INFO_KEY);

	cl.players[i].real_topcolor = top;
	cl.players[i].real_bottomcolor = bottom;

	NQD_SetSpectatorFlag(&cl.players[i]);

	// Update team (based on bottom colour)
	if (cl.players[i].spectator)
	{
		Info_SetValueForKey (cl.players[i].userinfo, "team", "", MAX_INFO_KEY);
		strlcpy(cl.players[i].team, "", sizeof(cl.players[i].team));
	}
	else 
	{
		char* bottom_as_string = SettingColorName(bottom); 
		Info_SetValueForKey (cl.players[i].userinfo, "team", bottom_as_string, MAX_INFO_KEY);
		strlcpy(cl.players[i].team, bottom_as_string, sizeof(cl.players[i].team));
	}

	// Update skins
	if (TP_NeedRefreshSkins() && client_team_changed)
		TP_RefreshSkins();
	else if (player_skin_changed)
		TP_RefreshSkin(i);
	Sbar_Changed ();
}

			
/*
==================
NQD_ParsePrint
==================
*/
static void NQD_ParsePrint (void)
{
	extern cvar_t	cl_chatsound;

	char *s = MSG_ReadString();
	if (s[0] == 1) {	// chat
		if (cl_chatsound.value)
			S_LocalSound ("misc/talk.wav");
	}
	Com_Printf ("%s", s);
}


// JPG's ProQuake hacks
static int ReadPQByte (void) {
	int word;
	word = MSG_ReadByte() * 16;
	word += MSG_ReadByte() - 272;
	return word;
}
static int ReadPQShort (void) {
	int word;
	word = ReadPQByte() * 256;
	word += ReadPQByte();
	return word;
}

/*
==================
NQD_ParseStufftext
==================
*/
static void NQD_ParseStufftext (void)
{
	char	*s;
	byte	*p;

	if (msg_readcount + 7 <= net_message.cursize &&
		net_message.data[msg_readcount] == 1 && net_message.data[msg_readcount + 1] == 7)
	{
		int num, ping;
		MSG_ReadByte();
		MSG_ReadByte();
		while ((ping = ReadPQShort()) != 0)
		{
			num = ping / 4096;
			if ((unsigned int)num >= nq_maxclients)
				Host_Error ("Bad ProQuake message");
			cl.players[num].ping = ping & 4095;
			nq_drawpings = true;
		}
		// fall through to stufftext parsing (yes that's how it's intended by JPG)
	}

	s = MSG_ReadString ();
	if (developer.integer > 1) {
		Com_DPrintf("stufftext: %s\n", s);
	}

	for (p = (byte *)s; *p; p++) {
		if (*p > 32 && *p < 128)
			goto ok;
	}
	// ignore weird ProQuake stuff
	return;

ok:
	Cbuf_AddTextEx (&cbuf_svc, s);
}


/*
==================
NQD_ParseServerData
==================
*/
static void NQD_ParseServerData(void)
{
	char	*str;
	int		i;
	int		nummodels, numsounds;
	char	mapname[MAX_QPATH];

	Com_DPrintf("Serverdata packet received.\n");

	// wipe the client_state_t struct
	CL_ClearState();

#ifdef PROTOCOL_VERSION_FTE
	cls.fteprotocolextensions = 0;
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
	cls.fteprotocolextensions2 = 0;
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
	cls.mvdprotocolextensions1 = 0;
#endif

#ifdef FTE_PEXT_FLOATCOORDS
	msg_coordsize = 2;
	msg_anglesize = 1;
#endif

	// parse protocol version number
	i = MSG_ReadLong();
	if (i != NQ_PROTOCOL_VERSION)
		Host_Error("Server returned version %i, not %i", i, NQ_PROTOCOL_VERSION);

	// parse maxclients
	nq_maxclients = MSG_ReadByte();
	if (nq_maxclients < 1 || nq_maxclients > NQ_MAX_CLIENTS)
		Host_Error("Bad maxclients (%u) from server", nq_maxclients);

	// parse gametype
	cl.gametype = MSG_ReadByte() ? GAME_DEATHMATCH : GAME_COOP;

	// parse signon message
	str = MSG_ReadString();
	strlcpy(cl.levelname, str, sizeof(cl.levelname));

	// separate the printfs so the server message can have a color
	Com_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
	Com_Printf("%c%s\n", 2, str);

	//
	// first we go through and touch all of the precache data that still
	// happens to be in the cache, so precaching something else doesn't
	// needlessly purge it
	//

	// precache models
	*mapname = 0;
	for (nummodels = 1; ; nummodels++) {
		str = MSG_ReadString();
		if (!str[0]) {
			break;
		}
		if (nummodels == MAX_MODELS) {
			Host_Error("Server sent too many model precaches");
		}
		strlcpy(cl.model_name[nummodels], str, sizeof(cl.model_name[0]));
		Mod_TouchModel(str);

		if (nummodels == 1) {
			COM_StripExtension(COM_SkipPath(cl.model_name[1]), mapname, sizeof(mapname));
		}
	}

	// precache sounds
	for (numsounds = 1; ; numsounds++) {
		str = MSG_ReadString();
		if (!str[0]) {
			break;
		}
		if (numsounds == MAX_SOUNDS) {
			Host_Error("Server sent too many sound precaches");
		}
		strlcpy(cl.sound_name[numsounds], str, sizeof(cl.sound_name[0]));
		// S_TouchSound (str); @ZQ@
	}

	// now we try to load everything else until a cache allocation fails
	cl.clipmodels[1] = CM_LoadMap(cl.model_name[1], true, NULL, &cl.map_checksum2);
	if (!com_serveractive) {
		Cvar_ForceSet(&host_mapname, mapname);
	}
	COM_StripExtension(COM_SkipPath(cl.model_name[1]), mapname, sizeof(mapname));
	cl.map_checksum2 = Com_TranslateMapChecksum(mapname, cl.map_checksum2);

	for (i = 1; i < nummodels; i++) {
		cl.model_precache[i] = Mod_ForName(cl.model_name[i], false);
		if (cl.model_precache[i] == NULL) {
			Host_Error("Model %s not found", cl.model_name[i]);
		}

		if (cl.model_name[i][0] == '*') {
			cl.clipmodels[i] = CM_InlineModel(cl.model_name[i]);
		}
	}

	for (i = 1; i < numsounds; i++) {
		cl.sound_precache[i] = S_PrecacheSound(cl.sound_name[i]);
	}

	// local state
	cl.worldmodel = cl.model_precache[1];
	if (!cl.model_precache[1]) {
		Host_Error("NQD_ParseServerData: NULL worldmodel");
	}

	Classic_InitParticles();
	CL_FindModelNumbers();
	R_NewMap(false);
	TP_NewMap();
	MT_NewMap();
	Stats_NewMap();

	// Reset the status grid.
	StatsGrid_Remove(&stats_grid);
	StatsGrid_ResetHoldItems();
	HUD_NewMap();

	Hunk_Check(); // make sure nothing is hurt

	nq_signon = 0;
	nq_num_entities = 0;
	nq_drawpings = false; // unless we have the ProQuake extension
	cl.servertime_works = true;
	//	cl.allow_fbskins = true; @ZQ@
	cls.state = ca_onserver;
	CL_Demo_Check_For_Rewind(nq_mtime[0]);

	// Demos don't store this so we set from user-defined option
	cl.teamplay = cl_demoteamplay.integer;

	nq_lastseektype = DST_SEEKING_NONE;
}

/*
==================
NQD_ParseStartSoundPacket
==================
*/
static void NQD_ParseStartSoundPacket(void)
{
    vec3_t  pos;
    int 	channel, ent;
    int 	sound_num;
    int 	volume;
    int 	field_mask;
    float 	attenuation;  
 	int		i;
	           
    field_mask = MSG_ReadByte(); 

    if (field_mask & NQ_SND_VOLUME)
		volume = MSG_ReadByte ();
	else
		volume = DEFAULT_SOUND_PACKET_VOLUME;
	
    if (field_mask & NQ_SND_ATTENUATION)
		attenuation = MSG_ReadByte () / 64.0;
	else
		attenuation = DEFAULT_SOUND_PACKET_ATTENUATION;
	
	channel = MSG_ReadShort ();
	sound_num = MSG_ReadByte ();

	ent = channel >> 3;
	channel &= 7;

	if (ent > NQ_MAX_EDICTS)
		Host_Error ("NQD_ParseStartSoundPacket: ent = %i", ent);
	
	for (i=0 ; i<3 ; i++)
		pos[i] = MSG_ReadCoord ();
 
    S_StartSound (ent, channel, cl.sound_precache[sound_num], pos, volume/255.0, attenuation);
}       


/*
===============
CL_ParseParticleEffect

Back from NetQuake
===============
*/
static void CL_ParseParticleEffect (void)
{
	vec3_t		org, dir;
	int			i, count, color;

	for (i = 0; i < 3; i++)
		org[i] = MSG_ReadCoord ();
	for (i = 0; i < 3; i++)
		dir[i] = MSG_ReadChar () * (1.0/16);
	count = MSG_ReadByte ();
	color = MSG_ReadByte ();

	// now run the effect
	if (count == 255)
		Classic_ParticleExplosion (org);
	else 
		R_RunParticleEffect (org, dir, color, count);
}

/*
==================
NQD_ParseUpdate

Parse an entity update message from the server
If an entities model or origin changes from frame to frame, it must be
relinked.  Other attributes can change without relinking.
==================
*/
static void NQD_ParseUpdate (int bits)
{
	int			i;
//	model_t		*model;
	int			modnum;
	qbool		forcelink;
	centity_t	*ent;
	entity_state_t	*state;
	int			num;
	int prev_frame;

	if (nq_signon == NQ_SIGNONS - 1)
	{	// first update is the final signon stage
		nq_signon = NQ_SIGNONS;
		Con_ClearNotify ();
		//TP_ExecTrigger ("f_spawn");
		SCR_EndLoadingPlaque ();
		cls.state = ca_active;
		CL_Demo_Check_For_Rewind(nq_mtime[0]);
	}

	if (bits & NQ_U_MOREBITS)
	{
		i = MSG_ReadByte ();
		bits |= (i<<8);
	}

	if (bits & NQ_U_LONGENTITY)	
		num = MSG_ReadShort ();
	else
		num = MSG_ReadByte ();

	if (num >= NQ_MAX_EDICTS)
		Host_Error ("NQD_ParseUpdate: ent > MAX_EDICTS");

	NQD_BumpEntityCount (num);

	ent = &cl_entities[num];
//##	ent->previous = ent->current;
	VectorCopy (ent->current.origin, ent->old_origin);	//##
	VectorCopy (ent->current.angles, ent->old_angles);	//##
	prev_frame = ent->current.frame;
	ent->current = ent->baseline;
	state = &ent->current;
	state->number = num;

	if (ent->sequence != cl_entframecount - 1)
		forcelink = true;	// no previous frame to lerp from
	else
		forcelink = false;
	ent->oldsequence = ent->sequence;
	ent->sequence = cl_entframecount;
	
	if (bits & NQ_U_MODEL)
	{
		modnum = MSG_ReadByte ();
		if (modnum >= MAX_MODELS)
			Host_Error ("CL_ParseModel: bad modnum");
	}
	else
		modnum = ent->baseline.modelindex;
		
//	model = cl.model_precache[modnum];
	if (modnum != state->modelindex)
	{
		state->modelindex = modnum;
		// automatic animation (torches, etc) can be either all together
		// or randomized
		if (modnum)
		{
			/*if (model->synctype == ST_RAND)
				state->syncbase = (float)(rand()&0x7fff) / 0x7fff;
			else
				state->syncbase = 0.0;
				*/
		}
		else
			forcelink = true;	// hack to make null model players work
	}
	
	if (bits & NQ_U_FRAME)
		state->frame = MSG_ReadByte ();
	else
		state->frame = ent->baseline.frame;

	if (bits & NQ_U_COLORMAP)
		i = MSG_ReadByte();
	else
		i = ent->baseline.colormap;

	state->colormap = i;

	if (bits & NQ_U_SKIN)
		state->skinnum = MSG_ReadByte();
	else
		state->skinnum = ent->baseline.skinnum;

	if (bits & NQ_U_EFFECTS)
		state->effects = MSG_ReadByte();
	else
		state->effects = 0;

	if (bits & NQ_U_ORIGIN1)
		state->origin[0] = MSG_ReadCoord ();
	else
		state->origin[0] = ent->baseline.origin[0];
	if (bits & NQ_U_ANGLE1)
		state->angles[0] = MSG_ReadAngle ();
	else
		state->angles[0] = ent->baseline.angles[0];

	if (bits & NQ_U_ORIGIN2)
		state->origin[1] = MSG_ReadCoord ();
	else
		state->origin[1] = ent->baseline.origin[1];
	if (bits & NQ_U_ANGLE2)
		state->angles[1] = MSG_ReadAngle ();
	else
		state->angles[1] = ent->baseline.angles[1];

	if (bits & NQ_U_ORIGIN3)
		state->origin[2] = MSG_ReadCoord ();
	else
		state->origin[2] = ent->baseline.origin[2];
	if (bits & NQ_U_ANGLE3)
		state->angles[2] = MSG_ReadAngle ();
	else
		state->angles[2] = ent->baseline.angles[2];

	if ( bits & NQ_U_NOLERP )
		forcelink = true;

	if (state->frame != prev_frame) {
		ent->frametime = cl.time;
		ent->oldframe = prev_frame;
	}
	
	if ( forcelink )
	{	// didn't have an update last message
		VectorCopy (state->origin, ent->old_origin);
		VectorCopy (state->origin, ent->lerp_origin);
		VectorCopy (state->angles, ent->old_angles);
//we get U_NOLERP for monsters, but we want to lerp them	ent->frametime = -1;
		//ent->forcelink = true;
	}
}


/*
===============
NQD_LerpPoint

Determines the fraction between the last two messages that the objects
should be put at.
===============
*/
static float NQD_LerpPoint (void)
{
	float	f, frac;

	f = nq_mtime[0] - nq_mtime[1];
	
	if (!f || /* cl_nolerp.value || */ cls.timedemo) {
		cl.time = nq_mtime[0];
		return 1;
	}
		
	if (f > 0.1)
	{	// dropped packet, or start of demo
		nq_mtime[1] = nq_mtime[0] - 0.1;
		f = 0.1;
	}
	frac = (cl.time - nq_mtime[1]) / f;
	if (frac < 0)
	{
		if (frac < -0.01)
			cl.time = nq_mtime[1];
		frac = 0;
	}
	else if (frac > 1)
	{
		if (frac > 1.01)
			cl.time = nq_mtime[0];
		frac = 1;
	}
		
	return frac;
}

static void NQD_LerpPlayerinfo (float f)
{
	if (cl.intermission) {
		// just stay there
		return;
	}

	if (nq_player_teleported) {
		VectorCopy (nq_mvelocity[0], cl.simvel);
		VectorCopy (nq_mviewangles[0], cl.viewangles);
		VectorCopy (nq_mviewangles[0], cl.simangles);
		return;
	}

	VectorInterpolate (nq_mvelocity[1], f, nq_mvelocity[0], cl.simvel);
	AngleInterpolate (nq_mviewangles[1], f, nq_mviewangles[0], cl.simangles);
	VectorCopy (cl.simangles, cl.viewangles);
}

static int NQD_FirstPersonCamera(void)
{
	extern cvar_t cam_thirdperson, cl_camera_tpp;

	return !cam_thirdperson.integer && !cl_camera_tpp.integer;
}

void NQD_LinkEntities (void)
{
	entity_t            ent;
	centity_t*          cent;
	entity_state_t*     state;
	float               f;
	struct model_s*     model;
	int                 modelflags;
	vec3_t              cur_origin;
	float               autorotate;
	int                 i, num;
	customlight_t       cst_lt = { 0 };
	float               flicker = (r_lightflicker.integer ? rand() & 31 : 0);

	f = NQD_LerpPoint ();

	NQD_LerpPlayerinfo (f);

	autorotate = anglemod (100*cl.time);

	memset (&ent, 0, sizeof(ent));

	for (num = 1; num < nq_num_entities; num++)
	{
		cent = &cl_entities[num];
		state = &cent->current;

		if (cent->sequence != cl_entframecount)
			continue;		// not present in this frame

		VectorCopy (state->origin, cur_origin);
		if (state->effects & EF_BRIGHTFIELD) {
			CL_EntityParticles(cur_origin);
		}

		// spawn light flashes, even ones coming from invisible objects
		if (state->effects & EF_MUZZLEFLASH) {
			vec3_t		angles, forward;
			dlight_t	*dl;

			dl = CL_AllocDlight (-num);
			VectorCopy (state->angles, angles);
			AngleVectors (angles, forward, NULL, NULL);
			VectorMA (cur_origin, 18, forward, dl->origin);
			dl->origin[2] += 16;
			dl->radius = 200 + flicker;
			dl->minlight = 32;
			dl->die = cl.time + 0.1;
			dl->type = lt_muzzleflash;
		}
		if (state->effects & EF_BRIGHTLIGHT) {
			if (state->modelindex != cl_modelindices[mi_player] || r_powerupglow.integer) {
				vec3_t	tmp;
				VectorCopy (cur_origin, tmp);
				tmp[2] += 16;
				CL_NewDlight(state->number, cur_origin, 400 + flicker, 0.1, lt_default, 0);
			}
		}
		if (state->effects & EF_DIMLIGHT) {
			if (state->modelindex != cl_modelindices[mi_player] || r_powerupglow.integer) {
				CL_NewDlight(state->number, cur_origin, 200 + flicker, 0.1, lt_default, 0);
			}
		}

		// if set to invisible, skip
		if (!state->modelindex) {
			continue;
		}

		cent->current = *state;

		ent.model = model = cl.model_precache[state->modelindex];
		if (!model) {
			Host_Error("CL_LinkPacketEntities: bad modelindex");
		}

		if (cl_rocket2grenade.value && cl_modelindices[mi_grenade] != -1) {
			if (state->modelindex == cl_modelindices[mi_rocket]) {
				ent.model = cl.model_precache[cl_modelindices[mi_grenade]];
			}
		}

		modelflags = R_ModelFlags (model);

		// rotate binary objects locally
		if (modelflags & EF_ROTATE) {
			ent.angles[0] = 0;
			ent.angles[1] = autorotate;
			ent.angles[2] = 0;
		}
		else {
			AngleInterpolate(cent->old_angles, f, cent->current.angles, ent.angles);
		}

		// calculate origin
		for (i = 0; i < 3; i++) {
			if (fabs(cent->current.origin[i] - cent->old_origin[i]) > 128.0f) {
				// teleport or something, don't lerp
				VectorCopy(cur_origin, ent.origin);
				if (num == nq_viewentity) {
					nq_player_teleported = true;
				}
				break;
			}
			ent.origin[i] = cent->old_origin[i] + f * (cur_origin[i] - cent->old_origin[i]);
		}

		if (num == nq_viewentity) {
			VectorCopy (ent.origin, cent->lerp_origin);	// FIXME?

			if (!cls.nqdemoplayback || NQD_FirstPersonCamera()) {
				continue;			// player entity
			}
		}

		if (cl_deadbodyfilter.value && state->modelindex == cl_modelindices[mi_player]
			&& ( (i=state->frame)==49 || i==60 || i==69 || i==84 || i==93 || i==102) )
			continue;

		if (cl_gibfilter.value &&
			(state->modelindex == cl_modelindices[mi_h_player] || state->modelindex == cl_modelindices[mi_gib1]
			|| state->modelindex == cl_modelindices[mi_gib2] || state->modelindex == cl_modelindices[mi_gib3]))
			continue;

		// set colormap
		if (state->colormap && state->colormap <= MAX_CLIENTS
			&& state->modelindex == cl_modelindices[mi_player]
		) 
		{
			ent.colormap = cl.players[state->colormap-1].translations;
			ent.scoreboard = &cl.players[state->colormap-1];
		}
		else
		{
			ent.colormap = vid.colormap;
			ent.scoreboard = NULL;
		}

		// set skin
		ent.skinnum = state->skinnum;

		// set frame
		ent.frame = state->frame;
		if (cent->frametime >= 0 && cent->frametime <= cl.time) {
			ent.oldframe = cent->oldframe;
			ent.framelerp = (cl.time - cent->frametime) * 10;
		}
		else {
			ent.oldframe = ent.frame;
			ent.framelerp = -1;
		}
		
		// add automatic particle trails
		if ((modelflags & ~EF_ROTATE)) {
			CL_AddParticleTrail(&ent, cent, &cst_lt, state);
		}

		VectorCopy(ent.origin, cent->lerp_origin);
		cent->sequence = cl_entframecount;
		CL_AddEntity(&ent);
	}

	if (nq_viewentity == 0) {
		Host_Error("viewentity == 0");
	}
	VectorCopy(cl_entities[nq_viewentity].lerp_origin, cl.simorg);
}





extern char *svc_strings[];
extern const int num_svc_strings;

#define SHOWNET(x) {if(cl_shownet.value==2)Com_Printf ("%3i:%s\n", msg_readcount-1, x);}

static void NQD_ParseServerMessage (void)
{
	int		cmd;
	int		i;
	qbool	message_with_datagram;		// hack to fix glitches when receiving a packet
											// without a datagram

	nq_player_teleported = false;		// OMG, it's a hack!
	message_with_datagram = false;
	cl_entframecount++;

	if (cl_shownet.value == 1)
		Com_Printf ("%i ", net_message.cursize);
	else if (cl_shownet.value == 2)
		Com_Printf ("------------------\n");
	
	cl.onground = false;	// unless the server says otherwise	

//
// parse the message
//
	MSG_BeginReading ();
	while (1)
	{
		if (msg_badread)
			Host_Error ("CL_ParseServerMessage: Bad server message");

		cmd = MSG_ReadByte ();

		if (cmd == -1)
		{
			SHOWNET("END OF MESSAGE");
			if (!message_with_datagram) {
				cl_entframecount--;
			}
			else
			{
				VectorCopy (nq_mviewangles[0], nq_mviewangles[1]);
				VectorCopy (nq_mviewangles_temp, nq_mviewangles[0]);
			}
			return;		// end of message
		}

	// if the high bit of the command byte is set, it is a fast update
		if (cmd & 128)
		{
			SHOWNET("fast update");
			NQD_ParseUpdate (cmd&127);
			continue;
		}

		if (cmd < num_svc_strings)
			SHOWNET(svc_strings[cmd]);
	
	// other commands
		switch (cmd)
		{
		default:
			Host_Error ("CL_ParseServerMessage: Illegible server message (cmd %i)\n", cmd);
			break;

		case svc_nop:
			break;

		case nq_svc_time:
			nq_mtime[1] = nq_mtime[0];
			nq_mtime[0] = MSG_ReadFloat ();
			cl.servertime = nq_mtime[0];
			CL_CheckForNQDSeekPointFound();
			if (demostarttime <= 0) 
				demostarttime = nq_mtime[0];
			if (cls.demotime < demostarttime) 
				cls.demotime = demostarttime;
			message_with_datagram = true;
			break;

		case nq_svc_clientdata:
			i = MSG_ReadShort ();
			NQD_ParseClientdata (i);
			break;

		case nq_svc_version:
			i = MSG_ReadLong ();
			if (i != NQ_PROTOCOL_VERSION)
				Host_Error ("CL_ParseServerMessage: Server is protocol %i instead of %i\n", i, NQ_PROTOCOL_VERSION);
			break;

		case svc_disconnect:
			Com_Printf ("\n======== End of demo ========\n\n");
//##			CL_NextDemo ();
			Host_EndGame ();
			Host_Abort ();
			break;

		case svc_print:
			NQD_ParsePrint ();
			break;
			
		case svc_centerprint:
			SCR_CenterPrint (MSG_ReadString ());
			break;

		case svc_stufftext:
			NQD_ParseStufftext ();
			break;

		case svc_damage:
			V_ParseDamage ();
			break;

		case svc_serverdata:
			NQD_ParseServerData ();
			break;

		case svc_setangle:
			for (i=0 ; i<3 ; i++)
				nq_last_fixangle[i] = cl.simangles[i] = cl.viewangles[i] = MSG_ReadAngle ();
			break;

		case nq_svc_setview:
			nq_viewentity = MSG_ReadShort ();
			if (nq_viewentity <= nq_maxclients)
				cl.playernum = nq_viewentity - 1;
			else	{
				// just let cl.playernum stay where it was
			}
			break;

		case svc_lightstyle:
			i = MSG_ReadByte ();
			if (i >= MAX_LIGHTSTYLES)
				Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
			strlcpy (cl_lightstyle[i].map,  MSG_ReadString(), sizeof(cl_lightstyle[0].map));
			cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
			break;

		case svc_sound:
			NQD_ParseStartSoundPacket();
			break;

		case svc_stopsound:
			i = MSG_ReadShort();
			S_StopSound(i>>3, i&7);
			break;

		case nq_svc_updatename:
			Sbar_Changed ();
			i = MSG_ReadByte ();
			if (i >= nq_maxclients)
				Host_Error ("CL_ParseServerMessage: svc_updatename > NQ_MAX_CLIENTS");
			strlcpy (cl.players[i].name, MSG_ReadString(), sizeof(cl.players[i].name));
			break;

		case svc_updatefrags:
			Sbar_Changed ();
			i = MSG_ReadByte ();
			if (i >= nq_maxclients)
				Host_Error ("CL_ParseServerMessage: svc_updatefrags > NQ_MAX_CLIENTS");
			cl.players[i].frags = MSG_ReadShort();
			break;

		case nq_svc_updatecolors:
			NQD_ParseUpdatecolors ();
			break;
			
		case nq_svc_particle:
			CL_ParseParticleEffect ();
			break;

		case svc_spawnbaseline:
			i = MSG_ReadShort ();
			if (i >= NQ_MAX_EDICTS)
				Host_Error ("svc_spawnbaseline: ent > MAX_EDICTS");
			NQD_BumpEntityCount (i);
			CL_ParseBaseline (&cl_entities[i].baseline);
			break;
		case svc_spawnstatic:
			CL_ParseStatic (false);
			break;
		case svc_temp_entity:
			CL_ParseTEnt ();
			break;

		case svc_setpause:
			if (MSG_ReadByte() != 0)
				cl.paused |= PAUSED_SERVER;
			else
				cl.paused &= ~PAUSED_SERVER;

			if (ISPAUSED)
				CDAudio_Pause ();
			else
				CDAudio_Resume ();
			break;

		case nq_svc_signonnum:
			i = MSG_ReadByte ();
			if (i <= nq_signon)
				Host_Error ("Received signon %i when at %i", i, nq_signon);
			nq_signon = i;
			break;

		case svc_killedmonster:
			cl.stats[STAT_MONSTERS]++;
			break;

		case svc_foundsecret:
			cl.stats[STAT_SECRETS]++;
			break;

		case svc_updatestat:
			i = MSG_ReadByte ();
			if (i < 0 || i >= MAX_CL_STATS)
				Sys_Error ("svc_updatestat: %i is invalid", i);
			cl.stats[i] = MSG_ReadLong ();;
			break;

		case svc_spawnstaticsound:
			CL_ParseStaticSound ();
			break;

		case svc_cdtrack:
			cl.cdtrack = MSG_ReadByte ();
			MSG_ReadByte();		// loop track (unused)
			if (nq_forcecdtrack != -1)
				CDAudio_Play ((byte)nq_forcecdtrack, true);
			else
				CDAudio_Play ((byte)cl.cdtrack, true);
			break;

		case svc_intermission:
			cl.intermission = 1;
			cl.completed_time = cl.time;
			cl.solo_completed_time = cl.servertime;
			VectorCopy (nq_last_fixangle, cl.simangles);
			break;

		case svc_finale:
			cl.intermission = 2;
			cl.completed_time = cl.time;
			cl.solo_completed_time = cl.servertime;
			SCR_CenterPrint (MSG_ReadString ());
			VectorCopy (nq_last_fixangle, cl.simangles);
			break;

		case nq_svc_cutscene:
			cl.intermission = 3;
			cl.completed_time = cl.time;
			cl.solo_completed_time = cl.servertime;
			SCR_CenterPrint (MSG_ReadString ());
			VectorCopy (nq_last_fixangle, cl.simangles);
			break;

		case svc_sellscreen:
			break;
		}
	}
}


void NQD_ReadPackets (void)
{
	extern qbool	host_skipframe;

	while (CL_GetNQDemoMessage()) {
		NQD_ParseServerMessage();
	}
	
	CL_SetSolidEntities();

	// If we're seeking, demotime is set to the target time: stop demotime from being advanced as normal
	if (cls.demoseeking)
		host_skipframe = true;
}


void NQD_StartPlayback (void)
{
	byte	c;
	qbool	neg = false;

	extern qbool pb_ensure(void);

	pb_ensure(); // FIXME: zzzz, is it possible to put "track parsing" somewhere in CL_GetNQDemoMessage() ????

	// parse forced cd track
	for (c = 0; c != '\n'; ) {
		CL_Demo_Read(&c, 1, false);

		if (c == '-')
			neg = true;
		else
			nq_forcecdtrack = nq_forcecdtrack * 10 + (c - '0');
	}
	if (neg)
		nq_forcecdtrack = -nq_forcecdtrack;

	cl.spectator = false;
	nq_signon = 0;
	nq_mtime[0] = 0;
	nq_maxclients = 0;
	cl_entframecount = 0;
}


================================================
FILE: src/cl_parse.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: cl_parse.c,v 1.135 2007-10-28 19:56:44 qqshka Exp $
*/

#include "quakedef.h"
#include "gl_model.h"
#include "cdaudio.h"
#include "ignore.h"
#include "fchecks.h"
#include "config_manager.h"
#include "utils.h"
#include "localtime.h"
#include "sbar.h"
#include "textencoding.h"
#include "vx_stuff.h"
#include "gl_model.h"
#include "teamplay.h"
#include "tp_triggers.h"
#include "pmove.h"
#include "stats_grid.h"
#include "qsound.h"
#include "menu.h"
#include "keys.h"
#include "hud.h"
#include "hud_common.h"
#include "mvd_utils.h"
#include "input.h"
#include "qtv.h"
#include "r_brushmodel_sky.h"
#include "demo_spawnwarn.h"
#include "central.h"

int CL_LoginImageId(const char* name);

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
void IN_ServerSideWeaponSelectionResponse(const char* s);
#endif

#ifdef MVD_PEXT1_HIDDEN_MESSAGES
static void CL_ParseAntilagPosition(int size);
static void CL_ParseDemoInfo(int size);
static void CL_ParseDemoWeapon(int size, qbool server_side);
static void CL_ParseDamageDone(int size);
static void CL_ParseDemoWeaponInstruction(int size);
static void CL_ParseUserCommand(int size);
#endif // MVD_PEXT1_HIDDEN_MESSAGES

void R_TranslatePlayerSkin (int playernum);

char *svc_strings[] = {
	"svc_bad",
	"svc_nop",
	"svc_disconnect",
	"svc_updatestat",
	"svc_version",		// [long] server version
	"svc_setview",		// [short] entity number
	"svc_sound",		// <see code>
	"svc_time",			// [float] server time
	"svc_print",		// [string] null terminated string
	"svc_stufftext",	// [string] stuffed into client's console buffer
						// the string should be \n terminated
	"svc_setangle",		// [vec3] set the view angle to this absolute value

	"svc_serverdata",	// [long] version ...
	"svc_lightstyle",	// [byte] [string]
	"svc_updatename",	// [byte] [string]
	"svc_updatefrags",	// [byte] [short]
	"svc_clientdata",	// <shortbits + data>
	"svc_stopsound",	// <see code>
	"svc_updatecolors",	// [byte] [byte]
	"svc_particle",		// [vec3] <variable>
	"svc_damage",		// [byte] impact [byte] blood [vec3] from

	"svc_spawnstatic",
	"OBSOLETE svc_spawnbinary",
	"svc_spawnbaseline",

	"svc_temp_entity",	// <variable>
	"svc_setpause",
	"svc_signonnum",
	"svc_centerprint",
	"svc_killedmonster",
	"svc_foundsecret",
	"svc_spawnstaticsound",
	"svc_intermission",
	"svc_finale",

	"svc_cdtrack",
	"svc_sellscreen",

	"svc_smallkick",
	"svc_bigkick",

	"svc_updateping",
	"svc_updateentertime",

	"svc_updatestatlong",
	"svc_muzzleflash",
	"svc_updateuserinfo",
	"svc_download",
	"svc_playerinfo",
	"svc_nails",
	"svc_choke",
	"svc_modellist",
	"svc_soundlist",
	"svc_packetentities",
 	"svc_deltapacketentities",
	"svc_maxspeed",
	"svc_entgravity",

	"svc_setinfo",
	"svc_serverinfo",
	"svc_updatepl",
	"svc_nails2",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL",
	"NEW PROTOCOL"
};

const int num_svc_strings = sizeof(svc_strings)/sizeof(svc_strings[0]);

//=========================================================
// Cl_Messages, just some simple network statistics/profiling
//=========================================================

#define NUMMSG 256 // for svc_xxx used one byte, so its in range...

typedef struct cl_message_s
{
	int msgs;
	int size;

	int svc; // well, its helpful after qsort
} cl_message_t;

static cl_message_t cl_messages[NUMMSG];

static void CL_Messages_f(void);
static void CL_InitialiseDemoMessageIfRequired(void);

void Cl_Messages_Init(void)
{
	int i;

	memset(cl_messages, 0, sizeof(cl_messages));

	for (i = 0; i < NUMMSG; i++)
		cl_messages[i].svc = i; // well, its helpful after qsort

	Cmd_AddCommand ("cl_messages", CL_Messages_f);
}

static int CL_Messages_qsort(const void *a, const void *b)
{
	cl_message_t *msg1 = (cl_message_t*)a;
	cl_message_t *msg2 = (cl_message_t*)b;

	if ( msg1->size < msg2->size )
		return -1;

	if ( msg1->size > msg2->size )
		return 1;

   return 0;
}

static void CL_Messages_f(void)
{
	cl_message_t messages[NUMMSG]; // local copy of cl_messages[] for qsorting

	int i, svc, total;
	char *svc_name;

	memcpy(messages, cl_messages, sizeof(messages)); // copy it
	qsort(messages, NUMMSG, sizeof(messages[0]), CL_Messages_qsort); // qsort it

	Com_Printf("Received msgs:\n");

	for (i = 0, total = 0; i < NUMMSG; i++)
	{
		if (messages[i].msgs < 1)
			continue;

		svc = messages[i].svc;

		if (svc < 0 || svc >= NUMMSG) {
			Sys_Error("CL_Messages_f: svc < 0 || svc >= NUMMSG");
			return;
		}

		svc_name = ( svc < num_svc_strings ? svc_strings[svc] : "unknown" );

		Com_Printf("%2d:%s: %d msgs: %0.2fk\n", svc, svc_name, messages[i].msgs, (float)(messages[i].size)/1024);

		total += messages[i].size;
	}

	Com_Printf("Total size: %d\n", total);
}

//=============================================================================

packet_info_t network_stats[NETWORK_STATS_SIZE];

int packet_latency[NET_TIMINGS];

int CL_CalcNet (void) 
{
	int a, i, j, lost, packetcount;
	frame_t	*frame;

	static cvar_t * netgraph_inframes = NULL;
	extern hud_t * hud_netgraph;

	static int last_calculated_outgoing;
	static int last_calculated_incoming;
	static int last_lost;

	if (last_calculated_incoming == cls.netchan.incoming_sequence  &&
	    last_calculated_outgoing == cls.netchan.outgoing_sequence)
		return last_lost;

	last_calculated_outgoing = cls.netchan.outgoing_sequence;
	last_calculated_incoming = cls.netchan.incoming_sequence;

	if (netgraph_inframes == NULL)
	    netgraph_inframes = HUD_FindVar(hud_netgraph, "inframes");

	for (i = cls.netchan.outgoing_sequence-UPDATE_BACKUP + 1; i <= cls.netchan.outgoing_sequence; i++) 
	{
		frame = &cl.frames[i & UPDATE_MASK];
	        j = i & NETWORK_STATS_MASK;
		if (frame->receivedtime == -1)
		{
			packet_latency[i & NET_TIMINGSMASK] = 9999;	// dropped
			network_stats[j].status = packet_dropped;
		}
		else if (frame->receivedtime == -2) 
		{
			packet_latency[i & NET_TIMINGSMASK] = 10000;	// choked
			network_stats[j].status = packet_choked;
		}
		else if (frame->receivedtime == -3)
		{
			packet_latency[i & NET_TIMINGSMASK] = -1;	// choked by c2spps
			network_stats[j].status = packet_netlimit;
		}
		else if (frame->invalid) 
		{
			packet_latency[i & NET_TIMINGSMASK] = 9998;	// invalid delta
			network_stats[j].status = packet_delta;
		}
		else 
		{
			double l;
			if (netgraph_inframes->value)      // [frames]
				l = 2*(frame->seq_when_received-i);
			else                                // [miliseconds]
				l = min((frame->receivedtime - frame->senttime)*1000, 1000);

			packet_latency[i&NET_TIMINGSMASK] = (int)l;
			network_stats[j].status = packet_ok;
		}
	}

	lost = packetcount = 0;
	for (a = 0; a < NET_TIMINGS; a++)	
	{
		// fix for packetloss on high ping
		if (a < UPDATE_BACKUP && (cls.realtime -
			cl.frames[(cls.netchan.outgoing_sequence-a)&UPDATE_MASK].senttime) < cls.latency)
			continue;

		i = (cls.netchan.outgoing_sequence-a) & NET_TIMINGSMASK;
		if (packet_latency[i] == 9999)
			lost++;
		if (packet_latency[i] != -1)	// don't count packets choked by c2spps
			packetcount++;
	}
	last_lost = packetcount ? lost * 100 / packetcount : 100;
	return last_lost;
}

// More network statistics
int CL_CalcNetStatistics(
            /* in */
            float period,           // period of time
            packet_info_t *samples, // statistics table
            int num_samples,        // table size
            /* out */
            net_stat_result_t *res)
{
    int i, p, q;   // calc fom p to q

    float ping_min, ping_max, ping_avg, ping_dev, ping_sum, ping_dev_sum;
    float f_min, f_max, f_avg, f_dev, f_sum, f_dev_sum;
    int lost_lost, lost_rate, lost_delta, lost_netlimit;
    int size_sent, size_received;
    int samples_received, samples_sent, samples_delta;

    if (cls.netchan.outgoing_sequence - cls.netchan.incoming_sequence  >  NETWORK_STATS_SIZE/2)
        return (res->samples = 0);

    // find boundaries
    q = cls.netchan.incoming_sequence - 1;
    p = q - 1;
    while (p > cls.netchan.outgoing_sequence - NETWORK_STATS_SIZE + 1  &&
           samples[q&NETWORK_STATS_MASK].senttime - samples[p&NETWORK_STATS_MASK].senttime < period)
	{
        p--;
	}

    // init values
    samples_sent = 0;
    samples_received = 0;
    samples_delta = 0;  // packets with delta compression applied

    ping_sum = 0;
    ping_min =  99999999;
    ping_max = -99999999;
    ping_dev_sum = 0;

    f_sum = 0;
    f_min =  99999999;
    f_max = -99999999;
    f_dev_sum = 0;

    lost_lost = 0;
    lost_rate = 0;
    lost_netlimit = 0;
    lost_delta = 0;

    size_sent = 0;
    size_received = 0;

    for (i=p; i < q; i++)
    {
        int a = i & NETWORK_STATS_MASK;

        if (samples[a].status == packet_netlimit)
        {
            // not even sent
            lost_netlimit++;
            continue;
        }

        // packet was sent
        samples_sent++;

        size_sent += samples[a].sentsize;

        switch (samples[a].status)
        {
			case packet_delta:
				lost_delta++;
				samples_delta++;
				break;
			case packet_choked:
				lost_rate++;
				break;
			case packet_dropped:
				lost_lost++;
				break;
			case packet_ok:
				// packet received
				{
					float ping;
					int frames;

					samples_received++;
					frames = samples[a].seq_diff;
					ping = 1000*(samples[a].receivedtime - samples[a].senttime);

					if (ping < ping_min)    ping_min = ping;
					if (ping > ping_max)    ping_max = ping;
					if (frames < f_min)     f_min = frames;
					if (frames > f_max)     f_max = frames;

					ping_sum += ping;
					f_sum += frames;

					size_received += samples[a].receivedsize;

					if (samples[a].delta)
						samples_delta++;
				}
			default:
				break;
        }

        // end of loop
    }

    if (samples_sent <= 0  ||  samples_received <= 0)
        return (res->samples = 0);

    ping_avg = ping_sum / samples_received;
    f_avg = f_sum / samples_received;

    // loop again to calc standard deviation
    for (i=p; i < q; i++)
    {
        int a = i & NETWORK_STATS_MASK;

        if (samples[a].status == packet_ok)
        {
            float ping;
            int frames;

            frames = samples[a].seq_diff;
            ping = 1000*(samples[a].receivedtime - samples[a].senttime);

            ping_dev_sum += (ping - ping_avg) * (ping - ping_avg);
            f_dev_sum += (frames - f_avg) * (frames - f_avg);
        }
    }

    ping_dev = sqrt(ping_dev_sum / samples_received);
    f_dev = sqrt(f_dev_sum / samples_received);

    // fill-in result struct
    res->ping_min = ping_min;
    res->ping_max = ping_max;
    res->ping_avg = ping_avg;
    res->ping_dev = ping_dev;

    res->ping_f_min = f_min;
    res->ping_f_max = f_max;
    res->ping_f_avg = f_avg;
    res->ping_f_dev = f_dev;

    res->lost_netlimit = lost_netlimit * 100.0 / (q-p);
    res->lost_lost     = lost_lost     * 100.0 / samples_sent;
    res->lost_rate     = lost_rate     * 100.0 / samples_sent;
    res->bandwidth_in  = lost_delta    * 100.0 / samples_sent;

    res->size_out = size_sent      / (float)samples_sent;
    res->size_in  = size_received  / (float)samples_received;

    res->bandwidth_out = size_sent      / period;
    res->bandwidth_in  = size_received  / period;

    res->delta = (samples_delta > 0) ? 1 : 0;
    res->samples = q-p;
    return res->samples;
}

//=============================================================================

qbool CL_Download_Accept(const char *filename);

// Returns true if the file exists, otherwise it attempts to start a download from the server.
qbool CL_CheckOrDownloadFile(char *filename)
{
	if (!CL_Download_Accept(filename))
	{
		return true;
	}

	// Can't download when playback, except qtv which support download
	if (cls.demoplayback)
	{
		if (cls.mvdplayback == QTV_PLAYBACK)
		{
			if (!(cls.qtv_ezquake_ext & QTV_EZQUAKE_EXT_DOWNLOAD)) 
			{
				Com_Printf ("Unable to download %s, this QTV does't support download\n", filename);
				return true;
			}
		}
		else
			return true;
	}

	if (cls.state < ca_connected) 
	{
		Com_DPrintf ("Unable to download %s, not connected\n", filename);
		return true;
	}

	snprintf (cls.downloadname, sizeof(cls.downloadname), "%s/%s", cls.gamedir, filename);
	Com_Printf ("Downloading %s...\n", filename);

	// download to a temp name, and only rename
	// to the real name when done, so if interrupted
	// a runt file wont be left

	cls.downloadmethod    = DL_QW; // by default its DL_QW, if server support DL_QWCHUNKED it will be changed.
	cls.downloadstarttime = Sys_DoubleTime();

	COM_StripExtension (cls.downloadname, cls.downloadtempname, sizeof(cls.downloadtempname));
	strlcat (cls.downloadtempname, ".tmp", sizeof(cls.downloadtempname));

	if (cls.mvdplayback == QTV_PLAYBACK) 
	{
		QTV_Cmd_Printf(QTV_EZQUAKE_EXT_DOWNLOAD, "download \"%s\"", filename);
	}
	else 
	{
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		MSG_WriteString (&cls.netchan.message, va("download \"%s\"", filename));
	}

	cls.downloadnumber++;

	return false;
}

void CL_FindModelNumbers (void) 
{
	int i, j;

	for (i = 0; i < cl_num_modelindices; i++)
		cl_modelindices[i] = -1;

	for (i = 0; i < MAX_MODELS; i++) 
	{
		for (j = 0; j < cl_num_modelindices; j++) 
		{
			if (!strcmp(cl_modelnames[j], cl.model_name[i]))
			{
				cl_modelindices[j] = i;
				break;
			}
		}
	}
}

void CL_ProxyEnter (void) 
{
	if (!strcmp(cl.levelname, "Qizmo menu") ||	// qizmo detection
		strstr(cl.serverinfo, "*QTV")) 			// fteqtv detection
	{
		// If we are connected only to the proxy frontend
		// we presume that the menu is on.
		M_EnterProxyMenu();

	} 
	else if (key_dest == key_menu && m_state == m_proxy) 
	{
		// This happens when we connect to a server using a proxy.
		M_LeaveMenus();
	}

	// If we used console to connect to a server via proxy,
	// cancel return to the proxy menu, because it's not there.
	if (key_dest_beforecon == key_menu)
		key_dest_beforecon = key_game;
}

static void CL_TransmitModelCrc (int index, char *info_key)
{
	if (index != -1) 
	{
		struct model_s *model = cl.model_precache[index];
		unsigned short crc = model->crc;
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		MSG_WriteString (&cls.netchan.message, va("setinfo %s %d", info_key, (int) crc));
		Info_SetValueForKey(cls.userinfo, info_key, va("%d", (int) crc), MAX_INFO_STRING);
	}
}

void CL_Prespawn (void)
{
	cl.worldmodel = cl.model_precache[1];
	if (!cl.worldmodel)
		Host_Error ("Model_NextDownload: NULL worldmodel");

	CL_FindModelNumbers ();
	R_NewMap (false);
	TP_NewMap();
	MT_NewMap();
	Stats_NewMap();
	CL_ProxyEnter();
	MVD_Stats_Cleanup();

	// Reset the status grid.
	StatsGrid_Remove(&stats_grid);
	StatsGrid_ResetHoldItems();
	HUD_NewMap();
	Hunk_Check(); // make sure nothing is hurt

	CL_TransmitModelCrc (cl_modelindices[mi_player], "pmodel");
	CL_TransmitModelCrc (cl_modelindices[mi_eyes], "emodel");

	CL_SpawnWarn_LoadPoints();

#if 0
//TEI: loading entitys from map, at clientside,
// will be usefull to locate more eyecandy and cameras
	if (cl.worldmodel->entities)
	{
		CL_PR_LoadProgs();
		CL_ED_LoadFromFile (cl.worldmodel->entities);
	}
#endif

	// done with modellist, request first of static signon messages, in case of qtv it different
	if (cls.mvdplayback == QTV_PLAYBACK)
	{
		QTV_Cmd_Printf(QTV_EZQUAKE_EXT_DOWNLOAD, "qtvspawn %i", cl.servercount);
	}
	else 
	{
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		MSG_WriteString (&cls.netchan.message, va("prespawn %i 0 %i", cl.servercount, cl.map_checksum2));
	}
}

/*
=================
VWepModel_NextDownload
=================
*/
void CL_ParseVWepPrecache (char *str);
void VWepModel_NextDownload (void)
{
	int		i;
	extern cvar_t cl_novweps;

	if (((!(cl.z_ext & Z_EXT_VWEP) || !cl.vw_model_name[0][0]) && !cls.mvdplayback)
	|| cl_novweps.value) 
	{
		// no vwep support, go straight to prespawn
		CL_Prespawn ();
		return;
	}

	if (cls.mvdplayback && cls.downloadnumber == 0)
	{
		CL_ParseVWepPrecache ("//vwep vwplayer w_axe w_shot w_shot2 w_nail w_nail2 w_rock w_rock2 w_light");
	}

	if (cls.downloadnumber == 0)
	{
		if (!com_serveractive || developer.value)
			Com_DPrintf ("Checking vwep models...\n");
		//cls.downloadnumber = 0;
	}

	cls.downloadtype = dl_vwep_model;
	for ( ; cls.downloadnumber < MAX_VWEP_MODELS; cls.downloadnumber++)
	{
		if (!cl.vw_model_name[cls.downloadnumber][0] ||
			cl.vw_model_name[cls.downloadnumber][0] == '-')
			continue;
		if (!CL_CheckOrDownloadFile(cl.vw_model_name[cls.downloadnumber]))
			return;		// started a download
	}

	for (i = 0; i < MAX_VWEP_MODELS; i++)
	{
		if (!cl.vw_model_name[i][0])
			continue;

		if (strcmp(cl.vw_model_name[i], "-"))
			cl.vw_model_precache[i] = Mod_ForName (cl.vw_model_name[i], false);

		if (!cl.vw_model_precache[i])
		{
			// never mind
			// Com_Printf ("Warning: model %s could not be found\n", cl.vw_model_name[i]);
		}
	}

	if (!strcmp(cl.vw_model_name[0], "-") || cl.vw_model_precache[0])
		cl.vwep_enabled = true;
	else 
	{
		// if the vwep player model is required but not present,
		// don't enable vwep support
	}

	// all done
	CL_Prespawn ();
}

void Model_NextDownload (void) 
{
	int	i;
	char *s;
	char mapname[MAX_QPATH];

	if (cls.downloadnumber == 0) 
	{
		if (!com_serveractive || developer.value)
			Com_DPrintf ("Checking models...\n");
		cls.downloadnumber = 1;
	}

	cls.downloadtype = dl_model;
	for ( ; cl.model_name[cls.downloadnumber][0]; cls.downloadnumber++)	
	{
		s = cl.model_name[cls.downloadnumber];
		if (s[0] == '*')
			continue; // inline brush model

		if (!CL_CheckOrDownloadFile(s))
			return;	// started a download
	}

	cl.clipmodels[1] = CM_LoadMap (cl.model_name[1], true, NULL, &cl.map_checksum2);
	COM_StripExtension (COM_SkipPath(cl.model_name[1]), mapname, sizeof(mapname));
	cl.map_checksum2 = Com_TranslateMapChecksum (mapname, cl.map_checksum2);
	R_NewMapPreLoad();

	for (i = 1; i < MAX_MODELS; i++) {
		if (!cl.model_name[i][0]) {
			break;
		}

		cl.model_precache[i] = Mod_ForName(cl.model_name[i], false);

		if (!cl.model_precache[i]) {
			Com_Printf("\n&cf22Couldn't load model:&r %s\n", cl.model_name[i]);
			Host_EndGame();
			return;
		}

		if (cl.model_name[i][0] == '*') {
			cl.clipmodels[i] = CM_InlineModel(cl.model_name[i]);
		}
	}

	// Done with normal models, request vwep models if necessary
	cls.downloadtype = dl_vwep_model;
	cls.downloadnumber = 0;
	VWepModel_NextDownload ();
}

void Sound_NextDownload (void) 
{
	char *s;
	int i;

	if (cls.downloadnumber == 0)
	{
		if (!com_serveractive || developer.value)
			Com_DPrintf ("Checking sounds...\n");
		cls.downloadnumber = 1;
	}

	cls.downloadtype = dl_sound;
	for ( ; cl.sound_name[cls.downloadnumber][0]; cls.downloadnumber++)	
	{
		s = cl.sound_name[cls.downloadnumber];
		if (!CL_CheckOrDownloadFile(va("sound/%s",s)))
			return;		// started a download
	}

	for (i = 1; i < MAX_SOUNDS; i++) 
	{
		if (!cl.sound_name[i][0])
			break;
		cl.sound_precache[i] = S_PrecacheSound (cl.sound_name[i]);
	}

	// Done with sound downloads, go for models
	cls.downloadnumber = 0;
	cls.downloadtype = dl_model;
	Model_NextDownload ();

}

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS

//
// FTE's chunked download
//

extern void CL_RequestNextDownload (void);

#define MAXBLOCKS 1024	// Must be power of 2
#define DLBLOCKSIZE 1024

int chunked_download_number = 0; // Never reset, bumped up.

int downloadsize;
int receivedbytes;
int recievedblock[MAXBLOCKS];
int firstblock;
int blockcycle;

int CL_RequestADownloadChunk(void)
{
	int i;
	int b;

	if (cls.downloadmethod != DL_QWCHUNKS) // Paranoia!
		Host_Error("download not initiated\n");

	for (i = 0; i < MAXBLOCKS; i++)
	{
		blockcycle++;

		b = ((blockcycle) & (MAXBLOCKS-1)) + firstblock;

		if (!recievedblock[b&(MAXBLOCKS-1)]) // Don't ask for ones we've already got.
		{
			if (b >= (downloadsize+DLBLOCKSIZE-1)/DLBLOCKSIZE)	// Don't ask for blocks that are over the size of the file.
				continue;
			return b;
		}
	}

	return -1;
}

void CL_SendChunkDownloadReq(void)
{
	extern cvar_t cl_chunksperframe;
	int i, j, chunks;
	
	chunks = bound(1, cl_chunksperframe.integer, 30);

	for (j = 0; j < chunks; j++)
	{
		if (cls.downloadmethod != DL_QWCHUNKS)
			return;

		i = CL_RequestADownloadChunk();
		// i < 0 mean client complete download, let server know
		// qqshka: download percent optional, server does't really require it, that my extension, hope does't fuck up something

		if (i < 0)
		{
			if (strstr(Info_ValueForKey(cl.serverinfo, "*version"), "MVDSV"))
				CL_SendClientCommand(true, "nextdl %d %d %d", i, cls.downloadpercent, chunked_download_number);
			else
				CL_SendClientCommand(true, "stopdownload");

			cls.downloadpercent = 100;
			CL_FinishDownload(); // this also request next dl
		}
		else
		{
			CL_SendClientCommand(false, "nextdl %d %d %d", i, cls.downloadpercent, chunked_download_number);
		}
	}
}

void CL_ParseDownload (void);

void CL_Parse_OOB_ChunkedDownload(void)
{
	int j;

	for ( j = 0; j < sizeof("\\chunk")-1; j++ )
		MSG_ReadByte ();

	//
	// qqshka: well, this is evil.
	// In case of when one file completed download and next started
	// here may be some packets which travel via network,
	// so we got packets from different file, that mean we may assemble wrong data,
	// need somehow discard such packets, i have no idea how, so adding at least this check.
	//

	if (chunked_download_number != MSG_ReadLong ())
	{
		Com_DPrintf("Dropping OOB chunked message, out of sequence\n");
		return;
	}

	if (MSG_ReadByte() != svc_download)
	{
		Com_DPrintf("Something wrong in OOB message and chunked download\n");
		return;
	}

	CL_ParseDownload ();
}

void CL_ParseChunkedDownload(void)
{
	char *svname;
	int totalsize;
	int chunknum;
	char data[DLBLOCKSIZE];
	double tm;

	chunknum = MSG_ReadLong();
	if (chunknum < 0)
	{
		totalsize = MSG_ReadLong();
		svname    = MSG_ReadString();

		if (cls.download) 
		{ 
			// Ensure FILE is closed
			if (totalsize != -3) // -3 = dl stopped, so this known issue, do not warn
				Com_Printf ("cls.download shouldn't have been set\n");

			fclose (cls.download);
			cls.download = NULL;
			cls.downloadpercent = 0;
		}

		if (cls.demoplayback)
			return;

		if (totalsize < 0)
		{
			switch (totalsize)
			{
				case -3: Com_DPrintf("Server cancel downloading file %s\n", svname);			break;
				case -2: Com_Printf("Server permissions deny downloading file %s\n", svname);	break;
				default: Com_Printf("Couldn't find file %s on the server\n", svname);			break;
			}

			CL_FinishDownload(); // this also request next dl
			return;
		}

		if (cls.downloadmethod == DL_QWCHUNKS)
			Host_Error("Received second download - \"%s\"\n", svname);

// FIXME: damn, fixme!!!!!
//		if (strcasecmp(cls.downloadname, svname))
//			Host_Error("Server sent the wrong download - \"%s\" instead of \"%s\"\n", svname, cls.downloadname);

		// Start the new download
		FS_CreatePath (cls.downloadtempname);

		if ( !(cls.download = fopen (cls.downloadtempname, "wb")) ) 
		{
			Com_Printf ("Failed to open %s\n", cls.downloadtempname);
			CL_FinishDownload(); // This also requests next dl.
			return;
		}

		cls.downloadmethod  = DL_QWCHUNKS;
		cls.downloadpercent = 0;

		chunked_download_number++;

		downloadsize        = totalsize;

		firstblock    = 0;
		receivedbytes = 0;
		blockcycle    = -1;	//so it requests 0 first. :)
		memset(recievedblock, 0, sizeof(recievedblock));
		return;
	}

	MSG_ReadData(data, DLBLOCKSIZE);

	if (!cls.download) 
	{ 
		return;
	}

	if (cls.downloadmethod != DL_QWCHUNKS)
		Host_Error("cls.downloadmethod != DL_QWCHUNKS\n");

	if (cls.demoplayback)
	{	
		// Err, yeah, when playing demos we don't actually pay any attention to this.
		return;
	}

	if (chunknum < firstblock)
	{
		return;
	}

	if (chunknum - firstblock >= MAXBLOCKS)
	{
		return;
	}

	if (recievedblock[chunknum&(MAXBLOCKS-1)])
	{
		return;
	}

	receivedbytes += DLBLOCKSIZE;
	recievedblock[chunknum&(MAXBLOCKS-1)] = true;

	while(recievedblock[firstblock&(MAXBLOCKS-1)])
	{
		recievedblock[firstblock&(MAXBLOCKS-1)] = false;
		firstblock++;
	}

	fseek(cls.download, chunknum * DLBLOCKSIZE, SEEK_SET);
	if (downloadsize - chunknum * DLBLOCKSIZE < DLBLOCKSIZE)	//final block is actually meant to be smaller than we recieve.
		fwrite(data, 1, downloadsize - chunknum * DLBLOCKSIZE, cls.download);
	else
		fwrite(data, 1, DLBLOCKSIZE, cls.download);

	cls.downloadpercent = receivedbytes/(float)downloadsize*100;

	tm = Sys_DoubleTime() - cls.downloadstarttime; // how long we dl-ing
	cls.downloadrate = (tm ? receivedbytes / 1024 / tm : 0); // some average dl speed in KB/s
}

#endif // FTE_PEXT_CHUNKEDDOWNLOADS

void CL_RequestNextDownload (void) 
{
	switch (cls.downloadtype)
	{
		case dl_single:
			break;
		case dl_skin:
			Skin_NextDownload ();
			break;
		case dl_model:
			Model_NextDownload ();
			break;
		case dl_vwep_model:
			VWepModel_NextDownload ();
			break;
		case dl_sound:
			Sound_NextDownload ();
			break;
		case dl_none:
		default:
			Com_DPrintf ("Unknown download type.\n");
	}
}

void CL_FinishDownload(void)
{
	if (cls.download) {
		fclose (cls.download);

		if (cls.downloadpercent == 100) {
			Com_DPrintf("Download took %.1f seconds\n", Sys_DoubleTime() - cls.downloadstarttime);

			// rename the temp file to its final name
			if (strcmp(cls.downloadtempname, cls.downloadname))
				if (rename(cls.downloadtempname, cls.downloadname))
					Com_Printf ("Failed to rename %s to %s.\n",	cls.downloadtempname, cls.downloadname);
		} else {
			/* If download didn't complete, remove the unfinished leftover .tmp file ... */
			unlink(cls.downloadtempname);
		}
	}

	cls.download = NULL;
	cls.downloadpercent = 0;
	cls.downloadmethod = DL_NONE;

	// VFS-FIXME: D-Kure: Surely there is somewhere better for this in fs.c
	filesystemchanged = true;

	// get another file if needed

	if (cls.state != ca_disconnected)
		CL_RequestNextDownload ();
}

// A download message has been received from the server
void CL_ParseDownload (void)
{
	int size, percent;

	double current = Sys_DoubleTime();
	static double time = 0;
	static int s = 0;

	#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	if (cls.fteprotocolextensions & FTE_PEXT_CHUNKEDDOWNLOADS)
	{
		CL_ParseChunkedDownload();
		return;
	}
	#endif // PFTE_PEXT_CHUNKEDDOWNLOADS

	if (cls.downloadmethod != DL_QW)
		Host_Error("cls.downloadmethod != DL_QW\n");

	// Read the data
	size = MSG_ReadShort ();
	percent = MSG_ReadByte ();

	s += size;
	if (current - time > 1) 
	{
		cls.downloadrate = s / (1024 * (current - time));
		time = current;
		s = 0;
	}

	if (cls.demoplayback) 
	{
		qbool skip_download = true;

		// Skip download data in demo playback, except during qtving which support download.

		if (cls.mvdplayback == QTV_PLAYBACK)
		{
			if (cls.qtv_ezquake_ext & QTV_EZQUAKE_EXT_DOWNLOAD)
				skip_download = false;
		}

		if (skip_download)
		{
			if (size > 0)
				msg_readcount += size;
			return;
		}
	}

	if (size == -1)	
	{
		Com_Printf ("File not found.\n");
		if (cls.download) {
			Com_Printf ("cls.download shouldn't have been set\n");
			fclose (cls.download);
			cls.download = NULL;
		}
		CL_FinishDownload(); // this also request next dl
		return;
	}

	// Open the file if not opened yet
	if (!cls.download) 
	{
		FS_CreatePath (cls.downloadtempname);

		if ( !(cls.download = fopen (cls.downloadtempname, "wb")) )
		{
			msg_readcount += size;
			Com_Printf ("Failed to open %s\n", cls.downloadtempname);
			CL_FinishDownload(); // this also request next dl
			return;
		}
	}

	fwrite (net_message.data + msg_readcount, 1, size, cls.download);
	msg_readcount += size;

	if (percent != 100) 
	{
		// Change display routines by zoid.
		// Request next block.
		cls.downloadpercent = percent;

		if (cls.mvdplayback == QTV_PLAYBACK) 
		{
			// nothing
		}
		else 
		{
			MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
			SZ_Print (&cls.netchan.message, "nextdl");
		}
	} 
	else
	{
		cls.downloadpercent = 100;
		CL_FinishDownload(); // this also request next dl
	}
}

/*
=====================================================================

  UPLOAD FILE FUNCTIONS

=====================================================================
*/
void CL_NextUpload(void)
{
	static byte	buffer[FILE_TRANSFER_BUF_SIZE];
	int		r;
	int		percent;
	int		size;
	static int s = 0;
	double current = Sys_DoubleTime();
	static double	time;

	if ((!cls.is_file && !cls.mem_upload) || (cls.is_file && !cls.upload))
		return;

	r = min(cls.upload_size - cls.upload_pos, (int)sizeof(buffer));
	MSG_WriteByte (&cls.netchan.message, clc_upload);
	MSG_WriteShort (&cls.netchan.message, r);

	if (cls.is_file)
	{
		if ((int)fread(buffer, 1, r, cls.upload) != r)
		{
			Com_Printf("Error reading the upload file\n");
			CL_StopUpload();
			return;
		}
	} 
	else 
	{
		memcpy(buffer, cls.mem_upload + cls.upload_pos, r);
	}
	cls.upload_pos += r;
	size = cls.upload_size ? cls.upload_size : 1;
	percent = cls.upload_pos * 100 / size;
	cls.uploadpercent = percent;
	MSG_WriteByte (&cls.netchan.message, percent);
	SZ_Write (&cls.netchan.message, buffer, r);

	Com_DPrintf ("UPLOAD: %6d: %d written\n", cls.upload_pos - r, r);

	s += r;
	if (current - time > 1) 
	{
		cls.uploadrate = s/(1024*(current - time));
		time = current;
		s = 0;
	}
	
	if (cls.upload_pos != cls.upload_size)
		return;

	Com_Printf ("Upload completed\n");

	if (cls.is_file) 
	{
		fclose (cls.upload);
		cls.upload = NULL;
	} 
	else 
	{
		Q_free(cls.mem_upload);
		cls.mem_upload = 0;
	}
	cls.upload_pos = 0;
	cls.upload_size = 0;
}

void CL_StartUpload (byte *data, int size)
{
	if (cls.state < ca_onserver)
		return; // gotta be connected

	cls.is_file = false;

	// override
	if (cls.mem_upload)
		Q_free(cls.mem_upload);
	cls.mem_upload = (byte *) Q_malloc (size);
	memcpy(cls.mem_upload, data, size);
	cls.upload_size = size;
	cls.upload_pos = 0;
	Com_Printf ("Upload starting of %d...\n", cls.upload_size);

	CL_NextUpload();
}

static void ReplaceChar(char *s, char from, char to)
{
	if (s)
	{
		for ( ;*s ; ++s)
		{
			if (*s == from)
				*s = to;
		}
	}
}

void CL_StartFileUpload (void)
{
	char *name;
	int i;
	extern cvar_t cl_allow_uploads;

	if (!cl_allow_uploads.integer)
	{
		Com_Printf ("This command has been disabled for security reasons. Set cl_allow_uploads to 1 if you want to enable uploads.\n");
		return;
	}

	if (cls.state < ca_onserver) 
	{
		Com_Printf("must be connected\n");
		return;
	}

	name = Cmd_Argv (2);

	ReplaceChar(name, '\\', '/');

	if (
//		TODO: split name to pathname and filename
//		and check for 'bad symbols' only in pathname
		*name == '/' //no absolute
		|| !strncmp(name, "../", 3) // no leading ../
		|| strstr (name, "/../") // no /../
		|| ((i = strlen(name)) < 3 ? 0 : !strncmp(name + i - 3, "/..", 4)) // no /.. at end
		|| *name == '.' //relative is pointless
		|| ((i = strlen(name)) < 4 ? 0 : !strncasecmp(name+i-4,".log",4)) // no logs
#ifdef _WIN32
		// no leading X:
		|| ( name[1] == ':' && ((*name >= 'a' && *name <= 'z') ||
			(*name >= 'A' && *name <= 'Z')) )
#endif //_WIN32
	) 
	{
		Com_Printf ("File upload: bad path/name \"%s\"", name);
		return;
	}

	cls.is_file = true;

	// override
	if (cls.upload) 
	{
		fclose(cls.upload);
		cls.upload = NULL;
	}

	strlcpy(cls.uploadname, Cmd_Argv(2), sizeof(cls.uploadname));
	cls.upload = fopen(cls.uploadname, "rb"); // BINARY

	if (!cls.upload)
	{
		Com_Printf ("Bad file \"%s\"\n", cls.uploadname);
		return;
	}

	cls.upload_size = FS_FileLength(cls.upload);
	cls.upload_pos = 0;

	Com_Printf ("Upload starting: %s (%d bytes)...\n", cls.uploadname, cls.upload_size);

	CL_NextUpload();
}

qbool CL_IsUploading(void)
{
	if ((!cls.is_file && cls.mem_upload) || (cls.is_file && cls.upload))
		return true;
	return false;
}

void CL_StopUpload(void)
{
	if (cls.is_file) 
	{
		if (cls.upload) 
		{
			fclose(cls.upload);
			cls.upload = NULL;
		}
	} 
	else 
	{
		if (cls.mem_upload) 
		{
			Q_free(cls.mem_upload);
			cls.mem_upload = NULL;
		}
	}
}

/*
=====================================================================
  SERVER CONNECTING MESSAGES
=====================================================================
*/

void CL_ParseServerData (void) 
{
	char *str, fn[MAX_OSPATH];
	FILE *f;
	qbool cflag = false;
	int i, protover;

	Com_DPrintf("Serverdata packet received.\n");

	// wipe the clientState_t struct
	CL_ClearState();

	// parse protocol version number
	// allow 2.2 and 2.29 demos to play
#ifdef PROTOCOL_VERSION_FTE
	cls.fteprotocolextensions = 0;
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
	cls.fteprotocolextensions2 = 0;
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
	cls.mvdprotocolextensions1 = 0;
#endif

	for(;;)
	{
		protover = MSG_ReadLong ();
#ifdef PROTOCOL_VERSION_FTE
		if (protover == PROTOCOL_VERSION_FTE)
		{
			cls.fteprotocolextensions = MSG_ReadLong();
			Com_DPrintf ("Using FTE extensions 0x%x\n", cls.fteprotocolextensions);
			continue;
		}
#endif

#ifdef PROTOCOL_VERSION_FTE2
		if (protover == PROTOCOL_VERSION_FTE2)
		{
			cls.fteprotocolextensions2 = MSG_ReadLong();
			Com_DPrintf ("Using FTE extensions2 0x%x\n", cls.fteprotocolextensions2);
			continue;
		}
#endif

#ifdef PROTOCOL_VERSION_MVD1
		if (protover == PROTOCOL_VERSION_MVD1) {
			extern cvar_t cl_pext_lagteleport;
			extern cvar_t cl_debug_antilag_send;

			cls.mvdprotocolextensions1 = MSG_ReadLong();
			Com_DPrintf("Using MVDSV extensions 0x%x\n", cls.mvdprotocolextensions1);
			if (!cls.demoplayback) {
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
				extern cvar_t cl_pext_serversideweapon;

				if (cl_pext_serversideweapon.integer && !(cls.mvdprotocolextensions1 & MVD_PEXT1_SERVERSIDEWEAPON)) {
					Con_Printf("&cf00Warning&r: weapon scripts will be executed client-side\n");
				}
#endif
#ifdef MVD_PEXT1_HIGHLAGTELEPORT
				if (cl_pext_lagteleport.integer && !(cls.mvdprotocolextensions1 & MVD_PEXT1_HIGHLAGTELEPORT)) {
					Con_Printf("&cf00Warning&r: high-lag teleport fix not available\n");
				}
#endif
#ifdef MVD_PEXT1_DEBUG_ANTILAG
				if (cl_debug_antilag_send.integer && !(cls.mvdprotocolextensions1 & MVD_PEXT1_DEBUG_ANTILAG)) {
					Con_Printf("&cf00Warning&r: server doesn't support antilag debugging - will not send\n");
				}
#endif
			}
			continue;
		}
#endif

		if (protover == PROTOCOL_VERSION) //this ends the version info
			break;
		if (cls.demoplayback && protover >= 24 && protover <= 28)	//older versions, maintain demo compatability.
			break;
		Host_Error ("Server returned version %i, not %i\nYou probably need to upgrade.\nCheck http://www.quakeworld.net/", protover, PROTOCOL_VERSION);
	}

#ifdef FTE_PEXT_FLOATCOORDS
	if (cls.fteprotocolextensions & FTE_PEXT_FLOATCOORDS)
	{
		if (!com_serveractive)
		{
			msg_coordsize = 4;
			msg_anglesize = 2;
		}
	}
	else
	{
		if (!com_serveractive)
		{
			msg_coordsize = 2;
			msg_anglesize = 1;
		}
	}
#endif

	cl.protoversion = protover;
	cl.servercount = MSG_ReadLong ();

	// game directory
	str = MSG_ReadString ();

	if (!strcmp(str, "")  || !strcmp(str, ".") || strstr(str, "..") || strstr(str, "//") || strchr(str, '\\') || strchr(str, ':')  || str[0] == '/') {
		Host_Error("Server reported invalid gamedir!\n");
	}

	cl.teamfortress = !strcasecmp(str, "fortress");
	if (cl.teamfortress) 
	{
		extern cvar_t	v_iyaw_cycle, v_iroll_cycle, v_ipitch_cycle,
			v_iyaw_level, v_iroll_level, v_ipitch_level, v_idlescale;
		cbuf_current = &cbuf_svc;	// hack
		Cvar_SetValue (&v_iyaw_cycle, 2);
		Cvar_SetValue (&v_iroll_cycle, 0.5);
		Cvar_SetValue (&v_ipitch_cycle, 1);
		Cvar_SetValue (&v_iyaw_level, 0.3);
		Cvar_SetValue (&v_iroll_level, 0.1);
		Cvar_SetValue (&v_ipitch_level, 0.3);
		Cvar_SetValue (&v_idlescale, 0);
	}

	if (strcasecmp(cls.gamedirfile, str)) 
	{
		strlcpy (cls.gamedirfile, str, sizeof(cls.gamedirfile));
		snprintf (cls.gamedir, sizeof(cls.gamedir),
			"%s/%s", com_basedir, cls.gamedirfile);
		cflag = true;
	}

	if (!com_serveractive)
		FS_SetGamedir (str, false);

	if (cfg_legacy_exec.value && (cflag || cfg_legacy_exec.value >= 2)) 
	{
		snprintf (fn, sizeof(fn), "%s/%s", cls.gamedir, "config.cfg");
		Cbuf_AddText ("cl_warncmd 0\n");
		if ((f = fopen(fn, "r")) != NULL) 
		{
			fclose(f);
			if (!strcmp(cls.gamedirfile, com_gamedirfile))
				Cbuf_AddText ("exec config.cfg\n");
			else
				Cbuf_AddText (va("exec ../%s/config.cfg\n", cls.gamedirfile));
		} 
		else if (cfg_legacy_exec.value == 3 && strcmp(cls.gamedir, "qw"))
		{
			snprintf (fn, sizeof(fn), "qw/%s", "config.cfg");
			if ((f = fopen(fn, "r")) != NULL) 
			{
				fclose(f);
				Cbuf_AddText ("exec config.cfg\n");
			}
		}
		snprintf (fn, sizeof(fn), "%s/%s", cls.gamedir, "frontend.cfg");
		if ((f = fopen(fn, "r")) != NULL) 
		{
			fclose(f);
			if (!strcmp(cls.gamedirfile, com_gamedirfile))
				Cbuf_AddText ("exec frontend.cfg\n");
			else
				Cbuf_AddText (va("exec ../%s/frontend.cfg\n", cls.gamedirfile));
		} 
		else if (cfg_legacy_exec.value == 3 && strcmp(cls.gamedir, "qw"))
		{
			snprintf (fn, sizeof(fn), "qw/%s", "frontend.cfg");
			if ((f = fopen(fn, "r")) != NULL) 
			{
				fclose(f);
				Cbuf_AddText ("exec frontend.cfg\n");
			}
		}
		Cbuf_AddText ("cl_warncmd 1\n");
	}


	// parse player slot, high bit means spectator
	if (cls.mvdplayback)
	{
		cls.netchan.last_received = nextdemotime = olddemotime = MSG_ReadFloat();
		cl.playernum = MAX_CLIENTS - 1;
		cl.spectator = true;
		for (i = 0; i < UPDATE_BACKUP; i++)
			cl.frames[i].playerstate[cl.playernum].pm_type = PM_SPECTATOR;
	}
	else 
	{
		cl.playernum = MSG_ReadByte ();
		if (cl.playernum & 128) 
		{
			cl.spectator = true;
			cl.playernum &= ~128;
		}
	}

	// get the full level name
	str = MSG_ReadString ();
	strlcpy (cl.levelname, str, sizeof(cl.levelname));

	// get the movevars
	if (cl.protoversion >= 25) 
	{
		movevars.gravity			= MSG_ReadFloat();
		movevars.stopspeed          = MSG_ReadFloat();
		cl.maxspeed                 = MSG_ReadFloat();
		movevars.spectatormaxspeed  = MSG_ReadFloat();
		movevars.accelerate         = MSG_ReadFloat();
		movevars.airaccelerate      = MSG_ReadFloat();
		movevars.wateraccelerate    = MSG_ReadFloat();
		movevars.friction           = MSG_ReadFloat();
		movevars.waterfriction      = MSG_ReadFloat();
		cl.entgravity               = MSG_ReadFloat();
	}
	else
	{
		// These seem to be the defaults for standard QW... 
		//   if there are mods with other defaults, we could 
		//   set accordingly to give best experience?
		movevars.gravity = 800.0f;
		movevars.stopspeed = 100.0f;
		cl.maxspeed = 320.0f;
		movevars.spectatormaxspeed = 500.0f;
		movevars.accelerate = 10.0f;
		movevars.airaccelerate = 0.7f;
		movevars.wateraccelerate = 10.0f;
		movevars.friction = 6.0f;
		movevars.waterfriction = 1.0f;
		cl.entgravity = 1.0f;
	}

	// separate the printfs so the server message can have a color
	if (!cls.demoseeking) {
		Com_Printf ("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
		Com_Printf ("%c%s\n", 2, str);
	}

	// ask for the sound list next
	memset(cl.sound_name, 0, sizeof(cl.sound_name));

	if (cls.mvdplayback == QTV_PLAYBACK) 
	{
		cls.qtv_donotbuffer = true; // do not try buffering before "skins" not received
		QTV_Cmd_Printf(QTV_EZQUAKE_EXT_DOWNLOAD, "qtvsoundlist %i %i", cl.servercount, 0);
	}
	else 
	{
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		MSG_WriteString (&cls.netchan.message, va("soundlist %i %i", cl.servercount, 0));
	}

	// now waiting for downloads, etc
	cls.state = ca_onserver;

#ifdef FTE_PEXT2_VOICECHAT
	S_Voip_MapChange();
#endif
}

void CL_ParseSoundlist (void)
{
	int	numsounds, n;
	char *str;

	// precache sounds
	// memset (cl.sound_precache, 0, sizeof(cl.sound_precache));

	if (cl.protoversion >= 26) 
	{
		numsounds = MSG_ReadByte();

		while (1) 
		{
			str = MSG_ReadString ();
			if (!str[0])
				break;
			numsounds++;
			if (numsounds >= MAX_SOUNDS) {
				Host_Error("Server sent too many sound_precache");
				return;
			}
			if (str[0] == '/')
				str++; // hexum -> fixup server error (submitted by empezar bug #1026106)
			strlcpy (cl.sound_name[numsounds], str, sizeof(cl.sound_name[numsounds]));
		}

		n = MSG_ReadByte();

		if (n) 
		{
			if (cls.mvdplayback == QTV_PLAYBACK) 
			{
				// none
			}
			else 
			{
				MSG_WriteByte(&cls.netchan.message, clc_stringcmd);
				MSG_WriteString(&cls.netchan.message, va("soundlist %i %i", cl.servercount, n));
			}

			return;
		}
	}
	else 
	{
		// Taken from http://www.quakewiki.net/archives/demospecs/qwd/qwd.html#AEN562
		numsounds = 0;
		do {
			if (++numsounds > 255)
				Host_Error ("Server sent too many sound_precache");
			str = MSG_ReadString ();
			strlcpy (cl.sound_name[numsounds], str, sizeof(cl.sound_name[numsounds]));
		} while (*str);
	}

	// AFTER we got the soundlist, request the modellist (older FTE servers will send it right away anyway)
	// done with sounds, request models now
	memset (cl.model_precache, 0, sizeof(cl.model_precache));

	if (cls.mvdplayback == QTV_PLAYBACK)
	{
		QTV_Cmd_Printf(QTV_EZQUAKE_EXT_DOWNLOAD, "qtvmodellist %i %i", cl.servercount, 0);
	}
	else 
	{
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		MSG_WriteString (&cls.netchan.message, va("modellist %i %i", cl.servercount, 0));
	}
}

void CL_ParseModellist (qbool extended)
{
	int	nummodels, n;
	char *str;

	if (cl.protoversion >= 26)
	{
		// Precache models and note certain default indexes
		nummodels = (extended) ? (unsigned) MSG_ReadShort () : MSG_ReadByte ();

		while (1) 
		{
			str = MSG_ReadString ();
			if (!str[0])
				break;

			#if defined (PROTOCOL_VERSION_FTE) && defined (FTE_PEXT_MODELDBL)
			nummodels++;
			if (nummodels >= MAX_MODELS) {
				// Spike: tweeked this, we still complain if the server exceeds the standard limit without using extensions.
				Host_Error("Server sent too many model_precache");
				return;
			}
		
			if (nummodels >= 256 && !(cls.fteprotocolextensions & FTE_PEXT_MODELDBL))
			#else
			if (++nummodels >= MAX_MODELS)
			#endif // PROTOCOL_VERSION_FTE
			{
				Host_Error ("Server sent too many model_precache");
				return;
			}

			if (str[0] == '/')
				str++; // hexum -> fixup server error (submitted by empezar bug #1026106)
			strlcpy (cl.model_name[nummodels], str, sizeof(cl.model_name[nummodels]));

			if (nummodels == 1)
				if (!com_serveractive) 
				{
					char mapname[MAX_QPATH];
					COM_StripExtension (COM_SkipPath(cl.model_name[1]), mapname, sizeof(mapname));
					Cvar_ForceSet (&host_mapname, mapname);
				}
		}

		if ((n = MSG_ReadByte())) 
		{
			if (cls.mvdplayback == QTV_PLAYBACK) 
			{
				// none
			}
			else 
			{
				MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
			
				#if defined (PROTOCOL_VERSION_FTE) && defined (FTE_PEXT_MODELDBL)
				MSG_WriteString (&cls.netchan.message, va("modellist %i %i", cl.servercount, (nummodels&0xff00)+n));
				#else
				MSG_WriteString (&cls.netchan.message, va("modellist %i %i", cl.servercount, n));
				#endif // PROTOCOL_VERSION_FTE
			}

			return;
		}
	}
	else 
	{
		// Up to 2.1 (taken from http://www.quakewiki.net/archives/demospecs/qwd/qwd.html#AEN562)
		nummodels = 0;
		do 
		{
			if (++nummodels > 255)
				Host_Error ("Server sent too many model_precache\n");
			str = MSG_ReadString ();
			strlcpy (cl.model_name[nummodels], str, sizeof(cl.model_name[nummodels]));

			if (nummodels == 1)
				if (!com_serveractive) 
				{
					char mapname[MAX_QPATH];
					COM_StripExtension (COM_SkipPath(cl.model_name[1]), mapname, sizeof(mapname));
					Cvar_ForceSet (&host_mapname, mapname);
				}
		} while (*str);
	}
	// We now get here after having received both soundlist and modellist, but no
	// sounds have been downloaded yet, we must do that first, when that is finished
	// it will call for model download 
	// FIXME Implement a download queue later on and thus break this long chain of events
	cls.downloadnumber = 0;
	cls.downloadtype = dl_sound;
	Sound_NextDownload();
}

void CL_ParseBaseline (entity_state_t *es)
{
	int	i;

	es->modelindex = MSG_ReadByte ();
	es->frame = MSG_ReadByte ();
	es->colormap = MSG_ReadByte();
	es->skinnum = MSG_ReadByte();

	for (i = 0; i < 3; i++) 
	{
		es->origin[i] = MSG_ReadCoord ();
		es->angles[i] = MSG_ReadAngle ();
	}

#ifdef FTE_PEXT_TRANS
	es->trans = 0;
#endif
#ifdef FTE_PEXT_COLOURMOD
	es->colourmod[0] = 0;
	es->colourmod[1] = 0;
	es->colourmod[2] = 0;
#endif
}

// An easy way to keep compatability with other entity extensions
#if defined (PROTOCOL_VERSION_FTE) && defined (FTE_PEXT_SPAWNSTATIC2)
extern void CL_ParseDelta (entity_state_t *from, entity_state_t *to, int bits);

static void CL_ParseSpawnBaseline2 (void)
{
	entity_state_t nullst, es;

	if (!(cls.fteprotocolextensions & FTE_PEXT_SPAWNSTATIC2)) 
	{
		Com_Printf ("illegible server message\nsvc_fte_spawnbaseline2 (%i) without FTE_PEXT_SPAWNSTATIC2\n", svc_fte_spawnbaseline2);
		Host_EndGame();
	}

	memset(&nullst, 0, sizeof (entity_state_t));
	memset(&es, 0, sizeof (entity_state_t));

	CL_ParseDelta(&nullst, &es, MSG_ReadShort());
	memcpy(&cl_entities[es.number].baseline, &es, sizeof(es));
}
#endif

// Static entities are non-interactive world objects like torches
void CL_ParseStatic (qbool extended)
{
	entity_t *ent;
	entity_state_t es;

	if (extended)
	{
		entity_state_t nullst;
		memset (&nullst, 0, sizeof(entity_state_t));

		CL_ParseDelta (&nullst, &es, MSG_ReadShort());
	} 
	else
	{
		CL_ParseBaseline (&es);
	}

	if (cl.num_statics >= MAX_STATIC_ENTITIES) {
		Host_Error("Too many static entities");
	}
	ent = &cl_static_entities[cl.num_statics++];
	ent->entity_id = cl.num_statics;

	// Copy it to the current state
	ent->model = cl.model_precache[es.modelindex];
	ent->frame = es.frame;
	ent->colormap = vid.colormap;
	ent->skinnum = es.skinnum;
#ifdef FTE_PEXT_TRANS
	// set trans, 0 and 255 are both opaque, represented by alpha 0.
	ent->alpha = es.trans == 255 ? 0.0f : (float)es.trans / 254.0f;
#endif
#ifdef FTE_PEXT_COLOURMOD
	// Skip colourmod if unset, or identity
	if ((es.colourmod[0] > 0 || es.colourmod[1] > 0 || es.colourmod[2] > 0) &&
	    !(es.colourmod[0] == 32 && es.colourmod[1] == 32 && es.colourmod[2] == 32))
	{
		ent->r_modelcolor[0] = (float)es.colourmod[0] * 8.0f / 256.0f;
		ent->r_modelcolor[1] = (float)es.colourmod[1] * 8.0f / 256.0f;
		ent->r_modelcolor[2] = (float)es.colourmod[2] * 8.0f / 256.0f;
		ent->renderfx |= RF_FORCECOLOURMOD;
	}
#endif

	VectorCopy(es.origin, ent->origin);
	VectorCopy(es.angles, ent->angles);

	R_AddEfrags(ent);
}

void CL_ParseStaticSound (void)
{
	extern cvar_t cl_staticsounds;
	static_sound_t ss;
	int i;

	for (i = 0; i < 3; i++) {
		ss.org[i] = MSG_ReadCoord();
	}

	ss.sound_num = MSG_ReadByte();
	ss.vol = MSG_ReadByte();
	ss.atten = MSG_ReadByte();

	if (cl.num_static_sounds < MAX_STATIC_SOUNDS) 
	{
		cl.static_sounds[cl.num_static_sounds] = ss;
		cl.num_static_sounds++;
	}

	if ((int) cl_staticsounds.value)
		S_StaticSound(cl.sound_precache[ss.sound_num], ss.org, ss.vol, ss.atten);
}

/*
=====================================================================
ACTION MESSAGES
=====================================================================
*/

void CL_ParseStartSoundPacket(void)
{
    vec3_t pos;
    int channel, ent, sound_num, volume, i;
	int tracknum;
    float attenuation;

    channel = MSG_ReadShort();

	volume = (channel & SND_VOLUME) ? MSG_ReadByte() : DEFAULT_SOUND_PACKET_VOLUME;

	attenuation = (channel & SND_ATTENUATION) ? MSG_ReadByte() / 64.0 : DEFAULT_SOUND_PACKET_ATTENUATION;

	sound_num = MSG_ReadByte();

	for (i = 0; i < 3; i++)
		pos[i] = MSG_ReadCoord();

	ent = (channel >> 3) & 1023;
	channel &= 7;

	if (ent > CL_MAX_EDICTS)
		Host_Error ("CL_ParseStartSoundPacket: ent = %i", ent);

	// MVD Playback
    if (cls.mvdplayback)
	{
	    tracknum = Cam_TrackNum();

	    if (cl.spectator && tracknum != -1 && ent == tracknum + 1 && cl_multiview.value < 2)
		{
		    ent = cl.playernum + 1;
		}
    }

	if (CL_Demo_SkipMessage(true))
		return;

    S_StartSound (ent, channel, cl.sound_precache[sound_num], pos, volume/255.0, attenuation);

	if (ent == cl.playernum+1)
		TP_CheckPickupSound (cl.sound_name[sound_num], pos);
}

// Server information pertaining to this client only, sent every frame
void CL_ParseClientdata (void) 
{
	int newparsecount, i;
	float latency;
	frame_t *frame;

	// calculate simulated time of message
	newparsecount = cls.netchan.incoming_acknowledged;

	cl.oldparsecount = (cls.mvdplayback) ? newparsecount - 1 : cl.parsecount;
	cl.parsecount = newparsecount;
	cl.parsecountmod = (cl.parsecount & UPDATE_MASK);
	frame = &cl.frames[cl.parsecountmod];

	frame->receivedtime = cls.realtime;
	if (cls.mvdplayback) {
		frame->senttime = cls.realtime - cls.frametime;
	}
	else if (cls.demoplayback) {
		frame->receivedtime = cls.demopackettime;
	}
	cl.parsecounttime = cl.frames[cl.parsecountmod].senttime;

	frame->seq_when_received = cls.netchan.outgoing_sequence;

	frame->receivedsize = net_message.cursize;

	// update network stats table
	i = cls.netchan.incoming_sequence & NETWORK_STATS_MASK;
	network_stats[i].receivedtime = cls.realtime;
	network_stats[i].receivedsize = net_message.cursize;
	network_stats[i].seq_diff = cls.netchan.outgoing_sequence - cls.netchan.incoming_sequence;

	// calculate latency
	latency = frame->receivedtime - frame->senttime;

	if (latency >= 0 && latency <= 1) 
	{
		// drift the average latency towards the observed latency
		if (latency <= cls.latency)
			cls.latency = latency;
		else
			cls.latency += min(0.001, latency - cls.latency);	// drift up, so correction is needed
	}
}

void CL_NewTranslation (int slot)
{
	player_info_t *player;

	if (cls.state < ca_connected)
	{
		return;
	}

	if (slot >= MAX_CLIENTS)
	{
		Sys_Error ("CL_NewTranslation: slot >= MAX_CLIENTS");
	}

	player = &cl.players[slot];
	if (!player->name[0] || player->spectator) {
		return;
	}

	player->topcolor = player->real_topcolor;
	player->bottomcolor = player->real_bottomcolor;
	player->teammate = false;

	skinforcing_team = TP_SkinForcingTeam();

	if (!cl.teamfortress && !(cl.fpd & FPD_NO_FORCE_COLOR)) {
		qbool lockedTeams = TP_TeamLockSpecified();
		qbool teammate = false;

		// it's me or it's teamplay and he's my teammate
		if (cl.spectator && slot == cl.spec_track && !lockedTeams) {
			teammate = true;
		}
		else if (!cl.spectator && slot == cl.playernum) {
			teammate = true;
		}
		else if (cl.teamplay && !strcmp(player->team, skinforcing_team)) {
			teammate = true;
		}

		player->teammate = teammate;

		if (teammate) {
			if (cl_teamtopcolor.integer != -1) {
				player->topcolor = cl_teamtopcolor.value;
			}
			if (cl_teambottomcolor.integer != -1) {
				player->bottomcolor = cl_teambottomcolor.value;
			}
		}
		else if (slot != cl.playernum) {
			if (cl_enemytopcolor.integer != -1) {
				player->topcolor = cl_enemytopcolor.value;
			}
			if (cl_enemybottomcolor.integer != -1) {
				player->bottomcolor = cl_enemybottomcolor.value;
			}
		}
	}

	R_TranslatePlayerSkin(slot);
}

void CL_ProcessUserInfo(int slot, player_info_t *player, char *key)
{
	strlcpy(player->name, Info_ValueForKey(player->userinfo, "name"), sizeof(player->name));

	if (!player->name[0] && player->userid && strlen(player->userinfo) >= MAX_INFO_STRING - 17) {
		// Somebody's trying to hide himself by overloading userinfo.
		strlcpy(player->name, " ", sizeof(player->name));
	}

	CL_RemovePrefixFromName(slot);

	player->real_topcolor = atoi(Info_ValueForKey(player->userinfo, "topcolor"));
	player->real_bottomcolor = atoi(Info_ValueForKey(player->userinfo, "bottomcolor"));

	strlcpy(player->team, Info_ValueForKey(player->userinfo, "team"), sizeof(player->team));

	if (atoi(Info_ValueForKey(player->userinfo, "*spectator"))) {
		player->spectator = true;
	}
	else {
		player->spectator = false;
	}

	if (slot == cl.playernum && player->name[0]) {
		if (cl.spectator != player->spectator) {
			Cam_Reset();
			cl.spectator = player->spectator;
			TP_RefreshSkins();
		}
	}

	Sbar_Changed();

	Skin_UserInfoChange(slot, player, key);

	strlcpy(player->_team, player->team, sizeof (player->_team));

	// Fix the team color in scoreboard when using TF
	player->known_team_color = 0;
	if (!strcasecmp(player->team, cl.fixed_team_names[0])) {
		player->known_team_color = 13;
	}
	else if (!strcasecmp(player->team, cl.fixed_team_names[1])) {
		player->known_team_color = 4;
	}
	else if (!strcasecmp(player->team, cl.fixed_team_names[2])) {
		player->known_team_color = 12;
	}
	else if (!strcasecmp(player->team, cl.fixed_team_names[3])) {
		player->known_team_color = 11;
	}

	// login info
	strlcpy(player->loginname, Info_ValueForKey(player->userinfo, "*auth"), sizeof(player->loginname));
	strlcpy(player->loginflag, Info_ValueForKey(player->userinfo, "*flag"), sizeof(player->loginflag));
	player->loginflag_id = CL_LoginImageId(player->loginflag);

	// gender
	{
		char* userinfo_gender = Info_ValueForKey(player->userinfo, "gender");
		if (!*userinfo_gender) {
			userinfo_gender = Info_ValueForKey(player->userinfo, "g");
		}

		player->gender = gender_unknown;
		if (userinfo_gender && userinfo_gender[0]) {
			char gender = userinfo_gender[0];
			if (gender == '0' || gender == 'M') {
				player->gender = gender_male;
			}
			else if (gender == '1' || gender == 'F') {
				player->gender = gender_female;
			}
			else if (gender == '2' || gender == 'N') {
				player->gender = gender_neutral;
			}
		}
	}

	// chat status
	{
		char* s = Info_ValueForKey(player->userinfo, "chat");

		player->chatflag = 0;
		if (s && s[0]) {
			player->chatflag = Q_atoi(s);
		}
	}
}

void CL_NotifyOnFull(void)
{
	if (!cl.spectator && !cls.demoplayback) {
		int limit = Q_atoi(Info_ValueForKey(cl.serverinfo, "maxclients"));
		int players = 0;
		int i;

		for (i = 0; i < MAX_CLIENTS; i++) {
			if (*cl.players[i].name && !cl.players[i].spectator) {
				players++;
			}
		}

		if (players >= limit) {
			VID_NotifyActivity();
		}
	}
}

void CL_PlayerEnterSlot(player_info_t *player) 
{
	extern player_state_t oldplayerstates[MAX_CLIENTS];

	player->ignored = false;
	memset(&oldplayerstates[player - cl.players], 0, sizeof(player_state_t));
	Stats_EnterSlot(player - cl.players);
	CL_NotifyOnFull();
}

void CL_PlayerLeaveSlot(player_info_t *player) 
{
	return;
}

void CL_UpdateUserinfo (void) 
{
	qbool was_empty_slot;
	int slot;
	player_info_t *player;

	if (CL_Demo_SkipMessage(false)) {
		// Older demos (kteams?) can send blank userinfo strings to specs, then re-send the old strings again in next packet
		//   Not sure why this happened, but it breaks our scoreboard, autotrack etc, so ignore
		MSG_ReadByte();
		MSG_ReadLong();
		MSG_ReadString();
		return;
	}

	slot = MSG_ReadByte();
	if (slot >= MAX_CLIENTS)
		Host_Error ("CL_ParseServerMessage: svc_updateuserinfo > MAX_CLIENTS");

	player = &cl.players[slot];

	was_empty_slot = player->name[0] ? false : true;

	player->userid = MSG_ReadLong();
	strlcpy (player->userinfo, MSG_ReadString(), sizeof(player->userinfo));

	CL_ProcessUserInfo(slot, player, NULL);

	if (player->name[0] && was_empty_slot) {
		CL_PlayerEnterSlot(player);
		MVD_Init_Info(slot);
	}
	else if (!player->name[0] && !was_empty_slot) {
		CL_PlayerLeaveSlot(player);
		MVD_Init_Info(slot);
	}
}

void CL_SetInfo (void) 
{
	int	slot;
	player_info_t *player;
	char key[MAX_INFO_STRING], value[MAX_INFO_STRING];

	slot = MSG_ReadByte ();
	if (slot >= MAX_CLIENTS)
		Host_Error ("CL_ParseServerMessage: svc_setinfo > MAX_CLIENTS");

	player = &cl.players[slot];

	strlcpy(key, MSG_ReadString(), sizeof(key));
	strlcpy(value, MSG_ReadString(), sizeof(value));

	if (!cl.teamfortress)	// don't allow cheating in TF
		Com_DPrintf ("SETINFO %s: %s=%s\n", player->name, key, value);

	Info_SetValueForStarKey (player->userinfo, key, value, MAX_INFO_STRING);

	CL_ProcessUserInfo (slot, player, key);
}

/*
 * qqshka: Well, "cmd pext" slightly broken in MVDSV 0.30. I have to fix it somehow.
 */
static void CL_PEXT_Fix(void)
{
	char version_bugged[] = "MVDSV 0.30";
	char *version = Info_ValueForKey(cl.serverinfo, "*version");

	if (!strncmp(version, version_bugged, sizeof(version_bugged)-1))
	{
		// MVDSV 0.30 support maximum this FTE extensions.
#ifdef PROTOCOL_VERSION_FTE
		{
			unsigned int ext = 0;
#ifdef FTE_PEXT_ACCURATETIMINGS
			ext |= FTE_PEXT_ACCURATETIMINGS;
#endif
#ifdef FTE_PEXT_256PACKETENTITIES
			ext |= FTE_PEXT_256PACKETENTITIES;
#endif
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
			ext |= FTE_PEXT_CHUNKEDDOWNLOADS;
#endif
			cls.fteprotocolextensions &= ext;
		}
#endif // PROTOCOL_VERSION_FTE

		// MVDSV 0.30 support maximum this FTE extensions2.
#ifdef PROTOCOL_VERSION_FTE2
		{
			unsigned int ext = 0;
			cls.fteprotocolextensions2 &= ext;
		}
#endif // PROTOCOL_VERSION_FTE2

#ifdef FTE_PEXT_FLOATCOORDS
		if (!com_serveractive)
		{
			if (msg_coordsize != 2 || msg_anglesize != 1)
			{
				Com_DPrintf("Fixing FTE_PEXT_FLOATCOORDS!\n");

				msg_coordsize = 2;
				msg_anglesize = 1;
			}
		}
#endif
	}
}

// Called by CL_FullServerinfo_f and CL_ParseServerInfoChange
void CL_ProcessServerInfo (void) 
{
	char *p, *minlight;
	int new_teamplay, newfpd;
	qbool skin_refresh, standby, countdown;

	// fix broken PEXT.
	CL_PEXT_Fix(); // must be called once from CL_FullServerinfo_f() but should be ok here too.

	// game type (sbar code checks it) (GAME_DEATHMATCH default)
	cl.gametype = *(p = Info_ValueForKey(cl.serverinfo, "deathmatch")) ? (atoi(p) ? GAME_DEATHMATCH : GAME_COOP) : GAME_DEATHMATCH;

	// server side fps restriction
	cl.maxfps = Q_atof(Info_ValueForKey(cl.serverinfo, "maxfps"));

	newfpd = cls.demoplayback ? 0 : atoi(Info_ValueForKey(cl.serverinfo, "fpd"));

	p = Info_ValueForKey(cl.serverinfo, "status");
	standby = !strcasecmp(p, "standby");
	countdown = !strcasecmp(p, "countdown");

	if ((cl.standby || cl.countdown) && !(standby || countdown)) 
	{
		cl.gametime = 0;
		cl.gamestarttime = Sys_DoubleTime();

		if (cls.mvdplayback) {
			MVD_GameStart();
		}
	}

	if (countdown && cl.countdown)
	{
		TP_ExecTrigger("f_countdownstart");
	}
	else if (standby && !cl.standby && !countdown && cl.countdown)
	{
		TP_ExecTrigger("f_countdownbreak");
	}

	cl.standby = standby;
	cl.countdown = countdown;

	cl.minlight = (strlen(minlight = Info_ValueForKey(cl.serverinfo, "minlight")) ? bound(0, Q_atoi(minlight), 255) : 4);

	// Get the server's ZQuake extension bits
	cl.z_ext = atoi(Info_ValueForKey(cl.serverinfo, "*z_ext"));

	// Initialize cl.maxpitch & cl.minpitch
	p = (cl.z_ext & Z_EXT_PITCHLIMITS) ? Info_ValueForKey (cl.serverinfo, "maxpitch") : "";
	cl.maxpitch = *p ? Q_atof(p) : 80.0f;
	p = (cl.z_ext & Z_EXT_PITCHLIMITS) ? Info_ValueForKey (cl.serverinfo, "minpitch") : "";
	cl.minpitch = *p ? Q_atof(p) : -70.0f;

	// movement vars for prediction
	cl.bunnyspeedcap = Q_atof(Info_ValueForKey(cl.serverinfo, "pm_bunnyspeedcap"));
	movevars.slidefix = (Q_atof(Info_ValueForKey(cl.serverinfo, "pm_slidefix")) != 0);
	movevars.airstep = (Q_atof(Info_ValueForKey(cl.serverinfo, "pm_airstep")) != 0);
	movevars.pground = (Q_atof(Info_ValueForKey(cl.serverinfo, "pm_pground")) != 0)
		&& (cl.z_ext & Z_EXT_PF_ONGROUND) /* pground doesn't make sense without this */;
	movevars.ktjump = *(p = Info_ValueForKey(cl.serverinfo, "pm_ktjump")) ? Q_atof(p) : cl.teamfortress ? 0 : 1;
	movevars.rampjump = (Q_atof(Info_ValueForKey(cl.serverinfo, "pm_rampjump")) != 0);
	movevars.safestrafe = Q_atoi(Info_ValueForKey(cl.serverinfo, "sv_safestrafe"));

	// Deathmatch and teamplay.
	cl.deathmatch = atoi(Info_ValueForKey(cl.serverinfo, "deathmatch"));
	new_teamplay = atoi(Info_ValueForKey(cl.serverinfo, "teamplay"));

	// Timelimit and fraglimit.
	cl.timelimit = atoi(Info_ValueForKey(cl.serverinfo, "timelimit"));
	cl.fraglimit = atoi(Info_ValueForKey(cl.serverinfo, "fraglimit"));

	cl.racing = !strcmp(Info_ValueForKey(cl.serverinfo, "ktxmode"), "race");
	cl.scoring_system = atoi(Info_ValueForKey(cl.serverinfo, "scoring"));

	// Update fakeshaft limits
	{
		char* p = Info_ValueForKey(cl.serverinfo, "fakeshaft");
		if (!p[0]) {
			p = Info_ValueForKey(cl.serverinfo, "truelightning");
		}

		if (p[0]) {
			cl.fakeshaft_policy = bound(0, Q_atof(p), 1);
		}
		else {
			cl.fakeshaft_policy = 1;
		}
	}

	// Update skins if needed.
	skin_refresh = ( !new_teamplay != !cl.teamplay || ( (newfpd ^ cl.fpd) & (FPD_NO_FORCE_COLOR|FPD_NO_FORCE_SKIN) ) );
	cl.teamplay = new_teamplay;
	cl.fpd = newfpd;
	if (skin_refresh)
		TP_RefreshSkins();

	// Set fixed teamnames if broadcast by server
	{
		const char* s = NULL;

		if (*(s = Info_ValueForKey(cl.serverinfo, "team1")) || *(s = Info_ValueForKey(cl.serverinfo, "t1"))) {
			strlcpy(cl.fixed_team_names[0], s, sizeof(cl.fixed_team_names[0]));
		}
		if (*(s = Info_ValueForKey(cl.serverinfo, "team2")) || *(s = Info_ValueForKey(cl.serverinfo, "t2"))) {
			strlcpy(cl.fixed_team_names[1], s, sizeof(cl.fixed_team_names[1]));
		}
		if (*(s = Info_ValueForKey(cl.serverinfo, "team3")) || *(s = Info_ValueForKey(cl.serverinfo, "t3"))) {
			strlcpy(cl.fixed_team_names[2], s, sizeof(cl.fixed_team_names[2]));
		}
		if (*(s = Info_ValueForKey(cl.serverinfo, "team4")) || *(s = Info_ValueForKey(cl.serverinfo, "t4"))) {
			strlcpy(cl.fixed_team_names[3], s, sizeof(cl.fixed_team_names[3]));
		}
	}
}

// Parse a string looking like this: //vwep vwplayer w_axe w_shot w_shot2
void CL_ParseVWepPrecache (char *str)
{
	int i, num;
	const char *p;

	Cmd_TokenizeString (str + 2 /* skip the // */);

	if (Cmd_Argc() < 2)
	{
		cl.vwep_enabled = 0;
		return;
	}

	if (cls.state == ca_active)
	{
		// vweps can be turned off on the fly, but not back on
		Com_DPrintf ("CL_ParseVWepPrecache: ca_active, ignoring\n");
		return;
	}

	num = min(Cmd_Argc()-1, MAX_VWEP_MODELS);

	for (i = 0; i < num; i++)
	{
		p = Cmd_Argv(i+1);

		if (!strcmp(p, "-")) 
		{
			// empty model
			strlcpy (cl.vw_model_name[i], "-", MAX_QPATH);
		}
		else 
		{
			if (strstr(p, "..") || p[0] == '/' || p[0] == '\\')
				Host_Error("CL_ParseVWepPrecache: illegal model name '%s'", p);

			if (strchr(p, '/'))
			{
				// A full path was specified.
				strlcpy(cl.vw_model_name[i], p, sizeof(cl.vw_model_name[0]));
			}
			else 
			{
				// Use default path.
				strlcpy(cl.vw_model_name[i], "progs/", sizeof(cl.vw_model_name[0]));
				strlcat(cl.vw_model_name[i], p, sizeof(cl.vw_model_name[0]));
			}

			// Use default extension if not specified.
			if (!strchr(p, '.'))
				strlcat(cl.vw_model_name[i], ".mdl", sizeof(cl.vw_model_name[0]));
		}
	}

	Com_DPrintf ("VWEP precache: %i models\n", num);
}

void CL_ParseServerInfoChange (void) 
{
	char key[MAX_INFO_STRING], value[MAX_INFO_STRING];

	strlcpy (key, MSG_ReadString(), sizeof(key));
	strlcpy (value, MSG_ReadString(), sizeof(value));

	Com_DPrintf ("SERVERINFO: %s=%s\n", key, value);
	if (!cl.standby && !cl.countdown && !strncmp(key, "status", 6)) 
	{
		int timeleft = atoi(value) * 60;
		if (timeleft) 
		{
			if (cls.demoplayback) 
			{
				cl.gametime = (cl.timelimit * 60) - timeleft;
			}
			else 
			{
				cl.gamestarttime = Sys_DoubleTime() - (cl.timelimit * 60) + timeleft - cl.gamepausetime;
				Com_DPrintf("Clock sync, match started %i seconds ago\n", (cl.timelimit*60) + atoi(value)*60);
			}
		}
	}

	Info_SetValueForKey (cl.serverinfo, key, value, MAX_SERVERINFO_STRING);

	CL_ProcessServerInfo ();
}

// Converts quake color 4 to "&cf00", 13 to "&c00f", 12 to "&cff0" and so on
// those are marks used to make colored text in console
char *CL_Color2ConColor(int color)
{
	static char buf[6] = "&c000";
	const char hexc[] = "0123456789abcdefffffffffffffffff";
	// For some reason my palette doesn't give higher number then 127, those Fs are there for palettes that give higher than that
	int x = Sbar_ColorForMap(color);
	buf[2] = hexc[host_basepal[x * 3 + 0] / 8];
	buf[3] = hexc[host_basepal[x * 3 + 1] / 8];
	buf[4] = hexc[host_basepal[x * 3 + 2] / 8];
	return buf;
}

// Will add colors to nicks in "ParadokS rides JohnNy_cz's rocket"
// source - source frag message, dest - destination buffer, destlen - length of buffer
// cff - see the cfrags_format definition 
static wchar* CL_ColorizeFragMessage (const wchar *source, cfrags_format *cff)
{
	static wchar dest_buf[2048] = {0};
	wchar col1[6+1] = {0}, col2[6+1] = {0}, *dest = dest_buf, *col_off;
	int destlen = sizeof(dest_buf)/sizeof(dest_buf[0]), len;

	dest[0] = 0; // new string

	qwcslcpy(col1, str2wcs(CL_Color2ConColor(cff->p1col)), sizeof(col1)/sizeof(wchar));
	qwcslcpy(col2, str2wcs(CL_Color2ConColor(cff->p2col)), sizeof(col2)/sizeof(wchar));

	// before 1st nick
	qwcslcpy(dest, source, bound(0, cff->p1pos + 1, destlen));
	destlen -= (len = qwcslen(dest));
	dest += len;
	
	// color1
	len = qwcslen(col1) + 1;
	qwcslcpy(dest, col1, bound(0, len, destlen));
	destlen -= (len = qwcslen(dest));
	dest += len;
	// 1st nick
	qwcslcpy(dest, source + cff->p1pos, bound(0, cff->p1len + 1, destlen));
	destlen -= (len = qwcslen(dest));
	dest += len;
	// color off
	len = qwcslen(col_off = str2wcs("&cfff")) + 1;
	qwcslcpy(dest, col_off, bound(0, len, destlen));
	destlen -= (len = qwcslen(dest));
	dest += len;

	if (cff->p2len)
	{
		// middle part
		qwcslcpy(dest, source + cff->p1pos + cff->p1len, bound(0, cff->p2pos - cff->p1len - cff->p1pos + 1, destlen));
		destlen -= (len = qwcslen(dest));
		dest += len;
		// color2
		len = qwcslen(col2) + 1;
		qwcslcpy(dest, col2, bound(0, len, destlen));
		destlen -= (len = qwcslen(dest));
		dest += len;
		// 2nd nick
		qwcslcpy(dest, source + cff->p2pos, bound(0, cff->p2len + 1, destlen));
		destlen -= (len = qwcslen(dest));
		dest += len;
		// color off
		len = qwcslen(col_off = str2wcs("&cfff")) + 1;
		qwcslcpy(dest, col_off, bound(0, len, destlen));
		destlen -= (len = qwcslen(dest));
		dest += len;
		// the rest
		qwcslcpy(dest, source + cff->p2pos + cff->p2len, destlen);
	}
	else 
	{
		// the rest
		qwcslcpy(dest, source + cff->p1pos + cff->p1len, destlen);
	}

	return dest_buf;
}

extern cvar_t con_highlight, con_highlight_mark, name;
extern cvar_t cl_showFragsMessages;
extern cvar_t scr_coloredfrags;

// For CL_ParsePrint
static void FlushString (const wchar *s, int level, qbool team, int offset) 
{
	extern cvar_t demo_jump_skip_messages;

	char *s0; // C-char copy of s

	char *mark;
	const wchar *text; // needed for con_highlight work
	char *f; 

	wchar zomfg[4096]; // FIXME

	cfrags_format cff = {0, 0, 0, 0, 0, 0, false}; // Stats_ParsePrint stuff

	// During gametime, use notify for team messages only
	if (con_mm2_only.integer && !team && !(cl.standby || cl.countdown))
		Print_flags[Print_current] |= PR_NONOTIFY;

	s0 = wcs2str (s);
	f = strstr (s0, name.string);
	CL_SearchForReTriggers (s0, 1<<level); // re_triggers, s0 not modified

	// Highlighting on && nickname found && it's not our own text (nickname not close to the beginning)
	if (con_highlight.value && f && ((f - s0) > 1)) 
	{
		switch ((int)(con_highlight.value)) 
		{
			case 1:
				mark = "";
				text = s;
				break;
			case 2:
				mark = con_highlight_mark.string;
				text = (level == PRINT_CHAT) ? (const wchar *) TP_ParseWhiteText (s, team, offset) : s;
				break;
			default:
			case 3:
				mark = con_highlight_mark.string;
				text = s;
				break;
		}
	}
	else 
	{
		mark = "";
		text = (level == PRINT_CHAT) ? (const wchar *) TP_ParseWhiteText(s, team, offset) : s;
	}

	// s0 is same after Stats_ParsePrint like before, but Stats_ParsePrint modify it during it's work
	// we can change this function a bit, so s0 can be const char*
	Stats_ParsePrint(s0, level, &cff);

	if (CL_Demo_SkipMessage(demo_jump_skip_messages.integer >= 1)) {
		return;
	}

	// Colorize player names here
	if (scr_coloredfrags.value && cff.isFragMsg && cff.p1len) {
		text = CL_ColorizeFragMessage(text, &cff);
	}

	/* FIXME
	 * disconnect: There should be something like Com_PrintfW...
	 * we have to *Print* message with one Con_Printf/Con_PrintfW call
	 * else re_triggers with remove option will be fucked
	 * so we have to use additional buffer
	 */
	memset (zomfg, 0, sizeof (zomfg));
	qwcslcpy (zomfg, str2wcs(mark), sizeof (zomfg) / sizeof (wchar));
	qwcslcpy (zomfg + qwcslen (zomfg), text, sizeof (zomfg) / sizeof (wchar) - qwcslen (zomfg));
	if (cl_showFragsMessages.value || !cff.isFragMsg) {
		if (cl_showFragsMessages.integer == 2 && cff.isFragMsg) {
			Print_flags[Print_current] |= PR_NONOTIFY;
		}
		Con_PrintW(zomfg); // FIXME logging
	}

	if (level >= 4)
		return;

	if (team)
		level = 4;

	TP_SearchForMsgTriggers ((const char *)wcs2str(s + offset), level);
}

#define  CHAT_MM1   1
#define  CHAT_MM2   2
#define  CHAT_SPEC  3
int SeparateChat(char *chat, int *out_type, char **out_msg)
{
    int server_cut = 31;    // maximum characters sent in nick by server

    int i;
    int classified = -1;
    int type = 0;
    char *msg=NULL;

	for (i=0; i <= MAX_CLIENTS; i++)
    {
        int client = -1;
        char buf[512];

        if (i == MAX_CLIENTS)
        {
            strlcpy (buf, "console: ", sizeof (buf));

			if (!strncmp(chat, buf, strlen(buf)))
            {
                client = i;
                type = CHAT_MM1;
                msg = chat + strlen(buf);
            }
        }
        else
        {
            if (!cl.players[i].name[0])
                continue;

            snprintf(buf,  sizeof (buf), "%.*s: ", server_cut, Info_ValueForKey(cl.players[i].userinfo, "name"));

			if (!strncmp(chat, buf, strlen(buf)))
            {
                client = i;
                type = CHAT_MM1;
                msg = chat + strlen(buf);
            }

            snprintf(buf,  sizeof (buf), "(%.*s): ", server_cut, Info_ValueForKey(cl.players[i].userinfo, "name"));

			if (!strncmp(chat, buf, strlen(buf)))
            {
                client = i;
                type = CHAT_MM2;
                msg = chat + strlen(buf);
            }

            snprintf(buf,  sizeof (buf), "[SPEC] %.*s: ", server_cut, Info_ValueForKey(cl.players[i].userinfo, "name"));

			if (!strncmp(chat, buf, strlen(buf)))
            {
                client = i;
                type = CHAT_SPEC;
                msg = chat + strlen(buf);
            }
        }

        if (client >= 0)
        {
            if (classified < 0)
                classified = client;
            else
                return -1;
        }
    }
    
    if (classified < 0)
        return -1;

    if (out_msg)
        *out_msg = msg;
    if (out_type)
        *out_type = type;

    return classified;
}

// QTV chat formed like #qtv2_id:qtv2_name: #qtv1_id:qtv1_name: #qtvClient_id:qtvClient_name: chat text
// above example was for case qtvClient -> qtv1 -> qtv2 -> server

// So, this fucntion intended for skipping leading proxies names and ids, and just return "qtvClient_name: chat text"

static char *SkipQTVLeadingProxies(char *s)
{
	char *last = NULL; // pointer to "qtvClient_name: chat text" at the end of parsing or NULL if we fail of some kind

	for ( ; s[0]; )
	{
		if (s[0] == '#' && isdigit(s[1])) // check do we have # and at least one digit
		{
			s++; // skip #
    
			while(isdigit(s[0])) // skip digits
				s++;
    
			if (s[0] == ':') // ok, seems it was qtv chat
			{
				char *name;

				s++; // skip :

				name = s; // remember name start

				// skip name
				// well, this code allow empty names... like "#id:: chat text"
				if (s[0] != ' ') // name must NOT start from space, unless someone do "crime"
				{
					while(s[0] && s[0] != ':')
						s++;

					if (s[0] == ':')
					{
						last = name; // yeah, its well formed qtv chat string

						if (!qtv_skipchained.integer)
							break; // user select to not skip chained proxies

						s++; // skip :

						if (s[0] == ' ')
							s++; // skip space

						continue; // probably we have chained qtvs, lets check it
					}
					else
					{
						break;
					}
				}
				else
				{
					break;
				}
			}
			else
			{
				break; // seems it wasn't chat
			}
		}

		break;
	}

	return last;
}

extern qbool TP_SuppressMessage (wchar *);
extern cvar_t cl_chatsound, msg_filter;
extern cvar_t ignore_qizmo_spec;

void CL_ProcessPrint (int level, char* s0)
{
	qbool suppress_talksound;
	wchar *s, str[2048], *p, check_flood;
	char *qtvtmp, qtvstr[2048];
	int flags = 0, offset = 0;
	size_t len;

	int client;
	int type;
	char *msg;

	char *chat_sound_file;
	float chat_sound_vol = 0.0;

	extern cvar_t ignore_no_weapon;
	extern cvar_t ignore_not_enough_ammo;

	// { QTV: check do this string is QTV chat
	qtvtmp = SkipQTVLeadingProxies(s0);

	if (qtvtmp)
	{
		char name[1024] = {0}, *column;

		column = strchr(qtvtmp, ':');

		if (!column)
		{
			// this must not be the case, but...
			column = qtvtmp;
			name[0] = 0;
		}
		else
		{
			strlcpy(name, qtvtmp, bound(1, column - qtvtmp + 1, (int)sizeof(name)));
		}

		if      (!strncmp(s0, "#0:qtv_say_game:",      sizeof("#0:qtv_say_game:")-1))
			snprintf(qtvstr, sizeof(qtvstr), "%s%s%s\n", TP_ParseFunChars(qtv_gamechatprefix.string, false), name, column);
		else if (!strncmp(s0, "#0:qtv_say_team_game:", sizeof("#0:qtv_say_team_game:")-1))
			snprintf(qtvstr, sizeof(qtvstr), "%s(%s)%s\n", TP_ParseFunChars(qtv_gamechatprefix.string, false), name, column);
		else
			snprintf(qtvstr, sizeof(qtvstr), "%s%s%s\n", TP_ParseFunChars(qtv_chatprefix.string, false), name, column);

		s0 = qtvstr;
	}
	// }

	s = decode_string (s0);

	qwcslcpy (str, s, sizeof(str)/sizeof(str[0]));
	s = str; // so no memmory overwrite, because decode_string() uses static buffers

	if (level == PRINT_CHAT) 
	{
		if (TP_SuppressMessage (s)) {
			Com_DPrintf("Suppressed TP message: %s\n", s);
			return;
		}

		s0 = wcs2str (s); // TP_SuppressMessage may modify the source string, so s0 should be updated

		flags = TP_CategorizeMessage (s0, &offset);
		if (qtvtmp) {
			flags |= msgtype_qtv;
		}

		FChecks_CheckRequest (s0);

		s0 = wcs2str (s);

		if (Ignore_Message(s0, flags, offset)) {
			Com_DPrintf("Ignoring message: %s\n", s0);
			return;
		}

		if (flags == 0 && ignore_qizmo_spec.value && strlen (s0) > 0 && s0[0] == '[' && strstr(s0, "]: ") ) {
			Com_DPrintf("Ignoring qizmo message: %s\n", s0);
			return;
		}

		if (flags == 2 && strstr(s0, "#inlay#") ) {
			Com_DPrintf("Ignoring unezQuake inlay message: %s\n", s0);
			return;
		}

		if (flags == 2 && !TP_FilterMessage (s + offset)) {
			Com_DPrintf("Filtered message: %s\n", s0);
			return;
		}

		check_flood = Ignore_Check_Flood(s0, flags, offset); // @CHECKME@
		if (check_flood == IGNORE_NO_ADD) {
			Com_DPrintf("Ignoring flood message: %s\n", s0);
			return;
		}
		else if (check_flood == NO_IGNORE_ADD)
			Ignore_Flood_Add(s0); // @CHECKME@

		suppress_talksound = false;

		if (flags == 2) 
		{
			suppress_talksound = TP_CheckSoundTrigger (s + offset);
			s0 = wcs2str (s); // TP_CheckSoundTrigger may modify the source string, so s0 should be updated
		}

		if (!cl_chatsound.value ||						// no sound at all
				(cl_chatsound.value == 2 && flags != 2))	// only play sound in mm2
			suppress_talksound = true;

		chat_sound_file = NULL;

		client = SeparateChat(s0, &type, &msg); // @CHECKME@

		if (client >= 0 && !suppress_talksound)
		{
			if (
					(
					 (type == CHAT_MM1 || type == CHAT_SPEC)
					 && (msg_filter.value == 1 || msg_filter.value == 3)
					)
					|| (
						(type == CHAT_MM2)
						&& (msg_filter.value == 2 || msg_filter.value == 3)
					   )
			   ) {
				return;
			}

			// Allow customisation of sounds...
			if (cl.players[client].spectator)
			{
				chat_sound_file = con_sound_spec_file.string;
				chat_sound_vol = con_sound_spec_volume.value;
			}
			else
			{
				switch (type)
				{
					case CHAT_MM1:
						chat_sound_file = con_sound_mm1_file.string;
						chat_sound_vol = con_sound_mm1_volume.value;
						break;
					case CHAT_MM2:
						chat_sound_file = con_sound_mm2_file.string;
						chat_sound_vol = con_sound_mm2_volume.value;
						break;
					case CHAT_SPEC:
						chat_sound_file = con_sound_spec_file.string;
						chat_sound_vol = con_sound_spec_volume.value;
						break;
					default:
						break;
				}
			}

			// ... but only when spec (players can still customise volume)
			if (!cls.demoplayback && !cl.spectator) {
				chat_sound_file = DEFAULT_CHAT_SOUND;
			}
		}

		if (chat_sound_file == NULL) {
			// assign "other" if not recognized
			chat_sound_file = con_sound_other_file.string;
			chat_sound_vol = con_sound_other_volume.value;
		}

		if (chat_sound_vol > 0 && !suppress_talksound) {
			S_LocalSoundWithVol(chat_sound_file, chat_sound_vol);
		}

		if (level >= PRINT_HIGH && s[0]) // actually there are no need for level >= PRINT_HIGH check
			VID_NotifyActivity();

		if (s[0])  // KT sometimes sends empty strings
		{
			// @CHECKME@
			if (con_timestamps.integer) {
				SYSTEMTIME lt;
				char tmpbuf[16];
				GetLocalTime (&lt);
				if (con_timestamps.integer == 2 && (cl.spectator || cls.demoplayback || cl.standby)) {
					snprintf(tmpbuf, sizeof(tmpbuf), "%2d:%02d:%02d ", lt.wHour, lt.wMinute, lt.wSecond);
					Com_Printf(tmpbuf);
				}
				else {
					snprintf(tmpbuf, sizeof(tmpbuf), "%2d:%02d ", lt.wHour, lt.wMinute);
					Com_Printf(tmpbuf);
				}
			}
		}

		if (cl_nofake.value == 1 || (cl_nofake.value == 2 && flags != 2)) 
		{
			for (p = s; *p; p++)
			{
				if (*p == 0x0D || (*p == 0x0A && p[1]))
					*p = ' ';
			}
		}
	}
	else if (level == PRINT_HIGH)
	{
		if (ignore_no_weapon.integer > 0 && strncmp(s0, "no weapon", 9) == 0)
		{
			return;
		}
		else if (ignore_not_enough_ammo.integer > 0 && strncmp(s0, "not enough ammo", 15) == 0)
		{
			return;
		}
	}

	if (cl.sprint_buf[0] && (level != cl.sprint_level || s[0] == 1 || s[0] == 2)) 
	{
		FlushString (cl.sprint_buf, cl.sprint_level, false, 0);
		cl.sprint_buf[0] = 0;
	}

	if (s[0] == 1 || s[0] == 2) 
	{
		FlushString (s, level, (flags == 2), offset);
		return;
	}

	// Emulate qwcslcat (which is not implemented)
	qwcslcpy (cl.sprint_buf + qwcslen(cl.sprint_buf), s, sizeof(cl.sprint_buf)/sizeof(wchar) - qwcslen(cl.sprint_buf));
	cl.sprint_level = level;

	if ((p = qwcsrchr(cl.sprint_buf, '\n'))) 
	{
		len = p - cl.sprint_buf + 1;
		memcpy(str, cl.sprint_buf, len * sizeof(wchar));
		str[len] = '\0';
		qwcslcpy (cl.sprint_buf, p + 1, sizeof(cl.sprint_buf)/sizeof(wchar));
		FlushString (str, level, (flags == 2), offset);
	}
}

void CL_ParsePrint (void)
{
	int level = MSG_ReadByte ();
	char* s0 = MSG_ReadString ();

	if (CL_Demo_NotForTrackedPlayer()) {
		return;
	}

	CL_ProcessPrint (level, s0);
}

void CL_ParseStufftext (void) 
{
	char *s = MSG_ReadString();

	// Always process demomarks, regardless of who inserted them
	if (!strcmp(s, "//demomark\n"))
	{
		// demo mark
		if (cls.demoseeking == DST_SEEKING_DEMOMARK) {
			cls.demoseeking = DST_SEEKING_FOUND; // it will reset to the DST_SEEKING_NONE in the deep of the demo code

			return;
		}
	}
	else if (!strncmp(s, "//ktx ", sizeof("//ktx ") - 1)) {
		if (!strncmp(s, "//ktx race ", sizeof("//ktx race ") - 1)) {
			if (!strncmp(s, "//ktx race pm ", sizeof("//ktx race pm ") - 1)) {
				cl.race_pacemaker_ent = atoi(s + sizeof("//ktx race pm ") - 1);
			}
		}
		else if (!strcmp(s, "//ktx matchstart\n")) {
			if (cls.mvdplayback) {
				MVDAnnouncer_MatchStart();
			}
		}
		else if (!strncmp(s, "//ktx took ", sizeof("//ktx took ") - 1)) {
			if (cls.mvdplayback) {
				MVDAnnouncer_ItemTaken(s + 2);
			}
		}
		else if (!strncmp(s, "//ktx timer ", sizeof("//ktx timer ") - 1)) {
			if (cls.mvdplayback) {
				MVDAnnouncer_StartTimer(s + 2);
			}
		}
		else if (!strncmp(s, "//ktx drop ", sizeof("//ktx drop ") - 1)) {
			if (cls.mvdplayback) {
				MVDAnnouncer_PackDropped(s + 2);
			}
		}
		else if (!strncmp(s, "//ktx expire ", sizeof("//ktx expire ") - 1)) {
			if (cls.mvdplayback) {
				MVDAnnouncer_Expired(s + 2);
			}
		}
		else if (!strncmp(s, "//ktx bp ", sizeof("//ktx bp ") - 1)) {
			if (cls.mvdplayback) {
				MVDAnnouncer_BackpackPickup(s + 2);
			}
		}
		else if (!strncmp(s, "//ktx di ", sizeof("//ktx di ") - 1)) {
			if (cl.standby && !CL_Demo_SkipMessage(true)) {
				// Ignore if not the tracked player
				CL_ReadKtxDamageIndicatorString(s + 2);
			}
		}
	}

	// Any processing after this point will be ignored if not tracking the target player
	if (cls.state == ca_active && CL_Demo_SkipMessage(true))
		return;

	if (!strncmp(s, "//wps ", sizeof("//wps ") - 1) || !strncmp(s, "alias ", 6) || !strncmp(s, "cmd mapslist_dl ", sizeof("cmd mapslist_dl ") - 1) || !strncmp(s, "cmd cmdslist_dl ", sizeof("cmd cmdslist_dl ") - 1)) {
		if (developer.integer > 1) {
			Com_DPrintf("stufftext: %s\n", s);
		}
	}
	else {
		Com_DPrintf ("stufftext: %s\n", s);	
	}

	if (!strncmp(s, "alias _cs", 9))
		Cbuf_AddTextEx(&cbuf_svc, "alias _cs \"wait;+attack;wait;wait;-attack;wait\"\n");
	else if (!strncmp(s, "alias _y", 8))
		Cbuf_AddTextEx(&cbuf_svc, "alias _y \"wait;-attack;wait;wait;+attack;wait;wait;-attack;wait\"\n");
	else if (!strcmp(s, "cmd snap") || (!strncmp (s, "r_skyname ", 10) && !strchr (s, '\n')))
		Cbuf_AddTextEx(&cbuf_svc, va("%s\n", s));
	else if (!strncmp(s, "//tinfo ", sizeof("//tinfo ") - 1))
	{
		extern void Parse_TeamInfo(char *s);

		if (!cls.mvdplayback && !check_ktx_ca_wo())
		{
			Parse_TeamInfo( s + 2 );
		}
	}
	else if (!strncmp(s, "//cainfo ", sizeof("//cainfo ") - 1))
	{
		extern void Parse_CAInfo(char *s);

		Parse_CAInfo( s + 2 );
	}
	else if (!strncmp(s, "//at ", sizeof("//at ") - 1))
	{
		// This is autotrack info from MVD demo/QTV stream, they are almost same.
		extern cvar_t demo_autotrack;
		extern cvar_t mvd_autotrack;

		if (demo_autotrack.integer)
		{
			Cbuf_AddTextEx (&cbuf_svc, va("track %s\n", s + sizeof("//at ")-1));
			if (mvd_autotrack.integer) 
			{
				// Do not let mvd_autotrack and demo_autotrack fight.
				Com_Printf("Server autotrack found, client autotrack turned off\n");
				Cvar_SetValue(&mvd_autotrack, 0);
			}
		}
	}
	else if (!strncmp(s, "//vwep ", 7) && s[strlen(s) - 1] == '\n') 
	{
		CL_ParseVWepPrecache(s);
		return;
	}
	else if (!strncmp(s, "//sn ", sizeof("//sn ") - 1))
	{
		extern void Parse_Shownick(char *s)	;
		Parse_Shownick( s + 2 );
	}
	else if (!strncmp(s, "//qul ", sizeof("//qul ") - 1))
	{
		// qtv user list
		Parse_QtvUserList( s + 2 );
	}
	else if (!strncmp(s, "//wps ", sizeof("//wps ") - 1))
	{
		// weapon stats
		extern void Parse_WeaponStats(char *s);
		Parse_WeaponStats( s + 2 );
	}
	else if (!strcmp(s, "cmd pext\n"))
	{
		// If someone requested protocol extensions we support - reply.

#ifdef PROTOCOL_VERSION_FTE
		extern unsigned int CL_SupportedFTEExtensions (void);
#endif // PROTOCOL_VERSION_FTE
#ifdef PROTOCOL_VERSION_FTE2
		extern unsigned int CL_SupportedFTEExtensions2 (void);
#endif // PROTOCOL_VERSION_FTE2
#ifdef PROTOCOL_VERSION_MVD1
		extern unsigned int CL_SupportedMVDExtensions1(void);
#endif

		char tmp[128];
		char data[1024] = "cmd pext";
		int ext;

#ifdef PROTOCOL_VERSION_FTE
		ext = cls.fteprotocolextensions ? cls.fteprotocolextensions : CL_SupportedFTEExtensions();
		snprintf(tmp, sizeof(tmp), " 0x%x 0x%x", PROTOCOL_VERSION_FTE, ext);
		Com_Printf_State(PRINT_DBG, "PEXT: 0x%x is fte protocol ver and 0x%x is fteprotocolextensions\n", PROTOCOL_VERSION_FTE, ext);
		strlcat(data, tmp, sizeof(data));
#endif // PROTOCOL_VERSION_FTE 

#ifdef PROTOCOL_VERSION_FTE2
		ext = cls.fteprotocolextensions2 ? cls.fteprotocolextensions2 : CL_SupportedFTEExtensions2();
		snprintf(tmp, sizeof(tmp), " 0x%x 0x%x", PROTOCOL_VERSION_FTE2, ext);
		Com_Printf_State(PRINT_DBG, "PEXT: 0x%x is fte protocol ver and 0x%x is fteprotocolextensions2\n", PROTOCOL_VERSION_FTE2, ext);
		strlcat(data, tmp, sizeof(data));
#endif // PROTOCOL_VERSION_FTE2 

#ifdef PROTOCOL_VERSION_MVD1
		ext = cls.mvdprotocolextensions1 ? cls.mvdprotocolextensions1 : CL_SupportedMVDExtensions1();
		snprintf(tmp, sizeof(tmp), " 0x%x 0x%x", PROTOCOL_VERSION_MVD1, ext);
		Com_Printf_State(PRINT_DBG, "PEXT: 0x%x is mvdsv protocol ver and 0x%x is mvdprotocolextensions1\n", PROTOCOL_VERSION_MVD1, ext);
		strlcat(data, tmp, sizeof(data));
#endif

		strlcat(data, "\n", sizeof(data));
		Cbuf_AddTextEx(&cbuf_svc, data);
	}
	else if (!strncmp(s, "//ucmd ", sizeof("//ucmd ") - 1))
	{
		extern void MVD_ParseUserCommand(const char* s);

		MVD_ParseUserCommand(s + sizeof("//ucmd ") - 1);
	}
	else if (!strncmp(s, "//finalscores ", sizeof("//finalscores ") - 1))
	{
		cmd_alias_t* alias = Cmd_FindAlias("f_qtvfinalscores");

		if (alias) {
			Cbuf_AddTextEx(&cbuf_svc, va("f_qtvfinalscores %s\n", s + sizeof("//finalscores ") - 1));
		}
	}
	else if (!strcmp(s, "//authprompt\n")) {
		if (!cls.demoplayback) {
			extern cvar_t cl_username;

			if (cls.auth_logintoken[0] && cl_username.string[0]) {
				Cbuf_AddTextEx(&cbuf_main, va("cmd login %s\n", cl_username.string));
			}
		}
	}
	else if (!strncmp(s, "//challenge ", sizeof("//challenge ") - 1)) {
		if (!cls.demoplayback) {
			Cmd_TokenizeString(s + 2);

			if (Cmd_Argc() >= 2) {
				strlcpy(cl.auth_challenge, Cmd_Argv(1), sizeof(cl.auth_challenge));

				if (cls.auth_logintoken[0]) {
					Central_FindChallengeResponse(cls.auth_logintoken, cl.auth_challenge);
				}
			}
		}
	}
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	else if (!strncmp(s, "//mvdsv_ssw ", sizeof("//mvdsv_ssw ") - 1)) {
		if (!cls.demoplayback && !cl.spectator) {
			IN_ServerSideWeaponSelectionResponse(s + sizeof("//mvdsv_ssw ") - 1);
		}
	}
#endif
	else
	{
		Cbuf_AddTextEx(&cbuf_svc, s);
	}

	// Execute stuffed commands immediately when starting a demo
	if (cls.demoplayback && cls.state != ca_active)
		Cbuf_ExecuteEx (&cbuf_svc); // FIXME: execute cbuf_main too?
}

void CL_SetStat (int stat, int value)
{
	int	j;
	extern cvar_t scr_gameclock;

	if (stat < 0 || stat >= MAX_CL_STATS) {
		Host_Error("CL_SetStat: %i is invalid", stat);
		return;
	}

	// Set the stat value for the current player we're parsing in the MVD.
	if (cls.mvdplayback)
	{
		int old_value = cl.players[cls.lastto].stats[stat];

		cl.players[cls.lastto].stats[stat] = value;

		// If we're not tracking the active player,
		// then don't update sbar and such.
		if (Cam_TrackNum() != cls.lastto) {
			return;
		}

		if (stat == STAT_ITEMS && (old_value & IT_ALL_WEAPONS) > (value & IT_ALL_WEAPONS)) {
			// Weapons removed, reset last fired
			cl.lastfired = 0;
		}
	}

	Sbar_Changed();

	if (stat == STAT_ITEMS)
	{
		// Set flash times.
		for (j = 0; j < 32; j++)
			if ( (value & (1 << j)) && !(cl.stats[stat] & (1 << j)) )
				cl.item_gettime[j] = cl.time;
	}

	// Reset safestrafe state when respawning (health goes from 0 or less to positive)
	if (stat == STAT_HEALTH && value > 0 && cl.stats[stat] <= 0 && !cl.spectator) {
		memset(&cl.safestrafe, 0, sizeof(cl.safestrafe));
		CL_SpawnWarn_SuppressAfterRespawn();
	}

	cl.stats[stat] = value;

#ifdef FTE_PEXT_ACCURATETIMINGS
	if (stat == STAT_TIME && (cls.fteprotocolextensions & FTE_PEXT_ACCURATETIMINGS))
	{
		cl.servertime_works = true;
		cl.servertime = cl.stats[STAT_TIME] * 0.001;
	}
	else
#endif
		if (stat == STAT_TIME && cl.z_ext & Z_EXT_SERVERTIME)
		{
			cl.servertime_works = true;
			cl.servertime = cl.stats[STAT_TIME] * 0.001;
		}

	// Since the server doesn't include overtime data, we can't rely on
	// the STAT_MATCHSTARTTIME data when using a game clock that counts
	// down. Instead, we'll have to wait for a "[X] minutes remaining"
	// message to sync the game clock. Without this, during overtime, the
	// clock will start counting up instead of down.
	if (cl.stats[STAT_MATCHSTARTTIME] && scr_gameclock.value != 2 && scr_gameclock.value != 4)
	{
		cl.gamestarttime = Sys_DoubleTime() - cl.servertime + ((double)cl.stats[STAT_MATCHSTARTTIME])/1000 - cl.gamepausetime;
		if (cls.mvdplayback && cl.servertime_works && !cl.gametime) {
			cl.gametime = max(0, cl.servertime - cl.stats[STAT_MATCHSTARTTIME] * 0.001);
		}
	}

	TP_StatChanged(stat, value);
}

void CL_MuzzleFlash (void) 
{
	vec3_t forward, right, up, org, angles;
	model_t *mod;

	dlight_t *dl;
	int i, j, num_ent;
	entity_state_t *ent;
	player_state_t *state;
	vec3_t none = {0,0,0};

	i = MSG_ReadShort();

	if (CL_Demo_SkipMessage(true))
		return;

	if (!cl_muzzleflash.value)
		return;

	if (!cl.validsequence)
		return;

	if ((unsigned) (i - 1) >= MAX_CLIENTS) 
	{
		// A monster firing
		num_ent = cl.frames[cl.validsequence & UPDATE_MASK].packet_entities.num_entities;

		for (j = 0; j < num_ent; j++) {
			ent = &cl.frames[cl.validsequence & UPDATE_MASK].packet_entities.entities[j];

			if (ent->number == i) {
				mod = cl.model_precache[ent->modelindex];

				// Special muzzleflashes for some enemies.
				if (mod->modhint == MOD_SOLDIER) {
					AngleVectors(ent->angles, forward, right, up);
					VectorMA(ent->origin, 22, forward, org);
					VectorMA(org, 10, right, org);
					VectorMA(org, 12, up, org);

					if (amf_part_muzzleflash.integer) {
						if (!ISPAUSED && amf_coronas.integer) {
							R_CoronasEntityNew(C_SMALLFLASH, &cl_entities[ent->number]);
						}
						DrawMuzzleflash(org, ent->angles, none);
					}
				}
				else if (mod->modhint == MOD_ENFORCER) {
					AngleVectors (ent->angles, forward, right, up);
					VectorMA(ent->origin, 22, forward, org);
					VectorMA(org, 10, right, org);
					VectorMA(org, 12, up, org);
					if (amf_part_muzzleflash.integer) {
						if (amf_coronas.integer) {
							R_CoronasEntityNew(C_SMALLFLASH, &cl_entities[ent->number]);
						}
						DrawMuzzleflash(org, ent->angles, none);
					}
				}
				else if (mod->modhint == MOD_OGRE) {
					AngleVectors(ent->angles, forward, right, up);
					VectorMA(ent->origin, 22, forward, org);
					VectorMA(org, -8, right, org);
					VectorMA(org, 14, up, org);
					if (amf_part_muzzleflash.integer) {
						if (amf_coronas.integer) {
							R_CoronasEntityNew(C_SMALLFLASH, &cl_entities[ent->number]);
						}
						DrawMuzzleflash(org, ent->angles, none);
					}
				}
				else {
					AngleVectors(ent->angles, forward, NULL, NULL);
					VectorMA(ent->origin, 18, forward, org);
				}

				dl = CL_AllocDlight(-i);
				dl->radius = 200 + (rand() & 31);
				dl->minlight = 32;
				dl->die = cl.time + 0.1;

				// Blue muzzleflashes for shamblers/teslas
				if (mod->modhint == MOD_SHAMBLER || mod->modhint == MOD_TESLA) {
					dl->type = lt_blue;
				}
				else {
					dl->type = lt_muzzleflash;
				}
				VectorCopy(org, dl->origin);

				break;
			}
		}
		return;
	}

	if (cl_muzzleflash.value == 2 && i - 1 == cl.viewplayernum)
		return;

	dl = CL_AllocDlight(-i);
	state = &cl.frames[cls.mvdplayback ? (cl.oldparsecount & UPDATE_MASK) : cl.parsecountmod].playerstate[i - 1];

	if ((i - 1) == cl.viewplayernum)
	{
		VectorCopy(cl.simangles, angles);
		VectorCopy(cl.simorg, org);
	}
	else
	{
		VectorCopy(state->viewangles, angles);
		VectorCopy(state->origin, org);
	}

	AngleVectors(angles, forward, right, up);
	VectorMA(org, 22, forward, org);
	VectorMA(org, 10, right, org);
	VectorMA(org, 12, up, org);
	VectorCopy(org, dl->origin);

	dl->radius = 200 + (rand()&31);
	dl->minlight = 32;
	dl->die = cl.time + 0.1;
	dl->type = lt_muzzleflash;

	if (amf_part_muzzleflash.integer) {
		if (((i - 1) != cl.viewplayernum) || (cameratype != C_NORMAL)) {
			if (amf_coronas.integer) {
				R_CoronasNew(C_SMALLFLASH, dl->origin);
			}
			DrawMuzzleflash(org, angles, state->velocity);
		}
	}
}

void CL_ParseQizmoVoice (void) 
{
	byte frame_data[33];
	byte sequence_low;
	int sequence;
	int voice_id;

	// Qizmo prefixes each frame with one low sequence byte. The next byte is
	// mixed: bits 4-5 extend the sequence, bits 6-7 identify the voice burst,
	// and the low nibble remains GSM data restored before decoding.
	sequence_low = MSG_ReadByte();

	MSG_ReadData(frame_data, sizeof(frame_data));
	sequence = sequence_low | ((frame_data[0] & 0x30) << 4);
	voice_id = frame_data[0] >> 6;

	if (!CL_Demo_SkipMessage(true)) {
		S_QizmoVoice_PlayFrame(sequence, voice_id, frame_data, sizeof(frame_data));
	}
}

#define SHOWNET(x) {if (cl_shownet.value == 2) Com_Printf ("%3i:%s\n", msg_readcount - 1, x);}

// SV_RotateCmd
// Rotates client command so a high-ping player can better control direction as they exit teleporters on high-ping
static void CL_RotateCmd(usercmd_t* cmd, float yaw_delta)
{
	static vec3_t up = { 0, 0, 1 };
	vec3_t direction = { cmd->sidemove, cmd->forwardmove, 0 };
	vec3_t result;

	RotatePointAroundVector(result, up, direction, yaw_delta);

	cmd->sidemove = result[0];
	cmd->forwardmove = result[1];
}

void CL_ParseServerMessage (void) 
{
	int cmd, i, j = 0;
	char *s;
	extern int mvd_fixangle;
	vec3_t newangles;
	int msg_svc_start;
	int oldread = 0;

	if (cl_shownet.value == 1) 
	{
		Print_flags[Print_current] |= PR_TR_SKIP;
		Com_Printf ("%i ", net_message.cursize);
	}
	else if (cl_shownet.value == 2) 
	{
		Print_flags[Print_current] |= PR_TR_SKIP;
		Com_Printf ("------------------\n");
	}

	cls.demomessage.cursize = 0;

	CL_ParseClientdata();
	CL_ClearProjectiles();

	// Parse the message.
	while (1) 
	{
		if (msg_badread) 
		{
			Host_Error ("CL_ParseServerMessage: Bad server message");
			break;
		}

		msg_svc_start = msg_readcount;
		cmd = MSG_ReadByte ();

		if (cmd == -1) 
		{
			msg_readcount++;	// so the EOM showner has the right value
			SHOWNET("END OF MESSAGE");
			break;
		}

		if (cmd == svc_qizmovoice)
			SHOWNET("svc_qizmovoice")
		else if (cmd < num_svc_strings)
			SHOWNET(svc_strings[cmd]);

		// Update msg no:
		if (cmd < NUMMSG)
			cl_messages[cmd].msgs++;

		oldread = msg_readcount;

		// Other commands
		switch (cmd) 
		{
			default:
				{	
					Host_Error ("CL_ParseServerMessage: Illegible server message (%d)\n", cmd);
					break;
				}
			case svc_nop:
				{
					break;
				}
			case svc_disconnect:
				{
					VID_NotifyActivity();

					if (cls.mvdplayback == QTV_PLAYBACK)
					{ 
						// Workaround, do not disconnect in case of QTV playback
						if (net_message.cursize > msg_readcount && strcmp(s = MSG_ReadString(), "EndOfDemo"))
							Com_Printf("WARNING: Non-standard disconnect message from QTV '%s'\n", s);
						break;
					}

					if (cls.mvdplayback == MVD_FILE_PLAYBACK) {
						// MVD playback, but not QTV stream.
						// We still have some data, so lets try ignore disconnect since it probably multy map MVD.
						int ms;

						if (Demo_BufferSize(&ms)) {
							if (net_message.cursize > msg_readcount && strcmp(s = MSG_ReadString(), "EndOfDemo")) {
								Com_Printf("WARNING: Non-standard disconnect message in MVD '%s'\n", s);
							}

							Com_DPrintf("Ignoring Server disconnect\n");
							break;
						}
					}

					if (cls.state == ca_connected) 
					{
						Host_Error( "Server disconnected\n"
								"Server version may not be compatible");
					} 
					else if (cls.demoplayback && cls.state == ca_demostart) 
					{
						Com_DPrintf("Server disconnect found - hadn't started yet, ignoring.\n");
					}
					else 
					{
						Com_DPrintf("Server disconnected\n");
						Host_EndGame();	// The server will be killed if it tries to kick the local player.
						Host_Abort();
					}
					break;
				}
			case nq_svc_time:
				{
					MSG_ReadFloat();
					break;
				}
			case svc_print:
				{
					CL_ParsePrint();
					break;
				}
			case svc_centerprint:
				{
					// SCR_CenterPrint (MSG_ReadString ());
					// Centerprint re-triggers
					s = MSG_ReadString();

					if (CL_Demo_SkipMessage (true))
						break;

					if (!cls.demoseeking)
					{
						if (!CL_SearchForReTriggers(s, RE_PRINT_CENTER))
							SCR_CenterPrint(s);
						Print_flags[Print_current] = 0;
					}
					break;
				}
			case svc_stufftext:
				{
					CL_ParseStufftext();
					break;
				}
			case svc_damage:
				{
					V_ParseDamage();
					break;
				}
			case svc_serverdata:
				{
					Cbuf_ExecuteEx(&cbuf_svc);		// make sure any stuffed commands are done
					CL_ParseServerData();
					vid.recalc_refdef = true;		// leave full screen intermission
					break;
				}
			case svc_setangle:
				{
					if (cls.mvdplayback || (cls.mvdprotocolextensions1 & MVD_PEXT1_HIGHLAGTELEPORT)) {
						j = MSG_ReadByte();
					}

					for (i = 0; i < 3; i++) {
						newangles[i] = MSG_ReadAngle();
					}

					if (CL_Demo_SkipMessage(true)) {
						break;
					}

					CL_DisableLerpMove();

					if (cls.mvdplayback) 
					{
						mvd_fixangle |= 1 << j;

						if (j == Cam_TrackNum()) {
							VectorCopy(newangles, cl.viewangles);
						}
					} 
					else {
						VectorCopy (newangles, cl.viewangles);

						if ((cls.mvdprotocolextensions1 & MVD_PEXT1_HIGHLAGTELEPORT) && j) {
							// Update all subsequent packets with amended directions to try and keep prediction correct
							frame_t* this_frame = &cl.frames[cl.parsecount & UPDATE_MASK];
							float yaw_delta = newangles[YAW] - this_frame->cmd.angles[YAW];

							for (i = 2; i < UPDATE_BACKUP - 1 && cl.validsequence + i < cls.netchan.outgoing_sequence; i++) {
								frame_t* f = &cl.frames[(cl.validsequence + i) & UPDATE_MASK];

								if (j == 1) {
									// Teleport
									CL_RotateCmd(&f->cmd, yaw_delta);

									cl.viewangles[YAW] = f->cmd.angles[YAW] + yaw_delta;
								}
								else if (j == 2) {
									// Respawn, angle sent from client was over-ruled
									f->cmd.angles[YAW] = newangles[YAW];
								}
							}
						}
					}
					break;
				}
			case svc_lightstyle:
				{
					i = MSG_ReadByte ();
					if (i >= MAX_LIGHTSTYLES)
						Host_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
					strlcpy(cl_lightstyle[i].map, MSG_ReadString(), sizeof(cl_lightstyle[i].map));
					cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
					break;
				}
			case svc_sound:
				{
					CL_ParseStartSoundPacket();
					break;
				}
			case svc_stopsound:
				{
					i = MSG_ReadShort();

					if (CL_Demo_SkipMessage (true))
						break;

					S_StopSound(i >> 3, i & 7);
					break;
				}

#ifdef FTE_PEXT2_VOICECHAT
			case svc_fte_voicechat:
			{
				S_Voip_Parse();
				break;
			}
#endif

			case svc_updatefrags:
				{
					Sbar_Changed();
					i = MSG_ReadByte();
					if (i >= MAX_CLIENTS)
						Host_Error("CL_ParseServerMessage: svc_updatefrags > MAX_CLIENTS");
					cl.players[i].frags = MSG_ReadShort();
					break;
				}
			case svc_updateping:
				{
					i = MSG_ReadByte();
					if (i >= MAX_CLIENTS)
						Host_Error("CL_ParseServerMessage: svc_updateping > MAX_CLIENTS");
					cl.players[i].ping = MSG_ReadShort();
					break;
				}
			case svc_updatepl:
				{
					i = MSG_ReadByte();
					if (i >= MAX_CLIENTS)
						Host_Error("CL_ParseServerMessage: svc_updatepl > MAX_CLIENTS");
					cl.players[i].pl = MSG_ReadByte();
					break;
				}
			case svc_updateentertime:
				{
					// Time is sent over as seconds ago.
					i = MSG_ReadByte();
					if (i >= MAX_CLIENTS)
						Host_Error ("CL_ParseServerMessage: svc_updateentertime > MAX_CLIENTS");
					cl.players[i].entertime = (cls.demoplayback ? cls.demotime : cls.realtime) - MSG_ReadFloat();
					break;
				}
			case svc_spawnbaseline:
				{
					i = MSG_ReadShort();
					CL_ParseBaseline(&cl_entities[i].baseline);
					break;
				}
#if defined (PROTOCOL_VERSION_FTE) && defined (FTE_PEXT_SPAWNSTATIC2)
			case svc_fte_spawnbaseline2:
				{
					CL_ParseSpawnBaseline2();
					break;
				}
#endif // PROTOCOL_VERSION_FTE
			case svc_spawnstatic:
				{
					CL_ParseStatic(false);
					break;
				}
#if defined (PROTOCOL_VERSION_FTE) && defined (FTE_PEXT_SPAWNSTATIC2)
			case svc_fte_spawnstatic2:
				{
					if (cls.fteprotocolextensions & FTE_PEXT_SPAWNSTATIC2)
						CL_ParseStatic(true);
					else
						Host_Error("CL_ParseServerMessage: svc_fte_spawnstatic2 without FTE_PEXT_SPAWNSTATIC2");
					break;
				}
#endif // PROTOCOL_VERSION_FTE
			case svc_temp_entity:
				{
					CL_ParseTEnt();
					break;
				}
			case svc_killedmonster:
				{
					cl.stats[STAT_MONSTERS]++;
					break;
				}
			case svc_foundsecret:
				{
					cl.stats[STAT_SECRETS]++;
					break;
				}
			case svc_updatestat:
				{
					i = MSG_ReadByte();
					j = MSG_ReadByte();

					CL_SetStat(i, j);
					break;
				}
			case svc_updatestatlong:
				{
					i = MSG_ReadByte();
					j = MSG_ReadLong();

					CL_SetStat(i, j);
					break;
				}
			case svc_spawnstaticsound:
				{
					CL_ParseStaticSound();
					break;
				}
			case svc_cdtrack:
				{
					cl.cdtrack = MSG_ReadByte ();
					CDAudio_Play((byte)cl.cdtrack, true);
					break;
				}
			case svc_intermission:
				{
					cl.intermission = 1;
					cl.completed_time = cls.demoplayback ? cls.demotime : cls.realtime;
					cl.solo_completed_time = cl.servertime;
					vid.recalc_refdef = true;	// go to full screen
					for (i = 0; i < 3; i++)
						cl.simorg[i] = MSG_ReadCoord();
					for (i = 0; i < 3; i++)
						cl.simangles[i] = MSG_ReadAngle();
					VectorClear(cl.simvel);
					TP_ExecTrigger ("f_mapend");

					if (cls.demoseeking == DST_SEEKING_END) {
						cls.demoseeking = DST_SEEKING_FOUND_NOREWIND; // it will reset to the DST_SEEKING_NONE in the deep of the demo code
					}
					break;
				}
			case svc_finale:
				{
					cl.intermission = 2;
					cl.completed_time = cls.demoplayback ? cls.demotime : cls.realtime;
					cl.solo_completed_time = cl.servertime;
					vid.recalc_refdef = true;	// go to full screen
					SCR_CenterPrint(MSG_ReadString ());
					break;
				}
			case svc_sellscreen:
				{
					Cmd_ExecuteString("help");
					break;
				}
			case svc_smallkick:
				{
					if (CL_Demo_SkipMessage (true))
						break;

					cl.ideal_punchangle = -2;
					break;
				}
			case svc_bigkick:
				{
					if (CL_Demo_SkipMessage (true))
						break;

					cl.ideal_punchangle = -4;
					break;
				}
			case svc_muzzleflash:
				{
					CL_MuzzleFlash();
					break;
				}
			case svc_updateuserinfo:
				{
					CL_UpdateUserinfo();
					break;
				}
			case svc_setinfo:
				{
					CL_SetInfo();
					break;
				}
			case svc_serverinfo:
				{
					CL_ParseServerInfoChange();
					break;
				}
			case svc_download:
				{
					CL_ParseDownload();
					break;
				}
			case svc_playerinfo:
				{
					if (cls.demorecording)
					{
						CL_InitialiseDemoMessageIfRequired();
						MSG_WriteByte(&cls.demomessage, svc_playerinfo);
					}
					CL_ParsePlayerinfo();
					break;
				}
			case svc_nails:
				{
					CL_ParseProjectiles(false);
					break;
				}
			case svc_nails2:
				{
					if (!cls.mvdplayback)
						Host_Error("CL_ParseServerMessage: svc_nails2 without cls.mvdplayback");
					CL_ParseProjectiles(true);
					break;
				}
			case svc_chokecount: // Some preceding packets were choked
				{
					i = MSG_ReadByte();
					for (j = cls.netchan.incoming_acknowledged - 1; i > 0 && j > cls.netchan.outgoing_sequence - UPDATE_BACKUP; j--) 
					{
						if (cl.frames[j & UPDATE_MASK].receivedtime != -3) 
						{
							cl.frames[j & UPDATE_MASK].receivedtime = -2;
							i--;
						}
					}
					break;
				}
			case svc_modellist:
				{
					CL_ParseModellist(false);
					break;
				}
#if defined (PROTOCOL_VERSION_FTE) && defined (FTE_PEXT_MODELDBL)
			case svc_fte_modellistshort:
				{
					if (cls.fteprotocolextensions & FTE_PEXT_MODELDBL)
						CL_ParseModellist(true);
					else
						Host_Error("CL_ParseServerMessage: svc_fte_modellistshort without FTE_PEXT_MODELDBL");

					break;
				}
#endif  // PROTOCOL_VERSION_FTE
			case svc_soundlist:
				{
					CL_ParseSoundlist();
					break;
				}
			case svc_packetentities:
				{
					CL_ParsePacketEntities(false);
					break;
				}
			case svc_deltapacketentities:
				{
					CL_ParsePacketEntities(true);
					break;
				}
			case svc_maxspeed:
				{
					float newspeed = MSG_ReadFloat ();

					if (CL_Demo_SkipMessage (false))
						break;

					cl.maxspeed = newspeed;
					break;
				}
			case svc_entgravity :
				{
					float newgravity = MSG_ReadFloat ();

					if (CL_Demo_SkipMessage (false))
						break;

					cl.entgravity = newgravity;
					break;
				}
			case svc_setpause:
				{
					if (MSG_ReadByte())
						cl.paused |= PAUSED_SERVER;
					else
						cl.paused &= ~PAUSED_SERVER;

					if (ISPAUSED) {
						CDAudio_Pause();
						CL_StorePausePredictionLocations();
					}
					else {
						CDAudio_Resume();
					}
					break;
				}
			case svc_qizmovoice:
				{
					CL_ParseQizmoVoice();
					break;
				}
		}

		// cl_messages, update size
		if (cmd < NUMMSG)
			cl_messages[cmd].size += msg_readcount - oldread;

		if (cls.demorecording)
		{
			// Init the demo message buffer if it hasn't been done.
			CL_InitialiseDemoMessageIfRequired();

			// Write the change in entities to the demo being recorded
			// or the net message we just received.
			if (cmd == svc_deltapacketentities) {
				extern cvar_t cl_demo_qwd_delta;
				int newpacket = cls.netchan.incoming_sequence & UPDATE_MASK;
				int deltaseq = cl.frames[newpacket].delta_sequence;
				qbool delta_valid = deltaseq > 0 && !cl.frames[deltaseq & UPDATE_MASK].invalid && cl.frames[deltaseq & UPDATE_MASK].in_qwd;

				// Only write if it was parsed correctly and we've written the original packet to qwd
				if (cl_demo_qwd_delta.integer && cl.validsequence == cls.netchan.incoming_sequence && delta_valid) {
					SZ_Write(&cls.demomessage, net_message.data + msg_svc_start, msg_readcount - msg_svc_start);
				}
				else {
					// Write from baselines instead (old way)
					CL_WriteDemoEntities();
				}
				cl.frames[newpacket].in_qwd = true;
			}
			else if (cmd == svc_download) {
				// there's no point in writing it to the demo
			}
			else if (cmd == svc_serverdata) {
				CL_WriteServerdata(&cls.demomessage);
			}
			else if (cmd != svc_playerinfo) {
				// We write svc_playerinfo out as we read it in
				SZ_Write(&cls.demomessage, net_message.data + msg_svc_start, msg_readcount - msg_svc_start);
			}
		}
	}

	if (cls.demorecording)
	{
		// Write the gathered changes to the demo file.
		if (cls.demomessage.cursize)
			CL_WriteDemoMessage (&cls.demomessage);
	}

	CL_SetSolidEntities ();
}

static void CL_DemoMessageBufferOverflow(struct sizebuf_s* buf, int length)
{
	int newsize = buf->maxsize + MAX_MSGLEN * 2;
	byte* mem = Q_realloc(buf->data, newsize);

	if (mem) {
		buf->maxsize = newsize;
		buf->data = mem;
	}
}

static void CL_InitialiseDemoMessageIfRequired(void)
{
	if (!cls.demomessage.maxsize) {
		byte* data = Q_malloc(MAX_MSGLEN * 2);

		SZ_InitEx2(&cls.demomessage, data, MAX_MSGLEN * 2, false, CL_DemoMessageBufferOverflow);
	}
	if (!cls.demomessage.cursize) {
		SZ_Write(&cls.demomessage, net_message.data, 8);
	}
}

#ifdef MVD_PEXT1_HIDDEN_MESSAGES
// Hidden data packets (stuffed into mvd/qtv stream)
void CL_ParseHiddenDataMessage(void)
{
	while (true) {
		int size = LittleLong(MSG_ReadLong());
		int protocol_version = 0, type;

		if (size == -1) {
			break;
		}

		type = LittleLong(MSG_ReadShort());
		while (type == 0xFFFF && size > 0) {
			type = LittleLong(MSG_ReadShort());
			++protocol_version;
		}

		if (protocol_version != 0) {
			MSG_ReadSkip(size);
			continue;
		}

		switch (type) {
		case mvdhidden_antilag_position:
			CL_ParseAntilagPosition(size);
			break;
		case mvdhidden_demoinfo:
			CL_ParseDemoInfo(size);
			break;
		case mvdhidden_usercmd_weapons:
			CL_ParseDemoWeapon(size, false);
			break;
		case mvdhidden_usercmd_weapons_ss:
			CL_ParseDemoWeapon(size, true);
			break;
		case mvdhidden_usercmd:
			CL_ParseUserCommand(size);
			break;
		case mvdhidden_dmgdone:
			CL_ParseDamageDone(size);
			break;
		case mvdhidden_usercmd_weapon_instruction:
			CL_ParseDemoWeaponInstruction(size);
			break;
		default:
			MSG_ReadSkip(size);
			break;
		}
	}
}

#define DEMOINFO_BLOCK_SIZE (16 * 1024)
static byte* demoinfo_buffer;
static size_t demoinfo_buffer_size;

static void CL_ParseDemoInfo(int size)
{
	int block_number = LittleShort(MSG_ReadShort());
	size -= sizeof(short);

	if (cl.demoinfo_bytes + size >= demoinfo_buffer_size) {
		size_t new_size = ((cl.demoinfo_bytes + size + DEMOINFO_BLOCK_SIZE) / DEMOINFO_BLOCK_SIZE) * DEMOINFO_BLOCK_SIZE;
		demoinfo_buffer = Q_realloc_named(demoinfo_buffer, new_size, "demoinfo_buffer");
		demoinfo_buffer_size = new_size;
	}

	if (block_number == cl.demoinfo_blocknumber + 1 || block_number == 0) {
		MSG_ReadData(demoinfo_buffer + cl.demoinfo_bytes, size);
		cl.demoinfo_bytes += size;
		cl.demoinfo_blocknumber = block_number;
	}
	else {
		MSG_ReadSkip(size);
		cl.demoinfo_bytes = 0;
		cl.demoinfo_blocknumber = 0;
	}

	if (block_number == 0 && cl.demoinfo_bytes > 0) {
		// finished, parse stats and do something useful here
#if 0
		FILE* file = fopen("qw/demoinfo.txt", "wb");
		if (file) {
			fwrite(demoinfo_buffer, 1, cl.demoinfo_bytes, file);
			fclose(file);
		}
#endif
		Q_free(demoinfo_buffer);
		demoinfo_buffer_size = 0;
		cl.demoinfo_bytes = 0;
		cl.demoinfo_blocknumber = 0;
	}
}

static void CL_ParseAntilagPosition(int size)
{
	mvdhidden_antilag_position_header_t header;
	int old_readcount = msg_readcount;

	header.playernum = MSG_ReadByte();
	header.players = MSG_ReadByte();
	header.incoming_seq = LittleLong(MSG_ReadLong());
	header.server_time = LittleFloat(MSG_ReadFloat());
	header.target_time = LittleFloat(MSG_ReadFloat());

	size -= (msg_readcount - old_readcount);
	if (size != header.players * sizeof_mvdhidden_antilag_position_t) {
		Con_DPrintf("unexpected size: %d vs %d (%d players)\n", size, header.players * sizeof_mvdhidden_antilag_position_t, header.players);
		MSG_ReadSkip(size);
	}
	else if (header.playernum != cl.viewplayernum) {
		MSG_ReadSkip(size);
	}
	else {
		mvdhidden_antilag_position_t position;
		int i;

		memset(&cl.antilag_positions, 0, sizeof(cl.antilag_positions));
		for (i = 0; i < header.players; ++i) {
			qbool clientpos_valid = false;

			position.playernum = MSG_ReadByte();
			clientpos_valid = position.playernum & MVD_PEXT1_ANTILAG_CLIENTPOS;
			position.playernum &= ~MVD_PEXT1_ANTILAG_CLIENTPOS;

			position.pos[0] = LittleFloat(MSG_ReadFloat());
			position.pos[1] = LittleFloat(MSG_ReadFloat());
			position.pos[2] = LittleFloat(MSG_ReadFloat());
			position.msec = MSG_ReadByte();
			position.predmodel = MSG_ReadByte();
			position.clientpos[0] = LittleFloat(MSG_ReadFloat());
			position.clientpos[1] = LittleFloat(MSG_ReadFloat());
			position.clientpos[2] = LittleFloat(MSG_ReadFloat());

			if (position.playernum >= 0 && position.playernum < MAX_CLIENTS) {
				VectorCopy(position.pos, cl.antilag_positions[position.playernum].pos);
				cl.antilag_positions[position.playernum].present = true;
				VectorCopy(position.clientpos, cl.antilag_positions[position.playernum].clientpos);
				cl.antilag_positions[position.playernum].clientpresent = clientpos_valid;
			}
		}
	}
}

static void CL_ParseDemoWeaponInstruction(int size)
{
	extern cvar_t cl_debug_weapon_view;

	byte playernum;
	byte flags;
	int mode;
	byte weaponlist[10];

	playernum = MSG_ReadByte();
	flags = MSG_ReadByte();
	LittleLong(MSG_ReadLong()); // sequence_set =
	mode = LittleLong(MSG_ReadLong());

	MSG_ReadData(weaponlist, sizeof(weaponlist));

	if (cl_debug_weapon_view.integer && playernum == cl.viewplayernum) {
		char description[128] = { 0 };
		int i;

		strlcat(description, "WS(I) ", sizeof(description));
		if (flags & MVDHIDDEN_SSWEAPON_HIDE_AXE) {
			strlcat(description, "hide(1) ", sizeof(description));
		}
		if (flags & MVDHIDDEN_SSWEAPON_HIDE_SG) {
			strlcat(description, "hide(2) ", sizeof(description));
		}
		if (flags & MVDHIDDEN_SSWEAPON_HIDEONDEATH) {
			strlcat(description, "hod ", sizeof(description));
		}
		if (flags & MVDHIDDEN_SSWEAPON_ENABLED) {
			strlcat(description, "enabled ", sizeof(description));
		}
		else {
			strlcat(description, "disabled ", sizeof(description));
		}
		if (flags & MVDHIDDEN_SSWEAPON_FORGETORDER) {
			strlcat(description, "forget ", sizeof(description));
		}
		if (mode & clc_mvd_weapon_mode_presel) {
			strlcat(description, "presel ", sizeof(description));
		}
		if (mode & clc_mvd_weapon_mode_iffiring) {
			strlcat(description, "iffiring ", sizeof(description));
		}

		strlcat(description, "[", sizeof(description));
		for (i = 0; i < sizeof(weaponlist) / sizeof(weaponlist[0]); ++i) {
			if (!weaponlist[i]) {
				break;
			}

			strlcat(description, va("%s%d", (i ? "," : ""), weaponlist[i]), sizeof(description));
		}
		strlcat(description, "]", sizeof(description));

		Con_Printf("%s\n", description);
	}
}

static void CL_ParseDemoWeapon(int size, qbool server_side)
{
	extern cvar_t cl_debug_weapon_view;
	byte playernum = MSG_ReadByte();
	int items = LittleLong(MSG_ReadLong());
	byte shells = MSG_ReadByte();
	byte nails = MSG_ReadByte();
	byte rockets = MSG_ReadByte();
	byte cells = MSG_ReadByte();
	byte choice = MSG_ReadByte();
	char* str = MSG_ReadString();
	char indicator = (server_side ? 'S' : 'C');

	if (cl_debug_weapon_view.integer && playernum == cl.viewplayernum) {
		char script_options[128] = { 0 };
		const char* has_weapon = "&c0f0";
		const char* no_weapon = "&cf00";
		const char* no_ammo = "&cff0";
		const char* unknown_weapon = "[";

		while (*str) {
			const char* prefix = unknown_weapon;
			const char* postfix = "";
			switch (*str) {
			case 1:
				prefix = (items & IT_AXE) ? has_weapon : no_weapon;
				break;
			case 2:
				prefix = (items & IT_SHOTGUN) ? (shells > 0 ? has_weapon : no_ammo) : no_weapon;
				break;
			case 3:
				prefix = (items & IT_SUPER_SHOTGUN) ? (shells > 1 ? has_weapon : no_ammo) : no_weapon;
				break;
			case 4:
				prefix = (items & IT_NAILGUN) ? (nails > 0 ? has_weapon : no_ammo) : no_weapon;
				break;
			case 5:
				prefix = (items & IT_SUPER_NAILGUN) ? (nails > 1 ? has_weapon : no_ammo) : no_weapon;
				break;
			case 6:
				prefix = (items & IT_GRENADE_LAUNCHER) ? (rockets > 0 ? has_weapon : no_ammo) : no_weapon;
				break;
			case 7:
				prefix = (items & IT_ROCKET_LAUNCHER) ? (rockets > 0 ? has_weapon : no_ammo) : no_weapon;
				break;
			case 8:
				prefix = (items & IT_LIGHTNING) ? (rockets > 0 ? has_weapon : no_ammo) : no_weapon;
				break;
			default:
				prefix = "[";
				postfix = "]";
			}
			strlcat(script_options, va("%s%d&r%s", prefix, str[0], postfix), sizeof(script_options));
			str++;
		}

		Con_Printf("WS(%c) %s, A %d,%d,%d,%d => %d\n", indicator, script_options, shells, nails, rockets, cells, choice);
	}
}

void CL_SpawnDamageIndicator(int deathtype, int targ_ent, int damage, qbool splash_damage, qbool team_damage);

static void CL_ParseDamageDone(int size)
{
	short deathtype;
	short attacker_ent;
	short targ_ent;
	short damage;
	qbool splash_damage;
	int player = Cam_TrackNum();

	if (size != 8) {
		// Unknown
		MSG_ReadSkip(size);
		return;
	}

	deathtype = MSG_ReadShort();
	attacker_ent = MSG_ReadShort();
	targ_ent = MSG_ReadShort();
	damage = MSG_ReadShort();

	splash_damage = (deathtype & MVDHIDDEN_DMGDONE_SPLASHDAMAGE);
	deathtype &= ~MVDHIDDEN_DMGDONE_SPLASHDAMAGE;

	// Don't trigger for self damage
	if (player + 1 == attacker_ent && player + 1 != targ_ent) {
		qbool team_damage = (targ_ent >= 1 && targ_ent <= MAX_CLIENTS && cl.players[targ_ent - 1].teammate);

		CL_SpawnDamageIndicator(deathtype, targ_ent, damage, splash_damage, team_damage);
	}
}

static void CL_ParseUserCommand(int size)
{
	byte playernum, dropnum, msec;
	vec3_t angles;
	short forward, side, up;
	byte buttons, impulse;
	frame_t* frame;

	if (size != sizeof_mvdhidden_block_header_t_usercmd) {
		MSG_ReadSkip(size);
		return;
	}

	playernum = MSG_ReadByte();
	dropnum = MSG_ReadByte();
	msec = MSG_ReadByte();
	angles[0] = MSG_ReadFloat();
	angles[1] = MSG_ReadFloat();
	angles[2] = MSG_ReadFloat();
	forward = MSG_ReadShort();
	side = MSG_ReadShort();
	up = MSG_ReadShort();
	buttons = MSG_ReadByte();
	impulse = MSG_ReadByte();

	if (playernum >= MAX_CLIENTS) {
		return;
	}

	if (dropnum != 0) {
		// replaying an old packet due to loss in this frame
		return;
	}

	frame = &cl.frames[cl.validsequence & UPDATE_MASK];
	if (frame->playerstate[playernum].messagenum == cl.parsecount || frame->playerstate[playernum].messagenum == cl.oldparsecount) {
		usercmd_t* cmd = &frame->playerstate[playernum].command;

		VectorCopy(angles, cmd->angles);
		cmd->buttons = buttons;
		cmd->forwardmove = forward;
		cmd->sidemove = side;
		cmd->upmove = up;
		cmd->impulse = impulse;
		cmd->msec = msec;
	}
}

#endif // #ifdef MVD_PEXT1_HIDDEN_MESSAGES


================================================
FILE: src/cl_pred.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
#include "quakedef.h"
#include "pmove.h"


cvar_t	cl_nopred	= {"cl_nopred", "0"};

extern cvar_t cl_independentPhysics;

#ifdef JSS_CAM
cvar_t cam_thirdperson = {"cam_thirdperson", "0"};
cvar_t cam_dist = {"cam_dist", "100"};
cvar_t cam_lockdir = {"cam_lockdir", "0"};
cvar_t cam_lockpos = {"cam_lockpos", "0"};
static vec3_t saved_angles;
qbool clpred_newpos = false;
#endif

static qbool nolerp[2];
static qbool nolerp_nextpos;

void CL_PredictUsercmd (player_state_t *from, player_state_t *to, usercmd_t *u) {
	// split up very long moves
	if (u->msec > 50) {
		player_state_t temp;
		usercmd_t split;

		split = *u;
		split.msec /= 2;

		CL_PredictUsercmd (from, &temp, &split);
		CL_PredictUsercmd (&temp, to, &split);
		return;
	}

	VectorCopy (from->origin, pmove.origin);
	VectorCopy (u->angles, pmove.angles);
	VectorCopy (from->velocity, pmove.velocity);

	pmove.jump_msec = (cl.z_ext & Z_EXT_PM_TYPE) ? 0 : from->jump_msec;
	pmove.jump_held = from->jump_held;
	pmove.waterjumptime = from->waterjumptime;
	pmove.pm_type = from->pm_type;
	pmove.onground = from->onground;
	pmove.cmd = *u;

#ifdef JSS_CAM
	if (cam_lockdir.value) {
		VectorCopy (saved_angles, pmove.cmd.angles);
		VectorCopy (saved_angles, pmove.angles);
	}
	else
		VectorCopy (pmove.cmd.angles, saved_angles);
#endif

	movevars.entgravity = cl.entgravity;
	movevars.maxspeed = cl.maxspeed;
	movevars.bunnyspeedcap = cl.bunnyspeedcap;

	PM_PlayerMove();

	to->waterjumptime = pmove.waterjumptime;
	to->pm_type = pmove.pm_type;
	to->jump_held = pmove.jump_held;
	to->jump_msec = pmove.jump_msec;
	pmove.jump_msec = 0;

	VectorCopy (pmove.origin, to->origin);
	VectorCopy (pmove.angles, to->viewangles);
	VectorCopy (pmove.velocity, to->velocity);
	to->onground = pmove.onground;

	to->weaponframe = from->weaponframe;
}

//Used when cl_nopred is 1 to determine whether we are on ground, otherwise stepup smoothing code produces ugly jump physics
void CL_CategorizePosition (void) {
	if (cl.spectator && cl.playernum == cl.viewplayernum) {
		cl.onground = false;	// in air
		return;
	}
	VectorClear (pmove.velocity);
	VectorCopy (cl.simorg, pmove.origin);
	pmove.numtouch = 0;
	PM_CategorizePosition ();
	cl.onground = pmove.onground;
}

//Smooth out stair step ups.
//Called before CL_EmitEntities so that the player's lightning model origin is updated properly
void CL_CalcCrouch (void)
{
	qbool teleported;
	static vec3_t oldorigin = {0, 0, 0};
	static float oldz = 0, extracrouch = 0, crouchspeed = 100;

	teleported = nolerp[0] || !VectorL2Compare(cl.simorg, oldorigin, 48);
	VectorCopy(cl.simorg, oldorigin);

	if (teleported) {
		// possibly teleported or respawned
		oldz = cl.simorg[2];
		extracrouch = 0;
		crouchspeed = 100;
		cl.crouch = 0;
		return;
	}

	if (cl.onground && cl.simorg[2] - oldz > 0) {
		if (cl.simorg[2] - oldz > 20) {
			// if on steep stairs, increase speed
			if (crouchspeed < 160) {
				extracrouch = cl.simorg[2] - oldz - cls.frametime * 200 - 15;
				extracrouch = min(extracrouch, 5);
			}
			crouchspeed = 160;
		}

		oldz += cls.frametime * crouchspeed;
		if (oldz > cl.simorg[2])
			oldz = cl.simorg[2];

		if (cl.simorg[2] - oldz > 15 + extracrouch)
			oldz = cl.simorg[2] - 15 - extracrouch;
		extracrouch -= cls.frametime * 200;
		extracrouch = max(extracrouch, 0);

		cl.crouch = oldz - cl.simorg[2];
	}
	else {
		// in air or moving down
		oldz = cl.simorg[2];
		cl.crouch += cls.frametime * 150;
		if (cl.crouch > 0)
			cl.crouch = 0;
		crouchspeed = 100;
		extracrouch = 0;
	}
}

void CL_DisableLerpMove(void)
{
	nolerp[0] = nolerp[1] = nolerp_nextpos = true;
}

static void CL_LerpMove (qbool angles_lerp)
{	
	static int		lastsequence = 0;
	static vec3_t	lerp_angles[3];
	static vec3_t	lerp_origin[3];
	static double	lerp_times[3];
	static double	demo_latency = 0.01;
	float	frac;
	double	simtime;
	int		i;
	int		from, to;
	extern cvar_t cl_nolerp;
	extern int cmdtime_msec;
	extern double physframetime;
	extern qbool cl_nolerp_on_entity_flag;
	double  current_time = cls.demoplayback ? cls.demotime : cls.realtime;
	double  current_lerp_time = cls.demoplayback ? cls.demopackettime : (cmdtime_msec * 0.001);
	qbool   physframe = cls.netchan.outgoing_sequence != lastsequence;

	if ((cl_nolerp.value || cl_nolerp_on_entity_flag)) {
		//reset
		nolerp[0] = nolerp[1] = nolerp_nextpos = false;
		lastsequence = ((unsigned)-1) >> 1;
		return;
	}

	if (cls.netchan.outgoing_sequence < lastsequence) 
	{
		// reset
		lastsequence = -1;
		lerp_times[0] = -1;
		demo_latency = 0.01;
	}

	// Independent physics.
	if (physframe)
	{
		lastsequence = cls.netchan.outgoing_sequence;

		// move along
		lerp_times[2] = lerp_times[1];
		lerp_times[1] = lerp_times[0];
		lerp_times[0] = current_lerp_time;

		VectorCopy (lerp_origin[1], lerp_origin[2]);
		VectorCopy (lerp_origin[0], lerp_origin[1]);
		VectorCopy (cl.simorg, lerp_origin[0]);

		VectorCopy (lerp_angles[1], lerp_angles[2]);
		VectorCopy (lerp_angles[0], lerp_angles[1]);
		VectorCopy (cl.simangles, lerp_angles[0]);

		nolerp[1] = nolerp[0];
		nolerp[0] = nolerp_nextpos;
		nolerp_nextpos = false;

		for (i = 0; i < 3; i++)
		{
			if (fabs(lerp_origin[0][i] - lerp_origin[1][i]) > 100)
			{
				break;
			}
		}

		if (i < 3)
		{
			extern cvar_t cl_earlypackets;

			// a teleport or something
			nolerp[0] = true;

			// cl.simangles will already be set, don't lerp there either
			// (gives a flash of looking in wrong direction at teleport entrance)
			nolerp[1] |= (cl_earlypackets.integer);
		}
	}

	simtime = current_time - demo_latency;

	// Adjust latency
	if (simtime > lerp_times[0]) 
	{
		// High clamp
		demo_latency = current_time - lerp_times[0];
	}
	else if (simtime < lerp_times[2]) 
	{
		// Low clamp
		demo_latency = current_time - lerp_times[2];
	} 
	else
	{
		// slowly drift down till corrected
		if (physframe)
			demo_latency -= min(physframetime * 0.005, 0.001);
	}

	// decide where to lerp from
	if (simtime > lerp_times[1]) {
		from = 1;
		to = 0;
	} 
	else {
		from = 2;
		to = 1;
	}

	if (nolerp[to]) {
		return;
	}

    frac = (simtime - lerp_times[from]) / (lerp_times[to] - lerp_times[from]);
    frac = bound (0, frac, 1);

	if ((cl.spectator && cl.viewplayernum != cl.playernum) || angles_lerp) {
		// we track someone, so lerp angles
		AngleInterpolate(lerp_angles[from], frac, lerp_angles[to], cl.simangles);
	}

	for (i = 0; i < 3; i++)	{
		cl.simorg[i] = lerp_origin[from][i] + (lerp_origin[to][i] - lerp_origin[from][i]) * frac;
	}
}

qbool cl_nolerp_on_entity_flag = false;
// function check_standing_on_entity(void)
// raises flag cl_nolerp_on_entity_flag if standing on entity
// and cl_nolerp_on_entity.value is 1
static void check_standing_on_entity(void)
{
  extern cvar_t cl_nolerp;
  extern cvar_t cl_nolerp_on_entity;
  extern cvar_t cl_independentPhysics;
  cl_nolerp_on_entity_flag = 
       (pmove.onground && pmove.groundent > 0 &&
        cl_nolerp_on_entity.value &&
        cl_independentPhysics.value);
}

void CL_PredictMove (qbool physframe) {
	int i, oldphysent;
	frame_t *from = NULL, *to;
	qbool angles_lerp = false;

	if (cl.paused && !CL_MultiviewEnabled())
		return;

	if (cl.intermission) {
		cl.crouch = 0;
		return;
	}

	if (cls.nqdemoplayback)
		return;

	if (!cl.validsequence)
		return;

	if (cls.netchan.outgoing_sequence - cl.validsequence >= UPDATE_BACKUP - 1)
		return;

	VectorCopy (cl.viewangles, cl.simangles);

	// this is the last valid frame received from the server
	to = &cl.frames[cl.validsequence & UPDATE_MASK];


#ifdef JSS_CAM
	if (clpred_newpos && cls.demoplayback && cl.spectator)
		VectorCopy (cl.simorg, to->playerstate[cl.playernum].origin);
	clpred_newpos = false;
#endif

	// FIXME...
	if (cls.demoplayback && cl.spectator && cl.viewplayernum != cl.playernum) {
		VectorCopy (to->playerstate[cl.viewplayernum].velocity, cl.simvel);
#ifdef JSS_CAM
		if (!(cam_thirdperson.value && cam_lockpos.value) && !clpred_newpos)
			VectorCopy (to->playerstate[cl.viewplayernum].origin, cl.simorg);
		if (!cam_thirdperson.value)
			VectorCopy (to->playerstate[cl.viewplayernum].viewangles, cl.simangles);
#endif
		CL_CategorizePosition ();
	}
	else if (to->playerstate[cl.playernum].pm_type == PM_LOCK)
	{
		angles_lerp = true;

		VectorCopy (to->playerstate[cl.playernum].velocity, cl.simvel);
		VectorCopy (to->playerstate[cl.playernum].origin, cl.simorg);
		VectorCopy (to->playerstate[cl.playernum].command.angles, cl.simangles);
		cl.onground = false;
	}
	else if ((cl_nopred.value && !cls.mvdplayback) || cl.validsequence + 1 >= cls.netchan.outgoing_sequence) {
		VectorCopy (to->playerstate[cl.playernum].velocity, cl.simvel);
		VectorCopy (to->playerstate[cl.playernum].origin, cl.simorg);
		CL_CategorizePosition ();
	}
	else if (physframe || !cl_independentPhysics.value)
	{
		oldphysent = pmove.numphysent;
		CL_SetSolidPlayers (cl.playernum);

		// run frames
		for (i = 1; i < UPDATE_BACKUP - 1 && cl.validsequence + i < cls.netchan.outgoing_sequence; i++) {
			from = to;
			to = &cl.frames[(cl.validsequence + i) & UPDATE_MASK];
			CL_PredictUsercmd (&from->playerstate[cl.playernum], &to->playerstate[cl.playernum], &to->cmd);
		}

		pmove.numphysent = oldphysent;

		// save results
		VectorCopy (to->playerstate[cl.playernum].velocity, cl.simvel);
		VectorCopy (to->playerstate[cl.playernum].origin, cl.simorg);
		cl.onground = pmove.onground;
		cl.waterlevel = pmove.waterlevel;
		check_standing_on_entity();
	}

	if (!cls.mvdplayback && cl_independentPhysics.value != 0) {
		CL_LerpMove (angles_lerp || cls.demoplayback);
	}
    CL_CalcCrouch ();

#ifdef JSS_CAM
	if (cam_thirdperson.value && cam_lockpos.value && cl.viewplayernum != cl.playernum) {
		vec3_t v;
		player_state_t *pstate;
		int i;

		i = cl.viewplayernum;

		pstate = &cl.frames[cl.parsecount & UPDATE_MASK].playerstate[i];
		VectorSubtract (pstate->origin, cl.simorg, v);
		vectoangles (v, cl.simangles);
		cl.simangles[PITCH] = -cl.simangles[PITCH];
	}
	else if (cam_thirdperson.value && cl.viewplayernum != cl.playernum) {
		int i;
		player_state_t *pstate;
		vec3_t fw, rt, up;

		i = cl.viewplayernum;

		pstate = &cl.frames[cl.parsecount & UPDATE_MASK].playerstate[i];

		AngleVectors (cl.simangles, fw, rt, up);
		VectorMA (pstate->origin, -cam_dist.value, fw, cl.simorg);
	}
#endif	// JSS_CAM
	
}

void CL_InitPrediction(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_NETWORK);
	Cvar_Register(&cl_nopred);
	Cvar_ResetCurrentGroup();

#ifdef JSS_CAM
	Cvar_SetCurrentGroup(CVAR_GROUP_SPECTATOR);
	Cvar_Register(&cam_thirdperson);
	Cvar_Register(&cam_dist);
	Cvar_Register(&cam_lockdir);
	Cvar_Register(&cam_lockpos);
	Cvar_ResetCurrentGroup();
#endif
}
 


================================================
FILE: src/cl_screen.c
================================================
/*
Copyright (C) 1996-2003 Id Software, Inc., A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: cl_screen.c,v 1.156 2007-10-29 00:56:47 qqshka Exp $
*/

/// declarations may be found in screen.h

#include "quakedef.h"
#include <time.h>
#include "vx_tracker.h"
#include "gl_model.h"
#include "mvd_utils.h"
#include "keys.h"
#include "hud.h"
#include "hud_common.h"
#include "hud_editor.h"
#include "utils.h"
#include "vx_stuff.h"
#include "gl_model.h"
#include "teamplay.h"
#include "input.h"
#include "utils.h"
#include "sbar.h"
#include "menu.h"
#include "Ctrl.h"
#include "qtv.h"
#include "demo_controls.h"
#include "r_trace.h"
#include "r_lightmaps.h"
#include "r_local.h"
#include "r_chaticons.h"
#include "r_renderer.h"
#include "r_matrix.h"
#include "qsound.h"

#ifndef CLIENTONLY
#include "server.h"
#endif

void WeaponStats_CommandInit(void);
void SCR_DrawHud(void);
void SCR_DrawClocks(void);
void R_SetupFrame(void);
void SCR_Draw_TeamInfo(void);
void SCR_Draw_ShowNick(void);
void SCR_DrawQTVBuffer(void);
void SCR_DrawFPS(void);
void SCR_DrawSpeed(void);
qbool V_PreRenderView(void);

static void SCR_DrawDamageIndicators(void);
void SCR_SetupDamageIndicators(void);
static void SCR_RegisterDamageIndicatorCvars(void);
void CL_SpawnDamageIndicator(int deathtype, int targ_ent, int damage, qbool splash_damage, qbool team_damage);

int	glx, gly, glwidth, glheight;

#define ALPHA_COLOR(x, y) RGBA_TO_COLOR((x)[0],(x)[1],(x)[2],(y))

extern byte	current_pal[768];	// Tonik

int	host_screenupdatecount; // kazik - HUD -> hexum

// only the refresh window will be updated unless these variables are flagged
int		scr_copytop;
int		scr_copyeverything;

float	scr_con_current;
float	scr_conlines;           // lines of console to display

qbool	scr_skipupdate;
qbool	block_drawing;

float	oldscreensize, oldfov, oldsbar;

#define ZOOMEDFOV 35
qbool	zoomedin;
float	unzoomedfov;
float	unzoomedsensitivity;

void OnFovChange (cvar_t *var, char *value, qbool *cancel);
void OnDefaultFovChange (cvar_t *var, char *value, qbool *cancel);
cvar_t	scr_fov					= {"fov", "90", CVAR_NONE, OnFovChange};	// 10 - 140
cvar_t	default_fov				= {"default_fov", "90", CVAR_NONE, OnDefaultFovChange};
cvar_t	scr_viewsize			= {"viewsize", "100", CVAR_NONE};
cvar_t	scr_consize				= {"scr_consize", "0.5"};
cvar_t	scr_conspeed			= {"scr_conspeed", "9999"};
cvar_t	scr_showturtle			= {"showturtle", "0"};
cvar_t	scr_showpause			= {"showpause", "1"};

cvar_t	scr_newHud              = {"scr_newhud", "0"};

cvar_t	show_velocity_3d		= {"show_velocity_3d", "0"};
cvar_t	show_velocity_3d_offset_forward	= {"show_velocity_3d_offset_forward", "2.5"};
cvar_t	show_velocity_3d_offset_down	= {"show_velocity_3d_offset_down", "5"};

cvar_t	cl_hud					= {"cl_hud", "1"};	// QW262 HUD.

cvar_t	gl_triplebuffer			= {"gl_triplebuffer", "1"};
cvar_t  r_chaticons_alpha		= {"r_chaticons_alpha", "0.8"};
cvar_t	scr_coloredfrags		= {"scr_coloredfrags", "0"};

cvar_t	scr_cursor_scale		= {"scr_cursor_scale", "0.2"};			// The mouse cursor scale.
cvar_t	scr_cursor_iconoffset_x	= {"scr_cursor_iconoffset_x", "0"};	// How much the cursor icon should be offseted from the cursor.
cvar_t	scr_cursor_iconoffset_y	= {"scr_cursor_iconoffset_y", "0"};
cvar_t	scr_cursor_alpha		= {"scr_cursor_alpha", "1"};

cvar_t  scr_showcrosshair       = {"scr_showcrosshair", "1"}; // so crosshair does't affected by +showscores, or vice versa
cvar_t  scr_notifyalways        = {"scr_notifyalways", "0"}; // don't hide notification messages in intermission

cvar_t  scr_fovmode             = {"scr_fovmode", "0"}; // When using reduced viewsize, reduce vertical fov or letterbox the screen
cvar_t  r_drawhud               = {"r_drawhud", "1"};   // disables hud rendering

qbool	scr_initialized;	// Ready to draw.

mpic_t	*scr_ram;
mpic_t	*scr_net;
mpic_t	*scr_turtle;
mpic_t  *scr_cursor;		// Cursor image.
mpic_t	*scr_cursor_icon;	// Cursor icon image (load icon or similar).

int		scr_fullupdate;

int		clearconsole;
int		clearnotify;

viddef_t vid; // global video state

vrect_t	scr_vrect;

qbool	scr_skipupdate;

qbool	scr_drawloading;
qbool	scr_disabled_for_loading;
float	scr_disabled_time;

qbool	block_drawing;

double cursor_x = 0, cursor_y = 0;

void SCR_DrawMultiviewBorders(void);
void SCR_DrawMVStatus(void);
void SCR_DrawMVStatusStrings(void);

/************************************ FOV ************************************/

extern	cvar_t		v_idlescale;
qbool	concussioned = false;

void OnFovChange (cvar_t *var, char *value, qbool *cancel)
{
	float newfov = Q_atof(value);

	if (newfov > 140)
		newfov = 140;
	else if (newfov < 10)
		newfov = 10;

	if (newfov == scr_fov.value && newfov == default_fov.value) {
		*cancel = true;
		return;
	}

	if (cbuf_current != &cbuf_svc) {
		Cvar_SetValue (&default_fov, newfov);
		if (concussioned && !cls.demoplayback) {
			*cancel = true;
			return;
		}
	} else {
		if (newfov != 90 && cl.teamfortress && v_idlescale.value >= 20) {
			concussioned = true;
			if (v_idlescale.value == 100)
				TP_ExecTrigger ("f_conc");
		} else if (newfov == 90 && cl.teamfortress) {
			concussioned = false;
		}
		if (cls.demoplayback) { // && !cl_fovfromdemo.value)
			*cancel = true;
			return;
		}
	}

	vid.recalc_refdef = true;
	if (newfov == 90) {
		Cvar_Set (&scr_fov,default_fov.string);
		*cancel = true;
		return;
	}

	Cvar_SetValue (&scr_fov, newfov);
	*cancel = true;
}

void OnDefaultFovChange (cvar_t *var, char *value, qbool *cancel)
{
	float newfov = Q_atof(value);

	if (newfov < 10.0 || newfov > 140.0){
		Com_Printf("Invalid default_fov\n");
		*cancel = true;
	}
}

// Much above this for fovx and we'd need to change the visibility calculations, getting hall of mirrors effect
#define FOVX_SANITY_LIMIT 165
#define FOVY_SANITY_LIMIT 140

static void CalcFov(float fov, float *fov_x, float *fov_y, float width, float height, float view_width, float view_height, qbool reduce_vertfov)
{
	float t;
	float fovx;
	float fovy;

	fov = bound(10, fov, 140);

	if (width / 4 < height / 3) {
		fovx = fov;

		if (reduce_vertfov) {
			// Crop vertically when viewsize decreased
			// hmx: Fixes "legacy" fov style causing some visual glitches since 3.0.1 in rare aspect ratios/viewsizes combos
			// *almost* matches 3.0 results *and* not visually broken
			t = view_width / tan(fovx / 360 * M_PI);
			fovy = atan(view_height / t) * 360 / M_PI;
		}
		else {
			t = width / tan(fovx / 360 * M_PI);
			fovy = atan(height / t) * 360 / M_PI;
		}
	}
	else {
		fovx = fov;

		// Work out what the vertical FOV would be on 4:3 display
		t = 4.0 / tan(fovx / 360 * M_PI);
		fovy = atan (3.0 / t) * 360 / M_PI;

		// Now work out what the correct FOV is
		t = height / tan(fovy / 360 * M_PI);
		fovx = atan (width / t) * 360 / M_PI;

		if (reduce_vertfov) {
			// Crop vertically when viewsize decreased
			t = view_width / tan (fovx / 360 * M_PI);
			fovy = atan (view_height / t) * 360 / M_PI;
		}
	}

	if ((fovx < 10 || fovx > FOVX_SANITY_LIMIT))
	{
		Con_DPrintf("Limiting fovx (was %f)\n", fovx);
		fovx = bound(10, fovx, FOVX_SANITY_LIMIT);

		t = width / tan(fovx / 360 * M_PI);
		fovy = atan (height / t) * 360 / M_PI;
	}

	if (fovy < 10 || fovy > FOVY_SANITY_LIMIT)
	{
		Con_DPrintf("Limiting FOVY (was %f)\n", fovy);
		fovy = bound(10, fovy, FOVY_SANITY_LIMIT);

		t = height / tan(fovy / 360 * M_PI);
		fovx = atan (width / t) * 360 / M_PI;
	}

	if (fovx < 1 || fovx > FOVX_SANITY_LIMIT || fovy < 1 || fovy > FOVY_SANITY_LIMIT) {
		Sys_Error("CalcFov: Bad fov (%f, %f)", fovx, fovy);
	}
	else {
		Con_DPrintf("fov: %f %f\n", fovx, fovy);
	}

	*fov_x = fovx;
	*fov_y = fovy;
}

//Must be called whenever vid changes
void SCR_CalcRefdef(void)
{
	float size = 0;
	qbool full = false;
	int h;
	float aspectratio = vid.height ? (float)vid.width / vid.height : 1;
	qbool letterbox = (scr_fovmode.integer == 1);
	qbool height_reduced = false;

	scr_fullupdate = 0;             // force a background redraw
	vid.recalc_refdef = 0;

	// force the status bar to redraw
	Sbar_Changed ();

	// bound viewsize
	if (scr_viewsize.value < 30) {
		Cvar_Set(&scr_viewsize, "30");
	}
	if (scr_viewsize.value > 120) {
		Cvar_Set(&scr_viewsize, "120");
	}

	// intermission is always full screen
	size = cl.intermission ? 120 : scr_viewsize.value;

	if (size >= 120) {
		sb_lines = 0;           // no status bar at all
	}
	else if (size >= 110) {
		sb_lines = 24;          // no inventory
	}
	else {
		sb_lines = 24 + 16 + 8;
	}

	if (scr_viewsize.value >= 100.0) {
		full = true;
		size = 100.0;
	}
	else {
		size = scr_viewsize.value;
	}
	if (cl.intermission) {
		full = true;
		size = 100.0;
		sb_lines = 0;
	}
	size /= 100.0;

	if (!cl_sbar.value && full)
		h = vid.height;
	else
		h = vid.height - sb_lines;

	r_refdef.vrect.width = vid.width * size;
	if (r_refdef.vrect.width < 96) {
		size = 96.0 / r_refdef.vrect.width;
		r_refdef.vrect.width = 96;      // min for icons
	}

	r_refdef.vrect.height = vid.height * size;
	if (cl_sbar.value || !full) {
		if (r_refdef.vrect.height > vid.height - sb_lines) {
			r_refdef.vrect.height = vid.height - sb_lines;
			height_reduced = true;
		}
	} else if (r_refdef.vrect.height > vid.height) {
		r_refdef.vrect.height = vid.height;
	}

	// Reduce width to keep aspect ratio constant with monitor
	if (letterbox) {
		r_refdef.vrect.width = min (r_refdef.vrect.width, r_refdef.vrect.height * aspectratio);
		height_reduced = false;
	}

	r_refdef.vrect.x = (vid.width - r_refdef.vrect.width) / 2;
	if (full)
		r_refdef.vrect.y = 0;
	else
		r_refdef.vrect.y = (h - r_refdef.vrect.height) / 2;

	CalcFov (scr_fov.value, &r_refdef.fov_x, &r_refdef.fov_y, vid.width, vid.height, r_refdef.vrect.width, r_refdef.vrect.height, height_reduced);

	scr_vrect = r_refdef.vrect;
}

//Keybinding command
void SCR_SizeUp_f(void)
{
	Cvar_SetValue(&scr_viewsize, scr_viewsize.value + 10);
	vid.recalc_refdef = 1;
}

//Keybinding command
void SCR_SizeDown_f(void)
{
	Cvar_SetValue(&scr_viewsize, scr_viewsize.value - 10);
	vid.recalc_refdef = 1;
}

void SCR_ZoomIn_f(void)
{
	if (zoomedin) {
		return;
	}
	zoomedin = true;
	unzoomedfov = scr_fov.value;
	unzoomedsensitivity = sensitivity.value;
	Cvar_SetValue(&scr_fov, ZOOMEDFOV);
	Cvar_SetValue(&sensitivity, unzoomedsensitivity * ((double)ZOOMEDFOV / unzoomedfov));
}

void SCR_ZoomOut_f(void)
{
	if (!zoomedin) {
		return;
	}
	zoomedin = false;
	Cvar_SetValue(&scr_fov, unzoomedfov);
	Cvar_SetValue(&sensitivity, unzoomedsensitivity);
}

/********************************** ELEMENTS **********************************/

#ifdef EXPERIMENTAL_SHOW_ACCELERATION
void SCR_DrawAccel (void) {
	extern qbool player_in_air;
	extern float cosinus_val;

	int x, y, length, charsize, pos;
	const float scale_factor = 10.f;
	char cosinus_str[10];
	if(!player_in_air) return;

	charsize = (int) (8.f * vid.height / vid.conheight);
	length = vid.width / 3;
	x = (vid.width - length) / 2;
	y = vid.height - sb_lines - charsize - 1;

	pos = (int) ((cosinus_val + 1) * length / 2);

	hud.draw_accel_bar(x, y, length, charsize, pos);

	//scale: show most interesting
	pos = (int) ((cosinus_val * scale_factor + 1) * length / 2);

	hud.draw_accel_bar(x, y - 2 * charsize, length, charsize, pos);

	cosinus_str[0] = '\0';
	sprintf(cosinus_str,"%.3f", cosinus_val);
	Draw_String(x, y - charsize, cosinus_str);
}
#endif

void SCR_DrawTurtle(void)
{
	if (!scr_showturtle.value || cls.fps >= scr_showturtle.value) {
		return;
	}

	Draw_Pic(scr_vrect.x, scr_vrect.y, scr_turtle);
}

static void SCR_DrawNet(void)
{
	if (cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged < UPDATE_BACKUP - 1) {
		return;
	}
	if (cls.demoplayback || scr_newHud.value == 1) {
		return;
	}

	Draw_Pic(scr_vrect.x + 64, scr_vrect.y, scr_net);
}

static void SCR_DrawPause (void) {
	mpic_t *pic;

	if (!scr_showpause.value)               // turn off for screenshots
		return;

	if (!cl.paused)
		return;

#ifndef CLIENTONLY
	if (sv.paused == 2)
		return; // auto-paused in single player
#endif

	pic = Draw_CachePic (CACHEPIC_PAUSE);
	Draw_Pic ((vid.width - pic->width) / 2, (vid.height - 48 - pic->height) / 2, pic);
}

void SCR_DrawLoading (void) {
	mpic_t *pic;

	if (!scr_drawloading)
		return;

	pic = Draw_CachePic (CACHEPIC_LOADING);
	Draw_Pic ( (vid.width - pic->width )/ 2, (vid.height - 48 - pic->height) / 2, pic);
}



void SCR_BeginLoadingPlaque (void) {
	if (cls.state != ca_active)
		return;

	if (key_dest == key_console)
		return;

	// redraw with no console and the loading plaque
	scr_fullupdate = 0;
	Sbar_Changed ();
	scr_drawloading = true;
	SCR_UpdateScreen ();
	scr_drawloading = false;

	scr_disabled_for_loading = true;
	scr_disabled_time = cls.realtime;
	scr_fullupdate = 0;
}

void SCR_EndLoadingPlaque (void) {
	if (!scr_disabled_for_loading)
		return;
	scr_disabled_for_loading = false;
	scr_fullupdate = 0;
}

/********************************** CONSOLE **********************************/

void SCR_SetUpToDrawConsole (void) {
	Con_CheckResize ();
	
	// decide on the height of the console
	if (SCR_NEED_CONSOLE_BACKGROUND) {
		scr_conlines = vid.height;		// full screen
		scr_con_current = scr_conlines;
	} else if (key_dest == key_console) {
		scr_conlines = vid.height * scr_consize.value;
		scr_conlines = bound(30, scr_conlines, vid.height);
	} else {
		scr_conlines = 0;				// none visible
	}

	if (scr_conlines < scr_con_current)	{
		scr_con_current -= scr_conspeed.value * cls.trueframetime * vid.height / 320;
		scr_con_current = max(scr_con_current, scr_conlines);
	} else if (scr_conlines > scr_con_current) {
		scr_con_current += scr_conspeed.value * cls.trueframetime * vid.height / 320;
		scr_con_current = min(scr_con_current, scr_conlines);
	}

	if (clearconsole++ < vid.numpages)
	{
		Sbar_Changed ();
	}
	else
	{
		con_notifylines = 0;
	}

	clearnotify++;
}

void SCR_DrawConsole (void) {
	if (scr_con_current) {
		scr_copyeverything = 1;
		Con_DrawConsole (scr_con_current);
		clearconsole = 0;
	} else {
		if (key_dest == key_game || key_dest == key_message || (key_dest == key_menu && m_state == m_proxy))
			Con_DrawNotify ();      // only draw notify in game
	}
}

/********************************* TILE CLEAR *********************************/

void SCR_TileClear(void)
{
	int sb_lines_cleared = scr_newHud.integer ? 0 : sb_lines; // newhud does not (typically) have solid status bar, so clear the bottom of the screen

	if (cls.state != ca_active && cl.intermission) {
		Draw_TileClear(0, 0, vid.width, vid.height);
		return;
	}

	if (r_refdef.vrect.x > 0) {
		// left
		Draw_TileClear(0, 0, r_refdef.vrect.x, vid.height - sb_lines_cleared);
		// right
		Draw_TileClear(r_refdef.vrect.x + r_refdef.vrect.width, 0,
			vid.width - (r_refdef.vrect.x + r_refdef.vrect.width), vid.height - sb_lines_cleared);
	}
	if (r_refdef.vrect.y > 0) {
		// top
		Draw_TileClear(r_refdef.vrect.x, 0, r_refdef.vrect.width, r_refdef.vrect.y);
	}
	if (r_refdef.vrect.y + r_refdef.vrect.height < vid.height - sb_lines_cleared) {
		// bottom
		Draw_TileClear(r_refdef.vrect.x,
			r_refdef.vrect.y + r_refdef.vrect.height,
			r_refdef.vrect.width,
			vid.height - sb_lines_cleared - (r_refdef.vrect.height + r_refdef.vrect.y));
	}
}

//
// Calculates the cursor scale based on the current screen/text size
//
static double SCR_GetCursorScale(void) 
{
	return (double) scr_cursor_scale.value * ((double) vid.width / (double)vid.conwidth);
}

static void SCR_DrawCursor(void) 
{
	double scale = SCR_GetCursorScale();

	// Always draw the cursor if fullscreen
	if (IN_QuakeMouseCursorRequired()) {
		float x_coord = scr_pointer_state.x;
		float y_coord = scr_pointer_state.y;

		if (scr_cursor && R_TextureReferenceIsValid(scr_cursor->texnum)) {
			Draw_SAlphaPic(x_coord + scr_cursor_iconoffset_x.value, y_coord + scr_cursor_iconoffset_y.value, scr_cursor, scr_cursor_alpha.value, scale);

			if (scr_cursor_icon && R_TextureReferenceIsValid(scr_cursor_icon->texnum)) {
				Draw_SAlphaPic(x_coord + scr_cursor_iconoffset_x.value, y_coord + scr_cursor_iconoffset_y.value, scr_cursor_icon, scr_cursor_alpha.value, scale);
			}
		}
		else {
			color_t c = RGBA_TO_COLOR(0, 255, 0, 255);

			Draw_AlphaLineRGB(x_coord + (10 * scale), y_coord + (10 * scale), x_coord + (40 * scale), y_coord + (40 * scale), 10 * scale, c);
			Draw_AlphaLineRGB(x_coord, y_coord, x_coord + (20 * scale), y_coord, 10 * scale, c);
			Draw_AlphaLineRGB(x_coord, y_coord, x_coord, y_coord + 20 * scale, 10 * scale, c);
			Draw_AlphaLineRGB(x_coord + (20 * scale), y_coord, x_coord, y_coord + (20 * scale), 10 * scale, c);
		}
	}

	// remember the position for future
	scr_pointer_state.x_old = scr_pointer_state.x;
	scr_pointer_state.y_old = scr_pointer_state.y;
}

static void SCR_UpdateCursor(void)
{
	int max_x = VID_RenderWidth2D();
	int max_y = VID_RenderHeight2D();

	// vid_sdl2 updates absolute cursor position when not locked
	scr_pointer_state.x = bound(0, (cursor_x * vid.conwidth) / max_x, max_x - 1);
	scr_pointer_state.y = bound(0, (cursor_y * vid.conheight) / max_y, max_y - 1);

	if (IN_MouseTrackingRequired() && (scr_pointer_state.x != scr_pointer_state.x_old || scr_pointer_state.y != scr_pointer_state.y_old)) {
		Mouse_MoveEvent();
	}
}

static void SCR_VoiceMeter(void)
{
#ifdef FTE_PEXT2_VOICECHAT

	float	range;
	int		loudness;
	int		w1, w2;
	int		w = 100;												// random.
	int     h = 8;
	int     x, y;

	if (!S_Voip_ShowMeter (&x, &y)) {
		return;
	}

	loudness = S_Voip_Loudness();

	if (loudness < 0)
		return;

	range = loudness / 100.0f;
	range = bound(0.0f, range, 1.0f);
	w1 = range * w;
	w2 = w - w1;
	Draw_String (x, y, "mic ");
	x += 8 * (sizeof("mic ")-1);
	Draw_AlphaRectangleRGB(x, y, w1, h, 1, true, RGBA_TO_COLOR(255, 0, 0, 255));
	x += w1;
	Draw_AlphaRectangleRGB(x, y, w2, h, 1, true, RGBA_TO_COLOR(0, 255, 0, 255));

#endif // FTE_PEXT2_VOICECHAT
}

void SCR_DrawMultiviewOverviewElements (void)
{
	SCR_DrawMultiviewBorders ();
}

// Elements to be drawn on every view during multiview
void SCR_DrawMultiviewIndividualElements(void)
{
	extern qbool  sb_showscores,  sb_showteamscores;

	// Show autoid in all views
	if (!sb_showscores && !sb_showteamscores) {
		SCR_DrawAutoID();
		SCR_DrawDamageIndicators();
	}

	// Crosshair
	if ((key_dest != key_menu) && (scr_showcrosshair.integer || (!sb_showscores && !sb_showteamscores))) {
		if (!CL_MultiviewInsetView() || cl_mvinsetcrosshair.integer) {
			Draw_Crosshair();
		}
	}

	// Draw multiview mini-HUD's.
	if (cl_mvdisplayhud.integer) {
		if (cl_mvdisplayhud.integer >= 2) {
			// Graphical with icons.
			SCR_DrawMVStatus();
		}
		else {
			// Only strings.
			SCR_DrawMVStatusStrings();
		}
	}

	CL_MultiviewInsetRestoreStats();
}

static void SCR_DrawElements(void) 
{
	extern qbool  sb_showscores,  sb_showteamscores;
	extern cvar_t	scr_menudrawhud;

	if (scr_drawloading) 
	{
		SCR_DrawLoading ();
		Sbar_Draw ();
		HUD_Draw ();		// HUD -> hexum
	}
	else 
	{
		SCR_UpdateCursor();

		if( !(!scr_menudrawhud.integer && (m_state != m_none)) || (!scr_menudrawhud.integer && (m_state == m_proxy)) )
		{
			if (cl.intermission == 1) {
				Sbar_IntermissionOverlay();
				if (!scr_notifyalways.integer) {
					Con_ClearNotify();
				}
				HUD_Draw();
			}
			else if (cl.intermission == 2) {
				Sbar_FinaleOverlay();
				SCR_CenterString_Draw();
				if (!scr_notifyalways.integer) {
					Con_ClearNotify();
				}
				HUD_Draw();
			}
			else if (cls.state == ca_active) {
				SCR_DrawNet ();
				SCR_DrawTurtle ();
#ifdef EXPERIMENTAL_SHOW_ACCELERATION
				SCR_DrawAccel();
#endif

				if (!sb_showscores && !sb_showteamscores) 
				{ 
					// Do not show if +showscores
					SCR_DrawPause();

					SCR_DrawAutoID();

					SCR_DrawAntilagIndicators();

					SCR_DrawDamageIndicators();

					SCR_VoiceMeter();
				}

				if ((key_dest != key_menu) && (scr_showcrosshair.integer || (!sb_showscores && !sb_showteamscores)))
				{
					Draw_Crosshair ();
				}

				// Do not show if +showscores
				if (!sb_showscores && !sb_showteamscores)
				{
					SCR_Draw_TeamInfo();

					SCR_Draw_ShowNick();

					SCR_CenterString_Draw();
					SCR_DrawSpeed();
					SCR_DrawClocks();
					SCR_DrawQTVBuffer();
					SCR_DrawFPS();
				}

				// QW262
				SCR_DrawHud();

				if (cls.mvdplayback) {
					MVD_Screen();
				}

				// VULT DISPLAY KILLS
				VX_TrackerThink();

				if (CL_MultiviewEnabled())
					SCR_DrawMultiviewOverviewElements ();

				Sbar_Draw();
				HUD_Draw();
				HUD_Editor_Draw();

				DemoControls_Draw();
			}
		}

		if (!SCR_TakingAutoScreenshot()) {
			SCR_DrawConsole();

			M_Draw();
		}

		SCR_DrawCursor();
	}
}

/******************************* UPDATE SCREEN *******************************/

qbool SCR_UpdateScreenPrePlayerView (void)
{
	extern cvar_t gl_clear;
	extern qbool Minimized;
	static int oldfovmode = 0;

	if (!scr_initialized) {
		return false;
	}

	if (scr_skipupdate || block_drawing) {
		return false;
	}

	if (scr_disabled_for_loading) {
		if (cls.realtime - scr_disabled_time > 20) {
			scr_disabled_for_loading = false;
		}
		else {
			return false;
		}
	}
	// Don't suck up any cpu if minimized.

	if (Minimized) {
		return false;
	}

	vid.numpages = 2 + gl_triplebuffer.value;

	scr_copytop = 0;
	scr_copyeverything = 0;

	host_screenupdatecount++;  // For HUD.

	// Check for vid changes.
	if (oldfov != scr_fov.value) 
	{
		oldfov = scr_fov.value;
		vid.recalc_refdef = true;
	}

	if (oldscreensize != scr_viewsize.value) 
	{
		oldscreensize = scr_viewsize.value;
		vid.recalc_refdef = true;
	}

	if (oldsbar != cl_sbar.value) 
	{
		oldsbar = cl_sbar.value;
		vid.recalc_refdef = true;
	}

	if (oldfovmode != scr_fovmode.integer) {
		oldfovmode = scr_fovmode.integer;
		vid.recalc_refdef = true;
	}

	if (vid.recalc_refdef) {
		SCR_CalcRefdef();
	}

	if ((v_contrast.value > 1 && !vid_hwgamma_enabled) || gl_clear.value) {
		Sbar_Changed();
	}
	else if (scr_newHud.integer == 2 && scr_viewsize.value < 120) {
		Sbar_Changed();
	}

	return true;
}

void SCR_UpdateScreenPlayerView(int flags)
{
	qbool draw_2d = !(flags & UPDATESCREEN_3D_ONLY);
	qbool draw_3d = !(flags & UPDATESCREEN_2D_ONLY);

	if (draw_3d) {
		R_CheckReloadLightmaps();

		// preache skins if needed
		Skins_PreCache();

		SCR_SetUpToDrawConsole();

		R_BeginRendering(&glx, &gly, &glwidth, &glheight);

		if (V_PreRenderView()) {
			R_SetupFrame();

			R_RenderView();

			if (flags & UPDATESCREEN_POSTPROCESS) {
				R_PostProcessScene();
			}
		}
	}

	if (draw_2d) {
		R_SetupChatIcons();

		R_Set2D();

		R_PolyBlend();

		// draw any areas not covered by the refresh
		SCR_TileClear();
	}
}

void SCR_HUD_WeaponStats(hud_t* hud);

// Drawing new HUD items in old HUD mode - eventually move everything across
static void SCR_DrawNewHudElements(void)
{
	extern cvar_t r_netgraph, r_netstats;
	static hud_t *hud_netstats = NULL;
	static hud_t *hud_weaponstats = NULL;
	if (hud_netstats == NULL) // first time
		hud_netstats = HUD_Find("net");
	if (hud_weaponstats == NULL)
		hud_weaponstats = HUD_Find("weaponstats");

	if (r_netgraph.value)
	{
		float temp = hud_netgraph->show->value;

		Cvar_SetValue(hud_netgraph->show, 1);
		SCR_HUD_Netgraph(hud_netgraph);
		Cvar_SetValue(hud_netgraph->show, temp);
	}

	if (r_netstats.value)
	{
		float temp = hud_netstats->show->value;

		Cvar_SetValue(hud_netstats->show, 1);
		SCR_HUD_DrawNetStats(hud_netstats);
		Cvar_SetValue(hud_netstats->show, temp);
	}

	if (hud_weaponstats && hud_weaponstats->show && hud_weaponstats->show->value) {
		SCR_HUD_WeaponStats(hud_weaponstats);
	}
}

void SCR_UpdateScreenHudOnly(void)
{
	if (r_drawhud.integer) {
		R_TraceEnterNamedRegion("HUD");
		if (scr_newHud.value != 1) {
			SCR_DrawNewHudElements();
		}

		SCR_DrawElements();

		// Actual rendering...
		if (r_drawhud.integer != 2) {
			R_FlushImageDraw();
		}
		R_TraceLeaveNamedRegion();
	}
}

void SCR_UpdateScreenPostPlayerView(void)
{
	SCR_UpdateScreenHudOnly();

	renderer.PostProcessScreen();

	SCR_CheckAutoScreenshot();

	VID_RenderFrameEnd();

	R_EndRendering();
}

// This is called every frame, and can also be called explicitly to flush text to the screen.
// WARNING: be very careful calling this from elsewhere, because the refresh needs almost the entire 256k of stack space!
qbool SCR_UpdateScreen(void)
{
	if (!SCR_UpdateScreenPrePlayerView()) {
		VID_RenderFrameEnd();
		return false;
	}

	renderer.ScreenDrawStart();

	SCR_UpdateScreenPlayerView(UPDATESCREEN_POSTPROCESS);

	SCR_UpdateScreenPostPlayerView();

	return true;
}

void SCR_UpdateWholeScreen(void)
{
	scr_fullupdate = 0;
	SCR_UpdateScreen();
}

mpic_t *SCR_LoadCursorImage(char *cursorimage)
{
	mpic_t *image = NULL;

	image = Draw_CachePicSafe(va("%s.lmp", cursorimage), false, false);

	// Failed to load anything, maybe missing .lmp-file, so just try
	// loading any 24-bit version that's available instead.
	if(!image)
	{
		image = Draw_CachePicSafe(cursorimage, false, true);
	}

	return image;
}

/************************************ TEMPORARY *******************************/

/* FIXME: Remove this when most people have upgraded to 3.0 */
static void tmp_calc_fov(void)
{
	float fov;
	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: calc_fov <old_fov>\n");
		return;
	}

	fov = Q_atof(Cmd_Argv(1));
	fov = atan(((tan((fov/2)*M_PI/180))/1.2))*360/M_PI;

	Com_Printf("Use fov %d (%f)\n", (int)(fov+0.5), fov);
}


/************************************ INIT ************************************/

void SCR_Init (void)
{
	scr_ram = Draw_CacheWadPic ("ram", WADPIC_RAM);
	scr_net = Draw_CacheWadPic ("net", WADPIC_NET);
	scr_turtle = Draw_CacheWadPic ("turtle", WADPIC_TURTLE);
	scr_cursor = SCR_LoadCursorImage("gfx/cursor");

	if (!host_initialized) {
		Cvar_SetCurrentGroup(CVAR_GROUP_VIEW);
		Cvar_Register(&scr_fov);
		Cvar_Register(&default_fov);
		Cvar_Register(&scr_viewsize);
		Cvar_Register(&scr_fovmode);

		Cvar_SetCurrentGroup(CVAR_GROUP_SBAR);
		Cvar_Register(&scr_newHud);
		Cvar_ResetCurrentGroup();

		Cvar_SetCurrentGroup(CVAR_GROUP_CONSOLE);
		Cvar_Register(&scr_consize);
		Cvar_Register(&scr_conspeed);

		Cvar_SetCurrentGroup(CVAR_GROUP_OPENGL);
		Cvar_Register(&gl_triplebuffer);

		Cvar_SetCurrentGroup(CVAR_GROUP_EYECANDY);
		Cvar_Register(&r_chaticons_alpha);

		Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
		Cvar_Register(&scr_showturtle);
		Cvar_Register(&scr_showpause);

		Cvar_Register(&show_velocity_3d);
		Cvar_Register(&show_velocity_3d_offset_forward);
		Cvar_Register(&show_velocity_3d_offset_down);

		Cvar_Register(&scr_coloredfrags);

		Cmd_AddCommand("calc_fov", tmp_calc_fov);

		// QW 262 HUD
		Cvar_Register(&cl_hud);
		Cvar_Register(&r_drawhud);

		Cvar_Register(&scr_showcrosshair);
		Cvar_Register(&scr_notifyalways);
		Cvar_ResetCurrentGroup();

		Cvar_SetCurrentGroup(CVAR_GROUP_MENU);
		Cvar_Register(&scr_cursor_scale);
		Cvar_Register(&scr_cursor_iconoffset_x);
		Cvar_Register(&scr_cursor_iconoffset_y);
		Cvar_Register(&scr_cursor_alpha);
		Cvar_ResetCurrentGroup();

		Cmd_AddCommand("sizeup", SCR_SizeUp_f);
		Cmd_AddCommand("sizedown", SCR_SizeDown_f);
		Cmd_AddCommand("+zoom", SCR_ZoomIn_f);
		Cmd_AddCommand("-zoom", SCR_ZoomOut_f);
	}

	SCR_RegisterAutoIDCvars();
	SShot_RegisterCvars();
	WeaponStats_CommandInit();
	SCR_CenterPrint_Init();
	SCR_RegisterDamageIndicatorCvars();

	scr_initialized = true;

	ScrollBars_Init();
}

mpic_t * SCR_GetWeaponIconByFlag (int flag)
{
	extern mpic_t *sb_weapons[7][8];  // sbar.c Weapon pictures.

	if (flag == IT_LIGHTNING || flag == IT_SUPER_LIGHTNING)
	{
		return sb_weapons[0][6];
	}
	else if (flag == IT_ROCKET_LAUNCHER)
	{
		return sb_weapons[0][5];
	}
	else if (flag == IT_GRENADE_LAUNCHER)
	{
		return sb_weapons[0][4];
	}
	else if (flag == IT_SUPER_NAILGUN)
	{
		return sb_weapons[0][3];
	}
	else if (flag == IT_NAILGUN)
	{
		return sb_weapons[0][2];
	}
	else if (flag == IT_SUPER_SHOTGUN)
	{
		return sb_weapons[0][1];
	}
	else if (flag == IT_SHOTGUN)
	{
		return sb_weapons[0][0];
	}

	return NULL;
}

static cvar_t  scr_damage_proportional     = { "scr_damage_proportional", "0" };
static cvar_t  scr_damage_floating         = { "scr_damage_floating", "0" };
static cvar_t  scr_damage_hitbeep          = { "scr_damage_hitbeep", "0" };
static cvar_t  scr_damage_scale            = { "scr_damage_scale", "1" };
static cvar_t  scr_damage_offset_spectator = { "scr_damage_offset_spectator", "28" };
static cvar_t  scr_damage_offset_ingame    = { "scr_damage_offset_ingame", "14" };

static float DAMAGE_INITIAL_VELOCITY[2] = { 250, 200 };
#define DAMAGE_VERTICAL_OFFSET_INGAME 16
#define DAMAGE_VERTICAL_OFFSET_SPECTATOR 32
#define DAMAGE_GRAVITY 400

static int direction_order = 0;

void SCR_SetupDamageIndicators(void)
{
	vec3_t r;
	float winz;
	int i;

	if (cl.intermission || !scr_damage_floating.integer) {
		memset(cl.damage_notifications, 0, sizeof(cl.damage_notifications));
		return;
	}

	if (cls.state != ca_active || !cl.validsequence) {
		return;
	}

	for (i = 0; i < MAX_DAMAGE_NOTIFICATIONS; ++i) {
		scr_damage_t* dmg = &cl.damage_notifications[i];

		dmg->visible = false;
		if (!dmg->time || cls.realtime - dmg->time >= MAX_DAMAGE_NOTIFICATION_TIME) {
			dmg->time = 0;
			continue;
		}

		dmg->vel[1] -= cls.frametime * DAMAGE_GRAVITY;

		VectorScale(vright, dmg->vel[0], r);
		VectorMA(dmg->origin, cls.frametime, r, dmg->origin);
		dmg->origin[2] += dmg->vel[1] * cls.frametime;

		if (R_CullSphere(dmg->origin, 0)) {
			continue;
		}

		dmg->visible = R_Project3DCoordinates(dmg->origin[0], dmg->origin[1], dmg->origin[2] + 28, &dmg->x, &dmg->y, &winz);
	}
}

static void SCR_DrawDamageIndicators(void)
{
	int i;

	if (cl.intermission || !scr_damage_floating.integer) {
		return;
	}

	for (i = 0; i < MAX_DAMAGE_NOTIFICATIONS; ++i) {
		scr_damage_t * dmg = &cl.damage_notifications[i];

		if (dmg->visible) {
			float x = dmg->x * vid.width / glwidth;
			float y = (glheight - dmg->y) * vid.height / glheight;
			float scale = (scr_damage_scale.value > 0 ? scr_damage_scale.value : 1.0);
			float age = (cls.realtime - dmg->time);
			float alpha = 1.0f;

			if (age > MAX_DAMAGE_NOTIFICATION_TIME / 2) {
				alpha = 1 - 2 * age / MAX_DAMAGE_NOTIFICATION_TIME;
			}
			Draw_SStringAligned(x - 5 * 8 * scale, y - 8 * scale, dmg->text, scale, alpha, scr_damage_proportional.integer, text_align_center, x + 5 * 8 * scale);
		}
	}
}

static void SCR_DamageInit(scr_damage_t * dmg, int damage, vec3_t origin, qbool team, qbool splash)
{
	const char* color = "&c7f7"; // direct/projectile
	float distance;

	if (team) {
		color = "&cf55";
	}
	else if (splash) {
		color = "&cff5";
	}

	distance = VectorDistance(origin, cl.simorg) / 300.0f;
	distance = bound(0.1f, distance, 1.0f);

	dmg->time = cls.realtime;
	snprintf(dmg->text, sizeof(dmg->text), "%s%d", color, damage);
	VectorCopy(origin, dmg->origin);
	dmg->origin[2] += (cl.spectator ? scr_damage_offset_spectator.value : scr_damage_offset_ingame.value);
	switch (direction_order % 4) {
	case 0:
		dmg->vel[0] = DAMAGE_INITIAL_VELOCITY[0];
		break;
	case 1:
		dmg->vel[0] = -DAMAGE_INITIAL_VELOCITY[0];
		break;
	case 2:
		dmg->vel[0] = DAMAGE_INITIAL_VELOCITY[0] / 3;
		break;
	case 3:
		dmg->vel[0] = -DAMAGE_INITIAL_VELOCITY[0] / 3;
		break;
	}
	dmg->vel[0] *= distance;
	dmg->vel[1] = DAMAGE_INITIAL_VELOCITY[1] * distance;
	VectorCopy(dmg->origin, origin);
	++direction_order;
}

static void CL_SpawnDamageIndicatorDirect(int deathtype, vec3_t origin, int damage, qbool splash_damage, qbool team_damage)
{
	if (scr_damage_hitbeep.integer) {
		S_LocalSound("dmg-notification.wav");
	}

	if (scr_damage_floating.integer) {
		int i;
		double earliest_time;
		int earliest_slot;

		earliest_time = cls.realtime;
		earliest_slot = -1;
		for (i = 0; i < MAX_DAMAGE_NOTIFICATIONS; ++i) {
			scr_damage_t* dmg = &cl.damage_notifications[i];

			if (dmg->time == 0 || dmg->time < cls.realtime - MAX_DAMAGE_NOTIFICATION_TIME) {
				SCR_DamageInit(dmg, damage, origin, team_damage, splash_damage);
				return;
			}

			if (earliest_time > dmg->time) {
				earliest_time = dmg->time;
				earliest_slot = i;
			}
		}

		if (earliest_slot >= 0) {
			SCR_DamageInit(&cl.damage_notifications[earliest_slot], damage, origin, team_damage, splash_damage);
		}
	}
}

void CL_SpawnDamageIndicator(int deathtype, int targ_ent, int damage, qbool splash_damage, qbool team_damage)
{
	if (!(scr_damage_floating.integer || scr_damage_hitbeep.integer) || damage == 0) {
		return;
	}

	if (targ_ent == 0 || targ_ent >= sizeof(cl_entities) / sizeof(cl_entities[0])) {
		return;
	}

	CL_SpawnDamageIndicatorDirect(deathtype, cl_entities[targ_ent].current.origin, damage, splash_damage, team_damage);
}

void CL_ReadKtxDamageIndicatorString(const char* s)
{
	vec3_t origin;
	int deathtype;
	int damage;
	qbool splash_damage;
	qbool team_damage;

	Cmd_TokenizeString((char*)s);

	if (Cmd_Argc() == 9) {
		origin[0] = atoi(Cmd_Argv(2));
		origin[1] = atoi(Cmd_Argv(3));
		origin[2] = atoi(Cmd_Argv(4));
		deathtype = atoi(Cmd_Argv(5));
		damage = atoi(Cmd_Argv(6));
		splash_damage = atoi(Cmd_Argv(7));
		team_damage = atoi(Cmd_Argv(8));

		CL_SpawnDamageIndicatorDirect(deathtype, origin, damage, splash_damage, team_damage);
	}
}

static void SCR_RegisterDamageIndicatorCvars(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register(&scr_damage_proportional);
	Cvar_Register(&scr_damage_floating);
	Cvar_Register(&scr_damage_hitbeep);
	Cvar_Register(&scr_damage_scale);
	Cvar_Register(&scr_damage_offset_spectator);
	Cvar_Register(&scr_damage_offset_ingame);
	Cvar_ResetCurrentGroup();
}


================================================
FILE: src/cl_screenshot.c
================================================
/*
Copyright (C) 1996-2003 Id Software, Inc., A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: cl_screen.c,v 1.156 2007-10-29 00:56:47 qqshka Exp $
*/

#include "quakedef.h"
#include "gl_model.h"
#include "image.h"
#ifdef _WIN32
#include "movie.h"	//joe: capturing to avi
#include "movie_avi.h"	//
#endif
#include "utils.h"
#include "r_local.h"
#include "r_renderer.h"
#ifdef X11_GAMMA_WORKAROUND
#include "tr_types.h"
#endif

#define	DEFAULT_SSHOT_FORMAT "png"

static void OnChange_scr_allowsnap(cvar_t *, char *, qbool *);

static cvar_t scr_sshot_autoname = { "sshot_autoname", "0" };
cvar_t scr_allowsnap      = { "scr_allowsnap", "1", 0, OnChange_scr_allowsnap };
cvar_t scr_sshot_format = { "sshot_format", DEFAULT_SSHOT_FORMAT };
cvar_t scr_sshot_dir = { "sshot_dir", "" };

static int scr_autosshot_countdown = 0;
static char auto_matchname[2 * MAX_OSPATH];

/******************************** SCREENSHOTS ********************************/

#define SSHOT_FAILED		-1
#define SSHOT_FAILED_QUIET	-2		//failed but don't print an error message
#define SSHOT_SUCCESS		0

static char *SShot_ExtForFormat(int format)
{
	switch (format) {
		case IMAGE_PCX:		return ".pcx";
		case IMAGE_TGA:		return ".tga";
		case IMAGE_JPEG:	return ".jpg";
		case IMAGE_PNG:		return ".png";
	}
	assert(!"SShot_ExtForFormat: unknown format");
	return "err";
}

static image_format_t SShot_FormatForName(char *name)
{
	char *ext;

	ext = COM_FileExtension(name);

	if (!strcasecmp(ext, "tga"))
		return IMAGE_TGA;

#ifdef WITH_PNG
	else if (!strcasecmp(ext, "png"))
		return IMAGE_PNG;
#endif

#ifdef WITH_JPEG
	else if (!strcasecmp(ext, "jpg"))
		return IMAGE_JPEG;
#endif

#ifdef WITH_PNG
	else if (!strcasecmp(scr_sshot_format.string, "png") || !strcasecmp(ext, "apng"))
		return IMAGE_PNG;
#endif

#ifdef WITH_JPEG
	else if (!strcasecmp(scr_sshot_format.string, "jpg") || !strcasecmp(scr_sshot_format.string, "jpeg"))
		return IMAGE_JPEG;
#endif

	else
		return IMAGE_TGA;
}

static char *Sshot_SshotDirectory(void)
{
	static char dir[MAX_PATH];

	strlcpy(dir, FS_LegacyDir(scr_sshot_dir.string), sizeof(dir));

	return dir;
}

#ifdef X11_GAMMA_WORKAROUND
extern unsigned short ramps[3][4096];
#else
extern unsigned short ramps[3][256];
#endif

//applies hwgamma to RGB data
static void applyHWGamma(byte *buffer, size_t size)
{
	int i;

	if (vid_hwgamma_enabled) {
		for (i = 0; i < size; i += 3) {
			int r = buffer[i + 0];
			int g = buffer[i + 1];
			int b = buffer[i + 2];

#ifdef X11_GAMMA_WORKAROUND
			if (glConfig.gammacrap.size >= 256 && glConfig.gammacrap.size <= 4096) {
				r = (int)((r * glConfig.gammacrap.size) / 256.0f);
				g = (int)((g * glConfig.gammacrap.size) / 256.0f);
				b = (int)((b * glConfig.gammacrap.size) / 256.0f);
			}
#endif
			buffer[i + 0] = ramps[0][r] >> 8;
			buffer[i + 1] = ramps[1][g] >> 8;
			buffer[i + 2] = ramps[2][b] >> 8;
		}
	}
}

int SCR_Screenshot(char *name, qbool movie_capture)
{
	scr_sshot_target_t* target_params = Q_malloc(sizeof(scr_sshot_target_t));
	size_t width = renderer.ScreenshotWidth();
	size_t height = renderer.ScreenshotHeight();
	size_t buffer_size = width * height * 3;

	// name is fullpath now
	//	name = (*name == '/') ? name + 1 : name;
	target_params->format = SShot_FormatForName(name);
	strlcpy(target_params->fileName, name, sizeof(target_params->fileName));
	COM_ForceExtension(target_params->fileName, SShot_ExtForFormat(target_params->format));
	target_params->width = width;
	target_params->height = height;

	target_params->buffer = Movie_TempBuffer(width, height);
	target_params->movie_capture = movie_capture;
	if (!target_params->buffer) {
		target_params->buffer = Q_malloc(buffer_size);
		target_params->freeMemory = true;
	}

	renderer.Screenshot(target_params->buffer, buffer_size);

	if (movie_capture && Movie_BackgroundCapture(target_params)) {
		return SSHOT_SUCCESS;
	}

	return SCR_ScreenshotWrite(target_params);
}

int SCR_ScreenshotWrite(scr_sshot_target_t* target_params)
{
	int i, temp;
	int success = SSHOT_FAILED;
	int format = target_params->format;
	byte* buffer = target_params->buffer;
	char* name = target_params->fileName;
	size_t buffersize = target_params->width * target_params->height * 3;

#ifdef WITH_PNG
	if (format == IMAGE_PNG) {
		applyHWGamma(buffer, buffersize);

		if (target_params->movie_capture && Movie_AnimatedPNG()) {
			extern cvar_t movie_fps;

			Image_WriteAPNGFrame(buffer, target_params->width, target_params->height, movie_fps.integer);
		}
		else {
			success = Image_WritePNG(name, image_png_compression_level.value, buffer, target_params->width, target_params->height) ? SSHOT_SUCCESS : SSHOT_FAILED;
		}
	}
#endif

#ifdef WITH_JPEG
	if (format == IMAGE_JPEG) {
		applyHWGamma(buffer, buffersize);
		success = Image_WriteJPEG(
			name, image_jpeg_quality_level.value,
			buffer + buffersize - 3 * target_params->width, -(int)target_params->width, (int)target_params->height
		) ? SSHOT_SUCCESS : SSHOT_FAILED;
	}
#endif

	if (format == IMAGE_TGA) {
		// swap rgb to bgr
		for (i = 0; i < buffersize; i += 3) {
			temp = buffer[i];
			buffer[i] = buffer[i + 2];
			buffer[i + 2] = temp;
		}
		applyHWGamma(buffer, buffersize);
		success = Image_WriteTGA(name, buffer, target_params->width, target_params->height) ? SSHOT_SUCCESS : SSHOT_FAILED;
	}

	if (target_params->freeMemory) {
		Q_free(target_params->buffer);
	}
	Q_free(target_params);
	return success;
}

#define MAX_SCREENSHOT_COUNT	65535

int SCR_GetScreenShotName(char *name, int name_size, char *sshot_dir)
{
	int i = 0;
	char ext[4], basename[64];
	FILE *f;

	ext[0] = 0;

	// Find a file name to save it to
#ifdef WITH_PNG
	if (!strcasecmp(scr_sshot_format.string, "png")) {
		strlcpy(ext, "png", 4);
	}
#endif

#ifdef WITH_JPEG
	if (!strcasecmp(scr_sshot_format.string, "jpeg") || !strcasecmp(scr_sshot_format.string, "jpg")) {
		strlcpy(ext, "jpg", 4);
	}
#endif

	if (!strcasecmp(scr_sshot_format.string, "tga")) {
		strlcpy(ext, "tga", 4);
	}

	if (!strcasecmp(scr_sshot_format.string, "pcx")) {
		strlcpy(ext, "pcx", 4);
	}

	if (!ext[0]) {
		strlcpy(ext, DEFAULT_SSHOT_FORMAT, sizeof(ext));
	}

	if (fabsf(scr_sshot_autoname.value - 1.0f) < 0.0001f) {
		// if sshot_autoname is 1, prefix with map name.
		snprintf(basename, sizeof(basename), "%s_", host_mapname.string);
	}
	else {
		// otherwise prefix with ezquake.
		strcpy(basename, "ezquake");
	}

	for (i = 0; i < MAX_SCREENSHOT_COUNT; i++) {
		snprintf(name, name_size, "%s%03i.%s", basename, i, ext);
		if (!(f = fopen(va("%s/%s", sshot_dir, name), "rb"))) {
			break;  // file doesn't exist
		}
		fclose(f);
	}

	if (i == MAX_SCREENSHOT_COUNT) {
		Com_Printf("Error: Cannot create more than %d screenshots\n", MAX_SCREENSHOT_COUNT);
		return -1;
	}

	return 1;
}

void SCR_ScreenShot_f(void)
{
	char name[MAX_OSPATH], *filename, *sshot_dir;
	int success;

	sshot_dir = Sshot_SshotDirectory();

	if (Cmd_Argc() == 2) {
		strlcpy(name, Cmd_Argv(1), sizeof(name));
	}
	else if (Cmd_Argc() == 1) {
		if (SCR_GetScreenShotName(name, sizeof(name), sshot_dir) < 0) {
			return;
		}
	}
	else {
		Com_Printf("Usage: %s [filename]\n", Cmd_Argv(0));
		return;
	}

	for (filename = name; *filename == '/' || *filename == '\\'; filename++)
		;

	success = SCR_Screenshot(va("%s/%s", sshot_dir, filename), false);

	if (success != SSHOT_FAILED_QUIET) {
		Com_Printf("%s %s\n", success == SSHOT_SUCCESS ? "Wrote" : "Couldn't write", name);
	}
}

void SCR_RSShot_f(void)
{
	int success = SSHOT_FAILED;
	char filename[MAX_PATH];
	int width, height;
	byte *base, *pixels;

	if (CL_IsUploading())
		return;		// already one pending

	if (cls.state < ca_onserver)
		return;		// gotta be connected

	if (!scr_allowsnap.value) {
		MSG_WriteByte(&cls.netchan.message, clc_stringcmd);
		SZ_Print(&cls.netchan.message, "snap\n");
		return;
	}
	
	snprintf(filename, sizeof(filename), "%s/temp/__rsshot__", Sshot_SshotDirectory());

	width = 800; height = 600;
	base = (byte *)Q_malloc((width * height + glwidth * glheight) * 3);
	pixels = base + glwidth * glheight * 3;

	renderer.Screenshot(base, glwidth * glheight * 3);
	Image_Resample(base, glwidth, glheight, pixels, width, height, 3, 0);
#ifdef WITH_JPEG
	success = Image_WriteJPEG(filename, 70, pixels + 3 * width * (height - 1), -width, height) ? SSHOT_SUCCESS : SSHOT_FAILED;
#endif
	if (success == SSHOT_FAILED) {
		success = Image_WriteTGA(filename, pixels, width, height) ? SSHOT_SUCCESS : SSHOT_FAILED;
	}

	Q_free(base);

	if (success == SSHOT_SUCCESS) {
		FILE	*f;
		byte	*screen_shot;
		int	size;
		if ((size = FS_FileOpenRead(filename, &f)) != -1) {
			screen_shot = (byte *)Q_malloc(size);
			if (fread(screen_shot, 1, (size_t)size, f) == (size_t)size) {
				CL_StartUpload(screen_shot, size);
			}

			fclose(f);
			Q_free(screen_shot);
		}
	}

	remove(filename);
}

qbool SCR_TakingAutoScreenshot(void)
{
	return scr_autosshot_countdown > 0;
}

void SCR_CheckAutoScreenshot(void)
{
	char *filename, savedname[MAX_PATH], *sshot_dir, *fullsavedname, *ext;
	char *exts[5] = { "pcx", "tga", "png", "jpg", NULL };
	int num;

	if (scr_autosshot_countdown <= 0 || --scr_autosshot_countdown) {
		return;
	}

	if (!cl.intermission) {
		return;
	}

	sshot_dir = Sshot_SshotDirectory();

	// no, sorry
	//	while (*sshot_dir && (*sshot_dir == '/'))
	//		sshot_dir++; // will skip all '/' chars at the beginning

	if (!sshot_dir[0])
		sshot_dir = cls.gamedir;

	for (filename = auto_matchname; *filename == '/' || *filename == '\\'; filename++)
		;

	ext = SShot_ExtForFormat(SShot_FormatForName(filename));

	fullsavedname = va("%s/%s", sshot_dir, filename);
	if ((num = Util_Extend_Filename(fullsavedname, exts)) == -1) {
		Com_Printf("Error: no available filenames\n");
		return;
	}

	snprintf(savedname, sizeof(savedname), "%s_%03i%s", filename, num, ext);
	fullsavedname = va("%s/%s", sshot_dir, savedname);

	renderer.EnsureFinished();

	if ((SCR_Screenshot(fullsavedname, false)) == SSHOT_SUCCESS) {
		Com_Printf("Match scoreboard saved to %s\n", savedname);
	}
}

void SCR_AutoScreenshot(char *matchname)
{
	if (cl.intermission == 1) {
		scr_autosshot_countdown = vid.numpages;
		strlcpy(auto_matchname, matchname, sizeof(auto_matchname));
	}
}

// Capturing to avi.
void SCR_Movieshot(char *name)
{
#ifdef _WIN32
	if (Movie_IsCapturingAVI()) {
		int size = 0;
		// Capturing a movie.
		int i;
		byte *buffer, temp;

		// Set buffer size to fit RGB data for the image.
		size = glwidth * glheight * 3;

		// Allocate the RGB buffer, get the pixels from GL and apply the gamma.
		buffer = (byte *)Q_malloc(size);
		renderer.Screenshot(buffer, size);
		applyHWGamma(buffer, size);

		// We now have a byte buffer with RGB values, but
		// before we write it to the file, we need to swap
		// them to GBR instead, which windows DIBs uses.
		// (There's a GL Extension that allows you to use
		// BGR_EXT instead of GL_RGB in the glReadPixels call
		// instead, but there is no real speed gain using it).
		for (i = 0; i < size; i += 3) {
			// Swap RGB => GBR
			temp = buffer[i];
			buffer[i] = buffer[i + 2];
			buffer[i + 2] = temp;
		}

		// Write the buffer to video.
		Capture_WriteVideo(buffer, size);

		Q_free(buffer);
	}
	else {
		// We're just capturing images.
		SCR_Screenshot(name, true);
	}

#else // _WIN32

	// Capturing to avi only supported in windows yet.
	SCR_Screenshot(name, true);

#endif // _WIN32
}

static void OnChange_scr_allowsnap(cvar_t *var, char *s, qbool *cancel)
{
	*cancel = (cls.state >= ca_connected && cbuf_current == &cbuf_svc);
}

void SShot_RegisterCvars(void)
{
	if (!host_initialized) {
		Cvar_SetCurrentGroup(CVAR_GROUP_SCREENSHOTS);
		Cvar_Register(&scr_allowsnap);
		Cvar_Register(&scr_sshot_autoname);
		Cvar_Register(&scr_sshot_format);
		Cvar_Register(&scr_sshot_dir);
		Cvar_ResetCurrentGroup();

		Cmd_AddCommand("screenshot", SCR_ScreenShot_f);
	}
}


================================================
FILE: src/cl_skygroups.c
================================================
/*

Copyright (C) 2002-2003       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "utils.h"

#define FIRSTUSERSKYGROUP (last_system_skygroup ? last_system_skygroup->next : skygroups)
#define MAX_SKYGROUP_MEMBERS	36

typedef struct skygroup_s {
	char groupname[MAX_QPATH];
	char members[MAX_SKYGROUP_MEMBERS][MAX_QPATH];
	struct skygroup_s *next, *prev;
	qbool system;
	int nummembers;
} skygroup_t;

static skygroup_t *skygroups = NULL;
static skygroup_t *last_system_skygroup = NULL;
static qbool skygroups_init = false;

static skygroup_t *GetSkyGroupWithName(char *groupname)
{
	skygroup_t *node;

	for (node = skygroups; node; node = node->next) {
		if (!strcasecmp(node->groupname, groupname))
			return node;
	}
	return NULL;
}

static skygroup_t *GetSkyGroupWithMember(char *member)
{
	int j;
	skygroup_t *node;

	for (node = skygroups; node; node = node->next) {
		for (j = 0; j < node->nummembers; j++) {
			if (!strcasecmp(node->members[j], member))
				return node;
		}
	}
	return NULL;
}

static void DeleteSkyGroup(skygroup_t *group)
{
	if (!group)
		return;

	if (group->prev)
		group->prev->next = group->next;
	if (group->next)
		group->next->prev = group->prev;


	if (group == skygroups) {
		skygroups = skygroups->next;
		if (group == last_system_skygroup)
			last_system_skygroup = NULL;
	}
	else if (group == last_system_skygroup) {
		last_system_skygroup = last_system_skygroup->prev;
	}

	Q_free(group);
}

static void ResetSkyGroupMembers(skygroup_t *group)
{
	int i;

	if (!group)
		return;

	for (i = 0; i < group->nummembers; i++)
		group->members[i][0] = 0;

	group->nummembers = 0;
}

static void DeleteSkyGroupMember(skygroup_t *group, char *member)
{
	int i;

	if (!group)
		return;

	for (i = 0; i < group->nummembers; i++) {
		if (!strcasecmp(member, group->members[i]))
			break;
	}

	if (i == group->nummembers)
		return;

	if (i < group->nummembers - 1)
		memmove(group->members[i], group->members[i + 1], (group->nummembers - 1 - i) * sizeof(group->members[0]));

	group->nummembers--;
}

static void AddSkyGroupMember(skygroup_t *group, char *member)
{
	int i;

	if (!group || group->nummembers == MAX_SKYGROUP_MEMBERS)
		return;

	for (i = 0; i < group->nummembers; i++) {
		if (!strcasecmp(member, group->members[i]))
			return;
	}

	strlcpy(group->members[group->nummembers], member, sizeof(group->members[group->nummembers]));
	group->nummembers++;
}

void MT_SkyGroup_f(void)
{
	int i, c, j;
	qbool removeflag = false;
	skygroup_t *node, *group, *tempnode;
	extern cvar_t r_skyname;
	char *groupname, *member;

	extern int R_SetSky(char *skyname);

	if ((c = Cmd_Argc()) == 1) {
		if (!FIRSTUSERSKYGROUP) {
			Com_Printf("No sky groups defined\n");
		}
		else {
			for (node = FIRSTUSERSKYGROUP; node; node = node->next) {
				Com_Printf("\x02%s: ", node->groupname);
				for (j = 0; j < node->nummembers; j++)
					Com_Printf("%s ", node->members[j]);
				Com_Printf("\n");
			}
		}
		return;
	}

	groupname = Cmd_Argv(1);

	if (c == 2 && !strcasecmp(groupname, "clear")) {
		for (node = FIRSTUSERSKYGROUP; node; node = tempnode) {
			tempnode = node->next;
			DeleteSkyGroup(node);
		}
		return;
	}

	if (Util_Is_Valid_Filename(groupname) == false) {
		Com_Printf("Error: %s is not a valid sky group name\n", groupname);
		return;
	}

	group = GetSkyGroupWithName(groupname);

	if (c == 2) {
		if (!group) {
			Com_Printf("No sky group named \"%s\"\n", groupname);
		}
		else {
			Com_Printf("\x02%s: ", groupname);
			for (j = 0; j < group->nummembers; j++)
				Com_Printf("%s ", group->members[j]);
			Com_Printf("\n");
		}
		return;
	}

	if (group && group->system) {
		Com_Printf("Cannot modify system group \"%s\"\n", groupname);
		return;
	}

	if (c == 3 && !strcasecmp(Cmd_Argv(2), "clear")) {
		if (!group && !strcmp("exmx", groupname))
			Com_Printf("\"%s\" is not a sky group name\n", groupname);
		else
			DeleteSkyGroup(group);
		return;
	}



	if (!group) {
		group = (skygroup_t *)Q_calloc(1, sizeof(skygroup_t));
		strlcpy(group->groupname, groupname, sizeof(group->groupname));
		group->system = !skygroups_init;
		if (skygroups) {
			for (tempnode = skygroups; tempnode->next; tempnode = tempnode->next)
				;
			tempnode->next = group;
			group->prev = tempnode;
		}
		else {
			skygroups = group;
		}
	}
	else {
		member = Cmd_Argv(2);
		if (member[0] != '+' && member[0] != '-')
			ResetSkyGroupMembers(group);
	}

	for (i = 2; i < c; i++) {
		member = Cmd_Argv(i);
		if (member[0] == '+') {
			removeflag = false;
			member++;
		}
		else if (member[0] == '-') {
			removeflag = true;
			member++;
		}

		if (!removeflag && (tempnode = GetSkyGroupWithMember(member)) && tempnode != group) {
			if (cl_warncmd.integer || developer.integer)
				Com_Printf("Warning: \"%s\" is already a member of group \"%s\"...ignoring\n", member, tempnode->groupname);
			continue;
		}

		if (removeflag)
			DeleteSkyGroupMember(group, member);
		else
			AddSkyGroupMember(group, member);
	}

	if (!group->nummembers) {
		DeleteSkyGroup(group);
	}

	R_SetSky(r_skyname.string);
}

void MT_AddSkyGroups(void)
{
	char clear[256] = { 0 };

	strlcat(clear, "skygroup exmy clear", sizeof(clear));
	Cmd_TokenizeString(clear);
	MT_SkyGroup_f();
	skygroups_init = true;
}

char *MT_GetSkyGroupName(char *mapname, qbool *system)
{
	skygroup_t *group;

	group = GetSkyGroupWithMember(mapname);
	if (group && strcmp(mapname, group->groupname)) {
		if (system)
			*system = group->system;
		return group->groupname;
	}
	else {
		return NULL;
	}
}

void DumpSkyGroups(FILE *f)
{
	skygroup_t *node;
	int j;
	if (!FIRSTUSERSKYGROUP) {
		fprintf(f, "skygroup clear\n");
		return;
	}
	for (node = FIRSTUSERSKYGROUP; node; node = node->next) {
		fprintf(f, "skygroup %s ", node->groupname);
		for (j = 0; j < node->nummembers; j++)
			fprintf(f, "%s ", node->members[j]);
		fprintf(f, "\n");
	}
}


================================================
FILE: src/cl_slist.c
================================================
/*
Copyright (C) 1999,2000  contributors of the QuakeForge project

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: cl_slist.c,v 1.10 2007-03-11 06:01:36 disconn3ct Exp $
*/

#include "quakedef.h"
#include "cl_slist.h"
#include "utils.h"


static qbool slist_initialised = false;

server_entry_t	slist[MAX_SERVER_LIST];

void SList_Init(void) {
	memset(&slist, 0, sizeof(slist));
}

void SList_Shutdown(void) {  
	char filename[MAX_OSPATH] = {0};
	FILE *f;

	if (!slist_initialised)
		return;

	snprintf(&filename[0], sizeof(filename), "%s/servers.txt", com_basedir);

	if (!(f = fopen(filename, "w"))) {
		Com_DPrintf("Couldn't open %s\n", filename);
		return;
	}
	SList_Save(f);
	fclose(f);
}

void SList_Set (int i, char *addr, char *desc) {
	if (i >= MAX_SERVER_LIST || i < 0)
		Sys_Error("SList_Switch: Bad index %d", i);

	if (slist[i].server)
		Q_free(slist[i].server);
	if (slist[i].description)
		Q_free(slist[i].description);

	slist[i].server = Q_strdup (addr);
	slist[i].description = Q_strdup (desc);
}

void SList_Reset_NoFree (int i) { 
	if (i >= MAX_SERVER_LIST || i < 0)
		Sys_Error("SList_Switch: Bad index %d", i);

	slist[i].description = slist[i].server = NULL;
}

void SList_Reset (int i) {
	if (i >= MAX_SERVER_LIST || i < 0)
		Sys_Error("SList_Switch: Bad index %d", i);

	if (slist[i].server) {
		Q_free(slist[i].server);
		slist[i].server = NULL;
	}

	if (slist[i].description) {
		Q_free(slist[i].description);
		slist[i].description = NULL;
	}
}

void SList_Switch (int a, int b) {
	server_entry_t temp;

	if (a >= MAX_SERVER_LIST || a < 0)
		Sys_Error("SList_Switch: Bad index %d", a);
	if (b >= MAX_SERVER_LIST || b < 0)
		Sys_Error("SList_Switch: Bad index %d", b);

	memcpy(&temp, &slist[a], sizeof(temp));
	memcpy(&slist[a], &slist[b], sizeof(temp));
	memcpy(&slist[b], &temp, sizeof(temp));
}

int SList_Length (void) {
	int count;

	for (count = 0; count < MAX_SERVER_LIST && slist[count].server; count++)
		;
	return count;
}

void SList_Load (void) {
	char line[128];
	char filename[MAX_OSPATH] = {0};
	char *desc, *addr;
	unsigned int len;
	int c, argc, count;
	FILE *f;

	snprintf(&filename[0], sizeof(filename), "%s/servers.txt", com_basedir);
	if (!(f = fopen(filename, "r")))
		return;

	count = len = 0;
	while ((c = getc(f))) {
		if (c == '\n' || c == '\r' || c == EOF) {
			if (c == '\r' && (c = getc(f)) != '\n' && c != EOF)
				ungetc(c, f);

			line[len] = 0;
			len = 0;
			Cmd_TokenizeString(line);

			if ((argc = Cmd_Argc()) >= 1) {
				addr = Cmd_Argv(0);
				desc = (argc >= 2) ? Cmd_MakeArgs(1) : "Unknown";
				SList_Set (count, addr, desc);
				if (++count == MAX_SERVER_LIST)
					break;
			}
			if (c == EOF)
				break;	//just in case an EOF follows a '\r'
		} else {
			if (len + 1 < sizeof(line))
				line[len++] = c;
		}
	}

	fclose (f);

	slist_initialised = true;
}

void SList_Save (FILE *f) {
	int i;
	char *spaces;

	for (i = 0; i < MAX_SERVER_LIST; i++) {
		if (!slist[i].server)
			break;
		spaces = CreateSpaces(32 - strlen(slist[i].server));
		fprintf(f, "%s%s%s\n", slist[i].server, spaces, slist[i].description);
	}
}


================================================
FILE: src/cl_slist.h
================================================
/*
Copyright (C) 1999,2000  contributors of the QuakeForge project

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#define MAX_SERVER_LIST 512

typedef struct {
	char *server;
	char *description;
} server_entry_t;

extern server_entry_t slist[MAX_SERVER_LIST];

void SList_Init(void);
void SList_Shutdown(void);
void SList_Set(int i,char *addr,char *desc);
void SList_Reset_NoFree(int i);
void SList_Reset(int i);
void SList_Switch(int a,int b);
int SList_Length(void);
void SList_Load(void);
void SList_Save(FILE *f);


================================================
FILE: src/cl_tent.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: cl_tent.c,v 1.31 2007-10-29 00:13:26 d3urk Exp $
*/
// cl_tent.c -- client side temporary entities

#include "quakedef.h"
#include "gl_model.h"
#include "vx_stuff.h"
#include "rulesets.h"
#include "pmove.h"
#include "utils.h"
#include "qsound.h"
#include "qmb_particles.h"

extern cvar_t gl_no24bit;

temp_entity_list_t temp_entities;

#define	MAX_BEAMS 32
typedef struct 
{
	int entity;
	model_t *model;
	float endtime;
	vec3_t start, end;
} beam_t;

beam_t cl_beams[MAX_BEAMS];

static vec3_t playerbeam_end;
static qbool playerbeam_update;

#define MAX_EXPLOSIONS 32
typedef struct explosion_s 
{
	struct explosion_s *prev, *next;
	vec3_t origin;
	float start;
	model_t *model;
} explosion_t;


// cl_free_explosions = linear linked list of free explosions
explosion_t	cl_explosions[MAX_EXPLOSIONS];
explosion_t cl_explosions_headnode, *cl_free_explosions;

static model_t	*cl_explo_mod, *cl_bolt1_mod, *cl_bolt2_mod, *cl_bolt3_mod, *cl_beam_mod;

sfx_t	*cl_sfx_wizhit, *cl_sfx_knighthit, *cl_sfx_tink1, *cl_sfx_ric1, *cl_sfx_ric2, *cl_sfx_ric3, *cl_sfx_r_exp3;

cvar_t r_lgbloodColor = {"r_lgbloodColor", "225"};
cvar_t r_rlbloodColor_small = {"r_rlbloodColor_small", "225"};
cvar_t r_rlbloodColor_big = {"r_rlbloodColor_big", "73"};
cvar_t r_sgbloodColor = {"r_sgbloodColor", "73"};
cvar_t r_shiftbeam = {"r_shiftbeam", "0"};

void CL_InitTEnts(void)
{
	cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav");
	cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav");
	cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");
	cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav");
	cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
	cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
	cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
}

void CL_InitTEntsCvar(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_EYECANDY);
	Cvar_Register(&r_lgbloodColor);
	Cvar_Register(&r_rlbloodColor_small);
	Cvar_Register(&r_rlbloodColor_big);
	Cvar_Register(&r_sgbloodColor);
	Cvar_Register(&r_shiftbeam);
	Cvar_ResetCurrentGroup();
}

void CL_ClearTEnts(void) 
{
	int i;

	cl_explo_mod = cl_bolt1_mod = cl_bolt2_mod = cl_bolt3_mod = cl_beam_mod = NULL;

	memset (&cl_beams, 0, sizeof(cl_beams));
	memset (&cl_explosions, 0, sizeof(cl_explosions));

	// link explosions 
	cl_free_explosions = cl_explosions; 
	cl_explosions_headnode.next = cl_explosions_headnode.prev = &cl_explosions_headnode; 

	for (i = 0; i < MAX_EXPLOSIONS - 1; i++) 
		cl_explosions[i].next = &cl_explosions[i + 1]; 
}

explosion_t *CL_AllocExplosion(void) 
{
	explosion_t *ex;

	if (cl_free_explosions) 
	{	
		// Take a free explosion if possible.
		ex = cl_free_explosions;
		cl_free_explosions = ex->next;
	} 
	else
	{
		// Grab the oldest one otherwise.
		ex = cl_explosions_headnode.prev;
		ex->prev->next = ex->next;
		ex->next->prev = ex->prev;
	}

	// Put the explosion at the start of the list.
	ex->prev = &cl_explosions_headnode;
	ex->next = cl_explosions_headnode.next;
	ex->next->prev = ex;
	ex->prev->next = ex;

	return ex;
}

void CL_FreeExplosion(explosion_t *ex)
{
	// Remove from linked active list.
	ex->prev->next = ex->next;
	ex->next->prev = ex->prev;

	// Insert into front linked free list.
	ex->next = cl_free_explosions;
	cl_free_explosions = ex;
}

static void CL_ParseBeam(int type, vec3_t end)
{
	int ent, i;
	vec3_t start;
	beam_t *b;
	struct model_s *m;

	ent = MSG_ReadShort();

	start[0] = MSG_ReadCoord();
	start[1] = MSG_ReadCoord();
	start[2] = MSG_ReadCoord();

	end[0] = MSG_ReadCoord();
	end[1] = MSG_ReadCoord();
	end[2] = MSG_ReadCoord();

	if (CL_Demo_SkipMessage(true))
		return;

	if (cl.intermission && ent >= 1 && ent <= MAX_CLIENTS) {
		return;
	}

    // an experimental protocol extension:
    // TE_LIGHTNING1 with entity num in -512..-1 range is a rail trail
    if (type == 1 && (ent >= -512 && ent <= -1)) 
	{
        int colors[8] = { 6 /* white (change to something else?) */,
                208 /* blue */,
                180 /* green */, 35 /* light blue */, 224 /* red */,
                133 /* magenta... kinda */, 192 /* yellow */, 6 /* white */};
        int color;
        int cnum;

        // -512..-257 are colored trails assigned to a specific
        // player, so overrides can be applied; encoded as follows:
        // 7654321076543210
        // 1111111nnnnnnccc  (n = player num, c = color code)
        cnum = ent & 7;
        //pnum = (ent >> 3) & 63;
        color = colors[cnum];

		//color is ignored by most of trails
		switch(r_instagibtrail.integer)
		{
			case 1:
			R_ParticleTrail(start, end, GRENADE_TRAIL);
			break;

			case 2:
			R_ParticleTrail(start, end, ROCKET_TRAIL);
			break;

			case 3:
			R_ParticleTrail(start, end, ALT_ROCKET_TRAIL);
			break;

			case 4:
			R_ParticleTrail(start, end, BLOOD_TRAIL);
			break;

			case 5:
			R_ParticleTrail(start, end, BIG_BLOOD_TRAIL);
			break;

			case 6:
			R_ParticleTrail(start, end, TRACER1_TRAIL);
			break;

			case 7:
			R_ParticleTrail(start, end, TRACER2_TRAIL);
			break;

			case 8:
			R_ParticleTrail(start, end, VOOR_TRAIL);
			break;

			case 9:
			Classic_ParticleRailTrail(start, end, color);
			break;

			case 10:
			R_ParticleTrail(start, end, RAIL_TRAIL);
			break;

			case 11:
			QMB_ParticleRailTrail(start, end, color);
			break;

			case 12:
			R_ParticleTrail(start, end, LAVA_TRAIL);
			break;

			case 13:
			R_ParticleTrail(start, end, AMF_ROCKET_TRAIL);
			break;

			default: break;
		}

        return;
    }

	switch (type) 
	{
		case 1:
			if (!cl_bolt1_mod)
				cl_bolt1_mod = Mod_CustomModel(custom_model_bolt, true);
			m = cl_bolt1_mod;
			break;
		case 2:
			if (!cl_bolt2_mod)
				cl_bolt2_mod = Mod_CustomModel(custom_model_bolt2, true);
			m = cl_bolt2_mod;
			break;
		case 3:
			if (!cl_bolt3_mod)
				cl_bolt3_mod = Mod_CustomModel(custom_model_bolt3, true);
			m = cl_bolt3_mod;
			break;
		case 4: default:
			if (!cl_beam_mod)
				cl_beam_mod = Mod_CustomModel(custom_model_beam, true);
			m = cl_beam_mod;
			break;
	}
	
	if (ent == cl.viewplayernum + 1) {
		VectorCopy(end, playerbeam_end); // for cl_fakeshaft
		playerbeam_update = true;
	}

	// Override any beam with the same entity.
	for (i = 0, b = cl_beams; i < MAX_BEAMS; i++, b++) 
	{
		if (b->entity == ent) 
		{
			b->model = m;
			b->endtime = cl.time + 0.2;
			VectorCopy(start, b->start);
			VectorCopy(end, b->end);
			return;
		}
	}

	// Find a free beam.
	for (i = 0, b = cl_beams; i < MAX_BEAMS; i++, b++)
	{
		if (!b->model || b->endtime < cl.time) 
		{
			b->entity = ent;
			b->model = m;
			b->endtime = cl.time + 0.2;
			VectorCopy(start, b->start);
			VectorCopy(end, b->end);
			return;
		}
	}
	Com_DPrintf ("beam list overflow!\n");
}

void CL_ExplosionSprite(vec3_t pos) 
{					
	explosion_t	*ex;

	ex = CL_AllocExplosion();
	VectorCopy(pos, ex->origin);
	ex->start = cl.time;
	if (!cl_explo_mod)
		cl_explo_mod = Mod_CustomModel(custom_model_explosion, true);
	ex->model = cl_explo_mod;
}

static void CL_Parse_TE_WIZSPIKE(vec3_t pos)
{
	if (amf_part_sparks.value && !Rulesets_RestrictParticles())
	{
		byte col[3] = {0, 124, 0};
		SparkGen(pos, col, 20, 90, 1);
	}
	else
	{
		R_RunParticleEffect(pos, vec3_origin, 20, 30);
	}
	S_StartSound(-1, 0, cl_sfx_wizhit, pos, 1, 1);
}

// FIXME: D-Kure: This seems to be unused
#if 0
static void CL_Parse_TE_KNIGHTSPIKE(vec3_t pos)
{
	if (amf_part_sparks.value && !Rulesets_RestrictParticles())
	{
		byte col[3] = {255, 77, 0};
		SparkGen(pos, col, 20, 150, 1);
	}
	else
	{
		R_RunParticleEffect(pos, vec3_origin, 226, 20);
	}

	S_StartSound(-1, 0, cl_sfx_knighthit, pos, 1, 1);
}
#endif

static void CL_Parse_TE_SPIKE(vec3_t pos)
{
	int rnd;

	if (amf_part_spikes.value && !Rulesets_RestrictParticles() && !gl_no24bit.integer)
		VXNailhit(pos, 10 * amf_part_spikes.value);
	else
	{
		R_RunParticleEffect(pos, vec3_origin, 0, 10);
	}

	if ( rand() % 5 ) 
	{
		S_StartSound(-1, 0, cl_sfx_tink1, pos, 1, 1);
	}
	else
	{
		rnd = rand() & 3;
		if (rnd == 1)
			S_StartSound(-1, 0, cl_sfx_ric1, pos, 1, 1);
		else if (rnd == 2)
			S_StartSound(-1, 0, cl_sfx_ric2, pos, 1, 1);
		else
			S_StartSound(-1, 0, cl_sfx_ric3, pos, 1, 1);
	}
}

static void CL_Parse_TE_SUPERSPIKE(vec3_t pos)
{
	int rnd;

	if (amf_part_spikes.value && !Rulesets_RestrictParticles() && !gl_no24bit.integer)
		VXNailhit(pos, 20 * amf_part_spikes.value);
	else
	{
		R_RunParticleEffect(pos, vec3_origin, 0, 20);
	}

	if (rand() % 5) 
	{
		S_StartSound(-1, 0, cl_sfx_tink1, pos, 1, 1);
	}
	else
	{
		rnd = rand() & 3;
		if (rnd == 1)
			S_StartSound(-1, 0, cl_sfx_ric1, pos, 1, 1);
		else if (rnd == 2)
			S_StartSound(-1, 0, cl_sfx_ric2, pos, 1, 1);
		else
			S_StartSound(-1, 0, cl_sfx_ric3, pos, 1, 1);
	}
}

static void CL_Parse_TE_EXPLOSION(vec3_t pos)
{
	dlight_t *dl;
	extern cvar_t gl_part_explosions;

	if (cls.state != ca_active) {
		return;
	}

	if (r_explosiontype.value == 2) {
		if (amf_part_teleport.value) {
			VXTeleport(pos);
		}
		else {
			// Teleport splash
			R_TeleportSplash(pos);
		}

		if (amf_coronas_tele.integer) {
			R_CoronasNew(C_BLUEFLASH, pos);
		}
	}
	else if (r_explosiontype.value == 3) {
		// lightning blood
		R_RunParticleEffect(pos, vec3_origin, r_rlbloodColor_small.value ? r_rlbloodColor_small.integer : 225, 50);
	}
	else if (r_explosiontype.value == 4) {
		// Big blood
		R_RunParticleEffect(pos, vec3_origin, r_rlbloodColor_big.value ? r_rlbloodColor_big.integer : 73, 20 * 32);
	}
	else if (r_explosiontype.value == 5) {
		// Double gunshot
		R_RunParticleEffect(pos, vec3_origin, 0, 20 * 14);
	}
	else if (r_explosiontype.value == 6) {
		if (amf_part_blobexplosion.value) {
			VXBlobExplosion(pos);
		}
		else {
			R_BlobExplosion(pos); // Blob explosion
		}
		if (amf_coronas.integer) {
			R_CoronasNew(C_BLUEFLASH, pos);
		}
	}
	else if (r_explosiontype.value == 7 && qmb_initialized && gl_part_explosions.value) {
		QMB_DetpackExplosion(pos);	// Detpack explosion
	}
	else if (r_explosiontype.value == 8 && qmb_initialized) {
		FuelRodExplosion(pos);
	}
	else if (r_explosiontype.value == 10) {
		/* Explosions turned off */
	}
	else {
		// sprite and particles
		if (amf_part_explosion.value)
			VXExplosion(pos);
		else {
			R_ParticleExplosion(pos); // Normal explosion
		}
	}

	if (r_explosionlight.value) {
		dl = CL_AllocDlight(0);
		VectorCopy(pos, dl->origin);
		dl->radius = 150 + 200 * bound(0, r_explosionlight.value, 1);
		dl->die = cl.time + 0.5;
		dl->decay = 300;
		if (r_explosiontype.value == 8) {
			dl->type = lt_green;
		}
		else {
			customlight_t cst_lt = { 0 };
			dlightColorEx(r_explosionlightcolor.value, r_explosionlightcolor.string, lt_explosion, true, &cst_lt);
			dl->type = cst_lt.type;

			if (dl->type == lt_custom) {
				VectorCopy(cst_lt.color, dl->color);
			}
		}
		if (amf_coronas.integer && r_explosiontype.integer != 7 && r_explosiontype.integer != 2 && r_explosiontype.integer != 8) {
			R_CoronasNew(C_FLASH, pos);
		}
	}

	S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
}

static void CL_Parse_TE_TAREXPLOSION(vec3_t pos)
{
	if (amf_part_blobexplosion.value) {
		VXBlobExplosion(pos);
	}
	else {
		R_BlobExplosion(pos); // Blob explosion
	}
	
	if (amf_coronas.integer) {
		R_CoronasNew(C_BLUEFLASH, pos);
	}

	S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
}

static void CL_Parse_TE_TELEPORT(vec3_t pos)
{
	if (r_telesplash.value)
	{
		if (amf_part_teleport.value) {
			VXTeleport(pos);
		}
		else {
			R_TeleportSplash(pos); // Teleport splash
		}
		if (amf_coronas_tele.integer) {
			R_CoronasNew(C_BLUEFLASH, pos);
		}
	}
}

static void CL_Parse_TE_GUNSHOT(vec3_t pos)
{
	int count;

	if (cls.nqdemoplayback) {
		count = 1;
	}
	else {
		count = MSG_ReadByte();
	}

	pos[0] = MSG_ReadCoord();
	pos[1] = MSG_ReadCoord();
	pos[2] = MSG_ReadCoord();

	if (CL_Demo_SkipMessage(true)) {
		return;
	}
	
	if (amf_part_gunshot.value && !Rulesets_RestrictParticles()) {
		VXGunshot(pos, 5 * count * amf_part_gunshot.value);
	}
	else {
		R_RunParticleEffect(pos, vec3_origin, 256 /* magic! */, 20 * count);
	}
}

static void CL_Parse_TE_BLOOD(vec3_t pos)
{
	int count;
	dlight_t *dl;
	
	if (cls.nqdemoplayback) {
		// NQ_TE_EXPLOSION2
		pos[0] = MSG_ReadCoord();
		pos[1] = MSG_ReadCoord();
		pos[2] = MSG_ReadCoord();
		MSG_ReadByte(); // colorStart
		MSG_ReadByte(); // colorLength

		if (CL_Demo_SkipMessage(true)) {
			return;
		}

		dl = CL_AllocDlight(0);
		VectorCopy(pos, dl->origin);
		dl->radius = 350;
		dl->die = cl.time + 0.5;
		dl->decay = 300;
		S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
		return;
	}

	count = MSG_ReadByte();
	pos[0] = MSG_ReadCoord();
	pos[1] = MSG_ReadCoord();
	pos[2] = MSG_ReadCoord();

	if (CL_Demo_SkipMessage(true)) {
		return;
	}

	if (amf_part_blood.value) {
		VXBlood(pos, 5 * count * amf_part_blood.value);
	}
	else {
        extern cvar_t gl_part_blood;

		R_RunParticleEffect(pos, vec3_origin, gl_part_blood.value ? 73 : r_sgbloodColor.integer, 20 * count);
	}
}

static void CL_Parse_TE_LIGHTNINGBLOOD(vec3_t pos)
{
	if (cls.nqdemoplayback) {
		// NQ_TE_BEAM - grappling hook beam
		CL_ParseBeam(4, pos);
	}
	else {
		extern cvar_t gl_part_blood;

		pos[0] = MSG_ReadCoord();
		pos[1] = MSG_ReadCoord();
		pos[2] = MSG_ReadCoord();

		if (CL_Demo_SkipMessage(true)) {
			return;
		}

		R_RunParticleEffect(pos, vec3_origin, gl_part_blood.value ? 225 : r_lgbloodColor.integer, 50); // 225 default
	}
}

void CL_ParseTEnt (void) 
{
	int	type;
	vec3_t pos;
	qbool parsed = false;
	
	memset(pos, 0, sizeof(pos));
	
	type = MSG_ReadByte();

	// Handle special cases first (need to parse more than just position).
	switch (type)
	{
		// Lightning bolts.
		case TE_LIGHTNING1:			
			CL_ParseBeam(1, pos);
			parsed = true;
			break;

		case TE_LIGHTNING2:
			CL_ParseBeam(2, pos);
			parsed = true;
			break;

		case TE_LIGHTNING3:
			CL_ParseBeam(3, pos);
			parsed = true;
			break;

		// Bullet hitting wall.
		case TE_GUNSHOT:
			CL_Parse_TE_GUNSHOT(pos);
			parsed = true;
			break;

		// Bullets hitting body.
		case TE_BLOOD: 
			CL_Parse_TE_BLOOD(pos);
			parsed = true;
			break;

		// Lightning hitting body
		case TE_LIGHTNINGBLOOD: 
			CL_Parse_TE_LIGHTNINGBLOOD(pos);
			parsed = true;
			break;
	}

	if (!parsed)
	{
		// The rest only needs position.
		pos[0] = MSG_ReadCoord();
		pos[1] = MSG_ReadCoord();
		pos[2] = MSG_ReadCoord();

		if (CL_Demo_SkipMessage(true)) {
			return;
		}
		
		switch (type) 
		{
			// Spike hitting wall.
			case TE_WIZSPIKE: 
				CL_Parse_TE_WIZSPIKE(pos);
				break;

			// Spike hitting wall.
			case TE_KNIGHTSPIKE: 
				CL_Parse_TE_WIZSPIKE(pos);
				break;
			
			// Spike hitting wall.
			case TE_SPIKE: 
				CL_Parse_TE_SPIKE(pos);
				break;

			// Super spike hitting wall.
			case TE_SUPERSPIKE:		
				CL_Parse_TE_SUPERSPIKE(pos);
				break;

			// Rocket explosion.
			case TE_EXPLOSION:	
				CL_Parse_TE_EXPLOSION(pos);
				break;

			// Tarbaby explosion
			case TE_TAREXPLOSION:
				CL_Parse_TE_TAREXPLOSION(pos);
				break;

			case TE_LAVASPLASH:	
				R_LavaSplash(pos);
				break;

			case TE_TELEPORT:
				CL_Parse_TE_TELEPORT(pos);
				break;

			default:
				Host_Error("CL_ParseTEnt: unknown type %d", type);
		}
	}
	else if (CL_Demo_SkipMessage(true)) {
		return;
	}

	// Save the temp entities.
	VectorCopy(pos, temp_entities.list[temp_entities.count].pos);
	temp_entities.list[temp_entities.count].time = cls.demoplayback ? cls.demotime : cls.realtime; // FIXME: Use realtime here?
	temp_entities.list[temp_entities.count].type = type;
	temp_entities.count = (temp_entities.count + 1 >= MAX_TEMP_ENTITIES) ? 0 : temp_entities.count + 1;
}

void vectoangles(vec3_t vec, vec3_t ang);

#define MAX_LIGHTNINGBEAMS 10

static float fakeshaft_policy (void)
{
	if (cls.demoplayback || cl.spectator) {
		return 1;
	}
	else {
		return cl.fakeshaft_policy;
	}
}

static void CL_UpdateBeams(void)
{
	int i;
	beam_t *b;	
	vec3_t dist, org;
	entity_t ent;
	float d, yaw, pitch, forward, fakeshaft;
	extern cvar_t v_viewheight;

	float lg_size = bound(3, amf_lightning_size.value, 30);
	int beamstodraw, j, k;
	qbool sparks = false;
	vec3_t beamstart[MAX_LIGHTNINGBEAMS], beamend[MAX_LIGHTNINGBEAMS];
	vec3_t furthest_sparks;
	beamstodraw = bound(1, amf_lightning.value, MAX_LIGHTNINGBEAMS);	

	memset (&ent, 0, sizeof(entity_t));
	ent.colormap = vid.colormap;

	fakeshaft = cl.intermission ? 0 : bound(0, cl_fakeshaft.value, fakeshaft_policy());

	// Update lightning.
	for (i = 0, b = cl_beams; i < MAX_BEAMS; i++, b++) {
		sparks = false;

		if (!b->model || b->endtime < cl.time) {
			continue;
		}
		if (b->entity >= 1 && b->entity <= MAX_CLIENTS && cl.intermission) {
			continue;
		}

		// if coming from the player, update the start position
		if (b->entity == cl.viewplayernum + 1) {
			VectorCopy (cl.simorg, b->start);
			b->start[2] += cl.crouch + bound(-7, v_viewheight.value, 4);
			VectorMA(b->start, r_shiftbeam.value, vright, b->start);

			if (fakeshaft && (cl_fakeshaft_extra_updates.value || playerbeam_update)) {
				vec3_t	forward, v, org, ang, target_angles, target_origin;
				float	delta;
				trace_t	trace;

				playerbeam_update = false;

				if (cl_fakeshaft.value == 2 && !cl.spectator && !cls.nqdemoplayback) {
					// try to simulate 13 ms ping
					frame_t *frame = &cl.frames[(cls.netchan.outgoing_sequence - 2) & UPDATE_MASK];
					VectorCopy(frame->cmd.angles, target_angles);
					VectorCopy(frame->playerstate[cl.viewplayernum].origin, target_origin);
				}
				else {
					VectorCopy(cl.simangles, target_angles);
					VectorCopy(cl.simorg, target_origin);
				}

				VectorSubtract (playerbeam_end, target_origin, v);
				v[2] -= 22;	// Adjust for view height.
				vectoangles (v, ang);

				// Lerp pitch.
				ang[0] = -ang[0];
				if (ang[0] < -180) {
					ang[0] += 360;
				}
				ang[0] += (target_angles[0] - ang[0]) * fakeshaft;

				// Lerp yaw.
				delta = target_angles[1] - ang[1];
				if (delta > 180) {
					delta -= 360;
				}
				if (delta < -180) {
					delta += 360;
				}
				ang[1] += delta * fakeshaft;
				ang[2] = 0;

				AngleVectors (ang, forward, NULL, NULL);
				VectorScale (forward, 600, forward);
				VectorCopy (target_origin, org);
				org[2] += 16;
				VectorAdd (org, forward, b->end);

				trace = PM_TraceLine (org, b->end);
				if (trace.fraction < 1) {
					VectorCopy(trace.endpos, b->end);
				}
			}
		}

		// Calculate pitch and yaw.
		VectorSubtract (b->end, b->start, dist);

		if (dist[1] == 0 && dist[0] == 0) {
			yaw = 0;
			pitch = (dist[2] > 0) ? 90 : 270;
		}
		else {
			yaw = atan2(dist[1], dist[0]) * 180 / M_PI;
			if (yaw < 0) {
				yaw += 360;
			}
	
			forward = sqrt (dist[0]*dist[0] + dist[1]*dist[1]);
			pitch = atan2(dist[2], forward) * 180 / M_PI;
			if (pitch < 0) {
				pitch += 360;
			}
		}

		// Add new entities for the lightning.
		VectorCopy (b->start, org);
		
		for (k = 0; k < beamstodraw; k++) {
			VectorCopy(b->start, beamstart[k]);
		}
		
		d = VectorNormalize(dist);
		VectorScale (dist, 30, dist);

		for ( ; d > 0; d -= 30) {
			if (!amf_lightning.value || Rulesets_RestrictParticles()) {
				VectorCopy (org, ent.origin);
				ent.model = b->model;
				ent.angles[0] = pitch;
				ent.angles[1] = yaw;
				ent.angles[2] = (cl.racing ? 0 : rand() % 360);
				if ((cl.racing && b->entity >= MAX_CLIENTS) || !Rulesets_RestrictParticles()) {
					ent.alpha = r_shaftalpha.value;
				}

				CL_AddEntity (&ent);
			}
			else if (!ISPAUSED) {
				//VULT - Some people might like their lightning beams thicker
				for (k = 0; k < beamstodraw; k++) {
					VectorAdd(org, dist, beamend[k]);
					if (!cl.racing) {
						for (j = 0; j < 3; j++) {
							beamend[k][j] += f_rnd(-lg_size, lg_size);
						}
					}
					VX_LightningBeam(beamstart[k], beamend[k]);
					VectorCopy(beamend[k], beamstart[k]);
				}
			}

			// The infamous d-light glow has been replaced with a simple corona so it doesn't light up the room anymore.
			if (amf_coronas.value && amf_lightning.value && !ISPAUSED) {
				if (b->entity == cl.viewplayernum + 1 && !((cls.demoplayback || cl.spectator) && cl_camera_tpp.integer)) {
					R_CoronasNew(C_SMALLLIGHTNING, org);
				}
				else {
					R_CoronasNew(C_LIGHTNING, org);
				}
			}

			VectorAdd (org, dist, org);

			// LIGHTNING SPARKS
			if (amf_lightning_sparks.value && !Rulesets_RestrictParticles() && !ISPAUSED && !gl_no24bit.integer) {
				trace_t	trace;
				trace = PM_TraceLine (org, b->end);
				if (trace.fraction < 1) {
					VectorCopy(trace.endpos, furthest_sparks);
					sparks = true;
				}
			}
		}

		if (sparks) {
			SparkGen(furthest_sparks, amf_lightning_color.color, (int)(3 * amf_lightning_sparks.value), amf_lightning_sparks_size.value, 0.25);
		}
	}
}

static void CL_UpdateExplosions(void)
{
	int f;
	explosion_t	*ex, *next, *hnode;
	entity_t ent;

	memset (&ent, 0, sizeof(entity_t));
	ent.colormap = vid.colormap;

	hnode = &cl_explosions_headnode;
	for (ex = hnode->next; ex != hnode; ex = next) {
		next = ex->next;
		f = 10 * (cl.time - ex->start);

		if (f >= ex->model->numframes) {
			CL_FreeExplosion (ex);
			continue;
		}

		VectorCopy (ex->origin, ent.origin);
		ent.model = ex->model;
		ent.frame = f;

		CL_AddEntity (&ent);
	}
}

void CL_UpdateTEnts (void)
{
	CL_UpdateBeams();
	CL_UpdateExplosions();
}



================================================
FILE: src/cl_view.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "vx_stuff.h"
#include "gl_model.h"
#include "teamplay.h"
#include "rulesets.h"
#include "utils.h"
#include "hud.h"
#include "hud_common.h"
#include "mvd_utils.h"
#include "r_matrix.h"

#ifdef X11_GAMMA_WORKAROUND
#include "tr_types.h"
#endif
#include "r_local.h"
#include "r_renderer.h"
#include "r_brushmodel.h"

/*
The view is allowed to move slightly from its true position for bobbing,
but if it exceeds 8 pixels linear distance (spherical, not box), the list of
entities sent from the server may not include everything in the pvs, especially
when crossing a water boudnary.
*/

static cvar_t cl_bob      = { "cl_bob",      "0"   };
static cvar_t cl_bobcycle = { "cl_bobcycle", "0.0" };
static cvar_t cl_bobup    = { "cl_bobup",    "0.0" };
static cvar_t cl_bobhead  = { "cl_bobhead",  "0"   };

cvar_t	cl_rollspeed = {"cl_rollspeed", "200"};
cvar_t	cl_rollangle = {"cl_rollangle", "0"};
cvar_t	cl_rollalpha = {"cl_rollalpha", "20"};
cvar_t	v_kicktime = {"v_kicktime", "0.0"};
cvar_t	v_kickroll = {"v_kickroll", "0.0"};
cvar_t	v_kickpitch = {"v_kickpitch", "0.0"};
cvar_t	v_gunkick = {"v_gunkick", "0"};
cvar_t	v_viewheight = {"v_viewheight", "0"};

cvar_t	cl_drawgun = {"r_drawviewmodel", "1"};
cvar_t	cl_drawgun_invisible = {"r_drawviewmodel_invisible", "0"};
cvar_t  r_nearclip = {"r_nearclip", "2", CVAR_RULESET_MAX | CVAR_RULESET_MIN, NULL, R_MINIMUM_NEARCLIP, R_MAXIMUM_FARCLIP, R_MINIMUM_NEARCLIP };
cvar_t	r_viewmodelsize = {"r_viewmodelSize", "1"};
cvar_t	r_viewmodeloffset = {"r_viewmodeloffset", ""};
cvar_t  r_viewpreselgun = {"r_viewpreselgun", "0"};
cvar_t	r_viewlastfired = {"r_viewmodellastfired", "0"};

void Change_v_idle (cvar_t *var, char *value, qbool *cancel);
cvar_t	v_iyaw_cycle = {"v_iyaw_cycle", "2", 0, Change_v_idle};
cvar_t	v_iroll_cycle = {"v_iroll_cycle", "0.5", 0, Change_v_idle};
cvar_t	v_ipitch_cycle = {"v_ipitch_cycle", "1", 0, Change_v_idle};
cvar_t	v_iyaw_level = {"v_iyaw_level", "0.3", 0, Change_v_idle};
cvar_t	v_iroll_level = {"v_iroll_level", "0.1", 0, Change_v_idle};
cvar_t	v_ipitch_level = {"v_ipitch_level", "0.3", 0, Change_v_idle};
cvar_t	v_idlescale = {"v_idlescale", "0", 0, Change_v_idle};

cvar_t	crosshair = {"crosshair", "4",};
cvar_t	crosshaircolor = {"crosshaircolor", "255 0 0", CVAR_COLOR};
cvar_t	crosshairsize	= {"crosshairsize", "1"};
cvar_t  cl_crossx = {"cl_crossx", "0"};
cvar_t  cl_crossy = {"cl_crossy", "0"};

// gamma updates are expensive in hw: update at lower fps, otherwise drops are severe
static cvar_t vid_hwgamma_fps = { "vid_hwgamma_fps", "60" };

// QW262: less flash grenade effect in demos
cvar_t cl_demoplay_flash       = { "cl_demoplay_flash",      "0.33" };

cvar_t v_contentblend          = { "v_contentblend",         "0.2" };
cvar_t v_damagecshift          = { "v_damagecshift",         "0.2" };
cvar_t v_quadcshift            = { "v_quadcshift",           "0.5" };
cvar_t v_suitcshift            = { "v_suitcshift",           "0.5" };
cvar_t v_ringcshift            = { "v_ringcshift",           "0.5" };
cvar_t v_pentcshift            = { "v_pentcshift",           "0.5" };
cvar_t v_dlightcshift          = { "v_dlightcshift",         "1" };
cvar_t v_dlightcolor           = { "v_dlightcolor",          "1" };
cvar_t v_dlightcshiftpercent   = { "v_dlightcshiftpercent",  "0.5" };

cvar_t v_bonusflash            = { "cl_bonusflash",          "0" };

float	v_dmg_time, v_dmg_roll, v_dmg_pitch;

frame_t			*view_frame;
player_state_t	view_message;

void Change_v_idle (cvar_t *var, char *value, qbool *cancel) {
	// Don't allow cheating in TF
	*cancel = (cl.teamfortress && cls.state >= ca_connected && cbuf_current != &cbuf_svc);
}

float V_CalcRoll (vec3_t angles, vec3_t velocity) {
	vec3_t right;
	float sign, side;

	AngleVectors (angles, NULL, right, NULL);
	side = DotProduct (velocity, right);
	sign = side < 0 ? -1 : 1;
	side = fabs(side);

	side = (side < cl_rollspeed.value) ? side * Ruleset_RollAngle() / cl_rollspeed.value : Ruleset_RollAngle();

	if (side > 45)
		side = 45;

	return side * sign;
	
}

float V_CalcBob (void) {
	static double bobtime;
	static float bob;
	float cycle;
	
	if (cl.spectator)
		return 0;

	if (!cl.onground)
		return bob;		// just use old value

	if (cl_bobcycle.value <= 0)	
		return 0;

	bobtime += cls.frametime;
	cycle = bobtime - (int) (bobtime / cl_bobcycle.value) * cl_bobcycle.value;
	cycle /= cl_bobcycle.value;
	if (cycle < cl_bobup.value)
		cycle = M_PI * cycle / cl_bobup.value;
	else
		cycle = M_PI + M_PI * (cycle - cl_bobup.value) / (1.0 - cl_bobup.value);

	// bob is proportional to simulated velocity in the xy plane
	// (don't count Z, or jumping messes it up)
	bob = sqrt(cl.simvel[0] * cl.simvel[0] + cl.simvel[1] * cl.simvel[1]) * cl_bob.value;
	bob = bob * 0.3 + bob * 0.7 * sin(cycle);
	bob = bound (-7, bob, 4);
	return bob;	
}

//=============================================================================

cvar_t	v_centermove = {"v_centermove", "0.15"};
cvar_t	v_centerspeed = {"v_centerspeed","500"};

void Force_Centerview_f (void)
{
	if (concussioned)
		return;

	cl.viewangles[PITCH] = 0;
}

void V_StartPitchDrift (void) {
	if (cl.laststop == cl.time)
		return;		// something else is keeping it from drifting

	if (cl.nodrift || !cl.pitchvel) {
		cl.pitchvel = v_centerspeed.value;
		cl.nodrift = false;
		cl.driftmove = 0;
	}
}

void V_StopPitchDrift (void) {
	cl.laststop = cl.time;
	cl.nodrift = true;
	cl.pitchvel = 0;
}

/*
Moves the client pitch angle towards cl.idealpitch sent by the server.

If the user is adjusting pitch manually, either with lookup/lookdown,
mlook and mouse, or klook and keyboard, pitch drifting is constantly stopped.

Drifting is enabled when the center view key is hit, mlook is released and
lookspring is non 0, or when 
*/
void V_DriftPitch (void) {
	float delta, move;

	if (!cl.onground || cls.demoplayback ) {
		cl.driftmove = cl.pitchvel = 0;
		return;
	}

// don't count small mouse motion
	if (cl.nodrift) {
		if (abs(cl.frames[(cls.netchan.outgoing_sequence-1)&UPDATE_MASK].cmd.forwardmove) < 200)
			cl.driftmove = 0;
		else
			cl.driftmove += cls.frametime;
	
		if ( cl.driftmove > v_centermove.value)
			V_StartPitchDrift ();

		return;
	}
	
	delta = 0 - cl.viewangles[PITCH];

	if (!delta) {
		cl.pitchvel = 0;
		return;
	}

	move = cls.frametime * cl.pitchvel;
	cl.pitchvel += cls.frametime * v_centerspeed.value;

	if (delta > 0) {
		if (move > delta) {
			cl.pitchvel = 0;
			move = delta;
		}
		cl.viewangles[PITCH] += move;
	} else if (delta < 0) {
		if (move > -delta) {
			cl.pitchvel = 0;
			move = -delta;
		}
		cl.viewangles[PITCH] -= move;
	}
}

/*
============================================================================== 
 						PALETTE FLASHES 
============================================================================== 
*/
 
cshift_t	cshift_empty = { {130,80,50}, 0 };
cshift_t	cshift_water = { {130,80,50}, 128 };
cshift_t	cshift_slime = { {0,25,5}, 150 };
cshift_t	cshift_lava = { {255,80,0}, 150 };

cvar_t		gl_cshiftpercent = {"gl_cshiftpercent", "100"};
cvar_t		gl_hwblend = {"gl_hwblend", "0"};
float		v_blend[4];		// rgba 0.0 - 1.0
cvar_t		v_gamma = {"gl_gamma", "1.0"};
cvar_t		v_contrast = {"gl_contrast", "1.0"};

#ifdef X11_GAMMA_WORKAROUND
unsigned short ramps[3][4096];
#else
unsigned short	ramps[3][256];
#endif

void V_ParseDamage (void)
{
	int armor, blood, i;
	vec3_t from, forward, right;
	float side, count, fraction;

	armor = MSG_ReadByte ();
	blood = MSG_ReadByte ();
	for (i = 0; i < 3; i++)
		from[i] = MSG_ReadCoord ();

	if (cls.mvdplayback && cls.lastto >= 0 && cls.lastto < MAX_CLIENTS) {
		cl.players[cls.lastto].max_health_last_set = cls.demotime;
	}

	if (CL_Demo_SkipMessage(true))
		return;

	count = blood * 0.5 + armor * 0.5;
	if (count < 10)
		count = 10;

	cl.faceanimtime = cl.time + 0.2;		// put sbar face into pain frame

	cl.hurtblur = cl.time + count / 24;		// use hurt motion blur.

	cl.cshifts[CSHIFT_DAMAGE].percent += 3*count;
	if (cl.cshifts[CSHIFT_DAMAGE].percent < 0)
		cl.cshifts[CSHIFT_DAMAGE].percent = 0;
	if (cl.cshifts[CSHIFT_DAMAGE].percent > 150)
		cl.cshifts[CSHIFT_DAMAGE].percent = 150;

	fraction = bound(0, v_damagecshift.value, 1);
	cl.cshifts[CSHIFT_DAMAGE].percent *= fraction;

	if (armor > blood) {
		cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 200;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 100;
	} else if (armor) {
		cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 220;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 50;
	} else {
		cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 255;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 0;
	}

	// calculate view angle kicks
	VectorSubtract (from, cl.simorg, from);
	VectorNormalizeFast (from);

	AngleVectors (cl.simangles, forward, right, NULL);

	side = DotProduct (from, right);
	v_dmg_roll = count * side * v_kickroll.value;

	side = DotProduct (from, forward);
	v_dmg_pitch = count * side * v_kickpitch.value;

	v_dmg_time = v_kicktime.value;
}

// disconnect -->
qbool flashed = false; // it should be used for f_flashout tirgger
extern cvar_t v_gamma, v_contrast;

void V_TF_FlashSettings(qbool flashed)
{
	static float old_gamma, old_contrast;

	// remove read only flag if it was set
	if (Cvar_GetFlags(&v_gamma) & CVAR_ROM) {
		Cvar_SetFlags(&v_gamma, Cvar_GetFlags(&v_gamma) & ~CVAR_ROM);
	}
	if (Cvar_GetFlags(&v_contrast) & CVAR_ROM) {
		Cvar_SetFlags(&v_contrast, Cvar_GetFlags(&v_contrast) & ~CVAR_ROM);
	}

	if (flashed) {
		// store normal settings
		old_gamma = v_gamma.value;
		old_contrast = v_contrast.value;

		// set MTFL flash settings	
		Cvar_SetValue(&v_gamma, MTFL_FLASH_GAMMA);
		Cvar_SetValue(&v_contrast, MTFL_FLASH_CONTRAST);

		// made gamma&contrast read only
		Cvar_SetFlags(&v_gamma, Cvar_GetFlags(&v_gamma) | CVAR_ROM);
		Cvar_SetFlags(&v_contrast, Cvar_GetFlags(&v_contrast) | CVAR_ROM);
	}
	else {
		// restore old settings
		Cvar_SetValue(&v_gamma, old_gamma);
		Cvar_SetValue(&v_contrast, old_contrast);
	}
}

void V_TF_FlashStuff (void)
{
	static float last_own_flash_time;
	static float last_other_flash_time;
	float blocktime;

	// 240 = Normal TF || 255 = Angel TF
	if (cshift_empty.percent == 240 || cshift_empty.percent == 255 ) {
		TP_ExecTrigger ("f_flash");
		if (!flashed && Rulesets_ToggleWhenFlashed()) {
			V_TF_FlashSettings(true);
		}

		flashed = true;
		last_other_flash_time = cls.realtime;
	}

	if (cshift_empty.percent == 160) {
		// flashed by your own flash
		if (!flashed && Rulesets_ToggleWhenFlashed()) {
			V_TF_FlashSettings(true);
		}

		flashed = true;
		last_own_flash_time = cls.realtime;
	}

	blocktime = (last_other_flash_time > last_own_flash_time) ? 20.0 : 10.0;

	{
		qbool flashed_for_10seconds = (!(cls.realtime - max(last_own_flash_time, last_other_flash_time) < blocktime));
		qbool death_while_flashed = (cshift_empty.percent == 0 && cbuf_current == &cbuf_svc);

		if (flashed_for_10seconds || death_while_flashed) {
			// turn gamma and contrast back
			if (flashed && Rulesets_ToggleWhenFlashed()) {
				V_TF_FlashSettings(false);
			}
			flashed = false;
		}
	}

	if (cls.demoplayback && cshift_empty.destcolor[0] == cshift_empty.destcolor[1]) {
		cshift_empty.percent *= bound(0, cl_demoplay_flash.value, 1.0f);
	}
}
// <-- disconnect

void V_cshift_f (void) {
	// don't allow cheating in TF
	if (cls.state >= ca_connected && cl.teamfortress && cbuf_current != &cbuf_svc)
		return;

	cshift_empty.destcolor[0] = atoi(Cmd_Argv(1));
	cshift_empty.destcolor[1] = atoi(Cmd_Argv(2));
	cshift_empty.destcolor[2] = atoi(Cmd_Argv(3));
	cshift_empty.percent = atoi(Cmd_Argv(4));

	// TF flash grenades stuff
	if (cl.teamfortress)
		V_TF_FlashStuff ();
}

//When you run over an item, the server sends this command
void V_BonusFlash_f (void) {
        static double last_bonusflashtrigger = 0;

	if (cls.realtime != last_bonusflashtrigger) { // do not trigger twice a frame
		TP_ExecTrigger ("f_bonusflash");
		last_bonusflashtrigger = cls.realtime;
	}

	if (!v_bonusflash.value && cbuf_current == &cbuf_svc)
		return;

	cl.cshifts[CSHIFT_BONUS].destcolor[0] = 215;
	cl.cshifts[CSHIFT_BONUS].destcolor[1] = 186;
	cl.cshifts[CSHIFT_BONUS].destcolor[2] = 69;
	cl.cshifts[CSHIFT_BONUS].percent = 50;
}

//Underwater, lava, etc each has a color shift
void V_SetContentsColor (int contents)
{
	extern cvar_t gl_polyblend;

	if (!v_contentblend.value) {
		cl.cshifts[CSHIFT_CONTENTS] = cshift_empty;
		cl.cshifts[CSHIFT_CONTENTS].percent *= 100;
		return;
	}

	switch (contents) {
		case CONTENTS_EMPTY:
			cl.cshifts[CSHIFT_CONTENTS] = cshift_empty;
			break;
		case CONTENTS_LAVA:
			cl.cshifts[CSHIFT_CONTENTS] = cshift_lava;
			break;
		case CONTENTS_SOLID:
		case CONTENTS_SLIME:
			cl.cshifts[CSHIFT_CONTENTS] = cshift_slime;
			break;
		default:
			cl.cshifts[CSHIFT_CONTENTS] = cshift_water;
			break;
	}

	if (v_contentblend.value > 0 && v_contentblend.value < 1 && contents != CONTENTS_EMPTY) {
		cl.cshifts[CSHIFT_CONTENTS].percent *= v_contentblend.value;
	}

	if (!gl_polyblend.value && !cl.teamfortress) {
		cl.cshifts[CSHIFT_CONTENTS].percent = 0;
	}
	else {
		// ignore gl_cshiftpercent on custom cshifts (set with v_cshift
		// command) to avoid cheating in TF
		if (contents != CONTENTS_EMPTY) {
			if (!gl_polyblend.value) {
				cl.cshifts[CSHIFT_CONTENTS].percent = 0;
			}
			else {
				cl.cshifts[CSHIFT_CONTENTS].percent *= gl_cshiftpercent.value;
			}
		}
		else {
			cl.cshifts[CSHIFT_CONTENTS].percent *= 100;
		}
	}
}

void V_CalcPowerupCshift(void)
{
	float fraction;

	if (cl.stats[STAT_ITEMS] & IT_QUAD)	{
		cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
		cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 0;
		cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 255;
		fraction = bound (0, v_quadcshift.value, 1);
		cl.cshifts[CSHIFT_POWERUP].percent = 30 * fraction;
	} else if (cl.stats[STAT_ITEMS] & IT_SUIT) {
		cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
		cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
		cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
		fraction = bound (0, v_suitcshift.value, 1);
		cl.cshifts[CSHIFT_POWERUP].percent = 20 * fraction;
	} else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) {
		cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 100;
		cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 100;
		cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 100;
		fraction = bound (0, v_ringcshift.value, 1);
		cl.cshifts[CSHIFT_POWERUP].percent = 100 * fraction;
	} else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) {
		cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 255;
		cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
		cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
		fraction = bound (0, v_pentcshift.value, 1);
		cl.cshifts[CSHIFT_POWERUP].percent = 30 * fraction;
	} else {
		cl.cshifts[CSHIFT_POWERUP].percent = 0;
	}
}

void V_CalcBlend (void)
{
	float r, g, b, a, a2, t;
	int j;
	extern cvar_t gl_polyblend;

	r = g = b = a = 0;

	if (cls.state != ca_active) {
		cl.cshifts[CSHIFT_CONTENTS] = cshift_empty;
		cl.cshifts[CSHIFT_POWERUP].percent = 0;
	}
	else {
		V_CalcPowerupCshift ();
	}

	// drop the damage value
	t = cls.frametime * 150;
	cl.cshifts[CSHIFT_DAMAGE].percent -= t;
	if (cl.cshifts[CSHIFT_DAMAGE].percent <= 0) {
		cl.cshifts[CSHIFT_DAMAGE].percent = 0;
	}

	// drop the bonus value
	cl.cshifts[CSHIFT_BONUS].percent -= cls.frametime * 100;
	if (cl.cshifts[CSHIFT_BONUS].percent <= 0) {
		cl.cshifts[CSHIFT_BONUS].percent = 0;
	}

	for (j = 0; j < NUM_CSHIFTS; j++)	{
		if ((!gl_cshiftpercent.value || !gl_polyblend.value) && j != CSHIFT_CONTENTS) {
			continue;
		}

		if (j == CSHIFT_CONTENTS) {
			a2 = cl.cshifts[j].percent / 100.0 / 255.0;
		}
		else {
			a2 = ((cl.cshifts[j].percent * gl_cshiftpercent.value) / 100.0) / 255.0;
		}

		if (!a2) {
			continue;
		}
		a = a + a2 * (1-a);

		a2 = a2 / a;
		r = r * (1 - a2) + cl.cshifts[j].destcolor[0] * a2;
		g = g * (1 - a2) + cl.cshifts[j].destcolor[1] * a2;
		b = b * (1 - a2) + cl.cshifts[j].destcolor[2 ]* a2;
	}

	v_blend[0] = r / 255.0;
	v_blend[1] = g / 255.0;
	v_blend[2] = b / 255.0;
	v_blend[3] = a;
	v_blend[3] = bound(0, v_blend[3], 1);
}

void V_AddLightBlend(float r, float g, float b, float a2, qbool suppress_polyblend)
{
	float a;
	extern cvar_t gl_polyblend;
	qbool shift_on_dlight = gl_polyblend.integer && (v_dlightcshift.integer == 1 || (v_dlightcshift.integer == 2 && !suppress_polyblend));
	float percentage = bound(0, v_dlightcshiftpercent.value, 1);

	if (percentage <= 0 || !shift_on_dlight) {
		return;
	}

	if (!v_dlightcolor.integer) {
		r = 1.0f;
		g = 0.5f;
		b = 0.0f;
	}
	else {
		// some kind of scaling, the normal colors aren't full red/blue etc
		float max = max(r, max(g, b));

		if (max > 0) {
			r /= max;
			g /= max;
			b /= max;
		}
	}

	a2 = bound(0, a2, 1);
	a2 *= percentage;

	v_blend[3] = a = v_blend[3] + a2 * (1 - v_blend[3]);

	if (!a) {
		return;
	}

	a2 = a2 / a;

	v_blend[0] = v_blend[0] * (1 - a2) + r * a2;
	v_blend[1] = v_blend[1] * (1 - a2) + g * a2;
	v_blend[2] = v_blend[2] * (1 - a2) + b * a2;
}

void V_UpdatePalette (void)
{
	int i, j, c;
	float current_gamma, current_contrast, a, rgb[3];
	static float prev_blend[4] = { 0, 0, 0, 0 };
	static float old_gamma = 1, old_contrast = 1;
	static qbool old_change_palette = false;
	static double last_set = 0;
	extern float vid_gamma;
	float hw_vblend[4];
	// whether or not to include content/damage palette shifts as part of the hw gamma
	qbool change_palette = (vid_hwgamma_enabled && gl_hwblend.value && !cl.teamfortress);
	int change_flags = 0;

	if (change_palette) {
		memcpy(hw_vblend, v_blend, sizeof(hw_vblend));
	}
	else {
		memset(hw_vblend, 0, sizeof(hw_vblend));
	}
	current_gamma = (vid_hwgamma_enabled ? bound(0.3, v_gamma.value, 3) : 1);
	current_contrast = (vid_hwgamma_enabled ? bound(1, v_contrast.value, 3) : 1);

	change_flags |= (memcmp(hw_vblend, prev_blend, sizeof(hw_vblend)) ? 1 : 0);
	change_flags |= (current_gamma != old_gamma || v_gamma.modified ? 2 : 0);
	change_flags |= (current_contrast != old_contrast ? 4 : 0);
	change_flags |= (change_palette != old_change_palette ? 8 : 0);

	if (!change_flags) {
		return;
	}

	// don't update if not enough time has passed & only palette updating
	if (change_flags == 1 && vid_hwgamma_fps.integer && curtime < last_set + (1.0f / max(10, vid_hwgamma_fps.integer))) {
		return;
	}

	// store flags
	old_change_palette = change_palette;
	prev_blend[0] = hw_vblend[0];
	prev_blend[1] = hw_vblend[1];
	prev_blend[2] = hw_vblend[2];
	prev_blend[3] = hw_vblend[3];
	old_gamma = current_gamma;
	old_contrast = current_contrast;
	last_set = curtime;
	v_gamma.modified = false;
	if (developer.integer == 3) {
		Con_DPrintf("palette: change_flags %d [%d %d %d %d] %.2f %.2f\n", change_flags, (int)(hw_vblend[0] * 255), (int)(hw_vblend[1] * 255), (int)(hw_vblend[2] * 255), (int)(hw_vblend[3] * 255), current_gamma, current_contrast);
	}

	a = hw_vblend[3];
	if (R_OldGammaBehaviour() && vid_gamma != 1.0) {
		current_contrast = pow(current_contrast, vid_gamma);
		current_gamma = current_gamma / vid_gamma;
	}

	// Have to do this in a loop these days as certain color ranges will be blocked by OS
	do {
		float std_alpha;

		rgb[0] = 255 * hw_vblend[0] * a;
		rgb[1] = 255 * hw_vblend[1] * a;
		rgb[2] = 255 * hw_vblend[2] * a;

		std_alpha = 1 - a;

#ifdef X11_GAMMA_WORKAROUND
		std_alpha *= 256.0 / glConfig.gammacrap.size;
		for (i = 0; i < glConfig.gammacrap.size; i++) {
#else
		for (i = 0; i < 256; i++) {
#endif
			for (j = 0; j < 3; j++) {
				// apply blend and contrast
				c = (i * std_alpha + rgb[j]) * current_contrast;
				if (c > 255) {
					c = 255;
				}
				// apply gamma
				c = 255 * pow(c / 255.5, current_gamma) + 0.5;
				c = bound(0, c, 255);
				ramps[j][i] = c << 8;
			}
		}

		a *= 0.8;
	} while (VID_SetDeviceGammaRamp((unsigned short *)ramps) && a > 0.1);
}

// BorisU -->
void V_TF_ClearGrenadeEffects (void)
{
	cbuf_t *cbuf_tmp;
	extern cvar_t scr_fov, default_fov;
	
	cbuf_tmp = cbuf_current;
	cbuf_current = &cbuf_svc;
	// Concussion effect off
	concussioned = false;
	Cvar_SetValue (&scr_fov, default_fov.value);
	Cvar_SetValue (&v_idlescale, 0.0f);

	// Flash effect off
	if (flashed && Rulesets_ToggleWhenFlashed()) {
		V_TF_FlashSettings (false);
	}
	flashed = false;

	cshift_empty.destcolor[0] = 0;
	cshift_empty.destcolor[1] = 0;
	cshift_empty.destcolor[2] = 0;
	cshift_empty.percent = 0;
	cbuf_current = cbuf_tmp;
}
// <-- BorisU
/* 
============================================================================== 
						         VIEW RENDERING 
============================================================================== 
*/

float angledelta (float a) {
	a = anglemod(a);
	if (a > 180)
		a -= 360;
	return a;
}

void V_BoundOffsets (void) {
	// absolutely bound refresh relative to entity clipping hull
	// so the view can never be inside a solid wall

	if (r_refdef.vieworg[0] < cl.simorg[0] - 14)
		r_refdef.vieworg[0] = cl.simorg[0] - 14;
	else if (r_refdef.vieworg[0] > cl.simorg[0] + 14)
		r_refdef.vieworg[0] = cl.simorg[0] + 14;

	if (r_refdef.vieworg[1] < cl.simorg[1] - 14)
		r_refdef.vieworg[1] = cl.simorg[1] - 14;
	else if (r_refdef.vieworg[1] > cl.simorg[1] + 14)
		r_refdef.vieworg[1] = cl.simorg[1] + 14;

	if (r_refdef.vieworg[2] < cl.simorg[2] - 22)
		r_refdef.vieworg[2] = cl.simorg[2] - 22;
	else if (r_refdef.vieworg[2] > cl.simorg[2] + 30)
		r_refdef.vieworg[2] = cl.simorg[2] + 30;
}

//Idle swaying
void V_AddIdle (void) {
	r_refdef.viewangles[ROLL] += v_idlescale.value * sin(cl.time * v_iroll_cycle.value) * v_iroll_level.value;
	r_refdef.viewangles[PITCH] += v_idlescale.value * sin(cl.time * v_ipitch_cycle.value) * v_ipitch_level.value;
	r_refdef.viewangles[YAW] += v_idlescale.value * sin(cl.time * v_iyaw_cycle.value) * v_iyaw_level.value;
}

//Roll is induced by movement and damage
void V_CalcViewRoll (void) {
	float side, adjspeed;

	side = V_CalcRoll (cl.simangles, cl.simvel);
	adjspeed = cl_rollalpha.value * bound (2, Ruleset_RollAngle(), 45);
	if (side > cl.rollangle) {
		cl.rollangle += cls.frametime * adjspeed;
		if (cl.rollangle > side)
			cl.rollangle = side;
	} else if (side < cl.rollangle) {
		cl.rollangle -= cls.frametime * adjspeed;
		if (cl.rollangle < side)
			cl.rollangle = side;
	}
	r_refdef.viewangles[ROLL] += cl.rollangle;

	if (v_dmg_time > 0) {
		r_refdef.viewangles[ROLL] += v_dmg_time/v_kicktime.value*v_dmg_roll;
		r_refdef.viewangles[PITCH] += v_dmg_time/v_kicktime.value*v_dmg_pitch;
		v_dmg_time -= cls.frametime;
	}
}

// tells the model number of the current carried/selected/preselected weapon
// if user wish so, weapon pre-selection is also taken in account
// todo: if user selects different weapon while the current one is still
// firing, wait until the animation is finished
static int V_CurrentWeaponModel(void)
{
	extern cvar_t cl_weaponpreselect;
	int bestgun;
	int realw = cl.stats[STAT_WEAPON];

	if (cls.demoplayback && r_viewlastfired.integer) {
		if (realw == 0) {
			cl.lastfired = realw;
			cl.lastviewplayernum = cl.viewplayernum;
			return realw;
		}
		if (view_message.weaponframe) {
			cl.lastfired = realw;
			cl.lastviewplayernum = cl.viewplayernum;
			return realw;
		}
		else if (cl.lastfired) {
			if (cl.lastviewplayernum == cl.viewplayernum) {
				return cl.lastfired;
			}
			else {
				cl.lastfired = realw;
				cl.lastviewplayernum = cl.viewplayernum;
				return realw;
			}
		}
		else {
			return realw;
		}
	}
	else {
		if (ShowPreselectedWeap() && r_viewpreselgun.integer && !view_message.weaponframe) {
			bestgun = IN_BestWeaponReal(true);
			if (bestgun == 1) {
				return cl_modelindices[mi_vaxe];
			}
			if (bestgun > 1 && bestgun <= 8) {
				return cl_modelindices[mi_weapon1 - 1 + bestgun];
			}
		}
		return cl.stats[STAT_WEAPON];
	}
}

extern void TP_ParseWeaponModel(model_t *model);

static void V_AddViewWeapon(float bob)
{
	vec3_t forward, right, up;
	centity_t *cent;
	int gunmodel = V_CurrentWeaponModel();
	extern cvar_t scr_fov, scr_fovmode, scr_newHud;

	cent = CL_WeaponModelForView();
	TP_ParseWeaponModel(cl.model_precache[gunmodel]);

	if (!cl_drawgun.value
		|| (cl_drawgun.value == 2 && scr_fov.value > 90)
		|| ((view_message.flags & (PF_GIB | PF_DEAD)))
		|| (!cl_drawgun_invisible.value && cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
		|| cl.stats[STAT_HEALTH] <= 0
		|| !Cam_DrawViewModel()) {
		cent->current.modelindex = 0;	//no model
		return;
	}

	//angles
	cent->current.angles[YAW] = r_refdef.viewangles[YAW];
	cent->current.angles[PITCH] = -r_refdef.viewangles[PITCH];
	cent->current.angles[ROLL] = r_refdef.viewangles[ROLL];
	//origin

	AngleVectors(r_refdef.viewangles, forward, right, up);
	VectorCopy(r_refdef.vieworg, cent->current.origin);

	VectorMA(cent->current.origin, bob * 0.4, forward, cent->current.origin);

	if (r_viewmodeloffset.string[0]) {
		float offset[3];
		int size = sizeof(offset) / sizeof(offset[0]);

		ParseFloats(r_viewmodeloffset.string, offset, &size);
		VectorMA(cent->current.origin, offset[0], right, cent->current.origin);
		VectorMA(cent->current.origin, -offset[1], up, cent->current.origin);
		VectorMA(cent->current.origin, offset[2], forward, cent->current.origin);
	}

	// fudge position around to keep amount of weapon visible roughly equal with different FOV
	if (!scr_fovmode.value) {
		if (cl_sbar.value && scr_newHud.value == 0 && scr_viewsize.value == 110)
			cent->current.origin[2] += 1;
		else if (cl_sbar.value && scr_newHud.value == 0 && scr_viewsize.value == 100)
			cent->current.origin[2] += 2;
		else if (scr_viewsize.value == 90)
			cent->current.origin[2] += 1;
		else if (scr_viewsize.value == 80)
			cent->current.origin[2] += 0.5;
	}

	if (cent->current.modelindex != gunmodel) {
		cent->frametime = -1;
	}
	else {
		if (cent->current.frame != view_message.weaponframe) {
			cent->frametime = cl.time;
			cent->oldframe = cent->current.frame;
		}
	}

	cent->current.modelindex = gunmodel;
	cent->current.frame = view_message.weaponframe;
}

static void V_CalcIntermissionRefdef(void)
{
	float old;

	VectorCopy (cl.simorg, r_refdef.vieworg);
	VectorCopy (cl.simangles, r_refdef.viewangles);

	// we don't draw weapon in intermission
	CL_WeaponModelForView()->current.modelindex = 0;

	// always idle in intermission
	old = v_idlescale.value;
	v_idlescale.value = 1;
	V_AddIdle ();
	v_idlescale.value = old;
}

static void V_CalcRefdef(void)
{
	vec3_t forward;
	float bob;
	float height_adjustment;

	V_DriftPitch();

	bob = V_CalcBob();

	height_adjustment = v_viewheight.value ? bound(-7, v_viewheight.value, 4) : V_CalcBob();
	if (cl_bobhead.integer) {
		height_adjustment += bob;
		bob = 0;
	}

	// set up the refresh position
	VectorCopy(cl.simorg, r_refdef.vieworg);

	// never let it sit exactly on a node line, because a water plane can
	// dissapear when viewed with the eye exactly on it.
	// the server protocol only specifies to 1/8 pixel, so add 1/16 in each axis
	r_refdef.vieworg[0] += 1.0 / 16;
	r_refdef.vieworg[1] += 1.0 / 16;
	r_refdef.vieworg[2] += 1.0 / 16;

	// add view height
	r_refdef.viewheight_test = 4;
	if (view_message.flags & PF_GIB) {
		r_refdef.vieworg[2] += 8;	// gib view height
	}
	else if (view_message.flags & PF_DEAD && (cl.stats[STAT_HEALTH] <= 0)) {
		r_refdef.vieworg[2] -= 16;	// corpse view height
	}
	else {
		// normal view height
		// Use STAT_VIEWHEIGHT in case of server support it or NQ demoplayback, if not then use default viewheight.
		r_refdef.vieworg[2] += ((cl.z_ext & Z_EXT_VIEWHEIGHT) || cls.nqdemoplayback) ? cl.stats[STAT_VIEWHEIGHT] : DEFAULT_VIEWHEIGHT;

		r_refdef.vieworg[2] += height_adjustment;

		// smooth out stair step ups
		r_refdef.vieworg[2] += cl.crouch;

		// standard offset
		r_refdef.viewheight_test = 10;
	}

	// set up refresh view angles
	VectorCopy(cl.simangles, r_refdef.viewangles);
	V_CalcViewRoll();
	V_AddIdle();

	if (v_gunkick.value) {
		// add weapon kick offset
		AngleVectors(r_refdef.viewangles, forward, NULL, NULL);
		VectorMA(r_refdef.vieworg, cl.punchangle, forward, r_refdef.vieworg);

		// add weapon kick angle
		r_refdef.viewangles[PITCH] += cl.punchangle * 0.5;
	}

	if (view_message.flags & PF_DEAD && (cl.stats[STAT_HEALTH] <= 0)) {
		r_refdef.viewangles[ROLL] = 80;	// dead view angle
	}

	//VULT CAMERAS
	CameraUpdate(view_message.flags & PF_DEAD);

	// meag: really viewheight shouldn't be here, but it was incorrectly passed for years instead of bob,
	//       and so without it the gun is rendered too far forward if e.g. viewheight -6
	V_AddViewWeapon(bob + height_adjustment);
}

void DropPunchAngle (void) {
	if (cl.ideal_punchangle < cl.punchangle) {
		if (cl.ideal_punchangle == -2)	// small kick
			cl.punchangle -= 20 * cls.frametime;
		else							// big kick
			cl.punchangle -= 40 * cls.frametime;

		if (cl.punchangle <= cl.ideal_punchangle) {
			cl.punchangle = cl.ideal_punchangle;
			cl.ideal_punchangle = 0;
		}
	}else {
		cl.punchangle += 20 * cls.frametime;
		if (cl.punchangle > 0)
			cl.punchangle = 0;
	}
}

//The player's clipping box goes from (-16 -16 -24) to (16 16 32) from
//the entity origin, so any view position inside that will be valid
extern vrect_t scr_vrect;

qbool V_PreRenderView(void)
{
	char *p;

	cl.simangles[ROLL] = 0;	// FIXME @@@ 

	if (cls.state != ca_active) {
		V_CalcBlend();
	}
	else {
		view_frame = &cl.frames[cl.validsequence & UPDATE_MASK];
		if (!cls.nqdemoplayback) {
			view_message = view_frame->playerstate[cl.viewplayernum];
		}

		DropPunchAngle();
		if (cl.intermission) {
			// intermission / finale rendering
			V_CalcIntermissionRefdef();
		}
		else {
			V_CalcRefdef();
		}

		MVD_PowerupCam_Frame();

		R_PushDlights();

		r_refdef2.time = cl.time;
		r_refdef2.sin_time = sin(r_refdef2.time);
		r_refdef2.cos_time = cos(r_refdef2.time);

		// scroll parameters for powerup shells
		r_refdef2.powerup_scroll_params[0] = cos(cl.time * 1.5);
		r_refdef2.powerup_scroll_params[1] = sin(cl.time * 1.1);
		r_refdef2.powerup_scroll_params[2] = cos(cl.time * -0.5);
		r_refdef2.powerup_scroll_params[3] = sin(cl.time * -0.5);

		// restrictions
		r_refdef2.allow_cheats = cls.demoplayback || (Info_ValueForKey(cl.serverinfo, "*cheats")[0] && com_serveractive);
		if (cls.demoplayback || cl.spectator) {
			r_refdef2.allow_lumas = true;
			r_refdef2.max_fbskins = 1;
		}
		else {
			r_refdef2.allow_lumas = !strcmp(Info_ValueForKey(cl.serverinfo, "24bit_fbs"), "0") ? false : true;
			r_refdef2.max_fbskins = *(p = Info_ValueForKey(cl.serverinfo, "fbskins")) ? bound(0, Q_atof(p), 1) : (cl.teamfortress ? 0 : 1);
		}

		// Only allow alpha water if the server allows it, or they are spectator and have novis enabled
		{
			extern cvar_t r_novis;

			r_refdef2.max_watervis = *(p = Info_ValueForKey(cl.serverinfo, "watervis")) ? bound(0, Q_atof(p), 1) : 0;
			if ((cls.demoplayback || cl.spectator) && (r_novis.integer || r_refdef2.max_watervis > 0)) {
				// ignore server limit
				r_refdef2.max_watervis = 1;
			}
			r_refdef2.wateralpha = R_WaterAlpha();  // relies on r_refdef2.max_watervis
		}

		// time-savers
		{
			extern cvar_t r_drawflat_mode, r_drawflat, r_fastturb, gl_caustics;
			extern texture_ref underwatertexture;

			r_refdef2.drawFlatFloors = r_drawflat_mode.integer == 0 && (r_drawflat.integer == 2 || r_drawflat.integer == 1);
			r_refdef2.drawFlatWalls = r_drawflat_mode.integer == 0 && (r_drawflat.integer == 3 || r_drawflat.integer == 1);
			r_refdef2.solidTexTurb = (!r_fastturb.integer && r_refdef2.wateralpha == 1);

			r_refdef2.drawCaustics = (R_TextureReferenceIsValid(underwatertexture) && gl_caustics.integer);
			r_refdef2.drawWorldOutlines = R_DrawWorldOutlines();
			r_refdef2.distanceScale = tan(r_refdef.fov_x * (M_PI / 180) * 0.5f);
			VectorScale(vpn, 0.002 * r_refdef2.distanceScale, r_refdef2.outline_vpn);
			r_refdef2.outlineBase = 1 - DotProduct(r_origin, r_refdef2.outline_vpn);
		}
	}

	renderer.PreRenderView();

	return cls.state == ca_active;
}

//============================================================================

void V_Init (void) {
	Cmd_AddCommand ("v_cshift", V_cshift_f);	
	Cmd_AddCommand ("bf", V_BonusFlash_f);
	Cmd_AddCommand ("centerview", V_StartPitchDrift);
	Cmd_AddCommand ("force_centerview", Force_Centerview_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_VIEW);
	Cvar_Register (&v_centermove);
	Cvar_Register (&v_centerspeed);
	Cvar_Register (&cl_rollspeed);
	Cvar_Register (&cl_rollangle);
	Cvar_Register (&cl_rollalpha);

	Cvar_Register (&v_idlescale);
	Cvar_Register (&v_iyaw_cycle);
	Cvar_Register (&v_iroll_cycle);
	Cvar_Register (&v_ipitch_cycle);
	Cvar_Register (&v_iyaw_level);
	Cvar_Register (&v_iroll_level);
	Cvar_Register (&v_ipitch_level);
	Cvar_Register (&r_nearclip);

	Cvar_SetCurrentGroup(CVAR_GROUP_CROSSHAIR);
	Cvar_Register(&crosshaircolor);
	Cvar_Register(&crosshair);
	Cvar_Register(&crosshairsize);
	Cvar_Register(&cl_crossx);
	Cvar_Register(&cl_crossy);

	Cvar_SetCurrentGroup(CVAR_GROUP_VIEWMODEL);
	Cvar_Register(&cl_bob);
	Cvar_Register(&cl_bobcycle);
	Cvar_Register(&cl_bobup);
	Cvar_Register(&cl_bobhead);

	Cvar_Register(&cl_drawgun);
	Cvar_Register(&cl_drawgun_invisible);
	Cvar_Register(&r_viewmodelsize);
	Cvar_Register(&r_viewmodeloffset);
	Cvar_Register(&r_viewpreselgun);
	Cvar_Register(&r_viewlastfired);

	Cvar_SetCurrentGroup(CVAR_GROUP_VIEW);
	Cvar_Register (&v_kicktime);
	Cvar_Register (&v_kickroll);
	Cvar_Register (&v_kickpitch);
	Cvar_Register (&v_gunkick);


	Cvar_Register (&v_viewheight);


	Cvar_SetCurrentGroup(CVAR_GROUP_BLEND);

	Cvar_Register (&v_bonusflash);
	Cvar_Register (&v_contentblend);
	Cvar_Register (&v_damagecshift);
	Cvar_Register (&v_quadcshift);
	Cvar_Register (&v_suitcshift);
	Cvar_Register (&v_ringcshift);
	Cvar_Register (&v_pentcshift);
	Cvar_Register (&cl_demoplay_flash); // from QW262

	Cvar_Register(&v_dlightcshift);
	Cvar_Register(&v_dlightcolor);
	Cvar_Register(&v_dlightcshiftpercent);
	Cvar_Register(&gl_cshiftpercent);
	Cvar_Register(&gl_hwblend);
	Cvar_Register(&vid_hwgamma_fps);

	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register(&v_gamma);
	Cvar_Register(&v_contrast);

	// we do not need this after host initialized
	if (!host_initialized) {
		int i;
		float def_gamma = 1.0f;
		extern float vid_gamma;

		if ((i = COM_CheckParm(cmdline_param_client_gamma)) != 0 && i + 1 < COM_Argc()) {
			def_gamma = Q_atof(COM_Argv(i + 1));
			def_gamma = bound(0.3, def_gamma, 3);
			Cvar_SetDefaultAndValue(&v_gamma, def_gamma, def_gamma);
			vid_gamma = def_gamma;
		}
		else {
			vid_gamma = 1.0;
		}

		v_gamma.modified = true;
	}
	Cvar_ResetCurrentGroup();
}


================================================
FILE: src/cl_view.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

extern float v_blend[4];
void V_AddLightBlend (float r, float g, float b, float a2, qbool suppress_polyblend);

extern cvar_t v_gamma;
extern cvar_t v_contrast;

void V_Init (void);
void V_UpdatePalette (void);
void V_ParseDamage (void);
void V_SetContentsColor (int contents);
void V_CalcBlend (void);

float V_CalcRoll (vec3_t angles, vec3_t velocity);

void V_StartPitchDrift (void);
void V_StopPitchDrift (void);

void V_TF_ClearGrenadeEffects (void); // BorisU


================================================
FILE: src/client.h
================================================
/**
	\file

	\brief
	Main client structures
**/

/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: client.h,v 1.74 2007-10-12 00:08:42 cokeman1982 Exp $

*/
// client.h

#ifndef EZQUAKE_CLIENT_HEADER
#define EZQUAKE_CLIENT_HEADER

#if defined(_MSC_VER) && !defined(__attribute__)
#define __attribute__(A) /**/
#endif

#define MAXWEAPONS 10
#define MAX_ANTIROLLOVER_LEVELS 32

#define MAX_STATIC_SOUNDS 256
typedef struct
{
	vec3_t		org;
	int			sound_num;
	int			vol;
	int			atten;
} static_sound_t;

extern cvar_t cl_demospeed;
extern cvar_t cl_demoteamplay;

#define MVD_FILE_PLAYBACK   1
#define QTV_PLAYBACK        2           // cls.mvdplayback == QTV_PLAYBACK if QTV playback
#define ISPAUSED (cl.paused || (!cl_demospeed.value && cls.demoplayback && cls.mvdplayback != QTV_PLAYBACK && !cls.timedemo))
#define	MAX_PROJECTILES	32

typedef enum {
	skin_base,
	skin_base_teammate,
	skin_fb,
	skin_dead,
	skin_dead_teammate,
	skin_textures
} skin_texture_t;

#define MV_VIEWS 4

typedef struct 
{
	char            name[16];
	qbool           failedload;             // the name isn't a valid skin
	qbool           warned;                 // warning about falied to load was alredy printed
	int             width, height;          // this is valid for pcx too, but used for 32bit skins only
	int             bpp;                    // used in gl, bpp = 1 for pcx and 4 for 32bit skins
	texture_ref     texnum[skin_textures];  // texture num, used for 32bit skins, speed up
	byte*           cached_data;
} skin_t;

enum {
	dbg_antilag_rewind_present = 1,
	dbg_antilag_client_present = 2,
	dbg_antilag_position_set   = 4
};

// player_state_t is the information needed by a player entity
// to do move prediction and to generate a drawable entity
typedef struct 
{
	int			messagenum;		// All players won't be updated each frame.

	double		state_time;		// Not the same as the packet time,
								// Because player commands come asyncronously.
	usercmd_t	command;		// Last command for prediction.

	vec3_t		origin;
	vec3_t		viewangles;		// Only for demos, not from server.
	vec3_t		velocity;
	int			weaponframe;

	int			modelindex;
	int			frame;
	int			skinnum;
	int			effects;

	int			flags;			// Dead, gib, etc.

#ifdef FTE_PEXT_TRANS
	byte		alpha;
#endif
#ifdef FTE_PEXT_COLOURMOD
	byte		colourmod[3];
#endif

	byte		vw_index;
	byte		pm_type;
	float		waterjumptime;
	qbool		onground;
	qbool		jump_held;
	int			jump_msec;		// Fix bunny-hop flickering.

	vec3_t      current_origin; // current location (no antilag applied)
	vec3_t      rewind_origin;  // location antilag server has rewound to
	vec3_t      client_origin;  // location client rendered the player
	int         antilag_flags;  // bitmask: dbg_antilag_rewind_present | dbg_antilag_client_present
} player_state_t;

typedef enum {
	gender_unknown = 0,
	gender_male,
	gender_female,
	gender_neutral
} gender_id;

typedef struct player_info_s 
{
	int		userid;

	// Scoreboard information.
	char	name[MAX_SCOREBOARDNAME];
	char    shortname[MAX_SCOREBOARDNAME];           // used in tracker, when user wants to remove prefixes
	float	entertime;
	int		frags;
	int		ping;
	byte	pl;
	unsigned char spectator;

	// Skin information.
	unsigned char   topcolor;
	unsigned char   bottomcolor;
	qbool           teammate;

	unsigned char   _topcolor;
	unsigned char   _bottomcolor;
	qbool           _teammate;

	unsigned char   real_topcolor;
	unsigned char   real_bottomcolor;

	int    fps_msec;
	int    last_fps;
	int    fps;						// > 0 - fps, < 0 - invalid, 0 - collecting
	int    fps_frames;
	double fps_measure_time;
	qbool isnear;

	skin_t	*skin;

	qbool dead;
	qbool	skin_refresh;
	qbool	ignored;                // for ignore
	qbool   vignored;               // for voip-ignore

	// VULT DEATH EFFECT
	// Better putting the dead flag here instead of on the entity so whats dead stays dead
	int		stats[MAX_CL_STATS];
	byte	translations[VID_GRADES*256];
	char	userinfo[MAX_INFO_STRING];
	char	team[MAX_INFO_STRING];
	char	_team[MAX_INFO_STRING];
	int     known_team_color;

	// used for showing stack/health bar hud elements
	double  max_health_last_set;
	int     max_health;
	double  prev_health_last_set;
	int     prev_health;

	// authentication
	char	loginname[MAX_SCOREBOARDNAME];
	char    loginflag[8];
	int     loginflag_id;

	// extracted from userinfo
	int           chatflag;
	gender_id     gender;
} __attribute__((aligned(64))) player_info_t;


typedef struct 
{
	qbool		interpolate;
	vec3_t		origin;
	vec3_t		angles;
	int			oldindex;
} interpolate_t;


typedef struct 
{
	// Generated on client side.
	usercmd_t           cmd;                        // Cmd that generated the frame.
	double              senttime;                   // Time cmd was sent off.
	int                 delta_sequence;             // Sequence number to delta from, -1 = full update.
	int                 sentsize;

	// Received from server.
	double              receivedtime;               // Time message was received, or -1.
	player_state_t      playerstate[MAX_CLIENTS];   // Message received that reflects performing the usercmd.
	packet_entities_t   packet_entities;
	qbool               invalid;                    // True if the packet_entities delta was invalid
	int                 receivedsize;
	int                 seq_when_received;

	qbool               in_qwd;
} frame_t;

typedef struct centity_trail_s {
	vec3_t          stop;          // last position the trail was generated in
	double          lasttime;      // last time this trail generated a particle, or 0 if new
} centity_trail_t;

typedef struct 
{
	entity_state_t	baseline;
	entity_state_t	current;

	vec3_t			lerp_origin;

	vec3_t			velocity; // hack

	vec3_t			old_origin;
	vec3_t			old_angles;
	int				oldframe;

	int				sequence;
	int				oldsequence;

	double			startlerp;
	double			deltalerp;
	double			frametime;

	int				old_vw_index;	// player entities only
	int				old_vw_frame;	// player entities only

	int             contents;

	centity_trail_t trails[4];
	float           particle_emittime;
	int             trail_number;   // this changes as trails are killed and entity re-used (can be used to detect reset)
	int             corona_id;
} centity_t;

typedef struct 
{
	int		destcolor[3];
	float	percent;		// 0-256
} cshift_t;

#define	CSHIFT_CONTENTS	0
#define	CSHIFT_DAMAGE	1
#define	CSHIFT_BONUS	2
#define	CSHIFT_POWERUP	3
#define	NUM_CSHIFTS		4


// clientState_t should hold all pieces of the client state

#define	MAX_DLIGHTS			32
#define	MAX_STYLESTRING		64

typedef enum {lt_default, lt_muzzleflash, lt_explosion, lt_rocket,
	lt_red, lt_blue, lt_redblue, lt_green, lt_redgreen, lt_bluegreen,
	lt_white, lt_custom, NUM_DLIGHTTYPES } dlighttype_t;

typedef struct {
	int				key;				// so entities can reuse same entry
	vec3_t			origin;
	float			radius;
	float			die;				// stop lighting after this time
	float			decay;				// drop this each second
	float			minlight;			// don't add when contributing less
	int				bubble;				// non zero means no flashblend bubble
	dlighttype_t	type;
	byte			color[3];			// use such color if type == lt_custom
	byte unused[3];
} dlight_t;

typedef struct customlight_s {
	dlighttype_t    type;
	byte            color[3];           // use such color if type == lt_custom
	byte            alpha;
} customlight_t;

typedef struct {
	int		length;
	char	map[MAX_STYLESTRING];
} lightstyle_t;

#define	MAX_STATIC_ENTITIES	2048		// torches, etc
#define	MAX_DEMOS			8
#define	MAX_DEMONAME		16

typedef enum {
ca_disconnected, 	// full screen console with no connection
ca_demostart,		// starting up a demo
ca_connected,		// netchan_t established, waiting for svc_serverdata
ca_onserver,		// processing data lists, donwloading, etc
ca_active			// everything is in, so frames can be rendered
} cactive_t;

typedef enum 
{
	dl_none,
	dl_model,
	dl_vwep_model,
	dl_sound,
	dl_skin,
	dl_single
} dltype_t;		// download type

typedef enum demoseekingtype_e
{
	DST_SEEKING_NONE = 0,         ///< seeking nothing
	DST_SEEKING_NORMAL = 1,       ///< demo_jump seeking
	DST_SEEKING_DEMOMARK,         ///< demo_jump_mark seeking
	DST_SEEKING_STATUS,           ///< demo_jump_status seeking
	DST_SEEKING_FOUND,            ///< mark/status seeking, hint that we are done and should stop seeking
	DST_SEEKING_END,              ///< demo_jump_end seeking (intermission or 1 second before end)
	DST_SEEKING_FOUND_NOREWIND,   ///< mark/status seeking, no automatic rewind
} demoseekingtype_t;

typedef enum
{
	DEMOSEEKINGSTATUS_MATCH_EQUAL,
	DEMOSEEKINGSTATUS_MATCH_NOT_EQUAL,
	DEMOSEEKINGSTATUS_MATCH_LESS_THAN,
	DEMOSEEKINGSTATUS_MATCH_GREATER_THAN,
	DEMOSEEKINGSTATUS_MATCH_BIT_ON,
	DEMOSEEKINGSTATUS_MATCH_BIT_OFF
} demoseekingstatus_matchtype_t;

typedef struct demoseekingstatus_condition_s demoseekingstatus_condition_t;

struct demoseekingstatus_condition_s {
	demoseekingstatus_matchtype_t	type;
	int		stat;
	int		value;
	demoseekingstatus_condition_t *or;
	demoseekingstatus_condition_t *and;
};

typedef struct {
	qbool		non_matching_found; // whether a non matching frame has been found yet
	demoseekingstatus_condition_t *conditions;
} demoseekingstatus_t;

#define TIMEDEMO_OFF      0
#define TIMEDEMO_CLASSIC  1
#define TIMEDEMO_FIXEDFPS 2

#define TIMEDEMO_FIXEDFPS_DEFAULT (308)
#define TIMEDEMO_FIXEDFPS_MINIMUM (20)
#define TIMEDEMO_FIXEDFPS_MAXIMUM (10000)

typedef struct {
	double last_snapshot_time;
	double last_run_time;
	double lastfps_value;
	double lastframetime_value;
	double time_of_last_minfps_update;
	double time_of_last_maxframetime_update;
	int fps_count;
} perfinfo_t;

/// A structure that is persistent through an arbitrary number of server connections.
typedef struct
{
	/// Connection information.
	cactive_t	state;

	//
	// Time vars.
	//
	int         framecount;       ///< Incremented every frame, never reset.
	double      realtime;         ///< Scaled by cl_demospeed.
	double      demotime;         ///< Scaled by cl_demospeed, reset when starting a demo.
	double      demo_rewindtime;  ///< The time that we should jump to when rewinding.
	double      trueframetime;    ///< Time since last frame.
	double      frametime;        ///< Time since last frame, scaled by cl_demospeed.
	double      demopackettime;   ///< Timestamp of current demo packet, whether seeking or not

	//
	// Network stuff.
	//
	netchan_t	netchan;
	char		servername[MAX_OSPATH];	///< name of server from original connect
	int			qport;
	netadr_t	server_adr;
	int socketip;

	//
	// Variables related to client cmds aka clc_stringcmd, unreliable part, reliable part goes to cls.netchan.message
	//

	byte		cmdmsg_data[1024];		///< have no idea which size here must be
	sizebuf_t	cmdmsg;

	// TCPCONNECT
	int			sockettcp;
	netadr_t	sockettcpdest;
	byte		tcpinbuffer[1500];
	int 		tcpinlen;

	//
	// Private userinfo for sending to masterless servers
	//
	char		userinfo[MAX_INFO_STRING];

	//
	// On a local server these may differ from com_gamedirfile and com_gamedir.
	//
	char		gamedirfile[MAX_QPATH];
	char		gamedir[MAX_OSPATH];

	//
	// Download vars.
	//
	FILE		*download;				///< file transfer from server
	char		downloadtempname[MAX_PATH];
	char		downloadname[MAX_PATH];
	int			downloadnumber;
	dltype_t	downloadtype;
	int			downloadpercent;
	int			downloadrate;
	double		downloadstarttime;
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	enum {DL_NONE = 0, DL_QW, DL_QWCHUNKS} downloadmethod;
#else
	enum {DL_NONE = 0, DL_QW             } downloadmethod;
#endif

#ifdef PROTOCOL_VERSION_FTE
	unsigned int fteprotocolextensions; ///< the extensions we told the server that we support.
#endif
#ifdef PROTOCOL_VERSION_FTE2
	unsigned int fteprotocolextensions2; ///< the extensions we told the server that we support.
#endif
#ifdef PROTOCOL_VERSION_MVD1
	unsigned int mvdprotocolextensions1;
#endif

	//
	// Upload vars.
	//
	FILE		*upload;
	char		uploadname[MAX_OSPATH];
	int			uploadpercent;
	int			uploadrate;
	qbool		is_file;
	byte		*mem_upload;
	int			upload_pos;
	int			upload_size;

	//
	// Demo recording info must be here, because record
	// is started before entering a map (and clearing clientState_t)
	//
	qbool       demorecording;
	qbool       demoplayback;
	demoseekingtype_t demoseeking;
	demoseekingstatus_t demoseekingstatus;
	qbool       demorewinding;
	char        demoname[MAX_PATH];
	qbool       nqdemoplayback;
	int         timedemo;
	double      td_lastframe;              ///< To meter out one message a frame.
	int         td_startframe;             ///< cls.framecount at start
	double      td_starttime;              ///< Realtime at second frame of timedemo.
	double      td_frametime;              ///< frametime for stop-motion timedemo (timedemo2)
	int         td_frametime_stats[1000];  ///< keep track of performance (to 0.1ms level, if it's over 100ms we're in bad shape)
	int         td_frametime_max;          ///< worse ms score so far
	int         td_frametime_max_frame;    ///< which frame# did we get that on?
	double      td_nonrendering;           ///< time not in the rendering hot loop

	qbool		mvdrecording;		///< this is not real mvd recording, but just cut particular moment of mvd stream

	sizebuf_t	demomessage;

	double      fps;
	double      min_fps;
	double      avg_frametime;
	double      max_frametime;

	// FPS stats for performance info
	perfinfo_t  fps_stats;

	int			challenge;

	float		latency;			///< Rolling average

	int			mvdplayback;		///< 0 = Not playing MVD; 1 = Playing MVD; 2 = Playing QTV
	float		qtv_svversion;		///< version of qtvsv/proxy, note it float
	int			qtv_ezquake_ext;	///< qtv ezquake extensions supported by qtvsv/proxy
	qbool		qtv_donotbuffer;	///< do not try buffering even if not enough data
	char        qtv_source[128];    ///< last qtv source sent (so we can re-send with challenge response)

	/// \brief Tells which players are affected by a demo message.
	///	- If multiple players are affected (dem_multiple) this will be a
	///	  bit mask containing which players the last demo message relates to. (32-bits, 32 players)
	///	- If only a single player should receive the message (dem_single),
	///	  this is a a 5-bit number containing the player number. (2^5 = 32 unique player numbers)
	int			lastto;			

	int			lasttype;		///< The type of the last demo message.
	qbool		findtrack;

	// authenticating via web server
	char        auth_logintoken[128];
} clientPersistent_t;

extern clientPersistent_t	cls;

typedef struct antilag_pos_s {
	vec3_t      pos;
	qbool       present;
	vec3_t      clientpos;
	qbool       clientpresent;
} antilag_pos_t;

typedef struct antilag_stats_s {
	double      client_rewind_distance;
	double      client_rewind_samples;
} antilag_stats_t;

// cl.paused flags

#define PAUSED_SERVER		1
#define PAUSED_DEMO			2

#define MAX_DAMAGE_NOTIFICATION_TIME 1.5
#define MAX_DAMAGE_NOTIFICATIONS 15 // ((int)(10 * MAX_DAMAGE_NOTIFICATION_TIME))

typedef struct scr_damage_s {
	char text[64];
	double time;
	vec3_t origin;
	vec3_t offset;
	float vel[2];

	// position on screen
	float x, y;
	qbool visible;
} scr_damage_t;

/// a structure that is wiped completely at every server signon
typedef struct {
	int			servercount;		///< server identification for prespawns

	char		serverinfo[MAX_SERVERINFO_STRING];

	int			protoversion;
	// some important serverinfo keys are mirrored here:
	int			deathmatch;
	int			teamplay;
	int			gametype;			///< GAME_COOP or GAME_DEATHMATCH
	qbool		teamfortress;		///< true if gamedir is "fortress"
	int			fpd;				///< FAQ proxy flags
	int			z_ext;				///< ZQuake protocol extensions flags
	qbool		vwep_enabled;
	int			timelimit;
	int			fraglimit;
	float		maxfps;
	float		minpitch;
	float		maxpitch;

	int			last_fps;

	int			parsecount;			///< server message counter
	int			oldparsecount;
	int         parsecountmod;
	double      parsecounttime;


	int			validsequence;		///< this is the sequence number of the last good
									///< packetentity_t we got.  If this is 0, we can't
									///< render a frame yet
	int			oldvalidsequence;
	int			delta_sequence;		///< sequence number of the packet we can request
									///< delta from

	int			spectator;

	double		last_ping_request;	///< while showing scoreboard

	// sentcmds[cl.netchan.outgoing_sequence & UPDATE_MASK] = cmd
	frame_t		frames[UPDATE_BACKUP];

	// information for local display
	int			stats[MAX_CL_STATS];///< health, etc
	float		item_gettime[32];	///< cl.time of acquiring item, for blinking
	float		faceanimtime;		///< use anim frame if cl.time < this
	float		hurtblur;			///< blur view caused by damage

	cshift_t	cshifts[NUM_CSHIFTS];	///< color shifts for damage, powerups and content types

	// the client maintains its own idea of view angles, which are
	// sent to the server each frame.  And only reset at level change
	// and teleport times
	vec3_t		viewangles;

	// the client simulates or interpolates movement to get these values
	double		time;				// this is the time value that the client
									// is rendering at.  always <= realtime

	double		servertime;
	qbool		servertime_works;	///< Does the server actually send STAT_TIME/svc_time?
	double		gametime;			///< match duration
	double		gamestarttime;		///< this gets saved on match start
	double		gamepausetime;		///< this gets increased during the pause


	vec3_t		simorg;
	vec3_t		simvel;
	vec3_t		simangles;

	// pitch drifting vars
	float		pitchvel;
	qbool		nodrift;
	float		driftmove;
	double		laststop;

	qbool		onground;
	float		crouch;				///< local amount for smoothing stepups
//	float		viewheight;			///< removed, since it does not work well in case of MVD, search for cl.stats[STAT_VIEWHEIGHT] instead.

	qbool		paused;				///< a combination of PAUSED_SERVER and PAUSED_DEMO flags

	float		ideal_punchangle;	///< temporary view kick from weapon firing
	float		punchangle;			///< drifts towards ideal_punchangle
	float		rollangle;			///< smooth out rollangle changes when strafing

	int			intermission;		///< don't change view angle, full screen, etc
	int			completed_time;		///< latched from time at intermission start
	int			solo_completed_time;///< to draw on intermission screen

	// information that is static for the entire time connected to a server
	char		model_name[MAX_MODELS][MAX_QPATH];
	char		vw_model_name[MAX_VWEP_MODELS][MAX_QPATH];	///< VWep support
	char		sound_name[MAX_SOUNDS][MAX_QPATH];

	struct model_s	*model_precache[MAX_MODELS];
	struct model_s	*vw_model_precache[MAX_VWEP_MODELS];	///< VWep support
	struct sfx_s	*sound_precache[MAX_SOUNDS];

	cmodel_t	*clipmodels[MAX_MODELS];
	unsigned	map_checksum2;

	static_sound_t	static_sounds[MAX_STATIC_SOUNDS];
	int			num_static_sounds;

	char		levelname[40];		///< for display on solo scoreboard
	int			playernum;
	int			viewplayernum;		///< either playernum or spec_track (in chase camera mode)

	// refresh related state
	struct model_s	*worldmodel;	///< cl_entitites[0].model
	struct efrag_s	*free_efrags;
	int			num_statics;		///< stored top down in cl_entities

	int			cdtrack;			///< cd audio

	centity_t viewent[MV_VIEWS];	        // weapon models

	// all player information
	player_info_t	players[MAX_CLIENTS];

	// sprint buffer
	int			sprint_level;
	wchar		sprint_buf[2048];

	// localized movement vars
	float		entgravity;
	float		maxspeed;
	float		bunnyspeedcap;

	int			waterlevel;


	double		whensaid[10];       ///< For floodprots
 	int			whensaidhead;       ///< Head value for floodprots


	qbool		standby;
	qbool		countdown;
	qbool		userfb;
	int			minlight;

	interpolate_t	int_projectiles[MAX_PROJECTILES];

	int         last_armor_pickup;
	int         last_weapon_pickup;
	int         last_ammo_pickup;

	float       mvd_time_offset;
	int         mvd_user_cmd[8];
	float       mvd_user_cmd_time[8];

	qbool       racing;
	int         race_pacemaker_ent;

	float       fakeshaft_policy;

	int         sv_maxclients;

	int         cif_flags;

	int         scoring_system;

	char        fixed_team_names[4][16];
	qbool       mvd_ktx_markers;

	// r_viewmodellastfired
	int         lastfired;
	int         lastviewplayernum;

	// Weapon preferences
	int         weapon_order[MAXWEAPONS];
	int         weapon_order_clientside[MAXWEAPONS];
	int         weapon_order_sequence_set;
	qbool       weapon_order_use_clientside;

	// anti-rollover weapon firing
	int         ar_weapon_orders[MAX_ANTIROLLOVER_LEVELS][MAXWEAPONS];
	int         ar_keycodes[MAX_ANTIROLLOVER_LEVELS];
	int         ar_count;

	// When teamlock 1 is specified, lock in the selected team and don't change again
	char        teamlock1_teamname[16];

	// authenticating via web server
	char        auth_challenge[128];

	// camera tracking
	int         autocam;              // CAM_NONE or CAM_TRACK
	int         spec_track;           // player# of who we are tracking
	int         ideal_track;          // The currently tracked player.
	qbool       spec_locked;          // Is the spectator locked to a players view or free flying.

	// antilag debug playback
	antilag_pos_t antilag_positions[MAX_CLIENTS];
	antilag_stats_t antilag_stats[MAX_CLIENTS];

	// demoinfo (stats file embedded in demo)
	int         demoinfo_blocknumber;
	int         demoinfo_bytes;

	// damage notifications
	scr_damage_t damage_notifications[MAX_DAMAGE_NOTIFICATIONS];

	// fog info read from worldspawn
	vec3_t map_fog_color;
	float map_fog_density;
	qbool map_fog_enabled;
	float map_fog_sky;

	// sv_safestrafe client-side prediction
	struct {
		int      pending_frames;    // Frames of forced stop remaining
		float    pending_direction; // Desired sidemove after stop
		int      stop_frames;       // Accumulated frames with sidemove=0
		float    last_sidemove;     // Previous frame's sidemove value
	} safestrafe;
} clientState_t;

#define SCORING_SYSTEM_DEFAULT   0
#define SCORING_SYSTEM_STANDARD  1
#define SCORING_SYSTEM_TEAMFRAGS 2

extern	clientState_t	cl;

typedef enum visentlist_entrytype_s {
	visent_outlines,
	visent_firstpass,
	visent_normal,
	visent_alpha,
	visent_shells,
	visent_additive,

	visent_max
} visentlist_entrytype_t;

typedef struct visentity_s {
	entity_t    ent;
	modtype_t   type;
	float       distance;

	qbool       draw[visent_max];
} visentity_t;

#define MAX_STANDARD_ENTITIES 2048

typedef struct visentlist_s {
	visentity_t list[MAX_STANDARD_ENTITIES];
	int         count;

	int         typecount[visent_max];
} visentlist_t;

extern visentlist_t cl_visents;

// ezQuake cvars
extern cvar_t cl_floodprot;
extern cvar_t cl_fp_messages;
extern cvar_t cl_fp_persecond;
extern cvar_t cl_cmdline;
extern cvar_t b_switch;     // added for the sake of menu.c
extern cvar_t w_switch;     // added for the sake of menu.c
extern cvar_t gender;       // added for the sake of menu.c

extern cvar_t  cl_mediaroot;

// Multiview cvars
extern cvar_t cl_multiview;
extern cvar_t cl_mvdisplayhud;
extern cvar_t cl_mvhudpos;
extern cvar_t cl_mvhudvertical;
extern cvar_t cl_mvhudflip;
extern cvar_t cl_mvinset;
extern cvar_t cl_mvinsetcrosshair;
extern cvar_t cl_mvinsethud;

extern cvar_t r_rocketlight;
extern cvar_t r_rocketlightcolor;
extern cvar_t r_explosionlightcolor;
extern cvar_t r_explosionlight;
extern cvar_t r_explosiontype;
extern cvar_t r_flagcolor;
extern cvar_t r_lightflicker;
extern cvar_t r_lightmap_lateupload;
extern cvar_t r_lightmap_packbytexture;
extern cvar_t r_telesplash;
extern cvar_t r_shaftalpha;

extern cvar_t cl_restrictions;

// ZQuake cvars
extern cvar_t	cl_warncmd;
extern	cvar_t	cl_shownet;
extern	cvar_t	cl_sbar;
extern	cvar_t	cl_hudswap;
extern	cvar_t	cl_deadbodyfilter;
extern	cvar_t	cl_gibfilter;
extern  cvar_t  cl_backpackfilter;
extern	cvar_t	cl_muzzleflash;
extern	cvar_t	cl_fakeshaft;
extern	cvar_t	cl_fakeshaft_extra_updates;

extern cvar_t r_rockettrail;
extern cvar_t r_grenadetrail;
extern cvar_t r_railtrail;
extern cvar_t r_instagibtrail;

extern cvar_t r_powerupglow;

// FIXME, allocate dynamically
extern	centity_t        cl_entities[CL_MAX_EDICTS];
extern	entity_t         cl_static_entities[MAX_STATIC_ENTITIES];
extern	lightstyle_t     cl_lightstyle[MAX_LIGHTSTYLES];
extern	dlight_t         cl_dlights[MAX_DLIGHTS];
extern  unsigned int     cl_dlight_active[MAX_DLIGHTS/32];       

extern byte		*host_basepal;
extern byte		*host_colormap;

//=============================================================================

// cl_main

void CL_Init (void);
void CL_ClearState (void);
void CL_BeginServerConnect(void);
void CL_Disconnect (void);
void CL_Disconnect_f (void);
void CL_Reconnect_f (void);
qbool CL_ConnectedToProxy(void);
void CL_MakeActive(void);

extern char emodel_name[], pmodel_name[];

// cl_cmd
typedef struct {
	qbool forward, back, left, right, jump, attack, up, down;
} usermainbuttons_t;
void CL_PrintQStatReply (char *s);
// returns last button user pressed
usermainbuttons_t CL_GetLastCmd (int player_slot);

// cl_nqdemo.c
void NQD_StartPlayback (void);
void NQD_LinkEntities (void);
void NQD_ReadPackets (void);
void NQD_SetSpectatorFlags (void);

// cl_demo.c
qbool CL_GetDemoMessage (void);
void CL_WriteDemoCmd (usercmd_t *pcmd);
void CL_WriteDemoMessage (sizebuf_t *msg);
void CL_WriteDemoEntities (void);
void CL_WriteServerdata (sizebuf_t *msg);
void CL_StopPlayback (void);
void CL_Stop_f (void);
void CL_CheckQizmoCompletion(void);
void CL_Demo_Jump(double seconds, int relative, demoseekingtype_t seeking);
void CL_Demo_Init(void);
void CL_Demo_Jump_Status_Check (void);
void CL_Demo_Check_For_Rewind(float nextdemotime);
void CL_Demo_Stop_Rewinding(void);
double Demo_GetSpeed(void);
void Demo_AdjustSpeed(void);
qbool CL_IsDemoExtension(const char *filename);
qbool CL_Demo_SkipMessage(qbool skip_if_seeking);
qbool CL_Demo_NotForTrackedPlayer(void);
qbool CL_DemoExtensionMatch(const char* path);

void CL_AutoRecord_StopMatch(void);
void CL_AutoRecord_CancelMatch(void);
void CL_AutoRecord_StartMatch(char *demoname);
qbool CL_AutoRecord_Status(void);
void CL_AutoRecord_SaveMatch(void);

qbool SCR_QTVBufferToBeDrawn(int options);
int Demo_BufferSize(int* ms);

extern double demostarttime;
extern double nextdemotime, olddemotime;

// cl_parse.c
#define NET_TIMINGS 256
#define NET_TIMINGSMASK 255
extern int	packet_latency[NET_TIMINGS];

// advanced network stats

#define  NETWORK_STATS_SIZE  512    // must be power of 2
#define  NETWORK_STATS_MASK  (NETWORK_STATS_SIZE-1)

typedef  enum{packet_ok, packet_dropped, packet_choked,
              packet_delta, packet_netlimit}  packet_status;

typedef struct packet_info_s
{
    packet_status   status;

    double          senttime;
    double          receivedtime;

    int             sentsize;
    int             receivedsize;

    int             seq_diff;   // frames elapsed between send and recv

    qbool        delta;  // if deltaying
}
packet_info_t;

extern packet_info_t network_stats[NETWORK_STATS_SIZE];

typedef struct net_stat_result_s
{
    int samples;    // samples processed to calculate stats

    // latency [miliseconds]
    float ping_min;
    float ping_avg;
    float ping_max;
    float ping_dev;

    // latency [frames]
    int   ping_f_min;
    int   ping_f_max;
    float ping_f_avg;
    float ping_f_dev;

    // packet loss [percent]
    float lost_lost;
    float lost_rate;
    float lost_delta;
    float lost_netlimit;

    // average packet sizes [bytes]
    float size_in;
    float size_out;

    // bandwidth [bytes / sec]
    float bandwidth_in;
    float bandwidth_out;

    // if delta compression occured
    int delta;

} net_stat_result_t;

int CL_CalcNetStatistics(
            float period,           // [IN] period of time
            packet_info_t *samples, // [IN] statistics table
            int num_samples,        // [IN] table size
            net_stat_result_t *res); // [OUT]

int CL_CalcNet (void);
void CL_ParseServerMessage (void);
void CL_NewTranslation (int slot);
qbool CL_CheckOrDownloadFile (char *filename);
qbool CL_IsUploading(void);
void CL_NextUpload(void);
void CL_StartUpload (byte *data, int size);
void CL_StopUpload(void);
void CL_StartFileUpload(void);

void CL_ParseClientdata (void);

void CL_FinishDownload(void);

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS

void	CL_ParseChunkedDownload(void);
void	CL_Parse_OOB_ChunkedDownload(void);
int		CL_RequestADownloadChunk(void);
void	CL_SendChunkDownloadReq(void);

#endif // FTE_PEXT_CHUNKEDDOWNLOADS

// cl_tent.c
void CL_InitTEnts (void);
void CL_InitTEntsCvar(void);
void CL_ClearTEnts (void);
void CL_ParseTEnt (void);
void CL_ExplosionSprite (vec3_t);
void CL_ClearPlayerBeams(void);
void CL_UpdateTEnts(void);

// cl_ents.c
typedef enum cl_modelindex_s {
	mi_spike, mi_player, mi_eyes, mi_flag, mi_tf_flag, mi_tf_stan, mi_stag, mi_basrkey, mi_basbkey, mi_w_s_key, mi_w_g_key, mi_b_g_key, mi_b_s_key, mi_ff_flag, mi_harbflag, mi_princess, mi_explod1, mi_explod2, mi_h_player,
	mi_gib1, mi_gib2, mi_gib3, mi_rocket, mi_grenade, mi_bubble,
	mi_vaxe, mi_vbio, mi_vgrap, mi_vknife, mi_vknife2, mi_vmedi, mi_vspan,
	mi_flame,	//joe: for changing flame/flame0 models
	mi_monster1,mi_m2,mi_m3,mi_m4,mi_m5,mi_m6,mi_m7,mi_m8,mi_m9,mi_m10,mi_m11,mi_m12,
	mi_m13, mi_m14, mi_m15, mi_m16, mi_m17,
	mi_weapon1, mi_weapon2, mi_weapon3, mi_weapon4, mi_weapon5, mi_weapon6, mi_weapon7, mi_weapon8,
	cl_num_modelindices,
} cl_modelindex_t;

extern int cl_modelindices[cl_num_modelindices];
extern char *cl_modelnames[cl_num_modelindices];

void CL_InitEnts(void);
void CL_AddEntity (entity_t *ent);
void CL_ClearScene (void) ;
void CL_AddParticleTrail(entity_t* ent, centity_t* cent, customlight_t* cst_lt, entity_state_t *state);

dlighttype_t dlightColor(float f, dlighttype_t def, qbool random);
customlight_t *dlightColorEx(float f, char *str, dlighttype_t def, qbool random, customlight_t *l);

dlight_t *CL_AllocDlight (int key);
void CL_NewDlight (int key, vec3_t origin, float radius, float time, dlighttype_t type, int bubble);
void CL_NewDlightEx (int key, vec3_t origin, float radius, float time, customlight_t *l, int bubble);
void CL_DecayLights (void);

void CL_SetSolidPlayers (int playernum);
void CL_SetUpPlayerPrediction(qbool dopred);
void CL_EmitEntities (void);
void CL_ClearProjectiles (void);
void CL_ParsePacketEntities (qbool delta);
void CL_SetSolidEntities (void);
void CL_ParsePlayerinfo (void);
void CL_StorePausePredictionLocations(void);


void MVD_Interpolate(void);
void CL_ClearPredict(void);
void CL_ParseProjectiles(qbool indexed);


// cl_pred.c
void CL_InitPrediction(void);
void CL_PredictMove(qbool physframe);
void CL_PredictUsercmd(player_state_t *from, player_state_t *to, usercmd_t *u);
void CL_DisableLerpMove(void);

// cl_cam.c
void vectoangles(vec3_t vec, vec3_t ang);
#define CAM_NONE	0
#define CAM_TRACK	1

int WhoIsSpectated (void);
void CL_Cam_SetKiller(int killernum, int victimnum);
void Cam_Angles_Set(float pitch, float yaw, float roll);
void Cam_Pos_Set(float x, float y, float z);

qbool Cam_DrawViewModel (void);
qbool Cam_DrawPlayer (int playernum);
void Cam_Track (usercmd_t *cmd);
void Cam_FinishMove (usercmd_t *cmd);
void Cam_Reset (void);
void Cam_SetViewPlayer (void);
void CL_InitCam (void);
void Cam_TryLock (void);

int Cam_TrackNum(void);
void Cam_Lock(int playernum);

// skin.c
void Skin_Skins_f(void);
void Skin_Clear(qbool download);
void Skin_AllSkins_f(void);
void Skin_NextDownload(void);
void Skin_ShowSkins_f(void);
void Skins_PreCache(void);
void Skin_InvalidateTextures(void);
void Skin_UserInfoChange(int slot, player_info_t* player, const char* key);
void Skin_RegisterCvars(void);

// match_tools.c
void MT_Init(void);
void MT_Frame(void);
void MT_Disconnect(void);
void MT_NewMap(void);
char *MT_MatchName(void);
char *MT_ShortStatus(void);
void MT_Shutdown(void);

// fragstats.c

void Stats_Init(void);
void Stats_Reset(void);
void Stats_NewMap(void);
void Stats_EnterSlot(int num);
void Stats_ParsePrint(char *s, int level, cfrags_format *cff);
void Stats_Shutdown(void);

qbool Stats_IsActive(void);
qbool Stats_IsFlagsParsed(void);
void Stats_GetBasicStats(int num, int *stats);
void Stats_GetFlagStats(int num, int *stats);

#define RSSHOT_WIDTH 320
#define RSSHOT_HEIGHT 200

void CL_CalcPlayerFPS(player_info_t *info, int msec);

qbool CL_DrawnPlayerPosition(int player_num, float* pos, int* msec);

//
// Multiview vars
// ===================================================================================
void CL_MultiviewInitialise (void);
void CL_MultiviewTrackingAdjustment (int adjustment);

// Status
qbool CL_MultiviewEnabled (void);
qbool CL_MultiviewInsetEnabled (void);
qbool CL_MultiviewInsetView (void);
int CL_MultiviewNumberViews (void);
int CL_MultiviewActiveViews (void);
int CL_MultiviewCurrentView (void);
int CL_MultiviewNextPlayer (void);
int CL_MultiviewAutotrackSlot (void);
int CL_MultiviewMainView(void);
void CL_MultiviewInsetSetScreenCoordinates(int x, int y, int width, int height);

void CL_MultiviewSetTrackSlot (int trackNum, int player);
void CL_MultiviewResetCvars (void);

// Events
void CL_MultiviewFrameStart (void);
void CL_MultiviewPreUpdateScreen (void);
qbool CL_MultiviewAdvanceView (void);
void CL_MultiviewFrameFinish (void);
void CL_MultiviewDemoStart (void);
void CL_MultiviewDemoFinish (void);
void CL_MultiviewDemoStartRewind (void);
void CL_MultiviewDemoStopRewind (void);

// Restore stats for main view hud
void CL_MultiviewInsetRestoreStats(void);

// Weapons
centity_t* CL_WeaponModelForView(void);

// ===================================================================================
// client side min_ping aka delay

extern cvar_t cl_delay_packet;
extern cvar_t cl_delay_packet_target;
extern cvar_t cl_delay_packet_dev;

#define CL_MAX_DELAYED_PACKETS 16 /* 13 * 16 = 208 ms, should be enough */
#define CL_MAX_PACKET_DELAY 75 /* total delay two times more */
#define CL_MAX_PACKET_DELAY_DEVIATION 5
#define CL_MAX_PACKET_DELAY_TARGET 155

typedef struct cl_delayed_packet_s
{
	byte data[MSG_BUF_SIZE]; // packet data, perhaps we can/should use [MAX_MSGLEN + PACKET_HEADER]
	int length; // how much data we actually have in data[]
	netadr_t addr; // to/from

	double time; // when we should read/send this packet

} cl_delayed_packet_t;

qbool CL_QueInputPacket(void);
qbool CL_UnqueOutputPacket(qbool sendall);
void CL_ClearQueuedPackets(void);

// ===================================================================================

// Sound
#ifdef FTE_PEXT2_VOICECHAT
void S_Voip_Transmit(unsigned char clc, sizebuf_t *buf);
qbool S_Voip_ShowMeter(int* x, int* y);
qbool S_Voip_Speaking (unsigned int player);
void S_Capture_Shutdown(void);
int S_Voip_Loudness(void);
void S_Voip_MapChange(void);
void S_Voip_Parse(void);
void S_Voip_Ignore(unsigned int slot, qbool ignore);
float S_VoipVoiceTransmitVolume(void);
#else
#define S_Voip_ShowMeter(x, y) false
#define S_Voip_Speaking(x) false
#define S_Voip_Loudness() (0)
#define S_VoipVoiceTransmitVolume() (1)
#endif

// KTX
#define KTX_RACING_PLAYER_MIN_DISTANCE 24.0f
#define KTX_RACING_PLAYER_MAX_DISTANCE 256.0f
#define KTX_RACING_PLAYER_ALPHA_SCALE  512.0f

// Player Dead?
#define ISDEAD(i) ( (i) >= 41 && (i) <= 102 )

// Screenshot queue
typedef enum image_format_s {IMAGE_PCX, IMAGE_TGA, IMAGE_JPEG, IMAGE_PNG} image_format_t;

typedef struct scr_sshot_target_s {
	char fileName[128];
	byte* buffer;
	qbool freeMemory;
	qbool movie_capture;
	size_t width;
	size_t height;
	image_format_t format;
} scr_sshot_target_t;

int SCR_ScreenshotWrite(scr_sshot_target_t* target_params);

qbool Movie_AnimatedPNG(void);

qbool Movie_BackgroundCapture(scr_sshot_target_t* params);
byte* Movie_TempBuffer(size_t width, size_t height);
qbool Movie_BackgroundInitialise(void);
void Movie_BackgroundShutdown(void);

void Cache_Flush(void);

#define DEFAULT_CHAT_SOUND "misc/talk.wav"

#ifdef WITH_RENDERING_TRACE
void Dev_VidFrameStart(void);
void Dev_VidFrameTrace(void);
void Dev_VidTextureDump(void);
void Dev_TextureList(void);
#endif

// weapons scripts
int IN_BestWeapon(qbool rendering_only);
int IN_BestWeaponReal(qbool rendering_only);

// hud_common.c
void CL_RemovePrefixFromName(int player);

#endif // EZQUAKE_CLIENT_HEADER


================================================
FILE: src/cmd.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: cmd.c,v 1.92 2007-10-28 02:45:19 qqshka Exp $
*/

#ifndef _WIN32
#include <strings.h>
#endif

#include "quakedef.h"
#include "gl_model.h"
#include "teamplay.h"
#include "rulesets.h"
#include "tp_triggers.h"
#include "parser.h"
#include "utils.h"
#include "keys.h"
#include "hash.h"
#include <pcre2.h>

typedef struct {
	char name[MAX_MACRO_NAME];
	char *(*func) (void);
	int teamplay;
} macro_command_t;

#define MACRO_DEF(x) { #x, NULL, 0 }

static macro_command_t macro_commands[num_macros] = {
#include "macro_ids.h"
};

#undef MACRO_DEF

qbool CL_CheckServerCommand (void);

static void Cmd_ExecuteStringEx (cbuf_t *context, char *text);
static int gtf = 0; // global trigger flag

cvar_t cl_warncmd = {"cl_warncmd", "1"};

cvar_t cl_warnexec = {"cl_warnexec", "1"};
cvar_t cl_curlybraces = {"cl_curlybraces", "0"};

#define REMOTE_CAPABILITIES "+attack,-attack,alias,bf,changing,cmd,color,download,exec,fullserverinfo," \
				"impulse,infoset,ktx_infoset,ktx_sinfoset,nextul,on_admin,on_connect," \
				"on_connect_ctf,on_connect_ffa,on_enter,on_enter_ctf,on_enter_ffa,on_matchend," \
				"on_matchstart,on_observe,on_observe_ctf,on_observe_ffa,on_spec_enter," \
				"on_spec_enter_ctf,on_spec_enter_ffa,on_spec_matchend,on_spec_matchstart," \
				"on_unadmin,packet,play,rate,reconnect,say,sinfoset,skin,skins,team,tempalias," \
				"track,wait"

static void OnChange_remote_capabilities(cvar_t *var, char *string, qbool *cancel);
cvar_t cl_remote_capabilities = {"cl_remote_capabilities", REMOTE_CAPABILITIES, 0,
				   OnChange_remote_capabilities};
hashtable_t *rc_hash;

cvar_t cl_allow_downloads = {"cl_allow_downloads", "bsp,lmp,loc,mdl,mvd,pcx,spr,wad,wav"};
cvar_t cl_allow_uploads = {"cl_allow_uploads", "0"};

cbuf_t cbuf_main;
cbuf_t cbuf_svc;
cbuf_t cbuf_safe, cbuf_formatted_comms;
cbuf_t cbuf_server;

cbuf_t *cbuf_current = NULL;

static void OnChange_remote_capabilities(cvar_t *var, char *string, qbool *cancel)
{
	char *cmd, *ent, *tmp;

	if (cls.state != ca_disconnected)
	{
		Com_Printf("You cannot change remote capabilities unless you are disconnected\n");
		return;
	}

	if (!rc_hash || strlen(var->string) == 0)
	{
		goto add;
	}

	tmp = Q_strdup(var->string);
	cmd = strtok(tmp, ",");
	while (cmd != NULL)
	{
		Com_DPrintf("Removing %s from remote capabilities\n", cmd);

		if ((ent = Hash_Get(rc_hash, cmd)))
		{
			Q_free(ent);
			Hash_Remove(rc_hash, cmd);
		}

		cmd = strtok(NULL, ",");
	}
	Q_free(tmp);

add:
	if (!rc_hash)
	{
		rc_hash = Hash_InitTable(512);
	}
	else
	{
		Hash_Flush(rc_hash);
	}

	tmp = Q_strdup(string);
	cmd = strtok(tmp, ",");
	while (cmd != NULL)
	{
		Com_DPrintf("Adding %s to capabilities\n", cmd);

		if (!Hash_Get(rc_hash, cmd))
		{
			ent = Q_malloc(sizeof(char));
			*ent = 1;
			Hash_Add(rc_hash, cmd, (void *)ent);
		}

		cmd = strtok(NULL, ",");
	}
	Q_free(tmp);
}

qbool CL_IsDownloadableFileExtension(const char *filename)
{
	qbool is_allowed = false;
	char *ext, *str, *tmp;

	ext = COM_FileExtension(filename);
	str = Q_strdup(cl_allow_downloads.string);
	tmp = strtok(str, ",");
	while (tmp != NULL) {
		if (strcmp(ext, tmp) == 0) {
			is_allowed = true;
			break;
		}

		tmp = strtok(NULL, ",");
	}
	Q_free(str);

	return is_allowed;
}

//=============================================================================

//Causes execution of the remainder of the command buffer to be delayed until next frame.
//This allows commands like: bind g "impulse 5 ; +attack ; wait ; -attack ; impulse 2"
void Cmd_Wait_f (void)
{
	if (cbuf_current)
		cbuf_current->wait = true;

	return;
}

// copies the first argument to clipboard
void Cmd_Clipboard_f(void) {
	CopyToClipboard(Cmd_Args());
}

/*
=============================================================================
						COMMAND BUFFER
=============================================================================
*/

void Cbuf_AddText (const char *text)
{
	Cbuf_AddTextEx (&cbuf_main, text);
}

void Cbuf_InsertText (const char *text)
{
	Cbuf_InsertTextEx (&cbuf_main, text);
}

void Cbuf_Execute (void)
{
	Cbuf_ExecuteEx (&cbuf_main);
	Cbuf_ExecuteEx (&cbuf_safe);
	Cbuf_ExecuteEx (&cbuf_formatted_comms);
	Cbuf_ExecuteEx (&cbuf_server);
}

void Cbuf_Flush(cbuf_t* cbuf)
{
	while (cbuf->text_end > cbuf->text_start)
		Cbuf_ExecuteEx(cbuf);
}

//fuh : ideally we should have 'cbuf_t *Cbuf_Register(int maxsize, int flags, qbool (*blockcmd)(void))
//fuh : so that cbuf_svc and cbuf_safe can be registered outside cmd.c in cl_* .c
//fuh : flags can be used to deal with newline termination etc for cbuf_svc, and *blockcmd can be used for blocking cmd's for cbuf_svc
//fuh : this way cmd.c would be independant of '#ifdef CLIENTONLY's'.
//fuh : I'll take care of that one day.
static void Cbuf_Register (cbuf_t *cbuf, int maxsize)
{
	assert (!host_initialized);
	cbuf->maxsize = maxsize;
	cbuf->text_buf = (char *) Hunk_AllocName(maxsize, "cbuf");
	cbuf->text_start = cbuf->text_end = (cbuf->maxsize >> 1);
	cbuf->wait = false;
	cbuf->waitCount = 0;
}

void Cbuf_Init (void)
{
	Cbuf_Register (&cbuf_main, 1 << 18); // 256kb
	Cbuf_Register (&cbuf_svc, 1 << 13); // 8kb
	Cbuf_Register (&cbuf_safe, 1 << 11); // 2kb
	Cbuf_Register (&cbuf_formatted_comms, 1 << 11); // 2kb
	Cbuf_Register (&cbuf_server, 1 << 18); // 256kb
}

//Adds command text at the end of the buffer
void Cbuf_AddTextEx (cbuf_t *cbuf, const char *text)
{
	size_t new_start, new_bufsize;
	size_t len;

	len = strlen (text);

	if (cbuf->text_end + len <= cbuf->maxsize) {
		memcpy (cbuf->text_buf + cbuf->text_end, text, len);
		cbuf->text_end += len;
		return;
	}

	new_bufsize = cbuf->text_end-cbuf->text_start+len;
	if (new_bufsize > cbuf->maxsize) {
		Com_Printf ("Cbuf_AddText: overflow\n");
		return;
	}

	// Calculate optimal position of text in buffer
	new_start = ((cbuf->maxsize - new_bufsize) >> 1);

	memcpy (cbuf->text_buf + new_start, cbuf->text_buf + cbuf->text_start, cbuf->text_end-cbuf->text_start);
	memcpy (cbuf->text_buf + new_start + cbuf->text_end-cbuf->text_start, text, len);
	cbuf->text_start = new_start;
	cbuf->text_end = cbuf->text_start + new_bufsize;
}

//Adds command text at the beginning of the buffer
void Cbuf_InsertTextEx (cbuf_t *cbuf, const char *text)
{
	size_t new_start, new_bufsize;
	size_t len;

	len = strlen (text);

	if (len <= cbuf->text_start) {
		memcpy (cbuf->text_buf + (cbuf->text_start - len), text, len);
		cbuf->text_start -= len;
		return;
	}

	new_bufsize = cbuf->text_end - cbuf->text_start + len;
	if (new_bufsize > cbuf->maxsize) {
		Com_Printf ("Cbuf_InsertText: overflow\n");
		return;
	}

	// Calculate optimal position of text in buffer
	new_start = ((cbuf->maxsize - new_bufsize) >> 1);

	memmove (cbuf->text_buf + (new_start + len), cbuf->text_buf + cbuf->text_start, cbuf->text_end - cbuf->text_start);
	memcpy (cbuf->text_buf + new_start, text, len);
	cbuf->text_start = new_start;
	cbuf->text_end = cbuf->text_start + new_bufsize;
}

#define MAX_RUNAWAYLOOP 1000

void Cbuf_ExecuteEx (cbuf_t *cbuf)
{
	size_t i, j;
	size_t cursize, nextsize;
	char *text, line[1024], *src, *dest;
	qbool comment;
	int quotes;

	if (cbuf == &cbuf_safe)
		gtf++;

	nextsize = cbuf->text_end - cbuf->text_start;

	while (cbuf->text_end > cbuf->text_start)
	{
		// find a \n or ; line break
		text = (char *) cbuf->text_buf + cbuf->text_start;

		cursize = cbuf->text_end - cbuf->text_start;
		comment = false;
		quotes = 0;

		for (i = 0; i < cursize; i++)
		{
			if (cl_curlybraces.integer)
			{
				if (text[i] == '\\')
				{
					if (i + 1 < cursize && text[i+1] == '\n')
					{ // escaped endline
						text[i] = text[i+1] = '\r'; // '\r' removed later during copying
						i++;
						continue;
					}
					else if (i + 2 < cursize && text[i+1] == '\r' && text[i+2] == '\n')
					{ // escaped dos endline
						text[i] = text[i+2] = '\r';
						i+=2;
						continue;
					}
				}
			}

			if (text[i] == '\n')
				break;

			if (text[i] == '"' && quotes <= 0)
			{
				if (!quotes)
					quotes = -1;
				else
					quotes = 0;
			}
			else if (quotes >= 0)
			{
				if (cl_curlybraces.integer)
				{
					if (text[i] == '{')
						quotes++;
					else if (text[i] == '}')
						quotes--;
				}
			}

			if (comment || quotes)
				continue;

			if (text[i] == '/' && i + 1 < cursize && text[i + 1] == '/')
				comment = true;
			else if (text[i] == ';' && !quotes)
				break;
		}

		if ((cursize - i) < nextsize) // have we reached the next command?
			nextsize = cursize - i;

		// don't execute lines without ending \n; this fixes problems with
		// partially stuffed aliases not being executed properly

		if (cbuf_current == &cbuf_svc && i == cursize)
			break;

		// Copy text to line, skipping carriage return chars
		src = text;
		dest = line;
		j = min (i, sizeof (line) - 1);
		for ( ; j; j--, src++)
		{
			if (*src != '\r')
				*dest++ = *src;
		}
		*dest = 0;

		// delete the text from the command buffer and move remaining commands down  This is necessary
		// because commands (exec, alias) can insert data at the beginning of the text buffer
		if (i == cursize)
		{
			cbuf->text_start = cbuf->text_end = (cbuf->maxsize >> 1);
		}
		else
		{
			i++;
			cbuf->text_start += i;
		}

		cursize = cbuf->text_end - cbuf->text_start;

		// TODO: make it in a more right way
		// since, hud262_add can not correctly create hud elements during normal start
		// (some cvars are not created/initialized at the time when we want to use them in hud262)
		// we should save these commands to buffer and execute it when all
		// cvars will be created
		if (!host_initialized) {
			Hud_262CatchStringsOnLoad(line);
		}

		Cmd_ExecuteStringEx (cbuf, line);	// execute the command line

		if (cbuf->text_end - cbuf->text_start > cursize)
			cbuf->runAwayLoop++;

		if (cbuf->runAwayLoop > MAX_RUNAWAYLOOP)
		{
			Com_Printf("\x02" "A recursive alias has caused an infinite loop.");
			Com_Printf("\x02" " Clearing execution buffer to prevent lockup.\n");
			cbuf->text_start = cbuf->text_end = (cbuf->maxsize >> 1);
			cbuf->runAwayLoop = 0;
		}

		if (cbuf->wait && cbuf->waitCount >= Rulesets_MaxSequentialWaitCommands())
		{
			Com_Printf("\x02" "Max number of wait commands detected.\n");
			cbuf->text_start = cbuf->text_end = (cbuf->maxsize >> 1);
			cbuf->wait = false;
			cbuf->waitCount = 0;
		}

		if (cbuf->wait)
		{
			// skip out while text still remains in buffer, leaving it for next frame
			cbuf->wait = false;
			++cbuf->waitCount;

			cbuf->runAwayLoop += Q_rint (0.5 * cls.frametime * MAX_RUNAWAYLOOP);

			if (cbuf == &cbuf_safe)
				gtf--;
			return;
		}
	}

	if (cbuf == &cbuf_safe)
		gtf--;

	cbuf->runAwayLoop = 0;
	cbuf->waitCount = 0;

	return;
}

/*
==============================================================================
						SCRIPT COMMANDS
==============================================================================
*/

/*
Set commands are added early, so they are guaranteed to be set before
the client and server initialize for the first time.

Other commands are added late, after all initialization is complete.
*/
void Cbuf_AddEarlyCommands (void)
{
	int i;

	for (i = 0; i < COM_Argc () - 2; i++) {
		if (strcasecmp (COM_Argv(i), "+set"))
			continue;

		Cbuf_AddText (va ("set %s %s\n", COM_Argv (i + 1), COM_Argv (i + 2)));
		i += 2;
	}
}

qbool Cmd_IsAllowedStuffCmdsCommand(const char *str)
{
	char*	banned_list[] = {"set ", "cfg_load ", NULL};
	char**	banned_cmd = banned_list;

	while(*banned_cmd)
	{
		if(strncasecmp(str, *banned_cmd, strlen(*banned_cmd)) == 0)
		{
			//+set is processed in Cbuf_AddEarlyCommands(), +cfg_load allowed only once in Host_Init()
			if((strncasecmp(str, "set ", 4) != 0) && (strncasecmp(str, "cfg_load ", 9) != 0))
			{
				Com_Printf("+%s is not allowed in cmdline or obsolete.\n", *banned_cmd);
			}
			return false;
		}
		banned_cmd++;
	}
	return true;
}

/*
Adds command line parameters as script statements
Commands lead with a +, and continue until a - or another +
quake +prog jctest.qp +cmd amlev1
quake -nosound +cmd amlev1
*/
void Cmd_StuffCmds_f (void)
{
	int k, len = 0;
	char *s, *text, *token;

	// build the combined string to parse from
	for (k = 1; k < COM_Argc(); k++)
		len += strlen (COM_Argv(k)) + 1;

	if (!len)
		return;

	text = (char *) Q_malloc(len + 1);
	text[0] = '\0';
	for (k = 1; k < COM_Argc(); k++) {
		strlcat (text, COM_Argv(k), len + 1);
		if (k != COM_Argc() - 1)
			strlcat (text, " ", len + 1);
	}

	// pull out the commands
	token = (char *) Q_malloc(len + 1);

	s = text;
	while (*s) {
		if (*s == '+')	{
			k = 0;
			for (s = s + 1; s[0] && (s[0] != ' ' || (s[1] != '-' && s[1] != '+')); s++)
				token[k++] = s[0];
			token[k++] = '\n';
			token[k] = 0;
			if(Cmd_IsAllowedStuffCmdsCommand(token))
				Cbuf_AddText (token);
		} else if (*s == '-') {
			for (s = s + 1; s[0] && s[0] != ' '; s++)
				;
		} else {
			s++;
		}
	}

	Q_free(text);
	Q_free (token);
}

void Cmd_Exec_f (void)
{
	char *f, name[MAX_OSPATH];
	char reset_bindphysical[128];
	qbool server_command = false;

	if (Rulesets_RestrictExec()) {
		Com_Printf("The use of exec is not allowed during matches\n");
		return;
	}

	if (Cmd_Argc () != 2) {
		Com_Printf ("%s <filename> : execute a script file\n", Cmd_Argv(0));
		return;
	}

#if !defined(SERVERONLY) && !defined(CLIENTONLY)
	server_command = cbuf_current == &cbuf_server || !strcmp(Cmd_Argv(0), "serverexec");
#endif

	if (CL_IsDownloadableFileExtension(Cmd_Argv(1))) {
		Com_Printf("Warning: \"%s\" is not allowed to be executed. Remove \"%s\" from cl_allow_downloads to allow execution\n", Cmd_Argv(1), COM_FileExtension(Cmd_Argv(1)));
		return;
	}

	strlcpy (name, Cmd_Argv(1), sizeof(name) - 4);
	if (!(f = (char *) FS_LoadHeapFile(name, NULL)))	{
		const char *p;
		p = COM_SkipPath (name);
		if (!strchr (p, '.')) {
			// no extension, so try the default (.cfg)
			strlcat (name, ".cfg", sizeof (name));
			f = (char *)FS_LoadHeapFile(name, NULL);
		}
		if (!f) {
			Com_Printf ("couldn't exec %s\n", Cmd_Argv(1));
			return;
		}
	}
	if (cl_warnexec.integer || developer.integer) {
		Com_Printf("execing %s/%s\n", FS_Locate_GetPath(name), name);
	}

	// All config files default to con_bindphysical 1, and would have to over-ride if they
	//   want different behaviour.
	sprintf(reset_bindphysical, "\ncon_bindphysical %d\n", con_bindphysical.integer);
	if (cbuf_current == &cbuf_svc) {
		Cbuf_AddTextEx(&cbuf_main, "con_bindphysical 1\n");
		Cbuf_AddTextEx(&cbuf_main, f);
		Cbuf_AddTextEx(&cbuf_main, reset_bindphysical);
	}
	else if (server_command) {
		Cbuf_AddTextEx(&cbuf_server, f);
	}
	else {
		Cbuf_InsertTextEx(&cbuf_main, reset_bindphysical);
		Cbuf_InsertTextEx(&cbuf_main, f);
		Cbuf_InsertTextEx(&cbuf_main, "con_bindphysical 1\n");
	}
	
	Q_free(f);
}

//Just prints the rest of the line to the console
/*void Cmd_Echo_f (void) {
	int i;

	for (i = 1; i < Cmd_Argc(); i++)
		Com_Printf ("%s ", Cmd_Argv(i));
	Com_Printf ("\n");
}*/
void Cmd_Echo_f (void)
{
	int	i;
	char *str;
	char args[MAX_MACRO_STRING];
	char buf[MAX_MACRO_STRING];

	memset (args, 0, MAX_MACRO_STRING);

	snprintf (args, MAX_MACRO_STRING, "%s", Cmd_Argv(1));

	for (i = 2; i < Cmd_Argc(); i++) {
		strlcat (args, " ", MAX_MACRO_STRING);
		strlcat (args, Cmd_Argv(i), MAX_MACRO_STRING);
	}

	//	str = TP_ParseMacroString(args);

	str = TP_ParseMacroString(args);
	str = TP_ParseFunChars(str, false);

	strlcpy (buf, str, MAX_MACRO_STRING);

	CL_SearchForReTriggers (buf, RE_PRINT_ECHO); 	// BorisU
	Print_flags[Print_current] |= PR_TR_SKIP;
	Com_Printf ("%s\n", buf);
}

/*
=============================================================================
								ALIASES
=============================================================================
*/
#define ALIAS_HASHPOOL_SIZE 256
cmd_alias_t *cmd_alias_hash[ALIAS_HASHPOOL_SIZE];
cmd_alias_t	*cmd_alias;

cmd_alias_t *Cmd_FindAlias (const char *name)
{
	int key;
	cmd_alias_t *alias;

	key = Com_HashKey (name) % ALIAS_HASHPOOL_SIZE;
	for (alias = cmd_alias_hash[key]; alias; alias = alias->hash_next) {
		if (!strcasecmp(name, alias->name))
			return alias;
	}
	return NULL;
}

char *Cmd_AliasString (char *name)
{
	int key;
	cmd_alias_t *alias;

	key = Com_HashKey (name) % ALIAS_HASHPOOL_SIZE;
	for (alias = cmd_alias_hash[key]; alias; alias = alias->hash_next) {
		if (!strcasecmp(name, alias->name)) {
			return alias->value;
		}
	}
	return NULL;
}

void Cmd_Viewalias_f (void)
{
	cmd_alias_t	*alias;
	char		*name;
	int		i,m;

	if (Cmd_Argc() < 2) {
		Com_Printf ("viewalias <cvar> [<cvar2>..] : view body of alias\n");
		return;
	}

	for (i=1; i<Cmd_Argc(); i++) {
		name = Cmd_Argv(i);

		if (IsRegexp(name)) {
			if (!ReSearchInitEx(name, false)) {
				return;
			}
			Com_Printf ("Current alias commands:\n");

			for (alias = cmd_alias, i = m = 0; alias; alias = alias->next, i++) {
				if (ReSearchMatch(alias->name)) {
					Com_Printf("%s : %s\n", alias->name, alias->value);
					m++;
				}
			}

			Com_Printf ("------------\n%i/%i aliases\n", m, i);
			ReSearchDone();
		}
		else if ((alias = Cmd_FindAlias(name))) {
			Com_Printf("%s : \"%s\"\n", Cmd_Argv(i), alias->value);
		}
		else {
			Com_Printf("No such alias: %s\n", Cmd_Argv(i));
		}
	}
}


int Cmd_AliasCompare (const void *p1, const void *p2)
{
	cmd_alias_t *a1, *a2;

	a1 = *((cmd_alias_t **) p1);
	a2 = *((cmd_alias_t **) p2);

	if (a1->name[0] == '+') {
		if (a2->name[0] == '+')
			return strcasecmp(a1->name + 1, a2->name + 1);
		else
			return -1;
	} else if (a1->name[0] == '-') {
		if (a2->name[0] == '+')
			return 1;
		else if (a2->name[0] == '-')
			return strcasecmp(a1->name + 1, a2->name + 1);
		else
			return -1;
	} else if (a2->name[0] == '+' || a2->name[0] == '-') {
		return 1;
	} else {
		return strcasecmp(a1->name, a2->name);
	}
}

void Cmd_AliasList_f (void)
{
	cmd_alias_t *a;
	int i, c, m = 0;
	static int count;
	static cmd_alias_t *sorted_aliases[4096];

#define MAX_SORTED_ALIASES (sizeof(sorted_aliases) / sizeof(sorted_aliases[0]))

	for (a = cmd_alias, count = 0; a && count < MAX_SORTED_ALIASES; a = a->next, count++)
		sorted_aliases[count] = a;
	qsort(sorted_aliases, count, sizeof (cmd_alias_t *), Cmd_AliasCompare);

	if (count == MAX_SORTED_ALIASES)
		assert(!"count == MAX_SORTED_ALIASES");

	c = Cmd_Argc();
	if (c > 1 && !ReSearchInitEx(Cmd_Argv(1), false)) {
		return;
	}

	Com_Printf ("List of aliases:\n");
	for (i = 0; i < count; i++) {
		a = sorted_aliases[i];
		if (c==1 || ReSearchMatch(a->name)) {
			Com_Printf ("\x02%s :", sorted_aliases[i]->name);
			Com_Printf (" %s\n", sorted_aliases[i]->value);
			m++;
		}
	}

	if (c>1)
		ReSearchDone();
	Com_Printf ("------------\n%i/%i aliases\n", m, count);
}

void Cmd_AliasEdit_f (void)
{
	cmd_alias_t	*a;
	char *s, *v, final_string[MAXCMDLINE - 1];
	int c;

	c = Cmd_Argc();
	if (c == 1)	{
		Com_Printf ("%s <name> : modify an alias\n", Cmd_Argv(0));
		Com_Printf ("aliaslist : list all aliases\n");
		return;
	}

	s = Cmd_Argv(1);
	if (s[0] == '\0') {
		Com_Printf("Alias name must be specified\n");
		return;
	} else if(strlen(s) >= MAX_ALIAS_NAME) {
		Com_Printf("Alias name is too long\n");
		return;
	}

	a = Cmd_FindAlias(s);
	v = (a ? a->value : "");

	strlcpy(final_string, "/alias \"", sizeof(final_string));
	strlcat(final_string, s, sizeof(final_string));
	strlcat(final_string, "\" \"", sizeof(final_string));
	strlcat(final_string, v, sizeof(final_string));
	strlcat(final_string, "\"", sizeof(final_string));
	Key_ClearTyping();
	key_linepos = 9 + (int)strlen(s) + 3; // move to where the commands are in the alias
	memcpy(key_lines[edit_line]+1, str2wcs(final_string), (strlen(final_string) + 1) * sizeof(wchar));
}

static cmd_alias_t* Cmd_AliasCreate (char* name)
{
	cmd_alias_t	*a;
	int key;

	key = Com_HashKey(name) % ALIAS_HASHPOOL_SIZE;

	a = (cmd_alias_t *) Q_malloc(sizeof(cmd_alias_t));
	a->next = cmd_alias;
	cmd_alias = a;
	a->hash_next = cmd_alias_hash[key];
	cmd_alias_hash[key] = a;

	strlcpy (a->name, name, sizeof (a->name));
	return a;
}

//Creates a new command that executes a command string (possibly ; separated)
void Cmd_Alias_f (void)
{
	cmd_alias_t	*a;
	char *s;
	int c, key;

	c = Cmd_Argc();
	if (c == 1)	{
		Com_Printf("%s <name> : show alias content\n", Cmd_Argv(0));
		Com_Printf("%s <name> <command> : create or modify an alias\n", Cmd_Argv(0));
		Com_Printf("use aliaslist to search for aliases\n");
		return;
	}

	s = Cmd_Argv(1);
	if (strlen(s) >= MAX_ALIAS_NAME) {
		Com_Printf ("Alias name is too long\n");
		return;
	}
	else if (s[0] == '\0') {
		Com_Printf("Alias name must be specified\n");
		return;
	}

	key = Com_HashKey(s) % ALIAS_HASHPOOL_SIZE;

	// if the alias already exists, reuse it
	for (a = cmd_alias_hash[key]; a; a = a->hash_next) {
		if (!strcasecmp(a->name, s)) {
			if (Cmd_Argc() == 2) {
				Com_Printf("\x02%s :", a->name);
				Com_Printf(" %s\n", a->value);
				return;
			}
			Q_free(a->value);
			break;
		}
	}

	if (!a)	{
		a = (cmd_alias_t *) Q_malloc(sizeof(cmd_alias_t));
		a->next = cmd_alias;
		cmd_alias = a;
		a->hash_next = cmd_alias_hash[key];
		cmd_alias_hash[key] = a;
	}

	strlcpy (a->name, s, sizeof (a->name));

	a->flags = 0;
	// QW262 -->
	s=Cmd_MakeArgs(2);
	while (*s) {
		if (*s == '%' && ( s[1]>='0' || s[1]<='9')) {
			a->flags |= ALIAS_HAS_PARAMETERS;
			break;
		}
		++s;
	}
	// <-- QW262

	if (cbuf_current == &cbuf_svc)
		a->flags |= ALIAS_SERVER;
	if (!strcasecmp(Cmd_Argv(0), "tempalias"))
		a->flags |= ALIAS_TEMP;

	// copy the rest of the command line
	a->value = Q_strdup(Cmd_MakeArgs(2));
}

qbool Cmd_DeleteAlias (char *name)
{
	cmd_alias_t *a, *prev;
	int key;

	key = Com_HashKey (name) % ALIAS_HASHPOOL_SIZE;

	prev = NULL;
	for (a = cmd_alias_hash[key]; a; a = a->hash_next) {
		if (!strcasecmp(a->name, name)) {
			// unlink from hash
			if (prev)
				prev->hash_next = a->hash_next;
			else
				cmd_alias_hash[key] = a->hash_next;
			break;
		}
		prev = a;
	}

	if (!a)
		return false;	// not found

	prev = NULL;
	for (a = cmd_alias; a; a = a->next) {
		if (!strcasecmp(a->name, name)) {
			// unlink from alias list
			if (prev)
				prev->next = a->next;
			else
				cmd_alias = a->next;

			// free
			Q_free(a->value);
			Q_free(a);
			return true;
		}
		prev = a;
	}

	assert(!"Cmd_DeleteAlias: alias list broken");
	return false; // shut up compiler
}

void Cmd_UnAlias (qbool use_regex)
{
	int 		i;
	char		*name;
	cmd_alias_t	*a, *next;
	qbool		re_search = false;

	if (Cmd_Argc() < 2) {
		Com_Printf ("unalias <cvar> [<cvar2>..]: erase an existing alias\n");
		return;
	}

	for (i=1; i<Cmd_Argc(); i++) {
		name = Cmd_Argv(i);

		if (use_regex && (re_search = IsRegexp(name))) {
			if (!ReSearchInitEx(name, false)) {
				continue;
			}
		}

		if (strlen(name) >= MAX_ALIAS_NAME) {
			Com_Printf ("Alias name is too long: \"%s\"\n", Cmd_Argv(i));
			continue;
		}

		if (use_regex && re_search) {
			for (a = cmd_alias; a; a = next) {
				next = a->next;

				if (ReSearchMatch(a->name))
					Cmd_DeleteAlias(a->name);
			}
		} else {
			if (!Cmd_DeleteAlias(Cmd_Argv(i)))
				Com_Printf ("unalias: unknown alias \"%s\"\n", Cmd_Argv(i));
		}

		if (use_regex && re_search)
			ReSearchDone();

	}
}

void Cmd_UnAlias_f (void)
{
	Cmd_UnAlias(false);
}

void Cmd_UnAlias_re_f (void)
{
	Cmd_UnAlias(true);
}

/* 
 * Remove all aliases unless connected, then remove
 * all aliases except the server created aliases
 */
void Cmd_UnAliasAll_f (void)
{
	cmd_alias_t	*a, *next;

/* FIXME: Optimize this, its n^2 slow atm since Cmd_DeleteAlias will loop through
 * the list again for each entry
 */
	if (cls.state >= ca_connected) {
		Com_Printf("Connected to a server, will not remove server aliases\n");
		for (a = cmd_alias; a; a = next) {
			next = a->next;
			if ((a->flags & ALIAS_SERVER) == 0) {
				Cmd_DeleteAlias(a->name);
			}
		}
	} else {
		for (a = cmd_alias; a ; a = next) {
			next = a->next;
			Q_free(a->value);
			Q_free(a);
		}
		cmd_alias = NULL;

		// clear hash
		memset (cmd_alias_hash, 0, sizeof(cmd_alias_t*) * ALIAS_HASHPOOL_SIZE);
	}
}

void DeleteServerAliases(void)
{
	cmd_alias_t *a, *next;

	for (a = cmd_alias; a; a = next) {
		next = a->next;

		if (a->flags & ALIAS_SERVER)
			Cmd_DeleteAlias (a->name);
	}
}

/*
=============================================================================
					LEGACY COMMANDS
=============================================================================
*/

legacycmd_t *legacycmds = NULL;

void Cmd_AddLegacyCommand(char *oldname, char *newname)
{
	legacycmd_t *cmd;
	cmd = (legacycmd_t *) Q_malloc(sizeof(legacycmd_t));
	cmd->next = legacycmds;
	legacycmds = cmd;

	cmd->oldname = oldname;
	cmd->newname = newname;
	cmd->dummy_cmd.name = oldname;
}

qbool Cmd_IsLegacyCommand (char *oldname)
{
	legacycmd_t *cmd;

	for (cmd = legacycmds; cmd; cmd = cmd->next) {
		if (!strcasecmp(cmd->oldname, oldname))
			return true;
	}
	return false;
}

static qbool Cmd_LegacyCommand (void)
{
	static qbool recursive = false;
	legacycmd_t *cmd;
	char text[1024];

	for (cmd = legacycmds; cmd; cmd = cmd->next) {
		if (!strcasecmp(cmd->oldname, Cmd_Argv(0)))
			break;
	}
	if (!cmd)
		return false;

	if (!cmd->newname[0])
		return true;		// just ignore this command

	// build new command string
	strlcpy(text, cmd->newname, sizeof(text));
	strlcat(text, " ", sizeof(text));
	strlcat(text, Cmd_Args(), sizeof(text));

	if (recursive) {
		Com_Printf("error: recursive legacy command, aborting");
		recursive = false;
		return false;
	}

	recursive = true;
	Cmd_ExecuteString(text);
	recursive = false;

	return true;
}

/*
=============================================================================
					COMMAND EXECUTION
=============================================================================
*/

#define CMD_HASHPOOL_SIZE 512
cmd_function_t	*cmd_hash_array[CMD_HASHPOOL_SIZE];
/*static*/ cmd_function_t	*cmd_functions;		// possible commands to execute

static  tokenizecontext_t cmd_tokenizecontext;

static	char	*cmd_null_string = "";

int Cmd_ArgcEx (tokenizecontext_t *ctx)
{
	return ctx->cmd_argc;
}

char *Cmd_ArgvEx (tokenizecontext_t *ctx, int arg)
{
	if (arg >= ctx->cmd_argc || arg < 0)
		return cmd_null_string;

	return ctx->cmd_argv[arg];
}

// Returns a single string containing argv(1) to argv(argc() - 1)
char *Cmd_ArgsEx (tokenizecontext_t *ctx)
{
	return ctx->cmd_args;
}

// Returns a single string containing argv(start) to argv(argc() - 1)
// Unlike Cmd_Args, shrinks spaces between argvs
char *Cmd_MakeArgsEx (tokenizecontext_t *ctx, int start)
{
	int i, c;

	ctx->text[0] = 0;
	c = Cmd_ArgcEx(ctx);

	for (i = start; i < c; i++)
	{
		if (i > start)
			strlcat (ctx->text, " ", sizeof (ctx->text) - strlen (ctx->text));

		strlcat (ctx->text, Cmd_ArgvEx(ctx, i), sizeof (ctx->text) - strlen (ctx->text));
	}

	return ctx->text;
}

// Parses the given string into command line tokens.
void Cmd_TokenizeStringEx2(tokenizecontext_t *ctx, const char *text, qbool curlybraces)
{
	int idx = 0, token_len;

	memset(ctx, 0, sizeof(*ctx));

	while (1)
	{
		// skip whitespace
		while (*text == ' ' || *text == '\t' || *text == '\r')
			text++;

		// a newline separates commands in the buffer
		if (*text == '\n')
			return;

		if (!*text)
			return;

		if (ctx->cmd_argc == 1)
			strlcpy(ctx->cmd_args, text, sizeof(ctx->cmd_args));

		text = COM_ParseEx(text, curlybraces);
		if (!text)
			return;

		if (ctx->cmd_argc >= MAX_ARGS)
			return;

		token_len = strlen(com_token);

		// ouch ouch, no more space
		if (idx + token_len + 1 > sizeof(ctx->argv_buf))
			return;

		ctx->cmd_argv[ctx->cmd_argc] = ctx->argv_buf + idx;
		strcpy (ctx->cmd_argv[ctx->cmd_argc], com_token);
		ctx->cmd_argc++;

		idx += token_len + 1;
	}
}

void Cmd_TokenizeStringEx(tokenizecontext_t* ctx, const char* text)
{
	Cmd_TokenizeStringEx2(ctx, text, false);
}

// and wrappers for backward compatibility

int Cmd_Argc (void)
{
	return Cmd_ArgcEx(&cmd_tokenizecontext);
}

char *Cmd_Argv (int arg)
{
	return Cmd_ArgvEx(&cmd_tokenizecontext, arg);
}

//Returns a single string containing argv(1) to argv(argc() - 1)
char *Cmd_Args (void)
{
	return Cmd_ArgsEx(&cmd_tokenizecontext);
}

//Returns a single string containing argv(start) to argv(argc() - 1)
//Unlike Cmd_Args, shrinks spaces between argvs
char *Cmd_MakeArgs (int start)
{
	return Cmd_MakeArgsEx(&cmd_tokenizecontext, start);
}

//Parses the given string into command line tokens.
void Cmd_TokenizeString (const char *text)
{
	Cmd_TokenizeStringEx(&cmd_tokenizecontext, text);
}

// save cmd_tokenizecontext struct to ctx
void Cmd_SaveContext(tokenizecontext_t *ctx)
{
	ctx[0] = cmd_tokenizecontext;
}

// restore cmd_tokenizecontext struct from ctx
void Cmd_RestoreContext(tokenizecontext_t *ctx)
{
	cmd_tokenizecontext = ctx[0];
}

void Cmd_AddCommand (char *cmd_name, xcommand_t function)
{
	cmd_function_t *cmd;
	int	key;

	/* commented out when vid_restart was added
	if (host_initialized)	// because hunk allocation would get stomped
		assert (!"Cmd_AddCommand after host_initialized");
	*/

/*	// fail if the command is a variable name
	if (Cvar_Find(cmd_name)) {
		Com_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
		return;
	} */

	key = Com_HashKey (cmd_name) % CMD_HASHPOOL_SIZE;

	// fail if the command already exists
	for (cmd = cmd_hash_array[key]; cmd; cmd=cmd->hash_next) {
		if (!strcasecmp (cmd_name, cmd->name)) {
			Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
			return;
		}
	}

	cmd = (cmd_function_t *) Hunk_AllocName (sizeof(cmd_function_t), "cmd");
	cmd->name = cmd_name;
	cmd->function = function;
	cmd->zmalloced = false;
	cmd->next = cmd_functions;
	cmd_functions = cmd;
	cmd->hash_next = cmd_hash_array[key];
	cmd_hash_array[key] = cmd;
}

qbool Cmd_AddRemCommand (char *cmd_name, xcommand_t function)
{
	cmd_function_t *cmd;
	int	key;

	key = Com_HashKey (cmd_name) % CMD_HASHPOOL_SIZE;

	// fail if the command already exists
	for (cmd = cmd_hash_array[key]; cmd; cmd=cmd->hash_next) {
		if (!strcasecmp (cmd_name, cmd->name)) {
			Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
			return false;
		}
	}

	cmd = (cmd_function_t*)Q_malloc(sizeof(cmd_function_t)+strlen(cmd_name)+1);
	cmd->name = (char*)(cmd+1); // points to extra space created after the structure
	strcpy(cmd->name, cmd_name);
	cmd->function = function;
	cmd->zmalloced = true;
	cmd->next = cmd_functions;
	cmd_functions = cmd;
	cmd->hash_next = cmd_hash_array[key];
	cmd_hash_array[key] = cmd;

	return true;
}

// removes command from the hash map of the commands
cmd_function_t *Cmd_RemoveCommand_Hash(char *cmd_name)
{
	int key = Com_HashKey (cmd_name) % CMD_HASHPOOL_SIZE;
	cmd_function_t *cmd = cmd_hash_array[key];
	cmd_function_t *prev = NULL;
	cmd_function_t *retval = NULL;

	if (strcasecmp(cmd_name, cmd->name) == 0) {
		retval = cmd;
		cmd_hash_array[key] = cmd_hash_array[key]->hash_next;
	}
	else
	{
		prev = cmd;
		for (cmd = cmd->hash_next; cmd; cmd = cmd->hash_next) {
			if (strcasecmp(cmd_name, cmd->name) == 0) {
				retval = cmd;
				prev->hash_next = cmd->hash_next;
			}
		}
	}

	return retval;
}

// removes command from the linked list of all commands
cmd_function_t *Cmd_RemoveCommand_List (char *cmd_name)
{
	cmd_function_t	*cmd, **back;

	back = &cmd_functions;
	while (1)
	{
		cmd = *back;
		if (!cmd)
		{
			return NULL;
		}
		if (!strcmp (cmd_name, cmd->name))
		{
			*back = cmd->next;
			return cmd;
		}
		back = &cmd->next;
	}
}

// removes command from all structures and deallocates it
void Cmd_RemoveCommand (char *cmd_name)
{
	cmd_function_t *cmd;

	cmd = Cmd_RemoveCommand_List(cmd_name);
	cmd = Cmd_RemoveCommand_Hash(cmd_name);

	if (cmd) {
		if (cmd->zmalloced)
		{
			Q_free(cmd);
		}
		else
		{
			Con_Printf("Cmd_RemoveCommand: %s was not added dynamically\n", cmd_name);
		}
	}
}

qbool Cmd_Exists (char *cmd_name)
{
	int	key;
	cmd_function_t	*cmd;

	key = Com_HashKey (cmd_name) % CMD_HASHPOOL_SIZE;
	for (cmd=cmd_hash_array[key]; cmd; cmd = cmd->hash_next) {
		if (!strcasecmp (cmd_name, cmd->name))
			return true;
	}
	return false;
}

cmd_function_t *Cmd_FindCommand (const char *cmd_name)
{
	int	key;
	cmd_function_t *cmd;

	key = Com_HashKey (cmd_name) % CMD_HASHPOOL_SIZE;
	for (cmd = cmd_hash_array[key]; cmd; cmd = cmd->hash_next) {
		if (!strcasecmp (cmd_name, cmd->name))
			return cmd;
	}
	return NULL;
}

char *Cmd_CompleteCommand (char *partial)
{
	cmd_function_t *cmd;
	int len;
	cmd_alias_t *alias;
	legacycmd_t* legacy_cmd;

	len = strlen(partial);

	if (!len)
		return NULL;

	// check for exact match
	for (cmd = cmd_functions; cmd; cmd = cmd->next)
		if (!strcasecmp (partial, cmd->name))
			return cmd->name;
	for (alias = cmd_alias; alias; alias = alias->next)
		if (!strcasecmp (partial, alias->name))
			return alias->name;
	for (legacy_cmd = legacycmds; legacy_cmd; legacy_cmd = legacy_cmd->next) {
		if (!strcasecmp(partial, legacy_cmd->oldname)) {
			return legacy_cmd->oldname;
		}
	}

	// check for partial match
	for (cmd = cmd_functions; cmd; cmd = cmd->next)
		if (!strncasecmp (partial, cmd->name, len))
			return cmd->name;
	for (alias = cmd_alias; alias; alias = alias->next)
		if (!strncasecmp (partial, alias->name, len))
			return alias->name;
	for (legacy_cmd = legacycmds; legacy_cmd; legacy_cmd = legacy_cmd->next) {
		if (!strncasecmp(partial, legacy_cmd->oldname, len)) {
			return legacy_cmd->oldname;
		}
	}

	return NULL;
}

int Cmd_CompleteCountPossible (char *partial)
{
	cmd_function_t *cmd;
	legacycmd_t* legacy_cmd;
	int len, c = 0;

	len = strlen(partial);
	if (!len)
		return 0;

	for (cmd = cmd_functions; cmd; cmd = cmd->next) {
		if (!strncasecmp(partial, cmd->name, len)) {
			c++;
		}
	}

	// Also check legacy commands
	for (legacy_cmd = legacycmds; legacy_cmd; legacy_cmd = legacy_cmd->next) {
		if (!strncasecmp(partial, legacy_cmd->oldname, len)) {
			++c;
		}
	}

	return c;
}

int Cmd_AliasCompleteCountPossible (char *partial)
{
	cmd_alias_t *alias;
	int len, c = 0;

	len = strlen(partial);
	if (!len)
		return 0;

	for (alias = cmd_alias; alias; alias = alias->next)
		if (!strncasecmp (partial, alias->name, len))
			c++;

	return c;
}

int Cmd_CommandCompare (const void *p1, const void *p2)
{
	return strcmp((*((cmd_function_t **) p1))->name, (*((cmd_function_t **) p2))->name);
}

void Cmd_CmdList (qbool use_regex)
{
	static cmd_function_t *sorted_cmds[1024];
	int i, c, m = 0, count;
	cmd_function_t *cmd;
	char *pattern;

#define MAX_SORTED_CMDS (sizeof (sorted_cmds) / sizeof (sorted_cmds[0]))

	for (cmd = cmd_functions, count = 0; cmd && count < MAX_SORTED_CMDS; cmd = cmd->next, count++)
		sorted_cmds[count] = cmd;
	qsort (sorted_cmds, count, sizeof (cmd_function_t *), Cmd_CommandCompare);

	if (count == MAX_SORTED_CMDS)
		assert(!"count == MAX_SORTED_CMDS");

	pattern = (Cmd_Argc() > 1) ? Cmd_Argv(1) : NULL;

	if (((c = Cmd_Argc()) > 1) && use_regex) {
		if (!ReSearchInitEx(Cmd_Argv(1), false)) {
			return;
		}
	}

	Com_Printf ("List of commands:\n");
	for (i = 0; i < count; i++) {
		cmd = sorted_cmds[i];
		if (use_regex) {
			if (!(c == 1 || ReSearchMatch (cmd->name)))
				continue;
		} else {
			if (pattern && !Q_glob_match (pattern, cmd->name))
				continue;
		}

		Com_Printf ("%s\n", cmd->name);
		m++;
	}

	if (use_regex && (c > 1))
		ReSearchDone ();

	Com_Printf ("------------\n%i/%i commands\n", m,count);
}

void Cmd_CmdList_f (void)
{
	Cmd_CmdList (false);
}

void Cmd_CmdList_re_f (void)
{
	Cmd_CmdList (true);
}

void Cmd_ReInitAllMacro(void)
{
	int i;
	int teamplay = (int)Rulesets_RestrictTriggers();

	for (i = 0; i < num_macros; i++) {
		if (macro_commands[i].teamplay != MACRO_NORULES) {
			macro_commands[i].teamplay = teamplay;
		}
	}
}

void Cmd_AddMacroEx(macro_id id, char *(*f) (void), int teamplay)
{
	if (id < 0 || id >= num_macros) {
		return;
	}

	macro_commands[id].func = f;
	macro_commands[id].teamplay = teamplay;
}

void Cmd_AddMacro (macro_id id, char *(*f) (void))
{
	Cmd_AddMacroEx(id, f, MACRO_NORULES);
}

char *Cmd_MacroString (const char* s, int *macro_length)
{
	int i;
	macro_command_t	*macro;
	int best = -1;
	int best_length = -1;

	*macro_length = 0;
	for (i = 0; i < num_macros; i++) {
		macro = &macro_commands[i];
		if (macro->func) {
			int name_length = strlen(macro->name);
			if (!strncasecmp(s, macro->name, name_length)) {
				if (best_length == -1 || best_length < name_length) {
					best = i;
					best_length = name_length;
				}
			}
		}
	}

	if (best >= 0) {
		if (cbuf_current == &cbuf_main && (macro_commands[best].teamplay == MACRO_DISALLOWED)) {
			cbuf_current = &cbuf_formatted_comms;
		}
		*macro_length = best_length;
		return macro_commands[best].func();
	}

	return NULL;
}

static int Cmd_MacroCompare (const void *p1, const void *p2)
{
	return strcmp ((*((macro_command_t **) p1))->name, (*((macro_command_t **) p2))->name);
}

const char* Cmd_MacroName(macro_id id)
{
	return macro_commands[id].name;
}

qbool Cmd_MacroTeamplayRestricted(macro_id id)
{
	return macro_commands[id].teamplay;
}

void Cmd_MacroList_f (void)
{
	int i, c, m = 0;
	static macro_command_t* sorted_macros[num_macros];

	for (i = 0; i < num_macros; i++) {
		sorted_macros[i] = &macro_commands[i];
	}
	qsort(sorted_macros, num_macros, sizeof (macro_command_t *), Cmd_MacroCompare);

	c = Cmd_Argc();
	if (c > 1 && !ReSearchInitEx(Cmd_Argv(1), false)) {
		return;
	}

	Com_Printf ("List of macros:\n");
	for (i = 0; i < num_macros; i++) {
		if (c==1 || ReSearchMatch (sorted_macros[i]->name)) {
			Com_Printf ("$%s\n", sorted_macros[i]->name);
			m++;
		}
	}

	if (c > 1) {
		ReSearchDone();
	}

	Com_Printf ("------------\n%i/%i macros\n", m, num_macros);
}

void TP_SetDefaultMacroFormat(char* cvar_lookup, int* fixed_width, int* alignment);
char* TP_AlignMacroText(char* text, int fixed_width, int alignment);

//Expands all $cvar expressions to cvar values
//Also expands $macro expressions
//Note: dest must point to a 1024 byte buffer
void Cmd_ExpandString (const char *data, char *dest)
{
	unsigned int c;
	char buf[255], *str;
	int i, len = 0, quotes = 0, name_length = 0;
	cvar_t *var, *bestvar;
	int macro_length;

	while ((c = *data)) {
		if (c == '"')
			quotes++;

		if (c == '$' && !(quotes & 1)) {
			data++;

			// Copy the text after '$' to a temp buffer
			i = 0;
			buf[0] = 0;
			bestvar = NULL;
			while ((c = *data) > 32) {
				if (c == '$')
					break;

				data++;
				buf[i++] = c;
				buf[i] = 0;

				if ((var = Cvar_Find(buf)))
					bestvar = var;

				if (i >= (int) sizeof (buf) - 1)
					break; // there no more space in buf
			}

			str = Cmd_MacroString (buf, &macro_length);
			name_length = macro_length;

			if (bestvar && (!str || (strlen (bestvar->name) > macro_length))) {
				str = bestvar->string;
				name_length = strlen(bestvar->name);
                if (bestvar->teamplay)
                    cbuf_current = &cbuf_formatted_comms;
			}

			if (str) {
				int fixed_width = 0;
				int alignment = 0;

				TP_SetDefaultMacroFormat(buf, &fixed_width, &alignment);
				if (fixed_width != 0)
					str = TP_AlignMacroText(str, fixed_width, alignment);

				// check buffer size
				if (len + strlen (str) >= 1024 - 1)
					break;

				strcpy (&dest[len], str);
				len += strlen (str);
				i = name_length;
				while (buf[i])
					dest[len++] = buf[i++];
			} else {
				// no matching cvar or macro
				dest[len++] = '$';
				if (len + strlen (buf) >= 1024 - 1)
					break;

				strcpy (&dest[len], buf);
				len += strlen (buf);
			}
		} else {
			dest[len] = c;
			data++;
			len++;
			if (len >= 1024 - 1)
				break;
		}
	}

	dest[len] = 0;
}

int Commands_Compare_Func (const void * arg1, const void * arg2)
{
	return strcasecmp (*(char**) arg1, *(char**) arg2);
}

char *msgtrigger_commands[] = {
	"play", "playvol", "stopsound", "stopsound_script", "set", "echo", "say", "say_team",
	"alias", "unalias", "msg_trigger", "inc", "bind", "unbind", "record",
	"easyrecord", "stop", "if", "if_exists", "wait", "log", "match_forcestart",
	"dns", "addserver", "connect", "join", "observe",
	"tcl_proc", "tcl_exec", "tcl_eval", "exec",
	"set_ex", "set_alias_str", "set_bind_str","unset", "unset_re" ,
	"toggle", "toggle_re", "set_calc", "rcon", "user", "users",
	"unalias", "unalias_re",
	"re_trigger", "re_trigger_options", "re_trigger_delete",
	"re_trigger_enable","re_trigger_disable", "re_trigger_match",
	"hud262_add","hud262_remove","hud262_position","hud262_bg",
	"hud262_move","hud262_width","hud262_alpha","hud262_blink",
	"hud262_disable","hud262_enable","hud262_list","hud262_bringtofront",
	"hud_262font","hud262_hover","hud262_button",
	"alias_in", "alias_out", "cvar_in", "cvar_out"
	// ,NULL
};

char *formatted_comms_commands[] = {
	"if", "wait", "echo", "say", "say_team", "set_tp",
	"tp_point", "tp_pickup", "tp_took",
	"tp_msgreport", "tp_msgcoming", "tp_msglost", "tp_msgenemypwr",
	"tp_msgquaddead", "tp_msgsafe", "tp_msgkillme", "tp_msghelp",
	"tp_msggetquad", "tp_msggetpent", "tp_msgpoint", "tp_msgtook",
	"tp_msgtrick", "tp_msgreplace", "tp_msgneed", "tp_msgyesok",
	"tp_msgnocancel", "tp_msgutake", "tp_msgitemsoon", "tp_msgwaiting",
	"tp_msgslipped",
    NULL
};

float	impulse_time = -9999;
int		impulse_counter;

qbool AllowedImpulse(int imp)
{

	static int Allowed_TF_Impulses[] = {
	                                   135, 99, 101, 102, 103, 104, 105, 106, 107, 108, 109, 23, 144, 145,
	                                   159, 160, 161, 162, 163, 164, 165, 166, 167
	                               };

	int i;

	if (!cl.teamfortress) return false;
	for (i=0; i<sizeof(Allowed_TF_Impulses)/sizeof(Allowed_TF_Impulses[0]); i++) {
		if (Allowed_TF_Impulses[i] == imp) {
			if(++impulse_counter >= 30) {
				if (cls.realtime < impulse_time + 5 && !cls.demoplayback) {
					return false;
				}
				impulse_time = cls.realtime;
				impulse_counter = 0;
			}
			return true;
		}
	}
	return false;
}

static qbool Cmd_IsCommandAllowedInMessageTrigger( const char *command )
{
	if( !strcasecmp( command, "impulse") )
		return AllowedImpulse(Q_atoi(Cmd_Argv(1)));

	return 	  bsearch( &(command), msgtrigger_commands,
	                   sizeof(msgtrigger_commands)/sizeof(msgtrigger_commands[0]),
	                   sizeof(msgtrigger_commands[0]),Commands_Compare_Func) != NULL;
}

static qbool Cmd_IsCommandAllowedInTeamPlayMacros( const char *command )
{
	char **s;
	for (s = formatted_comms_commands; *s; s++) {
		if (!strcasecmp(command, *s))
			break;
	}
	return *s != NULL;
}

//A complete command line has been parsed, so try to execute it
static void Cmd_ExecuteStringEx (cbuf_t *context, char *text)
{
	cvar_t *v;
	cmd_function_t *cmd;
	cmd_alias_t *a;
	static char buf[1024];
	cbuf_t *inserttarget, *oldcontext;
	char *p, *n, *s;
	char text_exp[1024];
	qbool is_server_alias = false;

	oldcontext = cbuf_current;
	cbuf_current = context;

	Cmd_ExpandString(text, text_exp);
	Cmd_TokenizeStringEx2(&cmd_tokenizecontext, text_exp, cl_curlybraces.integer);

	if (!Cmd_Argc())
		goto done; // no tokens

	if (cbuf_current == &cbuf_svc) {
		if (CL_CheckServerCommand())
			goto done;
	}

#ifndef CLIENTONLY
	// 'status' on remote ktx servers..
	if (!strcmp(Cmd_Argv(0), "status") && Cmd_Argc() == 1 && Cmd_FindAlias("status")) {
		goto checkaliases;
	}
#endif

	// check functions
	if ((cmd = Cmd_FindCommand(Cmd_Argv(0)))) {
		if (gtf || cbuf_current == &cbuf_safe) {
			if (!Cmd_IsCommandAllowedInMessageTrigger(Cmd_Argv(0))) {
				Com_Printf ("\"%s\" cannot be used in message triggers\n", Cmd_Argv(0));
				goto done;
			}
		} else if (cbuf_current == &cbuf_formatted_comms) {
			if (!Cmd_IsCommandAllowedInTeamPlayMacros(Cmd_Argv(0))) {
				Com_Printf ("\"%s\" cannot be used in combination with teamplay $macros\n", Cmd_Argv(0));
				goto done;
			}
		}

		if (cmd->function) {
			if (cbuf_current == &cbuf_svc && !Hash_Get(rc_hash, cmd->name)) {
				Com_Printf("Blocked %s: not in cl_remote_capabilities\n", cmd->name);
				goto done;
			}

			cmd->function();
		}
		else {
			Cmd_ForwardToServer ();
		}
		goto done;
	}

	// some bright guy decided to use "skill" as a mod command in Custom TF, sigh
	if (!strcmp(Cmd_Argv(0), "skill") && Cmd_Argc() == 1 && Cmd_FindAlias("skill"))
		goto checkaliases;

	// check cvars
	if ((v = Cvar_Find(Cmd_Argv(0)))) {
		if (cbuf_current == &cbuf_svc && !Hash_Get(rc_hash, v->name)) {
			Com_Printf("Blocked %s: not in cl_remote_capabilities\n", v->name);
			goto done;
		}

		if (cbuf_current == &cbuf_formatted_comms) {
			Com_Printf ("\"%s\" cannot be used in combination with teamplay $macros\n", Cmd_Argv(0));
			goto done;
		}
		if (Cvar_Command())
			goto done;
	}

	// check aliases
checkaliases:
	if ((a = Cmd_FindAlias(Cmd_Argv(0)))) {
		is_server_alias = a->flags & ALIAS_SERVER;

		// QW262 -->
		if (a->value[0] == '\0') {
			goto done; // alias is empty.
		}

		if(a->flags & ALIAS_HAS_PARAMETERS) { // %parameters are given in alias definition
			s=a->value;
			buf[0] = '\0';
			do {
				n = strchr(s, '%');
				if(n) {
					if(*++n >= '1' && *n <= '9') {
						n[-1] = 0;
						strlcat(buf, s, sizeof(buf));
						n[-1] = '%';
						// insert numbered parameter
						strlcat(buf,Cmd_Argv(*n-'0'), sizeof(buf));
					} else if (*n == '0') {
						n[-1] = 0;
						strlcat(buf, s, sizeof(buf));
						n[-1] = '%';
						// insert all parameters
						strlcat(buf, Cmd_Args(), sizeof(buf));
					} else if (*n == '%') {
						n[0] = 0;
						strlcat(buf, s, sizeof(buf));
						n[0] = '%';
					} else {
						if (*n) {
							char tmp = n[1];
							n[1] = 0;
							strlcat(buf, s, sizeof(buf));
							n[1] = tmp;
						} else
							strlcat(buf, s, sizeof(buf));
					}
					s=n+1;
				}
			} while(n);
			strlcat(buf, s, sizeof(buf));
			p = buf;

		} else  // alias has no parameters
			p = a->value;
		// <-- QW262

		if (cbuf_current == &cbuf_svc)
		{
			inserttarget = is_server_alias ? &cbuf_svc : &cbuf_main;
			Cbuf_AddTextEx (inserttarget, p);
			Cbuf_AddTextEx (inserttarget, "\n");
		} else
		{
			if (is_server_alias)
				inserttarget = &cbuf_svc;
			else
				inserttarget = cbuf_current ? cbuf_current : &cbuf_main;

			Cbuf_InsertTextEx (inserttarget, "\n");

			// if the alias value is a command or cvar and
			// the alias is called with parameters, add them
			if (Cmd_Argc() > 1 && !strchr(p, ' ') && !strchr(p, '\t') &&
			        (Cvar_Find(p) || (Cmd_FindCommand(p) && p[0] != '+' && p[0] != '-'))
			   ) {
				Cbuf_InsertTextEx (inserttarget, Cmd_Args());
				Cbuf_InsertTextEx (inserttarget, " ");
			}
			Cbuf_InsertTextEx (inserttarget, p);
		}
		goto done;
	}

	if (Cmd_LegacyCommand())
		goto done;

	if (!host_initialized && Cmd_Argc() > 1) {
		if (Cvar_CreateTempVar())
			goto done;
	}

	if (cbuf_current != &cbuf_svc)
	{
		if (cl_warncmd.integer || developer.integer)
			Com_Printf ("Unknown command \"%s\"\n", Cmd_Argv(0));
	}

done:
	cbuf_current = oldcontext;
}

void Cmd_ExecuteString (char *text)
{
	Cmd_ExecuteStringEx (NULL, text);
}

static qbool is_numeric (char *c)
{
	return ( isdigit((int)(unsigned char)*c) ||
	         ((*c == '-' || *c == '+') && (c[1] == '.' || isdigit((int)(unsigned char)c[1]))) ||
	         (*c == '.' && isdigit((int)(unsigned char)c[1])) );
}

void Re_Trigger_Copy_Subpatterns (const char *s, size_t* offsets, int num, cvar_t *re_sub); // QW262
extern cvar_t re_sub[10]; // QW262

void Cmd_CatchTriggerSubpatterns(const char *s, size_t* offsets, int num)
{
	Re_Trigger_Copy_Subpatterns(s, offsets, min(num, 10), re_sub);
}

// this is a test replacement of the "if" command
void Cmd_If_New(void)
{
	// syntax of this command has two possibilities:
	// if (<expr>) then <cmd1> [else <cmd2>]
	// if o1 o2 o3 [then] <cmd1> [else <cmd2>]
	// the second one is for backward compatibility
	parser_extra pars_ex;
	int c;
	int then_pos = 0;
	qbool then_found = false, else_found = false;
	int i, clen;
	size_t expr_len = 0;
	char* expr, * curarg;
	int result, error;
	char buf[1024];

	pars_ex.subpatt_fnc = Cmd_CatchTriggerSubpatterns;
	pars_ex.var2val_fnc = NULL;

	c = Cmd_Argc();

	// 0  1 2    3
	// if e then c
	if (c < 4) {
		Com_Printf("Usage: if <expr> then <cmds> [else <cmds>]\n");
		return;
	}

	for (i = 2; i < c; i++) {
		if (!strcmp(Cmd_Argv(i), "then")) {
			then_pos = i; then_found = true; break;
		}
	}

	if (!then_found) {
		Com_Printf("if command: \"then\" not found\n");
		return;
	}

	for (i = 1; i < then_pos; i++) {
		clen = strlen(Cmd_Argv(i));
		expr_len += clen ? clen + 1 : 3; // we will take '' as a representation of an empty string
	}

	expr = (char *) Q_malloc(expr_len + 1);
	expr[0] = '\0';

	for (i = 1; i < then_pos; i++) {
		if (i > 1)
			strlcat(expr, " ", expr_len + 1);

		curarg = Cmd_Argv(i);

		if (*curarg)
			strlcat(expr, curarg, expr_len + 1);
		else
			strlcat(expr, "''", expr_len + 1);
	}

	error = Expr_Eval_Bool(expr, &pars_ex, &result);
	if (error != EXPR_EVAL_SUCCESS) {
		Com_Printf("Error in condition: %s (\"%s\")\n", Parser_Error_Description(error), expr);
		Q_free(expr);
		return;
	}

	Q_free(expr);

	then_pos++;	// skip "then"

	buf[0] = '\0';
	if (result)	// true case
	{
		for (i = then_pos; i < c; i++) {
			if (!else_found && !strcmp(Cmd_Argv(i), "else"))
				break;

			if (buf[0])
				strlcat (buf, " ", sizeof(buf));

			strlcat (buf, Cmd_Argv(i), sizeof(buf));
		}
	}
	else // result = false
	{
		for (i = then_pos; i < c; i++) {
			if (else_found) {
				if (buf[0])
					strlcat (buf, " ", sizeof(buf));
				strlcat (buf, Cmd_Argv(i), sizeof(buf));
			}
			if (!else_found && !strcmp(Cmd_Argv(i), "else")) else_found = true;
		}
	}

	strlcat (buf, "\n", sizeof(buf));
	Cbuf_InsertTextEx (cbuf_current ? cbuf_current : &cbuf_main, buf);
}

void Cmd_If_Old (void)
{
	int	i, c;
	char *op, buf[1024] = {0};
	qbool result;

	if ((c = Cmd_Argc()) < 5) {
		Com_Printf ("Usage: if <expr1> <op> <expr2> <command> [else <command>]\n");
		return;
	}

	op = Cmd_Argv(2);
	if (!strcmp(op, "==") || !strcmp(op, "=") || !strcmp(op, "!=") || !strcmp(op, "<>")) {
		if (is_numeric(Cmd_Argv(1)) && is_numeric(Cmd_Argv(3)))
			result = Q_atof(Cmd_Argv(1)) == Q_atof(Cmd_Argv(3));
		else
			result = !strcmp(Cmd_Argv(1), Cmd_Argv(3));

		if (op[0] != '=')
			result = !result;
	} else if (!strcmp(op, ">")) {
		result = Q_atof(Cmd_Argv(1)) > Q_atof(Cmd_Argv(3));
	} else if (!strcmp(op, "<")) {
		result = Q_atof(Cmd_Argv(1)) < Q_atof(Cmd_Argv(3));
	} else if (!strcmp(op, ">=")) {
		result = Q_atof(Cmd_Argv(1)) >= Q_atof(Cmd_Argv(3));
	} else if (!strcmp(op, "<=")) {
		result = Q_atof(Cmd_Argv(1)) <= Q_atof(Cmd_Argv(3));

	} else if (!strcmp(op, "isin")) {
		result = (strstr(Cmd_Argv(3), Cmd_Argv(1)) ? 1 : 0);
	} else if (!strcmp(op, "!isin")) {
		result = (strstr(Cmd_Argv(3), Cmd_Argv(1)) ? 0 : 1);

	} else if (!strcmp(op, "=~") || !strcmp(op, "!~")) {
		pcre2_code       *regexp;
		int              error;
		PCRE2_SIZE       error_offset;
		pcre2_match_data *match_data = NULL;
		int              rc;

		regexp = pcre2_compile ((PCRE2_SPTR)Cmd_Argv(3), PCRE2_ZERO_TERMINATED, 0, &error, &error_offset, NULL);
		if (!regexp) {
			PCRE2_UCHAR error_str[256];
			pcre2_get_error_message(error, error_str, sizeof(error_str));
			Com_Printf ("Error in regexp: %s\n", error_str);
			return;
		}
		match_data = pcre2_match_data_create_from_pattern(regexp, NULL);
		rc = pcre2_match (regexp, (PCRE2_SPTR)Cmd_Argv(1), strlen(Cmd_Argv(1)),
		                0, 0, match_data, NULL);
		if (rc >= 0) {
			PCRE2_SIZE *offsets = pcre2_get_ovector_pointer(match_data);
			Re_Trigger_Copy_Subpatterns (Cmd_Argv(1), offsets, min(rc, 10), re_sub);
			result = true;
		} else
			result = false;

		if (op[0] != '=')
			result = !result;

		pcre2_match_data_free (match_data);
		pcre2_code_free (regexp);
	} else {
		Com_Printf ("unknown operator: %s\n", op);
		Com_Printf ("valid operators are ==, =, !=, <>, >, <, >=, <=, isin, !isin, =~, !~\n");
		return;
	}

	if (result)	{
		for (i = 4; i < c; i++) {
			if ((i == 4) && !strcasecmp(Cmd_Argv(i), "then"))
				continue;
			if (!strcasecmp(Cmd_Argv(i), "else"))
				break;
			if (buf[0])
				strlcat (buf, " ", sizeof (buf) - strlen (buf) - 1);

			strlcat (buf, Cmd_Argv(i), sizeof (buf) - strlen (buf) - 1);
		}
	} else {
		for (i = 4; i < c ; i++) {
			if (!strcasecmp(Cmd_Argv(i), "else"))
				break;
		}
		if (i == c)
			return;
		for (i++; i < c; i++) {
			if (buf[0])
				strlcat (buf, " ", sizeof (buf) - strlen (buf) - 1);

			strlcat (buf, Cmd_Argv(i), sizeof (buf) - strlen (buf) - 1);
		}
	}

	strlcat (buf, "\n", sizeof (buf) - strlen (buf));
	Cbuf_InsertTextEx (cbuf_current ? cbuf_current : &cbuf_main, buf);
}

void Cmd_If_f(void) {
	if (Cmd_Argc() > 2 && Cmd_Argv(1)[0] == '(')
		 // new "if" requires parentheses around the condition
		 // while the original "if" wouldn't work with these so it's safe
		 // to presume noone used it there
		 Cmd_If_New();
	else Cmd_If_Old();
}

void Cmd_If_Exists_f(void)
{
	int	argc;
	char	*type;
	char	*name;
	qbool	exists;
	qbool	iscvar, isalias, istrigger, ishud;

	argc = Cmd_Argc();
	if ( argc < 4 || argc > 5) {
		Com_Printf ("if_exists <type> <name> <cmd1> [<cmd2>] - conditional execution\n");
		return;
	}

	type = Cmd_Argv(1);
	name = Cmd_Argv(2);
	if ( ( (iscvar = !strcmp(type, "cvar")) && Cvar_Find(name) )			||
	        ( (isalias = !strcmp(type, "alias")) && Cmd_FindAlias (name) )			||
	        ( (istrigger = !strcmp(type, "trigger")) && CL_FindReTrigger (name) )	||
	        ( (ishud = !strcmp(type, "hud")) && Hud_ElementExists (name) ) )
		exists = true;
	else {
		exists = false;
		if (!(iscvar || isalias || istrigger || ishud)) {
			Com_Printf("if_exists: <type> can be cvar, alias, trigger, hud\n");
			return;
		}
	}

	if (exists) {
		Cbuf_InsertTextEx (cbuf_current ? cbuf_current : &cbuf_main,"\n");
		Cbuf_InsertTextEx (cbuf_current ? cbuf_current : &cbuf_main,Cmd_Argv(3));
	} else if (argc == 5) {
		Cbuf_InsertTextEx (cbuf_current ? cbuf_current : &cbuf_main,"\n");
		Cbuf_InsertTextEx (cbuf_current ? cbuf_current : &cbuf_main,Cmd_Argv(4));
	} else
		return;
}

void Cmd_Eval_f(void)
{
	int errn;
	expr_val value;

	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: eval <expression>\n"
			"Prints the value of given expression after evaluation in the internal parser\n");
		return;
	}

	value = Expr_Eval(Cmd_Argv(1), NULL, &errn);

	if (errn != EXPR_EVAL_SUCCESS)
	{
		Com_Printf("Error occured: %s\n", Parser_Error_Description(errn));
		return;
	}
	else
	{
		switch (value.type) {
		case ET_INT:  Com_Printf("Result: %i (integer)\n", value.i_val); break;
		case ET_DBL:  Com_Printf("Result: %f (double)\n",  value.d_val); break;
		case ET_BOOL: Com_Printf("Result: %s (bool)\n", value.b_val ? "true" : "false"); break;
		case ET_STR:  Com_Printf("Result: (string)\n\"%s\"\n", value.s_val); Q_free(value.s_val); break;
		default:      Com_Printf("Error: Unknown value type\n"); break;
		}
	}
}

// QW262 -->
static qbool do_in(char *buf, char *orig, char *str, int options)
{
	if ((options & 2) && strstr(orig, str))
		return false;

	if (options & 1) { // buf size is 1024 both in Cmd_Alias_In_f and Cmd_Cvar_In_f
		strlcpy(buf, orig, 1024);
		strlcat(buf, str, 1024);
	} else {
		strlcpy(buf, str, 1024);
		strlcat(buf, orig, 1024);
	}
	return true;
}

static qbool do_out(char *orig, char *str, int options)
{
	char	*p;
	int		len = strlen(str);

	if (!(p=strstr(orig, str)))
		return false;

	if (!(options & 1))
		memmove(p, p+len, strlen(p)+1);
	return true;
}

void Cmd_Alias_In_f (void)
{
	cmd_alias_t	*alias;
	cvar_t		*var;
	char		buf[1024];
	char		*alias_name;
	int			options;

	if (Cmd_Argc() < 3 || Cmd_Argc() > 4) {
		Com_Printf ("alias_in <alias> <cvar> [<options>]\n");
		return;
	}

	alias_name = Cmd_Argv(1);
	alias = Cmd_FindAlias(alias_name);
	options = atoi(Cmd_Argv(3));

	if (!alias) {
		if ((options & 8)) {
			alias = Cmd_AliasCreate(alias_name);
			if (!alias)
				return;
			alias->value = Q_strdup("");
		} else {
			Com_Printf ("alias_in: unknown alias \"%s\"\n", alias_name);
			return;
		}
	}

	var = Cvar_Find(Cmd_Argv(2));
	if (!var) {
		Com_Printf ("alias_in: unknown cvar \"%s\"\n", Cmd_Argv(2));
		return;
	}

	if (!do_in (buf, alias->value, var->string, options)) {
		if (options & 4)
			Com_Printf ("alias_in: already inserted\n");
		return;
	}

	Q_free(alias->value);
	alias->value = Q_strdup(buf);
	if (strchr(buf, '%'))
		alias->flags |= ALIAS_HAS_PARAMETERS;
}

void Cmd_Alias_Out_f (void)
{
	cmd_alias_t	*alias;
	cvar_t		*var;
	int			options;

	if (Cmd_Argc() < 3 || Cmd_Argc() > 4) {
		Com_Printf ("alias_out <alias> <cvar> [options]\n");
		return;
	}

	options = atoi(Cmd_Argv(3));

	alias = Cmd_FindAlias(Cmd_Argv(1));
	if (!alias) {
		Com_Printf ("alias_out: unknown alias \"%s\"\n", Cmd_Argv(1));
		return;
	}

	var = Cvar_Find(Cmd_Argv(2));
	if (!var) {
		Com_Printf ("alias_out: unknown cvar \"%s\"\n", Cmd_Argv(2));
		return;
	}

	if (!do_out (alias->value, var->string, options)) {
		if (!(options & 2))
			Com_Printf ("alias_out: not found\n");
		return;
	}
}

void Cmd_Cvar_In_f (void)
{
	cvar_t		*var1;
	cvar_t		*var2;
	char		buf[1024];
	char		*var_name;
	int			options;

	if (Cmd_Argc() < 3 || Cmd_Argc() > 4) {
		Com_Printf ("cvar_in <cvar1> <cvar2> [<options>]\n");
		return;
	}

	var_name = Cmd_Argv(1);
	options = atoi(Cmd_Argv(3));

	var1 = Cvar_Find(var_name);
	if (!var1) {
		if ((options & 8)) {
			var1 = Cvar_Create (var_name, "", 0);
		} else {
			Com_Printf ("cvar_in: unknown cvar \"%s\"\n", var_name);
			return;
		}
	}

	var2 = Cvar_Find(Cmd_Argv(2));
	if (!var2) {
		Com_Printf ("cvar_in: unknown cvar \"%s\"\n", Cmd_Argv(2));
		return;
	}

	if (!do_in (buf, var1->string, var2->string, options)) {
		if (options & 4)
			Com_Printf ("cvar_in: already inserted\n");
		return;
	}

	Cvar_Set (var1, buf);
}

void Cmd_Cvar_Out_f (void)
{
	cvar_t		*var1;
	cvar_t		*var2;
	char		buf[1024];
	int			options;

	if (Cmd_Argc()<3 || Cmd_Argc()>4){
		Com_Printf ("cvar_out <cvar1> <cvar2> [<options>]\n");
		return;
	}

	options = atoi(Cmd_Argv(3));
	var1 = Cvar_Find(Cmd_Argv(1));
	if (!var1) {
		Com_Printf ("cvar_out: unknown cvar \"%s\"\n", Cmd_Argv(1));
		return;
	}

	var2 = Cvar_Find(Cmd_Argv(2));
	if (!var2) {
		Com_Printf ("cvar_out: unknown cvar \"%s\"\n", Cmd_Argv(2));
		return;
	}

	strcpy (buf, var1->string);
	if (!do_out (buf, var2->string, options)) {
		if (!(options & 2))
			Com_Printf ("cvar_out: not found\n");
		return;
	}

	Cvar_Set (var1, buf);
}
// <-- QW262


void Cmd_Init (void)
{
	// register our commands
	Cmd_AddCommand ("exec", Cmd_Exec_f);
#ifndef SERVERONLY
	Cmd_AddCommand ("serverexec", Cmd_Exec_f);
#endif
	Cmd_AddCommand ("echo", Cmd_Echo_f);
	Cmd_AddCommand ("aliaslist", Cmd_AliasList_f);
	Cmd_AddCommand ("aliasedit", Cmd_AliasEdit_f);
	Cmd_AddCommand ("alias", Cmd_Alias_f);
	Cmd_AddCommand ("tempalias", Cmd_Alias_f);
	Cmd_AddCommand ("viewalias", Cmd_Viewalias_f);
	Cmd_AddCommand ("unaliasall", Cmd_UnAliasAll_f);
	Cmd_AddCommand ("unalias", Cmd_UnAlias_f);
	Cmd_AddCommand ("unalias_re", Cmd_UnAlias_re_f);
	Cmd_AddCommand ("wait", Cmd_Wait_f);
	Cmd_AddCommand ("cmdlist", Cmd_CmdList_f);
	Cmd_AddCommand ("cmdlist_re", Cmd_CmdList_re_f);
	Cmd_AddCommand ("if", Cmd_If_f);
	Cmd_AddCommand ("if_exists", Cmd_If_Exists_f);
	Cmd_AddCommand ("eval", Cmd_Eval_f);
	Cmd_AddCommand ("clipboard", Cmd_Clipboard_f);
// QW262 -->
	Cmd_AddCommand ("alias_in", Cmd_Alias_In_f);
	Cmd_AddCommand ("alias_out", Cmd_Alias_Out_f);
	Cmd_AddCommand ("cvar_in", Cmd_Cvar_In_f);
	Cmd_AddCommand ("cvar_out", Cmd_Cvar_Out_f);
// <-- QW262

	Cvar_Register(&cl_curlybraces);
	Cvar_Register(&cl_warnexec);
	Cvar_Register(&cl_remote_capabilities);
	Cvar_Register(&cl_allow_downloads);
	Cvar_Register(&cl_allow_uploads);

	Cmd_AddCommand ("macrolist", Cmd_MacroList_f);
	qsort(msgtrigger_commands,
	      sizeof(msgtrigger_commands)/sizeof(msgtrigger_commands[0]),
	      sizeof(msgtrigger_commands[0]),Commands_Compare_Func);
}

void Cmd_Shutdown(void)
{
	int i;
	cmd_alias_t* alias;
	cmd_alias_t* next_alias;
	cmd_function_t* cmd;
	cmd_function_t* next_cmd;
	legacycmd_t* legacycmd;
	legacycmd_t* next_legacycmd;

	Sys_Printf("Cmd_Shutdown(aliases)\n");
	for (i = 0; i < sizeof(cmd_alias_hash) / sizeof(cmd_alias_hash[0]); ++i) {
		cmd_alias_hash[i] = NULL;
	}

	for (alias = cmd_alias; alias; alias = next_alias) {
		next_alias = alias->next;
		Q_free(alias->value);
		Q_free(alias);
	}
	cmd_alias = NULL;

	Sys_Printf("Cmd_Shutdown(functions)\n");
	for (cmd = cmd_functions; cmd; cmd = next_cmd) {
		next_cmd = cmd->next;

		if (cmd->zmalloced) {
			Q_free(cmd);
		}
	}
	cmd_functions = NULL;

	Sys_Printf("Cmd_Shutdown(legacy)\n");
	for (legacycmd = legacycmds; legacycmd; legacycmd = next_legacycmd) {
		next_legacycmd = legacycmd->next;
		Q_free(legacycmd);
	}
}


================================================
FILE: src/cmd.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// cmd.h -- Command buffer and command execution

//===========================================================================

/*
Any number of commands can be added in a frame, from several different sources.
Most commands come from either keybindings or console line input, but remote
servers can also send across commands and entire text files can be execed.

The + command line options are also added to the command buffer.

The game starts with a Cbuf_AddText ("exec quake.rc\n"); Cbuf_Execute ();
*/

typedef struct cbuf_s {
	char*   text_buf;
	size_t  maxsize;
	size_t  text_start;
	size_t  text_end;
	qbool   wait;
	int     waitCount;
	int     runAwayLoop;
} cbuf_t;

extern cbuf_t cbuf_main;
extern cbuf_t cbuf_safe; // msg_trigger commands
extern cbuf_t cbuf_formatted_comms;
extern cbuf_t cbuf_svc; // svc_stufftext commands
extern cbuf_t cbuf_server;  // mod commands
extern cbuf_t *cbuf_current;

void Cbuf_AddTextEx (cbuf_t *cbuf, const char *text);
void Cbuf_InsertTextEx (cbuf_t *cbuf, const char *text);
void Cbuf_ExecuteEx (cbuf_t *cbuf);

void Cbuf_Init (void);
// allocates an initial text buffer that will grow as needed

void Cbuf_AddText (const char *text);
// as new commands are generated from the console or keybindings,
// the text is added to the end of the command buffer.

void Cbuf_InsertText (const char *text);
// when a command wants to issue other commands immediately, the text is
// inserted at the beginning of the buffer, before any remaining unexecuted
// commands.

void Cbuf_Execute (void);
// Pulls off \n terminated lines of text from the command buffer and sends
// them through Cmd_ExecuteString.  Stops when the buffer is empty.
// Normally called once per frame, but may be explicitly invoked.
// Do not call inside a command function!

void Cbuf_Flush(cbuf_t* cbuf);
// Intended for startup... keeps executing until empty

//===========================================================================

/*
Command execution takes a null terminated string, breaks it into tokens,
then searches for a command or variable that matches the first token.
*/

typedef void (*xcommand_t) (void);

typedef struct cmd_function_s {
	struct cmd_function_s	*hash_next;
	struct cmd_function_s	*next;
	char					*name;
	xcommand_t				function;
	qbool                   zmalloced;
} cmd_function_t;

void Cmd_Init (void);
void Cmd_Shutdown (void);

void Cmd_AddCommand (char *cmd_name, xcommand_t function);
// called by the init functions of other parts of the program to
// register commands and functions to call for them.
// The cmd_name is referenced later, so it should not be in temp memory
// if function is NULL, the command will be forwarded to the server
// as a clc_stringcmd instead of executed locally

// plugins use it; command is Q_malloced, name is stored within the same memory piece
qbool Cmd_AddRemCommand (char *cmd_name, xcommand_t function);

// only used by plugins, other commands stay in the client forever
void Cmd_RemoveCommand (char *cmd_name);

qbool Cmd_Exists (char *cmd_name);
// used by the cvar code to check for cvar / command name overlap

cmd_function_t *Cmd_FindCommand (const char *cmd_name);  // for message triggers

char *Cmd_CompleteCommand (char *partial);
// attempts to match a partial command for automatic command line completion
// returns NULL if nothing fits

#define	MAX_ARGS		80

typedef struct tokenizecontext_s
{
	int		cmd_argc; // arguments count
	char	*cmd_argv[MAX_ARGS]; // links to argv_buf[]

	// FIXME: MAX_COM_TOKEN not defined here, need redesign headers or something

	char	argv_buf[/*MAX_COM_TOKEN*/ 1024]; // here we store data for *cmd_argv[]

	char	cmd_args[/*MAX_COM_TOKEN*/ 1024 * 2]; // here we store original of what we parse, from argv(1) to argv(argc() - 1)

	char	text[/*MAX_COM_TOKEN*/ 1024]; // this is used/overwrite each time we using Cmd_MakeArgs()

} tokenizecontext_t;

int Cmd_ArgcEx (tokenizecontext_t *ctx);
char *Cmd_ArgvEx (tokenizecontext_t *ctx, int arg);

//Returns a single string containing argv(1) to argv(argc() - 1)
char *Cmd_ArgsEx (tokenizecontext_t *ctx);

//Returns a single string containing argv(start) to argv(argc() - 1)
//Unlike Cmd_Args, shrinks spaces between argvs
char *Cmd_MakeArgsEx (tokenizecontext_t *ctx, int start);

//Parses the given string into command line tokens.
void Cmd_TokenizeStringEx (tokenizecontext_t *ctx, const char *text);

int	Cmd_Argc (void);
char *Cmd_Argv (int arg);
char *Cmd_Args (void);
char *Cmd_MakeArgs (int start);

// save cmd_tokenizecontext struct to ctx
void Cmd_SaveContext(tokenizecontext_t *ctx);

// restore cmd_tokenizecontext struct from ctx
void Cmd_RestoreContext(tokenizecontext_t *ctx);

// The functions that execute commands get their parameters with these
// functions. Cmd_Argv () will return an empty string, not a NULL
// if arg > argc, so string operations are always safe.

void Cmd_ExpandString (const char *data, char *dest);
// Expands all $cvar or $macro expressions.
// dest should point to a 1024-byte buffer

void Cmd_TokenizeString (const char *text);
// Takes a null terminated string.  Does not need to be /n terminated.
// breaks the string up into arg tokens.

void Cmd_ExecuteString (char *text);
// Parses a single line of text into arguments and tries to execute it
// as if it was typed at the console

void Cmd_ForwardToServer (void);
// adds the current command line as a clc_stringcmd to the client message.
// things like godmode, noclip, etc, are commands directed to the server,
// so when they are typed in at the console, they will need to be forwarded.

void Cbuf_AddEarlyCommands (void);
void Cmd_StuffCmds_f (void);
qbool Cmd_IsLegacyCommand (char *oldname);
void Cmd_AddLegacyCommand (char *oldname, char *newname);
qbool CL_IsDownloadableFileExtension(const char *filename);

//===========================================================================

#define	MAX_ALIAS_NAME 32

#define ALIAS_ARCHIVE			1
#define ALIAS_SERVER			2
#define ALIAS_TEMP				4
#define	ALIAS_HAS_PARAMETERS	8

typedef struct cmd_alias_s {
	struct cmd_alias_s	*hash_next;
	struct cmd_alias_s	*next;
	char				name[MAX_ALIAS_NAME];
	char				*value;
	int					flags;
} cmd_alias_t;

qbool Cmd_DeleteAlias (char *name);	// return true if successful
cmd_alias_t *Cmd_FindAlias (const char *name); // returns NULL on failure
char *Cmd_AliasString (char *name); // returns NULL on failure

void DeleteServerAliases (void);

#define	MAX_MACRO_NAME 32
#define MACRO_NORULES -1
#define MACRO_ALLOWED 0
#define MACRO_DISALLOWED 1

#include "macro_definitions.h"

void Cmd_AddMacro(macro_id id, char *(*f)(void));
void Cmd_AddMacroEx(macro_id id, char *(*f)(void), int teamplay);
char* Cmd_MacroString(const char *s, int *macro_length);
const char* Cmd_MacroName(macro_id id);
qbool Cmd_MacroTeamplayRestricted(macro_id id);

// only here for enumerating from keys.c (tab-complete) - move to cmd.c
typedef struct legacycmd_s
{
	char* oldname, * newname;
	cmd_function_t dummy_cmd;
	struct legacycmd_s* next;
} legacycmd_t;

extern legacycmd_t* legacycmds;


================================================
FILE: src/cmdline_params.h
================================================

#ifndef EZQUAKE_CMDLINE_PARAMS_H
#define EZQUAKE_CMDLINE_PARAMS_H

#define CMDLINE_DEF(x, str) cmdline_param_ ## x

typedef enum {
#include "cmdline_params_ids.h"
	num_cmdline_params
} cmdline_param_id;

#undef CMDLINE_DEF

#endif // EZQUAKE_CMDLINE_PARAMS_H



================================================
FILE: src/cmdline_params_ids.h
================================================

CMDLINE_DEF(client_nosound, "-nosound"),
CMDLINE_DEF(client_democache, "-democache"),
CMDLINE_DEF(client_norjscripts, "-norjscripts"),
CMDLINE_DEF(client_noscripts, "-noscripts"),
CMDLINE_DEF(client_noindphys, "-noindphys"),
CMDLINE_DEF(client_nomultitexturing, "-nomtex"),
CMDLINE_DEF(client_no_npot_textures, "-nonpot"),
CMDLINE_DEF(client_notriplebuffering, "-no-triple-gl-buffer"),
CMDLINE_DEF(client_noinverselightmaps, "-noinvlmaps"),
CMDLINE_DEF(client_forwardonlyprofile, "-gl-forward-only-profile"),
CMDLINE_DEF(client_detailtrails, "-detailtrails"),
CMDLINE_DEF(client_maximum2textureunits, "-maxtmu2"),
CMDLINE_DEF(client_no24bittextures, "-no24bit"),
CMDLINE_DEF(client_forcetexturereload, "-forcetexturereload"),
CMDLINE_DEF(client_showlibraryerrors, "-showliberrors"),
CMDLINE_DEF(client_ruleset, "-ruleset"),
CMDLINE_DEF(client_particlecount, "-particles"),
CMDLINE_DEF(client_nohardwaretimers, "-nohwtimer"),
CMDLINE_DEF(client_allowmultipleclients, "-allowmultiple"),
CMDLINE_DEF(client_unaccelerated_visuals, "-no-accel-visuals"),
CMDLINE_DEF(client_printopenglextensions, "-gl_ext"),
CMDLINE_DEF(client_gamma, "-gamma"),
CMDLINE_DEF(client_nohardwaregamma, "-nohwgamma"),
CMDLINE_DEF(client_oldgammabehaviour, "-oldgamma"),
CMDLINE_DEF(client_windowedmode, "-window"),
CMDLINE_DEF(client_startwindowed, "-startwindowed"),
CMDLINE_DEF(client_video_frequency, "-freq"),
CMDLINE_DEF(client_video_bpp, "-bpp"),
CMDLINE_DEF(client_video_width, "-width"),
CMDLINE_DEF(client_video_height, "-height"),
CMDLINE_DEF(client_video_displaynumber, "-display"),
CMDLINE_DEF(client_video_conwidth, "-conwidth"),
CMDLINE_DEF(client_video_conheight, "-conheight"),
CMDLINE_DEF(client_video_glsl_renderer, "-glsl-renderer"),
CMDLINE_DEF(client_video_r_debug, "-r-debug"),
CMDLINE_DEF(client_video_r_trace, "-r-trace"),
CMDLINE_DEF(client_video_r_dump_shaders, "-r-dump-shaders"),
CMDLINE_DEF(client_nostdinput, "-noconinput"),
CMDLINE_DEF(client_nostdoutput, "-nostdout"),
CMDLINE_DEF(client_nolibpng, "-nolibpng"),
CMDLINE_DEF(client_nolibjpeg, "-nolibjpeg"),
CMDLINE_DEF(client_video_nodesktopres, "-nodesktopres"),
CMDLINE_DEF(client_cd_audio, "-cdaudio"),
CMDLINE_DEF(client_cd_device, "-cddev"),
CMDLINE_DEF(client_noatlas, "-noatlas"),
CMDLINE_DEF(client_verify_glstate, "-r-verify"),
CMDLINE_DEF(client_novao, "-r-novao"),
CMDLINE_DEF(client_nocallback, "-r-nocallback"),
CMDLINE_DEF(client_nomultibind, "-r-nomultibind"),
CMDLINE_DEF(client_no_amd_fix, "-r-no-amd-fix"),

CMDLINE_DEF(filesystem_basedir, "-basedir"),
CMDLINE_DEF(filesystem_nohome, "-nohome"),
CMDLINE_DEF(filesystem_userdir, "-userdir"),
CMDLINE_DEF(filesystem_game, "-game"),
CMDLINE_DEF(filesystem_data, "-data"),

CMDLINE_DEF(host_memory_minimum, "-minmemory"),
CMDLINE_DEF(host_memory_kb, "-heapsize"),
CMDLINE_DEF(host_memory_mb, "-mem"),

CMDLINE_DEF(net_ipaddress, "-ip"),
CMDLINE_DEF(net_clientport, "-clientport"),
CMDLINE_DEF(net_serverport, "-port"),

CMDLINE_DEF(console_buffersize, "-conbufsize"),
CMDLINE_DEF(console_debug, "-condebug"),
CMDLINE_DEF(developer_mode, "-dev"),

CMDLINE_DEF(server_progtype, "-progtype"),
CMDLINE_DEF(server_enablecheats, "-cheats"),
CMDLINE_DEF(server_enablelocalcommand, "-enablelocalcommand"),
CMDLINE_DEF(server_democache_kb, "-democache"),
// leave trailing ,



================================================
FILE: src/cmodel.c
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// cmodel.c - collision model.

#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "common.h"
#include "cvar.h"
#endif

typedef struct cnode_s {
	// common with leaf
	int                contents; // 0, to differentiate from leafs
	struct cnode_s     *parent;

	// node specific
	mplane_t           *plane;
	struct cnode_s     *children[2];	
} cnode_t;

typedef struct cleaf_s {
	// common with node
	int                contents;         // a negative contents number
	struct cnode_s     *parent;

	// leaf specific
	byte               ambient_sound_level[NUM_AMBIENTS];
} cleaf_t;

static char			loadname[32];	// for hunk tags

static char			map_name[MAX_QPATH];
static unsigned int	map_checksum, map_checksum2;

static int			numcmodels;
static cmodel_t		map_cmodels[MAX_MAP_MODELS];

static mplane_t		*map_planes;
static int			numplanes;

static cnode_t		*map_nodes;
static int			numnodes;

static mclipnode_t	*map_clipnodes;
static int			numclipnodes;

static cleaf_t		*map_leafs;
static int			numleafs;
static int			visleafs;

static byte			map_novis[MAX_MAP_LEAFS/8];

static byte			*map_pvs;					// fully expanded and decompressed
static byte			*map_phs;					// only valid if we are the server
static int			map_vis_rowbytes;			// for both pvs and phs
static int			map_vis_rowlongs;			// map_vis_rowbytes / 4

static char			*map_entitystring;

static qbool		map_halflife;

static mphysicsnormal_t* map_physicsnormals;     // must be same number as clipnodes to save reallocations in worst case scenario

// lumps immediately follow:
typedef struct {
	char lumpname[24];
	int fileofs;
	int filelen;
} bspx_lump_t;

static bspx_lump_t* CM_LoadBSPX(vfsfile_t* vf, dheader_t* header, bspx_header_t *xheader);
static byte* CM_BSPX_ReadLump(vfsfile_t* vf, bspx_header_t *xheader, bspx_lump_t* lump, char* lumpname, int* plumpsize);

/*
===============================================================================

HULL BOXES

===============================================================================
*/

static hull_t		box_hull;
static mclipnode_t	box_clipnodes[6];
static mplane_t		box_planes[6];

/*
** CM_InitBoxHull
**
** Set up the planes and clipnodes so that the six floats of a bounding box
** can just be stored out and get a proper hull_t structure.
*/
static void CM_InitBoxHull(void)
{
	int side, i;

	box_hull.clipnodes = box_clipnodes;
	box_hull.planes = box_planes;
	box_hull.firstclipnode = 0;
	box_hull.lastclipnode = 5;

	for (i = 0; i < 6; i++) {
		box_clipnodes[i].planenum = i;
		side = i & 1;
		box_clipnodes[i].children[side] = CONTENTS_EMPTY;
		box_clipnodes[i].children[side ^ 1] = (i != 5) ? (i + 1) : CONTENTS_SOLID;
		box_planes[i].type = i >> 1;
		box_planes[i].normal[i >> 1] = 1;
	}
}

/*
** CM_HullForBox
**
** To keep everything totally uniform, bounding boxes are turned into small
** BSP trees instead of being compared directly.
*/
hull_t *CM_HullForBox (vec3_t mins, vec3_t maxs)
{
	box_planes[0].dist = maxs[0];
	box_planes[1].dist = mins[0];
	box_planes[2].dist = maxs[1];
	box_planes[3].dist = mins[1];
	box_planes[4].dist = maxs[2];
	box_planes[5].dist = mins[2];

	return &box_hull;
}

int CM_CachedHullPointContents(hull_t* hull, int num, vec3_t p, float* min_dist)
{
	mclipnode_t* node;
	mplane_t* plane;
	float d;

	*min_dist = 999;
	while (num >= 0) {
		if (num < hull->firstclipnode || num > hull->lastclipnode) {
			if (map_halflife && num == hull->lastclipnode + 1) {
				return CONTENTS_EMPTY;
			}
			Sys_Error("CM_HullPointContents: bad node number");
		}

		node = hull->clipnodes + num;
		plane = hull->planes + node->planenum;

		d = PlaneDiff(p, plane);
		if (d < 0) {
			*min_dist = min(*min_dist, -d);
			num = node->children[1];
		}
		else {
			*min_dist = min(*min_dist, d);
			num = node->children[0];
		}
	}

	return num;
}

int CM_HullPointContents(hull_t *hull, int num, vec3_t p)
{
	mclipnode_t *node;
	mplane_t *plane;
	float d;

	while (num >= 0) {
		if (num < hull->firstclipnode || num > hull->lastclipnode) {
			if (map_halflife && num == hull->lastclipnode + 1) {
				return CONTENTS_EMPTY;
			}
			Sys_Error("CM_HullPointContents: bad node number");
		}

		node = hull->clipnodes + num;
		plane = hull->planes + node->planenum;

		d = PlaneDiff(p, plane);
		num = (d < 0) ? node->children[1] : node->children[0];
	}

	return num;
}

/*
===============================================================================

LINE TESTING IN HULLS

===============================================================================
*/

// 1/32 epsilon to keep floating point happy
#define	DIST_EPSILON	0.03125

enum { TR_EMPTY, TR_SOLID, TR_BLOCKED };

typedef struct {
	hull_t *hull;
	trace_t	trace;
	int leafcount;
} hulltrace_local_t;

//====================
int RecursiveHullTrace (hulltrace_local_t *htl, int num, float p1f, float p2f, const vec3_t p1, const vec3_t p2)
{
	mplane_t	*plane;
	float		t1, t2;
	mclipnode_t *node;
	int			i;
	int			nearside;
	float		frac, midf;
	vec3_t		mid;
	int			check, oldcheck;
	hull_t *hull = htl->hull;
	trace_t *trace = &htl->trace;

start:
	if (num < 0) {
		// this is a leaf node
		htl->leafcount++;
		if (num == CONTENTS_SOLID) {
			if (htl->leafcount == 1)
				trace->startsolid = true;
			return TR_SOLID;
		}
		else {
			if (num == CONTENTS_EMPTY)
				trace->inopen = true;
			else
				trace->inwater = true;
			return TR_EMPTY;
		}
	}

	// FIXME, check at load time
	if (num < hull->firstclipnode || num > hull->lastclipnode)
	{
		if (map_halflife && num == hull->lastclipnode + 1)
			return TR_EMPTY;
		Sys_Error ("RecursiveHullTrace: bad node number");
	}

	node = hull->clipnodes + num;

	//
	// find the point distances
	//
	plane = hull->planes + node->planenum;

	if (plane->type < 3) {
		t1 = p1[plane->type] - plane->dist;
		t2 = p2[plane->type] - plane->dist;
	}
	else {
		t1 = DotProduct (plane->normal, p1) - plane->dist;
		t2 = DotProduct (plane->normal, p2) - plane->dist;
	}

	// see which sides we need to consider
	if (t1 >= 0 && t2 >= 0) {
		num = node->children[0];	// go down the front side
		goto start;
	}
	if (t1 < 0 && t2 < 0) {
		num = node->children[1];	// go down the back side
		goto start;
	}

	// find the intersection point
	frac = t1 / (t1 - t2);
	frac = bound (0, frac, 1);
	midf = p1f + (p2f - p1f)*frac;
	for (i = 0; i < 3; i++)
		mid[i] = p1[i] + frac*(p2[i] - p1[i]);

	// move up to the node
	nearside = (t1 < t2) ? 1 : 0;
	check = RecursiveHullTrace (htl, node->children[nearside], p1f, midf, p1, mid);
	if (check == TR_BLOCKED)
		return check;

	// if we started in solid, allow us to move out to an empty area
	if (check == TR_SOLID && (trace->inopen || trace->inwater))
		return check;
	oldcheck = check;

	// go past the node
	check = RecursiveHullTrace (htl, node->children[1 - nearside], midf, p2f, mid, p2);
	if (check == TR_EMPTY || check == TR_BLOCKED)
		return check;

	if (oldcheck != TR_EMPTY)
		return check;	// still in solid

	// near side is empty, far side is solid
	// this is the impact point
	if (!nearside) {
		VectorCopy (plane->normal, trace->plane.normal);
		trace->plane.dist = plane->dist;
	}
	else {
		VectorNegate (plane->normal, trace->plane.normal);
		trace->plane.dist = -plane->dist;
	}

	// put the final point DIST_EPSILON pixels on the near side
	if (t1 < t2)
		frac = (t1 + DIST_EPSILON) / (t1 - t2);
	else
		frac = (t1 - DIST_EPSILON) / (t1 - t2);
	frac = bound (0, frac, 1);
	midf = p1f + (p2f - p1f)*frac;
	for (i = 0; i < 3; i++)
		mid[i] = p1[i] + frac*(p2[i] - p1[i]);

	trace->fraction = midf;
	VectorCopy (mid, trace->endpos);
	trace->physicsnormal = (!nearside ? num + 1 : -(num + 1));

	return TR_BLOCKED;
}

trace_t CM_HullTrace (hull_t *hull, vec3_t start, vec3_t end)
{
	int check;

	// this structure is passed as a pointer to RecursiveHullTrace
	// so as not to use much stack but still be thread safe
	hulltrace_local_t htl;
	htl.hull = hull;
	htl.leafcount = 0;
	// fill in a default trace
	memset (&htl.trace, 0, sizeof(htl.trace));
	htl.trace.fraction = 1;
	htl.trace.startsolid = false;
	VectorCopy (end, htl.trace.endpos);

	check = RecursiveHullTrace (&htl, hull->firstclipnode, 0, 1, start, end);

	if (check == TR_SOLID) {
		htl.trace.startsolid = htl.trace.allsolid = true;
		// it would be logical to set fraction to 0, but original id code
		// would leave it at 1.   We emulate that just in case.
		// (FIXME: is it just QW, or NQ as well?)
		//htl.trace.fraction = 0;
		VectorCopy (start, htl.trace.endpos);
	}

	return htl.trace;
}

//===========================================================================

int	CM_NumInlineModels (void)
{
	return numcmodels;
}

char *CM_EntityString (void)
{
	return map_entitystring;
}

int CM_Leafnum (const cleaf_t *leaf)
{
	assert (leaf);
	return leaf - map_leafs;
}

int	CM_LeafAmbientLevel (const cleaf_t *leaf, int ambient_channel)
{
	assert ((unsigned)ambient_channel <= NUM_AMBIENTS);
	assert (leaf);

	return leaf->ambient_sound_level[ambient_channel];
}

// always returns a valid cleaf_t pointer
cleaf_t *CM_PointInLeaf (const vec3_t p)
{
	float d;
	cnode_t *node;
	mplane_t *plane;

	if (!numnodes)
		Host_Error ("CM_PointInLeaf: numnodes == 0");

	node = map_nodes;
	while (1) {
		if (node->contents < 0) {
			return (cleaf_t *)node;
		}

		plane = node->plane;
		d = DotProduct(p, plane->normal) - plane->dist;
		node = (d > 0) ? node->children[0] : node->children[1];
	}

	return NULL; // never reached
}


byte *CM_LeafPVS (const cleaf_t *leaf)
{
	if (leaf == map_leafs)
		return map_novis;

	return map_pvs + (leaf - 1 - map_leafs) * map_vis_rowbytes;
}


/*
** only the server may call this
*/
byte *CM_LeafPHS (const cleaf_t *leaf)
{
	if (leaf == map_leafs)
		return map_novis;

	if (!map_phs) {
		return NULL;
	}

	return map_phs + (leaf - 1 - map_leafs) * map_vis_rowbytes;
}

/*
=============================================================================

The PVS must include a small area around the client to allow head bobbing
or other small motion on the client side.  Otherwise, a bob might cause an
entity that should be visible to not show up, especially when the bob
crosses a waterline.

=============================================================================
*/

static int	fatbytes;
static byte	fatpvs[MAX_MAP_LEAFS/8];
static vec3_t	fatpvs_org;

static void AddToFatPVS_r (cnode_t *node)
{
	int i;
	float d;
	byte *pvs;
	mplane_t *plane;

	while (1)
	{ // if this is a leaf, accumulate the pvs bits
		if (node->contents < 0)
		{
			if (node->contents != CONTENTS_SOLID)
			{
				pvs = CM_LeafPVS ( (cleaf_t *)node);
				for (i=0 ; i<fatbytes ; i++)
					fatpvs[i] |= pvs[i];
			}
			return;
		}

		plane = node->plane;
		d = DotProduct (fatpvs_org, plane->normal) - plane->dist;
		if (d > 8)
			node = node->children[0];
		else if (d < -8)
			node = node->children[1];
		else
		{ // go down both
			AddToFatPVS_r (node->children[0]);
			node = node->children[1];
		}
	}
}

/*
=============
CM_FatPVS

Calculates a PVS that is the inclusive or of all leafs within 8 pixels of the
given point.
=============
*/
byte *CM_FatPVS (vec3_t org)
{
	VectorCopy (org, fatpvs_org);

	fatbytes = (visleafs+31)>>3;
	memset (fatpvs, 0, fatbytes);
	AddToFatPVS_r (map_nodes);
	return fatpvs;
}


/*
** Recursively build a list of leafs touched by a rectangular volume
*/
static int leafs_count;
static int leafs_maxcount;
static qbool leafs_overflow;
static int *leafs_list;
static int leafs_topnode;
static vec3_t leafs_mins, leafs_maxs;

static void FindTouchedLeafs_r(const cnode_t *node)
{
	mplane_t *splitplane;
	cleaf_t *leaf;
	int sides;

	while (1) {
		if (node->contents == CONTENTS_SOLID) {
			return;
		}

		// the node is a leaf
		if (node->contents < 0) {
			if (leafs_count == leafs_maxcount) {
				leafs_overflow = true;
				return;
			}

			leaf = (cleaf_t *)node;
			leafs_list[leafs_count++] = leaf - map_leafs;
			return;
		}

		// NODE_MIXED
		splitplane = node->plane;
		sides = BOX_ON_PLANE_SIDE(leafs_mins, leafs_maxs, splitplane);

		// recurse down the contacted sides
		if (sides == 1) {
			node = node->children[0];
		}
		else if (sides == 2) {
			node = node->children[1];
		}
		else {
			if (leafs_topnode == -1) {
				leafs_topnode = node - map_nodes;
			}
			FindTouchedLeafs_r(node->children[0]);
			node = node->children[1];
		}
	}
}

/*
** Returns an array filled with leaf nums
*/
int CM_FindTouchedLeafs (const vec3_t mins, const vec3_t maxs, int leafs[], int maxleafs, int headnode, int *topnode)
{
	leafs_count = 0;
	leafs_maxcount = maxleafs;
	leafs_list = leafs;
	leafs_topnode = -1;
	leafs_overflow = false;
	VectorCopy (mins, leafs_mins);
	VectorCopy (maxs, leafs_maxs);

	FindTouchedLeafs_r (&map_nodes[headnode]);

	if (leafs_overflow) {
		leafs_count = -1;
	}

	if (topnode)
		*topnode = leafs_topnode;

	return leafs_count;
}


/*
===============================================================================

                          BRUSHMODEL LOADING

===============================================================================
*/

static void CM_LoadEntities (byte *buffer, int length)
{
	if (!length) {
		map_entitystring = NULL;
		return;
	}
	map_entitystring = (char *) Hunk_AllocName (length, loadname);
	memcpy (map_entitystring, buffer, length);
}


/*
=================
CM_LoadSubmodels
=================
*/
static void CM_LoadSubmodels (byte *buffer, int length)
{
	dmodel_t *in;
	cmodel_t *out;
	int i, j, count;

	in = (dmodel_t *) buffer;

	if (length % sizeof(*in))
		Host_Error ("CM_LoadMap: funny lump size");

	count = length / sizeof(*in);

	if (count < 1)
		Host_Error ("Map with no models");

	if (count > MAX_MAP_MODELS)
		Host_Error ("Map has too many models (%d vs %d)", count, MAX_MAP_MODELS);

	out = map_cmodels;
	numcmodels = count;

	visleafs = LittleLong (in[0].visleafs);

	for (i = 0; i < count; i++, in++, out++)
	{
		for (j = 0; j < 3; j++) {
			// spread the mins / maxs by a pixel
			out->mins[j] = LittleFloat (in->mins[j]) - 1;
			out->maxs[j] = LittleFloat (in->maxs[j]) + 1;
			out->origin[j] = LittleFloat (in->origin[j]);
		}
		for (j = 0; j < MAX_MAP_HULLS; j++) {
			out->hulls[j].planes = map_planes;
			out->hulls[j].clipnodes = map_clipnodes;
			out->hulls[j].firstclipnode = LittleLong (in->headnode[j]);
			out->hulls[j].lastclipnode = numclipnodes - 1;
		}

		VectorClear (out->hulls[0].clip_mins);
		VectorClear (out->hulls[0].clip_maxs);

		if (map_halflife)
		{
			VectorSet (out->hulls[1].clip_mins, -16, -16, -36);
			VectorSet (out->hulls[1].clip_maxs, 16, 16, 36);

			VectorSet (out->hulls[2].clip_mins, -32, -32, -36);
			VectorSet (out->hulls[2].clip_maxs, 32, 32, 36);
			// not really used
			VectorSet (out->hulls[3].clip_mins, -16, -16, -18);
			VectorSet (out->hulls[3].clip_maxs, 16, 16, 18);
		}
		else
		{
			VectorSet (out->hulls[1].clip_mins, -16, -16, -24);
			VectorSet (out->hulls[1].clip_maxs, 16, 16, 32);

			VectorSet (out->hulls[2].clip_mins, -32, -32, -24);
			VectorSet (out->hulls[2].clip_maxs, 32, 32, 64);
		}
	}
}

/*
=================
CM_SetParent
=================
*/
static void CM_SetParent (cnode_t *node, cnode_t *parent)
{
	node->parent = parent;
	if (node->contents < 0)
		return;
	CM_SetParent (node->children[0], node);
	CM_SetParent (node->children[1], node);
}

/*
=================
CM_LoadNodes
=================
*/
static void CM_LoadNodes (byte *buffer, int length)
{
	int i, j, count, p;
	dnode_t *in;
	cnode_t *out;

	in = (dnode_t *) buffer;
	if (length % sizeof(*in))
		Host_Error ("CM_LoadMap: funny lump size");

	count = length / sizeof(*in);
	out = (cnode_t *) Hunk_AllocName ( count*sizeof(*out), loadname);

	map_nodes = out;
	numnodes = count;

	for (i = 0; i < count; i++, in++, out++)
	{
		p = LittleLong(in->planenum);
		out->plane = map_planes + p;

		for (j=0 ; j<2 ; j++)
		{
			p = LittleShort (in->children[j]);
			out->children[j] = (p >= 0) ? (map_nodes + p) : ((cnode_t *)(map_leafs + (-1 - p)));
		}
	}

	CM_SetParent (map_nodes, NULL); // sets nodes and leafs
}

static void CM_LoadNodes29a(byte *buffer, int length)
{
	int i, j, count, p;
	dnode29a_t *in;
	cnode_t *out;

	in = (dnode29a_t *) buffer;
	if (length % sizeof(*in))
		Host_Error("CM_LoadMap: funny lump size");

	count = length / sizeof(*in);
	out = (cnode_t *)Hunk_AllocName(count * sizeof(*out), loadname);

	map_nodes = out;
	numnodes = count;

	for (i = 0; i < count; i++, in++, out++) {
		p = LittleLong(in->planenum);
		out->plane = map_planes + p;

		for (j = 0; j < 2; j++) {
			p = LittleLong(in->children[j]);
			out->children[j] = (p >= 0) ? (map_nodes + p) : ((cnode_t *)(map_leafs + (-1 - p)));
		}
	}

	CM_SetParent(map_nodes, NULL); // sets nodes and leafs
}

static void CM_LoadNodesBSP2(byte *buffer, int length)
{
	int i, j, count, p;
	dnode_bsp2_t *in;
	cnode_t *out;

	in = (dnode_bsp2_t *) buffer;
	if (length % sizeof(*in))
		Host_Error("CM_LoadMap: funny lump size");

	count = length / sizeof(*in);
	out = (cnode_t *)Hunk_AllocName(count * sizeof(*out), loadname);

	map_nodes = out;
	numnodes = count;

	for (i = 0; i < count; i++, in++, out++) {
		p = LittleLong(in->planenum);
		out->plane = map_planes + p;

		for (j = 0; j < 2; j++) {
			p = LittleLong(in->children[j]);
			out->children[j] = (p >= 0) ? (map_nodes + p) : ((cnode_t *)(map_leafs + (-1 - p)));
		}
	}

	CM_SetParent(map_nodes, NULL); // sets nodes and leafs
}

/*
** CM_LoadLeafs
*/
static void CM_LoadLeafs (byte *buffer, int length)
{
	dleaf_t *in;
	cleaf_t *out;
	int i, j, count, p;

	in = (dleaf_t *) buffer;

	if (length % sizeof(*in))
		Host_Error ("CM_LoadMap: funny lump size");
	count = length / sizeof(*in);
	out = (cleaf_t *) Hunk_AllocName ( count*sizeof(*out), loadname);

	map_leafs = out;
	numleafs = count;

	for (i = 0; i < count; i++, in++, out++) {
		p = LittleLong(in->contents);
		out->contents = p;
		for (j = 0; j < 4; j++)
			out->ambient_sound_level[j] = in->ambient_level[j];
	}
}

static void CM_LoadLeafs29a (byte *buffer, int length)
{
	dleaf29a_t *in;

	cleaf_t *out;
	int i, j, count, p;

	in = (dleaf29a_t *) buffer;
	if (length % sizeof(*in)) {
		Host_Error("CM_LoadMap: funny lump size");
	}

	count = length / sizeof(*in);
	out = Hunk_AllocName ( count*sizeof(*out), loadname);

	map_leafs = out;
	numleafs = count;

	for (i = 0; i < count; i++, in++, out++) {
		p = LittleLong(in->contents);
		out->contents = p;
		for (j = 0; j < 4; j++)
			out->ambient_sound_level[j] = in->ambient_level[j];
	}

}

static void CM_LoadLeafsBSP2 (byte *buffer, int length)
{
	dleaf_bsp2_t *in;

	cleaf_t *out;
	int i, j, count, p;

	in = (dleaf_bsp2_t *) buffer;

	if (length % sizeof(*in)) {
		Host_Error("CM_LoadMap: funny lump size");
	}

	count = length / sizeof(*in);
	out = Hunk_AllocName ( count*sizeof(*out), loadname);

	map_leafs = out;
	numleafs = count;

	for (i = 0; i < count; i++, in++, out++) {
		p = LittleLong(in->contents);
		out->contents = p;
		for (j = 0; j < 4; j++)
			out->ambient_sound_level[j] = in->ambient_level[j];
	}
}

/*
=================
CM_LoadClipnodes
=================
*/
static void CM_LoadClipnodes(byte *buffer, int length)
{
	dclipnode_t *in;
	mclipnode_t *out;
	int i, count;

	in = (dclipnode_t *) buffer;
	if (length % sizeof(*in))
		Host_Error("CM_LoadMap: funny lump size");
	count = length / sizeof(*in);
	out = (mclipnode_t *)Hunk_AllocName(count * sizeof(*out), loadname);

	map_clipnodes = out;
	numclipnodes = count;

	for (i = 0; i < count; i++, out++, in++) {
		out->planenum = LittleLong(in->planenum);
		out->children[0] = LittleShort(in->children[0]);
		out->children[1] = LittleShort(in->children[1]);
	}
}

static void CM_LoadClipnodesBSP2(byte *buffer, int length)
{
	dclipnode29a_t *in;
	mclipnode_t *out;
	int i, count;

	in = (void *) buffer;
	if (length % sizeof(*in))
		Host_Error("CM_LoadMap: funny lump size");
	count = length / sizeof(*in);
	out = Hunk_AllocName(count * sizeof(*out), loadname);

	map_clipnodes = out;
	numclipnodes = count;

	for (i = 0; i < count; i++, out++, in++) {
		out->planenum = LittleLong(in->planenum);
		out->children[0] = LittleLong(in->children[0]);
		out->children[1] = LittleLong(in->children[1]);
	}
}

static qbool CM_LoadPhysicsNormalsData(byte* data, int datalength)
{
	mphysicsnormal_t* in = (mphysicsnormal_t*)(data + 8);
	int i;

	if (datalength != 8 + sizeof(map_physicsnormals[0]) * numclipnodes) {
		return false;
	}

#ifndef CLIENTONLY
	{
		float* cvars = (float*)data;
		extern cvar_t pm_rampjump;

		Cvar_SetValue(&pm_rampjump, LittleFloat(cvars[0]));
	}
#endif
	// Meag: previously the maximum speed was set here but I don't think it should be map-specific (?)

	for (i = 0; i < numclipnodes; ++i) {
		map_physicsnormals[i].normal[0] = LittleFloat(in[i].normal[0]);
		map_physicsnormals[i].normal[1] = LittleFloat(in[i].normal[1]);
		map_physicsnormals[i].normal[2] = LittleFloat(in[i].normal[2]);
		map_physicsnormals[i].flags = PHYSICSNORMAL_SET | (int)LittleLong(in[i].flags);
	}
	return true;
}

static void CM_LoadPhysicsNormals(byte *physnormals, int len_physnormals)
{
	// Same logic as .lit file support: load from bspx, allow over-ride with .qpn files
	//   As client-side movement prediction will be incorrect if physics normals don't
	//     match, I strongly recommend the .bspx solution
	int i;
	qbool bspx_loaded = false;

	// Allocate memory, all maps default to rampjump off
#ifndef CLIENTONLY
	{
		extern cvar_t pm_rampjump;
		Cvar_SetValue(&pm_rampjump, 0);
	}
#endif
	map_physicsnormals = Hunk_AllocName(numclipnodes * sizeof(map_physicsnormals[0]), loadname);

	// Try and load from BSPX lump
	if (physnormals) {
		bspx_loaded = CM_LoadPhysicsNormalsData(physnormals, len_physnormals);
		if (bspx_loaded) {
			Con_Printf("Loading BSPX physics normals\n");
		}
	}

	// If not supplied, initialise with default values from clipnodes
	if (!bspx_loaded) {
		for (i = 0; i < numclipnodes; ++i) {
			VectorCopy(map_planes[map_clipnodes[i].planenum].normal, map_physicsnormals[i].normal);
			map_physicsnormals[i].flags = PHYSICSNORMAL_SET;
		}
	}

	// Now over-ride from external file
	{
		char extfile[MAX_OSPATH];
		int extfilesize = 0;
		void* data = NULL;
		int mark;

		mark = Hunk_LowMark();
		snprintf(extfile, sizeof(extfile), "maps/%s.qpn", loadname);
		data = FS_LoadHunkFile(extfile, &extfilesize);
		if (data) {
			if (CM_LoadPhysicsNormalsData(data, extfilesize)) {
				Con_Printf("Loading external physics normals\n");
			}
			else {
				Con_Printf("%s is corrupt or wrong size\n", extfile);
			}
			Hunk_FreeToLowMark(mark);
		}
	}
}

/*
=================
CM_MakeHull0

Deplicate the drawing hull structure as a clipping hull
=================
*/
static void CM_MakeHull0(void)
{
	cnode_t *in, *child;
	mclipnode_t *out;
	int i, j, count;

	in = map_nodes;
	count = numnodes;
	out = (mclipnode_t *)Hunk_AllocName(count * sizeof(*out), loadname);

	// fix up hull 0 in all cmodels
	for (i = 0; i < numcmodels; i++) {
		map_cmodels[i].hulls[0].clipnodes = out;
		map_cmodels[i].hulls[0].lastclipnode = count - 1;
	}

	// build clipnodes from nodes
	for (i = 0; i < count; i++, out++, in++) {
		out->planenum = in->plane - map_planes;
		for (j = 0; j < 2; j++) {
			child = in->children[j];
			out->children[j] = (child->contents < 0) ? (child->contents) : (child - map_nodes);
		}
	}
}

/*
=================
CM_LoadPlanes
=================
*/
static void CM_LoadPlanes(byte *buffer, size_t length)
{
	int i, j, count, bits;
	mplane_t *out;
	dplane_t *in;

	in = (dplane_t *) buffer;

	if (length % sizeof(*in))
		Host_Error("CM_LoadMap: funny lump size");

	count = length / sizeof(*in);
	out = (mplane_t *)Hunk_AllocName(count * sizeof(*out), loadname);

	map_planes = out;
	numplanes = count;

	for (i = 0; i < count; i++, in++, out++) {
		bits = 0;
		for (j = 0; j < 3; j++) {
			out->normal[j] = LittleFloat(in->normal[j]);
			if (out->normal[j] < 0)
				bits |= 1 << j;
		}

		out->dist = LittleFloat(in->dist);
		out->type = LittleLong(in->type);
		out->signbits = bits;
	}
}


/*
** DecompressVis
*/
static byte *DecompressVis(byte *in)
{
	static byte decompressed[MAX_MAP_LEAFS / 8];
	int c, row;
	byte *out;

	row = (visleafs + 7) >> 3;
	out = decompressed;

	if (!in) { // no vis info, so make all visible
		while (row) {
			*out++ = 0xff;
			row--;
		}
		return decompressed;
	}

	do {
		if (*in) {
			*out++ = *in++;
			continue;
		}

		c = in[1];
		in += 2;
		while (c) {
			*out++ = 0;
			c--;
		}
	} while (out - decompressed < row);

	return decompressed;
}


/*
** CM_BuildPVS
**
** Call after CM_LoadLeafs!
*/
static void CM_BuildPVS(byte *visdata, int vis_len, byte *leaf_buf, int leaf_len)
{
	byte *scan;
	dleaf_t *in;
	int i;

	map_vis_rowlongs = (visleafs + 31) >> 5;
	map_vis_rowbytes = map_vis_rowlongs * 4;
	map_pvs = (byte *)Hunk_AllocName(map_vis_rowbytes * visleafs, "pvs");

	if (!vis_len) {
		memset(map_pvs, 0xff, map_vis_rowbytes * visleafs);
		return;
	}

	// FIXME, add checks for lump_vis->filelen and leafs' visofs

	// go through all leafs and decompress visibility data
	in = (dleaf_t *) leaf_buf;
	in++; // pvs row 0 is leaf 1
	scan = map_pvs;
	for (i = 0; i < visleafs; i++, in++, scan += map_vis_rowbytes) {
		int p = LittleLong(in->visofs);
		memcpy(scan, (p == -1) ? map_novis : DecompressVis(visdata + p), map_vis_rowbytes);
	}
}

static void CM_BuildPVS29a(byte *visdata, int vis_len, byte *leaf_buf, int leaf_len)
{
	byte *scan;
	dleaf29a_t *in;
	int i;

	map_vis_rowlongs = (visleafs + 31) >> 5;
	map_vis_rowbytes = map_vis_rowlongs * 4;
	map_pvs = (byte *)Hunk_AllocName(map_vis_rowbytes * visleafs, "pvs");

	if (!vis_len) {
		memset(map_pvs, 0xff, map_vis_rowbytes * visleafs);
		return;
	}

	// FIXME, add checks for lump_vis->filelen and leafs' visofs

	// go through all leafs and decompress visibility data
	in = (dleaf29a_t *) leaf_buf;
	in++; // pvs row 0 is leaf 1
	scan = map_pvs;
	for (i = 0; i < visleafs; i++, in++, scan += map_vis_rowbytes) {
		int p = LittleLong(in->visofs);
		memcpy(scan, (p == -1) ? map_novis : DecompressVis(visdata + p), map_vis_rowbytes);
	}
}

static void CM_BuildPVSBSP2(byte *visdata, int vis_len, byte *leaf_buf, int leaf_len)
{
	byte *scan;
	dleaf_bsp2_t *in;
	int i;

	map_vis_rowlongs = (visleafs + 31) >> 5;
	map_vis_rowbytes = map_vis_rowlongs * 4;
	map_pvs = (byte *)Hunk_AllocName(map_vis_rowbytes * visleafs, "pvs");

	if (!vis_len) {
		memset(map_pvs, 0xff, map_vis_rowbytes * visleafs);
		return;
	}

	// FIXME, add checks for lump_vis->filelen and leafs' visofs

	// go through all leafs and decompress visibility data
	in = (dleaf_bsp2_t *) leaf_buf;
	in++; // pvs row 0 is leaf 1
	scan = map_pvs;
	for (i = 0; i < visleafs; i++, in++, scan += map_vis_rowbytes) {
		int p = LittleLong(in->visofs);
		memcpy(scan, (p == -1) ? map_novis : DecompressVis(visdata + p), map_vis_rowbytes);
	}
}

/*
** CM_BuildPHS
**
** Expands the PVS and calculates the PHS (potentially hearable set)
** Call after CM_BuildPVS (so that map_vis_rowbytes & map_vis_rowlongs are set)
*/
static void CM_BuildPHS (void)
{
	int i, j, k, l, index1, bitbyte;
	unsigned *dest, *src;
	byte *scan;

	map_phs = NULL;
	if (map_vis_rowbytes * visleafs > 0x100000) {
		return;
	}

	map_phs = (byte *) Hunk_AllocName (map_vis_rowbytes * visleafs, "phs");
	scan = map_pvs;
	dest = (unsigned *)map_phs;
	for (i = 0; i < visleafs; i++, dest += map_vis_rowlongs, scan += map_vis_rowbytes)
	{
		// copy from pvs
		memcpy (dest, scan, map_vis_rowbytes);

		// or in hearable leafs
		for (j = 0; j < map_vis_rowbytes; j++)
		{
			bitbyte = scan[j];
			if (!bitbyte)
				continue;
			for (k = 0; k < 8; k++)
			{
				if (! (bitbyte & (1<<k)) )
					continue;
				// or this pvs row into the phs
				index1 = (j<<3) + k;
				if (index1 >= visleafs)
					continue;
				src = (unsigned *)map_pvs + index1 * map_vis_rowlongs;
				for (l = 0; l < map_vis_rowlongs; l++)
					dest[l] |= src[l];
			}
		}
	}
}



/*
** hunk was reset by host, so the data is no longer valid
*/
void CM_InvalidateMap (void)
{
	map_name[0] = 0;

	// null out the pointers to turn up any attempt to call CM functions
	map_planes = NULL;
	map_nodes = NULL;
	map_clipnodes = NULL;
	map_leafs = NULL;
	map_pvs = NULL;
	map_phs = NULL;
	map_entitystring = NULL;
	map_physicsnormals = NULL;
}

static vfsfile_t *CM_OpenMap(char *name, dheader_t *header)
{
#ifndef CLIENTONLY
	extern cvar_t sv_bspversion, sv_halflifebsp;
#endif
	vfsfile_t *vf;
	int i, read;

	vf = FS_OpenVFS(name, "rb", FS_ANY); // FIXME: should be FS_GAME.
	if (!vf) {
		Host_Error ("CM_OpenMap: %s not found", name);
	}

	read = VFS_READ(vf, header, sizeof(dheader_t), NULL);
	if (read != sizeof(dheader_t))
	{
		Con_Printf("Failed to read BSP header, got %d of %d bytes\n", read, sizeof(dheader_t));
		VFS_CLOSE(vf);
		return NULL;
	}

	for (i = 0; i < sizeof(dheader_t) / 4; i++) {
		((int *)header)[i] = LittleLong(((int *)header)[i]);
	}

	switch (header->version) {
	case Q1_BSPVERSION:
	case HL_BSPVERSION:
#ifndef CLIENTONLY
	  Cvar_SetROM(&sv_bspversion, "1");
#endif
	  break;
	case Q1_BSPVERSION2:
	case Q1_BSPVERSION29a:
#ifndef CLIENTONLY
	  Cvar_SetROM(&sv_bspversion, "2");
#endif
	  break;
	default:
		VFS_CLOSE(vf);
		Host_Error ("CM_OpenMap: %s has wrong version number (%i should be %i)", name, i, Q1_BSPVERSION);
		break;
	}

	map_halflife = (header->version == HL_BSPVERSION);

#ifndef CLIENTONLY
	Cvar_SetROM(&sv_halflifebsp, map_halflife ? "1" : "0");
#endif

	return vf;
}

static qbool CM_CalcChecksum(vfsfile_t *f, dheader_t *header, unsigned *checksum, unsigned *checksum2)
{
	byte *buf;
	int i, read;

	// checksum all of the map, except for entities
	map_checksum = map_checksum2 = 0;
	for (i = 0; i < HEADER_LUMPS; i++) {
		if (i == LUMP_ENTITIES)
			continue;

		if (VFS_SEEK(f, header->lumps[i].fileofs, SEEK_SET) < 0)
		{
			Con_Printf("Seek to BSP lump at %d failed\n", header->lumps[i].fileofs);
			return false;
		}

		buf = Hunk_TempAlloc (header->lumps[i].filelen);

		read = VFS_READ(f, buf, header->lumps[i].filelen, NULL);
		if (read != header->lumps[i].filelen)
		{
			Con_Printf("Failed to read BSP lump, got %d of %d bytes\n", read, header->lumps[i].filelen);
			return false;
		}

		map_checksum ^= LittleLong(Com_BlockChecksum(buf, header->lumps[i].filelen));

		if (i == LUMP_VISIBILITY || i == LUMP_LEAFS || i == LUMP_NODES)
			continue;

		map_checksum2 ^= LittleLong(Com_BlockChecksum(buf, header->lumps[i].filelen));
	}

	if (checksum)
		*checksum = map_checksum;

	if (checksum2)
		*checksum2 = map_checksum2;

	return true;
}

static byte *CM_ReadLump(vfsfile_t *vf, lump_t *lump)
{
	byte *out;
	int read;

	if (VFS_SEEK(vf, lump->fileofs, SEEK_SET) < 0)
	{
		Con_Printf("Seek to BSP lump at %d failed\n", lump->fileofs);
		return NULL;
	}
	out = Hunk_TempAllocMore(lump->filelen);

	read = VFS_READ(vf, out, lump->filelen, NULL);
	if (read != lump->filelen)
	{
		Con_Printf("Failed to read BSP lump, got %d of %d bytes\n", read, lump->filelen);
		return NULL;
	}

	return out;
}

/*
** CM_LoadMap
*/
typedef void(*BuildPVSFunction)(byte *vis_buf, int vis_len, byte *leaf_buf, int leaf_len);
cmodel_t *CM_LoadMap (char *name, qbool clientload, unsigned *checksum, unsigned *checksum2)
{
	dheader_t header = { 0 };
	BuildPVSFunction cm_load_pvs_func = CM_BuildPVS;
	vfsfile_t *vf;
	byte *l_planes, *l_leafs, *l_nodes, *l_clipnodes, *l_entities, *l_models, *l_vis;
	bspx_header_t xheader = { 0 };
	bspx_lump_t *xlumps;
	byte *l_physnormals = NULL;
	int l_physnormals_len = 0;

	if (map_name[0]) {
		if (strcmp(name, map_name))
			Con_Printf("CM_LoadMap: '%s' != '%s'\n", name, map_name);

		if (checksum)
			*checksum = map_checksum;
		*checksum2 = map_checksum2;
		return &map_cmodels[0]; // still have the right version
	}

	vf = CM_OpenMap(name, &header);
	if (!vf)
	{
		return NULL;
	}

	if (!CM_CalcChecksum(vf, &header, checksum, checksum2))
	{
		VFS_CLOSE(vf);
		return NULL;
	}

	COM_FileBase (name, loadname);

	// Flush to temp zone to leave as much heap available to map loading as possible.
	Hunk_TempFlush();

	l_planes = CM_ReadLump(vf, &header.lumps[LUMP_PLANES]);
	l_leafs = CM_ReadLump(vf, &header.lumps[LUMP_LEAFS]);
	l_nodes = CM_ReadLump(vf, &header.lumps[LUMP_NODES]);
	l_clipnodes = CM_ReadLump(vf, &header.lumps[LUMP_CLIPNODES]);
	l_entities = CM_ReadLump(vf, &header.lumps[LUMP_ENTITIES]);
	l_models = CM_ReadLump(vf, &header.lumps[LUMP_MODELS]);
	l_vis = CM_ReadLump(vf, &header.lumps[LUMP_VISIBILITY]);

	xlumps = CM_LoadBSPX(vf, &header, &xheader);
	if (xlumps)
		l_physnormals = CM_BSPX_ReadLump(vf, &xheader, xlumps, "MVDSV_PHYSICSNORMALS", &l_physnormals_len);

	VFS_CLOSE(vf);

	if (!l_planes || !l_leafs || !l_nodes || !l_clipnodes || !l_entities || !l_models || !l_vis)
	{
		return NULL;
	}

	// load into heap
	CM_LoadPlanes (l_planes, header.lumps[LUMP_PLANES].filelen);
	if (LittleLong(header.version) == Q1_BSPVERSION29a) {
		CM_LoadLeafs29a(l_leafs, header.lumps[LUMP_LEAFS].filelen);
		CM_LoadNodes29a(l_nodes, header.lumps[LUMP_NODES].filelen);
		CM_LoadClipnodesBSP2(l_clipnodes, header.lumps[LUMP_CLIPNODES].filelen);
		cm_load_pvs_func = CM_BuildPVS29a;
	}
	else if (LittleLong(header.version) == Q1_BSPVERSION2) {
		CM_LoadLeafsBSP2(l_leafs, header.lumps[LUMP_LEAFS].filelen);
		CM_LoadNodesBSP2(l_nodes, header.lumps[LUMP_NODES].filelen);
		CM_LoadClipnodesBSP2(l_clipnodes, header.lumps[LUMP_CLIPNODES].filelen);
		cm_load_pvs_func = CM_BuildPVSBSP2;
	}
	else {
		CM_LoadLeafs(l_leafs, header.lumps[LUMP_LEAFS].filelen);
		CM_LoadNodes(l_nodes, header.lumps[LUMP_NODES].filelen);
		CM_LoadClipnodes(l_clipnodes, header.lumps[LUMP_CLIPNODES].filelen);
		cm_load_pvs_func = CM_BuildPVS;
	}
	CM_LoadEntities (l_entities, header.lumps[LUMP_ENTITIES].filelen);
	CM_LoadSubmodels (l_models, header.lumps[LUMP_MODELS].filelen);

	CM_LoadPhysicsNormals(l_physnormals, l_physnormals_len);
	CM_MakeHull0 ();

	cm_load_pvs_func (l_vis, header.lumps[LUMP_VISIBILITY].filelen, l_leafs, header.lumps[LUMP_LEAFS].filelen);

	if (!clientload) // client doesn't need PHS
		CM_BuildPHS ();

	strlcpy (map_name, name, sizeof(map_name));

	// Flush temp zone to leave as much heap available to mods as possible.
	Hunk_TempFlush();

	return &map_cmodels[0];
}

cmodel_t *CM_InlineModel (char *name)
{
	int num;

	if (!name || name[0] != '*')
		Host_Error ("CM_InlineModel: bad name");

	num = atoi (name+1);
	if (num < 1 || num >= numcmodels)
		Host_Error ("CM_InlineModel: bad number");

	return &map_cmodels[num];
}

void CM_Init (void)
{
	memset (map_novis, 0xff, sizeof(map_novis));
	CM_InitBoxHull ();
}

#ifndef SERVER_ONLY
// Allow in-memory modifications to ground normals...
void CM_PhysicsNormalSet(int num, float x, float y, float z, int flags)
{
	if (num > 0 && num <= numclipnodes) {
		VectorSet(map_physicsnormals[num - 1].normal, x, y, z);
		map_physicsnormals[num - 1].flags = flags;
	}
}

// Allow map developer to dump normals
void CM_PhysicsNormalDump(FILE* out, float rampjump, float maxgroundspeed)
{
	if (map_physicsnormals) {
		fwrite(&rampjump, 4, 1, out);
		fwrite(&maxgroundspeed, 4, 1, out);
		fwrite(map_physicsnormals, sizeof(*map_physicsnormals) * numclipnodes, 1, out);
	}
}
#endif

mphysicsnormal_t CM_PhysicsNormal(int num)
{
	mphysicsnormal_t ret;
	qbool inverse = num < 0;

	memset(&ret, 0, sizeof(ret));

	num = abs(num);

	if (num > 0 && num <= numclipnodes) {
		ret = map_physicsnormals[num - 1];
		if (inverse) {
			VectorNegate(ret.normal, ret.normal);
		}
	}

	return ret;
}

static int CM_BSPX_FindOffset(dheader_t *header, int filesize)
{
	int i, xofs = 0;

	for (i = 0; i < HEADER_LUMPS; i++) {
		xofs = max(xofs, header->lumps[i].fileofs + header->lumps[i].filelen);
	}

	if (xofs + sizeof(bspx_header_t) > filesize) {
		return -1;
	}

	return xofs;
}

static qbool CM_BSPX_LoadLumps(bspx_lump_t *lump, int numlumps, int filesize)
{
	int i;

	// byte-swap and check sanity
	for (i = 0; i < numlumps; i++, lump++) {
		lump->lumpname[sizeof(lump->lumpname) - 1] = '\0'; // make sure it ends with zero
		lump->fileofs = LittleLong(lump->fileofs);
		lump->filelen = LittleLong(lump->filelen);
		if (lump->fileofs < 0 || lump->filelen < 0 || (unsigned)(lump->fileofs + lump->filelen) >(unsigned)filesize) {
			Con_Printf("Invalid BSPX lump position, ofs: %d, len: %d, filelen: %d\n", lump->fileofs, lump->filelen, filesize);
			return false;
		}
	}

    return true;
}

#ifndef SERVERONLY
// Used by ezquake
void* Mod_BSPX_FindLump(bspx_header_t* bspx_header, char* lumpname, int* plumpsize, byte* mod_base)
{
	int i;
	bspx_lump_t* lump;

	if (!bspx_header) {
		return NULL;
	}

	lump = (bspx_lump_t*)(bspx_header + 1);
	for (i = 0; i < bspx_header->numlumps; i++, lump++) {
		if (!strcmp(lump->lumpname, lumpname)) {
			if (plumpsize) {
				*plumpsize = lump->filelen;
			}
			return mod_base + lump->fileofs;
		}
	}

	return NULL;
}

// Used by ezquake
bspx_header_t* Mod_LoadBSPX(int filesize, byte* mod_base)
{
	dheader_t* header;
	bspx_header_t* xheader;
	bspx_lump_t* lump;
	int xofs;

	// find end of last lump
	header = (dheader_t*)mod_base;
	xofs = CM_BSPX_FindOffset(header, filesize);
	if (xofs < 0) {
		return NULL;
	}

	xheader = (bspx_header_t*)(mod_base + xofs);
	xheader->numlumps = LittleLong(xheader->numlumps);

	if (xheader->numlumps < 0 || xofs + sizeof(bspx_header_t) + xheader->numlumps * sizeof(bspx_lump_t) > filesize) {
		return NULL;
	}

	lump = (bspx_lump_t*)(xheader + 1); // lumps immediately follow the header
	if (!CM_BSPX_LoadLumps(lump, xheader->numlumps, filesize)) {
		return NULL;
	}

	// success
	return xheader;
}
#endif

static byte* CM_BSPX_ReadLump(vfsfile_t *vf, bspx_header_t *xheader, bspx_lump_t* lump, char* lumpname, int* plumpsize)
{
	byte *buffer;
	int i, read;

	if (!lump) {
		return NULL;
	}

	for (i = 0; i < xheader->numlumps; i++, lump++) {
		if (!strcmp(lump->lumpname, lumpname)) {
			if (plumpsize) {
				*plumpsize = lump->filelen;
			}

			buffer = Hunk_TempAllocMore(lump->filelen);
			if (VFS_SEEK(vf, lump->fileofs, SEEK_SET) < 0)
			{
				Con_Printf("Seek to BSPX lump at %d failed\n", lump->fileofs);
				return NULL;
			}
			read = VFS_READ(vf, buffer, lump->filelen, NULL);
			if (read != lump->filelen)
			{
				Con_Printf("Failed to read BSPX lump, got %d of %d bytes\n", read, lump->filelen);
				return NULL;
			}

			return buffer;
		}
	}

	return NULL;
}

static bspx_lump_t* CM_LoadBSPX(vfsfile_t *vf, dheader_t *header, bspx_header_t *xheader)
{
	bspx_lump_t* lump;
	int xofs;
	int read, lumpssize, filesize;

	filesize = VFS_GETLEN(vf);

	// find end of last lump
	xofs = CM_BSPX_FindOffset(header, filesize);
	if (xofs < 0) {
		return NULL;
	}

	if (VFS_SEEK(vf, xofs, SEEK_SET) < 0)
	{
		return NULL;
	}

	read = VFS_READ(vf, xheader, sizeof(bspx_header_t), NULL);
	if (read != sizeof(bspx_header_t))
	{
		return NULL;
	}

	xheader->numlumps = LittleLong(xheader->numlumps);

	lumpssize = sizeof(bspx_lump_t) * xheader->numlumps;

	if (xheader->numlumps < 0 || xofs + sizeof(bspx_header_t) + lumpssize > filesize) {
        Con_Printf("Corrupt BSPX header\n");
		return NULL;
	}

	lump = (bspx_lump_t*)Hunk_TempAllocMore(lumpssize);

	read = VFS_READ(vf, lump, lumpssize, NULL);
	if (read != lumpssize)
	{
		Con_Printf("Failed to read BSPX lumps header, got %d of %d bytes\n", read, lumpssize);
		return NULL;
	}

	if (!CM_BSPX_LoadLumps(lump, xheader->numlumps, filesize)) {
		return NULL;
	}

	return lump;
}


================================================
FILE: src/cmodel.h
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

// cmodel.h
#ifndef __CMODEL_H__
#define __CMODEL_H__

#include "bspfile.h"

// mplane->type
enum {
	SIDE_FRONT = 0,
	SIDE_BACK = 1,
	SIDE_ON = 2
};


// plane_t structure
// !!! if this is changed, it must be changed in asm_i386.h too !!!
typedef struct mplane_s {
	vec3_t	normal;
	float	dist;
	byte	type;			// for texture axis selection and fast side tests
	byte	signbits;		// signx + signy<<1 + signz<<1
	byte	pad[2];
} mplane_t;

// !!! if this is changed, it must be changed in asm_i386.h too !!!
typedef struct {
	mclipnode_t	*clipnodes;
	mplane_t	*planes;
	int			firstclipnode;
	int			lastclipnode;
	vec3_t		clip_mins;
	vec3_t		clip_maxs;
} hull_t;

typedef struct {
	vec3_t	normal;
	float	dist;
} plane_t;

typedef struct mphysicsnormal_s {
	vec3_t             normal;
	int                flags;
} mphysicsnormal_t;

#define PHYSICSNORMAL_SET      1
#define PHYSICSNORMAL_FLIPX    2
#define PHYSICSNORMAL_FLIPY    4
#define PHYSICSNORMAL_FLIPZ    8

mphysicsnormal_t CM_PhysicsNormal(int num);
#ifndef SERVER_ONLY
void CM_PhysicsNormalSet(int num, float x, float y, float z, int flags);
void CM_PhysicsNormalDump(FILE* out, float rampjump, float maxgroundspeed);
#endif

typedef struct {
	qbool   allsolid;           // if true, plane is not valid
	qbool   startsolid;         // if true, the initial point was in a solid area
	qbool   inopen, inwater;
	float   fraction;           // time completed, 1.0 = didn't hit anything
	vec3_t  endpos;             // final position
	plane_t plane;              // surface normal at impact
	int     physicsnormal;      // surface normal for physics
	union {                     // entity the surface is on
		int entnum;             // for pmove
		struct edict_s *ent;    // for sv_world
	} e;
} trace_t;

typedef struct {
	vec3_t	mins, maxs;
	vec3_t	origin;
	hull_t	hulls[MAX_MAP_HULLS];
} cmodel_t;

hull_t *CM_HullForBox (vec3_t mins, vec3_t maxs);
int CM_HullPointContents (hull_t *hull, int num, vec3_t p);
int CM_CachedHullPointContents(hull_t* hull, int num, vec3_t p, float* min_dist);
trace_t CM_HullTrace (hull_t *hull, vec3_t start, vec3_t end);
struct cleaf_s *CM_PointInLeaf (const vec3_t p);
int CM_Leafnum (const struct cleaf_s *leaf);
int CM_LeafAmbientLevel (const struct cleaf_s *leaf, int ambient_channel);
byte *CM_LeafPVS (const struct cleaf_s *leaf);
byte *CM_LeafPHS (const struct cleaf_s *leaf); // only for the server
byte *CM_FatPVS (vec3_t org);
int CM_FindTouchedLeafs (const vec3_t mins, const vec3_t maxs, int leafs[], int maxleafs, int headnode, int *topnode);
char *CM_EntityString (void);
int CM_NumInlineModels (void);
cmodel_t *CM_InlineModel (char *name);
void CM_InvalidateMap (void);
cmodel_t *CM_LoadMap (char *name, qbool clientload, unsigned *checksum, unsigned *checksum2);
void CM_Init (void);

typedef struct bspx_header_s {
	char id[4];  // 'BSPX'
	int numlumps;
} bspx_header_t;

#ifndef SERVERONLY
void* Mod_BSPX_FindLump(bspx_header_t* bspx_header, char* lumpname, int* plumpsize, byte* mod_base);
bspx_header_t* Mod_LoadBSPX(int filesize, byte* mod_base);
#endif

#endif /* !__CMODEL_H__ */


================================================
FILE: src/collision.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "quakedef.h"
#include "pmove.h"

float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal)
{
	trace_t trace = PM_TraceLine (start, end); /* PM_TraceLine hits bmodels and players */
	VectorCopy (trace.endpos, impact);
	if (normal)
		VectorCopy (trace.plane.normal, normal);

	return 0.0;
}


================================================
FILE: src/com_msg.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: com_msg.c,v 1.6 2006-07-24 15:13:28 disconn3ct Exp $
*/

#include "quakedef.h"

/*
==============================================================================
                          MESSAGE IO FUNCTIONS
==============================================================================
Handles byte ordering and avoids alignment errors
*/

#ifdef FTE_PEXT_FLOATCOORDS

int msg_coordsize = 2; // 2 or 4.
int msg_anglesize = 1; // 1 or 2.

float MSG_FromCoord(coorddata c, int bytes)
{
	switch(bytes)
	{
	case 2:	//encode 1/8th precision, giving -4096 to 4096 map sizes
		return LittleShort(c.b2)/8.0f;
	case 4:
		return LittleFloat(c.f);
	default:
		Host_Error("MSG_FromCoord: not a sane size");
		return 0;
	}
}

coorddata MSG_ToCoord(float f, int bytes)	//return value should be treated as (char*)&ret;
{
	coorddata r;
	switch(bytes)
	{
	case 2:
		r.b4 = 0;
		if (f >= 0)
			r.b2 = LittleShort((short)(f*8+0.5f));
		else
			r.b2 = LittleShort((short)(f*8-0.5f));
		break;
	case 4:
		r.f = LittleFloat(f);
		break;
	default:
		Host_Error("MSG_ToCoord: not a sane size");
		r.b4 = 0;
	}

	return r;
}

coorddata MSG_ToAngle(float f, int bytes)	//return value is NOT byteswapped.
{
	coorddata r;
	switch(bytes)
	{
	case 1:
		r.b4 = 0;
		if (f >= 0)
			r.b[0] = (int)(f*(256.0f/360.0f) + 0.5f) & 255;
		else
			r.b[0] = (int)(f*(256.0f/360.0f) - 0.5f) & 255;
		break;
	case 2:
		r.b4 = 0;
		if (f >= 0)
			r.b2 = LittleShort((int)(f*(65536.0f/360.0f) + 0.5f) & 65535);
		else
			r.b2 = LittleShort((int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
		break;
//	case 4:
//		r.f = LittleFloat(f);
//		break;
	default:
		Host_Error("MSG_ToAngle: not a sane size");
		r.b4 = 0;
	}

	return r;
}

#endif

// writing functions
void MSG_WriteChar (sizebuf_t *sb, int c)
{
	byte *buf;

#ifdef PARANOID
	if (c < -128 || c > 127)
		Sys_Error ("MSG_WriteChar: range error");
#endif

	buf = SZ_GetSpace (sb, 1);
	buf[0] = c;
}

void MSG_WriteByte (sizebuf_t *sb, int c)
{
	byte *buf;

#ifdef PARANOID
	if (c < 0 || c > 255)
		Sys_Error ("MSG_WriteByte: range error");
#endif

	buf = SZ_GetSpace (sb, 1);
	buf[0] = c;
}

void MSG_WriteShort (sizebuf_t *sb, int c)
{
	byte *buf;

#ifdef PARANOID
	if (c < ((short)0x8000) || c > (short)0x7fff)
		Sys_Error ("MSG_WriteShort: range error");
#endif

	buf = SZ_GetSpace (sb, 2);
	buf[0] = c & 0xff;
	buf[1] = c >> 8;
}

void MSG_WriteLong (sizebuf_t *sb, int c)
{
	byte *buf;

	buf = SZ_GetSpace (sb, 4);
	buf[0] = c & 0xff;
	buf[1] = (c >> 8) & 0xff;
	buf[2] = (c >> 16) & 0xff;
	buf[3] = c >> 24;
}

void MSG_WriteFloat (sizebuf_t *sb, float f)
{
	union {
		float	f;
		int	l;
	} dat;

	dat.f = f;
	dat.l = LittleLong (dat.l);

	SZ_Write (sb, &dat.l, 4);
}

void MSG_WriteString (sizebuf_t *sb, const char *s)
{
	if (!s || !*s)
		SZ_Write (sb, "", 1);
	else
		SZ_Write (sb, s, strlen(s)+1);
}

void MSG_WriteUnterminatedString (sizebuf_t *sb, char *s)
{
	if (s && *s)
		SZ_Write (sb, s, strlen(s));
}

void MSG_WriteCoord (sizebuf_t *sb, float f)
{
#ifdef FTE_PEXT_FLOATCOORDS
	coorddata i = MSG_ToCoord(f, msg_coordsize);
	SZ_Write (sb, (void*)&i, msg_coordsize);
#else
	MSG_WriteShort (sb, (int)(f * 8));
#endif
}

void MSG_WriteAngle16 (sizebuf_t *sb, float f)
{
	MSG_WriteShort (sb, Q_rint(f * 65536.0 / 360.0) & 65535);
}

void MSG_WriteAngle (sizebuf_t *sb, float f)
{
#ifdef FTE_PEXT_FLOATCOORDS
	if (msg_anglesize == 2)
		MSG_WriteAngle16(sb, f);
//	else if (msg_anglesize==4)
//		MSG_WriteFloat(sb, f);
	else
#endif
		MSG_WriteByte (sb, Q_rint(f * 256.0 / 360.0) & 255);
}

int MSG_WriteDeltaUsercmd(sizebuf_t *buf, struct usercmd_s *from, struct usercmd_s *cmd, unsigned int mvdsv_extensions)
{
	int bits;

	// send the movement message
	bits = 0;
	if (cmd->angles[0] != from->angles[0])
		bits |= CM_ANGLE1;
	if (cmd->angles[1] != from->angles[1])
		bits |= CM_ANGLE2;
	if (cmd->angles[2] != from->angles[2])
		bits |= CM_ANGLE3;
	if (cmd->forwardmove != from->forwardmove)
		bits |= CM_FORWARD;
	if (cmd->sidemove != from->sidemove)
		bits |= CM_SIDE;
	if (cmd->upmove != from->upmove)
		bits |= CM_UP;
	if (cmd->buttons != from->buttons)
		bits |= CM_BUTTONS;
	if (cmd->impulse != from->impulse)
		bits |= CM_IMPULSE;

	MSG_WriteByte (buf, bits);

	if (bits & CM_ANGLE1)
		MSG_WriteAngle16 (buf, cmd->angles[0]);
	if (bits & CM_ANGLE2)
		MSG_WriteAngle16 (buf, cmd->angles[1]);
	if (bits & CM_ANGLE3)
		MSG_WriteAngle16 (buf, cmd->angles[2]);

	if (bits & CM_FORWARD)
		MSG_WriteShort (buf, cmd->forwardmove);
	if (bits & CM_SIDE)
		MSG_WriteShort (buf, cmd->sidemove);
	if (bits & CM_UP)
		MSG_WriteShort (buf, cmd->upmove);

	if (bits & CM_BUTTONS)
		MSG_WriteByte (buf, cmd->buttons);
	if (bits & CM_IMPULSE) {
		MSG_WriteByte(buf, cmd->impulse);
	}
	MSG_WriteByte (buf, cmd->msec);

	return bits;
}

//Writes part of a packetentities message.
//Can delta from either a baseline or a previous packet_entity
void MSG_WriteDeltaEntity (entity_state_t *from, entity_state_t *to, sizebuf_t *msg, qbool force, unsigned int fte_extensions, unsigned int mvdsv_extensions)
{
	int bits, i;
#ifdef PROTOCOL_VERSION_FTE
	int evenmorebits = 0;
	unsigned int required_extensions = 0;
#endif

	// send an update
	bits = 0;

	for (i=0 ; i<3 ; i++)
		if ( to->origin[i] != from->origin[i] )
			bits |= U_ORIGIN1<<i;

	if ( to->angles[0] != from->angles[0] )
		bits |= U_ANGLE1;

	if ( to->angles[1] != from->angles[1] )
		bits |= U_ANGLE2;

	if ( to->angles[2] != from->angles[2] )
		bits |= U_ANGLE3;

	if ( to->colormap != from->colormap )
		bits |= U_COLORMAP;

	if ( to->skinnum != from->skinnum )
		bits |= U_SKIN;

	if ( to->frame != from->frame )
		bits |= U_FRAME;

	if ( to->effects != from->effects )
		bits |= U_EFFECTS;

	if (to->modelindex != from->modelindex) {
		bits |= U_MODEL;
#ifdef FTE_PEXT_ENTITYDBL
		if (to->modelindex > 255) {
			if (to->modelindex > 512) {
				bits &= ~U_MODEL;
			}
			evenmorebits |= U_FTE_MODELDBL;
			required_extensions |= FTE_PEXT_MODELDBL;
		}
#endif
	}

	if (bits & U_CHECKMOREBITS)
		bits |= U_MOREBITS;

	if (to->flags & U_SOLID)
		bits |= U_SOLID;

	// Taken from FTE
	if (msg->cursize + 40 > msg->maxsize && !msg->overflow_handler)
	{
		//not enough space in the buffer, don't send the entity this frame. (not sending means nothing changes, and it takes no bytes!!)
		int oldnum = to->number;
		*to = *from;
		if (oldnum && !from->number) {
			to->number = oldnum;
		}
		return;
	}

	//
	// write the message
	//
	if (!to->number) {
		Sys_Error("Unset entity number");
	}

#ifdef PROTOCOL_VERSION_FTE
	if (to->number >= 512)
	{
		if (to->number >= 1024)
		{
			if (to->number >= 1024 + 512) {
				evenmorebits |= U_FTE_ENTITYDBL;
				required_extensions |= FTE_PEXT_ENTITYDBL;
			}

			evenmorebits |= U_FTE_ENTITYDBL2;
			required_extensions |= FTE_PEXT_ENTITYDBL2;
			if (to->number >= 2048) {
				Sys_Error("Entity number >= 2048");
			}
		}
		else {
			evenmorebits |= U_FTE_ENTITYDBL;
			required_extensions |= FTE_PEXT_ENTITYDBL;
		}
	}

#ifdef U_FTE_TRANS
	if (to->trans != from->trans && (fte_extensions & FTE_PEXT_TRANS)) {
		evenmorebits |= U_FTE_TRANS;
		required_extensions |= FTE_PEXT_TRANS;
    }
#endif

#ifdef U_FTE_COLOURMOD
	if ((to->colourmod[0] != from->colourmod[0] ||
		 to->colourmod[1] != from->colourmod[1] ||
		 to->colourmod[2] != from->colourmod[2]) && (fte_extensions & FTE_PEXT_COLOURMOD)) {
		evenmorebits |= U_FTE_COLOURMOD;
		required_extensions |= FTE_PEXT_COLOURMOD;
    }
#endif

	if (evenmorebits&0xff00)
		evenmorebits |= U_FTE_YETMORE;
	if (evenmorebits&0x00ff)
		bits |= U_FTE_EVENMORE;
	if (bits & 511)
		bits |= U_MOREBITS;
#endif

	if (to->number >= MAX_EDICTS)
	{
		/*SV_Error*/
		Con_Printf ("Entity number >= MAX_EDICTS (%d), set to MAX_EDICTS - 1\n", MAX_EDICTS);
		to->number = MAX_EDICTS - 1;
	}

#ifdef PROTOCOL_VERSION_FTE
	if (evenmorebits && (fte_extensions & required_extensions) != required_extensions) {
		return;
	}
#endif
	if (!bits && !force) {
		return;		// nothing to send!
	}

	i = (to->number & U_CHECKMOREBITS) | (bits&~U_CHECKMOREBITS);
	if (i & U_REMOVE)
		Sys_Error ("U_REMOVE");
	MSG_WriteShort (msg, i);

	if (bits & U_MOREBITS)
		MSG_WriteByte (msg, bits&255);
#ifdef PROTOCOL_VERSION_FTE
	if (bits & U_FTE_EVENMORE)
		MSG_WriteByte (msg, evenmorebits&255);
	if (evenmorebits & U_FTE_YETMORE)
		MSG_WriteByte (msg, (evenmorebits>>8)&255);
#endif

	if (bits & U_MODEL)
		MSG_WriteByte (msg, to->modelindex & 255);
	else if (evenmorebits & U_FTE_MODELDBL)
		MSG_WriteShort(msg, to->modelindex);
	if (bits & U_FRAME)
		MSG_WriteByte (msg, to->frame);
	if (bits & U_COLORMAP)
		MSG_WriteByte (msg, to->colormap);
	if (bits & U_SKIN)
		MSG_WriteByte (msg, to->skinnum);
	if (bits & U_EFFECTS)
		MSG_WriteByte (msg, to->effects);
	if (bits & U_ORIGIN1) {
		if (mvdsv_extensions & MVD_PEXT1_FLOATCOORDS) {
			MSG_WriteLongCoord(msg, to->origin[0]);
		}
		else {
			MSG_WriteCoord(msg, to->origin[0]);
		}
	}
	if (bits & U_ANGLE1)
		MSG_WriteAngle(msg, to->angles[0]);
	if (bits & U_ORIGIN2) {
		if (mvdsv_extensions & MVD_PEXT1_FLOATCOORDS) {
			MSG_WriteLongCoord(msg, to->origin[1]);
		}
		else {
			MSG_WriteCoord(msg, to->origin[1]);
		}
	}
	if (bits & U_ANGLE2)
		MSG_WriteAngle(msg, to->angles[1]);
	if (bits & U_ORIGIN3) {
		if (mvdsv_extensions & MVD_PEXT1_FLOATCOORDS) {
			MSG_WriteLongCoord(msg, to->origin[2]);
		}
		else {
			MSG_WriteCoord(msg, to->origin[2]);
		}
	}
	if (bits & U_ANGLE3)
		MSG_WriteAngle(msg, to->angles[2]);

#ifdef U_FTE_TRANS
	if (evenmorebits & U_FTE_TRANS)
		MSG_WriteByte (msg, to->trans);
#endif

#ifdef U_FTE_COLOURMOD
	if (evenmorebits & U_FTE_COLOURMOD)
	{
		MSG_WriteByte (msg, to->colourmod[0]);
		MSG_WriteByte (msg, to->colourmod[1]);
		MSG_WriteByte (msg, to->colourmod[2]);
	}
#endif
}

/********************************** READING **********************************/

int msg_readcount;
qbool msg_badread;

void MSG_BeginReading (void)
{
	msg_readcount = 0;
	msg_badread = false;
}

int MSG_GetReadCount(void)
{
	return msg_readcount;
}

// returns -1 and sets msg_badread if no more characters are available
int MSG_ReadChar (void)
{
	int	c;

	if (msg_readcount + 1 > net_message.cursize) {
		msg_badread = true;
		return -1;
	}

	c = (signed char)net_message.data[msg_readcount];
	msg_readcount++;

	return c;
}

int MSG_ReadByte (void)
{
	int	c;

	if (msg_readcount + 1 > net_message.cursize) {
		msg_badread = true;
		return -1;
	}

	c = (unsigned char)net_message.data[msg_readcount];
	msg_readcount++;

	return c;
}

int MSG_ReadShort (void)
{
	int	c;

	if (msg_readcount + 2 > net_message.cursize) {
		msg_badread = true;
		return -1;
	}

	c = (short)(net_message.data[msg_readcount]
		+ (net_message.data[msg_readcount + 1] << 8));

	msg_readcount += 2;

	return c;
}

int MSG_ReadLong (void)
{
	int	c;

	if (msg_readcount + 4 > net_message.cursize) {
		msg_badread = true;
		return -1;
	}

	c = net_message.data[msg_readcount]
		+ (net_message.data[msg_readcount + 1] << 8)
		+ (net_message.data[msg_readcount + 2] << 16)
		+ (net_message.data[msg_readcount + 3] << 24);

	msg_readcount += 4;

	return c;
}

float MSG_ReadFloat (void)
{
	union {
		byte b[4];
		float f;
		int	l;
	} dat;

	dat.b[0] = net_message.data[msg_readcount];
	dat.b[1] = net_message.data[msg_readcount + 1];
	dat.b[2] = net_message.data[msg_readcount + 2];
	dat.b[3] = net_message.data[msg_readcount + 3];
	msg_readcount += 4;

	dat.l = LittleLong (dat.l);

	return dat.f;
}

char *MSG_ReadString (void)
{
	static char string[2048];
	unsigned int l;
	int c;

	l = 0;
	do {
		c = MSG_ReadByte ();

		if (c == 255) // skip these to avoid security problems
			continue; // with old clients and servers

		if (c == -1 || c == 0) // msg_badread or end of string
			break;

		string[l] = c;
		l++;
	} while (l < sizeof(string)-1);

	string[l] = 0;

	return string;
}

char *MSG_ReadStringLine (void)
{
	static char	string[2048];
	unsigned int l;
	int c;

	l = 0;
	do {
		c = MSG_ReadByte ();
		if (c == 255)
			continue;
		if (c == -1 || c == 0 || c == '\n')
			break;
		string[l] = c;
		l++;
	} while (l < sizeof(string) - 1);

	string[l] = 0;

	return string;
}

float MSG_ReadCoord (void)
{
#ifdef FTE_PEXT_FLOATCOORDS

	coorddata c = {0};
	MSG_ReadData(&c, msg_coordsize);
	return MSG_FromCoord(c, msg_coordsize);

#else // FTE_PEXT_FLOATCOORDS

	return MSG_ReadShort() * (1.0 / 8);

#endif // FTE_PEXT_FLOATCOORDS
}

float MSG_ReadFloatCoord(void)
{
	float f;
	MSG_ReadData(&f, 4);
	return LittleFloat(f);
}

void MSG_WriteLongCoord(sizebuf_t* sb, float f)
{
	f = LittleFloat(f);

	MSG_WriteFloat(sb, f);
}

float MSG_ReadAngle16 (void)
{
	return MSG_ReadShort() * (360.0 / 65536);
}

float MSG_ReadAngle (void)
{
#ifdef FTE_PEXT_FLOATCOORDS

	switch(msg_anglesize)
	{
	case 1:
		return MSG_ReadChar() * (360.0/256);
	case 2:
		return MSG_ReadAngle16();
//	case 4:
//		return MSG_ReadFloat();
	default:
		Host_Error("MSG_ReadAngle: Bad angle size\n");
		return 0;
	}

#else // FTE_PEXT_FLOATCOORDS

	return MSG_ReadChar() * (360.0 / 256);

#endif // FTE_PEXT_FLOATCOORDS
}

#define CM_MSEC	(1 << 7) // same as CM_ANGLE2

void MSG_ReadDeltaUsercmd (usercmd_t *from, usercmd_t *move, int protoversion)
{
	int bits;

	memcpy (move, from, sizeof(*move));

	bits = MSG_ReadByte ();

	if (protoversion <= 26) {
		// read current angles
		if (bits & CM_ANGLE1)
			move->angles[0] = MSG_ReadAngle16 ();
		move->angles[1] = MSG_ReadAngle16 (); // always sent
		if (bits & CM_ANGLE3)
			move->angles[2] = MSG_ReadAngle16 ();

		// read movement
		if (bits & CM_FORWARD)
			move->forwardmove = MSG_ReadChar() << 3;
		if (bits & CM_SIDE)
			move->sidemove = MSG_ReadChar() << 3;
		if (bits & CM_UP)
			move->upmove = MSG_ReadChar() << 3;
	} else {
		// read current angles
		if (bits & CM_ANGLE1)
			move->angles[0] = MSG_ReadAngle16 ();
		if (bits & CM_ANGLE2)
			move->angles[1] = MSG_ReadAngle16 ();
		if (bits & CM_ANGLE3)
			move->angles[2] = MSG_ReadAngle16 ();

		// read movement
		if (bits & CM_FORWARD)
			move->forwardmove = MSG_ReadShort ();
		if (bits & CM_SIDE)
			move->sidemove = MSG_ReadShort ();
		if (bits & CM_UP)
			move->upmove = MSG_ReadShort ();
	}

	// read buttons
	if (bits & CM_BUTTONS)
		move->buttons = MSG_ReadByte ();

	if (bits & CM_IMPULSE)
		move->impulse = MSG_ReadByte ();

	// read time to run command
	if (protoversion <= 26 && (bits & CM_MSEC)) {
		move->msec = MSG_ReadByte ();
	} 
	else if (protoversion >= 27) {
		move->msec = MSG_ReadByte (); // always sent
	}
}

void MSG_ReadData (void *data, int len)
{
	int	i;

	for (i = 0 ; i < len ; i++)
		((byte *)data)[i] = MSG_ReadByte ();
}

void MSG_ReadSkip(int bytes)
{
	for ( ; !msg_badread && bytes > 0; bytes--)
	{
		MSG_ReadByte ();
	}
}

#ifndef SERVERONLY
byte MSG_EncodeMVDSVWeaponFlags(int deathmatch, int weaponmode, int weaponhide, qbool weaponhide_axe, qbool forgetorder, qbool forgetondeath, int max_impulse)
{
	byte flags = clc_mvd_weapon_switching;
	qbool hide = ((weaponhide == 1) || ((weaponhide == 2) && (deathmatch == 1)));

	if (weaponmode == 3) {
		weaponmode = (deathmatch == 1 ? 1 : 0);
	}
	else if (weaponmode == 4) {
		weaponmode = (deathmatch == 1 ? 2 : 0);
	}

	if (weaponmode == 1) {
		flags |= clc_mvd_weapon_mode_presel;
	}
	else if (weaponmode == 2) {
		flags |= clc_mvd_weapon_mode_iffiring;
	}

	if (forgetorder) {
		flags |= clc_mvd_weapon_forget_ranking;
	}

	if (hide) {
		if (weaponhide_axe) {
			flags |= clc_mvd_weapon_hide_axe;
		}
		else {
			flags |= clc_mvd_weapon_hide_sg;
		}
	}

	flags |= (forgetondeath ? clc_mvd_weapon_reset_on_death : 0);

	flags |= (max_impulse >= 16 ? clc_mvd_weapon_full_impulse : 0);

	return flags;
}
#endif

void MSG_DecodeMVDSVWeaponFlags(int flags, int* weaponmode, int* weaponhide, qbool* forgetorder, int* sequence)
{

}



================================================
FILE: src/common.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: common.c,v 1.108 2007-10-13 15:36:55 cokeman1982 Exp $

*/

#include "common.h"

#ifdef _WIN32
#include <direct.h>
#include <shlobj.h>
#include <errno.h>
#else
#include <stdio.h>
#include <unistd.h>
#endif

#include "quakedef.h"

#include "utils.h"
#include "gl_model.h"
#include "teamplay.h"
#include "crc.h"
#include "stats_grid.h"
#include "tp_triggers.h"
#include "fs.h"
#include "rulesets.h"

typedef struct commandline_option_s {
	const char* name;
	int position;
} commandline_option_t;

#define CMDLINE_DEF(x, str) { str, 0 }

static commandline_option_t commandline_parameters[num_cmdline_params] = {
#include "cmdline_params_ids.h"
};

#undef CMDLINE_DEF

const char* Cmd_CommandLineParamName(cmdline_param_id id)
{
	return commandline_parameters[id].name;
}

void Draw_BeginDisc (void);
void Draw_EndDisc (void);

#define MAX_NUM_ARGVS	50

usercmd_t nullcmd; // guaranteed to be zero

static char	*largv[MAX_NUM_ARGVS + 1];

cvar_t	developer = {"developer", "0"};
cvar_t	host_mapname = {"mapname", "", CVAR_ROM};

qbool com_serveractive = false;


/*
All of Quake's data access is through a hierarchic file system, but the contents of the file system can be transparently merged from several sources.

The "base directory" is the path to the directory holding the quake.exe and all game directories.  The sys_* files pass this to host_init in quakeparms_t->basedir.  This can be overridden with the "-basedir" command line parm to allow code debugging in a different directory.  The base directory is
only used during filesystem initialization.

The "game directory" is the first tree on the search path and directory that all generated files (savegames, screenshots, demos, config files) will be saved to.  This can be overridden with the "-game" command line parameter.  The game directory can never be changed while quake is executing.  This is a precacution against having a malicious server instruct clients to write files over areas they shouldn't.
*/

//============================================================================

void COM_StoreOriginalCmdline (int argc, char **argv)
{
	char buf[4096]; // enough?
	int i;

	buf[0] = 0;
	strlcat (buf, " ", sizeof (buf));

	for (i=0; i < argc; i++)
		strlcat (buf, argv[i], sizeof (buf));

	com_args_original = Q_strdup (buf);
}

//============================================================================

const char *COM_SkipPath (const char *pathname)
{
	const char *last;
	const char *p;

	last = p = pathname;

	while (*p)
	{
		if (*p == '/' || *p == '\\')
			last = p + 1;

		p++;
	}

	return last;
}

//============================================================================

char *COM_SkipPathWritable (char *pathname)
{
	char *last;
	char *p;

	last = p = pathname;

	while (*p)
	{
		if (*p == '/' || *p == '\\')
			last = p + 1;

		p++;
	}

	return last;
}

//
// Makes a path fit in a specified sized string "c:\quake\bla\bla\bla" => "c:\quake...la\bla"
//
char *COM_FitPath(char *dest, int destination_size, char *src, int size_to_fit)
{
	if (!src)
	{
		return dest;
	}

	if (size_to_fit > destination_size)
	{
		size_to_fit = destination_size;
	}

	if (strlen(src) <= size_to_fit)
	{
		// Entire path fits in the destination.
		strlcpy(dest, src, destination_size);
	}
	else
	{
		#define DOT_SIZE		3
		#define MIN_LEFT_SIZE	3
		int right_size = 0;
		int left_size = 0;
		int temp = 0;
		char *right_dir = COM_SkipPathWritable(src);

		// Get the size of the right-most part of the path (filename/directory).
		right_size = strlen (right_dir);

		// Try to fit the dir/filename if possible.
		temp = right_size + DOT_SIZE + MIN_LEFT_SIZE;
		right_size = (temp > size_to_fit) ? abs(right_size - (temp - size_to_fit)) : right_size;

		// Let the left have the rest.
		left_size = size_to_fit - right_size - DOT_SIZE;

		// Only let the left have 35% of the total size.
		left_size = min (left_size, Q_rint(0.35 * size_to_fit));

		// Get the final right size.
		right_size = size_to_fit - left_size - DOT_SIZE - 1;

		// Make sure we don't have negative values,
		// because then our safety checks won't work.
		left_size = max (0, left_size);
		right_size = max (0, right_size);

		if (left_size < destination_size)
		{
			strlcpy (dest, src, destination_size);
			strlcpy (dest + left_size, "...", destination_size);

			if (left_size + DOT_SIZE + right_size < destination_size)
			{
				strlcpy (dest + left_size + DOT_SIZE, src + strlen(src) - right_size, right_size + 1);
			}
		}
	}

	return dest;
}

void COM_StripExtension (const char *in, char *out, int out_size)
{
	char *dot;

	if (in != out)
		strlcpy (out, in, out_size);

	dot = strrchr (out, '.');
	if (dot) {
		*dot = 0;
	}
}


char *COM_FileExtension (const char *in)
{
	static char exten[8];
	int i;

	if (!(in = strrchr(in, '.')))
		return "";
	in++;
	for (i = 0 ; i < 7 && *in ; i++,in++)
		exten[i] = *in;
	exten[i] = 0;
	return exten;
}

//
// Extract file name without extension, to be used for hunk tags (up to 32 characters, including trailing zero)
//
void COM_FileBase (const char *in, char *out)
{
	const char *start, *end;
	int	length;

	if (!(end = strrchr(in, '.')))
		end = in + strlen(in);

	if (!(start = strrchr(in, '/')))
		start = in;
	else
		start += 1;

	length = end - start;
	if (length < 0)
		strcpy (out, "?empty filename?");
	else if (length == 0)
		out[0] = 0;
	else {
		if (length > 31)
			length = 31;
		memcpy (out, start, length);
		out[length] = 0;
	}
}

//
// If path doesn't have a .EXT, append extension (extension should include the .)
//
void COM_DefaultExtension (char *path, char *extension, size_t path_size)
{
	char *src;

	src = path + strlen(path) - 1;

	while (*src != '/' && src != path) {
		if (*src == '.')
			return;                 // it has an extension
		src--;
	}

	strlcat (path, extension, path_size);
}

// If path doesn't have an extension or has a different extension, append(!) specified extension
// Extension should include the .
// path buffer supposed to be MAX_OSPATH size
void COM_ForceExtension (char *path, char *extension)
{
	char *src;

	src = path + strlen(path) - strlen(extension);
	if (src >= path && !strcmp(src, extension))
		return;

	strlcat (path, extension, MAX_OSPATH);
}

// If path doesn't have an extension or has a different extension, append(!) specified extension
// a bit extended version of COM_ForceExtension(), we suply size of path, so append safe, sure if u provide right path size
void COM_ForceExtensionEx (char *path, char *extension, size_t path_size)
{
	char *src;

	if (path_size < 1 || path_size <= strlen (extension)) // too small buffer, can't even theoreticaly append extension
		Sys_Error("COM_ForceExtensionEx: internall error"); // this is looks like a bug, be fatal then

	src = path + strlen (path) - strlen (extension);
	if (src >= path && !strcmp (src, extension))
		return; // seems we alredy have this extension

	strlcat (path, extension, path_size);

	src = path + strlen (path) - strlen (extension);
	if (src >= path && !strcmp (src, extension))
		return; // seems we succeed

	Com_Printf ("Failed to force extension %s for %s\n", extension, path); // its good to know about failure
}

//
// Get the path of a temporary directory.
// Returns length of the path or negative value if error.
//
int COM_GetTempDir(char *buf, int bufsize)
{
	int returnval = 0;
#ifdef WIN32
	returnval = GetTempPath (bufsize, buf);

	if (returnval > bufsize || returnval == 0) {
		return -1;
	}
#else // UNIX
	char *tmp;
	if (!(tmp = getenv ("TMPDIR")))
		tmp = P_tmpdir; // defined at <stdio.h>

	returnval = strlen (tmp);

	if (returnval > bufsize || returnval == 0) {
		return -1;
	}

	strlcpy (buf, tmp, bufsize);
#endif // WIN32

	return returnval;
}

qbool COM_WriteToUniqueTempFileVFS(char* path, int path_buffer_size, const char* ext, vfsfile_t* input)
{
	size_t bytes = VFS_GETLEN(input);
	byte* buffer = Q_malloc(bytes);
	vfserrno_t err;
	qbool result;

	if (!buffer) {
		return false;
	}
	VFS_READ(input, buffer, (int)bytes, &err);
	VFS_SEEK(input, 0, SEEK_SET);

	result = COM_WriteToUniqueTempFile(path, path_buffer_size, ext, buffer, bytes);
	Q_free(buffer);
	return result;
}

//
// Get a unique temp filename.
// Returns negative value on failure.
//
qbool COM_WriteToUniqueTempFile(char *path, int path_buffer_size, const char* ext, const byte* buffer, size_t bytes)
{
	char temp_path[MAX_OSPATH];

	if (ext == NULL) {
		ext = "";
	}

	// Get the path to temporary directory
	if (COM_GetTempDir(temp_path, sizeof(temp_path)) < 0) {
		return false;
	}

#ifdef _WIN32
	{
		GUID guid;
		char* dot = "";

		dot = (ext[0] && ext[0] != '.' ? "." : "");

		if (path_buffer_size < MAX_PATH) {
			return false;
		}

		if (CoCreateGuid(&guid) == S_OK) {
			if (path_buffer_size > snprintf(path, path_buffer_size, "%s\\%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X%s%s", temp_path, guid.Data1, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7], dot, ext)) {
				FS_WriteFile_2(path, buffer, (int)bytes);
				return true;
			}
		}

		return false;
	}
#else
	{
		int fd = 0;
		strlcat(path, "/ezquakeXXXXXX", path_buffer_size);
		if (ext[0]) {
			int ext_len = 0;

			if (ext[0] != '.') {
				strlcat(path, ".", path_buffer_size);
				strlcat(path, ext, path_buffer_size);
				ext_len = strlen(ext) + 1;
			}
			else {
				strlcat(path, ext, path_buffer_size);
				ext_len = strlen(ext);
			}
			fd = mkstemps(path, ext_len);
		}
		else {
			fd = mkstemp(path);
		}

		if (fd < 0) {
			return false;
		}

		write(fd, buffer, bytes);

		close(fd);
		return true;
	}
#endif
}

qbool COM_FileExists (char *path)
{
	FILE *fexists = NULL;

	// Try opening the file to see if it exists.
	fexists = fopen(path, "rb");

	// The file exists.
	if (fexists)
	{
		// Make sure the file is closed.
		fclose (fexists);
		return true;
	}

	return false;
}


char		com_token[MAX_COM_TOKEN];
static int	com_argc;
static char	**com_argv;
char 		*com_args_original;

com_tokentype_t com_tokentype;

//Parse a token out of a string
const char* COM_ParseEx(const char *data, qbool curlybraces)
{
	unsigned char c;
	int len;
	int quotes;

	len = 0;
	com_token[0] = 0;

	if (!data) {
		return NULL;
	}

	// skip whitespace
	while (true) {
		while ((c = *data) == ' ' || c == '\t' || c == '\r' || c == '\n') {
			data++;
		}

		if (c == 0) {
			return NULL;			// end of file;
		}

		// skip // comments
		if (c == '/' && data[1] == '/') {
			while (*data && *data != '\n') {
				data++;
			}
		}
		else {
			break;
		}
	}

	// handle quoted strings specially
	if (c == '\"' || (c == '{' && curlybraces) ) {
		if (c == '{') {
			quotes = 1;
		}
		else {
			quotes = -1;
		}
		data++;
		while (1) {
			c = *data;
			data++;
			if (quotes < 0) {
				if (c == '\"') {
					quotes++;
				}
			}
			else {
				if (c == '}' && curlybraces) {
					quotes--;
				}
				else if (c == '{' && curlybraces) {
					quotes++;
				}
			}

			if (!quotes || !c) {
				com_token[len] = 0;
				return c ? data : data - 1;
			}
			com_token[len] = c;
			len++;

			if (len >= sizeof(com_token) - 1) {
				return NULL; // quoted section too long
			}
		}
	}

	// parse a regular word
	do {
		com_token[len] = c;
		data++;
		len++;
		if (len >= sizeof(com_token) - 1) {
			break;
		}
		c = *data;
	} while (c && c != ' ' && c != '\t' && c != '\n' && c != '\r');

	com_token[len] = 0;
	return data;
}

const char* COM_Parse(const char* data)
{
	return COM_ParseEx(data, false);
}

#define DEFAULT_PUNCTUATION "(,{})(\':;=!><&|+"
char *COM_ParseToken (const char *data, const char *punctuation)
{
	int c;
	int	len;

	if (!punctuation)
		punctuation = DEFAULT_PUNCTUATION;

	len = 0;
	com_token[0] = 0;

	if (!data)
	{
		com_tokentype = TTP_UNKNOWN;
		return NULL;
	}

	// skip whitespace
skipwhite:
	while ((c = *(unsigned char *) data) <= ' ')
	{
		if (c == 0)
		{
			com_tokentype = TTP_UNKNOWN;
			return NULL; // end of file;
		}

		data++;
	}

	// skip // comments
	if (c == '/')
	{
		if (data[1] == '/')
		{
			while (*data && *data != '\n')
				data++;

			goto skipwhite;
		}
		else if (data[1] == '*')
		{
			data += 2;

			while (*data && (*data != '*' || data[1] != '/'))
				data++;

			data += 2;
			goto skipwhite;
		}
	}


	// handle quoted strings specially
	if (c == '\"')
	{
		com_tokentype = TTP_STRING;
		data++;
		while (1)
		{
			if (len >= MAX_COM_TOKEN - 1)
			{
				com_token[len] = '\0';
				return (char*) data;
			}

			c = *data++;

			if (c=='\"' || !c)
			{
				com_token[len] = 0;
				return (char*) data;
			}

			com_token[len] = c;
			len++;
		}
	}

	com_tokentype = TTP_UNKNOWN;

	// parse single characters
	if (strchr (punctuation, c))
	{
		com_token[len] = c;
		len++;
		com_token[len] = 0;
		return (char*) (data + 1);
	}

	// parse a regular word
	do
	{
		if (len >= MAX_COM_TOKEN - 1)
			break;

		com_token[len] = c;
		data++;
		len++;
		c = *data;
		if (strchr (punctuation, c))
			break;

	} while (c > 32);

	com_token[len] = 0;
	return (char*) data;
}

//Adds the given string at the end of the current argument list
void COM_AddParm (char *parm)
{
	if (com_argc >= MAX_NUM_ARGVS)
		return;
	largv[com_argc++] = parm;
}

//Returns the position (1 to argc-1) in the program's argument list
//where the given parameter appears, or 0 if not present
int COM_FindParm(const char* parm)
{
	int		i;

	for (i = 1; i < com_argc; i++) {
		if (!strcmp(parm, com_argv[i])) {
			return i;
		}
	}

	return 0;
}

int COM_CheckParm(cmdline_param_id id)
{
	if (id < 0 || id >= num_cmdline_params) {
		return 0;
	}

	return commandline_parameters[id].position;
}

//Tei: added cos -data feature use it.
int COM_CheckParmOffset(cmdline_param_id id, int offset)
{
	int             i;
	const char* parm;

	if (id < 0 || id >= num_cmdline_params) {
		return 0;
	}

	parm = commandline_parameters[id].name;
	for (i = offset; i < com_argc; i++) {
		// NEXTSTEP sometimes clears appkit vars.
		if (!com_argv[i]) {
			continue;
		}

		if (!strcmp(parm, com_argv[i])) {
			return i;
		}
	}

	return 0;
}
//qbism// 1999-12-23 Multiple "-data" parameters by Maddes  end


int COM_Argc (void)
{
	return com_argc;
}

char *COM_Argv(int arg)
{
	if (arg < 0 || arg >= com_argc) {
		return "";
	}

	return com_argv[arg];
}

void COM_ClearArgv(int arg)
{
	if (arg < 0 || arg >= com_argc) {
		return;
	}
	com_argv[arg] = "";
}

void COM_InitArgv(int argc, char **argv)
{
	int id;
	int i;

	for (i = 0, com_argc = 0; com_argc < MAX_NUM_ARGVS - 1 && i < argc; ++i) {
		if (argv[i]) {
			// follow qw urls if they are our argument without a +qwurl command
			if (!strncmp(argv[i], "qw://", 5) && (i == 0 || strncmp(argv[i - 1], "+qwurl", 6)) && com_argc < MAX_NUM_ARGVS - 1) {
				largv[com_argc++] = "+qwurl";
				largv[com_argc++] = argv[i];
			}
			else {
				largv[com_argc++] = argv[i];
			}
		}
		else {
			largv[com_argc++] = "";
		}
	}

	largv[com_argc] = "";
	com_argv = largv;

	for (id = 0; id < num_cmdline_params; ++id) {
		commandline_parameters[id].position = COM_FindParm(commandline_parameters[id].name);
	}
}

void COM_Init(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_NO_GROUP);
	Cvar_Register(&developer);
	Cvar_Register(&host_mapname);

	Cvar_ResetCurrentGroup();
}

//does a varargs printf into a temp buffer, so I don't need to have varargs versions of all text functions.
char *va(const char *format, ...)
{
	va_list argptr;
	static char string[32][2048];
	static int idx = 0;

	idx++;
	if (idx == 32) {
		idx = 0;
	}

	va_start (argptr, format);
	vsnprintf (string[idx], sizeof(string[idx]), format, argptr);
	va_end (argptr);

	return string[idx];
}

// equals to consecutive calls of strtok(s, " ") that assign values to array
int COM_GetFloatTokens(const char *s, float *fl_array, int fl_array_size)
{
    int i;
    if (!s || !*s) return 0;

    for(i = 0; *s && i < fl_array_size; i++)
    {
        fl_array[i] = atof(s);
        while(*s && *s != ' ') s++; // skips the number
        while(*s && *s == ' ') s++; // skips the spaces
    }

    return i;
}


/*
=====================================================================
  INFO STRINGS
=====================================================================
*/

//Searches the string for the given key and returns the associated value, or an empty string.
char *Info_ValueForKey (char *s, char *key) {
	char pkey[512];
	static char value[4][512];	// use two buffers so compares work without stomping on each other
	static int	valueindex;
	char *o;

	valueindex = (valueindex + 1) % 4;
	if (*s == '\\')
		s++;
	while (1) {
		o = pkey;
		while (*s != '\\') {
			if (!*s)
				return "";
			*o++ = *s++;
		}
		*o = 0;
		s++;

		o = value[valueindex];

		while (*s != '\\' && *s) {
			if (!*s)
				return "";
			*o++ = *s++;
		}
		*o = 0;

		if (!strcmp (key, pkey) )
			return value[valueindex];

		if (!*s)
			return "";
		s++;
	}
}

void Info_RemoveKey (char *s, char *key) {
	char *start, pkey[512], value[512], *o;

	if (strchr (key, '\\')) {
		Com_Printf ("Can't use a key with a \\\n");
		return;
	}

	while (1) {
		start = s;
		if (*s == '\\')
			s++;
		o = pkey;
		while (*s != '\\') {
			if (!*s)
				return;
			*o++ = *s++;
		}
		*o = 0;
		s++;

		o = value;
		while (*s != '\\' && *s) {
			if (!*s)
				return;
			*o++ = *s++;
		}
		*o = 0;

		if (!strcmp (key, pkey) ) {
			Q_strcpy (start, s);	// remove this part
			return;
		}

		if (!*s)
			return;
	}

}

void Info_RemovePrefixedKeys (char *start, char prefix) {
	char *s, pkey[512], value[512], *o;

	s = start;

	while (1) {
		if (*s == '\\')
			s++;
		o = pkey;
		while (*s != '\\') {
			if (!*s)
				return;
			*o++ = *s++;
		}
		*o = 0;
		s++;

		o = value;
		while (*s != '\\' && *s) {
			if (!*s)
				return;
			*o++ = *s++;
		}
		*o = 0;

		if (pkey[0] == prefix) {
			Info_RemoveKey (start, pkey);
			s = start;
		}

		if (!*s)
			return;
	}

}

void Info_SetValueForStarKeyEx (char *s, char *key, char *value, int maxsize, qbool max_info_key_check)
{
	char new[1024], *v;
	int c;
#ifndef CLIENTONLY
//	extern cvar_t sv_highchars;
#endif

	if (strchr (key, '\\') || strchr (value, '\\') ) {
		Com_Printf ("Can't use keys or values with a \\\n");
		return;
	}

	if (strchr (key, '\"') || strchr (value, '\"') ) {
		Com_Printf ("Can't use keys or values with a \"\n");
		return;
	}

	if (max_info_key_check)
	{
		if (strlen(key) >= MAX_INFO_KEY || strlen(value) >= MAX_INFO_KEY)
		{
			Com_Printf ("Keys and values must be < %i characters.\n", MAX_INFO_KEY);
			return;
		}
	}

	// this next line is kinda trippy
	if (*(v = Info_ValueForKey(s, key))) {
		// key exists, make sure we have enough room for new value, if we don't,
		// don't change it!
		if ((int) (strlen(value) - strlen(v) + strlen(s)) >= maxsize) {
			Com_Printf ("Info string length exceeded\n");
			return;
		}
	}
	Info_RemoveKey (s, key);
	if (!value || !strlen(value))
		return;

	snprintf (new, sizeof (new), "\\%s\\%s", key, value);

	if ((int) (strlen(new) + strlen(s)) >= maxsize) {
		Com_Printf ("Info string length exceeded\n");
		return;
	}

	// only copy ascii values
	s += strlen(s);
	v = new;
#ifndef CLIENTONLY
//	if (!sv_highchars.value) {
//		while (*v) {
//			c = (unsigned char)*v++;
//			if (c == ('\\'|128))
//				continue;
//			c &= 127;
//			if (c >= 32)
//				*s++ = c;
//		}
//	} else
#endif
	{
		while (*v) {
			c = (unsigned char)*v++;
			if (c > 13)
				*s++ = c;
		}
		*s = 0;
	}
}

void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize)
{
	Info_SetValueForStarKeyEx(s, key, value, maxsize, true);
}

void Info_SetValueForKeyEx (char *s, char *key, char *value, int maxsize, qbool max_info_key_check)
{
	if (key[0] == '*')
	{
		Com_Printf ("Can't set * keys\n");
		return;
	}

	Info_SetValueForStarKeyEx (s, key, value, maxsize, max_info_key_check);
}

void Info_SetValueForKey (char *s, char *key, char *value, int maxsize)
{
	Info_SetValueForKeyEx (s, key, value, maxsize, true);
}

#define INFO_PRINT_FIRST_COLUMN_WIDTH 20
void Info_Print (char *s) {
	char key[512], value[512], *o;
	int l;

	if (*s == '\\')
		s++;
	while (*s) {
		o = key;
		while (*s && *s != '\\')
			*o++ = *s++;

		l = o - key;
		if (l < INFO_PRINT_FIRST_COLUMN_WIDTH) {
			memset (o, ' ', INFO_PRINT_FIRST_COLUMN_WIDTH - l);
			key[INFO_PRINT_FIRST_COLUMN_WIDTH] = 0;
		} else {
			*o = 0;
		}
		Com_Printf ("%s", key);

		if (!*s) {
			Com_Printf ("MISSING VALUE\n");
			return;
		}

		o = value;
		s++;
		while (*s && *s != '\\')
			*o++ = *s++;
		*o = 0;

		if (*s)
			s++;
		Com_Printf ("%s\n", value);
	}
}

//============================================================
//
// Alternative variant manipulation with info strings
//
//============================================================

// this is seems to be "better" than Com_HashKey()
static unsigned int Info_HashKey (const char *str)
{
	unsigned int hash = 0;
	int c;

	// the (c&~32) makes it case-insensitive
	// hash function known as sdbm, used in gawk
	while ((c = *str++))
        hash = (c &~ 32) + (hash << 6) + (hash << 16) - hash;

    return hash;
}

// used internally
static info_t *_Info_Get (ctxinfo_t *ctx, const char *name)
{
	info_t *a;
	int key;

	if (!ctx || !name || !name[0])
		return NULL;

	key = Info_HashKey (name) % INFO_HASHPOOL_SIZE;

	for (a = ctx->info_hash[key]; a; a = a->hash_next)
		if (!strcasecmp(name, a->name))
			return a;

	return NULL;
}

char *Info_Get(ctxinfo_t *ctx, const char *name)
{
	static	char value[4][512];
	static	int valueindex = 0;

	info_t *a = _Info_Get(ctx, name);

	if ( a )
	{
		valueindex = (valueindex + 1) % 4;

		strlcpy(value[valueindex], a->value, sizeof(value[0]));

		return value[valueindex];
	}
	else
	{
		return "";
	}
}

qbool Info_SetStar (ctxinfo_t *ctx, const char *name, const char *value)
{
	info_t	*a;
	int key;

	if (!value)
		value = "";

	if (!ctx || !name || !name[0])
		return false;

	// empty value, instead of set just remove it
	if (!value[0])
	{
		return Info_Remove(ctx, name);
	}

	if (strchr(name, '\\') || strchr(value, '\\'))
		return false;
	if (strchr(name, 128 + '\\') || strchr(value, 128 + '\\'))
		return false;
	if (strchr(name, '"') || strchr(value, '"'))
		return false;
	if (strchr(name, '\r') || strchr(value, '\r')) // bad for print functions
		return false;
	if (strchr(name, '\n') || strchr(value, '\n')) // bad for print functions
		return false;
	if (strchr(name, '$') || strchr(value, '$')) // variable expansion may be exploited, escaping this
		return false;
	if (strchr(name, ';') || strchr(value, ';')) // interpreter may be haxed, escaping this
		return false;

	if (strlen(name) >= MAX_KEY_STRING || strlen(value) >= MAX_KEY_STRING)
		return false; // too long name/value, its wrong

	key = Info_HashKey(name) % INFO_HASHPOOL_SIZE;

	// if already exists, reuse it
	for (a = ctx->info_hash[key]; a; a = a->hash_next)
		if (!strcasecmp(name, a->name))
		{
			Q_free (a->value);
			break;
		}

	// not found, create new one
	if (!a)
	{
		if (ctx->cur >= ctx->max)
			return false; // too much infos

		a = (info_t *) Q_malloc (sizeof(info_t));
		a->next = ctx->info_list;
		ctx->info_list = a;
		a->hash_next = ctx->info_hash[key];
		ctx->info_hash[key] = a;

		ctx->cur++; // increase counter

		// copy name
		a->name = Q_strdup (name);
	}

	// copy value
#if 0
	{
		// unfortunatelly evil users use non printable/control chars, so that does not work well
		a->value = Q_strdup (value);
	}
#else
	{
		// skip some control chars, doh
		char v_buf[MAX_KEY_STRING] = {0}, *v = v_buf;
		int i;

		for (i = 0; value[i]; i++) // len of 'value' should be less than MAX_KEY_STRING according to above checks
		{
			if ((unsigned char)value[i] > 13)
				*v++ = value[i];
		}
		*v = 0;

		a->value = Q_strdup (v_buf);
	}
#endif

	// hrm, empty value, remove it then
	if (!a->value[0])
	{
		return Info_Remove(ctx, name);
	}

	return true;
}

qbool Info_Set (ctxinfo_t *ctx, const char *name, const char *value)
{
	if (!value)
		value = "";

	if (!ctx || !name || !name[0])
		return false;

	if (name[0] == '*')
	{
		Con_Printf ("Can't set * keys\n");
		return false;
	}

	return Info_SetStar (ctx, name, value);
}

// used internally
static void _Info_Free(info_t *a)
{
	if (!a)
		return;

	Q_free (a->name);
	Q_free (a->value);
	Q_free (a);
}

qbool Info_Remove (ctxinfo_t *ctx, const char *name)
{
	info_t *a, *prev;
	int key;

	if (!ctx || !name || !name[0])
		return false;

	key = Info_HashKey (name) % INFO_HASHPOOL_SIZE;

	prev = NULL;
	for (a = ctx->info_hash[key]; a; a = a->hash_next)
	{
		if (!strcasecmp(name, a->name))
		{
			// unlink from hash
			if (prev)
				prev->hash_next = a->hash_next;
			else
				ctx->info_hash[key] = a->hash_next;
			break;
		}
		prev = a;
	}

	if (!a)
		return false;	// not found

	prev = NULL;
	for (a = ctx->info_list; a; a = a->next)
	{
		if (!strcasecmp(name, a->name))
		{
			// unlink from info list
			if (prev)
				prev->next = a->next;
			else
				ctx->info_list = a->next;

			// free
			_Info_Free(a);

			ctx->cur--; // decrease counter

			return true;
		}
		prev = a;
	}

	Sys_Error("Info_Remove: info list broken");
	return false; // shut up compiler
}

// remove all infos
void Info_RemoveAll (ctxinfo_t *ctx)
{
	info_t	*a, *next;

	if (!ctx)
		return;

	for (a = ctx->info_list; a; a = next) {
		next = a->next;

		// free
		_Info_Free(a);
	}
	ctx->info_list = NULL;
	ctx->cur = 0; // set counter to 0

	// clear hash
	memset (ctx->info_hash, 0, sizeof(ctx->info_hash));
}

qbool Info_Convert(ctxinfo_t *ctx, char *str)
{
	char name[MAX_KEY_STRING], value[MAX_KEY_STRING], *start;

	if (!ctx)
		return false;

	for ( ; str && str[0]; )
	{
		if (!(str = strchr(str, '\\')))
			break;

		start = str; // start of name

		if (!(str = strchr(start + 1, '\\')))  // end of name
			break;

		strlcpy(name, start + 1, min(str - start, (int)sizeof(name)));

		start = str; // start of value

		str = strchr(start + 1, '\\'); // end of value

		strlcpy(value, start + 1, str ? min(str - start, (int)sizeof(value)) : (int)sizeof(value));

		Info_SetStar(ctx, name, value);
	}

	return true;
}

qbool Info_ReverseConvert(ctxinfo_t *ctx, char *str, int size)
{
	info_t *a;
	int next_size;
	
	if (!ctx)
		return false;

	if (!str || size < 1)
		return false;

	str[0] = 0;

	for (a = ctx->info_list; a; a = a->next)
	{
		if (!a->value[0])
			continue; // empty

		next_size = size - 2 - strlen(a->name) - strlen(a->value);

		if (next_size < 1)
		{
			// sigh, next snprintf will not fit
			return false;
		}

		snprintf(str, size, "\\%s\\%s", a->name, a->value);
		str += (size - next_size);
		size = next_size;
	}

	return true;
}

qbool Info_CopyStar(ctxinfo_t *ctx_from, ctxinfo_t *ctx_to)
{
	info_t *a;

	if (!ctx_from || !ctx_to)
		return false;

	if (ctx_from == ctx_to)
		return true; // hrm

	for (a = ctx_from->info_list; a; a = a->next)
	{
		if (a->name[0] != '*')
			continue; // not a star key

		// do we need check status of this function?
		Info_SetStar (ctx_to, a->name, a->value);
	}

	return true;
}

void Info_PrintList(ctxinfo_t *ctx)
{
	info_t *a;
	int cnt = 0;

	if (!ctx)
		return;

	for (a = ctx->info_list; a; a = a->next)
	{
		Con_Printf("%-20s %s\n", a->name, a->value);
		cnt++;
	}

	
	Con_DPrintf("%d infos\n", cnt);
}

//============================================================================

static byte chktbl[1024] = {
                               0x78,0xd2,0x94,0xe3,0x41,0xec,0xd6,0xd5,0xcb,0xfc,0xdb,0x8a,0x4b,0xcc,0x85,0x01,
                               0x23,0xd2,0xe5,0xf2,0x29,0xa7,0x45,0x94,0x4a,0x62,0xe3,0xa5,0x6f,0x3f,0xe1,0x7a,
                               0x64,0xed,0x5c,0x99,0x29,0x87,0xa8,0x78,0x59,0x0d,0xaa,0x0f,0x25,0x0a,0x5c,0x58,
                               0xfb,0x00,0xa7,0xa8,0x8a,0x1d,0x86,0x80,0xc5,0x1f,0xd2,0x28,0x69,0x71,0x58,0xc3,
                               0x51,0x90,0xe1,0xf8,0x6a,0xf3,0x8f,0xb0,0x68,0xdf,0x95,0x40,0x5c,0xe4,0x24,0x6b,
                               0x29,0x19,0x71,0x3f,0x42,0x63,0x6c,0x48,0xe7,0xad,0xa8,0x4b,0x91,0x8f,0x42,0x36,
                               0x34,0xe7,0x32,0x55,0x59,0x2d,0x36,0x38,0x38,0x59,0x9b,0x08,0x16,0x4d,0x8d,0xf8,
                               0x0a,0xa4,0x52,0x01,0xbb,0x52,0xa9,0xfd,0x40,0x18,0x97,0x37,0xff,0xc9,0x82,0x27,
                               0xb2,0x64,0x60,0xce,0x00,0xd9,0x04,0xf0,0x9e,0x99,0xbd,0xce,0x8f,0x90,0x4a,0xdd,
                               0xe1,0xec,0x19,0x14,0xb1,0xfb,0xca,0x1e,0x98,0x0f,0xd4,0xcb,0x80,0xd6,0x05,0x63,
                               0xfd,0xa0,0x74,0xa6,0x86,0xf6,0x19,0x98,0x76,0x27,0x68,0xf7,0xe9,0x09,0x9a,0xf2,
                               0x2e,0x42,0xe1,0xbe,0x64,0x48,0x2a,0x74,0x30,0xbb,0x07,0xcc,0x1f,0xd4,0x91,0x9d,
                               0xac,0x55,0x53,0x25,0xb9,0x64,0xf7,0x58,0x4c,0x34,0x16,0xbc,0xf6,0x12,0x2b,0x65,
                               0x68,0x25,0x2e,0x29,0x1f,0xbb,0xb9,0xee,0x6d,0x0c,0x8e,0xbb,0xd2,0x5f,0x1d,0x8f,
                               0xc1,0x39,0xf9,0x8d,0xc0,0x39,0x75,0xcf,0x25,0x17,0xbe,0x96,0xaf,0x98,0x9f,0x5f,
                               0x65,0x15,0xc4,0x62,0xf8,0x55,0xfc,0xab,0x54,0xcf,0xdc,0x14,0x06,0xc8,0xfc,0x42,
                               0xd3,0xf0,0xad,0x10,0x08,0xcd,0xd4,0x11,0xbb,0xca,0x67,0xc6,0x48,0x5f,0x9d,0x59,
                               0xe3,0xe8,0x53,0x67,0x27,0x2d,0x34,0x9e,0x9e,0x24,0x29,0xdb,0x69,0x99,0x86,0xf9,
                               0x20,0xb5,0xbb,0x5b,0xb0,0xf9,0xc3,0x67,0xad,0x1c,0x9c,0xf7,0xcc,0xef,0xce,0x69,
                               0xe0,0x26,0x8f,0x79,0xbd,0xca,0x10,0x17,0xda,0xa9,0x88,0x57,0x9b,0x15,0x24,0xba,
                               0x84,0xd0,0xeb,0x4d,0x14,0xf5,0xfc,0xe6,0x51,0x6c,0x6f,0x64,0x6b,0x73,0xec,0x85,
                               0xf1,0x6f,0xe1,0x67,0x25,0x10,0x77,0x32,0x9e,0x85,0x6e,0x69,0xb1,0x83,0x00,0xe4,
                               0x13,0xa4,0x45,0x34,0x3b,0x40,0xff,0x41,0x82,0x89,0x79,0x57,0xfd,0xd2,0x8e,0xe8,
                               0xfc,0x1d,0x19,0x21,0x12,0x00,0xd7,0x66,0xe5,0xc7,0x10,0x1d,0xcb,0x75,0xe8,0xfa,
                               0xb6,0xee,0x7b,0x2f,0x1a,0x25,0x24,0xb9,0x9f,0x1d,0x78,0xfb,0x84,0xd0,0x17,0x05,
                               0x71,0xb3,0xc8,0x18,0xff,0x62,0xee,0xed,0x53,0xab,0x78,0xd3,0x65,0x2d,0xbb,0xc7,
                               0xc1,0xe7,0x70,0xa2,0x43,0x2c,0x7c,0xc7,0x16,0x04,0xd2,0x45,0xd5,0x6b,0x6c,0x7a,
                               0x5e,0xa1,0x50,0x2e,0x31,0x5b,0xcc,0xe8,0x65,0x8b,0x16,0x85,0xbf,0x82,0x83,0xfb,
                               0xde,0x9f,0x36,0x48,0x32,0x79,0xd6,0x9b,0xfb,0x52,0x45,0xbf,0x43,0xf7,0x0b,0x0b,
                               0x19,0x19,0x31,0xc3,0x85,0xec,0x1d,0x8c,0x20,0xf0,0x3a,0xfa,0x80,0x4d,0x2c,0x7d,
                               0xac,0x60,0x09,0xc0,0x40,0xee,0xb9,0xeb,0x13,0x5b,0xe8,0x2b,0xb1,0x20,0xf0,0xce,
                               0x4c,0xbd,0xc6,0x04,0x86,0x70,0xc6,0x33,0xc3,0x15,0x0f,0x65,0x19,0xfd,0xc2,0xd3,

                               // Only the first 512 bytes of the table are initialized, the rest
                               // is just zeros.
                               // This is an idiocy in QW but we can't change this, or checksums
                               // will not match.
                           };

//For proxy protecting
byte COM_BlockSequenceCRCByte (byte *base, int length, int sequence) {
	unsigned short crc;
	byte *p;
	byte chkb[60 + 4];

	p = chktbl + ((unsigned int)sequence % (sizeof(chktbl) - 4));

	if (length > 60)
		length = 60;
	memcpy (chkb, base, length);

	chkb[length] = (sequence & 0xff) ^ p[0];
	chkb[length+1] = p[1];
	chkb[length+2] = ((sequence>>8) & 0xff) ^ p[2];
	chkb[length+3] = p[3];

	length += 4;

	crc = CRC_Block (chkb, length);

	crc &= 0xff;

	return crc;
}

//=====================================================================

#define	MAXPRINTMSG	4096

void (*rd_print) (char *) = NULL;

void Com_BeginRedirect (void (*RedirectedPrint) (char *)) {
	rd_print = RedirectedPrint;
}

void Com_EndRedirect (void) {
	rd_print = NULL;
}

// All console printing must go through this in order to be logged to disk
unsigned Print_flags[16];
int Print_current = 0;

/* FIXME: Please make us thread safe! */
void Com_Printf (char *fmt, ...) 
{
	va_list argptr;
	char msg[MAXPRINTMSG];

	va_start (argptr, fmt);
	vsnprintf (msg, sizeof(msg), fmt, argptr);
	va_end (argptr);

	if (rd_print) {
		// add to redirected message
		rd_print (msg);
		return;
	}

	// also echo to debugging console
	Sys_Printf ("%s", msg);

	/* This is beyond retarded because it may cause RECURSION */
	// Triggers with mask 64
	if (!(Print_flags[Print_current] & PR_TR_SKIP))
		CL_SearchForReTriggers (msg, RE_PRINT_INTERNAL);

	// write it to the scrollable buffer
	//	Con_Print (va("ezQuake: %s", msg));
	Con_PrintW (str2wcs(msg));
}

void Com_DPrintf (char *fmt, ...) 
{
	va_list argptr;
	char msg[MAXPRINTMSG];

	if (!developer.value)
		return;			// don't confuse non-developers with techie stuff...

	Print_flags[Print_current] |= PR_TR_SKIP;
	va_start (argptr,fmt);
	vsnprintf (msg, sizeof(msg), fmt, argptr);
	va_end (argptr);

	Com_Printf ("%s", msg);
}

void Com_Printf_State(int state, const char *fmt, ...)
{
/* Com_Printf equivalent with importance level as a first parm for each msg,
   it should be one of PRINT_OK, PRINT_INFO, PRINT_FAIL defines
   PRINT_OK won't be displayed unless we're in developer mode
*/
	va_list argptr;
	char *prefix = "";
	char msg[MAXPRINTMSG];

	msg[0] = 0;

	switch (state)
	{
		case PRINT_FAIL:
			prefix = "\x02" "\x10" "fail" "\x11 ";
			break;
		case PRINT_OK:

			if (!developer.integer)
				return;  // NOTE: print msgs only in developer mode

			prefix = " " " ok " "  ";
			break;
		case PRINT_DBG:
			if (!developer.integer)
				return;  // NOTE: print msgs only in developer mode

			prefix = "";
			break;

		case PRINT_WARNING:
		case PRINT_ALL:
			prefix = ""; // FIXME: put here some color
			break;
		case PRINT_ERR_FATAL:
			prefix = "";
			break;
		default:
		case PRINT_INFO:
			prefix = "\x9c\x9c\x9c ";
			break;
	}

	va_start (argptr, fmt);
	vsnprintf (msg, sizeof(msg), fmt, argptr);
	va_end(argptr);
	Com_Printf ("%s%s", prefix, msg);

	if (state == PRINT_ERR_FATAL)
		Sys_Error(msg);
}

void Com_PrintVerticalBar(int width)
{
	int i;
	Com_Printf("\x80");

	for (i = 0; i < width; i++)
	{
		Com_Printf("\x81");
	}

	Com_Printf("\x82");
}

void COM_ParseIPCData(const char *buf, unsigned int bufsize)
{
	if (Rulesets_RestrictIPC()) {
		Com_Printf("The use of IPC is not allowed during matches\n");
		return;
	}

	if (bufsize > 0)
	{
		// TODO : Expect some more fancy commands and stuff here instead.. if we want to use it for more than qw:// urls...
		if (!strncasecmp(buf, "qw://", 5))
		{
			Cbuf_AddText(va("qwurl %s\n", buf));
		}
		else
		{
			Cbuf_AddText(buf);
		}
	}
}

//
// Check if the first command line argument is a .qtv or a demo to be played.
//
qbool COM_CheckArgsForPlayableFiles(char *commandbuf_out, unsigned int commandbuf_size)
{
	// Check for .qtv or demo files to play.
	if (COM_Argc() >= 2) 
	{
		char *infile = COM_Argv(1);

		if (infile[0] && infile[0] != '-' && infile[0] != '+') 
		{
			char *ext = COM_FileExtension(infile);

			if (!strncasecmp(ext, "qtv", sizeof("qtv")))
			{
				snprintf(commandbuf_out, commandbuf_size, "qtvplay \"#%s\"\n", infile);
			}
			else if (!strncasecmp(ext, "qw", sizeof("qw")))
			{
				snprintf(commandbuf_out, commandbuf_size, "qtvplay \"#%s\"\n", infile);
			}
			else if (CL_IsDemoExtension(infile))
			{
				snprintf(commandbuf_out, commandbuf_size, "playdemo \"%s\"\n", infile);
			}
			else if (!strncasecmp(infile, "qw://", sizeof("qw://") - 1))
			{
				snprintf(commandbuf_out, commandbuf_size, "qwurl \"%s\"\n", infile);
			}
			else 
			{
				return false;
			}

			return true;
		}
	}

    return false;
}

//============================================================================

static char q_normalize_chartbl[256];
static qbool q_normalize_chartbl_init;

static void Q_normalizetext_Init (void)
{
	int i;

	for (i = 0; i < 32; i++)
		q_normalize_chartbl[i] = q_normalize_chartbl[i + 128] = '#';
	for (i = 32; i < 128; i++)
		q_normalize_chartbl[i] = q_normalize_chartbl[i + 128] = i;

	// special cases
	q_normalize_chartbl[10] = 10;
	q_normalize_chartbl[13] = 13;

	// dot
	q_normalize_chartbl[5      ] = q_normalize_chartbl[14      ] = q_normalize_chartbl[15      ] = q_normalize_chartbl[28      ] = q_normalize_chartbl[46      ] = '.';
	q_normalize_chartbl[5 + 128] = q_normalize_chartbl[14 + 128] = q_normalize_chartbl[15 + 128] = q_normalize_chartbl[28 + 128] = q_normalize_chartbl[46 + 128] = '.';

	// numbers
	for (i = 18; i < 28; i++)
		q_normalize_chartbl[i] = q_normalize_chartbl[i + 128] = i + 30;

	// brackets
	q_normalize_chartbl[16] = q_normalize_chartbl[16 + 128]= '[';
	q_normalize_chartbl[17] = q_normalize_chartbl[17 + 128] = ']';
	q_normalize_chartbl[29] = q_normalize_chartbl[29 + 128] = q_normalize_chartbl[128] = '(';
	q_normalize_chartbl[31] = q_normalize_chartbl[31 + 128] = q_normalize_chartbl[130] = ')';

	// left arrow
	q_normalize_chartbl[127] = '>';
	// right arrow
	q_normalize_chartbl[141] = '<';

	// '='
	q_normalize_chartbl[30] = q_normalize_chartbl[129] = q_normalize_chartbl[30 + 128] = '=';

	q_normalize_chartbl_init = true;
}

/*
==================
Q_normalizetext
returns readable extended quake names
==================
*/
char *Q_normalizetext (char *str)
{
	unsigned char	*i;

	if (!q_normalize_chartbl_init)
		Q_normalizetext_Init();

	for (i = (unsigned char*)str; *i; i++)
		*i = q_normalize_chartbl[*i];
	return str;
}

/*
==================
Q_redtext
returns extended quake names
==================
*/
unsigned char *Q_redtext (unsigned char *str)
{
	unsigned char *i;
	for (i = str; *i; i++)
		if (*i > 32 && *i < 128)
			*i |= 128;
	return str;
}
//<-

/*
==================
Q_yelltext
returns extended quake names (yellow numbers)
==================
*/
unsigned char *Q_yelltext (unsigned char *str)
{
	unsigned char *i;
	for (i = str; *i; i++)
	{
		if (*i >= '0' && *i <= '9')
			*i += 18 - '0';
		else if (*i > 32 && *i < 128)
			*i |= 128;
		else if (*i == 13)
			*i = ' ';
	}
	return str;
}

//=====================================================================

// "GPL map" support.  If we encounter a map with a known "GPL" CRC,
// we fake the CRC so that, on the client side, the CRC of the original
// map is transferred to the server, and on the server side, comparison
// of clients' CRC is done against the orignal one
typedef struct {
	const char *mapname;
	int original;
	int gpl;
} csentry_t;

static csentry_t table[] = {
	// CRCs for AquaShark's "simpletextures" maps
	{ "dm1",  0xc5c7dab3, 0x7d37618e },
	{ "dm2",  0x65f63634, 0x7b337440 },
	{ "dm3",  0x15e20df8, 0x912781ae },
	{ "dm4",  0x9c6fe4bf, 0xc374df89 },
	{ "dm5",  0xb02d48fd, 0x77ca7ce5 },
	{ "dm6",  0x5208da2b, 0x200c8b5d },
	{ "end",  0xbbd4b4a5, 0xf89b12ae }, // this is the version with the extra room
	{ "end",  0xbbd4b4a5, 0x924f4d33 }, // GPL end
	{ "e2m2", 0xaf961d4d, 0xa23126c5 }, // GPL e2m2
	{ NULL, 0, 0 },
};

int Com_TranslateMapChecksum (const char *mapname, int checksum)
{
	csentry_t *p;

//	Com_Printf ("Map checksum (%s): 0x%x\n", mapname, checksum);

	for (p = table; p->mapname; p++)
		if (!strcmp(p->mapname, mapname) && checksum == p->gpl)
			return p->original;

	return checksum;
}

float AdjustAngle(float current, float ideal, float fraction)
{
	float move = ideal - current;

	if (move >= 180)
		move -= 360;
	else if (move <= -180)
		move += 360;

	return current + fraction * move;
}

int Q_namecmp(const char* s1, const char* s2)
{
	if (s1 == NULL && s2 == NULL)
		return 0;

	if (s1 == NULL)
		return -1;

	if (s2 == NULL)
		return 1;

	while (*s1 || *s2) {
		if (tolower(*s1 & 0x7f) != tolower(*s2 & 0x7f)) {
			return tolower(*s1 & 0x7f) - tolower(*s2 & 0x7f);
		}
		s1++;
		s2++;
	}

	return 0;
}


================================================
FILE: src/common.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: common.h,v 1.76 2007-10-13 15:36:56 cokeman1982 Exp $
*/
// common.h  -- general definitions

#ifndef __COMMON_H__
#define __COMMON_H__

//============================================================================

// include frequently used headers

// fixes mingw warning about winsock2.h
#ifdef _WIN32
#include <winsock2.h>
#endif

#include "q_shared.h"
#include "zone.h"
#include "cvar.h"
#include "cmd.h"
#include "net.h"
#include "protocol.h"
#include "cmodel.h"
#include "cmdline_params.h"
#include "fs.h"

#if defined(_WIN64) && !defined(__MINGW64__)
int Q_strlen(const char* s);
#define strlen Q_strlen
#endif

typedef struct texture_ref_s { unsigned int index; } texture_ref;
extern const texture_ref null_texture_reference;
qbool R_TextureValid(texture_ref ref);
#define R_TextureReferenceIsValid(ref) ((ref).index && R_TextureValid(ref))
#define R_TextureReferenceInvalidate(ref) { (ref).index = 0; }
#define R_TextureReferenceEqual(ref1, ref2) ((ref1).index == (ref2).index)
#define R_TextureReferenceCompare(ref1, ref2) (ref1.index < ref2.index ? -1 : ref1.index > ref2.index ? 1 : 0)

typedef enum
{
	mod_brush,
	mod_sprite,
	mod_alias,
	mod_alias3,

	mod_unknown
} modtype_t;

//============================================================================

// per-level limits
#define CL_MAX_EDICTS           2048	// FIXME: ouch! ouch! ouch!
#define MAX_EDICTS              2048    // can't encode more than this, see SV_WriteDelta
#define MAX_EDICTS_SAFE         512     // lower limit, to make sure no client limits exceeded
#define MAX_LIGHTSTYLES         64
#define MAX_MODELS              4096    // can't encode more than this, see SV_WriteDelta
#define MAX_STATIC_ENTITIES     2048
#define MAX_VWEP_MODELS         32	    // could be increased to 256
#define MAX_SOUNDS              256	    // so they cannot be blindly increased

#define	SAVEGAME_COMMENT_LENGTH 39

//============================================================================

// stats are integers communicated to the client by the server
#define	MAX_CL_STATS		32

#define STAT_HEALTH             0
//define STAT_FRAGS             1
#define STAT_WEAPON             2
#define STAT_AMMO               3
#define STAT_ARMOR              4
//define STAT_WEAPONFRAME       5
#define STAT_SHELLS             6
#define STAT_NAILS              7
#define STAT_ROCKETS            8
#define STAT_CELLS              9
#define STAT_ACTIVEWEAPON       10
#define STAT_TOTALSECRETS       11
#define STAT_TOTALMONSTERS      12
#define STAT_SECRETS            13		// bumped on client side by svc_foundsecret
#define STAT_MONSTERS           14		// bumped by svc_killedmonster
#define STAT_ITEMS              15
#define STAT_VIEWHEIGHT         16		// Z_EXT_VIEWHEIGHT protocol extension
#define STAT_TIME               17		// Z_EXT_TIME extension
#define STAT_MATCHSTARTTIME     18		// Server should send this as msec (int)

// item flags
#define	IT_SHOTGUN              1
#define	IT_SUPER_SHOTGUN        2
#define	IT_NAILGUN              4
#define	IT_SUPER_NAILGUN        8
#define	IT_GRENADE_LAUNCHER     16
#define	IT_ROCKET_LAUNCHER      32
#define	IT_LIGHTNING            64
#define	IT_SUPER_LIGHTNING      128
#define	IT_SHELLS               256
#define	IT_NAILS                512
#define	IT_ROCKETS              1024
#define	IT_CELLS                2048
#define	IT_AXE                  4096
#define	IT_ARMOR1               8192
#define	IT_ARMOR2               16384
#define	IT_ARMOR3               32768
#define	IT_SUPERHEALTH          65536
#define	IT_KEY1                 131072
#define	IT_KEY2                 262144
#define	IT_INVISIBILITY         524288
#define	IT_INVULNERABILITY      1048576
#define	IT_SUIT                 2097152
#define	IT_QUAD                 4194304

#define IT_ALL_WEAPONS          (IT_AXE | IT_SHOTGUN | IT_SUPER_SHOTGUN | IT_NAILGUN | IT_SUPER_NAILGUN | IT_GRENADE_LAUNCHER | IT_ROCKET_LAUNCHER | IT_LIGHTNING | IT_SUPER_LIGHTNING)

#define	IT_SIGIL1               (1<<28)
#define	IT_SIGIL2               (1<<29)
#define	IT_SIGIL3               (1<<30)
#define	IT_SIGIL4               (1<<31)

//
// entity effects
//
#define EF_BRIGHTFIELD        1
#define EF_MUZZLEFLASH        2
#define EF_GREEN              2     // D-Kure: EF_GREEN will replace
#define EF_BRIGHTLIGHT        4     // EF_MUZZLEFLASH and provide RGB colours
#define EF_DIMLIGHT           8     // Both are needed as NQ uses EF_MUZZLE..
#define EF_FLAG1             16
#define EF_FLAG2             32
#define EF_BLUE              64
#define EF_RED              128

// game types sent by serverinfo
// these determine which intermission screen plays
#define	GAME_COOP			0
#define	GAME_DEATHMATCH		1

#define	MAX_INFO_KEY 64
//#define	MAX_INFO_STRING	1024
#define	MAX_SERVERINFO_STRING 512
#define	MAX_LOCALINFO_STRING 32768

#define	MAX_KEY_STRING      (MAX_INFO_KEY)     // mvdsv compatibility
#define	MAX_EXT_INFO_STRING (MAX_INFO_STRING)  // mvdsv compatibility

//============================================================================

#define Cvar_SetROM	Cvar_ForceSet	// mvdsv compatibility

#define Con_Printf  Com_Printf  	// mvdsv compatibility
#define Con_DPrintf Com_DPrintf		// mvdsv compatibility
#define fs_gamedir  com_gamedir		// mvdsv compatibility

//============================================================================


#define MAX_COM_TOKEN 1024

extern	char	com_token[MAX_COM_TOKEN];
extern	qbool	com_eof;
typedef enum {TTP_UNKNOWN, TTP_STRING} com_tokentype_t;

const char *COM_Parse(const char *data);
const char* COM_ParseEx(const char* data, qbool curlybraces);
char *COM_ParseToken (const char *data, const char *punctuation);

char *COM_Argv (int arg); // range and null checked
void COM_ClearArgv (int arg);
void COM_AddParm (char *parm);
void COM_InitArgv (int argc, char **argv);
int COM_Argc (void);
int COM_CheckParm(cmdline_param_id parm_id);
int COM_CheckParmOffset(cmdline_param_id parm_id, int offset);
int COM_FindParm(const char* parm);
const char* Cmd_CommandLineParamName(cmdline_param_id id);

#define IsDeveloperMode() (COM_CheckParm(cmdline_param_developer_mode))

// equals to consecutive calls of strtok(s, " ") that assign values to array
// "1 3.5 6 7" will lead to fl_array[0] = 1.0; fl_array[1] = 3.5; ...
int COM_GetFloatTokens(const char *s, float *fl_array, int fl_array_size);

void COM_Init (void);

const char *COM_SkipPath (const char *pathname);
char *COM_SkipPathWritable (char *pathname);
char *COM_FitPath(char *dest, int destination_size, char *src, int size_to_fit);
char *COM_FileExtension (const char *in);
void COM_StripExtension (const char *in, char *out, int out_size);
void COM_FileBase (const char *in, char *out);
void COM_DefaultExtension (char *path, char *extension, size_t path_len);
// If path doesn't have an extension or has a different extension, append(!) specified extension.
// path buffer supposed to be MAX_OSPATH size
void COM_ForceExtension (char *path, char *extension);
// If path doesn't have an extension or has a different extension, append(!) specified extension.
// a bit extended version of COM_ForceExtension(), we suply size of path, so append safe, sure if u provide right path size
void COM_ForceExtensionEx (char *path, char *extension, size_t path_size);
int COM_GetTempDir(char *buf, int bufsize);
qbool COM_WriteToUniqueTempFile(char* path, int path_buffer_size, const char* ext, const byte* buffer, size_t bytes);
qbool COM_WriteToUniqueTempFileVFS(char* path, int path_buffer_size, const char* ext, vfsfile_t* input);
qbool COM_FileExists(char *path);
void COM_StoreOriginalCmdline(int argc, char **argv);

extern char *SYSINFO_GetString(void);

char *va(const char *format, ...); // does a varargs printf into a temp buffer

//============================================================================
// Quake File System
// for more File System control, include fs.h in your sources

extern int fs_filepos;
extern char *com_filesearchpath;
extern char	fs_netpath[MAX_OSPATH];
struct cache_user_s;

extern char	com_gamedir[MAX_OSPATH];
extern char	com_basedir[MAX_OSPATH];
extern char	com_gamedirfile[MAX_QPATH];
extern char com_homedir[MAX_PATH];

extern qbool file_from_gamedir;	// set if file came from a gamedir (and gamedir wasn't id1/qw)

void FS_InitFilesystem (void);
void FS_Shutdown(void);
void FS_SetGamedir (char *dir, qbool force);
int FS_FOpenFile (const char *filename, FILE **file);
int FS_FOpenPathFile (const char *filename, FILE **file);
byte *FS_LoadTempFile (char *path, int *len);
byte *FS_LoadHunkFile (char *path, int *len);
byte *FS_LoadHeapFile (const char *path, int *len);
qbool FS_WriteFile(const char *filename, const void *data, int len); //The filename will be prefixed by com_basedir
qbool FS_WriteFile_2(const char *filename, const void *data, int len); //The filename used as is
void FS_CreatePath (char *path);
int FS_FCreateFile (char *filename, FILE **file, char *path, char *mode);
char *FS_LegacyDir (char *media_dir);

int FS_FileLength (FILE *f);
int FS_FileOpenRead (char *path, FILE **hndl);

char * FS_Locate_GetPath (const char *file);

//============================================================
// Alternative variant manipulation with info strings
//============================================================

#define INFO_HASHPOOL_SIZE 256

#define MAX_CLIENT_INFOS 128

typedef struct info_s {
	struct info_s	*hash_next;
	struct info_s	*next;

	char				*name;
	char				*value;

} info_t;

typedef struct ctxinfo_s {

	info_t	*info_hash[INFO_HASHPOOL_SIZE];
	info_t	*info_list;

	int		cur; // current infos
	int		max; // max    infos

} ctxinfo_t;

// return value for given key
char			*Info_Get(ctxinfo_t *ctx, const char *name);
// set value for given key
qbool			Info_Set (ctxinfo_t *ctx, const char *name, const char *value);
// set value for given star key
qbool			Info_SetStar (ctxinfo_t *ctx, const char *name, const char *value);
// remove given key
qbool			Info_Remove (ctxinfo_t *ctx, const char *name);
// remove all infos
void			Info_RemoveAll (ctxinfo_t *ctx);
// convert old way infostring to new way: \name\qqshka\noaim\1 to hashed variant
qbool			Info_Convert(ctxinfo_t *ctx, char *str);
// convert new way to old way
qbool			Info_ReverseConvert(ctxinfo_t *ctx, char *str, int size);
// copy star keys from ont ctx to other
qbool			Info_CopyStar(ctxinfo_t *ctx_from, ctxinfo_t *ctx_to);
// just print all key value pairs
void			Info_PrintList(ctxinfo_t *ctx);

//============================================================================

char *Info_ValueForKey (char *s, char *key);
void Info_RemoveKey (char *s, char *key);
void Info_RemovePrefixedKeys (char *start, char prefix);
void Info_SetValueForKey (char *s, char *key, char *value, int maxsize);
void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize);
void Info_Print (char *s);

// Same as Info_SetValueForStarKey() but allow do not check for key and value length is less than MAX_INFO_KEY.
// Please do NOT use it unless you sure.
void Info_SetValueForStarKeyEx (char *s, char *key, char *value, int maxsize, qbool max_info_key_check);
// Same as Info_SetValueForKey() but allow do not check for key and value length is less than MAX_INFO_KEY.
// Please do NOT use it unless you sure.
void Info_SetValueForKeyEx (char *s, char *key, char *value, int maxsize, qbool max_info_key_check);

unsigned Com_BlockChecksum (void *buffer, int length);
void Com_BlockFullChecksum (void *buffer, int len, unsigned char *outbuf);
byte COM_BlockSequenceCRCByte (byte *base, int length, int sequence);

//============================================================================

void Com_BeginRedirect (void (*RedirectedPrint) (char *));
void Com_EndRedirect (void);
void Com_Printf (char *fmt, ...);
void Com_DPrintf (char *fmt, ...);
void Com_PrintVerticalBar(int width);

// why not just 1 2 3 4 ... ?
#define PRINT_OK		(1<<0) // have prefix, printed only if developer != 0
#define PRINT_INFO		(1<<1) // have prefix
#define PRINT_FAIL		(1<<2) // have prefix
#define PRINT_WARNING	(1<<3) // do not have prefix
#define PRINT_ALL		(1<<4) // do not have prefix
#define PRINT_ERR_FATAL	(1<<5) // do Sys_Error()
#define PRINT_DBG		(1<<6) // do not have prefix, printed only if developer != 0

void Com_Printf_State(int state, const char *fmt, ...);

extern unsigned	Print_flags[16];
extern int	Print_current;

#define     PR_SKIP     1
#define     PR_LOG_SKIP 2
#define     PR_TR_SKIP  4
#define     PR_IS_CHAT  8
#define     PR_NONOTIFY 16
#define     PR_NORESET  32        // Don't reset at the end of each Print() call

//============================================================================

#ifdef FTE_PEXT_FLOATCOORDS

typedef union {	//note: reading from packets can be misaligned
	int b4;
	float f;
	short b2;
	char b[4];
} coorddata;

extern int msg_coordsize; // 2 or 4.
extern int msg_anglesize; // 1 or 2.

float MSG_FromCoord(coorddata c, int bytes);
coorddata MSG_ToCoord(float f, int bytes);	//return value should be treated as (char*)&ret;
coorddata MSG_ToAngle(float f, int bytes);	//return value is NOT byteswapped.

#endif

struct usercmd_s;

extern struct usercmd_s nullcmd;

void MSG_WriteChar (sizebuf_t *sb, int c);
void MSG_WriteByte (sizebuf_t *sb, int c);
void MSG_WriteShort (sizebuf_t *sb, int c);
void MSG_WriteLong (sizebuf_t *sb, int c);
void MSG_WriteFloat (sizebuf_t *sb, float f);
void MSG_WriteString (sizebuf_t *sb, const char *s);
void MSG_WriteUnterminatedString (sizebuf_t *sb, char *s);
void MSG_WriteCoord (sizebuf_t *sb, float f);
void MSG_WriteLongCoord (sizebuf_t *sb, float f);
void MSG_WriteAngle (sizebuf_t *sb, float f);
void MSG_WriteAngle16 (sizebuf_t *sb, float f);
int MSG_WriteDeltaUsercmd (sizebuf_t *sb, struct usercmd_s *from, struct usercmd_s *cmd, unsigned int mvdsv_extensions);
void MSG_WriteDeltaEntity  (entity_state_t *from, entity_state_t *to, sizebuf_t *msg, qbool force, unsigned int fte_extensions, unsigned int mvdsv_extensions);

extern	int	msg_readcount;
extern	qbool	msg_badread; // set if a read goes beyond end of message

void MSG_BeginReading (void);
int MSG_GetReadCount(void);
int MSG_ReadChar (void);
int MSG_ReadByte (void);
int MSG_ReadShort (void);
int MSG_ReadLong (void);
float MSG_ReadFloat (void);
char *MSG_ReadString (void);
char *MSG_ReadStringLine (void);

float MSG_ReadCoord (void);
float MSG_ReadFloatCoord (void);
float MSG_ReadAngle (void);
float MSG_ReadAngle16 (void);
void MSG_ReadDeltaUsercmd (struct usercmd_s *from, struct usercmd_s *cmd, int protoversion);

void MSG_ReadData (void *data, int len);
void MSG_ReadSkip(int bytes);

//============================================================================

extern cvar_t	developer;
extern cvar_t	host_mapname;

extern qbool	com_serveractive; // true if sv.state != ss_dead
extern int	CL_ClientState (void); // returns cls.state

extern double	curtime; // not bounded or scaled, shared by local client and server

// host
extern qbool host_initialized;
extern qbool host_everything_loaded;
extern int host_memsize;

void Host_Init (int argc, char **argv, int default_memsize);
void Host_ClearMemory (void);
void Host_Shutdown (void);
void Host_Frame (double time);
void Host_Abort (void);	 // longjmp() to Host_Frame
void Host_EndGame (void); // kill local client and server
void Host_Error (char *error, ...);
void Host_Quit (void);

void CL_Init (void);
void CL_Shutdown (void);
void CL_Frame (double time);
void CL_Disconnect(void);
void CL_BeginLocalConnection (void);
void CL_UpdateCaption(qbool force);
void Con_Init (void);

void SV_Init (void);
void SV_Shutdown (char *finalmsg);
void SV_Frame (double time);

void SV_Error (char *error, ...);

void COM_ParseIPCData(const char *buf, unsigned int bufsize);

qbool COM_CheckArgsForPlayableFiles(char *commandbuf_out, unsigned int commandbuf_size);

int Com_TranslateMapChecksum (const char *mapname, int checksum);
float AdjustAngle(float current, float ideal, float fraction);

char *Q_normalizetext(char *str);
unsigned char *Q_redtext(unsigned char *str);
unsigned char *Q_yelltext(unsigned char *str);

// Name comparison: case insensitive, red/white text insensitive
int Q_namecmp(const char* s1, const char* s2);

#endif /* !__COMMON_H__ */



================================================
FILE: src/common_draw.c
================================================
/*
Module for common graphics (soft and GL)

Copyright (C) 2011 ezQuake team and kazik

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <time.h>
#include "quakedef.h"
#include "localtime.h"
#include "common_draw.h"
#include "stats_grid.h"
#include "utils.h"
#include "Ctrl.h"

#include "gl_model.h"

void Draw_ClearConback(void);

// FIXME: this is horrible - points to &hud_gameclock_offset->integer
int* gameclockoffset;

#if 0
void Draw_CenterString (int y, char *str)
{
    Draw_String((vid.width-(8*strlen(str)))/2, y, str);
}

void Draw_CenterAltString (int y, char *str)
{
    Draw_Alt_String((vid.width-(8*strlen(str)))/2, y, str);
}

/*
==================
SCR_DrawDemoStatus
draws demo name, status and progress
==================
*/
int SCR_DrawDemoStatus(void)
{
    extern cvar_t demo_statustime;
    char st[128];
    int x, y;
    int w, i;
    int mins, secs;

    if (cls.timedemo || !cls.demoplayback)
        return 0;

    if (!cls.demopaused  &&  (realtime - cls.demobartime > demo_statustime.value  ||  cls.demobartime < 0))
        return 0;

    w = min(((vid.width / 2) / 16) * 2, 40);
    //w = 20;

    x = vid.width / 2 - (w*8/2);
    y = vid.height - sb_lines - 8;

    // status
    if (cls.demopaused)
        Draw_String(vid.width/2-4*6, y-16, "paused");

    // speed
    snprintf (st, sizeof (st), "%d%%", cls.demospeed);
    Draw_String(x+8, y-16, st);

    // status - time
    mins = ((int)(hosttime-cls.demostarttime)) / 60;
    secs = ((int)(hosttime-cls.demostarttime)) % 60;
    snprintf (st, sizeof (st), "%d:%02d", mins, secs);
    Draw_String(x+8*(w-strlen(st)-1), y-16, st);

    // progress bar
    memset(st, '\x81', w);
    st[0] = '\x80';
    st[w-1] = '\x82';
    st[w] = 0;
    Draw_String(x, y-24, st);
    Draw_Character((int)(x + 8*((cls.demopos / cls.demolength)*(w-3)+1)), y-24, '\x83');

    // demo name
    strlcpy (st, cls.demoname, sizeof (st));
    st[vid.width/8] = 0;
    Draw_Alt_String(vid.width/2 - 4*strlen(st), y-4, st);

    return 1;
}

/*
==================
SCR_PrepareCrosshair
prepare crosshair shape in memory for drawing functions (both soft and GL)
==================
*/
#define CSET(x,y) tab[x+5][y+5]=1
void PrepareCrosshair(int num, byte tab[10][10])
{
    int i, j;
    for (i=0; i < 10; i++)
        for (j=0; j < 10; j++)
            tab[i][j] = 0;

    switch (num)
    {
    case 3:
        CSET(0-2,0-2);
        CSET(0-3,0-3);
        CSET(0-4,0-4);
        CSET(0+2,0+2);
        CSET(0+3,0+3);
        CSET(0+4,0+4);
        CSET(0+2,0-2);
        CSET(0+3,0-3);
        CSET(0+4,0-4);
        CSET(0-2,0+2);
        CSET(0-3,0+3);
        CSET(0-4,0+4);
        break;
    case 4:
        CSET(0 - 2, 0 - 2);
        CSET(0 - 3, 0 - 3);
        CSET(0 + 2, 0 + 2);
        CSET(0 + 3, 0 + 3);
        CSET(0 + 2, 0 - 2);
        CSET(0 + 3, 0 - 3);
        CSET(0 - 2, 0 + 2);
        CSET(0 - 3, 0 + 3);
        break;
    case 5:
        CSET(0, 0 - 2);
        CSET(0, 0 - 3);
        CSET(0, 0 - 4);
        CSET(0 + 2, 0 + 2);
        CSET(0 + 3, 0 + 3);
        CSET(0 + 4, 0 + 4);
        CSET(0 - 2, 0 + 2);
        CSET(0 - 3, 0 + 3);
        CSET(0 - 4, 0 + 4);
        break;
    case 6:
        CSET(0    , 0 - 1);
        CSET(0 - 1, 0    );
        CSET(0    , 0    );
        CSET(0 + 1, 0    );
        CSET(0    , 0 + 1);
        break;
    case 7:
        CSET(0 - 1, 0 - 1);
        CSET(0    , 0 - 1);
        CSET(0 + 1, 0 - 1);
        CSET(0 - 1, 0    );
        CSET(0    , 0    );
        CSET(0 + 1, 0    );
        CSET(0 - 1, 0 + 1);
        CSET(0    , 0 + 1);
        CSET(0 + 1, 0 + 1);
        break;
    case 8:
        CSET(0 + 1, 0 + 1);
        CSET(0    , 0 + 1);
        CSET(0 + 1, 0    );
        CSET(0    , 0    );
        break;
    case 9:
        CSET(0, 0);
        break;
    case 10:
        CSET(-2, -2);
        CSET(-2, -1);
        CSET(-1, -2);
        CSET(2, -2);
        CSET(2, -1);
        CSET(1, -2);
        CSET(-2, 2);
        CSET(-2, 1);
        CSET(-1, 2);

        CSET(2, 2);
        CSET(2, 1);
        CSET(1, 2);
        break;
    case 11:
        CSET(0, -1);
        CSET(1, -1);
        CSET(-1, 0);
        CSET(2, 0);
        CSET(-1, 1);
        CSET(2, 1);
        CSET(0, 2);
        CSET(1, 2);
        break;
    case 12:
        CSET(0, -1);
        CSET(1, -1);
        CSET(-1, 0);
        CSET(2, 0);
        CSET(-1, 1);
        CSET(2, 1);
        CSET(0, 2);
        CSET(1, 2);

        CSET(0, 0);
        CSET(1, 0);
        CSET(0, 1);
        CSET(1, 1);
        break;
    case 13:
        CSET(0, -2);
        CSET(1, -2);
        CSET(-1, -1);
        CSET(0, -1);
        CSET(1, -1);
        CSET(2, -1);
        CSET(-2, 0);
        CSET(-1, 0);
        CSET(2, 0);
        CSET(3, 0);
        CSET(-2, 1);
        CSET(-1, 1);
        CSET(2, 1);
        CSET(3, 1);
        CSET(-1, 2);
        CSET(0, 2);
        CSET(1, 2);
        CSET(2, 2);
        CSET(0, 3);
        CSET(1, 3);
        break;
    case 14:
        CSET(0, -2);
        CSET(1, -2);
        CSET(-1, -1);
        CSET(0, -1);
        CSET(1, -1);
        CSET(2, -1);
        CSET(-2, 0);
        CSET(-1, 0);
        CSET(2, 0);
        CSET(3, 0);
        CSET(-2, 1);
        CSET(-1, 1);
        CSET(2, 1);
        CSET(3, 1);
        CSET(-1, 2);
        CSET(0, 2);
        CSET(1, 2);
        CSET(2, 2);
        CSET(0, 3);
        CSET(1, 3);

        CSET(0, 0);
        CSET(1, 0);
        CSET(0, 1);
        CSET(1, 1);
        break;
    case 15:
        CSET(-1, -3);
        CSET( 0, -3);
        CSET( 1, -3);

        CSET(-2, -2);
        CSET(-1, -2);
        CSET( 0, -2);
        CSET( 1, -2);
        CSET( 2, -2);

        CSET(-3, -1);
        CSET(-2, -1);
        CSET(-1, -1);
        CSET( 1, -1);
        CSET( 2, -1);
        CSET( 3, -1);

        CSET(-3, 0);
        CSET(-2, 0);
        CSET( 2, 0);
        CSET( 3, 0);

        CSET(-3, 1);
        CSET(-2, 1);
        CSET(-1, 1);
        CSET( 1, 1);
        CSET( 2, 1);
        CSET( 3, 1);

        CSET(-2, 2);
        CSET(-1, 2);
        CSET( 0, 2);
        CSET( 1, 2);
        CSET( 2, 2);

        CSET(-1, 3);
        CSET( 0, 3);
        CSET( 1, 3);
        break;
    case 16:
        CSET(-1, -3);
        CSET( 0, -3);
        CSET( 1, -3);

        CSET(-2, -2);
        CSET(-1, -2);
        CSET( 0, -2);
        CSET( 1, -2);
        CSET( 2, -2);

        CSET(-3, -1);
        CSET(-2, -1);
        CSET(-1, -1);
        CSET( 1, -1);
        CSET( 2, -1);
        CSET( 3, -1);

        CSET(-3, 0);
        CSET(-2, 0);
        CSET( 2, 0);
        CSET( 3, 0);

        CSET(-3, 1);
        CSET(-2, 1);
        CSET(-1, 1);
        CSET( 1, 1);
        CSET( 2, 1);
        CSET( 3, 1);

        CSET(-2, 2);
        CSET(-1, 2);
        CSET( 0, 2);
        CSET( 1, 2);
        CSET( 2, 2);

        CSET(-1, 3);
        CSET( 0, 3);
        CSET( 1, 3);

        CSET(-1,  0);
        CSET( 1,  0);
        CSET( 0, -1);
        CSET( 0,  1);
        CSET( 0,  0);
        break;
    default:
        CSET(0 - 1, 0);
        CSET(0 - 3, 0);
        CSET(0 + 1, 0);
        CSET(0 + 3, 0);
        CSET(0, 0 - 1);
        CSET(0, 0 - 3);
        CSET(0, 0 + 1);
        CSET(0, 0 + 3);
        break;
    }
}

/*
==================
SCR_DrawClients
draws clients list with selected values from userinfo
==================
*/
void SCR_DrawClients(void)
{
	extern sb_showclients;
	int uid_w, clients;
	int i, y, x;
	char line[128], buf[64];

	if (!sb_showclients || cls.state == ca_disconnected)
		return;

	// prepare
	clients = 0;
	uid_w = 3;
	for (i=0; i < MAX_CLIENTS; i++)
	{
		int w;

		if (!cl.players[i].name[0])
			continue;

		clients++;
		w = strlen(va("%d", cl.players[i].userid));

		if (w > uid_w)
			uid_w = w;
	}

	y = (vid.height - sb_lines - 8 * (clients + 6));
	y = max (y, 0);
	x = (vid.width - 320) / 2 + 4;

	strlcpy (line, " # ", sizeof (line));
	snprintf (buf, sizeof (buf), "%*.*s ", uid_w, uid_w, "uid");
	strlcat (line, buf, sizeof (line));
	snprintf (buf, sizeof (buf), "%-*.*s ", 16-uid_w, 16-uid_w, "name");
	strlcat (line, buf, sizeof (line));
	strlcat (line, "team skin     rate", sizeof (line));

	Draw_String (x, y, line);
	y += 8;

	strlcpy (line, "\x1D\x1F \x1D", sizeof (line));
	snprintf (buf, sizeof (buf), "%*.*s", uid_w-2, uid_w-2, "\x1E\x1E\x1E\x1E");
	strlcat (line, buf, sizeof (line));
	strlcat (line, "\x1F \x1D", sizeof (line));
	snprintf (buf, sizeof (buf), "%*.*s", 16-uid_w-2, 16-uid_w-2, "\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E");
	strlcat (line, buf, sizeof (line));
    strlcat (line, "\x1F \x1D\x1E\x1E\x1F \x1D\x1E\x1E\x1E\x1E\x1E\x1E\x1F \x1D\x1E\x1E\x1F", sizeof (line));

	Draw_String(x, y, line);
    y += 8;

	for (i=0; i < MAX_CLIENTS; i++)
	{
		if (!cl.players[i].name[0])
			continue;

		if (y > vid.height - 8)
			break;

		line[0] = 0;

		snprintf (buf, sizeof (buf), "%2d ", i);
		strlcat (line, buf, sizeof (line));

		snprintf (buf, sizeof (buf), "%*d ", uid_w, cl.players[i].userid);
        strlcat(line, buf, sizeof (line));

		snprintf (buf, sizeof (buf), "%-*.*s ", 16-uid_w, 16-uid_w, cl.players[i].name);
		strlcat (line, buf, sizeof (line));

		snprintf(buf, sizeof (buf), "%-4.4s ", Info_ValueForKey(cl.players[i].userinfo, "team"));
		strlcat (line, buf, sizeof (line));

		if (cl.players[i].spectator)
			strlcpy (buf, "<spec>   ", sizeof (buf));
		else
			snprintf (buf, sizeof (buf), "%-8.8s ", Info_ValueForKey(cl.players[i].userinfo, "skin"));

		strlcat (line, buf, sizeof (line));

		snprintf (buf, sizeof (buf), "%4d", min(9999, atoi(Info_ValueForKey(cl.players[i].userinfo, "rate"))));
		strlcat (line, buf, sizeof (line));

		Draw_String (x, y, line);
		y += 8;
	}
}
#endif

cachepic_node_t *cachepics[CACHED_PICS_HDSIZE];

/*
 * Removes the pic from the cache if refcount hits zero,
 * otherwise decreases refcount.
 */
qbool CachePic_Remove(const char *path)
{
	int key = Com_HashKey(path) % CACHED_PICS_HDSIZE;
	cachepic_node_t *searchpos = cachepics[key];
	cachepic_node_t *old = NULL;

	while (searchpos) {
		if (!strcmp(searchpos->data.name, path)) {
			searchpos->refcount--;

			if (searchpos->refcount == 0) {
				if (old == NULL) {
					/* It's the first entry in list.
					 * Set new start to next item in list
					 * or NULL if we're the only entry.*/
					cachepics[key] = searchpos->next;
				} else {
					/* It's in the middle or end of the list.
					 * Need to make sure the prev entry points
					 * to the next one and skips us. */
					old->next = searchpos->next;
				}
				/* Free both data and our entry itself */
				Q_free(searchpos->data.pic);
				Q_free(searchpos);
			}
			return true;
		}
		old = searchpos;
		searchpos = searchpos->next;
	}
	return false;
}

// Same as CachePic_Remove, but without specifying the name
qbool CachePic_RemoveByPic(mpic_t* pic)
{
	int key;

	for (key = 0; key < CACHED_PICS_HDSIZE; ++key) {
		cachepic_node_t *searchpos = cachepics[key];
		cachepic_node_t *old = NULL;

		while (searchpos) {
			if (searchpos->data.pic == pic) {
				searchpos->refcount--;

				if (searchpos->refcount == 0) {
					if (old == NULL) {
						/* It's the first entry in list.
						* Set new start to next item in list
						* or NULL if we're the only entry.*/
						cachepics[key] = searchpos->next;
					}
					else {
						/* It's in the middle or end of the list.
						* Need to make sure the prev entry points
						* to the next one and skips us. */
						old->next = searchpos->next;
					}
					/* Free both data and our entry itself */
					Q_free(searchpos->data.pic);
					Q_free(searchpos);
				}
				return true;
			}
			old = searchpos;
			searchpos = searchpos->next;
		}
	}
	return false;
}

mpic_t *CachePic_Find(const char *path, qbool inc_refcount) 
{
	int key = Com_HashKey(path) % CACHED_PICS_HDSIZE;
	cachepic_node_t *searchpos = cachepics[key];

	while (searchpos) {
		if (!strcmp(searchpos->data.name, path)) {
			if (inc_refcount) {
				searchpos->refcount++;
			}
			return searchpos->data.pic;
		}
		searchpos = searchpos->next;
	}

	return NULL;
}

/* Copies data if necessary to make use of the refcount */
mpic_t *CachePic_Add(const char *path, mpic_t *pic) 
{
	int key = Com_HashKey(path) % CACHED_PICS_HDSIZE;
	cachepic_node_t *searchpos = cachepics[key];
	cachepic_node_t **nextp = cachepics + key;

	while (searchpos) {
		/* Check if we already have the entry */
		if (!strcmp(searchpos->data.name, path)) {
			searchpos->refcount++;
			return searchpos->data.pic;
		}
		nextp = &searchpos->next;
		searchpos = searchpos->next;
	}

	/* We didn't find a matching entry, create a new one */
	searchpos = Q_malloc_named(sizeof(cachepic_node_t), path);
	searchpos->data.pic = Q_malloc_named(sizeof(mpic_t), path);
	memcpy(searchpos->data.pic, pic, sizeof(mpic_t));
	
	strlcpy(searchpos->data.name, path, sizeof(searchpos->data.name));
	searchpos->next = NULL; // Terminate the list.
	searchpos->refcount++;
	*nextp = searchpos;		// Connect to the list.

	return searchpos->data.pic;
}

void CachePics_Shutdown(void)
{
	int i;
	cachepic_node_t *cur = NULL, *nxt = NULL;

	for (i = 0; i < CACHED_PICS_HDSIZE; i++)
	{
		for (cur = cachepics[i]; cur; cur = nxt)
		{
			nxt = cur->next;
			Q_free(cur->data.pic);
			Q_free(cur);
		}
	}

	memset(cachepics, 0, sizeof(cachepics));
	Draw_ClearConback();
}

const int COLOR_WHITE = 0xFFFFFFFF;

color_t RGBA_TO_COLOR(byte r, byte g, byte b, byte a) 
{
	return ((r << 0) | (g << 8) | (b << 16) | (a << 24)) & 0xFFFFFFFF;
}

color_t RGBAVECT_TO_COLOR(byte rgba[4])
{
	return ((rgba[0] << 0) | (rgba[1] << 8) | (rgba[2] << 16) | (rgba[3] << 24)) & 0xFFFFFFFF;
}

color_t RGBAVECT_TO_COLOR_PREMULT(byte rgba[4])
{
	byte premult[4];
	float alpha = rgba[3] / 255.0f;

	premult[0] = rgba[0] * alpha;
	premult[1] = rgba[1] * alpha;
	premult[2] = rgba[2] * alpha;
	premult[3] = rgba[3];

	return ((premult[0] << 0) | (premult[1] << 8) | (premult[2] << 16) | (premult[3] << 24)) & 0xFFFFFFFF;
}

color_t RGBAVECT_TO_COLOR_PREMULT_SPECIFIC(byte rgba[4], float alpha)
{
	byte premult[4];

	premult[0] = rgba[0] * alpha;
	premult[1] = rgba[1] * alpha;
	premult[2] = rgba[2] * alpha;
	premult[3] = 255 * alpha;

	return ((premult[0] << 0) | (premult[1] << 8) | (premult[2] << 16) | (premult[3] << 24)) & 0xFFFFFFFF;
}

byte* COLOR_TO_RGBA(color_t i, byte rgba[4]) 
{
	rgba[0] = (i >> 0  & 0xFF);
	rgba[1] = (i >> 8  & 0xFF);
	rgba[2] = (i >> 16 & 0xFF);
	rgba[3] = (i >> 24 & 0xFF);

	return rgba;
}

byte* COLOR_TO_RGBA_PREMULT(color_t i, byte rgba[4])
{
	float alpha;

	rgba[0] = (i >> 0 & 0xFF);
	rgba[1] = (i >> 8 & 0xFF);
	rgba[2] = (i >> 16 & 0xFF);
	rgba[3] = (i >> 24 & 0xFF);

	alpha = rgba[3] / 255.0f;
	rgba[0] *= alpha;
	rgba[1] *= alpha;
	rgba[2] *= alpha;

	return rgba;
}

float* COLOR_TO_FLOATVEC_PREMULT(color_t i, float rgba[4])
{
	float alpha = (i >> 24 & 0xFF) / 255.0f;

	rgba[0] = ((i >> 0 & 0xFF) * alpha) / 255.0f;
	rgba[1] = ((i >> 8 & 0xFF) * alpha) / 255.0f;
	rgba[2] = ((i >> 16 & 0xFF) * alpha) / 255.0f;
	rgba[3] = alpha;

	return rgba;
}

//
// Draw a subpic fitted inside a specified area.
//
void Draw_FitAlphaSubPic (int x, int y, int target_width, int target_height, 
						  mpic_t *gl, int srcx, int srcy, int src_width, int src_height, float alpha)
{
	float scale_x = (target_width / (float)src_width);
	float scale_y = (target_height / (float)src_height);

	Draw_SAlphaSubPic2(x, y, gl, srcx, srcy, src_width, src_height, scale_x, scale_y, alpha);

	return;
}

//
// Draws a subpic tiled inside of a specified target area.
//
void Draw_SubPicTiled(int x, int y, 
					int target_width, int target_height, 
					mpic_t *pic, int src_x, int src_y, 
					int src_width, int src_height,
					float alpha)
{
    int cx					= 0;
	int cy					= 0;
	int scaled_src_width	= src_width; //(src_width * scale);
	int scaled_src_height	= src_height; //(src_height * scale); 
	int draw_width;
	int draw_height;

	while (cy < target_height)
    {
		while (cx < target_width)
        {
			draw_width = min(src_width, (target_width - cx));
			draw_height = min(src_height, (target_height - cy));

			// TODO : Make this work properly in GL so that scale can be used (causes huge rounding issues).
			Draw_AlphaSubPic((x + cx), (y + cy), 
							pic, 
							src_x, src_y, 
							draw_width, draw_height, 
							alpha);

            cx += scaled_src_width;
        }

        cx = 0;
        cy += scaled_src_height;
    }
}

const char* SCR_GetTime (const char *format)
{
	static char buf[128];
	time_t t;
	struct tm *ptm;

	time (&t);
	ptm = localtime (&t);
	if (!ptm) {
		return "-:-";
	}
	if (!strftime(buf, sizeof(buf) - 1, format, ptm)) {
		return "-:-";
	}
	//snprintf(buf, sizeof (buf), "%2d:%02d:%02d", tm->wHour, tm->wMinute, tm->wSecond);
	return buf;
}

char* SCR_GetGameTime(int t)
{
	static char str[9];
	float timelimit;

	timelimit = (t == TIMETYPE_GAMECLOCKINV) ? 60 * Q_atof(Info_ValueForKey(cl.serverinfo, "timelimit")) + 1: 0;

	if (cl.countdown || cl.standby)
		strlcpy (str, SecondsToMinutesString(timelimit), sizeof(str));
	else
		strlcpy (str, SecondsToMinutesString((int)fabs(timelimit - cl.gametime + *gameclockoffset)), sizeof(str));

	return str;
}

char* SCR_GetDemoTime(void)
{
	static char str[9]; // '01:02:03\0'
	strlcpy (str, SecondsToMinutesString((int) (cls.demotime - demostarttime)), sizeof(str));
	return str;
}

char* SCR_GetHostTime(void)
{
	static char str[9]; // '01:02:03\0'
	strlcpy(str, SecondsToMinutesString((int)curtime), sizeof(str));
	return str;
}

char* SCR_GetConnectedTime(void)
{
	static char str[9]; // '01:02:03\0'
	float time = (cl.servertime_works) ? cl.servertime : cls.realtime;
	strlcpy(str, SecondsToHourString((int)time), sizeof(str));
	return str;
}

int SCR_GetClockStringWidth(const char *s, qbool big, float scale, qbool proportional)
{
	int w = 0;
	if (big) {
		while (*s) {
			w += (*s++ == ':') ? (16 * scale) : (24 * scale);
		}
	}
	else {
		w = Draw_StringLength(s, -1, scale, proportional);
	}
	return w;
}

int SCR_GetClockStringHeight(qbool big, float scale)
{
	if (big) {
		return (24 * scale);
	}
	else {
		// FIXME: proportional
		return (LETTERWIDTH * scale);
	}
}

const char* SCR_GetTimeString(int timetype, const char *format)
{
	switch (timetype) {
		case TIMETYPE_GAMECLOCK:
		case TIMETYPE_GAMECLOCKINV:
			return SCR_GetGameTime(timetype);

		case TIMETYPE_DEMOCLOCK:
			return SCR_GetDemoTime();

		case TIMETYPE_HOSTCLOCK:
			return SCR_GetHostTime();

		case TIMETYPE_CONNECTEDCLOCK:
			return SCR_GetConnectedTime();

		case TIMETYPE_CLOCK:
		default:
			return SCR_GetTime(format);
	}
}

//
// Finds the coordinates in the bigfont texture of a given character.
//
void Draw_GetBigfontSourceCoords(char c, int char_width, int char_height, int *sx, int *sy)
{
	if (c >= 'A' && c <= 'Z')
	{
		(*sx) = ((c - 'A') % 8) * char_width;
		(*sy) = ((c - 'A') / 8) * char_height;
	}
	else if (c >= 'a' && c <= 'z')
	{
		// Skip A-Z, hence + 26.
		(*sx) = ((c - 'a' + 26) % 8) * char_width;
		(*sy) = ((c - 'a' + 26) / 8) * char_height;
	}
	else if (c >= '0' && c <= '9')
	{
		// Skip A-Z and a-z.
		(*sx) = ((c - '0' + 26 * 2) % 8 ) * char_width;
		(*sy) = ((c - '0' + 26 * 2) / 8) * char_height;
	}
	else if (c == ':')
	{
		// Skip A-Z, a-z and 0-9.
		(*sx) = ((c - '0' + 26 * 2 + 10) % 8) * char_width;
		(*sy) = ((c - '0' + 26 * 2 + 10) / 8) * char_height;
	}
	else if (c == '/')
	{
		// Skip A-Z, a-z, 0-9 and :
		(*sx) = ((c - '0' + 26 * 2 + 11) % 8) * char_width;
		(*sy) = ((c - '0' + 26 * 2 + 11) / 8) * char_height;
	}
	else
	{
		(*sx) = -1;
		(*sy) = -1;
	}
}

qbool Draw_BigFontAvailable(void)
{
	// mcharset looks ugly in software rendering, therefore don't allow it in there
	return Draw_CachePicSafe(MCHARSET_PATH, false, true) != NULL;
}

void SCR_DrawWadString(int x, int y, float scale, const char *t)
{
    extern  mpic_t	*sb_nums[2][11];
    extern  mpic_t	*sb_colon, *sb_slash;
	qbool			red = false;

	while (*t)
    {
        if (*t >= '0'  &&  *t <= '9')
        {
			Draw_STransPic(x, y, sb_nums[red ? 1 : 0][*t-'0'], scale);
            x += 24*scale;
        }
        else if (*t == ':')
        {
			Draw_STransPic (x, y, sb_colon, scale);
			x += 16*scale;
        }
		else if (*t == '/')
		{
			Draw_STransPic(x, y, sb_slash, scale);
            x += 16*scale;
		}
		else if (*t == '-')
		{
			x -= 12*scale;
			Draw_STransPic (x, y, sb_nums[red ? 1 : 0][10], scale);
			x += 28*scale;
		}
		else if (*t == ' ')
		{
			x += 16*scale;
		}
		else if(*t == 'c')
		{
			red = true;
		}
		else if(*t == 'r')
		{
			red = false;
		}
        t++;
    }
}

// little shortcut for SCR_HUD_DrawBar* functions
void SCR_HUD_DrawBar(int direction, int value, float max_value, byte *color, int x, int y, int width, int height)
{
	int amount;

	if(direction >= 2)
		// top-down
		amount = Q_rint(fabs((height * value) / max_value));
	else// left-right
		amount = Q_rint(fabs((width * value) / max_value));

	if(direction == 0)
		// left->right
		Draw_AlphaFillRGB(x, y, amount, height, RGBAVECT_TO_COLOR(color));
	else if (direction == 1)
		// right->left
		Draw_AlphaFillRGB(x + width - amount, y, amount, height, RGBAVECT_TO_COLOR(color));
	else if (direction == 2)
		// down -> up
		Draw_AlphaFillRGB(x, y + height - amount, width, amount, RGBAVECT_TO_COLOR(color));
	else
		// up -> down
		Draw_AlphaFillRGB(x, y, width, amount, RGBAVECT_TO_COLOR(color));
}



================================================
FILE: src/common_draw.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __COMMON_DRAW__H__
#define __COMMON_DRAW__H__

#define TIMETYPE_CLOCK             0
#define TIMETYPE_GAMECLOCK         1
#define TIMETYPE_GAMECLOCKINV      2
#define TIMETYPE_DEMOCLOCK         3
#define TIMETYPE_HOSTCLOCK         4
#define TIMETYPE_CONNECTEDCLOCK    5

void CommonDraw_Init(void);

typedef struct cachepic_s 
{
	char		name[MAX_QPATH];
	mpic_t		*pic;
} cachepic_t;

typedef struct cachepic_node_s 
{
	cachepic_t data;
	unsigned int refcount;
	struct cachepic_node_s *next;
	struct cachepic_node_s *size_order;
	int width, height;
} cachepic_node_t;

#define	CACHED_PICS_HDSIZE		64

mpic_t *CachePic_Find(const char *path, qbool inc_refcount);
mpic_t* CachePic_Add(const char *path, mpic_t *pic);
qbool CachePic_Remove(const char *path);
qbool CachePic_RemoveByPic(mpic_t* pic);
void CachePics_Shutdown(void);

int SCR_GetClockStringWidth(const char *s, qbool big, float scale, qbool proportional);
int SCR_GetClockStringHeight(qbool big, float scale);
const char* SCR_GetTimeString(int timetype, const char *format);
void SCR_NetStats(int x, int y, float period);

void Draw_FitAlphaSubPic (int x, int y, int target_width, int target_height, 
						  mpic_t *gl, int srcx, int srcy, int src_width, int src_height, float alpha);

void Draw_SubPicTiled(int x, int y, 
					int target_width, int target_height, 
					mpic_t *pic, int src_x, int src_y, 
					int src_width, int src_height,
					float alpha);

void HUD_BeforeDraw(void);
void HUD_AfterDraw(void);

qbool Draw_BigFontAvailable(void);

extern int *gameclockoffset;  // hud_gameclock time offset in seconds

void SCR_DrawWadString(int x, int y, float scale, const char *t);
void SCR_HUD_DrawBar(int direction, int value, float max_value, byte *color, int x, int y, int width, int height);

#endif  // __COMMON_DRAW__H__


================================================
FILE: src/config_manager.c
================================================
/*
Copyright (C) 2001-2002 A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but	WITHOUT ANY WARRANTY; without even the implied warranty	of
MERCHANTABILITY or FITNESS FOR A PARTICULARPURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You	should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: config_manager.c,v 1.49 2007-10-11 05:55:47 dkure Exp $
*/

#include "quakedef.h"
#include "input.h"
#include "utils.h"
#include "keys.h"
#include "fs.h"
#include "config_manager.h"
#include "version.h"
#include "gl_model.h"
#include "vfs.h"

char *Key_KeynumToString (int keynum);

void DumpSkyGroups(FILE *f);
qbool Key_IsLeftRightSameBind(int b);
void DumpMapGroups(FILE *f);
void TP_DumpTriggers(FILE *);
void TP_DumpMsgFilters(FILE *f);
void TP_ResetAllTriggers(void);
qbool Cmd_DeleteAlias (char *);
void DumpFlagCommands(FILE *);
int Cvar_CvarCompare (const void *p1, const void *p2);
int Cmd_AliasCompare (const void *p1, const void *p2);

extern void WriteSourcesConfiguration(FILE *f);
void MarkDefaultSources(void);

extern cvar_group_t *cvar_groups;
extern cmd_alias_t *cmd_alias;
extern cvar_t *cvar_vars;

extern kbutton_t	in_mlook, in_klook,	in_left, in_right, in_forward, in_back;
extern kbutton_t	in_lookup, in_lookdown,	in_moveleft, in_moveright;
extern kbutton_t	in_strafe, in_speed, in_use, in_jump, in_attack, in_up,	in_down;

extern qbool		sb_showscores, sb_showteamscores;

extern cvar_t		cl_teamtopcolor, cl_teambottomcolor, cl_enemytopcolor, cl_enemybottomcolor;
extern char		allskins[MAX_OSPATH];

cvar_t	cfg_save_unchanged	=	{"cfg_save_unchanged", "0"};
cvar_t	cfg_save_userinfo	=	{"cfg_save_userinfo", "2"};
cvar_t	cfg_save_onquit		=	{"cfg_save_onquit", "0"};
cvar_t	cfg_save_cvars		=	{"cfg_save_cvars", "1"};
cvar_t	cfg_save_aliases	=	{"cfg_save_aliases", "1"};
cvar_t	cfg_save_cmds		=	{"cfg_save_cmds", "1"};
cvar_t	cfg_save_binds		=	{"cfg_save_binds", "1"};
cvar_t	cfg_save_sysinfo	=	{"cfg_save_sysinfo", "0"};
cvar_t	cfg_save_cmdline	=	{"cfg_save_cmdline", "1"};
cvar_t	cfg_backup			=	{"cfg_backup", "0"};
cvar_t	cfg_legacy_exec		=	{"cfg_legacy_exec", "1"};
cvar_t  cfg_use_home		=	{"cfg_use_home", "0"};
cvar_t  cfg_use_gamedir		=	{"cfg_use_gamedir", "0"};

/************************************ DUMP FUNCTIONS ************************************/

#define BIND_ALIGN_COL 20
void DumpBindings (FILE *f)
{
	int i, leftright;
	char *spaces, *string;
	qbool printed = false;

	fprintf(f, "unbindall\n");
	for (i = 0; i < (sizeof(keybindings) / sizeof(*keybindings)); i++) {

		leftright = Key_IsLeftRightSameBind(i) ? 1 : 0;
		if (keybindings[i] || leftright) {
			printed = true;
			string = Key_KeynumToString(i);
			spaces = CreateSpaces(BIND_ALIGN_COL - strlen(string) - 6);
			if (i == ';')
				fprintf (f, "bind  \";\"%s\"%s\"\n", spaces, keybindings[i]);
			else
				fprintf (f, "bind  %s%s\"%s\"\n", string, spaces, keybindings[leftright ? i + 1 : i]);

			if (leftright)
				i += 2;
		}
	}
	if (!printed)
		fprintf(f, "//no bindings\n");
}

static qbool Config_Unsaved_Cvar(const char *name)
{
	return (!strcmp(name, "cl_delay_packet"))
        || (!strcmp(name, "cl_proxyaddr"))
        || (!strcmp(name, "hud_planmode"))
        || (!strcmp(name, "con_bindphysical"));
}

#define CONFIG_MAX_COL 60
#define MAX_DUMPED_CVARS 4096
static void DumpVariables(FILE	*f)
{
	cvar_t *var, *sorted_vars[MAX_DUMPED_CVARS];
	cvar_group_t *group;
	char *spaces;
	int count, i, col_size;
	qbool skip_userinfo = false;



	for (col_size = 0,  var = cvar_vars; var; var = var->next) {
		if ( !(
		            (var->flags & (CVAR_USER_CREATED | CVAR_ROM | CVAR_INIT)) ||
		            (var->group && (!strcmp(CVAR_GROUP_NO_GROUP, var->group->name) || !strcmp(CVAR_GROUP_SERVERINFO, var->group->name)) )
		        )) {
			col_size = max(col_size, strlen(var->name));
		}
	}
	col_size = min(col_size + 2, CONFIG_MAX_COL);


	if (cfg_save_unchanged.value) {
		fprintf(f, "//All variables (even those with default values) are listed below.\n");
		fprintf(f, "//You can use \"cfg_save_unchanged 0\" to save only changed variables.\n\n");
	} else {
		fprintf(f, "//Only variables with non-default values are listed below.\n");
		fprintf(f, "//You can use \"cfg_save_unchanged 1\" to save all variables.\n\n");
	}


	for (group = cvar_groups; group; group = group->next)  {

		if (
		    !strcmp(CVAR_GROUP_NO_GROUP, group->name) ||
		    !strcmp(CVAR_GROUP_SERVERINFO, group->name) ||
		    (!cfg_save_userinfo.value && !strcmp(CVAR_GROUP_USERINFO, group->name))
		)
			continue;

		skip_userinfo = ((cfg_save_userinfo.value == 1) && !strcmp(CVAR_GROUP_USERINFO, group->name)) ? true : false;


		for (count = 0, var = group->head; var && count < MAX_DUMPED_CVARS; var = var->next_in_group) {
			if (skip_userinfo && (
			            !strcmp(var->name, "team") || !strcmp(var->name, "skin") ||
			            !strcmp(var->name, "spectator") || !strcmp(var->name, "topcolor") ||
				    !strcmp(var->name, "bottomcolor")
			        ))
				continue;
			
			if (Config_Unsaved_Cvar(var->name)) {
				continue;
			}
			
			if (!(var->flags & (CVAR_USER_CREATED |	CVAR_ROM | CVAR_INIT))) {
				if (cfg_save_unchanged.value || strcmp(var->string, var->defaultvalue)) {
					sorted_vars[count++] = var;
				}
			}
		}
		if (!count)
			continue;


		if (
		    strcmp(group->name, CVAR_GROUP_ITEM_NAMES) &&
		    strcmp(group->name, CVAR_GROUP_ITEM_NEED) &&
		    strcmp(group->name, CVAR_GROUP_USERINFO) &&
		    strcmp(group->name, CVAR_GROUP_SKIN)
		)
			qsort(sorted_vars, count, sizeof (cvar_t *), Cvar_CvarCompare);


		fprintf(f, "//%s\n", group->name);


		for (i = 0; i < count; i++) {
			var = sorted_vars[i];
			if (cfg_save_unchanged.value || strcmp(var->string, var->defaultvalue)) {
				spaces = CreateSpaces(col_size - strlen(var->name));
				fprintf(f, "%s%s\"%s\"\n", var->name, spaces, var->string);
			}
		}

		fprintf(f, "\n");
	}



	for (count = 0, var = cvar_vars; var && count < MAX_DUMPED_CVARS; var = var->next) {
		if (!var->group && !(var->flags & (CVAR_USER_CREATED | CVAR_ROM | CVAR_INIT))) {
			if (cfg_save_unchanged.value || strcmp(var->string, var->defaultvalue)) {
				sorted_vars[count++] = var;
			}
		}
	}
	if (count) {

		qsort(sorted_vars, count, sizeof (cvar_t *), Cvar_CvarCompare);


		fprintf(f, "//Unsorted Variables\n");


		for (i = 0; i < count; i++) {
			var = sorted_vars[i];
			spaces = CreateSpaces(col_size - strlen(var->name));
			fprintf(f, "%s%s\"%s\"\n", var->name, spaces, var->string);
		}

		fprintf(f, "\n");
	}



	for	(col_size = col_size - 2, count = 0, var = cvar_vars; var && count < MAX_DUMPED_CVARS; var = var->next)	{
		if ((var->flags & CVAR_USER_CREATED) && !(var->flags & CVAR_MOD_CREATED)) {
			sorted_vars[count++] = var;
			col_size = max(col_size, strlen(var->name));
		}
	}
	if (!count)
		return;

	col_size = min(col_size + 2, CONFIG_MAX_COL);


	qsort(sorted_vars, count, sizeof (cvar_t *), Cvar_CvarCompare);


	fprintf(f, "//User Created Variables\n");


	for (i = 0; i < count; i++) {
		var = sorted_vars[i];

		spaces = CreateSpaces(col_size - strlen(var->name) - 5);
		fprintf	(f, "%s %s%s\"%s\"\n", (var->teamplay) ? "set_tp" : "set", var->name, spaces, var->string);
	}
}

void DumpVariablesDefaults_f(void)
{
	cvar_t *var;
	cvar_group_t *group;
    char filepath[MAX_PATH];
    FILE *f;
	qbool anyUngrouped = false;

    snprintf(filepath, sizeof(filepath), "%s/ezquake/configs/cvar_defaults.cfg", com_basedir);

    f = fopen(filepath, "w");
    if (!f)
    {
        Com_Printf("Couldn't open %s for writing\n", filepath);
        return;
    }

	for (group = cvar_groups; group; group = group->next) {
	    fprintf(f, "\n//%s\n", group->name);

        for (var = group->head; var; var = var->next_in_group) {
			fprintf(f, "%s \"%s\"\n", var->name, var->defaultvalue);
		}
	}

	// Add those without
	for (var = cvar_vars; var; var = var->next) {
		if (!var->group && !(var->flags & (CVAR_USER_CREATED | CVAR_ROM | CVAR_INIT))) {
			if (!anyUngrouped)
				fprintf(f, "\n//\n");
			fprintf(f, "%s \"%s\"\n", var->name, var->defaultvalue);
			anyUngrouped = true;
		}
	}

    if (fclose(f))
        Com_Printf("Couldn't close %s", filepath);
    else
        Com_Printf("Variables default values dumped to:\n%s\n", filepath);
}

#define MAX_ALIGN_COL 60
static void DumpAliases(FILE *f)
{
	int maxlen, i, j, count, lonely_count, minus_index, minus_count;
	char *spaces;
	cmd_alias_t	*b, *a, *sorted_aliases[2048], *lonely_pluses[512];
	qbool partner, printed;

	fprintf(f, "unaliasall\n");
	for (count = maxlen = 0, a = cmd_alias;	(count < (sizeof(sorted_aliases) / sizeof(*sorted_aliases))) && a; a = a->next) {
		if (!(a->flags & (ALIAS_SERVER|ALIAS_TEMP))) {
			maxlen = max(maxlen, strlen(a->name));
			count++;
		}
	}

	if (!count) {
		fprintf(f, "//no aliases\n");
		return;
	}

	for (i = 0, a = cmd_alias; i < count; a = a->next) {
		if (!(a->flags & (ALIAS_SERVER|ALIAS_TEMP)))
			sorted_aliases[i++] = a;
	}

	qsort(sorted_aliases, count, sizeof (cmd_alias_t *), Cmd_AliasCompare);



	for (minus_index = -1, minus_count = i = 0; i < count; i++) {
		a = sorted_aliases[i];

		if (a->name[0] == '-') {
			if (minus_index == -1)
				minus_index = i;
			minus_count++;
		} else if (a->name[0] != '+')
			break;
	}

	printed = false;

	for (lonely_count = i = 0; i < count; i++) {
		a = sorted_aliases[i];

		if (a->name[0] != '+')
			break;

		for (partner = false, j = minus_index; j >= 0 && j < minus_index + minus_count; j++) {
			b = sorted_aliases[j];

			if (!strcasecmp(b->name + 1, a->name + 1)) {

				spaces = CreateSpaces(maxlen + 3 - strlen(a->name));
				fprintf	(f, "alias %s%s\"%s\"\n", a->name, spaces, a->value);
				spaces = CreateSpaces(maxlen + 3 - strlen(b->name));
				fprintf	(f, "alias %s%s\"%s\"\n", b->name, spaces, b->value);
				printed = partner = true;
				break;
			}
		}

		if (!partner)
			lonely_pluses[lonely_count++] = a;
	}


	for (i = 0; i < lonely_count; i++) {
		a = lonely_pluses[i];

		spaces = CreateSpaces(maxlen + 3 - strlen(a->name));
		fprintf	(f, "alias %s%s\"%s\"\n", a->name, spaces, a->value);
		printed = true;
	}


	for (i = minus_index; i >= 0 && i < minus_index + minus_count; i++) {
		a = sorted_aliases[i];

		for (partner = false, j = 0; j < minus_index; j++) {
			b = sorted_aliases[j];

			if (!strcasecmp(b->name + 1, a->name + 1)) {

				partner = true;
				break;
			}
		}
		if (!partner) {

			spaces = CreateSpaces(maxlen + 3 - strlen(a->name));
			fprintf	(f, "alias %s%s\"%s\"\n", a->name, spaces, a->value);
			printed = true;
		}
	}
	for (i = (minus_index == -1 ? 0 : minus_index + minus_count); i < count; i++) {
		a = sorted_aliases[i];

		if (minus_index != -1 || a->name[0] != '+') {
			if (printed)
				fprintf(f, "\n");
			printed = false;
			spaces = CreateSpaces(maxlen + 3 - strlen(a->name));
			fprintf	(f, "alias %s%s\"%s\"\n", a->name, spaces, a->value);
		}
	}
}

static void DumpPlusCommand(FILE *f, kbutton_t	*b,	const char *name)
{
	if (b->state & 1 && b->down[0] < 0)
		fprintf(f, "+%s\n",	name);
	else
		fprintf(f, "-%s\n",	name);
}

static void DumpPlusCommands(FILE *f)
{
	DumpPlusCommand(f, &in_up, "moveup");
	DumpPlusCommand(f, &in_down, "movedown");
	DumpPlusCommand(f, &in_left, "left");
	DumpPlusCommand(f, &in_right, "right");
	DumpPlusCommand(f, &in_forward,	"forward");
	DumpPlusCommand(f, &in_back, "back");
	DumpPlusCommand(f, &in_lookup, "lookup");
	DumpPlusCommand(f, &in_lookdown, "lookdown");
	DumpPlusCommand(f, &in_strafe, "strafe");
	DumpPlusCommand(f, &in_moveleft, "moveleft");
	DumpPlusCommand(f, &in_moveright, "moveright");
	DumpPlusCommand(f, &in_speed, "speed");
	DumpPlusCommand(f, &in_attack, "attack");
	DumpPlusCommand(f, &in_use,	"use");
	DumpPlusCommand(f, &in_jump, "jump");
	DumpPlusCommand(f, &in_klook, "klook");
	DumpPlusCommand(f, &in_mlook, "mlook");

	fprintf(f, sb_showscores ? "+showscores\n" : "-showscores\n");
	fprintf(f, sb_showteamscores ? "+showteamscores\n" : "-showteamscores\n");
}

static void DumpTeamplay(FILE *f)
{

	if (allskins[0]) {
		fprintf(f, "allskins \"%s\"\n", allskins);
	}

	fprintf(f, "\n");

	DumpFlagCommands(f);

	fprintf(f, "\n");
	TP_DumpMsgFilters(f);

	fprintf(f, "\n");
	TP_DumpTriggers(f);
}

#ifndef CLIENTONLY
void DumpFloodProtSettings(FILE *f)
{
	extern int fp_messages, fp_persecond, fp_secondsdead;
	fprintf(f, "floodprot %d %d %d\n", fp_messages, fp_persecond, fp_secondsdead);
}
#endif

void DumpMisc(FILE *f)
{

	DumpMapGroups(f);
	fprintf(f, "\n");

	DumpSkyGroups(f);
	fprintf(f, "\n");

#ifndef CLIENTONLY
	DumpFloodProtSettings(f);
	fprintf(f, "\n");
#endif

	fprintf(f, "hud_recalculate\n\n");

	if (cl.teamfortress) {
		if (!strcasecmp(Info_ValueForKey (cls.userinfo, "ec"), "on") ||
		        !strcasecmp(Info_ValueForKey (cls.userinfo, "exec_class"), "on")
		   ) {
			fprintf(f, "setinfo ec on\n");
		}
		if (!strcasecmp(Info_ValueForKey (cls.userinfo, "em"), "on") ||
		        !strcasecmp(Info_ValueForKey (cls.userinfo, "exec_map"), "on")
		   ) {
			fprintf(f, "setinfo em on\n");
		}
	}
}

void DumpCmdLine(FILE *f)
{
	fprintf(f, "// %s\n", cl_cmdline.string);
}

void DumpHUD262(FILE *f)
{
	hud_element_t *elem;
	char *type;
	char *param;
	int i, mask;
	extern hud_element_t *hud_list;

	elem = hud_list;

	for(i = 0; elem; elem = elem->next, i++) {
		if (elem->flags & HUD_CVAR) {
			type = "cvar";
			param = ((cvar_t*)elem->contents)->name;
		} else if (elem->flags & HUD_STRING) {
			type = "str";
			param = elem->contents;
		} else {
			continue;
		}

		mask = (elem->flags & HUD_BLINK_F) ? 1 : 0 + (elem->flags & HUD_BLINK_B) ? 2 : 0;
		fprintf(f, "hud262_add %s %s %s\n", elem->name, type, param);
		fprintf(f, "hud262_alpha %s %1.2f\n", elem->name, elem->alpha);
		fprintf(f, "hud262_bg %s %d\n", elem->name, elem->coords[3]);
		fprintf(f, "hud262_blink %s %d %d\n", elem->name, (int) ceil(elem->blink * 1000.0), mask);
		fprintf(f, "hud262_%s %s\n", (elem->flags & HUD_ENABLED) ? "enable" : "disable", elem->name);
		fprintf(f, "hud262_position %s %d %d %d\n", elem->name, elem->coords[0], elem->coords[1], elem->coords[2]);
		fprintf(f, "hud262_width %s %d\n", elem->name, elem->width);
	}
}

/************************************ RESET FUNCTIONS ************************************/

static void ResetVariables(int cvar_flags, qbool resetting_before_load)
{
	cvar_t *var;

	if (resetting_before_load) {
		if (!cfg_save_userinfo.integer) {
			cvar_flags |= CVAR_USERINFO;
		}
		else if (cfg_save_userinfo.integer == 1) {
			cvar_flags |= CVAR_USERINFONORESET;
		}
	}

	for (var = cvar_vars; var; var = var->next) {
		// don't reset based on flags (see cfg_save_userinfo)
		if (var->flags & (cvar_flags | CVAR_ROM | CVAR_INIT | CVAR_USER_CREATED | CVAR_NO_RESET)) {
			continue;
		}

		// don't reset ungrouped cvars (... why?)
		if (var->group && !strcmp(var->group->name, CVAR_GROUP_NO_GROUP)) {
			continue;
		}

		Cvar_ResetVar(var);
	}
}

static void DeleteUserAliases(void)
{
	cmd_alias_t *a, *next;

	for (a = cmd_alias; a; a = next) {
		next = a->next;

		if (!(a->flags & (ALIAS_SERVER|ALIAS_TEMP)))
			Cmd_DeleteAlias(a->name);
	}
}

static void DeleteUserVariables(void)
{
	cvar_t *var, *next;

	for (var = cvar_vars; var; var = next) {
		next = var->next;

		if ((var->flags & CVAR_USER_CREATED) && !(var->flags & CVAR_MOD_CREATED)) {
			Cvar_Delete(var->name);
		}
	}

}

static void ResetPlusCommands(void)
{
	Cbuf_AddText("-moveup;-movedown\n");
	Cbuf_AddText("-left;-right\n");
	Cbuf_AddText("-forward;-back\n");
	Cbuf_AddText("-lookup;-lookdown\n");
	Cbuf_AddText("-strafe\n");
	Cbuf_AddText("-moveleft;-moveright\n");
	Cbuf_AddText("-speed\n");
	Cbuf_AddText("-attack\n");
	Cbuf_AddText("-use\n");
	Cbuf_AddText("-jump\n");
	Cbuf_AddText("-klook\n");
	Cbuf_AddText("-mlook\n");

	Cbuf_AddText("-showscores\n");
	Cbuf_AddText("-showteamscores\n");
}

void ResetBinds(void)
{
	Key_Unbindall_f();

	Key_SetBinding(K_ESCAPE, "togglemenu");
	Key_SetBinding('`',      "toggleconsole");
#ifdef __APPLE__
	Key_SetBinding('~',      "toggleconsole");
#endif
	Key_SetBinding(K_PAUSE,  "toggleproxymenu");

	Key_SetBinding(K_MOUSE1, "+attack");
	Key_SetBinding(K_CTRL,   "+attack");
	Key_SetBinding(K_MOUSE2, "+jump");
	Key_SetBinding(K_SPACE,  "+jump");

	Key_SetBinding('w',      "+forward");
	Key_SetBinding('s',      "+back");
	Key_SetBinding('a',      "+moveleft");
	Key_SetBinding('d',      "+moveright");
	Key_SetBinding('e',      "impulse 10");
	Key_SetBinding('q',      "impulse 12");
	Key_SetBinding('t',      "messagemode");
	Key_SetBinding('y',      "messagemode2");
	Key_SetBinding('1',		 "impulse 1");
	Key_SetBinding('2',		 "impulse 2");
	Key_SetBinding('3',		 "impulse 3");
	Key_SetBinding('4',		 "impulse 4");
	Key_SetBinding('5',		 "impulse 5");
	Key_SetBinding('6',		 "impulse 6");
	Key_SetBinding('7',		 "impulse 7");
	Key_SetBinding('8',		 "impulse 8");
	Key_SetBinding('9',		 "impulse 9");
	Key_SetBinding('0',		 "impulse 10");

	Key_SetBinding(K_ALT,    "+zoom");
	Key_SetBinding(K_TAB,    "+showscores");

	Key_SetBinding('r',      "tp_msgreport");
	Key_SetBinding('z',      "tp_msgtook");
	Key_SetBinding('x',		 "tp_msgsafe");
	Key_SetBinding('c',      "tp_msghelp");
	Key_SetBinding('v',      "tp_msgpoint");

	// user will get confusing warnings on these if he joins a server where these do not exist
	// maybe some wrappers should be made for these commands which would
	// before calling them check if they exist
    Key_SetBinding('f',      "shownick");
	Key_SetBinding(K_F1,     "yes");
	Key_SetBinding(K_F2,     "agree");
	Key_SetBinding(K_F3,     "ready");
	Key_SetBinding(K_F4,     "break");
	Key_SetBinding(K_F5,     "join");
	Key_SetBinding(K_F6,     "observe");
	Key_SetBinding(K_F10,    "quit");
	Key_SetBinding(K_F12,    "screenshot");
}

static void ResetTeamplayCommands(void)
{
	allskins[0]	= 0;
	Cbuf_AddText("enemycolor off\nteamcolor	off\n");
	Cbuf_AddText("filter clear\n");
	TP_ResetAllTriggers();
	Cbuf_AddText("tp_took default\ntp_pickup default\ntp_point default\n");
}

static void ResetMiscCommands(void)
{
	Cbuf_AddText("mapgroup clear\n");
	Cbuf_AddText("skygroup clear\n");

	MarkDefaultSources();

	Info_RemoveKey(cls.userinfo, "ec");
	Info_RemoveKey(cls.userinfo, "exec_class");
	Info_RemoveKey(cls.userinfo, "em");
	Info_RemoveKey(cls.userinfo, "exec_map");
}

/************************************ PRINTING FUNCTIONS ************************************/

#define CONFIG_WIDTH 100

static void Config_PrintBorder(FILE *f)
{
	char buf[CONFIG_WIDTH + 1] = {0};

	if (!buf[0]) {
		memset(buf, '/', CONFIG_WIDTH);
		buf[CONFIG_WIDTH] = 0;
	}
	fprintf(f, "%s\n", buf);
}

static void Config_PrintLine(FILE *f, char *title, int width)
{
	char buf[CONFIG_WIDTH + 1] = {0};
	int title_len, i;

	width = bound(1, width, CONFIG_WIDTH << 3);

	for (i = 0; i < width; i++)
		buf[i] = buf[CONFIG_WIDTH - 1 - i] = '/';
	memset(buf + width,  ' ', CONFIG_WIDTH - 2 * width);
	if (strlen(title) > CONFIG_WIDTH - (2 * width + 4))
		title = "Config_PrintLine : TITLE TOO BIG";
	title_len = strlen(title);
	memcpy(buf + width + ((CONFIG_WIDTH - title_len - 2 * width) >>	1),	title, title_len);
	buf[CONFIG_WIDTH] = 0;
	fprintf(f, "%s\n", buf);
}

static void Config_PrintHeading(FILE *f, char *title)
{
	Config_PrintBorder(f);
	Config_PrintLine(f, "", 2);
	Config_PrintLine(f, title, 2);
	Config_PrintLine(f, "", 2);
	Config_PrintBorder(f);
	fprintf(f, "\n\n");
}

static void Config_PrintPreamble(FILE *f)
{
	extern cvar_t name;
	char	*newlines = "\n";

	Config_PrintBorder(f);
	Config_PrintBorder(f);
	Config_PrintLine(f, "", 3);
	Config_PrintLine(f, "", 3);
	Config_PrintLine(f, "E Z Q U A K E   C O N F I G U R A T I O N", 3);
	Config_PrintLine(f, "", 3);
	Config_PrintLine(f, "", 3);
	Config_PrintBorder(f);
	Config_PrintBorder(f);
	fprintf(f,"\n// %s's config\n\n", name.string);
	fprintf(f,"// ezQuake %s " __DATE__ ", " __TIME__"\n", VersionString());

	if (cfg_save_cmdline.value) {
		DumpCmdLine(f);
		fprintf(f, "%s", newlines);
	}
}

/************************************ MAIN FUCTIONS	************************************/

// Executes default.cfg as long as it isn't the one from pak0.pak or nQuake's default (which is executed from autoexec.cfg ...)
void Cfg_ExecuteDefaultConfig(void)
{
	flocation_t loc;

	if (FS_FLocateFile("default.cfg", FSLFRT_IFFOUND, &loc)) {
		char pak0default[MAX_OSPATH];
		char nquakedefault[MAX_OSPATH];

		strlcpy(pak0default, com_basedir, sizeof(pak0default));
		strlcat(pak0default, "/id1/pak0.pak/default.cfg", sizeof(pak0default));

		strlcpy(nquakedefault, com_basedir, sizeof(nquakedefault));
		strlcat(nquakedefault, "/qw/nquake.pk3", sizeof(nquakedefault));

		if (strcasecmp(pak0default, loc.rawname) && strcasecmp(nquakedefault, loc.rawname)) {
			Cbuf_AddText("exec default.cfg\n");
		}
	}
}

static void ResetConfigs(qbool explicit_reset, qbool read_legacy_configs)
{
	vfsfile_t *v;

	ResetVariables(CVAR_SERVERINFO, !explicit_reset);
	DeleteUserAliases();
	DeleteUserVariables();
	ResetBinds();
	ResetPlusCommands();
	ResetTeamplayCommands();
	ResetMiscCommands();

	if (read_legacy_configs) {
		Cbuf_AddText("cl_warncmd 0\n");
		Cfg_ExecuteDefaultConfig();
		Cbuf_Execute();
		if ((v = FS_OpenVFS("autoexec.cfg", "rb", FS_ANY))) {
			Cbuf_AddText("exec autoexec.cfg\n");
			VFS_CLOSE(v);
		}
		Cbuf_AddText("cl_warncmd 1\n");
	}
}

void Cfg_GetConfigPath(char* path, size_t max_length, const char* name)
{
	const char* default_gamedir = (cfg_use_home.integer ? "" : "ezquake");
	const char* base_directory = (cfg_use_home.integer ? com_homedir : com_basedir);

	strlcpy(path, base_directory, max_length);
	if (path[0]) {
		strlcat(path, "/", max_length);
	}
	strlcat(path, (strcmp(com_gamedirfile, "qw") == 0 || !cfg_use_gamedir.integer) ? default_gamedir : com_gamedirfile, max_length);
	if (path[0]) {
		strlcat(path, "/", max_length);
	}
	if (!cfg_use_home.integer) {
		strlcat(path, "configs/", max_length);
	}
	strlcat(path, name, max_length);
}

void DumpConfig(char *name)
{
	char outfile[MAX_OSPATH];
	FILE* f;
	char* newlines = "\n";

	Cfg_GetConfigPath(outfile, sizeof(outfile) / sizeof(outfile[0]), name);

	if (!(f	= fopen(outfile, "w"))) {
		FS_CreatePath(outfile);
		if (!(f	= fopen	(outfile, "w"))) {
			Com_Printf ("Couldn't write	%s.\n",	name);
			return;
		}
	}

	Com_Printf("Saving configuration to %s\n", outfile);

	Config_PrintPreamble(f);

	if (cfg_save_cvars.value) {
		Config_PrintHeading(f, "V A R I A B L E S");
		DumpVariables(f);
		fprintf(f, "%s", newlines);
	}

	if (cfg_save_cmds.value) {
		Config_PrintHeading(f, "S E L E C T E D   S O U R C E S");
		WriteSourcesConfiguration(f);
		fprintf(f, "%s", newlines);
	}

	if (cfg_save_aliases.value) {
		Config_PrintHeading(f, "A L I A S E S");
		DumpAliases(f);
		fprintf(f, "%s", newlines);
	}

	if (cfg_save_cmds.value) {
		Config_PrintHeading(f, "Q W 2 6 2   H U D");
		DumpHUD262(f);
		fprintf(f, "%s", newlines);

		Config_PrintHeading(f, "T E A M P L A Y   C O M M A N D S");
		DumpTeamplay(f);
		fprintf(f, "%s", newlines);

		Config_PrintHeading(f, "M I S C E L L A N E O U S   C O M M A N D S");
		DumpMisc(f);
		fprintf(f, "%s", newlines);

		Config_PrintHeading(f, "P L U S   C O M M A N D S");
		DumpPlusCommands(f);
		fprintf(f, "%s", newlines);
	}

	if (cfg_save_binds.value) {
		Config_PrintHeading(f, "K E Y   B I N D I N G S");
		DumpBindings(f);
	}

	fclose(f);
}

void DumpHUD(const char *name)
{
	// Dumps all variables from CFG_GROUP_HUD into a file
	extern cvar_t scr_newHud;

	FILE *f;
	int max_width = 0, i = 0, j;
	char *outfile, *spaces;
	cvar_t *var;
	cvar_t *sorted[MAX_DUMPED_CVARS];

	outfile = va("%s/ezquake/configs/%s", com_basedir, name);
	if (!(f	= fopen	(outfile, "w"))) {
		FS_CreatePath(outfile);
		if (!(f	= fopen	(outfile, "w"))) {
			Com_Printf ("Couldn't write	%s.\n",	name);
			return;
		}
	}

	fprintf(f, "//\n");
	fprintf(f, "// Head Up Display Configuration Dump\n");
	fprintf(f, "//\n\n");

	for(var = cvar_vars; var; var = var->next)
		if(var->group && !strcmp(var->group->name, CVAR_GROUP_HUD)) {
			max_width = max(max_width, strlen(var->name));
			sorted[i++] = var;
		}

	max_width++;
	qsort(sorted, i, sizeof(cvar_t *), Cvar_CvarCompare);

	spaces = CreateSpaces(max_width - strlen(scr_newHud.name));
	fprintf(f, "%s%s\"%d\"\n", scr_newHud.name, spaces, scr_newHud.integer);

	for(j = 0; j < i; j++) {
		spaces = CreateSpaces(max_width - strlen(sorted[j]->name));
		fprintf(f, "%s%s\"%s\"\n", sorted[j]->name, spaces, sorted[j]->string);
	}

	fprintf(f, "hud_recalculate\n");

	fclose(f);
}
/************************************ API ************************************/

extern qbool filesystemchanged; // fix bug 2359900

static void SaveConfig(const char *cfgname)
{
	char filename[MAX_PATH] = {0};
	FILE *f;

	if (cfgname[0] && FS_UnsafeFilename(cfgname)) {
		Con_Printf("Invalid/unsafe filename, config not saved.\n");
		return;
	}

	snprintf(filename, sizeof(filename) - 4, "%s", cfgname[0] ? cfgname : MAIN_CONFIG_FILENAME); // use config.cfg if no params was specified
	COM_ForceExtensionEx (filename, ".cfg", sizeof (filename));

	if (cfg_backup.integer) {
		char backupname_ext[MAX_PATH];
		char filename_ext[MAX_OSPATH];

		Cfg_GetConfigPath(filename_ext, sizeof(filename_ext) / sizeof(filename_ext[0]), filename);

		if ((f = fopen(filename_ext, "r"))) {
			fclose(f);
			strlcpy(backupname_ext, filename_ext, sizeof(backupname_ext));
			strlcat(backupname_ext, ".bak", sizeof(backupname_ext));

			if ((f = fopen(backupname_ext, "r"))) {
				fclose(f);
				if (remove(backupname_ext)) {
					Con_Printf("Failed to delete old backup file %s - save cancelled\n", backupname_ext);
					Con_Printf("  If you want to save config without a backup, set %s 0\n", cfg_backup.name);
					return;
				}
			}

			if (rename(filename_ext, backupname_ext)) {
				Con_Printf("Failed to backup config file %s - save cancelled\n", filename_ext);
				Con_Printf("  If you want to save config without a backup, set %s 0\n", cfg_backup.name);
				return;
			}
		}
	}

	DumpConfig(filename);
	filesystemchanged = true; // fix bug 2359900
}

void SaveConfig_f(void)
{
	SaveConfig(Cmd_Argv(1));
}

void Config_QuitSave(void)
{
	if (cfg_save_onquit.integer) {
		SaveConfig("");
	}
}

void ResetConfigs_f(void)
{
	int argc = Cmd_Argc();
	qbool read_legacy_configs = argc == 2 && !strcmp(Cmd_Argv(1), "full");

	if (argc != 1 && !read_legacy_configs) {
		Com_Printf("Usage: %s [full]\n",	Cmd_Argv(0));
		return;
	}
	Com_Printf("Resetting configuration to default state...\n");

	ResetConfigs(true, read_legacy_configs);
}

// well exec /home/qqshka/ezquake/config.cfg does't work, security or something, so adding this
// so this is some replacement for exec
qbool LoadCfg(FILE *f)
{
	char *fileBuffer;
	char reset_bindphysical[128];
    int size;

	if (!f) {
		return false;
	}

	size = FS_FileLength(f);
	fileBuffer = Q_malloc(size + 1); // +1 for null terminator
	if (fread(fileBuffer, 1, size, f) != size) {
		Com_Printf("Error reading config file\n");
		Q_free(fileBuffer);
		return false;
	}
	fileBuffer[size] = 0;

	snprintf(reset_bindphysical, sizeof(reset_bindphysical), "\ncon_bindphysical %d\n", con_bindphysical.integer);
	Cbuf_AddText("con_bindphysical 1\n");
	Cbuf_AddText(fileBuffer);
	Cbuf_AddText(reset_bindphysical);
	Q_free(fileBuffer);
	return true;
}

/*
	example how it works
	
	=== ./ezquake -game testmod -config testcfg
	homedir/testmod/testcfg.cfg (fullname)
	homedir/testcfg.cfg (fullname_moddefault)
	quakedir/testmod/configs/testcfg.cfg
	quakedir/ezquake/configs/testcfg.cfg
	built-in ezquake config
*/
void LoadConfig_f(void)
{
	FILE	*f = NULL;
	char	filename[MAX_PATH] = {0},
			fullname[MAX_PATH] = {0},
			fullname_moddefault[MAX_PATH] = {0},
			*arg1;
	int		use_home;

	arg1 = COM_SkipPathWritable(Cmd_Argv(1));

	snprintf(filename, sizeof(filename) - 4, "%s", arg1[0] ? arg1 : MAIN_CONFIG_FILENAME); // use config.cfg if no params was specified

	COM_ForceExtensionEx (filename, ".cfg", sizeof (filename));
	use_home = cfg_use_home.integer || !host_everything_loaded;

	// home
	snprintf(fullname, sizeof(fullname), "%s/%s%s", com_homedir, (strcmp(com_gamedirfile, "qw") == 0) ? "" : va("%s/", com_gamedirfile), filename);
	snprintf(fullname_moddefault, sizeof(fullname_moddefault), "%s/%s", com_homedir, filename);

	if (use_home) {
		if (cfg_use_gamedir.integer) {
			f = fopen(fullname, "rb");
		}
		if (f == NULL) {
			f = fopen(fullname_moddefault, "rb");
		}
		if (f == NULL) {
			use_home = false;
		}
	}

	// basedir
	snprintf(fullname, sizeof(fullname), "%s/%s/configs/%s", com_basedir, (strcmp(com_gamedirfile, "qw") == 0) ? "ezquake" : com_gamedirfile, filename);
	snprintf(fullname_moddefault, sizeof(fullname_moddefault), "%s/ezquake/configs/%s", com_basedir, filename);

	if(!use_home) {
		if (cfg_use_gamedir.integer) {
			f = fopen(fullname, "rb");
		}
		if (f == NULL) {
			f = fopen(fullname_moddefault, "rb");
		}
	}

	if (f == NULL) {
		Com_Printf("Couldn't load %s %s\n", filename, (cfg_use_gamedir.integer) ? "(using gamedir search)" : "(not using gamedir search)");
		return;
	}

	con_suppress = true;
	ResetConfigs(false, true);
	con_suppress = false;

	if(use_home)
		Com_Printf("Loading %s%s (Using Home Directory) ...\n", (strcmp(com_gamedirfile, "qw") == 0) ? "" : va("%s/",com_gamedirfile), filename);
	else
		Com_Printf("Loading %s/configs/%s ...\n", (strcmp(com_gamedirfile, "qw") == 0) ? "ezquake" : com_gamedirfile, filename);
	
	Cbuf_AddText ("cl_warncmd 0\n");

	LoadCfg(f);
	fclose(f);

	/* johnnycz:
	  This should be called with TP_ExecTrigger("f_cfgload"); but definition
	  of f_cfgload alias is stored in config which is waiting to be executed
	  in command queue so nothing would happen. We have to add f_cfgload as
	  a standard command to the queue. Since warnings are off this is OK but
	  regarding to other f_triggers non-standard.
	*/
	Cbuf_AddText ("f_cfgload\n");

	Cbuf_AddText ("cl_warncmd 1\n");
}

void DumpHUD_f(void)
{
	char *filename;
	char buf[MAX_PATH];

	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: %s <filename>\n", Cmd_Argv(0));
		return;
	}
	filename = COM_SkipPathWritable(Cmd_Argv(1));
	strlcpy(buf, filename, sizeof(buf));
	COM_ForceExtensionEx (buf, ".cfg", sizeof(buf));
	DumpHUD(buf);
	Com_Printf("HUD variables exported to %s\n",buf);
}

void Config_TroubleShoot_Tip(const char* problem, const char* description,
							 const char* solution, int priority)
{
	con_ormask = 128;
	switch (priority) {
	case 0:
		Com_Printf("Minor issue: ");
		break;
	case 1: default:
		Com_Printf("Major issue: ");
		break;
	}
	con_ormask = 0;

	Com_Printf("%s\n", problem);

	con_margin = 2;
	Com_Printf("%s\n\n", description);
	con_margin = 0;

	con_ormask = 128;
	Com_Printf("Solution: ");
	con_ormask = 0;

	con_margin = 2;
	Com_Printf("%s\n\n", solution);
	con_margin = 0;
}

void Config_TroubleShoot_f(void)
{
	unsigned problems = 0;
	extern cvar_t r_novis, r_swapInterval;
	extern cvar_t m_filter, sys_yieldcpu, cl_maxfps, hud_planmode;
	extern cvar_t in_raw;

	if (r_novis.value) {
		Config_TroubleShoot_Tip("r_novis is enabled",
			"r_novis causes a major performance hit, it's only useful if you need transparent liquids "
			"on non-vised maps",
			"set r_novis to 0", 1);
		problems++;
	}

	if (m_filter.value) {
		Config_TroubleShoot_Tip("m_filter is enabled",
			"m_filter causes a serious delay in processing of the mouse input data",
			"set m_filter to 0", 1);
		problems++;
	}

	if (cl_maxfps.integer == 0 && sys_yieldcpu.value == 0 && r_swapInterval.value == 0) {
		Config_TroubleShoot_Tip("cl_maxfps, sys_yieldcpu, and vid_vsync are all 0",
			"unlimited FPS with CPU yielding disabled typically leads to interruptions "
			"in reading input devices (keyboard, mouse)",
			"either set sys_yieldcpu 1, vid_vsync 1, or or limit your FPS with cl_maxfps", 1);
		problems++;
	}

	if (cl_maxfps.integer == 0 && sys_yieldcpu.value == 0) {
		Config_TroubleShoot_Tip("cl_maxfps and sys_yieldcpu are 0",
			"unlimited FPS with CPU yielding disabled typically leads to interruptions "
			"in reading input devices (keyboard, mouse)",
			"either set sys_yieldcpu 1 or or limit your FPS with cl_maxfps", 1);
		problems++;
	}

	if (in_raw.integer != 1) {
		Config_TroubleShoot_Tip("in_raw is not set to 1",
			"It is the recommended setting for mouse input",
			"set in_raw to 1", 0);
		problems++;
	}

	if (hud_planmode.value) {
		Config_TroubleShoot_Tip("hud_planmode is enabled",
			"hud_planmode turns on the display of all possible head up display elements "
			"so that you can fine-tune your head up display settings",
			"set hud_planmode to 0", 1);
	}

	if (!problems) {
		Com_Printf("No problems detected. For more help, please visit the forum in %s\n\n", CharsToBrownStatic("www.QuakeWorld.nu"));
	}
}

void ConfigManager_Init(void)
{
	Cmd_AddCommand("cfg_save", SaveConfig_f);
	Cmd_AddCommand("cfg_load", LoadConfig_f);
	Cmd_AddCommand("cfg_reset",	ResetConfigs_f);
	Cmd_AddCommand("hud_export", DumpHUD_f);
	if (IsDeveloperMode()) {
		Cmd_AddCommand("dev_dump_defaults", DumpVariablesDefaults_f);
	}
	Cmd_AddCommand("troubleshoot", Config_TroubleShoot_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_CONFIG);
	Cvar_Register(&cfg_save_unchanged);
	Cvar_Register(&cfg_save_userinfo);
	Cvar_Register(&cfg_save_onquit);
	Cvar_Register(&cfg_save_cvars);
	Cvar_Register(&cfg_save_aliases);
	Cvar_Register(&cfg_save_cmds);
	Cvar_Register(&cfg_save_binds);
	Cvar_Register(&cfg_save_cmdline);
	Cvar_Register(&cfg_save_sysinfo);
	Cvar_Register(&cfg_backup);
	Cvar_Register(&cfg_legacy_exec);
	Cvar_Register(&cfg_use_home);
	Cvar_Register(&cfg_use_gamedir);
	Cvar_ResetCurrentGroup();
}


================================================
FILE: src/config_manager.h
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef _CONFIG_MANAGER_H_

#define _CONFIG_MANAGER_H_

void ConfigManager_Init (void);
void Config_QuitSave(void);
void ResetBinds(void);
void Cfg_ExecuteDefaultConfig(void);
void Cfg_GetConfigPath(char* path, size_t max_length, const char* name);

extern cvar_t	cfg_save_unchanged, cfg_legacy_exec;

#define MAIN_CONFIG_FILENAME "config.cfg"

#endif


================================================
FILE: src/console.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: console.c,v 1.63 2007-10-04 13:48:11 dkure Exp $
*/
// console.c

#include "quakedef.h"
#include <fcntl.h>
#ifdef _WIN32
#include <io.h>
#else
#include <stdio.h>
#endif
#include "gl_model.h"
#if defined(_WIN32) || defined(__linux__) || defined(__FreeBSD__)
#include "tr_types.h"
#endif // _WIN32 || __linux__ || __FreeBSD__
#include "keys.h"
#include "ignore.h"
#include "logging.h"
#include "utils.h"
#include "localtime.h"
#include "irc.h"
#include "fonts.h"
#include "rulesets.h"
#include "menu.h"

#define     MINIMUM_CONBUFSIZE     (1 << 15)
#define     DEFAULT_CONBUFSIZE     (1 << 16)
#define     MAXIMUM_CONBUFSIZE     (1 << 22)
#define     MAX_NOTIFICATION_TIME  10

console_t	con;
int         con_margin=0;       // kazik: margin on the left side

qbool    con_addtimestamp;

int			con_ormask;
int 		con_linewidth;		// characters across screen
int			con_totallines;		// total lines in console scrollback
float		con_cursorspeed = 4;

cvar_t		con_notify = {"con_notify", "1"};
cvar_t		_con_notifylines = {"con_notifylines","4"};
cvar_t		con_notifytime = {"con_notifytime","3"};		//seconds
cvar_t		con_wordwrap = {"con_wordwrap","1"};
cvar_t		con_clearnotify = {"con_clearnotify","1"};

cvar_t		con_highlight  		= {"con_highlight","0"};
cvar_t		con_highlight_mark 	= {"con_highlight_mark",""};

cvar_t      con_sound_mm1_file      = {"s_mm1_file",      "misc/talk.wav"};
cvar_t      con_sound_mm2_file      = {"s_mm2_file",      "misc/talk.wav"};
cvar_t      con_sound_spec_file     = {"s_spec_file",     "misc/talk.wav"};
cvar_t      con_sound_other_file    = {"s_otherchat_file",    "misc/talk.wav"};
cvar_t      con_sound_mm1_volume    = {"s_mm1_volume",    "1"};
cvar_t      con_sound_mm2_volume    = {"s_mm2_volume",    "1"};
cvar_t      con_sound_spec_volume   = {"s_spec_volume",   "1"};
cvar_t      con_sound_other_volume  = {"s_otherchat_volume",  "1"};

cvar_t      con_timestamps          = {"con_timestamps", "0"};
cvar_t      con_shift               = {"con_shift", "-10"};
cvar_t      cl_textEncoding         = {"cl_textencoding", "0"};
cvar_t      con_mm2_only            = {"con_mm2_only", "0"};
cvar_t      con_proportional        = {"con_proportional", "0"};
cvar_t      con_margin_left         = {"con_margin_left", "0"};

#ifdef _WIN32
cvar_t      con_toggle_deadkey      = {"con_deadkey", "1"};
#endif

#define	NUM_CON_TIMES 16
float		con_times[NUM_CON_TIMES];	// cls.realtime time the line was generated
										// for transparent notify lines

int			con_vislines;
int			con_notifylines;			// scan lines to clear for notify lines

qbool	con_initialized = false;
qbool	con_suppress = false;

FILE		*qconsole_log = NULL;


char *months[12] = {
    "jan",
    "feb",
    "mar",
    "apr",
    "may",
    "jun",
    "jul",
    "aug",
    "sep",
    "oct",
    "nov",
    "dec" };

char *days[7] = {
    "Sun",
    "Mon",
    "Tue",
    "Wed",
    "Thu",
    "Fri",
    "Sat"}; 

void Date_f (void)
{
    // Sun  Nov 05 2000, 16:39
    SYSTEMTIME tm;
    char *day, *month;
    GetLocalTime(&tm);
    month = months[tm.wMonth-1];
    day = days[tm.wDayOfWeek];

    con_ormask = 128;
    Com_Printf ("%s %s %02d, %2d:%02d %d\n", day, month, tm.wDay, tm.wHour, tm.wMinute, tm.wYear);
    con_ormask = 0;
}

static qbool Con_MenuWillDrawConsole(void)
{
	if (m_state == m_none || key_dest != key_menu || m_state == m_proxy) {
		return false;
	}
	return (SCR_NEED_CONSOLE_BACKGROUND);
}

void MakeStringRed(char *s)
{
    while (*s)
    {
        if (*s >= '0'  &&  *s <= '9')
            *s |= 128;
        s++;
    }
}

void MakeStringYellow(char *s)
{
    while (*s)
    {
        if (*s >= '0'  &&  *s <= '9')
            *s -= 30;
        s++;
    }
}

/*
==================
Calendar_f - prints calendar
==================
*/
void Calendar_f(void)
{
    int alldays, day, column;
    SYSTEMTIME tm;
    GetLocalTime(&tm);

    Date_f();
    Com_Printf (" mo tu we th fr sa su\n");

    alldays = 31;
    day = tm.wDay;
    day -= (tm.wDayOfWeek==0 ? 7 : tm.wDayOfWeek) - 1;
    day = (day % 7);
    if (day > 1)
        day -= 7;
    column = 0;

    switch (tm.wMonth)
    {
    case  1:    alldays = 31; break;
	case  2:    alldays = (tm.wYear % 400 ? 28 : (tm.wYear % 100 ? 29 : (tm.wYear % 4) ? 28 : 29)); break;
    case  3:    alldays = 31; break;
    case  4:    alldays = 30; break;
    case  5:    alldays = 31; break;
    case  6:    alldays = 30; break;
    case  7:    alldays = 31; break;
    case  8:    alldays = 31; break;
    case  9:    alldays = 30; break;
    case 10:    alldays = 31; break;
    case 11:    alldays = 30; break;
    case 12:    alldays = 31; break;
    default:    alldays = 31; break;
    }

    while (day <= alldays)
    {
        column ++;

        if (day > 0)
        {
            char buf[8];
            snprintf(buf, sizeof (buf), "%3d", day);
            if (day == tm.wDay)
                ; // MakeStringYellow(buf);
            else
            {
                if (column == 7)
                    MakeStringYellow(buf);
                else
                    MakeStringRed(buf);
            }
            Com_Printf ("%s", buf);
        }
        else
            Com_Printf ("   ");


        if (day == alldays  ||  column == 7)
        {
            column = 0;
            Com_Printf ("\n");
        }

        day++;
    }
}

void Con_ToggleConsole_f (void) {
	Key_ClearTyping ();

	if (key_dest == key_console) {
		if (!SCR_NEED_CONSOLE_BACKGROUND)
			key_dest = key_dest_beforecon;
	} else {
		key_dest_beforecon = key_dest;
		key_dest = key_console;

#ifdef _WIN32
		if (con_toggle_deadkey.integer) {
			Sys_CancelDeadKey ();
		}
#endif
	}

	if (con_clearnotify.value)
		Con_ClearNotify ();
}

void Con_SetColor(int idx_from, int count, int c) {
	int i;

	if (idx_from < 0 || idx_from >= con.maxsize || count < 0 || idx_from + count > con.maxsize)
		Sys_Error("Con_SetColor: wrong idx");;

	for (i = idx_from; i < count; i++) {
		memset(&con.clr[i], 0, sizeof(clrinfo_t)); // zeroing whole struct
		con.clr[i].c = c;
		con.clr[i].i = i;
	}
}

void Con_SetWhite (void) {
// no need for memset(), Con_SetColor() do it too
//	memset (con.clr, 0, con.maxsize * sizeof(clrinfo_t)); // set whole struct array to zero

	Con_SetColor(0, con.maxsize, COLOR_WHITE); // set white color
}

void Con_Clear_f (void) {
	int	i;

	con.numlines = 0;
	for (i = 0; i < con.maxsize; i++)
		con.text[i] = ' ';
	con.display = con.current;
	Con_SetWhite(); // set default color to white
}

void Con_ClearNotify (void) {
	int i;

	for (i = 0; i < NUM_CON_TIMES; i++)
		con_times[i] = 0;
}

void Con_MessageMode_Common (chat_type t) {
	if (cls.state != ca_active)
		return;

	chat_team = t;
	key_dest_beforemm = key_dest; // where to return after we finish typing
	key_dest = key_message;
	chat_buffer[0] = 0;
	chat_linepos = 0;
}

void Con_MessageMode_f (void) {
	Con_MessageMode_Common(chat_mm1);
}

void Con_MessageMode2_f (void) {
	if (cls.mvdplayback == QTV_PLAYBACK)
	{
		// mm2 has no meaning in QTV so let's save some keys and make it QTV->game chat
		Con_MessageMode_Common(chat_qtvtogame);
	}
	else
	{
		Con_MessageMode_Common(chat_mm2);
	}
}

#ifdef WITH_IRC
void Con_MessageModeIRC_f (void) {
	Con_MessageMode_Common(chat_irc);
}
#endif

void Con_MessageModeQTVtoGAME_f (void) {
	Con_MessageMode_Common(chat_qtvtogame);
}

//If the line width has changed, reformat the buffer
void Con_CheckResize (void) {
	int i, j, width, oldwidth, oldtotallines, numlines, numchars;
	wchar *tempbuf;

	width = (vid.width >> 3) - 2;

	if (width == con_linewidth)
		return;

	if (width < 1) { // video hasn't been initialized yet
#if defined(_WIN32) || defined(__linux__) || defined(__FreeBSD__)
		cvar_t *cv = Cvar_Find(r_conwidth.name); // r_conwidth not yet registered, but let user specifie it via
													 // config.cfg or somehow else
		if ( cv ) {
			width = max(320, cv->integer);
			width &= 0xfff8; // make it a multiple of eight
			width = (width >> 3) - 2;
			width = max(width, 38);
		}
		else
#endif
			width = 38;

		con_linewidth = width;
		con_totallines = con.maxsize / con_linewidth;
		for (i = 0; i < con.maxsize; i++)
			con.text[i] = ' ';
		Con_SetWhite();
	} else {
		int idx_old, idx_new;
		clrinfo_t *clr;

		oldwidth = con_linewidth;
		con_linewidth = width;
		oldtotallines = con_totallines;
		con_totallines = con.maxsize / con_linewidth;
		numlines = oldtotallines;

		if (con_totallines < numlines)
			numlines = con_totallines;

		numchars = oldwidth;

		if (con_linewidth < numchars)
			numchars = con_linewidth;

		tempbuf = (wchar *) Hunk_TempAlloc(con.maxsize * sizeof(wchar));
		memcpy (tempbuf, con.text, con.maxsize * sizeof(wchar));
		for (i = 0; i < con.maxsize; i++)
			con.text[i] = ' ';

		clr = Q_malloc(con.maxsize * sizeof(clrinfo_t)); // alloc temporaly
		memcpy(clr, con.clr, con.maxsize * sizeof(clrinfo_t)); // save color array
		Con_SetWhite(); // wipe color array entirely

		for (i = 0; i < numlines; i++) {
			for (j = 0; j < numchars; j++) {
				idx_new = (con_totallines - 1 - i) * con_linewidth + j;
				idx_old = ((con.current - i + oldtotallines) % oldtotallines) * oldwidth + j;
				con.text[idx_new] = tempbuf[idx_old];

				con.clr[idx_new]   = clr[idx_old]; // restore color info
				con.clr[idx_new].i = idx_new; // re-index
			}
		}

		Con_ClearNotify ();
		Q_free(clr); // free
	}

	con.current = con_totallines - 1;
	con.display = con.current;
}


char readableChars[256] = {	'.', '_' , '_' , '_' , '_' , '.' , '_' , '_' , '_' , '_' , '\n' , '_' , '\n' , '>' , '.' , '.',
						'[', ']', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '_', '_', '_'};


static void Con_CreateReadableChars(void) {
	int i;

	for (i = 32; i < 127; i++)
		readableChars[i] = readableChars[128 + i] = i;
	readableChars[127] = readableChars[128 + 127] = '_';

	for (i = 0; i < 32; i++)
		readableChars[128 + i] = readableChars[i];
	readableChars[128] = '_';
	readableChars[10 + 128] = '_';
	readableChars[12 + 128] = '_';
}


static void Con_InitConsoleBuffer(console_t *conbuffer, int size) {
	con.maxsize = size;
	con.text = (wchar *) Hunk_AllocName(con.maxsize * sizeof(wchar), "console_buffer");
	con.clr = (clrinfo_t *) Hunk_AllocName(con.maxsize * sizeof(clrinfo_t), "console_clr");
}

void Con_Init (void) {
	int i, conbufsize;

	//Tei: moved there, because on windows can't capture the output for debug purposes
	if (!qconsole_log && COM_CheckParm(cmdline_param_console_debug)) {
		char tmp_path[MAX_OSPATH] = {0};

		snprintf(&tmp_path[0], sizeof(tmp_path), "%s/qw/qconsole.log", com_basedir);
		qconsole_log = fopen(tmp_path, "a");
	}

	if ((i = COM_CheckParm(cmdline_param_console_buffersize)) && i + 1 < COM_Argc()) {
		conbufsize = Q_atoi(COM_Argv(i + 1)) << 10;
		conbufsize = bound (MINIMUM_CONBUFSIZE , conbufsize, MAXIMUM_CONBUFSIZE);
	} else {
		conbufsize = DEFAULT_CONBUFSIZE;
	}
	Con_InitConsoleBuffer(&con, conbufsize);

	con_linewidth = -1;
	Con_CheckResize ();

	Con_CreateReadableChars();

	con_initialized = true;
	Com_Printf_State (PRINT_OK, "Console initialized\n");

	Cvar_SetCurrentGroup(CVAR_GROUP_CONSOLE);
	// register our commands and cvars
	Cvar_Register (&_con_notifylines);
	Cvar_Register (&con_notifytime);
	Cvar_Register (&con_wordwrap);
	Cvar_Register (&con_clearnotify);
	Cvar_Register (&con_notify);
#ifdef _WIN32
	Cvar_Register (&con_toggle_deadkey);
#endif

	// added by jogi start
	Cvar_Register (&con_highlight);
	Cvar_Register (&con_highlight_mark);
	// added by jogi stop

	Cvar_Register (&con_timestamps); 
	Cvar_Register (&con_shift); 
	Cvar_Register (&con_mm2_only);
	Cvar_Register (&con_proportional);
	Cvar_Register (&con_margin_left);

	Cvar_ResetCurrentGroup();

    Cvar_SetCurrentGroup(CVAR_GROUP_SOUND);

	Cvar_Register (&con_sound_mm1_file); 
	Cvar_Register (&con_sound_mm2_file); 
	Cvar_Register (&con_sound_spec_file); 
	Cvar_Register (&con_sound_other_file); 
	Cvar_Register (&con_sound_mm1_volume); 
	Cvar_Register (&con_sound_mm2_volume); 
	Cvar_Register (&con_sound_spec_volume); 
	Cvar_Register (&con_sound_other_volume); 

    Cvar_ResetCurrentGroup();

	Cvar_Register(&cl_textEncoding);

	Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
	Cmd_AddCommand ("messagemode", Con_MessageMode_f);
	Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
#ifdef WITH_IRC
	Cmd_AddCommand ("messagemodeirc", Con_MessageModeIRC_f);
#endif
	Cmd_AddCommand ("messagemodeqtvtogame", Con_MessageModeQTVtoGAME_f);
	Cmd_AddCommand ("clear", Con_Clear_f);
    Cmd_AddCommand ("date", Date_f);
	Cmd_AddCommand ("calendar", Calendar_f);
  
}

void Con_Shutdown (void) {
	if (qconsole_log)
		fclose(qconsole_log);
}

void Con_Linefeed (void) {
	int idx, i;
	con.x = 0;
	con.x = con_margin;    // kazik
	if (con.display == con.current)
		con.display++;
	con.current++;
	if (con.numlines < con_totallines)
		con.numlines++;
	idx = (con.current%con_totallines)*con_linewidth;
	for (i = 0; i < con_linewidth; i++)
		con.text[idx + i] = ' ';
	Con_SetColor(idx, con_linewidth, COLOR_WHITE);

	// mark time for transparent overlay
	if (con.current >= 0) {
		con_times[con.current % NUM_CON_TIMES] = (Print_flags[Print_current] & PR_NONOTIFY ? 0 : cls.realtime);
	}
}

/*
==================
Con_SafePrintf

Okay to call even when the screen can't be updated

==================
*/
void Con_SafePrintf (char *fmt, ...)
{
    va_list     argptr;
    char        msg[1024];
    int         temp;

    va_start (argptr,fmt);
    vsnprintf (msg,sizeof(msg),fmt,argptr);
    va_end (argptr);

    temp = scr_disabled_for_loading;
    scr_disabled_for_loading = true;
    Com_Printf ("%s", msg);
    scr_disabled_for_loading = temp;
}

//Handles cursor positioning, line wrapping, etc
void Con_PrintW(wchar *txt)
{
	int y, c, l, d, mask, color = COLOR_WHITE, r, g, b, idx;
	wchar *s;
	static int cr;

	if (!(Print_flags[Print_current] & PR_LOG_SKIP)) {
		if (Ruleset_CanLogConsole() && qconsole_log) {
			char *tempbuf = Q_wcs2str_malloc(txt);
			fprintf(qconsole_log, "%s", tempbuf);
			fflush(qconsole_log);
			Q_free(tempbuf);
		}
		if (Log_IsLogging()) {
			if (log_readable.integer) {
				char *s, *tempbuf = Q_wcs2str_malloc(txt);
				for (s = tempbuf; *s; s++)
					*s = readableChars[(unsigned char)*s];
				Log_Write(tempbuf);
				Q_free(tempbuf);
			}
			else {
				Log_Write(wcs2str(txt));
			}
		}
	}

	if ((Print_flags[Print_current] & PR_SKIP))
		goto zomfg;

	if (!con_initialized || con_suppress)
		goto zomfg;

	if (txt[0] == 1 || txt[0] == 2) {
		mask = 128;		// go to colored text
		txt++;
	}
	else {
		mask = 0;
	}

	while ((c = *txt)) {
		// get color modificator if any
		if (*txt == '&') {
			if (txt[1] == 'c' && txt[2] && txt[3] && txt[4]) {
				r = HexToInt(txt[2]);
				g = HexToInt(txt[3]);
				b = HexToInt(txt[4]);
				if (r >= 0 && g >= 0 && b >= 0) {
					color = RGBA_TO_COLOR(255 * r / 16, 255 * g / 16, 255 * b / 16, 255);
					txt += 5;
					continue; // we got color, get now normal char
				}
			}
			else if (txt[1] == 'r') {
				color = COLOR_WHITE;
				txt += 2;
				continue; // we got color, get now normal char
			}
		}

		// count word length
		for (s = txt, l = 0; s[0] && l < con_linewidth;) {
			// skip color, not count in word length
			if (*s == '&') {
				if (s[1] == 'c' && s[2] && s[3] && s[4]) {
					r = HexToInt(s[2]);
					g = HexToInt(s[3]);
					b = HexToInt(s[4]);
					if (r >= 0 && g >= 0 && b >= 0) {
						s += 5;
						continue; // we got color, get now normal char
					}
				}
				else if (s[1] == 'r') {
					s += 2;
					continue; // we got color, get now normal char
				}
			}

			d = (s[0] & ~128);
			if ((con_wordwrap.value && (!d || d == 0x09 || d == 0x0D || d == 0x0A || d == 0x20))
				|| (!con_wordwrap.value && d <= 32) // 32 is a space as well as 0x20
				)
				break;

			l++; // increase word length
			s++; // get next char
		}

		// word wrap
		if (l != con_linewidth && con.x + l > con_linewidth)
			con.x = 0;

		txt++;

		if (cr) {
			con.current--;
			cr = false;
		}

		if (!con.x)
			Con_Linefeed();

		switch (c) {
			case '\n':
				con.x = 0;
				break;

			case '\r':
				con.x = 0;
				cr = 1;
				break;

			default:	// display character and advance
				if (con.x >= con_linewidth) {
					Con_Linefeed();
				}
				y = con.current % con_totallines;
				idx = y * con_linewidth + con.x + con_margin_left.integer;
				con.text[idx] = c | (c > 0 && c <= 0x7F ? (mask | con_ormask) : 0);	// only apply mask if in 'standard' charset
				memset(&con.clr[idx], 0, sizeof(clrinfo_t)); // zeroing whole struct
				con.clr[idx].c = color;
				con.clr[idx].i = idx; // no, that not stupid :P
				con.x++;
				break;
		}
	}
zomfg:
	if (!(Print_flags[Print_current] & PR_NORESET)) {
		Print_flags[Print_current] = 0;
	}
}

/*
==============================================================================
DRAWING
==============================================================================
*/

//The input line scrolls horizontally if typing goes beyond the right edge
static void Con_DrawInput(void) {
	int		len, i;
	wchar	*text;
	wchar	temp[MAXCMDLINE + 1];       //+ 1 for cursor if stlen(key_lines[edit_line]) == 255

	if (key_dest != key_console && cls.state == ca_active) {
		return;
	}

	qwcslcpy (temp, key_lines[edit_line], MAXCMDLINE);
	len = qwcslen(temp);

	text = temp;

	// fill out remainder with spaces
	for (i = 0; i < MAXCMDLINE - len; i++) {
		(text + len)[i] = ' ';
	}
	
	text[MAXCMDLINE] = 0;

	// add the cursor frame
	if ((int)(curtime*con_cursorspeed) & 1) {
		text[key_linepos] = con_redchars ? (11 + 128) : 11;
	}

	//	prestep if horizontally scrolling
	if (key_linepos >= con_linewidth) {
		text += 1 + key_linepos - con_linewidth;
	}

	Draw_ConsoleString(8, con_vislines - 22 + bound(0, con_shift.value, 8), text, NULL, 0, 0, 1, con_proportional.integer);
}

// Returns first line to start printing from in order to fill up notify area
static int Con_FirstNotifyLine (int notification_lines, float notification_timelimit)
{
	int maxlines = bound(0, notification_lines, NUM_CON_TIMES - 1);
	int first_line = con.current;
	float threshold_time = cls.realtime - notification_timelimit;

	// Work backwards to skip non-ignored lines
	while (first_line >= 0 && first_line > (con.current - NUM_CON_TIMES + 1) && maxlines) {
		float line_time = con_times[first_line % NUM_CON_TIMES];
		if (line_time && line_time > threshold_time) {
			--maxlines;
		}
		if (maxlines)
			--first_line;
	}

	return first_line;
}

static qbool Con_NotifyMessageLine(float posX, float posY, float width, float height, float scale, qbool proportional)
{
	int x;

	if (key_dest == key_message) {
		wchar temp[MAXCMDLINE + 1];
		wchar* s;
		qbool display_cursor;

		clearnotify = 0;
		scr_copytop = 1;

		if (chat_team == chat_mm2) {
			posX += Draw_SString(posX, posY + bound(0, con_shift.value, 8), "say_team:", scale, proportional);
		}
		else if (chat_team == chat_mm1) {
			posX += Draw_SString(posX, posY + bound(0, con_shift.value, 8), "say:", scale, proportional);
		}
#ifdef WITH_IRC
		else if (chat_team == chat_irc) {
			char dest[256];

			strlcpy(dest, IRC_GetCurrentChan(), sizeof(dest));
			strlcat(dest, ":", sizeof(dest));

		}
#endif
		else if (chat_team == chat_qtvtogame) {
			posX += Draw_SString(posX, posY + bound(0, con_shift.value, 8), "say_game:", scale, proportional);
		}

		// FIXME: clean this up
		qwcslcpy(temp, chat_buffer, sizeof(temp) / sizeof(wchar));
		s = temp;

		// add the cursor frame
		display_cursor = (int)(curtime * con_cursorspeed) & 1;
		if (display_cursor && chat_linepos == (int)qwcslen(s)) {
			s[chat_linepos + 1] = '\0';
		}

		// prestep if horizontally scrolling
		if (!proportional) {
			if (chat_linepos * 8 * scale + posX >= width) {
				s += (int)((1 + chat_linepos)) + (int)((posX - width) / (8 * scale));
			}
		}
		else {
			// measure full string, cut off characters until string fits
			float length = Draw_StringLengthW(s, chat_linepos, scale, proportional);

			while (*s && length >= 0 && length >= width - posX) {
				length -= FontCharacterWidthWide(*s, scale, proportional);
				++s;
			}
		}

		x = 0;
		while (s[x] && posX < width) {
			float char_width = Draw_CharacterWSP(posX, posY + bound(0, con_shift.value, 8), s[x], scale, proportional);

			if (display_cursor && x == chat_linepos) {
				Draw_SCharacterP(posX, posY + bound(0, con_shift.value, 8), 11, scale, proportional);
				display_cursor = false;
			}
			posX += char_width;
			x++;
		}
		if (display_cursor) {
			Draw_SCharacterP(posX, posY + bound(0, con_shift.value, 8), 11, scale, proportional);
		}
		posY += 8 * scale;
		return true;
	}

	return false;
}

//Draws the last few lines of output transparently over the game top
void Con_DrawNotify(void)
{
	if (con_notify.integer) {
		SCR_DrawNotify(8, bound(0, con_shift.value, 8), 1.0f, con_notifytime.value, _con_notifylines.integer, con_linewidth, con_proportional.integer);
	}
}

// Draws the last few lines of output as a custom HUD element.
void SCR_DrawNotify(int posX, int posY, float scale, int notifyTime, int notifyLines, int notifyCols, qbool proportional)
{
	int v, i, idx;
	float time;
	float timeout = bound (0, notifyTime, MAX_NOTIFICATION_TIME);

	notifyCols = bound(10, notifyCols, con_linewidth);

	v = 0;
	if (notifyLines) {
		int first_line = Con_FirstNotifyLine(notifyLines, timeout);

		for (i = first_line; i <= con.current; i++) {
			if (i < 0) {
				continue;
			}
			time = con_times[i % NUM_CON_TIMES];
			if (time == 0) {
				continue;
			}
			time = cls.realtime - time;
			if (time > timeout) {
				continue;
			}
			idx = (i % con_totallines) * con_linewidth;

			clearnotify = 0;
			scr_copytop = 1;

			int printed = 0;
			int last = idx + con_linewidth - 1;
			while (last > idx && (con.text + last)[0] == 32) {
				--last;
			}

			while (last > idx) {
				printed = Draw_ConsoleString(posX, v + posY, con.text + idx, con.clr + idx, min(notifyCols, last - idx + 1), 0, scale, proportional);
				idx += printed;
				v += (8 * scale);
				if (printed == 0 || con.text[idx] == 0 || con.text[idx] == 0x80) {
					break;
				}
			}
		}
	}

	if (Con_NotifyMessageLine(posX, v + posY, notifyCols * 8 * scale, v * 8 * scale, scale, proportional)) {
		v += 8 * scale;
	}

	if (v > con_notifylines) {
		con_notifylines = v + bound(0, con_shift.value, 8);
	}
}

//Draws the console with the solid background
void Con_DrawConsole (int lines) {
	int i, j, x, y, n=0, rows, row, idx, probing_progress;
	char *text, dlbar[1024];
	qbool is_probing;

	if (lines <= 0 || Con_MenuWillDrawConsole())
		return;

	// draw the background
	Draw_ConsoleBackground (lines);

	// draw the text
	con_vislines = lines;

	// changed to line things up better
	rows = (lines - 22) >> 3;		// rows of text to draw

	y = lines - 30;

	row = con.display;

	// draw from the bottom up
	if (con.display != con.current) {
	// draw arrows to show the buffer is backscrolled
		for (x = 0; x < con_linewidth; x += 4)
			Draw_Character ((x + 1) << 3, y + bound(0, con_shift.value, 8), '^');

		y -= 8;
		rows--;
		row--;
	}

	for (i = 0; i < rows; i++, y -= 8, row--) {
		if (row < 0)
			break;
		if (con.current - row >= con_totallines)
			break;		// past scrollback wrap point

		idx = (row % con_totallines)*con_linewidth;

		// copy current line to buffer
		Draw_ConsoleString( 1 << 3, y + bound(0, con_shift.value, 8), con.text + idx, con.clr + idx, con_linewidth, 0, 1, con_proportional.integer);
	}

	is_probing = IsPortPingProbeEnabled() && NET_GetPortPingProbeStatus() == PORTPINGPROBE_PROBING;
	probing_progress = IsPortPingProbeEnabled() && is_probing ? NET_GetPortPingProbeProgress() : 0;

	// draw the download bar
	// figure out width
	if (cls.download || cls.upload || is_probing) {
		int	slider_box_position = -1;

		if (cls.download) {
			if ((text = strrchr(cls.downloadname, '/')) != NULL)
				text++;
			else
				text = cls.downloadname;
		} else if (cls.upload) {
			if ((text = strrchr(cls.uploadname, '/')) != NULL)
				text++;
			else
				text = cls.uploadname;
		} else if (is_probing) {
			text = "probing";
		} else
			return;

		x = con_linewidth - ((con_linewidth * 7) / 40);
		y = x - strlen(text) - 8;
		i = con_linewidth/3;
		if (strlen(text) > i) {
			y = x - i - 11;
			strlcpy (dlbar, text, i);
			strlcat (dlbar, "...", sizeof (dlbar));
		} else {
			strlcpy (dlbar, text, sizeof (dlbar));
		}
		strlcat (dlbar, ": ", sizeof (dlbar));
		i = strlen (dlbar);
		dlbar[i++] = '\x80';
		// where's the dot go?
		if (cls.download) {
			if (cls.downloadpercent == 0)
				n = 0;
			else
				n = y * cls.downloadpercent / 100;
		} else if (cls.upload) {
			if (cls.uploadpercent == 0)
				n = 0;
			else
				n = y * cls.uploadpercent / 100;
		} else if (is_probing) {
			n = y * probing_progress / 100;
		}

		for (j = 0; j < y; j++)
		{
			if (j == n)
				slider_box_position = i;

			dlbar[i++] = '\x81';
		}
		if (slider_box_position >= 0)
			dlbar[slider_box_position] = '\x83';
		dlbar[i++] = '\x82';
		dlbar[i] = 0;

		i = strlen (dlbar);
		if (cls.download)
			snprintf (dlbar + i, sizeof (dlbar) - i, " %02d%%(%dkb/s)", cls.downloadpercent, cls.downloadrate);
		else if (cls.upload)
			snprintf (dlbar + i, sizeof (dlbar) - i, " %02d%%(%dkb/s)", cls.uploadpercent, cls.uploadrate);
		else if (is_probing)
			snprintf (dlbar + i, sizeof (dlbar) - i, " %02d%%", probing_progress);
		else
			return;

		// draw it
		y = con_vislines - 22 + 8;
		Draw_String (8, y + bound(0, con_shift.value, 8), dlbar);
	}

	// draw the input prompt, user text, and cursor if desired
	Con_DrawInput ();
}



================================================
FILE: src/console.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

//
// console
//

#ifndef	_CONSOLE_H_

#define _CONSOLE_H_

typedef struct
{
	wchar	*text;
	int		maxsize;
	int		current;		// line where next message will be printed
	int		x;				// offset in current line for next print
	int		display;		// bottom of console displays this line
	int		numlines;		// number of non-blank text lines, used for backscroling
	clrinfo_t *clr; // clr[maxsize]
} console_t;

extern	console_t	con;

// colored frag messages offsets, used to add team/enemy colors to frag messages
typedef struct cfrags_format_s {
	int p1pos;	// position
	int p1len;	// length, if zero - no coloring
	int p1col;	// color
	int p2pos;
	int p2len;
	int p2col;
	qbool isFragMsg; // true if that was frag msg
} cfrags_format;

extern  qbool    con_addtimestamp;

extern	int			con_ormask;

extern int con_totallines;
extern int con_linewidth;
extern qbool con_initialized, con_suppress;
extern	int	con_notifylines;		// scan lines to clear for notify lines

void Con_CheckResize (void);
void Con_Init (void);
void Con_Shutdown (void);
void Con_DrawConsole (int lines);
void Con_SafePrintf (char *fmt, ...);
void Con_PrintW (wchar *txt);
void Con_Clear_f (void);
void Con_DrawNotify (void);

void SCR_DrawNotify(int x, int y, float scale, int notifyTime, int notifyLines, int notifyCols, qbool proportional);

void Con_ClearNotify (void);
void Con_ToggleConsole_f (void);

extern cvar_t con_timestamps;

extern cvar_t con_shift;

extern cvar_t con_sound_mm1_file;
extern cvar_t con_sound_mm1_volume;
extern cvar_t con_sound_mm2_file;
extern cvar_t con_sound_mm2_volume;
extern cvar_t con_sound_spec_file;
extern cvar_t con_sound_spec_volume;
extern cvar_t con_sound_other_file;
extern cvar_t con_sound_other_volume;
extern cvar_t con_mm2_only;
extern  int         con_margin;         // kazik: margin on the left side

#endif		//_CONSOLE_H_


================================================
FILE: src/crc.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
/* crc.c */

#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "common.h"
#endif
#include "crc.h"

// this is a 16 bit, non-reflected CRC using the polynomial 0x1021
// and the initial and final xor values shown below...  in other words, the
// CCITT standard CRC used by XMODEM

#define CRC_INIT_VALUE	0xffff
#define CRC_XOR_VALUE	0x0000

static unsigned short crctable[256] =
{
	0x0000,	0x1021,	0x2042,	0x3063,	0x4084,	0x50a5,	0x60c6,	0x70e7,
	0x8108,	0x9129,	0xa14a,	0xb16b,	0xc18c,	0xd1ad,	0xe1ce,	0xf1ef,
	0x1231,	0x0210,	0x3273,	0x2252,	0x52b5,	0x4294,	0x72f7,	0x62d6,
	0x9339,	0x8318,	0xb37b,	0xa35a,	0xd3bd,	0xc39c,	0xf3ff,	0xe3de,
	0x2462,	0x3443,	0x0420,	0x1401,	0x64e6,	0x74c7,	0x44a4,	0x5485,
	0xa56a,	0xb54b,	0x8528,	0x9509,	0xe5ee,	0xf5cf,	0xc5ac,	0xd58d,
	0x3653,	0x2672,	0x1611,	0x0630,	0x76d7,	0x66f6,	0x5695,	0x46b4,
	0xb75b,	0xa77a,	0x9719,	0x8738,	0xf7df,	0xe7fe,	0xd79d,	0xc7bc,
	0x48c4,	0x58e5,	0x6886,	0x78a7,	0x0840,	0x1861,	0x2802,	0x3823,
	0xc9cc,	0xd9ed,	0xe98e,	0xf9af,	0x8948,	0x9969,	0xa90a,	0xb92b,
	0x5af5,	0x4ad4,	0x7ab7,	0x6a96,	0x1a71,	0x0a50,	0x3a33,	0x2a12,
	0xdbfd,	0xcbdc,	0xfbbf,	0xeb9e,	0x9b79,	0x8b58,	0xbb3b,	0xab1a,
	0x6ca6,	0x7c87,	0x4ce4,	0x5cc5,	0x2c22,	0x3c03,	0x0c60,	0x1c41,
	0xedae,	0xfd8f,	0xcdec,	0xddcd,	0xad2a,	0xbd0b,	0x8d68,	0x9d49,
	0x7e97,	0x6eb6,	0x5ed5,	0x4ef4,	0x3e13,	0x2e32,	0x1e51,	0x0e70,
	0xff9f,	0xefbe,	0xdfdd,	0xcffc,	0xbf1b,	0xaf3a,	0x9f59,	0x8f78,
	0x9188,	0x81a9,	0xb1ca,	0xa1eb,	0xd10c,	0xc12d,	0xf14e,	0xe16f,
	0x1080,	0x00a1,	0x30c2,	0x20e3,	0x5004,	0x4025,	0x7046,	0x6067,
	0x83b9,	0x9398,	0xa3fb,	0xb3da,	0xc33d,	0xd31c,	0xe37f,	0xf35e,
	0x02b1,	0x1290,	0x22f3,	0x32d2,	0x4235,	0x5214,	0x6277,	0x7256,
	0xb5ea,	0xa5cb,	0x95a8,	0x8589,	0xf56e,	0xe54f,	0xd52c,	0xc50d,
	0x34e2,	0x24c3,	0x14a0,	0x0481,	0x7466,	0x6447,	0x5424,	0x4405,
	0xa7db,	0xb7fa,	0x8799,	0x97b8,	0xe75f,	0xf77e,	0xc71d,	0xd73c,
	0x26d3,	0x36f2,	0x0691,	0x16b0,	0x6657,	0x7676,	0x4615,	0x5634,
	0xd94c,	0xc96d,	0xf90e,	0xe92f,	0x99c8,	0x89e9,	0xb98a,	0xa9ab,
	0x5844,	0x4865,	0x7806,	0x6827,	0x18c0,	0x08e1,	0x3882,	0x28a3,
	0xcb7d,	0xdb5c,	0xeb3f,	0xfb1e,	0x8bf9,	0x9bd8,	0xabbb,	0xbb9a,
	0x4a75,	0x5a54,	0x6a37,	0x7a16,	0x0af1,	0x1ad0,	0x2ab3,	0x3a92,
	0xfd2e,	0xed0f,	0xdd6c,	0xcd4d,	0xbdaa,	0xad8b,	0x9de8,	0x8dc9,
	0x7c26,	0x6c07,	0x5c64,	0x4c45,	0x3ca2,	0x2c83,	0x1ce0,	0x0cc1,
	0xef1f,	0xff3e,	0xcf5d,	0xdf7c,	0xaf9b,	0xbfba,	0x8fd9,	0x9ff8,
	0x6e17,	0x7e36,	0x4e55,	0x5e74,	0x2e93,	0x3eb2,	0x0ed1,	0x1ef0
};

void CRC_Init(unsigned short *crcvalue)
{
	*crcvalue = CRC_INIT_VALUE;
}

void CRC_ProcessByte(unsigned short *crcvalue, byte data)
{
	*crcvalue = (*crcvalue << 8) ^ crctable[(*crcvalue >> 8) ^ data];
}

unsigned short CRC_Value(unsigned short crcvalue)
{
	return crcvalue ^ CRC_XOR_VALUE;
}

unsigned short CRC_Block (byte *start, unsigned int count)
{
	unsigned short	crc;

	CRC_Init (&crc);
	while (count--)
		crc = (crc << 8) ^ crctable[(crc >> 8) ^ *start++];

	return crc;
}

void CRC_AddBlock (unsigned short *crcvalue, byte *start, int count)
{
    while (count--)
		CRC_ProcessByte(crcvalue, *start++);
}


================================================
FILE: src/crc.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
/* crc.h */

#ifndef __CRC_H__
#define __CRC_H__

void CRC_Init(unsigned short *crcvalue);
void CRC_ProcessByte(unsigned short *crcvalue, byte data);
unsigned short CRC_Value(unsigned short crcvalue);
unsigned short CRC_Block (byte *start, unsigned int count);
void CRC_AddBlock (unsigned short *crcvalue, byte *start, int count);

#endif /* !__CRC_H__ */


================================================
FILE: src/cvar.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


*/
// cvar.c -- dynamic variable tracking

#ifdef SERVERONLY
#include "qwsvdef.h"

#define VAR_HASHPOOL_SIZE 32
#else
#include "common.h"
#include "teamplay.h"
#include "rulesets.h"
#include "keys.h"
#include "utils.h"
#include "parser.h"
#include "r_renderer.h"

static void Cvar_ApplyLatchedUpdate(cvar_t* var);

void CL_UserinfoChanged(char *key, char *value);
void SV_ServerinfoChanged(char *key, char *value);
void Help_DescribeCvar(cvar_t *v);
void VID_ReloadCvarChanged(cvar_t* var);

extern cvar_t r_fullbrightSkins;
extern cvar_t cl_fakeshaft;
extern cvar_t allow_scripts;

static cvar_t cvar_viewdefault = {"cvar_viewdefault", "1"};
static cvar_t cvar_viewhelp    = {"cvar_viewhelp",    "1"};
static cvar_t cvar_viewlatched = {"cvar_viewlatched", "1"};

#define VAR_HASHPOOL_SIZE 1024

static void Cvar_AddCvarToGroup(cvar_t *var);
#endif

static cvar_t *cvar_hash[VAR_HASHPOOL_SIZE];
cvar_t *cvar_vars;
static char	*cvar_null_string = "";

// Use this to walk through all vars
cvar_t* Cvar_Next(cvar_t *var)
{
	if (var) {
		return var->next;
	}
	else {
		return cvar_vars;
	}
}

cvar_t *Cvar_Find(const char *var_name)
{
	cvar_t *var;
	int key = Com_HashKey (var_name) % VAR_HASHPOOL_SIZE;

	for (var = cvar_hash[key]; var; var = var->hash_next) {
		if (!strcasecmp(var_name, var->name)) {
			return var;
		}
	}

	return NULL;
}

float Cvar_Value (const char *var_name)
{
	cvar_t *var = Cvar_Find (var_name);

	if (!var) {
		return 0;
	}
	return Q_atof (var->string);
}

char *Cvar_String (const char *var_name)
{
	cvar_t *var = Cvar_Find (var_name);

	if (!var)
		return cvar_null_string;
	return var->string;
}

void SV_SendServerInfoChange(char *key, char *value);

char* Cvar_ServerInfoValue(char* key, char* value)
{
	// force serverinfo "0" vars to be "".
	// meag: deathmatch is a special case as clients default 'not in serverinfo' to non-coop
	if (!strcmp(value, "0") && strcmp(key, "deathmatch")) {
		return "";
	}
	return value;
}

void Cvar_SetEx(cvar_t *var, char *value, qbool ignore_callback)
{
	static qbool changing = false;
	char *new_val;
#ifndef SERVERONLY
	extern cvar_t cl_warncmd;
	extern cvar_t re_subi[10];
	float test;
	qbool same_value;
#endif

	if (!var)
		return;

	// force serverinfo "0" vars to be "".
	if (var->flags & CVAR_SERVERINFO) {
		value = Cvar_ServerInfoValue(var->name, value);
	}

#ifndef SERVERONLY
	// C code may wrongly use Cvar_Set on non registered variable, some 99.99% accurate check
	// variables for internal triggers are not registered intentionally
	if (var < re_subi || var > re_subi + 9) {
		if (!var->next /* this is fast, but a bit flawed logic */ && !Cvar_Find(var->name)) {
			Com_Printf("Cvar_Set: on non linked var %s\n", var->name);
			return;
		}
	}
#endif

	if (var->flags & CVAR_ROM) {
#ifndef SERVERONLY
		Com_Printf ("\"%s\" is write protected\n", var->name);
#endif
		return;
	}

#ifndef SERVERONLY
	if (var->flags & CVAR_RULESET_MIN) {
		test  = Q_atof (value);
		if (test < var->minrulesetvalue) {
			Com_Printf ("min \"%s\" is limited to %0.2f\n", var->name,var->minrulesetvalue);
			return;
		}
	}

	if (var->flags & CVAR_RULESET_MAX) {
		test  = Q_atof (value);
		if (test > var->maxrulesetvalue) {
			Com_Printf ("max \"%s\" is limited to %0.2f\n", var->name,var->maxrulesetvalue);
			return;
		}
	}

	if ((var->flags & CVAR_INIT) && host_initialized) {
		if (cl_warncmd.value || developer.value)
			Com_Printf ("\"%s\" can only be changed with \"+set %s %s\" on the command line.\n", var->name, var->name, value);
		return;
	}

	// We do this before OnChange check, which means no OnChange check for latched cvars.
	if (var->flags & CVAR_LATCH)
	{
		if (var->latchedString)
		{
			if (strcmp(value, var->latchedString) == 0)
				return; // latched string alredy has this value
			Q_free(var->latchedString); // switching latching string to other, so free it
		}
		else
		{
			if (strcmp(value, var->string) == 0)
				return; // we change string value to the same, do no create latched string then
		}

		// HACK: sometime I need somehow silently change latched cvars.
		//       So, flag CVAR_SILENT for latched cvars mean no this warning.
		//       However keep this flag always on latched variable is stupid imo.
		//       So, do not mix CVAR_LATCHED | CVAR_SILENT in cvar definition.
		if ( !(var->flags & CVAR_SILENT) ) {
			const char* restartcmd = "vid_restart (video/graphics)";
			if (strncmp(var->name, "in_", 3) == 0) {
				restartcmd = "in_restart (input)";
			}
			else if (strncmp(var->name, "s_", 2) == 0) {
				restartcmd = "s_restart (sound)";
			}
			Com_Printf ("%s needs %s to take effect.\n", var->name, restartcmd);
		}
		var->latchedString = Q_strdup_named(value, var->name);
		var->modified = true; // set to true even car->string is not changed yet, that how q3 does
		return;
	}
#endif

	if (!ignore_callback && var->OnChange && !changing) {
		qbool cancel = false;

		changing = true;
		var->flags &= ~(CVAR_AUTOSETRECENT);
		var->OnChange(var, value, &cancel);
		changing = false;

		if (cancel) {
			return; // change rejected.
		}
	}

#ifndef SERVERONLY
	same_value = value && var->string && (value == var->string || !strcmp (value, var->string));
#endif
	// dup string first (before free) since 'value' and 'var->string' can point at the same memory area.
	new_val = Q_strdup_named(value, var->name);
	// free the old value string
	Q_free(var->string);
	// assign new value
	var->string = new_val;
	var->value = Q_atof (var->string);
#ifndef SERVERONLY
	var->integer = Q_atoi (var->string);
	if (var->flags & CVAR_TRACKERCOLOR) {
		TrackerStringToRGB_W(var->string, var->color);
	}
	else {
		StringToRGB_W(var->string, var->color);
	}
	if (!same_value && !(var->flags & CVAR_AUTOSETRECENT)) {
		Cvar_AutoReset (var);
	}
	var->flags &= ~(CVAR_AUTOSETRECENT);
	var->modified = true;
#endif

#ifndef CLIENTONLY
	if (var->flags & CVAR_SERVERINFO) {
		SV_ServerinfoChanged(var->name, var->string);
	}
#endif

#ifndef SERVERONLY
	if (var->flags & CVAR_USERINFO) {
		CL_UserinfoChanged(var->name, var->string);
	}
	if (var->flags & CVAR_RECOMPILE_PROGS) {
		renderer.CvarForceRecompile(var);
	}
	if ((var->flags & CVAR_RELOAD_GFX) && host_everything_loaded && !same_value) {
		VID_ReloadCvarChanged(var);
	}
#endif
}

void Cvar_SetIgnoreCallback(cvar_t *var, char *value)
{
	Cvar_SetEx(var, value, true);
}

void Cvar_Set(cvar_t *var, char *value)
{
	Cvar_SetEx(var, value, false);
}

void Cvar_ForceSet (cvar_t *var, char *value)
{
	int saved_flags;

	if (!var)
		return;

	saved_flags = var->flags;
	var->flags &= ~CVAR_ROM;
	Cvar_Set (var, value);
	var->flags = saved_flags;
}

void Cvar_SetByName (const char *var_name, char *value)
{
	cvar_t	*var;

	var = Cvar_Find (var_name);
	if (!var)
	{	// there is an error in C code if this happens
		Con_DPrintf ("Cvar_Set: variable %s not found\n", var_name);
		return;
	}

	Cvar_Set (var, value);
}

static void Cvar_ValueToString(char* val, int size, float value)
{
	int	i;

	snprintf(val, size - 1, "%f", value);
	for (i = strlen(val) - 1; i > 0 && val[i] == '0'; i--) {
		val[i] = 0;
	}

	if (val[i] == '.') {
		val[i] = '\0';
	}
}

void Cvar_SetValue (cvar_t *var, const float value)
{
	char val[128];

	Cvar_ValueToString(val, sizeof(val), value);

	Cvar_Set(var, val);
}

void Cvar_SetValueByName(const char *var_name, const float value)
{
	char val[32];

	snprintf(val, sizeof(val), "%.8g", value);
	Cvar_SetByName(var_name, val);
}

void Cvar_Register(cvar_t *var)
{
	int key;
	cvar_t *old = Cvar_Find(var->name);

	// All variables must be named :)
	if (var->name[0] == '\0')
		return;

#ifdef SERVERONLY
	char* value;

	// first check to see if it has already been defined
	if (old) {
		Con_Printf("Can't register variable %s, already defined\n", var->name);
		return;
	}

	// check for overlap with a command
	if (Cmd_Exists(var->name)) {
		Con_Printf("Cvar_Register: %s is a command\n", var->name);
		return;
	}

	// link the variable in
	key = Com_HashKey(var->name);
	var->hash_next = cvar_hash[key];
	cvar_hash[key] = var;
	var->next = cvar_vars;
	cvar_vars = var;

	// set it through the function to be consistent
	value = var->string;
	var->string = Q_strdup("");
	Cvar_SetROM(var, value);
#else
	// we already register cvar, warn about it
	if (old && !(old->flags & CVAR_USER_CREATED)) {
		// allow re-register latched cvar
		if (old->flags & CVAR_LATCH) {
			// if we have a latched string, take that value now
			Cvar_ApplyLatchedUpdate(old);
			Cvar_AutoReset(old);

			return;
		}

		// warn if CVAR_SILENT is not set
		if (!(old->flags & CVAR_SILENT)) {
			Com_Printf("Can't register variable %s, already defined\n", var->name);
		}

		return;
	}

	if (old && old == var) {
		Sys_Error("Cvar_Register: something wrong with %s", var->name);
	}

	if (var->defaultvalue) {
		Sys_Error("Cvar_Register: defaultvalue already set for %s", var->name);
	}

	var->defaultvalue = Q_strdup_named(var->string, var->name);
	if (old) {
		char string[512];
		qbool queued_replace;

		// Trigger change later if this is a proper cvar replacing a user one
		queued_replace = (old->flags & CVAR_USER_CREATED) && (var->flags & CVAR_QUEUED_TRIGGER) && !(var->flags & CVAR_USER_CREATED);
		if (queued_replace) {
			// Created by executing config, now we have the 'proper' cvar - store old value to trigger later
			var->latchedString = Q_strdup_named(old->string, var->name);
		}

		var->flags |= old->flags & ~(CVAR_USER_CREATED | CVAR_TEMP);
		strlcpy(string, (var->flags & CVAR_ROM) || queued_replace ? var->string : old->string, sizeof(string));
		Cvar_Delete(old->name);
		var->string = Q_strdup_named(string, var->name);
	}
	else {
		// allocate the string on zone because future sets will Q_free it
		var->string = Q_strdup_named(var->string, var->name);
	}

	var->value = Q_atof(var->string);
	if (((var->flags & CVAR_RULESET_MIN) && var->value < var->minrulesetvalue) ||
	    ((var->flags & CVAR_RULESET_MAX) && var->value > var->maxrulesetvalue)) {
		char val[128];

		var->value = bound(var->minrulesetvalue, var->value, var->maxrulesetvalue);
		Cvar_ValueToString(val, sizeof(val), var->value);

		Q_free(var->string);
		var->string = Q_strdup_named(val, var->name);
	}
	var->integer = Q_atoi(var->string);
	StringToRGB_W(var->string, var->color);
	var->modified = true;

	// link the variable in
	key = Com_HashKey(var->name) % VAR_HASHPOOL_SIZE;
	var->hash_next = cvar_hash[key];
	cvar_hash[key] = var;
	var->next = cvar_vars;
	cvar_vars = var;

	Cvar_AddCvarToGroup(var);

#ifndef CLIENTONLY
	if (var->flags & CVAR_SERVERINFO) {
		SV_ServerinfoChanged(var->name, var->string);
	}
#endif

	if (var->flags & CVAR_USERINFO) {
		CL_UserinfoChanged(var->name, var->string);
	}
#endif // !SERVERONLY
}

static void Cvar_ApplyLatchedUpdate(cvar_t* var)
{
	if (var->latchedString) {
		// I did't want bother with all this CVAR_ROM and OnChange handler, just set value
		Q_free(var->string);
		var->string = var->latchedString;
		var->latchedString = NULL;
		var->value = Q_atof(var->string);
		var->integer = Q_atoi(var->string);
		StringToRGB_W(var->string, var->color);
		var->modified = true;
	}
}

qbool Cvar_Command (void)
{
	cvar_t *v;

	// check variables
	if (!(v = Cvar_Find (Cmd_Argv(0))))
		return false;

	if (Cmd_Argc() == 1) {
#ifndef SERVERONLY
		if (cvar_viewhelp.value)
			Help_DescribeCvar (v);

		if (cvar_viewdefault.value) {
			char *spaces = CreateSpaces(strlen(v->name) + 2);

			Con_Printf ("%s : default value is \"%s\"\n", v->name, v->defaultvalue);

			Con_Printf ("%s current value is \"%s\"\n", spaces, v->string);

			if ((v->flags & CVAR_AUTO) && v->autoString) {
				Con_Printf ("%s auto    value is \"%s\"\n", spaces, v->autoString);
			}

			if (cvar_viewlatched.integer && v->latchedString) {
				Con_Printf ("%s latched value is \"%s\"\n", spaces, v->latchedString);
			}
		}
		else {
#endif
			Con_Printf ("\"%s\" is \"%s\"\n", v->name, v->string);
#ifndef SERVERONLY
			if ((v->flags & CVAR_AUTO) && v->autoString) {
				Con_Printf ("auto: \"%s\"\n", v->autoString);
			}

			if (cvar_viewlatched.integer && v->latchedString) {
				Con_Printf ("latched: \"%s\"\n", v->latchedString);
			}
		}
#endif
	}
	else {
#ifndef SERVERONLY
		// RestrictTriggers means that advanced (possibly cheaty) scripts are not allowed
		// So we will force the usage of user-created variables to go through the set command
		if (cbuf_current == &cbuf_server) {
			// Keep the mod from changing user cvars that it didn't create
			if ((v->flags & CVAR_USER_CREATED) && !(v->flags & CVAR_MOD_CREATED)) {
				Con_Printf ("Error: server attempt to \"set\" user created variable [%s]\n", v->name);
				return true;
			}
		}
		else if ((v->flags & CVAR_USER_CREATED) && Rulesets_RestrictTriggers()) {
			Con_Printf ("Current ruleset requires \"set\" with user created variables [%s]\n", v->name);
			return true;
		}
#endif
		Cvar_Set (v, Cmd_MakeArgs(1));
	}

	return true;
}

static void Cvar_Toggle_f_base (qbool use_regex)
{
	cvar_t *var;
	char *name;
	int i;

	if (Cmd_Argc() < 2) {
		Con_Printf("%s <cvar> [<cvar>..]: toggle a cvar on/off\n", Cmd_Argv(0));
		return;
	}

	for (i = 1; i < Cmd_Argc(); i++) {
		name = Cmd_Argv(i);

		if (use_regex && IsRegexp(name)) {
			if (!ReSearchInitEx(name, false)) {
				continue;
			}

			for (var = cvar_vars; var; var = var->next) {
				if (ReSearchMatch(var->name)) {
					Cvar_Set(var, var->value ? "0" : "1");
				}
			}

			ReSearchDone();
		}
		else {
			var = Cvar_Find(name);

			if (!(var)) {
				Con_Printf("Unknown variable \"%s\"\n", name);
				continue;
			}
			Cvar_Set(var, var->value ? "0" : "1");
		}
	}
}

void Cvar_Toggle_f (void)
{
	Cvar_Toggle_f_base(false);
}

void Cvar_Toggle_re_f (void)
{
	Cvar_Toggle_f_base(true);
}

void Cvar_Toggle (cvar_t *var)
{
	Cvar_SetValue (var, (var->value == 0) ? 1 : 0);
}

int Cvar_CvarCompare (const void *p1, const void *p2)
{
	return strcmp((*((cvar_t **) p1))->name, (*((cvar_t **) p2))->name);
}

void Cvar_CvarList(qbool use_regex)
{
	static cvar_t *sorted_cvars[4096];
	int i, c, m = 0, count;
	cvar_t *var;
	char *pattern;

#define MAX_SORTED_CVARS (sizeof (sorted_cvars) / sizeof (sorted_cvars[0]))

	for (var = cvar_vars, count = 0; var && count < MAX_SORTED_CVARS; var = var->next, count++) {
		sorted_cvars[count] = var;
	}
	qsort(sorted_cvars, count, sizeof(cvar_t *), Cvar_CvarCompare);

	if (count == MAX_SORTED_CVARS) {
		assert(!"count == MAX_SORTED_CVARS");
	}

	pattern = (Cmd_Argc() > 1) ? Cmd_Argv(1) : NULL;

	if (((c = Cmd_Argc()) > 1) && use_regex) {
		if (!ReSearchInitEx(Cmd_Argv(1), false)) {
			return;
		}
	}

	Con_Printf("List of cvars:\n");
	for (i = 0; i < count; i++) {
		var = sorted_cvars[i];
		if (use_regex) {
			if (!(c == 1 || ReSearchMatch(var->name))) {
				continue;
			}
		}
		else {
			if (pattern && !Q_glob_match(pattern, var->name)) {
				continue;
			}
		}

		Con_Printf("%c%c %s\n",
#ifndef SERVERONLY
			var->flags & CVAR_USERINFO ? 'u' :
#endif
			' ',
#ifndef CLIENTONLY
			var->flags & CVAR_SERVERINFO ? 's' : 
#endif
			' ',
			var->name);
		m++;
	}

	if (use_regex && (c > 1)) {
		ReSearchDone();
	}

	Con_Printf("------------\n%i/%i %svariables\n", m, count, (pattern) ? "matching " : "");
}

void Cvar_CvarList_f (void)
{
	Cvar_CvarList (false);
}

void Cvar_CvarList_re_f (void)
{
	Cvar_CvarList (true);
}

static void Cvar_CvarEdit_f(void)
{
	cvar_t* cvar;
	char *s, final_string[MAXCMDLINE - 1];
	int c;

	c = Cmd_Argc();
	if (c == 1) {
		Com_Printf("%s <name> : modify a cvar\n", Cmd_Argv(0));
		Com_Printf("cvarlist : list all cvars\n");
		return;
	}

	cvar = Cvar_Find(Cmd_Argv(1));
	if (cvar == NULL) {
		Com_Printf("\"%s\" not a valid cvar\n", Cmd_Argv(1));
		return;
	}
	else {
		s = Q_strdup(cvar->string);
	}

	snprintf(final_string, sizeof(final_string), "/%s \"%s\"", Cmd_Argv(1), s);
	Key_ClearTyping();
	memcpy(key_lines[edit_line] + 1, str2wcs(final_string), strlen(final_string) * sizeof(wchar));
	Q_free(s);
}

cvar_t *Cvar_Create(const char *name, const char *string, int cvarflags)
{
	cvar_t *v;
	int key;

	v = Cvar_Find(name);
	if (v) {
#ifndef SERVERONLY
		v->flags &= ~CVAR_TEMP;
#endif
		v->flags |= cvarflags;
		return v;
	}
	v = (cvar_t *)Q_malloc(sizeof(cvar_t));
	// Cvar doesn't exist, so we create it
	v->next = cvar_vars;
	cvar_vars = v;

	key = Com_HashKey(name) % VAR_HASHPOOL_SIZE;
	v->hash_next = cvar_hash[key];
	cvar_hash[key] = v;

	v->name = Q_strdup_named(name, name);
	v->string = Q_strdup_named(string, name);
	v->value = Q_atof(v->string);
	v->flags = cvarflags;
#ifndef SERVERONLY
	v->flags |= CVAR_USER_CREATED;
	v->defaultvalue = Q_strdup_named(string, name);
	if (cbuf_current == &cbuf_server) {
		v->flags |= CVAR_MOD_CREATED;
	}
	v->integer = Q_atoi(v->string);
	StringToRGB_W(v->string, v->color);
	v->modified = true;
#endif

	return v;
}

// returns true if the cvar was found (and deleted)
qbool Cvar_Delete(const char *name)
{
	cvar_t *var, *prev = NULL;
	int key = Com_HashKey(name) % VAR_HASHPOOL_SIZE;

	for (var = cvar_hash[key]; var; var = var->hash_next) {
		if (!strcasecmp(var->name, name)) {
			// unlink from hash
			if (prev) {
				prev->hash_next = var->hash_next;
			}
			else {
				cvar_hash[key] = var->hash_next;
			}
			break;
		}
		prev = var;
	}

	if (!var) {
		return false;
	}

	prev = NULL;
	for (var = cvar_vars; var; var = var->next) {
		if (!strcasecmp(var->name, name)) {
			// unlink from cvar list
			if (prev) {
				prev->next = var->next;
			}
			else {
				cvar_vars = var->next;
			}
#ifndef SERVERONLY
			Q_free(var->defaultvalue);
#endif
			// free
			Q_free(var->string);
			Q_free(var->name);
			Q_free(var);
			return true;
		}
		prev = var;
	}

	Sys_Error("Cvar list broken");
	return false;
}

void Cvar_Set_f (void)
{
	cvar_t *var;
	char *var_name;

	if (Cmd_Argc() != 3) {
		Con_Printf ("Usage: %s <cvar> <value>\n", Cmd_Argv(0));
		return;
	}

	var_name = Cmd_Argv (1);
	var = Cvar_Find (var_name);

	if (var) {
		Cvar_Set(var, Cmd_Argv(2));
	}
	else {
		if (Cmd_Exists(var_name)) {
			Con_Printf("\"%s\" is a command\n", var_name);
			return;
		}

		var = Cvar_Create (var_name, Cmd_Argv(2), cbuf_current == &cbuf_server ? CVAR_MOD_CREATED : CVAR_USER_CREATED);
	}
}

void Cvar_Inc_f(void)
{
	int     c;
	cvar_t  *var;
	float   delta;

	c = Cmd_Argc();
	if (c != 2 && c != 3) {
		Con_Printf("Usage: inc <cvar> [value]\n");
		return;
	}

	var = Cvar_Find(Cmd_Argv(1));
	if (!var) {
		Con_Printf("Unknown variable \"%s\"\n", Cmd_Argv(1));
		return;
	}
	delta = (c == 3) ? atof(Cmd_Argv(2)) : 1;

	Cvar_SetValue(var, var->value + delta);
}

int Cvar_GetFlags (cvar_t *var)
{
	return var->flags;
}

#ifndef SERVERONLY
qbool Cvar_ForceCallback(cvar_t *var)
{
	qbool cancel = false;

	if (!var || !var->OnChange)
		return cancel;

	var->OnChange(var, var->string, &cancel);
	return cancel;
}

void Cvar_ResetVar (cvar_t *var)
{
	if (var && strcmp(var->string, var->defaultvalue)) {
		Cvar_Set(var, var->defaultvalue);
	}
}

void Cvar_Reset(qbool use_regex)
{
	qbool re_search = false;
	cvar_t *var;
	char *name;
	int i;

	if (Cmd_Argc() < 2) {
		Com_Printf("%s <cvar> [<cvar2>..]: reset variable to it default value\n", Cmd_Argv(0));
		return;
	}

	for (i = 1; i < Cmd_Argc(); i++) {
		name = Cmd_Argv(i);

		if (use_regex && (re_search = IsRegexp(name))) {
			if (!ReSearchInitEx(name, false)) {
				continue;
			}
		}

		if (use_regex && re_search) {
			for (var = cvar_vars; var; var = var->next) {
				if (ReSearchMatch(var->name)) {
					Cvar_ResetVar(var);
				}
			}
		}
		else {
			if ((var = Cvar_Find(name))) {
				Cvar_ResetVar(var);
			}
			else {
				Com_Printf("%s : No variable with name %s\n", Cmd_Argv(0), name);
			}
		}
		if (use_regex && re_search) {
			ReSearchDone();
		}
	}
}

void Cvar_Reset_f (void)
{
	Cvar_Reset(false);
}

void Cvar_Reset_re_f (void)
{
	Cvar_Reset(true);
}

void Cvar_SetDefaultAndValue(cvar_t *var, float default_value, float actual_value)
{
	char val[128];
	int i;

	snprintf (val, sizeof(val), "%f", default_value);
	for (i = strlen(val) - 1; i > 0 && val[i] == '0'; i--)
		val[i] = 0;
	if (val[i] == '.')
		val[i] = 0;
	Q_free(var->defaultvalue);
	var->defaultvalue = Q_strdup_named(val, var->name);
	Cvar_SetValue(var, actual_value);
}

char *Cvar_CompleteVariable (char *partial)
{
	cvar_t *cvar;
	int len;

	if (!(len = strlen(partial)))
		return NULL;

	// check exact match
	for (cvar = cvar_vars; cvar; cvar = cvar->next)
		if (!strcasecmp (partial,cvar->name))
			return cvar->name;

	// check partial match
	for (cvar = cvar_vars; cvar; cvar = cvar->next)
		if (!strncasecmp (partial,cvar->name, len))
			return cvar->name;

	return NULL;
}

int Cvar_CompleteCountPossible (char *partial)
{
	cvar_t *cvar;
	int len, c = 0;

	if (!(len = strlen(partial)))
		return 0;

	// check partial match
	for (cvar = cvar_vars; cvar; cvar = cvar->next)
		if (!strncasecmp (partial, cvar->name, len))
			c++;

	return c;
}

void Cvar_RulesetSet(cvar_t *var, char *val, int m)
{
	float rulesetval_f = Q_atof (val);

	switch (m) {
	case 0:
		var->minrulesetvalue = rulesetval_f;
		break;
	case 1:
		var->maxrulesetvalue = rulesetval_f;
		break;
	case 2:
		var->minrulesetvalue = rulesetval_f;
		var->maxrulesetvalue = rulesetval_f;
		break;
	default:
		return;
	}
}

void Cvar_AutoSet(cvar_t *var, char *value)
{
	if (!var || !(var->flags & CVAR_AUTO) || !value) {
		return;
	}

	Q_free(var->autoString);

	var->autoString = Q_strdup(value);
	var->flags |= CVAR_AUTOSETRECENT;
}

void Cvar_AutoSetInt(cvar_t *var, int value)
{
	char val[128];

	if (!var || !(var->flags & CVAR_AUTO)) {
		return;
	}

	Q_free(var->autoString);

	snprintf(&val[0], sizeof(val), "%d", value);

	var->autoString = Q_strdup_named(val, var->name);
	var->flags |= CVAR_AUTOSETRECENT;
}

void Cvar_AutoReset(cvar_t *var)
{
	if (!var) {
		return;
	}

	Q_free(var->autoString);
}

// silently set value for latched cvar
void Cvar_LatchedSet(cvar_t *var, char *value)
{
	// yea, do not mess things
	if (!(var->flags & CVAR_LATCH)) {
		Sys_Error("Cvar_LatchedSet: non latched var %s", var->name);
	}

	var->flags |= CVAR_SILENT; // shut up warnings, at least some...
	Cvar_Set(var, value);
	// remove this flag, btw if variable have this flag before set this flag will be removed anyway..
	var->flags &= ~CVAR_SILENT;
	// actually set value
	Cvar_Register(var);
}

// silently set value for latched cvar
void Cvar_LatchedSetValue(cvar_t *var, float value)
{
	// yea, do not mess things
	if (!(var->flags & CVAR_LATCH)) {
		Sys_Error("Cvar_LatchedSet: non latched var %s", var->name);
	}

	var->flags |= CVAR_SILENT; // shut up warnings, at least some...
	Cvar_SetValue(var, value);
	// remove this flag, btw if variable have this flag before set this flag will be removed anyway..
	var->flags &= ~CVAR_SILENT;
	// actually set value
	Cvar_Register(var);
}

void Cvar_SetFlags(cvar_t *var, int flags)
{
	var->flags = flags;
}

static cvar_group_t *current = NULL;
cvar_group_t *cvar_groups = NULL;

#define CVAR_GROUPS_DEFINE_VARIABLES
#include "cvar_groups.h"
#undef CVAR_GROUPS_DEFINE_VARIABLES

static cvar_group_t *Cvar_AddGroup(char *name)
{
	static qbool initialised = false;
	cvar_group_t *newgroup;
	char **s;

	if (!initialised) {
		initialised = true;
		for (s = cvar_groups_list; *s; s++)
			Cvar_AddGroup(*s);
	}

	for (newgroup = cvar_groups; newgroup; newgroup = newgroup->next)
		if (!strcasecmp(newgroup->name, name))
			return newgroup;

	newgroup = (cvar_group_t *) Q_malloc(sizeof(cvar_group_t));
	strlcpy(newgroup->name, name, sizeof(newgroup->name));
	newgroup->count = 0;
	newgroup->head = NULL;
	newgroup->next = cvar_groups;
	cvar_groups = newgroup;

	return newgroup;
}

void Cvar_SetCurrentGroup(char *name)
{
	cvar_group_t *group;

	for (group = cvar_groups; group; group = group->next) {
		if (!strcmp(group->name, name)) {
			current = group;
			return;
		}
	}
	current = Cvar_AddGroup(name);
}

void Cvar_ResetCurrentGroup(void)
{
	current = NULL;
}

static void Cvar_AddCvarToGroup(cvar_t *var)
{
	if ((var->group = current)) {
		var->next_in_group = current->head;
		current->head = var;
		current->count++;
	}
	else {
		var->next_in_group = NULL;
	}
}

void Cvar_Set_tp_f(void)
{
	cvar_t *var;
	char *var_name;

	if (Cmd_Argc() != 3) {
		Com_Printf("Usage: %s <cvar> <value>\n", Cmd_Argv(0));
		return;
	}

	var_name = Cmd_Argv(1);
	var = Cvar_Find(var_name);

	if (var) {
		if (!var->teamplay) {
			Com_Printf("\"%s\" is not a teamplay variable\n", var->name);
			return;
		}
		else {
			Cvar_Set(var, Cmd_Argv(2));
		}
	}
	else {
		if (Cmd_Exists(var_name)) {
			Com_Printf("\"%s\" is a command\n", var_name);
			return;
		}
		var = Cvar_Create(var_name, Cmd_Argv(2), 0);
		var->teamplay = true;
	}
}

static void Cvar_Set_ex_f(void)
{
	cvar_t* var;
	char* var_name;
	char* st = NULL;
	char	text_exp[1024];
	qbool   parse_funchars = !strcasecmp(Cmd_Argv(0), "set_ex");

	if (Rulesets_RestrictSetEx()) {
		Com_Printf("The use of set_ex/set_ex2 is not allowed during matches\n");
		return;
	}

	if (Cmd_Argc() != 3) {
		Com_Printf("usage: %s <cvar> <value>\n", Cmd_Argv(0));
		return;
	}

	var_name = Cmd_Argv(1);
	var = Cvar_Find(var_name);

	if (!var) {
		if (Cmd_Exists(var_name)) {
			Com_Printf("\"%s\" is a command\n", var_name);
			return;
		}
		var = Cvar_Create(var_name, "", 0);
	}

	Cmd_ExpandString(Cmd_Argv(2), text_exp);
	st = TP_ParseMacroString(text_exp);
	if (parse_funchars) {
		st = TP_ParseFunChars(st, false);
	}

	Cvar_Set(var, st);
}

void Cvar_Set_Alias_Str_f (void)
{
	cvar_t		*var;
	char		*var_name;
	char		*alias_name;
	//char		str[1024];
	char		*v /*,*s*/;
	if (Cmd_Argc() != 3) {
		Com_Printf ("usage: set_alias_str <cvar> <alias>\n");
		return;
	}

	var_name = Cmd_Argv (1);
	alias_name = Cmd_Argv (2);
	var = Cvar_Find (var_name);
	v = Cmd_AliasString( alias_name );

	if ( !var) {
		if (Cmd_Exists(var_name)) {
			Com_Printf ("\"%s\" is a command\n", var_name);
			return;
		}
		var = Cvar_Create(var_name, "", 0);
	}

	if (!var) {
		Com_Printf ("Unknown variable \"%s\"\n", var_name);
		return;
	}
	else if (!v) {
		Com_Printf ("Unknown alias \"%s\"\n", alias_name);
		return;
	}
	else {
		Cvar_Set (var, v);
	}
}

void Cvar_Set_Bind_Str_f(void)
{
	cvar_t		*var;
	int			keynum;
	char		*var_name;
	char		*key_name;
	//char		str[1024];
	//char		*v,*s;

	if (Cmd_Argc() != 3) {
		Com_Printf("usage: set_bind_str <cvar> <key>\n");
		return;
	}

	var_name = Cmd_Argv(1);
	key_name = Cmd_Argv(2);
	var = Cvar_Find(var_name);
	keynum = Key_StringToKeynum(key_name);

	if (!var) {
		if (Cmd_Exists(var_name)) {
			Com_Printf("\"%s\" is a command\n", var_name);
			return;
		}
		var = Cvar_Create(var_name, "", 0);
	}

	if (!var) {
		Com_Printf("Unknown variable \"%s\"\n", var_name);
		return;
	}
	else if (keynum == -1) {
		Com_Printf("Unknown key \"%s\"\n", key_name);
		return;
	}
	else {
		if (keybindings[keynum]) {
			Cvar_Set(var, keybindings[keynum]);
		}
		else {
			Cvar_Set(var, "");
		}
	}
}

// disconnect -->
void Cvar_UnSet (qbool use_regex)
{
	cvar_t	*var, *next;
	char	*name;
	int		i;
	qbool	re_search = false;

	if (Cmd_Argc() < 2) {
		Com_Printf ("unset <cvar> [<cvar2>..]: erase user-created variable\n");
		return;
	}

	for (i=1; i<Cmd_Argc(); i++) {
		name = Cmd_Argv(i);

		if (use_regex && (re_search = IsRegexp(name))) {
			if (!ReSearchInitEx(name, false)) {
				continue;
			}
		}

		if (use_regex && re_search) {
			for (var = cvar_vars ; var ; var = next) {
				next = var->next;

				if (ReSearchMatch(var->name)) {
					if ((var->flags & CVAR_USER_CREATED) && !(var->flags & CVAR_MOD_CREATED)) {
						Cvar_Delete(var->name);
					}
					else {
						Com_Printf("Can't delete not user created cvars (\"%s\")\n", var->name);
					}
				}
			}
		}
		else {
			if (!(var = Cvar_Find(name))) {
				Com_Printf("Can't delete \"%s\": no such cvar\n", name);
				continue;
			}

			if ((var->flags & CVAR_USER_CREATED) && !(var->flags & CVAR_MOD_CREATED)) {
				Cvar_Delete(name);
			}
			else {
				Com_Printf("Can't delete not user created cvars (\"%s\")\n", name);
			}
		}
		if (use_regex && re_search)
			ReSearchDone();
	}
}

void Cvar_UnSet_f(void)
{
	Cvar_UnSet(false);
}

void Cvar_UnSet_re_f(void)
{
	Cvar_UnSet(true);
}
// <-- disconnect

// QW262 -->

// XXX: this could do with some refactoring
void Cvar_Set_Calc_f(void)
{
	cvar_t *var, *var2;
	char *var_name, *op, *a2, *a3;
	int	pos, len, division_by_zero = 0;
	float num1, num2, result;
	char buf[1024];

	if (Rulesets_RestrictSetCalc()) {
		Com_Printf("The use of set_calc is not allowed during matches\n");
		return;
	}

	var_name = Cmd_Argv (1);
	var = Cvar_Find (var_name);

	if (!var)
		var = Cvar_Create (var_name, Cmd_Argv (2), 0);

	a2 = Cmd_Argv (2);
	a3 = Cmd_Argv (3);

	if (!strcmp (a2, "strlen")) {
		Cvar_SetValue (var, strlen (a3));
		return;
	} else if (!strcmp (a2, "int")) {
		Cvar_SetValue (var, (int) Q_atof (a3));
		return;
	} else if (!strcmp (a2, "substr")) {
		int var2len;
		var2 = Cvar_Find (a3);

		if (!var2) {
			Com_Printf ("Unknown variable \"%s\"\n", a3);
			return;
		}

		pos = atoi (Cmd_Argv (4));
		len = (Cmd_Argc () < 6)? 1 : atoi (Cmd_Argv (5));

		if (len == 0) {
			Cvar_Set (var, "");
			return;
		}

		if (len < 0 || pos < 0) {
			Com_Printf ("substr: invalid len or pos\n");
			return;
		}

		var2len = strlen (var2->string);

		if (var2len < pos) {
			Com_Printf ("substr: string length exceeded\n");
			return;
		}

		len = min (var2len - pos, len);
		strlcpy (buf, var2->string + pos, len);
		Cvar_Set (var, buf);
		return;

	} else if (!strcmp (a2, "set_substr")) {
		int	var1len,var2len;
		var2 = Cvar_Find (a3);

		if (!var2) {
			Com_Printf ("Unknown variable \"%s\"\n", a3);
			return;
		}

		var1len = strlen (var->string);
		var2len = strlen (var2->string);
		pos = atoi (Cmd_Argv (4));

		strlcpy (buf, var->string, sizeof (buf));

		if (pos + var2len > var1len) { // need to expand
			int i;
			for (i = var1len; i < pos + var2len; i++)
				buf[i] = ' ';
			buf[pos+var2len] = 0;
		}

		strlcpy (buf + pos, var2->string, sizeof (buf) - pos);
		Cvar_Set (var, buf);

		return;
	} else if (!strcmp (a2, "pos")) {
		var2 = Cvar_Find (a3);

		if (!var2) {
			Com_Printf ("Unknown variable \"%s\"\n", a3);
			return;
		}

		op = strstr (var2->string, Cmd_Argv (4));
		Cvar_SetValue (var, op ? op - var2->string : -1);
		return;
	} else if (!strcmp (a2, "tobrown")) {
		strlcpy (buf, var->string, sizeof (buf));
		CharsToBrown (buf, buf + strlen (buf));
		Cvar_Set (var, buf);
		return;
	} else if (!strcmp (a2, "towhite")) {
		strlcpy (buf, var->string, sizeof (buf));
		CharsToWhite (buf, buf + strlen (buf));
		Cvar_Set (var, buf);
		return;
	}

	num1 = Q_atof (a2);
	op = a3;
	num2 = Q_atof (Cmd_Argv (4));

	if (!strcmp (op, "+"))
		result = num1 + num2;
	else if (!strcmp (op, "-"))
		result = num1 - num2;
	else if (!strcmp (op, "*"))
		result = num1 * num2;
	else if (!strcmp (op, "/")) {
		if (num2 != 0)
			result = num1 / num2;
		else
			division_by_zero = 1;
	} else if (!strcmp (op, "%")) {
		if ((int) num2 != 0)
			result = (int) num1 % (int) num2;
		else
			division_by_zero = 1;
	} else if (!strcmp (op, "div")) {
		if ((int) num2 != 0)
			result = (int) num1 / (int) num2;
		else
			division_by_zero = 1;
	} else if (!strcmp (op, "and")) {
		result = (int) num1 & (int) num2;
	} else if (!strcmp (op, "or")) {
		result = (int) num1 | (int) num2;
	} else if (!strcmp (op, "xor")) {
		result = (int) num1 ^ (int) num2;
	} else {
		Com_Printf ("set_calc: unknown operator: %s\nvalid operators are: + - * / div %% and or xor\n", op);
		// Com_Printf("set_calc: unknown command: %s\nvalid commands are: strlen int substr set_substr pos\n", a2);
		return;
	}

	if (division_by_zero) {
		Com_Printf ("set_calc: can't divide by zero\n");
		result = 999;
	}

	Cvar_SetValue (var, result);
}

// <-- QW262

void Cvar_Set_Eval_f(void)
{
	if (Rulesets_RestrictSetEval()) {
		Com_Printf("The use of set_eval is not allowed during matches\n");
		return;
	}

	if (Cmd_Argc() < 3) {
		Com_Printf("Usage:\n"
			"set_eval <variable> <expression>\n"
			"set_eval is similar to set_calc but supports richer expressions\n");
		return;
	}
	else {
		const char *expression;
		char *var_name;
		cvar_t *var;
		int errn;
		expr_val result;

		var_name = Cmd_Argv (1);
		var = Cvar_Find (var_name);

		if (!var)
			var = Cvar_Create (var_name, Cmd_Argv (1), 0);

		expression = Cmd_MakeArgs(2);

		result = Expr_Eval(expression, NULL, &errn);

		if (errn == EXPR_EVAL_SUCCESS) {
			switch (result.type) {
			case ET_INT:
				Cvar_SetValue(var, result.i_val);
				break;
			case ET_DBL:
				Cvar_SetValue(var, result.d_val);
				break;
			case ET_BOOL:
				Cvar_SetValue(var, result.b_val ? 1 : 0);
				break;
			case ET_STR:
				Cvar_Set(var, result.s_val);
				Q_free(result.s_val);
				break;
			}
		}
		else {
			Com_Printf("Error in expression: %s\n", Parser_Error_Description(errn));
		}
	}
}



// if an unknown command with parameters was encountered when loading
// config.cfg, assume it's a cvar set and spawn a temp var
qbool Cvar_CreateTempVar (void)
{
	char *name = Cmd_Argv(0);
	// FIXME, make sure it's a valid cvar name, return false if not
	Cvar_Create (name, Cmd_MakeArgs(1), CVAR_TEMP);
	return true;
}

// if none of the subsystems claimed the cvar from config.cfg, remove it
void Cvar_CleanUpTempVars (void)
{
	cvar_t *var, *next;

	for (var = cvar_vars; var; var = next) {
		next = var->next;
		if (var->flags & CVAR_TEMP)
			Cvar_Delete (var->name);
	}
}
#endif

void Cvar_Init(void)
{
	Cmd_AddCommand("cvarlist", Cvar_CvarList_f);
	Cmd_AddCommand("cvaredit", Cvar_CvarEdit_f);
	Cmd_AddCommand("cvarlist_re", Cvar_CvarList_re_f);
	Cmd_AddCommand("toggle", Cvar_Toggle_f);
	Cmd_AddCommand("set", Cvar_Set_f);
	Cmd_AddCommand("inc", Cvar_Inc_f);

#ifndef SERVERONLY
	Cmd_AddCommand("set_tp", Cvar_Set_tp_f);
	Cmd_AddCommand("set_ex", Cvar_Set_ex_f);
	Cmd_AddCommand("set_ex2", Cvar_Set_ex_f);
	Cmd_AddCommand("set_alias_str", Cvar_Set_Alias_Str_f);
	Cmd_AddCommand("set_bind_str", Cvar_Set_Bind_Str_f);
	Cmd_AddCommand("unset", Cvar_UnSet_f);
	Cmd_AddCommand("unset_re", Cvar_UnSet_re_f);
	Cmd_AddCommand("toggle_re", Cvar_Toggle_re_f);
	Cmd_AddCommand("cvar_reset", Cvar_Reset_f);
	Cmd_AddCommand("cvar_reset_re", Cvar_Reset_re_f);
	Cmd_AddCommand("set_calc", Cvar_Set_Calc_f);
	Cmd_AddCommand("set_eval", Cvar_Set_Eval_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_CONSOLE);
	Cvar_Register(&cvar_viewdefault);
	Cvar_Register(&cvar_viewhelp);
	Cvar_Register(&cvar_viewlatched);

	Cvar_ResetCurrentGroup();
#endif
}

void Cvar_Shutdown(void)
{
	cvar_t *cvar;
	cvar_t *next;
	cvar_group_t* group;
	cvar_group_t* next_group;

	for (cvar = cvar_vars; cvar; cvar = next) {
		next = cvar->next;

#ifndef SERVERONLY
		Q_free(cvar->latchedString);
		Q_free(cvar->autoString);
		Q_free(cvar->defaultvalue);
#endif
		Q_free(cvar->string);

#ifndef SERVERONLY
		if (cvar->flags & CVAR_USER_CREATED) {
			Q_free(cvar->name);
			Q_free(cvar);
		}
#endif
	}

#ifndef SERVERONLY
	for (group = cvar_groups; group; group = next_group) {
		next_group = group->next;
		Q_free(group);
	}
#endif
}

void Cvar_ExecuteQueuedChanges(void)
{
	cvar_t* cvar;
	qbool vid_restart = false;
	qbool vid_reload = false;
	qbool sound_restart = false;

	for (cvar = cvar_vars; cvar; cvar = cvar->next) {
		if ((cvar->flags & CVAR_QUEUED_TRIGGER) && cvar->latchedString) {
			if (cvar->OnChange) {
				qbool cancel = false;

				cvar->OnChange(cvar, cvar->latchedString, &cancel);
				if (!cancel) {
					Cvar_ApplyLatchedUpdate(cvar);
				}
			}

			Q_free(cvar->latchedString);
		}

		vid_restart |= (cvar->flags & CVAR_LATCH_GFX) && cvar->latchedString;
		vid_reload |= (cvar->flags & CVAR_RELOAD_GFX && cvar->modified);
		sound_restart |= (cvar->flags & CVAR_LATCH_SOUND) && cvar->latchedString;
	}

	if (vid_restart) {
		Cbuf_AddTextEx(&cbuf_main, "\nvid_restart\n");
	}
	else {
		if (sound_restart) {
			Cbuf_AddTextEx(&cbuf_main, "\ns_restart\n");
		}
		if (vid_reload) {
			Cbuf_AddTextEx(&cbuf_main, "\nvid_reload\n");
		}
	}

	Cvar_ClearAllModifiedFlags(CVAR_RELOAD_GFX);
}

void Cvar_ClearAllModifiedFlags(int flags)
{
	cvar_t* cvar;

	for (cvar = cvar_vars; cvar; cvar = cvar->next) {
		if (cvar->flags & flags) {
			cvar->modified = false;
		}
	}
}

qbool Cvar_AnyModified(int flags)
{
	cvar_t* cvar;

	for (cvar = cvar_vars; cvar; cvar = cvar->next) {
		if ((cvar->flags & flags) && cvar->modified) {
			return true;
		}
	}
	return false;
}


================================================
FILE: src/cvar.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// cvar.h
#ifndef __CVAR_H__
#define __CVAR_H__

#ifndef SERVERONLY
#include "cvar_groups.h"
#endif

// cvar flags
#define CVAR_NONE			 (0)
#define CVAR_ARCHIVE         (1<<0)  // !!!obsolete!!!
#define CVAR_USERINFO        (1<<1)  // mirrored to userinfo
#define CVAR_SERVERINFO      (1<<2)  // mirrored to serverinfo
#define CVAR_ROM             (1<<3)  // read only
#define CVAR_INIT            (1<<4)  // can only be set during initialization
#define	CVAR_USER_CREATED    (1<<5)  // created by a set command
#define	CVAR_USER_ARCHIVE    (1<<6)  // created by a seta command !!!obsolete!!!
#define CVAR_RULESET_MAX     (1<<7)  // limited by ruleset
#define CVAR_RULESET_MIN     (1<<8)  // limited by ruleset
#define CVAR_NO_RESET        (1<<9)  // do not perform reset to default in /cfg_load command, but /cvar_reset will still work
#define CVAR_TEMP            (1<<10) // created during config.cfg execution, before subsystems are initialized
#define CVAR_LATCH_GFX       (1<<11) // will only change when C code next does a Cvar_Register(), so it can't be changed
                                     // without proper initialization.  modified will be set, even though the value hasn't changed yet
                                     // will trigger vid_restart if modified on startup
#define CVAR_SILENT          (1<<12) // skip warning when trying Cvar_Register() second time
#define CVAR_COLOR           (1<<13) // on change convert the string to internal RGBA type
#define CVAR_AUTO            (1<<14) // Cvar can possibly have an automatically calculated value that shouldn't be saved, but still presentable
#define CVAR_MOD_CREATED     (1<<15) // Cvar created by the mod issuing 'set' command
#define CVAR_RECOMPILE_PROGS (1<<16) // Flag all programs to be recompiled if the value changes
#define CVAR_TRACKERCOLOR    (1<<17) // Convert the string from tracker format (0-9)(0-9)(0-9)
#define CVAR_QUEUED_TRIGGER  (1<<18) // Found in config and then registered...
#define CVAR_AUTOSETRECENT   (1<<19) // Ugh... temporary flag so Cvar_SetEx() knows if auto-value set during on-change event
#define CVAR_USERINFONORESET (1<<20) // won't be reset by cfg_reset/cfg_load when 
#define CVAR_LATCH_SOUND     (1<<21) // will only change when C code next does a Cvar_Register()... will trigger sound restart if modified on startup
#define CVAR_RELOAD_GFX      (1<<22) // changes immediately but takes effect as textures load, prompt for vid_reload

#define CVAR_LATCH (CVAR_LATCH_GFX | CVAR_LATCH_SOUND)

#define CVAR_USERINFO_NO_CFG_RESET (CVAR_USERINFO | CVAR_USERINFONORESET)

typedef struct cvar_s {
	char    *name;
	char    *string;
	int     flags;
	void    (*OnChange)(struct cvar_s *var, char *value, qbool *cancel);
	float   value;              // may be set in Cvar_Set(), Cvar_Register(), Cvar_Create()

#ifndef SERVERONLY
	float   maxrulesetvalue;
	float   minrulesetvalue;
	char    *defaultvalue;
	char    *latchedString;
	char    *autoString;        // Must be set via Cvar_AutoSet()
	int     integer;            // may be set in Cvar_Set(), Cvar_Register(), Cvar_Create()
	byte    color[4];           // gets set in Cvar_Set, Cvar_Register, Cvar_Create
	qbool   modified;           // set to true in Cvar_Set(), Cvar_Register(), Cvar_Create(), reset to false manually in C code
	qbool   teamplay;           // is this variable protected so that it can be only used within messaging?

	struct cvar_group_s *group;
	struct cvar_s       *next_in_group;
#endif

	struct cvar_s *hash_next;
	struct cvar_s *next;
} cvar_t;

#ifndef SERVERONLY
typedef struct cvar_group_s {
	char	name[65];
	int		count;
	cvar_t	*head;
	struct cvar_group_s *next;
} cvar_group_t;
#else
#define Cvar_SetCurrentGroup(...)		// ezquake compatibility
#define Cvar_ResetCurrentGroup(...)		// ezquake compatibility
#endif

// registers a cvar that already has the name, string, and optionally the
// archive elements set.
void Cvar_Register (cvar_t *variable);

// Use this to walk through all vars
cvar_t *Cvar_Next (cvar_t *var);

// creates a cvar dynamically
cvar_t *Cvar_Create (const char *name, const char *string, int cvarflags);

// equivalent to "<name> <variable>" typed at the console
void Cvar_Set (cvar_t *var, char *value);
void Cvar_SetIgnoreCallback(cvar_t *var, char *value);

// equivalent to "<name> <variable>" typed at the console
void Cvar_SetByName (const char *var_name, char *value);
void Cvar_SetValueByName (const char *var_name, const float value);
void Cvar_LatchedSetValue(cvar_t *var, float value);

// expands value to a string and calls Cvar_Set
void Cvar_SetValue (cvar_t *var, const float value);

// force a set even if the cvar is read only
void Cvar_ForceSet (cvar_t *var, char *value);
#define Cvar_SetROM Cvar_ForceSet

// toggle boolean variable
void Cvar_Toggle (cvar_t *var);

int Cvar_GetFlags (cvar_t *var);

// returns 0 if not defined or non numeric
float Cvar_Value (const char *var_name);

// returns an empty string if not defined
char *Cvar_String (const char *var_name);

// called by Cmd_ExecuteString when Cmd_Argv(0) doesn't match a known
// command.  Returns true if the command was a variable reference that
// was handled. (print or change)
qbool Cvar_Command (void);

cvar_t *Cvar_Find (const char *name);
qbool Cvar_Delete (const char *name);

void Cvar_Init(void);
void Cvar_Shutdown(void);

#ifndef SERVERONLY
// Used for automatically calculated variables (for presentation)
// but not to be saved in config
void Cvar_AutoSet(cvar_t *var, char *value);
void Cvar_AutoSetInt(cvar_t *var, int value);
void Cvar_AutoReset(cvar_t *var);

// equivalent to "<name> <variable>" typed at the console, but silent for latched var
void Cvar_LatchedSet (cvar_t *var, char *value);

// sets ruleset limit for variable
// when ruleset is active you can't set lower/higher value than this
void Cvar_RulesetSet(cvar_t *var, char *val, int m); // m=0 --> min, m=1--> max, m=2-->locked(max&min)

void Cvar_SetFlags (cvar_t *var, int flags);

void Cvar_SetDefaultAndValue(cvar_t *var, float default_value, float actual_value);

// attempts to match a partial variable name for command line completion
// returns NULL if nothing fits
char  *Cvar_CompleteVariable (char *partial);

// call OnChange callback.
qbool Cvar_ForceCallback(cvar_t *var);
void Cvar_ResetVar (cvar_t *var);

void Cvar_SetCurrentGroup(char *name);
void Cvar_ResetCurrentGroup(void);

qbool Cvar_CreateTempVar (void);	// when parsing config.cfg
void Cvar_CleanUpTempVars (void);	// clean up afterwards
#else
// ezquake compatibility - integrate into mvdsv?
#define IsRegexp(...) false
#define ReSearchInit(...) false
#define ReSearchInitEx(...) false
#define ReSearchMatch(...) false
#define ReSearchDone(...)
#endif

char* Cvar_ServerInfoValue(char* key, char* value);

void Cvar_ClearAllModifiedFlags(int flags);
void Cvar_ExecuteQueuedChanges(void);
qbool Cvar_AnyModified(int flags);

#endif /* !__CVAR_H__ */



================================================
FILE: src/cvar_groups.h
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef CVAR_GROUPS_DEFINE_VARIABLES

#define CVAR_GROUP_NO_GROUP                 "#No Group#"
#define CVAR_GROUP_SERVER_PERMISSIONS       "Serverside Permissions"
#define CVAR_GROUP_SERVER_PHYSICS           "Serverside Physics"
#define CVAR_GROUP_SERVERINFO               "Serverinfo Keys"
#define CVAR_GROUP_SERVER_MAIN              "Server Settings"
#define CVAR_GROUP_ITEM_NEED                "Item Need Amounts"
#define CVAR_GROUP_ITEM_NAMES               "Item Names"
#define CVAR_GROUP_SPECTATOR                "Spectator Tracking"
#define CVAR_GROUP_SCREENSHOTS              "Screenshot Settings"
#define CVAR_GROUP_DEMO                     "Demo Handling"
#define CVAR_GROUP_MATCH_TOOLS              "Match Tools"
#define CVAR_GROUP_VIEW                     "View Settings"
#define CVAR_GROUP_BLEND                    "Screen & Powerup Blends"
#define CVAR_GROUP_SCREEN                   "Screen Settings"
#define CVAR_GROUP_CROSSHAIR                "Crosshair Settings"
#define CVAR_GROUP_SBAR                     "Status Bar and Scoreboard"
#define CVAR_GROUP_SERVER_BROWSER           "Server Browser"
#define CVAR_GROUP_NETWORK                  "Network Settings"
#define CVAR_GROUP_INPUT_MISC               "Input - Misc"
#define CVAR_GROUP_INPUT_MOUSE              "Input - Mouse"
#define CVAR_GROUP_INPUT_KEYBOARD           "Input - Keyboard"
#define CVAR_GROUP_INPUT_JOYSTICK           "Input - Joystick"
#define CVAR_GROUP_SOUND                    "Sound Settings"
#define CVAR_GROUP_VIDEO                    "Video Settings"
#define CVAR_GROUP_SYSTEM_SETTINGS          "System Settings"
#define CVAR_GROUP_OPENGL                   "OpenGL Rendering"
#define CVAR_GROUP_TEXTURES                 "Texture Settings"
#define CVAR_GROUP_VIEWMODEL                "Weapon View Model Settings"
#define CVAR_GROUP_TURB                     "Turbulency and Sky Settings"
#define CVAR_GROUP_LIGHTING                 "Lighting"
#define CVAR_GROUP_PARTICLES                "Particle Effects"
#define CVAR_GROUP_EYECANDY                 "FPS and EyeCandy Settings"
#define CVAR_GROUP_CHAT                     "Chat Settings"
#define CVAR_GROUP_CONSOLE                  "Console Settings"
#define CVAR_GROUP_SKIN                     "Skin Settings"
#define CVAR_GROUP_COMMUNICATION            "Teamplay Communications"

#define CVAR_GROUP_USERINFO                 "Player Settings"
#define CVAR_GROUP_CONFIG                   "Config Management"
#define CVAR_GROUP_HUD                      "MQWCL HUD" // HUD -> hexum

#define CVAR_GROUP_MVD                      "MultiView Demos"
#define CVAR_GROUP_QTV                      "QTV Settings"
#define CVAR_GROUP_MENU                     "Menu"
#define CVAR_GROUP_FILESYSTEM               "File System"

#else   // CVAR_GROUPS_DEFINE_VARIABLES

char *cvar_groups_list[] = {
	CVAR_GROUP_NO_GROUP,
	CVAR_GROUP_SERVER_PERMISSIONS,
	CVAR_GROUP_SERVER_PHYSICS,
	CVAR_GROUP_SERVERINFO,
	CVAR_GROUP_SERVER_MAIN,
	CVAR_GROUP_ITEM_NEED,
	CVAR_GROUP_ITEM_NAMES,
	CVAR_GROUP_SPECTATOR,
	CVAR_GROUP_SCREENSHOTS,
	CVAR_GROUP_DEMO,
	CVAR_GROUP_MATCH_TOOLS,
	CVAR_GROUP_VIEW,
	CVAR_GROUP_BLEND,
	CVAR_GROUP_SCREEN,
	CVAR_GROUP_CROSSHAIR,
	CVAR_GROUP_SBAR,
	CVAR_GROUP_SERVER_BROWSER,
	CVAR_GROUP_NETWORK,
	CVAR_GROUP_INPUT_MISC,
	CVAR_GROUP_INPUT_MOUSE,
	CVAR_GROUP_INPUT_KEYBOARD,
	CVAR_GROUP_INPUT_JOYSTICK,
	CVAR_GROUP_SOUND,
	CVAR_GROUP_VIDEO,
	CVAR_GROUP_SYSTEM_SETTINGS,
	CVAR_GROUP_OPENGL,
	CVAR_GROUP_CONFIG,
	CVAR_GROUP_TEXTURES,
	CVAR_GROUP_VIEWMODEL,
	CVAR_GROUP_TURB,
	CVAR_GROUP_LIGHTING,
	CVAR_GROUP_PARTICLES,
	CVAR_GROUP_EYECANDY,
	CVAR_GROUP_CHAT,
	CVAR_GROUP_CONSOLE,
	CVAR_GROUP_SKIN,
	CVAR_GROUP_COMMUNICATION,
	CVAR_GROUP_USERINFO,
	CVAR_GROUP_HUD,        // HUD -> hexum
	CVAR_GROUP_MVD,
	CVAR_GROUP_QTV,
	CVAR_GROUP_MENU,
	CVAR_GROUP_FILESYSTEM,
	NULL
};

#endif //CVAR_GROUPS_VARIABLES


================================================
FILE: src/demo_controls.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: demo_controls.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "ez_controls.h"
#include "ez_slider.h"
#include "ez_window.h"
#include "ez_label.h"
#include "ez_button.h"
#include "demo_controls.h"

float CL_GetDemoLength(void);
double Demo_GetSpeed(void);
extern cvar_t cl_demospeed;

// The control tree.
static ez_tree_t	democontrol_tree;

// Controls.
static ez_control_t *root;				// Root of the control tree (transparent, as big as the conwidth/height, 
										// just here to be able to get all mouse events on the screen).
static ez_window_t	*window;			// The demo controls window.
static ez_slider_t	*demo_slider;		// The demo time slider.
static ez_label_t	*timelabel;			// The text label that shows the current time.
static ez_label_t	*hover_timelabel;	// The text label that shows the time where the cursor is positioned on the slider.
static ez_label_t	*speed_title_label;	// The title text label for the speed.
static ez_label_t	*speed_label;		// The text label that shows the current demo speed in percent.

static ez_control_t	*button_container;	// A container to easily move all the buttons around together.
static ez_button_t	*fast_button;		// Faster button.
static ez_button_t	*slow_button;		// Slower button.
static ez_button_t	*play_button;		// Play button.
static ez_button_t	*pause_button;		// Pause button.
static ez_button_t	*stop_button;		// Stop button.
//static ez_button_t	*prev_button;		// Play next demo in the playlist.
//static ez_button_t	*next_button;		// Play previous demo in the playlist.

// State.
static qbool slider_updating = false;
static qbool democontrols_on = false;
static double previous_demospeed = 1.0;

static void DemoControls_SetTimeLabelText(ez_label_t *label, double time)
{
	EZ_label_SetText(label, va("%02d:%02d", Q_rint(time / 60), Q_rint((int)time % 60)));
}

static void DemoControls_Destroy(void)
{
	democontrols_on = false;
	key_dest = key_game;
	key_dest_beforecon = key_game;
	EZ_tree_Destroy(&democontrol_tree);
}

void DemoControls_Draw(void)
{
	if (democontrols_on)
	{
		// Position the slider based on the current demo time.
		if (cls.demoplayback)
		{
			float demo_length = CL_GetDemoLength();
			float current_demotime = cls.demotime - demostarttime; // TODO: Make a function for this in cl_demo.c
			
			int pos = Q_rint(demo_slider->max_value * (double)(cls.demotime - demostarttime) / max(1, demo_length));

			DemoControls_SetTimeLabelText(timelabel, current_demotime);

			slider_updating = true;
			EZ_slider_SetPosition(demo_slider, pos);
			slider_updating = false;
		}
		else
		{
			DemoControls_Destroy();
		}
	}

	// Should always be run so that any final cleanup is done on a destroy.
	EZ_tree_EventLoop(&democontrol_tree);
}

static int DemoControls_SliderChanged(ez_control_t *self, void *payload, void *ext_event_info)
{
	ez_slider_t *demo_slider = (ez_slider_t *)self;

	if (!slider_updating)
	{
		float demo_length = CL_GetDemoLength();
		double newdemotime = ((demo_slider->slider_pos * demo_length) / (double)demo_slider->max_value);

		DemoControls_SetTimeLabelText(timelabel, newdemotime);

		CL_Demo_Jump(newdemotime, false, DST_SEEKING_NORMAL);
	}

	return 0;
}

static int DemoControls_Slider_OnMouseEnter(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	EZ_control_SetVisible((ez_control_t *)hover_timelabel, true);
	return 0;
}

static int DemoControls_Slider_OnMouseLeave(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	EZ_control_SetVisible((ez_control_t *)hover_timelabel, false);
	return 0;
}

static int DemoControls_Slider_OnMouseHover(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	ez_slider_t *demo_slider = (ez_slider_t *)self;
	float demo_length = CL_GetDemoLength();
	double demotime = ((EZ_slider_GetPositionFromMouse(demo_slider, ms->x, ms->y) * demo_length) / (double)demo_slider->max_value);

	EZ_control_SetPosition((ez_control_t *)hover_timelabel, (ms->x - self->absolute_x), -8);
	EZ_label_SetText(hover_timelabel, va("%02d:%02d", Q_rint(demotime / 60), max(0, Q_rint((int)demotime % 60))));

	return 0;
}

static void DemoControls_SetSpeedLabel(void)
{
	char label_text[20] = { 0 };

	snprintf(label_text, sizeof(label_text) - 1, "%4i%%", Q_rint(Demo_GetSpeed() * 100));

	EZ_label_SetText(speed_label, label_text);
}

static void DemoControls_SetDemoSpeed(double speed)
{
	speed = bound(0.0, speed, 10.0);

	if (speed != previous_demospeed)
	{
		previous_demospeed = Demo_GetSpeed();
	}

	Cvar_SetValue(&cl_demospeed, speed);
	DemoControls_SetSpeedLabel();
}

static int DemoControls_SpeedButton_OnMouseClick(ez_control_t *self, void *payload, mouse_state_t *ms)
{	
	float delta = (self == ((ez_control_t *)fast_button)) ? 0.1 : -0.1;	
	
	DemoControls_SetDemoSpeed(cl_demospeed.value + delta);
	
	return 1;
}

static int DemoControls_PlayButton_OnMouseClick(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	if ((previous_demospeed != 0.0) && (Demo_GetSpeed() == 0.0))
	{
		DemoControls_SetDemoSpeed(previous_demospeed);
	}
	else
	{
		// We're not paused so just reset the speed when clicking the play button.
		DemoControls_SetDemoSpeed(1.0);
	}
	
	return 1;
}

static int DemoControls_PauseButton_OnMouseClick(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	DemoControls_SetDemoSpeed(0.0);	
	return 1;
}

static int DemoControls_StopButton_OnMouseClick(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	Cbuf_AddText("disconnect\n");
	DemoControls_Destroy();
	return 1;
}

// TODO: Fade these gradually instead.
static int DemoControls_Window_OnMouseEnter(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	EZ_control_SetOpacity(self, 1.0);
	return 0;
}

static int DemoControls_Window_OnMouseLeave(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	EZ_control_SetOpacity(self, 0.5);
	return 0;
}

static int DemoControls_Window_OnCloseClick(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	DemoControls_Destroy();
	return 0;
}

static void DemoControls_Init(void)
{
	#define DEMO_BUTTON_GAP		5
	#define DEMO_BUTTON_HEIGHT	16
	#define DEMO_BUTTON_WIDTH	24

	// Root.
	{
		root = EZ_control_Create(&democontrol_tree, NULL, "Root", "", 0, 0, vid.conwidth, vid.conheight, 0);
	}

	// Demo time slider.
	{
		demo_slider = EZ_slider_Create(&democontrol_tree, root, 
			"Demo slider", "", 5, 5, 8, 8, control_focusable | control_contained);

		EZ_control_SetAnchor((ez_control_t *)demo_slider, anchor_left | anchor_right);
		EZ_slider_SetMax(demo_slider, 1000);

		// Add a event handler for when the slider handle changes position.
		EZ_slider_AddOnSliderPositionChanged(demo_slider, DemoControls_SliderChanged, NULL);
		EZ_control_AddOnMouseHover((ez_control_t *)demo_slider, DemoControls_Slider_OnMouseHover, NULL);
		EZ_control_AddOnMouseEnter((ez_control_t *)demo_slider, DemoControls_Slider_OnMouseEnter, NULL);
		EZ_control_AddOnMouseLeave((ez_control_t *)demo_slider, DemoControls_Slider_OnMouseLeave, NULL);

		// When we click a point on the slider, make the slider handle jump there.
		EZ_slider_SetJumpToClick(demo_slider, true);
	}

	// Demo time label.
	{
		timelabel = EZ_label_Create(&democontrol_tree, root, 
			"Demo time label", "", -15, 5, 40, 16,  
			control_focusable | control_contained | control_resizeable, 
			0, "");

		EZ_label_SetReadOnly(timelabel, true);
		EZ_label_SetTextSelectable(timelabel, false);
		EZ_control_SetAnchor((ez_control_t *)timelabel, anchor_right | anchor_top);
	}

	// Demo hover time label (when the slider is hovered).
	{
		ez_control_t *tmp;
		hover_timelabel = EZ_label_Create(&democontrol_tree, (ez_control_t *)demo_slider, 
			"Hover demo time label", "", 0, 0, 40, 8, 0, 0, "");

		tmp = (ez_control_t *)hover_timelabel;

		EZ_label_SetReadOnly(hover_timelabel, true);
		EZ_label_SetTextSelectable(hover_timelabel, false);
		EZ_label_SetTextColor(hover_timelabel, 125, 125, 0, 255);
		EZ_control_SetAnchor(tmp, anchor_left | anchor_top);
		EZ_control_SetVisible(tmp, false);
		EZ_control_SetContained(tmp, false);
		EZ_control_SetBackgroundColor(tmp, 0, 0, 0, 125);
		EZ_control_SetFocusable(tmp, false);
	}

	// Demo speed title label.
	{
		speed_title_label = EZ_label_Create(&democontrol_tree, root, 
			"Demo speed title label", "", -(15 + 32), 15, 64, 16,
			control_contained | control_resizeable, 
			0, "");

		EZ_label_SetAutoSize(speed_title_label, true);
		EZ_label_SetText(speed_title_label, "Speed:");
		EZ_label_SetTextColor(speed_title_label, 255, 150, 0, 255);
		EZ_label_SetReadOnly(speed_title_label, true);
		EZ_label_SetTextSelectable(speed_title_label, false);
		EZ_control_SetAnchor((ez_control_t *)speed_title_label, anchor_right | anchor_top);
	}

	// Demo speed label.
	{
		speed_label = EZ_label_Create(&democontrol_tree, root, 
			"Demo speed label", "", -7, 15, 32, 16,
			control_contained | control_resizeable, 
			0, "");

		EZ_label_SetAutoSize(speed_label, true);
		DemoControls_SetSpeedLabel();
		EZ_label_SetReadOnly(speed_label, true);
		EZ_label_SetTextSelectable(speed_label, false);
		EZ_control_SetAnchor((ez_control_t *)speed_label, anchor_right | anchor_top);
	}

	// Buttons.
	{
		// Button container.
		{
			button_container = EZ_control_Create(&democontrol_tree, root, 
				"Demo button container", NULL, 10, 25, 200, 16, control_contained | control_focusable);

			EZ_control_SetAnchor(button_container, anchor_left | anchor_right);
		}		

		// Slower button.
		{
			slow_button = EZ_button_Create(&democontrol_tree, button_container,
				"Slower button", "Slows down demo playback", 0, 0, DEMO_BUTTON_WIDTH, DEMO_BUTTON_HEIGHT, control_contained);

			EZ_button_SetTextAlignment(slow_button, middle_center);
			EZ_button_SetText(slow_button, " <<");
			EZ_control_SetAnchor((ez_control_t *)slow_button, anchor_top);
			EZ_control_AddOnMouseClick((ez_control_t *)slow_button, DemoControls_SpeedButton_OnMouseClick, NULL);
		}

		// Play button.
		{
			play_button = EZ_button_Create(&democontrol_tree, button_container,
				"Play button", "Starts demo playback or resets it to normal speed", 
				(DEMO_BUTTON_WIDTH + DEMO_BUTTON_GAP), 0, 
				DEMO_BUTTON_WIDTH, DEMO_BUTTON_HEIGHT, control_contained);

			EZ_button_SetTextAlignment(play_button, middle_center);
			EZ_button_SetText(play_button, " >");
			EZ_control_SetAnchor((ez_control_t *)play_button, anchor_top);
			EZ_control_AddOnMouseClick((ez_control_t *)play_button, DemoControls_PlayButton_OnMouseClick, NULL);
		}

		// Pause button.
		{
			pause_button = EZ_button_Create(&democontrol_tree, button_container,
				"Pause button", "Pauses demo playback", 
				2 * (DEMO_BUTTON_WIDTH + DEMO_BUTTON_GAP), 0, 
				DEMO_BUTTON_WIDTH, DEMO_BUTTON_HEIGHT, control_contained);

			EZ_button_SetTextAlignment(pause_button, middle_center);
			EZ_button_SetText(pause_button, " ||");
			EZ_control_SetAnchor((ez_control_t *)pause_button, anchor_top);
			EZ_control_AddOnMouseClick((ez_control_t *)pause_button, DemoControls_PauseButton_OnMouseClick, NULL);
		}

		// Stop button.
		{
			stop_button = EZ_button_Create(&democontrol_tree, button_container,
				"Stop button", "Stop demo playback", 
				3 * (DEMO_BUTTON_WIDTH + DEMO_BUTTON_GAP), 0, 
				DEMO_BUTTON_WIDTH, DEMO_BUTTON_HEIGHT, control_contained);

			EZ_button_SetTextAlignment(stop_button, middle_center);
			EZ_button_SetText(stop_button, " []");
			EZ_control_SetAnchor((ez_control_t *)stop_button, anchor_top);
			EZ_control_AddOnMouseClick((ez_control_t *)stop_button, DemoControls_StopButton_OnMouseClick, NULL);
		}

		// Faster button.
		{
			fast_button = EZ_button_Create(&democontrol_tree, button_container,
				"Faster button", "Speeds up demo playback", 
				4 * (DEMO_BUTTON_WIDTH + DEMO_BUTTON_GAP), 0, 24, 16, control_contained);

			EZ_button_SetTextAlignment(fast_button, middle_center);
			EZ_button_SetText(fast_button, " >>");
			EZ_control_SetAnchor((ez_control_t *)fast_button, anchor_top);
			EZ_control_AddOnMouseClick((ez_control_t *)fast_button, DemoControls_SpeedButton_OnMouseClick, NULL);
		}
	}

	// Window.
	{
		window = EZ_window_Create(&democontrol_tree, root, 
			"Demo controls window", NULL, 50, (vid.conheight - 100), 250, 100, control_resize_h | control_resize_v);
		EZ_control_SetBackgroundColor((ez_control_t *)window, 0, 0, 0, 150);

		EZ_control_AddOnMouseEnter((ez_control_t *)window, DemoControls_Window_OnMouseEnter, NULL);
		EZ_control_AddOnMouseLeave((ez_control_t *)window, DemoControls_Window_OnMouseLeave, NULL);

		// Add our precious children :D		
		EZ_window_AddChild(window, (ez_control_t *)demo_slider);
		EZ_window_AddChild(window, (ez_control_t *)timelabel);
		EZ_window_AddChild(window, (ez_control_t *)speed_title_label);
		EZ_window_AddChild(window, (ez_control_t *)speed_label);
		EZ_window_AddChild(window, (ez_control_t *)button_container);

		// Size the children to fit within the window properly.
		EZ_control_SetSize((ez_control_t *)demo_slider, (window->window_area->virtual_width - 64), 8);
		EZ_control_SetSize((ez_control_t *)button_container, (window->window_area->virtual_width - 20), button_container->height);

		// Enable the window close button.
		EZ_control_AddOnMouseClick((ez_control_t *)window->close_button, DemoControls_Window_OnCloseClick, NULL);
	}

	// Make sure all the controls are properly position and sized.
	EZ_tree_Refresh(&democontrol_tree);

	key_dest = key_demo_controls;
}

qbool DemoControls_MouseEvent(mouse_state_t *ms)
{
	return EZ_tree_MouseEvent(&democontrol_tree, ms);
}

static void DemoControls_Toggle(void)
{
	democontrols_on = !democontrols_on;

	if (democontrols_on)
	{
		DemoControls_Init();
	}
	else
	{
		key_dest = key_game;
		key_dest_beforecon = key_game;
		DemoControls_Destroy();
	}
}

qbool DemoControls_KeyEvent(int key, int unichar, qbool down)
{
	switch (key)
	{
		case K_ESCAPE :
			DemoControls_Destroy();
			return true;
	}

	return EZ_tree_KeyEvent(&democontrol_tree, key, unichar, down);
}

void DemoControls_f(void)
{
	if (!cls.demoplayback && !democontrols_on)
	{
		Com_Printf("Error: not playing a demo\n");
		return;
	}

	DemoControls_Toggle();
}



================================================
FILE: src/demo_controls.h
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: demo_controls.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

void DemoControls_Draw(void);
qbool DemoControls_MouseEvent(mouse_state_t *ms);
qbool DemoControls_KeyEvent(int key, int unichar, qbool down);
void DemoControls_f(void);




================================================
FILE: src/demo_spawnwarn.c
================================================
/*
 * Copyright (C) 2026 Oscar Linderholm <osm@recv.se>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include "quakedef.h"
#include "demo_spawnwarn.h"

#define MAX_DEMO_SPAWNWARN_POINTS 128

static const double demo_spawnwarn_ignore_duration = 1.0;
static const vec3_t demo_spawnwarn_touch_mins = { -16, -16, -24 };
static const vec3_t demo_spawnwarn_touch_maxs = { 16, 16, 32 };

typedef struct
{
	char classname[MAX_COM_TOKEN];
	char target[MAX_COM_TOKEN];
	char targetname[MAX_COM_TOKEN];
	vec3_t origin;
	qbool has_origin;
	qbool has_target;
	qbool has_targetname;
} demo_spawnwarn_entity_t;

typedef struct
{
	char targetname[MAX_COM_TOKEN];
	vec3_t origin;
} demo_spawnwarn_teleport_destination_t;

typedef struct
{
	char target[MAX_COM_TOKEN];
} demo_spawnwarn_teleport_trigger_t;

static vec3_t cl_spawnwarn_points[MAX_DEMO_SPAWNWARN_POINTS];
static int cl_num_spawnwarn_points;
static qbool cl_spawnwarn_active;
static double cl_spawnwarn_warning_suppressed_until;
static qbool cl_spawnwarn_point_overflow_warned;

cvar_t demo_spawnwarn = { "demo_spawnwarn", "0" };
cvar_t demo_spawnwarn_text = {
	"demo_spawnwarn_text",
	"you crossed a spawn"
};

extern temp_entity_list_t temp_entities;

static void CL_SpawnWarn_ResetState(void)
{
	memset(cl_spawnwarn_points, 0, sizeof(cl_spawnwarn_points));
	cl_num_spawnwarn_points = 0;
	cl_spawnwarn_active = false;
	cl_spawnwarn_warning_suppressed_until = 0;
	cl_spawnwarn_point_overflow_warned = false;
}

static qbool CL_SpawnWarn_ParseEntityOrigin(const char *value, vec3_t origin)
{
	return sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]) == 3;
}

static void CL_SpawnWarn_WarnOverflow(void)
{
	if (!cl_spawnwarn_point_overflow_warned)
	{
		Con_Printf("demo_spawnwarn: too many points on map, limit is %d\n",
			MAX_DEMO_SPAWNWARN_POINTS);
		cl_spawnwarn_point_overflow_warned = true;
	}
}

static void CL_SpawnWarn_AddPoint(const vec3_t origin)
{
	int point_index;

	if (cl_num_spawnwarn_points >= MAX_DEMO_SPAWNWARN_POINTS)
	{
		CL_SpawnWarn_WarnOverflow();
		return;
	}

	point_index = cl_num_spawnwarn_points++;
	VectorCopy(origin, cl_spawnwarn_points[point_index]);
}

static void CL_SpawnWarn_ClearEntity(demo_spawnwarn_entity_t *entity)
{
	memset(entity, 0, sizeof(*entity));
}

static void CL_SpawnWarn_AddTeleportTrigger(
	const char *target,
	demo_spawnwarn_teleport_trigger_t triggers[],
	int *num_triggers)
{
	int trigger_index;

	if (*num_triggers >= MAX_DEMO_SPAWNWARN_POINTS)
	{
		CL_SpawnWarn_WarnOverflow();
		return;
	}

	trigger_index = *num_triggers;
	strlcpy(triggers[trigger_index].target,
		target,
		sizeof(triggers[trigger_index].target)
	);
	*num_triggers = trigger_index + 1;
}

static void CL_SpawnWarn_AddTeleportDestination(
	const char *targetname,
	const vec3_t origin,
	demo_spawnwarn_teleport_destination_t destinations[],
	int *num_destinations)
{
	int destination_index;

	if (*num_destinations >= MAX_DEMO_SPAWNWARN_POINTS)
	{
		CL_SpawnWarn_WarnOverflow();
		return;
	}

	destination_index = *num_destinations;
	strlcpy(destinations[destination_index].targetname,
		targetname,
		sizeof(destinations[destination_index].targetname));
	VectorCopy(origin, destinations[destination_index].origin);
	*num_destinations = destination_index + 1;
}

static void CL_SpawnWarn_CollectPointData(
	const demo_spawnwarn_entity_t *entity,
	demo_spawnwarn_teleport_trigger_t triggers[],
	int *num_triggers,
	demo_spawnwarn_teleport_destination_t destinations[],
	int *num_destinations)
{
	if (!strcmp(entity->classname, "info_player_deathmatch") && entity->has_origin)
	{
		CL_SpawnWarn_AddPoint(entity->origin);
	}
	else if (!strcmp(entity->classname, "trigger_teleport")
		&& entity->has_target && !entity->has_targetname)
	{
		// Store the trigger target so we can resolve the exit entity
		// later.
		CL_SpawnWarn_AddTeleportTrigger(entity->target, triggers, num_triggers);
	}
	else if (entity->has_targetname && entity->has_origin)
	{
		// Store possible teleport destinations; matching targetname
		// becomes the exit.
		CL_SpawnWarn_AddTeleportDestination(entity->targetname,
			entity->origin,
			destinations,
			num_destinations);
	}
}

static void CL_SpawnWarn_ResolveTeleportExitPoints(
	const demo_spawnwarn_teleport_trigger_t triggers[],
	int num_triggers,
	const demo_spawnwarn_teleport_destination_t destinations[],
	int num_destinations)
{
	int i;

	for (i = 0; i < num_triggers; i++)
	{
		int j;

		for (j = 0; j < num_destinations; j++)
		{
			if (!strcmp(triggers[i].target, destinations[j].targetname))
			{
				CL_SpawnWarn_AddPoint(destinations[j].origin);
				break;
			}
		}
	}
}

static qbool CL_SpawnWarn_ParseEntityBlock(
	const char **data_p,
	demo_spawnwarn_entity_t *entity)
{
	char key[MAX_COM_TOKEN];
	const char *data = *data_p;

	CL_SpawnWarn_ClearEntity(entity);

	while (1)
	{
		data = COM_Parse(data);
		if (!data)
		{
			Con_DPrintf(
				"CL_SpawnWarn_ParseEntityBlock: unexpected end of entity key\n");
			return false;
		}

		if (com_token[0] == '}')
		{
			*data_p = data;
			return true;
		}

		strlcpy(key, com_token, sizeof(key));

		data = COM_Parse(data);
		if (!data)
		{
			Con_DPrintf(
				"CL_SpawnWarn_ParseEntityBlock: unexpected end of entity value\n");
			return false;
		}

		if (!strcmp(key, "classname"))
		{
			strlcpy(entity->classname, com_token, sizeof(entity->classname));
		}
		else if (!strcmp(key, "origin"))
		{
			entity->has_origin = CL_SpawnWarn_ParseEntityOrigin(com_token,
				entity->origin);
		}
		else if (!strcmp(key, "target"))
		{
			entity->has_target = true;
			strlcpy(entity->target, com_token, sizeof(entity->target));
		}
		else if (!strcmp(key, "targetname"))
		{
			entity->has_targetname = true;
			strlcpy(entity->targetname, com_token, sizeof(entity->targetname));
		}
	}
}

static qbool CL_SpawnWarn_ParseEntityLump(const char *entstring)
{
	demo_spawnwarn_teleport_destination_t teleport_destinations[MAX_DEMO_SPAWNWARN_POINTS];
	demo_spawnwarn_teleport_trigger_t teleport_triggers[MAX_DEMO_SPAWNWARN_POINTS];
	const char *data;
	int num_teleport_destinations = 0;
	int num_teleport_triggers = 0;

	if (!entstring || !entstring[0])
	{
		return true;
	}

	data = entstring;
	while ((data = COM_Parse(data)) != NULL)
	{
		demo_spawnwarn_entity_t entity;

		if (com_token[0] != '{')
		{
			Con_DPrintf("CL_SpawnWarn_ParseEntityLump: found %s when expecting {\n",
				com_token);
			CL_SpawnWarn_ResetState();
			return false;
		}

		if (!CL_SpawnWarn_ParseEntityBlock(&data, &entity))
		{
			CL_SpawnWarn_ResetState();
			return false;
		}

		CL_SpawnWarn_CollectPointData(&entity,
			teleport_triggers,
			&num_teleport_triggers,
			teleport_destinations,
			&num_teleport_destinations);
	}

	CL_SpawnWarn_ResolveTeleportExitPoints(teleport_triggers,
		num_teleport_triggers,
		teleport_destinations,
		num_teleport_destinations);

	return true;
}

void CL_SpawnWarn_LoadPoints(void)
{
	CL_SpawnWarn_ResetState();

	if (!cls.demoplayback)
	{
		return;
	}

	CL_SpawnWarn_ParseEntityLump(CM_EntityString());
}

static qbool CL_SpawnWarn_BoxesTouch(
	const vec3_t absmin1,
	const vec3_t absmax1,
	const vec3_t absmin2,
	const vec3_t absmax2)
{
	return !(absmin1[0] > absmax2[0] || absmin1[1] > absmax2[1]
		|| absmin1[2] > absmax2[2]
		|| absmax1[0] < absmin2[0] || absmax1[1] < absmin2[1]
		|| absmax1[2] < absmin2[2]);
}

static void CL_SpawnWarn_CheckTeleportSuppression(double current_time)
{
	int i;

	for (i = 0; i < MAX_TEMP_ENTITIES; i++)
	{
		temp_entity_t *temp = &temp_entities.list[i];
		vec3_t teleport_absmin, teleport_absmax, player_absmin, player_absmax;

		if (temp->type != TE_TELEPORT
			|| current_time - temp->time > demo_spawnwarn_ignore_duration)
		{
			continue;
		}

		VectorAdd(temp->pos, demo_spawnwarn_touch_mins, teleport_absmin);
		VectorAdd(temp->pos, demo_spawnwarn_touch_maxs, teleport_absmax);
		VectorAdd(cl.simorg, demo_spawnwarn_touch_mins, player_absmin);
		VectorAdd(cl.simorg, demo_spawnwarn_touch_maxs, player_absmax);

		if (CL_SpawnWarn_BoxesTouch(teleport_absmin,
			teleport_absmax,
			player_absmin,
			player_absmax))
		{
			CL_SpawnWarn_SuppressAfterTeleport();
		}
	}
}

static void CL_SpawnWarn_SuppressWarning(void)
{
	if (!cls.demoplayback)
	{
		return;
	}

	cl_spawnwarn_warning_suppressed_until = max(
		cl_spawnwarn_warning_suppressed_until,
		cls.demotime + demo_spawnwarn_ignore_duration);
}

void CL_SpawnWarn_ClearPoints(void)
{
	CL_SpawnWarn_ResetState();
}

void CL_SpawnWarn_SuppressAfterRespawn(void)
{
	CL_SpawnWarn_SuppressWarning();
}

void CL_SpawnWarn_SuppressAfterTeleport(void)
{
	CL_SpawnWarn_SuppressWarning();
}

void CL_SpawnWarn_UpdateWarning(void)
{
	qbool any_spawn_triggered = false;
	double current_time = cls.demotime;
	int i;

	if (!cls.demoplayback)
	{
		return;
	}

	if (!demo_spawnwarn.integer)
	{
		return;
	}

	if (cl.stats[STAT_HEALTH] <= 0)
	{
		return;
	}

	CL_SpawnWarn_CheckTeleportSuppression(current_time);

	if (current_time < cl_spawnwarn_warning_suppressed_until)
	{
		cl_spawnwarn_active = false;
		return;
	}

	for (i = 0; i < cl_num_spawnwarn_points; i++)
	{
		vec3_t spawn_absmin, spawn_absmax, player_absmin, player_absmax;

		VectorAdd(cl_spawnwarn_points[i], demo_spawnwarn_touch_mins, spawn_absmin);
		VectorAdd(cl_spawnwarn_points[i], demo_spawnwarn_touch_maxs, spawn_absmax);
		VectorAdd(cl.simorg, demo_spawnwarn_touch_mins, player_absmin);
		VectorAdd(cl.simorg, demo_spawnwarn_touch_maxs, player_absmax);

		if (CL_SpawnWarn_BoxesTouch(spawn_absmin,
			spawn_absmax,
			player_absmin,
			player_absmax))
		{
			any_spawn_triggered = true;
		}
	}

	if (any_spawn_triggered && !cl_spawnwarn_active)
	{
		SCR_CenterPrint(demo_spawnwarn_text.string);
		cl_spawnwarn_active = true;
	}
	else if (!any_spawn_triggered)
	{
		cl_spawnwarn_active = false;
	}
}


================================================
FILE: src/demo_spawnwarn.h
================================================
/*
 * Copyright (C) 2026 Oscar Linderholm <osm@recv.se>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifndef EZQUAKE_DEMO_SPAWNWARN_H
#define EZQUAKE_DEMO_SPAWNWARN_H

#include "cvar.h"

extern cvar_t demo_spawnwarn;
extern cvar_t demo_spawnwarn_text;

void CL_SpawnWarn_ClearPoints(void);
void CL_SpawnWarn_LoadPoints(void);
void CL_SpawnWarn_UpdateWarning(void);
void CL_SpawnWarn_SuppressAfterRespawn(void);
void CL_SpawnWarn_SuppressAfterTeleport(void);

#endif


================================================
FILE: src/document_rendering.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"


// document constants
#define DOCUMENT_INDENT     2


#define LINE_MAX_LEN    512

#include "expat.h"
#include "xsd.h"
#include "document_rendering.h"

typedef struct document_rendering_context_s
{
    // current buffer status
    int     line;
    int     line_pos;
    byte    *buf;
    int     nocopy;
    int     nometadata;
    int     width;

    // link table
    document_rendered_link_t *links;
    document_rendered_link_t *inline_links; // current inline links

    // section table
    document_rendered_section_t *sections;
    document_rendered_section_t *current_section;

    // where last blank line was added
    int     last_blank;

    // visual settings
    int     l_margin;
    int     r_margin;

    // shared line buffer
    char line_buf[LINE_MAX_LEN];

    // some state markers
    int     list_count;
    document_align_t align;
    int     do_color;
}
document_rendering_context_t;


char * Add_Inline_Tag(document_rendering_context_t *cx, char *text, document_tag_t *tag);
char *Add_Inline_String(char *text, char *string);
static void RenderBlockChain(document_rendering_context_t *cx, document_tag_t *tag);





// check if given tag is a block rather than inline
static int IsBlockElement(document_tag_t *tag)
{
    switch (tag->type)
    {
    case tag_section:
    case tag_p:
    case tag_list:
    case tag_dict:
    case tag_hr:
    case tag_pre:
    case tag_h:
        return 1;

    default:
        return 0;
    }
}

// finish current line and add it to the buffer
static void LineFeed(document_rendering_context_t *cx)
{
    if (cx->line_pos != cx->l_margin)
    {
        // check alignment
        if (cx->align != align_left)
        {
            int l, r;
            int offset;

            l = cx->l_margin;
            r = cx->width - cx->r_margin;
            while ((cx->line_buf[r-1] == 0  ||  cx->line_buf[r-1] == ' ')  &&
                r > l)
                r--;

            offset = 0;
            if (cx->align == align_right)
            {
                offset = cx->width-cx->r_margin-r;
            }
            if (cx->align == align_center)
            {
                offset = (cx->width-cx->r_margin-cx->l_margin - (r - l)) / 2;
            }

            if (offset)
            {
                document_rendered_link_t *l;

                memmove(cx->line_buf+offset, cx->line_buf, r);
                memset(cx->line_buf, 0, offset);

                // change links
                l = cx->inline_links;
                while (l)
                {
                    if (l->start >= cx->line*cx->width  &&  l->start < (cx->line+1)*cx->width)
                        l->start += offset;
                    if (l->end >= cx->line*cx->width  &&  l->end < (cx->line+1)*cx->width)
                        l->end += offset;

                    l = l->next;
                }
            }
        }

        // copy to buffer
        if (!cx->nocopy)
            memcpy(cx->buf + cx->line*cx->width, cx->line_buf, cx->width);

        // manage state variables
        cx->line ++;
        memset(cx->line_buf, 0, LINE_MAX_LEN);
        cx->line_pos = cx->l_margin;
    }
}

// add blank line, checking if there aren't any already
static void AddBlankLine(document_rendering_context_t *cx)
{
//    int i;

    // do not add blank as the first line
    if (cx->line == 0)
        goto skip;

    // check if previous line is not blank
    if (cx->line-1 == cx->last_blank)
        goto skip;

    // add line
    memset(cx->line_buf, 0, LINE_MAX_LEN);
    cx->last_blank = cx->line;
    cx->line ++;

skip:

    cx->line_pos = cx->l_margin;
}

// add link to the inline link table
static void AddInlineLink(document_rendering_context_t *cx, document_rendered_link_t *link)
{
    if (cx->nometadata)
    {
        Q_free(link);
    }
    else
    {
        document_rendered_link_t *last;

        last = cx->inline_links;

        if (last == NULL)
            cx->inline_links = link;
        else
        {
            while (last->next)
                last = last->next;
            last->next = link;
        }
    }
}

// strip spaces from inline text, making links working
char * StripInlineSpaces(char *str, document_rendered_link_t *links)
{
    int cut = 0;

    char *buf, *ret;
    int p=0, q=0;

    if (str == NULL)
        return str;

    buf = (char *) Q_malloc(strlen(str)+1);
    for (p=0; p < strlen(str); p++)
    {
        // offset links
        document_rendered_link_t *l = links;
        while (l)
        {
            if (l->start == p)
                l->start -= cut;
            if (l->end == p)
                l->end -= cut;

            l = l->next;
        }

        if (XSD_IsSpace(str[p]))
        {
            if (q == 0  ||  XSD_IsSpace(buf[q-1]))
                cut++;
            else
            {
                // add this char, but replace with pure space
                buf[q++] = ' ';
            }
        }
        else
            buf[q++] = str[p];
    }

    // strip spaces from the end
    while (q > 0  &&  XSD_IsSpace(buf[q-1]))
        q--;
    buf[q] = 0;

	ret = (char *) Q_strdup(buf);
    Q_free(buf);
    Q_free(str);
    return ret;
}

static char ChangeColor(char c)
{
    char low = c & 127;

    if (low > ' '  &&  low <= '~')
        return c ^ 128;

    return c;
}

static void Render_String(document_rendering_context_t *cx, char *text)
{
    int l;
    char c;
    document_rendered_link_t *link;

    char *txt = text;
    int t_width = cx->width - cx->l_margin - cx->r_margin;

    if (t_width < 8)    // witdth of text
        return;

    if (txt == NULL)
        return;

    // make links negative
    link = cx->inline_links;
    while (link)
    {
        link->start *= -1;
        link->end *= -1;
        link = link->next;
    }

    while ((c = *txt))
    {
        // count word length
        for (l=0 ; l < t_width; l++)
            if (isspace2(txt[l]) || txt[l]=='\n'+(char)128  ||  !txt[l])
                break;

        // word wrap
        if (l != t_width && (cx->line_pos + l > cx->width - cx->r_margin) )
            LineFeed(cx);

        // recalculate links indexes to absolute
        link = cx->inline_links;
        while (link)
        {
            int i = txt - text;

            if (link->start <= 0  &&  i >= -link->start)
                link->start = cx->line*cx->width + cx->line_pos;
            if (link->end <= 0  &&  i >= -link->end)
                link->end = cx->line*cx->width + cx->line_pos;
            link = link->next;
        }
        
        txt++;

        switch (c)
        {
        case (char)('\n' | 128):
            LineFeed(cx);
            break;

        case (char)(' ' | 128):
            cx->line_buf[cx->line_pos++] = ' ';
            break;

        default:
            cx->line_buf[cx->line_pos++] = c;
        }

        if (cx->line_pos >= cx->width - cx->r_margin)
        {
            LineFeed(cx);

            // we linefeed because of no space, so skip spaces which are next
            while (isspace2(*txt))
                txt++;
        }
    }
    LineFeed(cx);

    // add inline links to document links
    if (cx->links == NULL)
        cx->links = cx->inline_links;
    else
    {
        link = cx->links;
        while (link->next)
            link = link->next;
        link->next = cx->inline_links;
    }
    cx->inline_links = NULL;
}

// render P tag
static void Render_P(document_rendering_context_t *cx, document_tag_p_t *p)
{
    document_align_t old_align = cx->align;
    cx->align = p->align;

    if (p->indent)
    {
        cx->l_margin += DOCUMENT_INDENT;
        AddBlankLine(cx);
    }

    RenderBlockChain(cx, p->tags);

    if (p->indent)
    {
        cx->l_margin -= DOCUMENT_INDENT;
        AddBlankLine(cx);
    }

    cx->align = old_align;
}

// render Section tag
static void Render_Section(document_rendering_context_t *cx, document_tag_section_t *p)
{
    if (p->indent)
    {
        cx->l_margin += DOCUMENT_INDENT;
        AddBlankLine(cx);
    }

    RenderBlockChain(cx, p->tags);

    if (p->indent)
    {
        cx->l_margin -= DOCUMENT_INDENT;
        AddBlankLine(cx);
    }
}

// render H tag
static void Render_H(document_rendering_context_t *cx, document_tag_h_t *h)
{
    document_align_t old_align;
    int old_do_color;
    
    old_align = cx->align;
    cx->align = h->align;

    old_do_color = cx->do_color;
    cx->do_color = 1;

    RenderBlockChain(cx, h->tags);

    cx->do_color = old_do_color;
    cx->align = old_align;
}

// render PRE tag
static void Render_Pre(document_rendering_context_t *cx, document_tag_pre_t *pre)
{
    int     l_width, width;
    char    *text, *s, *d;
    
    if (!pre->text)
        return;

    // duplicate text and calculate width
    width = l_width = 0;
    s = pre->text;
    d = text = (char *) Q_malloc(strlen(s)+1);
    while (*s)
    {
        char c = *s++;

        // skip LF and TAB
        if (c == '\r'  ||  c == '\t')
            continue;

        // copy character to output
        *d++ = c=='\n' ? (char)('\n' + 128) : c;

        // check line width
        if (c == '\n')
        {
            if (l_width > width)
                width = l_width;
            l_width = 0;
        }
        else
        {
            l_width++;
        }
    }
    *d = 0;

    // check if our render context width allow for such image
    if (width <= cx->width - cx->l_margin - cx->r_margin - 1)
    {
        // render inline

        document_align_t align;
        int offset;

        // remporarily disable alignment, because we use our own
        align = cx->align;
        cx->align = align_left;

        // calculate alignment offset
        switch (align)
        {
        default:
        case align_left:
            offset = 0;
            break;
        case align_right:
            offset = cx->width - cx->l_margin - cx->r_margin - width - 1;
            break;
        case align_center:
            offset = (cx->width - cx->l_margin - cx->r_margin - width - 1) / 2;
            break;
        }

        cx->l_margin += offset;
        AddBlankLine(cx);
        Render_String(cx, text);

        cx->l_margin -= offset;
        AddBlankLine(cx);

        cx->align = align;
    }
    else
    {
        // render as link

        char *t = Q_strdup("");

        t = Add_Inline_String(t, "\x90");
        t = Add_Inline_String(t, pre->alt ? pre->alt : "picture");
        t = Add_Inline_String(t, "\x91");

        Render_String(cx, t);

        Q_free(t);
    }

    Q_free(text);
}

// render HR tag
static void Render_Hr(document_rendering_context_t *cx, document_tag_hr_t *hr)
{
    int i;

    document_align_t old_align = cx->align;
    cx->align = align_center;

    AddBlankLine(cx);

    cx->line_buf[cx->line_pos++] = 29;
    for (i=0; i < (cx->width - cx->l_margin - cx->r_margin) / 2; i++)
        cx->line_buf[cx->line_pos++] = 30;
    cx->line_buf[cx->line_pos++] = 31;

    LineFeed(cx);

    AddBlankLine(cx);

    cx->align = old_align;
}

// render LIST tag
static void Render_List(document_rendering_context_t *cx, document_tag_list_t *list)
{
    char separator[128];
    int indent;
    document_tag_li_t *item;
    int item_num;
    int num_width = 0;

    // first check, how much indentation we should use
    indent = 2;
    if (list->separator != list_separator_none)
        indent++;
    switch (list->bullet)
    {
    case list_bullet_none:
        break;

    case list_bullet_dot:
    case list_bullet_letter:
    case list_bullet_bigletter:
        indent++;
        break;

    case list_bullet_number:
        {
            // count list size
            item_num = 0;
            item = list->items;
            while (item)
            {
                item_num++;
                item = (document_tag_li_t *) item->next;
            }
            if (item_num == 0)
                break;
            num_width = log10(item_num) + 1;
            indent += num_width;
        }
    }

    cx->list_count++;
    cx->l_margin += indent;
    AddBlankLine(cx);

    item = list->items;
    item_num = 1;

    while (item)
    {
        // make separator
        strlcpy (separator, " ", sizeof (separator));
        switch (list->bullet)
        {
        case list_bullet_none:
            break;
        case list_bullet_dot:
            strlcat (separator, va("%c", (cx->list_count%2) ? 143 : 15), sizeof (separator));
            break;
        case list_bullet_letter:
            strlcat(separator, va("%c", (item_num % ('z'-'a'+1)) + 'a'), sizeof (separator));
            break;
        case list_bullet_bigletter:
            strlcat(separator, va("%c", (item_num % ('Z'-'A'+1)) + 'A'), sizeof (separator));
            break;
        case list_bullet_number:
            strlcat(separator, va("%*d", num_width, item_num), sizeof (separator));
            break;
        }
        switch (list->separator)
        {
        case list_separator_none:
            break;
        case list_separator_dot:
            strlcat(separator, ".", sizeof (separator));
            break;
        case list_separator_par:
            strlcat(separator, ")", sizeof (separator));
            break;
        }
        strlcat(separator, " ", sizeof (separator));

        memcpy(cx->line_buf + (cx->l_margin - indent), separator, strlen(separator));
        RenderBlockChain(cx, item->tags);

        item_num++;
        item = (document_tag_li_t *) item->next;
    }

    cx->l_margin -= indent;
    AddBlankLine(cx);
    cx->list_count--;
}

// render LIST tag
static void Render_Dict(document_rendering_context_t *cx, document_tag_dict_t *dict)
{
    char separator[128];
    int indent;
    document_tag_di_t *item;
    int item_num;
    int num_width = 0;

    // first check, how much indentation we should use
    indent = 2;
    if (dict->separator != list_separator_none)
        indent++;
    switch (dict->bullet)
    {
    case list_bullet_none:
        break;

    case list_bullet_dot:
    case list_bullet_letter:
    case list_bullet_bigletter:
        indent++;
        break;

    case list_bullet_number:
        {
            // count dict size
            item_num = 0;
            item = dict->items;
            while (item)
            {
                item_num++;
                item = (document_tag_di_t *) item->next;
            }
            if (item_num == 0)
                break;
            num_width = log10(item_num) + 1;
            indent += num_width;
        }
    }

    cx->list_count++;
    cx->l_margin += indent;
    AddBlankLine(cx);

    item = dict->items;
    item_num = 1;

    while (item)
    {
        int old_do_color;

        // make separator
        strlcpy(separator, " ", sizeof (separator));
        switch (dict->bullet)
        {
        case list_bullet_none:
            break;
        case list_bullet_dot:
            strlcat(separator, va("%c", (cx->list_count%2) ? 143 : 15), sizeof (separator));
            break;
        case list_bullet_letter:
            strlcat(separator, va("%c", (item_num % ('z'-'a'+1)) + 'a'), sizeof (separator));
            break;
        case list_bullet_bigletter:
            strlcat(separator, va("%c", (item_num % ('Z'-'A'+1)) + 'A'), sizeof (separator));
            break;
        case list_bullet_number:
            strlcat(separator, va("%*d", num_width, item_num), sizeof (separator));
            break;
        }
        switch (dict->separator)
        {
        case list_separator_none:
            break;
        case list_separator_dot:
            strlcat(separator, ".", sizeof (separator));
            break;
        case list_separator_par:
            strlcat(separator, ")", sizeof (separator));
            break;
        }
        strlcat(separator, " ", sizeof (separator));

        memcpy(cx->line_buf + (cx->l_margin - indent), separator, strlen(separator));
        old_do_color = cx->do_color;
        cx->do_color = 1;
        RenderBlockChain(cx, item->name);
        cx->do_color = old_do_color;

        // render description
        cx->l_margin += 2;
        AddBlankLine(cx);
        RenderBlockChain(cx, item->description);
        cx->l_margin -= 2;
        AddBlankLine(cx);

        item_num++;
        item = (document_tag_di_t *) item->next;
    }

    cx->l_margin -= indent;
    AddBlankLine(cx);
    cx->list_count--;
}


// adds string
char *Add_Inline_String (char *text, char *string)
{
	size_t size = strlen (text) + strlen (string) + 1;
    char *buf = (char *) Q_malloc (size);
    strlcpy (buf, text, size);
    Q_free(text);
    strlcat (buf, string, size);
    return buf;
}

// adds text element
char *Add_Inline_Text (document_rendering_context_t *cx, char *text, document_tag_text_t *tag)
{
	char *s, *d;
	char *buf;
	size_t size;

	size = strlen (text) + strlen (tag->text) + 1;
	buf = (char *) Q_malloc (size);
	strlcpy (buf, text, size);
	Q_free (text);

	d = buf + strlen(buf);
	s = tag->text;

	while (*s)
	{
		char c = *s++;

		if (cx->do_color)
			c = ChangeColor(c);

		*d++ = c;
	}

	*d = 0;

	return buf;
}

// adds EM element
char * Add_Inline_Em(document_rendering_context_t *cx, char *text, document_tag_em_t *tag)
{
    text = Add_Inline_String(text, "_");
    text = Add_Inline_Tag(cx, text, tag->tags);
    text = Add_Inline_String(text, "_");
    return text;
}

// adds COLOR element
char * Add_Inline_Color(document_rendering_context_t *cx, char *text, document_tag_color_t *tag)
{
    int old_do_color = cx->do_color;
    cx->do_color = true;

    text = Add_Inline_Tag(cx, text, tag->tags);

    cx->do_color = old_do_color;
    return text;
}

// adds A element
char * Add_Inline_A(document_rendering_context_t *cx, char *text, document_tag_a_t *tag)
{
    // create new link object
    document_rendered_link_t *link;

    link = (document_rendered_link_t *) Q_malloc(sizeof(document_rendered_link_t));
    memset(link, 0, sizeof(document_rendered_link_t));

    link->tag = tag;
    link->start = strlen(text) + 1;

    text = Add_Inline_String(text, "\x90");
    text = Add_Inline_Tag(cx, text, tag->tags);
    text = Add_Inline_String(text, "\x91");

    link->end = strlen(text) - 1;
    AddInlineLink(cx, link);

    return text;
}

// adds IMG element
char * Add_Inline_Img(document_rendering_context_t *cx, char *text, document_tag_img_t *tag)
{
    text = Add_Inline_String(text, "\x90");
    text = Add_Inline_Tag(cx, text, tag->tags);
    text = Add_Inline_String(text, "\x91");
    return text;
}

// adds BR element
char * Add_Inline_Br(document_rendering_context_t *cx, char *text, document_tag_br_t *tag)
{
    text = Add_Inline_String(text, va("%c", '\n' | 128));
    return text;
}

// adds SP element
char * Add_Inline_Sp(document_rendering_context_t *cx, char *text, document_tag_sp_t *tag)
{
    text = Add_Inline_String(text, va("%c", ' ' | 128));
    return text;
}

// add inline element
char * Add_Inline_Tag(document_rendering_context_t *cx, char *text, document_tag_t *tag)
{
    if (tag == NULL)
        return text;

    switch (tag->type)
    {
    case tag_text:
        text = Add_Inline_Text(cx, text, (document_tag_text_t *) tag);
        break;

    case tag_em:
        text = Add_Inline_Em(cx, text, (document_tag_em_t *) tag);
        break;

    case tag_color:
        text = Add_Inline_Color(cx, text, (document_tag_color_t *) tag);
        break;

    case tag_a:
        text = Add_Inline_A(cx, text, (document_tag_a_t *) tag);
        break;

    case tag_img:
        text = Add_Inline_Img(cx, text, (document_tag_img_t *) tag);
        break;

    case tag_br:
        text = Add_Inline_Br(cx, text, (document_tag_br_t *) tag);
        break;

    case tag_sp:
        text = Add_Inline_Sp(cx, text, (document_tag_sp_t *) tag);
        break;

    case tag_di:
    case tag_dict:
    case tag_h:
    case tag_hr:
    case tag_li:
    case tag_list:
    case tag_p:
    case tag_pre:
    case tag_section:
	/* TODO */
	break;
    }

    return text;
}

// renders inline chain, stops at first non-inline tag and returns this tag
static document_tag_t * RenderInlineChain(document_rendering_context_t *cx, document_tag_t *tag)
{
    char *text = Q_strdup("");

    while (tag && !IsBlockElement(tag))
    {
        text = Add_Inline_Tag(cx, text, tag);

        tag = tag->next;
    }

    text = StripInlineSpaces(text, cx->inline_links);
    Render_String(cx, text);
    LineFeed(cx);

    Q_free(text);

    return tag;
}

// render block chain
static void RenderBlockChain(document_rendering_context_t *cx, document_tag_t *tag)
{
    while (tag)
    {
        document_tag_t *next = tag->next;

        AddBlankLine(cx);

        if (IsBlockElement(tag))
        {
            // process tag with appropiate renderer
            switch (tag->type)
            {
            case tag_section:
                Render_Section(cx, (document_tag_section_t *) tag);
                break;

            case tag_p:
                Render_P(cx, (document_tag_p_t *) tag);
                break;

            case tag_list:
                Render_List(cx, (document_tag_list_t *) tag);
                break;

            case tag_dict:
                Render_Dict(cx, (document_tag_dict_t *) tag);
                break;

            case tag_hr:
                Render_Hr(cx, (document_tag_hr_t *) tag);
                break;

            case tag_pre:
                Render_Pre(cx, (document_tag_pre_t *) tag);
                break;

            case tag_h:
                Render_H(cx, (document_tag_h_t *) tag);
                break;

            default:    // skip this tag
                break;
            }
        }
        else
        {
            next = RenderInlineChain(cx, tag);
        }

        AddBlankLine(cx);

        tag = next;
    }
}

// renders document into memory buffer,
// returns total lines processed,
// with nocopy=true does not affect output buffer (it may be NULL),
// which may be used for calculating needed buffer size
static int XSD_RenderDocumentOnce(xml_document_t *doc, byte *buf, int width, int lines,
                                  document_rendered_link_t **link, document_rendered_section_t **section)
{
    document_rendering_context_t context;

//    int i;
//    int l;
//    int total_lines = 0;
//    qbool first = true;
//    document_tag_p_t *tag = (document_tag_p_t *) doc->content;
//    byte line[1024];

    memset(&context, 0, sizeof(context));
    context.buf = buf;
    context.line = 0;
    context.line_pos = 0;
    context.nocopy = lines==0 ? 1 : 0;
    context.nometadata = link==NULL  ||  section==NULL;
    context.last_blank = -1;

    context.l_margin = 0;
    context.r_margin = 0;
    context.width = width;

    context.list_count = 0;
    context.align = align_left;
    context.do_color = 0;

    memset(context.line_buf, 0, LINE_MAX_LEN);

    // zero the buffer
    if (lines > 0)
        memset(buf, 0, lines * width);

    RenderBlockChain(&context, doc->content);

    // skip last blank line
    if (context.line - 1 == context.last_blank)
        context.line--;

    // set links
    if (!context.nometadata)
    {
        *link = context.links;
        *section = context.sections;
    }

    return context.line;
}

// renders document into memory buffer,
int XSD_RenderDocument(document_rendered_t *ret, xml_document_t *doc, int width)
{
    int lines;

    memset(ret, 0, sizeof(document_rendered_t));

    // render document title
    if (doc->title)
    {
        int lines;
        document_tag_text_t *text;
        document_tag_p_t *p;
        xml_document_t *tdoc;

        tdoc = XSD_Document_New();

        // create p tag
        p = (document_tag_p_t *) Q_malloc(sizeof(document_tag_p_t));
        memset(p, 0, sizeof(document_tag_p_t));
        p->type = tag_p;
        p->align = align_center;

        tdoc->content = (document_tag_t *) p;

        // create text tag
        text = (document_tag_text_t *) Q_malloc(sizeof(document_tag_text_t));
        memset(text, 0, sizeof(document_tag_text_t));
        text->type = tag_text;
        text->text = Q_strdup(doc->title);

        p->tags = (document_tag_t *) text;

        lines = XSD_RenderDocumentOnce(tdoc, NULL, width, 0, NULL, NULL);
        if (lines > 0)
        {
            ret->title = (char *) Q_malloc(lines*width);
	    ret->title_lines = XSD_RenderDocumentOnce(tdoc,(byte *) ret->title, width, lines, NULL, NULL);
        }

        XSD_Document_Free((xml_t *)tdoc);
    }

    // render document body
    lines = XSD_RenderDocumentOnce(doc, NULL, width, 0, NULL, NULL);
    if (lines <= 0)
        goto error;
    ret->text = (char *) Q_malloc(lines*width);
    ret->text_lines = XSD_RenderDocumentOnce(doc,(byte *) ret->text, width, lines, &ret->links, &ret->sections);
    return 1;

error:
    XSD_RenderClear(ret);
    return 0;
}

void RenderFreeSection(document_rendered_section_t *section)
{
    document_rendered_section_t *next;

    if (section == NULL)
        return;

    while (section)
    {
        next = section->next;

        RenderFreeSection(section->children);
        Q_free(section);

        section = next;
    }
}

// free rendered document
void XSD_RenderClear(document_rendered_t *r)
{
    document_rendered_link_t *link, *next;

    if (r->text)
        Q_free(r->text);
    if (r->title)
        Q_free(r->title);
    
    link = r->links;
    while (link)
    {
        next = link->next;

        Q_free(link);
        link = next;
    }

    RenderFreeSection(r->sections);
}


================================================
FILE: src/document_rendering.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __DOCUMENT_RENDERING_H__
#define __DOCUMENT_RENDERING_H__


typedef struct document_rendered_link_s
{
    int start;
    int end;
    document_tag_a_t *tag;

    struct document_rendered_link_s *next;
}
document_rendered_link_t;

typedef struct document_rendered_section_s
{
    int start;
    document_tag_section_t *tag;

    struct document_rendered_section_s *children;
    struct document_rendered_section_s *next;
}
document_rendered_section_t;


typedef struct document_renered_s
{
    // head
    char *title;
    int title_lines;

    // body
    char *text;
    int text_lines;

    // metadata
    document_rendered_link_t *links;
    document_rendered_section_t *sections;
}
document_rendered_t;

// renders document into memory buffer,
 int XSD_RenderDocument(document_rendered_t *r, xml_document_t *doc, int width);

// free rendered document
void XSD_RenderClear(document_rendered_t *);




#endif // __DOCUMENT_RENDERING_H__


================================================
FILE: src/draw.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// draw.h -- these are the only functions outside the refresh allowed
// to touch the vid buffer

#ifndef __DRAW_H__
#define __DRAW_H__

typedef struct
{
	int          width, height;
	texture_ref  texnum;
	float        sl, tl, sh, th;
} mpic_t;

typedef enum {
	CACHEPIC_PAUSE,
	CACHEPIC_LOADING,
	CACHEPIC_BOX_TL,
	CACHEPIC_BOX_ML,
	CACHEPIC_BOX_BL,
	CACHEPIC_BOX_TM,
	CACHEPIC_BOX_MM,
	CACHEPIC_BOX_MM2,
	CACHEPIC_BOX_BM,
	CACHEPIC_BOX_TR,
	CACHEPIC_BOX_MR,
	CACHEPIC_BOX_BR,
	CACHEPIC_TTL_MAIN,
	CACHEPIC_MAINMENU,
	CACHEPIC_MENUDOT1,
	CACHEPIC_MENUDOT2,
	CACHEPIC_MENUDOT3,
	CACHEPIC_MENUDOT4,
	CACHEPIC_MENUDOT5,
	CACHEPIC_MENUDOT6,
	CACHEPIC_TTL_SGL,
	CACHEPIC_QPLAQUE,
	CACHEPIC_SP_MENU,
	CACHEPIC_P_LOAD,
	CACHEPIC_P_SAVE,
	CACHEPIC_P_MULTI,
	CACHEPIC_RANKING,
	CACHEPIC_COMPLETE,
	CACHEPIC_INTER,
	CACHEPIC_FINALE,

	CACHEPIC_NUM_OF_PICS
} cache_pic_id_t;

void Draw_AdjustConback (void);

extern	mpic_t		*draw_disc;	// also used on sbar

#define MCHARSET_PATH "gfx/mcharset.png"

typedef int color_t;

extern const color_t COLOR_WHITE;

color_t RGBA_TO_COLOR(byte r, byte g, byte b, byte a);
color_t RGBAVECT_TO_COLOR(byte rgba[4]);
color_t RGBAVECT_TO_COLOR_PREMULT(byte rgba[4]);
color_t RGBAVECT_TO_COLOR_PREMULT_SPECIFIC(byte rgba[4], float alpha);
byte* COLOR_TO_RGBA(int i, byte rgba[4]);
byte* COLOR_TO_RGBA_PREMULT(color_t i, byte rgba[4]);
float* COLOR_TO_FLOATVEC_PREMULT(color_t i, float rgba[4]);
void Draw_SetOverallAlpha(float opacity);
float Draw_MultiplyOverallAlpha(float alpha);

void Draw_Init(void);
void Draw_Shutdown(void);
void Draw_Character(float x, float y, int num);
void Draw_CharacterW(float x, float y, wchar num);
float Draw_CharacterWSP(float x, float y, wchar num, float scale, qbool proportional);
void Draw_SubPic(float x, float y, mpic_t *pic, int srcx, int srcy, int width, int height);
void Draw_Pic(float x, float y, mpic_t *pic);
void Draw_TransPic(float x, float y, mpic_t *pic);
void Draw_ConsoleBackground (int lines);
void Draw_BeginDisc(void);
void Draw_EndDisc(void);
void Draw_TileClear(int x, int y, int w, int h);
void Draw_Fill(int x, int y, int w, int h, byte c);
void Draw_FadeScreen(float alpha);

typedef struct clrinfo_s
{
	color_t c;	// Color.
	int i;		// Index when this colors starts.
} clrinfo_t;

typedef enum {
	text_align_left,
	text_align_center,
	text_align_right
} text_alignment_t;

void Draw_AdjustImages(int first, int last, float x_offset);
int Draw_ImagePosition(void);
void Draw_SStringAligned(int x, int y, const char *text, float scale, float alpha, qbool proportional, text_alignment_t align, float max_x);
void Draw_SColoredStringAligned(int x, int y, const char *text, clrinfo_t* color, int color_count, float scale, float alpha, qbool proportional, text_alignment_t align, float max_x);

void Draw_GetBigfontSourceCoords(char c, int char_width, int char_height, int *sx, int *sy);
void Draw_BigString(float x, float y, const char *text, clrinfo_t *color, int color_count, float scale, float alpha, int char_gap);
void Draw_String(float x, float y, const char *str);
void Draw_AlphaString(float x, float y, const char *str, float alpha);
void Draw_Alt_String(float x, float y, const char *str, float scale, qbool proportional);
void Draw_ColoredString(float x, float y, const char *str, int red, qbool proportional);
void Draw_SColoredStringBasic(float x, float y, const char *text, int red, float scale, qbool proportional);
void Draw_ColoredString3(float x, float y, const char *text, clrinfo_t *clr, int clr_cnt, int red);
float Draw_SColoredAlphaString(float x, float y, const char *text, clrinfo_t *color, int color_count, int red, float scale, float alpha, qbool proportional);
void Draw_SAlt_String(float x, float y, const char *text, float scale, qbool proportional);
float Draw_SString(float x, float y, const char *str, float scale, qbool proportional);
float Draw_SStringAlpha(int x, int y, const char* text, float scale, float alpha, qbool proportional);

int Draw_ConsoleString(float x, float y, const wchar *text, clrinfo_t *clr, int clr_cnt, int red, float scale, qbool proportional);
float Draw_StringLengthW(const wchar *text, int length, float scale, qbool proportional);
float Draw_StringLength(const char *text, int length, float scale, qbool proportional);
float Draw_StringLengthColors(const char *text, int length, float scale, qbool proportional);
float Draw_StringLengthColorsByTerminator(const char *text, int length, float scale, qbool proportional, char terminator);
int Draw_CharacterFit(const char* text, float width, float scale, qbool proportional);

mpic_t *Draw_CachePicSafe(const char *path, qbool crash, qbool only24bit);
mpic_t *Draw_CachePic(cache_pic_id_t id);
mpic_t *Draw_CacheWadPic(char *name, int code);
void Draw_Crosshair(void);
void Draw_TextBox(float x, float y, int width, int lines);

float Draw_SCharacterP(float x, float y, int num, float scale, qbool proportional);

void Draw_SCharacter(float x, float y, int num, float scale);
void Draw_SPic(float x, float y, mpic_t *, float scale);
void Draw_FitPic(float x, float y, int fit_width, int fit_height, mpic_t *gl); // Will fit image into given area; will keep it's proportions.
void Draw_FitPicAlpha(float x, float y, int fit_width, int fit_height, mpic_t *gl, float alpha);
void Draw_FitPicAlphaCenter(float x, float y, int fit_width, int fit_height, mpic_t* gl, float alpha);
void Draw_SAlphaPic(float x, float y, mpic_t *, float alpha, float scale);
void Draw_SSubPic(float x, float y, mpic_t *, int srcx, int srcy, int width, int height, float scale);
void Draw_STransPic(float x, float y, mpic_t *, float scale);

void Draw_AlphaPieSlice (int x, int y, float radius, float startangle, float endangle, float thickness, qbool fill, byte c, float alpha);

void Draw_AlphaCircleRGB(float x, float y, float radius, float thickness, qbool fill, color_t color);
void Draw_AlphaCircle(float x, float y, float radius, float thickness, qbool fill, byte c, float alpha);
void Draw_AlphaCircleOutlineRGB(float x, float y, float radius, float thickness, color_t color);
void Draw_AlphaCircleOutline(float x, float y, float radius, float thickness, byte color, float alpha);
void Draw_AlphaCircleFillRGB(float x, float y, float radius, color_t color);
void Draw_AlphaCircleFill(float x, float y, float radius, byte color, float alpha);

void Draw_AlphaLineRGB(float x_start, float y_start, float x_end, float y_end, float thickness, color_t color);
void Draw_AlphaLine(float x_start, float y_start, float x_end, float y_end, float thickness, byte c, float alpha);

void Draw_AlphaFill(float x, float y, float w, float h, byte c, float alpha);
void Draw_AlphaRectangleRGB(float x, float y, float w, float h, float thickness, qbool fill, color_t color);
void Draw_AlphaFillRGB(float x, float y, float w, float h, color_t color);

void Draw_AlphaSubPic(float x, float y, mpic_t *pic, int srcx, int srcy, int width, int height, float alpha);
void Draw_SAlphaSubPic(float x, float y, mpic_t *pic, int src_x, int src_y, int src_width, int src_height, float scale, float alpha);
void Draw_SAlphaSubPic2(float x, float y, mpic_t *pic, int src_x, int src_y, int src_width, int src_height, float scale_x, float scale_y, float alpha);
void Draw_AlphaPic(float x, float y, mpic_t *pic, float alpha);
void Draw_2dAlphaTexture(float x, float y, float width, float height, texture_ref texture_num, float alpha);

qbool R_CharAvailable (wchar num);

void Draw_EnableScissorRectangle(float x, float y, float width, float height);
void Draw_EnableScissor(float left, float right, float top, float bottom);
void Draw_DisableScissor(void);

void InitTracker(void);

enum {
	WADPIC_RAM = 0,
	WADPIC_NET,
	WADPIC_TURTLE,
	WADPIC_DISC,
	WADPIC_BACKTILE,
	WADPIC_NUM_0,
	WADPIC_NUM_1,
	WADPIC_NUM_2,
	WADPIC_NUM_3,
	WADPIC_NUM_4,
	WADPIC_NUM_5,
	WADPIC_NUM_6,
	WADPIC_NUM_7,
	WADPIC_NUM_8,
	WADPIC_NUM_9,
	WADPIC_ANUM_0,
	WADPIC_ANUM_1,
	WADPIC_ANUM_2,
	WADPIC_ANUM_3,
	WADPIC_ANUM_4,
	WADPIC_ANUM_5,
	WADPIC_ANUM_6,
	WADPIC_ANUM_7,
	WADPIC_ANUM_8,
	WADPIC_ANUM_9,
	WADPIC_NUM_MINUS,
	WADPIC_ANUM_MINUS,
	WADPIC_NUM_COLON,
	WADPIC_NUM_SLASH,
	WADPIC_INV_SHOTGUN,
	WADPIC_INV_SSHOTGUN,
	WADPIC_INV_NAILGUN,
	WADPIC_INV_SNAILGUN,
	WADPIC_INV_RLAUNCH,
	WADPIC_INV_SRLAUNCH,
	WADPIC_INV_LIGHTNG,
	WADPIC_INV2_SHOTGUN,
	WADPIC_INV2_SSHOTGUN,
	WADPIC_INV2_NAILGUN,
	WADPIC_INV2_SNAILGUN,
	WADPIC_INV2_RLAUNCH,
	WADPIC_INV2_SRLAUNCH,
	WADPIC_INV2_LIGHTNG,
	WADPIC_INVA1_SHOTGUN,
	WADPIC_INVA2_SHOTGUN,
	WADPIC_INVA3_SHOTGUN,
	WADPIC_INVA4_SHOTGUN,
	WADPIC_INVA5_SHOTGUN,
	WADPIC_INVA1_SSHOTGUN,
	WADPIC_INVA2_SSHOTGUN,
	WADPIC_INVA3_SSHOTGUN,
	WADPIC_INVA4_SSHOTGUN,
	WADPIC_INVA5_SSHOTGUN,
	WADPIC_INVA1_NAILGUN,
	WADPIC_INVA2_NAILGUN,
	WADPIC_INVA3_NAILGUN,
	WADPIC_INVA4_NAILGUN,
	WADPIC_INVA5_NAILGUN,
	WADPIC_INVA1_SNAILGUN,
	WADPIC_INVA2_SNAILGUN,
	WADPIC_INVA3_SNAILGUN,
	WADPIC_INVA4_SNAILGUN,
	WADPIC_INVA5_SNAILGUN,
	WADPIC_INVA1_RLAUNCH,
	WADPIC_INVA2_RLAUNCH,
	WADPIC_INVA3_RLAUNCH,
	WADPIC_INVA4_RLAUNCH,
	WADPIC_INVA5_RLAUNCH,
	WADPIC_INVA1_SRLAUNCH,
	WADPIC_INVA2_SRLAUNCH,
	WADPIC_INVA3_SRLAUNCH,
	WADPIC_INVA4_SRLAUNCH,
	WADPIC_INVA5_SRLAUNCH,
	WADPIC_INVA1_LIGHTNG,
	WADPIC_INVA2_LIGHTNG,
	WADPIC_INVA3_LIGHTNG,
	WADPIC_INVA4_LIGHTNG,
	WADPIC_INVA5_LIGHTNG,
	WADPIC_SB_SHELLS,
	WADPIC_SB_NAILS,
	WADPIC_SB_ROCKET,
	WADPIC_SB_CELLS,
	WADPIC_SB_ARMOR1,
	WADPIC_SB_ARMOR2,
	WADPIC_SB_ARMOR3,
	WADPIC_SB_KEY1,
	WADPIC_SB_KEY2,
	WADPIC_SB_INVIS,
	WADPIC_SB_INVULN,
	WADPIC_SB_SUIT,
	WADPIC_SB_QUAD,
	WADPIC_SB_SIGIL1,
	WADPIC_SB_SIGIL2,
	WADPIC_SB_SIGIL3,
	WADPIC_SB_SIGIL4,
	WADPIC_SB_FACE1,
	WADPIC_SB_FACE_P1,
	WADPIC_SB_FACE2,
	WADPIC_SB_FACE_P2,
	WADPIC_SB_FACE3,
	WADPIC_SB_FACE_P3,
	WADPIC_SB_FACE4,
	WADPIC_SB_FACE_P4,
	WADPIC_SB_FACE5,
	WADPIC_SB_FACE_P5,
	WADPIC_FACE_INVIS,
	WADPIC_FACE_INVUL2,
	WADPIC_FACE_INV2,
	WADPIC_FACE_QUAD,
	WADPIC_SB_SBAR,
	WADPIC_SB_IBAR,
	WADPIC_SB_SCOREBAR,

	WADPIC_SB_IBAR_AMMO1,
	WADPIC_SB_IBAR_AMMO2,
	WADPIC_SB_IBAR_AMMO3,
	WADPIC_SB_IBAR_AMMO4,

	WADPIC_PIC_COUNT
};

typedef struct wadpic_s {
	char name[32];
	mpic_t* pic;
} wadpic_t;

extern wadpic_t wad_pictures[WADPIC_PIC_COUNT];

void CachePics_CreateAtlas(void);
void CachePics_AtlasFrame(void);
void CachePics_MarkAtlasDirty(void);
void Atlas_SolidTextureCoordinates(texture_ref* ref, float* s, float* t);
qbool Draw_IsConsoleBackground(mpic_t* pic);
qbool Draw_KeepOffAtlas(const char* path);
mpic_t* Mod_SimpleTextureForHint(int model_hint, int skinnum);

#endif // __DRAW_H__


================================================
FILE: src/ez_button.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_scrollpane.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_controls.h"
#include "ez_button.h"

#ifdef _MSC_VER
#pragma warning( disable : 4189 )
#endif

// =========================================================================================
// Button
// =========================================================================================

//
// Button - Recalculates and sets the position of the buttons label.
//
static void EZ_button_RecalculateLabelPosition(ez_button_t *button)
{
	ez_control_t *self				= ((ez_control_t *)button);
	ez_label_t *label				= button->text_label;
	ez_control_t *text_label_ctrl	= ((ez_control_t *)label);
//	ez_textalign_t alignment		= button->text_alignment;
	int new_x						= text_label_ctrl->x;
	int new_y						= text_label_ctrl->y;
	int new_anchor					= EZ_control_GetAnchor(text_label_ctrl);

	// TODO : Hmm, should we even bothered with a special case for text alignment? Why not just use ez_anchor_t stuff? Also remember to add support for middle_top and such.
	switch (button->text_alignment)
	{
		case top_left :
		{
			new_anchor = (anchor_left | anchor_top);
			new_x = 0;
			new_y = 0;
			break;
		}
		case top_right :
		{
			new_anchor = (anchor_right | anchor_top);
			new_x = 0;
			new_y = 0;
			break;
		}
		case top_center :
		{
			new_anchor = anchor_top;
			new_x = Q_rint((self->width  - text_label_ctrl->width) / 2.0);
			new_y = 0;
			break;
		}
		case bottom_left :
		{
			new_anchor = (anchor_left | anchor_bottom);
			new_x = 0;
			new_y = 0;
			break;
		}
		case bottom_right :
		{
			new_anchor = (anchor_right | anchor_bottom);
			new_x = 0;
			new_y = 0;
			break;
		}
		case bottom_center :
		{
			new_anchor = anchor_bottom;
			new_x = Q_rint((self->width  - text_label_ctrl->width) / 2.0);
			new_y = 0;
			break;
		}
		case middle_right :
		{
			new_anchor = anchor_right;
			new_x = 0;
			new_y = Q_rint((self->height - text_label_ctrl->height) / 2.0);
			break;
		}
		case middle_left :
		{
			new_anchor = anchor_left;
			new_x = 0;
			new_y = Q_rint((self->height - text_label_ctrl->height) / 2.0);
			break;
		}
		case middle_center :
		{
			new_anchor = (anchor_left | anchor_top);
			new_x = Q_rint((self->width  - text_label_ctrl->width) / 2.0);
			new_y = Q_rint((self->height - text_label_ctrl->height) / 2.0);
			break;
		}
		default :
			break;
	}

	if (new_anchor != EZ_control_GetAnchor(text_label_ctrl))
	{
		EZ_control_SetAnchor(text_label_ctrl, new_anchor);
	}

	if ((new_x != text_label_ctrl->x) || (new_y != text_label_ctrl->y))
	{
		EZ_control_SetPosition(text_label_ctrl, new_x, new_y);
	}
}

//
// Button - Event handler for the buttons OnTextChanged event.
// 
static int EZ_button_OnLabelTextChanged(ez_control_t *self, void *payload, void *ext_event_info)
{
	ez_button_t *button = NULL;
	
	if ((self->parent == NULL) || (self->parent->CLASS_ID != EZ_BUTTON_ID))
	{
		Sys_Error("EZ_button_OnLabelTextChanged: The buttons text labels parent isn't a button!");
	}
	
	button = (ez_button_t *)self->parent;

	EZ_button_RecalculateLabelPosition(button);

	return 0;
}

//
// Button - Creates a new button and initializes it.
//
ez_button_t *EZ_button_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	ez_button_t *button = NULL;

	// We have to have a tree to add the control to.
	if (!tree)
	{
		return NULL;
	}

	button = (ez_button_t *)Q_malloc(sizeof(ez_button_t));
	memset(button, 0, sizeof(ez_button_t));

	EZ_button_Init(button, tree, parent, name, description, x, y, width, height, flags);
	
	return button;
}

//
// Button - Sets either the background image or color.
//
static void EZ_button_SetColorOrBackground(ez_control_t *self, mpic_t *background, byte *c)
{
	ez_button_t *button = (ez_button_t *)self;

	if (button->ext_flags & button_use_images)
	{
		self->background = background;
	}
	else
	{
		EZ_control_SetBackgroundColor(self, c[0], c[1], c[2], c[3]);
	}
}

//
// Button - Initializes a button.
//
void EZ_button_Init(ez_button_t *button, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	// Initialize the inherited class first.
	EZ_control_Init(&button->super, tree, parent, name, description, x, y, width, height, flags);

	// Initilize the button specific stuff.
	((ez_control_t *)button)->CLASS_ID	= EZ_BUTTON_ID;

	// TODO : Make a default macro for button flags.
	((ez_control_t *)button)->ext_flags	|= (flags | control_focusable | control_contained | control_bg_tile_center | control_bg_tile_edges);

	// Override the draw function.
	CONTROL_REGISTER_EVENT(button, EZ_button_OnDraw, OnDraw, ez_control_t);
	CONTROL_REGISTER_EVENT(button, EZ_button_OnResize, OnResize, ez_control_t);
	CONTROL_REGISTER_EVENT(button, EZ_button_OnMouseClick, OnMouseClick, ez_control_t);
	CONTROL_REGISTER_EVENT(button, EZ_button_OnMouseLeave, OnMouseLeave, ez_control_t);
	CONTROL_REGISTER_EVENT(button, EZ_button_OnMouseEnter, OnMouseEnter, ez_control_t);	
	CONTROL_REGISTER_EVENT(button, EZ_button_OnMouseDown, OnMouseDown, ez_control_t);
	CONTROL_REGISTER_EVENT(button, EZ_button_OnMouseUp, OnMouseUp, ez_control_t);	

	// Button specific events.
	CONTROL_REGISTER_EVENT(button, EZ_button_OnAction, OnAction, ez_button_t);
	CONTROL_REGISTER_EVENT(button, EZ_button_OnTextAlignmentChanged, OnTextAlignmentChanged, ez_button_t);
	CONTROL_REGISTER_EVENT(button, EZ_button_OnToggled, OnToggled, ez_button_t);

	// Create the buttons text label.
	{
		button->text_label = EZ_label_Create(tree, (ez_control_t *)button, "Button text label", "", button->padding_left, button->padding_top, 1, 1, 0, 0, "");

		EZ_label_AddOnTextChanged(button->text_label, EZ_button_OnLabelTextChanged, NULL);

		// Don't allow any interaction with the label, it's just there to show text.
		EZ_label_SetReadOnly(button->text_label, true);
		EZ_label_SetTextSelectable(button->text_label, false);
		EZ_label_SetAutoSize(button->text_label, true);
		EZ_control_SetIgnoreMouse((ez_control_t *)button->text_label, true);
		EZ_control_SetFocusable((ez_control_t *)button->text_label, false);
		EZ_control_SetMovable((ez_control_t *)button->text_label, false);

		CONTROL_RAISE_EVENT(NULL, ((ez_control_t *)button), ez_control_t, OnResize, NULL);
	}

	EZ_button_SetNormalImage(button, EZ_BUTTON_DEFAULT_NORMAL_IMAGE);
	EZ_button_SetHoverImage(button, EZ_BUTTON_DEFAULT_HOVER_IMAGE);
	EZ_button_SetPressedImage(button, EZ_BUTTON_DEFAULT_PRESSED_IMAGE);
	EZ_button_SetToggledHoverImage(button, EZ_BUTTON_DEFAULT_PRESSED_HOVER_IMAGE);

	button->ext_flags |= button_use_images;

	EZ_button_SetColorOrBackground((ez_control_t *)button, button->normal_image, button->color_normal);
}

//
// Button - Destroys the button.
//
void EZ_button_Destroy(ez_control_t *self, qbool destroy_children)
{
	ez_button_t *button = (ez_button_t *)self;
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDestroy, destroy_children);

	EZ_control_Destroy(&button->super, destroy_children);

	EZ_eventhandler_Remove(button->event_handlers.OnAction, NULL, true);
	EZ_eventhandler_Remove(button->event_handlers.OnTextAlignmentChanged, NULL, true);
}

//
// Button - OnAction event handler.
//
int EZ_button_OnAction(ez_control_t *self, void *ext_event_info)
{
	ez_button_t *button = (ez_button_t *)self;
	CONTROL_EVENT_HANDLER_CALL(NULL, button, ez_button_t, OnAction, NULL);

	return 0;
}

//
// Button - OnResize event handler.
//
int EZ_button_OnResize(ez_control_t *self, void *ext_event_info)
{
	ez_button_t *button = (ez_button_t *)self;

	// Run the super class implementation.
	EZ_control_OnResize(self, NULL);

	EZ_button_RecalculateLabelPosition(button);

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnResize, NULL);

	return 0;
}

//
// Button - Use images for the button?
//
void EZ_button_SetUseImages(ez_button_t *button, qbool useimages)
{
	SET_FLAG(button->ext_flags, button_use_images, useimages);
}

//
// Button - Sets if the button is toggleable.
//
void EZ_button_SetToggleable(ez_button_t *button, qbool toggleable)
{
	SET_FLAG(button->ext_flags, button_is_toggleable, toggleable);
}

//
// Button - Gets if the button is toggled.
//
qbool EZ_button_GetIsToggled(ez_button_t *button)
{
	return (button->int_flags & button_toggled);
}

//
// Button - Set the text of the button. 
//
void EZ_button_SetText(ez_button_t *button, const char *text)
{
	EZ_label_SetText(button->text_label, text);
}

//
// Button - Set the text of the button. 
//
void EZ_button_SetTextAlignment(ez_button_t *button, ez_textalign_t text_alignment)
{
	button->text_alignment = text_alignment;

	CONTROL_RAISE_EVENT(NULL, button, ez_button_t, OnTextAlignmentChanged, NULL);
}

//
// Button - Set the event handler for the OnTextAlignmentChanged event.
//
void EZ_button_AddOnTextAlignmentChanged(ez_button_t *button, ez_eventhandler_fp OnTextAlignmentChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(button, EZ_CONTROL_HANDLER, OnTextAlignmentChanged, ez_button_t, OnTextAlignmentChanged, payload);
	CONTROL_RAISE_EVENT(NULL, button, ez_control_t, OnEventHandlerChanged, NULL);
}

// 
// Button - Sets the OnToggled event handler.
//
void EZ_button_AddOnToggled(ez_button_t *button, ez_eventhandler_fp OnToggled, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(button, EZ_CONTROL_HANDLER, OnToggled, ez_button_t, OnToggled, payload);
	CONTROL_RAISE_EVENT(NULL, button, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Button - Set the normal image for the button.
//
void EZ_button_SetNormalImage(ez_button_t *button, const char *normal_image)
{
	button->normal_image = normal_image ? Draw_CachePicSafe(normal_image, false, true) : NULL;
}

//
// Button - Set the hover image for the button.
//
void EZ_button_SetHoverImage(ez_button_t *button, const char *hover_image)
{
	button->hover_image = hover_image ? Draw_CachePicSafe(hover_image, false, true) : NULL;
}

//
// Button - Set the hover image for the button.
//
void EZ_button_SetPressedImage(ez_button_t *button, const char *pressed_image)
{
	button->pressed_image = pressed_image ? Draw_CachePicSafe(pressed_image, false, true) : NULL;
}

//
// Button - Set the hover image for the button when it is toggled.
//
void EZ_button_SetToggledHoverImage(ez_button_t *button, const char *toggled_hover_image)
{
	button->toggled_hover_image = toggled_hover_image ? Draw_CachePicSafe(toggled_hover_image, false, true) : NULL;
}

//
// Button - Sets the normal color of the button.
//
void EZ_button_SetNormalColor(ez_button_t *self, byte r, byte g, byte b, byte alpha)
{
	self->color_normal[0] = r;
	self->color_normal[1] = g;
	self->color_normal[2] = b;
	self->color_normal[3] = alpha;
}

//
// Button - Sets the pressed color of the button.
//
void EZ_button_SetPressedColor(ez_button_t *self, byte r, byte g, byte b, byte alpha)
{
	self->color_pressed[0] = r;
	self->color_pressed[1] = g;
	self->color_pressed[2] = b;
	self->color_pressed[3] = alpha;
}

//
// Button - Sets the hover color of the button.
//
void EZ_button_SetHoverColor(ez_button_t *self, byte r, byte g, byte b, byte alpha)
{
	self->color_hover[0] = r;
	self->color_hover[1] = g;
	self->color_hover[2] = b;
	self->color_hover[3] = alpha;
}

//
// Button - Sets the toggled hover color of the button.
//
void EZ_button_SetToggledHoverColor(ez_button_t *self, byte r, byte g, byte b, byte alpha)
{
	self->color_toggled_hover[0] = r;
	self->color_toggled_hover[1] = g;
	self->color_toggled_hover[2] = b;
	self->color_toggled_hover[3] = alpha;
}

//
// Button - Sets the focused color of the button.
//
void EZ_button_SetFocusedColor(ez_button_t *self, byte r, byte g, byte b, byte alpha)
{
	self->color_focused[0] = r;
	self->color_focused[1] = g;
	self->color_focused[2] = b;
	self->color_focused[3] = alpha;
}

//
// Button - Sets the OnAction event handler.
//
void EZ_button_AddOnAction(ez_button_t *self, ez_eventhandler_fp OnAction, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnAction, ez_button_t, OnAction, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Button - OnDraw event.
//
int EZ_button_OnDraw(ez_control_t *self, void *ext_event_info)
{
	ez_button_t *button = (ez_button_t *)self;

	int x, y;
	EZ_control_GetDrawingPosition(self, &x, &y);

	// Run the super class's implementation first.
	EZ_control_OnDraw(self, NULL);

	if (self->int_flags & control_focused)
	{
		if (button->ext_flags & button_use_images)
		{
		}
		else
		{
			Draw_AlphaRectangleRGB(x, y, self->width, self->height, 1, false, RGBAVECT_TO_COLOR(button->color_focused));
		}
	}

	// Draw control specifics.
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDraw, NULL);
	return 0;
}

//
// Button - OnTextAlignmentChanged event.
//
int EZ_button_OnTextAlignmentChanged(ez_control_t *self, void *ext_event_info)
{
	ez_button_t *button = (ez_button_t *)self;

	EZ_button_RecalculateLabelPosition(button);

	CONTROL_EVENT_HANDLER_CALL(NULL, button, ez_button_t, OnTextAlignmentChanged, NULL);
	return 0;
}

//
// Button - OnMouseClick event.
//
int EZ_button_OnMouseClick(ez_control_t *self, mouse_state_t *mouse_state)
{
	int mouse_handled = true;
	ez_button_t *button = (ez_button_t *)self;
	EZ_control_OnMouseClick(self, mouse_state);

	// Toggle the button.
	if (button->ext_flags & button_is_toggleable)
	{
		button->int_flags ^= button_toggled;
		CONTROL_RAISE_EVENT(NULL, button, ez_button_t, OnToggled, NULL);
	}
	else
	{
		button->int_flags &= ~button_toggled;
	}

	CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseClick, mouse_state);
	return mouse_handled;
}

//
// Button - OnToggled event. The button was toggled.
//
int EZ_button_OnToggled(ez_control_t *self, void *ext_event_info)
{
	ez_button_t *button = (ez_button_t *)self;

	// Set the background based on the new state.
	if (button->int_flags & button_toggled)
	{
		EZ_button_SetColorOrBackground(self, button->pressed_image, button->color_pressed);
	}
	else
	{
		EZ_button_SetColorOrBackground(self, button->normal_image, button->color_normal);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, button, ez_button_t, OnToggled, NULL);
	return 0;
}

//
// Button - OnMouseEnter event.
//
int EZ_button_OnMouseEnter(ez_control_t *self, mouse_state_t *mouse_state)
{
	ez_button_t *button = (ez_button_t *)self;
	EZ_control_OnMouseEnter(self, mouse_state);

	// Set the background based on the new state.
	if (button->int_flags & button_toggled)
	{
		EZ_button_SetColorOrBackground(self, button->toggled_hover_image, button->color_toggled_hover);
	}
	else
	{
		EZ_button_SetColorOrBackground(self, button->hover_image, button->color_hover);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnMouseEnter, NULL);
	return 0;
}

//
// Button - OnMouseLeave event.
//
int EZ_button_OnMouseLeave(ez_control_t *self, mouse_state_t *mouse_state)
{
	ez_button_t *button = (ez_button_t *)self;
	EZ_control_OnMouseLeave(self, mouse_state);

	// Set the background based on the new state.
	if (button->int_flags & button_toggled)
	{
		EZ_button_SetColorOrBackground(self, button->pressed_image, button->color_pressed);
	}
	else
	{
		EZ_button_SetColorOrBackground(self, button->normal_image, button->color_normal);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, button, ez_control_t, OnMouseLeave, NULL);
	return 0;
}

//
// Button - OnMouseDown event.
//
int EZ_button_OnMouseDown(ez_control_t *self, mouse_state_t *mouse_state)
{
	ez_button_t *button = (ez_button_t *)self;
	EZ_control_OnMouseDown(self, mouse_state);

	EZ_button_SetColorOrBackground(self, button->toggled_hover_image, button->color_toggled_hover);

	CONTROL_EVENT_HANDLER_CALL(NULL, button, ez_control_t, OnMouseDown, NULL);
	return 1;
}

//
// Button - OnMouseDown event.
//
int EZ_button_OnMouseUp(ez_control_t *self, mouse_state_t *mouse_state)
{
	ez_button_t *button = (ez_button_t *)self;
	EZ_control_OnMouseUp(self, mouse_state);

	if (!(button->ext_flags & button_is_toggleable))
	{
		EZ_button_SetColorOrBackground(self, button->hover_image, button->color_hover);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, button, ez_control_t, OnMouseUp, NULL);
	return 1;
}




================================================
FILE: src/ez_button.h
================================================

#ifndef __EZ_BUTTON_H__
#define __EZ_BUTTON_H__
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_button.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

#include "ez_controls.h"
#include "ez_label.h"

// =========================================================================================
// Button
// =========================================================================================

#define EZ_BUTTON_DEFAULT_NORMAL_IMAGE			"gfx/ui/ez_button_normal"
#define EZ_BUTTON_DEFAULT_HOVER_IMAGE			"gfx/ui/ez_button_hover"
#define EZ_BUTTON_DEFAULT_PRESSED_IMAGE			"gfx/ui/ez_button_pressed"
#define EZ_BUTTON_DEFAULT_PRESSED_HOVER_IMAGE	"gfx/ui/ez_button_pressed_hover"

typedef struct ez_button_eventcount_s
{
	int	OnAction;
	int	OnTextAlignmentChanged;
	int OnToggled;
} ez_button_eventcount_t;

typedef struct ez_button_events_s
{
	ez_event_fp	OnAction;				// The event that's raised when the button is clicked / activated via a button.
	ez_event_fp	OnTextAlignmentChanged;	// Text alignment changed.
	ez_event_fp	OnToggled;				// The button was toggled.
} ez_button_events_t;

typedef struct ez_button_eventhandlers_s
{
	ez_eventhandler_t		*OnAction;
	ez_eventhandler_t		*OnTextAlignmentChanged;
	ez_eventhandler_t		*OnToggled;
} ez_button_eventhandlers_t;

typedef enum ez_button_iflags_e
{
	button_toggled = (1 << 0)
} ez_button_iflags_t;

typedef enum ez_button_flags_e
{
	button_use_images		= (1 << 0),
	button_is_toggleable	= (1 << 1)
} ez_button_flags_t;

typedef enum ez_textalign_e
{
	top_left,
	top_center,
	top_right,
	middle_left,
	middle_center,
	middle_right,
	bottom_left,
	bottom_center,
	bottom_right
} ez_textalign_t;

typedef struct ez_button_s
{
	ez_control_t			super;				// The super class.

	ez_button_events_t		events;				// Specific events for the button control.
	ez_button_eventhandlers_t event_handlers;	// Specific event handlers for the button control.
	ez_button_eventcount_t	inherit_levels;
	ez_button_eventcount_t	override_counts;

	ez_label_t				*text_label;		// The buttons text label.

	mpic_t					*focused_image;		// The image for the button when it is focused.
	mpic_t					*normal_image;		// The normal image used for the button.
	mpic_t					*hover_image;		// The image that is shown for the button when the mouse is over it.
	mpic_t					*pressed_image;		// The image that is shown when the button is pressed.
	mpic_t					*toggled_hover_image; // The image that is shown for the button when the mouse is over it while toggled.

	byte					color_focused[4];	// Color of the focus indicator of the button.
	byte					color_normal[4];	// The normal color of the button.
	byte					color_hover[4];		// Color when the button is hovered.
	byte					color_pressed[4];	// Color when the button is pressed.
	byte					color_toggled_hover[4]; // Color when the button is hovered while toggled.

	ez_button_iflags_t		int_flags;			// Internal flags.
	ez_button_flags_t		ext_flags;			// External flags.

	int						padding_top;
	int						padding_left;
	int						padding_right;
	int						padding_bottom;
	ez_textalign_t			text_alignment;		// Text alignment.
	clrinfo_t				focused_text_color;	// Text color when the button is focused.
	clrinfo_t				normal_text_color;	// Text color when the button is in it's normal state.
	clrinfo_t				hover_text_color;	// Text color when the button is hovered.
	clrinfo_t				pressed_text_color;	// Text color when the button is pressed.

	int						override_count;		// These are needed so that subclasses can override button specific events.
	int						inheritance_level;
} ez_button_t;

//
// Button - Creates a new button and initializes it.
//
ez_button_t *EZ_button_Create(ez_tree_t *tree, ez_control_t *parent, 
							  char *name, char *description, 
							  int x, int y, int width, int height, 
							  ez_control_flags_t flags);

//
// Button - Initializes a button.
//
void EZ_button_Init(ez_button_t *button, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Button - Destroys the button.
//
void EZ_button_Destroy(ez_control_t *self, qbool destroy_children);

//
// Button - OnTextAlignmentChanged event.
//
int EZ_button_OnTextAlignmentChanged(ez_control_t *self, void *ext_event_info);

//
// Button - OnAction event handler.
//
int EZ_button_OnAction(ez_control_t *self, void *ext_event_info);

//
// Button - OnResize event handler.
//
int EZ_button_OnResize(ez_control_t *self, void *ext_event_info);

//
// Button - Use images for the button?
//
void EZ_button_SetUseImages(ez_button_t *button, qbool useimages);

//
// Button - Sets if the button is toggleable.
//
void EZ_button_SetToggleable(ez_button_t *button, qbool toggleable);

//
// Button - Gets if the button is toggled.
//
qbool EZ_button_GetIsToggled(ez_button_t *button);

//
// Button - Set the text of the button. 
//
void EZ_button_SetText(ez_button_t *button, const char *text);

//
// Button - Set the text of the button. 
//
void EZ_button_SetTextAlignment(ez_button_t *button, ez_textalign_t text_alignment);

//
// Button - Set if the edges of the button should be tiled or stretched.
//
void EZ_button_SetTileCenter(ez_button_t *button, qbool tileedges);

//
// Button - Set if the center of the button should be tiled or stretched.
//
void EZ_button_SetTileCenter(ez_button_t *button, qbool tilecenter);

//
// Button - Set the event handler for the OnTextAlignmentChanged event.
//
void EZ_button_AddOnTextAlignmentChanged(ez_button_t *button, ez_eventhandler_fp OnTextAlignmentChanged, void *payload);

//
// Button - Set the normal image for the button.
//
void EZ_button_SetNormalImage(ez_button_t *button, const char *normal_image);

//
// Button - Set the hover image for the button.
//
void EZ_button_SetHoverImage(ez_button_t *button, const char *hover_image);

//
// Button - Set the hover image for the button.
//
void EZ_button_SetPressedImage(ez_button_t *button, const char *pressed_image);

//
// Button - Set the hover image for the button when it is toggled.
//
void EZ_button_SetToggledHoverImage(ez_button_t *button, const char *toggled_hover_image);

// 
// Button - Sets the normal color of the button.
//
void EZ_button_SetNormalColor(ez_button_t *self, byte r, byte g, byte b, byte alpha);

// 
// Button - Sets the pressed color of the button.
//
void EZ_button_SetPressedColor(ez_button_t *self, byte r, byte g, byte b, byte alpha);

// 
// Button - Sets the hover color of the button.
//
void EZ_button_SetHoverColor(ez_button_t *self, byte r, byte g, byte b, byte alpha);

//
// Button - Sets the toggled hover color of the button.
//
void EZ_button_SetToggledHoverColor(ez_button_t *self, byte r, byte g, byte b, byte alpha);

// 
// Button - Sets the focused color of the button.
//
void EZ_button_SetFocusedColor(ez_button_t *self, byte r, byte g, byte b, byte alpha);

// 
// Button - Sets the OnAction event handler.
//
void EZ_button_AddOnAction(ez_button_t *self, ez_eventhandler_fp OnAction, void *payload);

// 
// Button - Sets the OnAction event handler.
//
void EZ_button_AddOnToggled(ez_button_t *self, ez_eventhandler_fp OnToggled, void *payload);

//
// Button - OnDraw event.
//
int EZ_button_OnDraw(ez_control_t *self, void *ext_event_info);

//
// Button - OnMouseClick event.
//
int EZ_button_OnMouseClick(ez_control_t *self, mouse_state_t *mouse_state);

//
// Button - OnToggled event. The button was toggled.
//
int EZ_button_OnToggled(ez_control_t *self, void *ext_event_info);

//
// Button - OnMouseEnter event.
//
int EZ_button_OnMouseEnter(ez_control_t *self, mouse_state_t *mouse_state);

//
// Button - OnMouseLeave event.
//
int EZ_button_OnMouseLeave(ez_control_t *self, mouse_state_t *mouse_state);

//
// Button - OnMouseDown event.
//
int EZ_button_OnMouseDown(ez_control_t *self, mouse_state_t *mouse_state);

//
// Button - OnMouseDown event.
//
int EZ_button_OnMouseUp(ez_control_t *self, mouse_state_t *mouse_state);

#endif // __EZ_BUTTON_H__


================================================
FILE: src/ez_controls.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_controls.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_controls.h"

#ifdef _MSC_VER
#pragma warning( disable : 4189 )
#endif

// =========================================================================================
// Double Linked List
// =========================================================================================

//
// Add item to double linked list.
//
void EZ_double_linked_list_Add(ez_double_linked_list_t *list, void *payload)
{
	ez_dllist_node_t *item = (ez_dllist_node_t *)Q_malloc(sizeof(ez_dllist_node_t));
	memset(item, 0, sizeof(ez_dllist_node_t));

	item->payload = payload;
	item->next = NULL;

	// Add the item to the start of the list if it's empty
	// otherwise add it to the tail.
	if(!list->head)
	{
		list->head = item;
		item->next = NULL;
		item->previous = NULL;
	}
	else
	{
		item->previous = list->tail;
	}

	// Make sure the previous item knows who we are.
	if(item->previous)
	{
		item->previous->next = item;
	}

	list->tail = item;
	list->count++;
}

//
// Finds a given node based on the specified payload.
//
ez_dllist_node_t *EZ_double_linked_list_FindByPayload(const ez_double_linked_list_t *list, const void *payload)
{
	ez_dllist_node_t *iter = list->head;

	while(iter)
	{
		if(iter->payload == payload)
		{
			return iter;
		}

		iter = iter->next;
	}

	return NULL;
}

//
// Double Linked List - Find a item by its index.
//
ez_dllist_node_t *EZ_double_linked_list_FindByIndex(const ez_double_linked_list_t *list, int index)
{
	int i;
	ez_dllist_node_t *iter = NULL;
	qbool fromStart = (list->count - index) >= index;

	if (fromStart)
	{
		iter = list->head;
		
		for (i = 0; i < index; i++)
		{
			iter = iter->next;
		}
	}
	else
	{
		iter = list->tail;
		
		for (i = list->count - 1; i >= index; i--)
		{
			iter = iter->previous;
		}
	}
	
	return iter;
}

//
// Double Linked List - Removes the first occurance of the item from double linked list and returns its payload.
//
void *EZ_double_linked_list_Remove(ez_double_linked_list_t *list, ez_dllist_node_t *item)
{
	void *payload = item->payload;

	if (item->previous)
	{
		item->previous->next = item->next;
	}
	else
	{
		// We removed the first item, so make sure we still have a head.
		list->head = item->next;
	}

	if (item->next)
	{
		item->next->previous = item->previous;
	}
	else if (item->previous)
	{
		// We removed the last item, so make sure we have a tail.
		list->tail = item->previous;
	}

	list->count--;

	Q_free(item);

	return payload; // WARNING THIS MUST BE FREED BY THE CALLER!
}

//
// Double Linked List - Removes an item from a linked list by its index.
//
void *EZ_double_linked_list_RemoveByIndex(ez_double_linked_list_t *list, int index)
{
	ez_dllist_node_t *node;
	
	if ((index < 0) || (index >= list->count))
	{
		return NULL;
	}

	node = EZ_double_linked_list_FindByIndex(list, index);
	return EZ_double_linked_list_Remove(list, node);
}

//
// Double Linked List - Removes a range of items in the list. 
//						A cleanup function needs to be supplied so that the payload of the item is also cleaned up.
//
void EZ_double_linked_list_RemoveRange(ez_double_linked_list_t *list, int start, int end, ez_removerange_cleanup_function_t func)
{
	int i;
	ez_dllist_node_t *iter = list->head;
	ez_dllist_node_t *tmp;

	if (!iter || (start < 0) || (end < 0) || (start >= list->count) || (end >= list->count) || (start > end))
	{
		return;
	}

	// Find the start index.
	for (i = 0; i <= start; i++)
	{
		iter = iter->next;
	}

	// Remove all items until the end.
	for (i = start; i <= end; i++)
	{
		tmp = iter;

		// Run the cleanup function on the current 
		func(EZ_double_linked_list_Remove(list, iter));
		iter = tmp->next;
	}
}

//
// Double Linked List - Removes an item from a linked list by its payload.
//
void *EZ_double_linked_list_RemoveByPayload(ez_double_linked_list_t *list, void *payload)
{
	ez_dllist_node_t *node = EZ_double_linked_list_FindByPayload(list, payload);
	return EZ_double_linked_list_Remove(list, node);
}

typedef void * PVOID;

//
// Double Linked List - Orders a list.
//
void EZ_double_linked_list_Sort(ez_double_linked_list_t *list, PtFuncCompare compare_function)
{
	int i = 0;
	ez_dllist_node_t *iter = NULL;
	PVOID **items = (PVOID **)Q_calloc(list->count, sizeof(PVOID *));

	iter = list->head;

	while(iter)
	{
		items[i] = iter->payload;
		i++;

		iter = iter->next;
	}

	qsort(items, list->count, sizeof(PVOID *), compare_function);

	iter = list->head;

	for(i = 0; i < list->count; i++)
	{
		iter->payload = items[i];
		iter = iter->next;
	}

	Q_free(items);
}

// =========================================================================================
// Control Tree
// =========================================================================================

//
// Control tree -
// Sets the drawing bounds for a control and then calls the function
// recursivly on all it's children. These bounds are used to restrict the drawing
// of all children that should be contained within it's parent, and their children
// to within the bounds of the parent.
//
static void EZ_tree_SetDrawBounds(ez_control_t *control)
{
	ez_dllist_node_t *iter = NULL;
	ez_control_t *child = NULL;
	ez_control_t *p = control->parent;
	qbool contained = control->ext_flags & control_contained;

	// Calculate the controls bounds.
	int top		= control->absolute_y;
	int bottom	= control->absolute_y + control->height;
	int left	= control->absolute_x;
	int right	= control->absolute_x + control->width;

	int p_bound_top		= p ? p->bound_top		: 0;
	int p_bound_bottom	= p ? p->bound_bottom	: 0;
	int p_bound_left	= p ? p->bound_left		: 0;
	int p_bound_right	= p ? p->bound_right	: 0;

	// Change the bounds so that we don't draw over our parents resize handles.
	if (p)
	{
		if (p->ext_flags & control_resize_h)
		{
			p_bound_right	-= p->resize_handle_thickness;
			p_bound_left	+= p->resize_handle_thickness;
		}

		if (p->ext_flags & control_resize_v)
		{
			p_bound_bottom	-= p->resize_handle_thickness;
			p_bound_top		+= p->resize_handle_thickness;
		}
	}

	// If the control has a parent (and should be contained within it's parent), 
	// set the corresponding bound to the parents bound (ex. button), 
	// otherwise use the drawing area of the control as bounds (ex. windows).
	control->bound_top		= (p && contained && (top	 < p_bound_top))		? (p_bound_top)		: top;
	control->bound_bottom	= (p && contained && (bottom > p_bound_bottom))		? (p_bound_bottom)	: bottom;
	control->bound_left		= (p && contained && (left	 < p_bound_left))		? (p_bound_left)	: left;
	control->bound_right	= (p && contained && (right	 > p_bound_right))		? (p_bound_right)	: right;

	// Make sure that the left bounds isn't greater than the right bounds and so on.
	// This would lead to controls being visible in a few incorrect cases.
	clamp(control->bound_top, 0, max(0, control->bound_bottom));
	clamp(control->bound_bottom, control->bound_top, vid.conheight);
	clamp(control->bound_left, 0, max(0, control->bound_right));
	clamp(control->bound_right, control->bound_left, vid.conwidth);

	// Calculate the bounds for the children.
	for (iter = control->children.head; iter; iter = iter->next)
	{
		child = (ez_control_t *)iter->payload;

		// TODO : Probably should some better check for infinte loop here also.
		if (child == control)
		{
			Sys_Error("EZ_tree_SetDrawBounds(): Infinite loop, child is its own parent.\n");
		}

		EZ_tree_SetDrawBounds(child);
	}
}

//
// Control Tree - Draws a control tree.
//
static void EZ_tree_Draw(ez_tree_t *tree)
{
	ez_control_t *payload = NULL;
	ez_dllist_node_t *iter = tree->drawlist.head;

	while (iter)
	{
		payload = (ez_control_t *)iter->payload;

		// TODO : Remove this test stuff.
		/*
		Draw_AlphaRectangleRGB(
			payload->absolute_virtual_x, 
			payload->absolute_virtual_y, 
			payload->virtual_width, 
			payload->virtual_height, 
			1, false, RGBA_TO_COLOR(255, 0, 0, 125));
			*/

		// Don't draw the invisible controls.
		if (!(payload->ext_flags & control_visible) || (payload->int_flags & control_hidden_by_parent))
		{
			iter = iter->next;
			continue;
		}

		// TODO : Remove this test stuff.
		/*
		if (!strcmp(payload->name, "Close button"))
		{
			Draw_String(payload->absolute_virtual_x, payload->absolute_virtual_y - 10, 
				va("x: %i y: %i", payload->x, payload->y));
		}
		*/

		/*
		if (!strcmp(payload->name, "label"))
		{
			Draw_String(payload->absolute_virtual_x, payload->absolute_virtual_y - 10, 
				va("avx: %i avy: %i vx: %i vy %i", 
				payload->absolute_virtual_x, payload->absolute_virtual_y, payload->virtual_x, payload->virtual_y));
		}

		if (!strcasecmp(payload->name, "Child 1"))
		{
			Draw_String(payload->absolute_virtual_x, payload->absolute_virtual_y - 10, 
				va("vw: %i vh: %i w: %i h %i", 
				payload->virtual_width, payload->virtual_height, payload->width, payload->height));
		}
		*/

		/*
		if (!strcasecmp(payload->name, "button"))
		{
			Draw_AlphaLineRGB(payload->bound_left, 0, payload->bound_left, vid.conheight, 1, RGBA_TO_COLOR(255, 0, 0, 255));
			Draw_AlphaLineRGB(payload->bound_right, 0, payload->bound_right, vid.conheight, 1, RGBA_TO_COLOR(255, 0, 0, 255));
		}
		*/

		/*
		if (!strcasecmp(payload->name, "Vertical scrollbar"))
		{
			Draw_String(payload->absolute_virtual_x, payload->absolute_virtual_y - 10, 
				va("b: %i r: %i", payload->bottom_edge_gap, payload->right_edge_gap));
		}
		*/

		/*
		if (!strcmp(payload->name, "Close button") || !strcmp(payload->name, "Window titlebar"))
		{
			Draw_AlphaRectangleRGB(
				payload->absolute_virtual_x, 
				payload->absolute_virtual_y, 
				payload->virtual_width, 
				payload->virtual_height, 
				1, false, RGBA_TO_COLOR(0, 0, 255, 125));
		}
		*/
		
		// Bugfix: Make sure we don't even bother trying to draw something that is completly offscreen
		// it will cause a weird flickering bug because of glScissor.
		if ((payload->bound_left == payload->bound_right) || (payload->bound_top == payload->bound_bottom))
		{
			iter = iter->next;
			continue;
		}

		// Make sure we keep raising Mouse hover events while inside the control.
		if (POINT_IN_CONTROL_DRAWBOUNDS(payload, payload->prev_mouse_state.x, payload->prev_mouse_state.y))
		{
			CONTROL_RAISE_EVENT(NULL, payload, ez_control_t, OnMouseHover, &payload->prev_mouse_state);
		}

		// Make sure that the control draws only within its bounds.
		Draw_EnableScissor(payload->bound_left, payload->bound_right, payload->bound_top, payload->bound_bottom);
		Draw_SetOverallAlpha(payload->overall_opacity);

		// Raise the draw event for the control.
		CONTROL_RAISE_EVENT(NULL, payload, ez_control_t, OnDraw, NULL);

		// Reset the drawing bounds to the entire screen after the control has been drawn.
		Draw_DisableScissor();
		Draw_SetOverallAlpha(1.0);

		iter = iter->next;
	}
}

//
// Control Tree - Checks how long mouse buttons have been pressed.
//
static void EZ_tree_RaiseRepeatedMouseButtonEvents(ez_tree_t *tree)
{
	if (tree->focused_node && tree->focused_node->payload)
	{
		ez_control_t *control = (ez_control_t *)tree->focused_node->payload;

		// Notify controls that are listening to repeat mouse events 
		// if the control's set delay has been reached.
		if (control->ext_flags & control_listen_repeat_mouse)
		{
			int i;
			double now			= Sys_DoubleTime();
			mouse_state_t ms	= tree->prev_mouse_state;
			ms.button_up		= 0;
			
			// Go through all the mouse buttons and compare the time since
			// the mouse buttons where pressed with the controls delay time.
			for (i = 1; i <= 8; i++)
			{
				// Only repeat the mouse click if the button is already down
				// and the repeat isn't set to be all the time.
				if (ms.buttons[i]
				 &&	(control->mouse_repeat_delay > 0.0) && (tree->mouse_pressed_time[i] > 0.0)
				 && ((now - tree->mouse_pressed_time[i]) >= control->mouse_repeat_delay))
				{
					ms.button_down = i;
					CONTROL_RAISE_EVENT(NULL, control, ez_control_t, OnMouseEvent, &ms);
				}
			}
		}
	}
}

//
// Control Tree - Needs to be called every frame to keep the tree alive.
//
void EZ_tree_EventLoop(ez_tree_t *tree)
{
	if (!tree)
	{
		return;
	}

	// We wait with destroying until after all events have run.
	if (tree->destroying)
	{
		EZ_control_Destroy(tree->root, true);
		memset(tree, 0, sizeof(ez_tree_t));
		return;
	}

	if (!tree->root)
	{
		return;
	}

	// Check if it's time to raise any repeat mouse events for controls listening to those.
	EZ_tree_RaiseRepeatedMouseButtonEvents(tree);

	// Calculate the drawing bounds for all the controls in the control tree.
	EZ_tree_SetDrawBounds(tree->root);

	EZ_tree_Draw(tree);
}

//
// Control Tree - Dispatches a mouse event to a control tree.
//
qbool EZ_tree_MouseEvent(ez_tree_t *tree, mouse_state_t *ms)
{
	int mouse_handled = false;
	ez_control_t *control = NULL;
	ez_dllist_node_t *iter = NULL;

	if (!tree)
	{
		Sys_Error("EZ_tree_MouseEvent: NULL tree reference.\n");
	}

	// Save the time that the specified button was last pressed.
	if (ms->button_down || ms->button_up)
	{
		// Set the time for the pressed button.
		if (ms->button_down)
		{
			tree->mouse_pressed_time[ms->button_down] = Sys_DoubleTime();
		}
		else if (ms->button_up)
		{
			tree->mouse_pressed_time[ms->button_up] = 0.0;
		}
	}

	// Save the mouse state so that it can be used when raising
	// repeated mouse click events for controls that wants them.
	tree->prev_mouse_state = *ms;

	// Propagate the mouse event in the opposite order that we drew
	// the controls (Since they are drawn from back to front), so
	// that the foremost control gets it first.
	for (iter = tree->drawlist.tail; iter; iter = iter->previous)
	{
		control = (ez_control_t *)iter->payload;

		// Notify the control of the mouse event.
		CONTROL_RAISE_EVENT(&mouse_handled, control, ez_control_t, OnMouseEvent, ms);

		if (mouse_handled)
		{
			return mouse_handled;
		}
	}

	return mouse_handled;
}

//
// Control Tree - Refreshes the position of all controls in the tree.
//
void EZ_tree_Refresh(ez_tree_t *tree)
{
	if (tree->root)
	{
		ez_dllist_node_t *iter = tree->drawlist.head;
		ez_control_t *payload = NULL;

		//CONTROL_RAISE_EVENT(NULL, (ez_control_t *)tree->root, ez_control_t, OnResize, NULL);
		//CONTROL_RAISE_EVENT(NULL, (ez_control_t *)tree->root, ez_control_t, OnMove, NULL);

		while (iter)
		{
			payload = (ez_control_t *)iter->payload;

			CONTROL_RAISE_EVENT(NULL, payload, ez_control_t, OnResize, NULL);
			CONTROL_RAISE_EVENT(NULL, payload, ez_control_t, OnMove, NULL);
			CONTROL_RAISE_EVENT(NULL, payload, ez_control_t, OnAnchorChanged, NULL);

			iter = iter->next;
		}
	}
}

//
// Control Tree - Moves the focus to the next control in the control tree.
//
void EZ_tree_ChangeFocus(ez_tree_t *tree, qbool next_control)
{
	qbool found = false;
	ez_dllist_node_t *node_iter = NULL;

	if(tree->focused_node)
	{
		node_iter = (next_control) ? tree->focused_node->next : tree->focused_node->previous;

		// Find the next control that can be focused.
		while(node_iter && !found)
		{
			// ez_control_t *ha = (ez_control_t *)node_iter->payload;
			found = EZ_control_SetFocusByNode((ez_control_t *)node_iter->payload, node_iter);
			node_iter = (next_control) ? node_iter->next : node_iter->previous;
		}
	}

	// We haven't found a focusable control yet,
	// or there was no focused control to start with.
	// So search for one from the start/end of the tab list
	// (depending on what direction we're searching in)
	if(!found || !tree->focused_node)
	{
		node_iter = (next_control) ? tree->tablist.head : tree->tablist.tail;

		// Find the next control that can be focused.
		while(node_iter && !found)
		{
			found = EZ_control_SetFocusByNode((ez_control_t *)node_iter->payload, node_iter);
			node_iter = (next_control) ? node_iter->next : node_iter->previous;
		}
	}

	// There is nothing to focus on.
	if(!found)
	{
		tree->focused_node = NULL;
	}
}

//
// Control Tree - Key event.
//
qbool EZ_tree_KeyEvent(ez_tree_t *tree, int key, int unichar, qbool down)
{
	int key_handled = false;
//	ez_control_t *payload = NULL;
//	ez_dllist_node_t *iter = NULL;

	if (!tree)
	{
		Sys_Error("EZ_tree_KeyEvent(): NULL control tree specified.\n");
	}

	if (tree->root && down)
	{
		switch (key)
		{
			case 'k' :
				key_handled = true;
				break;
			case K_TAB :
			{
				// Focus on the next focusable control (TAB)
				// or the previous (Shift + TAB)
				EZ_tree_ChangeFocus(tree, !keydown[K_SHIFT]);
				key_handled = true;
				break;
			}
		}
	}

	// Send key events to the focused control.
	if (tree->focused_node && tree->focused_node->payload)
	{
		CONTROL_RAISE_EVENT(&key_handled, (ez_control_t *)tree->focused_node->payload, ez_control_t, OnKeyEvent, key, unichar, down);
	}

	return key_handled;
}

//
// Control Tree - Finds any orphans and adds them to the root control.
//
void EZ_tree_UnOrphanizeChildren(ez_tree_t *tree)
{
	ez_control_t *payload = NULL;
	ez_dllist_node_t *iter = NULL;

	if(!tree)
	{
		assert(!"EZ_control_UnOrphanizeChildren: No control tree specified.\n");
		return;
	}

	iter = tree->drawlist.head;

	while(iter)
	{
		payload = (ez_control_t *)iter->payload;

		if(!payload->parent && payload != tree->root)
		{
			// The control is an orphan, and not the root control.
			EZ_double_linked_list_Add(&tree->root->children, payload);
		}
		else if(!tree->root)
		{
			// There was no root (should never happen).
			tree->root = payload;
		}

		iter = iter->next;
	}
}

//
// Control Tree - Destroys a tree. Will not free the memory for the tree.
//
void EZ_tree_Destroy(ez_tree_t *tree)
{
	if (!tree)
	{
		return;
	}

	// Make sure we abort all events before we destroy the tree
	// or they might try to read from freed memory. 
	// The actual destruction is done in EZ_tree_EventLoop.
	tree->destroying = true;
}

//
// Control Tree - Order function for the draw list based on the draw_order property.
//
static int EZ_tree_DrawOrderFunc(const void *val1, const void *val2)
{
	const ez_control_t **control1 = (const ez_control_t **)val1;
	const ez_control_t **control2 = (const ez_control_t **)val2;

	return ((*control1)->draw_order - (*control2)->draw_order);
}

//
// Control Tree - Orders the draw list based on the draw order property.
//
void EZ_tree_OrderDrawList(ez_tree_t *tree)
{
	EZ_double_linked_list_Sort(&tree->drawlist, EZ_tree_DrawOrderFunc);
}

//
// Control Tree - Tree Order function for the tab list based on the tab_order property.
//
static int EZ_tree_TabOrderFunc(const void *val1, const void *val2)
{
	const ez_control_t **control1 = (const ez_control_t **)val1;
	const ez_control_t **control2 = (const ez_control_t **)val2;

	return ((*control1)->tab_order - (*control2)->tab_order);
}

//
// Control Tree - Orders the tab list based on the tab order property.
//
void EZ_tree_OrderTabList(ez_tree_t *tree)
{
	EZ_double_linked_list_Sort(&tree->tablist, EZ_tree_TabOrderFunc);
}

// =========================================================================================
// Control
// =========================================================================================

//
// Control - Creates a new control and initializes it.
//
ez_control_t *EZ_control_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  int flags)
{
	ez_control_t *control = NULL;

	// We have to have a tree to add the control to.
	if(!tree || tree->destroying)
	{
		return NULL;
	}

	control = (ez_control_t *)Q_malloc(sizeof(ez_control_t));
	memset(control, 0, sizeof(ez_control_t));

	EZ_control_Init(control, tree, parent, name, description, x, y, width, height, flags);

	return control;
}

//
// Control - 
// Returns the screen position of the control. This will be different for a scrollable window
// since it's drawing position differs from the windows actual position on screen.
//
void EZ_control_GetDrawingPosition(ez_control_t *self, int *x, int *y)
{
	if (self->ext_flags & control_scrollable)
	{
		(*x) = self->absolute_virtual_x;
		(*y) = self->absolute_virtual_y;
	}
	else
	{
		(*x) = self->absolute_x;
		(*y) = self->absolute_y;
	}
}

//
// Eventhandler - Creates a eventhandler.
//
ez_eventhandler_t *EZ_eventhandler_Create(void *event_func, int func_type, void *payload)
{
	ez_eventhandler_t *e	= Q_calloc(1, sizeof(ez_eventhandler_t));
	e->function_type		= func_type;
	e->payload				= payload;

	switch(func_type)
	{
		case EZ_CONTROL_HANDLER :
			e->function.normal = (ez_eventhandler_fp)event_func;
			break;
		case EZ_CONTROL_MOUSE_HANDLER :
			e->function.mouse = (ez_mouse_eventhandler_fp)event_func;
			break;
		case EZ_CONTROL_KEY_HANDLER :
			e->function.key = (ez_key_eventhandler_fp)event_func;
			break;
		case EZ_CONTROL_KEYSP_HANDLER :
			e->function.key_sp = (ez_keyspecific_eventhandler_fp)event_func;
			break;
		case EZ_CONTROL_DESTROY_HANDLER :
			e->function.destroy = (ez_destroy_eventhandler_fp)event_func;
			break;
		case EZ_CONTROL_CHILD_HANDLER :
			e->function.child = (ez_child_eventhandler_event_fp)event_func;
			break;
		default :
			e->function.normal = NULL;
			break;
	}

	e->next	= NULL;

	return e;
}	

//
// Eventhandler - Goes through the list of events and removes the one with the specified function.
//
void EZ_eventhandler_Remove(ez_eventhandler_t *eventhandler, void *event_func, qbool all)
{
	ez_eventhandler_t *it = eventhandler;
	ez_eventhandler_t *prev = NULL;

	while (it)
	{
		if (all)
		{
			prev = it->next;
			Q_free(it);
			it = prev;
		}
		else 
		{
			if (event_func && ((void *)it->function.normal == (void *)event_func))
			{
				if (prev)
				{
					prev->next = it->next;
				}

				Q_free(it);

				return;
			}

			prev = it;
			it = it->next;
		}
	}
}

//
// Eventhandler - Execute an event handler.
//
void EZ_eventhandler_Exec(ez_eventhandler_t *event_handler, ez_control_t *ctrl, ...)
{
	va_list argptr;
	int ft = event_handler->function_type;
	void *payload = event_handler->payload;
	ez_eventhandlerfunction_t *et = &event_handler->function;

	va_start(argptr, ctrl);

	// Pass on the proper amount of arguments, depending on the type of function.
	if (ft == EZ_CONTROL_HANDLER)
	{
		et->normal(ctrl, payload, va_arg(argptr, void *));
	}
	else if (ft == EZ_CONTROL_MOUSE_HANDLER)
	{
		et->mouse(ctrl, payload, va_arg(argptr, mouse_state_t *));	
	}
	else if (ft == EZ_CONTROL_KEY_HANDLER)
	{
		et->key(ctrl, payload, va_arg(argptr, int), va_arg(argptr, int), va_arg(argptr, qbool));
	}
	else if (ft == EZ_CONTROL_KEYSP_HANDLER)
	{
		et->key_sp(ctrl, payload, va_arg(argptr, int), va_arg(argptr, int));
	}
	else if (ft == EZ_CONTROL_DESTROY_HANDLER)	
	{
		et->destroy(ctrl, payload, va_arg(argptr, qbool));
	}
	else if (ft == EZ_CONTROL_CHILD_HANDLER)	
	{
		et->child(ctrl, payload, va_arg(argptr, ez_control_t *));
	}

	va_end(argptr);
}

//
// Control - Initializes a control and adds it to the specified control tree.
//
void EZ_control_Init(ez_control_t *control, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height, 
							  ez_control_flags_t flags)
{
	static int order		= 0;

	control->initializing	= true;

	control->CLASS_ID		= EZ_CONTROL_ID;

	control->control_tree	= tree;
	control->name			= name;
	control->description	= description;
	control->ext_flags		= flags | control_enabled | control_visible | control_bg_tile_center | control_bg_tile_edges | control_resizeable;
	control->anchor_flags	= anchor_none;
	
	// Set the default opacity to full :)
	control->overall_opacity = 1.0;
	control->opacity = 1.0;

	// Default to containing a child within it's parent
	// if the parent is being contained by it's parent.
	if (parent && (parent->ext_flags & control_contained))
	{
		control->ext_flags |= control_contained;
	}

	control->draw_order					= order++;

	control->resize_handle_thickness	= 5;
	control->width_max					= vid.conwidth;
	control->height_max					= vid.conheight;
	control->width_min					= 5;
	control->height_min					= 5;

	// Setup the default event functions, none of these should ever be NULL.
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMouseEvent, OnMouseEvent, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMouseClick, OnMouseClick, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMouseDown,	OnMouseDown, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMouseUp, OnMouseUp, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMouseUpOutside, OnMouseUpOutside, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMouseEnter, OnMouseEnter, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMouseLeave, OnMouseLeave, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMouseHover, OnMouseHover, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_Destroy, OnDestroy, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnDraw, OnDraw, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnGotFocus, OnGotFocus, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnKeyEvent, OnKeyEvent, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnKeyDown, OnKeyDown, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnKeyUp, OnKeyUp, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnLostFocus, OnLostFocus, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnLayoutChildren, OnLayoutChildren, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMove, OnMove, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnScroll, OnScroll, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnParentScroll, OnParentScroll, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnResize, OnResize, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnParentResize, OnParentResize, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnMinVirtualResize, OnMinVirtualResize, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnVirtualResize, OnVirtualResize, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnFlagsChanged, OnFlagsChanged, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnEventHandlerChanged, OnEventHandlerChanged, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnAnchorChanged, OnAnchorChanged, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnVisibilityChanged, OnVisibilityChanged, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnOpacityChanged, OnOpacityChanged, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnChildMoved, OnChildMoved, ez_control_t);
	CONTROL_REGISTER_EVENT(control, EZ_control_OnChildResize, OnChildResize, ez_control_t);

	// Add the control to the draw and tab list.
	EZ_double_linked_list_Add(&tree->drawlist, (void *)control);
	EZ_double_linked_list_Add(&tree->tablist, (void *)control);

	// Order the lists.
	EZ_tree_OrderDrawList(tree);
	EZ_tree_OrderTabList(tree);

	// Position and size of the control.
	control->width					= width;
	control->height					= height;
	control->virtual_width			= width;
	control->virtual_height			= height;
	control->prev_width				= width;
	control->prev_height			= height;
	control->prev_virtual_width		= width;
	control->prev_virtual_height	= height;

	control->int_flags |= control_update_anchorgap;

	// Set the background settings.
	EZ_control_SetBackgroundImageOpacity(control, 1.0);
	EZ_control_SetBackgroundImageEdgePercentage(control, 10);

	EZ_control_SetVirtualSize(control, width, height);
	EZ_control_SetMinVirtualSize(control, 1, 1);
	EZ_control_SetPosition(control, x, y);
	EZ_control_SetSize(control, width, height);

	// Set a default delay for raising new mouse click events.
	EZ_control_SetRepeatMouseClickDelay(control, 0.2);
	
	// Add the control to the control tree.
	if (!tree->root)
	{
		// The first control will be the root.
		tree->root = control;
	}
	else if (!parent)
	{
		// No parent was given so make the control a root child.
		EZ_control_AddChild(tree->root, control);
	}
	else
	{
		// Add the control to the specified parent.
		EZ_control_AddChild(parent, control);
	}

	control->initializing = false;
}

//
// Control - Destroys a specified control.
//
int EZ_control_Destroy(ez_control_t *self, qbool destroy_children)
{
	ez_dllist_node_t *iter = NULL;
	ez_dllist_node_t *temp = NULL;

	// Nothing to destroy :(
	if (!self)
	{
		return 0;
	}

	if (!self->control_tree)
	{
		// Very bad!
		Sys_Error("EZ_control_Destroy(): tried to destroy control without a tree.\n");
		return 0;
	}

	// Cleanup any specifics this control may have.
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDestroy, destroy_children);

	iter = self->children.head;

	// Destroy the children!
	while (iter)
	{
		if (destroy_children)
		{
			// Destroy the child!
			CONTROL_RAISE_EVENT(NULL, ((ez_control_t *)iter->payload), ez_control_t, OnDestroy, destroy_children);
		}
		else
		{
			// The child becomes an orphan :~/
			((ez_control_t *)iter->payload)->parent = NULL;
		}

		temp = iter;
		iter = iter->next;

		// Remove the child from the list.
		EZ_double_linked_list_Remove(&self->children, temp);
	}

	EZ_eventhandler_Remove(self->event_handlers.OnDestroy, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnDraw, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnEventHandlerChanged, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnFlagsChanged, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnGotFocus, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnKeyDown, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnKeyEvent, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnKeyUp, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnLayoutChildren, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnLostFocus, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMinVirtualResize, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMouseClick, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMouseDown, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMouseEnter, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMouseEvent, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMouseHover, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMouseLeave, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMouseUp, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMouseUpOutside, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnMove, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnParentResize, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnParentScroll, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnResize, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnResizeHandleThicknessChanged, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnScroll, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnVirtualResize, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnAnchorChanged, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnVisibilityChanged, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnChildMoved, NULL, true);
	EZ_eventhandler_Remove(self->event_handlers.OnChildResize, NULL, true);

	Q_free(self);

	return 0;
}

//
// Control - Sets the OnDestroy event handler.
//
void EZ_control_AddOnDestroy(ez_control_t *self, ez_destroy_eventhandler_fp OnDestroy, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_DESTROY_HANDLER, OnDestroy, ez_control_t, OnDestroy, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnFlagsChanged event handler.
//
void EZ_control_AddOnFlagsChanged(ez_control_t *self, ez_eventhandler_fp OnFlagsChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnFlagsChanged, ez_control_t, OnFlagsChanged, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnLayoutChildren event handler.
//
void EZ_control_AddOnLayoutChildren(ez_control_t *self, ez_eventhandler_fp OnLayoutChildren, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnLayoutChildren, ez_control_t, OnLayoutChildren, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMove event handler.
//
void EZ_control_AddOnMove(ez_control_t *self, ez_eventhandler_fp OnMove, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnMove, ez_control_t, OnMove, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnScroll event handler.
//
void EZ_control_AddOnScroll(ez_control_t *self, ez_eventhandler_fp OnScroll, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnScroll, ez_control_t, OnScroll, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnResize event handler.
//
void EZ_control_AddOnResize(ez_control_t *self, ez_eventhandler_fp OnResize, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnResize, ez_control_t, OnResize, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnParentResize event handler.
//
void EZ_control_AddOnParentResize(ez_control_t *self, ez_eventhandler_fp OnParentResize, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnParentResize, ez_control_t, OnParentResize, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMinVirtualResize event handler.
//
void EZ_control_AddOnMinVirtualResize(ez_control_t *self, ez_eventhandler_fp OnMinVirtualResize, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnMinVirtualResize, ez_control_t, OnMinVirtualResize, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnVirtualResize event handler.
//
void EZ_control_AddOnVirtualResize(ez_control_t *self, ez_eventhandler_fp OnVirtualResize, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnVirtualResize, ez_control_t, OnVirtualResize, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnKeyEvent event handler.
//
void EZ_control_AddOnKeyEvent(ez_control_t *self, ez_key_eventhandler_fp OnKeyEvent, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_KEY_HANDLER, OnKeyEvent, ez_control_t, OnKeyEvent, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnLostFocus event handler.
//
void EZ_control_AddOnLostFocus(ez_control_t *self, ez_eventhandler_fp OnLostFocus, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnLostFocus, ez_control_t, OnLostFocus, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnGotFocus event handler.
//
void EZ_control_AddOnGotFocus(ez_control_t *self, ez_eventhandler_fp OnGotFocus, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnGotFocus, ez_control_t, OnGotFocus, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMouseHover event handler.
//
void EZ_control_AddOnMouseHover(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseHover, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_MOUSE_HANDLER, OnMouseHover, ez_control_t, OnMouseHover, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMouseLeave event handler.
//
void EZ_control_AddOnMouseLeave(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseLeave, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_MOUSE_HANDLER, OnMouseLeave, ez_control_t, OnMouseLeave, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMouseEnter event handler.
//
void EZ_control_AddOnMouseEnter(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseEnter, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_MOUSE_HANDLER, OnMouseEnter, ez_control_t, OnMouseEnter, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMouseClick event handler.
//
void EZ_control_AddOnMouseClick(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseClick, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_MOUSE_HANDLER, OnMouseClick, ez_control_t, OnMouseClick, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMouseUp event handler.
//
void EZ_control_AddOnMouseUp(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseUp, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_MOUSE_HANDLER, OnMouseUp, ez_control_t, OnMouseUp, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMouseUpOutside event handler.
//
void EZ_control_AddOnMouseUpOutside(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseUpOutside, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_MOUSE_HANDLER, OnMouseUpOutside, ez_control_t, OnMouseUpOutside, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMouseDown event handler.
//
void EZ_control_AddOnMouseDown(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseDown, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_MOUSE_HANDLER, OnMouseDown, ez_control_t, OnMouseDown, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnMouseEvent event handler.
//
void EZ_control_AddOnMouseEvent(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseEvent, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_MOUSE_HANDLER, OnMouseEvent, ez_control_t, OnMouseEvent, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnDraw event handler.
//
void EZ_control_AddOnDraw(ez_control_t *self, ez_eventhandler_fp OnDraw, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnDraw, ez_control_t, OnDraw, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Set the event handler for the OnEventHandlerChanged event.
//
void EZ_control_AddOnEventHandlerChanged(ez_control_t *self, ez_eventhandler_fp OnEventHandlerChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnEventHandlerChanged, ez_control_t, OnEventHandlerChanged, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnResizeHandleThicknessChanged event handler.
//
void EZ_control_AddOnResizeHandleThicknessChanged(ez_control_t *self, ez_eventhandler_fp OnResizeHandleThicknessChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnResizeHandleThicknessChanged, ez_control_t, OnResizeHandleThicknessChanged, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnChildMoved event handler.
//
void EZ_control_AddOnChildMoved(ez_control_t *self, ez_eventhandler_fp OnChildMoved, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnChildMoved, ez_control_t, OnChildMoved, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Sets the OnChildResize event handler.
//
void EZ_control_AddOnChildResize(ez_control_t *self, ez_eventhandler_fp OnChildResize, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(self, EZ_CONTROL_HANDLER, OnChildResize, ez_control_t, OnChildResize, payload);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Control - Focuses on a control.
//
qbool EZ_control_SetFocus(ez_control_t *self)
{
	return EZ_control_SetFocusByNode(self, EZ_double_linked_list_FindByPayload(&self->control_tree->tablist, self));
}

//
// Control - Focuses on a control associated with a specified node from the tab list.
//
qbool EZ_control_SetFocusByNode(ez_control_t *self, ez_dllist_node_t *node)
{
	ez_tree_t *tree = NULL;

	if(!self || !node->payload)
	{
		Sys_Error("EZ_control_SetFocus(): Cannot focus on a NULL control.\n");
	}

	// The nodes payload and the control must be the same.
	if(self != node->payload)
	{
		return false;
	}

	// We can't focus on this control.
	if(!(self->ext_flags & control_focusable) || !(self->ext_flags & control_enabled))
	{
		return false;
	}

	tree = self->control_tree;

	// Steal the focus from the currently focused control.
	if(tree->focused_node)
	{
		ez_control_t *payload = NULL;

		if(!tree->focused_node->payload)
		{
			Sys_Error("EZ_control_SetFocus(): Focused node has a NULL payload.\n");
		}

		payload = (ez_control_t *)tree->focused_node->payload;

		// We're trying to focus on the already focused node.
		if(payload == self)
		{
			return true;
		}

		// Remove the focus flag and set the focus node to NULL.
		payload->int_flags &= ~control_focused;
		tree->focused_node = NULL;

		// Reset all manipulation flags.
		payload->int_flags &= ~(control_clicked | control_moving | control_resizing_left | control_resizing_right | control_resizing_bottom | control_resizing_top);

		// Raise event for losing the focus.
		CONTROL_RAISE_EVENT(NULL, payload, ez_control_t, OnLostFocus, NULL);
	}

	// Set the new focus.
	self->int_flags |= control_focused;
	tree->focused_node = node;

	// Raise event for getting focus.
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnGotFocus, NULL);

	return true;
}

//
// Control - Set the background image for the control.
//
void EZ_control_SetBackgroundImage(ez_control_t *self, const char *background_path)
{
	self->background = background_path ? Draw_CachePicSafe(background_path, false, true) : NULL;
}

//
// Control - Set the opacity for the background image for the control.
//
void EZ_control_SetBackgroundImageOpacity(ez_control_t *self, float opacity)
{
	self->bg_opacity = opacity;
}

//
// Control - Set how much percentage of the width of the background image that should be used when drawing the edges of the control.
//
void EZ_control_SetBackgroundImageEdgePercentage(ez_control_t *self, int percentage)
{
	self->bg_edge_size_ratio = percentage / 100.0;
	clamp(self->bg_edge_size_ratio, 0.0, 1.0);
}

//
// Control - Set if the center of the button should be tiled or stretched.
//
void EZ_control_SetBackgroundTileCenter(ez_control_t *self, qbool tilecenter)
{
	SET_FLAG(self->ext_flags, control_bg_tile_center, tilecenter);
}

//
// Control - Set if the edges of the button should be tiled or stretched.
//
void EZ_control_SetBackgroundTileEdges(ez_control_t *self, qbool tileedges)
{
	SET_FLAG(self->ext_flags, control_bg_tile_edges, tileedges);
}

//
// Control - Sets whetever the control is contained within the bounds of it's parent or not, or is allowed to draw outside it.
//
void EZ_control_SetContained(ez_control_t *self, qbool contained)
{
	SET_FLAG(self->ext_flags, control_contained, contained);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is enabled or not.
//
void EZ_control_SetEnabled(ez_control_t *self, qbool enabled)
{
	// TODO : Make sure input isn't allowed if a control isn't enabled.
	SET_FLAG(self->ext_flags, control_enabled, enabled);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is movable.
//
void EZ_control_SetMovable(ez_control_t *self, qbool movable)
{
	SET_FLAG(self->ext_flags, control_movable, movable);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is focusable.
//
void EZ_control_SetFocusable(ez_control_t *self, qbool focusable)
{
	SET_FLAG(self->ext_flags, control_focusable, focusable);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is resizeable horizontally by the user.
//
void EZ_control_SetResizeableHorizontally(ez_control_t *self, qbool resize_horizontally)
{
	SET_FLAG(self->ext_flags, control_resize_h, resize_horizontally);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is resizeable both horizontally and vertically by the user.
//
void EZ_control_SetResizeableBoth(ez_control_t *self, qbool resize)
{
	SET_FLAG(self->ext_flags, (control_resize_h | control_resize_v), resize);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is resizeable at all, not just by the user.
//
void EZ_control_SetResizeable(ez_control_t *self, qbool resizeable)
{
	// TODO : Is it confusing having this resizeable?
	SET_FLAG(self->ext_flags, control_resizeable, resizeable);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is resizeable vertically by the user.
//
void EZ_control_SetResizeableVertically(ez_control_t *self, qbool resize_vertically)
{
	SET_FLAG(self->ext_flags, control_resize_v, resize_vertically);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is visible or not.
//
void EZ_control_SetVisible(ez_control_t *self, qbool visible)
{
	SET_FLAG(self->ext_flags, control_visible, visible);

	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnVisibilityChanged, NULL);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control is scrollable or not.
//
void EZ_control_SetScrollable(ez_control_t *self, qbool scrollable)
{
	SET_FLAG(self->ext_flags, control_scrollable, scrollable);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets if the control should move it's parent when it moves itself.
//
void EZ_control_SetMovesParent(ez_control_t *self, qbool moves_parent)
{
	SET_FLAG(self->ext_flags, control_move_parent, moves_parent);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets whetever the control should care about mouse input or not.
//
void EZ_control_SetIgnoreMouse(ez_control_t *self, qbool ignore_mouse)
{
	SET_FLAG(self->ext_flags, control_ignore_mouse, ignore_mouse);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Listen to repeated mouse click events when holding down a mouse button. 
//           The delay between events is set using EZ_control_SetRepeatMouseClickDelay(...)
//
void EZ_control_SetListenToRepeatedMouseClicks(ez_control_t *self, qbool listen_repeat)
{
	SET_FLAG(self->ext_flags, control_listen_repeat_mouse, listen_repeat);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets the amount of time to wait between each new mouse click event
//           when holding down the mouse over a control.
//
void EZ_control_SetRepeatMouseClickDelay(ez_control_t *self, double delay)
{
	self->mouse_repeat_delay = delay;
}

//
// Control - Sets the external flags of the control.
//
void EZ_control_SetFlags(ez_control_t *self, ez_control_flags_t flags)
{
	self->ext_flags = flags;
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnFlagsChanged, NULL);
}

//
// Control - Sets the external flags of the control.
//
ez_control_flags_t EZ_control_GetFlags(ez_control_t *self)
{
	return self->ext_flags;
}

//
// Control - Gets the anchor flags.
//
ez_anchor_t EZ_control_GetAnchor(ez_control_t *self)
{
	return self->anchor_flags;
}

//
// Control - Sets the tab order of a control.
//
void EZ_control_SetTabOrder(ez_control_t *self, int tab_order)
{
	self->tab_order = tab_order;
	EZ_tree_OrderTabList(self->control_tree);
}

//
// Control - Calculates the position percentages based on the current pixel position.
//
static void EZ_control_CalculatePositionPercentages(ez_control_t *self)
{
	if (self->parent)
	{
		ez_control_t *p = self->parent;
		// TODO: Should we ever use the normal width of the parent here? If the control is out of the parents view port in this case, it will never be visible.
		int p_width		= (self->int_flags & control_anchor_viewport) ? p->width  : p->virtual_width;
		int p_height	= (self->int_flags & control_anchor_viewport) ? p->height : p->virtual_height;

		self->x_percent = self->x / (float)p_width;
		self->y_percent = self->y / (float)p_height;

		self->x_percent = bound(0, self->x_percent, 1.0);
		self->y_percent = bound(0, self->y_percent, 1.0);
	}
	else
	{
		self->x_percent = 0.0;
		self->y_percent = 0.0;
	}
}

//
// Control - Updates the anchor gaps between the controls edges and its parent 
//           (the distance to maintain from the parent when anchored to opposite edges).
//
static void EZ_control_UpdateAnchorGap(ez_control_t *self)
{
	if (!(self->int_flags & control_update_anchorgap))
	{
		return;
	}
	else if (self->parent)
	{
		qbool anchor_viewport	= self->ext_flags & control_anchor_viewport;
		int p_height			= anchor_viewport ? self->parent->height : self->parent->virtual_height;
		int p_width				= anchor_viewport ? self->parent->width  : self->parent->virtual_width;
		
		// Anchored to both top and bottom edges.
		if ((self->anchor_flags & (anchor_bottom | anchor_top)) == (anchor_bottom | anchor_top))
		{
			self->top_edge_gap		= self->y;
			self->bottom_edge_gap	= p_height - (self->y + self->height);
		}

		// Anchored to both left and right edges.
		if ((self->anchor_flags & (anchor_left | anchor_right)) == (anchor_left | anchor_right))
		{
			self->left_edge_gap		= self->x;
			self->right_edge_gap	= p_width - (self->x + self->width);
		}
	}
}

//
// Control - Sets the anchoring of the control to it's parent.
//           !!! NOTE !!! 
//           If you set an anchoring to a single edge, make sure you do this
//           after the parent has its final size, otherwise you might get some
//           goofy behavior.
//           !!! NOTE !!!
//
void EZ_control_SetAnchor(ez_control_t *self, ez_anchor_t anchor_flags)
{
	self->anchor_flags = anchor_flags;

	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnAnchorChanged, NULL);
}

//
// Control - Sets the tab order of a control.
//
void EZ_control_SetDrawOrder(ez_control_t *self, int draw_order, qbool update_children)
{
	// TODO : Is this the best way to change the draw order for the children?
	if (update_children && self->children.count > 0)
	{
		ez_dllist_node_t *it	= self->children.head;
		ez_control_t *child		= (ez_control_t *)it->payload;
		int draw_order_delta	= draw_order - self->draw_order;

		while (it)
		{
			child = (ez_control_t *)it->payload;
			EZ_control_SetDrawOrder(child, (draw_order + draw_order_delta), update_children);
			it = it->next;
		}
	}

	self->draw_order = draw_order;

	// TODO : Force teh user to do this explicitly? Because it will be run a lot of times if there's many children. 
	EZ_tree_OrderDrawList(self->control_tree);
}

//
// Control - Sets the payload for the control.
//
void EZ_control_SetPayload(ez_control_t *self, void *payload)
{
	self->payload = payload;
}

//
// Control - Sets the size of a control.
//
void EZ_control_SetSize(ez_control_t *self, int width, int height)
{
	self->prev_width = self->width;
	self->prev_height = self->height;

	self->width  = width;
	self->height = height;

	clamp(self->height, self->height_min, self->height_max);
	clamp(self->width, self->width_min, self->width_max);

	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnResize, NULL);
}

//
// Control - Set the thickness of the resize handles (if any).
//
void EZ_control_SetResizeHandleThickness(ez_control_t *self, int thickness)
{
	self->resize_handle_thickness = thickness;
}

//
// Control - Set the max size for the control.
//
void EZ_control_SetMaxSize(ez_control_t *self, int max_width, int max_height)
{
	self->width_max = max(0, max_width);
	self->height_max = max(0, max_height);

	// Do we need to change the size of the control to fit?
	if ((self->width > self->width_max) || (self->height > self->height_max))
	{
		EZ_control_SetSize(self, min(self->width, self->width_max), min(self->height, self->height_max));
	}
}

//
// Control - Set the min size for the control.
//
void EZ_control_SetMinSize(ez_control_t *self, int min_width, int min_height)
{
	self->width_min = max(0, min_width);
	self->height_min = max(0, min_height);

	// Do we need to change the size of the control to fit?
	if ((self->width < self->width_min) || (self->height < self->height_min))
	{
		EZ_control_SetSize(self, max(self->width, self->width_min), max(self->height, self->height_min));
	}
}

//
// Control - Set color of a control.
//
void EZ_control_SetBackgroundColor(ez_control_t *self, byte r, byte g, byte b, byte alpha)
{
	self->background_color[0] = r;
	self->background_color[1] = g;
	self->background_color[2] = b;
	self->background_color[3] = alpha;
}

//
// Control - Sets the position of a control, relative to it's parent.
//
void EZ_control_SetPosition(ez_control_t *self, int x, int y)
{
	// Set the new relative position.
	self->x = x;
	self->y = y;

	// Raise the event that we have moved.
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnMove, NULL);
}

//
// Control - Sets the part of the control that should be shown if it's scrollable.
//
void EZ_control_SetScrollPosition(ez_control_t *self, int scroll_x, int scroll_y)
{
	// Only scroll scrollable controls.
	if (!(self->ext_flags & control_scrollable))
	{
		return;
	}

	// Don't allow scrolling outside the scroll area.
	if ((scroll_x > (self->virtual_width - self->width)) 
	 || (scroll_y > (self->virtual_height - self->height))
	 || (scroll_x < 0)
	 || (scroll_y < 0))
	{
		return;
	}

	self->virtual_x = scroll_x;
	self->virtual_y = scroll_y;
 
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnScroll, NULL);
}

//
// Control - Convenient function for changing the scroll position by a specified amount.
//
void EZ_control_SetScrollChange(ez_control_t *self, int delta_scroll_x, int delta_scroll_y)
{
	EZ_control_SetScrollPosition(self, (self->virtual_x + delta_scroll_x), (self->virtual_y + delta_scroll_y));
}

//
// Control - Sets the virtual size of the control (this area can be scrolled around in).
//
void EZ_control_SetVirtualSize(ez_control_t *self, int virtual_width, int virtual_height)
{
	self->prev_virtual_width = self->virtual_width;
	self->prev_virtual_height = self->virtual_height;

	// Set the new virtual size of the control (cannot be smaller than the current size of the control).
	self->virtual_width = max(virtual_width, self->virtual_width_min);
	self->virtual_height = max(virtual_height, self->virtual_height_min);

	self->virtual_width = max(self->virtual_width, self->width + self->virtual_x);
	self->virtual_height = max(self->virtual_height, self->height + self->virtual_y);

	// Raise the event that we have changed the virtual size of the control.
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnVirtualResize, NULL);
}

//
// Control - Set the min virtual size for the control, the control size is not allowed to be larger than this.
//
void EZ_control_SetMinVirtualSize(ez_control_t *self, int min_virtual_width, int min_virtual_height)
{
	self->virtual_width_min = max(0, min_virtual_width);
	self->virtual_height_min = max(0, min_virtual_height);

	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnMinVirtualResize, NULL);
}

//
// Control - Returns true if this control is the root control.
//
qbool EZ_control_IsRoot(ez_control_t *self)
{
	return (self->parent == NULL);
}

//
// Control - Adds a child to the control.
//
void EZ_control_AddChild(ez_control_t *self, ez_control_t *child)
{
	// Remove the control from it's current parent.
	if (child->parent)
	{
		EZ_double_linked_list_RemoveByPayload(&child->parent->children, child);
	}
 
	// Set the new parent of the child.
	child->parent = self;

	// Add the child to the new parents list of children.
	EZ_double_linked_list_Add(&self->children, child);
}

//
// Control - Remove a child from the control. Returns a reference to the child that was removed.
//
ez_control_t *EZ_control_RemoveChild(ez_control_t *self, ez_control_t *child)
{
	return (ez_control_t *)EZ_double_linked_list_RemoveByPayload(&self->children, child);
}

//
// Control - The anchoring for the control changed.
//
int EZ_control_OnAnchorChanged(ez_control_t *self, void *ext_event_info)
{
	// Calculate the gaps to the parents edges (used for anchoring, see OnParentResize for detailed explination).
	EZ_control_UpdateAnchorGap(self);

	// Calculate the position percentages in relation to the parents size.
	// We'll use this in the case where the control is only anchored to
	// one edge of its parent so that it will "flow" as the parent is resized.
	EZ_control_CalculatePositionPercentages(self);

	// Make sure the control is repositioned correctly.
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnMove, NULL);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnParentResize, NULL);

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnAnchorChanged, NULL);
	return 0;
}

//
// Control - The control got focus.
//
int EZ_control_OnGotFocus(ez_control_t *self, void *ext_event_info)
{
	if(!(self->int_flags & control_focused))
	{
		return 0;
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnGotFocus, NULL);

	return 0;
}

//
// Control - The control lost focus.
//
int EZ_control_OnLostFocus(ez_control_t *self, void *ext_event_info)
{
	if (self->int_flags & control_focused)
	{
		return 0;
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnLostFocus, NULL);

	return 0;
}

//
// Control - The control was resized.
//
int EZ_control_OnResize(ez_control_t *self, void *ext_event_info)
{
	// Calculate how much the width has changed so that we can
	// compensate by scrolling.
	int scroll_change_x = (self->prev_width - self->width);
	int scroll_change_y = (self->prev_height - self->height);

	ez_control_t *payload = NULL;
	ez_dllist_node_t *iter = self->children.head;

	// Calculate the gaps to the parents edges (used for anchoring, see OnParentResize for detailed explination).
	EZ_control_UpdateAnchorGap(self);

	// Make sure the virtual size never is smaller than the normal size of the control
	// and that it's never smaller than the virtual max size.
	EZ_control_SetVirtualSize(self, self->width, self->height);

	// First scroll the window so that we use the current virtual space fully
	// before expanding it. That is, only start expanding when the:
	// REAL_SIZE > VIRTUAL_MIN_SIZE
	if (scroll_change_x < 0)
	{
		EZ_control_SetScrollChange(self, scroll_change_x, 0);
	}

	if (scroll_change_y < 0)
	{
		EZ_control_SetScrollChange(self, 0, scroll_change_y);
	}

	// Tell the children we've resized.
	while (iter)
	{
		payload = (ez_control_t *)iter->payload;
		CONTROL_RAISE_EVENT(NULL, payload, ez_control_t, OnParentResize, NULL);
		iter = iter->next;
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnResize, NULL);

	// Tell our parent we've moved.
	if (self->parent)
	{
		CONTROL_RAISE_EVENT(NULL, self->parent, ez_control_t, OnChildResize, self);
	}

	return 0;
}

//
// Control - The controls parent was resized.
//
int EZ_control_OnParentResize(ez_control_t *self, void *ext_event_info)
{
	if (self->parent && (self->ext_flags & control_resizeable))
	{
		ez_control_t *p			= self->parent;
		int x					= self->x;
		int y					= self->y;
		int new_width			= self->width;
		int new_height			= self->height;
		qbool anchor_viewport	= (self->ext_flags & control_anchor_viewport);
//		int parent_prev_width	= anchor_viewport ? p->prev_width	: p->prev_virtual_width;
//		int parent_prev_height	= anchor_viewport ? p->prev_height	: p->prev_virtual_height;
		int parent_width		= anchor_viewport ? p->width		: p->virtual_width; 
		int parent_height		= anchor_viewport ? p->height		: p->virtual_height;

		//
		// Calculate our new position.
		//
		{
			int new_x = self->x;
			int new_y = self->y;			

			// If we're exlusivly anchored to one edge, we change our position
			// based on the parents size.
			if ((self->anchor_flags == anchor_top) || (self->anchor_flags == anchor_bottom))
			{
				new_x = Q_rint(parent_width * self->x_percent);
			}
			else if ((self->anchor_flags == anchor_left) || (self->anchor_flags == anchor_right))
			{
				new_y = Q_rint(parent_height * self->y_percent);
			}

			// Only update the position if it has changed.
			if ((new_x != self->x) || (new_y != self->y))
			{
				// Only update the position if our calculated position is still within
				// the bounds of the parent. If we don't check for this, the control
				// will never be visible in the case were you position a child outside of
				// the parents viewport, then set the anchoring, and then resize the parent
				// to its final size. This is because the x/y_percentage vars are only
				// set on the OnAnchoringChanged event, where x_percent = x / parent_width.
				// if x is greater than parent_width x_percent will be > 1 which means
				// any position we calculate here will be outside of the parent control.
				// (Yes this is confusing :D).
				if ((new_x < parent_width) && (new_y < parent_height))
				{
					EZ_control_SetPosition(self, new_x, new_y);
				}
			}
		}

		if ((self->anchor_flags & (anchor_left | anchor_right)) == (anchor_left | anchor_right))
		{			
			// Set the new width so that the right side of the control is
			// still the same distance from the right side of the parent.
			new_width = parent_width - (x + self->right_edge_gap);
		}

		if ((self->anchor_flags & (anchor_top | anchor_bottom)) == (anchor_top | anchor_bottom))
		{
			new_height = parent_height - (y + self->bottom_edge_gap);
		}

		// Set the new size if it changed.
		if ((self->width != new_width) || (self->height != new_height))
		{
			// When the control is anchored to two opposit edges we want to stretch it
			// when it's parent is resized. If the parent becomes either
			// smaller or larger than the controls max/min size when doing this, it will
			// make us stop resizing the child. And since we want the child to

			// We need special behaviour when resizing a control that is anchored to two
			// opposite edges of it's parent (it should be stretched). A child control is placed
			// inside of a parent, and it's given a size and anchoring points. When resizing the
			// parent, we want to maintain the distance between the parents edges and the childs edges,
			// that is, if the childs right edge was 10 pixels from it's parents right edge before
			// we resized the parent, we want it to be the same afterwards also. We achieve this by
			// resizing the child (stretching it) to maintain the same gap. 
			//
			// This all works fine if the child is allowed to have any size (even negative), since it will
			// always maintain the same gap between the edges. The problem arises when you introduce the 
			// possibility for a control to have a min/max size, in this case we need to stop updating 
			// the gap when the min/max size has been reached, and remember the last used gap size until
			// the parent goes back to a size that let's its child keep the correct edge gap without 
			// violating its size bounds again. 
			//
			// We do this by only updating the gap size either when setting new anchoring points,
			// or when someone explicitly changes the size of the child control. Therefore any resize of the child
			// control that is triggered by its parent being resized doesn't produce a new gap size.
			self->int_flags &= ~control_update_anchorgap;
			
			EZ_control_SetSize(self, new_width, new_height);

			self->int_flags |= control_update_anchorgap;
		}
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnParentResize, NULL);

	return 0;
}

//
// Control - The minimum virtual size has changed for the control.
//
int EZ_control_OnMinVirtualResize(ez_control_t *self, void *ext_event_info)
{
	int new_virtual_width	= max(self->virtual_width_min, self->virtual_width);
	int new_virtual_height	= max(self->virtual_height_min, self->virtual_height);

	// Make sure the virtual size isn't smaller than the new minimum virtual size.
	if ((new_virtual_width != self->virtual_width) || (new_virtual_height != self->virtual_height))
	{
		EZ_control_SetVirtualSize(self, new_virtual_width, new_virtual_height);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnMinVirtualResize, NULL);

	return 0;
}

//
// Control - Hide a control if its parent is hidden. We don't unset control_visible for this
//			because we want to let any child inside of a control to decide if it should be
//			visible or not on it's own, if we just set control_visible here we'd overwrite
//			the childs visibility.
//
static void EZ_control_SetHiddenByParent(ez_control_t *self, qbool hidden)
{
	ez_dllist_node_t *iter	= self->children.head;
	ez_control_t *child		= NULL;

	SET_FLAG(self->int_flags, control_hidden_by_parent, hidden);

	// Show or hide our children also.
	while(iter)
	{
		child = (ez_control_t *)iter->payload;
		EZ_control_SetHiddenByParent(child, hidden);
		iter = iter->next;
	}
}

//
// Control - Visibility changed.
//
int EZ_control_OnVisibilityChanged(ez_control_t *self, void *ext_event_info)
{
	// Hide any children.
	EZ_control_SetHiddenByParent(self, !(self->ext_flags & control_visible));

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnVisibilityChanged, NULL);
	return 0;
}

//
// Label - The flags for the control changed.
//
int EZ_control_OnFlagsChanged(ez_control_t *self, void *ext_event_info)
{
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnFlagsChanged, NULL);
	return 0;
}

//
// Control - OnResizeHandleThicknessChanged event.
//
int EZ_control_OnResizeHandleThicknessChanged(ez_control_t *self, void *ext_event_info)
{
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnResizeHandleThicknessChanged, NULL);
	return 0;
}

//
// Label - The virtual size of the control has changed.
//
int EZ_control_OnVirtualResize(ez_control_t *self, void *ext_event_info)
{
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnVirtualResize, NULL);

	return 0;
}

//
// Control - The control was moved.
//
int EZ_control_OnMove(ez_control_t *self, void *ext_event_info)
{	
	ez_control_t *child		= NULL;
	ez_dllist_node_t *iter	= self->children.head;
	qbool anchor_viewport	= (self->ext_flags & control_anchor_viewport);
	int parent_x			= 0;
	int parent_y			= 0;

	self->prev_absolute_x = self->absolute_x;
	self->prev_absolute_y = self->absolute_y;

	// Get the position of the area we're anchoring to. Normal behaviour is to anchor to the virtual area.
	if (self->parent)
	{
		parent_x = anchor_viewport ? self->parent->absolute_x : self->parent->absolute_virtual_x;
		parent_y = anchor_viewport ? self->parent->absolute_y : self->parent->absolute_virtual_y;
	}

	// Update the absolute screen position based on the parents position.
	self->absolute_x = (self->parent ? parent_x : 0) + self->x;
	self->absolute_y = (self->parent ? parent_y : 0) + self->y;

	if (self->parent)
	{
		// If the control has a parent, position it in relation to it
		// and the way it's anchored to it.
//		int parent_prev_width	= anchor_viewport ? self->parent->prev_width	: self->parent->prev_virtual_width;
//		int parent_prev_height	= anchor_viewport ? self->parent->prev_height	: self->parent->prev_virtual_height;
		int parent_width		= anchor_viewport ? self->parent->width			: self->parent->virtual_width; 
		int parent_height		= anchor_viewport ? self->parent->height		: self->parent->virtual_height;
		
		/*
		EZ_control_CalculatePositionPercentages(self);

		// If we're exlusivly anchored to one edge, we change our position
		// based on the parents width.
		if ((self->anchor_flags == anchor_top) || (self->anchor_flags == anchor_bottom))
		{
			self->x = Q_rint(parent_width * self->x_percent);
		}
		else if ((self->anchor_flags == anchor_left) || (self->anchor_flags == anchor_right)
		{
			self->y = Q_rint(parent_height * self->y_percent);
		}*/

		// If we're anchored to both the left and right part of the parent we position
		// based on the parents left pos 
		// (We will stretch to the right if the control is resizable and if the parent is resized).
		if ((self->anchor_flags & anchor_left) && !(self->anchor_flags & anchor_right))
		{
			self->absolute_x = parent_x + self->x;
		}
		else if ((self->anchor_flags & anchor_right) && !(self->anchor_flags & anchor_left))
		{
			self->absolute_x = parent_x + parent_width + (self->x - self->width);
		}

		if ((self->anchor_flags & anchor_top) && !(self->anchor_flags & anchor_bottom))
		{
			self->absolute_y = parent_y + self->y;
		}
		else if ((self->anchor_flags & anchor_bottom) && !(self->anchor_flags & anchor_top))
		{
			self->absolute_y = parent_y + parent_height + (self->y - self->height);
		}
	}
	else
	{
		// No parent, position based on screen coordinates.
		self->absolute_x = self->x;
		self->absolute_y = self->y;
	}

	// We need to move the virtual area of the control also.
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnScroll, NULL);

	// Tell the children we've moved.
	while(iter)
	{
		child = (ez_control_t *)iter->payload;
		CONTROL_RAISE_EVENT(NULL, child, ez_control_t, OnMove, NULL);
		iter = iter->next;
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnMove, NULL);

	// Tell our parent we've moved.
	if (self->parent)
	{
		CONTROL_RAISE_EVENT(NULL, self->parent, ez_control_t, OnChildMoved, self);
	}

	return 0;
}

//
// Control - On scroll event.
//
int EZ_control_OnScroll(ez_control_t *self, void *ext_event_info)
{
	ez_control_t *child = NULL;
	ez_dllist_node_t *iter = self->children.head;

	self->absolute_virtual_x = self->absolute_x - self->virtual_x;
	self->absolute_virtual_y = self->absolute_y - self->virtual_y;

	// Tell the children we've scrolled. And make them recalculate their
	// absolute position by telling them they've moved.
	while(iter)
	{
		child = (ez_control_t *)iter->payload;
		CONTROL_RAISE_EVENT(NULL, child, ez_control_t, OnMove, NULL);
		CONTROL_RAISE_EVENT(NULL, child, ez_control_t, OnParentScroll, NULL);
		iter = iter->next;
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnScroll, NULL);

	return 0;
}

//
// Control - On parent scroll event.
//
int EZ_control_OnParentScroll(ez_control_t *self, void *ext_event_info)
{
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnParentScroll, NULL);
	return 0;
}

//
// Control - Layouts children.
//
int EZ_control_OnLayoutChildren(ez_control_t *self, void *ext_event_info)
{
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnLayoutChildren, NULL);
	return 0;
}

//
// Control - Event for when a new event handler is set for an event.
//
int EZ_control_OnEventHandlerChanged(ez_control_t *self, void *ext_event_info)
{
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnEventHandlerChanged, NULL);
	return 0;
}

//
// Control - Draw the background.
//
static void EZ_control_DrawBackgroundImage(ez_control_t *self)
{
	int edge_size;		// The number of pixel from the edge of the texture 
	int edge_size2;		// to use when drawing the buttons edges.

	mpic_t *pic = self->background;

	int x, y;

	if (!pic)
	{
		return;
	}

	// Calculate the number of pixels to use for the edges.
	edge_size = Q_rint(self->bg_edge_size_ratio * pic->width);
	edge_size2 = (2 * edge_size);

	EZ_control_GetDrawingPosition(self, &x, &y);

	// Center background.
	if (self->ext_flags & control_bg_tile_center)
	{
		// Tiled.
		Draw_SubPicTiled((x + edge_size), (y + edge_size), 
			(self->width - edge_size2), (self->height - edge_size2),
			pic, 
			edge_size, edge_size, 
			(pic->width - edge_size2), (pic->height - edge_size2),
			self->bg_opacity);
	}
	else
	{
		// Stretch the image.
		Draw_FitAlphaSubPic((x + edge_size), (y + edge_size), (self->width - edge_size2), (self->height - edge_size2), 
			pic, edge_size, edge_size, (pic->width - edge_size2), (pic->height - edge_size2), self->bg_opacity);
	}

	// Only draw an edge if we have something to draw ;)
	if (edge_size > 0)
	{
		if (self->ext_flags & control_bg_tile_edges)
		{
			// Tiled.

			// Top center.
			Draw_SubPicTiled((x + edge_size), y, (self->width - edge_size2), edge_size, 
							pic, edge_size, 0, (pic->width - edge_size2), edge_size, self->bg_opacity);

			// Bottom center.
			Draw_SubPicTiled((x + edge_size), (y + self->height - edge_size), (self->width - edge_size2), edge_size, 
							pic, edge_size, (pic->height - edge_size), (pic->width - edge_size2), edge_size, self->bg_opacity);
			
			// Left center.
			Draw_SubPicTiled(x, (y + edge_size), edge_size, (self->height - edge_size2), 
							pic, 0, edge_size, edge_size, (pic->height - edge_size2), self->bg_opacity);

			// Right center.
			Draw_SubPicTiled((x + self->width - edge_size), (y + edge_size), edge_size, (self->height - edge_size2), 
							pic, (pic->width - edge_size), edge_size, edge_size, (pic->height - edge_size2), self->bg_opacity);
		}
		else
		{
			// Stretched.

			// Top center.
			Draw_FitAlphaSubPic((x + edge_size), y, (self->width - edge_size), edge_size, 
								pic, edge_size, 0, (pic->width - edge_size2), edge_size, self->bg_opacity);

			// Bottom center.
			Draw_FitAlphaSubPic((x + edge_size), (y + self->height - edge_size), (self->width - edge_size), edge_size, 
								pic, edge_size, (pic->height - edge_size), (pic->width - edge_size2), edge_size, self->bg_opacity);

			// Left center.
			Draw_FitAlphaSubPic(x, (y + edge_size), edge_size, (self->height - edge_size2), 
								pic, 0, edge_size, edge_size, (pic->height - edge_size2), self->bg_opacity);

			// Right center.
			Draw_FitAlphaSubPic((x + self->width - edge_size), (y + edge_size), edge_size, (self->height - edge_size2), 
								pic, (pic->width - edge_size), edge_size, edge_size, (pic->height - edge_size2), self->bg_opacity);
		}

		// Top left corner.
		Draw_AlphaSubPic(x, y, pic, 0, 0, edge_size, edge_size, self->bg_opacity);

		// Top right corner.
		Draw_AlphaSubPic((x + self->width - edge_size), y, pic, (pic->width - edge_size), 0, edge_size, edge_size, self->bg_opacity);

		// Bottom left corner.
		Draw_AlphaSubPic(x, (y + self->height - edge_size), pic, 0, (pic->height - edge_size), edge_size, edge_size, self->bg_opacity);

		// Bottom right corner.
		Draw_AlphaSubPic((x + self->width - edge_size), (y + self->height - edge_size), 
					pic, 
					(pic->width - edge_size), (pic->height - edge_size), 
					edge_size, edge_size, self->bg_opacity);
	}
}

//
// Control - Draws the control.
//
int EZ_control_OnDraw(ez_control_t *self, void *ext_event_info)
{
	int x, y;
	EZ_control_GetDrawingPosition(self, &x, &y);

	if (self->background)
	{
		EZ_control_DrawBackgroundImage(self);
	}
	else if (self->background_color[3] > 0)
	{
		Draw_AlphaRectangleRGB(self->absolute_x, self->absolute_y, self->width, self->height, 1, true, RGBAVECT_TO_COLOR(self->background_color));
	}

	// TODO : Remove this test stuff.
	/*
	Draw_String(x, y, va("%s%s%s%s",
			((self->int_flags & control_moving) ? "M" : " "),
			((self->int_flags & control_focused) ? "F" : " "),
			((self->int_flags & control_clicked) ? "C" : " "),
			((self->int_flags & control_resizing_left) ? "R" : " ")
			));
	*/

	// Draw control specifics.
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDraw, NULL);

	return 0;
}

//
// Control - Key down event.
//
int EZ_control_OnKeyDown(ez_control_t *self, int key, int unichar)
{
	int key_handled = false;

	CONTROL_EVENT_HANDLER_CALL(&key_handled, self, ez_control_t, OnKeyDown, key, unichar);

	return key_handled;
}

//
// Control - Key up event.
//
int EZ_control_OnKeyUp(ez_control_t *self, int key, int unichar)
{
	int key_handled = false;

	CONTROL_EVENT_HANDLER_CALL(&key_handled, self, ez_control_t, OnKeyUp, key, unichar);

	return key_handled;
}

//
// Control - Key event.
//
int EZ_control_OnKeyEvent(ez_control_t *self, int key, int unichar, qbool down)
{
	int key_handled			= false;
//	ez_control_t *payload	= NULL;
//	ez_dllist_node_t *iter	= self->children.head;

	if (down)
	{
		CONTROL_RAISE_EVENT(&key_handled, self, ez_control_t, OnKeyDown, key, unichar);
	}
	else
	{
		CONTROL_RAISE_EVENT(&key_handled, self, ez_control_t, OnKeyUp, key, unichar);
	}

	if (key_handled)
	{
		return true;
	}

	CONTROL_EVENT_HANDLER_CALL(&key_handled, self, ez_control_t, OnKeyEvent, key, unichar, down);

	return key_handled;
}

typedef enum
{
	RESIZE_LEFT		= (1 << 0),
	RESIZE_RIGHT	= (1 << 1),
	RESIZE_UP		= (1 << 2),
	RESIZE_DOWN		= (1 << 3)
} resize_direction_t;

//
// Control - Resizes the control by moving the left corner.
//
static void EZ_control_ResizeByDirection(ez_control_t *self, mouse_state_t *ms, int delta_x, int delta_y, resize_direction_t direction)
{
	int width				= self->width;
	int height				= self->height;
	int x					= self->x;
	int y					= self->y;
	qbool resizing_width	= (direction & RESIZE_LEFT) || (direction & RESIZE_RIGHT);
	qbool resizing_height	= (direction & RESIZE_UP) || (direction & RESIZE_DOWN);

	if (resizing_width)
	{
		// Set the new width based on how much the mouse has moved
		// keeping it within the allowed bounds.
		width = self->width + ((direction & RESIZE_LEFT) ? delta_x : -delta_x);
		clamp(width, self->width_min, self->width_max);

		// Move the control to counteract the resizing when resizing to the left.
		x = self->x + ((direction & RESIZE_LEFT) ? (self->width - width) : 0);
	}

	if (resizing_height)
	{
		height = self->height + ((direction & RESIZE_UP) ? delta_y : -delta_y);
		clamp(height, self->height_min, self->height_max);
		y = self->y + ((direction & RESIZE_UP) ? (self->height - height) : 0);
	}

	// If the child should be contained within it's parent the
	// mouse should stay within the parent also when resizing the control.
	if (ms && CONTROL_IS_CONTAINED(self))
	{
		if (resizing_width && !POINT_X_IN_CONTROL_DRAWBOUNDS(self->parent, ms->x))
		{
			ms->x = ms->x_old;
			x = self->x;
			width = self->width;
		}

		if (resizing_height && !POINT_Y_IN_CONTROL_DRAWBOUNDS(self->parent, ms->y))
		{
			ms->y = ms->y_old;
			y = self->y;
			height = self->height;
		}
	}

	EZ_control_SetSize(self, width, height);
	EZ_control_SetPosition(self, x, y);
}

//
// Control -
// The initial mouse event is handled by this, and then raises more specialized event handlers
// based on the new mouse state.
// 
// NOTICE! When extending this event you need to make sure that you need to tell the framework
// that you've handled all mouse events that happened within the controls bounds in your own
// implementation by returning true whenever the mouse is inside the control.
// This can easily be done with the following macro: MOUSE_INSIDE_CONTROL(self, ms); 
// If this is not done, all mouse events will "fall through" to controls below.
//
int EZ_control_OnMouseEvent(ez_control_t *self, mouse_state_t *ms)
{
	mouse_state_t *old_ms			= &self->prev_mouse_state;
	qbool mouse_inside				= false;
	qbool prev_mouse_inside			= false;
//	qbool mouse_inside_parent		= false;
//	qbool prev_mouse_inside_parent	= false;
//	qbool is_contained				= CONTROL_IS_CONTAINED(self);
	int mouse_handled_tmp			= false;
	int mouse_handled				= false;
	int mouse_delta_x				= 0;
	int mouse_delta_y				= 0;

	if (!ms)
	{
		Sys_Error("EZ_control_OnMouseEvent(): mouse_state_t NULL\n");
	}

	// Ignore the mouse?
	if (self->ext_flags & control_ignore_mouse)
	{
		return false;
	}

	mouse_delta_x = Q_rint(ms->x_old - ms->x);
	mouse_delta_y = Q_rint(ms->y_old - ms->y);

	mouse_inside		= POINT_IN_CONTROL_DRAWBOUNDS(self, ms->x, ms->y);
	prev_mouse_inside	= POINT_IN_CONTROL_DRAWBOUNDS(self, ms->x_old, ms->y_old);

	// Raise more specific events.
	if (mouse_inside)
	{
		if (!prev_mouse_inside)
		{
			// Were we inside of the control last time? Otherwise we've just entered it.
			CONTROL_RAISE_EVENT(&mouse_handled_tmp, self, ez_control_t, OnMouseEnter, ms);
		}
		else
		{
			// We're hovering the control.
			CONTROL_RAISE_EVENT(&mouse_handled_tmp, self, ez_control_t, OnMouseHover, ms);
		}

		mouse_handled = (mouse_handled || mouse_handled_tmp);

		if (ms->button_down)
		{
			// Mouse down.
			CONTROL_RAISE_EVENT(&mouse_handled_tmp, self, ez_control_t, OnMouseDown, ms);
			mouse_handled = (mouse_handled || mouse_handled_tmp);
		}

		if (ms->button_up)
		{
			// Mouse up.
			CONTROL_RAISE_EVENT(&mouse_handled_tmp, self, ez_control_t, OnMouseUp, ms);
			mouse_handled = (mouse_handled || mouse_handled_tmp);
		}
	}
	else if (prev_mouse_inside)
	{
		// Mouse leave.
		CONTROL_RAISE_EVENT(&mouse_handled_tmp, self, ez_control_t, OnMouseLeave, ms);
		mouse_handled = (mouse_handled || mouse_handled_tmp);
	}

	// Send a mouse up event to controls if the mouse is outside also.
	if (ms->button_up && (ms->button_up != old_ms->button_up))
	{
		// Mouse up.
		CONTROL_RAISE_EVENT(&mouse_handled_tmp, self, ez_control_t, OnMouseUpOutside, ms);
		mouse_handled = (mouse_handled || mouse_handled_tmp);
	}

	// Make sure we remove the click flag always when releasing the button
	// not just when we're hovering above the control.
	if (ms->button_up && (ms->button_up != old_ms->button_up))
	{
		self->int_flags &= ~control_clicked;
	}

	// TODO : Move these to new methods.

	if (!mouse_handled)
	{
		// Check for moving and resizing.
		if ((self->int_flags & control_resizing_left)
		 || (self->int_flags & control_resizing_right)
		 || (self->int_flags & control_resizing_top)
		 || (self->int_flags & control_resizing_bottom))
		{
			// These can be combined to grab the corners for resizing.

			// Resize by width.
			if (self->int_flags & control_resizing_left)
			{
				EZ_control_ResizeByDirection(self, ms, mouse_delta_x, mouse_delta_y, RESIZE_LEFT);
				mouse_handled = true;
			}
			else if (self->int_flags & control_resizing_right)
			{
				EZ_control_ResizeByDirection(self, ms, mouse_delta_x, mouse_delta_y, RESIZE_RIGHT);
				mouse_handled = true;
			}

			// Resize by height.
			if (self->int_flags & control_resizing_top)
			{
				EZ_control_ResizeByDirection(self, ms, mouse_delta_x, mouse_delta_y, RESIZE_UP);
				mouse_handled = true;
			}
			else if (self->int_flags & control_resizing_bottom)
			{
				EZ_control_ResizeByDirection(self, ms, mouse_delta_x, mouse_delta_y, RESIZE_DOWN);
				mouse_handled = true;
			}
		}
		else if (self->int_flags & control_moving)
		{
			// Root control will be moved relative to the screen,
			// others relative to their parent.
			int m_delta_x = Q_rint(ms->x - ms->x_old);
			int m_delta_y = Q_rint(ms->y - ms->y_old);
			int x = self->x + m_delta_x;
			int y = self->y + m_delta_y;

			// Should the control be contained within it's parent?
			// Then don't allow the mouse to move outside the parent
			// while moving the control.
			if (CONTROL_IS_CONTAINED(self))
			{
				if (!POINT_X_IN_CONTROL_DRAWBOUNDS(self->parent, ms->x))
				{
					ms->x = ms->x_old;
					x = self->x;
					mouse_handled = true;
				}

				if (!POINT_Y_IN_CONTROL_DRAWBOUNDS(self->parent, ms->y))
				{
					ms->y = ms->y_old;
					y = self->y;
					mouse_handled = true;
				}
			}

			if (self->parent && (self->ext_flags & control_move_parent))
			{
				// Move the parent instead of just the control, the parent will in turn move the control.
				// TODO : Do we need to keep the mouse inside the parents parent here also?
				EZ_control_SetPosition(self->parent, (self->parent->x + m_delta_x), (self->parent->y + m_delta_y));
			}
			else
			{
				EZ_control_SetPosition(self, x, y);
			}

			mouse_handled = true;
		}
	}

	// Let any event handler run if the mouse event wasn't handled.
	CONTROL_EVENT_HANDLER_CALL(&mouse_handled_tmp, self, ez_control_t, OnMouseEvent, ms);
	mouse_handled = (mouse_handled || mouse_handled_tmp);

	// Save the mouse state for the next time we check.
	self->prev_mouse_state = *ms;

	return mouse_handled;
}

//
// Control - The mouse was pressed and then released within the bounds of the control.
//
int EZ_control_OnMouseClick(ez_control_t *self, mouse_state_t *mouse_state)
{
	int mouse_handled = false;
	CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseClick, mouse_state);
	return mouse_handled;
}

//
// Control - The mouse entered the controls bounds.
//
int EZ_control_OnMouseEnter(ez_control_t *self, mouse_state_t *mouse_state)
{
	int mouse_handled = false;
	self->int_flags |= control_mouse_over;
	CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseEnter, mouse_state);
	return mouse_handled;
}

//
// Control - The mouse left the controls bounds.
//
int EZ_control_OnMouseLeave(ez_control_t *self, mouse_state_t *mouse_state)
{
	int mouse_handled = false;

	// Stop moving since the mouse is outside the control.
	self->int_flags &= ~(/*control_moving |*/ control_mouse_over);

	CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseLeave, mouse_state);
	return mouse_handled;
}

//
// Control - A mouse button was released either inside or outside of the control.
//
int EZ_control_OnMouseUpOutside(ez_control_t *self, mouse_state_t *ms)
{
	int mouse_handled_tmp	= false;
	int mouse_handled		= false;

	// Stop moving / resizing.
	self->int_flags &= ~(control_moving | control_resizing_left | control_resizing_right | control_resizing_top | control_resizing_bottom);

	// Call event handler.
	CONTROL_EVENT_HANDLER_CALL(&mouse_handled_tmp, self, ez_control_t, OnMouseUpOutside, ms);
	mouse_handled = (mouse_handled || mouse_handled_tmp);

	return mouse_handled;
}

//
// Control - A mouse button was released within the bounds of the control.
//
int EZ_control_OnMouseUp(ez_control_t *self, mouse_state_t *mouse_state)
{
	int mouse_handled_tmp	= false;
	int mouse_handled		= false;

	// Stop moving / resizing.
	self->int_flags &= ~(control_moving | control_resizing_left | control_resizing_right | control_resizing_top | control_resizing_bottom);

	// Raise a click event.
	if (self->int_flags & control_clicked)
	{
		self->int_flags &= ~control_clicked;
		CONTROL_RAISE_EVENT(&mouse_handled_tmp, self, ez_control_t, OnMouseClick, mouse_state);
		mouse_handled = (mouse_handled || mouse_handled_tmp);
	}

	// Call event handler.
	CONTROL_EVENT_HANDLER_CALL(&mouse_handled_tmp, self, ez_control_t, OnMouseUp, mouse_state);
	mouse_handled = (mouse_handled || mouse_handled_tmp);

	return mouse_handled;
}

//
// Control - A mouse button was pressed within the bounds of the control.
//
int EZ_control_OnMouseDown(ez_control_t *self, mouse_state_t *ms)
{
	int mouse_handled_tmp	= false;
	int mouse_handled		= false;

	if (!(self->ext_flags & control_enabled))
	{
		return false;
	}

	// Make sure the current control is focused.
	if (self->control_tree->focused_node)
	{
		// If the focused node isn't this one, refocus.
		if (self->control_tree->focused_node->payload != self)
		{
			mouse_handled = EZ_control_SetFocus(self);
		}
	}
	else
	{
		// If there's no focused node, focus on this one.
		mouse_handled = EZ_control_SetFocus(self);
	}

	if (self->int_flags & control_focused)
	{
		// Check if the mouse is at the edges of the control, and turn on the correct reszie mode if it is.
		if (((self->ext_flags & control_resize_h) || (self->ext_flags & control_resize_v)) && (ms->button_down == 1))
		{
			if (self->ext_flags & control_resize_h)
			{
				// Left side of the control.
				if (POINT_IN_RECTANGLE(ms->x, ms->y,
					self->absolute_x, self->absolute_y,
					self->resize_handle_thickness, self->height))
				{
					self->int_flags |= control_resizing_left;
					mouse_handled = true;
				}

				// Right side of the control.
				if (POINT_IN_RECTANGLE(ms->x, ms->y,
					self->absolute_x + self->width - self->resize_handle_thickness, self->absolute_y,
					self->resize_handle_thickness, self->height))
				{
					self->int_flags |= control_resizing_right;
					mouse_handled = true;
				}
			}

			if (self->ext_flags & control_resize_v)
			{
				// Top of the control.
				if (POINT_IN_RECTANGLE(ms->x, ms->y,
					self->absolute_x, self->absolute_y,
					self->width, self->resize_handle_thickness))
				{
					self->int_flags |= control_resizing_top;
					mouse_handled = true;
				}

				// Bottom of the control.
				if (POINT_IN_RECTANGLE(ms->x, ms->y,
					self->absolute_x, self->absolute_y + self->height - self->resize_handle_thickness,
					self->width, self->resize_handle_thickness))
				{
					self->int_flags |= control_resizing_bottom;
					mouse_handled = true;
				}
			}
		}

		// The control is being moved.
		if ((self->ext_flags & control_movable) && (ms->button_down == 1))
		{
			self->int_flags |= control_moving;
			mouse_handled = true;
		}

		if (ms->button_down)
		{
			self->int_flags |= control_clicked;
			mouse_handled = true;
		}
	}

	/*
	TODO : Fix OnMouseClick
	if(!mouse_handled)
	{
		CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, OnMouseClick, mouse_state);
	}
	*/

	CONTROL_EVENT_HANDLER_CALL(&mouse_handled_tmp, self, ez_control_t, OnMouseDown, ms);
	mouse_handled = (mouse_handled || mouse_handled_tmp);

	return mouse_handled;
}

/*
// TODO : Add support for mouse wheel.
//
// Control - The mouse wheel was triggered within the bounds of the control.
//
int EZ_control_OnMouseWheel(ez_control_t *self, mouse_state_t *mouse_state)
{
	int wheel_handled = false;
	CONTROL_EVENT_HANDLER_CALL(&wheel_handled, self, ez_control_t, OnMouseWheel, mouse_state);
	return wheel_handled;
}
*/

//
// Control - The mouse is hovering within the bounds of the control.
//
int EZ_control_OnMouseHover(ez_control_t *self, mouse_state_t *mouse_state)
{
	int mouse_handled = false;

	if (!mouse_handled)
	{
		CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseHover, mouse_state);
	}

	return mouse_handled;
}

//
// Control - Sets the overall opacity of the control (including its children).
//
void EZ_control_SetOpacity(ez_control_t *self, float opacity)
{
	self->opacity = bound(0, opacity, 1.0);
	CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnOpacityChanged, NULL);
}

//
// Control - The opacity of the control has just changed.
//
int EZ_control_OnOpacityChanged(ez_control_t *self, void *ext_event_info)
{
	ez_control_t *child = NULL;
	ez_dllist_node_t *iter = self->children.head;

	// Add our parents opacity to the equation.
	self->overall_opacity = self->parent ? (self->opacity * self->parent->overall_opacity) : self->opacity;

	// Tell the children we've changed opacity.
	while (iter)
	{
		child = (ez_control_t *)iter->payload;
		CONTROL_RAISE_EVENT(NULL, child, ez_control_t, OnOpacityChanged, NULL);
		iter = iter->next;
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnOpacityChanged, NULL);
	return 0;
}

//
// Control - Resizes the virtual size of the control based on the position/size of the child
//           to make sure that it fits within the parents scrollable area.
//
static void EZ_control_ResizeVirtualSizeBasedOnChild(ez_control_t *self, ez_control_t *child)
{
	int child_right_edge	= (child->x + child->width);
	int child_bottom_edge	= (child->y + child->height);
	int new_vwidth			= self->virtual_width;
	int new_vheight			= self->virtual_height;

	if (child_right_edge > self->virtual_width)
	{
		new_vwidth = self->virtual_width + child_right_edge;
	}

	if (child_bottom_edge > self->virtual_height)
	{
		new_vheight = self->virtual_height + child_bottom_edge;
	}

	if ((new_vwidth != self->virtual_width) && (new_vheight != self->virtual_height))
	{
		EZ_control_SetVirtualSize(self, new_vwidth, new_vheight);
	}

	// TODO: Hmm should probably shrink the virtual size also, but then we'd have to loop through all children to make sure none are left out.
}

//
// Control - A child control has been moved.
//
int EZ_control_OnChildMoved(ez_control_t *self, ez_control_t *child)
{
	EZ_control_ResizeVirtualSizeBasedOnChild(self, child);

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnChildMoved, child);
	return 0;
}

//
// Control - A child control has been resized.
//
int EZ_control_OnChildResize(ez_control_t *self, ez_control_t *child)
{
	EZ_control_ResizeVirtualSizeBasedOnChild(self, child);

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnChildResize, child);
	return 0;
}


================================================
FILE: src/ez_controls.h
================================================
#ifndef __EZ_CONTROLS_H__
#define __EZ_CONTROLS_H__
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_controls.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

//
// Description
//
// Basic design princilples
// ------------------------
// The base design principle for the framework is a "light" version of Object Orientated Programming (OOP).
// That is, all controls are regarded as objects that has methods associated with them that are used
// to manipulate them and change their inner state.
//
// Implementation
// --------------
// Each "class" in the framework consists of a struct and a set of methods, with the following name schemes:
// Struct: ez_nameofobject_t
// Method: EZ_name_of_object_NameOfMethod(...)
// 
// All methods that are associated with a particular object ALWAYS has a pointer to the object's struct type as the first
// argument of the function, that is:
// EZ_nameofobject_NameOfMethod(ez_nameofobject_t *self, ...);
//
// This means that "self" in this case can be regarded as the keyword "this" usually used in OOP languages.
// This way only objects that are of the type ez_nameofobject_t are allowed to run the method. A NULL pointer
// must never be passed to a method.
//
// Each object has the following types of methods:
//
// - Create method:
//   The create method allocates the memory of the object and then passes it on to the Init method.
//
// - Init method:
//   The init method initializes all the variables of the object and sets all the function pointers
//   for the different methods.
//
// - Set methods: 
//   Used to set properties of the object, such as changing the inner state of the object struct.
//
// - Get methods: 
//   Gets inner state from the object.
//
// - Event implementations: 
//   This is a core implementation for the object, such as OnDraw, that draws the control which will be 
//   called on all objects by the framework. An object must have an implementation for all of the events
//   that are associated with it. An event is raised using CONTROL_RAISE_EVENT when something happens
//   inside of the object, such as the width changes or a key is pressed.
//   (See the comment for the CONTROL_RAISE_EVENT macro for more detail on how this works).
//
// - Event handlers: 
//   These are optional functions that are set by the user of the framework, these can be set for each of 
//   the events described above. For instance, this can be used for running some specified function when 
//   a button is pressed. These are only run after all event implementations for that particular event
//   has been run in the class tree (see inheritance).
//   (See the comment for CONTROL_EVENT_HANDLER_CALL for more detail on how this works).
//
// The events and event handlers associated with an object are specified in a separate struct named
// "ez_nameofobject_events_t", which contains a set of function pointers to the different events associated
// with the object type. Each object then has two variables of this struct type in it named "events"
// and "event_handlers". All the function pointers in the events variable has to be set in the objects
// init function, but the function pointers in the "event_handlers" variable doesn't need to be set at all,
// they're set by the user of the object when needed.
//
// NOTICE! It is important that the contents of the object structs are NEVER changed directly, but always
// to the methods specified for the object. This is an important principle in OOP programming, hiding
// internal information from the outside world. Changing struct information directly might lead to crucial
// events not being raised which in turn puts the object in an undefined state.
//
// Inheritance
// -----------
// An object in the framework can inherit functionality from other objects, and override / reimplement their
// event methods (actually, more like extending than overriding to be precise). This is achieved by creating
// a new object, and at the beginning of the objects struct we place the object of the type we want to inherit from.
// That is:
//
// typedef struct ez_object2_s
// {
//		ez_object1_t super;
//		...
// } ez_object2_t;
//
// It is now possible to cast ez_object2_t to ez_object1_t, and use it with any object1 methods:
// ez_object2_t obj2 = EZ_object2_Create(...);
// EZ_object1_SomeObject1Method((ez_object1_t *)obj2);
//
// To be able to call all the methods of a particular event implementation involving inheritance, and the only
// run the event handler associated with that event ONCE at the end. That is, first let the control change it's
// internal state, and then finally signaling the outside world. The macros CONTROL_RAISE_EVENT and 
// CONTROL_EVENT_HANDLER_CALL are used, see the comment for them below for more detailed information on how they work.
//
// Each object struct contains a CLASS_ID used to identify what type of object it is, this should be unique for
// each object type. This is set at init of the control, and should never be changed after that.
//
// Control objects (ez_control_t / EZ_control_*)
// ---------------------------------------------
// Building on the principles described above the base object for all controls in the UI framework is defined
// with the ez_control_t struct and EZ_control_* methods. This object implements all the base functionality that
// are needed for a control, such as:
// - Mouse handling
//   * Each control gets an initial event whenever the mouse state changes in some way, 
//     mouse moved, or a button was pressed.
//   * The event is processed and if the mouse was inside the control and a button was pressed for instance
//     a more detailed event is raised, targeted only to that control. Examples of this:
//     OnMouseDown, OnMouseUp, OnMouseHover, OnMouseEnter, OnMouseLeave...
// - Key events
// - Moving
// - Resizing
// - Scrolling
//   * Each control has a visible area, and a "virtual" area, which can be scrolled within.
//
// The ez_control_t object also contains a list of children, sub-controls that are placed inside of that control
//
// All controls then inherits from this object, and extends the events it has defined, or adds new events.
//
// Control tree
// ------------
// To tie all these controls together, a root object exists called ez_tree_t. This tree has a pointer to
// the root control of the tree, which all of the other controls are contained within (this control usually
// has the same size as the screen). It also contains two lists, one is the draw list which holds the
// order in which the controls should be drawn in. The other is the tab list, which holds the order that
// the controls can be "tabbed" between (if the control is focusable).
//
// All instances of a control MUST be associated with a control tree that is passed to the creation function
// of the control.
//
// All input is sent to the control tree, which in turn propagates them to the controls that should have it.
// The control tree is also responsible for raising the OnDraw event for all the controls (in the order
// specified in it's draw list).
//
// There can be any number of control trees running at the same time, but the intended practice is to
// only use one at any given time.
//
// -- Cokeman 2007
//

#define POINT_IN_RECTANGLE(p_x, p_y, r_x, r_y, vid_width, vid_height) ((p_x >= r_x) && (p_y >= r_y) && (p_x <= (r_x + vid_width)) && (p_y <= (r_y + vid_height)))
#define POINT_X_IN_BOUNDS(p_x, left, right)	((p_x >= left) && (p_x <= right))
#define POINT_Y_IN_BOUNDS(p_y, top, bottom)	((p_y >= top)  && (p_y <= bottom))
#define POINT_IN_BOUNDS(p_x, p_y, left, right, top, bottom)	(POINT_X_IN_BOUNDS(p_x, left, right) && POINT_Y_IN_BOUNDS(p_y, top, bottom))

#define POINT_X_IN_CONTROL_DRAWBOUNDS(ctrl, p_x) (POINT_X_IN_BOUNDS(p_x, (ctrl)->bound_left, (ctrl)->bound_right))
#define POINT_Y_IN_CONTROL_DRAWBOUNDS(ctrl, p_y) (POINT_Y_IN_BOUNDS(p_y, (ctrl)->bound_top, (ctrl)->bound_bottom))
#define POINT_IN_CONTROL_DRAWBOUNDS(ctrl, p_x, p_y) (POINT_X_IN_CONTROL_DRAWBOUNDS(ctrl, p_x) && POINT_Y_IN_CONTROL_DRAWBOUNDS(ctrl, p_y))
#define POINT_IN_CONTROL_RECT(ctrl, p_x, p_y) POINT_IN_RECTANGLE(p_x, p_y, (ctrl)->absolute_x, (ctrl)->absolute_y, (ctrl)->width, (ctrl)->height)

#define SET_FLAG(flag_var, flag, on) ((flag_var) = ((on) ? ((flag_var) | (flag)) : ((flag_var) & ~(flag))))

typedef enum ez_control_id_e
{
	EZ_CONTROL_ID,
	EZ_BUTTON_ID,
	EZ_LABEL_ID,
	EZ_SLIDER_ID,
	EZ_SCROLLBAR_ID,
	EZ_SCROLLPANE_ID,
	EZ_WINDOW_ID,
	EZ_LISTVIEW_ID,
	EZ_LISTVIEWITEM_ID
} ez_control_id_t;

// =========================================================================================
// Double Linked List
// =========================================================================================

// 
// Double Linked List - Function pointer types.
//
typedef int (* PtFuncCompare)(const void *, const void *);

typedef struct ez_dllist_node_s
{
	struct ez_dllist_node_s *next;
	struct ez_dllist_node_s *previous;
	void *payload;
} ez_dllist_node_t;

typedef struct ez_double_linked_list_s
{
	int count;
	ez_dllist_node_t *head;
	ez_dllist_node_t *tail;
} ez_double_linked_list_t;

//
// Double Linked List - Add item to double linked list.
//
void EZ_double_linked_list_Add(ez_double_linked_list_t *list, void *payload);

//
// Double Linked List - Finds a given node based on the specified payload.
//
ez_dllist_node_t *EZ_double_linked_list_FindByPayload(const ez_double_linked_list_t *list, const void *payload);

//
// Double Linked List - Find a item by its index.
//
ez_dllist_node_t *EZ_double_linked_list_FindByIndex(const ez_double_linked_list_t *list, int index);

//
// Double Linked List - Removes an item from a linked list by its index.
//
void *EZ_double_linked_list_RemoveByIndex(ez_double_linked_list_t *list, int index);

//
// Double Linked List - Removes an item from a linked list by its payload.
//
void *EZ_double_linked_list_RemoveByPayload(ez_double_linked_list_t *list, void *payload);

//
// Double Linked List - A function pointer to a cleanup function that is run on each item when removing a range of items.
//
typedef void (*ez_removerange_cleanup_function_t)(void *payload);

//
// Double Linked List - Removes a range of items in the list. 
//						A cleanup function needs to be supplied so that the payload of the item is also cleaned up.
//
void EZ_double_linked_list_RemoveRange(ez_double_linked_list_t *list, int start, int end, ez_removerange_cleanup_function_t func);

//
// Double Linked List - Removes the first occurance of the item from double linked list and returns its payload.
//
void *EZ_double_linked_list_Remove(ez_double_linked_list_t *list, ez_dllist_node_t *item);

//
// Double Linked List - Orders a list.
//
void EZ_double_linked_list_Sort(ez_double_linked_list_t *list, PtFuncCompare compare_function);

// =========================================================================================
// Control Tree
// =========================================================================================

typedef struct ez_tree_s
{
	struct ez_control_s		*root;					// The control tree.
	qbool					destroying;				// Is the tree being destroyed? So we don't try to run any events when stuff is being removed.
	ez_dllist_node_t		*focused_node;			// The node of focused control (from the tablist). 
	ez_double_linked_list_t	drawlist;				// A list with the controls ordered in their drawing order.
	ez_double_linked_list_t	tablist;				// A list with the controls ordered in their tabbing order.

	mouse_state_t			prev_mouse_state;		// The last mouse state we received.
	double					mouse_pressed_time[9];	// How long the mouse buttons have been pressed. (Used for repeating mouse click events).
} ez_tree_t;

//
// Control Tree - Orders the tab list based on the tab order property.
//
void EZ_tree_OrderTabList(ez_tree_t *tree);

//
// Control Tree - Orders the draw list based on the draw order property.
//
void EZ_tree_OrderDrawList(ez_tree_t *tree);

//
// Control Tree - Needs to be called every frame to keep the tree alive.
//
void EZ_tree_EventLoop(ez_tree_t *tree);

//
// Control Tree - Dispatches a mouse event to a control tree.
//
qbool EZ_tree_MouseEvent(ez_tree_t *tree, mouse_state_t *ms);

//
// Control Tree - Key event.
//
qbool EZ_tree_KeyEvent(ez_tree_t *tree, int key, int unichar, qbool down);

//
// Tree Control - Finds any orphans and adds them to the root control.
//
void EZ_tree_UnOrphanizeChildren(ez_tree_t *tree);

//
// Control Tree - Refreshes the position of all controls in the tree.
//
void EZ_tree_Refresh(ez_tree_t *tree);

//
// Control Tree - Destroys a tree. Will not free the memory for the tree.
//
void EZ_tree_Destroy(ez_tree_t *tree);

// =========================================================================================
// Event handler 
// =========================================================================================

//
// Event function pointer types.
//
typedef int (*ez_event_fp) (struct ez_control_s *self, void *ext_event_info);
typedef int (*ez_mouse_event_fp) (struct ez_control_s *self, mouse_state_t *mouse_state);
typedef int (*ez_key_event_fp) (struct ez_control_s *self, int key, int unichar, qbool down);
typedef int (*ez_keyspecific_event_fp) (struct ez_control_s *self, int key, int unichar);
typedef int (*ez_destroy_event_fp) (struct ez_control_s *self, qbool destroy_children);
typedef int (*ez_child_event_fp) (struct ez_control_s *self, struct ez_control_s *child);

//
// Event handlers function pointer types (same as event function types, except they have a payload also).
//
typedef int (*ez_eventhandler_fp) (struct ez_control_s *self, void *payload, void *ext_info);
typedef int (*ez_mouse_eventhandler_fp) (struct ez_control_s *self, void *payload, mouse_state_t *mouse_state);
typedef int (*ez_key_eventhandler_fp) (struct ez_control_s *self, void *payload, int key, int unichar, qbool down);
typedef int (*ez_keyspecific_eventhandler_fp) (struct ez_control_s *self, void *payload, int key, int unichar);
typedef int (*ez_destroy_eventhandler_fp) (struct ez_control_s *self, void *payload, qbool destroy_children);
typedef int (*ez_child_eventhandler_event_fp) (struct ez_control_s *self, void *payload, struct ez_control_s *child);

#define EZ_CONTROL_HANDLER			0
#define EZ_CONTROL_MOUSE_HANDLER	1
#define EZ_CONTROL_KEY_HANDLER		2
#define EZ_CONTROL_KEYSP_HANDLER	3
#define EZ_CONTROL_DESTROY_HANDLER	4
#define EZ_CONTROL_CHILD_HANDLER	5

typedef union ez_eventhandlerfunction_u
{
	ez_eventhandler_fp				normal;
	ez_mouse_eventhandler_fp		mouse;
	ez_key_eventhandler_fp			key;
	ez_keyspecific_eventhandler_fp	key_sp;
	ez_destroy_eventhandler_fp		destroy;
	ez_child_eventhandler_event_fp	child;
} ez_eventhandlerfunction_t;

typedef struct ez_eventhandler_s
{
	int							function_type;
	ez_eventhandlerfunction_t	function;
	void						*payload;
	struct ez_eventhandler_s	*next;
} ez_eventhandler_t;

#define CONTROL_ADD_EVENTHANDLER(ctrl, func_type, eventfunc, eventroot, eventname, payload)	\
{																							\
	ez_eventhandler_t *e = EZ_eventhandler_Create((void *)eventfunc, func_type, payload);	\
	eventroot *c = (eventroot *)ctrl;														\
	if (c->event_handlers.eventname)														\
		e->next = c->event_handlers.eventname;												\
	c->event_handlers.eventname = e;														\
}

#define CONTROL_REMOVE_EVENTHANDLER(ctrl, func, eventroot, eventname)			\
{																				\
	eventroot *c = (eventroot *)ctrl;											\
	EZ_eventhandler_Remove(c->event_handlers.eventname, func, false);			\
}

//
// Eventhandler - Goes through the list of events and removes the one with the specified function.
//
void EZ_eventhandler_Remove(ez_eventhandler_t *eventhandler, void *event_func, qbool all);

//
// Eventhandler - Creates a eventhandler.
//
ez_eventhandler_t *EZ_eventhandler_Create(void *event_func, int func_type, void *payload);

// =========================================================================================
// Control
// =========================================================================================

#define CONTROL_IS_CONTAINED(self) (self->parent && (self->ext_flags & control_contained))

//
// Raises an event. (See the CONTROL_EVENT_HANDLER_CALL for a more detailed explination of how this works).
//
#ifdef __INTEL_COMPILER

#define CONTROL_RAISE_EVENT(retval, ctrl, eventroot, eventhandler, ...)											\
{																												\
	int temp = 0;																								\
	int *p = (int *)retval;																						\
	eventroot *c = (eventroot *)(ctrl);																			\
	c->override_counts.eventhandler = c->inherit_levels.eventhandler;											\
	if(!c->events.eventhandler)																					\
		Sys_Error("CONTROL_RAISE_EVENT : "#ctrl" ("#eventroot") has no event function for "#eventhandler);		\
	temp = c->events.eventhandler((ez_control_t *)(ctrl), __VA_ARGS__);											\
	if(p) (*p) = temp;																							\
}																																																	

#else

#define CONTROL_RAISE_EVENT(retval, ctrl, eventroot, eventhandler, ...)											\
{																												\
	int temp = 0;																								\
	int *p = (int *)retval;																						\
	eventroot *c = (eventroot *)(ctrl);																			\
	c->override_counts.eventhandler = c->inherit_levels.eventhandler;											\
	if(!c->events.eventhandler)																					\
		Sys_Error("CONTROL_RAISE_EVENT : "#ctrl" ("#eventroot") has no event function for "#eventhandler);		\
	temp = c->events.eventhandler((ez_control_t *)(ctrl), ##__VA_ARGS__);										\
	if(p) (*p) = temp;																							\
}

#endif // __INTEL_COMPILER

//
// Calls the event handler associated with an event after all controls have run their implementation of the event.
//
// Example: OnMouseUp defined in ez_control_t
// 1. Run EZ_control_OnMouseUp
// 2. Run EZ_label_OnMouseUp (Set in ctrl->events.OnMouseUp, which in turn MUST call EZ_control_OnMouseUp
//    the first thing it does).
// 3. Run any specified event handler associated with the OnMouseUp event. ctrl->event_handlers.OnMouseUp
//
// This works by having an "inheritance level" and "override count" in each control struct:
// Inheritance level:
// ------------------
// ez_control_t = 0
// ez_label_t	= 1
//
// When an initial event is raised using the CONTROL_RAISE_EVENT macro, the "override count" for the struct 
// is reset to the value of the "inheritance level" (which is always the same). Then each time that
// the CONTROL_EVENT_HANDLER_CALL is called, first in the ez_control_t implementation of the event
// and then in the ez_label_t implementation, the "override count" is decremented, and when it reaches
// ZERO the event handler (if there's one set) will be run.
//
// If a control such as ez_label_t implements new events OnTextChanged for example, any class inheriting
// from ez_label_t will have to have a inheritance level relative to ez_label_t also.
// Example:
// ez_control_t inheritance level:			0				1				2
// ez_label_t	inheritance level:			-				0				1
// Inheritance:							ez_control_t <- ez_label_t <- ez_crazylabel_t
//
// ez_crazylabel_t *crazylabel = CREATE(...);
// ((ez_control_t *)crazylabel)->inheritance_level = 2; // Relative to ez_control_t
// ((ez_label_t *)  crazylabel)->inheritance_level = 1;	// Relative to ez_label_t
//
// So if I now want to override OnTextChanged specified in ez_label_t for ez_crazylabel_t, the 
// ez_label_t inheritance level is used by the macro. And if I override OnMouseUp, the ez_control_t
// inheritance level is used instead.
//
// retval		= An integer pointer to the var that should receive the return value of the event handler.
// ctrl			= The control struct to call the event handler on.
// eventroot	= The name of the control struct that has the "root implementation" of the specified event.
// eventhandler = The name of the event that should be called.
//
#ifdef __INTEL_COMPILER

#define CONTROL_EVENT_HANDLER_CALL(retval, ctrl, eventroot, evnthndler, ...)				\
{																							\
	int *p = (int *)retval, temp = 0;														\
	eventroot *c = (eventroot *)ctrl;														\
	if (c->event_handlers.evnthndler)														\
	{																						\
		if (c->override_counts.evnthndler == 1)												\
		{																					\
			ez_eventhandler_t *e = c->event_handlers.evnthndler;							\
			while (e)																		\
			{																				\
				EZ_eventhandler_Exec(e, (ez_control_t *)ctrl, __VA_ARGS__);					\
				e = e->next;																\
			}																				\
		}																					\
		else																				\
			c->override_counts.evnthndler--;												\
	}																						\
	if(p) (*p) = temp;																		\
}


#else

#define CONTROL_EVENT_HANDLER_CALL(retval, ctrl, eventroot, evnthndler, ...)				\
{																							\
	int *p = (int *)retval, temp = 0;														\
	eventroot *c = (eventroot *)ctrl;														\
	if (c->event_handlers.evnthndler)														\
	{																						\
		if (c->override_counts.evnthndler == 1)												\
		{																					\
			ez_eventhandler_t *e = c->event_handlers.evnthndler;							\
			while (e)																		\
			{																				\
				EZ_eventhandler_Exec(e, (ez_control_t *)ctrl, ##__VA_ARGS__);				\
				e = e->next;																\
			}																				\
		}																					\
		else																				\
			c->override_counts.evnthndler--;												\
	}																						\
	if(p) (*p) = temp;																		\
}

#endif // __INTEL_COMPILER

//
// Registers a event function an event and sets it's inheritance level.
// ctrl			= The control that the event function should be registered to.
// eventfunc	= The function implementing the event. (Ex. EZ_control_OnMouseDown)
// eventname	= The name of the event. (Ex. OnMouseDown)
// eventroot	= The control that initially defined this event. (Ex. ez_control_t)
//
#define CONTROL_REGISTER_EVENT(ctrl, eventfunc, eventname, eventroot)	\
{																		\
	((eventroot *)ctrl)->events.eventname = eventfunc;					\
	((eventroot *)ctrl)->inherit_levels.eventname++;					\
}

typedef struct ez_control_eventcount_s
{
	int	OnMouseEvent;
	int	OnMouseClick;
	int	OnMouseUp;
	int	OnMouseUpOutside;
	int	OnMouseDown;
	int	OnMouseHover;
	int	OnMouseEnter;
	int	OnMouseLeave;
	int	OnKeyEvent;
	int	OnKeyDown;
	int	OnKeyUp;
	int	OnLayoutChildren;
	int	OnDraw;
	int	OnDestroy;
	int	OnMove;
	int	OnScroll;
	int	OnParentScroll;
	int	OnResize;
	int	OnParentResize;
	int	OnGotFocus;
	int	OnLostFocus;
	int	OnVirtualResize;
	int	OnMinVirtualResize;
	int	OnFlagsChanged;
	int OnResizeHandleThicknessChanged;
	int OnEventHandlerChanged;
	int OnAnchorChanged;
	int OnVisibilityChanged;
	int OnOpacityChanged;
	int OnChildMoved;
	int OnChildResize;
} ez_control_eventcount_t;

typedef struct ez_control_events_s
{
	ez_mouse_event_fp			OnMouseEvent;
	ez_mouse_event_fp			OnMouseClick;
	ez_mouse_event_fp			OnMouseUp;
	ez_mouse_event_fp			OnMouseUpOutside;
	ez_mouse_event_fp			OnMouseDown;
	ez_mouse_event_fp			OnMouseHover;
	ez_mouse_event_fp			OnMouseEnter;
	ez_mouse_event_fp			OnMouseLeave;
	ez_key_event_fp				OnKeyEvent;
	ez_keyspecific_event_fp		OnKeyDown;
	ez_keyspecific_event_fp		OnKeyUp;
	ez_event_fp					OnLayoutChildren;
	ez_event_fp					OnDraw;
	ez_destroy_event_fp			OnDestroy;
	ez_event_fp					OnMove;
	ez_event_fp					OnScroll;
	ez_event_fp					OnParentScroll;
	ez_event_fp					OnResize;
	ez_event_fp					OnParentResize;
	ez_event_fp					OnGotFocus;
	ez_event_fp					OnLostFocus;
	ez_event_fp					OnVirtualResize;
	ez_event_fp					OnMinVirtualResize;
	ez_event_fp					OnFlagsChanged;
	ez_event_fp					OnResizeHandleThicknessChanged;
	ez_event_fp					OnEventHandlerChanged;
	ez_event_fp					OnAnchorChanged;
	ez_event_fp					OnVisibilityChanged;
	ez_event_fp					OnOpacityChanged;
	ez_child_event_fp			OnChildMoved;
	ez_child_event_fp			OnChildResize;
} ez_control_events_t;

typedef struct ez_control_eventhandlers_s
{					
	ez_eventhandler_t	*OnMouseEvent;
	ez_eventhandler_t	*OnMouseClick;
	ez_eventhandler_t	*OnMouseUp;
	ez_eventhandler_t	*OnMouseUpOutside;
	ez_eventhandler_t	*OnMouseDown;
	ez_eventhandler_t	*OnMouseHover;
	ez_eventhandler_t	*OnMouseEnter;
	ez_eventhandler_t	*OnMouseLeave;
	ez_eventhandler_t	*OnKeyEvent;
	ez_eventhandler_t	*OnKeyDown;
	ez_eventhandler_t	*OnKeyUp;
	ez_eventhandler_t	*OnLayoutChildren;
	ez_eventhandler_t	*OnDraw;
	ez_eventhandler_t	*OnDestroy;
	ez_eventhandler_t	*OnMove;
	ez_eventhandler_t	*OnScroll;
	ez_eventhandler_t	*OnParentScroll;
	ez_eventhandler_t	*OnResize;
	ez_eventhandler_t	*OnParentResize;
	ez_eventhandler_t	*OnGotFocus;
	ez_eventhandler_t	*OnLostFocus;
	ez_eventhandler_t	*OnVirtualResize;
	ez_eventhandler_t	*OnMinVirtualResize;
	ez_eventhandler_t	*OnFlagsChanged;
	ez_eventhandler_t	*OnResizeHandleThicknessChanged;
	ez_eventhandler_t	*OnEventHandlerChanged;
	ez_eventhandler_t	*OnAnchorChanged;
	ez_eventhandler_t	*OnVisibilityChanged;
	ez_eventhandler_t	*OnOpacityChanged;
	ez_eventhandler_t	*OnChildMoved;
	ez_eventhandler_t	*OnChildResize;
} ez_control_eventhandlers_t;

typedef enum ez_anchor_e
{
	anchor_none		= (1 << 0),
	anchor_left		= (1 << 1), 
	anchor_right	= (1 << 2),
	anchor_top		= (1 << 3),
	anchor_bottom	= (1 << 4)
} ez_anchor_t;

//
// Control - External flags.
//
typedef enum ez_control_flags_e
{
	control_enabled				= (1 << 0),		// Is the control usable?
	control_movable				= (1 << 1),		// Can the control be moved?
	control_focusable			= (1 << 2),		// Can the control be given focus?
	control_resize_h			= (1 << 3),		// Is the control resizeable horizontally?
	control_resize_v			= (1 << 4),		// Is the control resizeable vertically?
	control_resizeable			= (1 << 5),		// Is the control resizeable at all, not just by the user? // TODO : Should this be external?
	control_contained			= (1 << 6),		// Is the control contained within it's parent or can it go outside its edges?
	control_visible				= (1 << 7),		// Is the control visible?
	control_scrollable			= (1 << 8),		// Is the control scrollable
	control_ignore_mouse		= (1 << 9),		// Should the control ignore mouse input?
	control_anchor_viewport		= (1 << 10),	// Anchor to the visible edges of the controls instead of the virtual edges.
	control_move_parent			= (1 << 11),	// When moving this control, should we also move it's parent?
	control_listen_repeat_mouse	= (1 << 12),	// Should the control listen to repeated mouse button events?
	control_bg_tile_center		= (1 << 13),	// Tile the center of the background image (otherwise it will be stretched).
	control_bg_tile_edges		= (1 << 14)		// Tile the edges of the background image.
} ez_control_flags_t;

#define DEFAULT_CONTROL_FLAGS	(control_enabled | control_focusable | control_contained | control_scrollable | control_visible)

//
// Control - Internal flags.
//
typedef enum ez_control_iflags_e
{
	control_focused				= (1 << 0),		// Is the control currently in focus?
	control_moving				= (1 << 1),		// Is the control in the process of being moved?
	control_resizing_left		= (1 << 2),		// Are we resizing the control to the left?
	control_resizing_right		= (1 << 3),		// Are we resizing the control to the right?
	control_resizing_top		= (1 << 4),		// Resizing upwards.
	control_resizing_bottom		= (1 << 5),		// Resizing downards.
	control_clicked				= (1 << 6),		// Is the control being clicked? (If the mouse button is released outside the control a click event isn't raised).
	control_mouse_over			= (1 << 7),		// Is the mouse over the control?
	control_update_anchorgap	= (1 << 8),		// Update the anchor gap when resizing the control?
	control_hidden_by_parent	= (1 << 9)		// Is the control hidden cause it's parent is not visible?
} ez_control_iflags_t;

typedef struct ez_control_s
{
	ez_control_id_t			CLASS_ID;				// An ID unique for this class, this is set at initilization
													// and should never be changed after that.
	char					*name;					// The name of the control.
	char					*description;			// A short description of the control.
	
	int	 					x;						// Relative position to it's parent.
	int						y;

	int						prev_x;					// Previous position.
	int						prev_y;

	int						absolute_x;				// The absolute screen coordinates for the control.
	int						absolute_y;	

	int						prev_absolute_x;		// Previous absolute position.
	int						prev_absolute_y;
	
	int 					width;					// Size.
	int						height;
	
	int						prev_width;				// Previous size.
	int						prev_height;

	int						virtual_x;				// The relative position in the virtual window that the "real" window is showing.
	int						virtual_y;

	int						absolute_virtual_x;		// The absolute position of the virtual window on the screen.
	int						absolute_virtual_y;

	int						virtual_width;			// The virtual size of the control (scrollable area).
	int						virtual_height;

	int						prev_virtual_width;		// The previous virtual size of the control.
	int						prev_virtual_height;

	int						virtual_width_min;		// The virtual min size for the control.
	int						virtual_height_min;
	
	int						width_max;				// Max/min sizes for the control.
	int						width_min;
	int						height_max;
	int						height_min;

	int						bound_top;				// The bounds the control is allowed to draw within.
	int						bound_left;
	int						bound_right;
	int						bound_bottom;

	int						left_edge_gap;			// The gap to the different edges, used for anchoring
	int						right_edge_gap;			// if the parent controls size becomes less than the
	int						top_edge_gap;			// childs min size, we need to keep track of how far
	int						bottom_edge_gap;		// from the edge we were.

	ez_anchor_t				anchor_flags;			// Which parts of it's parent the control is anchored to.

	int						resize_handle_thickness;// The thickness of the resize handles on the sides of the control.

	int						draw_order;				// The order the control is drawn in.
	int						tab_order;				// The tab number of the control.
	
	ez_control_flags_t		ext_flags;				// External flags that decide how the control should behave. Movable, resizeable and such.
	ez_control_iflags_t		int_flags;				// Internal flags that holds the current state of the control, moving, resizing and so on.

	byte					background_color[4];	// The background color of the control RGBA.
	mpic_t					*background;			// The background picture.
	float					bg_edge_size_ratio;		// The percentage of the width of the background picture to use for drawing the edges 
													// of the background when drawn tiled. Value range 0.0 - 1.0
	float					bg_opacity;				// The opacity of the control.
	float					opacity;				// My own opacity only.
	float					overall_opacity;		// The overall opacity of the control (including my parents opacity).

	float					x_percent;				// The x position in percentage based on the parents width.
	float					y_percent;				// The y position in percentage based on the parents height.

	void					*payload;				// A pointer to some user specified data associated with the control. Up to the caller to clean this up.

	ez_control_events_t			events;				// The base reaction for events. Is only set at initialization.
	ez_control_eventhandlers_t	event_handlers;
	ez_control_eventcount_t		inherit_levels;		// The number of times each event has been overriden. 
													// (Countdown before executing the event handler for the event, after all
													// event implementations in the inheritance chain have been run).
	ez_control_eventcount_t override_counts;		// This is reset each time an event is raised by CONTROL_RAISE_EVENT to the
													// inheritance level for the event in question.

	qbool					initializing;			// Is the control initializing?

	struct ez_control_s		*parent;				// The parent of the control. Only the root node has no parent.
	ez_double_linked_list_t	children;				// List of children belonging to the control.

	struct ez_tree_s		*control_tree;			// The control tree the control belongs to.

	mouse_state_t			prev_mouse_state;		// The previous mouse event that was passed on to this control.
	double					mouse_repeat_delay;		// The time to wait before raising a new mouse click event for this control (if control_listen_repeat_mouse is set).
} ez_control_t;

//
// Eventhandler - Execute an event handler. (We declare this here cause ez_control_t hasn't been defined above)
//
void EZ_eventhandler_Exec(ez_eventhandler_t *event_handler, ez_control_t *ctrl, ...);

//
// Control - Creates a new control and initializes it.
//
ez_control_t *EZ_control_Create(ez_tree_t *tree, ez_control_t *parent, 
							  char *name, char *description, 
							  int x, int y, int width, int height, 
							  int flags);

//
// Control - Initializes a control and adds it to the specified control tree.
//
void EZ_control_Init(ez_control_t *control, ez_tree_t *tree, ez_control_t *parent, 
							  char *name, char *description, 
							  int x, int y, int width, int height, 
							  ez_control_flags_t flags);

//
// Control - Destroys a specified control.
//
int EZ_control_Destroy(ez_control_t *self, qbool destroy_children);

//
// Control - 
// Returns the screen position of the control. This will be different for a scrollable window
// since it's drawing position differs from the windows actual position on screen.
//
void EZ_control_GetDrawingPosition(ez_control_t *self, int *x, int *y);

//
// Control - Gets the anchor flags.
//
ez_anchor_t EZ_control_GetAnchor(ez_control_t *self);

//
// Control - Sets the external flags of the control.
//
ez_control_flags_t EZ_control_GetFlags(ez_control_t *self);

//
// Control - Sets the external flags of the control.
//
void EZ_control_SetFlags(ez_control_t *self, ez_control_flags_t flags);

//
// Control - Set the thickness of the resize handles (if any).
//
void EZ_control_SetResizeHandleThickness(ez_control_t *self, int thickness);

//
// Control - Sets whetever the control is scrollable or not.
//
void EZ_control_SetScrollable(ez_control_t *self, qbool scrollable);

//
// Control - Sets if the control should move it's parent when it moves itself.
//
void EZ_control_SetMovesParent(ez_control_t *self, qbool moves_parent);

//
// Control - Sets whetever the control is visible or not.
//
void EZ_control_SetVisible(ez_control_t *self, qbool visible);

//
// Control - Sets whetever the control is resizeable vertically by the user.
//
void EZ_control_SetResizeableVertically(ez_control_t *self, qbool resize_vertically);

//
// Control - Sets whetever the control is resizeable at all, not just by the user.
//
void EZ_control_SetResizeable(ez_control_t *self, qbool resizeable);

//
// Control - Sets whetever the control is resizeable both horizontally and vertically by the user.
//
void EZ_control_SetResizeableBoth(ez_control_t *self, qbool resize);

//
// Control - Sets whetever the control is resizeable horizontally by the user.
//
void EZ_control_SetResizeableHorizontally(ez_control_t *self, qbool resize_horizontally);

//
// Control - Sets whetever the control is focusable.
//
void EZ_control_SetFocusable(ez_control_t *self, qbool focusable);

//
// Control - Sets whetever the control is movable.
//
void EZ_control_SetMovable(ez_control_t *self, qbool movable);

//
// Control - Sets whetever the control is enabled or not.
//
void EZ_control_SetEnabled(ez_control_t *self, qbool enabled);

//
// Control - Set the background image for the control.
//
void EZ_control_SetBackgroundImage(ez_control_t *self, const char *background_path);

//
// Control - Set the opacity for the background image for the control.
//
void EZ_control_SetBackgroundImageOpacity(ez_control_t *self, float opacity);

//
// Control - Set how much percentage of the width of the background image that should be used when drawing the edges of the control.
//
void EZ_control_SetBackgroundImageEdgePercentage(ez_control_t *self, int percentage);

//
// Control - Set if the center of the button should be tiled or stretched.
//
void EZ_control_SetBackgroundTileCenter(ez_control_t *self, qbool tilecenter);

//
// Control - Set if the edges of the button should be tiled or stretched.
//
void EZ_control_SetBackgroundTileEdges(ez_control_t *self, qbool tileedges);

//
// Control - Sets whetever the control is contained within the bounds of it's parent or not, or is allowed to draw outside it.
//
void EZ_control_SetContained(ez_control_t *self, qbool contained);

//
// Control - Sets whetever the control should care about mouse input or not.
//
void EZ_control_SetIgnoreMouse(ez_control_t *self, qbool ignore_mouse);

//
// Control - Listen to repeated mouse click events when holding down a mouse button. 
//           The delay between events is set using EZ_control_SetRepeatMouseClickDelay(...)
//
void EZ_control_SetListenToRepeatedMouseClicks(ez_control_t *self, qbool listen_repeat);

//
// Control - Sets the amount of time to wait between each new mouse click event
//           when holding down the mouse over a control.
//
void EZ_control_SetRepeatMouseClickDelay(ez_control_t *self, double delay);

//
// Control - Sets the OnDestroy event handler.
//
void EZ_control_AddOnDestroy(ez_control_t *self, ez_destroy_eventhandler_fp OnDestroy, void *payload);

//
// Control - Sets the OnLayoutChildren event handler.
//
void EZ_control_AddOnLayoutChildren(ez_control_t *self, ez_eventhandler_fp OnLayoutChildren, void *payload);

//
// Control - Sets the OnMove event handler.
//
void EZ_control_AddOnMove(ez_control_t *self, ez_eventhandler_fp OnMove, void *payload);

//
// Control - Sets the OnScroll event handler.
//
void EZ_control_AddOnScroll(ez_control_t *self, ez_eventhandler_fp OnScroll, void *payload);

//
// Control - Sets the OnResize event handler.
//
void EZ_control_AddOnResize(ez_control_t *self, ez_eventhandler_fp OnResize, void *payload);

//
// Control - Sets the OnParentResize event handler.
//
void EZ_control_AddOnParentResize(ez_control_t *self, ez_eventhandler_fp OnParentResize, void *payload);

//
// Control - Sets the OnVirtualResize event handler.
//
void EZ_control_AddOnVirtualResize(ez_control_t *self, ez_eventhandler_fp OnVirtualResize, void *payload);

//
// Control - Sets the OnMinVirtualResize event handler.
//
void EZ_control_AddOnMinVirtualResize(ez_control_t *self, ez_eventhandler_fp OnMinVirtualResize, void *payload);

//
// Control - Sets the OnFlagsChanged event handler.
//
void EZ_control_AddOnFlagsChanged(ez_control_t *self, ez_eventhandler_fp OnFlagsChanged, void *payload);

//
// Control - Sets the OnKeyEvent event handler.
//
void EZ_control_AddOnKeyEvent(ez_control_t *self, ez_key_eventhandler_fp OnKeyEvent, void *payload);

//
// Control - Sets the OnLostFocus event handler.
//
void EZ_control_AddOnLostFocus(ez_control_t *self, ez_eventhandler_fp OnLostFocus, void *payload);

//
// Control - Sets the OnGotFocus event handler.
//
void EZ_control_AddOnGotFocus(ez_control_t *self, ez_eventhandler_fp OnGotFocus, void *payload);

//
// Control - Sets the OnMouseHover event handler.
//
void EZ_control_AddOnMouseHover(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseHover, void *payload);

//
// Control - Sets the OnMouseLeave event handler.
//
void EZ_control_AddOnMouseLeave(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseLeave, void *payload);

//
// Control - Sets the OnMouseEnter event handler.
//
void EZ_control_AddOnMouseEnter(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseEnter, void *payload);

//
// Control - Sets the OnMouseClick event handler.
//
void EZ_control_AddOnMouseClick(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseClick, void *payload);

//
// Control - Sets the OnMouseEvent event handler.
//
void EZ_control_AddOnMouseUp(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseUp, void *payload);

//
// Control - Sets the OnMouseUp event handler.
//
void EZ_control_AddOnMouseUp(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseUp, void *payload);

//
// Control - Sets the OnMouseDown event handler.
//
void EZ_control_AddOnMouseDown(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseDown, void *payload);

//
// Control - Sets the OnMouseEvent event handler.
//
void EZ_control_AddOnMouseEvent(ez_control_t *self, ez_mouse_eventhandler_fp OnMouseEvent, void *payload);

//
// Control - Sets the OnDraw event handler.
//
void EZ_control_AddOnDraw(ez_control_t *self, ez_eventhandler_fp OnDraw, void *payload);

//
// Control - Set the event handler for the OnEventHandlerChanged event.
//
void EZ_control_AddOnEventHandlerChanged(ez_control_t *self, ez_eventhandler_fp OnEventHandlerChanged, void *payload);

//
// Control - Sets the OnResizeHandleThicknessChanged event handler.
//
void EZ_control_AddOnResizeHandleThicknessChanged(ez_control_t *self, ez_eventhandler_fp OnResizeHandleThicknessChanged, void *payload);

//
// Control - Sets the OnChildMoved event handler.
//
void EZ_control_AddOnChildMoved(ez_control_t *self, ez_eventhandler_fp OnChildMoved, void *payload);

//
// Control - Sets the OnChildResize event handler.
//
void EZ_control_AddOnChildResize(ez_control_t *self, ez_eventhandler_fp OnChildResize, void *payload);

//
// Control - Set color of a control.
//
void EZ_control_SetBackgroundColor(ez_control_t *self, byte r, byte g, byte b, byte alpha);

//
// Control - Sets the tab order of a control.
//
void EZ_control_SetDrawOrder(ez_control_t *self, int draw_order, qbool update_children);

//
// Control - Sets the payload for the control.
//
void EZ_control_SetPayload(ez_control_t *self, void *payload);

//
// Control - Sets the size of a control.
//
void EZ_control_SetSize(ez_control_t *self, int width, int height);

//
// Control - Set the max size for the control.
//
void EZ_control_SetMaxSize(ez_control_t *self, int max_width, int max_height);

//
// Control - Set the min size for the control.
//
void EZ_control_SetMinSize(ez_control_t *self, int min_width, int min_height);

//
// Control - Sets the position of a control.
//
void EZ_control_SetPosition(ez_control_t *self, int x, int y);

//
// Control - Sets the virtual size of the control (this area can be scrolled around in).
//
void EZ_control_SetVirtualSize(ez_control_t *self, int virtual_width, int virtual_height);

//
// Control - Set the min virtual size for the control, the control size is not allowed to be larger than this.
//
void EZ_control_SetMinVirtualSize(ez_control_t *self, int min_virtual_width, int min_virtual_height);

//
// Control - Sets the part of the control that should be shown if it's scrollable.
//
void EZ_control_SetScrollPosition(ez_control_t *self, int scroll_x, int scroll_y);

//
// Control - Sets the anchoring of the control to it's parent.
//           !!! NOTE !!! 
//           If you set an anchoring to a single edge, make sure you do this
//           after the parent has its final size, otherwise you might get some
//           goofy behavior.
//           !!! NOTE !!!
//
void EZ_control_SetAnchor(ez_control_t *self, ez_anchor_t anchor_flags);

//
// Control - Sets the tab order of a control.
//
void EZ_control_SetTabOrder(ez_control_t *self, int tab_order);

//
// Control - Focuses on a control.
//
qbool EZ_control_SetFocus(ez_control_t *self);

//
// Control - Focuses on a control associated with a specified node from the tab list.
//
qbool EZ_control_SetFocusByNode(ez_control_t *self, ez_dllist_node_t *node);

//
// Control - Returns true if this control is the root control.
//
qbool EZ_control_IsRoot(ez_control_t *self);

//
// Control - Adds a child to the control.
//
void EZ_control_AddChild(ez_control_t *self, ez_control_t *child);

//
// Control - Remove a child from the control. Returns a reference to the child that was removed.
//
ez_control_t *EZ_control_RemoveChild(ez_control_t *self, ez_control_t *child);

// =========================================================================================
// Control - Base Event Handlers (Any inheriting controls can have their own implementation)
// =========================================================================================

//
// Control - Event for when a new event handler is set for an event.
//
int EZ_control_OnEventHandlerChanged(ez_control_t *self, void *ext_event_info);

//
// Control - The control got focus.
//
int EZ_control_OnGotFocus(ez_control_t *self, void *ext_event_info);

//
// Control - The control lost focus.
//
int EZ_control_OnLostFocus(ez_control_t *self, void *ext_event_info);

//
// Control - The control was moved.
//
int EZ_control_OnMove(ez_control_t *self, void *ext_event_info);

//
// Control - On scroll event.
//
int EZ_control_OnScroll(ez_control_t *self, void *ext_event_info);

//
// Control - On parent scroll event.
//
int EZ_control_OnParentScroll(ez_control_t *self, void *ext_event_info);

//
// Control - Convenient function for changing the scroll position by a specified amount.
//
void EZ_control_SetScrollChange(ez_control_t *self, int delta_scroll_x, int delta_scroll_y);

//
// Control - The control was resized.
//
int EZ_control_OnResize(ez_control_t *self, void *ext_event_info);

//
// Control - The anchoring for the control changed.
//
int EZ_control_OnAnchorChanged(ez_control_t *self, void *ext_event_info);

//
// Control - The controls parent was resized.
//
int EZ_control_OnParentResize(ez_control_t *self, void *ext_event_info);

//
// Control - The minimum virtual size has changed for the control.
//
int EZ_control_OnMinVirtualResize(ez_control_t *self, void *ext_event_info);

//
// Label - The virtual size of the control has changed.
//
int EZ_control_OnVirtualResize(ez_control_t *self, void *ext_event_info);

//
// Control - Layouts children.
//
int EZ_control_OnLayoutChildren(ez_control_t *self, void *ext_event_info);

//
// Control - Visibility changed.
//
int EZ_control_OnVisibilityChanged(ez_control_t *self, void *ext_event_info);

//
// Label - The flags for the control changed.
//
int EZ_control_OnFlagsChanged(ez_control_t *self, void *ext_event_info);

//
// Control - OnResizeHandleThicknessChanged event.
//
int EZ_control_OnResizeHandleThicknessChanged(ez_control_t *self, void *ext_event_info);

//
// Control - Draws the control.
//
int EZ_control_OnDraw(ez_control_t *self, void *ext_event_info);

//
// Control - Key down event.
//
int EZ_control_OnKeyDown(ez_control_t *self, int key, int unichar);

//
// Control - Key up event.
//
int EZ_control_OnKeyUp(ez_control_t *self, int key, int unichar);

//
// Control - Key event.
//
int EZ_control_OnKeyEvent(ez_control_t *self, int key, int unichar, qbool down);

//
// Control -
// The initial mouse event is handled by this, and then raises more specialized event handlers
// based on the new mouse state.
// 
// NOTICE! When extending this event you need to make sure that you tell the framework
// that you've handled all mouse events that happened within the controls bounds in your own
// implementation by returning true whenever the mouse is inside the control.
// This can easily be done with the following macro: MOUSE_INSIDE_CONTROL(self, ms); 
// If this is not done, all mouse events will "fall through" to controls below.
//
int EZ_control_OnMouseEvent(ez_control_t *self, mouse_state_t *ms);

//
// Control - The mouse was pressed and then released within the bounds of the control.
//
int EZ_control_OnMouseClick(ez_control_t *self, mouse_state_t *mouse_state);

//
// Control - The mouse entered the controls bounds.
//
int EZ_control_OnMouseEnter(ez_control_t *self, mouse_state_t *mouse_state);

//
// Control - The mouse left the controls bounds.
//
int EZ_control_OnMouseLeave(ez_control_t *self, mouse_state_t *mouse_state);

//
// Control - A mouse button was released within the bounds of the control.
//
int EZ_control_OnMouseUp(ez_control_t *self, mouse_state_t *mouse_state);

//
// Control - A mouse button was released either inside or outside of the control.
//
int EZ_control_OnMouseUpOutside(ez_control_t *self, mouse_state_t *ms);

//
// Control - A mouse button was pressed within the bounds of the control.
//
int EZ_control_OnMouseDown(ez_control_t *self, mouse_state_t *mouse_state);

//
// Control - The mouse wheel was triggered within the bounds of the control.
//
int EZ_control_OnMouseWheel(ez_control_t *self, mouse_state_t *mouse_state);

//
// Control - The mouse is hovering within the bounds of the control.
//
int EZ_control_OnMouseHover(ez_control_t *self, mouse_state_t *mouse_state);

//
// Control - Sets the overall opacity of the control (including its children).
//
void EZ_control_SetOpacity(ez_control_t *self, float opacity);

//
// Control - The opacity of the control has just changed.
//
int EZ_control_OnOpacityChanged(ez_control_t *self, void *ext_event_info);

//
// Control - A child control has been moved.
//
int EZ_control_OnChildMoved(ez_control_t *self, ez_control_t *child);

//
// Control - A child control has been resized.
//
int EZ_control_OnChildResize(ez_control_t *self, ez_control_t *child);

#endif // __EZ_CONTROLS_H__	





================================================
FILE: src/ez_label.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_scrollpane.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_controls.h"
#include "ez_label.h"

#ifdef _MSC_VER
#pragma warning( disable : 4189 )
#endif

// =========================================================================================
// Label
// =========================================================================================

//
// Label - Creates a label control and initializes it.
//
ez_label_t *EZ_label_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags, ez_label_flags_t text_flags,
							  const char *text)
{
	ez_label_t *label = NULL;

	// We have to have a tree to add the control to.
	if (!tree)
	{
		return NULL;
	}

	label = (ez_label_t *)Q_malloc(sizeof(ez_label_t));
	memset(label, 0, sizeof(ez_label_t));

	EZ_label_Init(label, tree, parent, name, description, x, y, width, height, flags, text_flags, text);
	
	return label;
}

//
// Label - Initializes a label control.
//
void EZ_label_Init(ez_label_t *label, ez_tree_t *tree, ez_control_t *parent,
				  char *name, char *description,
				  int x, int y, int width, int height,
				  ez_control_flags_t flags, ez_label_flags_t text_flags,
				  const char *text)
{
	// Initialize the inherited class first.
	EZ_control_Init(&label->super, tree, parent, name, description, x, y, width, height, flags);

	label->super.CLASS_ID = EZ_LABEL_ID;

	// Overriden events.
	CONTROL_REGISTER_EVENT(label, EZ_label_OnDraw, OnDraw, ez_control_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnKeyDown, OnKeyDown, ez_control_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnKeyUp, OnKeyUp, ez_control_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnMouseDown, OnMouseDown, ez_control_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnMouseUp, OnMouseUp, ez_control_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnMouseHover, OnMouseHover, ez_control_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnResize, OnResize, ez_control_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_Destroy, OnDestroy, ez_control_t);

	// Label specific events.
	CONTROL_REGISTER_EVENT(label, EZ_label_OnTextChanged, OnTextChanged, ez_label_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnCaretMoved, OnCaretMoved, ez_label_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnTextScaleChanged, OnTextScaleChanged, ez_label_t);
	CONTROL_REGISTER_EVENT(label, EZ_label_OnTextFlagsChanged, OnTextFlagsChanged, ez_label_t);

	((ez_control_t *)label)->ext_flags				|= control_contained;

	EZ_label_SetTextFlags(label, text_flags | label_selectable);
	EZ_label_SetTextScale(label, 1.0);
	EZ_label_DeselectText(label);

	if (text) {
		EZ_label_SetText(label, text);
	}

	label->color.i = 0;
	label->color.c = RGBA_TO_COLOR(255, 255, 255, 255);
}

//
// Label - Destroys a label control.
//
int EZ_label_Destroy(ez_control_t *self, qbool destroy_children)
{
	ez_label_t *label = (ez_label_t *)self;

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDestroy, destroy_children);

	Q_free(label->text);

	EZ_eventhandler_Remove(label->event_handlers.OnCaretMoved, NULL, true);
	EZ_eventhandler_Remove(label->event_handlers.OnTextChanged, NULL, true);
	EZ_eventhandler_Remove(label->event_handlers.OnTextFlagsChanged, NULL, true);
	EZ_eventhandler_Remove(label->event_handlers.OnTextScaleChanged, NULL, true);

	// TODO: Can we just free a part like this here? How about children, will they be properly destroyed?
	EZ_control_Destroy(&label->super, destroy_children);

	return 0;
}

//
// Label - Sets the event handler for the OnTextChanged event.
//
void EZ_label_AddOnTextChanged(ez_label_t *label, ez_eventhandler_fp OnTextChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(label, EZ_CONTROL_HANDLER, OnTextChanged, ez_label_t, OnTextChanged, payload);
	CONTROL_RAISE_EVENT(NULL, label, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Label - Sets the event handler for the OnTextScaleChanged event.
//
void EZ_label_AddOnTextScaleChanged(ez_label_t *label, ez_eventhandler_fp OnTextScaleChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(label, EZ_CONTROL_HANDLER, OnTextScaleChanged, ez_label_t, OnTextScaleChanged, payload);
	CONTROL_RAISE_EVENT(NULL, label, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Label - Sets the event handler for the OnCaretMoved event.
//
void EZ_label_AddOnTextOnCaretMoved(ez_label_t *label, ez_eventhandler_fp OnCaretMoved, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(label, EZ_CONTROL_HANDLER, OnCaretMoved, ez_label_t, OnCaretMoved, payload);
	CONTROL_RAISE_EVENT(NULL, label, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Label - Calculates where in the label text that the wordwraps will be done.
//
static void EZ_label_CalculateWordwraps(ez_label_t *label)
{
	int i					= 0;
	int current_index		= -1;
	int last_index			= -1;
//	int current_col			= 0;
	int scaled_char_size	= label->scaled_char_size;

	label->num_rows			= 1;
	label->num_cols			= 0;

	if (label->text && (label->ext_flags & label_wraptext))
	{	
		// Wordwrap the string to the virtual size of the control and save the
		// indexes where each row ends in an array.
		while ((i < LABEL_MAX_WRAPS) && Util_GetNextWordwrapString(label->text, NULL, (current_index + 1), &current_index, LABEL_LINE_SIZE, label->super.virtual_width, scaled_char_size))
		{
			label->wordwraps[i].index = current_index;
			label->wordwraps[i].col = current_index - last_index;
			label->wordwraps[i].row = label->num_rows - 1;
			i++;

			// Find the number of rows and columns.
			label->num_cols = max(label->num_cols, label->wordwraps[i].col);
			label->num_rows++;

			last_index = current_index;
		}
	}
	else if (label->text)
	{
		// Normal non-wrapped text, still save new line locations.
		current_index = 0; // TODO : Will this be ok? Otherwise it will be -1, which definantly is bad :p

		while ((i < LABEL_MAX_WRAPS) && label->text[current_index])
		{
			if (label->text[current_index] == '\n')
			{
				label->wordwraps[i].index = current_index;
				label->wordwraps[i].col = current_index - last_index;
				label->wordwraps[i].row = label->num_rows - 1;
				i++;

				// Find the number of rows and columns.
				label->num_cols = max(label->num_cols, label->wordwraps[i].col);
				label->num_rows++;
			}
			
			current_index++;
		}
	}

	// Save the row/col information for the last row also.
	if (label->text)
	{
		label->wordwraps[i].index	= -1;
		label->wordwraps[i].row		= label->num_rows - 1;
		label->wordwraps[i].col		= label->text_length - label->wordwraps[max(0, i - 1)].index;
		label->num_cols				= max(label->num_cols, label->wordwraps[i].col);
	}
	else
	{
		// No text.
		label->wordwraps[0].index	= -1;
		label->wordwraps[0].row		= -1;
		label->wordwraps[0].col		= -1;
		label->num_cols				= 0;
		label->num_rows				= 0;
	}

	// Change the virtual height of the control to fit the text when wrapping.
	if (label->ext_flags & label_wraptext)
	{
		EZ_control_SetMinVirtualSize((ez_control_t *)label, label->super.virtual_width_min, scaled_char_size * (label->num_rows + 1));
	}
	else
	{
		EZ_control_SetMinVirtualSize((ez_control_t *)label, scaled_char_size * (label->num_cols + 1), scaled_char_size * (label->num_rows + 1));
	}
}

//
// Label - Sets if the label should use the large charset or the normal one.
//
void EZ_label_SetLargeFont(ez_label_t *label, qbool large_font)
{
	SET_FLAG(label->ext_flags, label_largefont, large_font);
	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextFlagsChanged, NULL);
}

//
// Label - Sets if the label should autosize itself to fit the text in the label.
//
void EZ_label_SetAutoSize(ez_label_t *label, qbool auto_size)
{
	SET_FLAG(label->ext_flags, label_autosize, auto_size);
	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextFlagsChanged, NULL);
}

//
// Label - Sets if the label should automatically add "..." at the end of the string when it doesn't fit in the label.
//
void EZ_label_SetAutoEllipsis(ez_label_t *label, qbool auto_ellipsis)
{
	SET_FLAG(label->ext_flags, label_autoellipsis, auto_ellipsis);
	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextFlagsChanged, NULL);
}

//
// Label - Sets if the text in the label should wrap to fit the width of the label.
//
void EZ_label_SetWrapText(ez_label_t *label, qbool wrap_text)
{
	SET_FLAG(label->ext_flags, label_wraptext, wrap_text);
	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextFlagsChanged, NULL);
}

//
// Label - Sets if the text in the label should be selectable.
//
void EZ_label_SetTextSelectable(ez_label_t *label, qbool selectable)
{
	SET_FLAG(label->ext_flags, label_selectable, selectable);
	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextFlagsChanged, NULL);
}

//
// Label - Sets if the label should be read only.
//
void EZ_label_SetReadOnly(ez_label_t *label, qbool read_only)
{
	SET_FLAG(label->ext_flags, label_readonly, read_only);
	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextFlagsChanged, NULL);
}

//
// Label - Sets the text flags for the label.
//
void EZ_label_SetTextFlags(ez_label_t *label, ez_label_flags_t flags)
{
	label->ext_flags = flags;
	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextFlagsChanged, NULL);
}

//
// Label - Gets the text flags for the label.
//
ez_label_flags_t EZ_label_GetTextFlags(ez_label_t *label)
{
	return label->ext_flags;
}

//
// Label - Set the text scale for the label.
//
void EZ_label_SetTextScale(ez_label_t *label, float scale)
{
	label->scale = scale;

	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextScaleChanged, NULL);
}

//
// Label - Sets the text color of a label.
//
void EZ_label_SetTextColor(ez_label_t *label, byte r, byte g, byte b, byte alpha)
{
	label->color.c = RGBA_TO_COLOR(r, g, b, alpha);
}

//
// Label - Hides the caret.
//
void EZ_label_HideCaret(ez_label_t *label)
{
	label->caret_pos.index = -1;
}

//
// Label - Deselects the text in the label.
//
void EZ_label_DeselectText(ez_label_t *label)
{
	label->int_flags	&= ~label_selecting;
	label->select_start = -1;
	label->select_end	= -1;
}

//
// Label - Gets the size of the selected text.
//
int EZ_label_GetSelectedTextSize(ez_label_t *label)
{
	if ((label->select_start > -1) && (label->select_end > -1))
	{
		return abs(label->select_end - label->select_start) + 1;
	}

	return 0;
}

//
// Label - Gets the selected text.
//
void EZ_label_GetSelectedText(ez_label_t *label, char *target, int target_size)
{
	if ((label->select_start > -1) && (label->select_end > -1))
	{
		int sublen = abs(label->select_end - label->select_start) + 1;
		
		if (sublen > 0)
		{
			snprintf(target, min(sublen, target_size), "%s", label->text + min(label->select_start, label->select_end));
		}
	}
}

//
// Label - Appends text at the given position in the text.
//
void EZ_label_AppendText(ez_label_t *label, int position, const char *append_text)
{
	int text_len		= label->text_length;
	int append_text_len	= strlen(append_text);

	clamp(position, 0, text_len);

	if (!label->text)
	{
		return;
	}

	// Reallocate the string to fit the new text.
	label->text = (char *)Q_realloc((void *)label->text, (text_len + append_text_len + 1) * sizeof(char));

	// Move the part of the string after the specified position.
	memmove(
		label->text + position + append_text_len,		// Destination, make room for the append text.
		label->text + position,							// Move everything after the specified position.
		(text_len + 1 - position) * sizeof(char));

	// Copy the append text into the newly created space in the string.
	memcpy(label->text + position, append_text, append_text_len * sizeof(char));

	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextChanged, NULL);
}

//
// Label - Removes text between two given indexes.
//
void EZ_label_RemoveText(ez_label_t *label, int start_index, int end_index)
{
	clamp(start_index, 0, label->text_length);
	clamp(end_index, start_index, label->text_length);

	if (!label->text)
	{
		return;
	}

	memmove(
		label->text + start_index,								// Destination.
		label->text + end_index,								// Source.
		(label->text_length - end_index + 1) * sizeof(char));	// Size.
	
	label->text = Q_realloc(label->text, (strlen(label->text) + 1) * sizeof(char));

	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextChanged, NULL);
}

//
// Label - Sets the text of a label.
//
void EZ_label_SetText(ez_label_t *label, const char *text)
{
	int text_len = strlen(text) + 1;

	Q_free(label->text);

	if (text)
	{
		label->text = Q_calloc(text_len, sizeof(char));
		strlcpy(label->text, text, text_len);
	}

	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextChanged, NULL);
}

//
// Label - The text flags for the label changed.
//
int EZ_label_OnTextFlagsChanged(ez_control_t *self, void *ext_event_info)
{
	ez_label_t *label = (ez_label_t *)self;

	// Deselect anything selected and hide the caret.
	if (!(label->ext_flags & label_selectable))
	{
		EZ_label_HideCaret(label);
		EZ_label_DeselectText(label);
	}
	
	// Make sure we recalculate the char size if we changed to large font.
	if (label->ext_flags & label_largefont)
	{
		CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextScaleChanged, NULL);
	}

	// The label will autosize on a text change, so trigger an event for that.
	if (label->ext_flags & label_autosize)
	{
		CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextChanged, NULL);
	}

	// Recalculate the line ends.
	if (label->ext_flags & label_wraptext)
	{
		CONTROL_RAISE_EVENT(NULL, self, ez_control_t, OnResize, NULL);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, label, ez_label_t, OnTextFlagsChanged, NULL);

	return 0;
}

//
// Label - The scale of the text changed.
//
int EZ_label_OnTextScaleChanged(ez_control_t *self, void *ext_event_info)
{
	ez_label_t *label		= (ez_label_t *)self;
	int char_size			= (label->ext_flags & label_largefont) ? 64 : 8;

	label->scaled_char_size	= Q_rint(char_size * label->scale);
	
	// We need to recalculate the wordwrap stuff since the size changed.
	EZ_label_CalculateWordwraps(label);

	CONTROL_EVENT_HANDLER_CALL(NULL, label, ez_label_t, OnTextScaleChanged, NULL);

	return 0;
}

//
// Label - Happens when the control has resized.
//
int EZ_label_OnResize(ez_control_t *self, void *ext_event_info)
{
	ez_label_t *label = (ez_label_t *)self;
	
	// Let the super class try first.
	EZ_control_OnResize(self, NULL);

	// Calculate where to wrap the text.
	EZ_label_CalculateWordwraps(label);

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnResize, NULL);

	return 0;
}

//
// Label - Draws a label control.
//
int EZ_label_OnDraw(ez_control_t *self, void *ext_event_info)
{
	int x, y, i = 0;
	char line[LABEL_LINE_SIZE];
	ez_label_t *label		= (ez_label_t *)self;
	int scaled_char_size	= label->scaled_char_size;
	int last_index			= -1;
	int curr_row			= 0;
	int curr_col			= 0;
	color_t selection_color	= RGBA_TO_COLOR(178, 0, 255, 125);
	color_t caret_color		= RGBA_TO_COLOR(255, 0, 0, 125);

	// Let the super class draw first.
	EZ_control_OnDraw(self, NULL);

	// Get the position we're drawing at.
	EZ_control_GetDrawingPosition(self, &x, &y);

	// Find any newlines and draw line by line.
	for (i = 0; i <= label->text_length; i++)
	{
		// Draw selection markers.
		if (label->ext_flags & label_selectable)
		{
			if (((label->select_start > -1) && (label->select_end > -1)			// Is something selected at all?
				&& (label->select_end != label->select_start))					// Only highlight if we have at least 1 char selected.
				&& (((i >= label->select_start) && (i < label->select_end))		// Is this index selected?
					|| ((i >= label->select_end) && (i < label->select_start)))
				)
			{
				// If this is one of the selected letters, draw a selection thingie behind it.
				// TODO : Make this an XOR drawing ontop of the text instead?
				Draw_AlphaFillRGB(
					x + (curr_col * scaled_char_size), 
					y + (curr_row * scaled_char_size), 
					scaled_char_size, scaled_char_size, 
					selection_color);
			}

			if (i == label->caret_pos.index)
			{
				// Draw the caret.
				Draw_AlphaFillRGB(
					x + (curr_col * scaled_char_size), 
					y + (curr_row * scaled_char_size), 
					max(5, Q_rint(scaled_char_size * 0.1)), scaled_char_size, 
					caret_color);
			}
		}

		if (i == label->wordwraps[curr_row].index || label->text[i] == '\0')
		{
			// We found the end of a line, copy the contents of the line to the line buffer.
			snprintf(line, min(LABEL_LINE_SIZE, (i - last_index) + 1), "%s", (label->text + last_index + 1));
			last_index = i;	// Skip the newline character

			if (label->ext_flags & label_largefont) {
				Draw_BigString(x, y + (curr_row * scaled_char_size), line, NULL, 0, label->scale, 1, 0);
			}
			else {
				Draw_SColoredAlphaString(x, y + (curr_row * scaled_char_size), line, &label->color, 1, 0, label->scale, 1, false);
			}

			curr_row++;
			curr_col = 0;
		}
		else
		{
			curr_col++;
		}
	}

	// TODO : Remove this test stuff.
	{
		char tmp[1024];

		int sublen = abs(label->select_end - label->select_start);
		if (sublen > 0)
		{
			snprintf(tmp, sublen + 1, "%s", label->text + min(label->select_start, label->select_end));
			Draw_String(x + (self->width / 2), y + (self->height / 2) + 8, tmp);
		}
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDraw, NULL);

	return 0;
}

//
// Label - Finds the row and column for a specified index. The proper wordwrap indexes must've been calculated first.
//
static void EZ_label_FindRowColumnByIndex(ez_label_t *label, int index, int *row, int *column)
{
	int i = 0;

	// Find the row the index is on.
	if (row)
	{
		// Find the wordwrap that's closest to the index but still larger
		// that will be the end of the row that the index is on.
		while ((label->wordwraps[i].index != -1) && (label->wordwraps[i].index < index))
		{
			i++;
		}

		// Save the row. (The last row as -1 as index, but still has the correct row saved).
		(*row) = label->wordwraps[i].row;
	}

	if (column)
	{
		// We don't have the last rows end index saved explicitly, so get it here.
		int row_end_index = (label->wordwraps[i].index < 0) ? strlen(label->text) : label->wordwraps[i].index;

		// The column at the end of the row minus the difference between
		// the given index and the index at the end of the row gives us
		// what column the index is in.
		(*column) = label->wordwraps[i].col - (row_end_index - index);
	}
}

//
// Label - Finds the index in the label text at the specified row and column.
//
static int EZ_label_FindIndexByRowColumn(ez_label_t *label, int row, int column)
{
	int row_end_index = 0;

	// Make sure we don't do anythin stupid.
	if ((row < 0) || (row > (label->num_rows - 1)) || (column < 0)) // || (label->wordwraps[row].index < 0))
	{
		return -1;
	}

	// We don't have the last rows end index saved explicitly, so get it here.
	row_end_index = (label->wordwraps[row].index < 0) ? strlen(label->text) : label->wordwraps[row].index;

	if (column > label->wordwraps[row].col)
	{
		// There is no such column on the specified row
		// return the index of the last character on that row instead.
		return row_end_index;
	}

	// Return the index of the specified column.
	return  row_end_index - (label->wordwraps[row].col - column);
}

//
// Label - Finds at what text index the mouse was clicked.
//
static int EZ_label_FindMouseTextIndex(ez_label_t *label, mouse_state_t *ms)
{
	// TODO : Support big font gaps?
	int x, y;
	int row, col;

	// Get the position we're drawing at.
	EZ_control_GetDrawingPosition((ez_control_t *)label, &x, &y);

	// Find the row and column where the mouse is.
	row = ((ms->y - y) / label->scaled_char_size);
	col = ((ms->x - x) / label->scaled_char_size);

	// Give the last index if the mouse is past the last row.
	if (row > (label->num_rows - 1))
	{
		return label->text_length;
	}

	return EZ_label_FindIndexByRowColumn(label, row, col) + 1;
}

//
// Label - Set the caret position.
//
void EZ_label_SetCaretPosition(ez_label_t *label, int caret_pos)
{
	if (label->ext_flags & label_selectable)
	{
		label->caret_pos.index = caret_pos;
		clamp(label->caret_pos.index, -1, label->text_length);
	}
	else
	{
		label->caret_pos.index = -1;
		EZ_label_DeselectText(label);
	}

	CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnCaretMoved, NULL);
}

//
// Label - Moves the caret up or down.
//
static void EZ_label_MoveCaretVertically(ez_label_t *label, int amount)
{
	// Find the index of the character above/below that position,
	// and set the caret to that position, if there is no char
	// exactly above that point, jump to the end of the line
	// of the previous/next row instead.

	int new_caret_index = EZ_label_FindIndexByRowColumn(label, max(0, label->caret_pos.row + amount), label->caret_pos.col);
	
	if (new_caret_index >= 0)
	{
		EZ_label_SetCaretPosition(label, new_caret_index);
	}
}

//
// Label - The caret was moved.
//
int EZ_label_OnCaretMoved(ez_control_t *self, void *ext_event_info)
{
	ez_label_t *label		= (ez_label_t *)self;
	int scaled_char_size	= label->scaled_char_size;
	int row_visible_start	= 0;
	int row_visible_end		= 0;
	int	col_visible_start	= 0;
	int col_visible_end		= 0;
	int prev_caret_row		= label->caret_pos.row;
	int prev_caret_col		= label->caret_pos.col;
	int new_scroll_x		= self->virtual_x;
	int new_scroll_y		= self->virtual_y;
	int num_visible_rows	= Q_rint((float)self->height / scaled_char_size - 1);	// The number of currently visible rows.
	int num_visible_cols	= Q_rint((float)self->width / scaled_char_size - 1);

	// Find the new row and column of the caret.
	EZ_label_FindRowColumnByIndex(label, label->caret_pos.index, &label->caret_pos.row, &label->caret_pos.col);

	row_visible_start	= (self->virtual_y / scaled_char_size);
	row_visible_end		= (row_visible_start + num_visible_rows);

	// Vertical scrolling.
	if (label->caret_pos.row <= row_visible_start)
	{
		// Caret at the top of the visible part of the text.
		new_scroll_y = label->caret_pos.row * scaled_char_size;
	}
	else if (prev_caret_row >= label->caret_pos.row)
	{
		// Caret in the middle.
	}
	else if (label->caret_pos.row >= (row_visible_end - 1))
	{
		// Caret at the bottom of the visible part.
		new_scroll_y = (label->caret_pos.row - num_visible_rows) * scaled_char_size;

		// Special case if it's the last line. Make sure we're allowed to
		// see the entire row, by scrolling a bit extra at the end.
		if ((label->caret_pos.row == (label->num_rows - 1)) && (new_scroll_y < label->super.virtual_height_min))
		{
			new_scroll_y += Q_rint(0.2 * scaled_char_size);
		}
	}

	// Only scroll horizontally if the text is not wrapped.
	if (!(label->ext_flags & label_wraptext))
	{
		col_visible_start	= (self->virtual_x / scaled_char_size);
		col_visible_end		= (col_visible_start + num_visible_cols);

		if (label->caret_pos.col <= (col_visible_start + 1))
		{
			// At the start of the visible text (columns).
			new_scroll_x = (label->caret_pos.col - 1) * scaled_char_size;
		}
		else if (prev_caret_col >= label->caret_pos.col)
		{
			// In the middle of the visible text.
		}
		else if (label->caret_pos.col >= (col_visible_end - 1))
		{
			// At the end of the visible text.
			new_scroll_x = (label->caret_pos.col - num_visible_cols) * scaled_char_size;
		}
	}

	// Only set a new scroll if it changed.
	if ((new_scroll_x != self->virtual_x) || (new_scroll_y != self->virtual_y))
	{
		EZ_control_SetScrollPosition(self, new_scroll_x, new_scroll_y);
	}

	// Select while holding down shift.
	if (keydown[K_SHIFT] && (label->select_start > -1))
	{
		label->int_flags |= label_selecting;
		label->select_end = label->caret_pos.index;
	}

	// Deselect any selected text if we're not in selection mode.
	if (!(label->int_flags & label_selecting))
	{
		EZ_label_DeselectText(label);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, label, ez_label_t, OnCaretMoved, NULL);

	return 0;
}

//
// Label - The text changed in the label.
//
int EZ_label_OnTextChanged(ez_control_t *self, void *ext_event_info)
{
	ez_label_t *label = (ez_label_t *)self;

	// Make sure we have the correct text length saved.
	label->text_length = label->text ? strlen(label->text) : 0;

	// Find the new places to wrap on.
	EZ_label_CalculateWordwraps(label);

	if (label->ext_flags & label_autosize)
	{
		// Only resize after the number of rows if we're wrapping the text.
		if (label->ext_flags & label_wraptext)
		{
			EZ_control_SetSize(self, self->width, (label->scaled_char_size * label->num_rows));
		}
		else
		{
			EZ_control_SetSize(self, (label->scaled_char_size * label->num_cols), (label->scaled_char_size * label->num_rows));
		}
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, label, ez_label_t, OnTextChanged, NULL);

	return 0;
}

//
// Label - Handle a page up/dn key press.
//
static void EZ_label_PageUpDnKeyDown(ez_label_t *label, int key)
{
	int num_visible_rows = Q_rint((float)label->super.height / label->scaled_char_size);

	switch (key)
	{
		case K_PGUP :
		{
			EZ_label_MoveCaretVertically(label, -num_visible_rows);
			break;
		}
		case K_PGDN :
		{
			EZ_label_MoveCaretVertically(label, num_visible_rows);
			break;
		}
		default :
		{
			break;
		}
	}
}

//
// Label - Gets the next word boundary.
//
static int EZ_label_GetNextWordBoundary(ez_label_t *label, int cur_pos, qbool forward)
{
	char *txt	= label->text;
	int dir		= forward ? 1 : -1;		

	// Make sure we're not out of bounds.
	clamp(cur_pos, 0, label->text_length);

	// Eat all the whitespaces.
	while ((cur_pos >= 0) && (cur_pos <= label->text_length) && ((txt[cur_pos] == ' ') || (txt[cur_pos] == '\n')))
	{
		cur_pos += dir;
	}
	
	// Find the next word boundary.
	while ((cur_pos >= 0) && (cur_pos <= label->text_length) && (txt[cur_pos] != ' ') && (txt[cur_pos] != '\n'))
	{
		cur_pos += dir;
	}

	return clamp(cur_pos, 0, label->text_length);
}

//
// Label - Handle a arrow key press.
//
static void EZ_label_ArrowKeyDown(ez_label_t *label, int key)
{
	switch(key)
	{
		case K_LEFTARROW :
		{
			if (keydown[K_CTRL])
			{
				EZ_label_SetCaretPosition(label, EZ_label_GetNextWordBoundary(label, label->caret_pos.index, false));
			}
			else
			{
				EZ_label_SetCaretPosition(label, max(0, label->caret_pos.index - 1));
			}
			break;
		}
		case K_RIGHTARROW :
		{
			if (keydown[K_CTRL])
			{
				EZ_label_SetCaretPosition(label, EZ_label_GetNextWordBoundary(label, label->caret_pos.index, true));
			}
			else
			{
				EZ_label_SetCaretPosition(label, label->caret_pos.index + 1);
			}
			break;
		}
		case K_UPARROW :
		{
			EZ_label_MoveCaretVertically(label, -1);
			break;
		}
		case K_DOWNARROW :
		{
			EZ_label_MoveCaretVertically(label, 1);
			break;
		}
		default :
		{
			break;
		}
	}
}

//
// Label - Handle a HOME/END key press.
//
static void EZ_label_EndHomeKeyDown(ez_label_t *label, int key)
{
	switch(key)
	{
		case K_HOME :
		{
			if (keydown[K_CTRL])
			{
				// Move the caret to the start of the text.
				EZ_label_SetCaretPosition(label, 0);
			}
			else
			{
				// Move the caret to the start of the current line.
				EZ_label_SetCaretPosition(label, label->caret_pos.index - label->caret_pos.col + 1);
			}
			break;
		}
		case K_END :
		{
			if (keydown[K_CTRL])
			{
				// Move the caret to the end of the text.
				EZ_label_SetCaretPosition(label, label->text_length);
			}
			else
			{
				// Move the caret to the end of the line.
				int i = 0;
				int line_end_index = 0;

				// Find the last index of the current row.
				while ((label->wordwraps[i].index > 0) && (label->wordwraps[i].index < label->caret_pos.index))
				{
					i++;
				}

				// Special case for last line.
				line_end_index = (label->wordwraps[i].index < 0) ? label->text_length : label->wordwraps[i].index;
				EZ_label_SetCaretPosition(label, line_end_index);
			}
			break;
		}
		default :
		{
			break;
		}
	}
}

//
// Label - Handle backspace/delete key presses.
//
static void EZ_label_BackspaceDeleteKeyDown(ez_label_t *label, int key)
{
	// Don't allow deleting if read only.
	if (label->ext_flags & label_readonly)
	{
		return;
	}

	if (LABEL_TEXT_SELECTED(label))
	{
		// Find the start and end of the selected text.
		int start = (label->select_start < label->select_end) ? label->select_start : label->select_end;
		int end	  = (label->select_start < label->select_end) ? label->select_end : label->select_start;

		// Remove a selected chunk of text.				
		EZ_label_RemoveText(label, start, end);
		
		// When deleting we need to move the cursor so that
		// it's at the "same point" in the text afterwards.
		if (label->select_start < label->select_end)
		{
			EZ_label_SetCaretPosition(label, label->select_start);
		}

		// Deselect what we just deleted.
		EZ_label_DeselectText(label);
	}
	else if (key == K_BACKSPACE)
	{
		// Remove a single character.
		EZ_label_RemoveText(label, label->caret_pos.index - 1, label->caret_pos.index);
		EZ_label_SetCaretPosition(label, label->caret_pos.index - 1);
	}
	else if (key == K_DEL)
	{
		EZ_label_RemoveText(label, label->caret_pos.index, label->caret_pos.index + 1);
	}
}

//
// Label - Handles Ctrl combination key presses.
//
static void EZ_label_CtrlComboKeyDown(ez_label_t *label, int key)
{
	char c = (char)key;

	switch (c)
	{
		case 'c' :
		case 'C' :
		{
			if (LABEL_TEXT_SELECTED(label))
			{
				// CTRL + C (Copy to clipboard).
				int selected_len = EZ_label_GetSelectedTextSize(label) + 1;
				char *selected_text = (char *)Q_malloc(selected_len * sizeof(char));

				EZ_label_GetSelectedText(label, selected_text, selected_len);

				CopyToClipboard(selected_text);
				break;
			}
		}
		case 'v' :
		case 'V' :
		{
			// CTRL + V (Paste from clipboard).
			char *pasted_text = ReadFromClipboard();
			EZ_label_AppendText(label, label->caret_pos.index, pasted_text);
			break;
		}
		case 'a' :
		case 'A' :
		{
			// CTRL + A (Select all).
			label->select_start = 0;
			label->select_end	= label->text_length;
			label->int_flags	|= label_selecting;
			EZ_label_SetCaretPosition(label, label->select_end);
			label->int_flags	&= ~label_selecting;
			break;
		}
		default :
		{
			break;
		}
	}
}

//
// Label - Handles input key was presses.
//
static void EZ_label_InputKeyDown(ez_label_t *label, int key)
{
	char c = (char)key;

	// Don't allow input if read only.
	if (label->ext_flags & label_readonly)
	{
		return;
	}

	// User typing text into the label.
	// TODO : Add support for input of all quake chars
	if ((label->caret_pos.index >= 0) 
		&& (	
				((c >= 'a') && (c <= 'z'))
				||	
				((c >= 'A') && (c <= 'Z'))
			)
		)
	{
		char char_str[2];				

		// First remove any selected text.
		if (LABEL_TEXT_SELECTED(label))
		{
			int start = (label->select_start < label->select_end) ? label->select_start : label->select_end;
			int end	  = (label->select_start < label->select_end) ? label->select_end : label->select_start;

			EZ_label_RemoveText(label, start, end);

			// Make sure the caret stays in the same place.
			EZ_label_SetCaretPosition(label, (label->select_start < label->select_end) ? label->select_start : label->select_end);
		}

		// Turn off selecting mode, since we don't want to be selecting
		// when typing capital letters for instance.
		EZ_label_DeselectText(label);

		// Add the text.
		snprintf(char_str, 2, "%c", (char)key);
		EZ_label_AppendText(label, label->caret_pos.index, char_str);
		EZ_label_SetCaretPosition(label, label->caret_pos.index + 1);
	}
}

//
// Label - Key down event.
//
int EZ_label_OnKeyDown(ez_control_t *self, int key, int unichar)
{
	ez_label_t *label	= (ez_label_t *)self;
	int key_handled		= false;

	key_handled = EZ_control_OnKeyDown(self, key, unichar);

	if (key_handled)
	{
		return true;
	}

	key_handled = true;

	// Only handle keys if text is selectable.
	if (label->ext_flags & label_selectable)
	{
		// Key down.
		switch (key)
		{
			case K_LEFTARROW :
			case K_RIGHTARROW :
			case K_UPARROW :
			case K_DOWNARROW :
			{
				EZ_label_ArrowKeyDown(label, key);
				break;
			}
			case K_PGDN :
			case K_PGUP :
			{
				EZ_label_PageUpDnKeyDown(label, key);
				break;
			}
			case K_HOME :
			case K_END :
			{
				EZ_label_EndHomeKeyDown(label, key);
				break;
			}
			case K_TAB :
			{
				break;
			}
			case K_LSHIFT :
			case K_RSHIFT :
			case K_SHIFT :
			{
				// Start selecting.
				label->select_start = label->caret_pos.index;
				label->int_flags |= label_selecting;
				break;
			}
			case K_RCTRL :
			case K_LCTRL :
			case K_CTRL :
			{
				break;
			}
			case K_DEL :
			case K_BACKSPACE :
			{
				EZ_label_BackspaceDeleteKeyDown(label, key);
				break;
			}
			default :
			{
				if (keydown[K_CTRL])
				{
					EZ_label_CtrlComboKeyDown(label, key);
				}
				else
				{
					EZ_label_InputKeyDown(label, key);
				}
				break;
			}
		}
	}

	CONTROL_EVENT_HANDLER_CALL(&key_handled, self, ez_control_t, OnKeyDown, key, unichar);
	return key_handled;
}

//
// Label - Key up event.
//
int EZ_label_OnKeyUp(ez_control_t *self, int key, int unichar)
{
	ez_label_t *label	= (ez_label_t *)self;
	int key_handled		= false;

	key_handled = EZ_control_OnKeyUp(self, key, unichar);

	if (key_handled)
	{
		return true;
	}

	key_handled = true;

	// Key up.
	switch (key)
	{
		case K_SHIFT :
		{
			label->int_flags &= ~label_selecting;
			break;
		}
	}

	return key_handled;
}

//
// Label - The mouse is hovering within the bounds of the label.
//
int EZ_label_OnMouseHover(ez_control_t *self, mouse_state_t *ms)
{
	qbool mouse_handled = false;
	ez_label_t *label = (ez_label_t *)self;

	// Call the super class first.
	mouse_handled = EZ_control_OnMouseHover(self, ms);

	// Find at what index in the text where the mouse is currently over.
	if (label->int_flags & label_selecting)
	{
		label->select_end = EZ_label_FindMouseTextIndex(label, ms);
		EZ_label_SetCaretPosition(label, label->select_end);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnMouseHover, ms);

	return mouse_handled;
}

//
// Label - Handles the mouse down event.
//
int EZ_label_OnMouseDown(ez_control_t *self, mouse_state_t *ms)
{
	int mouse_handled = false;
	ez_label_t *label = (ez_label_t *)self;

	// Call the super class first.
	mouse_handled = EZ_control_OnMouseDown(self, ms);

	// Find at what index in the text the mouse was clicked.
	label->select_start = EZ_label_FindMouseTextIndex(label, ms);

	// Reset the caret and selection end since we just started a new select / caret positioning.
	label->select_end = -1;
	EZ_label_HideCaret(label);

	// We just started to select some text.
	label->int_flags |= label_selecting;

	CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseDown, ms);

	return true;
}

//
// Label - Handles the mouse up event.
//
int EZ_label_OnMouseUp(ez_control_t *self, mouse_state_t *ms)
{
	int mouse_handled = false;
	ez_label_t *label = (ez_label_t *)self;

	// Call the super class first.
	mouse_handled = EZ_control_OnMouseUp(self, ms);

	// Find at what index in the text where the mouse was released.
	if ((self->int_flags & control_focused) && (label->int_flags & label_selecting))
	{
		label->select_end = EZ_label_FindMouseTextIndex(label, ms);
		
		EZ_label_SetCaretPosition(label, label->select_end);
	}
	else
	{
		label->select_start		= -1;
		label->select_end		= -1;
		EZ_label_SetCaretPosition(label, -1);
	}

	// We've stopped selecting.
	label->int_flags &= ~label_selecting;

	CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseUp, ms);

	return mouse_handled;
}




================================================
FILE: src/ez_label.h
================================================

#ifndef __EZ_LABEL_H__
#define __EZ_LABEL_H__
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_label.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

#include "ez_controls.h"

// =========================================================================================
// Label
// =========================================================================================

typedef enum ez_label_flags_e
{
	label_largefont		= (1 << 0),		// Use the large font.
	label_autosize		= (1 << 1),		// Autosize the label to fit the text (if it's not wrapped).
	label_autoellipsis	= (1 << 2),		// Show ... at the end of the text if it doesn't fit within the label.
	label_wraptext		= (1 << 3),		// Wrap the text to fit inside the label.
	label_selectable	= (1 << 4),		// Is text selectable?
	label_readonly		= (1 << 5)		// Is input allowed?
} ez_label_flags_t;

#define LABEL_DEFAULT_FLAGS	(label_wraptext | label_selectable)

typedef enum ez_label_iflags_e
{
	label_selecting		= (1 << 0)		// Are we selecting text?
} ez_label_iflags_t;

#define LABEL_MAX_WRAPS		512
#define LABEL_LINE_SIZE		1024

// Is any text selected in the label?
#define LABEL_TEXT_SELECTED(label) ((label->select_start > -1) && (label->select_end > - 1) && abs(label->select_end - label->select_start) > 0)

typedef struct ez_label_eventcount_s
{
	int	OnTextChanged;
	int	OnCaretMoved;
	int	OnTextScaleChanged;
	int	OnTextFlagsChanged;
} ez_label_eventcount_t;

typedef struct ez_label_events_s
{
	ez_event_fp	OnTextChanged;			// Event raised when the text in the label is changed.
	ez_event_fp	OnCaretMoved;			// The caret was moved.
	ez_event_fp	OnTextScaleChanged;		// The scale of the text changed.
	ez_event_fp	OnTextFlagsChanged;		// The text flags changed.
} ez_label_events_t;

typedef struct ez_label_eventhandlers_s
{
	ez_eventhandler_t		*OnTextChanged;
	ez_eventhandler_t		*OnCaretMoved;
	ez_eventhandler_t		*OnTextScaleChanged;
	ez_eventhandler_t		*OnTextFlagsChanged;
} ez_label_eventhandlers_t;

typedef struct ez_label_textpos_s
{
	int index;
	int row;
	int col;
} ez_label_textpos_t;

typedef struct ez_label_s
{
	ez_control_t			super;						// Super class.

	ez_label_events_t		events;						// Specific events for the label control.
	ez_label_eventhandlers_t event_handlers;			// Specific event handlers for the label control.
	ez_label_eventcount_t	inherit_levels;
	ez_label_eventcount_t	override_counts;

	char					*text;						// The text to be shown in the label.
	int						text_length;				// The length of the label text (excluding \0).
	
	ez_label_flags_t		ext_flags;					// External flags for how the text in the label is formatted.
	ez_label_iflags_t		int_flags;					// Internal flags for the current state of the label.

	ez_label_textpos_t		wordwraps[LABEL_MAX_WRAPS+1];	// Positions in the text where line breaks are located.
	clrinfo_t				color;						// The text color of the label. // TODO : Make this a pointer?
	float					scale;						// The scale of the text in the label.
	int						scaled_char_size;			// The actual size of the characters in the text.
	int						select_start;				// At what index the currently selected text starts at 
														// (this can be greater than select_end).
	int						select_end;					// The end index of the selected text.
	ez_label_textpos_t		caret_pos;					// The position of the caret (index / row / column).
	int						num_rows;					// The current number of rows in the label.
	int						num_cols;					// The current number of cols (for the longest row).
} ez_label_t;

ez_label_t *EZ_label_Create(ez_tree_t *tree, ez_control_t *parent, 
							  char *name, char *description, 
							  int x, int y, int width, int height,
							  ez_control_flags_t flags, ez_label_flags_t text_flags,
							  const char *text);

void EZ_label_Init(ez_label_t *label, ez_tree_t *tree, ez_control_t *parent, 
				  char *name, char *description, 
				  int x, int y, int width, int height,
				  ez_control_flags_t flags, ez_label_flags_t text_flags,
				  const char *text);

//
// Label - Destroys a label control.
//
int EZ_label_Destroy(ez_control_t *self, qbool destroy_children);

//
// Label - Sets if the label should use the large charset or the normal one.
//
void EZ_label_SetLargeFont(ez_label_t *label, qbool large_font);

//
// Label - Sets if the label should autosize itself to fit the text in the label.
//
void EZ_label_SetAutoSize(ez_label_t *label, qbool auto_size);

//
// Label - Sets if the label should automatically add "..." at the end of the string when it doesn't fit in the label.
//
void EZ_label_SetAutoEllipsis(ez_label_t *label, qbool auto_ellipsis);

//
// Label - Sets if the text in the label should wrap to fit the width of the label.
//
void EZ_label_SetWrapText(ez_label_t *label, qbool wrap_text);

//
// Label - Sets the text flags for the label.
//
void EZ_label_SetTextFlags(ez_label_t *label, ez_label_flags_t flags);

//
// Label - Sets if the label should be read only.
//
void EZ_label_SetReadOnly(ez_label_t *label, qbool read_only);

//
// Label - Sets if the text in the label should be selectable.
//
void EZ_label_SetTextSelectable(ez_label_t *label, qbool selectable);

//
// Label - Sets the event handler for the OnTextChanged event.
//
void EZ_label_AddOnTextChanged(ez_label_t *label, ez_eventhandler_fp OnTextChanged, void *payload);

//
// Label - Sets the event handler for the OnTextScaleChanged event.
//
void EZ_label_AddOnTextScaleChanged(ez_label_t *label, ez_eventhandler_fp OnTextScaleChanged, void *payload);

//
// Label - Sets the event handler for the OnCaretMoved event.
//
void EZ_label_AddOnTextOnCaretMoved(ez_label_t *label, ez_eventhandler_fp OnCaretMoved, void *payload);

//
// Label - Hides the caret.
//
void EZ_label_HideCaret(ez_label_t *label);

//
// Label - Gets the size of the selected text.
//
int EZ_label_GetSelectedTextSize(ez_label_t *label);

//
// Label - Gets the selected text.
//
void EZ_label_GetSelectedText(ez_label_t *label, char *target, int target_size);

//
// Label - Deselects the text in the label.
//
void EZ_label_DeselectText(ez_label_t *label);

//
// Label - Set the text scale for the label.
//
void EZ_label_SetTextScale(ez_label_t *label, float scale);

//
// Label - Sets the color of the text in the label.
//
void EZ_label_SetTextColor(ez_label_t *self, byte r, byte g, byte b, byte alpha);

//
// Label - Sets the text of the label (will be reallocated and copied to the heap).
//
void EZ_label_SetText(ez_label_t *self, const char *text);

//
// Label - Gets the text flags for the label.
//
ez_label_flags_t EZ_label_GetTextFlags(ez_label_t *label);

//
// Label - Sets the text flags for the label.
//
void EZ_label_SetTextFlags(ez_label_t *label, ez_label_flags_t flags);

//
// Label - Appends text at the given position in the text.
//
void EZ_label_AppendText(ez_label_t *label, int position, const char *append_text);

//
// Label - Set the caret position.
//
void EZ_label_SetCaretPosition(ez_label_t *label, int caret_pos);

//
// Label - The text flags for the label changed.
//
int EZ_label_OnTextFlagsChanged(ez_control_t *self, void *ext_event_info);

//
// Label - The scale of the text changed.
//
int EZ_label_OnTextScaleChanged(ez_control_t *self, void *ext_event_info);

//
// Label - Happens when the control has resized.
//
int EZ_label_OnResize(ez_control_t *self, void *ext_event_info);

//
// Label - On Draw.
//
int EZ_label_OnDraw(ez_control_t *label, void *ext_event_info);

//
// Label - The caret was moved.
//
int EZ_label_OnCaretMoved(ez_control_t *self, void *ext_event_info);

//
// Label - The text changed in the label.
//
int EZ_label_OnTextChanged(ez_control_t *self, void *ext_event_info);

//
// Label - Key down event.
//
int EZ_label_OnKeyDown(ez_control_t *self, int key, int unichar);

//
// Label - Key up event.
//
int EZ_label_OnKeyUp(ez_control_t *self, int key, int unichar);

//
// Label - Key event.
//
int EZ_label_OnKeyEvent(ez_control_t *self, int key, int unichar, qbool down);

//
// Label - Handles the mouse down event.
//
int EZ_label_OnMouseDown(ez_control_t *self, mouse_state_t *ms);

//
// Label - Handles the mouse up event.
//
int EZ_label_OnMouseUp(ez_control_t *self, mouse_state_t *ms);

//
// Label - The mouse is hovering within the bounds of the label.
//
int EZ_label_OnMouseHover(ez_control_t *self, mouse_state_t *mouse_state);

#endif // __EZ_LABEL_H__



================================================
FILE: src/ez_listview.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_listview.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_listview.h"

#ifdef _WIN32
#pragma warning( disable : 4189 )
#endif

//
// Listview - Lays out the control.
//
static void EZ_listview_Layout(ez_listview_t *self)
{
	ez_dllist_node_t *it = (self->sort_ascending ? self->items.head : self->items.tail);
	ez_control_t *lvi = NULL;
	int y = 0;

	// Make sure the header hasn't moved.
	EZ_control_SetPosition((ez_control_t *)self->header, 0, 0);
	y += ((ez_control_t *)self->header)->height + self->row_gap;

	// Position all the listview items according to the sort order.
	if (self->items.count > 0)
	{
		while ((self->sort_ascending ? it->next : it->previous))
		{
			lvi = (ez_control_t *)it->payload;
			
			EZ_control_SetPosition(lvi, 0, y);
			y += lvi->height + self->row_gap;

			it = (self->sort_ascending ? it->next : it->previous);
		}
	}
}

//
// Listview - On Mouse Click event handler for when a header label is clicked.
//
static int EZ_listview_OnHeaderMouseClick(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	int column = (int)(uintptr_t)payload;
	ez_listview_t *listview = (ez_listview_t *)self;

	// Change the sorting.
	listview->sort_ascending = !listview->sort_ascending;
	EZ_listview_SetSortColumn(listview, column);

	// Sort!
	EZ_listview_SortByColumn(listview);

	EZ_listview_Layout(listview);

	return 0;
}

//
// Listview - Creates a new listview and initializes it.
//
ez_listview_t *EZ_listview_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	ez_listview_t *listview = NULL;

	// We have to have a tree to add the control to.
	if (!tree)
	{
		return NULL;
	}

	listview = (ez_listview_t *)Q_malloc(sizeof(ez_listview_t));
	memset(listview, 0, sizeof(ez_listview_t));

	EZ_listview_Init(listview, tree, parent, name, description, x, y, width, height, flags);
	
	return listview;
}

//
// Listview - Initializes a listview.
//
void EZ_listview_Init(ez_listview_t *listview, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	int i;
	ez_listview_subitem_t subitem;
	ez_control_t *listview_ctrl	= (ez_control_t *)listview;

	// Initialize the inherited class first.
	//EZ_scrollpane_Init(&listview->super, tree, parent, name, description, x, y, width, height, flags);
	EZ_control_Init(&listview->super, tree, parent, name, description, x, y, width, height, flags);

	((ez_control_t *)listview)->CLASS_ID		= EZ_LISTVIEW_ID;
	((ez_control_t *)listview)->ext_flags		|= (flags | control_focusable | control_contained | control_resizeable);

	// Overridden events.
	//CONTROL_REGISTER_EVENT(listview_ctrl, EZ_listview_OnResize, OnResize, ez_control_t);

	// Listview specific events.
	CONTROL_REGISTER_EVENT(listview, EZ_listview_OnItemAdded, OnItemAdded, ez_listview_t);
	CONTROL_REGISTER_EVENT(listview, EZ_listview_OnRowGapChanged, OnRowGapChanged, ez_listview_t);
	CONTROL_REGISTER_EVENT(listview, EZ_listview_OnColumnGapChanged, OnColumnGapChanged, ez_listview_t);
	CONTROL_REGISTER_EVENT(listview, EZ_listview_OnColumnWidthChanged, OnColumnWidthChanged, ez_listview_t);
	CONTROL_REGISTER_EVENT(listview, EZ_listview_OnRowHeightChanged, OnRowHeightChanged, ez_listview_t);

	// Create the header listviewitem and add subitems to it and set their text to "" to start with.
	{
		ez_label_t *curlabel = NULL;
		listview->header = EZ_listviewitem_Create(listview_ctrl->control_tree, listview_ctrl, "List view header", "", 
									0, 0, listview_ctrl->width, 8, 0);

		subitem.payload = NULL;
		subitem.text = "HEJ";

		// Init the labels in the header list view item.
		for (i = 0; i < LISTVIEW_COLUMN_COUNT; i++)
		{
			EZ_listviewitem_AddColumn(listview->header, subitem, 30);
			curlabel = listview->header->items[i];

			// Pass the column index as payload (so we know what column to sort by when a header is clicked).
			EZ_control_AddOnMouseClick((ez_control_t *)curlabel, (void *)(uintptr_t)i, EZ_listview_OnHeaderMouseClick);
			
			EZ_control_SetAnchor((ez_control_t *)curlabel, anchor_left | anchor_top);
			EZ_label_SetReadOnly(curlabel, true);
			EZ_label_SetAutoSize(curlabel, false);
			EZ_label_SetTextSelectable(curlabel, false);
			EZ_control_SetBackgroundColor((ez_control_t *)curlabel, 0, 255, 0, 125); // TODO: Remove this.
		}

		// TODO: Add ez_control_t's that will act as resize handles between the column headers.
	}

	EZ_listview_Layout(listview);
}

//
// Listview - Cleans up a listview item when it is removed in a range.
//
static void EZ_listview_CleanupRangeItem(void *payload)
{
	if (payload != NULL)
	{
		ez_listviewitem_t *item = (ez_listviewitem_t *)payload;
		EZ_listviewitem_Destroy((ez_control_t *)item, true);
	}
}

//
// Listview - Destroys a listview.
//
int EZ_listview_Destroy(ez_control_t *self, qbool destroy_children)
{
	ez_listview_t *listview = (ez_listview_t *)self;
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDestroy, destroy_children); 

	// TODO : Remove any event handlers.

	// Cleanup listview items.
	EZ_double_linked_list_RemoveRange(&listview->items, 0, listview->items.count - 1, EZ_listview_CleanupRangeItem);
	
	EZ_control_Destroy(self, destroy_children);

	return 0;
}

//
// Listview - Adds a listview item to the listview. Expects an array of column items as argument (and a count of how many).
//
void EZ_listview_AddItem(ez_listview_t *self, const ez_listview_subitem_t *sub_items, int subitem_count, void *payload)
{
	int i;
	ez_control_t *ctrl_lstview = (ez_control_t *)self;
	ez_listviewitem_t *item;
	
	item = EZ_listviewitem_Create(ctrl_lstview->control_tree, ctrl_lstview, "List view item", "", 
								0, 0, ctrl_lstview->width, self->row_height, 0);

	for (i = 0; i < subitem_count; i++)
	{
		EZ_listviewitem_AddColumn(item, sub_items[i], 30); // TODO: Hmm what default width should we use?
	}

	EZ_double_linked_list_Add(&self->items, (void *)item);

	CONTROL_RAISE_EVENT(NULL, self, ez_listview_t, OnItemAdded, NULL)
}

//
// Listview - An item was added to the listview.
//
int EZ_listview_OnItemAdded(ez_control_t *self, void *ext_event_info)
{
	ez_listview_t *listview = (ez_listview_t *)self;

	// TODO: Maybe we should allow you to supress layout while adding a bunch of items.
	EZ_listview_Layout(listview);

	CONTROL_EVENT_HANDLER_CALL(NULL, listview, ez_listview_t, OnItemAdded, NULL);

	return 0;
}

//
// Listview - Set the text of the header.
//
void EZ_listview_SetHeaderText(ez_listview_t *self, int column, const char *text)
{
	if (column < 0 || column >= LISTVIEW_COLUMN_COUNT)
	{
		return;
	}

	EZ_label_SetText(self->header->items[column], text);
}

//
// Listview - Removes an item at a specific index.
//
void EZ_listview_RemoveItemByIndex(ez_listview_t *self, int index)
{
	ez_listviewitem_t *item = EZ_double_linked_list_RemoveByIndex(&self->items, index);
	
	if (item != NULL)
	{
		EZ_listviewitem_Destroy((ez_control_t *)item, true);
	}
}

//
// Listview - Removes an item with a specific payload.
//
void EZ_listview_RemoveItemByPayload(ez_listview_t *self, void *payload)
{
	ez_listviewitem_t *item = EZ_double_linked_list_RemoveByPayload(&self->items, payload);
	
	if (item != NULL)
	{
		EZ_listviewitem_Destroy((ez_control_t *)item, true);
	}
}

//
// Listview - Removes a range of items from a listview.
//
void EZ_listview_RemoveRange(ez_listview_t *self, int start, int end)
{
	EZ_double_linked_list_RemoveRange(&self->items, start, end, EZ_listview_CleanupRangeItem);
}

//
// Listview - Compares two columns to each other (based on the sort column set in the listview object they are related with).
//
static int EZ_listview_ColumnCompareFunc(const void *it1, const void *it2)
{
	int sci;
	int res = 0;
	ez_listviewitem_t *lvi1 = GET_LISTVIEW_ITEM(it1);
	ez_listviewitem_t *lvi2 = GET_LISTVIEW_ITEM(it2);
	ez_listview_t *lv = (ez_listview_t *)lvi1->super.parent; // We assume the item has a listview as parent, otherwise something is wrong.

	sci = lv->sort_column_index;

	if (sci < 0 || sci >= LISTVIEW_COLUMN_COUNT)
	{
		return 0;
	}

	res = strcmp(lvi1->items[sci]->text, lvi2->items[sci]->text);

	return res; // (lv->sort_ascending) ? res : -res; // HMM! Nevermind this, since we're using a double linked list to store the listview items we can just layout them from tail -> head instead of doing a sort :)
}

//
// Listview - Sorts the list view by a user supplied function.
//
void EZ_listview_SortByUserFunc(ez_listview_t *self, PtFuncCompare compare_function)
{
	EZ_double_linked_list_Sort(&self->items, EZ_listview_ColumnCompareFunc);
}

//
// Listview - Sorts the listview items by a specified column.
//
void EZ_listview_SortByColumn(ez_listview_t *self)
{
	EZ_listview_SortByUserFunc(self, EZ_listview_ColumnCompareFunc);
}

//
// Listview - Set the column to sort by.
//
void EZ_listview_SetSortColumn(ez_listview_t *self, int column)
{
	self->sort_column_index = column;
}

/*
//
// Listview - OnResize event handler.
//
int EZ_listview_OnResize(ez_control_t *self, void *ext_event_info)
{
	ez_listview_t *listview = (ez_listview_t *)self;

	// Run the super class implementation.
	EZ_scrollpane_OnResize(self, ext_event_info);

	//EZ_listview_Layout(listview);

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnResize, NULL);

	return 0;
}
*/

//
// Listview - Sets the row gap size of the listview.
//
void EZ_listview_SetRowGap(ez_listview_t *self, int gap)
{
	self->row_gap = gap;
	EZ_listview_Layout(self);

	CONTROL_RAISE_EVENT(NULL, self, ez_listview_t, OnRowGapChanged, NULL);
}

//
// Listview - The row gap size has changed.
//
int EZ_listview_OnRowGapChanged(ez_control_t *self, void *ext_event_info)
{
	ez_listview_t *listview = (ez_listview_t *)self;

	EZ_listview_Layout(listview);

	CONTROL_EVENT_HANDLER_CALL(NULL, listview, ez_listview_t, OnRowGapChanged, ext_event_info);

	return 0;
}

//
// Listview - Sets the column gap size of the listview.
//
void EZ_listview_SetColumnGap(ez_listview_t *self, int gap)
{
	self->col_gap = gap;
	CONTROL_RAISE_EVENT(NULL, self, ez_listview_t, OnRowGapChanged, NULL);
}

//
// Listview - The column gap size has changed.
//
int EZ_listview_OnColumnGapChanged(ez_control_t *self, void *ext_event_info)
{
	ez_listview_t *listview = (ez_listview_t *)self;
	ez_dllist_node_t *it = listview->items.head;
	ez_listviewitem_t *lvi = NULL;

	// Update all listview items to know about the new gap size.
	if (listview->items.count > 0)
	{
		while (it->next)
		{
			lvi = (ez_listviewitem_t *)it->payload;

			EZ_listviewitem_SetColumnGap(lvi, listview->col_gap);

			it = it->next;
		}
	}

	EZ_listview_Layout(listview);

	CONTROL_EVENT_HANDLER_CALL(NULL, listview, ez_listview_t, OnColumnGapChanged, ext_event_info);

	return 0;
}

//
// Listview - Set the width of a column.
//
void EZ_listview_SetColumnWidth(ez_listview_t *self, int column, int width)
{
	ez_listview_t *listview = (ez_listview_t *)self;

	if (column < 0 || column >= LISTVIEW_COLUMN_COUNT)
		return;

	self->col_widths[column] = width;

	CONTROL_RAISE_EVENT(NULL, listview, ez_listview_t, OnColumnWidthChanged, (void *)(uintptr_t)column);
}

//
// Listview - The width of a column has changed.
//
int EZ_listview_OnColumnWidthChanged(ez_control_t *self, void *ext_event_info)
{
	ez_listview_t *listview = (ez_listview_t *)self;
	ez_dllist_node_t *it = listview->items.head;
	ez_listviewitem_t *lvi = NULL;
	int column = (int)(uintptr_t)ext_event_info;

	if (listview->items.count > 0)
	{
		while (it->next)
		{
			lvi = (ez_listviewitem_t *)it->payload;
			EZ_listviewitem_SetColumnWidth(lvi, column, listview->col_widths[column]);
			it = it->next;
		}
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, listview, ez_listview_t, OnColumnWidthChanged, ext_event_info);
	return 0;
}

//
// Listview - Set the width of a column.
//
void EZ_listview_SetRowHeight(ez_listview_t *self, int row_height)
{
	self->row_height = row_height;

	CONTROL_RAISE_EVENT(NULL, self, ez_listview_t, OnRowHeightChanged, NULL);
}

//
// Listview - The height of the rows has changed.
//
int EZ_listview_OnRowHeightChanged(ez_control_t *self, void *ext_event_info)
{
	ez_listview_t *listview = (ez_listview_t *)self;
	ez_dllist_node_t *it = listview->items.head;
	ez_control_t *lvi = NULL;

	if (listview->items.count > 0)
	{
		while (it->next)
		{
			lvi = (ez_control_t *)it->payload;
			EZ_control_SetSize(lvi, lvi->width, lvi->height);
			it = it->next;
		}
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, listview, ez_listview_t, OnRowHeightChanged, ext_event_info);
	return 0;
}




================================================
FILE: src/ez_listview.h
================================================

#ifndef __EZ_LISTVIEW_H__
#define __EZ_LISTVIEW_H__
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_listviewitem.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

#include "ez_controls.h"
#include "ez_scrollpane.h"
#include "ez_listviewitem.h"

// =========================================================================================
// Listview
// =========================================================================================

//
// Information associated with the change of an item column change.
//
typedef struct ez_listview_changeinfo_s
{
	ez_listview_subitem_t *item;		// Contains the info about the new text of the listview column that was changed, and its user associated payload.
	int row;							// The row of the listview that this item is on.
	int column;							// The column of the listview that this item is on.
	void *payload;						// The user associated payload associated with this listview item (the entire row, not just the column).
} ez_listview_changeinfo_t;

typedef struct ez_listview_eventcount_s
{
	int OnItemAdded;
	int OnRowGapChanged;
	int OnColumnGapChanged;
	int OnColumnWidthChanged;
	int OnRowHeightChanged;
} ez_listview_eventcount_t;

typedef struct ez_listview_events_s
{
	ez_event_fp OnItemAdded;			// When an item is added to the listview.
	ez_event_fp OnRowGapChanged;		// The row gap has changed.
	ez_event_fp OnColumnGapChanged;		// The column gap has changed.
	ez_event_fp OnColumnWidthChanged;	// The width of a column has changed.
	ez_event_fp OnRowHeightChanged;		// The height of the rows has been changed.
} ez_listview_events_t;

typedef struct ez_listview_eventhandlers_s
{
	ez_eventhandler_t	*OnItemAdded;
	ez_eventhandler_t	*OnRowGapChanged;
	ez_eventhandler_t	*OnColumnGapChanged;
	ez_eventhandler_t	*OnColumnWidthChanged;
	ez_eventhandler_t	*OnRowHeightChanged;
} ez_listview_eventhandlers_t;

typedef struct ez_listview_s
{
	ez_control_t			super;
	//ez_scrollpane_t			super;				// The super class
												// (we inherit a scrollpane instead of a normal control so we get scrolling also)

	ez_listview_events_t	events;				// Specific events for the listview control.
	ez_listview_eventhandlers_t event_handlers;	// Specific event handlers for the listview control.
	ez_listview_eventcount_t inherit_levels;
	ez_listview_eventcount_t override_counts;

	ez_listviewitem_t		*header;			// The header row control of the listview.
	ez_double_linked_list_t	items;				// The listview items.
	int						row_height;			// The height of the listview rows.
	int						col_widths[LISTVIEW_COLUMN_COUNT];	// The widths of the  items.
	int						col_gap;			// The gap to use between columns.
	int						row_gap;			// The gap to use between rows.

	int						sort_column_index;	// The index of the column that we should sort by.
	qbool					sort_ascending;		// Sort ascending or descending when sorting by column?

	int						override_count;		// These are needed so that subclasses can override listview specific events.
	int						inheritance_level;
} ez_listview_t;

//
// Listview - Creates a new listview and initializes it.
//
ez_listview_t *EZ_listview_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Listview - Initializes a listview.
//
void EZ_listview_Init(ez_listview_t *listview, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Listview - Destroys a listview.
//
int EZ_listview_Destroy(ez_control_t *self, qbool destroy_children);

//
// Listview - Adds a listview item to the listview. Expects an array of column items as argument (and a count of how many).
//
void EZ_listview_AddItem(ez_listview_t *self, const ez_listview_subitem_t *sub_items, int subitem_count, void *payload);

//
// Listview - Removes an item at a specific index.
//
void EZ_listview_RemoveItemByIndex(ez_listview_t *self, int index);

//
// Listview - Removes an item with a specific payload.
//
void EZ_listview_RemoveItemByPayload(ez_listview_t *self, void *payload);

//
// Listview - Removes a range of items from a listview.
//
void EZ_listview_RemoveRange(ez_listview_t *self, int start, int end);

// 
// Convenience macro for getting the listview items from a void pointer in comparison functions.
//
#define GET_LISTVIEW_ITEM(lnode) ((ez_listviewitem_t *)( (ez_dllist_node_t *)(lnode))->payload)

//
// Listview - Sorts the list view by a user supplied function. (The listview items will have the listview as a parent).
//
void EZ_listview_SortByUserFunc(ez_listview_t *self, PtFuncCompare compare_function);

//
// Listview - Sorts the listview items by a specified column.
//
void EZ_listview_SortByColumn(ez_listview_t *self);

//
// Listview - Set the column to sort by.
//
void EZ_listview_SetSortColumn(ez_listview_t *self, int column);

//
// Listview - Set the text of the header.
//
void EZ_listview_SetHeaderText(ez_listview_t *self, int column, const char *text);

//
// Listview - On Resize event handler.
//
int EZ_listview_OnResize(ez_control_t *self, void *ext_event_info);

//
// Listview - An item was added to the listview.
//
int EZ_listview_OnItemAdded(ez_control_t *self, void *ext_event_info);

//
// Listview - Sets the column gap size of the listview.
//
void EZ_listview_SetColumnGap(ez_listview_t *self, int gap);

//
// Listview - Sets the row gap size of the listview.
//
void EZ_listview_SetRowGap(ez_listview_t *self, int gap);

//
// Listview - The column gap size has changed.
//
int EZ_listview_OnColumnGapChanged(ez_control_t *self, void *ext_event_info);

//
// Listview - The row gap size has changed.
//
int EZ_listview_OnRowGapChanged(ez_control_t *self, void *ext_event_info);

//
// Listview - Set the width of a column.
//
void EZ_listview_SetColumnWidth(ez_listview_t *self, int column, int width);

//
// Listview - The width of a column has changed.
//
int EZ_listview_OnColumnWidthChanged(ez_control_t *self, void *ext_event_info);

//
// Listview - Set the width of a column.
//
void EZ_listview_SetRowHeight(ez_listview_t *self, int row_height);

//
// Listview - The height of the rows has changed.
//
int EZ_listview_OnRowHeightChanged(ez_control_t *self, void *ext_event_info);

#endif // __EZ_LISTVIEW_H__



================================================
FILE: src/ez_listviewitem.c
================================================

/*
Copyright (C) 2008 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_listviewitem.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_listviewitem.h"

#define VALID_COLUMN(column) ((column >= 0) && (column < self->item_count))

//
// Listview item - Creates a new listview item and initializes it.
//
ez_listviewitem_t *EZ_listviewitem_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	ez_listviewitem_t *listviewitem = NULL;

	// We have to have a tree to add the control to.
	if (!tree)
	{
		return NULL;
	}

	listviewitem = (ez_listviewitem_t *)Q_malloc(sizeof(ez_listviewitem_t));
	memset(listviewitem, 0, sizeof(ez_listviewitem_t));

	EZ_listviewitem_Init(listviewitem, tree, parent, name, description, x, y, width, height, flags);
	
	return listviewitem;
}

//
// Listview item - Initializes a listview item.
//
void EZ_listviewitem_Init(ez_listviewitem_t *listviewitem, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	int i;

	// Initialize the inherited class first.
	EZ_control_Init(&listviewitem->super, tree, parent, name, description, x, y, width, height, flags);

	((ez_control_t *)listviewitem)->CLASS_ID		= EZ_LISTVIEWITEM_ID;
	((ez_control_t *)listviewitem)->ext_flags		|= (flags | control_focusable | control_contained | control_resizeable);

	// Make all columns visible by default :)
	for (i = 0; i < LISTVIEW_COLUMN_COUNT; i++)
	{
		listviewitem->item_visibile[i] = true;
	}

	// Listview item specific events.
	CONTROL_REGISTER_EVENT(listviewitem, EZ_listviewitem_OnColumnAdded, OnColumnAdded, ez_listviewitem_t);
	CONTROL_REGISTER_EVENT(listviewitem, EZ_listviewitem_OnColumnVisibilityChanged, OnColumnVisibilityChanged, ez_listviewitem_t);
	CONTROL_REGISTER_EVENT(listviewitem, EZ_listviewitem_OnColumnGapChanged, OnColumnGapChanged, ez_listviewitem_t);
	CONTROL_REGISTER_EVENT(listviewitem, EZ_listviewitem_OnColumnWidthChanged, OnColumnWidthChanged, ez_listviewitem_t);
	
	//CONTROL_REGISTER_EVENT(listviewitem, EZ_listviewitem_OnSubItemChanged, OnSubItemChanged, ez_listviewitem_t);
}

//
// Listview item - Destroys a listview item.
//
int EZ_listviewitem_Destroy(ez_control_t *self, qbool destroy_children)
{
	int i;
	ez_listviewitem_t *listviewitem = (ez_listviewitem_t *)self;
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDestroy, destroy_children); 

	// TODO : Remove any event handlers.
	EZ_eventhandler_Remove(listviewitem->event_handlers.OnColumnAdded, NULL, true);
	EZ_eventhandler_Remove(listviewitem->event_handlers.OnColumnVisibilityChanged, NULL, true);
	//EZ_eventhandler_Remove(listviewitem->event_handlers.OnSubItemChanged, NULL, true);

	// Cleanup columns.
	for (i = 0; i < listviewitem->item_count; i++)
	{
		// TODO: Hmm should we raise it like this?
		CONTROL_RAISE_EVENT(NULL, listviewitem->items[i], ez_control_t, OnDestroy, true);
	}

	EZ_control_Destroy((ez_control_t *)self, destroy_children);

	return 0;
}

//
// Listview item - Adds a column to the listview item.
//
void EZ_listviewitem_AddColumn(ez_listviewitem_t *self, ez_listview_subitem_t data, int width)
{
	int column = 0;
	ez_label_t *label = NULL;
	ez_control_t *ctrl = (ez_control_t *)self;

	if (self->item_count >= sizeof(self->items))
	{
		Sys_Error("EZ_listviewitem_AddColumn: Max allowed columns %i exceeded.\n", sizeof(self->items));
	}

	// Create a new label to use as the column.
	label = EZ_label_Create(ctrl->control_tree, ctrl, "Listview item column", "", 0, 0, width, 5, 0, 0, data.text);
	EZ_control_SetPayload(ctrl, data.payload);
	EZ_control_SetAnchor(ctrl, anchor_left | anchor_top | anchor_bottom);

	// Add the item to the columns.
	self->items[self->item_count] = label;
	column = self->item_count;
	self->item_count++;

	CONTROL_RAISE_EVENT(NULL, ctrl, ez_listviewitem_t, OnColumnAdded, (void *)(uintptr_t)column);
}

//
// Listview item - Event for when a new column was added to the listview item.
//
int EZ_listviewitem_OnColumnAdded(ez_control_t *self, void *column)
{
	ez_listviewitem_t *lvi = (ez_listviewitem_t *)self;
	EZ_listviewitem_LayoutControl(lvi);

	CONTROL_EVENT_HANDLER_CALL(NULL, lvi, ez_listviewitem_t, OnColumnAdded, column);
	// TODO: Layout the control again if some mischevaous event handler changed the size/position of the columns? :D

	return 0;
}

//
// Listview item - Lays out the control.
//
void EZ_listviewitem_LayoutControl(ez_listviewitem_t *self)
{
	int i;
	int x = 0;
	ez_control_t *ctrl		= (ez_control_t *)self;
	ez_control_t *lblctrl	= NULL;

	for (i = 0; i < self->item_count; i++)
	{
		if (!self->item_visibile[i])
			continue;

		lblctrl = (ez_control_t *)self->items[i];

		// Space out the labels in columns.
		EZ_control_SetPosition(lblctrl, x, 0);
		x += lblctrl->width + self->item_gap;

		// Make sure we reset the height if some naughty person changed it since last time.
		EZ_control_SetSize(lblctrl, lblctrl->width, ctrl->height);
	}
}

//
// Listview item - Gets a column from the listview item.
//
ez_label_t *EZ_listviewitem_GetColumn(ez_listviewitem_t *self, int column)
{
	return VALID_COLUMN(column) ? self->items[column] : NULL;
}

//
// Listview item - Sets if a column should be visible or not.
//
void EZ_listviewitem_SetColumnVisible(ez_listviewitem_t *self, int column, qbool visible)
{
	if (!VALID_COLUMN(column))
		return;

	self->item_visibile[column] = visible;
	EZ_control_SetVisible((ez_control_t *)self->items[column], visible);

	CONTROL_RAISE_EVENT(NULL, self, ez_listviewitem_t, OnColumnVisibilityChanged, (void *)(uintptr_t)column);
}

//
// Listview item - The visibility changed for a column.
//
int EZ_listviewitem_OnColumnVisibilityChanged(ez_control_t *self, void *column)
{
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_listviewitem_t, OnColumnVisibilityChanged, column);
	return 0;
}

//
// Listview item - Sets the gap between columns.
//
void EZ_listviewitem_SetColumnGap(ez_listviewitem_t *self, int gap)
{
	self->item_gap = gap;

	CONTROL_RAISE_EVENT(NULL, self, ez_listviewitem_t, OnColumnGapChanged, NULL);
}

//
// Listview item - Event for when the column gap has changed.
//
int EZ_listviewitem_OnColumnGapChanged(ez_control_t *self, void *ext_event_info)
{
	ez_listviewitem_t *lvi = (ez_listviewitem_t *)self;
	EZ_listviewitem_LayoutControl(lvi);
	
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_listviewitem_t, OnColumnGapChanged, NULL);
	return 0;
}

//
// Listview item - Sets the column width for a given column.
//
void EZ_listviewitem_SetColumnWidth(ez_listviewitem_t *self, int column, int width)
{
	if (!VALID_COLUMN(column))
		return;

	self->item_widths[column] = width;

	CONTROL_RAISE_EVENT(NULL, self, ez_listviewitem_t, OnColumnWidthChanged, (void *)(uintptr_t)column);
}

//
// Listview item - The column width has changed for some column.
//
int EZ_listviewitem_OnColumnWidthChanged(ez_control_t *self, void *ext_event_info)
{
	ez_listviewitem_t *lvi = (ez_listviewitem_t *)self;
	int column = (int)(uintptr_t)ext_event_info;

	EZ_control_SetSize(self, lvi->item_widths[column], self->height);

	CONTROL_EVENT_HANDLER_CALL(NULL, lvi, ez_listviewitem_t, OnColumnWidthChanged, ext_event_info);
	return 0;
}

#if 0
//
// Listview item - A sub items text has changed.
//
int EZ_listviewitem_OnSubItemChanged(ez_control_t *self, void *ext_event_info)
{
	ez_listviewitem_changeinfo_t *change = (ez_listviewitem_changeinfo_t *)ext_event_info;

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_listviewitem_t, OnSubItemChanged, ext_event_info);
	return 0;
}


//
// Listview item - The text of a label in a sub item changed (event handler).
//
static int EZ_listviewitem_OnLabelTextChanged(ez_control_t *self, void *payload, void *ext_event_info)
{
	ez_label_t *label = (ez_label_t *)self;
	ez_listviewitem_changeinfo_t change;
	ez_listview_subitem_t item;

	item.payload	= self->payload;
	//item.text		= label->
	
	change.column	= (int)*self->payload; // TODO: Save the column in the label controls payload.
	change.payload	= self;
	

	CONTROL_RAISE_EVENT(NULL, self, ez_listviewitem_t, OnSubItemChanged, (void *)&change);
}
#endif



================================================
FILE: src/ez_listviewitem.h
================================================

#ifndef __EZ_LISTVIEWITEM_H__
#define __EZ_LISTVIEWITEM_H__
/*
Copyright (C) 2008 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_listviewitem.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

#include "ez_controls.h"
#include "ez_label.h"

// =========================================================================================
// Listview item
// =========================================================================================

#define LISTVIEW_COLUMN_COUNT	32

typedef struct ez_listview_subitem_s
{
	char *text;			// The text that should be used in the listview column. The contents of this pointer will be COPIED not used directly.
	void *payload;		// A pointer to a payload item supplied by the user. Up to the caller to clean this up.
} ez_listview_subitem_t;

//
// Information associated with the change of an item column change.
//
typedef struct ez_listviewitem_changeinfo_s
{
	//ez_listview_subitem_t	*item;		// Contains the info about the new text of the listview column that was changed, and its user associated payload.
	ez_label_t				*item;
	int						column;		// The column of the listview that this item is on.
	void					*payload;	// The user associated payload associated with this listview item (the entire row, not just the column).
} ez_listviewitem_changeinfo_t;

typedef struct ez_listviewitem_eventcount_s
{
	int OnColumnAdded;
	int OnColumnVisibilityChanged;
	int OnColumnGapChanged;
	int OnColumnWidthChanged;
	//int OnSubItemChanged;
} ez_listviewitem_eventcount_t;

typedef struct ez_listviewitem_events_s
{
	ez_event_fp OnColumnAdded;
	ez_event_fp	OnColumnVisibilityChanged;
	ez_event_fp OnColumnGapChanged;
	ez_event_fp OnColumnWidthChanged;
	//ez_event_fp OnSubItemChanged;
} ez_listviewitem_events_t;

typedef struct ez_listviewitem_eventhandlers_s
{
	ez_eventhandler_t *OnColumnAdded;
	ez_eventhandler_t *OnColumnVisibilityChanged;
	ez_eventhandler_t *OnColumnGapChanged;
	ez_eventhandler_t *OnColumnWidthChanged;
	//ez_eventhandler_t *OnSubItemChanged;
} ez_listviewitem_eventhandlers_t;

typedef struct ez_listviewitem_s
{
	ez_control_t			super;							// The super class.
															// (we inherit a scrollpane instead of a normal control so we get scrolling also)

	ez_listviewitem_events_t		events;
	ez_listviewitem_eventhandlers_t	event_handlers;
	ez_listviewitem_eventcount_t	inherit_levels;
	ez_listviewitem_eventcount_t	override_counts;

	ez_label_t				*items[LISTVIEW_COLUMN_COUNT];			// The sub items (what's shown in the columns).
	int						item_count;								// 
	int						item_gap;								// The gap between two controls.
	int						item_widths[LISTVIEW_COLUMN_COUNT];		// The width of the sub items.
	qbool					item_visibile[LISTVIEW_COLUMN_COUNT];	// Which columns are visible?

	int						override_count;							// These are needed so that subclasses can override listview specific events.
	int						inheritance_level;
} ez_listviewitem_t;

//
// Listview item - Creates a new listview item and initializes it.
//
ez_listviewitem_t *EZ_listviewitem_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Listview item - Initializes a listview item.
//
void EZ_listviewitem_Init(ez_listviewitem_t *listviewitem, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Listview item - Destroys a listview item.
//
int EZ_listviewitem_Destroy(ez_control_t *self, qbool destroy_children);

//
// Listview item - Event for when a new column was added to the listview item.
//
int EZ_listviewitem_OnColumnAdded(ez_control_t *self, void *column);

//
// Listview item - The visibility changed for a column.
//
int EZ_listviewitem_OnColumnVisibilityChanged(ez_control_t *self, void *ext_event_info);

//
// Listview item - Adds a column to the listview item.
//
void EZ_listviewitem_AddColumn(ez_listviewitem_t *self, ez_listview_subitem_t data, int width);

//
// Listview item - Lays out the control.
//
void EZ_listviewitem_LayoutControl(ez_listviewitem_t *self);

//
// Listview item - Gets a column from the listview item.
//
ez_label_t *EZ_listviewitem_GetColumn(ez_listviewitem_t *self, int column);

//
// Listview item - Sets if a column should be visible or not.
//
void EZ_listviewitem_SetColumnVisible(ez_listviewitem_t *self, int column, qbool visible);

//
// Listview item - A sub items text has changed.
//
int EZ_listviewitem_OnSubItemChanged(ez_control_t *self, void *ext_event_info);

//
// Listview item - Event for when the column gap has changed.
//
int EZ_listviewitem_OnColumnGapChanged(ez_control_t *self, void *ext_event_info);

//
// Listview item - Sets the gap between columns.
//
void EZ_listviewitem_SetColumnGap(ez_listviewitem_t *self, int gap);

//
// Listview item - Sets the column width for a given column.
//
void EZ_listviewitem_SetColumnWidth(ez_listviewitem_t *self, int column, int width);

//
// Listview item - The column width has changed for some column.
//
int EZ_listviewitem_OnColumnWidthChanged(ez_control_t *self, void *ext_event_info);

#endif // __EZ_LISTVIEWITEM_H__



================================================
FILE: src/ez_scrollbar.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_scrollpane.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_controls.h"
#include "ez_scrollbar.h"

#ifdef _MSC_VER
#pragma warning( disable : 4189 )
#endif

// =========================================================================================
// Scrollbar
// =========================================================================================

//
// Scrollbar - OnMouseDown event.
//
int EZ_scrollbar_OnSliderMouseDown(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	if (!self->parent || self->parent->CLASS_ID != EZ_SCROLLBAR_ID)
	{
		Sys_Error("EZ_scrollbar_OnSliderMove(): Parent of slider is not a scrollbar!");
	}
	else
	{
		ez_scrollbar_t *scrollbar = (ez_scrollbar_t *)self->parent;

		// Start sliding.
		scrollbar->int_flags |= sliding;
	}

	return true;
}

//
// Scrollbar - Generic scroll button action event handler.
//
static void EZ_scrollbar_OnScrollButtonMouseDown(ez_scrollbar_t *scrollbar, qbool back)
{
	ez_control_t *scrollbar_ctrl = (ez_control_t *)scrollbar;
	ez_control_t *scroll_target = (scrollbar->ext_flags & target_parent) ? scrollbar_ctrl->parent : scrollbar->target;

	if (!scroll_target)
	{
		return; // We have nothing to scroll.
	}

	if (scrollbar->orientation == vertical)
	{
		EZ_control_SetScrollChange(scroll_target, 0, (back ? -scrollbar->scroll_delta_y : scrollbar->scroll_delta_y));
	}
	else
	{
		EZ_control_SetScrollChange(scroll_target, (back ? -scrollbar->scroll_delta_x : scrollbar->scroll_delta_x), 0);
	}
}

//
// Scrollbar - Event handler for pressing the back button (left or up).
//
static int EZ_scrollbar_OnBackButtonMouseDown(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	if (!self->parent || self->parent->CLASS_ID != EZ_SCROLLBAR_ID)
	{
		Sys_Error("EZ_scrollbar_OnBackButtonMouseDown(): Parent of back button is not a scrollbar!");
	}
	else 
	{
		ez_scrollbar_t *scrollbar = (ez_scrollbar_t *)self->parent;
		EZ_scrollbar_OnScrollButtonMouseDown(scrollbar, true);
	}

	return true;
}

//
// Scrollbar - Event handler for pressing the back button (left or up).
//
static int EZ_scrollbar_OnForwardButtonMouseDown(ez_control_t *self, void *payload, mouse_state_t *ms)
{
	if (!self->parent || self->parent->CLASS_ID != EZ_SCROLLBAR_ID)
	{
		Sys_Error("EZ_scr	ollbar_OnForwardButtonMouseDown(): Parent of forward button is not a scrollbar!");
	}
	else
	{
		ez_scrollbar_t *scrollbar = (ez_scrollbar_t *)self->parent;
		EZ_scrollbar_OnScrollButtonMouseDown(scrollbar, false);
	}

	return true;
}

//
// Scrollbar - Creates a new scrollbar and initializes it.
//
ez_scrollbar_t *EZ_scrollbar_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	ez_scrollbar_t *scrollbar = NULL;

	// We have to have a tree to add the control to.
	if (!tree)
	{
		return NULL;
	}

	scrollbar = (ez_scrollbar_t *)Q_malloc(sizeof(ez_scrollbar_t));
	memset(scrollbar, 0, sizeof(ez_scrollbar_t));

	EZ_scrollbar_Init(scrollbar, tree, parent, name, description, x, y, width, height, flags);
	
	return scrollbar;
}

//
// Scrollbar - Initializes a scrollbar.
//
void EZ_scrollbar_Init(ez_scrollbar_t *scrollbar, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	// Initialize the inherited class first.
	EZ_control_Init(&scrollbar->super, tree, parent, name, description, x, y, width, height, flags);

	// Initilize the button specific stuff.
	((ez_control_t *)scrollbar)->CLASS_ID	= EZ_SCROLLBAR_ID;
	((ez_control_t *)scrollbar)->ext_flags	|= (flags | control_focusable | control_contained | control_resizeable);

	// Override control events.
	CONTROL_REGISTER_EVENT(scrollbar, EZ_scrollbar_Destroy, OnDestroy, ez_control_t);
	CONTROL_REGISTER_EVENT(scrollbar, EZ_scrollbar_OnResize, OnResize, ez_control_t);
	CONTROL_REGISTER_EVENT(scrollbar, EZ_scrollbar_OnParentResize, OnParentResize, ez_control_t);
	CONTROL_REGISTER_EVENT(scrollbar, EZ_scrollbar_OnMouseEvent, OnMouseEvent, ez_control_t);
	CONTROL_REGISTER_EVENT(scrollbar, EZ_scrollbar_OnMouseDown, OnMouseDown, ez_control_t);
	CONTROL_REGISTER_EVENT(scrollbar, EZ_scrollbar_OnMouseUpOutside, OnMouseUpOutside, ez_control_t);
	CONTROL_REGISTER_EVENT(scrollbar, EZ_scrollbar_OnParentScroll, OnParentScroll, ez_control_t);

	// Scrollbar specific events.
	CONTROL_REGISTER_EVENT(scrollbar, EZ_scrollbar_OnTargetChanged, OnTargetChanged, ez_scrollbar_t);

	scrollbar->back		= EZ_button_Create(tree, (ez_control_t *)scrollbar, "Scrollbar back button", "", 0, 0, 0, 0, control_contained | control_enabled);
	scrollbar->forward	= EZ_button_Create(tree, (ez_control_t *)scrollbar, "Scrollbar forward button", "", 0, 0, 0, 0, control_contained | control_enabled);
	scrollbar->slider	= EZ_button_Create(tree, (ez_control_t *)scrollbar, "Scrollbar slider button", "", 0, 0, 0, 0, control_contained | control_enabled);
	
	EZ_control_AddOnMouseDown((ez_control_t *)scrollbar->slider, EZ_scrollbar_OnSliderMouseDown, NULL);
	EZ_control_AddOnMouseDown((ez_control_t *)scrollbar->back, EZ_scrollbar_OnBackButtonMouseDown, NULL);
	EZ_control_AddOnMouseDown((ez_control_t *)scrollbar->forward, EZ_scrollbar_OnForwardButtonMouseDown, NULL);

	scrollbar->slider_minsize = 5;
	scrollbar->scroll_delta_x = 1;
	scrollbar->scroll_delta_y = 1;

	// Listen to repeated mouse events so that we continue scrolling when
	// holding down the mouse button over the scroll arrows.
	EZ_control_SetListenToRepeatedMouseClicks((ez_control_t *)scrollbar->back, true);
	EZ_control_SetListenToRepeatedMouseClicks((ez_control_t *)scrollbar->forward, true);
	
	// TODO : Remove this test stuff.
	/*
	{
		EZ_button_SetNormalColor(scrollbar->back, 255, 125, 125, 125);
		EZ_button_SetNormalColor(scrollbar->forward, 255, 125, 125, 125);
		EZ_button_SetNormalColor(scrollbar->slider, 255, 125, 125, 125);
	}
	*/

	CONTROL_RAISE_EVENT(NULL, (ez_control_t *)scrollbar, ez_control_t, OnResize, NULL);
}

//
// Scrollbar - Destroys the scrollbar.
//
int EZ_scrollbar_Destroy(ez_control_t *self, qbool destroy_children)
{
	ez_scrollbar_t *scrollbar = (ez_scrollbar_t *)self;
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDestroy, destroy_children);

	EZ_eventhandler_Remove(scrollbar->event_handlers.OnTargetChanged, NULL, true);

	EZ_control_Destroy(self, destroy_children);

	return 0;
}

//
// Scrollbar - Calculates and sets the parents scroll position based on where the slider button is.
//
static void EZ_scrollbar_CalculateParentScrollPosition(ez_scrollbar_t *scrollbar, ez_control_t *target)
{
//	ez_control_t *self			= (ez_control_t *)scrollbar;
	ez_control_t *back_ctrl		= (ez_control_t *)scrollbar->back;
//	ez_control_t *forward_ctrl	= (ez_control_t *)scrollbar->forward;
	ez_control_t *slider_ctrl	= (ez_control_t *)scrollbar->slider;
	float scroll_ratio;

	if (!target)
	{
		return;
	}

	if (scrollbar->orientation == vertical)
	{
		scroll_ratio = (slider_ctrl->y - back_ctrl->height) / (float)scrollbar->scroll_area;
		EZ_control_SetScrollPosition(target, target->virtual_x, Q_rint(scroll_ratio * target->virtual_height));
	}
	else
	{
		scroll_ratio = (slider_ctrl->x - back_ctrl->width) / (float)scrollbar->scroll_area;
		EZ_control_SetScrollPosition(target, Q_rint(scroll_ratio * target->virtual_width), target->virtual_y);
	}
}

//
// Scrollbar - Updates the slider position of the scrollbar based on the parents scroll position.
//
static void EZ_scrollbar_UpdateSliderBasedOnTarget(ez_scrollbar_t *scrollbar, ez_control_t *target)
{
	ez_control_t *self			= (ez_control_t *)scrollbar;
	ez_control_t *back_ctrl		= (ez_control_t *)scrollbar->back;
	ez_control_t *forward_ctrl	= (ez_control_t *)scrollbar->forward;
	ez_control_t *slider_ctrl	= (ez_control_t *)scrollbar->slider;
	float scroll_ratio;

	if (!target)
	{
		return;
	}

	// Don't do anything if this is the user moving the slider using the mouse.
	if (scrollbar->int_flags & scrolling)
	{
		return;
	}

	if (scrollbar->orientation == vertical)
	{
		int new_y;

		// Find how far down on the parent control we're scrolled (percentage).
		scroll_ratio = fabs(target->virtual_y / (float)target->virtual_height);
		
		// Calculate the position of the slider by multiplying the scroll areas
		// height with the scroll ratio.
		new_y = back_ctrl->height + Q_rint(scroll_ratio * scrollbar->scroll_area);
		clamp(new_y, back_ctrl->height, (self->height - forward_ctrl->height - slider_ctrl->height));

		EZ_control_SetPosition(slider_ctrl, 0, new_y);
	}
	else
	{
		int new_x;
		scroll_ratio = fabs(target->virtual_x / (float)target->virtual_width);
		
		new_x = back_ctrl->width + Q_rint(scroll_ratio * scrollbar->scroll_area);
		clamp(new_x, back_ctrl->width, (self->width - forward_ctrl->width - slider_ctrl->width));
		
		EZ_control_SetPosition(slider_ctrl, new_x, 0);
	}
}

//
// Scrollbar - Sets if the target for the scrollbar should be it's parent, or a specified target control.
//				(The target controls OnScroll event handler will be used if it's not the parent)
//
void EZ_scrollbar_SetTargetIsParent(ez_scrollbar_t *scrollbar, qbool targetparent)
{
	SET_FLAG(scrollbar->ext_flags, target_parent, targetparent);
}

//
// Scrollbar - Set the minimum slider size.
//
void EZ_scrollbar_SetSliderMinSize(ez_scrollbar_t *scrollbar, int minsize)
{
	scrollbar->slider_minsize = max(1, minsize);
}

//
// Scrollbar - Sets the amount to scroll the parent control when pressing the scrollbars scroll buttons.
//
void EZ_scrollbar_SetScrollDelta(ez_scrollbar_t *scrollbar, int scroll_delta_x, int scroll_delta_y)
{
	scrollbar->scroll_delta_x = max(1, scroll_delta_x);
	scrollbar->scroll_delta_y = max(1, scroll_delta_y);
}

//
// Scrollbar - Set if the scrollbar should be vertical or horizontal.
//
void EZ_scrollbar_SetIsVertical(ez_scrollbar_t *scrollbar, qbool is_vertical)
{
	scrollbar->orientation = (is_vertical ? vertical : horizontal);
}

//
// Scrollbar - Calculates the size of the slider button.
//
static void EZ_scrollbar_CalculateSliderSize(ez_scrollbar_t *scrollbar, ez_control_t *target)
{
	ez_control_t *self = (ez_control_t *)scrollbar;

	if (target)
	{
		if (scrollbar->orientation == vertical)
		{
			// Get the percentage of the parent that is shown and calculate the new slider button size from that. 
			float target_height_ratio	= (target->height / (float)target->virtual_height);
			int new_slider_height		= max(scrollbar->slider_minsize, Q_rint(target_height_ratio * scrollbar->scroll_area));

			EZ_control_SetSize((ez_control_t *)scrollbar->slider, self->width, new_slider_height);
		}
		else
		{
			float target_width_ratio	= (target->width / (float)target->virtual_width);
			int new_slider_width		= max(scrollbar->slider_minsize, Q_rint(target_width_ratio * scrollbar->scroll_area));

			EZ_control_SetSize((ez_control_t *)scrollbar->slider, new_slider_width, self->height);
		}
	}
}

//
// Scrollbar - Repositions the back / forward buttons according to orientation.
//
static void EZ_scrollbar_RepositionScrollButtons(ez_scrollbar_t *scrollbar)
{
	ez_control_t *self			= (ez_control_t *)scrollbar;
	ez_control_t *back_ctrl		= (ez_control_t *)scrollbar->back;
	ez_control_t *slider_ctrl	= (ez_control_t *)scrollbar->slider;
	ez_control_t *forward_ctrl	= (ez_control_t *)scrollbar->forward;

	// Let the super class do it's thing first.
	EZ_control_OnResize(self, NULL);

	if (scrollbar->orientation == vertical)
	{
		// Up button.
		EZ_control_SetSize(back_ctrl, self->width, self->width);
		EZ_control_SetAnchor(back_ctrl, anchor_left | anchor_top | anchor_right);

		// Slider.
		EZ_control_SetPosition(slider_ctrl, 0, self->width);
		EZ_control_SetAnchor(slider_ctrl, anchor_left | anchor_right);

		// Down button.
		EZ_control_SetSize(forward_ctrl, self->width, self->width);
		EZ_control_SetAnchor(forward_ctrl, anchor_left | anchor_bottom | anchor_right);

		scrollbar->scroll_area = self->height - (forward_ctrl->height + back_ctrl->height);
	}
	else
	{
		// Left button.
		EZ_control_SetSize(back_ctrl, self->height, self->height);
		EZ_control_SetAnchor(back_ctrl, anchor_left | anchor_top | anchor_bottom);

		// Slider.
		EZ_control_SetPosition(slider_ctrl, self->height, 0);
		EZ_control_SetAnchor(slider_ctrl, anchor_top | anchor_bottom);

		// Right button.
		EZ_control_SetSize(forward_ctrl, self->height, self->height);
		EZ_control_SetAnchor(forward_ctrl, anchor_top | anchor_bottom | anchor_right);

		scrollbar->scroll_area = self->width - (forward_ctrl->width + back_ctrl->width);
	}
}

//
// Control - Event handler for when the target control gets scrolled.
//
static int EZ_scrollbar_OnTargetScroll(ez_control_t *self, void *payload, void *ext_event_info)
{
	ez_scrollbar_t *scrollbar = NULL;

	if (!payload)
	{
		Sys_Error("EZ_scrollbar_OnTargetResize(): Payload is NULL, so no scrollbar object.");
	}

	scrollbar = (ez_scrollbar_t *)payload;

	if (!(scrollbar->ext_flags & target_parent))
	{
		EZ_scrollbar_UpdateSliderBasedOnTarget(scrollbar, scrollbar->target);
	}

	return 0;
}

//
// Scrollbar - Generic function of what to do when one of the scrollbars target was resized.
//
static int EZ_scrollbar_OnTargetResize(ez_control_t *self, void *payload, void *ext_event_info)
{
	ez_scrollbar_t *scrollbar = NULL;

	if (!payload)
	{
		Sys_Error("EZ_scrollbar_OnTargetResize(): Payload is NULL, so no scrollbar object.");
	}

	scrollbar = (ez_scrollbar_t *)payload;

	if (!(scrollbar->ext_flags & target_parent))
	{
		EZ_scrollbar_CalculateSliderSize(scrollbar, scrollbar->target);
	}

	return 0;
}

//
// Scrollbar - Set the target control that the scrollbar should scroll.
//
void EZ_scrollbar_SetTarget(ez_scrollbar_t *scrollbar, ez_control_t *target)
{
	// Remove the event handlers from the old target.
	if (scrollbar->target)
	{
		EZ_eventhandler_Remove(scrollbar->target->event_handlers.OnResize, EZ_scrollbar_OnTargetResize, false);
		EZ_eventhandler_Remove(scrollbar->target->event_handlers.OnScroll, EZ_scrollbar_OnTargetScroll, false);
	}

	scrollbar->target = target;
	CONTROL_RAISE_EVENT(NULL, scrollbar, ez_scrollbar_t, OnTargetChanged, NULL);
}

//
// Scrollbar - The target of the scrollbar changed.
//
int EZ_scrollbar_OnTargetChanged(ez_control_t *self, void *ext_event_info)
{
	ez_scrollbar_t *scrollbar = (ez_scrollbar_t *)self;

	if (scrollbar->target)
	{
		EZ_control_AddOnScroll(scrollbar->target, EZ_scrollbar_OnTargetScroll, scrollbar);
		EZ_control_AddOnResize(scrollbar->target, EZ_scrollbar_OnTargetResize, scrollbar);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, scrollbar, ez_scrollbar_t, OnTargetChanged, NULL);
	return 0;
}

//
// Scrollbar - OnResize event.
//
int EZ_scrollbar_OnResize(ez_control_t *self, void *ext_event_info)
{
	ez_scrollbar_t *scrollbar = (ez_scrollbar_t *)self;

	// Let the super class do it's thing first.
	EZ_control_OnResize(self, NULL);

	// Make sure the buttons are in the correct place.
	EZ_scrollbar_RepositionScrollButtons(scrollbar);
	EZ_scrollbar_CalculateSliderSize(scrollbar, ((scrollbar->ext_flags & target_parent) ? self->parent : scrollbar->target));

	// Reset the min virtual size to 1x1 so that the 
	// scrollbar won't stop resizing when it's parent is resized.
	EZ_control_SetMinVirtualSize(self, 1, 1);

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnResize, NULL);
	return 0;
}

//
// Scrollbar - OnParentResize event.
//
int EZ_scrollbar_OnParentResize(ez_control_t *self, void *ext_event_info)
{
	ez_scrollbar_t *scrollbar = (ez_scrollbar_t *)self;

	// Let the super class do it's thing first.
	EZ_control_OnParentResize(self, NULL);

	if (scrollbar->ext_flags & target_parent)
	{
		EZ_scrollbar_CalculateSliderSize(scrollbar, self->parent);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnParentResize, NULL);
	return 0;
}

//
// Scrollbar - OnMouseDown event.
//
int EZ_scrollbar_OnMouseDown(ez_control_t *self, mouse_state_t *ms)
{
	qbool  mouse_handled = false;
//	ez_scrollbar_t *scrollbar	= (ez_scrollbar_t *)self;

	EZ_control_OnMouseDown(self, ms);

	CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseDown, ms);

	return mouse_handled;
}

//
// Scrollbar - OnMouseUpOutside event.
//
int EZ_scrollbar_OnMouseUpOutside(ez_control_t *self, mouse_state_t *ms)
{
	ez_scrollbar_t *scrollbar	= (ez_scrollbar_t *)self;
	qbool mouse_handled			= false;

	EZ_control_OnMouseUpOutside(self, ms);

	scrollbar->int_flags &= ~sliding;

	CONTROL_EVENT_HANDLER_CALL(&mouse_handled, self, ez_control_t, OnMouseUpOutside, ms);

	return false;
}

//
// Scrollbar - Mouse event.
//
int EZ_scrollbar_OnMouseEvent(ez_control_t *self, mouse_state_t *ms)
{
	ez_scrollbar_t *scrollbar		= (ez_scrollbar_t *)self;
	ez_control_t *back_ctrl			= (ez_control_t *)scrollbar->back;
	ez_control_t *forward_ctrl		= (ez_control_t *)scrollbar->forward;
	ez_control_t *slider_ctrl		= (ez_control_t *)scrollbar->slider;
	int m_delta_x					= Q_rint(ms->x - ms->x_old);
	int m_delta_y					= Q_rint(ms->y - ms->y_old);
	qbool mouse_handled				= false;
	qbool mouse_handled_tmp			= false;

	mouse_handled = EZ_control_OnMouseEvent(self, ms);

	if (!mouse_handled)
	{
		if (scrollbar->int_flags & sliding)
		{
			if (scrollbar->orientation == vertical)
			{
//				float scroll_ratio = 0;

				// Reposition the slider within the scrollbar control based on where the mouse moves.
				int new_y = slider_ctrl->y + m_delta_y;

				// Only allow moving the scroll slider in the area between the two buttons (the scroll area).
				clamp(new_y, back_ctrl->height, (self->height - forward_ctrl->height - slider_ctrl->height));
				EZ_control_SetPosition(slider_ctrl, 0, new_y);

				mouse_handled = true;
			}
			else
			{
				int new_x = slider_ctrl->x + m_delta_x;
				clamp(new_x, back_ctrl->width, (self->width - forward_ctrl->width - slider_ctrl->width));
				EZ_control_SetPosition(slider_ctrl, new_x, 0);
				mouse_handled = true;
			}

			// Make sure we don't try to set the position of the slider
			// as the parents scroll position changes, like normal.
			scrollbar->int_flags |= scrolling;

			if (scrollbar->ext_flags & target_parent)
			{
				EZ_scrollbar_CalculateParentScrollPosition(scrollbar, self->parent);
			}
			else
			{
				EZ_scrollbar_CalculateParentScrollPosition(scrollbar, scrollbar->target);
			}
			
			scrollbar->int_flags &= ~scrolling;
		}
	}

	CONTROL_EVENT_HANDLER_CALL(&mouse_handled_tmp, self, ez_control_t, OnMouseEvent, ms);
	mouse_handled = (mouse_handled | mouse_handled_tmp);

	return mouse_handled;
}

//
// Scrollbar - OnParentScroll event.
//
int EZ_scrollbar_OnParentScroll(ez_control_t *self, void *ext_event_info)
{
	ez_scrollbar_t *scrollbar = (ez_scrollbar_t *)self;

	// Super class.
	EZ_control_OnParentScroll(self, NULL);

	// Update the slider button to match the new scroll position.
	if (scrollbar->ext_flags & target_parent)
	{
		EZ_scrollbar_UpdateSliderBasedOnTarget(scrollbar, self->parent);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnParentScroll, NULL);
	return 0;
}





================================================
FILE: src/ez_scrollbar.h
================================================

#ifndef __EZ_SCROLLBAR_H__
#define __EZ_SCROLLBAR_H__
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_scrollbar.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

#include "ez_controls.h"
#include "ez_button.h"

// =========================================================================================
// Scrollbar
// =========================================================================================

typedef enum ez_orientation_s
{
	vertical	= 0,
	horizontal	= 1
} ez_orientation_t;

typedef enum ez_scrollbar_flags_e
{
	target_parent	= (1 << 0)
} ez_scrollbar_flags_t;

typedef enum ez_scrollbar_iflags_e
{
	sliding			= (1 << 0),
	scrolling		= (1 << 1)
} ez_scrollbar_iflags_t;

typedef struct ez_scrollbar_eventcount_s
{
	int OnTargetChanged;
} ez_scrollbar_eventcount_t;

typedef struct ez_scrollbar_events_s
{
	ez_event_fp	OnTargetChanged;
} ez_scrollbar_events_t;

typedef struct ez_scrollbar_eventhandlers_s
{
	ez_eventhandler_t		*OnTargetChanged;
} ez_scrollbar_eventhandlers_t;

typedef struct ez_scrollbar_s
{
	ez_control_t				super;				// The super class.

	ez_scrollbar_events_t		events;
	ez_scrollbar_eventhandlers_t event_handlers;
	ez_scrollbar_eventcount_t	inherit_levels;
	ez_scrollbar_eventcount_t	override_counts;

	ez_button_t					*back;				// Up / left button depending on the scrollbars orientation.
	ez_button_t					*slider;			// The slider button.
	ez_button_t					*forward;			// Down / right button.
	
	ez_orientation_t			orientation;		// The orientation of the scrollbar, vertical / horizontal.
	int							scroll_area;		// The width or height (depending on orientation) of the area between
													// the forward/back buttons. That is, the area you can move the slider in.

	int							slider_minsize;		// The minimum size of the slider button.
	int							scroll_delta_x;		// How much should the scrollbar scroll it's parent when the scroll buttons are pressed?
	int							scroll_delta_y;

	ez_control_t				*target;			// The target of the scrollbar if the parent isn't targeted (ext_flag & target_parent).

	ez_scrollbar_flags_t		ext_flags;			// External flags for the scrollbar.
	ez_scrollbar_iflags_t		int_flags;			// The internal flags for the scrollbar.
} ez_scrollbar_t;

//
// Scrollbar - Creates a new scrollbar and initializes it.
//
ez_scrollbar_t *EZ_scrollbar_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Scrollbar - Initializes a scrollbar.
//
void EZ_scrollbar_Init(ez_scrollbar_t *scrollbar, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Scrollbar - Destroys the scrollbar.
//
int EZ_scrollbar_Destroy(ez_control_t *self, qbool destroy_children);

//
// Scrollbar - Set the target control that the scrollbar should scroll.
//
void EZ_scrollbar_SetTarget(ez_scrollbar_t *scrollbar, ez_control_t *target);

//
// Scrollbar - Set if the scrollbar should be vertical or horizontal.
//
void EZ_scrollbar_SetIsVertical(ez_scrollbar_t *scrollbar, qbool is_vertical);

//
// Scrollbar - Sets if the target for the scrollbar should be it's parent, or a specified target control.
//				(The target controls OnScroll event handler will be used if it's not the parent)
//
void EZ_scrollbar_SetTargetIsParent(ez_scrollbar_t *scrollbar, qbool targetparent);

//
// Scrollbar - The target of the scrollbar changed.
//
int EZ_scrollbar_OnTargetChanged(ez_control_t *self, void *ext_event_info);

//
// Scrollbar - OnResize event.
//
int EZ_scrollbar_OnResize(ez_control_t *self, void *ext_event_info);

//
// Scrollbar - OnParentResize event.
//
int EZ_scrollbar_OnParentResize(ez_control_t *self, void *ext_event_info);

//
// Scrollbar - OnMouseDown event.
//
int EZ_scrollbar_OnMouseDown(ez_control_t *self, mouse_state_t *ms);

//
// Scrollbar - OnMouseUpOutside event.
//
int EZ_scrollbar_OnMouseUpOutside(ez_control_t *self, mouse_state_t *ms);

//
// Scrollbar - Mouse event.
//
int EZ_scrollbar_OnMouseEvent(ez_control_t *self, mouse_state_t *ms);

//
// Scrollbar - OnParentScroll event.
//
int EZ_scrollbar_OnParentScroll(ez_control_t *self, void *ext_event_info);

#endif // __EZ_SCROLLBAR_H__


================================================
FILE: src/ez_scrollpane.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_scrollpane.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_controls.h"
#include "ez_scrollpane.h"

#ifdef _MSC_VER
#pragma warning( disable : 4189 )
#endif

// =========================================================================================
// Scrollpane
// =========================================================================================

//
// Scrollpane - Adjusts the scrollpanes target to fit in between the scrollbars.
//
static void EZ_scrollpane_AdjustTargetSize(ez_scrollpane_t *scrollpane)
{
	ez_control_t *scrollpane_ctrl	= (ez_control_t *)scrollpane;

	qbool show_v	= (scrollpane->ext_flags & always_h_scrollbar) || (scrollpane->int_flags & show_v_scrollbar);
	qbool show_h	= (scrollpane->ext_flags & always_v_scrollbar) || (scrollpane->int_flags & show_h_scrollbar);
	int rh_size_v	= (scrollpane_ctrl->ext_flags & control_resize_v ? scrollpane_ctrl->resize_handle_thickness : 0); 
	int rh_size_h	= (scrollpane_ctrl->ext_flags & control_resize_h ? scrollpane_ctrl->resize_handle_thickness : 0); 

	// Make sure we don't listen to the targets OnResize event when resizing it ourselves
	// or we'll get a stack overflow due to an infinite loop :S
	scrollpane->int_flags |= resizing_target;
	
	EZ_control_SetSize(scrollpane->target, 
						(scrollpane_ctrl->width  - (show_v ? scrollpane->scrollbar_thickness : 0) - rh_size_h),
						(scrollpane_ctrl->height - (show_h ? scrollpane->scrollbar_thickness : 0) - rh_size_v));

	scrollpane->int_flags &= ~resizing_target;
}

//
// Scrollpane - Resize the scrollbars based on the targets state.
//
static void EZ_scrollpane_ResizeScrollbars(ez_scrollpane_t *scrollpane)
{
	ez_control_t *scrollpane_ctrl	= (ez_control_t *)scrollpane;
	ez_control_t *v_scroll_ctrl		= (ez_control_t *)scrollpane->v_scrollbar;
	ez_control_t *h_scroll_ctrl		= (ez_control_t *)scrollpane->h_scrollbar;

//	qbool size_changed	= false;
	qbool show_v		= (scrollpane->ext_flags & always_h_scrollbar) || (scrollpane->int_flags & show_v_scrollbar);
	qbool show_h		= (scrollpane->ext_flags & always_v_scrollbar) || (scrollpane->int_flags & show_h_scrollbar);
	int rh_size_v		= (scrollpane_ctrl->ext_flags & control_resize_v ? scrollpane_ctrl->resize_handle_thickness : 0); 
	int rh_size_h		= (scrollpane_ctrl->ext_flags & control_resize_h ? scrollpane_ctrl->resize_handle_thickness : 0); 

	EZ_control_SetVisible((ez_control_t *)scrollpane->v_scrollbar, show_v);
	EZ_control_SetVisible((ez_control_t *)scrollpane->h_scrollbar, show_h);

	// Resize the scrollbars depending on if both are shown or not.
	EZ_control_SetSize(v_scroll_ctrl,
						scrollpane->scrollbar_thickness, 
						scrollpane_ctrl->height - (show_h ? scrollpane->scrollbar_thickness : 0) - (2 * rh_size_v));

	EZ_control_SetSize(h_scroll_ctrl,
						scrollpane_ctrl->width - (show_v ? scrollpane->scrollbar_thickness : 0) - (2 * rh_size_h), 
						scrollpane->scrollbar_thickness);

	// Resize the target control so that it doesn't overlap with the scrollbars.
	if (scrollpane->target)
	{
		// Since this resize operation is going to raise a new OnResize event on the target control
		// which in turn calls this function again we only change the size of the target to fit
		// within the scrollbars when the scrollbars actually changed size. Otherwise we'd get an infinite recursion.
		EZ_scrollpane_AdjustTargetSize(scrollpane);
	}
}

//
// Scrollpane - Determine if the scrollbars should be visible based on the target controls state.
//
static void EZ_scrollpane_DetermineScrollbarVisibility(ez_scrollpane_t *scrollpane)
{
	SET_FLAG(scrollpane->int_flags, show_v_scrollbar, (scrollpane->target->height <= scrollpane->target->virtual_height_min));
	SET_FLAG(scrollpane->int_flags, show_h_scrollbar, (scrollpane->target->width <= scrollpane->target->virtual_width_min));
}

// TODO : Add an event handler for handling when the target control changes it's min virtual size, we might need to show/hide the scrollbars if that happens.

//
// Scrollpane - Target changed it's virtual size.
//
static int EZ_scrollpane_OnTargetVirtualResize(ez_control_t *self, void *payload, void *ext_event_info)
{
	ez_scrollpane_t *scrollpane = NULL;

	if (!self->parent || (self->parent->CLASS_ID != EZ_SCROLLPANE_ID))
	{
		Sys_Error("EZ_scrollpane_OnTargetVirtualResize(): Target parent is not a scrollpane!.\n");
	}

	scrollpane = (ez_scrollpane_t *)self->parent;

	// Check if we should show/hide the scrollbars.
	EZ_scrollpane_DetermineScrollbarVisibility(scrollpane);

	return 0;
}

//
// Scrollpane - Creates a new Scrollpane and initializes it.
//
ez_scrollpane_t *EZ_scrollpane_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	ez_scrollpane_t *scrollpane = NULL;

	// We have to have a tree to add the control to.
	if (!tree)
	{
		return NULL;
	}

	scrollpane = (ez_scrollpane_t *)Q_malloc(sizeof(ez_scrollpane_t));
	memset(scrollpane, 0, sizeof(ez_scrollpane_t));

	EZ_scrollpane_Init(scrollpane, tree, parent, name, description, x, y, width, height, flags);
	
	return scrollpane;
}

//
// Scrollpane - Initializes a Scrollpane.
//
void EZ_scrollpane_Init(ez_scrollpane_t *scrollpane, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	int rh_size_h = 0;
	int rh_size_v = 0;
	ez_control_t *scrollpane_ctrl = (ez_control_t *)scrollpane;

	// Initialize the inherited class first.
	EZ_control_Init(&scrollpane->super, tree, parent, name, description, x, y, width, height, flags);

	// Initilize the button specific stuff.
	((ez_control_t *)scrollpane)->CLASS_ID	= EZ_SCROLLPANE_ID;
	((ez_control_t *)scrollpane)->ext_flags	|= (flags | control_focusable | control_contained | control_resizeable);

	// Override control events.
	CONTROL_REGISTER_EVENT(scrollpane, EZ_scrollpane_OnResize, OnResize, ez_control_t);

	// Scrollpane specific events.
	CONTROL_REGISTER_EVENT(scrollpane, EZ_scrollpane_OnTargetChanged, OnTargetChanged, ez_scrollpane_t);
	CONTROL_REGISTER_EVENT(scrollpane, EZ_scrollpane_OnScrollbarThicknessChanged, OnScrollbarThicknessChanged, ez_scrollpane_t);

	scrollpane->scrollbar_thickness = 10;

	rh_size_h = (scrollpane_ctrl->ext_flags & control_resize_h) ? scrollpane_ctrl->resize_handle_thickness : 0;
	rh_size_v = (scrollpane_ctrl->ext_flags & control_resize_v) ? scrollpane_ctrl->resize_handle_thickness : 0;

	EZ_control_SetMinVirtualSize(scrollpane_ctrl, 1, 1);

	scrollpane->int_flags |= (show_h_scrollbar | show_v_scrollbar);

	// Create vertical scrollbar.
	{
		scrollpane->v_scrollbar = EZ_scrollbar_Create(tree, scrollpane_ctrl, "Vertical scrollbar", "", 0, 0, 10, 10, control_anchor_viewport);
		EZ_control_SetVisible((ez_control_t *)scrollpane->v_scrollbar, true);
		EZ_control_SetPosition((ez_control_t *)scrollpane->v_scrollbar, -rh_size_h, rh_size_v);
		EZ_control_SetAnchor((ez_control_t *)scrollpane->v_scrollbar, (anchor_top | anchor_bottom | anchor_right));

		EZ_scrollbar_SetTargetIsParent(scrollpane->v_scrollbar, false);
 
		EZ_control_AddChild(scrollpane_ctrl, (ez_control_t *)scrollpane->v_scrollbar);
	}

	// Create horizontal scrollbar.
	{
		scrollpane->h_scrollbar = EZ_scrollbar_Create(tree, (ez_control_t *)scrollpane, "Horizontal scrollbar", "", 0, 0, 10, 10, control_anchor_viewport);
	
		EZ_control_SetVisible((ez_control_t *)scrollpane->h_scrollbar, true);
		EZ_control_SetPosition((ez_control_t *)scrollpane->h_scrollbar, rh_size_h, -rh_size_v);
		EZ_control_SetAnchor((ez_control_t *)scrollpane->h_scrollbar, (anchor_left | anchor_bottom | anchor_right));

		EZ_scrollbar_SetTargetIsParent(scrollpane->h_scrollbar, false);
		EZ_scrollbar_SetIsVertical(scrollpane->h_scrollbar, false);

		EZ_control_AddChild(scrollpane_ctrl, (ez_control_t *)scrollpane->h_scrollbar);
	}

	EZ_scrollpane_ResizeScrollbars(scrollpane);
}

//
// Scrollpane - Destroys the scrollpane.
//
int EZ_scrollpane_Destroy(ez_control_t *self, qbool destroy_children)
{
	ez_scrollpane_t *scrollpane = (ez_scrollpane_t *)self;
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDestroy, destroy_children);

	EZ_eventhandler_Remove(scrollpane->event_handlers.OnScrollbarThicknessChanged, NULL, true);
	EZ_eventhandler_Remove(scrollpane->event_handlers.OnTargetChanged, NULL, true);

	EZ_control_Destroy(self, destroy_children);

	return 0;
}

//
// Scrollpane - Always show the vertical scrollbar.
//
void EZ_scrollpane_SetAlwaysShowVerticalScrollbar(ez_scrollpane_t *scrollpane, qbool always_show)
{
	SET_FLAG(scrollpane->ext_flags, always_v_scrollbar, always_show);
}

//
// Scrollpane - Always show the horizontal scrollbar.
//
void EZ_scrollpane_SetAlwaysShowHorizontalScrollbar(ez_scrollpane_t *scrollpane, qbool always_show)
{
	SET_FLAG(scrollpane->ext_flags, always_h_scrollbar, always_show);
}

//
// Scrollpane - Set the target control of the scrollpane (the one to be scrolled).
//
void EZ_scrollpane_SetTarget(ez_scrollpane_t *scrollpane, ez_control_t *target)
{
	scrollpane->prev_target = scrollpane->target;
	scrollpane->target = target;
	CONTROL_RAISE_EVENT(NULL, scrollpane, ez_scrollpane_t, OnTargetChanged, NULL);
}

//
// Scrollpane - Set the thickness of the scrollbar controls.
//
void EZ_scrollpane_SetScrollbarThickness(ez_scrollpane_t *scrollpane, int scrollbar_thickness)
{
	scrollpane->scrollbar_thickness = scrollbar_thickness;
	CONTROL_RAISE_EVENT(NULL, scrollpane, ez_scrollpane_t, OnScrollbarThicknessChanged, NULL);
}

//
// Scrollpane - OnResize event.
//
int EZ_scrollpane_OnResize(ez_control_t *self, void *ext_event_info)
{
	ez_scrollpane_t *scrollpane = (ez_scrollpane_t *)self;

	EZ_control_OnResize(self, NULL);

	// Make sure we don't listen to resizing events of the target that we raised
	// ourselves, it causes an infinite loop.
	if (!(scrollpane->int_flags & resizing_target))
	{
		// Resize the scrollbars and target based on the state of the target.
		EZ_scrollpane_ResizeScrollbars(scrollpane);
	}
	
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnResize, NULL);
	return 0;
}

//
// Scrollpane - The target control changed.
//
int EZ_scrollpane_OnTargetChanged(ez_control_t *self, void *ext_event_info)
{
	ez_scrollpane_t *scrollpane = (ez_scrollpane_t *)self;

	// Clean up the old target.
	if (scrollpane->prev_target)
	{
		EZ_eventhandler_Remove(scrollpane->prev_target->event_handlers.OnVirtualResize, EZ_scrollpane_OnTargetVirtualResize, false);
		EZ_control_RemoveChild(self, scrollpane->target);
		EZ_control_SetMovesParent(scrollpane->prev_target, false);
	}

	// Set the new target for the scrollbars so they know what to scroll.
	EZ_scrollbar_SetTarget(scrollpane->v_scrollbar, scrollpane->target);
	EZ_scrollbar_SetTarget(scrollpane->h_scrollbar, scrollpane->target);

	if (scrollpane->target)
	{
		// Subscribe to the targets resize and scroll events.
		EZ_control_AddOnVirtualResize(scrollpane->target, EZ_scrollpane_OnTargetVirtualResize, scrollpane);
		EZ_control_AddChild(self, scrollpane->target);

		EZ_control_SetScrollable(scrollpane->target, true);
		EZ_control_SetMovable(scrollpane->target, true);
		EZ_control_SetResizeableBoth(scrollpane->target, true);
		EZ_control_SetResizeable(scrollpane->target, true);

		// Reposition the target inside the scrollpane.
		EZ_control_SetPosition(scrollpane->target, 0, 0);
		EZ_control_SetSize(scrollpane->target, (self->width - scrollpane->scrollbar_thickness), (self->height - scrollpane->scrollbar_thickness));
		EZ_control_SetAnchor(scrollpane->target, (anchor_left | anchor_right | anchor_top | anchor_bottom));

		// Make sure the target is drawn infront of the scrollpane.
		EZ_control_SetDrawOrder(scrollpane->target, ((ez_control_t *)scrollpane)->draw_order + 1, true);

		// When moving the target move the scrollpane with it
		// and don't allow moving the target inside of the scrollpane.
		EZ_control_SetMovesParent(scrollpane->target, true);

		// Resize the scrollbars / target to fit properly.
		EZ_scrollpane_DetermineScrollbarVisibility(scrollpane);
		EZ_scrollpane_ResizeScrollbars(scrollpane);
		EZ_scrollpane_AdjustTargetSize(scrollpane);

		CONTROL_RAISE_EVENT(NULL, (ez_control_t *)scrollpane->target, ez_control_t, OnResize, NULL);
		CONTROL_RAISE_EVENT(NULL, (ez_control_t *)scrollpane->target, ez_control_t, OnMove, NULL);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, scrollpane, ez_scrollpane_t, OnTargetChanged, NULL);
	return 0;
}

//
// Scrollpane - The scrollbar thickness changed.
//
int EZ_scrollpane_OnScrollbarThicknessChanged(ez_control_t *self, void *ext_event_info)
{
	ez_scrollpane_t *scrollpane = (ez_scrollpane_t *)self;

	// Resize the scrollbars and target with the new scrollbar thickness.
	EZ_scrollpane_ResizeScrollbars(scrollpane);

	CONTROL_EVENT_HANDLER_CALL(NULL, scrollpane, ez_scrollpane_t, OnScrollbarThicknessChanged, NULL);
	return 0;
}




================================================
FILE: src/ez_scrollpane.h
================================================

#ifndef __EZ_SCROLLPANE_H__
#define __EZ_SCROLLPANE_H__
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_scrollpane.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

#include "ez_controls.h"
#include "ez_scrollbar.h"

// =========================================================================================
// Scrollpane
// =========================================================================================

typedef enum ez_scrollpane_flags_e
{
	always_v_scrollbar	= (1 << 0),
	always_h_scrollbar	= (1 << 1)
} ez_scrollpane_flags_t;		

typedef enum ez_scrollpane_iflags_e
{
	show_v_scrollbar		= (1 << 0),	// Should the vertical scrollbar be shown?
	show_h_scrollbar		= (1 << 1),	// Should the horizontal scrollbar be shown?
	resizing_target			= (1 << 2)	// Are we resizing the target (if we are, don't care about OnResize events, it'll cause an infinite loop).
} ez_scrollpane_iflags_t;

typedef struct ez_scrollpane_eventcount_s
{
	int OnTargetChanged;
	int OnScrollbarThicknessChanged;
} ez_scrollpane_eventcount_t;

typedef struct ez_scrollpane_events_s
{
	ez_event_fp	OnTargetChanged;
	ez_event_fp	OnTargetResize;
	ez_event_fp	OnTargetScroll;
	ez_event_fp	OnScrollbarThicknessChanged;
} ez_scrollpane_events_t;

typedef struct ez_scrollpane_eventhandlers_s
{
	ez_eventhandler_t		*OnTargetChanged;
	ez_eventhandler_t		*OnTargetResize;
	ez_eventhandler_t		*OnTargetScroll;
	ez_eventhandler_t		*OnScrollbarThicknessChanged;
} ez_scrollpane_eventhandlers_t;

typedef struct ez_scrollpane_s
{
	ez_control_t				super;				// The super class.

	ez_scrollpane_events_t		events;
	ez_scrollpane_eventhandlers_t event_handlers;
	ez_scrollpane_eventcount_t	inherit_levels;
	ez_scrollpane_eventcount_t	override_counts;

	ez_control_t				*target;			// The target of the scrollbar if the parent isn't targeted (ext_flag & target_parent).
	ez_control_t				*prev_target;		// The previous target control. We keep this to clean up when we change target.

	ez_scrollbar_t				*v_scrollbar;		// The vertical scrollbar.
	ez_scrollbar_t				*h_scrollbar;		// The horizontal scrollbar.

	int							scrollbar_thickness; // The thickness of the scrollbars.

	ez_scrollpane_flags_t		ext_flags;			// External flags for the scrollbar.
	ez_scrollpane_iflags_t		int_flags;			// The internal flags for the scrollbar.
} ez_scrollpane_t;

//
// Scrollpane - Creates a new Scrollpane and initializes it.
//
ez_scrollpane_t *EZ_scrollpane_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Scrollpane - Initializes a Scrollpane.
//
void EZ_scrollpane_Init(ez_scrollpane_t *scrollpane, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Scrollpane - Destroys the scrollpane.
//
int EZ_scrollpane_Destroy(ez_control_t *self, qbool destroy_children);

//
// Scrollpane - Set the target control of the scrollpane (the one to be scrolled).
//
void EZ_scrollpane_SetTarget(ez_scrollpane_t *scrollpane, ez_control_t *target);

//
// Scrollpane - Set the thickness of the scrollbar controls.
//
void EZ_scrollpane_SetScrollbarThickness(ez_scrollpane_t *scrollpane, int scrollbar_thickness);

//
// Scrollpane - The target control changed.
//
int EZ_scrollpane_OnTargetChanged(ez_control_t *self, void *ext_event_info);

//
// Scrollpane - The scrollbar thickness changed.
//
int EZ_scrollpane_OnScrollbarThicknessChanged(ez_control_t *self, void *ext_event_info);

//
// Scrollpane - OnResize event.
//
int EZ_scrollpane_OnResize(ez_control_t *self, void *ext_event_info);

#endif // __EZ_SCROLLPANE_H__


================================================
FILE: src/ez_slider.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_scrollpane.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_slider.h"

// =========================================================================================
// Slider
// =========================================================================================

// TODO : Slider - Show somehow that it's focused?

//
// Slider - Creates a new button and initializes it.
//
ez_slider_t *EZ_slider_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	ez_slider_t *slider = NULL;

	// We have to have a tree to add the control to.
	if (!tree)
	{
		return NULL;
	}

	slider = (ez_slider_t *)Q_malloc(sizeof(ez_slider_t));
	memset(slider, 0, sizeof(ez_slider_t));

	EZ_slider_Init(slider, tree, parent, name, description, x, y, width, height, flags);
	
	return slider;
}

//
// Slider - Initializes a button.
//
void EZ_slider_Init(ez_slider_t *slider, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	height = max(height, 8);

	// Initialize the inherited class first.
	EZ_control_Init(&slider->super, tree, parent, name, description, x, y, width, height, flags);

	// Initilize the button specific stuff.
	((ez_control_t *)slider)->CLASS_ID					= EZ_SLIDER_ID;
	((ez_control_t *)slider)->ext_flags					|= (flags | control_focusable | control_contained | control_resizeable);

	// Overrided control events.
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnDraw, OnDraw, ez_control_t);
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnMouseDown, OnMouseDown, ez_control_t);
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnMouseUpOutside, OnMouseUpOutside, ez_control_t);
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnMouseEvent, OnMouseEvent, ez_control_t);
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnResize, OnResize, ez_control_t);
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnKeyDown, OnKeyDown, ez_control_t);

	// Slider specific events.
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnSliderPositionChanged, OnSliderPositionChanged, ez_slider_t);
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnMaxValueChanged, OnMaxValueChanged, ez_slider_t);
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnMinValueChanged, OnMinValueChanged, ez_slider_t);
	CONTROL_REGISTER_EVENT(slider, EZ_slider_OnScaleChanged, OnScaleChanged, ez_slider_t);

	// Set default values.
	EZ_slider_SetMax(slider, 100);
	EZ_slider_SetScale(slider, 1.0);
	EZ_slider_SetPosition(slider, 0);
}

//
// Slider - Calculates the actual slider position.
//
static inline void EZ_slider_CalculateRealSliderPos(ez_slider_t *slider)
{
	int pos = slider->slider_pos - slider->min_value;

	// Calculate the real position of the slider by multiplying by the gap size between each value.
	// (Don't start drawing at the exact start cause that would overwrite the edge marker)
	slider->real_slider_pos = Q_rint((slider->scaled_char_size / 2.0) + (pos * slider->gap_size));
}

//
// Slider - Calculates the gap size between values.
//
static inline void EZ_slider_CalculateGapSize(ez_slider_t *slider)
{
	slider->range = abs(slider->max_value - slider->min_value);

	// Calculate the gap between each value in pixels (floating point so that we don't get rounding errors).
	// Don't include the first and last characters in the calculation, the slider is not allowed to move over those.
	slider->gap_size = ((float)(((ez_control_t *)slider)->width - (2 * slider->scaled_char_size)) / (float)slider->range);
}

//
// Slider - Event handler for OnSliderPositionChanged.
//
void EZ_slider_AddOnSliderPositionChanged(ez_slider_t *slider, ez_eventhandler_fp OnSliderPositionChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(slider, EZ_CONTROL_HANDLER, OnSliderPositionChanged, ez_slider_t, OnSliderPositionChanged, payload);
	CONTROL_RAISE_EVENT(NULL, slider, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Slider - Event handler for OnMaxValueChanged.
//
void EZ_slider_AddOnMaxValueChanged(ez_slider_t *slider, ez_eventhandler_fp OnMaxValueChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(slider, EZ_CONTROL_HANDLER, OnMaxValueChanged, ez_slider_t, OnMaxValueChanged, payload);
	CONTROL_RAISE_EVENT(NULL, slider, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Slider - Event handler for OnMinValueChanged.
//
void EZ_slider_AddOnMinValueChanged(ez_slider_t *slider, ez_eventhandler_fp OnMinValueChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(slider, EZ_CONTROL_HANDLER, OnMinValueChanged, ez_slider_t, OnMinValueChanged, payload);
	CONTROL_RAISE_EVENT(NULL, slider, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Slider - Event handler for OnSliderPositionChanged.
//
void EZ_slider_AddOnScaleChanged(ez_slider_t *slider, ez_eventhandler_fp OnScaleChanged, void *payload)
{
	CONTROL_ADD_EVENTHANDLER(slider, EZ_CONTROL_HANDLER, OnScaleChanged, ez_slider_t, OnScaleChanged, payload);
	CONTROL_RAISE_EVENT(NULL, slider, ez_control_t, OnEventHandlerChanged, NULL);
}

//
// Slider - Gets the current position of the mouse in slider scale. (This does not care if the mouse is within the control)
//
int EZ_slider_GetPositionFromMouse(ez_slider_t *slider, float mouse_x, float mouse_y)
{
	ez_control_t *self = (ez_control_t *)slider;
	int x = Q_rint(self->absolute_virtual_x + (slider->scaled_char_size / 2.0));
	return Q_rint((mouse_x - x) / slider->gap_size);
}

//
// Slider - Get the current slider position.
//
int EZ_slider_GetPosition(ez_slider_t *slider)
{
	return slider->slider_pos;
}

//
// Slider - Set the slider position.
//
void EZ_slider_SetPosition(ez_slider_t *slider, int slider_pos)
{
	clamp(slider_pos, slider->min_value, slider->max_value);

	slider->slider_pos = slider_pos;

	CONTROL_RAISE_EVENT(NULL, slider, ez_slider_t, OnSliderPositionChanged, NULL);
}

//
// Slider - Set the max slider value.
//
void EZ_slider_SetMax(ez_slider_t *slider, int max_value)
{
	slider->max_value = max_value;

	CONTROL_RAISE_EVENT(NULL, slider, ez_slider_t, OnMaxValueChanged, NULL);
}

//
// Slider - Set the max slider value.
//
void EZ_slider_SetMin(ez_slider_t *slider, int min_value)
{
	slider->min_value = min_value;

	CONTROL_RAISE_EVENT(NULL, slider, ez_slider_t, OnMinValueChanged, NULL);
}

//
// Slider - Set the scale of the slider characters.
//
void EZ_slider_SetScale(ez_slider_t *slider, float scale)
{
	slider->scale = max(0.1, scale);

	CONTROL_RAISE_EVENT(NULL, slider, ez_slider_t, OnScaleChanged, NULL);
}

//
// Slider - Scale changed.
//
int EZ_slider_OnScaleChanged(ez_control_t *self, void *ext_event_info)
{
	ez_slider_t *slider = (ez_slider_t *)self;

	// Calculate the new character size.
	slider->scaled_char_size = slider->scale * 8;

	// Refit the control to fit the slider.
	EZ_control_SetSize(self, slider->super.width + slider->scaled_char_size, slider->scaled_char_size);

	CONTROL_EVENT_HANDLER_CALL(NULL, slider, ez_slider_t, OnScaleChanged, NULL);

	return 0;
}

//
// Slider - Draw function for the slider.
//
int EZ_slider_OnDraw(ez_control_t *self, void *ext_event_info)
{
	int x, y, i;
	ez_slider_t *slider = (ez_slider_t *)self;

	EZ_control_GetDrawingPosition(self, &x, &y);

	// Draw the background.
	{
		// Left edge.
		Draw_SCharacter(x, y, 128, slider->scale);

		for (i = 1; i < Q_rint((float)(self->width - slider->scaled_char_size) / slider->scaled_char_size); i++)
		{
			Draw_SCharacter(x + (i * slider->scaled_char_size), y, 129, slider->scale);
		}

		// Right edge.
		Draw_SCharacter(x + (i * slider->scaled_char_size), y, 130, slider->scale);
	}

	// Slider.
	Draw_SCharacter(x + slider->real_slider_pos, y, 131, slider->scale);

	return 0;
}

//
// Slider - The max value changed.
//
int EZ_slider_OnMaxValueChanged(ez_control_t *self, void *ext_event_info)
{
	ez_slider_t *slider = (ez_slider_t *)self;

	// Only allow positive values greater than the min value.
	slider->max_value = max(0, max(slider->max_value, slider->min_value));

	// Calculate the gap between each slider value.
	EZ_slider_CalculateGapSize(slider);

	CONTROL_EVENT_HANDLER_CALL(NULL, slider, ez_slider_t, OnMaxValueChanged, NULL);

	return 0;
}

//
// Slider - The min value changed.
//
int EZ_slider_OnMinValueChanged(ez_control_t *self, void *ext_event_info)
{
	ez_slider_t *slider = (ez_slider_t *)self;

	// Only allow positive values less than the max value.
	slider->min_value = max(0, min(slider->max_value, slider->min_value));

	// Calculate the gap between each slider value.
	EZ_slider_CalculateGapSize(slider);

	CONTROL_EVENT_HANDLER_CALL(NULL, slider, ez_slider_t, OnMinValueChanged, NULL);

	return 0;
}

//
// Slider - The slider position changed.
//
int EZ_slider_OnSliderPositionChanged(ez_control_t *self, void *ext_event_info)
{
	ez_slider_t *slider = (ez_slider_t *)self;

	// Recalculate the drawing position.
	EZ_slider_CalculateRealSliderPos(slider);

	CONTROL_EVENT_HANDLER_CALL(NULL, slider, ez_slider_t, OnSliderPositionChanged, NULL);

	return 0;
}

//
// Slider - Jumps to the point that was clicked on the slider 
//          (Normal behavior is to make a "big step" when clicking the slider outside the handle).
//
void EZ_slider_SetJumpToClick(ez_slider_t *slider, qbool jump_to_click)
{
	SET_FLAG(slider->ext_flags, slider_jump_to_click, jump_to_click);
	CONTROL_RAISE_EVENT(NULL, (ez_control_t *)slider, ez_control_t, OnFlagsChanged, NULL);
}

//
// Slider - Mouse down event.
//
int EZ_slider_OnMouseDown(ez_control_t *self, mouse_state_t *ms)
{
	ez_slider_t *slider		= (ez_slider_t *)self;
	int big_step			= max(1, slider->range / 10);
	int slider_left_edge; 
	int slider_right_edge;
	int x, y;
	
	EZ_control_GetDrawingPosition(self, &x, &y);

	slider_left_edge	= (x + slider->real_slider_pos);
	slider_right_edge	= (x + slider->real_slider_pos + slider->scaled_char_size);

	// Super class.
	EZ_control_OnMouseDown(self, ms);

	if ((ms->x >= slider_left_edge) && (ms->x <= slider_right_edge))
	{
		slider->int_flags |= slider_dragging;
	}
	else if (slider->ext_flags & slider_jump_to_click)
	{
		// Jump to the exact position on the slider that was clicked.
		int newpos = EZ_slider_GetPositionFromMouse(slider, ms->x, ms->y);
		EZ_slider_SetPosition(slider, newpos);
	}
	else if (ms->x < slider_left_edge)
	{
		// When clicking on the slider (but not the slider handle)
		// make a "big step" instead of dragging it.
		EZ_slider_SetPosition(slider, slider->slider_pos - big_step);		
	}
	else if (ms->x > slider_right_edge)
	{
		EZ_slider_SetPosition(slider, slider->slider_pos + big_step);
	}

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnMouseDown, ms);

	return true;
}

//
// Slider - Mouse up event.
//
int EZ_slider_OnMouseUpOutside(ez_control_t *self, mouse_state_t *ms)
{
	ez_slider_t *slider = (ez_slider_t *)self;

	// Super class.
	EZ_control_OnMouseUpOutside(self, ms);

	// Not dragging anymore.
	slider->int_flags &= ~slider_dragging;

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnMouseUp, ms);

	return true;
}

//
// Slider - Handles a mouse event.
//
int EZ_slider_OnMouseEvent(ez_control_t *self, mouse_state_t *ms)
{
	// Make sure we handle all mouse events when we're over the control
	// otherwise they will fall through to controls below.
	int mouse_handled	= POINT_IN_CONTROL_RECT(self, ms->x, ms->y); 
	ez_slider_t *slider = (ez_slider_t *)self;

	// Call the super class first.
	EZ_control_OnMouseEvent(self, ms);
	
	if (slider->int_flags & slider_dragging)
	{
		int new_slider_pos = slider->min_value + Q_rint((ms->x - self->absolute_x) / slider->gap_size);
		EZ_slider_SetPosition(slider, new_slider_pos);
		mouse_handled = true;
	}
	
	// Event handler call.
	{
		int mouse_handled_tmp = false;
		CONTROL_EVENT_HANDLER_CALL(&mouse_handled_tmp, self, ez_control_t, OnMouseEvent, ms);
		mouse_handled = (mouse_handled || mouse_handled_tmp);
	}

	return mouse_handled;
}

//
// Slider - The slider was resized.
//
int EZ_slider_OnResize(ez_control_t *self, void *ext_event_info)
{
	ez_slider_t *slider = (ez_slider_t *)self;

	// Call super class.
	EZ_control_OnResize(self, NULL);

	EZ_slider_CalculateGapSize(slider);
	EZ_slider_CalculateRealSliderPos(slider);

	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnResize, NULL);

	return 0;
}

//
// Slider - Key event.
//
int EZ_slider_OnKeyDown(ez_control_t *self, int key, int unichar)
{
	qbool key_handled	= false;
	ez_slider_t *slider = (ez_slider_t *)self;
	int big_step		= max(1, slider->max_value / 10);
	int step			= keydown[K_CTRL] ? big_step : 1;

	switch(key)
	{
		case K_RIGHTARROW :
		{
			EZ_slider_SetPosition(slider, slider->slider_pos + step);
			key_handled = true;
			break;
		}
		case K_LEFTARROW :
		{
			EZ_slider_SetPosition(slider, slider->slider_pos - step);
			key_handled = true;
			break;
		}
		default :
		{
			break;
		}
	}

	return key_handled;
}




================================================
FILE: src/ez_slider.h
================================================

#ifndef __EZ_SLIDER_H__
#define __EZ_SLIDER_H__
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_slider.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

#include "ez_controls.h"

// =========================================================================================
// Slider
// =========================================================================================

typedef enum ez_slider_iflags_e
{
	slider_dragging	= (1 << 0)
} ez_slider_iflags_t;

typedef enum ez_slider_flags_e
{
	slider_jump_to_click = (1 << 0)
} ez_slider_flags_t;

typedef struct ez_slider_eventcount_s
{
	int	OnSliderPositionChanged;
	int	OnMaxValueChanged;
	int	OnMinValueChanged;
	int	OnScaleChanged;
} ez_slider_eventcount_t;

typedef struct ez_slider_events_s
{
	ez_event_fp	OnSliderPositionChanged;
	ez_event_fp	OnMaxValueChanged;
	ez_event_fp	OnMinValueChanged;
	ez_event_fp	OnScaleChanged;
} ez_slider_events_t;

typedef struct ez_slider_eventhandlers_s
{
	ez_eventhandler_t		*OnSliderPositionChanged;
	ez_eventhandler_t		*OnMaxValueChanged;
	ez_eventhandler_t		*OnMinValueChanged;
	ez_eventhandler_t		*OnScaleChanged;
} ez_slider_eventhandlers_t;

typedef struct ez_slider_s
{
	ez_control_t			super;				// The super class.

	ez_slider_events_t		events;				// Slider specific events.
	ez_slider_eventhandlers_t event_handlers;	// Slider specific event handlers.
	ez_slider_eventcount_t	inherit_levels;
	ez_slider_eventcount_t	override_counts;

	ez_slider_flags_t		ext_flags;			// External slider flags.
	ez_slider_iflags_t		int_flags;			// Slider specific internal flags.
	int						slider_pos;			// The position of the slider.
	int						real_slider_pos;	// The actual slider position in pixels.
	int						max_value;			// The max value allowed for the slider.
	int						min_value;			// The min value allowed for the slider.
	int						range;				// The number of values between the min and max values.
	float					gap_size;			// The pixel gap between each value.
	float					scale;				// The scale of the characters used for drawing the slider.
	int						scaled_char_size;	// The scaled character size in pixels after applying scale to the slider chars.

	int						override_count;		// These are needed so that subclasses can override slider specific events.
	int						inheritance_level;
} ez_slider_t;

//
// Slider - Creates a new slider and initializes it.
//
ez_slider_t *EZ_slider_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Slider - Initializes a slider.
//
void EZ_slider_Init(ez_slider_t *slider, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Slider - Event handler for OnSliderPositionChanged.
//
void EZ_slider_AddOnSliderPositionChanged(ez_slider_t *slider, ez_eventhandler_fp OnSliderPositionChanged, void *payload);

//
// Slider - Event handler for OnSliderPositionChanged.
//
void EZ_slider_AddOnScaleChanged(ez_slider_t *slider, ez_eventhandler_fp OnScaleChanged, void *payload);

//
// Slider - Event handler for OnMaxValueChanged.
//
void EZ_slider_AddOnMaxValueChanged(ez_slider_t *slider, ez_eventhandler_fp OnMaxValueChanged, void *payload);

//
// Slider - Event handler for OnMinValueChanged.
//
void EZ_slider_AddOnMinValueChanged(ez_slider_t *slider, ez_eventhandler_fp OnMinValueChanged, void *payload);

//
// Slider - Gets the current position of the mouse in slider scale. (This does not care if the mouse is within the control)
//
int EZ_slider_GetPositionFromMouse(ez_slider_t *slider, float mouse_x, float mouse_y);

//
// Slider - Get the current slider position.
//
int EZ_slider_GetPosition(ez_slider_t *slider);

//
// Slider - Set the slider position.
//
void EZ_slider_SetPosition(ez_slider_t *slider, int slider_pos);

//
// Slider - Set the max slider value.
//
void EZ_slider_SetMax(ez_slider_t *slider, int max_value);

//
// Slider - Set the max slider value.
//
void EZ_slider_SetMin(ez_slider_t *slider, int min_value);

//
// Slider - Set the scale of the slider characters.
//
void EZ_slider_SetScale(ez_slider_t *slider, float scale);

//
// Slider - Draw function for the slider.
//
int EZ_slider_OnDraw(ez_control_t *self, void *ext_event_info);

//
// Slider - The max value changed.
//
int EZ_slider_OnMaxValueChanged(ez_control_t *self, void *ext_event_info);

//
// Slider - The min value changed.
//
int EZ_slider_OnMinValueChanged(ez_control_t *self, void *ext_event_info);

//
// Slider - Scale changed.
//
int EZ_slider_OnScaleChanged(ez_control_t *self, void *ext_event_info);

//
// Slider - The slider position changed.
//
int EZ_slider_OnSliderPositionChanged(ez_control_t *self, void *ext_event_info);

//
// Slider - Mouse down event.
//
int EZ_slider_OnMouseDown(ez_control_t *self, mouse_state_t *ms);

//
// Slider - Mouse up event.
//
int EZ_slider_OnMouseUpOutside(ez_control_t *self, mouse_state_t *ms);

//
// Slider - Handles a mouse event.
//
int EZ_slider_OnMouseEvent(ez_control_t *self, mouse_state_t *ms);

//
// Slider - The slider was resized.
//
int EZ_slider_OnResize(ez_control_t *self, void *ext_event_info);

//
// Slider - Key event.
//
int EZ_slider_OnKeyDown(ez_control_t *self, int key, int unichar);

//
// Slider - Jumps to the point that was clicked on the slider 
//          (Normal behavior is to make a "big step" when clicking the slider outside the handle).
//
void EZ_slider_SetJumpToClick(ez_slider_t *slider, qbool jump_to_click);

#endif // __EZ_SLIDER_H__


================================================
FILE: src/ez_window.c
================================================

/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_window.c,v 1.78 2007/10/27 14:51:15 cokeman1982 Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "utils.h"
#include "common_draw.h"
#include "ez_window.h"

#ifdef _MSC_VER
#pragma warning( disable : 4189 )
#endif

// =========================================================================================
// Window
// =========================================================================================

//
// Window - Creates a new window and initializes it.
//
ez_window_t *EZ_window_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	ez_window_t *window = NULL;

	// We have to have a tree to add the control to.
	if (!tree)
	{
		return NULL;
	}

	window = (ez_window_t *)Q_malloc(sizeof(ez_window_t));
	memset(window, 0, sizeof(ez_window_t));

	EZ_window_Init(window, tree, parent, name, description, x, y, width, height, flags);
	
	return window;
}

//
// Window - Initializes a window.
//
void EZ_window_Init(ez_window_t *window, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags)
{
	ez_control_t *window_ctrl		= (ez_control_t *)window;
	ez_control_t *titlebar_ctrl		= NULL;
	ez_control_t *scrollpane_ctrl	= NULL;
	int rh_size						= 0;

	// Initialize the inherited class first.
	EZ_control_Init(&window->super, tree, parent, name, description, x, y, width, height, flags);

	((ez_control_t *)window)->CLASS_ID		= EZ_WINDOW_ID;
	((ez_control_t *)window)->ext_flags		|= (flags | control_focusable | control_contained | control_resizeable);

	rh_size = window_ctrl->resize_handle_thickness;

	// Set the background.
	EZ_control_SetBackgroundImage(window_ctrl, EZ_WINDOW_DEFAULT_BACKGROUND_IMAGE);
	EZ_control_SetBackgroundImageOpacity(window_ctrl, 1.0);
	EZ_control_SetBackgroundImageEdgePercentage(window_ctrl, 20);

	// Title bar.
	{
		// Set the tilebar to move it's parent.
		window->titlebar = EZ_control_Create(tree, window_ctrl, "Window titlebar", NULL, rh_size, rh_size, window_ctrl->width, 15, 
			(control_focusable | control_move_parent | control_movable | control_resizeable | control_enabled | control_anchor_viewport));

		titlebar_ctrl = (ez_control_t *)window->titlebar;
		EZ_control_SetBackgroundImage(titlebar_ctrl, "gfx/ui/ez_titlebar");

		// Set the size to fit within the resize handles.
		EZ_control_SetSize(titlebar_ctrl, (window_ctrl->width - (2 * rh_size)), 15);
		EZ_control_SetAnchor(titlebar_ctrl, (anchor_left | anchor_top | anchor_right));

		EZ_control_SetDrawOrder(titlebar_ctrl, window_ctrl->draw_order + 1, true);

		// Close button.
		{
			#define CLOSE_BUTTON_EDGE_GAP	2
			int cb_sidelength = 0;
			ez_control_t *close_ctrl = NULL;
			window->close_button = EZ_button_Create(tree, titlebar_ctrl, "Close button", NULL, 
													0, 0, 10, 10, control_enabled);

			close_ctrl = (ez_control_t *)window->close_button;

			cb_sidelength = (titlebar_ctrl->height - (2 * CLOSE_BUTTON_EDGE_GAP));

			// Position the close button CLOSE_BUTTON_EDGE_GAP number of pixels from the edge
			// of the titlebar, and size it accordingly.
			EZ_control_SetPosition(close_ctrl, -CLOSE_BUTTON_EDGE_GAP, CLOSE_BUTTON_EDGE_GAP);
			EZ_control_SetSize(close_ctrl, cb_sidelength, cb_sidelength);
			EZ_control_SetAnchor(close_ctrl, (anchor_top | anchor_right));
		}
	}

	// Scrollpane.
	{
		window->scrollpane = EZ_scrollpane_Create(tree, window_ctrl, "Window scrollpane", NULL, rh_size, (rh_size + titlebar_ctrl->height), 10, 10, 0);
		scrollpane_ctrl = (ez_control_t *)window->scrollpane;

		// Size the scrollpane to fit inside the window control.
		EZ_control_SetSize(scrollpane_ctrl, 
			(window_ctrl->width - (2 * rh_size)), 
			(window_ctrl->height - (titlebar_ctrl->height + (2 * rh_size))));

		EZ_control_SetAnchor(scrollpane_ctrl, (anchor_left | anchor_right | anchor_bottom | anchor_top));

		// Window area.
		{
			window->window_area = EZ_control_Create(tree, scrollpane_ctrl, "Window area", NULL, 0, 0, 10, 10, (control_scrollable | control_enabled | control_resizeable));

			// Set the window area as the target of the scrollpane 
			// (this will make it a child of the scrollpane, so don't bother to add it as a child to the window itself).
			EZ_scrollpane_SetTarget(window->scrollpane, window->window_area);
			EZ_control_SetDrawOrder(window->window_area, scrollpane_ctrl->draw_order + 1, true);
		}
	}
}

//
// Window - Destroys a window.
//
int EZ_window_Destroy(ez_control_t *self, qbool destroy_children)
{
//	ez_window_t *window = (ez_window_t *)self;
	CONTROL_EVENT_HANDLER_CALL(NULL, self, ez_control_t, OnDestroy, destroy_children);

	EZ_control_Destroy(self, destroy_children);

	// TODO : Remove any event handlers.

	return 0;
}

//
// Window - Set window area virtual size (The part where you can put controls in the window).
//
void EZ_window_SetWindowAreaMinVirtualSize(ez_window_t *window, int min_virtual_width, int min_virtual_height)
{
	if (window->window_area)
	{
		EZ_control_SetMinVirtualSize(window->window_area, min_virtual_width, min_virtual_height);
	}
}

//
// Window - Adds a child control to the window.
//
void EZ_window_AddChild(ez_window_t *window, ez_control_t *child)
{
	if (!window->scrollpane->target)
	{
		Sys_Error("EZ_window_AddChild(): Window scrollpane has a NULL target.\n");
	}

	EZ_control_AddChild(window->window_area, child);
	EZ_control_SetDrawOrder(child, window->window_area->draw_order + 1, true);
}

// TODO: Add an event for when pressing the close button on the window control.



================================================
FILE: src/ez_window.h
================================================

#ifndef __EZ_WINDOW_H__
#define __EZ_WINDOW_H__
/*
Copyright (C) 2007 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: ez_window.h,v 1.55 2007-10-27 14:51:15 cokeman1982 Exp $
*/

#include "ez_controls.h"
#include "ez_scrollpane.h"

// =========================================================================================
// Window
// =========================================================================================

#define EZ_WINDOW_DEFAULT_BACKGROUND_IMAGE	"gfx/ui/ez_window"

typedef struct ez_window_s
{
	ez_control_t			super;				// The super class.

	ez_scrollpane_t			*scrollpane;		// The scrollpane for the window to enable scrolling.
	ez_control_t			*window_area;		// The window area where child controls are placed, also the target of the scrollpane.

	ez_control_t			*titlebar;			// The titlebar for the window.
	ez_button_t				*close_button;		// The close button in the upper right corner.
} ez_window_t;

//
// Window - Creates a new slider and initializes it.
//
ez_window_t *EZ_window_Create(ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Window - Initializes a slider.
//
void EZ_window_Init(ez_window_t *window, ez_tree_t *tree, ez_control_t *parent,
							  char *name, char *description,
							  int x, int y, int width, int height,
							  ez_control_flags_t flags);

//
// Window - Destroys a window.
//
int EZ_window_Destroy(ez_control_t *self, qbool destroy_children);

//
// Window - Adds a child control to the window.
//
void EZ_window_AddChild(ez_window_t *window, ez_control_t *child);

//
// Window - Set window area virtual size (The part where you can put controls in the window).
//
void EZ_window_SetWindowAreaMinVirtualSize(ez_window_t *window, int min_virtual_width, int min_virtual_height);

#endif // __EZ_WINDOW_H__



================================================
FILE: src/ezquake-icon.c
================================================
/* GIMP RGBA C-Source image dump (ezquake-icon.c) */

static const struct {
  unsigned int 	 width;
  unsigned int 	 height;
  unsigned int 	 bytes_per_pixel; /* 2:RGB16, 3:RGB, 4:RGBA */ 
  unsigned char	 pixel_data[48 * 48 * 4 + 1];
} ezquake_icon = {
  48, 48, 4,
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\3\0\0\0%\0\0\0T\0\0\0\203\0\0\0\237\0\0\0\252\0\0\0\252\0\0\0\240"
  "\0\0\0\210\0\0\0V\0\0\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\30\0\0\0p\0\0\0\304\30\30\24\367KL<\377{|`\377\227"
  "\230u\377\241\243{\377\242\244{\377\231\233t\377\201\202a\377IJ8\377\14\14"
  "\12\360\0\0\0\251\0\0\0C\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0'\0\0\0\14"
  "\0\0\0\260LM<\377\270\271\215\377\360\363\263\377\377\377\276\377\377\377"
  "\300\377\377\377\276\377\377\377\271\377\377\377\262\377\377\377\257\377"
  "\377\377\264\377\377\377\271\377\361\363\250\377\230\232j\377)(\35\375\0"
  "\0\0\253\0\0\0+\0\0\0\0\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\15\0\0\0\220\10\10\7\377\1\1\0\215\0\0\0\206mmR\377"
  "\377\377\301\377\377\377\250\377\372\374\227\377\307\311v\377\213\214R\377"
  "QR0\37722\36\377''\27\376,,\32\377CD)\377\203\204Q\377\316\320\203\377\365"
  "\367\237\377\213\214[\377\6\6\5\353\0\0\0Y\0\0\0\0\0\0\0\1\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0$\0\0\0\313__F\377\311\311\220\377\20\20"
  "\14\347\0\0\0e\27\27\15\361\324\325~\377\224\224S\377..\31\377\2\2\1\345"
  "\0\0\0\270\0\0\0\216\0\0\0u\0\0\0j\0\0\0l\0\0\0\177\0\0\0\252\0\0\0\335-"
  ".\33\377\253\254i\377\274\275t\377\36\36\22\374\0\0\0l\0\0\0\0\0\0\0\2\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0/\1\2\2\336\212\211d\377\377\377\265\377\377"
  "\377\252\377[[8\377\0\0\0\216\1\1\1\261\17\17\10\377\0\0\0\307\0\0\0~\0\0"
  "\0J\0\0\0/\0\0\0$\0\0\0\35\0\0\0\32\0\0\0\31\0\0\0\33\0\0\0\"\0\0\0""8\0"
  "\0\0r\0\0\0\317II*\377\246\245d\377&%\31\373\0\0\0f\0\0\0\2\0\0\0\2\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0&\0\0\1\342\236\235q\377\377\377\262\377\374\371\223\377\377\377"
  "\221\377\261\260b\377\0\0\0\325\0\0\0L\0\0\0Y\0\0\0""5\0\0\0#\0\0\0\26\0"
  "\0\0\15\0\0\0\7\0\0\0\4\0\0\0\2\0\0\0\2\0\0\0\3\0\0\0\7\0\0\0\15\0\0\0\24"
  "\0\0\0+\0\0\0\207\25\25\14\365zzJ\377\33\33\21\371\0\0\0T\0\0\0\2\0\0\0\1"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\11"
  "\0\0\0\306\213\212d\377\377\377\260\377\373\366\216\377\377\377\206\377\327"
  "\324j\377'&\23\377\0\0\0\243\0\0\0(\0\0\0\23\0\0\0\20\0\0\0\10\0\0\0\2\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\3\0"
  "\0\0\13\0\0\0\25\0\0\0`\22\22\11\354^]9\377\13\13\5\344\0\0\0.\0\0\0\2\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\202"
  "ZYA\377\377\377\256\377\374\366\217\377\377\375\204\377\326\322i\377\36\35"
  "\17\377\0\0\0\232\0\0\0""3\0\0\0\26\0\0\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\6\0\0\0\16\0\0\0]\26\26\16\366?=&\377\0\0\0\257\0\0\0\17\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0""3\26\25\20\367\346"
  "\343\235\377\377\371\226\377\377\366\202\377\347\341p\377&$\22\377\0\0\0"
  "\232\0\0\0""2\0\0\0\30\0\0\0\6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\4\0\0\0\11\0\0\0m!\40\24\377%$\26\377\0\0\0e\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\250\210\206^\377\377\377\242"
  "\377\372\357\201\377\377\366{\377VR(\377\0\0\0\262\0\0\0""7\0\0\0\27\0\0"
  "\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\20\0\0\0\243NL.\377\232\227Z\377\0\0\0\307\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0.\30\27\22\370\353\345\231\377\375\362\212\377"
  "\377\370}\377\251\241N\377\0\0\0\337\0\0\0K\0\0\0\34\0\0\0\6\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\36\0\0\0\302g"
  "cD\377\330\317\201\37742\35\377\0\0\0\243\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\205roM\377\377\375\234\377\373\354{\377\366\350p\377"
  "1.\26\377\0\0\0\201\0\0\0#\0\0\0\12\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0C\2\2\2\341\223\215d\377\333\322\214\377"
  "'%\27\377\0\0\0\243\0\0\0""6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\11\0\0\0\320\305\276~\377\377\363\213\377\377\361w\377\260\244N\377\0"
  "\0\0\326\0\0\0<\0\0\0\23\0\0\0\2\0\0\0\0\0\0\0\1\0\0\0\1\0\0\0\2\0\0\0\2"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0r\25\24\20\373\304\275\205\377\321\310\205\377\23\22"
  "\13\374\0\0\0\223\0\0\0""4\0\0\0\31\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0.!\40\27\371\365\350\223\377\373\350|\377\377\357r\377e\\+\377\0"
  "\0\0\230\0\0\0!\0\0\0\10\0\0\0\0\0\0\0\0\0\0\0\34\0\0\0\321\0\0\0l\0\0\0"
  "\1\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\13\0\0\0\2352/#\377\347\337\232\377\305\275{\377\20\16\10\371\0"
  "\0\0\210\0\0\0""1\0\0\0\27\0\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0ZTO5\377\377\362\220\377\372\344q\377\366\337f\377,'\22\377\0\0\0"
  "`\0\0\0\15\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]\1\1\0\377\0\0\0\227\0\0\0\15\0"
  "\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0#\0\0"
  "\0\304ZU=\377\375\364\245\377\261\247h\377\10\7\4\366\0\0\0\202\0\0\0.\0"
  "\0\0\25\0\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\1\0\0\0\17\0\0\0\40\0\0\0""7\0\0\0X\0\0\0s\0\0\0\201\0\0\0\311"
  "\211\200Q\377\377\361\206\377\373\342k\377\351\321^\377\24\22\11\367\0\0"
  "\0x\0\0\0K\0\0\0@\0\0\0=\0\0\0a\15\15\7\343:6&\377\0\0\0\240\0\0\0\25\0\0"
  "\0\3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\3\3\3\350\220"
  "\207`\377\377\377\251\377\224\212S\377\0\0\0\356\0\0\0s\0\0\0+\0\0\0\22\0"
  "\0\0\3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\24\0\0\0*\0\0\0Q\0\0\0{\0\0"
  "\0\233\0\0\0\301\5\5\4\341\27\26\17\361-+\37\376NI4\377jcE\377zrN\377\222"
  "\207W\377\352\327}\377\372\341q\377\367\335c\377\367\335`\377od-\377/*\27"
  "\37751\36\37751\"\37730\"\377LG1\377\276\261s\377\203{N\377\0\0\0\241\0\0"
  "\0\26\0\0\0\3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0j\21\21\15\370"
  "\267\255x\377\377\377\243\377\201vD\377\0\0\0\347\0\0\0i\0\0\0)\0\0\0\21"
  "\0\0\0\3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\0\0\0\327\0\0\0\355\34\32\22\373"
  "QK4\377\200wR\377\237\223c\377\302\264x\377\336\315\210\377\354\331\215\377"
  "\373\346\223\377\377\356\225\377\377\361\223\377\377\357\216\377\377\355"
  "\205\377\372\340q\377\366\331d\377\366\330^\377\367\331]\377\375\342f\377"
  "\372\340o\377\373\343\177\377\374\346\212\377\374\347\216\377\377\355\220"
  "\377\377\370\214\377|o;\377\0\0\0\241\0\0\0\26\0\0\0\3\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\10\0\0\0\224*'\35\377\324\310\211\377\377\371\230\377oc7\377"
  "\0\0\0\340\0\0\0`\0\0\0(\0\0\0\20\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0[\0\0\0\311\0\0\0\347\35\33\23\376PJ3\377\211}P\377\270\247e\377\324"
  "\277m\377\356\325s\377\376\341u\377\377\344r\377\377\346p\377\377\345m\377"
  "\377\345k\377\377\343g\377\367\327_\377\366\325[\377\366\324Y\377\372\331"
  "Z\377\377\341_\377\377\342d\377\377\344j\377\377\344m\377\377\344n\377\377"
  "\344m\377\377\360n\377}n2\377\0\0\0\241\0\0\0\26\0\0\0\3\0\0\0\0\0\0\0\0"
  "\0\0\0\"\0\0\0\303XQ;\377\362\344\227\377\374\355\212\377WM)\377\0\0\0\321"
  "\0\0\0T\0\0\0$\0\0\0\16\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\11\0\0\0\34\0\0\0;\0\0\0^\0\0\0\177\0\0\0\246\0\0\0\312\0\0\0\341\22"
  "\20\10\3660)\23\377E<\32\377\\O\"\377o_)\377p`(\377\214x2\377\363\321V\377"
  "\367\324V\377\374\330W\377\320\263H\377SG\35\377NC\34\377PE\35\377PE\35\377"
  "KA\34\377NC\35\377\241\213:\377wg,\377\0\0\0\241\0\0\0\26\0\0\0\3\0\0\0\0"
  "\0\0\0B\1\1\2\344\204yU\377\377\363\234\377\365\341}\377OE\"\377\0\0\0\307"
  "\0\0\0L\0\0\0\"\0\0\0\14\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\4\0\0\0\12\0\0\0\20\0\0\0\24\0\0\0\32\0\0\0\"\0\0\0.\0\0\0"
  "=\0\0\0T\0\0\0m\0\0\0\200\0\0\0\222\0\0\0\241\0\0\0\243\0\0\0\344\275\242"
  "C\377\377\331X\377\377\334W\377\222|1\377\0\0\0\326\0\0\0\216\0\0\0\214\0"
  "\0\0\212\0\0\0\207\0\0\0\213\2\2\1\323\23\20\7\377\0\0\0\241\0\0\0\23\0\0"
  "\0\0\0\0\0b\17\17\14\367\255\236m\377\377\367\231\377\354\323p\377A8\33\377"
  "\0\0\0\303\0\0\0F\0\0\0\40\0\0\0\12\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\0\0\4\0\0\0"
  "\7\0\0\0\13\0\0\0\17\0\0\0\23\0\0\0\26\0\0\0\32\0\0\0\36\0\0\0\"\0\0\0\40"
  "\0\0\0\250\214x6\377\377\334\\\377\375\324R\377\312\252B\377\4\3\1\345\0"
  "\0\0C\0\0\0#\0\0\0\36\0\0\0\36\0\0\0\34\0\0\0V\0\0\0\377\0\0\0\235\0\0\0"
  "\31\0\0\0\214)&\33\377\321\276\200\377\377\364\220\377\337\303b\3774,\25"
  "\377\0\0\0\270\0\0\0C\0\0\0\36\0\0\0\11\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\3\0\0\0\5\0\0\0\5\0"
  "\0\0\4\0\0\0cE<\36\377\377\330`\377\367\315N\377\373\321P\377=4\25\377\0"
  "\0\0m\0\0\0\14\0\0\0\5\0\0\0\4\0\0\0\4\0\0\0\37\0\0\0\274\0\0\0\224\0\0\0"
  "\276ME-\377\354\325\210\377\377\357\205\377\321\263U\377!\34\14\377\0\0\0"
  "\247\0\0\0;\0\0\0\34\0\0\0\7\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0(\12\11\6\354\333\272V\377\372\320P\377\377\325N\377\226}2\377"
  "\0\0\0\271\0\0\0\23\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0L\0\0\0\342vh<\377"
  "\374\337\177\377\377\347v\377\304\245K\377\30\24\10\377\0\0\0\234\0\0\0""7"
  "\0\0\0\33\0\0\0\7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1"
  "\0\0\0\7\0\0\0\251\211t8\377\377\327W\377\370\312H\377\345\275I\377\26\22"
  "\11\366\0\0\0E\0\0\0\6\0\0\0\0\0\0\0\0\0\0\0_\12\12\10\363\240\214T\377\377"
  "\341x\377\377\336g\377\273\233B\377\20\14\4\373\0\0\0\220\0\0\0""3\0\0\0"
  "\31\0\0\0\6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\1\0\0\0N#\35\17\377\356\304S\377\377\317G\377\374\315I\377=2\24"
  "\377\0\0\0\204\0\0\0\4\0\0\0\2\0\0\0\217)%\32\377\316\266s\377\377\341y\377"
  "\377\331^\377\247\2105\377\11\7\3\365\0\0\0\177\0\0\0.\0\0\0\26\0\0\0\4\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0J\0\0\0""3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\2\0\0\0\20\0\0\0\273\220v3\377\350\274E\377B4\21\377\0\0\0\322\0\0\0"
  "D\0\0\0\40\0\0\0\261KB.\377\353\320\204\377\377\336w\377\377\326\\\377\230"
  "z.\377\3\2\0\362\0\0\0y\0\0\0+\0\0\0\24\0\0\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0I\0\0"
  "\0\377\0\0\0a\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\3\0\0"
  "\0K\25\21\10\372\35\30\12\377\0\0\0\253\0\0\0""8\0\0\0J\0\0\0\330k^=\377"
  "\372\333\206\377\377\330m\377\377\322U\377\210m(\377\0\0\0\354\0\0\0p\0\0"
  "\0*\0\0\0\22\0\0\0\3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0.\0\0\0\357\0\0\0\322\0\0\0,\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\3\0\0\0\16\0\0\0d\0"
  "\0\0p\0\0\0)\0\0\0s\12\11\6\361\236\210P\377\377\335|\377\374\320a\377\374"
  "\312L\377oX\36\377\0\0\0\340\0\0\0c\0\0\0(\0\0\0\20\0\0\0\2\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0/\0\0\0\343\0\0\0\374\0\0\0a\0\0\0\35\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\6\0\0\0\13\0\0\0\24\0\0\0\223*$\25\377"
  "\310\251_\377\377\333q\377\370\311V\377\363\300C\377_J\27\377\0\0\0\323\0"
  "\0\0W\0\0\0$\0\0\0\16\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0>\1\1\0\344\0\0\0\377\0"
  "\0\0\223\0\0\0(\0\0\0\20\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\20\0\0\0\326\207tC\377\377\342s\377\370\305"
  "O\377\374\304@\377\307\231-\377\0\0\0\373\0\0\0{\0\0\0!\0\0\0\10\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\6\0\0\0v\17\16\11\367\12\11\6\377\0\0\0\266\0\0\0""7\0\0\0"
  "\30\0\0\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\3\0\0\0I\0\0\1\347~e,\377\370\301@\377\377\3036\377\363"
  "\2701\377\207g\35\377\17\16\5\367\0\0\0\244\0\0\0;\0\0\0\10\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\12\0\0\0O\7\6\2"
  "\312<4\"\377,&\31\377\0\0\0\304\0\0\0A\0\0\0\35\0\0\0\6\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\3\0"
  "\0\0\13\0\0\0@\0\0\0\3064(\14\377\272\215'\377\375\3012\377\377\3138\377"
  "\345\261=\377\202i.\377#\36\21\374\0\0\0\317\0\0\0\206\0\0\0Q\0\0\0*\0\0"
  "\0\33\0\0\0\32\0\0\0)\0\0\0Q\0\0\0\216\5\4\3\334MB*\377\177nF\3771+\33\377"
  "\0\0\0\270\0\0\0B\0\0\0\35\0\0\0\10\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\4\0\0\0"
  "\15\0\0\0'\0\0\0\206\2\2\1\351O<\20\377\271\214'\377\370\276:\377\377\326"
  "P\377\370\312Z\377\301\235P\377ye7\377E:#\377\35\30\21\370\22\20\11\353\23"
  "\21\11\353\"\35\22\370TH-\377\214wI\377\257\225[\377tc<\377\17\14\11\364"
  "\0\0\0\225\0\0\0:\0\0\0\35\0\0\0\10\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\2\0\0\0\13\0\0\0\26\0\0\0?\0\0\0\225\1\1\0\341+\40\12\377uY\34\377"
  "\261\210.\377\343\262E\377\371\306V\377\372\312`\377\353\277`\377\334\265"
  "_\377\326\261`\377\321\255`\377\260\223S\377gV1\377\23\17\12\367\0\0\0\271"
  "\0\0\0`\0\0\0-\0\0\0\30\0\0\0\7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\5\0\0\0\15\0\0\0\30\0\0\0""7\0\0\0h\0\0\0\233"
  "\0\0\0\313\7\5\1\345\33\22\6\364$\36\12\373*\"\15\374)\40\16\373\37\32\12"
  "\363\13\6\3\345\0\0\0\307\0\0\0\222\0\0\0]\0\0\0""2\0\0\0\36\0\0\0\17\0\0"
  "\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\1\0\0\0\5\0\0\0\14\0\0\0\23\0\0\0\35\0\0\0-\0\0\0@\0\0"
  "\0Q\0\0\0`\0\0\0d\0\0\0a\0\0\0U\0\0\0F\0\0\0""4\0\0\0%\0\0\0\32\0\0\0\20"
  "\0\0\0\6\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\6"
  "\0\0\0\13\0\0\0\17\0\0\0\23\0\0\0\25\0\0\0\26\0\0\0\27\0\0\0\26\0\0\0\23"
  "\0\0\0\17\0\0\0\10\0\0\0\4\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\0\0\1\0\0\0"
  "\1\0\0\0\1\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  "\0\0\0\0\0\0\0\0\0\0\0\0\0",
};



================================================
FILE: src/fchecks.c
================================================
/*
Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: fchecks.c,v 1.19 2007-09-14 13:29:28 disconn3ct Exp $
*/

#include "quakedef.h"
#include "rulesets.h"
#include "version.h"
#include "fmod.h"
#include "utils.h"


static float
f_system_reply_time,
f_cmdline_reply_time,
f_scripts_reply_time,
f_fshaft_reply_time,
f_ruleset_reply_time,
f_reply_time,
f_mod_reply_time,
f_version_reply_time,
f_skins_reply_time,
f_server_reply_time;

cvar_t allow_f_system  = {"allow_f_system",  "1"};
cvar_t allow_f_cmdline = {"allow_f_cmdline", "1"};

extern cvar_t enemyforceskins;
extern cvar_t cl_independentPhysics;
extern cvar_t allow_scripts;
extern cvar_t cl_delay_packet;
extern cvar_t r_fullbrightSkins;
extern cvar_t cl_fakeshaft;
extern cvar_t cl_iDrive;


static void FChecks_VersionResponse (void)
{
	Cbuf_AddText (va("say ezQuake %s " QW_PLATFORM ":" QW_RENDERER "\n", VersionString()));
}

static char *FChecks_FServerResponse_Text(void)
{
	netadr_t adr;

	if (!NET_StringToAdr (cls.servername, &adr))
		return NULL;

	if (adr.port == 0)
		adr.port = BigShort (PORT_SERVER);

	return NET_AdrToString(adr);
}

static void FChecks_FServerResponse (void)
{
	char *text = FChecks_FServerResponse_Text();

	if (!text)
		return;

	Cbuf_AddText(va("say ezQuake f_server response: %s\n", text));
}

static void FChecks_SkinsResponse (float fbskins)
{
	char *sf = enemyforceskins.integer ? ", individual enemy skin forcing" : "";

	if (fbskins > 0)
		Cbuf_AddText (va("say all skins %d%% fullbright%s\n", (int) (fbskins * 100), sf));
	else
		Cbuf_AddText (va("say not using fullbright skins%s\n", sf));
}

static void FChecks_ScriptsResponse (void)
{
	if (allow_scripts.integer < 1)
		Cbuf_AddText ("say not using scripts\n");
	else if (allow_scripts.integer < 2)
		Cbuf_AddText ("say using simple scripts\n");
	else
		Cbuf_AddText ("say using advanced scripts\n");
}

static qbool FChecks_ScriptsRequest (const char *s)
{
	if (cl.spectator || (f_scripts_reply_time && cls.realtime - f_scripts_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_scripts")) {
		FChecks_ScriptsResponse();
		f_scripts_reply_time = cls.realtime;
		return true;
	}

	return false;
}

static void FChecks_FakeshaftResponse (void)
{
	if (cl_fakeshaft.integer == 2)
		Cbuf_AddText("say fakeshaft 2 (emulation of fakeshaft 0 for servers with antilag feature)\n");
	else if (cl_fakeshaft.value > 0.999)
		Cbuf_AddText("say fakeshaft on\n");
	else if (cl_fakeshaft.value < 0.001)
		Cbuf_AddText("say fakeshaft off\n");
	else
		Cbuf_AddText(va("say fakeshaft %.1f%%\n", cl_fakeshaft.value * 100.0));
}

static qbool FChecks_FakeshaftRequest (const char *s)
{
	if (cl.spectator || (f_fshaft_reply_time && cls.realtime - f_fshaft_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_fakeshaft"))	{
		FChecks_FakeshaftResponse();
		f_fshaft_reply_time = cls.realtime;
		return true;
	}

	return false;
}

static qbool FChecks_VersionRequest (const char *s)
{
	if (cl.spectator || (f_version_reply_time && cls.realtime - f_version_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_version")) {
		FChecks_VersionResponse();
		f_version_reply_time = cls.realtime;
		return true;
	}

	return false;
}

static qbool FChecks_SkinRequest (const char *s)
{
	char *fbs;
	qbool fbskins_policy = (cls.demoplayback || cl.spectator) ? 1 :
		*(fbs = Info_ValueForKey(cl.serverinfo, "fbskins")) ? bound(0, Q_atof(fbs), 1) :
		cl.teamfortress ? 0 : 1;
	float fbskins = bound (0, r_fullbrightSkins.value, fbskins_policy);
	if (cl.spectator || (f_skins_reply_time && cls.realtime - f_skins_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_skins"))	{
		FChecks_SkinsResponse(fbskins);
		f_skins_reply_time = cls.realtime;
		return true;
	}

	return false;
}

static qbool FChecks_CheckFModRequest (const char *s)
{
	if (cl.spectator || (f_mod_reply_time && cls.realtime - f_mod_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_modified")) {
		FMod_Response();
		f_mod_reply_time = cls.realtime;
		return true;
	}

	return false;
}

static qbool FChecks_CheckFServerRequest (const char *s)
{
	netadr_t adr;

	if (cl.spectator || (f_server_reply_time && cls.realtime - f_server_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_server") && NET_StringToAdr (cls.servername, &adr)) {
		FChecks_FServerResponse();
		f_server_reply_time = cls.realtime;
		return true;
	}

	return false;
}

void FChecks_RulesetFeatureAppend(qbool on, const char *code, char *feat_on_buf,
								  size_t feat_on_size, char *feat_off_buf, size_t feat_off_size)
{
	if (on) {
		strlcat(feat_on_buf, code, feat_on_size);
	}
	else {
		strlcat(feat_off_buf, code, feat_off_size);
	}
}

// constructs a string telling which extra features are enabled
// besides those covered by the current ruleset)
// format: [+<enabled features>][-<disabled features>]
const char* FChecks_RulesetAdditionString(void)
{
	char feat_on_buf[16] = "+";
	char feat_off_buf[16] = "-";
	static char features[32] = "";

	*features = '\0';

	#define APPENDFEATURE(on,code) FChecks_RulesetFeatureAppend((on),(code),feat_on_buf,sizeof (feat_on_buf),feat_off_buf,sizeof (feat_off_buf))
	// modified models or sounds
	APPENDFEATURE((strcmp(FMod_Response_Text(), "all models ok") != 0),"m");

	// movement scripts enabled
	APPENDFEATURE((allow_scripts.integer),"s");

	// enemy skin forcing enabled
	APPENDFEATURE((enemyforceskins.integer),"f");

	// cl_iDrive - strafing aid
	APPENDFEATURE((cl_iDrive.integer),"i");
	#undef APPENDFEATURE

	if (strlen(feat_on_buf) > 1) {
		strlcat(features, feat_on_buf, sizeof (features));
	}
	if (strlen(feat_off_buf) > 1) {
		strlcat(features, feat_off_buf, sizeof (features));
	}

	return features;
}

static qbool FChecks_CheckFRulesetRequest (const char *s)
{
	// format of the reply:
	// [nick: ]
	// [padding] - so that "nick: " + padding is 17 chars long
	// [ip address] - padded with spaces to 21 chars
	// - this fits to 38 chars which is length of line with conwidth 320
	// [space]
	// [client version] - padded to 16 chars
	// [ruleset name]
	// [ruleset addition]
	// - these 4 should be less than 38 chars so that reply does never take up more than 2 lines
	char *fServer;
	const char *features;
	char *emptystring = "";
	char *brief_version = "ezq" VERSION_NUMBER;
	const char *ruleset = Rulesets_Ruleset();
	size_t name_len = strlen(cl.players[cl.playernum].name);
	size_t pad_len = 15 - min(name_len, 15);

	if (cl.spectator || (f_ruleset_reply_time && cls.realtime - f_ruleset_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_ruleset"))	{
		features = FChecks_RulesetAdditionString();
		fServer = FChecks_FServerResponse_Text();
		if (!fServer) {
			fServer = "server-na";
		}

		Cbuf_AddText(va("say \"%*s%21s %16s %s%s\"\n",
			pad_len, emptystring, fServer, brief_version, ruleset, features));
		f_ruleset_reply_time = cls.realtime;
		return true;
	}

	return false;
}

void FChecks_FRuleset_cmd(void)
{
	if (Cmd_Argc() < 2 || strcmp(Cmd_Argv(1), "check") != 0) {
		Com_Printf("Purpose:\n  "
			"All clients on the server should respond to \"f_ruleset\" message with their client settings in the reply\n"
			"Usage:\n  f_ruleset - prints this help\n"
			"  f_ruleset check - sends check message to all players on the server\n"
			"Flags:\n  End of the reply is ruleset name + flags denoting enabled and disabled features:\n"
			"  m - modified models or sounds\n"
			"  s - movement scripts\n"
			"  f - individual enemy skin forcing\n"
			"  i - side step aid (strafescript)\n"
			"  flags that start with + mean feature is enabled, - means disabled\n");
	}
	else {
		Cbuf_AddText("say \"f_ruleset\"\n");
	}		
}

static qbool FChecks_CmdlineRequest (const char *s)
{
	if (cl.spectator || (f_cmdline_reply_time && cls.realtime - f_cmdline_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_cmdline"))	{
		if (!allow_f_cmdline.integer) {
			Cbuf_AddText("say disabled\n");
		} else {
			Cbuf_AddText("say ");
			Cbuf_AddText(com_args_original);
			Cbuf_AddText("\n");
		}

		f_cmdline_reply_time = cls.realtime;
		return true;
	}

	return false;
}

static qbool FChecks_SystemRequest (const char *s)
{
	if (cl.spectator || (f_system_reply_time && cls.realtime - f_system_reply_time < 20))
		return false;

	if (Util_F_Match(s, "f_system")) {
		char *sys_string;

		sys_string = (allow_f_system.integer) ? SYSINFO_GetString() : "disabled";

		//if (sys_string != NULL && sys_string[0]) {
		Cbuf_AddText("say ");
		Cbuf_AddText(sys_string);
		Cbuf_AddText("\n");
		//}

		f_system_reply_time = cls.realtime;
		return true;
	}

	return false;
}

void FChecks_CheckRequest (const char *s)
{
	qbool fcheck = false;

	fcheck |= FChecks_VersionRequest (s);
	fcheck |= FChecks_CmdlineRequest (s);
	fcheck |= FChecks_SystemRequest (s);
	fcheck |= FChecks_SkinRequest (s);
	fcheck |= FChecks_ScriptsRequest (s);
	fcheck |= FChecks_FakeshaftRequest (s);
	fcheck |= FChecks_CheckFModRequest (s);
	fcheck |= FChecks_CheckFServerRequest (s);
	fcheck |= FChecks_CheckFRulesetRequest (s);

	if (fcheck)
		f_reply_time = cls.realtime;
}

void FChecks_Init (void)
{
	Cvar_SetCurrentGroup (CVAR_GROUP_CHAT);
	Cvar_Register (&allow_f_system);
	Cvar_Register (&allow_f_cmdline);
	Cvar_ResetCurrentGroup();

	FMod_Init();
	Cmd_AddCommand ("f_server", FChecks_FServerResponse);
	Cmd_AddCommand ("f_ruleset", FChecks_FRuleset_cmd);
}


================================================
FILE: src/fchecks.h
================================================
/*
Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: fchecks.h,v 1.4 2007-09-14 13:29:28 disconn3ct Exp $
*/

#ifndef __FCHECKS_H__
#define __FCHECKS_H__

void FChecks_Init (void);
void FChecks_CheckRequest (const char *);

#endif /* !__FCHECKS_H__ */


================================================
FILE: src/fmod.c
================================================
/*
Copyright (C) 2001-2002 A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: fmod.c,v 1.12 2007-09-14 13:29:28 disconn3ct Exp $
*/

#include "quakedef.h"
#include "fmod.h"
#include "sha1.h"
#include "rulesets.h"

typedef qbool (*pRulesetFilter)(const char* modelName);

typedef struct check_models_hashes_entry_s {
	const unsigned int hash[5];
	struct check_models_hashes_entry_s* next;
} check_models_hashes_entry_t;

// original models
static const int progs_armor_mdl_FMOD_DM_FMOD_TF[5]				= {0x18d1b8ef, 0xfe43d973, 0xbb104313, 0xef6a9090, 0x2b048696};
static const int progs_backpack_mdl_FMOD_DM_FMOD_TF[5]			= {0x80cedaeb, 0x18f7d282, 0xa911e7c2, 0xffe609aa, 0x050a6005};
static const int progs_bolt2_mdl_FMOD_DM_FMOD_TF[5]				= {0x14fba8de, 0x99237ae4, 0xc8806043, 0xebeea454, 0x024a99a9};
static const int progs_end1_mdl_FMOD_DM_FMOD_TF[5]				= {0xd1fed19f, 0x5d67c632, 0x1d72a0e6, 0x14ab39d7, 0x4bf435c4};
static const int progs_end2_mdl_FMOD_DM_FMOD_TF[5]				= {0x98eee620, 0x107acd79, 0x8331620d, 0x2a9a1848, 0x64d29e1a};
static const int progs_end3_mdl_FMOD_DM_FMOD_TF[5]				= {0x7f1e336d, 0xe04f4bb0, 0x4ac25a1a, 0x2caedde7, 0x09973319};
static const int progs_end4_mdl_FMOD_DM_FMOD_TF[5]				= {0xa4b572aa, 0xdd00c38d, 0x130f8da2, 0x797f0e55, 0xcca52b76};
static const int progs_eyes_mdl_FMOD_DM_FMOD_TF[5]				= {0x276f25a8, 0xc6b8f782, 0x3ef75d52, 0x911d163e, 0x5d79e557};
static const int progs_g_light_mdl_FMOD_DM_FMOD_TF[5]			= {0xcb9b9366, 0x1fd74d91, 0x9a6a82f6, 0x5d6b2e3e, 0xc458f5ac};
static const int progs_g_nail_mdl_FMOD_DM_FMOD_TF[5]			= {0x7b209f71, 0xa77cd00f, 0x91f24953, 0x932f264b, 0x350e7440};
static const int progs_g_nail2_mdl_FMOD_DM_FMOD_TF[5]			= {0x97cb4499, 0x88e3e11a, 0xecec6eca, 0x883f6c8f, 0xac7ecf0c};
static const int progs_g_rock_mdl_FMOD_DM_FMOD_TF[5]			= {0x9017dd83, 0x150d954c, 0x9b5f4544, 0x10843b72, 0x4697068e};
static const int progs_g_rock2_mdl_FMOD_DM_FMOD_TF[5]			= {0x5a47ec20, 0xd0211cdc, 0xd6b8af60, 0xaf813eab, 0xba330b5b};
static const int progs_g_shot_mdl_FMOD_DM_FMOD_TF[5]			= {0x35a735e1, 0xc1ee6090, 0x9f8940b5, 0x6cdefd1c, 0x7eec1d67};
static const int progs_gib1_mdl_FMOD_DM_FMOD_TF[5]				= {0x99dc9ea4, 0x6e9bf74a, 0x25710a1e, 0x701fc77b, 0x09777092};
static const int progs_gib2_mdl_FMOD_DM_FMOD_TF[5]				= {0x5ac3e29b, 0xd66358d9, 0x1044d27a, 0xb3da48ad, 0x5f1e9fbb};
static const int progs_gib3_mdl_FMOD_DM_FMOD_TF[5]				= {0xc6558e61, 0x13ea4f63, 0x20c9da45, 0x0640212e, 0x7b98f350};
static const int progs_grenade_mdl_FMOD_DM_FMOD_TF[5]			= {0x60dfffb8, 0xfc871f0c, 0xd9f3c325, 0x61aadcaf, 0x0ec37cbf};
static const int progs_invisibl_mdl_FMOD_DM_FMOD_TF[5]			= {0x23e2f389, 0x8479657f, 0x437e0d25, 0xee100bae, 0xbad6a775};
static const int progs_invulner_mdl_FMOD_DM_FMOD_TF[5]			= {0x987ee175, 0xfd0d4f35, 0x06d2641c, 0x725c0dc8, 0x871f537a};
static const int progs_missile_mdl_FMOD_DM_FMOD_TF[5]			= {0x9adfeee8, 0x185872c1, 0xb3bb36f8, 0x996e29ab, 0xd46ab2a9};
static const int progs_quaddama_mdl_FMOD_DM_FMOD_TF[5]			= {0x2760f663, 0x32dc8405, 0x057563df, 0x9614c3a7, 0x0125949b};
static const int progs_s_spike_mdl_FMOD_DM_FMOD_TF[5]			= {0xf308f8e5, 0xcdc242e2, 0x4f71b01f, 0xafb9880a, 0x52198e9f};
static const int progs_spike_mdl_FMOD_DM_FMOD_TF[5]				= {0xebd9adaf, 0xfb3b2f28, 0x67cc2c34, 0x926ec21a, 0x09e1a233};
static const int progs_suit_mdl_FMOD_DM_FMOD_TF[5]				= {0xb7dcb9dd, 0xed8da03b, 0x416efc5e, 0x8ee38d5a, 0x4063bf25};
static const int progs_player_mdl_FMOD_DM[5]					= {0x95ca0ab4, 0x021be62e, 0x6655e9a5, 0xd4a7ef1c, 0xb484582f};
static const int progs_player_mdl_FMOD_TF[5]					= {0x8fcab658, 0x027a97ef, 0xa96eee3d, 0xc1e44f46, 0x18a533c9};
static const int progs_tf_flag_mdl_FMOD_TF[5]					= {0x6e969df0, 0xc91b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_stag_mdl_FMOD_TF[5]						= {0x6e970df0, 0xc91b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_basrkey_bsp_FMOD_TF[5]					= {0x6e971df0, 0xc11b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_basbkey_bsp_FMOD_TF[5]					= {0x6e972df0, 0xc21b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_w_s_key_mdl_FMOD_TF[5]					= {0x6e973df0, 0xc31b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_w_g_key_mdl_FMOD_TF[5]					= {0x6e974df0, 0xc41b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_b_g_key_mdl_FMOD_TF[5]					= {0x6e975df0, 0xc51b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_b_s_key_mdl_FMOD_TF[5]					= {0x6e976df0, 0xc61b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_ff_flag_mdl_FMOD_TF[5]					= {0x6e977df0, 0xc71b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_harbflag_mdl_FMOD_TF[5]					= {0x6e978df0, 0xc81b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_princess_mdl_FMOD_TF[5]					= {0x6e979df0, 0xc92b9eef, 0x84cb1a40, 0xcaee122e, 0x1b1d3d28};
static const int progs_turrbase_mdl_FMOD_TF[5]					= {0x0cda73d5, 0x822703cb, 0x9e6cbe6b, 0x94fb95f7, 0xc7c04bed};
static const int progs_turrgun_mdl_FMOD_TF[5]					= {0x314b126f, 0x7d8d7cb5, 0x8df185c8, 0x1f3662f7, 0xa272957b};
static const int progs_disp_mdl_FMOD_TF[5]						= {0x5596fa4a, 0xd94e2457, 0x140f84df, 0x5859dda8, 0xe96752fc};
static const int progs_tf_stan_mdl_FMOD_TF[5]					= {0x1b732a1b, 0x763069c2, 0xe779e270, 0x252b9daa, 0xddf7db2a};
static const int progs_hgren2_mdl_FMOD_TF[5]					= {0x1dc3715f, 0x58c53c0f, 0xdb1504fc, 0xab354bdf, 0x6aacee97};
static const int progs_grenade2_mdl_FMOD_TF[5]					= {0x4b116cef, 0xebc6f074, 0x2acdea73, 0x876a8716, 0xe5e7409d};
static const int progs_detpack_mdl_FMOD_TF[5]					= {0xaf73d4e1, 0x0c98dc38, 0x6d3983c0, 0xd7a70033, 0x616a675e};
static const int progs_s_bubble_spr_FMOD_DM_FMOD_TF[5]			= {0x3dbefaf2, 0x73b38654, 0x70910774, 0xdfe285f3, 0x4db5d90e};
static const int progs_s_explod_spr_FMOD_DM_FMOD_TF[5]			= {0x295a7b06, 0xacdf1f88, 0x50a20894, 0x5c75905f, 0xb9d95d0b};
static const int maps_b_bh100_bsp_FMOD_DM_FMOD_TF[5]			= {0x65e7e302, 0x94a85b4d, 0x8092e674, 0xf700e5f0, 0xde667fcc};
static const int sound_buttons_airbut1_wav_FMOD_DM_FMOD_TF[5]	= {0x47d5141e, 0xc925e8eb, 0x26e5583c, 0xc8dfd021, 0x226792ef};
static const int sound_items_armor1_wav_FMOD_DM_FMOD_TF[5]		= {0x44488db0, 0xef0b0a1d, 0x3acda8b4, 0x3d87b467, 0xe4dd4fcc};
static const int sound_items_damage_wav_FMOD_DM_FMOD_TF[5]		= {0x197778ac, 0x92a252c5, 0x90c30256, 0x7ba6f264, 0x56ab654f};
static const int sound_items_damage2_wav_FMOD_DM_FMOD_TF[5]		= {0x719a9b4d, 0x1c76b218, 0xfcbf979f, 0x5ea5e6fa, 0x68afda0e};
static const int sound_items_damage3_wav_FMOD_DM_FMOD_TF[5]		= {0xfa07de6c, 0x6e306d39, 0x7d18f3ed, 0x90272558, 0x63d01e7a};
static const int sound_items_health1_wav_FMOD_DM_FMOD_TF[5]		= {0xebdd17b2, 0xa1289b80, 0x7810e3f2, 0xdb8d01bf, 0x0b495a96};
static const int sound_items_inv1_wav_FMOD_DM_FMOD_TF[5]		= {0xa01240b8, 0xb588d430, 0xc62406e0, 0x39e59dfd, 0xad5a4b98};
static const int sound_items_inv2_wav_FMOD_DM_FMOD_TF[5]		= {0x9ab6025d, 0x2d9d24a2, 0xc127b17c, 0x019e908a, 0xa521f7d3};
static const int sound_items_inv3_wav_FMOD_DM_FMOD_TF[5]		= {0xfb785777, 0x9c622826, 0x6121d05c, 0xf42d5661, 0xa34a5429};
static const int sound_items_itembk2_wav_FMOD_DM_FMOD_TF[5]		= {0x178c519b, 0x3b030527, 0x759aaed2, 0xf7dca7d7, 0xf01a1e36};
static const int sound_player_land_wav_FMOD_DM_FMOD_TF[5]		= {0xb8bb5e41, 0xf087ad8e, 0x13323cd5, 0x2e2d2052, 0x338e9e38};
static const int sound_player_land2_wav_FMOD_DM_FMOD_TF[5]		= {0x6c13b55c, 0xc46c1589, 0xeeabac42, 0x087cd24e, 0xd9552386};
static const int sound_misc_outwater_wav_FMOD_DM_FMOD_TF[5]		= {0x9cb6fc36, 0x9c20e9ba, 0x595f8418, 0x50e76d9f, 0xa7503dfd};
static const int sound_weapons_pkup_wav_FMOD_DM_FMOD_TF[5]		= {0x05a43523, 0x09bbab60, 0x77ce67a0, 0xb52fe23d, 0xf2715701};
static const int sound_player_plyrjmp8_wav_FMOD_DM_FMOD_TF[5]	= {0x75e2e946, 0xc9ad54f2, 0x6cd47b03, 0xeef0c9d4, 0x5d3386da};
static const int sound_items_protect_wav_FMOD_DM_FMOD_TF[5]		= {0x38ff1351, 0x7d6799c7, 0x7577256d, 0xbf233192, 0xb6223baa};
static const int sound_items_protect2_wav_FMOD_DM_FMOD_TF[5]	= {0x588dd159, 0xae489f2c, 0x22f7118e, 0x487eeb4c, 0x3c54c997};
static const int sound_items_protect3_wav_FMOD_DM_FMOD_TF[5]	= {0x869a1143, 0xc9e6a404, 0xcbd5d90e, 0xa1b57e4c, 0xae77dd20};
static const int sound_items_r_item1_wav_FMOD_DM_FMOD_TF[5]     = {0xdde12941, 0xfbb3b804, 0x776cf5fa, 0xe81df8ea, 0xa1429f63};
static const int sound_items_r_item2_wav_FMOD_DM_FMOD_TF[5]     = {0xd9da4047, 0x5a7b191a, 0xc02d860d, 0x18f679de, 0xc47bd93a};
static const int sound_misc_water1_wav_FMOD_DM_FMOD_TF[5]		= {0x8625dbc7, 0xbaf30ae6, 0xfdb53965, 0x2d7eb9d6, 0xf9fd9304};
static const int sound_misc_water2_wav_FMOD_DM_FMOD_TF[5]		= {0xccda75ec, 0xfb5cd780, 0xe2d73b5b, 0x9f3560ad, 0x4e116b85};

static const int sound_misc_menu1_wav_FMOD_DM_FMOD_TF[5]		= {0x2e19b817, 0x0c0e1c5f, 0xd7a0ecf8, 0xb278c27e, 0xb0e1923c};
static const int sound_misc_menu2_wav_FMOD_DM_FMOD_TF[5]		= {0xd6719ab1, 0x0a407e2b, 0xb03a053b, 0x2a4bc2cb, 0x61cd7ff3};
static const int sound_misc_menu3_wav_FMOD_DM_FMOD_TF[5]		= {0xae120b9a, 0x3a217d2e, 0xc34f0990, 0x2d4332ed, 0x97c18f76};
static const int sound_misc_talk_wav_FMOD_DM_FMOD_TF[5]			= {0x5b15321c, 0x1af2d826, 0xb0228e9f, 0x49c06f56, 0xa8355e8b};
static const int sound_misc_basekey_wav_FMOD_DM_FMOD_TF[5]		= {0x926134ce, 0x22806dd3, 0x1952624a, 0x8f43f7e9, 0xa6fdfe64};
static const int sound_doors_runeuse_wav_FMOD_DM_FMOD_TF[5]		= {0xf41d6d59, 0xe99b93e8, 0x15edfd25, 0x668a499c, 0x1ac62572};

static const int gfx_colormap_lmp_FMOD_DM_FMOD_TF[5]			= {0xa93b3795, 0x17016397, 0x0a761d38, 0x4866e67d, 0x3c2a2a75};
static const int gfx_palette_lmp_FMOD_DM_FMOD_TF[5]			= {0xa6a2e242, 0xbad0f7da, 0xe263351f, 0x6d51f8ad, 0x49a45d4a};

// debug
static check_models_hashes_entry_t mdlhash_debug_armor = { {0x8d264ffc, 0xfabb1e7c, 0xc81128bc, 0x21633d32, 0xfa0b594f}, NULL };
static check_models_hashes_entry_t mdlhash_debug_backpack = { {0xe7c1f382, 0x0c3dc22e, 0xd31a04c0, 0x7251ed52, 0x45baf223}, NULL };
//static check_models_hashes_entry_t mdlhash_debug_flame = { {0xcfd8e629, 0x143a35a7, 0x4781ad82, 0x4254f247, 0xe07cd565}, NULL };
static check_models_hashes_entry_t mdlhash_debug_g_light = { {0x9d78b478, 0xfb44c849, 0xc56b6d9d, 0xab737839, 0x1fcfd848}, NULL };
static check_models_hashes_entry_t mdlhash_debug_g_nail = { {0xc6619f5d, 0x55511a85, 0x6de0cc63, 0xef61171a, 0x36b1b173}, NULL };
static check_models_hashes_entry_t mdlhash_debug_g_nail2 = { {0x9cd58369, 0xe54c8527, 0xcea234b4, 0x472bd93e, 0x7dfa8655}, NULL };
static check_models_hashes_entry_t mdlhash_debug_g_rock = { {0x334e9253, 0xa5a5a252, 0x68b9a856, 0x5e226647, 0xe4baeec7}, NULL };
static check_models_hashes_entry_t mdlhash_debug_g_rock2 = { {0xe24e10f9, 0x0f53bc41, 0x6043ee2b, 0x3d577eec, 0xbc75124c}, NULL };
static check_models_hashes_entry_t mdlhash_debug_g_shot = { {0x7bbba828, 0x99438f98, 0x975e3747, 0x6cbc8a2b, 0xd3a64db7}, NULL };
static check_models_hashes_entry_t mdlhash_debug_gib1 = { {0x69ee06fd, 0x8bac8483, 0xf9c5a43e, 0xd7513722, 0x55d5a4ff}, NULL };
static check_models_hashes_entry_t mdlhash_debug_gib2 = { {0x3251a1df, 0x50e68208, 0xeff0f797, 0x89894e71, 0x65505be3}, NULL };
static check_models_hashes_entry_t mdlhash_debug_gib3 = { {0x798f0b46, 0xe55c7250, 0x882ff3f5, 0x75495a80, 0x19a3ed99}, NULL };
static check_models_hashes_entry_t mdlhash_debug_grenade = { {0xdaf5db12, 0x41d4fc02, 0x764dd35a, 0xa4490888, 0xd5d26cea}, NULL };
//static check_models_hashes_entry_t mdlhash_debug_h_player = { {0x22ee657b, 0x31ac0cb9, 0x8ce678cc, 0xb174b570, 0x1a102fd9}, NULL };
static check_models_hashes_entry_t mdlhash_debug_invisibl = { {0xe5acae60, 0x8b2fe8fd, 0xb8ef8e78, 0x8d236ae4, 0xc3db0be3}, NULL };
static check_models_hashes_entry_t mdlhash_debug_invulner = { {0x57b00a3e, 0x009afa6d, 0xa4c2c8cb, 0xa7b0eccc, 0xa9e57049}, NULL };
static check_models_hashes_entry_t mdlhash_debug_missile = { {0x2ae7a078, 0xc39393d4, 0x73576788, 0x242699d2, 0x8f190bfd}, NULL };
static check_models_hashes_entry_t mdlhash_debug_quaddama = { {0x9010a156, 0x1b63addb, 0xbc9bd9e3, 0xff8d6e4e, 0xcecd1260}, NULL };
static check_models_hashes_entry_t mdlhash_debug_s_spike = { {0xb159e4cc, 0xbc5dccf0, 0x656e93ab, 0x3e72dd24, 0x10446fc6}, NULL };
static check_models_hashes_entry_t mdlhash_debug_spike = { {0xe78bb944, 0x92a753e4, 0x435c226b, 0x4021a65e, 0xef388c6b}, NULL };
/*
static check_models_hashes_entry_t mdlhash_debug_v_axe = { {0x77c9f8d4, 0x66d8b9e8, 0xaa75b3ce, 0xe6325d71, 0x70f57eea}, NULL };
static check_models_hashes_entry_t mdlhash_debug_v_light = { {0xf1ac7d77, 0x9ff2321d, 0x4ad3b6f0, 0x4372d11e, 0x46765fa7}, NULL };
static check_models_hashes_entry_t mdlhash_debug_v_nail = { {0x2322c673, 0xd5ec1e41, 0xe762d27e, 0x89c6ae72, 0x9006bd90}, NULL };
static check_models_hashes_entry_t mdlhash_debug_v_nail2 = { {0x636a9adb, 0xaeca483a, 0x284f0999, 0x3198b142, 0xd174e963}, NULL };
static check_models_hashes_entry_t mdlhash_debug_v_rock = { {0xf13c7070, 0xecc5c390, 0x22412e14, 0x51b13f01, 0x3c803dee}, NULL };
static check_models_hashes_entry_t mdlhash_debug_v_rock2 = { {0xda85f801, 0xa8bd2523, 0xa338f574, 0xa0466a00, 0xc5dc3964}, NULL };
static check_models_hashes_entry_t mdlhash_debug_v_shot = { {0x67e9aa5b, 0x294674a8, 0x553aea03, 0x13165b3c, 0x161e851e}, NULL };
static check_models_hashes_entry_t mdlhash_debug_v_shot2 = { {0x309594be, 0xe11e461a, 0x92cfcfdd, 0xe9b78788, 0x650daa89}, NULL };
*/

// Primevil deathmatch pack
static check_models_hashes_entry_t mdlhash_pdp_g_nail = { {0x86dd1964, 0xebe66f85, 0xf27e5b4c, 0x3230aeda, 0x10c13860}, NULL };
static check_models_hashes_entry_t mdlhash_pdp_g_rock = { {0x10e990fe, 0x3b401ed2, 0x9a9d71ad, 0x9085f059, 0x7710088f}, NULL };
static check_models_hashes_entry_t mdlhash_pdp_g_rock2 = { {0x3c4280d9, 0xd8a43a56, 0xeff931eb, 0xb76310af, 0xb28c39ad}, NULL };
static check_models_hashes_entry_t mdlhash_pdp_g_shot = { {0x3a9f015f, 0xd817a29e, 0xdc7a87fa, 0xc6e31628, 0xaa991119}, NULL };

// ruohis
static check_models_hashes_entry_t mdlhash_ruohis_armor = { {0x7772c52a, 0xdee37c13, 0xbbbc8523, 0x348525ba, 0x6e1bd649}, NULL };
//static check_models_hashes_entry_t mdlhash_ruohis_backpack = { {0x1a57bc37, 0xabe69424, 0xaa3b6b52, 0x64af310b, 0x177b9c20}, NULL };

static check_models_hashes_entry_t mdlhash_ruohis_g_light = { {0xfe2d50b8, 0x6ad56eb4, 0xe579fceb, 0x43e46f6d, 0x82f616da}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_g_nail = { {0xbe7da37e, 0xb531272b, 0x0c7de89a, 0x26f387bd, 0x20dc31ee}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_g_nail2 = { {0x38df15ca, 0xe2db4350, 0x5c065841, 0x67ec548c, 0x3db3f0b2}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_g_rock = { {0xd2e3e29a, 0x1e3a2acf, 0xa2f21d53, 0x60452add, 0xd8732afa}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_g_rock2 = { {0x54350c58, 0x6a09fd88, 0xae214b80, 0xc71d71de, 0x109d0fe6}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_g_shot = { {0xc74cafd8, 0xbc3af902, 0xbb52b588, 0x6f6fca30, 0x5b2ab554}, NULL };

static check_models_hashes_entry_t mdlhash_ruohis_gib1 = { {0x05ff57f8, 0x1073a096, 0xc7e5d055, 0x9c6c040b, 0x96d2eb8a}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_gib2 = { {0xdf23d687, 0x51ea9047, 0xbfdb3497, 0xed7b63db, 0x131a1bfb}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_gib3 = { {0xff5df01e, 0x7606952f, 0xdd36c784, 0xa0d72d33, 0x066afa33}, NULL };

static check_models_hashes_entry_t mdlhash_ruohis_invisibl = { {0xb7507e7e, 0x84dc7019, 0x8f5f1c39, 0xc0df2979, 0xe86b93dd}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_invulner = { {0xddcca118, 0x9e143d41, 0xa2a8dc57, 0x82744eb7, 0x09af301b}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_quaddama = { {0xdb93cf6c, 0x7006a0b8, 0x90b28c56, 0xf97afba7, 0x423699cb}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_suit = { {0xbf4de4f3, 0xe60927c1, 0xf4824f00, 0x21feef56, 0xac00a897}, NULL };

static check_models_hashes_entry_t mdlhash_ruohis_grenade = { {0xece5571e, 0xa35d61e8, 0xe2b6df49, 0xf35372d9, 0x7ac78910}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_missile = { {0x7e844aca, 0xb1b07ef9, 0x3d8994d8, 0xe6b4d14e, 0x56c49858}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_spike = { {0xd8225980, 0x0299e9f7, 0x6732fd66, 0x54555264, 0x67bda403}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_s_spike = { {0x40bf84c5, 0xcab85a9c, 0x498baa24, 0xbe07d9c6, 0x6b666756}, NULL };

static check_models_hashes_entry_t mdlhash_ruohis_end1 = { {0x51ff9322, 0x8b31b83d, 0x8988bebf, 0x0917dce7, 0xd9578e04}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_end2 = { {0x2ea71e4b, 0x0ef6cf22, 0x86d53ba5, 0x1145433d, 0xe6712054}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_end3 = { {0x04c3eda0, 0x2b4f2534, 0x127abbca, 0x755c97cf, 0x135b6597}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_end4 = { {0x4d5a54c1, 0x1fa8aaba, 0x600a5b2b, 0x7508ff3f, 0xc7af03de}, NULL };

static check_models_hashes_entry_t mdlhash_ruohis_b_bh100 = { {0x527fd5b6, 0xd490707f, 0xabd69622, 0xf3d18a69, 0xe9bc0eb9}, NULL };
static check_models_hashes_entry_t mdlhash_ruohis_b_bh100_other = { {0xb42135c1, 0x6816429c, 0x21e3ce3e, 0xfab9f8fc, 0x09387ae1}, NULL };

// plagues
static check_models_hashes_entry_t mdlhash_plaguespak_armor = { {0x5647e7b2, 0x52465746, 0xc10320fa, 0x1e92c90c, 0x27577c72}, NULL };
//static check_models_hashes_entry_t mdlhash_plaguespak_b_g_key = { {0x3f9779fe, 0x5ec019b7, 0xa25fe622, 0x6e217fa6, 0xe84cee45}, NULL };
//static check_models_hashes_entry_t mdlhash_plaguespak_b_s_key = { {0x370e1810, 0xb9bc0a5b, 0x4bb3fb54, 0x1573b0f5, 0x351207ab}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_g_light = { {0x6231b892, 0x1f39d616, 0x1442715d, 0xfbfc2826, 0xc866d8d6}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_g_nail = { {0xcb2e31c6, 0x1f1064ab, 0x5e0be681, 0x5e658642, 0xd9411ef4}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_g_nail2 = { {0x7d3fe401, 0x738a4344, 0x4ab62439, 0xba7313eb, 0x6a6f8536}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_g_rock = { {0xe31fc7b0, 0x35200618, 0x8ba6973c, 0x1296c555, 0xb2541bde}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_g_rock2 = { {0x674eb3e9, 0xde325927, 0xdabd4337, 0xc97a755c, 0x97f4f1f9}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_g_shot = { {0xd3486358, 0x4a3a3d37, 0x0efc43e4, 0x55a42f89, 0xf8078519}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_grenade = { {0xe3a1b910, 0x28c4e36a, 0x1af69321, 0x9d19df99, 0x5bcebfcb}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_missile = { {0xe047b3ec, 0xad03d2e2, 0x2a146207, 0x99e1f2df, 0xfb229f42}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_s_spike = { {0xe7c61b11, 0x703a7f30, 0x0051a5da, 0xb84a5bd1, 0xe23645ac}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_spike = { {0x28f1cb95, 0xafb8ed91, 0x6a8300ff, 0xeb29c03f, 0x28a2bbcb}, NULL };
/*
static check_models_hashes_entry_t mdlhash_plaguespak_v_light = { {0x3c9ca1d7, 0x77303f95, 0x0ad05a82, 0x64a83757, 0x8257cf75}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_v_nail = { {0x71876b6d, 0x934d5f0a, 0x322763f9, 0x924fb71c, 0x5027e3b4}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_v_nail2 = { {0x0b154635, 0x5a49f995, 0x9671641a, 0x2dfb1212, 0xe2631d44}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_v_rock = { {0xbac51d54, 0x884906a3, 0xa7ebec69, 0xe994be29, 0xdd326508}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_v_rock2 = { {0x170a3ecf, 0x5cd131ab, 0xfcecd4fb, 0x62151b89, 0x3bc663b7}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_v_shot = { {0x93dc8f24, 0x6739d838, 0x996b00cc, 0x85c2d98f, 0x430b8e30}, NULL };
static check_models_hashes_entry_t mdlhash_plaguespak_v_shot2 = { {0x58e68b33, 0x1127186f, 0xd1bdae79, 0x66fd9ca3, 0x82421f9b}, NULL };
*/

// unknown
// these come with nQuake and are told to be "harmless"
static check_models_hashes_entry_t mdlhash_unknown_end2 = { {0xe3a1b910, 0x28c4e36a, 0x1af69321, 0x9d19df99, 0x5bcebfcb }, NULL };
static check_models_hashes_entry_t mdlhash_unknown_end3 = { {0xe3a1b910, 0x28c4e36a, 0x1af69321, 0x9d19df99, 0x5bcebfcb }, NULL };
static check_models_hashes_entry_t mdlhash_unknown_end4 = { {0xe3a1b910, 0x28c4e36a, 0x1af69321, 0x9d19df99, 0x5bcebfcb }, NULL };

// grenade converted from CPMA
//static check_models_hashes_entry_t mdlhash_cpma_grenade = { {0xe89d9866, 0xf52324c9, 0x005d0507, 0x083c8cb4, 0xc1918636 }, NULL };
// megaheath converted from Generations Arena
static check_models_hashes_entry_t mdlhash_generations_b_bh100 = { {0xc6b455ff, 0xad7cb845, 0xa7356729, 0x35375fcf, 0x10adb479}, NULL };

// megahealth alternatives
// this one is said to be used in the US
static check_models_hashes_entry_t sound_items_r_item2_wav_us = {{0xf62a00d2, 0x5fceaaca, 0x25f91692, 0xf7602cb7, 0x230da525}, NULL};
// this is just 11kHz version of the US one, but resampled to 11 kHz
// this one might be used widely in russia
static check_models_hashes_entry_t sound_items_r_item2_wav_ru = {{0x83a8e646, 0xbc4cc313, 0xa07aa96e, 0x9d81eada, 0xf619bd10}, NULL};

// Mindgrid Audio sound files
static check_models_hashes_entry_t sound_buttons_mindgrid_airbut1 = { {0xd5fbbce0, 0x2083e431, 0xaa11c54d, 0x089ce053, 0xdf03ce11}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_armor1 = { {0x1b47daed, 0x5a60cd6a, 0x83940499, 0x65eb651b, 0x4441f6cf}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_damage = { {0x3da087a3, 0x1799d4c7, 0x8ddabf31, 0x42e2de6f, 0x5bfdabec}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_damage2 = { {0xd0eb779c, 0x0bf1d83c, 0x120e1c7e, 0x50fa449b, 0x2cd4655b}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_damage3 = { {0x2e0c3b71, 0xdd52cfc9, 0x8e5fe1e5, 0x0ac48fd9, 0xa2d8b970}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_inv1 = { {0x787708ba, 0x63f52c51, 0x55835932, 0x7db46d86, 0xccc830cc}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_inv2 = { {0xb2a3bc8c, 0x7eb56b5f, 0x675e4d67, 0x24054040, 0x3b2ecd0b}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_inv3 = { {0xa1945433, 0x7f3e2c52, 0x9144528a, 0x02891cf0, 0xd95eb255}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_itembk2 = { {0x41dd6dad, 0x45a8c24b, 0xef56b75e, 0x5ab3915a, 0x2901a70f}, NULL };
static check_models_hashes_entry_t sound_misc_mindgrid_outwater = { {0x6be98515, 0xfeab0126, 0x80edc811, 0xe7cf7012, 0x1def4980}, NULL };
static check_models_hashes_entry_t sound_weapons_mindgrid_pkup = { {0xda261fbc, 0x12f47c68, 0x9e91e794, 0xce0a434d, 0xc4e35e77}, NULL };
static check_models_hashes_entry_t sound_player_mindgrid_plyrjmp8 = { {0x5a9e8263, 0xb9b3f06e, 0x8a047de1, 0x72c18bec, 0x547df977}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_protect = { {0x5948333f, 0xa28e882a, 0xb4b82964, 0xe10679c5, 0x191f8cb1}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_protect2 = { {0x29e977b0, 0x0d9378fe, 0xb4489037, 0x02d83d62, 0xce0b718d}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_protect3 = { {0x7619314c, 0x07b6901c, 0x000601e2, 0xc358367e, 0x999f90b1}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_r_item1 = { {0x0f5754d4, 0xa8b84c5f, 0x0001903a, 0xd3ab289c, 0xa93bc848}, NULL };
static check_models_hashes_entry_t sound_items_mindgrid_r_item2 = { {0xd2d0de39, 0x2bb78d33, 0x09ef3081, 0xbe90bacf, 0xbf71ecce}, NULL };
static check_models_hashes_entry_t sound_misc_mindgrid_water1 = { {0x838a0318, 0x0805e53e, 0x6ebf4065, 0xaa5fb9a0, 0xe1cad807}, NULL };
static check_models_hashes_entry_t sound_misc_mindgrid_water2 = { {0xfb0a6b17, 0x065fbc33, 0x5fab7cc5, 0x110c01aa, 0x278b612e}, NULL };

// CapnBub's new player model, see http://www.quakeworld.nu/forum/topic/6073/new-quake-models/page/1
static check_models_hashes_entry_t mdlhash_player_mdl_CapNBubs_FMOD_DM = { {0xC0223459, 0x42B97D8D, 0xC52FF472, 0xF3EE0710, 0x41E21132}, NULL };

// gpl_maps.pk3 include a small wav file to allow map to load
static check_models_hashes_entry_t sound_gpl_maps_silence_wav = { {0xc99871d4, 0xc60e0fef, 0x14e64bf9, 0xbaf43934, 0x5376df18}, NULL };

// rerelease
static check_models_hashes_entry_t sound_buttons_rerelease_airbut1 = { {0x81911593, 0x3e85656b, 0x7a9475d0, 0x87de29a0, 0x157d3ef9}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_armor1 = { {0x1bde8fc5, 0xc979543f, 0x8fc7f57b, 0xe2c1367b, 0x62cac72f}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_damage = { {0x4dde0192, 0x1791d662, 0xa33168eb, 0xb98d083f, 0x15ba0ded}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_damage2 = { {0x6c9b6f7c, 0x85e48943, 0x803ddafd, 0x8249af31, 0x9967d89c}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_damage3 = { {0x18a390ad, 0x0c47d3e9, 0x19db8c3b, 0x1426eda5, 0xa2feb55a}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_health1 = { {0x3ef1d863, 0x683899cb, 0xd9191607, 0x02353423, 0x0737419c}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_inv1 = { {0x24c5cf56, 0xb3569f7a, 0xb21bb96a, 0x95638065, 0x2ea0d036}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_inv2 = { {0x810f09ea, 0x34d8c482, 0xcc9561b1, 0xffeba6d0, 0xc6610c57}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_inv3 = { {0x037ed5b5, 0x27ab500b, 0xcee3abb1, 0xd882645a, 0x48e02c87}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_protect = { {0x7f894d4b, 0xe4a5c499, 0xd06df01a, 0xb1e57bc8, 0xb2d552aa}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_protect2 = { {0xa8a31b8a, 0xf96967b1, 0xc394287f, 0x3a5bf203, 0xe80d111b}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_protect3 = { {0xd8a88cdf, 0x394d1b5b, 0x28fb397b, 0x4120f605, 0x3e5dbefa}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_r_item1 = { {0xc850a036, 0x86199e27, 0x8550ac67, 0x7fc29886, 0x1d80678a}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_r_item2 = { {0xb0e2cb5d, 0xcc12db33, 0x5d599343, 0x2835ac62, 0x76fa4846}, NULL };
static check_models_hashes_entry_t sound_items_rerelease_itembk2 = { {0xf3937197, 0x71d317b7, 0x7827aee9, 0x68ab6f3a, 0x5cb0e9c7}, NULL };
static check_models_hashes_entry_t sound_player_rerelease_land = { {0x349bc931, 0x8621a826, 0xca259e9d, 0x5eb296d1, 0xe0f4ac70}, NULL };
static check_models_hashes_entry_t sound_player_rerelease_land2 = { {0x8ac31277, 0xdfc8eedf, 0xf6f322ca, 0x37188a1f, 0xe3f7a688}, NULL };
static check_models_hashes_entry_t sound_misc_rerelease_outwater = { {0x13930c6c, 0xaa57abbf, 0x5356d6ea, 0x1a2e6d40, 0x6a818b4c}, NULL };
static check_models_hashes_entry_t sound_weapons_rerelease_pkup = { {0x6a0c9888, 0x2d68fa77, 0x5e448d95, 0x2a95666c, 0x842ee9a9}, NULL };
static check_models_hashes_entry_t sound_player_rerelease_plyrjmp8 = { {0xd33205fa, 0x2ec2aa75, 0x074e991b, 0x2f32c63e, 0xafbbbb6a}, NULL };
static check_models_hashes_entry_t sound_misc_rerelease_water1 = { {0xa694280d, 0xd6b28324, 0x9e2c2def, 0x007d86f7, 0xbb583438}, NULL };
static check_models_hashes_entry_t sound_misc_rerelease_water2 = { {0xd974d2db, 0x7c609ba1, 0x9ffefe98, 0x376e5f5d, 0x8cc0cbb9}, NULL };
static check_models_hashes_entry_t sound_misc_rerelease_menu1 = { {0x0849e8f9, 0x5828515c, 0x55d6b38c, 0xf7299ac3, 0x0655378e}, NULL };
static check_models_hashes_entry_t sound_misc_rerelease_menu2 = { {0xe028d3c0, 0x710031e1, 0xd83221ad, 0xd28205c7, 0x51c10a10}, NULL };
static check_models_hashes_entry_t sound_misc_rerelease_menu3 = { {0x2205061f, 0x00f4c078, 0xfa26934b, 0x15bacdfd, 0x98d90a7b}, NULL };
static check_models_hashes_entry_t sound_misc_rerelease_talk = { {0xf28522df, 0x7ea37652, 0xc4605d1f, 0xce10e1cf, 0x2d1fc5fc}, NULL };
static check_models_hashes_entry_t sound_misc_rerelease_basekey = { {0x6871924c, 0xbcc9e6dc, 0x6cea01c2, 0x367f979f, 0xb16619ae}, NULL };
static check_models_hashes_entry_t sound_doors_rerelease_runeuse = { {0x00ffef66, 0x4ed15aae, 0x8e67b5ef, 0x563f0c0f, 0x70b11c41}, NULL };

#define MAX_CHECK_MODELS 256
#define	FMOD_DM 1
#define FMOD_TF 2

typedef struct check_models_s {
	char		name[MAX_QPATH];
	qbool		modified;
	qbool		checked;
	int			flags;
	const void*	hash;
	check_models_hashes_entry_t*
				hash_alt;
} check_models_t;

static check_models_t check_models[MAX_CHECK_MODELS];
static int check_models_num = 0;
static float fmod_warn_time = 0.0f;

static qbool FMod_IsModelModified (const char *name, const int flags, const byte *buf, const size_t len)
{
	int i;
	unsigned char hash[DIGEST_SIZE];
	SHA1_CTX context;
	qbool found = false;

	SHA1Init (&context);
	SHA1Update (&context, (unsigned char *) buf, len);
	SHA1Final (hash, &context);

	for (i = 0; i < check_models_num; i++) {
		if (strcmp(name, check_models[i].name) == 0) {
			if (check_models[i].flags == flags) {
				found = true;
				break;
			}
		}
	}

	if (found) {
		if (memcmp(check_models[i].hash, hash, DIGEST_SIZE) == 0) {
			// original model
			return false;
		}
		else {
			check_models_hashes_entry_t *cur = check_models[i].hash_alt;
			while (cur) {
				if (memcmp(cur->hash, hash, DIGEST_SIZE) == 0 && Rulesets_AllowAlternateModel(name)) {
					// alternative legal model
					return false;
				}
				cur = cur->next;
			}
		}
	}

	// no match found
	return true;
}

static int FMod_AddModel (const char *name, const qbool flags, const void *hash)
{
	if (check_models_num >= MAX_CHECK_MODELS)
		return -1;

	strlcpy (check_models[check_models_num].name, name, sizeof (check_models[check_models_num].name));	
	check_models[check_models_num].checked = check_models[check_models_num].modified = false;
	check_models[check_models_num].flags = flags;
	check_models[check_models_num].hash = hash;
	check_models[check_models_num].hash_alt = NULL;
	return check_models_num++;
}

/// adds alternative models' hashes
static void FMod_AddModelAlt (int cm_num, check_models_hashes_entry_t *hash_new)
{
	check_models_hashes_entry_t* curr_head;
	if (cm_num < 0) return;

	curr_head = check_models[cm_num].hash_alt;
	check_models[cm_num].hash_alt = hash_new;
	hash_new->next = curr_head;
}

void FMod_CheckModel (const char *name, const void *buf, const size_t len)
{
	int i;
	qbool modified, relevent;

	for (i = 0; i < MAX_CHECK_MODELS && i < check_models_num; i++) {
		relevent = (cl.teamfortress && (check_models[i].flags & FMOD_TF)) ||
			(!cl.teamfortress && (check_models[i].flags & FMOD_DM));

		if (relevent && !strcasecmp (name, check_models[i].name))
			break;
	}

	if (i >= check_models_num)
		return;

	modified = FMod_IsModelModified (name, check_models[i].flags, buf, len);

	if (check_models[i].checked && !check_models[i].modified && modified) {
		if (!fmod_warn_time || (float) cls.realtime - fmod_warn_time >= 3.0f) {
			Cbuf_AddText("say warning: models changed !!  Use f_modified again\n");
			fmod_warn_time = (float) cls.realtime;
		}
	}

	check_models[i].modified = modified;
	check_models[i].checked = true;
}

void FMod_Init (void)
{
	int lastid;

	Cmd_AddCommand("f_modified", FMod_Response);

	memset (check_models, 0, sizeof (check_models));

	lastid = FMod_AddModel ("progs/armor.mdl",			FMOD_DM | FMOD_TF,	progs_armor_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_armor);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_armor);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_armor);

	lastid = FMod_AddModel ("progs/backpack.mdl",		FMOD_DM | FMOD_TF,	progs_backpack_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_backpack);

	FMod_AddModel ("progs/bolt2.mdl",			FMOD_DM | FMOD_TF,	progs_bolt2_mdl_FMOD_DM_FMOD_TF);
	lastid = FMod_AddModel ("progs/end1.mdl",			FMOD_DM | FMOD_TF,	progs_end1_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_end1);
	lastid = FMod_AddModel ("progs/end2.mdl",			FMOD_DM | FMOD_TF,	progs_end2_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_unknown_end2);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_end2);
	lastid = FMod_AddModel ("progs/end3.mdl",			FMOD_DM | FMOD_TF,	progs_end3_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_unknown_end3);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_end3);
	lastid = FMod_AddModel ("progs/end4.mdl",			FMOD_DM | FMOD_TF,	progs_end4_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_unknown_end4);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_end4);
	FMod_AddModel ("progs/eyes.mdl",			FMOD_DM | FMOD_TF,	progs_eyes_mdl_FMOD_DM_FMOD_TF);
	lastid = FMod_AddModel ("progs/g_light.mdl",			FMOD_DM | FMOD_TF,	progs_g_light_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_g_light);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_g_light);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_g_light);

	lastid = FMod_AddModel ("progs/g_nail.mdl",			FMOD_DM | FMOD_TF,	progs_g_nail_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_g_nail);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_g_nail);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_g_nail);
	FMod_AddModelAlt(lastid, &mdlhash_pdp_g_nail);

	lastid = FMod_AddModel ("progs/g_nail2.mdl",			FMOD_DM | FMOD_TF,	progs_g_nail2_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_g_nail2);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_g_nail2);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_g_nail2);

	lastid = FMod_AddModel ("progs/g_rock.mdl",			FMOD_DM | FMOD_TF,	progs_g_rock_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_g_rock);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_g_rock);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_g_rock);
	FMod_AddModelAlt(lastid, &mdlhash_pdp_g_rock);

	lastid = FMod_AddModel ("progs/g_rock2.mdl",			FMOD_DM | FMOD_TF,	progs_g_rock2_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_g_rock2);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_g_rock2);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_g_rock2);
	FMod_AddModelAlt(lastid, &mdlhash_pdp_g_rock2);

	lastid = FMod_AddModel ("progs/g_shot.mdl",			FMOD_DM | FMOD_TF,	progs_g_shot_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_g_shot);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_g_shot);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_g_shot);
	FMod_AddModelAlt(lastid, &mdlhash_pdp_g_shot);

	lastid = FMod_AddModel ("progs/gib1.mdl",			FMOD_DM | FMOD_TF,	progs_gib1_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_gib1);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_gib1);

	lastid = FMod_AddModel ("progs/gib2.mdl",			FMOD_DM | FMOD_TF,	progs_gib2_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_gib2);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_gib2);

	lastid = FMod_AddModel ("progs/gib3.mdl",			FMOD_DM | FMOD_TF,	progs_gib3_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_gib3);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_gib3);

	lastid = FMod_AddModel ("progs/grenade.mdl",			FMOD_DM | FMOD_TF,	progs_grenade_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_grenade);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_grenade);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_grenade);
	//FMod_AddModelAlt(lastid, &mdlhash_cpma_grenade);

	lastid = FMod_AddModel ("progs/invisibl.mdl",		FMOD_DM | FMOD_TF,	progs_invisibl_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_invisibl);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_invisibl);

	lastid = FMod_AddModel ("progs/invulner.mdl",		FMOD_DM | FMOD_TF,	progs_invulner_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_invulner);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_invulner);

	lastid = FMod_AddModel ("progs/missile.mdl",			FMOD_DM | FMOD_TF,	progs_missile_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_missile);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_missile);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_missile);

	lastid = FMod_AddModel ("progs/quaddama.mdl",		FMOD_DM | FMOD_TF,	progs_quaddama_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_quaddama);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_quaddama);

	lastid = FMod_AddModel ("progs/s_spike.mdl",			FMOD_DM | FMOD_TF,	progs_s_spike_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_s_spike);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_s_spike);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_s_spike);

	lastid = FMod_AddModel ("progs/spike.mdl",			FMOD_DM | FMOD_TF,	progs_spike_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_debug_spike);
	FMod_AddModelAlt(lastid, &mdlhash_plaguespak_spike);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_spike);

	lastid = FMod_AddModel ("progs/suit.mdl",			FMOD_DM | FMOD_TF,	progs_suit_mdl_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_suit);

	lastid = FMod_AddModel ("progs/player.mdl",			FMOD_DM,			progs_player_mdl_FMOD_DM);
	FMod_AddModelAlt (lastid, &mdlhash_player_mdl_CapNBubs_FMOD_DM);
	FMod_AddModel ("progs/player.mdl",			FMOD_TF,			progs_player_mdl_FMOD_TF);

	FMod_AddModel ("progs/tf_flag.mdl",			FMOD_TF,			progs_tf_flag_mdl_FMOD_TF);
	FMod_AddModel("progs/stag.mdl",				FMOD_TF,			progs_stag_mdl_FMOD_TF);
	FMod_AddModel("progs/basrkey.bsp",			FMOD_TF,			progs_basrkey_bsp_FMOD_TF);
	FMod_AddModel("progs/basbkey.bsp",			FMOD_TF,			progs_basbkey_bsp_FMOD_TF);
	FMod_AddModel("progs/w_s_key.mdl",			FMOD_TF,			progs_w_s_key_mdl_FMOD_TF);
	FMod_AddModel("progs/w_g_key.mdl",			FMOD_TF,			progs_w_g_key_mdl_FMOD_TF);
	FMod_AddModel("progs/b_g_key.mdl",			FMOD_TF,			progs_b_g_key_mdl_FMOD_TF);
	FMod_AddModel("progs/b_s_key.mdl",			FMOD_TF,			progs_b_s_key_mdl_FMOD_TF);
	FMod_AddModel("progs/ff_flag.mdl",			FMOD_TF,			progs_ff_flag_mdl_FMOD_TF);
	FMod_AddModel("progs/harbflag.mdl",			FMOD_TF,			progs_harbflag_mdl_FMOD_TF);
	FMod_AddModel("progs/princess.mdl",			FMOD_TF,			progs_princess_mdl_FMOD_TF);
	FMod_AddModel ("progs/turrbase.mdl",		FMOD_TF,			progs_turrbase_mdl_FMOD_TF);
	FMod_AddModel ("progs/turrgun.mdl",			FMOD_TF,			progs_turrgun_mdl_FMOD_TF);
	FMod_AddModel ("progs/disp.mdl",			FMOD_TF,			progs_disp_mdl_FMOD_TF);
	FMod_AddModel ("progs/tf_stan.mdl",			FMOD_TF,			progs_tf_stan_mdl_FMOD_TF);
	FMod_AddModel ("progs/hgren2.mdl",			FMOD_TF,			progs_hgren2_mdl_FMOD_TF); // gren1
	FMod_AddModel ("progs/grenade2.mdl",		FMOD_TF,			progs_grenade2_mdl_FMOD_TF); // gren2
	FMod_AddModel ("progs/detpack.mdl",			FMOD_TF,			progs_detpack_mdl_FMOD_TF); // detpack

	FMod_AddModel ("progs/s_bubble.spr",		FMOD_DM | FMOD_TF,	progs_s_bubble_spr_FMOD_DM_FMOD_TF);
	FMod_AddModel ("progs/s_explod.spr",		FMOD_DM | FMOD_TF,	progs_s_explod_spr_FMOD_DM_FMOD_TF);

	lastid = FMod_AddModel ("maps/b_bh100.bsp",			FMOD_DM | FMOD_TF,	maps_b_bh100_bsp_FMOD_DM_FMOD_TF);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_b_bh100);
	FMod_AddModelAlt(lastid, &mdlhash_ruohis_b_bh100_other);
	FMod_AddModelAlt(lastid, &mdlhash_generations_b_bh100);

	//Wav files
	lastid = FMod_AddModel ("sound/buttons/airbut1.wav",	FMOD_DM | FMOD_TF,	sound_buttons_airbut1_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_buttons_mindgrid_airbut1);
		FMod_AddModelAlt(lastid, &sound_buttons_rerelease_airbut1);
	lastid = FMod_AddModel ("sound/items/armor1.wav",	FMOD_DM | FMOD_TF,	sound_items_armor1_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_armor1);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_armor1);
	lastid = FMod_AddModel ("sound/items/damage.wav",	FMOD_DM | FMOD_TF,	sound_items_damage_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_damage);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_damage);
	lastid = FMod_AddModel ("sound/items/damage2.wav",	FMOD_DM | FMOD_TF,	sound_items_damage2_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_damage2);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_damage2);
	lastid = FMod_AddModel ("sound/items/damage3.wav",	FMOD_DM | FMOD_TF,	sound_items_damage3_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_damage3);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_damage3);
	lastid = FMod_AddModel ("sound/items/health1.wav",	FMOD_DM | FMOD_TF,	sound_items_health1_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_health1);
	lastid = FMod_AddModel ("sound/items/inv1.wav",		FMOD_DM | FMOD_TF,	sound_items_inv1_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_inv1);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_inv1);
	lastid = FMod_AddModel ("sound/items/inv2.wav",		FMOD_DM | FMOD_TF,	sound_items_inv2_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_inv2);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_inv2);
	lastid = FMod_AddModel ("sound/items/inv3.wav",		FMOD_DM | FMOD_TF,	sound_items_inv3_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_inv3);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_inv3);
	lastid = FMod_AddModel ("sound/items/itembk2.wav",	FMOD_DM | FMOD_TF,	sound_items_itembk2_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_itembk2);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_itembk2);
	lastid = FMod_AddModel ("sound/player/land.wav",		FMOD_DM | FMOD_TF,	sound_player_land_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_player_rerelease_land);
	lastid = FMod_AddModel ("sound/player/land2.wav",	FMOD_DM | FMOD_TF,	sound_player_land2_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_player_rerelease_land2);
	lastid = FMod_AddModel ("sound/misc/outwater.wav",	FMOD_DM | FMOD_TF,	sound_misc_outwater_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_misc_mindgrid_outwater);
		FMod_AddModelAlt(lastid, &sound_misc_rerelease_outwater);
	lastid = FMod_AddModel ("sound/weapons/pkup.wav",	FMOD_DM | FMOD_TF,	sound_weapons_pkup_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_weapons_mindgrid_pkup);
		FMod_AddModelAlt(lastid, &sound_weapons_rerelease_pkup);
	lastid = FMod_AddModel ("sound/player/plyrjmp8.wav",	FMOD_DM | FMOD_TF,	sound_player_plyrjmp8_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_player_mindgrid_plyrjmp8);
		FMod_AddModelAlt(lastid, &sound_player_rerelease_plyrjmp8);
	lastid = FMod_AddModel ("sound/items/protect.wav",	FMOD_DM | FMOD_TF,	sound_items_protect_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_protect);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_protect);
	lastid = FMod_AddModel ("sound/items/protect2.wav",	FMOD_DM | FMOD_TF,	sound_items_protect2_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_protect2);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_protect2);
	lastid = FMod_AddModel ("sound/items/protect3.wav",	FMOD_DM | FMOD_TF,	sound_items_protect3_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_protect3);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_protect3);
	lastid = FMod_AddModel ("sound/items/r_item1.wav",	FMOD_DM | FMOD_TF,	sound_items_r_item1_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_r_item1);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_r_item1);

	lastid = FMod_AddModel ("sound/items/r_item2.wav",	FMOD_DM | FMOD_TF,	sound_items_r_item2_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_items_r_item2_wav_us);
		FMod_AddModelAlt(lastid, &sound_items_r_item2_wav_ru);
		FMod_AddModelAlt(lastid, &sound_items_mindgrid_r_item2);
		FMod_AddModelAlt(lastid, &sound_items_rerelease_r_item2);

	lastid = FMod_AddModel ("sound/misc/water1.wav",		FMOD_DM | FMOD_TF,	sound_misc_water1_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_misc_mindgrid_water1);
		FMod_AddModelAlt(lastid, &sound_misc_rerelease_water1);
	lastid = FMod_AddModel ("sound/misc/water2.wav",		FMOD_DM | FMOD_TF,	sound_misc_water2_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_misc_mindgrid_water2);
		FMod_AddModelAlt(lastid, &sound_misc_rerelease_water2);

	lastid = FMod_AddModel("sound/misc/menu1.wav", FMOD_DM | FMOD_TF, sound_misc_menu1_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_misc_rerelease_menu1);
	lastid = FMod_AddModel("sound/misc/menu2.wav", FMOD_DM | FMOD_TF, sound_misc_menu2_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_misc_rerelease_menu2);
	lastid = FMod_AddModel("sound/misc/menu3.wav", FMOD_DM | FMOD_TF, sound_misc_menu3_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_misc_rerelease_menu3);
	lastid = FMod_AddModel("sound/misc/talk.wav", FMOD_DM | FMOD_TF, sound_misc_talk_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_misc_rerelease_talk);
	lastid = FMod_AddModel("sound/misc/basekey.wav", FMOD_DM | FMOD_TF, sound_misc_basekey_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt (lastid, &sound_gpl_maps_silence_wav);
		FMod_AddModelAlt(lastid, &sound_misc_rerelease_basekey);
	lastid = FMod_AddModel("sound/doors/runeuse.wav", FMOD_DM | FMOD_TF, sound_doors_runeuse_wav_FMOD_DM_FMOD_TF);
		FMod_AddModelAlt(lastid, &sound_doors_rerelease_runeuse);

	FMod_AddModel ("gfx/colormap.lmp",			FMOD_DM | FMOD_TF,	gfx_colormap_lmp_FMOD_DM_FMOD_TF);
	FMod_AddModel ("gfx/palette.lmp",			FMOD_DM | FMOD_TF,	gfx_palette_lmp_FMOD_DM_FMOD_TF);
}

char *FMod_Response_Text(void)
{
	static char buf[512];
	int i, count;
	qbool relevent;

	strlcpy(buf, "modified:", sizeof(buf));

	for (i = count = 0; i < check_models_num; i++) {
		relevent = (cl.teamfortress && (check_models[i].flags & FMOD_TF)) || 
			(!cl.teamfortress && (check_models[i].flags & FMOD_DM));

		if (check_models[i].checked && check_models[i].modified && relevent ) {
			if (strlen (buf) < 240) {
				strlcat (buf, va(" %s", COM_SkipPath (check_models[i].name)), sizeof (buf));
				count++;
			} else {
				strlcat (buf, " & more...", sizeof (buf));
				break;
			}
		}
	}

	if (!count)
		strlcpy (buf, "all models ok", sizeof (buf));
	
	return buf;
}

void FMod_Response (void)
{
	Cbuf_AddText (va ("%s %s\n", cls.state == ca_disconnected ? "echo" : "say", FMod_Response_Text()));
}


================================================
FILE: src/fmod.h
================================================
/*
Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: fmod.h,v 1.3 2007-09-14 13:29:28 disconn3ct Exp $
*/

#ifndef __FMOD_H__
#define __FMOD_H__

void FMod_Init (void);
void FMod_CheckModel (const char *name, const void *buf, const size_t len);
char *FMod_Response_Text(void);
void FMod_Response (void);

#endif /* !__FMOD_H__ */


================================================
FILE: src/fonts.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// fonts.c
#ifdef EZ_FREETYPE_SUPPORT
#include <ft2build.h>
#include FT_FREETYPE_H
#include "pcre2.h"
#endif
#include "quakedef.h"
#include "gl_model.h"
#include "r_texture.h"
#include "fonts.h"
#include "r_renderer.h"
#include "rulesets.h"

#ifdef EZ_FREETYPE_SUPPORT
typedef struct glyphinfo_s {
	float offsets[2];
	int sizes[2];
	float advance[2];
	qbool loaded;
} glyphinfo_t;

#ifdef EZ_FREETYPE_SUPPORT_STATIC
#define ezFT_Init_FreeType   FT_Init_FreeType
#define ezFT_New_Face        FT_New_Face
#define ezFT_Done_FreeType   FT_Done_FreeType
#define ezFT_Set_Pixel_Sizes FT_Set_Pixel_Sizes
#define ezFT_Load_Char       FT_Load_Char
#define ezFT_Render_Glyph    FT_Render_Glyph
#define ezCloseFTDLL(x)
#else
#define ezCloseFTDLL(dll)    if (dll) { Sys_DLClose(dll); }
#endif

static glyphinfo_t glyphs[4096];
static float max_glyph_width;
static float max_num_glyph_width;

#define FONT_TEXTURE_SIZE 1024
charset_t proportional_fonts[MAX_CHARSETS];

int Font_Load(const char* path);
static void OnChange_font_facepath(cvar_t* cvar, char* newvalue, qbool* cancel);

static cvar_t font_facepath                   = { "font_facepath", "", 0, OnChange_font_facepath };
static cvar_t font_capitalize                 = { "font_capitalize", "0" };
static cvar_t font_gradient_normal_color1     = { "font_gradient_normal_color1", "255 255 255", CVAR_COLOR };
static cvar_t font_gradient_normal_color2     = { "font_gradient_normal_color2", "107 98 86", CVAR_COLOR };
static cvar_t font_gradient_normal_percent    = { "font_gradient_normal_percent", "0.2" };
static cvar_t font_gradient_alternate_color1  = { "font_gradient_alternate_color1", "175 120 52", CVAR_COLOR };
static cvar_t font_gradient_alternate_color2  = { "font_gradient_alternate_color2", "75 52 22", CVAR_COLOR };
static cvar_t font_gradient_alternate_percent = { "font_gradient_alternate_percent", "0.4" };
static cvar_t font_gradient_number_color1     = { "font_gradient_number_color1", "255 255 150", CVAR_COLOR };
static cvar_t font_gradient_number_color2     = { "font_gradient_number_color2", "218 132 7", CVAR_COLOR };
static cvar_t font_gradient_number_percent    = { "font_gradient_number_percent", "0.2" };
static cvar_t font_outline                    = { "font_outline_width", "2" };

typedef struct gradient_def_s {
	cvar_t* top_color;
	cvar_t* bottom_color;
	cvar_t* gradient_start;
} gradient_def_t;

static gradient_def_t standard_gradient = { &font_gradient_normal_color1, &font_gradient_normal_color2, &font_gradient_normal_percent };
static gradient_def_t brown_gradient    = { &font_gradient_alternate_color1, &font_gradient_alternate_color2, &font_gradient_alternate_percent };
static gradient_def_t numbers_gradient  = { &font_gradient_number_color1, &font_gradient_number_color2, &font_gradient_number_percent };

static void FontSetColor(byte* color, byte alpha, gradient_def_t* gradient, float relative_y)
{
	float base_color[3];
	float grad_start = bound(0, gradient->gradient_start->value, 1);

	if (relative_y <= grad_start) {
		VectorScale(gradient->top_color->color, 1.0f / 255, base_color);
	}
	else {
		float mix = (relative_y - grad_start) / (1.0f - grad_start);

		VectorScale(gradient->top_color->color, (1.0f - mix) / 255.0f, base_color);
		VectorMA(base_color, mix / 255.0f, gradient->bottom_color->color, base_color);
	}

	color[0] = min(1, base_color[0]) * alpha;
	color[1] = min(1, base_color[1]) * alpha;
	color[2] = min(1, base_color[2]) * alpha;
	color[3] = alpha;
}

// Very simple: boost the alpha of every pixel to strongest alpha nearby
// - small adjustment made for distance
// - not a great solution but works for the moment
// - can supply matrix to freetype, should use that instead
static void SimpleOutline(byte* image_buffer, int base_font_width, int base_font_height)
{
	int x, y;
	int xdiff, ydiff;
	byte* font_buffer = Q_malloc(base_font_width * base_font_height * 4);
	const int search_distance = bound(0, font_outline.integer, 4);

	memcpy(font_buffer, image_buffer, base_font_width * base_font_height * 4);
	for (x = 0; x < base_font_width; ++x) {
		for (y = 0; y < base_font_height; ++y) {
			int base = (x + y * base_font_width) * 4;
			int best_alpha = 0;

			if (font_buffer[base + 3] == 255) {
				continue;
			}

			for (xdiff = max(0, x - search_distance); xdiff <= min(x + search_distance, base_font_width - 1); ++xdiff) {
				for (ydiff = max(0, y - search_distance); ydiff <= min(y + search_distance, base_font_height - 1); ++ydiff) {
					float dist = abs(x - xdiff) + abs(y - ydiff);
					int this_alpha = font_buffer[(xdiff + ydiff * base_font_width) * 4 + 3] / (0.3 * (dist + 1));

					if (this_alpha >= best_alpha) {
						best_alpha = min(255, this_alpha);
					}
				}
			}

			image_buffer[base + 3] = best_alpha;
		}
	}

	Q_free(font_buffer);
}

static void FontLoadBitmap(int ch, FT_Face face, int base_font_width, int base_font_height, byte* image_buffer, gradient_def_t* gradient)
{
	byte* font_buffer;
	int x, y;
	int outline = bound(0, font_outline.integer, 4);

	glyphs[ch].loaded = true;
	glyphs[ch].advance[0] = ((face->glyph->metrics.horiAdvance / 64.0f) + (2 * outline)) / (base_font_width / 2);
	glyphs[ch].advance[1] = ((face->glyph->metrics.vertAdvance / 64.0f) + (2 * outline)) / (base_font_height / 2);
	glyphs[ch].offsets[0] = face->glyph->metrics.horiBearingX / 64.0f - (outline);
	glyphs[ch].offsets[1] = face->glyph->metrics.horiBearingY / 64.0f - (outline);
	glyphs[ch].sizes[0] = face->glyph->bitmap.width;
	glyphs[ch].sizes[1] = face->glyph->bitmap.rows;

	max_glyph_width = max(max_glyph_width, glyphs[ch].advance[0] * 8);
	if ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-') {
		max_num_glyph_width = max(max_num_glyph_width, glyphs[ch].advance[0] * 8);
	}

	font_buffer = face->glyph->bitmap.buffer;
	for (y = 0; y < face->glyph->bitmap.rows && y + outline < base_font_height - 4; ++y, font_buffer += face->glyph->bitmap.pitch) {
		for (x = 0; x < face->glyph->bitmap.width && x + outline < base_font_width - 4; ++x) {
			int base = (x + outline + (y + outline) * base_font_width) * 4;
			byte alpha = font_buffer[x];

			FontSetColor(&image_buffer[base], alpha, gradient, y * 1.0f / face->glyph->bitmap.rows);
		}
	}

	if (outline) {
		SimpleOutline(image_buffer, base_font_width, base_font_height);
	}
}

static void FontClear(int grouping)
{
	charset_t* charset;

	memset(glyphs, 0, sizeof(glyphs));
	max_glyph_width = max_num_glyph_width = 0;

	charset = &proportional_fonts[grouping];
	memset(charset, 0, sizeof(*charset));
}

static qbool FontCreate(int grouping, const char* userpath)
{
	char path[MAX_OSPATH];
	FT_Library library;
	FT_Error error;
	FT_Face face;
	int ch;
	byte* temp_buffer;
	byte* full_buffer;
	int original_width, original_height, original_left, original_top;
	int texture_width, texture_height;
	int base_font_width, base_font_height;
	int baseline_offset;
	charset_t* charset;
	int outline_width = bound(0, font_outline.integer, 4);
#ifndef EZ_FREETYPE_SUPPORT_STATIC
	// freetyped.lib;
	DL_t dll = NULL;
	FT_Error(*ezFT_Init_FreeType)(FT_Library* library) = NULL;
	FT_Error(*ezFT_New_Face)(FT_Library library, const char* filepathname, FT_Long face_index, FT_Face* aface) = NULL;
	FT_Error(*ezFT_Done_FreeType)(FT_Library library) = NULL;
	FT_Error(*ezFT_Set_Pixel_Sizes)(FT_Face face, FT_UInt pixel_width, FT_UInt pixel_height) = NULL;
	FT_Error(*ezFT_Load_Char)(FT_Face face, FT_ULong char_code, FT_Int32 load_flags) = NULL;
	FT_Error(*ezFT_Render_Glyph)(FT_GlyphSlot slot, FT_Render_Mode render_mode) = NULL;

	if (Rulesets_RestrictPacket()) {
		Con_Printf("Cannot change font during match\n");
		return false;
	}

	dll = Sys_DLOpen("freetype.dll");
	if (dll) {
		ezFT_Init_FreeType = Sys_DLProc(dll, "FT_Init_FreeType");
		ezFT_New_Face = Sys_DLProc(dll, "FT_New_Face");
		ezFT_Done_FreeType = Sys_DLProc(dll, "FT_Done_FreeType");
		ezFT_Set_Pixel_Sizes = Sys_DLProc(dll, "FT_Set_Pixel_Sizes");
		ezFT_Load_Char = Sys_DLProc(dll, "FT_Load_Char");
		ezFT_Render_Glyph = Sys_DLProc(dll, "FT_Render_Glyph");
	}

	if (ezFT_Init_FreeType == NULL || ezFT_New_Face == NULL || ezFT_Done_FreeType == NULL ||
		ezFT_Set_Pixel_Sizes == NULL || ezFT_Load_Char == NULL || ezFT_Render_Glyph == NULL) {
		Con_Printf("Unable to load freetype library, proportional fonts not available\n");
		ezCloseFTDLL(dll);
		return false;
	}
#endif

	error = ezFT_Init_FreeType(&library);
	if (error) {
		Con_Printf("Error during freetype initialisation\n");
		ezCloseFTDLL(dll);
		return false;
	}

	strlcpy(path, Sys_FontsDirectory(), sizeof(path));
	strlcat(path, "/", sizeof(path));
	strlcat(path, userpath, sizeof(path));
	COM_DefaultExtension(path, ".ttf", sizeof(path));

	error = ezFT_New_Face(library, path, 0, &face);
	if (error == FT_Err_Unknown_File_Format) {
		Con_Printf("Font file found, but format is unsupported\n");
		ezCloseFTDLL(dll);
		return false;
	}
	else if (error) {
		Con_Printf("Font file could not be opened\n");
		Con_Printf("> Attempted path: %s\n", path);
		ezCloseFTDLL(dll);
		return false;
	}

	charset = &proportional_fonts[grouping];
	if (R_TextureReferenceIsValid(charset->master)) {
		original_width = R_TextureWidth(charset->master);
		original_height = R_TextureHeight(charset->master);
		original_left = 0;
		original_top = 0;
		texture_width = original_width;
		texture_height = original_height;
	}
	else {
		original_width = texture_width = FONT_TEXTURE_SIZE * 2;
		original_height = texture_height = FONT_TEXTURE_SIZE * 2;
		original_left = original_top = 0;

		renderer.TextureCreate2D(&charset->master, texture_width, texture_height, "font", false);
	}
	base_font_width = texture_width / 16;
	base_font_height = texture_height / 16;
	baseline_offset = 0;

	memset(glyphs, 0, sizeof(glyphs));
	max_glyph_width = max_num_glyph_width = 0;

	ezFT_Set_Pixel_Sizes(
		face,
		base_font_width / 2 - 2 * outline_width,
		base_font_height / 2 - 2 * outline_width
	);

	temp_buffer = full_buffer = Q_malloc(4 * base_font_width * base_font_height * 256);
	for (ch = 18; ch < 128; ++ch, temp_buffer += 4 * base_font_width * base_font_height) {
		FT_UInt glyph_index;
		int offset128 = 4 * base_font_width * base_font_height * 128;
		int offsetCaps = 4 * base_font_width * base_font_height * ('a' - 'A');

		if (ch >= 28 && ch < 32) {
			continue;
		}

		if (font_capitalize.integer && ch >= 'a' && ch <= 'z') {
			continue;
		}

		if (ch < 32) {
			glyph_index = ezFT_Load_Char(face, '0' + (ch - 18), FT_LOAD_RENDER);
		}
		else {
			glyph_index = ezFT_Load_Char(face, ch, FT_LOAD_RENDER);
		}

		if (glyph_index) {
			continue;
		}

		error = ezFT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
		if (error) {
			continue;
		}

		if (ch < 32) {
			FontLoadBitmap(ch, face, base_font_width, base_font_height, temp_buffer, &numbers_gradient);
			FontLoadBitmap(ch + 128, face, base_font_width, base_font_height, temp_buffer + offset128, &numbers_gradient);
		}
		else {
			FontLoadBitmap(ch, face, base_font_width, base_font_height, temp_buffer, &standard_gradient);
			FontLoadBitmap(ch + 128, face, base_font_width, base_font_height, temp_buffer + offset128, &brown_gradient);

			if (font_capitalize.integer && ch >= 'A' && ch <= 'Z') {
				FontLoadBitmap(ch + ('a' - 'A'), face, base_font_width, base_font_height, temp_buffer + offsetCaps, &standard_gradient);
				FontLoadBitmap(ch + ('a' - 'A') + 128, face, base_font_width, base_font_height, temp_buffer + offset128 + offsetCaps, &brown_gradient);
			}
		}
	}
	ezFT_Done_FreeType(library);
	ezCloseFTDLL(dll);

	// Work out where the baseline is...
	{
		int max_beneath = 0;
		int beneath_baseline;

		for (ch = 18; ch < 128; ++ch) {
			if (!glyphs[ch].loaded) {
				continue;
			}

			beneath_baseline = glyphs[ch].sizes[1] - glyphs[ch].offsets[1];
			max_beneath = max(max_beneath, beneath_baseline);
		}

		baseline_offset = base_font_height / 2 - 1 - max_beneath - outline_width;
	}

	// Update charset image
	temp_buffer = full_buffer;
	memset(charset->glyphs, 0, sizeof(charset->glyphs));
	for (ch = 18; ch < 256; ++ch, temp_buffer += 4 * base_font_width * base_font_height) {
		int xbase = (ch % 16) * base_font_width;
		int ybase = (ch / 16) * base_font_height;
		int yoffset = max(0, baseline_offset - glyphs[ch].offsets[1]);
		float width = max(base_font_width / 2, glyphs[ch].sizes[0]);
		float height = max(base_font_height / 2, glyphs[ch].sizes[1]);

		if (!glyphs[ch].loaded) {
			continue;
		}

		if (yoffset) {
			memmove(temp_buffer + yoffset * base_font_width * 4, temp_buffer, (base_font_height - yoffset) * base_font_width * 4);
			memset(temp_buffer, 0, yoffset * base_font_width * 4);
		}

		glyphs[ch].offsets[0] /= (base_font_width / 2);
		glyphs[ch].offsets[1] /= (base_font_height / 2);

		charset->glyphs[ch].width = width;
		charset->glyphs[ch].height = height;
		charset->glyphs[ch].sl = (original_left + xbase) * 1.0f / texture_width;
		charset->glyphs[ch].tl = (original_top + ybase) * 1.0f / texture_height;
		charset->glyphs[ch].sh = charset->glyphs[ch].sl + width * 1.0f / texture_width;
		charset->glyphs[ch].th = charset->glyphs[ch].tl + height * 1.0f / texture_height;
		charset->glyphs[ch].texnum = charset->master;

		renderer.TextureReplaceSubImageRGBA(charset->master, original_left + xbase, original_top + ybase, base_font_width, base_font_height, temp_buffer);
	}
	Q_free(full_buffer);
	charset->custom_scale_x = charset->custom_scale_y = 1;

	CachePics_MarkAtlasDirty();

	return true;
}

// Used for allocating space - if we just measure the string then other hud elements
//   might move around as content changes, which is probably not what is wanted
int FontFixedWidth(int max_length, float scale, qbool digits_only, qbool proportional)
{
	if (!proportional || !R_TextureReferenceIsValid(proportional_fonts[0].master)) {
		return max_length * 8 * scale;
	}

	return ceil((digits_only ? max_num_glyph_width : max_glyph_width) * max_length * scale);
}

static void OnChange_font_facepath(cvar_t* cvar, char* newvalue, qbool* cancel)
{
	if (newvalue && !newvalue[0]) {
		FontClear(0);
		*cancel = false;
	}
	else {
		*cancel = !FontCreate(0, Cmd_Argv(1));
	}
}

void Draw_LoadFont_f(void)
{
	switch (Cmd_Argc()) {
	case 1:
		if (font_facepath.string[0]) {
			Com_Printf("Current proportional font is \"%s\"\n", font_facepath.string);
			Com_Printf("To clear, use \"%s none\"\n", Cmd_Argv(0));
		}
		else {
			Com_Printf("No proportional font loaded\n");
		}
		break;
	case 2:
		if (!strcmp(Cmd_Argv(1), "none")) {
			Cvar_Set(&font_facepath, "");
		}
		else {
			Cvar_Set(&font_facepath, Cmd_Argv(1));
		}
		break;
	default:
		Com_Printf("Usage: \"%s <path>\" or \"%s none\"\n", Cmd_Argv(0), Cmd_Argv(0));
		break;
	}
}

// FIXME, should be in client but relies on Sys_listdir
#ifndef CLIENTONLY
void Draw_ListFonts_f(void)
{
	char path[MAX_OSPATH];
	dir_t dir;
	int i, printed;
	pcre2_code* regexp = NULL;
	pcre2_match_data *match_data = NULL;

	strlcpy(path, Sys_FontsDirectory(), sizeof(path));

	if (Cmd_Argc() > 1) {
		int error = 0;
		PCRE2_SIZE error_offset = 0;

		regexp = pcre2_compile((PCRE2_SPTR)Cmd_Argv(1), PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &error, &error_offset, NULL);
		if (!regexp) {
			PCRE2_UCHAR error_str[256];
			pcre2_get_error_message(error, error_str, sizeof(error_str));
			Con_Printf("Error in regular expression: %s\n", error_str);
			return;
		}
	}

	dir = Sys_listdir(path, ".ttf", SORT_BY_NAME);
	for (i = 0, printed = 0; i < dir.numfiles; ++i) {
		if (dir.files[i].isdir) {
			continue;
		}
		if (regexp) {
			match_data = pcre2_match_data_create_from_pattern(regexp, NULL);
			if (pcre2_match(regexp, (PCRE2_SPTR)dir.files[i].name, strlen(dir.files[i].name), 0, 0, match_data, NULL) < 0) {
				pcre2_match_data_free(match_data);
				continue;
			}
			pcre2_match_data_free(match_data);
		}

		Con_Printf("  %s\n", dir.files[i].name);
		printed++;
	}

	if (regexp) {
		pcre2_code_free(regexp);
	}
	Con_Printf("Found %d/%d files in %s\n", printed, dir.numfiles, path);
}
#endif

void FontInitialise(void)
{
	Cmd_AddCommand("fontload", Draw_LoadFont_f);
#ifndef CLIENTONLY // FIXME
	Cmd_AddCommand("fontlist", Draw_ListFonts_f);
#endif

	Cvar_Register(&font_facepath);
	Cvar_Register(&font_capitalize);
	Cvar_Register(&font_gradient_normal_color1);
	Cvar_Register(&font_gradient_normal_color2);
	Cvar_Register(&font_gradient_normal_percent);
	Cvar_Register(&font_gradient_alternate_color1);
	Cvar_Register(&font_gradient_alternate_color2);
	Cvar_Register(&font_gradient_alternate_percent);
	Cvar_Register(&font_gradient_number_color1);
	Cvar_Register(&font_gradient_number_color2);
	Cvar_Register(&font_gradient_number_percent);
	Cvar_Register(&font_outline);
}

#endif // EZ_FREETYPE_SUPPORT

qbool FontAlterCharCoordsWide(float* x, float* y, wchar ch, qbool bigchar, float scale, qbool proportional)
{
	int char_size = (bigchar ? 64 : 8);

	// Totally off screen.
	if (*y <= (-char_size * scale)) {
		return false;
	}

	// Space (& 'red' version).
	if (ch == 32 || ch == (32 | 128)) {
		*x += FontCharacterWidthWide(ch, scale, proportional);
		return false;
	}

#ifdef EZ_FREETYPE_SUPPORT
	if (proportional && ch < sizeof(glyphs) / sizeof(glyphs[0]) && glyphs[ch].loaded) {
		*x += glyphs[ch].offsets[0] * char_size * scale;
	}
#endif

	return true;
}

float FontCharacterWidthWide(wchar ch, float scale, qbool proportional)
{
	int charset = ((ch >> 8) & 0xFF);
	float width = 8 * scale;

#ifdef EZ_FREETYPE_SUPPORT
	if (proportional && ch < sizeof(glyphs) / sizeof(glyphs[0]) && glyphs[ch].loaded) {
		return width * glyphs[ch].advance[0];
	}
#endif

	if (charset >= 0 && charset < sizeof(char_textures) / sizeof(char_textures[0]) && char_textures[charset].custom_scale_x != 0) {
		width *= char_textures[charset].custom_scale_x;
	}

	return width;
}

float FontCharacterWidth(char ch_, float scale, qbool proportional)
{
	int charset = 0;

#ifdef EZ_FREETYPE_SUPPORT
	int ch = (unsigned char)(ch_);

	if (proportional && ch < sizeof(glyphs) / sizeof(glyphs[0]) && glyphs[ch].loaded) {
		return 8 * glyphs[ch].advance[0] * scale;
	}
#endif

	if (charset < 0 || charset >= MAX_CHARSETS || char_textures[charset].custom_scale_x == 0) {
		return 8 * scale;
	}

	return 8 * char_textures[charset].custom_scale_x * scale;
}

void Draw_InitFont(void)
{
#ifdef EZ_FREETYPE_SUPPORT
	if (!font_facepath.string[0]) {
		FontClear(0);
	}
	else {
		FontCreate(0, font_facepath.string);
	}
#endif
}


================================================
FILE: src/fonts.h
================================================

#ifndef EZQUAKE_FONTS_HEADER
#define EZQUAKE_FONTS_HEADER

#ifdef EZ_FREETYPE_SUPPORT
void FontInitialise(void);
int FontFixedWidth(int max_length, float scale, qbool digits_only, qbool proportional);
#else
#define FontFixedWidth(max_length, scale, digits_only, proportional) (max_length * 8.0f * scale)
#endif

qbool FontAlterCharCoordsWide(float* x, float* y, wchar ch, qbool bigchar, float scale, qbool proportional);
float FontCharacterWidthWide(wchar ch, float scale, qbool proportional);
float FontCharacterWidth(char ch, float scale, qbool proportional);

#endif


================================================
FILE: src/fragstats.c
================================================
/*
Copyright (C) 2003       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: fragstats.c,v 1.22 2007-10-04 14:56:55 dkure Exp $
*/

#include "quakedef.h"
#include "vx_stuff.h"
#include "vx_tracker.h"
#include "utils.h"

cvar_t cl_parsefrags = {"cl_parseFrags", "1"};
cvar_t cl_showFragsMessages = {"con_fragmessages", "1"};
cvar_t cl_loadFragfiles = {"cl_loadFragfiles", "1"};

cvar_t cl_useimagesinfraglog = {"cl_useimagesinfraglog", "0"};

#define FUH_FRAGFILE_VERSION_1_00	"1.00" /* for compatibility with fuh */
#define FRAGFILE_VERSION_1_00		"ezquake-1.00" /* fuh suggest such format */

// The following values are fetched from nquake.pk3 and
// misc/fragfile/fragfile.dat respectively.
#define EZQUAKE_SG_QUAD   "&c06fQ&r-sg"
#define EZQUAKE_SSG_QUAD  "&c06fQ&r-ssg"
#define EZQUAKE_SNG_QUAD  "&c06fQ&r-sng"
#define EZQUAKE_RL_QUAD   "&c06fQ&r-rl"
#define EZQUAKE_LG_QUAD   "&c06fQ&r-lg"
#define EZQUAKE_QUAD      "&c06fQ&r-"
#define NQUAKE_SG_QUAD    "sg &c06fQ&r"
#define NQUAKE_SSG_QUAD   "ssg &c06fQ&r"
#define NQUAKE_SNG_QUAD   "sng &c06fQ&r"
#define NQUAKE_RL_QUAD    "rl &c06fQ&r"
#define NQUAKE_LG_QUAD    "lg &c06fQ&r"
#define NQUAKE_QUAD       " &c06fQ&r"
#define WEAPON_CLASS_SG   "sg"
#define WEAPON_CLASS_SSG  "ssg"
#define WEAPON_CLASS_SNG  "sng"
#define WEAPON_CLASS_RL   "rl"
#define WEAPON_CLASS_LG   "lg"

void Update_FlagStatus(int player_num, char *team, qbool got_flag);

typedef enum msgtype_s {
	mt_fragged,
	mt_frags,
	mt_tkills,
	mt_tkilled,

	mt_death,
	mt_suicide,
	mt_frag,
	mt_tkill,
	mt_tkilled_unk,
	mt_flagtouch,
	mt_flagdrop,
	mt_flagcap}
msgtype_t;

typedef struct wclass_s {
	char	*keyword;
	char	*name;
	char	*shortname;
	char	*imagename;
	char    *colorname;
	int     colorname_rgb_offset;
	qbool   colorname_skip;
} wclass_t;

typedef struct fragmsg_s {
	char		*msg1;
	char		*msg2;
	msgtype_t	type;
	int			wclass_index;
} fragmsg_t;

typedef struct fragdef_s {
	qbool	active;
	qbool	flagalerts;

	int			version;
	char		*gamedir;

	char		*title;
	char		*description;
	char		*author;
	char		*email;
	char		*webpage;

	fragmsg_t	*fragmsgs[MAX_FRAG_DEFINITIONS];
	fragmsg_t	msgdata[MAX_FRAG_DEFINITIONS];
	int			num_fragmsgs;
} fragdef_t;

static fragdef_t fragdefs;
static wclass_t wclasses[MAX_WEAPON_CLASSES];
static int num_wclasses;

static int fragmsg1_indexes[26];


#define MYISLOWER(c)	(c >= 'a' && c <= 'z')
int Compare_FragMsg (const void *p1, const void *p2) {
	unsigned char a, b;
	char *s, *s1, *s2;

	s1 = (*((fragmsg_t **) p1))->msg1;
	s2 = (*((fragmsg_t **) p2))->msg1;

	for (s = s1; *s && isspace(*s & 127); s++)
		;
	a = tolower(*s & 127);

	for (s = s2; *s && isspace(*s & 127); s++)
		;
	b = tolower(*s & 127);

	if (MYISLOWER(a) && MYISLOWER(b)) {
		return (a != b) ? a - b : -1 * strcasecmp(s1, s2);
	} else {
		return MYISLOWER(a) ? 1 : MYISLOWER(b) ? -1 : a != b ? a - b : -1 * strcasecmp(s1, s2);
	}
}

static void Build_FragMsg_Indices(void) {
	int i, j = -1, c;
	char *s;

	for (i = 0; i < fragdefs.num_fragmsgs; i++) {
		for (s = fragdefs.fragmsgs[i]->msg1; *s && isspace(*s & 127); s++)
			;
		c = tolower(*s & 127);
		if (!MYISLOWER(c))
			continue;

		if (c == 'a' + j)
			continue;
		while (++j < c - 'a')
			fragmsg1_indexes[j] = -1;

		fragmsg1_indexes[j] = i;
	}

	while (++j <= 'z' - 'a')
		fragmsg1_indexes[j] = -1;
}

static void InitFragDefs(qbool restart)
{
	int i;

	Q_free(fragdefs.gamedir);
	Q_free(fragdefs.title);
	Q_free(fragdefs.author);
	Q_free(fragdefs.email);
	Q_free(fragdefs.webpage);
	Q_free(fragdefs.description);

	for (i = 0; i < fragdefs.num_fragmsgs; i++) 
	{
		Q_free(fragdefs.msgdata[i].msg1);
		Q_free(fragdefs.msgdata[i].msg2);
	}

	for (i = 0; i < num_wclasses; i++) 
	{
		Q_free(wclasses[i].keyword);
		Q_free(wclasses[i].name);
		Q_free(wclasses[i].shortname);
		Q_free(wclasses[i].imagename);

		if (wclasses[i].colorname != NULL)
			Q_free(wclasses[i].colorname);
	}

	memset(&fragdefs, 0, sizeof(fragdefs));
	memset(wclasses, 0, sizeof(wclasses));

	if (restart) {
		wclasses[0].name = Q_strdup("Unknown");
		num_wclasses = 1;
		VX_TrackerInit();
	}
}

#define _checkargs(x)		if (c != x) {																			\
								Com_Printf("Fragfile warning (line %d): %d tokens expected\n", line, x);			\
								goto nextline;																		\
							}

#define _checkargs2(x, y)	if (c != x && c != y) {																	\
								Com_Printf("Fragfile warning (line %d): %d or %d tokens expected\n", line, x, y);	\
								goto nextline;																		\
							}

#define _checkargs3(x, y)	if (c < x || c > y) {																	\
								Com_Printf("Fragfile warning (line %d): %d to %d tokens expected\n", line, x, y);	\
								goto nextline;																		\
							}


#define	_check_version_defined	if (!gotversion) {																				\
									Com_Printf("Fragfile error: #FRAGFILE VERSION must be defined at the head of the file\n");	\
									goto end;																					\
								}

static void LoadFragFile(char *filename, qbool quiet)
{
	int c, line, i;
	msgtype_t msgtype;
	char save, *buffer = NULL, *start, *end, *token, fragfilename[MAX_OSPATH];
	qbool gotversion = false, warned_flagmsg_overflow = false;

	InitFragDefs(true);

	strlcpy(fragfilename, filename, sizeof(fragfilename));
	COM_ForceExtensionEx(fragfilename, ".dat", sizeof(fragfilename));

	// if it fragfile.dat then try to load from ezquake dir first,
	// because we have a bit different fragfile format comparing to fuhquake
	if (!strcasecmp(fragfilename, "fragfile.dat") && (buffer = (char *) FS_LoadHeapFile("../ezquake/fragfile.dat", NULL)))
		strlcpy(fragfilename, "ezquake/fragfile.dat", sizeof(fragfilename));

	if (!buffer && !(buffer = (char *)FS_LoadHeapFile(fragfilename, NULL))) {
		if (!quiet)
			Com_Printf("Couldn't load fragfile \"%s\"\n", fragfilename);
		return;
	}

	line = 1;
	start = end = buffer;
	while (1) {
		for ( ; *end && *end != '\n'; end++)
			;

		save = *end;
		*end = 0;
		Cmd_TokenizeString(start);
		*end = save;

		if (!(c = Cmd_Argc()))
			goto nextline;

		if (!strcasecmp(Cmd_Argv(0), "#FRAGFILE")) {

			_checkargs(3);
			if (!strcasecmp(Cmd_Argv(1), "VERSION")) {
				if (gotversion) {
					Com_Printf("Fragfile error (line %d): VERSION redefined\n", line);
					goto end;
				}
				token = Cmd_Argv(2);
				if (!strcasecmp(token, FUH_FRAGFILE_VERSION_1_00))
					token = FRAGFILE_VERSION_1_00; // so we compatible with old fuh format, because our format include all fuh features + our

				if (!strcasecmp(token, FRAGFILE_VERSION_1_00) && (token = strchr(token, '-'))) {
					token++; // find float component of string like this "ezquake-x.yz"
					fragdefs.version = (int) (100 * Q_atof(token));
					gotversion = true;
				} else {
					Com_Printf("Error: fragfile version (\"%s\") unsupported \n", Cmd_Argv(2));
					goto end;
				}
			} else if (!strcasecmp(Cmd_Argv(1), "GAMEDIR")) {
				_check_version_defined;
				if (!strcasecmp(Cmd_Argv(2), "ANY"))
					fragdefs.gamedir = NULL;
				else
					fragdefs.gamedir = Q_strdup(Cmd_Argv(2));
			} else {
				_check_version_defined;
				Com_Printf("Fragfile warning (line %d): unexpected token \"%s\"\n", line, Cmd_Argv(1));
				goto nextline;
			}
		} else if (!strcasecmp(Cmd_Argv(0), "#META")) {

			_check_version_defined;
			_checkargs(3);
			if (!strcasecmp(Cmd_Argv(1), "TITLE")) {
				fragdefs.title = Q_strdup(Cmd_Argv(2));
			} else if (!strcasecmp(Cmd_Argv(1), "AUTHOR")) {
				fragdefs.author = Q_strdup(Cmd_Argv(2));
			} else if (!strcasecmp(Cmd_Argv(1), "DESCRIPTION")) {
				fragdefs.description = Q_strdup(Cmd_Argv(2));
			} else if (!strcasecmp(Cmd_Argv(1), "EMAIL")) {
				fragdefs.email = Q_strdup(Cmd_Argv(2));
			} else if (!strcasecmp(Cmd_Argv(1), "WEBPAGE")) {
				fragdefs.webpage = Q_strdup(Cmd_Argv(2));
			} else {
				Com_Printf("Fragfile warning (line %d): unexpected token \"%s\"\n", line, Cmd_Argv(1));
				goto nextline;
			}
		} else if (!strcasecmp(Cmd_Argv(0), "#DEFINE")) {
			_check_version_defined;
			if (!strcasecmp(Cmd_Argv(1), "WEAPON_CLASS") || !strcasecmp(Cmd_Argv(1), "WC")) {

				_checkargs3(4, 6);

				token = Cmd_Argv(2);
				if (!strcasecmp(token, "NOWEAPON") || !strcasecmp(token, "NONE") || !strcasecmp(token, "NULL")) {
					Com_Printf("Fragfile warning (line %d): \"%s\" is a reserved keyword\n", line, token);
					goto nextline;
				}
				for (i = 1; i < num_wclasses; i++) {
					if (!strcasecmp(token, wclasses[i].keyword)) {
						Com_Printf("Fragfile warning (line %d): WEAPON_CLASS \"%s\" already defined\n", line, wclasses[i].keyword);
						goto nextline;
					}
				}
				if (num_wclasses == MAX_WEAPON_CLASSES) {
					Com_Printf("Fragfile warning (line %d): only %d WEAPON_CLASS's may be #DEFINE'd\n", line, MAX_WEAPON_CLASSES);
					goto nextline;
				}
				wclasses[num_wclasses].keyword   = Q_strdup(token);
				wclasses[num_wclasses].name      = Q_strdup(Cmd_Argv(3));
				wclasses[num_wclasses].shortname = Q_strdup(Cmd_Argv(4));
				wclasses[num_wclasses].imagename = Q_strdup(Cmd_Argv(5));
				wclasses[num_wclasses].colorname = NULL;
				wclasses[num_wclasses].colorname_rgb_offset = -1;
				wclasses[num_wclasses].colorname_skip = false;

				num_wclasses++;
			} else if (	!strcasecmp(Cmd_Argv(1), "OBITUARY") || !strcasecmp(Cmd_Argv(1), "OBIT")) {

				if (!strcasecmp(Cmd_Argv(2), "PLAYER_DEATH")) {
					_checkargs(5);
					msgtype = mt_death;
				} else if (!strcasecmp(Cmd_Argv(2), "PLAYER_SUICIDE")) {
					_checkargs(5);
					msgtype = mt_suicide;
				} else if (!strcasecmp(Cmd_Argv(2), "X_FRAGS_UNKNOWN")) {
					_checkargs(5);
					msgtype = mt_frag;
				} else if (!strcasecmp(Cmd_Argv(2), "X_TEAMKILLS_UNKNOWN")) {
					_checkargs(5);
					msgtype = mt_tkill;
				} else if (!strcasecmp(Cmd_Argv(2), "X_FRAGS_Y")) {
					_checkargs2(5, 6);
					msgtype = mt_frags;
				} else if (!strcasecmp(Cmd_Argv(2), "X_FRAGGED_BY_Y")) {
					_checkargs2(5, 6);
					msgtype = mt_fragged;
				} else if (!strcasecmp(Cmd_Argv(2), "X_TEAMKILLS_Y")) {
					_checkargs2(5, 6);
					msgtype = mt_tkills;
				} else if (!strcasecmp(Cmd_Argv(2), "X_TEAMKILLED_BY_Y")) {
					_checkargs2(5, 6);
					msgtype = mt_tkilled;
				} else if (!strcasecmp(Cmd_Argv(2), "X_TEAMKILLED_UNKNOWN")) {
					_checkargs(5);
					msgtype = mt_tkilled_unk;
				} else {
					Com_Printf("Fragfile warning (line %d): unexpected token \"%s\"\n", line, Cmd_Argv(2));
					goto nextline;
				}

				if (fragdefs.num_fragmsgs == MAX_FRAG_DEFINITIONS) {
					if (!warned_flagmsg_overflow) {
						Com_Printf("Fragfile warning (line %d): only %d OBITUARY's and FLAG_ALERT's's may be #DEFINE'd\n",
						line, MAX_FRAG_DEFINITIONS);
					}
					warned_flagmsg_overflow = true;
					goto nextline;
				}

				if (strlen(Cmd_Argv(4)) >= MAX_FRAGMSG_LENGTH || (c == 6 && strlen(Cmd_Argv(5)) >= MAX_FRAGMSG_LENGTH)) {
					Com_Printf("Fragfile warning (line %d): Message token cannot exceed %d characters\n", line, MAX_FRAGMSG_LENGTH - 1);
					goto nextline;
				}

				token = Cmd_Argv(3);
				if (!strcasecmp(token, "NOWEAPON") || !strcasecmp(token, "NONE") || !strcasecmp(token, "NULL")) {
					fragdefs.msgdata[fragdefs.num_fragmsgs].wclass_index = 0;
				} else {
					for (i = 1; i < num_wclasses; i++) {
						if (!strcasecmp(token, wclasses[i].keyword)) {
							fragdefs.msgdata[fragdefs.num_fragmsgs].wclass_index = i;
							break;
						}
					}
					if (i == num_wclasses) {
						Com_Printf("Fragfile warning (line %d): \"%s\" is not a defined WEAPON_CLASS\n", line, token);
						goto nextline;
					}
				}

				fragdefs.msgdata[fragdefs.num_fragmsgs].type = msgtype;
				fragdefs.msgdata[fragdefs.num_fragmsgs].msg1 = Q_strdup (Cmd_Argv(4));
				fragdefs.msgdata[fragdefs.num_fragmsgs].msg2 = (c == 6) ? Q_strdup(Cmd_Argv(5)) : NULL;
				fragdefs.num_fragmsgs++;
			} else if (!strcasecmp(Cmd_Argv(1), "FLAG_ALERT") || !strcasecmp(Cmd_Argv(1), "FLAG_MSG")) {

				_checkargs(4);
				if
				(
					!strcasecmp(Cmd_Argv(2), "X_TOUCHES_FLAG") ||
					!strcasecmp(Cmd_Argv(2), "X_GETS_FLAG") ||
					!strcasecmp(Cmd_Argv(2), "X_TAKES_FLAG")
				) {
					msgtype = mt_flagtouch;
				} else if
				(
					!strcasecmp(Cmd_Argv(2), "X_DROPS_FLAG") ||
					!strcasecmp(Cmd_Argv(2), "X_FUMBLES_FLAG") ||
					!strcasecmp(Cmd_Argv(2), "X_LOSES_FLAG")
				) {
					msgtype = mt_flagdrop;
				} else if
				(
					!strcasecmp(Cmd_Argv(2), "X_CAPTURES_FLAG") ||
					!strcasecmp(Cmd_Argv(2), "X_CAPS_FLAG") ||
					!strcasecmp(Cmd_Argv(2), "X_SCORES")
				) {
					msgtype = mt_flagcap;
				} else {
					Com_Printf("Fragfile warning (line %d): unexpected token \"%s\"\n", line, Cmd_Argv(2));
					goto nextline;
				}

				if (fragdefs.num_fragmsgs == MAX_FRAG_DEFINITIONS) {
					if (!warned_flagmsg_overflow) {
						Com_Printf("Fragfile warning (line %d): only %d OBITUARY's and FLAG_ALERT's's may be #DEFINE'd\n",
							line, MAX_FRAG_DEFINITIONS);
					}
					warned_flagmsg_overflow = true;
					goto nextline;
				}
				fragdefs.msgdata[fragdefs.num_fragmsgs].type = msgtype;
				fragdefs.msgdata[fragdefs.num_fragmsgs].msg1 = Q_strdup(Cmd_Argv(3));
				fragdefs.msgdata[fragdefs.num_fragmsgs].msg2 = NULL;
				fragdefs.num_fragmsgs++;

				fragdefs.flagalerts = true;
			}
		} else {
			_check_version_defined;
			Com_Printf("Fragfile warning (line %d): unexpected token \"%s\"\n", line, Cmd_Argv(0));
			goto nextline;
		}

nextline:
		if (!*end)
			break;

		start = end = end + 1;
		line++;
	}

	if (fragdefs.num_fragmsgs) {

		for (i = 0; i < fragdefs.num_fragmsgs; i++)
			fragdefs.fragmsgs[i] = &fragdefs.msgdata[i];
		qsort(fragdefs.fragmsgs, fragdefs.num_fragmsgs, sizeof(fragmsg_t *), Compare_FragMsg);
		Build_FragMsg_Indices();

		fragdefs.active = true;
		if (!quiet)
			Com_Printf("Loaded fragfile \"%s\" (%d frag defs)\n", fragfilename, fragdefs.num_fragmsgs);
		goto end;
	} else {
		if (!quiet)
			Com_Printf("Fragfile \"%s\" was empty\n", fragfilename);
		goto end;
	}

end:
	Q_free(buffer);
	VX_TrackerInit();
}

void Load_FragFile_f(void) {
	switch (Cmd_Argc()) {
		case 2:
			LoadFragFile(Cmd_Argv(1), false);
			break;
		default:
			Com_Printf("Usage: %s <filename>\n", Cmd_Argv(0));
			break;
	}
}


typedef struct fragstats_s {
	int deaths[MAX_CLIENTS];
	int teamdeaths[MAX_CLIENTS];
	int kills[MAX_CLIENTS];
	int teamkills[MAX_CLIENTS];
	int wdeaths[MAX_WEAPON_CLASSES];
	int wkills[MAX_WEAPON_CLASSES];
	//VULT DISPLAY NAMES
	int wsuicides[MAX_WEAPON_CLASSES];
	int streak;

	int totaldeaths;
	int totalfrags;
	int totalteamkills;
	int totalsuicides;

	int touches;
	int fumbles;
	int captures;
} fragstats_t;

static fragstats_t fragstats[MAX_CLIENTS];
static qbool flag_dropped, flag_touched, flag_captured;

static void Stats_ParsePrintLine(const char *s, cfrags_format *cff, int offset) 
{
	int start_search, end_Search, i, j, k, p1len, msg1len, msg2len, p2len, killer, victim;
	fragmsg_t *fragmsg;
	const char *start, *name1, *name2, *t;
	player_info_t *player1 = NULL, *player2 = NULL;

	for (i = 0; i < MAX_CLIENTS; i++) 
	{
		start = s;
		player1 = &cl.players[i];
	
		if (!player1->name[0] || player1->spectator)
			continue;

		name1 = Info_ValueForKey(player1->userinfo, "name");
		p1len = min(strlen(name1), 31);
		
		if (!strncmp(start, name1, p1len)) 
		{
			cff->p1pos = offset;
			cff->p1len = p1len; 
			cff->p1col = player1->topcolor;
			
			for (t = start + p1len; *t && isspace(*t & 127); t++)
				;

			k = tolower(*t & 127);
			
			if (MYISLOWER(k))
			{
				start_search = fragmsg1_indexes[k - 'a'];
				end_Search = (k == 'z') ? fragdefs.num_fragmsgs : fragmsg1_indexes[k - 'a' + 1];
			}
			else 
			{
				start_search = 0;
				end_Search = fragmsg1_indexes[0];
			}

			if (start_search == -1)
				continue;

			if (end_Search == -1)
				end_Search = fragdefs.num_fragmsgs;

			for (j = start_search; j < end_Search; j++) 
			{
				start = s + p1len;
				fragmsg = fragdefs.fragmsgs[j];
				msg1len = strlen(fragmsg->msg1);
				if (!strncmp(start, fragmsg->msg1, msg1len)) 
				{
					if (fragmsg->type == mt_fragged || fragmsg->type == mt_frags ||
						fragmsg->type == mt_tkills || fragmsg->type == mt_tkilled) 
					{
						for (k = 0; k < MAX_CLIENTS; k++) 
						{
							start = s + p1len + msg1len;
							player2 = &cl.players[k];
							
							if (!player2->name[0] || player2->spectator)
								continue;
							
							name2 = Info_ValueForKey(player2->userinfo, "name");
							p2len = min(strlen(name2), 31);
						
							if (!strncmp(start, name2, p2len)) 
							{
								cff->p2pos = start - s + offset;
								cff->p2len = p2len;
								cff->p2col = player2->topcolor;
								
								if (fragmsg->msg2) 
								{
									if (!*(start = s + p1len + msg1len + p2len))
										continue;

									msg2len = strlen(fragmsg->msg2);
									
									if (!strncmp(start, fragmsg->msg2, msg2len))
										goto foundmatch;
								}
								else 
								{
									goto foundmatch;
								}
							}
						}
					}
					else 
					{
						goto foundmatch;
					}
				}
			}
		}
	}

	return;
	
foundmatch:
	i = player1 - cl.players;
	if (player2)
		j = player2 - cl.players;

	switch (fragmsg->type) 
	{
		case mt_death:
		{
			cff->isFragMsg = true;
			fragstats[i].totaldeaths++;
			fragstats[i].wdeaths[fragmsg->wclass_index]++;
			VX_TrackerDeath(i, fragmsg->wclass_index, fragstats[i].wdeaths[fragmsg->wclass_index]);
			VX_TrackerStreakEnd(i, i, fragstats[i].streak);
			fragstats[i].streak=0;
			break;
		}
		case mt_suicide:
		{
			cff->isFragMsg = true;
			fragstats[i].totalsuicides++;
			fragstats[i].totaldeaths++;
			fragstats[i].wsuicides[fragmsg->wclass_index]++;
			VX_TrackerSuicide(i, fragmsg->wclass_index, fragstats[i].wsuicides[fragmsg->wclass_index]);
			VX_TrackerStreakEnd(i, i, fragstats[i].streak);
			fragstats[i].streak=0;
			break;
		}
		case mt_fragged:
		case mt_frags:
		{
			cff->isFragMsg = true;
			killer = (fragmsg->type == mt_fragged) ? j : i;
			victim = (fragmsg->type == mt_fragged) ? i : j;
			CL_Cam_SetKiller(killer,victim);
			fragstats[killer].kills[victim]++;
			fragstats[killer].totalfrags++;
			fragstats[killer].wkills[fragmsg->wclass_index]++;
			fragstats[victim].deaths[killer]++;
			fragstats[victim].totaldeaths++;
			fragstats[victim].wdeaths[fragmsg->wclass_index]++;
			VX_TrackerFragXvsY(victim, killer, fragmsg->wclass_index,
					fragstats[victim].wdeaths[fragmsg->wclass_index], fragstats[killer].wkills[fragmsg->wclass_index]);
			fragstats[killer].streak++;
			VX_TrackerStreak(killer, fragstats[killer].streak);
			VX_TrackerStreakEnd(victim, killer, fragstats[victim].streak);
			fragstats[victim].streak=0;
			break;
		}
		case mt_frag:
		{
			cff->isFragMsg = true;
			fragstats[i].totalfrags++;
			fragstats[i].wkills[fragmsg->wclass_index]++;
			VX_TrackerOddFrag(i, fragmsg->wclass_index, fragstats[i].wkills[fragmsg->wclass_index]);
			fragstats[i].streak++;
			VX_TrackerStreak(i, fragstats[i].streak);
			break;
		}
		case mt_tkilled:
		case mt_tkills:
		{	
			cff->isFragMsg = true;
			killer = (fragmsg->type == mt_tkilled) ? j : i;
			victim = (fragmsg->type == mt_tkilled) ? i : j;
			CL_Cam_SetKiller(killer,victim);

			fragstats[killer].teamkills[victim]++;
			fragstats[killer].totalteamkills++;

			fragstats[victim].teamdeaths[killer]++;
			fragstats[victim].totaldeaths++;

			VX_TrackerTK_XvsY(victim, killer, fragmsg->wclass_index,
						fragstats[killer].totalteamkills, fragstats[victim].teamdeaths[killer],
						fragstats[killer].totalteamkills, fragstats[killer].teamkills[victim]);
			VX_TrackerStreakEnd(victim, killer, fragstats[victim].streak);
			fragstats[victim].streak=0;
			break;
		}
		case mt_tkilled_unk:
		{
			cff->isFragMsg = true;
			fragstats[i].totaldeaths++;
			VX_TrackerOddTeamkilled(i, fragmsg->wclass_index);
			VX_TrackerStreakEndOddTeamkilled(i, fragstats[i].streak);
			fragstats[i].streak=0;
			break;
		}
		case mt_tkill:
		{
			cff->isFragMsg = true;
			fragstats[i].totalteamkills++;
			VX_TrackerOddTeamkill(i, fragmsg->wclass_index, fragstats[i].totalteamkills);
			// not enough data to stop streaks of killed man
			break;
		}
		case mt_flagtouch:
		{
			fragstats[i].touches++;
			Update_FlagStatus(i, player1->team, true);
			if (cl.playernum == i || (i == Cam_TrackNum() && cl.spectator))
				VX_TrackerFlagTouch(fragstats[i].touches);
			flag_touched = true;
			break;
		}
		case mt_flagdrop:
		{		
			fragstats[i].fumbles++;
			Update_FlagStatus(i, player1->team, false);
			if (cl.playernum == i || (i == Cam_TrackNum() && cl.spectator))
				VX_TrackerFlagDrop(fragstats[i].fumbles);
			flag_dropped = true;
			break;
		}
		case mt_flagcap:
		{		
			fragstats[i].captures++;
			Update_FlagStatus(i, player1->team, false);
			if (cl.playernum == i || (i == Cam_TrackNum() && cl.spectator))
				VX_TrackerFlagCapture(fragstats[i].captures);
			flag_captured = true;
			break;
		}
		default:
			break;
	}
}

void Stats_ParsePrint(char *s, int level, cfrags_format *cff) {
	char *start, *end, save;
	int offset = 0;

	if (!Stats_IsActive())
		return;

	if (level != PRINT_MEDIUM && level != PRINT_HIGH)
		return;

	start = end = s;
	while (1) {
		for ( ; *end && *end != '\n'; end++)
			;

		if (*end) {
			end++;
			save = *end;
			*end = 0;
			Stats_ParsePrintLine(start, cff, offset);
			*end = save;
			offset += (end - s);
		} else {
			Stats_ParsePrintLine(start, cff, offset);
			break;
		}

		start = end;
	}
}

void Stats_Reset(void) {
	memset(&fragstats, 0, sizeof(fragstats));
	flag_touched = flag_dropped = flag_captured = false;
}

void Stats_NewMap(void) {
	static char last_gamedir[MAX_OSPATH] = {0};

	if (!last_gamedir[0] || strcasecmp(last_gamedir, cls.gamedirfile)) {
		if (cl_loadFragfiles.value) {
			strlcpy(last_gamedir, cls.gamedirfile, sizeof(last_gamedir));
			LoadFragFile("fragfile", true);
		} else {
			InitFragDefs(true);
		}
	}

	Stats_Reset();
}

void Stats_EnterSlot(int num) {
	int i;

	if (num < 0 || num >= MAX_CLIENTS)
		Sys_Error("Stats_EnterSlot: num < 0 || num >= MAX_CLIENTS");

	memset(&fragstats[num], 0, sizeof(fragstats[num]));

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator)
			continue;
		if (i == num)
			continue;

		fragstats[i].teamdeaths[num] = fragstats[i].deaths[num] = 0;
		fragstats[i].teamkills[num] = fragstats[i].kills[num] = 0;
	}
}


void Stats_GetBasicStats(int num, int *playerstats) {
	if (num < 0 || num >= MAX_CLIENTS)
		Sys_Error("Stats_EnterSlot: num < 0 || num >= MAX_CLIENTS");

	playerstats[0] = fragstats[num].totalfrags;
	playerstats[1] = fragstats[num].totaldeaths;
	playerstats[2] = fragstats[num].totalteamkills;
	playerstats[3] = fragstats[num].totalsuicides;
}

void Stats_GetFlagStats(int num, int *playerstats) {
	if (num < 0 || num >= MAX_CLIENTS)
		Sys_Error("Stats_EnterSlot: num < 0 || num >= MAX_CLIENTS");

	if (!flag_touched && flag_dropped && flag_captured)
		playerstats[0] = fragstats[num].fumbles + fragstats[num].captures;
	else
		playerstats[0] = fragstats[num].touches;

	playerstats[1] = fragstats[num].fumbles;
	playerstats[2] = fragstats[num].captures;
}

qbool Stats_IsActive(void) {
	return (fragdefs.active && cl_parsefrags.value) ? true : false;
}

qbool Stats_IsFlagsParsed(void) {
	return (Stats_IsActive() && fragdefs.flagalerts) ? true : false;
}

void Stats_Init(void) {
	InitFragDefs(true);
	Cvar_SetCurrentGroup(CVAR_GROUP_SBAR);
	Cvar_Register(&cl_parsefrags);
	Cvar_Register(&cl_showFragsMessages);
	Cvar_Register(&cl_loadFragfiles);
	Cvar_Register(&cl_useimagesinfraglog);
	Cvar_ResetCurrentGroup();
	Cmd_AddCommand("loadFragfile", Load_FragFile_f);
}

//VULT DISPLAYNAMES
char *GetWeaponName (int num)
{
	if (cl_useimagesinfraglog.integer && wclasses[num].imagename && wclasses[num].imagename[0])
		return wclasses[num].imagename;

	if (wclasses[num].shortname && wclasses[num].shortname[0])
		return wclasses[num].shortname;

	if (wclasses[num].name && wclasses[num].name[0])
		return wclasses[num].name;

	return "Unknown";
}

static void InitColoredWeapon (int num, const byte *color)
{
	char *original_weapon, *weapon, *prefix = NULL, *suffix = NULL;
	int original_weapon_len = 0, weapon_len = 0, prefix_len = 0;

	original_weapon = GetWeaponName(num);
	original_weapon_len = strlen(original_weapon);

	// Check whether or not the original_weapon is a known string that we
	// need to handle in a specific way.
	//
	// The code supports the ezquake and nquake fragfile.dat values for quad
	// related weapons.
	//
	// We store the offset to 'R' in the "c&RGB" string so that we easily
	// can overwrite the RGB value later on.
	if (strcmp(original_weapon, EZQUAKE_SG_QUAD) == 0) {
		weapon = WEAPON_CLASS_SG;
		prefix = EZQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 11;
	} else if (strcmp(original_weapon, EZQUAKE_SSG_QUAD) == 0) {
		weapon = WEAPON_CLASS_SSG;
		prefix = EZQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 11;
	} else if (strcmp(original_weapon, EZQUAKE_SNG_QUAD) == 0) {
		weapon = WEAPON_CLASS_SNG;
		prefix = EZQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 11;
	} else if (strcmp(original_weapon, EZQUAKE_RL_QUAD) == 0) {
		weapon = WEAPON_CLASS_RL;
		prefix = EZQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 11;
	} else if (strcmp(original_weapon, EZQUAKE_LG_QUAD) == 0) {
		weapon = WEAPON_CLASS_LG;
		prefix = EZQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 11;
	} else if (strcmp(original_weapon, NQUAKE_SG_QUAD) == 0) {
		weapon = WEAPON_CLASS_SG;
		suffix = NQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 2;
	} else if (strcmp(original_weapon, NQUAKE_SSG_QUAD) == 0) {
		weapon = WEAPON_CLASS_SSG;
		suffix = NQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 2;
	} else if (strcmp(original_weapon, NQUAKE_SNG_QUAD) == 0) {
		weapon = WEAPON_CLASS_SNG;
		suffix = NQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 2;
	} else if (strcmp(original_weapon, NQUAKE_RL_QUAD) == 0) {
		weapon = WEAPON_CLASS_RL;
		suffix = NQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 2;
	} else if (strcmp(original_weapon, NQUAKE_LG_QUAD) == 0) {
		weapon = WEAPON_CLASS_LG;
		suffix = NQUAKE_QUAD;
		wclasses[num].colorname_rgb_offset = 2;
	} else if ((strstr(original_weapon, "&c")) == NULL) {
		// No fancy formatting is applied to the weapon.
		weapon = original_weapon;
		wclasses[num].colorname_rgb_offset = 2;
	} else  {
		// This case covers an unknown name that contains a "&c"
		// sequence. These weapon strings will be ignored.
		wclasses[num].colorname_skip = true;
		return;
	}

	// Allocate and initialize the memory for the colored weapon string.
	// We'll use the original weapon length + 8 additional bytes. The 8
	// bytes are for "&cRGB", "&r" and a trailing '\0' character.
	wclasses[num].colorname = Q_malloc(original_weapon_len + 8);
	memset(wclasses[num].colorname, 0, original_weapon_len + 8);

	if (prefix != NULL) {
		prefix_len = strlen(prefix);
		memcpy(wclasses[num].colorname, prefix, prefix_len);
	}

	weapon_len = strlen(weapon);
	memcpy(wclasses[num].colorname + prefix_len, "&cRGB", 5);
	memcpy(wclasses[num].colorname + prefix_len + 5, weapon, weapon_len);
	memcpy(wclasses[num].colorname + prefix_len + 5 + weapon_len, "&r", 2);

	if (suffix != NULL) {
		memcpy(wclasses[num].colorname + prefix_len + 5 + weapon_len + 2, suffix, strlen(suffix));
	}
}

char *GetColoredWeaponName (int num, const byte *color)
{
	char rgb[3];

	if (!wclasses[num].colorname_skip && wclasses[num].colorname == NULL)
		InitColoredWeapon(num, color);

	if (wclasses[num].colorname_skip)
		return GetWeaponName(num);

	// Convert color to string and overwrite the RGB values.
	RGBToString(color, rgb);
	memcpy(wclasses[num].colorname + wclasses[num].colorname_rgb_offset, rgb, 3);

	return wclasses[num].colorname;
}

const char* GetWeaponImageName(int num)
{
	if (wclasses[num].imagename && wclasses[num].imagename[0]) {
		return wclasses[num].imagename;
	}

	return NULL;
}

const char* GetWeaponTextName(int num)
{
	if (wclasses[num].shortname && wclasses[num].shortname[0]) {
		return wclasses[num].shortname;
	}

	if (wclasses[num].name && wclasses[num].name[0]) {
		return wclasses[num].name;
	}

	return NULL;
}

void Stats_Shutdown(void)
{
	InitFragDefs(false);
}


================================================
FILE: src/fs.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: fs.c,v 1.60 2007-10-25 14:06:20 dkure Exp $
*/

/**
  File System related code
  - old Quake FS - declarations in common.h
  - Virtual Quake System - vfs.h
  - GZIP/ZIP support - fs.h
*/

#include "quakedef.h"
#include "common.h"
#include "hash.h"
#include "fs.h"
#include "vfs.h"
#include "utils.h"
#ifdef _WIN32
#include <errno.h>
#else
#include <unistd.h>
#include <strings.h>
#if defined(__APPLE__)
#include <libproc.h>
#elif defined(__FreeBSD__)
#include <sys/sysctl.h>
#endif
#endif

static void FS_RebuildFSHash(void);
#ifdef SERVERONLY
static const char *FS_GetCleanPath(const char *pattern, char *outbuf, int outlen);
#endif
char *com_filesearchpath;

/*
=============================================================================
                        QUAKE FILESYSTEM
=============================================================================
*/

int		fs_filepos;
char	fs_netpath[MAX_OSPATH];

// WARNING: if u add some FS related global variable then made appropriate change to FS_ShutDown() too, if required.

char	com_gamedirfile[MAX_QPATH]; // qw tf ctf and etc. In other words single dir name without path
char	com_gamedir[MAX_OSPATH];    // c:/quake/qw
char	com_basedir[MAX_OSPATH];	// c:/quake
char	com_homedir[MAX_PATH];		// something really long C:/Documents and Settings/qqshka
char	userdirfile[MAX_OSPATH] = {0};
char	com_userdir[MAX_OSPATH] = {0};
int		userdir_type = -1;

searchpath_t	*fs_searchpaths = NULL;
searchpath_t	*fs_base_searchpaths = NULL;	// without gamedirs
searchpath_t	*fs_purepaths;

static int FS_AddPak(char *pathto, char *pakname, searchpath_t *search, searchpathfuncs_t *funcs);
static qbool FS_RemovePak (const char *pakfile);

//============================================================================
#include "q_shared.h"

#ifndef CLIENTONLY
#include "server.h"
#endif // CLIENTONLY

// To include pak3 support add this define
//#define WITH_PK3

hashtable_t *filesystemhash;
qbool filesystemchanged = true;
int fs_hash_dups;
int fs_hash_files;

cvar_t fs_cache = {"fs_cache", "1"};
static cvar_t fs_savegame_home = { "fs_savegame_home", "1" };

static void FS_CreatePathRelative(const char *pname, int relativeto);
void FS_ForceToPure(char *str, const char *crcs, int seed);
int FS_FLocateFile(const char *filename, FSLF_ReturnType_e returntype, flocation_t *loc); 
void FS_EnumerateFiles (char *match, int (*func)(char *, int, void *), void *parm);
int FS_FileOpenRead (char *path, FILE **hndl);
void FS_ReloadPackFiles_f(void);
void FS_ListFiles_f(void);
void FS_FlushFSHash(void);
void FS_AddHomeDirectory(char *dir, FS_Load_File_Types loadstuff);

static void FS_AddDataFiles(char *pathto, searchpath_t *search, char *extension, searchpathfuncs_t *funcs);
static searchpath_t *FS_AddPathHandle(char *probablepath, searchpathfuncs_t *funcs, void *handle, qbool copyprotect, qbool istemporary, FS_Load_File_Types loadstuff);

qbool Sys_PathProtection(const char *pattern);
void FS_Dir_f (void);
void FS_Locate_f (void);

// VFS-FIXME: Debug file for trying to open files
static void FS_DiffFile_f(void);


//============================================================================



/*
================
FS_FileLength
================
*/
int FS_FileLength (FILE *f)
{
	int		pos;
	int		end;

	pos = ftell (f);
	fseek (f, 0, SEEK_END);
	end = ftell (f);
	fseek (f, pos, SEEK_SET);

	return end;
}

/*
================
FS_FileOpenRead
================
*/
int FS_FileOpenRead (char *path, FILE **hndl)
{
	FILE *f;

	if (!(f = fopen(path, "rb"))) {
		*hndl = NULL;
		return -1;
	}
	*hndl = f;

	return FS_FileLength(f);
}

/*
============
FS_Path_f
============
*/
void FS_Path_f (void)
{
	searchpath_t	*search;

	Com_Printf ("Current search path:\n");
	if (fs_purepaths)
	{
		for (search=fs_purepaths ; search ; search=search->nextpure)
		{
			search->funcs->PrintPath(search->handle);
		}
		Com_Printf ("----------\n");
	}


	for (search=fs_searchpaths ; search ; search=search->next)
	{
		if (search == fs_base_searchpaths && !fs_purepaths)
			Com_Printf ("----------\n");

		search->funcs->PrintPath(search->handle);
	}
}


// VFS-FIXME: D-Kure This removes a sanity check
int FS_FCreateFile (char *filename, FILE **file, char *path, char *mode)
{
	char fullpath[MAX_OSPATH];

	if (path == NULL)
		path = com_gamedir;

	if (mode == NULL)
		mode = "wb";

	// try to create
	snprintf(fullpath, sizeof(fullpath), "%s/%s/%s", com_basedir, path, filename);
	FS_CreatePath(fullpath);
	*file = fopen(fullpath, mode);

	if (*file == NULL) {
		// no Sys_Error, quake can be run from read-only media like cd-rom
		return 0;
	}

	Sys_Printf ("FCreateFile: %s\n", filename);

	return 1;
}

//The filename will be prefixed by com_basedir
static qbool FS_WriteFileRelative(const char *filename, const void *data, int len, int relativeto)
{
	vfsfile_t *f;

	FS_CreatePathRelative(filename, relativeto);
	f = FS_OpenVFS(filename, "wb", relativeto);
	if (f) 
	{
		VFS_WRITE(f, data, len);
		VFS_CLOSE(f);
	} else {
		return false;
	}

	filesystemchanged=true;

	return true;
}


/*
============
FS_WriteFile

The filename will be prefixed by the current game directory
============
*/
qbool FS_WriteFile(const char *filename, const void *data, int len)
{
	Sys_Printf ("FS_WriteFile: %s\n", filename);
	return FS_WriteFileRelative(filename, data, len, FS_GAME_OS);
}

//The filename used as is
qbool FS_WriteFile_2(const char *filename, const void *data, int len)
{
	Sys_Printf ("FS_WriteFile_2: %s\n", filename);
	return FS_WriteFileRelative(filename, data, len, FS_NONE_OS);
}

#if 0
FILE *FS_WriteFileOpen (char *filename)	//like fopen, but based around quake's paths.
{
	FILE	*f;
	char	name[MAX_OSPATH];

	snprintf (name, sizeof (name), "%s/%s", com_gamedir, filename);

	FS_CreatePath(name);

	f = fopen (name, "wb");

	return f;
}
#endif

//Only used for CopyFile and download


/*
============
FS_CreatePath

Only used for CopyFile and download
============
*/
void FS_CreatePath(char *path)
{
	char *s, save;

	if (!*path)
		return;

	for (s = path + 1; *s; s++) {
#ifdef _WIN32
		if (*s == '/' || *s == '\\') {
#else
		if (*s == '/') {
#endif
			save = *s;
			*s = 0;
			Sys_mkdir(path);
			*s = save;
		}
	}
}

int FS_FOpenPathFile (const char *filename, FILE **file) {

	*file = NULL;
	fs_filepos = 0;
	fs_netpath[0] = 0;

	if ((*file = fopen (filename, "rb"))) {

		if (developer.value)
			Sys_Printf ("FindFile: %s\n", fs_netpath);

		return FS_FileLength (*file);
	}

	if (developer.value)
		Sys_Printf ("FindFile: can't find %s\n", filename);

	return -1;
}

//Finds the file in the search path.
//Sets fs_netpath and one of handle or file
//Sets fs_filepos to 0 for non paks, and to beging of file in pak file
qbool	file_from_pak;		// global indicating file came from a packfile
qbool	file_from_gamedir;	// global indicating file came from a gamedir (and gamedir wasn't id1/qw)

// VFS-FIXME: D-Kure: This function will be removed once we have the VFS layer

// Filename are relative to the quake directory.
// Always appends a 0 byte to the loaded data.
static byte *FS_LoadFile (const char *path, int usehunk, int *file_length)
{
	vfsfile_t *f = NULL;
	vfserrno_t err;
	flocation_t loc;
	byte *buf;
	char base[32];
	int len;

	// Look for it in the filesystem or pack files.
	//blanket-bans - Avoid combination of / & \ for directories
    if (Sys_PathProtection(path)) 
		return NULL;

	// VFS-FIXME: This only checks the pak files, not the base dir's
    FS_FLocateFile(path, FSLFRT_LENGTH, &loc);
	if (loc.search) {
		f = loc.search->funcs->OpenVFS(loc.search->handle, &loc, "rb");
	} else {
		f = FS_OpenVFS(path, "rb", FS_ANY);
	} 

	if (!f)
		return NULL;
	len = VFS_GETLEN(f);
	if(len == -1) {
		VFS_CLOSE(f);
		return NULL;
	}
	if (file_length)
		*file_length = len;

	// Extract the filename base name for hunk tag.
	COM_FileBase (path, base);

	// TODO: Make these into defines.
	if (usehunk == 1)
	{
		buf = (byte *) Hunk_AllocName (len + 1, base);
	}
	else if (usehunk == 2)
	{
		buf = (byte *) Hunk_TempAlloc (len + 1);
	}
	else if (usehunk == 5)
	{
		buf = Q_malloc_named(len + 1, path);
	}
	else
	{
		Sys_Error ("FS_LoadFile: bad usehunk\n");
		return NULL;
	}

	if (!buf) {
		Sys_Error ("FS_LoadFile: not enough space for %s\n", path);
		return NULL;
	}

	((byte *)buf)[len] = 0;

	Draw_BeginDisc ();

	VFS_READ(f, buf, len, &err);
	VFS_CLOSE(f);

	Draw_EndDisc ();

	return buf;
}

byte *FS_LoadHunkFile (char *path, int *len) {
	return FS_LoadFile (path, 1, len);
}

byte *FS_LoadTempFile (char *path, int *len) {
	return FS_LoadFile (path, 2, len);
}

// use Q_malloc, do not forget Q_free when no needed more
byte *FS_LoadHeapFile (const char *path, int *len)
{
	return FS_LoadFile (path, 5, len);
}

// QW262 -->
/*
================
FS_SetUserDirectory
================
*/
void FS_SetUserDirectory (char *dir, char *type) {
	char tmp[sizeof(com_gamedirfile)];

	if (strstr(dir, "..") || strchr(dir, '/')
	        || strchr(dir, '\\') || strchr(dir, ':') ) {
		Com_Printf ("Userdir should be a single filename, not a path\n");
		return;
	}
	strlcpy(userdirfile, dir, sizeof(userdirfile));
	userdir_type = Q_atoi(type);

	strlcpy(tmp, com_gamedirfile, sizeof(tmp)); // save
	com_gamedirfile[0]='\0'; // force reread
	FS_SetGamedir(tmp, false); // restore
}

// ==========
// FS_AddPak
// ==========
// Return Value:
// 0  - Pak added succesfully
// 1  - File does not exsist
// -1 - Error loading file

static int FS_AddPak(char *pathto, char *pakname, searchpath_t *search, searchpathfuncs_t *funcs) 
{
	vfsfile_t 		*vfs;
	flocation_t 	loc;
	char 			pakfile[MAX_OSPATH];
	void			*handle;
	char 			*ext;

	ext = COM_FileExtension(pakname);
	if (!funcs) {
		if (strcasecmp(ext, "pak") == 0) 
			funcs = &packfilefuncs;
#ifdef WITH_ZIP
		else if (strcasecmp(ext, "pk3") == 0) 
			funcs = &zipfilefuncs;
		else if (strcasecmp(ext, "pk4") == 0) 
			funcs = &zipfilefuncs;
#endif	// WITH_ZIP
#ifdef DOOMWADS
		else if (strcasecmp(ext, "wad") == 0)
			funcs = &doomwadfilefuncs;
#endif
		else 
		{
			Com_Printf("Unknown pak file type");
			return -1;
		}
	}

	/* Check the pak exists */
	if (!search->funcs->FindFile(search->handle, &loc, pakname, NULL))
		return 1;	//not found..

	/* Load the pak file */
	snprintf(pakfile, sizeof(pakfile), "%s%s", pathto, pakname);
	vfs = search->funcs->OpenVFS(search->handle, &loc, "r");
	if (!vfs)
		return -1;
	handle = funcs->OpenNew(vfs, pakfile);
	if (!handle) {
		VFS_CLOSE(vfs);
		return -1;
	}
	snprintf (pakfile, sizeof(pakfile), "%s%s/", pathto, pakname);
	FS_AddPathHandle(pakfile, funcs, handle, true, false, FS_LOAD_FILE_ALL);

	return 0;
}

static qbool FS_RemovePak (const char *pakfile) {
	searchpath_t *cur = fs_searchpaths;
	qbool ret = false;

	while (cur) {
		cur = cur->next;
	}

	return ret;
}

// ==============
// FS_AddUserPaks
// ==============
// Reads the pak.lst from the give directory 
// and adds the given paks 

static void FS_AddUserPaks(char *dir, searchpath_t *parent, FS_Load_File_Types loadstuff) 
{
	FILE	*f;
	char	pakfile[MAX_OSPATH];
	char	userpak[MAX_OSPATH];

	// add paks listed in paks.lst
	snprintf (pakfile, sizeof (pakfile), "%s/pak.lst", dir);
	f = fopen(pakfile, "r");
	if (f) {
		int len;
		while (1) {
			if (!fgets(userpak, MAX_OSPATH, f))
				break;
			len = strlen(userpak);
			// strip endline
			if (userpak[len-1] == '\n') {
				userpak[len-1] = '\0';
				--len;
			}
			if (userpak[len-1] == '\r') {
				userpak[len-1] = '\0';
				--len;
			}
			if (len < 5)
				continue;
			if (!strncasecmp(userpak,"soft",4))
				continue;
			FS_AddPak(dir, userpak, parent, NULL);
		}
		fclose(f);
	}
	// add userdir.pak
	if (UserdirSet) {
		snprintf (pakfile, sizeof (pakfile), "%s.pak", userdirfile);
		FS_AddPak(dir, pakfile, parent, NULL);
#ifdef WITH_ZIP
		snprintf (pakfile, sizeof (pakfile), "%s.pk3", userdirfile);
		FS_AddPak(dir, pakfile, parent, NULL);
#endif // WITH_ZIP
	}
}


// <-- QW262

void FS_AddUserDirectory(char *dir)
{
	size_t dir_len;
	char *malloc_dir;

	if (!UserdirSet) {
		return;
	}

	switch (userdir_type) {
	case 0:	snprintf(com_userdir, sizeof(com_userdir), "%s/%s", com_gamedir, userdirfile); break;
	case 1:	snprintf(com_userdir, sizeof(com_userdir), "%s/%s/%s", com_basedir, userdirfile, dir); break;
	case 2: snprintf(com_userdir, sizeof(com_userdir), "%s/qw/%s/%s", com_basedir, userdirfile, dir); break;
	case 3: snprintf(com_userdir, sizeof(com_userdir), "%s/qw/%s", com_basedir, userdirfile); break;
	case 4: snprintf(com_userdir, sizeof(com_userdir), "%s/%s", com_basedir, userdirfile); break;
	case 5: {
		const char* homedir = Sys_HomeDirectory();
		if (homedir && homedir[0]) {
			snprintf(com_userdir, sizeof(com_userdir), "%s/qw/%s", homedir, userdirfile);
		}
		break;
	}
	default:
		return;
	}

	dir_len = strlen(com_userdir) + 2;
	malloc_dir = Q_malloc(sizeof(char)*dir_len);
	snprintf(malloc_dir, dir_len, "%s/", com_userdir);
	FS_AddPathHandle(com_userdir, &osfilefuncs, malloc_dir, false, false, FS_LOAD_FILE_ALL);
}

void Draw_InitConback(void);

// Sets the gamedir and path to a different directory.
void FS_SetGamedir(char* dir, qbool force)
{
	searchpath_t* next;

	if (dir == NULL || !dir[0]) {
		dir = "qw";
	}

	if (strstr(dir, "..") || strchr(dir, '/') || strchr(dir, '\\') || strchr(dir, ':')) {
		Com_Printf("Gamedir should be a single filename, not a path\n");
		return;
	}

	if (!force && !strcmp(com_gamedirfile, dir)) {
		// Still the same
		return;
	}

	strlcpy(com_gamedirfile, dir, sizeof(com_gamedirfile));

	// Free up any current game dir info.
	FS_FlushFSHash();

	// free up any current game dir info
	while (fs_searchpaths != fs_base_searchpaths)
	{
		fs_searchpaths->funcs->ClosePath(fs_searchpaths->handle);
		next = fs_searchpaths->next;
		Q_free(fs_searchpaths);
		fs_searchpaths = next;
	}

	filesystemchanged = true;

	// Flush all data, so it will be forced to reload.
	Cache_Flush();

	snprintf(com_gamedir, sizeof(com_gamedir), "%s/%s", com_basedir, dir);

	FS_AddGameDirectory(com_gamedir, FS_LOAD_FILE_ALL);
	if (*com_homedir) {
		char tmp[MAX_OSPATH];
		snprintf(&tmp[0], sizeof(tmp), "%s/%s", com_homedir, dir);
		FS_AddHomeDirectory(tmp, FS_LOAD_FILE_ALL);
	}

	// Reload gamedir specific conback as its not flushed
	Draw_InitConback();

	FS_AddUserDirectory(dir);
}

char *FS_NextPath (char *prevpath)
{
	searchpath_t	*s;
	char			*prev;

	if (!prevpath)
		return com_gamedir;

	prev = com_gamedir;
	for (s=fs_searchpaths ; s ; s=s->next)
	{
		if (s->funcs != &osfilefuncs)
			continue;

		if (prevpath == prev)
			return s->handle;
		prev = s->handle;
	}

	return NULL;
}

void FS_ShutDown( void ) {

	// free data
	while (fs_searchpaths)	{
		searchpath_t  *next;
		next = fs_searchpaths->next;
		Q_free (fs_searchpaths);
		fs_searchpaths = next;
	}

	// flush all data, so it will be forced to reload
	Cache_Flush ();

	// reset globals

	fs_base_searchpaths = fs_searchpaths = NULL;

	com_gamedirfile[0]	= 0;
	com_gamedir[0]		= 0;
	com_basedir[0]		= 0;
	com_homedir[0]		= 0;

	userdirfile[0]		= 0;
	com_userdir[0]		= 0;
	userdir_type		= -1;
}

void SysLibrarySupportDir(char *basedir, int length);

void FS_InitFilesystemEx( qbool guess_cwd ) {
	int i;
	char tmp_path[MAX_OSPATH];

	FS_ShutDown();

	if (guess_cwd) { // so, com_basedir directory will be where ezquake*.exe located
#ifndef __APPLE__
		char *e;
#endif

#if defined(_WIN32)
		if(!(i = GetModuleFileName(NULL, com_basedir, sizeof(com_basedir)-1)))
			Sys_Error("FS_InitFilesystemEx: GetModuleFileName failed");
		com_basedir[i] = 0; // ensure null terminator
#elif defined(__linux__)
		if (!Sys_fullpath(com_basedir, "/proc/self/exe", sizeof(com_basedir)))
			Sys_Error("FS_InitFilesystemEx: Sys_fullpath failed");
#elif defined(__APPLE__)
		SysLibrarySupportDir(com_basedir, MAX_OSPATH);
#elif defined(__FreeBSD__)
		int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
		size_t com_basedirlen = sizeof(com_basedir);
		if (sysctl(mib, 4, com_basedir, &com_basedirlen, NULL, 0) < 0)
			Sys_Error("FS_InitFilesystemEx: sysctl failed");
#else
		com_basedir[0] = 0; // FIXME: others
#endif

#ifndef __APPLE__
		// strip ezquake*.exe, we need only path
		for (e = com_basedir+strlen(com_basedir)-1; e >= com_basedir; e--)
			if (*e == '/' || *e == '\\')
			{
				*e = 0;
				break;
			}
#endif
	}
	else if ((i = COM_CheckParm (cmdline_param_filesystem_basedir)) && i < COM_Argc() - 1) {
		// -basedir <path>
		// Overrides the system supplied base directory (under id1)
		strlcpy (com_basedir, COM_Argv(i + 1), sizeof(com_basedir));
	}
 	else { // made com_basedir equa to cwd
//#ifdef __FreeBSD__
//		strlcpy(com_basedir, DATADIR, sizeof(com_basedir) - 1);
//#else

		Sys_getcwd(com_basedir, sizeof(com_basedir) - 1); // FIXME strlcpy (com_basedir, ".", sizeof(com_basedir)); ?
//#endif
	}

	for (i = 0; i < (int) strlen(com_basedir); i++)
		if (com_basedir[i] == '\\')
			com_basedir[i] = '/';

	i = strlen(com_basedir) - 1;
	if (i >= 0 && com_basedir[i] == '/')
		com_basedir[i] = 0;

	strlcpy(com_homedir, Sys_HomeDirectory(), sizeof(com_homedir));

	if (COM_CheckParm(cmdline_param_filesystem_nohome)) {
		com_homedir[0] = 0;
	}

	if (com_homedir[0])
	{
#ifdef _WIN32
		strlcat(com_homedir, "/ezQuake", sizeof(com_homedir));
#else
		strlcat(com_homedir, "/.ezquake", sizeof(com_homedir));
#endif
		Com_Printf("Using home directory \"%s\"\n", com_homedir);
	}

	// start up with id1 by default
	snprintf(&tmp_path[0], sizeof(tmp_path), "%s/%s", com_basedir, "id1");
	if (!COM_FileExists(tmp_path)) {
		// (try upper-case ID1 if it's there... Steam...)
		snprintf(&tmp_path[0], sizeof(tmp_path), "%s/%s", com_basedir, "ID1");
		FS_AddGameDirectory(tmp_path, FS_LOAD_FILE_ALL);
	}
	else {
		FS_AddGameDirectory(tmp_path, FS_LOAD_FILE_ALL);
	}
	snprintf(&tmp_path[0], sizeof(tmp_path), "%s/%s", com_basedir, "ezquake");
	FS_AddGameDirectory(tmp_path, FS_LOAD_FILE_ALL);
	snprintf(&tmp_path[0], sizeof(tmp_path), "%s/%s", com_basedir, "qw");
	FS_AddGameDirectory(tmp_path, FS_LOAD_FILE_ALL);
	if (*com_homedir) {
	    FS_AddHomeDirectory(com_homedir, FS_LOAD_FILE_ALL);
	}

	// -data <datadir>
	// Adds datadirs similar to "-game"
	//
	//Tei: original code from qbism.

	i = 1;
	while((i = COM_CheckParmOffset (cmdline_param_filesystem_data, i))) {
		if (i && i < COM_Argc()-1) {
			char tmp_path[MAX_OSPATH];
			snprintf(&tmp_path[0], sizeof(tmp_path), "%s%s", com_basedir, COM_Argv(i+1)); /* FIXME: No slash?? Intentional?? */
			FS_AddGameDirectory(tmp_path, FS_LOAD_FILE_ALL);
		}
		i++;
	}


	// any set gamedirs will be freed up to here
	fs_base_searchpaths = fs_searchpaths;

	if ((i = COM_CheckParm(cmdline_param_filesystem_userdir)) && i < COM_Argc() - 2)
		FS_SetUserDirectory(COM_Argv(i+1), COM_Argv(i+2));

	// the user might want to override default game directory
	if (!(i = COM_CheckParm (cmdline_param_filesystem_game)))
		i = COM_FindParm("+gamedir");
	if (i && i < COM_Argc() - 1)
		FS_SetGamedir (COM_Argv(i + 1), true);
}

void FS_InitFilesystem( void ) {
	vfsfile_t *vfs;

	FS_InitModuleFS();
	FS_InitFilesystemEx( false ); // first attempt, simplified
	vfs = FS_OpenVFS("gfx.wad", "rb", FS_ANY); 
	if (vfs) { // // we found gfx.wad, seems we have proper com_basedir
		VFS_CLOSE(vfs);
		return;
	}

	FS_InitFilesystemEx( true );  // second attempt
}

// allow user select differet "style" how/where open/save different media files.
// so user select media_dir is relative to quake base dir or some system HOME dir or may be full path
// NOTE: using static buffer, use with care
char *FS_LegacyDir(char *media_dir)
{
	static char dir[MAX_PATH];

	// dir empty, return gamedir
	if (!media_dir || !media_dir[0]) {
		strlcpy(dir, cls.gamedir, sizeof(dir));
		return dir;
	}

	switch (cl_mediaroot.integer) {
		case 1:  //			/home/qqshka/ezquake/<demo_dir>
			while(media_dir[0] == '/' || media_dir[0] == '\\')
				media_dir++; // skip precending / probably smart

			snprintf(dir, sizeof(dir), "%s/%s", com_homedir, media_dir);
			return dir;
		case 2:  //			/fullpath
		  snprintf(dir, sizeof(dir), "%s", media_dir);
			return dir;

		default: //     /basedir/<demo_dir>
			while(media_dir[0] == '/' || media_dir[0] == '\\')
				media_dir++; // skip precending / probably smart

		  snprintf(dir, sizeof(dir), "%s/%s", com_basedir, media_dir);
			return dir;
	}
}


//=============================================================================
// VFS

void VFS_CHECKCALL (struct vfsfile_s *vf, void *fld, char *emsg) {
	if (!fld)
		Sys_Error("%s", emsg);
}

void VFS_CLOSE (struct vfsfile_s *vf) {
	assert(vf);
	VFS_CHECKCALL(vf, vf->Close, "VFS_CLOSE");
	vf->Close(vf);
}

unsigned long VFS_TELL (struct vfsfile_s *vf) {
	assert(vf);
	VFS_CHECKCALL(vf, vf->Tell, "VFS_TELL");
	return vf->Tell(vf);
}

unsigned long VFS_GETLEN (struct vfsfile_s *vf) {
	assert(vf);
	VFS_CHECKCALL(vf, vf->GetLen, "VFS_GETLEN");
	return vf->GetLen(vf);
}

/**
 * VFS_SEEK() reposition a stream
 * If whence is set to SEEK_SET, SEEK_CUR, or SEEK_END, the offset  is
 * relative to the  start of the file, the current position indicator, or
 * end-of-file, respectively.
 * Return Value
 * Upon successful completion, VFS_SEEK(), returns 0. 
 * Otherwise, -1 is returned
 */
int VFS_SEEK (struct vfsfile_s *vf, unsigned long pos, int whence) {
	assert(vf);
	VFS_CHECKCALL(vf, vf->Seek, "VFS_SEEK");
	return vf->Seek(vf, pos, whence);
}

int VFS_READ (struct vfsfile_s *vf, void *buffer, int bytestoread, vfserrno_t *err) {
	assert(vf);
	VFS_CHECKCALL(vf, vf->ReadBytes, "VFS_READ");
	return vf->ReadBytes(vf, buffer, bytestoread, err);
}

// FIXME: bytestowrite should be size_t
int VFS_WRITE (struct vfsfile_s *vf, const void *buffer, int bytestowrite) {
	assert(vf);
	VFS_CHECKCALL(vf, vf->WriteBytes, "VFS_WRITE");
	return vf->WriteBytes(vf, buffer, bytestowrite);
}

void VFS_FLUSH (struct vfsfile_s *vf) {
	assert(vf);
	if(vf->Flush)
		vf->Flush(vf);
}

// return null terminated string
char *VFS_GETS(struct vfsfile_s *vf, char *buffer, int buflen)
{
	char in;
	char *out = buffer;
	int len = buflen-1;

	assert(vf);
	VFS_CHECKCALL(vf, vf->ReadBytes, "VFS_GETS");

//	if (len == 0)
//		return NULL;

// FIXME: I am not sure how to handle this better
	if (len <= 0)
		Sys_Error("VFS_GETS: len <= 0");

	while (len > 0)
	{
		if (!VFS_READ(vf, &in, 1, NULL))
		{
			if (len == buflen-1)
				return NULL;
			*out = '\0';
			return buffer;
		}
		if (in == '\n')
			break;
		*out++ = in;
		len--;
	}
	*out = '\0';

	return buffer;
}

qbool VFS_COPYPROTECTED(struct vfsfile_s *vf) {
	assert(vf);
	return vf->copyprotected;
}

//
// some general function to open VFS file, except VFSTCP
//

/* ================
 * FS_OpenVFS
 * ================
 * This should be how all files are opened, will either give a valid vfsfile_t
 * or NULL. We first check the home directory for the file first, if not found 
 * we try the basedir.
 */
// VFS-XXX: This is very similar to FS_OpenVFS in fs.c
// VFS-FIXME: Clean up this function to reduce the relativeto options 
vfsfile_t *FS_OpenVFS(const char *filename, char *mode, relativeto_t relativeto)
{
	char fullname[MAX_OSPATH];
	flocation_t loc;
	vfsfile_t *vfs = NULL;

	//blanket-bans - Avoid combination of / & \ for directories
	if (Sys_PathProtection(filename)) 
		return NULL;

	if (strcmp(mode, "rb") && strcmp(mode, "wb") && strcmp(mode, "ab")) {
		return NULL; //urm, unable to write/append
	}

	/* General opening of files */
	switch (relativeto)
	{
	case FS_NONE_OS: 	//OS access only, no paks, open file as is
		if (*com_homedir)
		{
			snprintf(fullname, sizeof(fullname), "%s/%s", com_homedir, filename);
			vfs = VFSOS_Open(fullname, mode);
			if (vfs)
				return vfs;
		}

		snprintf(fullname, sizeof(fullname), "%s", filename);
		return VFSOS_Open(fullname, mode);

	case FS_GAME_OS:	//OS access only, no paks
		//sss: check userdir first
		if (*com_userdir) {
			snprintf (fullname, sizeof (fullname), "%s/%s", com_userdir, filename);
			vfs = VFSOS_Open (fullname, mode);
			if (vfs) {
				return vfs;
			}
		}

		if (*com_homedir)
		{
			snprintf(fullname, sizeof(fullname), "%s/%s/%s", com_homedir, com_gamedirfile, filename);
			vfs = VFSOS_Open(fullname, mode);
			if (vfs) {
				return vfs;
			}
		}

		snprintf(fullname, sizeof(fullname), "%s/%s/%s", com_basedir, com_gamedirfile, filename);
		return VFSOS_Open(fullname, mode);

/* VFS-XXX: Removed as we don't really use this
 *	case FS_SKINS:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/qw/skins/%s", com_homedir, filename);
		else
			snprintf(fullname, sizeof(fullname), "%s/qw/skins/%s", com_basedir, filename);
		break;
 */

	case FS_BASE:
//		if (*com_homedir)
//		{
//			snprintf(fullname, sizeof(fullname), "%s/%s", com_homedir, filename);
//			vfs = VFSOS_Open(fullname, mode);
//			if (vfs)
//				return vfs;
//		}
		snprintf(fullname, sizeof(fullname), "%s/%s", com_basedir, filename);
		return VFSOS_Open(fullname, mode);

/* VFS-XXX: Removed as we don't really use this
 * case FS_CONFIGONLY:
		if (*com_homedir)
		{
			snprintf(fullname, sizeof(fullname), "%s/%s", com_homedir, filename);
			vfs = VFSOS_Open(fullname, mode);
			if (vfs)
				return vfs;
		}
		snprintf(fullname, sizeof(fullname), "%s/ezquake/%s", com_basedir, filename);
		return VFSOS_Open(fullname, mode);
 */
	case FS_HOME:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/%s", com_homedir, filename);
		else
			return NULL;
		return VFSOS_Open(fullname, mode);

	case FS_PAK:
		snprintf(fullname, sizeof(fullname), "%s/%s/%s", com_basedir, com_gamedirfile, filename);
		break;

	case FS_ANY:
		vfs = FS_OpenVFS(filename, mode, FS_NONE_OS);
		if (vfs)
			return vfs;

		vfs = FS_OpenVFS(filename, mode, FS_HOME);
		if (vfs)
			return vfs;

		vfs = FS_OpenVFS(filename, mode, FS_GAME_OS);
		if (vfs)
			return vfs;

		return FS_OpenVFS(filename, mode, FS_PAK);

	default:
		Sys_Error("FS_OpenVFS: Bad relative path (%i)", relativeto);
		break;
	}

	FS_FLocateFile(filename, FSLFRT_IFFOUND, &loc);

	if (loc.search)
	{
		return loc.search->funcs->OpenVFS(loc.search->handle, &loc, mode);
		//return VFS_Filter(filename, loc.search->funcs->OpenVFS(loc.search->handle, &loc, mode));
	}

	//if we're meant to be writing, best write to it.
	if (strchr(mode , 'w') || strchr(mode , 'a'))
		return VFSOS_Open(fullname, mode);
	return NULL;
}



// VFS
//======================================================================================================

typedef enum { PAKOP_ADD, PAKOP_REM } pak_operation_t;

static qbool FS_PakOperation(char* pakfile, pak_operation_t op)
{
	switch (op) {
	case PAKOP_REM: return FS_RemovePak(pakfile);
	case PAKOP_ADD: return false; // VFS-FIXME: return FS_AddPak(pakfile);
	}

	return false;
}

static qbool FS_PakOper_NoPath(char* pakfile, pak_operation_t op)
{
	char pathbuf[MAX_PATH];
	
	if (op != PAKOP_REM) // do not allow removing e.g. "pak"
		if (FS_PakOperation(pakfile, op)) return true;

	// This is nonstandard, therefore should be discussed first
	// snprintf(pathbuf, sizeof(pathbuf), "addons/%s.pak", pakfile);
	// if (FS_PakOperation(pathbuf, op)) return true;

	snprintf(pathbuf, sizeof(pathbuf), "ezquake/%s.pak", pakfile);
	if (FS_PakOperation(pathbuf, op)) return true;

	snprintf(pathbuf, sizeof(pathbuf), "qw/%s.pak", pakfile);
	if (FS_PakOperation(pathbuf, op)) return true;

	snprintf(pathbuf, sizeof(pathbuf), "id1/%s.pak", pakfile);
	if (FS_PakOperation(pathbuf, op)) return true;

	return false;
}

static void FS_PakOper_Process(pak_operation_t op)
{
	int i;
	int c = Cmd_Argc();

	if (cls.state != ca_disconnected && !cls.demoplayback && !cls.mvdplayback) {
		Com_Printf("This command cannot be used while connected\n");
		return;
	}
	if (c < 2) {
		Com_Printf("Usage: %s <pakname> [<pakname> [<pakname> ...]\n", Cmd_Argv(0));
		return;
	}

	for (i = 1; i < c; i++)
	{
		if (FS_PakOper_NoPath(Cmd_Argv(i), op)) {
			Com_Printf("Pak %s has been %s\n", Cmd_Argv(i), op == PAKOP_ADD ? "added" : "removed");
			Cache_Flush();
		}
		else Com_Printf("Pak not %s\n", op == PAKOP_ADD ? "added" : "removed");
	}
}

void FS_PakAdd_f(void) { FS_PakOper_Process(PAKOP_ADD); }
void FS_PakRem_f(void) { FS_PakOper_Process(PAKOP_REM); }

#define CHUNK 16384

#ifdef WITH_ZLIB

int FS_GZipPack (char *source_path,
				  char *destination_path,
				  qbool overwrite)
{
	FILE *source			= NULL;
	gzFile gzip_destination = NULL;

	// Open source file.
	source = fopen (source_path, "rb");

	// Failed to open source.
	if (!source_path)
	{
		return 0;
	}

	// Check if the destination file exists and
	// if we're allowed to overwrite it.
	if (COM_FileExists (destination_path) && !overwrite)
	{
		return 0;
	}

	// Create the path for the destination.
	FS_CreatePath (COM_SkipPathWritable (destination_path));

	// Open destination file.
	gzip_destination = gzopen (destination_path, "wb");

	// Failed to open destination.
	if (!gzip_destination)
	{
		return 0;
	}

	// Pack.
	{
		unsigned char inbuf[CHUNK];
		int bytes_read = 0;

		while ((bytes_read = (int)fread (inbuf, 1, (int)sizeof(inbuf), source)) > 0)
		{
			gzwrite (gzip_destination, inbuf, bytes_read);
		}

		fclose (source);
		gzclose (gzip_destination);
	}

	return 1;
}

//
// Unpack a .gz file.
//
int FS_GZipUnpack (char *source_path,		// The path to the compressed source file.
					char *destination_path, // The destination file path.
					qbool overwrite)		// Overwrite the destination file if it exists?
{
	FILE *dest		= NULL;
	int retval		= 0;

	// Check if the destination file exists and
	// if we're allowed to overwrite it.
	if (COM_FileExists(destination_path) && !overwrite) {
		return 0;
	}

	// Create the path for the destination.
	FS_CreatePath(COM_SkipPathWritable(destination_path));

	// Open destination.
	dest = fopen(destination_path, "wb");

	// Failed to open the file for writing.
	if (!dest) {
		return 0;
	}

	// Unpack.
	{
		unsigned char out[CHUNK];
		gzFile gzip_file = gzopen (source_path, "rb");
		if (gzip_file == NULL) {
			fclose(dest);
			Sys_remove(destination_path);
			return 0;
		}

		while ((retval = gzread (gzip_file, out, CHUNK)) > 0) {
			fwrite (out, 1, retval, dest);
		}

		gzclose (gzip_file);
		fclose (dest);
	}

	return 1;
}

#define GZIP_MEMORY_DEFAULT   (4 * 1024 * 1024)
#define GZIP_MEMORY_INCREMENT (2 * 1024 * 1024)

void* FS_GZipUnpackToMemory(char* source_path, size_t* unpacked_length)
{
	byte* memory = NULL;
	size_t actual_length = 0;
	size_t allocated_length = 0;
	gzFile gzip_file;

	gzip_file = gzopen(source_path, "rb");
	if (gzip_file == NULL) {
		return NULL;
	}

	// Unpack.
	memory = Q_malloc_named(GZIP_MEMORY_DEFAULT, source_path);
	allocated_length = GZIP_MEMORY_DEFAULT;
	{
		unsigned char out[CHUNK];
		int retval; // bytes output

		while ((retval = gzread(gzip_file, out, CHUNK)) > 0) {
			if (actual_length + retval > allocated_length) {
				// Need to increase memory buffer
				byte* new_memory = Q_realloc_named(memory, allocated_length + GZIP_MEMORY_INCREMENT, source_path);

				// Failed to reallocate, clean-up and error
				if (new_memory == NULL) {
					gzclose(gzip_file);
					Q_free(memory);
					return NULL;
				}

				// Carry on
				memory = new_memory;
				allocated_length = allocated_length + GZIP_MEMORY_INCREMENT;
			}
			memcpy(memory + actual_length, out, retval);
			actual_length += retval;
		}

		gzclose(gzip_file);

		if (unpacked_length) {
			*unpacked_length = actual_length;
		}
		return memory;
	}
}

//
// Inflates source file into the dest file. (Stolen from a zlib example :D) ... NOT the same as gzip!
//
int FS_ZlibInflate(FILE *source, FILE *dest)
{
	int ret = 0;
	unsigned have = 0;
	z_stream strm;
	unsigned char in[CHUNK];
	unsigned char out[CHUNK];

	// Allocate inflate state.
	strm.zalloc		= Z_NULL;
	strm.zfree		= Z_NULL;
	strm.opaque		= Z_NULL;
	strm.avail_in	= 0;
	strm.next_in	= Z_NULL;
	ret				= inflateInit(&strm);

	if (ret != Z_OK)
	{
		return ret;
	}

	// Decompress until deflate stream ends or end of file.
	do
	{
		strm.avail_in = (int)fread(in, 1, CHUNK, source);

		if (ferror(source))
		{
			(void)inflateEnd(&strm);
			return Z_ERRNO;
		}

		if (strm.avail_in == 0)
		{
			break;
		}

		strm.next_in = in;

		// Run inflate() on input until output buffer not full.
		do
		{
			strm.avail_out = CHUNK;
			strm.next_out = out;
			ret = inflate(&strm, Z_NO_FLUSH);

			// State not clobbered.
			assert(ret != Z_STREAM_ERROR);

			switch (ret)
			{
				case Z_NEED_DICT:
					ret = Z_DATA_ERROR; // Fall through.
				case Z_DATA_ERROR:
				case Z_MEM_ERROR:
					(void)inflateEnd(&strm);
					return ret;
			}

			have = CHUNK - strm.avail_out;

			if (fwrite(out, 1, have, dest) != have || ferror(dest))
			{
				(void)inflateEnd(&strm);
				return Z_ERRNO;
			}
		} while (strm.avail_out == 0);

		// Done when inflate() says it's done
	} while (ret != Z_STREAM_END);

	// Clean up and return.
	(void)inflateEnd(&strm);

	return (ret == Z_STREAM_END) ? Z_OK : Z_DATA_ERROR;
}

//
// Unpack a zlib file. ... NOT the same as gzip!
//
int FS_ZlibUnpack (char *source_path,		// The path to the compressed source file.
					char *destination_path, // The destination file path.
					qbool overwrite)		// Overwrite the destination file if it exists?
{
	FILE *source	= NULL;
	FILE *dest		= NULL;
	int retval		= 0;

	// Open source.
	if (FS_FOpenPathFile (source_path, &source) < 0 || !source)
	{
		return 0;
	}

	// Check if the destination file exists and
	// if we're allowed to overwrite it.
	if (COM_FileExists (destination_path) && !overwrite)
	{
		fclose (source);
		return 0;
	}

	// Create the path for the destination.
	FS_CreatePath (COM_SkipPathWritable (destination_path));

	// Open destination.
	dest = fopen (destination_path, "wb");

	// Failed to open the file for writing.
	if (!dest)
	{
		return 0;
	}

	// Unpack.
	retval = FS_ZlibInflate (source, dest);

	fclose (source);
	fclose (dest);

	return (retval != Z_OK) ? 0 : 1;
}

/*
//
// Unpack a zlib file to a temp file... NOT the same as gzip!
//
int FS_ZlibUnpackToTemp (char *source_path,		// The compressed source file.
						  char *unpack_path,		// A buffer that will contain the path to the unpacked file.
						  int unpack_path_size,		// The size of the buffer.
						  char *append_extension)	// The extension if any that should be appended to the filename.
{
	int retval;
	// Get a unique temp filename.
	if (COM_GetUniqueTempFilename (NULL, unpack_path, unpack_path_size, true) < 0)
	{
		return 0;
	}

	// Delete the existing temp file (it is created when the filename is received above).
	retval = unlink (unpack_path);
	if (retval == -1 && qerrno != ENOENT)
	{
		unpack_path[0] = 0;
		return 0;
	}

	// Append the extension if any.
	if (append_extension != NULL)
	{
		char tmp_path[MAX_OSPATH];
		snprintf(&tmp_path[0], sizeof(tmp_path), "%s%s", unpack_path, append_extension);
		strlcpy (unpack_path, tmp_path, unpack_path_size);
	}

	// Unpack the file.
	if (!FS_ZlibUnpack (source_path, unpack_path, true))
	{
		unpack_path[0] = 0;
		return 0;
	}

	return 1;
}
*/

#endif // WITH_ZLIB

#ifdef WITH_ZIP

#define ZIP_WRITEBUFFERSIZE (8192)

void* FS_ZipUnpackOneFileToMemory(
	unzFile zip_file,
	const char *filename_inzip,
	qbool case_sensitive,
	qbool keep_path,
	const char *password,
	size_t* unpacked_length
)
{
	char			filename[MAX_PATH_LENGTH];
	unz_file_info	file_info;
	byte*           extracted_file = NULL;
	unsigned int    position = 0;

	if (filename_inzip == NULL || zip_file == NULL) {
		return NULL;
	}

	// Locate the file.
	if (unzLocateFile(zip_file, filename_inzip, case_sensitive) != UNZ_OK) {
		return NULL;
	}

	// unzLocateFile has set the current file
	if (unzGetCurrentFileInfo(zip_file, &file_info, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK) {
		return NULL;
	}

	extracted_file = Q_malloc(file_info.uncompressed_size);
	if (extracted_file == NULL) {
		return NULL;
	}
	*unpacked_length = file_info.uncompressed_size;

	//
	// Extract the file.
	//
	{
#define	EXPECTED_BYTES_READ	1
		int	bytes_read = 0;

		//
		// Open the zip file.
		//
		if (unzOpenCurrentFilePassword(zip_file, password) != UNZ_OK) {
			return NULL;
		}

		//
		// Write the decompressed file to the destination.
		//
		do
		{
			if (position >= file_info.uncompressed_size) {
				break;
			}

			// Read the decompressed data from the zip file.
			bytes_read = unzReadCurrentFile(zip_file, extracted_file + position, file_info.uncompressed_size - position);

			if (bytes_read > 0) {
				position += bytes_read;
			}
		} while (bytes_read > 0);

		//
		// Close the zip file
		//
		unzCloseCurrentFile(zip_file);
	}

	return extracted_file;
}

int FS_ZipBreakupArchivePath (char *archive_extension,			// The extension of the archive type we're looking fore "zip" for example.
							   char *path,						// The path that should be broken up into parts.
							   char *archive_path,				// The buffer that should contain the archive path after the breakup.
							   int archive_path_size,			// The size of the archive path buffer.
							   char *inzip_path,				// The buffer that should contain the inzip path after the breakup.
							   int inzip_path_size)				// The size of the inzip path buffer.
{
	char *archive_path_found = NULL;
	char *inzip_path_found = NULL;
	char regexp[MAX_PATH];
	int result_length = 0;

	snprintf(regexp, sizeof(regexp), "(.*?\\.%s)(\\\\|/)(.*)", archive_extension);

	// Get the archive path.
	if (Utils_RegExpGetGroup (regexp, path, (const char **) &archive_path_found, &result_length, 1))
	{
		strlcpy (archive_path, archive_path_found, archive_path_size);

		// Get the path of the demo in the zip.
		if (Utils_RegExpGetGroup (regexp, path, (const char **) &inzip_path_found, &result_length, 3))
		{
			strlcpy (inzip_path, inzip_path_found, inzip_path_size);
			Utils_RegExpFreeSubstring(archive_path_found);
			Utils_RegExpFreeSubstring(inzip_path_found);
			return 1;
		}
	}

	Utils_RegExpFreeSubstring(archive_path_found);
	Utils_RegExpFreeSubstring(inzip_path_found);

	return -1;
}

//
// Does the given path point to a zip file?
//
qbool FS_IsArchive (char *zip_path)
{
	return (!strcasecmp(COM_FileExtension (zip_path), "zip"));
}

unzFile FS_ZipUnpackOpenFile (const char *zip_path)
{
	return unzOpen (zip_path);
}

int FS_ZipUnpackCloseFile (unzFile zip_file)
{
	if (zip_file == NULL)
	{
		return UNZ_OK;
	}

	return unzClose (zip_file);
}

//
// Creates a directory entry from a unzip fileinfo struct.
//
static void FS_ZipMakeDirent (sys_dirent *ent, char *filename_inzip, unz_file_info *unzip_fileinfo)
{
	// Save the name.
    strlcpy(ent->fname, filename_inzip, sizeof(ent->fname));
    ent->fname[MAX_PATH_LENGTH-1] = 0;

	// TODO : Zip size is unsigned long, dir entry unsigned int, data loss possible for really large files.
	ent->size = (unsigned int)unzip_fileinfo->uncompressed_size;

    // Get the filetime.
	ent->time.wYear = unzip_fileinfo->tmu_date.tm_year;
	ent->time.wMonth = unzip_fileinfo->tmu_date.tm_mon + 1;
	ent->time.wDay = unzip_fileinfo->tmu_date.tm_mday;
	ent->time.wHour = unzip_fileinfo->tmu_date.tm_hour;
	ent->time.wMinute = unzip_fileinfo->tmu_date.tm_min;

	// FIXME: There is no directory structure inside of zip files, but the files are named as if there is.
	// that is, if the file is in the root it will be named "file" in the zip file info. If it's in a directory
	// it will be named "dir/file". So we could find out if it's a directory or not by checking the filename here.
	ent->directory = 0;
	ent->hidden = 0;
}

int FS_ZipUnpack(
	unzFile zip_file,
	char *destination_path,
	qbool case_sensitive,
	qbool keep_path,
	qbool overwrite,
	const char *password
)
{
	int error = UNZ_OK;
	unsigned long file_num = 0;
	unz_global_info global_info;

	// Get the number of files in the zip archive.
	error = unzGetGlobalInfo (zip_file, &global_info);

	if (error != UNZ_OK)
	{
		return error;
	}

	for (file_num = 0; file_num < global_info.number_entry; file_num++)
	{
		if (FS_ZipUnpackCurrentFile (zip_file, destination_path, case_sensitive, keep_path, overwrite, password) != UNZ_OK)
		{
			// We failed to extract a file, so there must be something wrong.
			break;
		}

		if ((file_num + 1) < global_info.number_entry)
		{
			error = unzGoToNextFile (zip_file);

			if (error != UNZ_OK)
			{
				// Either we're at the end or something went wrong.
				break;
			}
		}
	}

	return error;
}

int FS_ZipUnpackOneFile (unzFile zip_file,				// The zip file opened with FS_ZipUnpackOpenFile(..)
						  const char *filename_inzip,	// The name of the file to unpack inside the zip.
						  const char *destination_path, // The destination path where to extract the file to.
						  qbool case_sensitive,			// Should we look for the filename case sensitivly?
						  qbool keep_path,				// Should the path inside the zip be preserved when unpacking?
						  qbool overwrite,				// Overwrite any existing file with the same name when unpacking?
						  const char *password)			// The password to use when extracting the file.
{
	int	retval = UNZ_OK;

	if (filename_inzip == NULL || zip_file == NULL)
	{
		return UNZ_ERRNO;
	}

	// Locate the file.
	retval = unzLocateFile (zip_file, filename_inzip, case_sensitive);

	if (retval == UNZ_END_OF_LIST_OF_FILE || retval != UNZ_OK)
	{
		return retval;
	}

	// Unpack the file.
	FS_ZipUnpackCurrentFile (zip_file, destination_path, case_sensitive, keep_path, overwrite, password);

	return retval;
}

int FS_ZipUnpackCurrentFile (unzFile zip_file,
							  const char *destination_path,
							  qbool case_sensitive,
							  qbool keep_path,
							  qbool overwrite,
							  const char *password)
{
	int				error = UNZ_OK;
	void			*buf = NULL;
	unsigned int	size_buf = ZIP_WRITEBUFFERSIZE;
	char			filename[MAX_PATH_LENGTH];
	unz_file_info	file_info;

	// Nothing to extract from.
	if (zip_file == NULL)
	{
		return UNZ_ERRNO;
	}

	// Get the file info (including the filename).
	error = unzGetCurrentFileInfo (zip_file, &file_info, filename, sizeof(filename), NULL, 0, NULL, 0);

	if (error != UNZ_OK)
	{
		goto finish;
	}

	// Should the path in the zip file be preserved when extracting or not?
	if (!keep_path)
	{
		// Only keep the filename.
		strlcpy (filename, COM_SkipPath (filename), sizeof(filename));
	}

	//
	// Check if the file already exists and create the path if needed.
	//
	{
		char tmp_path[MAX_OSPATH];
		snprintf(&tmp_path[0], sizeof(tmp_path), "%s/%s", destination_path, filename);

		// Check if the file exists.
		if (COM_FileExists(tmp_path) && !overwrite) {
			error = UNZ_ERRNO;
			goto finish;
		}

		// Create the destination dir if it doesn't already exist.
		snprintf(&tmp_path[0], sizeof(tmp_path), "%s%s", destination_path, PATH_SEPARATOR);
		FS_CreatePath(tmp_path);

		// Create the relative path before extracting.
		if (keep_path) {
			snprintf(&tmp_path[0], sizeof(tmp_path), "%s%s%s", destination_path, PATH_SEPARATOR, filename);
			FS_CreatePath(tmp_path);
		}
	}

	//
	// Extract the file.
	//
	{
		#define	EXPECTED_BYTES_READ	1
		int	bytes_read	= 0;
		FILE *fout		= NULL;

		error = UNZ_OK;

		//
		// Open the zip file.
		//
		{
			error = unzOpenCurrentFilePassword (zip_file, password);

			// Failed opening the zip file.
			if (error != UNZ_OK)
			{
				goto finish;
			}
		}

		//
		// Open the destination file for writing.
		//
		{
			char tmp_path[MAX_OSPATH];
			snprintf(&tmp_path[0], sizeof(tmp_path), "%s/%s", destination_path, filename);
			fout = fopen(tmp_path, "wb");

			// Failure.
			if (fout == NULL)
			{
				error = UNZ_ERRNO;
				goto finish;
			}
		}

		//
		// Write the decompressed file to the destination.
		//
		buf = Q_malloc (size_buf);
		do
		{
			// Read the decompressed data from the zip file.
			bytes_read = unzReadCurrentFile (zip_file, buf, size_buf);

			if (bytes_read > 0)
			{
				// Write the decompressed data to the destination file.
				if (fwrite (buf, bytes_read, EXPECTED_BYTES_READ, fout) != EXPECTED_BYTES_READ)
				{
					// We failed to write the specified number of bytes.
					error = UNZ_ERRNO;
					fclose (fout);
					unzCloseCurrentFile (zip_file);
					goto finish;
				}
			}
		}
		while (bytes_read > 0);

		//
		// Close the zip file + destination file.
		//
		{
			if (fout)
			{
				fclose (fout);
			}

			unzCloseCurrentFile (zip_file);
		}

		// TODO : Change file date for the file.
	}

finish:
	Q_free (buf);

	return error;
}

// Gets the details about the file and save them in the sys_dirent struct.
static int FS_ZipGetDetails (unzFile zip_file, sys_dirent *ent)
{
	int error = UNZ_OK;
	char filename_inzip[MAX_PATH_LENGTH];
	unz_file_info unzip_fileinfo;

	error = unzGetCurrentFileInfo (zip_file,
		&unzip_fileinfo,						// File info.
		filename_inzip, sizeof(filename_inzip), // The files name will be copied to this.
		NULL, 0, NULL, 0);						// Extras + comment stuff. We don't care about this.

	if (error != UNZ_OK)
	{
		return error;
	}

	// Populate the directory entry object.
	FS_ZipMakeDirent (ent, filename_inzip, &unzip_fileinfo);

	return error;
}

int FS_ZipGetFirst (unzFile zip_file, sys_dirent *ent)
{
	int error = UNZ_OK;

	// Go to the first file in the zip.
	if ((error = unzGoToFirstFile (zip_file)) != UNZ_OK)
	{
		return error;
	}

	// Get details.
	if ((error = FS_ZipGetDetails(zip_file, ent)) != UNZ_OK)
	{
		return error;
	}

	return 1;
}

int FS_ZipGetNextFile (unzFile zip_file, sys_dirent *ent)
{
	int error = UNZ_OK;

	// Get the next file.
	error = unzGoToNextFile (zip_file);

	if (error == UNZ_END_OF_LIST_OF_FILE || error != UNZ_OK)
	{
		return error;
	}

	// Get details.
	if ((error = FS_ZipGetDetails(zip_file, ent)) != UNZ_OK)
	{
		return error;
	}

	return 1;
}

#endif // WITH_ZIP

//============================================================================

void FS_InitModuleFS (void)
{
	Cmd_AddCommand("fs_loadpak", FS_PakAdd_f);
	Cmd_AddLegacyCommand("loadpak", "fs_loadpak");
	Cmd_AddCommand("fs_removepak", FS_PakRem_f);
	Cmd_AddLegacyCommand("removepak", "fs_removepak");
	Cmd_AddCommand("fs_path", FS_Path_f);
	Cmd_AddLegacyCommand("path", "fs_path");
	Cmd_AddCommand("fs_restart", FS_ReloadPackFiles_f);
	Cmd_AddCommand("fs_diff", FS_DiffFile_f); 		// VFS-FIXME <-- Only a debug function
	Cmd_AddCommand("fs_dir", FS_Dir_f);
	Cmd_AddLegacyCommand("dir", "fs_dir");
	Cmd_AddCommand("fs_locate", FS_Locate_f);
	Cmd_AddLegacyCommand("locate", "fs_locate");
	Cmd_AddCommand("fs_search", FS_ListFiles_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_FILESYSTEM);
	Cvar_Register(&fs_cache);
	Cvar_Register(&fs_savegame_home);
	Cvar_ResetCurrentGroup();

	Com_Printf("Initialising quake VFS filesystem\n");
}


/******************************************************************************
 *     TODO:
 ****************************
 * 2) Need to check all the VFS-FIXME's
 * 		D-Kure: I have made comment on the ones I unsure of,
 * 		        others just need the time to do what the comment says.
 *
 * 3) Need to add Sys_EnumerateFiles for sys_mac.c
 * 		D-Kure: I have noooo idea what the mac eqivalent functions are.
 *
 * 4) Replace some of the functions (marked with VFS-XXX) with the ezquake equivlant
 * 		D-Kure: This functions seem to be in common.c and are marked 
 * 		        FS_* instead of COM_*.
 *
 * 9) Renaming of lots of the COM_* functions to FS_*
 *
 ****************************
 *     No particular order
 ****************************
 *  - Add tar.gz support
 *  - Replace zipped/tar/tar.gz demo opening with VFS calls
 *
 *****************************************************************************/

static searchpath_t *FS_AddPathHandle(char *probablepath, searchpathfuncs_t *funcs, void *handle, qbool copyprotect, qbool istemporary, FS_Load_File_Types loadstuff)
{
	searchpath_t *search;

	search = (searchpath_t*)Q_malloc (sizeof(searchpath_t));
	search->copyprotected = copyprotect;
	search->istemporary = istemporary;
	search->handle = handle;
	search->funcs = funcs;

	search->next = fs_searchpaths;
	fs_searchpaths = search;

	filesystemchanged = true;

	//add any data files too
	if (loadstuff & FS_LOAD_FILE_PAK)
		FS_AddDataFiles(probablepath, search, "pak", &packfilefuncs);//q1/hl/h2/q2
	//pk2s never existed.
#ifdef WITH_ZIP
	if (loadstuff & FS_LOAD_FILE_PK3)
		FS_AddDataFiles(probablepath, search, "pk3", &zipfilefuncs);	//q3 + offspring
	if (loadstuff & FS_LOAD_FILE_PK4)
		FS_AddDataFiles(probablepath, search, "pk4", &zipfilefuncs);	//q4
	//we could easily add zip, but it's friendlier not to
#endif

#ifdef DOOMWADS
	if (loadstuff & FS_LOAD_FILE_DOOMWAD)
		FS_AddDataFiles(probablepath, search, "wad", &doomwadfilefuncs);	//q4
#endif
	if (loadstuff & FS_LOAD_FROM_PAKLST)
		FS_AddUserPaks(probablepath, search, loadstuff);

	return search;
}

/*
============
FS_Dir_f
============
*/
#define FS_DIR_HIDE_DIRECTORY 1
#define FS_DIR_HIDE_EXTENSION 2
#define FS_DIR_HIDE_SIZE      4

static int FS_Dir_List(char *name, int size, void *parm)
{
	char filename[MAX_QPATH];
	int options = (int)(intptr_t)parm;

	if (options & FS_DIR_HIDE_DIRECTORY) {
		name = COM_SkipPathWritable(name);
	}

	if (options & FS_DIR_HIDE_EXTENSION) {
		COM_StripExtension(name, filename, sizeof(filename));
		name = filename;
	}

	if (name && name[0]) {
		if (options & FS_DIR_HIDE_SIZE) {
			Com_Printf("%s\n", name);
		}
		else {
			Com_Printf("%s  (%i)\n", name, size);
		}
	}
	return 1;
}

void FS_Dir_f(void)
{
	char match[MAX_QPATH];
	int options = 0;

	if (Cmd_Argc() == 1) {
		Com_Printf("Usage: %s [directory [file_suffix [options]]]\n", Cmd_Argv(0));
		Com_Printf("Options: hideext, hidedir, hidesize\n");
		return;
	}

	strlcpy(match, Cmd_Argv(1), sizeof(match));

	if (Cmd_Argc() > 2 && Cmd_Argv(2)[0]) {
		strlcat(match, "/*.", sizeof(match));
		strlcat(match, Cmd_Argv(2), sizeof(match));
	}
	else {
		strlcat(match, "/*", sizeof(match));
	}

	if (Cmd_Argc() > 3) {
		int i;
		for (i = 3; i < Cmd_Argc(); ++i) {
			if (!strcmp(Cmd_Argv(i), "hidedir")) {
				options |= FS_DIR_HIDE_DIRECTORY;
			}
			else if (!strcmp(Cmd_Argv(i), "hideext")) {
				options |= FS_DIR_HIDE_EXTENSION;
			}
			else if (!strcmp(Cmd_Argv(i), "hidesize")) {
				options |= FS_DIR_HIDE_SIZE;
			}
		}
	}

	FS_EnumerateFiles(match, FS_Dir_List, (void*)(intptr_t)options);
}

/*
============
FS_Locate_f
============
*/
char * FS_Locate_GetPath (const char *file);
void FS_Locate_f (void)
{
	flocation_t loc;
	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: %s filename\n", Cmd_Argv(0));
		return;
	}

	if (FS_FLocateFile(Cmd_Argv(1), FSLFRT_LENGTH, &loc)>=0)
	{
		if (!*loc.rawname)
		{
			Com_Printf("File is compressed inside ");
			loc.search->funcs->PrintPath(loc.search->handle);
		}
		else
		{
			Com_Printf("Inside %s\n", loc.rawname);
			loc.search->funcs->PrintPath(loc.search->handle);
		}
	}
	else
		Com_Printf("Not found\n");
}

char * FS_Locate_GetPath (const char *file)
{
	flocation_t loc;
	if (FS_FLocateFile(file, FSLFRT_LENGTH, &loc)>=0)
	{	//loc.search->funcs->PrintPath(loc.search->handle);
		return (char *) loc.search->handle;
	}
	else
	{
		return "";
	}
}

int fs_hash_dups;
int fs_hash_files;

void FS_FlushFSHash(void)
{
	if (filesystemhash)
	{
		Hash_Flush(filesystemhash);
	}

	filesystemchanged = true;
}

void FS_RebuildFSHash(void)
{
	searchpath_t	*search;
	if (!filesystemhash)
	{
		filesystemhash = Hash_InitTable(1024);
	}
	else
	{
		FS_FlushFSHash();
	}

	fs_hash_dups = 0;
	fs_hash_files = 0;

	if (fs_purepaths)
	{	
		// Go for the pure paths first.
		for (search = fs_purepaths; search; search = search->nextpure)
		{
			search->funcs->BuildHash(search->handle);
		}
	}
	for (search = fs_searchpaths ; search ; search = search->next)
	{
		search->funcs->BuildHash(search->handle);
	}

	filesystemchanged = false;

	Com_DPrintf("%i unique files, %i duplicates\n", fs_hash_files, fs_hash_dups);
}

/*
============
FS_FLocateFile

Finds the file in the search path.
Look FSLF_ReturnType_e definition so you know that it returns.
============
*/
int FS_FLocateFile(const char *filename, FSLF_ReturnType_e returntype, flocation_t *loc)
{
	int             depth = 0;
	int             len;
	searchpath_t    *search;
#ifdef SERVERONLY
	char            cleanpath[MAX_OSPATH];
#endif
	void            *pf = NULL;

#ifdef SERVERONLY
	filename = FS_GetCleanPath(filename, cleanpath, sizeof(cleanpath));
	if (!filename) {
		goto fail;
	}
#endif

	if (fs_cache.value) {
		if (filesystemchanged) {
			FS_RebuildFSHash();
		}
		pf = Hash_GetInsensitive(filesystemhash, filename);
		if (!pf) {
			goto fail;
		}
	}

#ifndef SERVERONLY
	if (fs_purepaths) {
		for (search = fs_purepaths; search; search = search->nextpure) {
			if (search->funcs->FindFile(search->handle, loc, filename, pf)) {
				if (loc) {
					loc->search = search;
					len = loc->len;
				}
				else {
					len = 0;
				}
				goto out;
			}
			depth += (search->funcs != &osfilefuncs || returntype == FSLFRT_DEPTH_ANYPATH);
		}
	}
#endif

	//
	// search through the path, one element at a time.
	//
	for (search = fs_searchpaths; search; search = search->next) {
		if (search->funcs->FindFile(search->handle, loc, filename, pf)) {
			if (loc) {
				loc->search = search;
				len = loc->len;
			}
			else {
				len = 0;
			}

			goto out;
		}

		depth += (search->funcs == &osfilefuncs || returntype == FSLFRT_DEPTH_ANYPATH);
	}

fail:
	if (loc)
		loc->search = NULL;
	depth = 0x7fffffff; // NOTE: weird, we return it on fail in some cases, may cause mistakes by user.
	len = -1;

out:
	if (returntype == FSLFRT_IFFOUND) {
		return len != -1;
	}
	else if (returntype == FSLFRT_LENGTH) {
		return len;
	}
	else {
		return depth;
	}
}

char *FS_GetPackHashes(char *buffer, int buffersize, qbool referencedonly)
{
	searchpath_t	*search;
	buffersize--;
	*buffer = 0;

	if (fs_purepaths)
	{
		for (search = fs_purepaths ; search ; search = search->nextpure)
		{
			char tmp[64];
			snprintf(&tmp[0], sizeof(tmp), "%i ", search->crc_check);
			strlcat(buffer, tmp, buffersize);
		}
		return buffer;
	}
	else
	{
		for (search = fs_searchpaths ; search ; search = search->next)
		{
			if (!search->crc_check && search->funcs->GeneratePureCRC)
				search->crc_check = search->funcs->GeneratePureCRC(search->handle, 0, 0);
			if (search->crc_check)
			{
				char tmp[64];
				snprintf(&tmp[0], sizeof(tmp), "%i ", search->crc_check);
				strlcat(buffer, tmp, buffersize);
			}
		}
		return buffer;
	}
}
char *FS_GetPackNames(char *buffer, int buffersize, qbool referencedonly)
{
	return "";
}


//true if protection kicks in
qbool Sys_PathProtection(const char *pattern)
{
	if (strchr(pattern, '\\'))
	{
		char *s;
		//Com_Printf("Warning: \\ charactures in filename %s\n", pattern);
		while((s = strchr(pattern, '\\')))
			*s = '/';
	}

	return false; // Ignore the stuff below so we always succed

/*	if (strstr(pattern, ".."))
		Com_Printf("Error: '..' charactures in filename %s\n", pattern);
	else if (pattern[0] == '/')
		Com_Printf("Error: absolute path in filename %s\n", pattern);
	else if (strstr(pattern, ":")) //win32 drive seperator (or mac path seperator, but / works there and they're used to it)
		Com_Printf("Error: absolute path in filename %s\n", pattern);
	else
		return false;
	return true;*/
}

#ifdef WITH_ZIP
typedef struct {
	unsigned char ident1;
	unsigned char ident2;
	unsigned char cm;
	unsigned char flags;
	unsigned int mtime;
	unsigned char xflags;
	unsigned char os;
} gzheader_t;
#define sizeofgzheader_t 10

#define	GZ_FTEXT	1
#define	GZ_FHCRC	2
#define GZ_FEXTRA	4
#define GZ_FNAME	8
#define GZ_FCOMMENT	16
#define GZ_RESERVED (32|64|128)

#include <zlib.h>

vfsfile_t *FS_DecompressGZip(vfsfile_t *infile, gzheader_t *header)
{
	char inchar;
	unsigned short inshort;
	vfsfile_t *temp;
	vfserrno_t err;

	if (header->flags & GZ_RESERVED)
	{	//reserved bits should be 0
		//this is probably static, so it's not a gz. doh.
		VFS_SEEK(infile, 0, SEEK_SET);
		return infile;
	}

	if (header->flags & GZ_FEXTRA)
	{
		VFS_READ(infile, &inshort, sizeof(inshort), &err);
		inshort = LittleShort(inshort);
		VFS_SEEK(infile, VFS_TELL(infile) + inshort, SEEK_SET);
	}

	if (header->flags & GZ_FNAME)
	{
		Com_Printf("gzipped file name: ");
		do {
			if (VFS_READ(infile, &inchar, sizeof(inchar), &err) != 1)
				break;
			Com_Printf("%c", inchar);
		} while(inchar);
		Com_Printf("\n");
	}

	if (header->flags & GZ_FCOMMENT)
	{
		Com_Printf("gzipped file comment: ");
		do {
			if (VFS_READ(infile, &inchar, sizeof(inchar), &err) != 1)
				break;
			Com_Printf("%c", inchar);
		} while(inchar);
		Com_Printf("\n");
	}

	if (header->flags & GZ_FHCRC)
	{
		VFS_READ(infile, &inshort, sizeof(inshort), &err);
	}



	temp = FS_OpenTemp();
	if (!temp)
	{
		VFS_SEEK(infile, 0, SEEK_SET);	//doh
		return infile;
	}


	{
		Bytef inbuffer[16384];
		Bytef outbuffer[16384];
		int ret;

		z_stream strm = {
			inbuffer,
			0,
			0,

			outbuffer,
			sizeof(outbuffer),
			0,

			NULL,
			NULL,

			NULL,
			NULL,
			NULL,

			Z_UNKNOWN,
			0,
			0
		};

		strm.avail_in = VFS_READ(infile, inbuffer, sizeof(inbuffer), &err);
		strm.next_in = inbuffer;

		inflateInit2(&strm, -MAX_WBITS);

		while ((ret=inflate(&strm, Z_SYNC_FLUSH)) != Z_STREAM_END)
		{
			if (strm.avail_in == 0 || strm.avail_out == 0)
			{
				if (strm.avail_in == 0)
				{
					strm.avail_in = VFS_READ(infile, inbuffer, sizeof(inbuffer), &err);
					strm.next_in = inbuffer;
				}

				if (strm.avail_out == 0)
				{
					strm.next_out = outbuffer;
					VFS_WRITE(temp, outbuffer, strm.total_out);
					strm.total_out = 0;
					strm.avail_out = sizeof(outbuffer);
				}
				continue;
			}

			//doh, it terminated for no reason
			inflateEnd(&strm);
			if (ret != Z_STREAM_END)
			{
				Com_Printf("Couldn't decompress gz file\n");
				VFS_CLOSE(temp);
				VFS_CLOSE(infile);
				return NULL;
			}
		}
		//we got to the end
		VFS_WRITE(temp, outbuffer, strm.total_out);

		inflateEnd(&strm);

		VFS_SEEK(temp, 0, SEEK_SET);
	}
	VFS_CLOSE(infile);

	return temp;
}
#endif

vfsfile_t *VFS_Filter(const char *filename, vfsfile_t *handle)
{
#ifdef WITH_ZIP
	vfserrno_t err;
	char *ext;

	if (!handle || handle->WriteBytes || handle->seekingisabadplan)	//only on readonly files
		return handle;

	ext = COM_FileExtension(filename);
	if (!strcasecmp(ext, "gz"))
	{
		gzheader_t gzh;
		if (VFS_READ(handle, &gzh, sizeofgzheader_t, &err) == sizeofgzheader_t)
		{
			if (gzh.ident1 == 0x1f && gzh.ident2 == 0x8b && gzh.cm == 8)
			{	//it'll do
				return FS_DecompressGZip(handle, &gzh);
			}
		}
		VFS_SEEK(handle, 0, SEEK_SET);
	}
#endif
	return handle;
}

int FS_Rename2(char *oldf, char *newf, relativeto_t oldrelativeto, relativeto_t newrelativeto)
{
	char oldfullname[MAX_OSPATH];
	char newfullname[MAX_OSPATH];

	switch (oldrelativeto)
	{
	case FS_GAME_OS:
		if (*com_homedir)
			snprintf(oldfullname, sizeof(oldfullname), "%s/%s/", com_homedir, com_gamedirfile);
		else
			snprintf(oldfullname, sizeof(oldfullname), "%s%s/", com_basedir, com_gamedirfile);
		break;
/*	case FS_SKINS:
		if (*com_homedir)
			snprintf(oldfullname, sizeof(oldfullname), "%sqw/skins/", com_homedir);
		else
			snprintf(oldfullname, sizeof(oldfullname), "%sqw/skins/", com_basedir);
		break;
 */

	case FS_BASE:
		if (*com_homedir)
			snprintf(oldfullname, sizeof(oldfullname), "%s", com_homedir);
		else
			snprintf(oldfullname, sizeof(oldfullname), "%s", com_basedir);
		break;
	default:
		Sys_Error("FS_Rename case not handled\n");
	}

	switch (newrelativeto)
	{
	case FS_GAME_OS:
		if (*com_homedir)
			snprintf(newfullname, sizeof(newfullname), "%s/%s/", com_homedir, com_gamedirfile);
		else
			snprintf(newfullname, sizeof(newfullname), "%s%s/", com_basedir, com_gamedirfile);
		break;

/*	case FS_SKINS:
		if (*com_homedir)
			snprintf(newfullname, sizeof(newfullname), "%s/qw/skins/", com_homedir);
		else
			snprintf(newfullname, sizeof(newfullname), "%sqw/skins/", com_basedir);
		break;
 */
	case FS_BASE:
		if (*com_homedir)
			snprintf(newfullname, sizeof(newfullname), "%s", com_homedir);
		else
			snprintf(newfullname, sizeof(newfullname), "%s", com_basedir);
		break;
	default:
		Sys_Error("FS_Rename case not handled\n");
	}

	strlcat(oldfullname, oldf, sizeof(oldfullname));
	strlcat(newfullname, newf, sizeof(newfullname));

	FS_CreatePathRelative(newf, newrelativeto);
	return rename(oldfullname, newfullname);
}
int FS_Rename(char *oldf, char *newf, relativeto_t relativeto)
{
	char oldfullname[MAX_OSPATH];
	char newfullname[MAX_OSPATH];

	switch (relativeto)
	{
	case FS_GAME_OS:
		if (*com_homedir)
			snprintf(oldfullname, sizeof(oldfullname), "%s/%s/", com_homedir, com_gamedirfile);
		else
			snprintf(oldfullname, sizeof(oldfullname), "%s%s/", com_basedir, com_gamedirfile);
		break;

/*	case FS_SKINS:
		if (*com_homedir)
			snprintf(oldfullname, sizeof(oldfullname), "%s/qw/skins/", com_homedir);
		else
			snprintf(oldfullname, sizeof(oldfullname), "%sqw/skins/", com_basedir);
		break;
 */

	case FS_BASE:
		if (*com_homedir)
			snprintf(oldfullname, sizeof(oldfullname), "%s", com_homedir);
		else
			snprintf(oldfullname, sizeof(oldfullname), "%s", com_basedir);
		break;

	default:
		Sys_Error("FS_Rename case not handled\n");
	}

	strlcpy(newfullname, oldfullname, sizeof(newfullname));
	strlcat(oldfullname, oldf, sizeof(oldfullname));
	strlcat(newfullname, newf, sizeof(newfullname));

	return rename(oldfullname, newfullname);
}

int FS_Remove(char *fname, int relativeto)
{
	char fullname[MAX_OSPATH];

	switch (relativeto)
	{
	case FS_GAME_OS:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/%s/%s", com_homedir, com_gamedirfile, fname);
		else
			snprintf(fullname, sizeof(fullname), "%s%s/%s", com_basedir, com_gamedirfile, fname);
		break;

/*	case FS_SKINS:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/qw/skins/%s", com_homedir, fname);
		else
			snprintf(fullname, sizeof(fullname), "%sqw/skins/%s", com_basedir, fname);
		break;
 */
	case FS_BASE:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/%s", com_homedir, fname);
		else
			snprintf(fullname, sizeof(fullname), "%s%s", com_basedir, fname);
		break;
	default:
		Sys_Error("FS_Rename case not handled\n");
		return 0;
	}

	return unlink (fullname);
}

static void FS_CreatePathRelative(const char *pname, int relativeto)
{
	char fullname[MAX_OSPATH];
	switch (relativeto)
	{
	case FS_NONE_OS:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/%s", com_homedir, pname);
		else
			snprintf(fullname, sizeof(fullname), "%s", pname);
		break;

	case FS_GAME_OS:
		snprintf(fullname, sizeof(fullname), "%s/%s", com_gamedir, pname);
		break;

	case FS_BASE:
	case FS_ANY:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/%s", com_homedir, pname);
		else
			snprintf(fullname, sizeof(fullname), "%s%s", com_basedir, pname);
		break;
/*	case FS_SKINS:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/qw/skins/%s", com_homedir, pname);
		else
			snprintf(fullname, sizeof(fullname), "%sqw/skins/%s", com_basedir, pname);
		break;
	case FS_CONFIGONLY:
		if (*com_homedir)
			snprintf(fullname, sizeof(fullname), "%s/fte/%s", com_homedir, pname);
		else
			snprintf(fullname, sizeof(fullname), "%sfte/%s", com_basedir, pname);
		break;*/
	default:
		Sys_Error("FS_CreatePathRelative: Bad relative path (%i)", relativeto);
		break;
	}
	FS_CreatePath(fullname);
}

// Compile this part of code for all wildcard searching 
// for pak files to be opened

typedef struct {
	searchpathfuncs_t *funcs;
	searchpath_t *parentpath;
	char *parentdesc;
} wildpaks_t;

static int FS_AddWildDataFiles (char *descriptor, int size, void *vparam)
{
	wildpaks_t *param = vparam;
	vfsfile_t *vfs;
	searchpathfuncs_t *funcs = param->funcs;
	searchpath_t	*search;
	void 			*pak;
	char			pakfile[MAX_OSPATH];
	flocation_t loc;

	snprintf (pakfile, sizeof (pakfile), "%s%s", param->parentdesc, descriptor);

	for (search = fs_searchpaths; search; search = search->next)
	{
		if (search->funcs != funcs)
			continue;
		if (!strcasecmp((char*)search->handle, pakfile))	//assumption: first member of structure is a char array
			return true; //already loaded (base paths?)
	}

	search = param->parentpath;

	if (!search->funcs->FindFile(search->handle, &loc, descriptor, NULL))
		return true;	//not found..
	vfs = search->funcs->OpenVFS(search->handle, &loc, "rb");
	pak = funcs->OpenNew (vfs, pakfile);
	if (!pak)
		return true;

	snprintf (pakfile, sizeof (pakfile), "%s%s/", param->parentdesc, descriptor);
	FS_AddPathHandle(pakfile, funcs, pak, true, false, FS_LOAD_FILE_ALL);

	return true;
}

static void FS_AddDataFiles(char *pathto, searchpath_t *parent, char *extension, searchpathfuncs_t *funcs)
{
	int				i;
	char			pakfile[MAX_OSPATH];
	wildpaks_t wp;
	FILE *pak_lst;

	for (i = 0; ; i++)
	{
		// try lower-case first
		snprintf (pakfile, sizeof(pakfile), "pak%i.%s", i, extension);
		if (FS_AddPak(pathto, pakfile, parent, funcs)) {
			// originals might be PAK0.PAK, try again
			Q_strupr(pakfile);
			if (FS_AddPak(pathto, pakfile, parent, funcs)) {
				break;
			}
		}
	}

	/* VFS-FIXME: Sure there is a better way to do this.... */
	snprintf (pakfile, sizeof (pakfile), "%s/pak.lst", pathto);
	pak_lst = fopen(pakfile, "r");
	if (!pak_lst) {
		snprintf (pakfile, sizeof (pakfile), "*.%s", extension);
		wp.funcs = funcs;
		wp.parentdesc = pathto;
		wp.parentpath = parent;
		parent->funcs->EnumerateFiles(parent->handle, pakfile, FS_AddWildDataFiles, &wp);
	} else {
		fclose(pak_lst);
	}
}

void FS_RefreshFSCache_f(void)
{
	filesystemchanged=true;
}

void FS_FlushFSCache(void)
{
	if (fs_cache.value != 2)
		filesystemchanged=true;
}


/*
================
FS_AddGameDirectory

Sets com_gamedir, adds the directory to the head of the path,
then loads and adds pak1.pak pak2.pak ...
================
*/
void FS_AddGameDirectory (char *dir, FS_Load_File_Types loadstuff)
{
	size_t size;
	searchpath_t *search;
	char *p;
	char tmp_path[MAX_OSPATH];

	if ((p = strrchr(dir, '/')) != NULL)
		strlcpy (com_gamedirfile, ++p, sizeof (com_gamedirfile));
	else
		strlcpy (com_gamedirfile, dir, sizeof (com_gamedirfile));

	if (com_gamedir != dir) strlcpy (com_gamedir, dir, sizeof (com_gamedir));

	for (search = fs_searchpaths; search; search = search->next)
	{
		if (search->funcs != &osfilefuncs)
			continue;

		if (!strcasecmp(search->handle, com_gamedir))
			return; //already loaded (base paths?)
	}

	// add the directory to the search path
	size = strlen (dir) + 1;
	p = Q_malloc_named(size, dir);
	strlcpy (p, dir, size);
	snprintf(&tmp_path[0], sizeof(tmp_path), "%s/", dir);
	FS_AddPathHandle (tmp_path, &osfilefuncs, p, false, false, loadstuff);
}

/*
================
FS_AddHomeDirectory

Adds the home directory to the head of the path,
then loads and adds pak1.pak pak2.pak ...
================
*/
void FS_AddHomeDirectory (char *dir, FS_Load_File_Types loadstuff)
{
	size_t size;
	searchpath_t *search;
	char *p;
	char tmp_path[MAX_OSPATH];

	for (search = fs_searchpaths; search; search = search->next)
	{
		if (search->funcs != &osfilefuncs)
			continue;

		if (!strcasecmp(search->handle, com_homedir))
			return; //already loaded (base paths?)
	}

	// add the directory to the search path
	size = strlen (dir) + 1;
	p = Q_malloc (size);
	strlcpy (p, dir, size);

	snprintf(&tmp_path[0], sizeof(tmp_path), "%s/", dir);
	FS_AddPathHandle (tmp_path, &osfilefuncs, p, false, false, loadstuff);
}

//space-seperate pk3 names followed by space-seperated crcs
//note that we'll need to reorder and filter out files that don't match the crc.
void FS_ForceToPure(char *str, const char *crcs, int seed)
{
	//pure files are more important than non-pure.

	searchpath_t *sp;
	searchpath_t *lastpure = NULL;
	int crc;

	if (!str)
	{	//pure isn't in use.
		fs_purepaths = NULL;
		FS_FlushFSHash();
		return;
	}

	for (sp = fs_searchpaths; sp; sp = sp->next)
	{
		if (sp->funcs->GeneratePureCRC)
		{
			sp->nextpure = (void*)0x1;
			sp->crc_check = sp->funcs->GeneratePureCRC(sp->handle, seed, 0);
			sp->crc_reply = sp->funcs->GeneratePureCRC(sp->handle, seed, 1);
		}
		else
		{
			sp->crc_check = 0;
			sp->crc_reply = 0;
		}
	}

	while(crcs)
	{
		crcs = COM_Parse(crcs);
		crc = atoi(com_token);

		if (!crc)
			continue;

		for (sp = fs_searchpaths; sp; sp = sp->next)
		{
			if (sp->nextpure == (void*)0x1)	//don't add twice.
				if (sp->crc_check == crc)
				{
					if (lastpure)
						lastpure->nextpure = sp;
					else
						fs_purepaths = sp;
					sp->nextpure = NULL;
					lastpure = sp;
					break;
				}
		}
		if (!sp)
			Com_Printf("Pure crc %i wasn't found\n", crc);
	}

/* don't add any extras.
	for (sp = fs_searchpaths; sp; sp = sp->next)
	{
		if (sp->nextpure == (void*)0x1)
		{
			if (lastpure)
				lastpure->nextpure = sp;
			sp->nextpure = NULL;
			lastpure = sp;
		}
	}
*/

	FS_FlushFSHash();
}

char *FS_GenerateClientPacksList(char *buffer, int maxlen, int basechecksum)
{
	flocation_t loc;
	int numpaks = 0;
	searchpath_t *sp;
	char tmp[64];

	FS_FLocateFile("vm/cgame.qvm", FSLFRT_LENGTH, &loc);
	
	snprintf(&tmp[0], sizeof(tmp), "%i ", loc.search->crc_reply);
	strlcat(buffer, tmp, maxlen);

	basechecksum ^= loc.search->crc_reply;

	FS_FLocateFile("vm/ui.qvm", FSLFRT_LENGTH, &loc);

	snprintf(&tmp[0], sizeof(tmp), "%i ", loc.search->crc_reply);
	strlcat(buffer, tmp, maxlen);

	basechecksum ^= loc.search->crc_reply;

	strlcat(buffer, "@ ", maxlen);

	for (sp = fs_purepaths; sp; sp = sp->nextpure) {
		if (sp->crc_reply) {
			snprintf(&tmp[0], sizeof(tmp), "%i ", sp->crc_reply);
			strlcat(buffer, tmp, maxlen);
			basechecksum ^= sp->crc_reply;
			numpaks++;
		}
	}

	basechecksum ^= numpaks;
	snprintf(&tmp[0], sizeof(tmp), "%i ", basechecksum);
	strlcat (buffer, tmp, maxlen);

	return buffer;
}

/*
================
FS_ReloadPackFiles
================

Called when the client has downloaded a new pak/pk3 file
*/
void FS_ReloadPackFilesFlags(FS_Load_File_Types reloadflags)
{
	searchpath_t	*oldpaths;
	searchpath_t	*oldbase;
	searchpath_t	*next;

	//a lame way to fix pure paks
	if (cls.state)
	{
		CL_Disconnect_f();
		CL_Reconnect_f();
	}

	FS_FlushFSHash();

	oldpaths = fs_searchpaths;
	fs_searchpaths = NULL;
	fs_purepaths = NULL;
	oldbase = fs_base_searchpaths;
	fs_base_searchpaths = NULL;

	//invert the order
	next = NULL;
	while(oldpaths)
	{
		oldpaths->nextpure = next;
		next = oldpaths;
		oldpaths = oldpaths->next;
	}
	oldpaths = next;

	fs_base_searchpaths = NULL;

	while(oldpaths)
	{
		next = oldpaths->nextpure;

		if (oldbase == oldpaths)
			fs_base_searchpaths = fs_searchpaths;

		if (oldpaths->funcs == &osfilefuncs)
			FS_AddGameDirectory(oldpaths->handle, reloadflags);

		oldpaths->funcs->ClosePath(oldpaths->handle);
		Q_free(oldpaths);
		oldpaths = next;
	}

	if (!fs_base_searchpaths)
		fs_base_searchpaths = fs_searchpaths;
}

void FS_UnloadPackFiles(void)
{
	FS_ReloadPackFilesFlags(FS_LOAD_NONE);
}

void FS_ReloadPackFiles(void)
{
	FS_ReloadPackFilesFlags(FS_LOAD_FILE_ALL);
}

void FS_ReloadPackFiles_f(void)
{
	if (Cmd_Argc() > 2) {
		Com_Printf("Usage: %s [reload flags]\n", Cmd_Argv(0));
		return;
	}
	if (atoi(Cmd_Argv(1))) {
		FS_ReloadPackFilesFlags(atoi(Cmd_Argv(1)));
	}
	else {
		FS_ReloadPackFilesFlags(FS_LOAD_FILE_ALL);
	}
	FS_Path_f();
}

void FS_ListFiles_f(void)
{
	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: fs_search <extension>\nLists files in search paths with given extension\n");
	}
	else if (!fs_cache.integer) {
		Com_Printf("Can't search, fs_cache must be turned on\n");
	}
	else {
		int i;
		char *ext = Cmd_Argv(1);
		size_t ext_len = strlen(ext);

		for (i = 0; i < filesystemhash->numbuckets; i++) {
			bucket_t *b = filesystemhash->bucket[i];
			while (b) {
				char *key = b->keystring;
				size_t len = strlen(key);
				if (strcmp(key+len-ext_len, ext) == 0) {
					Com_Printf("%s\n", b->keystring);
				}
				b = b->next;
			}
		}
	}
}

void FS_EnumerateFiles (char *match, int (*func)(char *, int, void *), void *parm)
{
	searchpath_t *search;
	for (search = fs_searchpaths; search ; search = search->next)
		if (!search->funcs->EnumerateFiles (search->handle, match, func, parm)) // is the element a pak file?
			break;
}

// DEBUG FUNCTION
// ===============
// FS_DiffFile_f
// ===============
// Premitive compare of two files
// This allows verifing of the VFS
// just use at a quake conosle fs_diff <file1> <file2>
// where file1 is a OS based file & file2 is a file
// placed in a zip, gzip, pak, pk3 etc
static void FS_DiffFile_f(void) 
{
	char buf1[CHUNK], buf2[CHUNK];
	char *filename1, *filename2;
	vfsfile_t *file1, *file2;
	vfserrno_t err1, err2;
	int differences = 0;
	int bytes_read1, bytes_read2, bytes_total = 0;

	if (Cmd_Argc() != 3) {
		Com_Printf("Usage: %s filename1 filename2\n", Cmd_Argv(0));
		return;
	}
	
	filename1 = Cmd_Argv(1);
	filename2 = Cmd_Argv(2);

	file1 = FS_OpenVFS(filename1, "rb", FS_NONE_OS);
	if (file1 == NULL) {
		Com_Printf("Unable to open %s\n", filename1);
		return;
	}
	file2 = FS_OpenVFS(filename2, "rb", FS_NONE_OS);
	if (file2 == NULL) {
		Com_Printf("Unable to open %s\n", filename2);
		return;
	}

	do {
		int i;
		bytes_read1 = VFS_READ(file1, buf1, sizeof(buf1), &err1);
		bytes_read2 = VFS_READ(file2, buf2, sizeof(buf2), &err2);

		if (bytes_read1 != bytes_read2) {
			Com_Printf("%s: Filesizes seem different, assuming files differ\n", Cmd_Argv(0));
			differences = 1;
			goto end;
		}

		/* Check the bytes read */
		for (i = 0; i < bytes_read1; i++, bytes_total++) {
			if (buf1[i] != buf2[i]) {
				differences = 1;
				goto end;
			}
		}
	} while (err1 != VFSERR_EOF && err2 != VFSERR_EOF);

	if (err1 != err2) {
		differences = 1;
	} 

end:
	if (!differences) {
		Com_Printf("%s & %s match\n", filename1, filename2);
	} else {
		Com_Printf("%s & %s differ on byte %d\n", filename1, filename2, bytes_total);
	}
	VFS_CLOSE(file1);
	VFS_CLOSE(file2);
}

#ifdef SERVERONLY
/*
================
FS_GetCleanPath

================
*/
static const char *FS_GetCleanPath(const char *pattern, char *outbuf, int outlen)
{
	char *s;

	if (strchr(pattern, '\\'))
	{
		strlcpy(outbuf, pattern, outlen);
		pattern = outbuf;

		Con_Printf("Warning: \\ characters in filename %s\n", pattern);

		for (s = (char*)pattern; (s = strchr(s, '\\')); s++)
			*s = '/';
	}

	if (*pattern == '/' || strstr(pattern, "..") || strstr(pattern, ":"))
		Con_Printf("Error: absolute path in filename %s\n", pattern);
	else
		return pattern;

	return NULL;
}
#endif

/*
===========
FS_UnsafeFilename

Returns true if user-specified path is unsafe
===========
*/
qbool FS_UnsafeFilename(const char* fileName)
{
	return !fileName ||
		!*fileName || // invalid name.
		fileName[1] == ':' ||	// dos filename absolute path specified - reject.
		*fileName == '\\' ||
		*fileName == '/' ||	// absolute path was given - reject.
		strstr(fileName, "..");
}

void FS_Shutdown(void)
{
	searchpath_t* path;
	searchpath_t* next;

	Hash_ShutdownTable(filesystemhash);
	filesystemhash = NULL;

	for (path = fs_searchpaths; path; path = next) {
		path->funcs->ClosePath(path->handle);
		next = path->next;
		Q_free(path);
	}
}

void FS_SaveGameDirectory(char* buffer, int buffer_size)
{
	extern cvar_t fs_savegame_home;

	if (fs_savegame_home.integer) {
		snprintf(buffer, buffer_size, "%s/%s/save/", com_homedir, com_gamedirfile);
	}
	else {
		snprintf(buffer, buffer_size, "%s/save/", com_gamedir);
	}
}


================================================
FILE: src/fs.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __FS_H__
#define __FS_H__

#ifdef WITH_ZLIB
#include "zlib.h"
#endif
#ifdef WITH_ZIP
#include "unzip.h"
#endif

void FS_InitModuleFS (void);

// ====================================================================
// Quake File System addons
// original common FS functions are declared in common.h

// QW262 -->
#define UserdirSet (userdirfile[0] != '\0')
extern	char userdirfile[MAX_OSPATH];
extern	char com_userdir[MAX_OSPATH];
void FS_SetUserDirectory (char *dir, char *type);
// <-- QW262

// ====================================================================
// Virtual File System

typedef enum {
	VFSERR_NONE,
	VFSERR_EOF
} vfserrno_t;

typedef struct vfsfile_s {
	int (*ReadBytes) (struct vfsfile_s *file, void *buffer, int bytestoread, vfserrno_t *err);
	int (*WriteBytes) (struct vfsfile_s *file, const void *buffer, int bytestowrite);
	int (*Seek) (struct vfsfile_s *file, unsigned long pos, int whence);	// Returns 0 on sucess, -1 otherwise
	unsigned long (*Tell) (struct vfsfile_s *file);
	unsigned long (*GetLen) (struct vfsfile_s *file);	// Could give some lag
	void (*Close) (struct vfsfile_s *file);
	void (*Flush) (struct vfsfile_s *file);
	qbool seekingisabadplan;
	qbool copyprotected;							// File found was in a pak
} vfsfile_t;

// VFS-FIXME: D-Kure Clean up this structure
typedef enum {
	FS_NONE_OS, // file name used as is, opened with OS functions (no paks)
	FS_GAME_OS, // file used as com_basedir/filename, opened with OS functions 
				// (no paks)
	FS_BASE,	// file is relative to the com_basedir/com_homedir
	FS_HOME,
	FS_PAK,
	FS_ANY      // file searched on quake file system even in paks, u may use
				// only "rb" mode for file since u can't write to pak
} relativeto_t;

// mostly analogs for stdio functions
void 			VFS_CLOSE  (struct vfsfile_s *vf);
unsigned long	VFS_TELL   (struct vfsfile_s *vf);
unsigned long	VFS_GETLEN (struct vfsfile_s *vf);
int				VFS_SEEK   (struct vfsfile_s *vf, unsigned long pos, int whence);
int				VFS_READ   (struct vfsfile_s *vf, void *buffer, int bytestoread, vfserrno_t *err);
int				VFS_WRITE  (struct vfsfile_s *vf, const void *buffer, int bytestowrite);
void			VFS_FLUSH  (struct vfsfile_s *vf);
char		   *VFS_GETS   (struct vfsfile_s *vf, char *buffer, int buflen); 
				// return null terminated string

void			VFS_TICK   (void);  // fill in/out our internall buffers 
									// (do read/write on socket)
vfsfile_t      *VFS_Filter(const char *filename, vfsfile_t *handle);
qbool			VFS_COPYPROTECTED(struct vfsfile_s *vf);

// some general function to open VFS file, except TCP
vfsfile_t *FS_OpenVFS(const char *filename, char *mode,relativeto_t relativeto);

// TCP VFS file
vfsfile_t *FS_OpenTCP(char *name);

typedef enum {
	FS_LOAD_NONE     = 1,
	FS_LOAD_FILE_PAK = 2,
	FS_LOAD_FILE_PK3 = 4,
	FS_LOAD_FILE_PK4 = 8,
	FS_LOAD_FILE_DOOMWAD = 16,
	FS_LOAD_FROM_PAKLST = 32,
	FS_LOAD_FILE_ALL = FS_LOAD_FILE_PAK | FS_LOAD_FILE_PK3 
		| FS_LOAD_FILE_PK4 | FS_LOAD_FILE_DOOMWAD | FS_LOAD_FROM_PAKLST,
} FS_Load_File_Types;

void FS_AddGameDirectory (char *dir, FS_Load_File_Types loadstuff);

char *FS_NextPath (char *prevpath);

extern cvar_t fs_cache;
extern qbool filesystemchanged;

// ====================================================================
// GZIP & ZIP De/compression

#ifdef WITH_ZLIB
int FS_GZipPack (char *source_path,
				  char *destination_path,
				  qbool overwrite);

int FS_GZipUnpack (char *source_path,		// The path to the compressed source file.
					char *destination_path, // The destination file path.
					qbool overwrite);		// Overwrite the destination file if it exists?

void* FS_GZipUnpackToMemory(char* source_path, size_t* unpacked_length);

int FS_ZlibInflate(FILE *source, FILE *dest);

int FS_ZlibUnpack (char *source_path,		// The path to the compressed source file.
					char *destination_path, // The destination file path.
					qbool overwrite);		// Overwrite the destination file if it exists?

int FS_ZlibUnpackToTemp (char *source_path,		// The compressed source file.
						  char *unpack_path,		// A buffer that will contain the path to the unpacked file.
						  int unpack_path_size,		// The size of the buffer.	
						  char *append_extension);	// The extension if any that should be appended to the filename.
#endif // WITH_ZLIB

#ifdef WITH_ZIP
qbool FS_IsArchive (char *path);

int FS_ZipBreakupArchivePath (char *archive_extension,			// The extension of the archive type we're looking fore "zip" for example.
							   char *path,						// The path that should be broken up into parts.
							   char *archive_path,				// The buffer that should contain the archive path after the breakup.
							   int archive_path_size,			// The size of the archive path buffer.
							   char *inzip_path,				// The buffer that should contain the inzip path after the breakup.
							   int inzip_path_size);			// The size of the inzip path buffer.

unzFile FS_ZipUnpackOpenFile (const char *zip_path);

int FS_ZipUnpackCloseFile (unzFile zip_file);

int FS_ZipUnpack (unzFile zip_file, 
				   char *destination_path, 
				   qbool case_sensitive, 
				   qbool keep_path, 
				   qbool overwrite, 
				   const char *password);

int FS_ZipUnpackToTemp (unzFile zip_file, 
				   qbool case_sensitive, 
				   qbool keep_path, 
				   const char *password,
				   char *unpack_path,					// The path where the file was unpacked.
				   int unpack_path_size);				// The size of the buffer for "unpack_path", MAX_PATH is a goode idea.)

int FS_ZipUnpackOneFile (unzFile zip_file,				// The zip file opened with FS_ZipUnpackOpenFile(..)
						  const char *filename_inzip,	// The name of the file to unpack inside the zip.
						  const char *destination_path, // The destination path where to extract the file to.
						  qbool case_sensitive,			// Should we look for the filename case sensitivly?
						  qbool keep_path,				// Should the path inside the zip be preserved when unpacking?
						  qbool overwrite,				// Overwrite any existing file with the same name when unpacking?
						  const char *password);		// The password to use when extracting the file.

void* FS_ZipUnpackOneFileToMemory(
	unzFile zip_file,
	const char* filename_inzip,
	qbool case_sensitive,
	qbool keep_path,
	const char* password,
	size_t* unpacked_length
);

int FS_ZipUnpackCurrentFile (unzFile zip_file, 
							  const char *destination_path, 
							  qbool case_sensitive, 
							  qbool keep_path, 
							  qbool overwrite, 
							  const char *password);

int FS_ZipGetFirst (unzFile zip_file, sys_dirent *ent);

int FS_ZipGetNextFile (unzFile zip_file, sys_dirent *ent);

#endif // WITH_ZIP

qbool FS_UnsafeFilename(const char* name);
void FS_SaveGameDirectory(char* buffer, int buffer_size);

#endif // __FS_H__


================================================
FILE: src/g_public.h
================================================
/*
 *  QW262
 *  Copyright (C) 2004  [sd] angel
 *
 *  This code is based on Q3 VM code by Id Software, Inc.
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 */

#ifndef __G_PUBLIC_H__
#define __G_PUBLIC_H__


// Copyright (C) 1999-2000 Id Software, Inc.
//
// g_public.h -- game module information visible to server

#define	GAME_API_VERSION	16

/*
 * Changes in GAME_API_VERSION 16:
 * - server edict data removed from game edict: typedef struct shared_edict_s { entvars_t v;} edict_t;
 * - SetSting works for PR1 only
 * - ported VM from Q3
 * - QVM mods should get mapname and client netnames with infokey trap
 *
 * mod should get client netname in GAME_CLIENT_CONNECT call:
 *  self = PROG_TO_EDICT(g_globalvars.self);
 *  self->s.v.netname = netnames[NUM_FOR_EDICT(self)-1];
 *  infokey( self, "netname", self->s.v.netname,  32);
 *
 * mod should get mapname in GAME_START_FRAME call:
 *  if (framecount == 0)
 *  {
 *     infokey(world, "mapname", mapname, sizeof(mapname));
 *     infokey(world, "modelname", worldmodel, sizeof(worldmodel));
 *     world->model = worldmodel;
 *  }
 *
 *  infokey( world, "mapname", mapname, sizeof(mapname) );
 *
 * - QVM GAME_CLIENT_USERINFO_CHANGED call now have integer paramater
 *
 * called with 0 before changing, with 1 after changing
 * mod must update client netname in call with param 1 and key = "name"
 */

//===============================================================

// !!! new traps comes to end of list !!!

//
// system traps provided by the main engine
//
typedef enum
{
	//============== general Quake services ==================

	G_GETAPIVERSION,		// ( void);

	G_DPRINT,		// ( const char *string );
	// print message on the local console

	G_ERROR,		// ( const char *string );
	// abort the game
	G_GetEntityToken,

	G_SPAWN_ENT,
	G_REMOVE_ENT,
	G_PRECACHE_SOUND,
	G_PRECACHE_MODEL,
	G_LIGHTSTYLE,
	G_SETORIGIN,
	G_SETSIZE,
	G_SETMODEL,
	G_BPRINT,
	G_SPRINT,
	G_CENTERPRINT,
	G_AMBIENTSOUND,
	G_SOUND,
	G_TRACELINE,
	G_CHECKCLIENT,
	G_STUFFCMD,
	G_LOCALCMD,
	G_CVAR,
	G_CVAR_SET,
	G_FINDRADIUS,
	G_WALKMOVE,
	G_DROPTOFLOOR,
	G_CHECKBOTTOM,
	G_POINTCONTENTS,
	G_NEXTENT,
	G_AIM,
	G_MAKESTATIC,
	G_SETSPAWNPARAMS,
	G_CHANGELEVEL,
	G_LOGFRAG,
	G_GETINFOKEY,
	G_MULTICAST,
	G_DISABLEUPDATES,
	G_WRITEBYTE,     
	G_WRITECHAR,     
	G_WRITESHORT,    
	G_WRITELONG,     
	G_WRITEANGLE,    
	G_WRITECOORD,    
	G_WRITESTRING,   
	G_WRITEENTITY,
	G_FLUSHSIGNON,
	g_memset,
	g_memcpy,		
	g_strncpy,		
	g_sin,	
	g_cos,	
	g_atan2,	
	g_sqrt,	
	g_floor,	
	g_ceil,	
	g_acos,
	G_CMD_ARGC,
	G_CMD_ARGV,
	G_TraceCapsule,
	G_FSOpenFile,
	G_FSCloseFile,
	G_FSReadFile,
	G_FSWriteFile,
	G_FSSeekFile,
	G_FSTellFile,
	G_FSGetFileList,
	G_CVAR_SET_FLOAT,
	G_CVAR_STRING,
	G_Map_Extension,
	G_strcmp,
	G_strncmp,
	G_stricmp,
	G_strnicmp,
	G_Find,
	G_executecmd,
	G_conprint,
	G_readcmd,
	G_redirectcmd,
	G_Add_Bot,
	G_Remove_Bot,
	G_SetBotUserInfo,
	G_SetBotCMD,
	G_QVMstrftime,
	G_CMD_ARGS,
	G_CMD_TOKENIZE,
	g_strlcpy,
	g_strlcat,
	G_MAKEVECTORS,
	G_NEXTCLIENT,
	G_PRECACHE_VWEP_MODEL,
	G_SETPAUSE,
	G_SETUSERINFO,
	G_MOVETOGOAL,
	G_VISIBLETO,
	_G__LASTAPI
} gameImport_t;

// !!! new things comes to end of list !!!

// G_Map_Extension syscalls
#define G_EXTENSIONS_FIRST 256

//
// functions exported by the game subsystem
//
typedef enum
{
	GAME_INIT,	// ( int levelTime, int randomSeed, int restart );
	// init and shutdown will be called every single level
	// The game should call G_GET_ENTITY_TOKEN to parse through all the
	// entity configuration text and spawn gentities.
	GAME_LOADENTS,
	GAME_SHUTDOWN,	// (void);

	GAME_CLIENT_CONNECT,	 	// ( int clientNum ,int isSpectator);
	// ( int clientNum, qbool firstTime, qbool isBot );
	// return NULL if the client is allowed to connect, otherwise return
	// a text string with the reason for denial
	GAME_PUT_CLIENT_IN_SERVER,
	//GAME_CLIENT_BEGIN,				// ( int clientNum ,int isSpectator);

	GAME_CLIENT_USERINFO_CHANGED,	// ( int clientNum,int isSpectator );

	GAME_CLIENT_DISCONNECT,			// ( int clientNum,int isSpectator );

	GAME_CLIENT_COMMAND,			// ( int clientNum,int isSpectator );

	GAME_CLIENT_PRETHINK,
	GAME_CLIENT_THINK,				// ( int clientNum,int isSpectator );
	GAME_CLIENT_POSTTHINK,

	GAME_START_FRAME,					// ( int levelTime );
	GAME_SETCHANGEPARMS, //self
	GAME_SETNEWPARMS,
	GAME_CONSOLE_COMMAND,			// ( void );
	GAME_EDICT_TOUCH,                      //(self,other)
	GAME_EDICT_THINK,                      //(self,other=world,time)
	GAME_EDICT_BLOCKED,                     //(self,other)
	// ConsoleCommand will be called when a command has been issued
	// that is not recognized as a builtin function.
	// The game can issue trap_argc() / trap_argv() commands to get the command
	// and parameters.  Return qfalse if the game doesn't recognize it as a command.
	GAME_CLIENT_SAY,			// ( int isTeamSay );
	GAME_PAUSED_TIC,			// ( int duration_msec );	// duration is in msecs
	GAME_CLEAR_EDICT,           // (self)
} gameExport_t;


typedef enum
{
	F_INT, 
	F_FLOAT,
	F_LSTRING,			// string on disk, pointer in memory, TAG_LEVEL
//	F_GSTRING,			// string on disk, pointer in memory, TAG_GAME
	F_VECTOR,
	F_ANGLEHACK,
//	F_ENTITY,			// index on disk, pointer in memory
//	F_ITEM,				// index on disk, pointer in memory
//	F_CLIENT,			// index on disk, pointer in memory
	F_IGNORE
} fieldtype_t;

typedef struct
{
	stringptr_t   name;
	int           ofs;
	fieldtype_t   type;
} field_t;

typedef struct
{
	int   name;
	int   ofs;
	int   type;
} field_vm_t;

typedef struct
{
	intptr_t        ents;
	int             sizeofent;
	intptr_t        global;
	intptr_t        fields;
	int             APIversion;
	int             maxentities;
} gameData_t;

typedef struct
{
	int         ents_p;
	int         sizeofent;
	int         global_p;
	int         fields_p;
	int         APIversion;
	int         maxentities;
} gameData_vm_t;
typedef int		fileHandle_t;

typedef enum {
	FS_READ_BIN,
	FS_READ_TXT,
	FS_WRITE_BIN,
	FS_WRITE_TXT,
	FS_APPEND_BIN,
	FS_APPEND_TXT
} fsMode_t;

typedef enum {
	FS_SEEK_CUR,
	FS_SEEK_END,
	FS_SEEK_SET
} fsOrigin_t;

#endif /* !__G_PUBLIC_H__ */


================================================
FILE: src/gl_aliasmodel.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// Alias model rendering (common to OpenGL)

#include "quakedef.h"
#include "gl_model.h"
#include "r_local.h"
#include "r_aliasmodel.h"



================================================
FILE: src/gl_aliasmodel_md3.c
================================================
/*
Copyright (C) 2011 fuh and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// Code to display .md3 files

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_aliasmodel_md3.h"
#include "r_aliasmodel.h"
#include "vx_vertexlights.h" 
#include "r_matrix.h"
#include "glsl/constants.glsl"

void GL_AliasModelSetVertexDirection(int num_triangles, vbo_model_vert_t* vbo_buffer, int v1, int v2, qbool limit_lerp, int key_pose);
void GL_AliasModelFixNormals(vbo_model_vert_t* vbo_buffer, int v, int vertsPerPose);

void GLM_MakeAlias3DisplayLists(model_t* model)
{
	md3Surface_t* surf;
	md3St_t* texCoords;
	ezMd3XyzNormal_t* vertices;
	int surfnum;
	int framenum;
	md3Triangle_t* triangles;
	int v;
	md3model_t* md3Model = (md3model_t *)Mod_Extradata(model);
	md3Header_t* pheader = MD3_HeaderForModel(md3Model);
	vbo_model_vert_t* vbo;

	// Work out how many verts we are going to need to store in VBO
	model->vertsInVBO = 0;
	MD3_ForEachSurface(pheader, surf, surfnum) {
		model->vertsInVBO += 3 * surf->numTriangles;
	}
	model->vertsInVBO *= pheader->numFrames;
	model->temp_vbo_buffer = vbo = Q_malloc(sizeof(vbo_model_vert_t) * model->vertsInVBO);

	// foreach frame
	for (framenum = 0, v = 0; framenum < pheader->numFrames; ++framenum) {
		int initial_v = v;

		// loop through the surfaces.
		MD3_ForEachSurface(pheader, surf, surfnum) {
			int i, triangle;

			texCoords = MD3_SurfaceTextureCoords(surf);
			vertices = MD3_SurfaceVertices(surf);
			triangles = MD3_SurfaceTriangles(surf);

			for (triangle = 0; triangle < surf->numTriangles; ++triangle) {
				for (i = 0; i < 3; ++i, ++v) {
					int vertexNumber = framenum * surf->numVerts + triangles[triangle].indexes[i];
					int nextFrame = Mod_ExpectedNextFrame(model, framenum, pheader->numFrames);
					int nextVertexNumber = nextFrame * surf->numVerts + triangles[triangle].indexes[i];
					ezMd3XyzNormal_t* vert = &vertices[vertexNumber];
					ezMd3XyzNormal_t* nextVert = &vertices[nextVertexNumber];
					float s, t;

					s = texCoords[triangles[triangle].indexes[i]].s;
					t = texCoords[triangles[triangle].indexes[i]].t;

					VectorCopy(vert->xyz, vbo[v].position);
					VectorCopy(vert->normal, vbo[v].normal);
					vbo[v].texture_coords[0] = s;
					vbo[v].texture_coords[1] = t;
					vbo[v].flags = 0;

					// Set direction
					VectorSubtract(nextVert->xyz, vert->xyz, vbo[v].direction);
					if (model->renderfx & RF_LIMITLERP) {
						if ((vert->xyz[0] > 0) != (nextVert->xyz[0] > 0)) {
							vbo[v].flags |= AM_VERTEX_NOLERP;
						}
					}
				}
			}
		}

		GL_AliasModelFixNormals(vbo, initial_v, v - initial_v);
	}
}


================================================
FILE: src/gl_buffers.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// OpenGL buffer handling

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "tr_types.h"
#include "r_local.h"
#include "glm_vao.h"
#include "r_trace.h"
#include "r_buffers.h"
#include "r_renderer.h"

static void GL_BufferStartFrame(void);
static void GL_BufferEndFrame(void);
static qbool GL_BuffersReady(void);

static void GL_InitialiseBufferState(void);

static qbool GL_CreateFixedBuffer(r_buffer_id id, buffertype_t type, const char* name, int size, void* data, bufferusage_t usage);
static void GL_GenFixedBuffer(r_buffer_id id, buffertype_t type, const char* name, int size, void* data, bufferusage_t usage);
static uintptr_t GL_BufferOffset(r_buffer_id ref);

static size_t GL_BufferSize(r_buffer_id id);

static void GL_BindBuffer(r_buffer_id id);
static void GL_BindBufferBase(r_buffer_id id, unsigned int index);
static void GL_BindBufferRange(r_buffer_id id, unsigned int index, ptrdiff_t offset, int size);
static void GL_UnBindBuffer(buffertype_t type);
static void GL_UpdateBuffer(r_buffer_id id, int size, void* data);
static void GL_UpdateBufferSection(r_buffer_id id, ptrdiff_t offset, int size, const void* data);
static void GL_ResizeBuffer(r_buffer_id id, int size, void* data);
static void GL_EnsureBufferSize(r_buffer_id id, int size);

static qbool GL_BindBufferImpl(GLenum target, GLuint buffer);

static qbool R_Stub_BufferNotValid(r_buffer_id id)
{
	return false;
}

typedef struct buffer_data_s {
	GLuint glref;
	char name[64];

	// These set at creation
	buffertype_t type;
	bufferusage_t usage;
	GLsizei size;
	GLuint storageFlags;         // flags for BufferStorage()
	qbool using_storage;

	void* persistent_mapped_ptr;
} buffer_data_t;

static GLenum GL_BufferTypeToTarget(buffertype_t type)
{
	switch (type) {
		case buffertype_index:
			return GL_ELEMENT_ARRAY_BUFFER;
		case buffertype_indirect:
			return GL_DRAW_INDIRECT_BUFFER;
		case buffertype_storage:
			return GL_VersionAtLeast(4, 3) ? GL_SHADER_STORAGE_BUFFER : GL_UNIFORM_BUFFER;
		case buffertype_vertex:
			return GL_ARRAY_BUFFER;
		case buffertype_uniform:
			return GL_UNIFORM_BUFFER;
		default:
			assert(false);
			return 0;
	}
}

static GLenum GL_BufferUsageToGLUsage(bufferusage_t usage)
{
	switch (usage) {
		case bufferusage_once_per_frame:
			return GL_STREAM_DRAW;
		case bufferusage_reuse_per_frame:
			return GL_STREAM_DRAW;
		case bufferusage_reuse_many_frames:
			return GL_STATIC_DRAW;
		case bufferusage_constant_data:
			return GL_STATIC_COPY;
		default:
			assert(false);
			return 0;
	}
}

// Buffer functions
GL_StaticProcedureDeclaration(glBindBuffer, "target=%u, buffer=%u", GLenum target, GLuint buffer)
GL_StaticProcedureDeclaration(glBufferData, "target=%u, size=%u, data=%p, usage=%u", GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
GL_StaticProcedureDeclaration(glBufferSubData, "target=%u, offset=%p, size=%p, data=%p", GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
GL_StaticProcedureDeclaration(glGenBuffers, "n=%d, buffers=%p", GLsizei n, GLuint* buffers)
GL_StaticProcedureDeclaration(glDeleteBuffers, "n=%d, buffers=%p", GLsizei n, const GLuint* buffers)
GL_StaticProcedureDeclaration(glBindBufferBase, "target=%u, index=%u, buffer=%u", GLenum target, GLuint index, GLuint buffer)
GL_StaticProcedureDeclaration(glBindBufferRange, "target=%u, index=%u, buffer=%u, offset=%p, size=%p", GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
GL_StaticProcedureDeclaration(glUnmapBuffer, "target=%u", GLenum target)

// DSA
GL_StaticProcedureDeclaration(glNamedBufferSubData, "buffer=%u, offset=%u, size=%d, data=%p", GLuint buffer, GLintptr offset, GLsizei size, const void* data)
GL_StaticProcedureDeclaration(glNamedBufferData, "buffer=%u, size=%d, data=%p, usage=%u", GLuint buffer, GLsizei size, const void* data, GLenum usage)
GL_StaticProcedureDeclaration(glUnmapNamedBuffer, "buffer=%u", GLuint buffer);

// AZDO-buffer-streaming (4.4)
// Persistent mapped buffers
GL_StaticFunctionDeclaration(glMapBufferRange, "mtarget=%u, offset=%u, length=%p, access=%u", "returns %p", void*, GLenum mtarget, GLintptr offset, GLsizeiptr length, GLbitfield access)
GL_StaticFunctionWrapperBody(glMapBufferRange, void*, mtarget, offset, length, access)
GL_StaticProcedureDeclaration(glBufferStorage, "target=%u, size=%p, data=%p, flags=%u", GLenum target, GLsizeiptr size, const GLvoid* data, GLbitfield flags)
GL_StaticFunctionDeclaration(glFenceSync, "condition=%u, flags=%u", "returns %p", GLsync, GLenum condition, GLbitfield flags)
GL_StaticFunctionWrapperBody(glFenceSync, GLsync, condition, flags)
GL_StaticFunctionDeclaration(glClientWaitSync, "sync=%p, flags=%u, timeout=%UI64", "returns %u", GLenum, GLsync sync, GLbitfield flags, GLuint64 timeout)
GL_StaticFunctionWrapperBody(glClientWaitSync, GLenum, sync, flags, timeout)
GL_StaticProcedureDeclaration(glDeleteSync, "sync=%p", GLsync sync)

// Cache OpenGL state
static struct {
	buffer_data_t buffers[r_buffer_count];
	qbool tripleBuffer_supported;
	GLsync tripleBufferSyncObjects[3];

	GLuint currentArrayBuffer;
	GLuint currentUniformBuffer;
	GLuint currentDrawIndirectBuffer;
	GLuint currentElementArrayBuffer;
} glBufferState;

#define GL_BufferInvalidateReference(name, glref) { name = ((name) == (glref)) ? 0 : (name); }

static buffer_data_t* GL_BufferAllocateSlot(r_buffer_id id, buffertype_t type, const char* name, GLsizei size, bufferusage_t usage)
{
	buffer_data_t* buffer = &glBufferState.buffers[id];

	assert(usage < bufferusage_count);

	if (buffer->glref) {
		GL_BufferInvalidateReference(glBufferState.currentArrayBuffer, buffer->glref);
		GL_BufferInvalidateReference(glBufferState.currentUniformBuffer, buffer->glref);
		GL_BufferInvalidateReference(glBufferState.currentDrawIndirectBuffer, buffer->glref);
		GL_BufferInvalidateReference(glBufferState.currentElementArrayBuffer, buffer->glref);
		if (buffer->type == buffertype_index) {
			R_BindVertexArrayElementBuffer(r_buffer_none);
		}
		R_BufferInvalidateBoundState(id);
		GL_Procedure(glDeleteBuffers, 1, &buffer->glref);
		buffer->glref = 0;
#ifdef DEBUG_MEMORY_ALLOCATIONS
		Sys_Printf("\nbuffer,free,%d,%s,%u\n", id, name, buffer->size * (buffer->persistent_mapped_ptr ? 3 : 1));
#endif
	}

	memset(buffer, 0, sizeof(*buffer));
	strlcpy(buffer->name, name && name[0] ? name : "?", sizeof(buffer->name));
	buffer->size = size;
	buffer->usage = usage;
	buffer->type = type;
	GL_Procedure(glGenBuffers, 1, &buffer->glref);
	return buffer;
}

static void GL_GenFixedBuffer(r_buffer_id id, buffertype_t type, const char* name, int size, void* data, bufferusage_t usage)
{
	GLenum target = GL_BufferTypeToTarget(type);
	GLenum glUsage = GL_BufferUsageToGLUsage(usage);
	buffer_data_t* buffer = GL_BufferAllocateSlot(id, type, name, size, usage);

	buffer->persistent_mapped_ptr = NULL;
	buffer->using_storage = false;
	GL_BindBufferImpl(target, buffer->glref);
	GL_TraceObjectLabelSet(GL_BUFFER, buffer->glref, -1, name);
	GL_Procedure(glBufferData, target, size, data, glUsage);
	if (target == GL_ELEMENT_ARRAY_BUFFER) {
		R_BindVertexArrayElementBuffer(id);
	}
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nbuffer,alloc,%d,%s,%u\n", id, name, size);
#endif
}

static qbool GL_CreateFixedBuffer(r_buffer_id id, buffertype_t type, const char* name, int size, void* data, bufferusage_t usage)
{
	GLenum target = GL_BufferTypeToTarget(type);
	buffer_data_t* buffer;

	qbool tripleBuffer = false;
	qbool useStorage = false;
	GLbitfield storageFlags = 0;
	GLsizei alignment = 1;

	if (!size) {
		return false;
	}

	DebugOutput(va("Generating buffer %s\n", name));
	buffer = GL_BufferAllocateSlot(id, type, name, size, usage);

	if (usage == bufferusage_once_per_frame) {
		useStorage = tripleBuffer = glBufferState.tripleBuffer_supported;
		storageFlags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;
	}
	else if (usage == bufferusage_reuse_per_frame) {
		useStorage = GL_Available(glBufferStorage);
		storageFlags = GL_DYNAMIC_STORAGE_BIT;
		tripleBuffer = false;
	}
	else if (usage == bufferusage_reuse_many_frames) {
		storageFlags = GL_MAP_WRITE_BIT;
		useStorage = GL_Available(glBufferStorage);
		if (!data) {
			Sys_Error("Buffer %s flagged as constant but no initial data", name);
			return false;
		}
	}
	else if (usage == bufferusage_constant_data) {
		storageFlags = (data ? 0 : GL_DYNAMIC_STORAGE_BIT);
		useStorage = GL_Available(glBufferStorage);
		if (!data) {
			Sys_Error("Buffer %s flagged as constant but no initial data", name);
			return false;
		}
	}
	else {
		Sys_Error("Unknown usage flag passed to GL_CreateFixedBuffer");
		return false;
	}

	if (!useStorage) {
		// Fall back to standard mutable buffer
		GL_GenFixedBuffer(id, type, name, size, data, usage);
		return true;
	}

	GL_BindBufferImpl(target, buffer->glref);
	if (target == GL_UNIFORM_BUFFER) {
		alignment = glConfig.uniformBufferOffsetAlignment;
	}
	else if (target == GL_SHADER_STORAGE_BUFFER) {
		alignment = glConfig.shaderStorageBufferOffsetAlignment;
	}

	if (alignment > 1) {
		buffer->size = ((size + (alignment - 1)) / alignment) * alignment;
	}

	GL_TraceObjectLabelSet(GL_BUFFER, buffer->glref, -1, name);

	if (tripleBuffer) {
		GL_Procedure(glBufferStorage, target, buffer->size * 3, NULL, storageFlags);
		buffer->persistent_mapped_ptr = GL_Function(glMapBufferRange, target, 0, buffer->size * 3, storageFlags);

		if (buffer->persistent_mapped_ptr) {
			if (data) {
				void* base = (void*)((uintptr_t)buffer->persistent_mapped_ptr + buffer->size * glConfig.tripleBufferIndex);

				memcpy(base, data, size);
			}
#ifdef DEBUG_MEMORY_ALLOCATIONS
			Sys_Printf("\nbuffer,alloc,%d,%s,%u\n", id, name, size * 3);
#endif
		}
		else {
			Con_Printf("\20opengl\21 triple-buffered allocation failed (%dKB)\n", (size * 3) / 1024);
			GL_GenFixedBuffer(id, type, name, size, data, usage);
			return true;
		}
	}
	else {
		GL_Procedure(glBufferStorage, target, size, data, storageFlags);
#ifdef DEBUG_MEMORY_ALLOCATIONS
		Sys_Printf("\nbuffer,alloc,%d,%s,%u\n", id, name, size);
#endif
	}

	buffer->using_storage = true;
	buffer->storageFlags = storageFlags;
	return true;
}

static void GL_UpdateBuffer(r_buffer_id id, int size, void* data)
{
	assert(id != r_buffer_none);
	assert(glBufferState.buffers[id].glref);
	assert(data != NULL);
	assert(size <= glBufferState.buffers[id].size);

	if (glBufferState.buffers[id].persistent_mapped_ptr) {
		void* start = (void*)((uintptr_t)glBufferState.buffers[id].persistent_mapped_ptr + GL_BufferOffset(id));

		R_TraceLogAPICall("GL_UpdateBuffer[memcpy](%s, %u)", glBufferState.buffers[id].name, size);
		memcpy(start, data, size);
	}
	else {
		R_TraceLogAPICall("GL_UpdateBuffer(%s)", glBufferState.buffers[id].name);
		if (GL_Available(glNamedBufferSubData)) {
			GL_Procedure(glNamedBufferSubData, glBufferState.buffers[id].glref, 0, (GLsizei)size, data);
		}
		else {
			GL_BindBuffer(id);
			GL_Procedure(glBufferSubData, GL_BufferTypeToTarget(glBufferState.buffers[id].type), 0, (GLsizeiptr)size, data);
		}
	}
}

static size_t GL_BufferSize(r_buffer_id id)
{
	if (id == r_buffer_none) {
		return 0;
	}

	return glBufferState.buffers[id].size;
}

static void GL_ResizeBuffer(r_buffer_id id, int size, void* data)
{
	assert(id != r_buffer_none);
	assert(glBufferState.buffers[id].glref);

	if (glBufferState.buffers[id].using_storage) {
		if (glBufferState.buffers[id].persistent_mapped_ptr) {
			if (GL_Available(glUnmapNamedBuffer)) {
				GL_Procedure(glUnmapNamedBuffer, glBufferState.buffers[id].glref);
			}
			else {
				GL_BindBuffer(id);
				GL_Procedure(glUnmapBuffer, GL_BufferTypeToTarget(glBufferState.buffers[id].type));
			}
		}
		GL_Procedure(glDeleteBuffers, 1, &glBufferState.buffers[id].glref);
		glBufferState.buffers[id].glref = 0;
#ifdef DEBUG_MEMORY_ALLOCATIONS
		Sys_Printf("\nbuffer,free-resize,%d,%s,%u\n", id, glBufferState.buffers[id].name, glBufferState.buffers[id].size * (glBufferState.buffers[id].persistent_mapped_ptr ? 3 : 1));
#endif

		GL_CreateFixedBuffer(id, glBufferState.buffers[id].type, glBufferState.buffers[id].name, size, data, glBufferState.buffers[id].usage);
	}
	else {
		if (GL_Available(glNamedBufferData)) {
			GL_Procedure(glNamedBufferData, glBufferState.buffers[id].glref, size, data, GL_BufferUsageToGLUsage(glBufferState.buffers[id].usage));
		}
		else {
			GL_BindBuffer(id);
			GL_Procedure(glBufferData, GL_BufferTypeToTarget(glBufferState.buffers[id].type), size, data, GL_BufferUsageToGLUsage(glBufferState.buffers[id].usage));
		}
#ifdef DEBUG_MEMORY_ALLOCATIONS
		Sys_Printf("\nbuffer,free-resize,%d,%s,%u\n", id, glBufferState.buffers[id].name, glBufferState.buffers[id].size);
		Sys_Printf("\nbuffer,alloc-resize,%d,%s,%u\n", id, glBufferState.buffers[id].name, size);
#endif

		glBufferState.buffers[id].size = size;
		R_TraceLogAPICall("GL_ResizeBuffer(%s)", glBufferState.buffers[id].name);
	}
}

static void GL_UpdateBufferSection(r_buffer_id id, ptrdiff_t offset, int size, const void* data)
{
	if (id == r_buffer_none) {
		Sys_Error("GL_UpdateBufferSection: id == r_buffer_none");
		return;
	}
	else if (glBufferState.buffers[id].glref == 0) {
		Sys_Error("GL_UpdateBufferSection: id(%d:%s) invalid GL ref", id, glBufferState.buffers[id].name);
		return;
	}
	else if (data == 0) {
		Sys_Error("GL_UpdateBufferSection: id(%d:%s) update with NULL data", id, glBufferState.buffers[id].name);
		return;
	}
	else if (offset < 0) {
		Sys_Error("GL_UpdateBufferSection: id(%d:%s) offset < 0", id, glBufferState.buffers[id].name);
		return;
	}
	else if (offset >= glBufferState.buffers[id].size) {
		Sys_Error("GL_UpdateBufferSection: id(%d:%s) offset >= bufsize (%d >= %d)", id, glBufferState.buffers[id].name, (int)offset, glBufferState.buffers[id].size);
		return;
	}
	else if (offset + size > glBufferState.buffers[id].size) {
		Sys_Error("GL_UpdateBufferSection: id(%d:%s) offset + size >= bufsize (%d + %d > %d)", id, glBufferState.buffers[id].name, (int)offset, size, glBufferState.buffers[id].size);
		return;
	}

	R_TraceLogAPICall("GL_UpdateBufferSection(%s)", glBufferState.buffers[id].name);
	if (glBufferState.buffers[id].persistent_mapped_ptr) {
		void* base = (void*)((uintptr_t)glBufferState.buffers[id].persistent_mapped_ptr + GL_BufferOffset(id) + offset);

		memcpy(base, data, size);
	}
	else {
		if (GL_Available(glNamedBufferSubData)) {
			GL_Procedure(glNamedBufferSubData, glBufferState.buffers[id].glref, offset, size, data);
		}
		else {
			GL_BindBuffer(id);
			GL_Procedure(glBufferSubData, GL_BufferTypeToTarget(glBufferState.buffers[id].type), offset, size, data);
		}
	}
}

static void GL_BufferShutdown(void)
{
	int i;

	for (i = 0; i < r_buffer_count; ++i) {
		if (glBufferState.buffers[i].glref) {
			if (GL_Available(glDeleteBuffers)) {
				GL_Procedure(glDeleteBuffers, 1, &glBufferState.buffers[i].glref);
#ifdef DEBUG_MEMORY_ALLOCATIONS
				Sys_Printf("\nbuffer,free,%d,%s,%u\n", i, glBufferState.buffers[i].name, glBufferState.buffers[i].size * (glBufferState.buffers[i].persistent_mapped_ptr ? 3 : 1));
#endif
			}
			glBufferState.buffers[i].glref = 0;
		}
	}

	for (i = 0; i < 3; ++i) {
		if (glBufferState.tripleBufferSyncObjects[i]) {
			GL_Procedure(glDeleteSync, glBufferState.tripleBufferSyncObjects[i]);
		}
	}
	memset(&glBufferState, 0, sizeof(glBufferState));
}

static void GL_BindBufferBase(r_buffer_id id, unsigned int index)
{
	assert(id != r_buffer_none);
	assert(glBufferState.buffers[id].glref);

	GL_Procedure(glBindBufferBase, GL_BufferTypeToTarget(glBufferState.buffers[id].type), index, glBufferState.buffers[id].glref);
}

static void GL_BindBufferRange(r_buffer_id id, unsigned int index, ptrdiff_t offset, int size)
{
	if (size == 0) {
		return;
	}

	assert(id != r_buffer_none);
	assert(glBufferState.buffers[id].glref);
	assert(size >= 0);
	assert(offset >= 0);
	assert(offset + size <= glBufferState.buffers[id].size * (glBufferState.buffers[id].persistent_mapped_ptr ? 3 : 1));

	GL_Procedure(glBindBufferRange, GL_BufferTypeToTarget(glBufferState.buffers[id].type), index, glBufferState.buffers[id].glref, offset, size);
}

static qbool GL_BindBufferImpl(GLenum target, GLuint buffer)
{
	if (target == GL_ARRAY_BUFFER) {
		if (buffer == glBufferState.currentArrayBuffer) {
			return false;
		}
		glBufferState.currentArrayBuffer = buffer;
	}
	else if (target == GL_UNIFORM_BUFFER) {
		if (buffer == glBufferState.currentUniformBuffer) {
			return false;
		}
		glBufferState.currentUniformBuffer = buffer;
	}
	else if (target == GL_DRAW_INDIRECT_BUFFER) {
		if (buffer == glBufferState.currentDrawIndirectBuffer) {
			return false;
		}
		glBufferState.currentDrawIndirectBuffer = buffer;
	}
	else if (target == GL_ELEMENT_ARRAY_BUFFER) {
		if (buffer == glBufferState.currentElementArrayBuffer) {
			return false;
		}
		glBufferState.currentElementArrayBuffer = buffer;
	}

	GL_Procedure(glBindBuffer, target, buffer);
	return true;
}

static void GL_BindBuffer(r_buffer_id id)
{
	qbool switched;
	GLenum glTarget;

	if (!(R_BufferReferenceIsValid(id) && glBufferState.buffers[id].glref)) {
		R_TraceLogAPICall("GL_BindBuffer(<invalid-reference:%s>)", glBufferState.buffers[id].name);
		return;
	}

	glTarget = GL_BufferTypeToTarget(glBufferState.buffers[id].type);
	switched = GL_BindBufferImpl(glTarget, glBufferState.buffers[id].glref);
	if (glBufferState.buffers[id].type == buffertype_index) {
		R_BindVertexArrayElementBuffer(id);
	}

	if (switched) {
		R_TraceLogAPICall("GL_BindBuffer(%s)", glBufferState.buffers[id].name);
	}
}

static void GL_InitialiseBufferState(void)
{
	qbool tripleBufferSupported = glBufferState.tripleBuffer_supported;
	memset(&glBufferState, 0, sizeof(glBufferState));
	glBufferState.tripleBuffer_supported = tripleBufferSupported;
	R_BindVertexArrayElementBuffer(r_buffer_none);
	R_InitialiseVAOState();
}

static void GL_UnBindBuffer(buffertype_t type)
{
	GLenum target = GL_BufferTypeToTarget(type);
	GL_BindBufferImpl(target, 0);
	R_TraceLogAPICall("GL_UnBindBuffer(%s)", target == GL_ARRAY_BUFFER ? "array-buffer" : (target == GL_ELEMENT_ARRAY_BUFFER ? "element-array" : "?"));
}

static qbool GL_BufferValid(r_buffer_id id)
{
	return id > r_buffer_none && id < r_buffer_count && glBufferState.buffers[id].glref != 0;
}

// Called when the VAO is bound
static void GL_SetElementArrayBuffer(r_buffer_id id)
{
	if (GL_BufferValid(id)) {
		glBufferState.currentElementArrayBuffer = glBufferState.buffers[id].glref;
	}
	else {
		glBufferState.currentElementArrayBuffer = 0;
	}
}

static void GL_EnsureBufferSize(r_buffer_id id, int size)
{
	assert(id);
	assert(glBufferState.buffers[id].glref);

	if (glBufferState.buffers[id].size < size) {
		GL_ResizeBuffer(id, size, NULL);
	}
}

static void GL_BufferStartFrame(void)
{
	if (glBufferState.tripleBuffer_supported && glBufferState.tripleBufferSyncObjects[glConfig.tripleBufferIndex]) {
		GLenum waitRet = GL_Function(glClientWaitSync, glBufferState.tripleBufferSyncObjects[glConfig.tripleBufferIndex], 0, 0);
		while (waitRet == GL_TIMEOUT_EXPIRED) {
			// Flush commands and wait for longer
			waitRet = GL_Function(glClientWaitSync, glBufferState.tripleBufferSyncObjects[glConfig.tripleBufferIndex], GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000);
		}
	}
}

static void GL_BufferEndFrame(void)
{
	if (glBufferState.tripleBuffer_supported) {
		if (glBufferState.tripleBufferSyncObjects[glConfig.tripleBufferIndex]) {
			GL_Procedure(glDeleteSync, glBufferState.tripleBufferSyncObjects[glConfig.tripleBufferIndex]);
		}
		glBufferState.tripleBufferSyncObjects[glConfig.tripleBufferIndex] = GL_Function(glFenceSync, GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
		glConfig.tripleBufferIndex = (glConfig.tripleBufferIndex + 1) % 3;
	}
}

static uintptr_t GL_BufferOffset(r_buffer_id id)
{
	return glBufferState.buffers[id].persistent_mapped_ptr ? glBufferState.buffers[id].size * glConfig.tripleBufferIndex : 0;
}

static qbool GL_BuffersReady(void)
{
	if (glBufferState.tripleBuffer_supported && glBufferState.tripleBufferSyncObjects[glConfig.tripleBufferIndex]) {
		if (GL_Function(glClientWaitSync, glBufferState.tripleBufferSyncObjects[glConfig.tripleBufferIndex], 0, 0) == GL_TIMEOUT_EXPIRED) {
			return false;
		}
	}
	return true;
}

#ifdef WITH_RENDERING_TRACE
static void GL_PrintBufferState(FILE* debug_frame_out, int debug_frame_depth)
{
	char label[64];

	if (glBufferState.currentArrayBuffer) {
		GL_TraceObjectLabelGet(GL_BUFFER, glBufferState.currentArrayBuffer, sizeof(label), NULL, label);
		fprintf(debug_frame_out, "%.*s   ArrayBuffer: %u (%s)\n", debug_frame_depth, "                                                          ", glBufferState.currentArrayBuffer, label);
	}
	if (glBufferState.currentElementArrayBuffer) {
		GL_TraceObjectLabelGet(GL_BUFFER, glBufferState.currentElementArrayBuffer, sizeof(label), NULL, label);
		fprintf(debug_frame_out, "%.*s   ElementArray: %u (%s)\n", debug_frame_depth, "                                                          ", glBufferState.currentElementArrayBuffer, label);
	}
}
#endif

void R_Stub_NoOperation(void)
{
}

qbool R_Stub_True(void)
{
	return true;
}

qbool R_Stub_False(void)
{
	return false;
}

uintptr_t R_Stub_BufferZero(r_buffer_id ref)
{
	return 0;
}

void GL_InitialiseBufferHandling(api_buffers_t* api)
{
	qbool buffers_supported = renderer.vaos_supported;

	memset(api, 0, sizeof(*api));

	GL_LoadMandatoryFunctionExtension(glBindBuffer, buffers_supported);
	GL_LoadMandatoryFunctionExtension(glBufferData, buffers_supported);
	GL_LoadMandatoryFunctionExtension(glBufferSubData, buffers_supported);
	GL_LoadMandatoryFunctionExtension(glGenBuffers, buffers_supported);
	GL_LoadMandatoryFunctionExtension(glDeleteBuffers, buffers_supported);
	GL_LoadMandatoryFunctionExtension(glUnmapBuffer, buffers_supported);

	R_TraceAPI("Buffers supported: %s", buffers_supported ? "yes" : "no (!)");

	// OpenGL 3.0 onwards, for 4.3+ support only
	if (GL_VersionAtLeast(3, 0)) {
		GL_LoadOptionalFunction(glBindBufferBase);
		GL_LoadOptionalFunction(glBindBufferRange);
	} else {
		GL_InvalidateFunction(glBindBufferBase);
		GL_InvalidateFunction(glBindBufferRange);
	}

	// OpenGL 4.4, persistent mapping of buffers
	glBufferState.tripleBuffer_supported = !COM_CheckParm(cmdline_param_client_notriplebuffering);
	if (GL_VersionAtLeast(3, 2) || SDL_GL_ExtensionSupported("GL_ARB_sync")) {
		GL_LoadMandatoryFunctionExtension(glFenceSync, glBufferState.tripleBuffer_supported);
		GL_LoadMandatoryFunctionExtension(glClientWaitSync, glBufferState.tripleBuffer_supported);
		GL_LoadMandatoryFunctionExtension(glDeleteSync, glBufferState.tripleBuffer_supported);
	}
	else {
		glBufferState.tripleBuffer_supported = false;
		GL_InvalidateFunction(glFenceSync);
		GL_InvalidateFunction(glClientWaitSync);
		GL_InvalidateFunction(glDeleteSync);
	}
	if (GL_VersionAtLeast(4, 4) || SDL_GL_ExtensionSupported("GL_ARB_buffer_storage")) {
		GL_LoadMandatoryFunctionExtension(glBufferStorage, glBufferState.tripleBuffer_supported);
	}
	else {
		glBufferState.tripleBuffer_supported = false;
		GL_InvalidateFunction(glBufferStorage);
	}
	if (GL_VersionAtLeast(3, 0)) {
		GL_LoadMandatoryFunctionExtension(glMapBufferRange, glBufferState.tripleBuffer_supported);
	}
	else {
		glBufferState.tripleBuffer_supported = false;
		GL_InvalidateFunction(glMapBufferRange);
	}

	// OpenGL 4.5 onwards, update directly
	if (GL_UseDirectStateAccess()) {
		GL_LoadOptionalFunction(glNamedBufferSubData);
		GL_LoadOptionalFunction(glNamedBufferData);
		GL_LoadOptionalFunction(glUnmapNamedBuffer);
	} else {
		GL_InvalidateFunction(glNamedBufferSubData);
		GL_InvalidateFunction(glNamedBufferData);
		GL_InvalidateFunction(glUnmapNamedBuffer);
	}

	glBufferState.tripleBuffer_supported &= buffers_supported;

	api->supported = buffers_supported;
	if (!api->supported) {
		api->FrameReady = R_Stub_True;
		api->IsValid = R_Stub_BufferNotValid;
		api->InitialiseState = api->Shutdown = R_Stub_NoOperation;
		api->StartFrame = api->EndFrame = R_Stub_NoOperation;
		api->BufferOffset = R_Stub_BufferZero;

		Con_Printf("Using GL buffers: disabled\n");
	}
	else {
		api->Bind = GL_BindBuffer;
		api->BindBase = GL_BindBufferBase;
		api->BindRange = GL_BindBufferRange;
		api->BufferOffset = GL_BufferOffset;
		api->Create = GL_CreateFixedBuffer;

		api->StartFrame = GL_BufferStartFrame;
		api->EndFrame = GL_BufferEndFrame;
		api->FrameReady = GL_BuffersReady;

		api->EnsureSize = GL_EnsureBufferSize;
		api->Resize = GL_ResizeBuffer;

		api->InitialiseState = GL_InitialiseBufferState;
		api->Size = GL_BufferSize;
		api->UnBind = GL_UnBindBuffer;
		api->Update = GL_UpdateBuffer;
		api->UpdateSection = GL_UpdateBufferSection;

		api->Shutdown = GL_BufferShutdown;
		api->SetElementArray = GL_SetElementArrayBuffer;
		api->IsValid = GL_BufferValid;
#ifdef WITH_RENDERING_TRACE
		api->PrintState = GL_PrintBufferState;
#endif
		api->supported = true;

		Con_Printf("Triple-buffering of GL buffers: %s\n", glBufferState.tripleBuffer_supported ? "enabled" : "disabled");
	}
}


================================================
FILE: src/gl_debug.c
================================================
/*
Copyright (C) 2002-2003 A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// gl_debug.c - OpenGL dev-only & debugging wrappers
#include <SDL.h>

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_texture.h"
#include "r_renderer.h"
#include "utils.h"
#include "gl_texture_internal.h"

#ifdef WITH_RENDERING_TRACE
static int debug_frame_depth = 0;
static unsigned long regions_trace_only;
static qbool dev_frame_debug_queued;
static FILE* debug_frame_out;
void GL_VerifyState(FILE* output);

#define DEBUG_FRAME_DEPTH_CHARS 2
#endif

GLuint GL_TextureNameFromReference(texture_ref ref);

// <debug-functions (4.3)>
GL_StaticProcedureDeclaration(glDebugMessageCallback, "callback=%p, userParam=%p", GLDEBUGPROC callback, void* userParam)
GL_StaticProcedureDeclaration(glDebugMessageControl, "source=%u, type=%u, severity=%u, count=%d, ids=%p, enabled=%d", GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled)

#ifdef WITH_RENDERING_TRACE
GL_StaticProcedureDeclaration(glPushDebugGroup, "source=%u, id=%u, length=%d, message=%s", GLenum source, GLuint id, GLsizei length, const char* message)
GL_StaticProcedureDeclaration(glPopDebugGroup, "", void)
GL_StaticProcedureDeclaration(glObjectLabel, "identifier=%u, name=%u, length=%d, label=%s", GLenum identifier, GLuint name, GLsizei length, const char* label)
GL_StaticProcedureDeclaration(glGetObjectLabel, "identifier=%u, name=%u, bufSize=%d, length=%p, label=%s", GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, char* label)
#endif
// </debug-functions>

// Debugging
// In Visual Studio, messages from the driver appear in Output tab
void APIENTRY MessageCallback(GLenum source,
							  GLenum type,
							  GLuint id,
							  GLenum severity,
							  GLsizei length,
							  const GLchar* message,
							  const void* userParam
)
{
	// FIXME: think this is caused by having fixed maximum array of samplers
	// - either bind to solidblack or have multiple programs and switch depending on # of texture units being used
	if (severity == GL_DEBUG_SEVERITY_LOW && strstr(message, "texture object (0) bound to")) {
		return;
	}

	if (source != GL_DEBUG_SOURCE_APPLICATION) {
		char buffer[1024] = { 0 };

		if (type == GL_DEBUG_TYPE_ERROR) {
			snprintf(buffer, sizeof(buffer) - 1,
					 "GL CALLBACK: ** GL ERROR ** type = 0x%x, severity = 0x%x, message = %s\n",
					 type, severity, message);
		}
		else {
			snprintf(buffer, sizeof(buffer) - 1,
					 "GL CALLBACK: type = 0x%x, severity = 0x%x, message = %s\n",
					 type, severity, message);
		}

#ifdef WITH_RENDERING_TRACE
		if (debug_frame_out) {
			fprintf(debug_frame_out, "%s", buffer);
			fflush(debug_frame_out);
		}
#endif
#ifdef _WIN32
		if (IsDebuggerPresent()) {
			OutputDebugString(buffer);
		}
		else {
			printf("[OGL] %s\n", buffer);
		}
#else
		printf("[OGL] %s\n", buffer);
#endif
	}
}

void GL_InitialiseDebugging(void)
{
	// During init, enable debug output
	if (R_DebugProfileContext()) {
		GL_LoadOptionalFunction(glDebugMessageCallback);
		GL_LoadOptionalFunction(glDebugMessageControl);

		if (GL_Available(glDebugMessageCallback) && !COM_CheckParm(cmdline_param_client_nocallback)) {
			glEnable(GL_DEBUG_OUTPUT);
			glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
			GL_Procedure(glDebugMessageCallback, (GLDEBUGPROC)MessageCallback, 0);
		}

		if (GL_Available(glDebugMessageControl) && !COM_CheckParm(cmdline_param_client_nocallback)) {
			GL_Procedure(glDebugMessageControl, GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
		}
	}

#ifdef WITH_RENDERING_TRACE
	GL_LoadOptionalFunction(glObjectLabel);
	GL_LoadOptionalFunction(glGetObjectLabel);
	GL_LoadOptionalFunction(glPushDebugGroup);
	GL_LoadOptionalFunction(glPopDebugGroup);
#endif
}

#ifdef WITH_RENDERING_TRACE
void R_TraceEnterRegion(const char* regionName, qbool trace_only)
{
	if (debug_frame_out) {
		fprintf(debug_frame_out, "Enter: %.*s %s {\n", debug_frame_depth, "                                                          ", regionName);
		fflush(debug_frame_out);
		debug_frame_depth += DEBUG_FRAME_DEPTH_CHARS;
	}
	else if (R_UseModernOpenGL()) {
		if (!trace_only && GL_Available(glPushDebugGroup)) {
			GL_Procedure(glPushDebugGroup, GL_DEBUG_SOURCE_APPLICATION, 0, -1, regionName);
		}
	}

	regions_trace_only <<= 1;
	regions_trace_only &= (trace_only ? 1 : 0);
}

void R_TraceLeaveRegion(qbool trace_only)
{
	if (debug_frame_out) {
		debug_frame_depth -= DEBUG_FRAME_DEPTH_CHARS;
		debug_frame_depth = max(debug_frame_depth, 0);
		fprintf(debug_frame_out, "Leave: %.*s }\n", debug_frame_depth, "                                                          ");
		fflush(debug_frame_out);
	}
	else if (R_UseModernOpenGL()) {
		if (!trace_only && GL_Available(glPopDebugGroup)) {
			GL_ProcedureNoArgs(glPopDebugGroup);
		}
	}
}

qbool R_TraceLoggingEnabled(void)
{
	return debug_frame_out != NULL;
}

void R_TraceAPI(const char* format, ...)
{
	if (debug_frame_out) {
		va_list argptr;
		char msg[4096];

		va_start(argptr, format);
		vsnprintf(msg, sizeof(msg), format, argptr);
		va_end(argptr);

		fprintf(debug_frame_out, "API:   %.*s %s\n", debug_frame_depth, "                                                          ", msg);
		fflush(debug_frame_out);
	}
	else  {

	}
}

void R_TraceLogAPICallDirect(const char* format, ...)
{
	if (debug_frame_out) {
		va_list argptr;
		char msg[4096];

		va_start(argptr, format);
		vsnprintf(msg, sizeof(msg), format, argptr);
		va_end(argptr);

		fprintf(debug_frame_out, "API:   %.*s %s\n", debug_frame_depth, "                                                          ", msg);
		fflush(debug_frame_out);
	}
}

void R_TraceResetRegion(qbool start)
{
	if (start && debug_frame_out) {
		fclose(debug_frame_out);
		debug_frame_out = NULL;
		dev_frame_debug_queued = COM_CheckParm(cmdline_param_client_video_r_trace);
	}

	if (start && dev_frame_debug_queued) {
		char fileName[MAX_PATH];
#ifndef _WIN32
		time_t t;
		struct tm date;
		t = time(NULL);
		localtime_r(&t, &date);

		snprintf(fileName, sizeof(fileName), "%s/qw/%s/frame_%04d-%02d-%02d_%02d-%02d-%02d.txt",
				 com_basedir, COM_CheckParm(cmdline_param_client_video_r_trace) ? "trace/" : "", 1900 + date.tm_year, 1 + date.tm_mon, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
#else
		SYSTEMTIME date;
		int i;

		GetLocalTime(&date);

		for (i = 0; i < 1000; ++i) {
			FILE* temp;

			snprintf(fileName, sizeof(fileName), "%s/qw/%s/frame_%04d-%02d-%02d_%02d-%02d-%02d_%04d.txt",
				com_basedir, COM_CheckParm(cmdline_param_client_video_r_trace) ? "trace/" : "", date.wYear, date.wMonth, date.wDay, date.wHour, date.wMinute, date.wSecond, i);

			if ((temp = fopen(fileName, "rt"))) {
				fclose(temp);
				continue;
			}

			break;
		}
#endif

		if (COM_CheckParm(cmdline_param_client_video_r_trace)) {
			Sys_mkdir(va("%s/qw/trace", com_basedir));
		}

		debug_frame_out = fopen(fileName, "wt");
		dev_frame_debug_queued = false;
	}

	if (debug_frame_out) {
		fprintf(debug_frame_out, "---Reset---\n");
		fflush(debug_frame_out);
		debug_frame_depth = 0;
	}
}

void GL_TraceObjectLabelSet(GLenum identifier, GLuint name, int length, const char* label)
{
	if (GL_Available(glObjectLabel)) {
		GL_Procedure(glObjectLabel, identifier, name, length, label ? label : "?");
	}
}

void GL_TraceObjectLabelGet(GLenum identifier, GLuint name, int bufSize, int* length, char* label)
{
	label[0] = '\0';
	if (GL_Available(glGetObjectLabel)) {
		GL_Procedure(glGetObjectLabel, identifier, name, bufSize, length, label);
	}
}

void GL_TextureLabelSet(texture_ref ref, const char* label)
{
	GL_TraceObjectLabelSet(GL_TEXTURE, GL_TextureNameFromReference(ref), -1, label);
}

void GL_TextureLabelGet(texture_ref ref, int bufSize, int* length, char* label)
{
	GL_TraceObjectLabelGet(GL_TEXTURE, GL_TextureNameFromReference(ref), bufSize, length, label);
}

void Dev_VidFrameStart(void)
{
	Dev_VidFrameTrace();
	R_TraceResetRegion(true);
}

void Dev_VidFrameTrace(void)
{
	dev_frame_debug_queued = true;
}

void R_TraceDebugState(void)
{
	if (debug_frame_out) {
		R_TracePrintState(debug_frame_out, debug_frame_depth);
	}
	if (COM_CheckParm(cmdline_param_client_verify_glstate)) {
		GL_VerifyState(debug_frame_out);
	}
}

void Dev_VidTextureDump(void)
{
	char folder[MAX_PATH];
	byte* buffer = NULL;
	byte* row = NULL;
	int buffer_size = 0;
	int row_size = 0;
	int i, j;
#ifndef _WIN32
	time_t t;
	struct tm date;
	t = time(NULL);
	localtime_r(&t, &date);

	snprintf(folder, sizeof(folder), "%s/qw/textures_%04d-%02d-%02d_%02d-%02d-%02d",
		com_basedir, 1900 + date.tm_year, 1 + date.tm_mon, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
#else
	SYSTEMTIME date;
	GetLocalTime(&date);

	snprintf(folder, sizeof(folder), "%s/qw/textures_%04d-%02d-%02d_%02d-%02d-%02d",
		com_basedir, date.wYear, date.wMonth, date.wDay, date.wHour, date.wMinute, date.wSecond);
#endif

	strlcat(folder, "/", sizeof(folder));
	FS_CreatePath(folder);

	for (i = 0; i < R_TextureCount(); ++i) {
		texture_ref ref = { i };

		if (R_TextureReferenceIsValid(ref)) {
			int row_length = R_TextureWidth(ref) * 4;
			int size = R_TextureWidth(ref) * R_TextureHeight(ref) * 4;
			if (size > buffer_size) {
				Q_free(buffer);
				buffer = Q_malloc(size);
				buffer_size = size;
			}
			else if (buffer_size) {
				memset(buffer, 0, buffer_size);
			}

			if (row_length > row_size) {
				Q_free(row);
				row = Q_malloc(row_length);
				row_size = row_length;
			}

			if (!size) {
				continue;
			}

			if (size) {
				char reftext[10];
				char filename[MAX_OSPATH];

				snprintf(reftext, sizeof(reftext), "%03d", i);
				strlcpy(filename, reftext, sizeof(filename));
				strlcat(filename, "-", sizeof(filename));
				strlcat(filename, R_TextureIdentifier(ref), sizeof(filename));
				Util_ToValidFileName(filename, filename, sizeof(filename));

				if (R_TextureType(ref) == texture_type_2d) {
					scr_sshot_target_t* sshot_params = Q_malloc(sizeof(scr_sshot_target_t));

					renderer.TextureGet(ref, buffer_size, buffer, 3);

					COM_ForceExtension(filename, ".png");
					sshot_params->buffer = buffer;
					sshot_params->freeMemory = false;
					sshot_params->format = IMAGE_PNG;
					strlcpy(sshot_params->fileName, folder, sizeof(sshot_params->fileName));
					strlcat(sshot_params->fileName, filename, sizeof(sshot_params->fileName));
					sshot_params->width = R_TextureWidth(ref);
					sshot_params->height = R_TextureHeight(ref);

					for (j = 0; j < sshot_params->height / 2; ++j) {
						size_t row_bytes = sshot_params->width * 3;
						byte* this_row = &buffer[j * row_bytes];
						byte* flipped_row = &buffer[(sshot_params->height - j - 1) * row_bytes];

						memcpy(row, this_row, row_bytes);
						memcpy(this_row, flipped_row, row_bytes);
						memcpy(flipped_row, row, row_bytes);
					}
					SCR_ScreenshotWrite(sshot_params);
				}
				else if (R_TextureType(ref) == texture_type_cubemap) {
					char side_filename[MAX_OSPATH];
					const char* side_labels[] = { "-pos-x", "-neg-x", "-pos-y", "-neg-y", "-pos-z", "-neg-z" };
					int j;

					GL_BindTextureUnit(GL_TEXTURE0, ref);
					for (j = 0; j < 6; ++j) {
						scr_sshot_target_t* sshot_params = Q_malloc(sizeof(scr_sshot_target_t));

						strlcpy(side_filename, filename, sizeof(side_filename));
						strlcat(side_filename, side_labels[j], sizeof(side_filename));
						COM_ForceExtension(side_filename, ".png");

						glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + j, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer);

						sshot_params->buffer = buffer;
						sshot_params->freeMemory = false;
						sshot_params->format = IMAGE_PNG;
						strlcpy(sshot_params->fileName, folder, sizeof(sshot_params->fileName));
						strlcat(sshot_params->fileName, side_filename, sizeof(sshot_params->fileName));
						sshot_params->width = R_TextureWidth(ref);
						sshot_params->height = R_TextureHeight(ref);
						SCR_ScreenshotWrite(sshot_params);
					}
				}
			}
		}
	}

	Q_free(buffer);
	Q_free(row);
}

#endif // WITH_RENDERING_TRACE


================================================
FILE: src/gl_drawcall_wrappers.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include <SDL.h>

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "tr_types.h"
#include "r_vao.h"

// <draw-functions (various)>
GL_StaticProcedureDeclaration(glMultiDrawArrays, "mode=%u, first=%p, count=%p, drawcount=%d", GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount)
GL_StaticProcedureDeclaration(glMultiDrawElements, "mode=%u, count=%p, type=%u, indices=%p, drawcount=%d", GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei drawcount)
GL_StaticProcedureDeclaration(glDrawElementsBaseVertex, "mode=%u, count=%d, type=%u, indices=%p, basevertex=%d", GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLint basevertex)
GL_StaticProcedureDeclaration(glPrimitiveRestartIndex, "index=%u", GLuint index)

// (modern/4.3+)
// typedef void (APIENTRY *glDrawArraysInstanced_t)(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
GL_StaticProcedureDeclaration(glMultiDrawArraysIndirect, "mode=%u, indirect=%p, drawcount=%d, stride=%d", GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride)
GL_StaticProcedureDeclaration(glMultiDrawElementsIndirect, "mode=%u, type=%u, indirect=%p, drawcount=%d, stride=%d", GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride)
GL_StaticProcedureDeclaration(glDrawArraysInstancedBaseInstance, "mode=%u, first=%d, count=%d, primcount=%d, baseinstance=%u", GLenum mode, GLint first, GLsizei count, GLsizei primcount, GLuint baseinstance)
GL_StaticProcedureDeclaration(glDrawElementsInstancedBaseInstance, "mode=%u, count=%d, type=%u, indices=%p, primcount=%d, baseinstance=%d", GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount, GLuint baseinstance)
GL_StaticProcedureDeclaration(glDrawElementsInstancedBaseVertexBaseInstance, "mode=%u, count=%d, type=%u, indices=%p, primcount=%d, basevertex=%d, baseinstance=%u", GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei primcount, GLint basevertex, GLuint baseinstance)
GL_StaticProcedureDeclaration(glDrawElementsIndirect, "mode=%u, type=%u, indirect=%p", GLenum mode, GLenum type, GLvoid* indirect)
GL_StaticProcedureDeclaration(glDrawArraysIndirect, "mode=%u, indirect=%p", GLenum mode, const void* indirect)
GL_StaticProcedureDeclaration(glUniformBlockBinding, "program=%u, index=%u, binding=%u", GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
GL_StaticFunctionDeclaration(glGetUniformBlockIndex, "program=%u, name=%s", "returns %u", GLuint, GLuint program, const GLchar *uniformBlockName)
GL_StaticFunctionWrapperBody(glGetUniformBlockIndex, GLuint, program, uniformBlockName)
// </draw-functions>

void GL_LoadDrawFunctions(void)
{
	glConfig.supported_features &= ~(R_SUPPORT_INDIRECT_RENDERING | R_SUPPORT_INSTANCED_RENDERING | R_SUPPORT_PRIMITIVERESTART);

	if (GL_VersionAtLeast(4, 3) || SDL_GL_ExtensionSupported("GL_ARB_multi_draw_indirect")) {
		qbool all_available = true;

		GL_LoadMandatoryFunctionExtension(glMultiDrawArraysIndirect, all_available);
		GL_LoadMandatoryFunctionExtension(glMultiDrawElementsIndirect, all_available);

		glConfig.supported_features |= (all_available ? R_SUPPORT_INDIRECT_RENDERING : 0);
	} else {
		GL_InvalidateFunction(glMultiDrawArraysIndirect);
		GL_InvalidateFunction(glMultiDrawElementsIndirect);
	}

	if (GL_VersionAtLeast(4, 2) || SDL_GL_ExtensionSupported("GL_ARB_base_instance")) {
		qbool all_available = true;

		GL_LoadMandatoryFunctionExtension(glDrawArraysInstancedBaseInstance, all_available);
		GL_LoadMandatoryFunctionExtension(glDrawElementsInstancedBaseInstance, all_available);
		GL_LoadMandatoryFunctionExtension(glDrawElementsInstancedBaseVertexBaseInstance, all_available);

		glConfig.supported_features |= (all_available ? R_SUPPORT_INSTANCED_RENDERING : 0);
	} else {
		GL_InvalidateFunction(glDrawArraysInstancedBaseInstance);
		GL_InvalidateFunction(glDrawElementsInstancedBaseInstance);
		GL_InvalidateFunction(glDrawElementsInstancedBaseVertexBaseInstance);
	}

	// GL 4.0 core: indirect draw and UBO binding functions
	if (GL_VersionAtLeast(4, 0)) {
		GL_LoadOptionalFunction(glDrawElementsIndirect);
		GL_LoadOptionalFunction(glDrawArraysIndirect);
	} else {
		GL_InvalidateFunction(glDrawElementsIndirect);
		GL_InvalidateFunction(glDrawArraysIndirect);
	}
	if (GL_VersionAtLeast(3, 1)) {
		GL_LoadOptionalFunction(glUniformBlockBinding);
		GL_LoadOptionalFunction(glGetUniformBlockIndex);
	} else {
		GL_InvalidateFunction(glUniformBlockBinding);
		GL_InvalidateFunction(glGetUniformBlockIndex);
	}

	// Draw functions used for modern & classic
	GL_LoadOptionalFunction(glMultiDrawArrays);
	GL_LoadOptionalFunction(glMultiDrawElements);

	// Use this instead of glDrawArrays() if on particular drivers (see github bug #416)
	if (GL_Available(glMultiDrawArrays) && glConfig.amd_issues) {
		glConfig.broken_features |= R_BROKEN_PREFERMULTIDRAW;
	}

	if (GL_VersionAtLeast(3, 2) || SDL_GL_ExtensionSupported("GL_ARB_draw_elements_base_vertex")) {
		GL_LoadOptionalFunction(glDrawElementsBaseVertex);
	} else {
		GL_InvalidateFunction(glDrawElementsBaseVertex);
	}

	GL_InvalidateFunction(glPrimitiveRestartIndex);

	glConfig.supported_features &= ~R_SUPPORT_PRIMITIVERESTART;
	if (R_UseModernOpenGL() || GL_VersionAtLeast(3, 1)) {
		GL_LoadOptionalFunction(glPrimitiveRestartIndex);
		if (GL_Available(glPrimitiveRestartIndex)) {
			glEnable(GL_PRIMITIVE_RESTART);
			if (GL_VersionAtLeast(4, 3)) {
				glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
			}
			else {
				GL_Procedure(glPrimitiveRestartIndex, (~(GLuint)0));
			}
			glConfig.supported_features |= R_SUPPORT_PRIMITIVERESTART;
		}
	}
}

// Wrappers around drawing functions
void GL_MultiDrawArrays(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount)
{
	if (GL_Available(glMultiDrawArrays)) {
		GL_Procedure(glMultiDrawArrays, mode, first, count, primcount);
		++frameStats.draw_calls;
		frameStats.subdraw_calls += primcount;
	}
	else {
		int i;
		for (i = 0; i < primcount; ++i) {
			GL_DrawArrays(mode, first[i], count[i]);
		}
	}
}

void GL_DrawArrays(GLenum mode, GLint first, GLsizei count)
{
	R_TraceLogAPICall("glDrawArrays(%d verts)", count);
	assert(R_VAOBound());
	if (!R_VAOBound()) {
		Con_Printf("GL_DrawArrays() with no VAO bound\n");
		return;
	}
	if (GL_WorkaroundNeeded(R_BROKEN_PREFERMULTIDRAW) && GL_Available(glMultiDrawArrays)) {
		GL_Procedure(glMultiDrawArrays, mode, &first, &count, 1);
	}
	else {
		GL_BuiltinProcedure(glDrawArrays, "(mode=%u, first=%d, count=%d)", mode, first, count);
	}
	++frameStats.draw_calls;
}

void GL_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLint basevertex)
{
	if (basevertex && !GL_Available(glDrawElementsBaseVertex)) {
		Sys_Error("glDrawElementsBaseVertex called, not supported");
	}
	else if (GL_Available(glDrawElementsBaseVertex)) {
		GL_Procedure(glDrawElementsBaseVertex, mode, count, type, indices, basevertex);
	}
	else {
		GL_BuiltinProcedure(glDrawElements, "mode=%u, count=%d, type=%u, indices=%p", mode, count, type, indices);
	}
	++frameStats.draw_calls;
}

qbool GL_DrawElementsBaseVertexAvailable(void)
{
	return GL_Available(glDrawElementsBaseVertex);
}

void GL_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
{
	R_TraceLogAPICall("glDrawElements(%d verts)", count);
	glDrawElements(mode, count, type, indices);
	++frameStats.draw_calls;
}

void GL_MultiDrawArraysIndirect(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride)
{
	if (GL_Available(glMultiDrawArraysIndirect)) {
		GL_Procedure(glMultiDrawArraysIndirect, mode, indirect, drawcount, stride);
	}
	else if (GL_Available(glDrawArraysIndirect)) {
		int actual_stride = stride ? stride : (4 * sizeof(GLuint));
		int i;
		for (i = 0; i < drawcount; i++) {
			GL_Procedure(glDrawArraysIndirect, mode, (const char*)indirect + i * actual_stride);
		}
	}
	++frameStats.draw_calls;
	frameStats.subdraw_calls += drawcount;
}

void GL_MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride)
{
	if (GL_Available(glMultiDrawElementsIndirect)) {
		GL_Procedure(glMultiDrawElementsIndirect, mode, type, indirect, drawcount, stride);
	}
	else if (GL_Available(glDrawElementsIndirect)) {
		int actual_stride = stride ? stride : (5 * sizeof(GLuint));
		int i;
		for (i = 0; i < drawcount; i++) {
			GL_Procedure(glDrawElementsIndirect, mode, type, (const char*)indirect + i * actual_stride);
		}
	}
	++frameStats.draw_calls;
	frameStats.subdraw_calls += drawcount;
}

void GL_DrawElementsIndirect(GLenum mode, GLenum type, GLvoid* indirect)
{
	GL_Procedure(glDrawElementsIndirect, mode, type, indirect);
	++frameStats.draw_calls;
}

void GL_DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei primcount, GLint basevertex, GLuint baseinstance)
{
	if (GL_Available(glDrawElementsInstancedBaseVertexBaseInstance)) {
		GL_Procedure(glDrawElementsInstancedBaseVertexBaseInstance, mode, count, type, indices, primcount, basevertex, baseinstance);
	}
	else {
		GL_DrawElementsBaseVertex(mode, count, type, indices, basevertex);
	}
	++frameStats.draw_calls;
}

void GL_UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
{
	GL_Procedure(glUniformBlockBinding, program, uniformBlockIndex, uniformBlockBinding);
}

GLuint GL_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
{
	if (!GL_Available(glGetUniformBlockIndex)) {
		return GL_INVALID_INDEX;
	}
	return GL_Function(glGetUniformBlockIndex, program, uniformBlockName);
}


================================================
FILE: src/gl_framebuffer.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// Loads and does all the framebuffer stuff

// Seems the original was for camquake & ported across to draw the hud on, but not used
//   Re-using file for deferred rendering & post-processing in modern

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "gl_framebuffer.h"
#include "tr_types.h"
#include "r_texture.h"
#include "gl_texture_internal.h"
#include "r_renderer.h"
#include "rulesets.h"

extern cvar_t vid_framebuffer;
extern cvar_t vid_framebuffer_depthformat;
extern cvar_t vid_software_palette;
extern cvar_t vid_framebuffer_hdr;
extern cvar_t vid_framebuffer_blit;
extern cvar_t vid_framebuffer_smooth;
extern cvar_t vid_framebuffer_multisample;
extern cvar_t gl_outline;

static framebuffer_id VID_MultisampledAlternateId(framebuffer_id id);

#ifndef GL_NEGATIVE_ONE_TO_ONE
#define GL_NEGATIVE_ONE_TO_ONE            0x935E
#endif

#ifndef GL_ZERO_TO_ONE
#define GL_ZERO_TO_ONE                    0x935F
#endif

// If this isn't defined, we use simple texture for depth buffer
//   in theory render buffers _might_ be better, as they can't be read from
#define GL_USE_RENDER_BUFFERS

// OpenGL functionality from elsewhere
GLuint GL_TextureNameFromReference(texture_ref ref);

// OpenGL wrapper functions
#ifdef GL_USE_RENDER_BUFFERS
#define EZ_USE_FIXED_SAMPLE_LOCATIONS (GL_TRUE)
static void GL_RenderBufferStorageMultisample(GLuint renderBuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
static void GL_RenderBufferStorage(GLuint renderBuffer, GLenum internalformat, GLsizei width, GLsizei height);
static void GL_FramebufferRenderbuffer(GLuint fbref, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
static void GL_GenRenderBuffers(GLsizei n, GLuint* buffers);
#else
#define EZ_USE_FIXED_SAMPLE_LOCATIONS (GL_FALSE)
#endif
static GLenum GL_CheckFramebufferStatus(GLuint fbref);
static void GL_FramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
static void GL_GenFramebuffers(GLsizei n, GLuint* buffers);
static void GL_FramebufferBlitSimple(framebuffer_id source_id, framebuffer_id destination_id);

typedef struct framebuffer_data_s {
	GLuint glref;
	texture_ref texture[fbtex_count];
	GLuint depthBuffer;
	GLenum depthFormat;

	GLsizei width;
	GLsizei height;
	GLenum status;
	int samples;
} framebuffer_data_t;

static const char* framebuffer_names[] = {
	"none", // framebuffer_none
	"std", // framebuffer_std,
	"std-ms", // framebuffer_std_ms,
	"hud", // framebuffer_hud
	"hud-ms", // framebuffer_hud_ms,
	"std-blit", // framebuffer_std_blit
	"std-blit-ms", // framebuffer_std_blit_ms
	"hud-blit", // framebuffer_hud_blit
	"hud-blit-ms", // framebuffer_hud_blit_ms
};
static const char* framebuffer_texture_names[] = {
	"std", // fbtex_standard,
	"depth", // fbtex_depth
	"env", // fbtex_bloom,
	"norms", // fbtex_worldnormals,
};
static qbool framebuffer_depth_buffer[] = {
	false, // framebuffer_none
	true, // framebuffer_std
	true, // framebuffer_std_ms
	false, // framebuffer_hud
	false, // framebuffer_hud_ms
	false, // framebuffer_std_blit
	false, // framebuffer_std_blit_ms
	false, // framebuffer_hud_blit
	false, // framebuffer_hud_blit_ms
};
static qbool framebuffer_hdr[] = {
	false, // framebuffer_none
	true, // framebuffer_std
	true, // framebuffer_std_ms
	false, // framebuffer_hud
	false, // framebuffer_hud_ms
	false, // framebuffer_std_blit
	false, // framebuffer_std_blit_ms
	false, // framebuffer_hud_blit
	false, // framebuffer_hud_blit_ms
};
static qbool framebuffer_alpha[] = {
	false, // framebuffer_none
	false, // framebuffer_std
	false, // framebuffer_std_ms
	true, // framebuffer_hud
	true, // framebuffer_hud_ms
	false, // framebuffer_std_blit
	false, // framebuffer_std_blit_ms
	false, // framebuffer_hud_blit
	false, // framebuffer_hud_blit_ms
};
static qbool framebuffer_multisampled[] = {
	false, // framebuffer_none
	false, // framebuffer_std
	true, // framebuffer_std_ms
	false, // framebuffer_hud
	true, // framebuffer_hud_ms
	false, // framebuffer_std_blit
	true, // framebuffer_std_blit_ms
	false, // framebuffer_hud_blit
	true, // framebuffer_hud_blit_ms
};
static framebuffer_id framebuffer_multisample_alternate[] = {
	framebuffer_none,
	// rendering
	framebuffer_std_ms,
	framebuffer_std_ms,
	framebuffer_hud_ms,
	framebuffer_hud_ms,
	// framebuffers used to resolve multisampling
	framebuffer_none,
	framebuffer_none,
	framebuffer_none,
	framebuffer_none,
};

#ifdef C_ASSERT
C_ASSERT(sizeof(framebuffer_names) / sizeof(framebuffer_names[0]) == framebuffer_count);
C_ASSERT(sizeof(framebuffer_texture_names) / sizeof(framebuffer_texture_names[0]) == fbtex_count);
C_ASSERT(sizeof(framebuffer_depth_buffer) / sizeof(framebuffer_depth_buffer[0]) == framebuffer_count);
C_ASSERT(sizeof(framebuffer_multisampled) / sizeof(framebuffer_multisampled[0]) == framebuffer_count);
C_ASSERT(sizeof(framebuffer_alpha) / sizeof(framebuffer_alpha[0]) == framebuffer_count);
C_ASSERT(sizeof(framebuffer_hdr) / sizeof(framebuffer_hdr[0]) == framebuffer_count);
C_ASSERT(sizeof(framebuffer_multisample_alternate) / sizeof(framebuffer_multisample_alternate[0]) == framebuffer_count);
#endif

static framebuffer_data_t framebuffer_data[framebuffer_count];

//
GL_StaticProcedureDeclaration(glGenFramebuffers, "n=%d, ids=%p", GLsizei n, GLuint* ids)
GL_StaticProcedureDeclaration(glDeleteFramebuffers, "n=%d, ids=%p", GLsizei n, GLuint* ids)
GL_StaticProcedureDeclaration(glBindFramebuffer, "target=%u, framebuffer=%u", GLenum target, GLuint framebuffer)

GL_StaticProcedureDeclaration(glGenRenderbuffers, "n=%d, ids=%p", GLsizei n, GLuint* ids)
GL_StaticProcedureDeclaration(glDeleteRenderbuffers, "n=%d, ids=%p", GLsizei n, GLuint* ids)
GL_StaticProcedureDeclaration(glBindRenderbuffer, "target=%u, renderbuffer=%u", GLenum target, GLuint renderbuffer)
GL_StaticProcedureDeclaration(glRenderbufferStorage, "target=%u, internalformat=%u, width=%d, height=%d", GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
GL_StaticProcedureDeclaration(glNamedRenderbufferStorage, "renderbuffer=%u, internalformat=%u, width=%d, height=%d", GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
GL_StaticProcedureDeclaration(glFramebufferRenderbuffer, "target=%u, attachment=%u, renderbuffertarget=%u, renderbuffer=%u", GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
GL_StaticProcedureDeclaration(glNamedFramebufferRenderbuffer, "framebuffer=%u, attachment=%u, renderbuffertarget=%u, renderbuffer=%u", GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)

GL_StaticProcedureDeclaration(glFramebufferTexture, "target=%u, attachment=%u, texture=%u, level=%d", GLenum target, GLenum attachment, GLuint texture, GLint level);
GL_StaticProcedureDeclaration(glNamedFramebufferTexture, "framebuffer=%u, attachment=%u, texture=%u, level=%d", GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
GL_StaticFunctionDeclaration(glCheckFramebufferStatus, "target=%u", "result=%u", GLenum, GLenum target)
GL_StaticFunctionWrapperBody(glCheckFramebufferStatus, GLenum, target)
GL_StaticFunctionDeclaration(glCheckNamedFramebufferStatus, "framebuffer=%u, target=%u", "result=%u", GLenum, GLuint framebuffer, GLenum target)
GL_StaticFunctionWrapperBody(glCheckNamedFramebufferStatus, GLenum, framebuffer, target)
GL_StaticProcedureDeclaration(glBlitFramebuffer, "srcX0=%d, srcY0=%d, srcX1=%d, srcY1=%d, dstX0=%d, dstY0=%d, dstX1=%d, dstY1=%d, mask=%u, filter=%u", GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
GL_StaticProcedureDeclaration(glBlitNamedFramebuffer, "readFrameBuffer=%u, drawFramebuffer=%u, srcX0=%d, srcY0=%d, srcX1=%d, srcY1=%d, dstX0=%d, dstY0=%d, dstX1=%d, dstY1=%d, mask=%u, filter=%u", GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
GL_StaticProcedureDeclaration(glDrawBuffers, "n=%d, bufs=%p", GLsizei n, const GLenum* bufs)
GL_StaticProcedureDeclaration(glClearBufferfv, "buffer=%u, drawbuffer=%d, value=%p", GLenum buffer, GLint drawbuffer, const GLfloat* value)
GL_StaticProcedureDeclaration(glClipControl, "origin=%u, depth=%u", GLenum origin, GLenum depth)

// Multi-sampled
GL_StaticProcedureDeclaration(glRenderbufferStorageMultisample, "target=%x, samples=%d, internalformat=%x, width=%d, height=%d", GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
GL_StaticProcedureDeclaration(glNamedRenderbufferStorageMultisample, "renderbuffer=%x, samples=%d, internalformat=%x, width=%d, height=%d", GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)

static GLenum glDepthFormats[] = { 0, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT32F };
typedef enum { r_depthformat_best, r_depthformat_16bit, r_depthformat_24bit, r_depthformat_32bit, r_depthformat_32bit_float, r_depthformat_count } r_depthformat;

#ifdef C_ASSERT
C_ASSERT(sizeof(framebuffer_names) / sizeof(framebuffer_names[0]) == framebuffer_count);
C_ASSERT(sizeof(framebuffer_texture_names) / sizeof(framebuffer_texture_names[0]) == fbtex_count);
C_ASSERT(sizeof(framebuffer_depth_buffer) / sizeof(framebuffer_depth_buffer[0]) == framebuffer_count);
C_ASSERT(sizeof(glDepthFormats) / sizeof(glDepthFormats[0]) == r_depthformat_count);
#endif

//
// Initialize framebuffer stuff, Loads procaddresses and such.
//
void GL_InitialiseFramebufferHandling(void)
{
	qbool framebuffers_supported = true;

	glConfig.supported_features &= ~(R_SUPPORT_FRAMEBUFFERS | R_SUPPORT_FRAMEBUFFERS_BLIT);

	if (GL_VersionAtLeast(3,0) || SDL_GL_ExtensionSupported("GL_ARB_framebuffer_object")) {
		GL_LoadMandatoryFunction(glGenFramebuffers, framebuffers_supported);
		GL_LoadMandatoryFunction(glDeleteFramebuffers, framebuffers_supported);
		GL_LoadMandatoryFunction(glBindFramebuffer, framebuffers_supported);

		GL_LoadMandatoryFunction(glGenRenderbuffers, framebuffers_supported);
		GL_LoadMandatoryFunction(glDeleteRenderbuffers, framebuffers_supported);
		GL_LoadMandatoryFunction(glBindRenderbuffer, framebuffers_supported);
		GL_LoadMandatoryFunction(glRenderbufferStorage, framebuffers_supported);
		GL_LoadMandatoryFunction(glFramebufferRenderbuffer, framebuffers_supported);
		GL_LoadMandatoryFunction(glBlitFramebuffer, framebuffers_supported);

		GL_LoadMandatoryFunction(glFramebufferTexture, framebuffers_supported);
		GL_LoadMandatoryFunction(glCheckFramebufferStatus, framebuffers_supported);
		GL_LoadMandatoryFunction(glDrawBuffers, framebuffers_supported);
		GL_LoadMandatoryFunction(glClearBufferfv, framebuffers_supported);

		GL_LoadOptionalFunction(glRenderbufferStorageMultisample);

		glConfig.supported_features |= (framebuffers_supported ? (R_SUPPORT_FRAMEBUFFERS | R_SUPPORT_FRAMEBUFFERS_BLIT) : 0);
		glConfig.supported_features |= (framebuffers_supported && GL_Available(glRenderbufferStorageMultisample) ? R_SUPPORT_FRAMEBUFFER_MS : 0);
		if (GL_VersionAtLeast(3, 0) || SDL_GL_ExtensionSupported("GL_ARB_depth_buffer_float")) {
			glConfig.supported_features |= R_SUPPORT_DEPTH32F;
		}
	}
	else if (GL_VersionAtLeast(3, 0) || (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object") && SDL_GL_ExtensionSupported("GL_ARB_depth_texture"))) {
		GL_LoadMandatoryFunctionEXT(glGenFramebuffers, framebuffers_supported);
		GL_LoadMandatoryFunctionEXT(glDeleteFramebuffers, framebuffers_supported);
		GL_LoadMandatoryFunctionEXT(glBindFramebuffer, framebuffers_supported);

		GL_LoadMandatoryFunctionEXT(glGenRenderbuffers, framebuffers_supported);
		GL_LoadMandatoryFunctionEXT(glDeleteRenderbuffers, framebuffers_supported);
		GL_LoadMandatoryFunctionEXT(glBindRenderbuffer, framebuffers_supported);
		GL_LoadMandatoryFunctionEXT(glRenderbufferStorage, framebuffers_supported);
		GL_LoadMandatoryFunctionEXT(glFramebufferRenderbuffer, framebuffers_supported);
		if (GL_VersionAtLeast(3, 0) || SDL_GL_ExtensionSupported("GL_EXT_framebuffer_blit")) {
			GL_LoadOptionalFunctionEXT(glBlitFramebuffer);
		}
		GL_LoadMandatoryFunctionEXT(glDrawBuffers, framebuffers_supported);

		GL_LoadMandatoryFunctionEXT(glFramebufferTexture, framebuffers_supported);
		GL_LoadMandatoryFunctionEXT(glCheckFramebufferStatus, framebuffers_supported);
		GL_LoadMandatoryFunctionEXT(glClearBufferfv, framebuffers_supported);

		glConfig.supported_features |= (framebuffers_supported ? (R_SUPPORT_FRAMEBUFFERS) : 0);
		glConfig.supported_features |= (framebuffers_supported && GL_Available(glBlitFramebuffer) ? (R_SUPPORT_FRAMEBUFFERS_BLIT) : 0);
		glConfig.supported_features |= GL_VersionAtLeast(3, 0) || SDL_GL_ExtensionSupported("GL_ARB_depth_buffer_float") ? R_SUPPORT_DEPTH32F : 0;
	}

	glConfig.supported_features |= GL_VersionAtLeast(3, 0) || SDL_GL_ExtensionSupported("GL_ARB_framebuffer_sRGB") ? R_SUPPORT_FRAMEBUFFERS_SRGB : 0;

	if (GL_UseDirectStateAccess()) {
		GL_LoadOptionalFunction(glNamedRenderbufferStorage);
		GL_LoadOptionalFunction(glNamedFramebufferRenderbuffer);
		GL_LoadOptionalFunction(glBlitNamedFramebuffer);
		GL_LoadOptionalFunction(glNamedFramebufferTexture);
		GL_LoadOptionalFunction(glCheckNamedFramebufferStatus);
		GL_LoadOptionalFunction(glNamedRenderbufferStorageMultisample);
	}

	// meag: disabled (classic needs glFrustum replaced, modern needs non-rubbish viewweapon
	//                 depth hack, and near-plane clipping issues when the player is gibbed)
	/*if (GL_VersionAtLeast(4, 5) || SDL_GL_ExtensionSupported("GL_ARB_clip_control")) {
		GL_LoadOptionalFunction(glClipControl);
	}*/

	memset(framebuffer_data, 0, sizeof(framebuffer_data));
}

void GL_FramebufferSetFiltering(qbool linear)
{
	texture_ref tex = framebuffer_data[framebuffer_std].texture[fbtex_standard];

	if (R_TextureReferenceIsValid(tex)) {
		texture_minification_id min_filter = linear ? texture_minification_linear : texture_minification_nearest;
		texture_magnification_id mag_filter = linear ? texture_magnification_linear : texture_magnification_nearest;

		renderer.TextureSetFiltering(tex, min_filter, mag_filter);
	}
}

static qbool GL_FramebufferCreateRenderingTexture(framebuffer_data_t* fb, fbtex_id tex_id, r_texture_type_id texture_type, GLenum framebuffer_format, const char* label, int width, int height)
{
	GL_CreateTexturesWithIdentifier(texture_type, 1, &fb->texture[tex_id], label);
	GL_TexStorage2D(fb->texture[tex_id], 1, framebuffer_format, width, height, false);
	renderer.TextureLabelSet(fb->texture[tex_id], label);
	renderer.TextureWrapModeClamp(fb->texture[tex_id]);
	renderer.TextureSetFiltering(fb->texture[tex_id], texture_minification_nearest, texture_magnification_nearest);
	R_TextureSetFlag(fb->texture[tex_id], R_TextureGetFlag(fb->texture[tex_id]) | TEX_NO_TEXTUREMODE);
	return true;
}

qbool GL_FramebufferCreate(framebuffer_id id, int width, int height)
{
	framebuffer_data_t* fb = NULL;
	char label[128];
	qbool hdr = (vid_framebuffer_hdr.integer && GL_VersionAtLeast(3, 0) && framebuffer_hdr[id]);
	GLenum framebuffer_format;

	if (!GL_Supported(R_SUPPORT_FRAMEBUFFERS)) {
		return false;
	}

	if (hdr) {
		framebuffer_format = GL_RGB16F;
	}
	else if (vid_gammacorrection.integer) {
		if (GL_Supported(R_SUPPORT_FRAMEBUFFERS_SRGB)) {
			framebuffer_format = framebuffer_alpha[id] ? GL_SRGB8_ALPHA8 : GL_SRGB8;
		}
		else {
			Con_Printf("sRGB framebuffers are not supported on your hardware.\n");
			Cvar_LatchedSetValue(&vid_framebuffer, 0);
			return false;
		}
	}
	else {
		framebuffer_format = framebuffer_alpha[id] ? GL_RGBA8 : GL_RGB8;
	}

	fb = &framebuffer_data[id];
	if (fb->glref) {
		return false;
	}

	memset(fb, 0, sizeof(*fb));

	// Multi-sampling round up to power of 2
	if (framebuffer_multisampled[id]) {
		Q_ROUND_POWER2(vid_framebuffer_multisample.integer, fb->samples);
		fb->samples = bound(0, fb->samples, glConfig.max_multisampling_level);
		if (vid_framebuffer_multisample.integer != fb->samples) {
			Cvar_SetValue(&vid_framebuffer_multisample, fb->samples);
			Con_Printf("&cff0vid_framebuffer_multisample&r has been set to %d\n", fb->samples);
		}
	}

	// Render to texture
	strlcpy(label, framebuffer_names[id], sizeof(label));
	strlcat(label, "/", sizeof(label));
	strlcat(label, framebuffer_texture_names[fbtex_standard], sizeof(label));

	// Create standard rendering texture
	GL_FramebufferCreateRenderingTexture(fb, fbtex_standard, texture_type_2d, framebuffer_format, label, width, height);

	// Create multi-sampled texture
	if (fb->samples) {
		GL_CreateTexturesWithIdentifier(texture_type_2d_multisampled, 1, &fb->texture[fbtex_standard], label);
		GL_TexStorage2DMultisample(fb->texture[fbtex_standard], fb->samples, framebuffer_format, width, height, EZ_USE_FIXED_SAMPLE_LOCATIONS);
	}

	// Set linear filtering if requested
	GL_FramebufferSetFiltering(vid_framebuffer_smooth.integer);

	// Create frame buffer with texture & depth
	GL_GenFramebuffers(1, &fb->glref);
	GL_TraceObjectLabelSet(GL_FRAMEBUFFER, fb->glref, -1, framebuffer_names[id]);

	// Depth buffer
	if (framebuffer_depth_buffer[id]) {
		GLenum depthFormat = glDepthFormats[bound(0, vid_framebuffer_depthformat.integer, r_depthformat_count - 1)];
		if (depthFormat == 0) {
			depthFormat = GL_Available(glClipControl) ? GL_DEPTH_COMPONENT32F : GL_DEPTH_COMPONENT32;
		}
		if (depthFormat == GL_DEPTH_COMPONENT32F && !GL_Supported(R_SUPPORT_DEPTH32F)) {
			depthFormat = GL_DEPTH_COMPONENT32;
		}

#ifdef GL_USE_RENDER_BUFFERS
		GL_GenRenderBuffers(1, &fb->depthBuffer);
		GL_TraceObjectLabelSet(GL_RENDERBUFFER, fb->depthBuffer, -1, "depth-buffer");
		if (fb->samples) {
			GL_RenderBufferStorageMultisample(fb->depthBuffer, fb->samples, fb->depthFormat = depthFormat, width, height);
			GL_FramebufferRenderbuffer(fb->glref, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fb->depthBuffer);
		}
		else {
			GL_RenderBufferStorage(fb->depthBuffer, fb->depthFormat = depthFormat, width, height);
			GL_FramebufferRenderbuffer(fb->glref, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fb->depthBuffer);
		}
#else
		// create depth texture
		strlcpy(label, framebuffer_names[id], sizeof(label));
		strlcat(label, "/", sizeof(label));
		strlcat(label, framebuffer_texture_names[fbtex_depth], sizeof(label));

		GL_CreateTexturesWithIdentifier(texture_type_2d, 1, &fb->texture[fbtex_depth], label);
		GL_TexStorage2D(fb->texture[fbtex_depth], 1, depthFormat, width, height, false);
		renderer.TextureSetFiltering(fb->texture[fbtex_depth], min_filter, mag_filter);
		renderer.TextureWrapModeClamp(fb->texture[fbtex_depth]);

		GL_FramebufferTexture(fb->glref, GL_DEPTH_ATTACHMENT, GL_TextureNameFromReference(fb->texture[fbtex_depth]), 0);
#endif

		if (GL_Available(glClipControl)) {
			if (depthFormat == GL_DEPTH_COMPONENT32F) {
				GL_Procedure(glClipControl, GL_LOWER_LEFT, GL_ZERO_TO_ONE);
				glClearDepth(0.0f);
				glConfig.reversed_depth = true;
			}
			else {
				GL_Procedure(glClipControl, GL_LOWER_LEFT, GL_NEGATIVE_ONE_TO_ONE);
				glClearDepth(1.0f);
				glConfig.reversed_depth = false;
			}
		}
		else {
			glConfig.reversed_depth = false;
			glClearDepth(1.0f);
		}
	}

	GL_FramebufferTexture(fb->glref, GL_COLOR_ATTACHMENT0, GL_TextureNameFromReference(fb->texture[fbtex_standard]), 0);

	fb->status = GL_CheckFramebufferStatus(fb->glref);
	fb->width = width;
	fb->height = height;

	GL_Procedure(glBindFramebuffer, GL_FRAMEBUFFER, 0);

	switch (fb->status) {
	case GL_FRAMEBUFFER_COMPLETE:
		return true;
	case GL_FRAMEBUFFER_UNDEFINED:
		Con_Printf("&cf00error&r: the specified framebuffer is the default read or draw framebuffer, but the default framebuffer does not exist\n");
		break;
	case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
		Con_Printf("&cf00error&r: one of the framebuffer attachment points is framebuffer incomplete\n");
		break;
	case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
		Con_Printf("&cf00error&r: framebuffer does not have at least one image attached\n");
		break;
	case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
		Con_Printf("&cf00error&r: incomplete draw buffer\n");
		break;
	case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
		Con_Printf("&cf00error&r: incomplete read buffer\n");
		break;
	case GL_FRAMEBUFFER_UNSUPPORTED:
		Con_Printf("&cf00error&r: combination of formats is not supported\n");
		break;
	case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
		Con_Printf("&cf00error&r: mixture of renderbuffer/texture sampling levels\n");
		break;
	case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
		Con_Printf("&cf00error&r: incomplete layer targets\n");
		break;
	}

	// Rollback, delete objects
	GL_FramebufferDelete(id);
	return false;
}

qbool GL_FramebufferStartWorldNormals(framebuffer_id id)
{
	framebuffer_data_t* fb = NULL;
	GLenum buffers[2] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
	float clearValue[] = { 0.0f, 0.0f, 0.0f, 0.0f };

	if (!(gl_outline.integer & 2) || !GL_Supported(R_SUPPORT_FRAMEBUFFERS) || !RuleSets_AllowEdgeOutline()) {
		return false;
	}

	id = VID_MultisampledAlternateId(id);
	fb = &framebuffer_data[id];
	if (!fb->glref) {
		return false;
	}

	if (!R_TextureReferenceIsValid(fb->texture[fbtex_worldnormals])) {
		char label[128];

		// normals
		strlcpy(label, framebuffer_names[id], sizeof(label));
		strlcat(label, "/", sizeof(label));
		strlcat(label, framebuffer_texture_names[fbtex_worldnormals], sizeof(label));

		if (fb->samples) {
			GL_CreateTexturesWithIdentifier(texture_type_2d_multisampled, 1, &fb->texture[fbtex_worldnormals], label);
			if (!R_TextureReferenceIsValid(fb->texture[fbtex_worldnormals])) {
				return false;
			}
			GL_TexStorage2DMultisample(fb->texture[fbtex_worldnormals], fb->samples, GL_RGBA16F, fb->width, fb->height, EZ_USE_FIXED_SAMPLE_LOCATIONS);
		}
		else {
			GL_CreateTexturesWithIdentifier(texture_type_2d, 1, &fb->texture[fbtex_worldnormals], label);
			if (!R_TextureReferenceIsValid(fb->texture[fbtex_worldnormals])) {
				return false;
			}
			GL_TexStorage2D(fb->texture[fbtex_worldnormals], 1, GL_RGBA16F, fb->width, fb->height, false);
			renderer.TextureSetFiltering(fb->texture[fbtex_worldnormals], texture_minification_nearest, texture_magnification_nearest);
			renderer.TextureWrapModeClamp(fb->texture[fbtex_worldnormals]);
		}
		R_TextureSetFlag(fb->texture[fbtex_worldnormals], R_TextureGetFlag(fb->texture[fbtex_worldnormals]) | TEX_NO_TEXTUREMODE);
	}

	GL_FramebufferTexture(fb->glref, GL_COLOR_ATTACHMENT1, GL_TextureNameFromReference(fb->texture[fbtex_worldnormals]), 0);
	GL_Procedure(glDrawBuffers, 2, buffers);
	GL_Procedure(glClearBufferfv, GL_COLOR, 1, clearValue);
	return true;
}

static void GL_MultiSamplingResolve(framebuffer_id src, framebuffer_id target, fbtex_id texture, framebuffer_id temp_src, framebuffer_id temp_dst)
{
	// Copy from (multi-sampled) src[texture] => (non-multi-sampled) target[texture]
	framebuffer_data_t* fb_orig_src = &framebuffer_data[src];
	framebuffer_data_t* fb_orig_dst = &framebuffer_data[target];
	framebuffer_data_t* fb_blit_src = &framebuffer_data[temp_src];
	framebuffer_data_t* fb_blit_dst = &framebuffer_data[temp_dst];

	if (!vid_framebuffer_multisample.integer || !fb_orig_src->glref || !fb_orig_dst->glref) {
		// nothing to do
		return;
	}

	if (temp_src) {
		if (fb_blit_src->width != fb_orig_src->width || fb_blit_src->height != fb_orig_src->height) {
			GL_FramebufferDelete(temp_src);
		}
		if (!fb_blit_src->glref && !GL_FramebufferCreate(temp_src, fb_orig_src->width, fb_orig_src->height)) {
			return;
		}
	}
	if (temp_dst) {
		if (fb_blit_dst->width != fb_orig_dst->width || fb_blit_src->height != fb_orig_dst->height) {
			GL_FramebufferDelete(temp_dst);
		}
		if (!fb_blit_dst->glref && !GL_FramebufferCreate(temp_dst, fb_orig_dst->width, fb_orig_dst->height)) {
			return;
		}
	}

	GL_FramebufferTexture(fb_blit_src->glref, GL_COLOR_ATTACHMENT0, GL_TextureNameFromReference(fb_orig_src->texture[texture]), 0);
	GL_FramebufferTexture(fb_blit_dst->glref, GL_COLOR_ATTACHMENT0, GL_TextureNameFromReference(fb_orig_dst->texture[texture]), 0);

	GL_FramebufferBlitSimple(temp_src, temp_dst);

	GL_FramebufferTexture(fb_blit_src->glref, GL_COLOR_ATTACHMENT0, 0, 0);
	GL_FramebufferTexture(fb_blit_dst->glref, GL_COLOR_ATTACHMENT0, 0, 0);
}

qbool GL_FramebufferEndWorldNormals(framebuffer_id id)
{
	framebuffer_data_t* fb = NULL;
	GLenum buffer = GL_COLOR_ATTACHMENT0;

	if (!GL_Supported(R_SUPPORT_FRAMEBUFFERS)) {
		return false;
	}

	id = VID_MultisampledAlternateId(id);
	fb = &framebuffer_data[id];
	if (!fb->glref) {
		return false;
	}

	GL_FramebufferTexture(fb->glref, GL_COLOR_ATTACHMENT1, 0, 0);
	GL_Procedure(glDrawBuffers, 1, &buffer);

	if (fb->samples && id == framebuffer_std_ms) {
		// Resolve multi-samples
		GL_MultiSamplingResolve(framebuffer_std_ms, framebuffer_std, fbtex_worldnormals, framebuffer_std_blit_ms, framebuffer_std_blit);
	}
	return true;
}

void GL_FramebufferDelete(framebuffer_id id)
{
	int i;
	framebuffer_data_t* fb = &framebuffer_data[id];

	if (id != framebuffer_none && fb->glref) {
		if (fb->depthBuffer) {
			GL_Procedure(glDeleteRenderbuffers, 1, &fb->depthBuffer);
		}
		for (i = 0; i < sizeof(fb->texture) / sizeof(fb->texture[0]); ++i) {
			if (R_TextureReferenceIsValid(fb->texture[i])) {
				R_DeleteTexture(&fb->texture[i]);
			}
		}
		if (fb->glref) {
			GL_Procedure(glDeleteFramebuffers, 1, &fb->glref);
		}

		memset(fb, 0, sizeof(*fb));
	}
}

void GL_FramebufferStartUsing(framebuffer_id id)
{
	GL_Procedure(glBindFramebuffer, GL_FRAMEBUFFER, framebuffer_data[id].glref);
}

void GL_FramebufferStartUsingScreen(void)
{
	// resolve any multi-sampling
	GL_MultiSamplingResolve(framebuffer_std_ms, framebuffer_std, fbtex_standard, framebuffer_std_blit_ms, framebuffer_std_blit);
	GL_MultiSamplingResolve(framebuffer_hud_ms, framebuffer_hud, fbtex_standard, framebuffer_hud_blit_ms, framebuffer_hud_blit);

	GL_Procedure(glBindFramebuffer, GL_FRAMEBUFFER, 0);
}

texture_ref GL_FramebufferTextureReference(framebuffer_id id, fbtex_id tex_id)
{
	return framebuffer_data[id].texture[tex_id];
}

// OpenGL wrapper functions
#ifdef GL_USE_RENDER_BUFFERS
static void GL_RenderBufferStorage(GLuint renderBuffer, GLenum internalformat, GLsizei width, GLsizei height)
{
	if (GL_Available(glNamedRenderbufferStorage)) {
		GL_Procedure(glNamedRenderbufferStorage, renderBuffer, internalformat, width, height);
	}
	else if (GL_Available(glBindRenderbuffer) && GL_Available(glRenderbufferStorage)) {
		GL_Procedure(glBindRenderbuffer, GL_RENDERBUFFER, renderBuffer);
		GL_Procedure(glRenderbufferStorage, GL_RENDERBUFFER, internalformat, width, height);
	}
	else {
		Sys_Error("ERROR: %s called without driver support", __func__);
	}
}

static void GL_RenderBufferStorageMultisample(GLuint renderBuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
	if (GL_Available(glNamedRenderbufferStorageMultisample)) {
		GL_Procedure(glNamedRenderbufferStorageMultisample, renderBuffer, samples, internalformat, width, height);
	}
	else if (GL_Available(glBindRenderbuffer) && GL_Available(glRenderbufferStorageMultisample)) {
		GL_Procedure(glBindRenderbuffer, GL_RENDERBUFFER, renderBuffer);
		GL_Procedure(glRenderbufferStorageMultisample, GL_RENDERBUFFER, samples, internalformat, width, height);
	}
	else {
		Sys_Error("ERROR: %s called without driver support", __func__);
	}
}

static void GL_FramebufferRenderbuffer(GLuint fbref, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
	if (GL_Available(glNamedFramebufferRenderbuffer)) {
		GL_Procedure(glNamedFramebufferRenderbuffer, fbref, attachment, renderbuffertarget, renderbuffer);
	}
	else if (GL_Available(glBindFramebuffer) && GL_Available(glFramebufferRenderbuffer)) {
		GL_Procedure(glBindFramebuffer, GL_FRAMEBUFFER, fbref);
		GL_Procedure(glFramebufferRenderbuffer, GL_FRAMEBUFFER, attachment, renderbuffertarget, renderbuffer);
	}
	else {
		Sys_Error("ERROR: %s called without driver support", __func__);
	}
}

static void GL_GenRenderBuffers(GLsizei n, GLuint* buffers)
{
	int i;

	GL_Procedure(glGenRenderbuffers, n, buffers);

	for (i = 0; i < n; ++i) {
		GL_Procedure(glBindRenderbuffer, GL_RENDERBUFFER, buffers[i]);
	}
}
#endif

static GLenum GL_CheckFramebufferStatus(GLuint fbref)
{
	if (GL_Available(glCheckNamedFramebufferStatus)) {
		return GL_Function(glCheckNamedFramebufferStatus, fbref, GL_FRAMEBUFFER);
	}
	else if (GL_Available(glBindFramebuffer) && GL_Available(glCheckFramebufferStatus)) {
		GL_Procedure(glBindFramebuffer, GL_FRAMEBUFFER, fbref);
		return GL_Function(glCheckFramebufferStatus, GL_FRAMEBUFFER);
	}
	else {
		Sys_Error("ERROR: %s called without driver support", __func__);
		return 0;
	}
}

static void GL_FramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
{
	if (GL_Available(glNamedFramebufferTexture)) {
		GL_Procedure(glNamedFramebufferTexture, framebuffer, attachment, texture, level);
	}
	else if (GL_Available(glBindFramebuffer) && GL_Available(glFramebufferTexture)) {
		GL_Procedure(glBindFramebuffer, GL_FRAMEBUFFER, framebuffer);
		GL_Procedure(glFramebufferTexture, GL_FRAMEBUFFER, attachment, texture, level);
	}
	else {
		Sys_Error("ERROR: %s called without driver support", __func__);
	}
}

static void GL_GenFramebuffers(GLsizei n, GLuint* buffers)
{
	int i;

	GL_Procedure(glGenFramebuffers, n, buffers);
	for (i = 0; i < n; ++i) {
		GL_Procedure(glBindFramebuffer, GL_FRAMEBUFFER, buffers[i]);
	}
}

int GL_FrameBufferWidth(framebuffer_id id)
{
	return framebuffer_data[id].width;
}

int GL_FrameBufferHeight(framebuffer_id id)
{
	return framebuffer_data[id].height;
}

static void GL_FramebufferBlitSimple(framebuffer_id source_id, framebuffer_id destination_id)
{
	framebuffer_data_t* src = &framebuffer_data[source_id];
	framebuffer_data_t* dest = &framebuffer_data[destination_id];
	GLint srcTL[2] = { 0, 0 };
	GLint srcSize[2];
	GLint destTL[2] = { 0, 0 };
	GLint destSize[2];
	GLenum filter = GL_NEAREST;

	srcSize[0] = src->glref ? src->width : glConfig.vidWidth;
	srcSize[1] = src->glref ? src->height : glConfig.vidHeight;
	destSize[0] = destination_id ? dest->width : glConfig.vidWidth;
	destSize[1] = destination_id ? dest->height : glConfig.vidHeight;
	if (srcSize[0] != destSize[0] || srcSize[1] != destSize[1]) {
		filter = GL_LINEAR;
	}

	if (GL_Available(glBlitNamedFramebuffer)) {
		GL_Procedure(
			glBlitNamedFramebuffer, src->glref, dest->glref,
			srcTL[0], srcTL[1], srcTL[0] + srcSize[0], srcTL[1] + srcSize[1],
			destTL[0], destTL[1], destTL[0] + destSize[0], destTL[1] + destSize[1],
			GL_COLOR_BUFFER_BIT, filter
		);
	}
	else if (GL_Available(glBlitFramebuffer)) {
		// ARB_framebuffer
		GL_Procedure(glBindFramebuffer, GL_READ_FRAMEBUFFER, src->glref);
		GL_Procedure(glBindFramebuffer, GL_DRAW_FRAMEBUFFER, dest->glref);

		GL_Procedure(
			glBlitFramebuffer,
			srcTL[0], srcTL[1], srcTL[0] + srcSize[0], srcTL[1] + srcSize[1],
			destTL[0], destTL[1], destTL[0] + destSize[0], destTL[1] + destSize[1],
			GL_COLOR_BUFFER_BIT, filter
		);
	}
	else {
		// Shouldn't have been called, not supported
	}
}

// --- Wrapper functionality over, rendering logic below ---
qbool GL_FramebufferEnabled3D(void)
{
	framebuffer_data_t* fb = &framebuffer_data[framebuffer_std];

	return vid_framebuffer.integer && fb->glref && R_TextureReferenceIsValid(fb->texture[fbtex_standard]);
}

qbool GL_FramebufferEnabled2D(void)
{
	framebuffer_data_t* fb = &framebuffer_data[framebuffer_hud];

	return vid_framebuffer.integer && fb->glref && R_TextureReferenceIsValid(fb->texture[fbtex_standard]);
}

static void VID_FramebufferFlip(void)
{
	qbool flip3d = vid_framebuffer.integer && GL_FramebufferEnabled3D();
	qbool flip2d = vid_framebuffer.integer == USE_FRAMEBUFFER_3DONLY && GL_FramebufferEnabled2D();

	if (flip3d || flip2d) {
		// Screen-wide framebuffer without any processing required, so we can just blit
		qbool should_blit = (
			//vid_framebuffer_multisample.integer == 0 &&
			vid_software_palette.integer == 0 &&
			vid_framebuffer.integer != USE_FRAMEBUFFER_3DONLY &&
			vid_framebuffer_blit.integer &&
			(glConfig.supported_features & R_SUPPORT_FRAMEBUFFERS_BLIT)
		);

		// render to screen from now on
		GL_FramebufferStartUsingScreen();

		if (should_blit && flip3d) {
			// Blit to screen
			GL_FramebufferBlitSimple(framebuffer_std, framebuffer_none);
		}
		else {
			renderer.RenderFramebuffers();
		}
	}
	else if (vid_software_palette.integer) {
		renderer.RenderFramebuffers();
	}
}

static void GL_FramebufferEnsureCreated(framebuffer_id id, int width, int height)
{
	framebuffer_data_t* fb = &framebuffer_data[id];
	int expected_samples = framebuffer_multisampled[id] ? vid_framebuffer_multisample.integer : 0;

	if (!fb->glref) {
		GL_FramebufferCreate(id, width, height);
	}
	else if (fb->width != width || fb->height != height || fb->samples != expected_samples) {
		GL_FramebufferDelete(id);

		GL_FramebufferCreate(id, width, height);
	}
}

static void GL_FramebufferEnsureDeleted(framebuffer_id id)
{
	framebuffer_data_t* fb = &framebuffer_data[id];

	if (fb->glref) {
		GL_FramebufferDelete(id);
	}
}

static framebuffer_id VID_MultisampledAlternateId(framebuffer_id id)
{
	if (vid_framebuffer_multisample.integer && framebuffer_multisample_alternate[id] && framebuffer_multisample_alternate[id] != id) {
		return framebuffer_multisample_alternate[id];
	}
	return id;
}

static qbool VID_FramebufferInit(framebuffer_id id, int effective_width, int effective_height)
{
	if (effective_width && effective_height) {
		GL_FramebufferEnsureCreated(id, effective_width, effective_height);

		if (framebuffer_data[id].glref) {
			framebuffer_id ms_alt = VID_MultisampledAlternateId(id);

			if (ms_alt != id) {
				GL_FramebufferEnsureCreated(ms_alt, effective_width, effective_height);

				if (framebuffer_data[ms_alt].glref) {
					GL_FramebufferStartUsing(ms_alt);
					return true;
				}
			}
			else {
				GL_FramebufferStartUsing(id);
				return true;
			}
		}
	}
	else {
		GL_FramebufferEnsureDeleted(id);
	}

	return false;
}

void GL_FramebufferScreenDrawStart(void)
{
	if (vid_framebuffer.integer) {
		VID_FramebufferInit(framebuffer_std, VID_ScaledWidth3D(), VID_ScaledHeight3D());
	}
}

qbool GL_Framebuffer2DSwitch(void)
{
	if (vid_framebuffer.integer == USE_FRAMEBUFFER_3DONLY) {

		if (VID_FramebufferInit(framebuffer_hud, glConfig.vidWidth, glConfig.vidHeight)) {
			R_Viewport(0, 0, glConfig.vidWidth, glConfig.vidHeight);
			R_ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
			glClear(GL_COLOR_BUFFER_BIT);
			return true;
		}
	}

	R_Viewport(glx, gly, glwidth, glheight);
	return false;
}

void GL_FramebufferPostProcessScreen(void)
{
	qbool framebuffer_active = GL_FramebufferEnabled3D() || GL_FramebufferEnabled2D();

	if (framebuffer_active || vid_software_palette.integer) {
		R_Viewport(glx, gly, glConfig.vidWidth, glConfig.vidHeight);

		VID_FramebufferFlip();
	}

	if (!vid_software_palette.integer) {
		renderer.BrightenScreen();

		// Hardware palette changes
		V_UpdatePalette();
	}
}

const char* GL_FramebufferZBufferString(framebuffer_id ref)
{
	if (framebuffer_data[ref].depthFormat == GL_DEPTH_COMPONENT16) {
		return "16-bit float z-buffer";
	}
	else if (framebuffer_data[ref].depthFormat == GL_DEPTH_COMPONENT24) {
		return "24-bit float z-buffer";
	}
	else if (framebuffer_data[ref].depthFormat == GL_DEPTH_COMPONENT32) {
		return "32-bit z-buffer";
	}
	else if (framebuffer_data[ref].depthFormat == GL_DEPTH_COMPONENT32F) {
		return "32-bit float z-buffer";
	}
	else {
		return "unknown z-buffer";
	}
}

static qbool GL_ScreenshotFramebuffer(void)
{
	extern cvar_t vid_framebuffer_sshotmode;

	return vid_framebuffer_sshotmode.integer && vid_framebuffer.integer == USE_FRAMEBUFFER_SCREEN && GL_FramebufferEnabled3D();
}

void GL_Screenshot(byte* buffer, size_t size)
{
	size_t width = renderer.ScreenshotWidth();
	size_t height = renderer.ScreenshotHeight();

	GL_PackAlignment(1);
	if (GL_Available(glBindFramebuffer)) {
		if (GL_ScreenshotFramebuffer()) {
			GL_Procedure(glBindFramebuffer, GL_READ_FRAMEBUFFER, framebuffer_data[framebuffer_std].glref);
		}
		else {
			GL_Procedure(glBindFramebuffer, GL_READ_FRAMEBUFFER, 0);
		}
	}
	glReadPixels(0, 0, (GLsizei)width, (GLsizei)height, GL_RGB, GL_UNSIGNED_BYTE, buffer);
}

size_t GL_ScreenshotWidth(void)
{
	if (GL_ScreenshotFramebuffer()) {
		return framebuffer_data[framebuffer_std].width;
	}

	return glConfig.vidWidth;
}

size_t GL_ScreenshotHeight(void)
{
	if (GL_ScreenshotFramebuffer()) {
		return framebuffer_data[framebuffer_std].height;
	}

	return glConfig.vidHeight;
}

int GL_FramebufferMultisamples(framebuffer_id framebuffer)
{
	framebuffer_data_t* fb = &framebuffer_data[framebuffer];

	if (vid_framebuffer.integer && fb->glref && R_TextureReferenceIsValid(fb->texture[fbtex_standard])) {
		return fb->samples;
	}

	return 0;
}

void GL_FramebufferDeleteAll(void)
{
	framebuffer_id i;

	for (i = 0; i < framebuffer_count; ++i) {
		GL_FramebufferEnsureDeleted(i);
	}
}

int GL_FramebufferFxaaPreset(void)
{
	static const int fxaa_cvar_to_preset[18] = {
			0, 10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 39
	};
	extern cvar_t vid_framebuffer_fxaa;

	return fxaa_cvar_to_preset[bound(0, vid_framebuffer_fxaa.integer, 17)];
}


================================================
FILE: src/gl_framebuffer.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __GL_FRAMEBUFFER_H__
#define __GL_FRAMEBUFFER_H__

typedef enum {
	framebuffer_none,
	// rendering
	framebuffer_std,
	framebuffer_std_ms,
	framebuffer_hud,
	framebuffer_hud_ms,
	// framebuffers used to resolve multisampling
	framebuffer_std_blit,
	framebuffer_std_blit_ms,
	framebuffer_hud_blit,
	framebuffer_hud_blit_ms,
	framebuffer_count
} framebuffer_id;

typedef enum {
	fbtex_standard,
	fbtex_depth,
	fbtex_bloom,
	fbtex_worldnormals,
	fbtex_count
} fbtex_id;

void GL_InitialiseFramebufferHandling(void);
qbool GL_FramebufferCreate(framebuffer_id id, int width, int height);
void GL_FramebufferDelete(framebuffer_id id);
void GL_FramebufferStartUsing(framebuffer_id id);
void GL_FramebufferStartUsingScreen(void);
texture_ref GL_FramebufferTextureReference(framebuffer_id id, fbtex_id tex_id);
int GL_FrameBufferWidth(framebuffer_id ref);
int GL_FrameBufferHeight(framebuffer_id ref);
const char* GL_FramebufferZBufferString(framebuffer_id ref);

void GL_FramebufferScreenDrawStart(void);
qbool GL_Framebuffer2DSwitch(void);
void GL_FramebufferPostProcessScreen(void);
qbool GL_FramebufferEnabled2D(void);
qbool GL_FramebufferEnabled3D(void);

qbool GL_FramebufferStartWorldNormals(framebuffer_id id);
qbool GL_FramebufferEndWorldNormals(framebuffer_id id);

int GL_FramebufferMultisamples(framebuffer_id framebuffer);
void GL_FramebufferDeleteAll(void);
int GL_FramebufferFxaaPreset(void);

#define USE_FRAMEBUFFER_SCREEN    1
#define USE_FRAMEBUFFER_3DONLY    2

#endif // __GL_FRAMEBUFFER_H__


================================================
FILE: src/gl_local.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
// gl_local.h -- private refresh defs
#ifndef __GL_LOCAL_H__
#define __GL_LOCAL_H__

#include <SDL_opengl.h>
#include <SDL_opengl_glext.h>

#include "gl_model.h"
#include "r_framestats.h"
#include "r_trace.h"
#include "r_local.h"
#include "tr_types.h"

void R_TimeRefresh_f (void);
texture_t *R_TextureAnimation(entity_t* ent, texture_t *base);

//====================================================

// view origin
extern	vec3_t	vup;
extern	vec3_t	vpn;
extern	vec3_t	vright;
extern	vec3_t	r_origin;

// screen size info
extern	texture_t	*r_notexture_mip;

extern	texture_ref netgraphtexture;

// Tomaz - Fog Begin
extern  cvar_t  gl_fogenable;
extern  cvar_t  gl_fogstart;
extern  cvar_t  gl_fogend;
extern  cvar_t  gl_fogred;
extern  cvar_t  gl_fogblue;
extern  cvar_t  gl_foggreen;
extern  cvar_t  gl_fogsky;
// Tomaz - Fog End

extern	cvar_t	r_drawentities;
extern	cvar_t	r_drawflame;
extern	cvar_t	r_speeds;
extern	cvar_t	r_fullbright;
extern	cvar_t	r_shadows;
extern	cvar_t	r_mirroralpha;
extern	cvar_t	r_dynamic;
extern	cvar_t	r_novis;
extern	cvar_t	r_netgraph;
extern	cvar_t	r_netstats;
extern	cvar_t	r_fullbrightSkins;
extern	cvar_t	r_fastsky;
extern	cvar_t	r_skycolor;
extern	cvar_t	r_drawflat;
extern	cvar_t	r_drawflat_mode;
extern	cvar_t	r_wallcolor;
extern	cvar_t	r_floorcolor;
extern	cvar_t	r_bloom;
extern	cvar_t	r_bloom_alpha;
extern	cvar_t	r_bloom_diamond_size;
extern	cvar_t	r_bloom_intensity;
extern	cvar_t	r_bloom_darken;
extern	cvar_t	r_bloom_sample_size;
extern	cvar_t	r_bloom_fast_sample;

extern	cvar_t	r_skyname;
extern  cvar_t  gl_caustics;
extern  cvar_t  gl_detail;
extern  cvar_t  gl_fog;
extern  cvar_t  gl_fog_density;
extern  cvar_t  gl_waterfog;
extern  cvar_t  gl_waterfog_density;

extern	cvar_t	gl_subdivide_size;
extern	cvar_t	gl_clear;
extern	cvar_t	gl_polyblend;
extern	cvar_t	gl_nocolors;
extern	cvar_t	gl_finish;
extern	cvar_t	gl_fb_bmodels;
extern	cvar_t	gl_fb_models;
extern	cvar_t	gl_playermip;

extern  cvar_t gl_part_explosions;
extern  cvar_t gl_part_bloodtrails;
extern  cvar_t gl_part_trails;
extern  cvar_t gl_part_spikes;
extern  cvar_t gl_part_gunshots;
extern  cvar_t gl_part_blood;
extern  cvar_t gl_part_telesplash;
extern  cvar_t gl_part_blobs;
extern  cvar_t gl_part_lavasplash;
extern	cvar_t gl_part_inferno;
extern  cvar_t gl_part_bubble;
extern	cvar_t gl_part_detpackexplosion_fire_color;
extern	cvar_t gl_part_detpackexplosion_ray_color;

extern	cvar_t gl_powerupshells;

extern cvar_t vid_gammacorrection;

// gl_rmain.c
qbool R_CullBox (vec3_t mins, vec3_t maxs);
qbool R_CullSphere (vec3_t centre, float radius);
void R_BrightenScreen (void);

extern int dlightcolor[NUM_DLIGHTTYPES][3];

// gl_ngraph.c
//void R_NetGraph (void); // HUD -> hexum
void R_MQW_NetGraph(int outgoing_sequence, int incoming_sequence, int *packet_latency,
                int lost, int minping, int avgping, int maxping, int devping,
                int posx, int posy, int width, int height, int revx, int revy);

// gl_rmisc.c
void R_InitOtherTextures(void);

//vid_common_gl.c

//anisotropic filtering
#ifndef GL_EXT_texture_filter_anisotropic
#define GL_EXT_texture_filter_anisotropic 1
#define GL_TEXTURE_MAX_ANISOTROPY_EXT				0x84FE
#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT			0x84FF
#endif

//multitexturing
#define	GL_TEXTURE0_ARB 			0x84C0
#define	GL_TEXTURE1_ARB 			0x84C1
#define	GL_TEXTURE2_ARB 			0x84C2
#define	GL_TEXTURE3_ARB 			0x84C3
#define GL_MAX_TEXTURE_UNITS_ARB	0x84E2

//texture compression
#define GL_COMPRESSED_ALPHA_ARB					0x84E9
#define GL_COMPRESSED_LUMINANCE_ARB				0x84EA
#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB		0x84EB
#define GL_COMPRESSED_INTENSITY_ARB				0x84EC
#define GL_COMPRESSED_RGB_ARB					0x84ED
#define GL_COMPRESSED_RGBA_ARB					0x84EE
#define GL_TEXTURE_COMPRESSION_HINT_ARB			0x84EF
#define GL_TEXTURE_IMAGE_SIZE_ARB				0x86A0
#define GL_TEXTURE_COMPRESSED_ARB				0x86A1
#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB	0x86A2
#define GL_COMPRESSED_TEXTURE_FORMATS_ARB		0x86A3

//sRGB gamma correction
#define GL_SRGB8 0x8C41
#define GL_SRGB8_ALPHA8 0x8C43
#define GL_FRAMEBUFFER_SRGB 0x8DB9

extern byte color_white[4], color_black[4];
extern qbool gl_mtexable;
extern int gl_textureunits;

void GL_LoadProgramFunctions(void);
void GL_LoadStateFunctions(void);
void GL_LoadTextureManagementFunctions(void);
void GL_LoadDrawFunctions(void);
void GL_InitialiseDebugging(void);

// Which renderer to use
#define GL_VersionAtLeast(major, minor) (glConfig.majorVersion > (major) || (glConfig.majorVersion == (major) && glConfig.minorVersion >= (minor)))

// When SSBOs are unavailable (GL < 4.3), storage buffers become UBOs.
// UBOs share the binding namespace with GlobalState (binding 0), so offset by 1.
#define EZQ_STORAGE_BLOCK_BINDING(n) (GL_VersionAtLeast(4, 3) ? (n) : ((n) + 1))

void GL_TextureInitialiseState(void);
void GL_InvalidateTextureReferences(GLuint texture);

// Functions
void GL_BeginDrawSprites(void);
void GL_EndDrawSprites(void);

// 
void R_RenderDynamicLightmaps(msurface_t *fa, qbool world);
void R_DrawViewModel(void);
void R_LightmapFrameInit(void);
void R_UploadChangedLightmaps(void);
void R_UploadLightMap(int textureUnit, int lightmapnum);

mspriteframe_t* R_GetSpriteFrame(entity_t *e, msprite2_t *psprite);

void GLC_DrawSpriteModel(entity_t* e);
void GLC_PolyBlend(float v_blend[4]);
void GLC_BrightenScreen(void);
void GLC_EmitCausticsPolys(void);
void GLC_DrawWorld(void);
void GLC_ClearTextureChains(void);
qbool GLC_SetTextureLightmap(int textureUnit, int lightmap_num);
qbool GLC_IsLightmapBound(int textureUnit, int lightmap_num);
texture_ref GLC_LightmapTexture(int index);
void GLC_ClearLightmapPolys(void);
void GLC_AddToLightmapChain(msurface_t* s);
void GLC_LightmapUpdate(int index);
glpoly_t* GLC_LightmapChain(int i);
int GLC_LightmapCount(void);
void GLC_DrawMapOutline(model_t *model);
void GLC_MultiTexCoord2f(GLenum target, float s, float t);

void GLM_DrawSpriteModel(entity_t* e);
void GLM_PolyBlend(float v_blend[4]);
texture_ref GLM_LightmapArray(void);
void GLM_PostProcessScreen(void);
void GLM_RenderView(void);
void GLM_UploadFrameConstants(void);
void GLM_PrepareWorldModelBatch(void);

void GL_InitialiseState(void);

byte* SurfaceFlatTurbColor(texture_t* texture);

struct custom_model_color_s;

void R_StateBeginAlphaLineRGB(float thickness);
void R_SetupFrame(void);

void GL_InitialiseFramebufferHandling(void);

// Rendering functions
void GL_DrawArrays(GLenum mode, GLint first, GLsizei count);
void GL_MultiDrawArrays(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount);
void GL_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLint basevertex);
void GL_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
void GL_MultiDrawArraysIndirect(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride);
void GL_MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride);
void GL_DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei primcount, GLint basevertex, GLuint baseinstance);
void GL_DrawElementsIndirect(GLenum mode, GLenum type, GLvoid* indirect);
qbool GL_DrawElementsBaseVertexAvailable(void);

GLuint GL_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
void GL_UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);

void GL_BindImageTexture(GLuint unit, texture_ref texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
GLenum GL_ProcessAllErrors(const char* message);

#ifdef WITH_RENDERING_TRACE
#define GL_ProcessErrors GL_ProcessAllErrors

#define GL_LoadRequiredFunction(varName, functionName)           (((varName) = (functionName##_t)SDL_GL_GetProcAddress(#functionName)) != NULL)
#define GL_LoadMandatoryFunction(functionName,testFlag)          { testFlag &= ((q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName)) != NULL); }
#define GL_LoadMandatoryFunctionEXT(functionName,testFlag)       { testFlag &= ((q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName "EXT")) != NULL); }
#define GL_LoadMandatoryFunctionExtension(functionName,testFlag) { testFlag &= ((q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName)) != NULL); }
#define GL_InvalidateFunction(functionName)      { q##functionName##_impl = NULL; }
#define GL_LoadOptionalFunction(functionName)    { q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName); }
#define GL_LoadOptionalFunctionEXT(functionName) { q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName "EXT"); }
#define GL_LoadOptionalFunctionARB(functionName) { q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName "ARB"); }
#define GL_UseDirectStateAccess() (GL_VersionAtLeast(4, 5) || SDL_GL_ExtensionSupported("GL_ARB_direct_state_access"))
#define GL_StaticProcedureDeclaration(name, formatString, ...) \
	typedef void (APIENTRY *name ## _t)(__VA_ARGS__); \
	static name ## _t    q ## name ## _impl; \
	static const char* q ## name ## _formatString = formatString;
#define GL_StaticFunctionDeclaration(name, formatString, resultFormatString, returnType, ...)\
	typedef returnType (APIENTRY *name ## _t)(__VA_ARGS__); \
	static name ## _t    q ## name ## _impl; \
	static const char* q ## name ## _formatString = formatString; \
	static const char* q ## name ## _resultString = resultFormatString; \
	static returnType GL_Wrapper_ ## name(__VA_ARGS__)

#define GL_StaticFunctionWrapperBody(name, returnType, ...) \
{ \
	returnType result; \
	if (COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		const char* args = va(q ## name ## _formatString, __VA_ARGS__); \
\
		R_TraceAPI("%s(%s)@%s,%d", #name, args, __FILE__, __LINE__); \
	} \
	result = q ## name ## _impl(__VA_ARGS__); \
	if (COM_CheckParm(cmdline_param_client_video_r_debug) || COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		GL_ProcessErrors(#name); \
		R_TraceAPI(q ## name ## _resultString, result); \
	} \
\
	return result; \
}

#define GL_StaticFunctionWrapperBodyNoArgs(name, returnType) \
{ \
	returnType result; \
	if (COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		R_TraceAPI("%s()@%s,%d", #name, __FILE__, __LINE__); \
	} \
	result = q ## name ## _impl(); \
	if (COM_CheckParm(cmdline_param_client_video_r_debug) || COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		GL_ProcessErrors(#name); \
		R_TraceAPI(q ## name ## _resultString, result); \
	} \
\
	return result; \
}

#define GL_Procedure(name, ...) \
{ \
	if (COM_CheckParm(cmdline_param_client_video_r_debug)) { \
		const char* ez_gldebug_args = va(q ## name ## _formatString, __VA_ARGS__); \
\
		R_TraceAPI("%s(%s)@%s,%d", #name, ez_gldebug_args, __FILE__, __LINE__); \
	} \
	q ## name ## _impl(__VA_ARGS__); \
	if (COM_CheckParm(cmdline_param_client_video_r_debug) || COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		GL_ProcessErrors(#name); \
	} \
}

#define GL_ProcedureNoArgs(name) \
{ \
	if (COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		R_TraceAPI("%s()@%s,%d", #name, __FILE__, __LINE__); \
	} \
	q ## name ## _impl(); \
	if (COM_CheckParm(cmdline_param_client_video_r_debug) || COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		GL_ProcessErrors(#name); \
	} \
}

#define GL_ProcedureReturnError(name, ...) \
{ \
	GLenum ez_gl_error = GL_NO_ERROR; \
	if (COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		const char* ez_gldebug_args = va(q ## name ## _formatString, __VA_ARGS__); \
\
		R_TraceAPI("%s(%s)@%s,%d", #name, ez_gldebug_args, __FILE__, __LINE__); \
	} \
	q ## name ## _impl(__VA_ARGS__); \
	if (COM_CheckParm(cmdline_param_client_video_r_debug) || COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		ez_gl_error = GL_ProcessErrors(#name); \
	} \
	else { \
		ez_gl_error = glGetError(); \
	} \
	return ez_gl_error; \
}

#define GL_ProcedureReturnIfError(name, ...) \
{ \
	GLenum ez_gl_error = GL_NO_ERROR; \
	if (COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		const char* ez_gldebug_args = va(q ## name ## _formatString, __VA_ARGS__); \
\
		R_TraceAPI("%s(%s)@%s,%d", #name, ez_gldebug_args, __FILE__, __LINE__); \
	} \
	q ## name ## _impl(__VA_ARGS__); \
	if (COM_CheckParm(cmdline_param_client_video_r_debug) || COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		ez_gl_error = GL_ProcessErrors(#name); \
	} \
	else { \
		ez_gl_error = glGetError(); \
	} \
	if (ez_gl_error != GL_NO_ERROR) { \
		return ez_gl_error; \
	} \
}

#define GL_BuiltinProcedure(name, formatString, ...) \
{ \
	if (COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		const char* ez_gldebug_args = va(formatString, __VA_ARGS__); \
\
		R_TraceAPI("%s(%s)@%s,%d", #name, ez_gldebug_args, __FILE__, __LINE__); \
	} \
	name(__VA_ARGS__); \
	if (COM_CheckParm(cmdline_param_client_video_r_debug) || COM_CheckParm(cmdline_param_client_video_r_trace)) { \
		GL_ProcessErrors(#name); \
	} \
}
#define GL_Function(name, ...)    GL_Wrapper_ ## name(__VA_ARGS__)
#define GL_FunctionNoArgs(name)   GL_Wrapper_ ## name()
#define GL_BuiltinFunction(name, returnType, ...)
#define GL_Available(name)        ((q ## name ## _impl) != NULL)
#else
// No direct tracing
#ifndef EZ_OPENGL_NO_EXTENSIONS
#define GL_LoadRequiredFunction(varName, functionName) (((varName) = (functionName##_t)SDL_GL_GetProcAddress(#functionName)) != NULL)
#define GL_LoadMandatoryFunction(functionName,testFlag) { testFlag &= ((q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName)) != NULL); }
#define GL_LoadMandatoryFunctionEXT(functionName,testFlag) { testFlag &= ((q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName "EXT")) != NULL); }
#define GL_LoadMandatoryFunctionExtension(functionName,testFlag) { testFlag &= ((q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName)) != NULL); }
#define GL_LoadOptionalFunction(functionName) { q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName); }
#define GL_LoadOptionalFunctionEXT(functionName) { q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName "EXT"); }
#define GL_LoadOptionalFunctionARB(functionName) { q##functionName##_impl = (functionName##_t)SDL_GL_GetProcAddress(#functionName "ARB"); }
#define GL_UseDirectStateAccess() (GL_VersionAtLeast(4, 5) || SDL_GL_ExtensionSupported("GL_ARB_direct_state_access"))
#else
#define GL_LoadMandatoryFunction(functionName,testFlag) { q##functionName##_impl = NULL; testFlag = false; }
#define GL_LoadMandatoryFunctionEXT(functionName,testFlag) { q##functionName##_impl = NULL; testFlag = false; }
#define GL_LoadMandatoryFunctionExtension(functionName,testFlag) { q##functionName##_impl = NULL; testFlag = false; }
#define GL_LoadOptionalFunction(functionName) { q##functionName##_impl = NULL; }
#define GL_LoadOptionalFunctionEXT(functionName) { q##functionName##_impl = NULL; }
#define GL_LoadOptionalFunctionARB(functionName) { q##functionName##_impl = NULL; }
#define GL_UseDirectStateAccess() (false)
#endif
#define GL_InvalidateFunction(functionName)      { q##functionName##_impl = NULL; }
#define GL_StaticProcedureDeclaration(name, formatString, ...) \
	typedef void (APIENTRY *name ## _t)(__VA_ARGS__); \
	static name ## _t    q ## name ## _impl;
#define GL_StaticFunctionDeclaration(name, formatString, resultFormatString, returnType, ...) \
	typedef returnType (APIENTRY *name ## _t)(__VA_ARGS__); \
	static name ## _t    q ## name ## _impl;
#define GL_StaticFunctionWrapperBody(...)
#define GL_StaticFunctionWrapperBodyNoArgs(...)
#define GL_Procedure(name, ...)   { q ## name ## _impl(__VA_ARGS__); }
#define GL_ProcedureNoArgs(name)  { q ## name ## _impl(); }
#define GL_BuiltinProcedure(name, formatString, ...) { name(__VA_ARGS__); }
#define GL_Function(name, ...) q ## name ## _impl(__VA_ARGS__)
#define GL_FunctionNoArgs(name)   q ## name ## _impl()
#define GL_Available(name) ((q ## name ## _impl) != NULL)
#define GL_ProcedureReturnError(name, ...) { q ## name ## _impl(__VA_ARGS__); return glGetError(); }
#define GL_ProcedureReturnIfError(name, ...) { \
	GLenum ez_gl_error; \
	q ## name ## _impl(__VA_ARGS__); \
	ez_gl_error = glGetError(); \
	if (ez_gl_error != GL_NO_ERROR) { \
		return ez_gl_error; \
	} \
}
#define GL_ProcessErrors(text)
#endif // 

void GLC_ClientActiveTexture(GLenum texture_unit);
void GL_ConsumeErrors(void);

void VK_PrintGfxInfo(void);

// Trace functions
#ifdef WITH_RENDERING_TRACE
void GL_TraceObjectLabelSet(GLenum identifier, GLuint name, int length, const char* label);
void GL_TraceObjectLabelGet(GLenum identifier, GLuint name, int bufSize, int* length, char* label);
#else
#define GL_TraceObjectLabelSet(...)
#define GL_TraceObjectLabelGet(...)
#endif

// For context creation
typedef struct opengl_version_s {
	int majorVersion;
	int minorVersion;
	qbool core;
	qbool legacy;
} opengl_version_t;

SDL_GLContext GL_SDL_CreateBestContext(SDL_Window* window, const opengl_version_t* versions, int count);

void GL_PackAlignment(int alignment_in_bytes);

#endif /* !__GL_LOCAL_H__ */


================================================
FILE: src/gl_misc.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
// gl_misc.c

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "tr_types.h"
#include "r_renderer.h"
#include "r_lightmaps_internal.h"
#include "gl_texture_internal.h"

typedef struct gl_enum_value_s {
	GLenum value;
	const char* name;
	int benchmark_bpp;
} gl_enum_value_t;

static gl_enum_value_t image_formats[] = {
	{ GL_RED, "RED", 0 },
	{ GL_RG, "RG", 0 },
	{ GL_RGB, "RGB", 0 },
	{ GL_BGR, "BGR", 0 },
	{ GL_RGBA, "RGBA", 4 },
	{ GL_BGRA, "BGRA", 4 },
	{ GL_RED_INTEGER, "RED_INT" },
	{ GL_RG_INTEGER, "RG_INT" },
	{ GL_RGB_INTEGER, "RGB_INT" },
	{ GL_BGR_INTEGER, "BGR_INT" },
	{ GL_RGBA_INTEGER, "RGBA_INT" },
	{ GL_BGRA_INTEGER, "BGRA_INT" },
	{ GL_STENCIL_INDEX, "STENCIL_INDEX" },
	{ GL_DEPTH_COMPONENT, "DEPTH_COMPONENT" },
	{ GL_DEPTH_STENCIL, "DEPTH_STENCIL" }
};
static gl_enum_value_t image_types[] = {
	{ GL_UNSIGNED_BYTE, "UBYTE", 3 },
	{ GL_BYTE, "BYTE", 3 },
	{ GL_UNSIGNED_SHORT, "USHORT", 0 },
	{ GL_SHORT, "SHORT", 0 },
	{ GL_UNSIGNED_INT, "UINT", 4 },
	{ GL_INT, "INT", 4 },
	{ GL_FLOAT, "FLOAT", 0 },
	{ GL_UNSIGNED_BYTE_3_3_2, "UBYTE_332", 0 },
	{ GL_UNSIGNED_BYTE_2_3_3_REV, "UBYTE_233R", 0 },
	{ GL_UNSIGNED_SHORT_5_6_5, "USHORT_565", 0 },
	{ GL_UNSIGNED_SHORT_5_6_5_REV, "USHORT_565R", 0 },
	{ GL_UNSIGNED_SHORT_4_4_4_4, "USHORT_4444", 0 },
	{ GL_UNSIGNED_SHORT_4_4_4_4_REV, "USHORT_4444R", 0 },
	{ GL_UNSIGNED_SHORT_5_5_5_1, "USHORT_5551", 0 },
	{ GL_UNSIGNED_SHORT_1_5_5_5_REV, "USHORT_1555R", 0 },
	{ GL_UNSIGNED_INT_8_8_8_8, "UINT_8888", 4 },
	{ GL_UNSIGNED_INT_8_8_8_8_REV, "UINT_8888R", 4 },
	{ GL_UNSIGNED_INT_10_10_10_2, "UINT_101010_2", 4 },
	{ GL_UNSIGNED_INT_2_10_10_10_REV, "UINT_2_101010R", 4 }
};


void GL_Clear(qbool clear_color)
{
	R_ApplyRenderingState(r_state_default_3d);
	glClear((clear_color ? GL_COLOR_BUFFER_BIT : 0) | GL_DEPTH_BUFFER_BIT);
}

void GL_EnsureFinished(void)
{
	glFinish();
}

GLenum GL_ProcessErrors(const char* message);

GLenum GL_ProcessAllErrors(const char* message)
{
	GLenum error = glGetError();
	GLenum firstError = error;

	while (error != GL_NO_ERROR) {
		if (error == GL_INVALID_ENUM) {
			R_TraceLogAPICall("  ERROR: %s (GL_INVALID_ENUM)\n", message);
		}
		else if (error == GL_INVALID_VALUE) {
			R_TraceLogAPICall("  ERROR: %s (GL_INVALID_VALUE)\n", message);
		}
		else if (error == GL_INVALID_OPERATION) {
			R_TraceLogAPICall("  ERROR: %s (GL_INVALID_OPERATION)\n", message);
		}
		else if (error == GL_STACK_OVERFLOW) {
			R_TraceLogAPICall("  ERROR: %s (GL_STACK_OVERFLOW)\n", message);
		}
		else if (error == GL_STACK_UNDERFLOW) {
			R_TraceLogAPICall("  ERROR: %s (GL_STACK_UNDERFLOW)\n", message);
		}
		else if (error == GL_OUT_OF_MEMORY) {
			R_TraceLogAPICall("  ERROR: %s (GL_OUT_OF_MEMORY)\n", message);
		}
		else {
			R_TraceLogAPICall("  ERROR: %s (UNKNOWN_ERROR 0x%X)\n", message, error);
		}
		error = glGetError();
	}
	return firstError;
}

void GL_ConsumeErrors(void)
{
	GL_ProcessAllErrors("Consuming prior errors...");
}

static void GL_PrintInfoLine(const char* label, int labelsize, const char* fmt, ...)
{
	va_list argptr;
	char msg[128];

	va_start(argptr, fmt);
	vsnprintf(msg, sizeof(msg), fmt, argptr);
	va_end(argptr);

	Com_Printf_State(PRINT_ALL, "  %-*s ", labelsize, label);
	con_margin = labelsize + 3;
	Com_Printf_State(PRINT_ALL, "%s", msg);
	con_margin = 0;
	Com_Printf_State(PRINT_ALL, "\n");
}

void GL_PrintGfxInfo(void)
{
	SDL_DisplayMode current;
	GLint num_extensions;
	int i;

	Com_Printf_State(PRINT_ALL, "\nOpenGL (%s)\n", R_UseImmediateOpenGL() ? "classic" : "glsl");
	GL_PrintInfoLine("Vendor:", 9, "%s", (const char*)glConfig.vendor_string);
	GL_PrintInfoLine("Renderer:", 9, "%s", (const char*)glConfig.renderer_string);
	GL_PrintInfoLine("GLSL:", 9, "%s", (const char*)glConfig.glsl_version);
	GL_PrintInfoLine("Version:", 9, "%s", (const char*)glConfig.version_string);

	if (r_showextensions.integer) {
		Com_Printf_State(PRINT_ALL, "GL_EXTENSIONS: ");
		if (GL_VersionAtLeast(3, 0)) {
			typedef const GLubyte* (APIENTRY *glGetStringi_t)(GLenum name, GLuint index);
			glGetStringi_t glGetStringi = (glGetStringi_t)SDL_GL_GetProcAddress("glGetStringi");
			if (glGetStringi) {
				glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
				for (i = 0; i < num_extensions; ++i) {
					Com_Printf_State(PRINT_ALL, "%s%s", i ? " " : "", glGetStringi(GL_EXTENSIONS, i));
				}
				Com_Printf_State(PRINT_ALL, "\n");
			}
			else {
				Com_Printf_State(PRINT_ALL, "(list unavailable)\n");
			}
		}
		else {
			Com_Printf_State(PRINT_ALL, "%s\n", (const char*)glGetString(GL_EXTENSIONS));
		}
	}

	Com_Printf_State(PRINT_ALL, "Textures:\n");
	GL_PrintInfoLine("Units:", 14, "%d", glConfig.texture_units);
	GL_PrintInfoLine("Size:", 14, "%d", glConfig.gl_max_size_default);
	if (R_UseModernOpenGL()) {
		GL_PrintInfoLine("3D Sizes:", 14, "%dx%dx%d\n", glConfig.max_3d_texture_size, glConfig.max_3d_texture_size, glConfig.max_texture_depth);
	}
	if (glConfig.preferred_format || glConfig.preferred_type) {
		Com_Printf_State(PRINT_ALL, "Preferences\n");
		const char* format = "?";
		const char* type = "?";

		for (i = 0; i < sizeof(image_formats) / sizeof(image_formats[0]); ++i) {
			if (image_formats[i].value == glConfig.preferred_format) {
				format = image_formats[i].name;
				break;
			}
		}
		for (i = 0; i < sizeof(image_types) / sizeof(image_types[0]); ++i) {
			if (image_types[i].value == glConfig.preferred_type) {
				type = image_types[i].name;
				break;
			}
		}

		GL_PrintInfoLine("Image Format:", 14, "0x%x (%s)", glConfig.preferred_format, format);
		GL_PrintInfoLine("Image Type:", 14, "0x%x (%s)", glConfig.preferred_type, type);
	}
	GL_PrintInfoLine("Lightmaps:", 14, "%s/%s", GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS) ? "BGRA" : "RGBA", GL_Supported(R_SUPPORT_INT8888R_LIGHTMAPS) ? "UINT8888R" : "UBYTE");

	Com_Printf_State(PRINT_ALL, "Supported features:\n");
	GL_PrintInfoLine("Shaders:", 15, "%s", GL_Supported(R_SUPPORT_RENDERING_SHADERS) ? "&c0f0available&r" : "&cf00unsupported&r");
	GL_PrintInfoLine("Compute:", 15, "%s", GL_Supported(R_SUPPORT_COMPUTE_SHADERS) ? "&c0f0available&r" : "&cf00unsupported&r");
	GL_PrintInfoLine("Framebuffers:", 15, "%s", GL_Supported(R_SUPPORT_FRAMEBUFFERS) ? "&c0f0available&r" : "&cf00unsupported&r");
	GL_PrintInfoLine("Tex arrays:", 15, "%s", GL_Supported(R_SUPPORT_TEXTURE_ARRAYS) ? "&c0f0available&r" : "&cf00unsupported&r");
	GL_PrintInfoLine("Tex samplers:", 15, "%s", GL_Supported(R_SUPPORT_TEXTURE_SAMPLERS) ? "&c0f0available&r" : "&cf00unsupported&r");
	GL_PrintInfoLine("HW lighting:", 15, "%s", GL_Supported(R_SUPPORT_FEATURE_HW_LIGHTING) ? "&c0f0available&r" : "&cf00unsupported&r");

	if (SDL_GetCurrentDisplayMode(VID_DisplayNumber(r_fullscreen.value), &current) != 0) {
		current.refresh_rate = 0; // print 0Hz if we run into problem fetching data
	}

	Com_Printf_State(PRINT_ALL, "Video\n");
	GL_PrintInfoLine("Resolution:", 12, "%dx%d@%dhz [%s]", current.w, current.h, current.refresh_rate, r_fullscreen.integer ? "fullscreen" : "windowed");
	GL_PrintInfoLine("Format:", 12, "%2d-bit color\n%2d-bit z-buffer\n%2d-bit stencil", glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits);
	if (GL_FramebufferEnabled3D()) {
		GL_PrintInfoLine("Framebuffer:", 12, "%dx%d,%s\n", GL_FrameBufferWidth(framebuffer_std), GL_FrameBufferHeight(framebuffer_std), GL_FramebufferZBufferString(framebuffer_std));
	}
	if (vid.aspect) {
		GL_PrintInfoLine("Aspect:", 12, "%f%%", vid.aspect);
	}
	if (r_conwidth.integer || r_conheight.integer) {
		GL_PrintInfoLine("Console Res:", 12,"%d x %d", r_conwidth.integer, r_conheight.integer);
	}
}

void GL_Viewport(int x, int y, int width, int height)
{
	glViewport(x, y, width, height);
}

const char* GL_DescriptiveString(void)
{
	return (const char*)glGetString(GL_RENDERER);
}

typedef struct {
	int format;
	int type;
	float result;
} lightmap_benchmark_t;

int LightmapBenchmarkComparison(const void* lhs_, const void* rhs_)
{
	lightmap_benchmark_t* lhs = (lightmap_benchmark_t*)lhs_;
	lightmap_benchmark_t* rhs = (lightmap_benchmark_t*)rhs_;

	if (lhs->result < rhs->result) {
		return -1;
	}
	if (lhs->result > rhs->result) {
		return 1;
	}
	return (uintptr_t)lhs < (uintptr_t)rhs ? -1 : 1;
}

static byte gl_lightmap_data[LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT * 16];

void GL_BenchmarkLightmapFormats(void)
{
	texture_ref texture;
	int format;
	int type;
	lightmap_benchmark_t results[(sizeof(image_formats) / sizeof(image_formats[0])) * (sizeof(image_types) / sizeof(image_types[0]))];
	int count = 0, i;

	for (format = 0; format < sizeof(image_formats) / sizeof(image_formats[0]); ++format) {
		for (type = 0; type < sizeof(image_types) / sizeof(image_types[0]); ++type) {
			double started;
			double finished;

			if (!image_formats[format].benchmark_bpp || !image_types[type].benchmark_bpp || image_types[type].benchmark_bpp > image_formats[format].benchmark_bpp) {
				continue;
			}

			memset(gl_lightmap_data, 255, sizeof(gl_lightmap_data));

			GL_ProcessErrors("Pre-init");

			GL_CreateTexturesWithIdentifier(texture_type_2d, 1, &texture, "lightmap-benchmark");
			renderer.TextureUnitBind(0, texture);
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, 0, image_formats[format].value, image_types[type].value, gl_lightmap_data);
			if (glGetError() != GL_NO_ERROR) {
				Con_Printf("%s/%s: error\n", image_formats[format].name, image_types[type].name);
				continue;
			}
			renderer.TextureSetFiltering(texture, texture_minification_linear, texture_magnification_linear);
			renderer.TextureWrapModeClamp(texture);
			glFinish();

			memset(gl_lightmap_data, 0, sizeof(gl_lightmap_data));
			started = Sys_DoubleTime();
			for (i = 0; i < 1000; ++i) {
				glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, image_formats[format].value, image_types[type].value, gl_lightmap_data);
			}
			glFinish();
			finished = Sys_DoubleTime();

			GL_ProcessErrors("Post-test");
			renderer.TextureDelete(texture);

			results[count].format = format;
			results[count].type = type;
			results[count].result = (finished - started) * 1000.0f;
			++count;
		}
	}

	qsort(results, count, sizeof(results[0]), LightmapBenchmarkComparison);

	Con_Printf("Results:\n");
	for (i = 0; i < count; ++i) {
		qbool preferred;
		qbool current;
		char label[20];

		format = results[i].format;
		type = results[i].type;

		strlcpy(label, image_formats[format].name, sizeof(label));
		strlcat(label, "/", sizeof(label));
		strlcat(label, image_types[type].name, sizeof(label));

		preferred = (image_formats[format].value == glConfig.preferred_format && image_types[type].value == glConfig.preferred_type);
		current = (GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS) ? GL_BGRA : GL_RGBA) == image_formats[format].value &&
		          (GL_Supported(R_SUPPORT_INT8888R_LIGHTMAPS) ? GL_UNSIGNED_INT_8_8_8_8_REV : GL_UNSIGNED_BYTE) == image_types[type].value;

		Con_Printf("%s %02d %-20s: %8.3fms%s&r\n", current ? "&c0f0>>>" : "   ", i + 1, label, results[i].result, current && preferred ? " <<< preferred" : preferred ? " &cff0<<< preferred" : "");
	}
}


================================================
FILE: src/gl_model.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef __MODEL__
#define __MODEL__

#include "modelgen.h"
#include "spritegn.h"
#include "bspfile.h"

#define VBO_FIELDOFFSET(type, field) (void*)((uintptr_t)&(((type*)0)->field))
#define VK_VBO_FIELDOFFSET(type, field) (uint32_t)((uintptr_t)&(((type*)0)->field))

/*
d*_t structures are on-disk representations
m*_t structures are in-memory
*/


/*
==============================================================================

BRUSH MODELS

==============================================================================
*/


//
// in memory representation
//
// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct mvertex_s {
	vec3_t		position;
} mvertex_t;

typedef struct texture_s {
	char                name[16];
	unsigned int        width, height;
	texture_ref         gl_texturenum;
	texture_ref         fb_texturenum;				//index of fullbright mask or 0
	struct msurface_s*  texturechain;
	struct msurface_s** texturechain_tail;          //Points to the node right after the last non-NULL node in the texturechain.

	int                 anim_total;                 //total tenths in sequence ( 0 = no)
	int                 anim_min, anim_max;         //time for this frame min <=time< max
	struct texture_s*   anim_next;                  //in the animation sequence
	struct texture_s*   alternate_anims;            //bmodels in frame 1 use these
	unsigned int        offsets[MIPLEVELS];         //four mip maps stored
	unsigned int        flatcolor3ub;               //just for r_fastturb's sake
	qbool               loaded;                     //help speed up vid_restart, actual only for brush models
	int                 isLumaTexture;              //fb is luma texture, rather than normal fb
	qbool               isAlphaTested;              //texture is flagged for alpha-testing
	qbool               isLitTurb;                  //turb texture has lightmap
	int                 turbType;

	int                 next_same_size;
	qbool               size_start;

	texture_ref         gl_texture_array;
	unsigned int        gl_texture_index;
	float               gl_texture_scaleS;
	float               gl_texture_scaleT;

	int                 index;
} texture_t;


#define	SURF_PLANEBACK		2
#define	SURF_DRAWSKY		4
#define SURF_DRAWSPRITE		8
#define SURF_DRAWTURB		16
#define SURF_DRAWTILED		32
#define SURF_DRAWBACKGROUND	64
#define SURF_UNDERWATER		128
#define SURF_DRAWALPHA		256
#define SURF_DRAWFLAT_FLOOR 512

// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct medge_s {
	unsigned int		v[2];
	unsigned int		cachededgeoffset;
} medge_t;

typedef struct mtexinfo_s {
	float         vecs[2][4];
	texture_t     *texture;
	int           miptex;
	int           flags;
	qbool         skippable;
	int           surfaces;
} mtexinfo_t;

// Filled in CopyVertToBuffer in glm_brushmodel
typedef struct vbo_world_vert_s {
	// Positions 0/4/8
	vec3_t position;

	// Positions 12/16/20
	vec3_t material_coords;

	// Positions 24/28/32
	vec3_t lightmap_coords;

	// Positions 36/40
	float detail_coords[2];

	// Positions 44/48/52
	float flatcolor[3];

	// Position 56
	int surface_num;

	// Position 60 (VBO_WORLD_X)
	int flags;
} vbo_world_vert_t;

// Trying to pad out to keep ATI/AMD happy (doesn't seem to make a difference?)
// https://developer.amd.com/wordpress/media/2012/10/ATI_OpenGL_Programming_and_Optimization_Guide.pdf
typedef struct glc_vbo_world_vert_s {
	float position[4];
	float material_coords[2];
	float detail_coords[2];
	float lightmap_coords[4];

	float flatstyle;
	float padding[3];
} glc_vbo_world_vert_t;

// GLC only...
// For turb surfaces, we use lightmap tex coords to store 8*sin(<s or t>), and detail coords to store 8*cos(<s or t>)
#define VERTEXSIZE 9  //xyz s1t1 s2t2 s3t3 where xyz = vert coords; s1t1 = normal tex coords; 
					  //s2t2 = lightmap tex coords; s3t3 = detail tex coords

typedef struct vbo_model_vert_s {
	vec3_t position;
	int lightnormalindex;
	vec3_t normal;
	int padding2;
	vec3_t direction;
	int padding3;
	float texture_coords[2];
	unsigned int flags;
	int padding4;
} vbo_model_vert_t;

typedef struct glpoly_s {
	struct	glpoly_s	*next;
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	struct	glpoly_s	*chain;						//next lightmap poly in chain
	struct	glpoly_s	*fb_chain;					//next fb poly in chain
	struct	glpoly_s	*luma_chain;				//next luma poly in chain
	struct	glpoly_s	*caustics_chain;			//next caustic poly in chain
	struct	glpoly_s	*detail_chain;				//next detail poly in chain
#endif

	unsigned int        vbo_start;
	int					numverts;
	float				verts[4][VERTEXSIZE];		// variable sized (xyz s1t1 s2t2 l)
} glpoly_t;

typedef struct msurface_s {
	int                 visframe;                   // should be drawn when node is crossed

	mplane_t*           plane;
	int                 flags;

	int                 firstedge;                  // look up in model->surfedges[], negative numbers
	int                 numedges;                   // are backwards edges
	
	short               texturemins[2];
	short               extents[2];

	short               lmshift;

	// gl lightmap coordinates
	int                 light_s;
	int                 light_t;

	glpoly_t            *polys;                     // multiple if warped
	glpoly_t            *subdivided;
	struct	msurface_s  *texturechain;
	struct	msurface_s  *drawflatchain;

	mtexinfo_t          *texinfo;

	// decoupled lm
	float               lmvecs[2][4];
	float               lmvlen[2];

	// lighting info
	int                 dlightframe;
	int                 dlightbits;

	// This is not an OpenGL texture name, it's the lightmap index
	int                 lightmaptexturenum;
	int                 surfacenum;

	byte                styles[MAXLIGHTMAPS];
	int                 cached_light[MAXLIGHTMAPS]; // values currently used in lightmap
	qbool               cached_dlight;              // true if dynamic light in cache
	byte                *samples;                   // [numstyles*surfsize]
} msurface_t;

typedef struct mnode_s {
	// common with leaf
	int					contents;					// 0, to differentiate from leafs
	int					visframe;					// node needs to be traversed if current
	
	float				minmaxs[6];					// for bounding box culling

	struct mnode_s		*parent;

	// node specific
	mplane_t			*plane;
	struct mnode_s		*children[2];	

	unsigned int		firstsurface;
	unsigned int		numsurfaces;
} mnode_t;

typedef struct mleaf_s {
	// common with node
	int					contents;					// wil be a negative contents number
	int					visframe;					// node needs to be traversed if current

	float				minmaxs[6];					// for bounding box culling

	struct mnode_s		*parent;

	// leaf specific
	byte				*compressed_vis;
	struct efrag_s		*efrags;

	msurface_t			**firstmarksurface;
	int					nummarksurfaces;
} mleaf_t;


/*
==============================================================================

SPRITE MODELS

==============================================================================
*/


// FIXME: shorten these?
typedef struct mspriteframe_s {
	int                 width;
	int                 height;
	float               up, down, left, right;
	texture_ref         gl_texturenum;
	texture_ref         gl_arraynum;
	int                 gl_arrayindex;

	float               gl_scalingS;
	float               gl_scalingT;
} mspriteframe_t;

typedef struct mspritegroup_s {
	int					numframes;
	float				*intervals;
	mspriteframe_t		*frames[1];
} mspritegroup_t;

typedef struct mspriteframedesc_s {
	spriteframetype_t	type;
	mspriteframe_t		*frameptr;
} mspriteframedesc_t;

typedef struct msprite_s {
	int					type;
	int					maxwidth;
	int					maxheight;
	int					numframes;
	float				beamlength; // remove?
	void				*cachespot; // remove?
	mspriteframedesc_t	frames[1];
} msprite_t;

#define MAX_SPRITE_FRAMES (512)

typedef struct mspriteframe2_s {
	mspriteframe_t		frame;
	float				interval;
} mspriteframe2_t;

typedef struct mspriteframedesc2_s {
	spriteframetype_t	type;

	int					numframes;			// always 1 for type == SPR_SINGLE
	int					offset;

} mspriteframedesc2_t;

typedef struct msprite2_s {
	int					type;
	int					maxwidth;
	int					maxheight;
	int					numframes;

	mspriteframedesc2_t	frames[MAX_SPRITE_FRAMES];
} msprite2_t; // actual frames follow after struct immidiately


/*
==============================================================================

ALIAS MODELS

Alias models are position independent, so the cache manager can move them.
==============================================================================
*/


typedef struct maliasframedesc_s {
	int					firstpose;
	int					numposes;
	float				interval;
	vec3_t				bboxmin;
	vec3_t				bboxmax;
	float				radius;
	int					frame;
	char				name[16];
	char                groupname[16];
	int                 groupnumber;
	int                 nextpose;
} maliasframedesc_t;

typedef struct maliasgroupframedesc_s {
	trivertx_t			bboxmin;
	trivertx_t			bboxmax;
	int					frame;
} maliasgroupframedesc_t;

typedef struct maliasgroup_s {
	int					numframes;
	int					intervals;
	maliasgroupframedesc_t frames[1];
} maliasgroup_t;

// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct mtriangle_s {
	int					facesfront;
	int					vertindex[3];
} mtriangle_t;


#define MAX_SKINS 32
typedef struct aliashdr_s {
	int          ident;
	int          version;
	vec3_t       scale;
	vec3_t       scale_origin;
	float        boundingradius;
	vec3_t       eyeposition;
	int          numskins;
	int          skinwidth;
	int          skinheight;
	int          numverts;
	int          numtris;
	int          numframes;
	synctype_t   synctype;
	int          flags;
	float        size;

	int          numposes;
	int          poseverts;
	int          posedata;	// numposes*poseverts ez_trivertx_t
	int          commands;	// gl command list with embedded s/t
	texture_ref  gl_texturenum[MAX_SKINS][4];
	texture_ref  glc_fb_texturenum[MAX_SKINS][4];

	int          vertsPerPose;

	maliasframedesc_t	frames[1];	// variable sized
} aliashdr_t;

//===================================================================

//
// Whole model
//

#define	MAXALIASVERTS	2048
#define	MAXALIASFRAMES	256
#define	MAXALIASTRIS	2048
extern	aliashdr_t		*pheader;
extern	stvert_t		stverts[MAXALIASVERTS];
extern	mtriangle_t		triangles[MAXALIASTRIS];
extern	trivertx_t		*poseverts[MAXALIASFRAMES];

// some models are special
typedef enum 
{
	MOD_NORMAL, 
	MOD_PLAYER, 
	MOD_EYES, 
	MOD_FLAME,
	MOD_THUNDERBOLT,
	MOD_BACKPACK,
	MOD_FLAG,
	MOD_SPIKE, 
	MOD_TF_TRAIL,
	MOD_GRENADE, 
	MOD_TESLA, 
	MOD_SENTRYGUN, 
	MOD_DETPACK,
	MOD_LASER, 
	MOD_DEMON, 
	MOD_SOLDIER,
	MOD_OGRE,
	MOD_ENFORCER,
	MOD_VOORSPIKE,
	MOD_LAVABALL,
	MOD_RAIL, 
	MOD_RAIL2,
	MOD_BUILDINGGIBS,
	MOD_CLUSTER,
	MOD_SHAMBLER, 
	MOD_TELEPORTDESTINATION,
	MOD_GIB,
	MOD_VMODEL,
	MOD_ROCKET,
	MOD_ARMOR,
	MOD_MEGAHEALTH,
	MOD_ROCKETLAUNCHER,
	MOD_LIGHTNINGGUN,
	MOD_QUAD,
	MOD_PENT,
	MOD_RING,
	MOD_FLAME0,
	MOD_FLAME2,
	MOD_FLAME3,
	MOD_SUIT,
	MOD_GRENADELAUNCHER,

	MOD_NUMBER_HINTS
} modhint_t;

#define	EF_ROCKET	1			// leave a trail
#define	EF_GRENADE	2			// leave a trail
#define	EF_GIB		4			// leave a trail
#define	EF_ROTATE	8			// rotate (bonus items)
#define	EF_TRACER	16			// green split trail
#define	EF_ZOMGIB	32			// small blood trail
#define	EF_TRACER2	64			// orange split trail + rotate
#define	EF_TRACER3	128			// purple trail

#define MOD_HDRLIGHTING (1u<<13)	//spike -- light samples are in e5bgr9 format. int aligned.

#define MAX_SIMPLE_TEXTURES 5
#define MAX_TEXTURE_ARRAYS_PER_MODEL 64

typedef struct worldspawn_info_s {
	char skybox_name[MAX_QPATH];
	float fog_density;
	vec3_t fog_color;
	float fog_sky;

	float wateralpha;
	float lavaalpha;
	float telealpha;
	float slimealpha;
} worldspawn_info_t;

typedef struct model_s {
	char				name[MAX_QPATH];
	qbool				needload; // bmodels and sprites don't cache normally

	unsigned short		crc;

	texture_ref         simpletexture[MAX_SIMPLE_TEXTURES]; // for simpleitmes

	modhint_t			modhint;
	modhint_t			modhint_trail;

	modtype_t			type;
	int					numframes;
	synctype_t			synctype;
	
	int					flags;

	// volume occupied by the model graphics
	vec3_t				mins, maxs;
	float				radius;

	// brush model
	int					firstmodelsurface, nummodelsurfaces;

	// FIXME, don't really need these two
	int					numsubmodels;
	dmodel_t			*submodels;

	int					numplanes;
	mplane_t			*planes;

	int					numleafs; // number of visible leafs, not counting 0
	mleaf_t				*leafs;

	int					numvertexes;
	mvertex_t			*vertexes;

	int					numedges;
	medge_t				*edges;

	int					numnodes;
	int					firstnode;
	mnode_t				*nodes;

	int					numtexinfo;
	mtexinfo_t			*texinfo;

	int					numsurfaces;
	msurface_t			*surfaces;

	int					numsurfedges;
	int					*surfedges;

	int					nummarksurfaces;
	msurface_t			**marksurfaces;

	int					numtextures;
	texture_t			**textures;

	byte*               visdata;
	int                 visdata_length;
	byte*               lightdata;
	size_t              lightdatasamplesize;

	int					bspversion;
	qbool				isworldmodel;

	// additional model data
	void*               cached_data;

	texture_ref         texture_arrays[MAX_TEXTURE_ARRAYS_PER_MODEL];
	float               texture_arrays_scale_s[MAX_TEXTURE_ARRAYS_PER_MODEL];
	float               texture_arrays_scale_t[MAX_TEXTURE_ARRAYS_PER_MODEL];
	unsigned int        texture_array_count;
	int                 texture_array_first[MAX_TEXTURE_ARRAYS_PER_MODEL];

	void*               temp_vbo_buffer;
	float               min_tex[2];
	float               max_tex[2];

	unsigned int        vbo_start;
	int                 vertsInVBO;

	texture_ref         simpletexture_array[MAX_SIMPLE_TEXTURES];
	int                 simpletexture_indexes[MAX_SIMPLE_TEXTURES];
	float               simpletexture_scalingS[MAX_SIMPLE_TEXTURES];
	float               simpletexture_scalingT[MAX_SIMPLE_TEXTURES];

	msurface_t*         drawflat_chain;
	qbool               drawflat_todo;
	qbool               alphapass_todo;
	int                 first_texture_chained;
	int                 last_texture_chained;
	qbool               texturechains_have_lumas;

	int                 renderfx;
} model_t;

//============================================================================

void	Mod_Init (void);
void	Mod_ClearAll (void);
model_t *Mod_ForName (const char *name, qbool crash);
void	*Mod_Extradata (model_t *mod); // handles caching
void	Mod_TouchModel (char *name);
void	Mod_TouchModels (void); // for vid_restart
void Mod_ReloadModels(qbool vid_restart);
void Mod_FreeAllCachedData(void);

mleaf_t *Mod_PointInLeaf(vec3_t p, model_t *model);
byte	*Mod_LeafPVS(mleaf_t *leaf, model_t *model);

qbool	Img_HasFullbrights (byte *pixels, int size);
void	Mod_ReloadModelsTextures (void); // for vid_restart

texture_ref Mod_LoadSimpleTexture(model_t *mod, int skinnum);
void    Mod_ClearSimpleTextures(void);

qbool Mod_IsAlphaTextureName(model_t* model, const char* name);
qbool Mod_IsSkyTextureName(model_t* model, const char* name);
qbool Mod_IsTurbTextureName(model_t* model, const char* name);

float RadiusFromBounds(vec3_t mins, vec3_t maxs);
void Mod_AddModelFlags(model_t *mod);
void R_LoadBrushModelTextures(model_t *m);
void R_BrushModelPolygonToTriangleStrip(glpoly_t* poly);

#include "r_aliasmodel_md3.h"

typedef enum {
	custom_model_explosion,
	custom_model_bolt,
	custom_model_bolt2,
	custom_model_bolt3,
	custom_model_beam,
	custom_model_flame0,

	custom_model_count
} custom_model_id_t;

extern model_t* cl_custommodels[custom_model_count];

model_t* Mod_CustomModel(custom_model_id_t id, qbool crash);

int Mod_ExpectedNextFrame(model_t* mod, int framenum, int framecount);

// aliasmodels
#define NUMVERTEXNORMALS    162
#define SHADEDOT_QUANT       64

#define MD3_INTERP_MAXDIST  300

// brushmodel
extern vec3_t modelorg;
// 
extern int      r_visframecount;
extern int      r_framecount;
extern mplane_t frustum[4];

// sky
#define BACKFACE_EPSILON	0.01


#define DEFAULT_LMSHIFT     4

#endif	// __MODEL__


================================================
FILE: src/gl_program.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// GL_program.c
// - All glsl program-related code

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_program.h"
#include "tr_types.h"
#include "glsl/constants.glsl"

typedef enum {
	renderer_classic = 1,
	renderer_modern,
} renderer_id;

#define STDOPTIONS_FOG_LINEAR     (1 << 0)
#define STDOPTIONS_FOG_EXP        (1 << 1)
#define STDOPTIONS_FOG_EXP2       (1 << 2)

#define STDOPTIONS_NONE           (0)
#define STDOPTIONS_FOG            (STDOPTIONS_FOG_LINEAR | STDOPTIONS_FOG_EXP | STDOPTIONS_FOG_EXP2)

#define GL_DefineProgram_VF(program_id, name, expect_params, sourcename, renderer, compile_function, standard_flags) \
	{ \
		extern unsigned char sourcename##_vertex_glsl[]; \
		extern unsigned int sourcename##_vertex_glsl_len; \
		extern unsigned char sourcename##_fragment_glsl[]; \
		extern unsigned int sourcename##_fragment_glsl_len; \
		extern qbool compile_function(void); \
		int i; \
\
		for (i = 0; i < MAX_SUBPROGRAMS; ++i) { \
			gl_program_t* prog = R_SpecificSubProgram((program_id), i); \
			memset(&prog->shaders, 0, sizeof(prog->shaders)); \
			strlcpy(prog->friendly_name, va("%s[%d]", (name), i), sizeof(prog->friendly_name)); \
			prog->needs_params = expect_params; \
			prog->shaders[shadertype_vertex].text = (const char*)sourcename##_vertex_glsl; \
			prog->shaders[shadertype_vertex].length = sourcename##_vertex_glsl_len; \
			prog->shaders[shadertype_fragment].text = (const char*)sourcename##_fragment_glsl; \
			prog->shaders[shadertype_fragment].length = sourcename##_fragment_glsl_len; \
			prog->initialised = true; \
			prog->renderer_id = renderer; \
			prog->compile_func = compile_function; \
			prog->standard_option_flags = standard_flags; \
		} \
	}

#define GL_DefineProgram_CS(program_id, name, expect_params, sourcename, renderer, compile_function, option_flags) \
	{ \
		extern unsigned char sourcename##_compute_glsl[]; \
		extern unsigned int sourcename##_compute_glsl_len; \
		extern qbool compile_function(void); \
		int i; \
\
		for (i = 0; i < MAX_SUBPROGRAMS; ++i) { \
			gl_program_t* prog = R_SpecificSubProgram((program_id), i); \
			memset(prog->shaders, 0, sizeof(prog->shaders)); \
			strlcat(prog->friendly_name, name, sizeof(prog->friendly_name)); \
			prog->needs_params = expect_params; \
			prog->shaders[shadertype_compute].text = (const char*)sourcename##_compute_glsl; \
			prog->shaders[shadertype_compute].length = sourcename##_compute_glsl_len; \
			prog->initialised = true; \
			prog->renderer_id = renderer; \
			prog->compile_func = compile_function; \
			prog->standard_option_flags = option_flags; \
		} \
	}

static void GL_BuildCoreDefinitions(void);

static const GLenum glBarrierFlags[] = {
	GL_SHADER_IMAGE_ACCESS_BARRIER_BIT,
	GL_TEXTURE_FETCH_BARRIER_BIT
};

#ifdef C_ASSERT
C_ASSERT(sizeof(glBarrierFlags) / sizeof(glBarrierFlags[0]) == r_program_memory_barrier_count);
#endif

enum {
	shadertype_vertex,
	shadertype_fragment,
	shadertype_geometry,
	shadertype_compute,

	shadertype_count
};

typedef struct gl_shader_def_s {
	const char* text;
	unsigned int length;
} gl_shader_def_t;

typedef qbool(*program_compile_func_t)(void);

#define MAX_SUBPROGRAMS 32
#define R_CurrentSubProgram(program_id) (&program_data[(program_id)][program_currentSubProgram[(program_id)]])
#define R_SpecificSubProgram(program_id, sub_id) (&program_data[(program_id)][(sub_id)])

typedef struct {
	qbool found;
	int location;
	int int_value;
} gl_program_uniform_t;

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
typedef struct {
	qbool found;
	GLint location;
} gl_program_attribute_t;
#endif

typedef enum {
	r_program_std_uniform_fog_linear_start,
	r_program_std_uniform_fog_linear_end,
	r_program_std_uniform_fog_density,
	r_program_std_uniform_fog_color,
	r_program_std_uniform_count
} r_program_std_uniform_id;

typedef struct {
	r_program_id program_id;
	const char* name;
	int count;
	qbool transpose;
} r_program_uniform_t;

static r_program_uniform_t program_std_uniforms[] = {
	// r_program_std_uniform_fog_linear_start
	{ r_program_none, "fogMinZ", 1, false },
	// r_program_std_uniform_fog_linear_end,
	{ r_program_none, "fogMaxZ", 1, false },
	// r_program_std_uniform_fog_density,
	{ r_program_none, "fogDensity", 1, false },
	// r_program_std_uniform_fog_color,
	{ r_program_none, "fogColor", 1, false }
};

#ifdef C_ASSERT
C_ASSERT(sizeof(program_std_uniforms) / sizeof(program_std_uniforms[0]) == r_program_std_uniform_count);
#endif

typedef struct gl_program_s {
	char friendly_name[128];
	qbool needs_params;
	program_compile_func_t compile_func;
	qbool initialised;
	gl_shader_def_t shaders[shadertype_count];

	GLuint shader_handles[shadertype_count];
	GLuint program;
	GLbitfield memory_barrier;

	char* included_definitions;
	gl_program_uniform_t uniforms[r_program_uniform_count];
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	gl_program_attribute_t attributes[r_program_attribute_count];
#endif

	unsigned int custom_options;
	qbool force_recompile;
	renderer_id renderer_id;
	unsigned int standard_options;
	unsigned int standard_option_flags;
	gl_program_uniform_t std_uniforms[r_program_std_uniform_count];
} gl_program_t;

static r_program_uniform_t program_uniforms[] = {
	// r_program_uniform_aliasmodel_drawmode
	{ r_program_aliasmodel, "mode", 1, false },
	// r_program_uniform_brushmodel_outlines
	{ r_program_brushmodel, "draw_outlines", 1, false },
	// r_program_uniform_brushmodel_sampler
	{ r_program_brushmodel, "SamplerNumber", 1, false },
	// r_program_uniform_sprite3d_alpha_test
	{ r_program_sprite3d, "alpha_test", 1, false },
	// r_program_uniform_hud_circle_matrix
	{ r_program_hud_circles, "matrix", 1, false },
	// r_program_uniform_hud_circle_color
	{ r_program_hud_circles, "color", 1, false },
	// r_program_uniform_post_process_glc_gamma
	{ r_program_post_process_glc, "gamma", 1, false },
	// r_program_uniform_post_process_glc_base,
	{ r_program_post_process_glc, "base", 1, false },
	// r_program_uniform_post_process_glc_overlay,
	{ r_program_post_process_glc, "overlay", 1, false },
	// r_program_uniform_post_process_glc_v_blend,
	{ r_program_post_process_glc, "v_blend", 1, false },
	// r_program_uniform_post_process_glc_contrast,
	{ r_program_post_process_glc, "contrast", 1, false },
	// r_program_uniform_post_process_glc_r_inv_width,
	{ r_program_post_process_glc, "r_inv_width", 1, false },
	// r_program_uniform_post_process_glc_r_inv_height,
	{ r_program_post_process_glc, "r_inv_height", 1, false },
	// r_program_uniform_sky_glc_cameraPosition,
	{ r_program_sky_glc, "cameraPosition", 1, false },
	// r_program_uniform_sky_glc_speedscale,
	{ r_program_sky_glc, "skySpeedscale", 1, false },
	// r_program_uniform_sky_glc_speedscale2,
	{ r_program_sky_glc, "skySpeedscale2", 1, false },
	// r_program_uniform_sky_glc_skyTex,
	{ r_program_sky_glc, "skyTex", 1, false },
	// r_program_uniform_sky_glc_skyWind,
	{ r_program_sky_glc, "skyWind", 1, false },
	// r_program_uniform_sky_glc_skyDomeTex,
	{ r_program_sky_glc, "skyDomeTex", 1, false },
	// r_program_uniform_sky_glc_skyDomeCloudTex,
	{ r_program_sky_glc, "skyDomeCloudTex", 1, false },
	// r_program_uniform_turb_glc_texSampler,
	{ r_program_turb_glc, "texSampler", 1, false },
	// r_program_uniform_turb_glc_time,
	{ r_program_turb_glc, "time", 1, false },
	// r_program_uniform_caustics_glc_texSampler,
	{ r_program_caustics_glc, "texSampler", 1, false },
	// r_program_uniform_caustics_glc_time,
	{ r_program_caustics_glc, "time", 1, false },
	// r_program_uniform_aliasmodel_std_glc_angleVector,
	{ r_program_aliasmodel_std_glc, "angleVector", 1, false },
	// r_program_uniform_aliasmodel_std_glc_shadelight,
	{ r_program_aliasmodel_std_glc, "shadelight", 1, false },
	// r_program_uniform_aliasmodel_std_glc_ambientlight,
	{ r_program_aliasmodel_std_glc, "ambientlight", 1, false },
	// r_program_uniform_aliasmodel_std_glc_texSampler,
	{ r_program_aliasmodel_std_glc, "texSampler", 1, false },
	// r_program_uniform_aliasmodel_std_glc_fsTextureEnabled,
	{ r_program_aliasmodel_std_glc, "fsTextureEnabled", 1, false },
	// r_program_uniform_aliasmodel_std_glc_fsMinLumaMix,
	{ r_program_aliasmodel_std_glc, "fsMinLumaMix", 1, false },
	// r_program_uniform_aliasmodel_std_glc_time,
	{ r_program_aliasmodel_std_glc, "time", 1, false },
	// r_program_uniform_aliasmodel_std_glc_fsCausticEffects
	{ r_program_aliasmodel_std_glc, "fsCausticEffects", 1, false },
	// r_program_uniform_aliasmodel_std_glc_lerpFraction
	{ r_program_aliasmodel_std_glc, "lerpFraction", 1, false },
	// r_program_uniform_aliasmodel_std_glc_causticsSampler
	{ r_program_aliasmodel_std_glc, "causticsSampler", 1, false },
	// r_program_uniform_aliasmodel_shell_glc_fsBaseColor1,
	{ r_program_aliasmodel_shell_glc, "fsBaseColor1", 1, false },
	// r_program_uniform_aliasmodel_shell_glc_fsBaseColor2,
	{ r_program_aliasmodel_shell_glc, "fsBaseColor2", 1, false },
	// r_program_uniform_aliasmodel_shell_glc_texSampler,
	{ r_program_aliasmodel_shell_glc, "texSampler", 1, false },
	// r_program_uniform_aliasmodel_shell_glc_lerpFraction,
	{ r_program_aliasmodel_shell_glc, "lerpFraction", 1, false },
	// r_program_uniform_aliasmodel_shell_glc_scroll,
	{ r_program_aliasmodel_shell_glc, "scroll", 1, false },
	// r_program_uniform_aliasmodel_shadow_glc_lerpFraction,
	{ r_program_aliasmodel_shadow_glc, "lerpFraction", 1, false },
	// r_program_uniform_aliasmodel_shadow_glc_shadevector,
	{ r_program_aliasmodel_shadow_glc, "shadevector", 1, false },
	// r_program_uniform_aliasmodel_shadow_glc_lheight,
	{ r_program_aliasmodel_shadow_glc, "lheight", 1, false },
	// r_program_uniform_world_drawflat_glc_wallcolor,
	{ r_program_world_drawflat_glc, "wallcolor", 1, false },
	// r_program_uniform_world_drawflat_glc_floorcolor,
	{ r_program_world_drawflat_glc, "floorcolor", 1, false },
	// r_program_uniform_world_drawflat_glc_skycolor,
	{ r_program_world_drawflat_glc, "skycolor", 1, false },
	// r_program_uniform_world_drawflat_glc_watercolor,
	{ r_program_world_drawflat_glc, "watercolor", 1, false },
	// r_program_uniform_world_drawflat_glc_slimecolor,
	{ r_program_world_drawflat_glc, "slimecolor", 1, false },
	// r_program_uniform_world_drawflat_glc_lavacolor,
	{ r_program_world_drawflat_glc, "lavacolor", 1, false },
	// r_program_uniform_world_drawflat_glc_telecolor,
	{ r_program_world_drawflat_glc, "telecolor", 1, false },
	// r_program_uniform_world_textured_glc_lightmapSampler,
	{ r_program_world_textured_glc, "lightmapSampler", 1, false },
	// r_program_uniform_world_textured_glc_texSampler,
	{ r_program_world_textured_glc, "texSampler", 1, false },
	// r_program_uniform_world_textured_glc_lumaSampler,
	{ r_program_world_textured_glc, "lumaSampler", 1, false },
	// r_program_uniform_world_textured_glc_causticSampler
	{ r_program_world_textured_glc, "causticsSampler", 1, false },
	// r_program_uniform_world_textured_glc_detailSampler
	{ r_program_world_textured_glc, "detailSampler", 1, false },
	// r_program_uniform_world_textured_glc_time
	{ r_program_world_textured_glc, "time", 1, false },
	// r_program_uniform_world_textured_glc_lumaScale
	{ r_program_world_textured_glc, "lumaMultiplier", 1, false },
	// r_program_uniform_world_textured_glc_fbScale
	{ r_program_world_textured_glc, "fbMultiplier", 1, false },
	// r_program_uniform_world_textured_glc_r_floorcolor
	{ r_program_world_textured_glc, "r_floorcolor", 1, false },
	// r_program_uniform_world_textured_glc_r_wallcolor
	{ r_program_world_textured_glc, "r_wallcolor", 1, false },
	// r_program_uniform_sprites_glc_materialSampler,
	{ r_program_sprites_glc, "materialSampler", 1, false },
	// r_program_uniform_sprites_glc_alphaThreshold,
	{ r_program_sprites_glc, "alphaThreshold", 1, false },
	// r_program_uniform_hud_images_glc_primarySampler,
	{ r_program_hud_images_glc, "primarySampler", 1, false },
	// r_program_uniform_hud_images_glc_secondarySampler
	{ r_program_hud_images_glc, "secondarySampler", 1, false },
	// r_program_uniform_aliasmodel_outline_glc_lerpFraction
	{ r_program_aliasmodel_outline_glc, "lerpFraction", 1, false },
	// r_program_uniform_aliasmodel_outline_glc_outlineScale
	{ r_program_aliasmodel_outline_glc, "outlineScale", 1, false },
	// r_program_uniform_brushmodel_alphatested_outlines,
	{ r_program_brushmodel_alphatested, "draw_outlines", 1, false },
	// r_program_uniform_brushmodel_alphatested_sampler,
	{ r_program_brushmodel_alphatested, "SamplerNumber", 1, false },
	// r_program_uniform_turb_glc_alpha
	{ r_program_turb_glc, "alpha", 1, false },
	// r_program_uniform_turb_glc_color
	{ r_program_turb_glc, "color", 1, false },
	// r_program_uniform_simple_color
	{ r_program_simple, "color", 1, false },
	// r_program_uniform_world_textures_glc_texture_multiplier
	{ r_program_world_textured_glc, "texture_multiplier", 1, false },
	// r_program_uniform_simple3d_color
	{ r_program_simple3d, "color", 1, false },
	// r_program_uniform_lighting_firstLightmap,
	{ r_program_lightmap_compute, "firstLightmap", 1, false },
	// r_program_uniform_turb_glc_fog_skyFogMix,
	{ r_program_sky_glc, "skyFogMix", 1, false },
	// r_program_uniform_outline_color
	{ r_program_fx_world_geometry, "outline_color", 1, false },
	// r_program_uniform_outline_depth_threshold
	{ r_program_fx_world_geometry, "outline_depth_threshold", 1, false },
	// r_program_uniform_outline_normal_threshold
	{ r_program_fx_world_geometry, "outline_normal_threshold", 1, false },
	// r_program_uniform_outline_scale
	{ r_program_fx_world_geometry, "outline_scale", 1, false },
	// r_program_uniform_aliasmodel_outline_color_model
	{ r_program_aliasmodel, "outline_color", 1, false },
	// r_program_uniform_aliasmodel_outline_color_team
	{ r_program_aliasmodel, "outline_color_team", 1, false },
	// r_program_uniform_aliasmodel_outline_color_enemy
	{ r_program_aliasmodel, "outline_color_enemy", 1, false },
	// r_program_uniform_aliasmodel_outline_use_player_color
	{ r_program_aliasmodel, "outline_use_player_color", 1, false },
	// r_program_uniform_aliasmodel_outline_scale
	{ r_program_aliasmodel, "outline_scale", 1, false },
	// r_program_uniform_brushmodel_detailtex
	{ r_program_brushmodel, "detailTex", 1, false },
	// r_program_uniform_brushmodel_causticstex
	{ r_program_brushmodel, "causticsTex", 1, false },
	// r_program_uniform_brushmodel_skytex
	{ r_program_brushmodel, "skyTex", 1, false },
	// r_program_uniform_brushmodel_skydometex
	{ r_program_brushmodel, "skyDomeTex", 1, false },
	// r_program_uniform_brushmodel_skydomecloudtex
	{ r_program_brushmodel, "skyDomeCloudTex", 1, false },
	// r_program_uniform_brushmodel_lightmaptex
	{ r_program_brushmodel, "lightmapTex", 1, false },
	// r_program_uniform_brushmodel_materialtex
	{ r_program_brushmodel, "materialTex", 1, false },
	// r_program_uniform_brushmodel_at_detailtex
	{ r_program_brushmodel_alphatested, "detailTex", 1, false },
	// r_program_uniform_brushmodel_at_causticstex
	{ r_program_brushmodel_alphatested, "causticsTex", 1, false },
	// r_program_uniform_brushmodel_at_skytex
	{ r_program_brushmodel_alphatested, "skyTex", 1, false },
	// r_program_uniform_brushmodel_at_skydometex
	{ r_program_brushmodel_alphatested, "skyDomeTex", 1, false },
	// r_program_uniform_brushmodel_at_skydomecloudtex
	{ r_program_brushmodel_alphatested, "skyDomeCloudTex", 1, false },
	// r_program_uniform_brushmodel_at_lightmaptex
	{ r_program_brushmodel_alphatested, "lightmapTex", 1, false },
	// r_program_uniform_brushmodel_at_materialtex
	{ r_program_brushmodel_alphatested, "materialTex", 1, false },
	// r_program_uniform_aliasmodel_causticstex
	{ r_program_aliasmodel, "causticsTex", 1, false },
	// r_program_uniform_aliasmodel_samplers
	{ r_program_aliasmodel, "samplers", 1, false },
	// r_program_uniform_sprites_materialtex
	{ r_program_sprite3d, "materialTex", 1, false },
	// r_program_uniform_postprocess_base
	{ r_program_post_process, "base", 1, false },
	// r_program_uniform_postprocess_overlay
	{ r_program_post_process, "overlay", 1, false },
	// r_program_uniform_fxworldgeometry_normaltex
	{ r_program_fx_world_geometry, "normal_texture", 1, false },
	// r_program_uniform_hudimage_tex
	{ r_program_hud_images, "tex", 1, false },
	// r_program_uniform_aliasmodel_instanceOffset
	{ r_program_aliasmodel, "instanceOffset", 1, false },
	// r_program_uniform_brushmodel_instanceOffset
	{ r_program_brushmodel, "instanceOffset", 1, false },
	// r_program_uniform_brushmodel_alphatested_instanceOffset
	{ r_program_brushmodel_alphatested, "instanceOffset", 1, false },
};

#ifdef C_ASSERT
C_ASSERT(sizeof(program_uniforms) / sizeof(program_uniforms[0]) == r_program_uniform_count);
#endif

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
typedef struct r_program_attribute_s {
	r_program_id program_id;
	const char* name;
} r_program_attribute_t;

static r_program_attribute_t program_attributes[] = {
	// r_program_attribute_aliasmodel_std_glc_flags
	{ r_program_aliasmodel_std_glc, "flags" },
	// r_program_attribute_aliasmodel_shell_glc_flags
	{ r_program_aliasmodel_shell_glc, "flags" },
	// r_program_attribute_aliasmodel_shadow_glc_flags
	{ r_program_aliasmodel_shadow_glc, "flags" },
	// r_program_attribute_aliasmodel_outline_glc_flags
	{ r_program_aliasmodel_outline_glc, "flags" },
	// r_program_attribute_world_drawflat_style
	{ r_program_world_drawflat_glc, "style" },
	// r_program_attribute_world_textured_style
	{ r_program_world_textured_glc, "style" },
	// r_program_attribute_world_textured_detailCoord
	{ r_program_world_textured_glc, "detailCoordInput" },
};

#ifdef C_ASSERT
C_ASSERT(sizeof(program_attributes) / sizeof(program_attributes[0]) == r_program_attribute_count);
#endif // C_ASSERT

static void R_ProgramFindAttributesForProgram(r_program_id program_id);
#else // RENDERER_OPTION_CLASSIC_OPENGL
#define R_ProgramFindAttributesForProgram(x)
#endif // !RENDERER_OPTION_CLASSIC_OPENGL

static qbool GL_CompileComputeShaderProgram(gl_program_t* prog, const char* shadertext, unsigned int length);

static gl_program_t program_data[r_program_count][MAX_SUBPROGRAMS];
static int program_currentSubProgram[r_program_count];

// Cached OpenGL state
static r_program_id currentProgram = 0;
static int currentProgramOptionSet = 0;

// Shader functions
GL_StaticFunctionDeclaration(glCreateShader, "shaderType=%u", "returned=%u", GLuint, GLenum shaderType)
GL_StaticFunctionWrapperBody(glCreateShader, GLuint, shaderType)
GL_StaticProcedureDeclaration(glShaderSource, "shader=%u, count=%d, string=%p, length=%p", GLuint shader, GLsizei count, const GLchar** string, const GLint* length)
GL_StaticProcedureDeclaration(glCompileShader, "shader=%u", GLuint shader)
GL_StaticProcedureDeclaration(glDeleteShader, "shader=%u", GLuint shader)
GL_StaticProcedureDeclaration(glGetShaderInfoLog, "shader=%u, maxLength=%d, length=%p, infoLog=%p", GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog)
GL_StaticProcedureDeclaration(glGetShaderiv, "shader=%u, pname=%u, params=%p", GLuint shader, GLenum pname, GLint* params)
GL_StaticProcedureDeclaration(glGetShaderSource, "shader=%u, bufSize=%d, length=%p, source=%p", GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source)

// Program functions
GL_StaticFunctionDeclaration(glCreateProgram, "", "result=%u", GLuint, void)
GL_StaticFunctionWrapperBodyNoArgs(glCreateProgram, GLuint)

GL_StaticProcedureDeclaration(glLinkProgram, "program=%u", GLuint program)
GL_StaticProcedureDeclaration(glDeleteProgram, "program=%u", GLuint program)
GL_StaticProcedureDeclaration(glGetProgramInfoLog, "program=%u, maxLength=%d, length=%p, infoLog=%p", GLuint program, GLsizei maxLength, GLsizei* length, GLchar* infoLog)
GL_StaticProcedureDeclaration(glUseProgram, "program=%u", GLuint program)
GL_StaticProcedureDeclaration(glAttachShader, "program=%u, shader=%u", GLuint program, GLuint shader)
GL_StaticProcedureDeclaration(glDetachShader, "program=%u, shader=%u", GLuint program, GLuint shader)
GL_StaticProcedureDeclaration(glGetProgramiv, "program=%u, pname=%u, params=%p", GLuint program, GLenum pname, GLint* params)

// Uniforms
GL_StaticFunctionDeclaration(glGetUniformLocation, "program=%u, name=%s", "result=%d", GLint, GLuint program, const GLchar* name)
GL_StaticFunctionWrapperBody(glGetUniformLocation, GLint, program, name)

GL_StaticProcedureDeclaration(glUniform1i, "location=%d, v0=%d", GLint location, GLint v0)
GL_StaticProcedureDeclaration(glUniform1f, "location=%d, value=%f", GLint location, GLfloat value)
GL_StaticProcedureDeclaration(glUniform2fv, "location=%d, count=%d, value=%p", GLint location, GLsizei count, const GLfloat* value)
GL_StaticProcedureDeclaration(glUniform3fv, "location=%d, count=%d, value=%p", GLint location, GLsizei count, const GLfloat* value)
GL_StaticProcedureDeclaration(glUniform4fv, "location=%d, count=%d, value=%p", GLint location, GLsizei count, const GLfloat* value)
GL_StaticProcedureDeclaration(glUniformMatrix4fv, "location=%d, count=%d, transpose=%d, value=%p", GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
GL_StaticProcedureDeclaration(glProgramUniform1i, "program=%u, location=%u, v0=%d", GLuint program, GLuint location, GLint v0)
GL_StaticProcedureDeclaration(glProgramUniform1f, "program=%u, location=%u, value=%f", GLuint program, GLuint location, GLfloat value)
GL_StaticProcedureDeclaration(glProgramUniform2fv, "program=%u, location=%u, count=%d, value=%p", GLuint program, GLuint location, GLsizei count, const GLfloat* value)
GL_StaticProcedureDeclaration(glProgramUniform3fv, "program=%u, location=%u, count=%d, value=%p", GLuint program, GLuint location, GLsizei count, const GLfloat* value)
GL_StaticProcedureDeclaration(glProgramUniform4fv, "program=%u, location=%u, count=%d, value=%p", GLuint program, GLuint location, GLsizei count, const GLfloat* value)
GL_StaticProcedureDeclaration(glProgramUniformMatrix4fv, "program=%u, location=%d, count=%d, transpose=%d, value=%p", GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
// Attributes
GL_StaticFunctionDeclaration(glGetAttribLocation, "program=%u, name=%s", "result=%d", GLint, GLuint program, const GLchar* name)
GL_StaticFunctionWrapperBody(glGetAttribLocation, GLint, program, name)
#endif

// Compute shaders
GL_StaticProcedureDeclaration(glDispatchCompute, "num_groups_x=%u, num_groups_y=%u, num_groups_z=%u", GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
GL_StaticProcedureDeclaration(glMemoryBarrier, "barriers=%u", GLbitfield barriers)

#define MAX_SHADER_COMPONENTS 8
#define EZQUAKE_DEFINITIONS_STRING "#ezquake-definitions"

static char macro_definitions[4096];
static char core_definitions[2048];
static char standard_definitions[2048];

static unsigned int R_ProgramStandardOptions(unsigned int option_flags)
{
	unsigned int flags =
		(r_refdef2.fog_calculation == fogcalc_linear ? STDOPTIONS_FOG_LINEAR : 0) |
		(r_refdef2.fog_calculation == fogcalc_exp    ? STDOPTIONS_FOG_EXP    : 0) |
		(r_refdef2.fog_calculation == fogcalc_exp2   ? STDOPTIONS_FOG_EXP2   : 0);

	return flags & option_flags;
}

static void R_ProgramBuildStandardDefines(unsigned int option_flags)
{
	unsigned int options = R_ProgramStandardOptions(option_flags);

	standard_definitions[0] = '\0';
	if (options & STDOPTIONS_FOG) {
		strlcat(standard_definitions, "#define DRAW_FOG\n", sizeof(standard_definitions));
		if (options & STDOPTIONS_FOG_LINEAR) {
			strlcat(standard_definitions, "#define FOG_LINEAR\n", sizeof(standard_definitions));
		}
		else if (options & STDOPTIONS_FOG_EXP) {
			strlcat(standard_definitions, "#define FOG_EXP\n", sizeof(standard_definitions));
		}
		else if (options & STDOPTIONS_FOG_EXP2) {
			strlcat(standard_definitions, "#define FOG_EXP2\n", sizeof(standard_definitions));
		}
	}
}

// GLM Utility functions
static void GL_ConPrintShaderLog(GLuint shader)
{
	GLint log_length;
	GLint src_length;
	char* buffer;

	GL_Procedure(glGetShaderiv, shader, GL_INFO_LOG_LENGTH, &log_length);
	GL_Procedure(glGetShaderiv, shader, GL_SHADER_SOURCE_LENGTH, &src_length);
	if (log_length || (src_length > 0 && developer.integer == 3)) {
		GLsizei written;

		buffer = Q_malloc(max(log_length, src_length) + 1);
		GL_Procedure(glGetShaderInfoLog, shader, log_length, &written, buffer);
		Con_Printf("-- Version: %s\n", glConfig.version_string);
		Con_Printf("--    GLSL: %s\n", glConfig.glsl_version);
		Con_Printf("%s\n", buffer);

		if (developer.integer == 2 || developer.integer == 3) {
			GL_Procedure(glGetShaderSource, shader, src_length, &written, buffer);
			Con_Printf("%s\n", buffer);
		}

		Q_free(buffer);
	}
}

static void GL_ConPrintProgramLog(GLuint program)
{
	GLint log_length;
	char* buffer;

	GL_Procedure(glGetProgramiv, program, GL_INFO_LOG_LENGTH, &log_length);
	if (log_length) {
		GLsizei written;

		buffer = Q_malloc(log_length);
		GL_Procedure(glGetProgramInfoLog, program, log_length, &written, buffer);
		Con_Printf(buffer);
		Q_free(buffer);
	}
}

// Uniform utility functions
static gl_program_uniform_t* GL_ProgramUniformFind(r_program_uniform_id uniform_id)
{
	r_program_uniform_t* uniform = &program_uniforms[uniform_id];
	r_program_id program_id = uniform->program_id;
	gl_program_t* program = R_CurrentSubProgram(program_id);
	gl_program_uniform_t* program_uniform = &program->uniforms[uniform_id];

	if (program->program && !program_uniform->found) {
		program_uniform->location = GL_Function(glGetUniformLocation, program->program, uniform->name);
		program_uniform->found = true;
	}

	return program_uniform;
}

static void R_ProgramFindUniformsForProgram(r_program_id program_id)
{
	r_program_uniform_id u;

	for (u = 0; u < r_program_uniform_count; ++u) {
		if (program_uniforms[u].program_id == program_id) {
			GL_ProgramUniformFind(u);
		}
	}
}

static qbool GL_CompileShader(GLsizei shaderComponents, const char* shaderText[], GLint shaderTextLength[], GLenum shaderType, GLuint* shaderId)
{
	GLuint shader;
	GLint result;

	*shaderId = 0;
	shader = GL_Function(glCreateShader, shaderType);
	if (shader) {
		GL_Procedure(glShaderSource, shader, shaderComponents, shaderText, shaderTextLength);
		GL_Procedure(glCompileShader, shader);
		GL_Procedure(glGetShaderiv, shader, GL_COMPILE_STATUS, &result);
		if (result) {
			*shaderId = shader;
			if (developer.integer == 3) {
				Con_Printf("Shader->Compile(%X) succeeded\n", shaderType);
				GL_ConPrintShaderLog(shader);
			}
			return true;
		}

		Con_Printf("Shader->Compile(%X) failed\n", shaderType);
		GL_ConPrintShaderLog(shader);
		GL_Procedure(glDeleteShader, shader);
	}
	else {
		Con_Printf("glCreateShader failed\n");
	}
	return false;
}

// Couldn't find standard library call to do this (!?)
// Search for <search_string> in non-nul-terminated <source>
static const char* safe_strstr(const char* source, size_t max_length, const char* search_string)
{
	size_t search_length = strlen(search_string);
	const char* position;

	while (true) {
		position = (const char*)memchr(source, search_string[0], max_length);
		if (!position) {
			break;
		}

		// Move along
		if (max_length < (position - source)) {
			break;
		}
		max_length -= (position - source);

		if (max_length < search_length) {
			break;
		}
		if (!memcmp(position, search_string, search_length)) {
			return position;
		}

		// Try again
		source = position + 1;
		max_length -= 1;
	}

	return NULL;
}

#if 0
static void GL_DebugPrintShaderText(GLuint shader)
{
	int length = 0;
	char* src;

	GL_Procedure(glGetShaderiv, shader, GL_SHADER_SOURCE_LENGTH, &length);
	src = Q_malloc(length + 1);
	GL_Procedure(glGetShaderSource, shader, length, NULL, src);

	DebugOutput(src);
	Q_free(src);
}
#endif

static int GL_InsertDefinitions(
	const char* strings[],
	GLint lengths[],
	const char* definitions,
	GLenum shader_type
)
{
	static unsigned char *glsl_constants_glsl = (unsigned char *)"", *glsl_common_glsl = (unsigned char *)"";
	unsigned int glsl_constants_glsl_len = 0, glsl_common_glsl_len = 0;
	const char* break_point;
	int i;

	if (!strings[0] || !strings[0][0]) {
		return 0;
	}

#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		extern unsigned char constants_glsl[], common_glsl[];
		extern unsigned int constants_glsl_len, common_glsl_len;

		glsl_constants_glsl = constants_glsl;
		glsl_common_glsl = common_glsl;
		glsl_constants_glsl_len = constants_glsl_len;
		glsl_common_glsl_len = common_glsl_len;
	}
#endif

	break_point = safe_strstr(strings[0], lengths[0], EZQUAKE_DEFINITIONS_STRING);
	
	if (break_point) {
		int position = break_point - strings[0];

		// Order: version, constants, macros, common, standard_defs, included_defs, core_defs, shader
		lengths[7] = lengths[0] - position - strlen(EZQUAKE_DEFINITIONS_STRING);
		lengths[6] = strlen(core_definitions);
		lengths[5] = definitions ? strlen(definitions) : 0;
		lengths[4] = strlen(standard_definitions);
		lengths[3] = glsl_common_glsl_len;
		lengths[2] = strlen(macro_definitions);
		lengths[1] = glsl_constants_glsl_len;
		lengths[0] = position;
		strings[7] = break_point + strlen(EZQUAKE_DEFINITIONS_STRING);
		strings[6] = core_definitions;
		strings[5] = definitions ? definitions : "";
		strings[4] = standard_definitions;
		strings[3] = (const char*)glsl_common_glsl;
		strings[2] = macro_definitions;
		strings[1] = (const char*)glsl_constants_glsl;

		// Inject the appropriate GLSL version string (with shader type for GLC core profile)
#ifdef RENDERER_OPTION_MODERN_OPENGL
		if (R_UseModernOpenGL()) {
			strings[0] = GL_VersionAtLeast(4, 3) ? "#version 430\n\n" : "#version 410\n\n";
		}
		else
#endif
		{
			if (glConfig.coreProfile) {
				if (shader_type == GL_VERTEX_SHADER) {
					strings[0] = "#version 330\n#define EZ_VERTEX_SHADER\n\n";
				}
				else {
					strings[0] = "#version 330\n#define EZ_FRAGMENT_SHADER\n\n";
				}
			}
			else {
				strings[0] = "#version 120\n\n";
			}
		}
		lengths[0] = strlen(strings[0]);

		// Some drivers interpret length 0 as nul terminated
		// spec is < 0 (https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glShaderSource.xhtml)
		for (i = 0; i < MAX_SHADER_COMPONENTS; ++i) {
			if (lengths[i] == 0) {
				strings[i] = "";
			}
		}

		return 8;
	}

	return 1;
}

static void GL_DumpShader(const char *name, const char *suffix, int components, const char* strings[], GLint lengths[])
{
	char filename[MAX_OSPATH];
	char buf[256];
	int i;
	FILE *fd;

	if (strings[0] == NULL) {
		return;
	}

	snprintf(filename, sizeof(filename), "%s/qw/shaders", com_basedir);
	Sys_mkdir(filename);
	snprintf(filename, sizeof(filename), "%s/qw/shaders/%s.%s", com_basedir, name, suffix);

	fd = fopen(filename, "wt");
	if (!fd) {
		Sys_Error("Could not open %s for writing\n", filename);
	}

	for (i = 0; i < components; i++) {
		if (!lengths[i]) {
			continue;
		}
		// Original source up to #ezquake-definitions, likely just "#version ..."
		if (i == 0) {
			if (sizeof(buf) <= lengths[0]) {
				Sys_Error("Unexpected shader preamble size (%d, max %d)\n", lengths[0], sizeof(buf));
			}
			strlcpy(buf, strings[0], lengths[0]);
			fprintf(fd, "%s\n", buf);
		}
		else {
			fprintf(fd, "%s\n", strings[i]);
		}
	}

	fclose(fd);
}

static qbool GL_CompileProgram(
	gl_program_t* program
)
{
	GLuint shaders[shadertype_count] = { 0 };
	GLuint program_handle = 0;
	GLint result = 0;
	int i;

	GLsizei vertex_components = 1;
	const char* vertex_shader_text[MAX_SHADER_COMPONENTS] = { program->shaders[shadertype_vertex].text, "", "", "", "", "", "" };
	GLint vertex_shader_text_length[MAX_SHADER_COMPONENTS] = { program->shaders[shadertype_vertex].length, 0, 0, 0, 0, 0, 0 };
	GLsizei geometry_components = 1;
	const char* geometry_shader_text[MAX_SHADER_COMPONENTS] = { program->shaders[shadertype_geometry].text, "", "", "", "", "", "" };
	GLint geometry_shader_text_length[MAX_SHADER_COMPONENTS] = { program->shaders[shadertype_geometry].length, 0, 0, 0, 0, 0, 0 };
	GLsizei fragment_components = 1;
	const char* fragment_shader_text[MAX_SHADER_COMPONENTS] = { program->shaders[shadertype_fragment].text, "", "", "", "", "", "" };
	GLint fragment_shader_text_length[MAX_SHADER_COMPONENTS] = { program->shaders[shadertype_fragment].length, 0, 0, 0, 0, 0, 0 };
	GLsizei compute_components = 1;
	const char* compute_shader_text[MAX_SHADER_COMPONENTS] = { program->shaders[shadertype_compute].text, "", "", "", "", "", "" };
	GLint compute_shader_text_length[MAX_SHADER_COMPONENTS] = { program->shaders[shadertype_compute].length, 0, 0, 0, 0, 0, 0 };

	DebugOutput(va("Compiling: %s\n", program->friendly_name));

	R_ProgramBuildStandardDefines(program->standard_option_flags);

	vertex_components = GL_InsertDefinitions(vertex_shader_text, vertex_shader_text_length, program->included_definitions, GL_VERTEX_SHADER);
	geometry_components = GL_InsertDefinitions(geometry_shader_text, geometry_shader_text_length, program->included_definitions, GL_GEOMETRY_SHADER);
	fragment_components = GL_InsertDefinitions(fragment_shader_text, fragment_shader_text_length, program->included_definitions, GL_FRAGMENT_SHADER);
	compute_components = GL_InsertDefinitions(compute_shader_text, compute_shader_text_length, program->included_definitions, GL_COMPUTE_SHADER);

	if (COM_CheckParm(cmdline_param_client_video_r_dump_shaders)) {
		GL_DumpShader(program->friendly_name, "vert", vertex_components, vertex_shader_text, vertex_shader_text_length);
		GL_DumpShader(program->friendly_name, "frag", fragment_components, fragment_shader_text, fragment_shader_text_length);
		GL_DumpShader(program->friendly_name, "geom", geometry_components, geometry_shader_text, geometry_shader_text_length);
		GL_DumpShader(program->friendly_name, "comp", compute_components, compute_shader_text, compute_shader_text_length);
	}

	if (program->shaders[shadertype_compute].text) {
		return GL_CompileComputeShaderProgram(program, compute_shader_text[0], compute_shader_text_length[0]);
	}

	if (GL_CompileShader(vertex_components, vertex_shader_text, vertex_shader_text_length, GL_VERTEX_SHADER, &shaders[shadertype_vertex])) {
		if (geometry_shader_text[0] == NULL || GL_CompileShader(geometry_components, geometry_shader_text, geometry_shader_text_length, GL_GEOMETRY_SHADER, &shaders[shadertype_geometry])) {
			if (GL_CompileShader(fragment_components, fragment_shader_text, fragment_shader_text_length, GL_FRAGMENT_SHADER, &shaders[shadertype_fragment])) {
				Con_DPrintf("Shader compilation completed successfully\n");

				program_handle = GL_FunctionNoArgs(glCreateProgram);
				if (program_handle) {
					GL_Procedure(glAttachShader, program_handle, shaders[shadertype_fragment]);
					GL_Procedure(glAttachShader, program_handle, shaders[shadertype_vertex]);
					if (shaders[shadertype_geometry]) {
						GL_Procedure(glAttachShader, program_handle, shaders[shadertype_geometry]);
					}
					GL_Procedure(glLinkProgram, program_handle);
					GL_Procedure(glGetProgramiv, program_handle, GL_LINK_STATUS, &result);

					if (result) {
						Con_DPrintf("ShaderProgram.Link() was successful\n");
						memcpy(program->shader_handles, shaders, sizeof(shaders));
						program->program = program_handle;
						memset(program->uniforms, 0, sizeof(program->uniforms));
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
						memset(program->attributes, 0, sizeof(program->attributes));
#endif
						program->force_recompile = false;
						program->standard_options = R_ProgramStandardOptions(program->standard_option_flags);

						GL_TraceObjectLabelSet(GL_PROGRAM, program->program, -1, program->friendly_name);
						return true;
					}
					else {
						Con_Printf("ShaderProgram.Link(%s) failed\n", program->friendly_name);
						GL_ConPrintProgramLog(program_handle);
					}
				}
			}
			else {
				Con_Printf("FragmentShader.Compile(%s) failed\n", program->friendly_name);
			}
		}
		else {
			Con_Printf("GeometryShader.Compile(%s) failed\n", program->friendly_name);
		}
	}
	else {
		Con_Printf("VertexShader.Compile(%s) failed\n", program->friendly_name);
	}

	if (program_handle) {
		GL_Procedure(glDeleteProgram, program_handle);
	}
	for (i = 0; i < sizeof(shaders) / sizeof(shaders[0]); ++i) {
		if (shaders[i]) {
			GL_Procedure(glDeleteShader, shaders[i]);
		}
	}
	return false;
}

static void GL_CleanupShader(GLuint program, GLuint shader)
{
	if (shader) {
		if (program) {
			GL_Procedure(glDetachShader, program, shader);
		}
		GL_Procedure(glDeleteShader, shader);
	}
}

// Called during vid_shutdown
void GL_ProgramsShutdown(qbool restarting)
{
	r_program_id p;
	gl_program_t* prog;
	int sub_program;

	R_ProgramUse(r_program_none);

	// Detach & delete shaders
	for (p = r_program_none; p < r_program_count; ++p) {
		for (sub_program = 0; sub_program < MAX_SUBPROGRAMS; ++sub_program) {
			int i;

			prog = R_SpecificSubProgram(p, sub_program);
			for (i = 0; i < sizeof(prog->shaders) / sizeof(prog->shaders[0]); ++i) {
				GL_CleanupShader(prog->program, prog->shader_handles[i]);
				prog->shader_handles[i] = 0;
			}
		}
	}

	for (p = r_program_none; p < r_program_count; ++p) {
		for (sub_program = 0; sub_program < MAX_SUBPROGRAMS; ++sub_program) {
			prog = R_SpecificSubProgram(p, sub_program);
			if (prog->program) {
				GL_Procedure(glDeleteProgram, prog->program);
				prog->program = 0;
			}

			if (!restarting) {
				// Keep definitions if we're about to recompile after restart
				Q_free(prog->included_definitions);
			}

			memset(prog->uniforms, 0, sizeof(prog->uniforms));
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
			memset(prog->attributes, 0, sizeof(prog->attributes));
#endif
		}
	}

	memset(program_currentSubProgram, 0, sizeof(program_currentSubProgram));
}

static qbool GL_AppropriateRenderer(renderer_id renderer)
{
	if (R_UseImmediateOpenGL() && renderer == renderer_classic) {
		return true;
	}
	if (R_UseModernOpenGL() && renderer == renderer_modern) {
		return true;
	}
	return false;
}

// Called during vid_restart, as starting up again
void GL_ProgramsInitialise(void)
{
	r_program_id p;
	int i;

	if (!(glConfig.supported_features & R_SUPPORT_RENDERING_SHADERS)) {
		return;
	}

	GL_BuildCoreDefinitions();

	for (i = 0; i < MAX_SUBPROGRAMS; ++i) {
		gl_program_t* prog = R_SpecificSubProgram(r_program_none, i);

		strlcpy(prog->friendly_name, "(none)", sizeof(prog->friendly_name));
	}

	for (p = r_program_none; p < r_program_count; ++p) {
		for (i = 0; i < MAX_SUBPROGRAMS; ++i) {
			gl_program_t* prog = R_SpecificSubProgram(p, i);

			if (!GL_AppropriateRenderer(prog->renderer_id)) {
				continue;
			}

			if (!prog->program && !prog->needs_params && prog->initialised) {
				gl_shader_def_t * compute = &prog->shaders[shadertype_compute];
				if (compute->length) {
					GL_CompileComputeShaderProgram(prog, compute->text, compute->length);
				}
				else {
					GL_CompileProgram(prog);
				}
				R_ProgramFindUniformsForProgram(p);
				R_ProgramFindAttributesForProgram(p);
			}
		}
	}

	memset(program_currentSubProgram, 0, sizeof(program_currentSubProgram));
}

qbool R_ProgramRecompileNeeded(r_program_id program_id, unsigned int options)
{
	//
	const gl_program_t* program = R_CurrentSubProgram(program_id);
	unsigned int standard_options = R_ProgramStandardOptions(program->standard_option_flags);

	return (!program->program) || program->force_recompile || program->custom_options != options || program->standard_options != standard_options;
}

GLuint R_ProgramId(r_program_id program_id)
{
	return R_CurrentSubProgram(program_id)->program;
}

void GL_CvarForceRecompile(cvar_t* cvar)
{
	r_program_id p;
	int i;

	for (p = r_program_none; p < r_program_count; ++p) {
		for (i = 0; i < MAX_SUBPROGRAMS; ++i) {
			R_SpecificSubProgram(p, i)->force_recompile = true;
		}
	}

	GL_BuildCoreDefinitions();
}

static qbool GL_CompileComputeShaderProgram(gl_program_t* program, const char* shadertext, unsigned int length)
{
	const char* shader_text[MAX_SHADER_COMPONENTS] = { shadertext, "", "", "", "", "", "" };
	GLint shader_text_length[MAX_SHADER_COMPONENTS] = { length, 0, 0, 0, 0, 0, 0 };
	int components;
	GLuint shader;
	int standard_options = R_ProgramStandardOptions(program->standard_option_flags);

	if (!GL_Supported(R_SUPPORT_COMPUTE_SHADERS)) {
		return false;
	}

	program->program = 0;

	components = GL_InsertDefinitions(shader_text, shader_text_length, "", GL_COMPUTE_SHADER);
	if (GL_CompileShader(components, shader_text, shader_text_length, GL_COMPUTE_SHADER, &shader)) {
		GLuint shader_program = GL_FunctionNoArgs(glCreateProgram);
		if (shader_program) {
			GLint result;

			GL_Procedure(glAttachShader, shader_program, shader);
			GL_Procedure(glLinkProgram, shader_program);
			GL_Procedure(glGetProgramiv, shader_program, GL_LINK_STATUS, &result);

			if (result) {
				Con_DPrintf("ShaderProgram.Link() was successful\n");
				program->shader_handles[shadertype_compute] = shader;
				program->program = shader_program;
				memset(program->uniforms, 0, sizeof(program->uniforms));
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
				memset(program->attributes, 0, sizeof(program->attributes));
#endif
				program->force_recompile = false;
				program->standard_options = standard_options;

				GL_TraceObjectLabelSet(GL_PROGRAM, program->program, -1, program->friendly_name);
				return true;
			}
			else {
				Con_Printf("ShaderProgram.Link() failed\n");
				GL_ConPrintProgramLog(shader_program);
			}
		}
	}

	return false;
}

void GL_LoadProgramFunctions(void)
{
	qbool rendering_shaders_support = true;

	glConfig.supported_features &= ~(R_SUPPORT_RENDERING_SHADERS | R_SUPPORT_COMPUTE_SHADERS);
	{
		// These are all core in OpenGL 2.0
		GL_LoadMandatoryFunctionExtension(glCreateShader, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glShaderSource, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glGetShaderSource, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glCompileShader, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glDeleteShader, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glGetShaderInfoLog, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glGetShaderiv, rendering_shaders_support);

		GL_LoadMandatoryFunctionExtension(glCreateProgram, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glLinkProgram, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glDeleteProgram, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glUseProgram, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glAttachShader, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glDetachShader, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glGetProgramInfoLog, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glGetProgramiv, rendering_shaders_support);

		GL_LoadMandatoryFunctionExtension(glGetUniformLocation, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glUniform1i, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glUniform1f, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glUniform2fv, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glUniform3fv, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glUniform4fv, rendering_shaders_support);
		GL_LoadMandatoryFunctionExtension(glUniformMatrix4fv, rendering_shaders_support);

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
		GL_LoadMandatoryFunctionExtension(glGetAttribLocation, rendering_shaders_support);
#endif

		glConfig.supported_features |= (rendering_shaders_support ? R_SUPPORT_RENDERING_SHADERS : 0);
	}

	if (GL_UseDirectStateAccess() || GL_VersionAtLeast(4, 1)) {
		GL_LoadOptionalFunction(glProgramUniform1i);
		GL_LoadOptionalFunction(glProgramUniform1f);
		GL_LoadOptionalFunction(glProgramUniform2fv);
		GL_LoadOptionalFunction(glProgramUniform3fv);
		GL_LoadOptionalFunction(glProgramUniform4fv);
		GL_LoadOptionalFunction(glProgramUniformMatrix4fv);
	} else {
		GL_InvalidateFunction(glProgramUniform1i);
		GL_InvalidateFunction(glProgramUniform1f);
		GL_InvalidateFunction(glProgramUniform2fv);
		GL_InvalidateFunction(glProgramUniform3fv);
		GL_InvalidateFunction(glProgramUniform4fv);
		GL_InvalidateFunction(glProgramUniformMatrix4fv);
	}

	if (GL_VersionAtLeast(4, 3) || (GL_VersionAtLeast(4, 2) && SDL_GL_ExtensionSupported("GL_ARB_compute_shader") && SDL_GL_ExtensionSupported("GL_ARB_shader_image_load_store"))) {
		qbool compute_shaders_support = true;

		GL_LoadMandatoryFunctionExtension(glDispatchCompute, compute_shaders_support);
		GL_LoadMandatoryFunctionExtension(glMemoryBarrier, compute_shaders_support);

		glConfig.supported_features |= (compute_shaders_support ? R_SUPPORT_COMPUTE_SHADERS : 0);
	} else {
		GL_InvalidateFunction(glDispatchCompute);
		GL_InvalidateFunction(glMemoryBarrier);
	}
}

void R_ProgramUse(r_program_id program_id)
{
	if (program_id != currentProgram || currentProgramOptionSet != program_currentSubProgram[program_id]) {
		if (GL_Available(glUseProgram)) {
			R_TraceLogAPICall("R_ProgramUse(%s[%d])", R_CurrentSubProgram(program_id)->friendly_name, program_currentSubProgram[program_id]);
			GL_Procedure(glUseProgram, R_CurrentSubProgram(program_id)->program);
		}

		currentProgram = program_id;
		currentProgramOptionSet = program_currentSubProgram[program_id];
	}

#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL() && program_id != r_program_none) {
		GLM_UploadFrameConstants();
	}
#endif
}

r_program_id R_ProgramInUse(void)
{
	return currentProgram;
}

void R_ProgramInitialiseState(void)
{
	currentProgram = 0;

	GL_BuildCoreDefinitions();
}

// Compute shaders
static void GL_ProgramComputeDispatch(r_program_id program_id, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
	R_ProgramUse(program_id);
	GL_Procedure(glDispatchCompute, num_groups_x, num_groups_y, num_groups_z);
}

static void GL_ProgramMemoryBarrier(r_program_id program_id)
{
	if (R_CurrentSubProgram(program_id)->memory_barrier) {
		GL_Procedure(glMemoryBarrier, R_CurrentSubProgram(program_id)->memory_barrier);
	}
}

void R_ProgramMemoryBarrier(r_program_id program_id)
{
	GL_ProgramMemoryBarrier(program_id);
}

void R_ProgramComputeDispatch(r_program_id program_id, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
	GL_ProgramComputeDispatch(program_id, num_groups_x, num_groups_y, num_groups_z);
}

void R_ProgramComputeSetMemoryBarrierFlag(r_program_id program_id, r_program_memory_barrier_id barrier_id)
{
	R_CurrentSubProgram(program_id)->memory_barrier |= glBarrierFlags[barrier_id];
}

// Wrappers
int R_ProgramCustomOptions(r_program_id program_id)
{
	return R_CurrentSubProgram(program_id)->custom_options;
}

void R_ProgramSetCustomOptions(r_program_id program_id, int options)
{
	R_CurrentSubProgram(program_id)->custom_options = options;
}

qbool R_ProgramReady(r_program_id program_id)
{
	return R_CurrentSubProgram(program_id)->program != 0;
}

void R_ProgramUniform1i(r_program_uniform_id uniform_id, int value)
{
	r_program_uniform_t* base_uniform = &program_uniforms[uniform_id];
	gl_program_uniform_t* program_uniform = GL_ProgramUniformFind(uniform_id);
	gl_program_t* prog = R_CurrentSubProgram(base_uniform->program_id);

	if (program_uniform->location >= 0) {
		R_TraceLogAPICall("%s(%s/%s,%d)", __func__, prog->friendly_name, base_uniform->name, value);
		if (GL_Available(glProgramUniform1i)) {
			GL_Procedure(glProgramUniform1i, prog->program, program_uniform->location, value);
		}
		else {
			R_ProgramUse(base_uniform->program_id);
			GL_Procedure(glUniform1i, program_uniform->location, value);
		}
		program_uniform->int_value = value;
	}
}

void R_ProgramUniform1iArrayBase(r_program_uniform_id uniform_id, int count, int base_value)
{
	r_program_uniform_t* base_uniform = &program_uniforms[uniform_id];
	gl_program_uniform_t* program_uniform = GL_ProgramUniformFind(uniform_id);
	int j;

	if (program_uniform->location >= 0) {
		R_ProgramUse(base_uniform->program_id);
		for (j = 0; j < count; ++j) {
			GL_Procedure(glUniform1i, program_uniform->location + j, base_value + j);
		}
		program_uniform->int_value = base_value;
	}
}

void R_ProgramUniform1f(r_program_uniform_id uniform_id, float value)
{
	r_program_uniform_t* base_uniform = &program_uniforms[uniform_id];
	gl_program_uniform_t* program_uniform = GL_ProgramUniformFind(uniform_id);
	gl_program_t* prog = R_CurrentSubProgram(base_uniform->program_id);

	if (program_uniform->location >= 0) {
		R_TraceLogAPICall("%s(%s/%s,%f)", __func__, prog->friendly_name, base_uniform->name, value);
		if (GL_Available(glProgramUniform1f)) {
			GL_Procedure(glProgramUniform1f, prog->program, program_uniform->location, value);
		}
		else {
			R_ProgramUse(base_uniform->program_id);
			GL_Procedure(glUniform1f, program_uniform->location, value);
		}
		program_uniform->int_value = value;
	}
}

void R_ProgramUniform2fv(r_program_uniform_id uniform_id, const float* values)
{
	r_program_uniform_t* base_uniform = &program_uniforms[uniform_id];
	gl_program_uniform_t* program_uniform = GL_ProgramUniformFind(uniform_id);
	gl_program_t* prog = R_CurrentSubProgram(base_uniform->program_id);

	if (program_uniform->location >= 0) {
		R_TraceLogAPICall("%s(%s/%s)", __func__, prog->friendly_name, base_uniform->name);
		if (GL_Available(glProgramUniform2fv)) {
			GL_Procedure(glProgramUniform2fv, prog->program, program_uniform->location, base_uniform->count, values);
		}
		else {
			R_ProgramUse(base_uniform->program_id);
			GL_Procedure(glUniform2fv, program_uniform->location, base_uniform->count, values);
		}
	}
}

void R_ProgramUniform3f(r_program_uniform_id uniform_id, float x, float y, float z)
{
	float vec[3] = { x, y, z };

	R_ProgramUniform3fv(uniform_id, vec);
}

static void R_ProgramStandardUniform3fv(r_program_id program_id, r_program_std_uniform_id id, const float* values)
{
	gl_program_t* program = R_CurrentSubProgram(program_id);
	r_program_uniform_t* std_uniform = &program_std_uniforms[id];
	gl_program_uniform_t* program_uniform = &program->std_uniforms[id];

	if (program->program && !program_uniform->found) {
		program_uniform->location = GL_Function(glGetUniformLocation, program->program, std_uniform->name);
		program_uniform->found = true;
	}

	if (program_uniform->location >= 0) {
		R_TraceLogAPICall("%s(%s/%s)", __func__, program->friendly_name, std_uniform->name);
		if (GL_Available(glProgramUniform3fv)) {
			GL_Procedure(glProgramUniform3fv, program->program, program_uniform->location, std_uniform->count, values);
		}
		else {
			R_ProgramUse(program_id);
			GL_Procedure(glUniform3fv, program_uniform->location, std_uniform->count, values);
		}
	}
}

static void R_ProgramStandardUniform1f(r_program_id program_id, r_program_std_uniform_id id, float value)
{
	gl_program_t* program = R_CurrentSubProgram(program_id);
	r_program_uniform_t* std_uniform = &program_std_uniforms[id];
	gl_program_uniform_t* program_uniform = &program->std_uniforms[id];

	if (program->program && !program_uniform->found) {
		program_uniform->location = GL_Function(glGetUniformLocation, program->program, std_uniform->name);
		program_uniform->found = true;
	}

	if (program_uniform->location >= 0) {
		R_TraceLogAPICall("%s(%s/%s)", __func__, program->friendly_name, std_uniform->name);
		if (GL_Available(glProgramUniform1f)) {
			GL_Procedure(glProgramUniform1f, program->program, program_uniform->location, value);
		}
		else {
			R_ProgramUse(program_id);
			GL_Procedure(glUniform1f, program_uniform->location, value);
		}
	}
}

void R_ProgramUniform3fv(r_program_uniform_id uniform_id, const float* values)
{
	r_program_uniform_t* base_uniform = &program_uniforms[uniform_id];
	gl_program_uniform_t* program_uniform = GL_ProgramUniformFind(uniform_id);
	gl_program_t* prog = R_CurrentSubProgram(base_uniform->program_id);

	if (program_uniform->location >= 0) {
		R_TraceLogAPICall("%s(%s/%s)", __func__, prog->friendly_name, base_uniform->name);
		if (GL_Available(glProgramUniform3fv)) {
			GL_Procedure(glProgramUniform3fv, prog->program, program_uniform->location, base_uniform->count, values);
		}
		else {
			R_ProgramUse(base_uniform->program_id);
			GL_Procedure(glUniform3fv, program_uniform->location, base_uniform->count, values);
		}
	}
}

void R_ProgramUniform3fNormalize(r_program_uniform_id uniform_id, const byte* values)
{
	float float_values[3];

	float_values[0] = values[0] * 1.0f / 255;
	float_values[1] = values[1] * 1.0f / 255;
	float_values[2] = values[2] * 1.0f / 255;

	R_ProgramUniform3fv(uniform_id, float_values);
}

void R_ProgramUniform4fv(r_program_uniform_id uniform_id, const float* values)
{
	r_program_uniform_t* base_uniform = &program_uniforms[uniform_id];
	gl_program_uniform_t* program_uniform = GL_ProgramUniformFind(uniform_id);
	gl_program_t* prog = R_CurrentSubProgram(base_uniform->program_id);

	if (program_uniform->location >= 0) {
		R_TraceLogAPICall("%s(%s/%s)", __func__, prog->friendly_name, base_uniform->name);
		if (GL_Available(glProgramUniform4fv)) {
			GL_Procedure(glProgramUniform4fv, prog->program, program_uniform->location, base_uniform->count, values);
		}
		else {
			R_ProgramUse(base_uniform->program_id);
			GL_Procedure(glUniform4fv, program_uniform->location, base_uniform->count, values);
		}
	}
}

void R_ProgramUniformMatrix4fv(r_program_uniform_id uniform_id, const float* values)
{
	r_program_uniform_t* base_uniform = &program_uniforms[uniform_id];
	gl_program_uniform_t* program_uniform = GL_ProgramUniformFind(uniform_id);
	gl_program_t* prog = R_CurrentSubProgram(base_uniform->program_id);

	if (program_uniform->location >= 0) {
		R_TraceLogAPICall("%s(%s/%s)", __func__, prog->friendly_name, base_uniform->name);
		if (GL_Available(glProgramUniformMatrix4fv)) {
			GL_Procedure(glProgramUniformMatrix4fv, prog->program, program_uniform->location, base_uniform->count, base_uniform->transpose, values);
		}
		else {
			R_ProgramUse(base_uniform->program_id);
			GL_Procedure(glUniformMatrix4fv, program_uniform->location, base_uniform->count, base_uniform->transpose, values);
		}
	}
}

int R_ProgramUniformGet1i(r_program_uniform_id uniform_id, int default_value)
{
	gl_program_uniform_t* program_uniform = GL_ProgramUniformFind(uniform_id);

	if (program_uniform->location >= 0) {
		return program_uniform->int_value;
	}
	return default_value;
}

// Set UBO block bindings manually when layout(binding=N) is unavailable (GL < 4.2)
static void R_PatchProgramBindings(r_program_id program_id)
{
	static const struct { const char* name; int binding; } storage_bindings[] = {
		{ "WorldCvars",            EZQ_GL_BINDINGPOINT_BRUSHMODEL_DRAWDATA },
		{ "SamplerMappingsBuffer", EZQ_GL_BINDINGPOINT_BRUSHMODEL_SAMPLERS },
		{ "AliasModelData",        EZQ_GL_BINDINGPOINT_ALIASMODEL_DRAWDATA },
		{ "surface_data",          EZQ_GL_BINDINGPOINT_WORLDMODEL_SURFACES },
	};
	GLuint prog, idx;
	int i;

	if (GL_VersionAtLeast(4, 2)) {
		return; // layout(binding=N) works in-shader
	}

	prog = R_ProgramId(program_id);

	// Set UBO binding for GlobalState
	idx = GL_GetUniformBlockIndex(prog, "GlobalState");
	if (idx != GL_INVALID_INDEX) {
		GL_UniformBlockBinding(prog, idx, EZQ_GL_BINDINGPOINT_FRAMECONSTANTS);
	}

	// Set UBO bindings for storage blocks (SSBOs that became UBOs)
	for (i = 0; i < (int)(sizeof(storage_bindings) / sizeof(storage_bindings[0])); i++) {
		idx = GL_GetUniformBlockIndex(prog, storage_bindings[i].name);
		if (idx != GL_INVALID_INDEX) {
			GL_UniformBlockBinding(prog, idx, EZQ_STORAGE_BLOCK_BINDING(storage_bindings[i].binding));
		}
	}
}

qbool R_ProgramCompile(r_program_id program_id)
{
	return R_ProgramCompileWithInclude(program_id, NULL);
}

qbool R_ProgramCompileWithInclude(r_program_id program_id, const char* included_definitions)
{
	gl_program_t* program = R_CurrentSubProgram(program_id);

	memset(program->shader_handles, 0, sizeof(program->shader_handles));
	Q_free(program->included_definitions);
	program->included_definitions = included_definitions ? Q_strdup(included_definitions) : NULL;

	if (GL_CompileProgram(program)) {
		if (program_id == currentProgram && GL_Available(glUseProgram)) {
			GL_Procedure(glUseProgram, R_CurrentSubProgram(program_id)->program);
		}
		R_ProgramFindUniformsForProgram(program_id);
		R_ProgramFindAttributesForProgram(program_id);
		R_PatchProgramBindings(program_id);
		return true;
	}
	return false;
}

static void GL_BuildCoreDefinitions(void)
{
	// macro_definitions: injected BEFORE common.glsl (macros used by common.glsl)
	memset(macro_definitions, 0, sizeof(macro_definitions));
	strlcpy(macro_definitions, (R_UseModernOpenGL() ? "#define EZ_MODERN_GL\n" : "#define EZ_LEGACY_GL\n"), sizeof(macro_definitions));

#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		if (GL_VersionAtLeast(4, 3)) {
			strlcat(macro_definitions,
				"#define EZ_HAS_SSBO 1\n"
				"#define EZ_LAYOUT_BINDING(n) layout(binding=n)\n"
				"#define EZ_SSBO_LAYOUT(qualifier, binding_name) layout(qualifier, binding=binding_name)\n"
				"#define EZ_SSBO(name) buffer name\n"
				"#define EZ_SSBO_ARRAY_SIZE(max_size)\n",
				sizeof(macro_definitions));
		}
		else {
			strlcat(macro_definitions,
				"#define EZ_LAYOUT_BINDING(n)\n"
				"#define EZ_SSBO_LAYOUT(qualifier, binding_name) layout(qualifier)\n"
				"#define EZ_SSBO(name) uniform name\n"
				"#define EZ_SSBO_ARRAY_SIZE(max_size) max_size\n",
				sizeof(macro_definitions));
		}
	}
#endif

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	// GLC core profile compatibility macros (only in actual core profile context)
	if (!R_UseModernOpenGL() && glConfig.coreProfile) {
		strlcat(macro_definitions,
			// Shared uniforms (available in both vertex and fragment shaders)
			"uniform mat4 ezModelViewProjectionMatrix;\n"
			"uniform mat4 ezTextureMatrix[4];\n"
			"#define gl_ModelViewProjectionMatrix ezModelViewProjectionMatrix\n"
			"#define gl_TextureMatrix ezTextureMatrix\n"
			// Vertex shader compatibility
			"#ifdef EZ_VERTEX_SHADER\n"
			"#define attribute in\n"
			"#define varying out\n"
			"in vec4 ezVertex;\n"
			"in vec3 ezNormal;\n"
			"in vec4 ezColor;\n"
			"in vec4 ezMultiTexCoord0;\n"
			"in vec4 ezMultiTexCoord1;\n"
			"#define gl_Vertex ezVertex\n"
			"#define gl_Normal ezNormal\n"
			"#define gl_Color ezColor\n"
			"#define gl_MultiTexCoord0 ezMultiTexCoord0\n"
			"#define gl_MultiTexCoord1 ezMultiTexCoord1\n"
			"#define ftransform() (ezModelViewProjectionMatrix * ezVertex)\n"
			"#endif\n"
			// Fragment shader compatibility
			"#ifdef EZ_FRAGMENT_SHADER\n"
			"#define varying in\n"
			"out vec4 ezFragColor;\n"
			"#define gl_FragColor ezFragColor\n"
			"#define texture2D texture\n"
			"#define texture2DArray texture\n"
			"#define textureCube texture\n"
			"#endif\n",
			sizeof(macro_definitions));
	}
#endif

	// core_definitions: injected AFTER common.glsl (fog functions that use GlobalState members)
	memset(core_definitions, 0, sizeof(core_definitions));
	strlcat(core_definitions,
		"#ifdef DRAW_FOG\n"
			"#ifdef FOG_EXP\n"
			"#ifdef EZ_LEGACY_GL\n"
				"uniform float fogDensity;\n"
				"uniform vec3 fogColor;\n"
			"#endif\n"
				"vec4 applyFog(vec4 vecinput, float z) {\n"
				"	float fogmix = exp(-fogDensity * z);\n"
				"	fogmix = clamp(fogmix, 0.0, 1.0); \n"
				"	return vec4(mix(fogColor, vecinput.rgb, fogmix), 1) * vecinput.a; \n"
				"}\n"
				"vec4 applyFogBlend(vec4 vecinput, float z) {\n"
				"	float fogmix = exp(-fogDensity * z);\n"
				"	fogmix = clamp(fogmix, 0.0, 1.0); \n"
				"	return vecinput * vec4(1, 1, 1, fogmix);\n"
				"}\n"
			"#elif defined(FOG_EXP2)\n"
				"const float LOG2 = 1.442695;\n"
			"#ifdef EZ_LEGACY_GL\n"
				"uniform float fogDensity;\n"
				"uniform vec3 fogColor;\n"
			"#endif"
				"\n"
				"vec4 applyFog(vec4 vecinput, float z) {\n"
				"	float fogmix = exp2(-fogDensity * z * z * LOG2);\n"
				"	fogmix = clamp(fogmix, 0.0, 1.0);\n"
				"	return vec4(mix(fogColor, vecinput.rgb, fogmix), 1) * vecinput.a;\n"
				"}\n"
				"vec4 applyFogBlend(vec4 vecinput, float z) {\n"
				"	float fogmix = exp2(-fogDensity * z * z * LOG2);\n"
				"	fogmix = clamp(fogmix, 0.0, 1.0);\n"
				"	return vecinput * vec4(1, 1, 1, fogmix);\n"
				"}\n"
			"#elif defined(FOG_LINEAR)\n"
			"#ifdef EZ_LEGACY_GL\n"
				"uniform float fogMinZ; \n"
				"uniform float fogMaxZ; \n"
				"uniform vec3 fogColor; \n"
			"#endif"
				"\n"
				"vec4 applyFog(vec4 vecinput, float z) {\n"
					"float fogmix = (fogMaxZ - z) / (fogMaxZ - fogMinZ); \n"
					"fogmix = clamp(fogmix, 0.0, 1.0); \n"
					"return vec4(mix(fogColor, vecinput.rgb / vecinput.a, fogmix), 1) * vecinput.a; \n"
				"}\n"
				"vec4 applyFogBlend(vec4 vecinput, float z) {\n"
					"float fogmix = (fogMaxZ - z) / (fogMaxZ - fogMinZ); \n"
					"fogmix = clamp(fogmix, 0.0, 1.0); \n"
					"return vecinput * vec4(1, 1, 1, fogmix);\n"
				"}\n"
			"#else\n"
				"vec4 applyFog(vec4 vecinput, float z) {\n"
				"	return vecinput; \n"
				"}\n"
				"vec4 applyFogBlend(vec4 vecinput, float z) {\n"
				"	return vecinput; \n"
				"}\n"
			"#endif\n"
		"#endif // DRAW_FOG\n", sizeof(core_definitions)
	);

#ifdef RENDERER_OPTION_MODERN_OPENGL
	GL_DefineProgram_VF(r_program_aliasmodel, "aliasmodel", true, draw_aliasmodel, renderer_modern, GLM_CompileAliasModelProgram, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_brushmodel, "brushmodel", true, draw_world, renderer_modern, GLM_CompileDrawWorldProgram, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_brushmodel_alphatested, "brushmodel-alphatested", true, draw_world, renderer_modern, GLM_CompileDrawWorldProgramAlphaTested, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_sprite3d, "3d-sprites", false, draw_sprites, renderer_modern, GLM_Compile3DSpriteProgram, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_hud_images, "image-draw", true, hud_draw_image, renderer_modern, GLM_CreateMultiImageProgram, STDOPTIONS_NONE);
	GL_DefineProgram_VF(r_program_hud_circles, "circle-draw", false, hud_draw_circle, renderer_modern, GLM_CompileHudCircleProgram, STDOPTIONS_NONE);
	GL_DefineProgram_VF(r_program_post_process, "post-process-screen", true, post_process_screen, renderer_modern, GLM_CompilePostProcessProgram, STDOPTIONS_NONE);
	GL_DefineProgram_CS(r_program_lightmap_compute, "lightmaps", false, lighting, renderer_modern, GLM_CompileLightmapComputeProgram, STDOPTIONS_NONE);
	GL_DefineProgram_VF(r_program_fx_world_geometry, "world-geometry", true, fx_world_geometry, renderer_modern, GLM_CompileWorldGeometryProgram, STDOPTIONS_NONE);
	GL_DefineProgram_VF(r_program_simple, "simple", false, simple, renderer_modern, GLM_CompileSimpleProgram, STDOPTIONS_NONE);
	GL_DefineProgram_VF(r_program_simple3d, "simple3d", false, simple3d, renderer_modern, GLM_CompileSimple3dProgram, STDOPTIONS_NONE);
#endif

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	GL_DefineProgram_VF(r_program_post_process_glc, "post-process-screen", true, glc_post_process_screen, renderer_classic, GLC_CompilePostProcessProgram, STDOPTIONS_NONE);
	GL_DefineProgram_VF(r_program_sky_glc, "sky-rendering", true, glc_sky, renderer_classic, GLC_SkyProgramCompile, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_turb_glc, "turb-rendering", true, glc_turbsurface, renderer_classic, GLC_TurbSurfaceProgramCompile, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_caustics_glc, "caustics-rendering", true, glc_caustics, renderer_classic, GLC_CausticsProgramCompile, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_aliasmodel_std_glc, "aliasmodel-std", true, glc_aliasmodel_std, renderer_classic, GLC_AliasModelStandardCompile, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_aliasmodel_shell_glc, "aliasmodel-shell", true, glc_aliasmodel_shell, renderer_classic, GLC_AliasModelShellCompile, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_aliasmodel_shadow_glc, "aliasmodel-shadow", true, glc_aliasmodel_shadow, renderer_classic, GLC_AliasModelShadowCompile, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_aliasmodel_outline_glc, "aliasmodel-outline", true, glc_aliasmodel_std, renderer_classic, GLC_AliasModelOutlineCompile, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_world_drawflat_glc, "drawflat-world", true, glc_world_drawflat, renderer_classic, GLC_DrawflatProgramCompile, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_world_textured_glc, "textured-world", true, glc_world_textured, renderer_classic, GLC_PreCompileWorldPrograms, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_world_secondpass_glc, "secondpass-world", true, glc_world_secondpass, renderer_classic, GLC_PreCompileWorldPrograms, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_sprites_glc, "3d-sprites", true, glc_draw_sprites, renderer_classic, GLC_CompileSpriteProgram, STDOPTIONS_FOG);
	GL_DefineProgram_VF(r_program_hud_images_glc, "hud-images", true, glc_hud_images, renderer_classic, GLC_ProgramHudImagesCompile, STDOPTIONS_NONE);
#endif
}

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
int R_ProgramAttributeLocation(r_program_attribute_id attr_id)
{
	r_program_id program_id;
	gl_program_attribute_t* attr;

	// FIXME: why is this is in release build?
	if (attr_id < 0 || attr_id >= r_program_attribute_count) {
		return -1;
	}

	program_id = program_attributes[attr_id].program_id;
	attr = &(R_CurrentSubProgram(program_id)->attributes[attr_id]);
	if (!attr->found) {
		return -1;
	}

	return attr->location;
}

r_program_id R_ProgramForAttribute(r_program_attribute_id attr_id)
{
	if (attr_id < 0 || attr_id >= r_program_attribute_count) {
		return r_program_none;
	}

	return program_attributes[attr_id].program_id;
}

static r_program_attribute_t* GL_ProgramAttributeFind(r_program_attribute_id attribute_id)
{
	r_program_attribute_t* attribute = &program_attributes[attribute_id];
	r_program_id program_id = attribute->program_id;
	gl_program_t* program = R_CurrentSubProgram(program_id);
	gl_program_attribute_t* program_attr = &program->attributes[attribute_id];

	if (program->program && !program_attr->found) {
		program_attr->location = GL_Function(glGetAttribLocation, program->program, attribute->name);
		program_attr->found = true;
	}

	return attribute;
}

static void R_ProgramFindAttributesForProgram(r_program_id program_id)
{
	r_program_attribute_id a;

	for (a = 0; a < r_program_attribute_count; ++a) {
		if (program_attributes[a].program_id == program_id) {
			R_CurrentSubProgram(program_id)->attributes[a].found = false;
			GL_ProgramAttributeFind(a);
		}
	}
}
#endif

void R_ProgramCompileAll(void)
{
	int i;
	int sub_program;

	for (i = 0; i < r_program_count; ++i) {
		for (sub_program = 0; sub_program < MAX_SUBPROGRAMS; ++sub_program) {
			gl_program_t* prog = R_SpecificSubProgram(i, sub_program);

			R_ProgramSetSubProgram(i, sub_program);
			if (!GL_AppropriateRenderer(prog->renderer_id)) {
				continue;
			}

			if (prog->initialised && prog->compile_func) {
				prog->compile_func();
			}
		}
		R_ProgramSetSubProgram(i, 0);
	}
}

void R_ProgramSetSubProgram(r_program_id program_id, int sub_index)
{
	program_currentSubProgram[program_id] = sub_index;
}

void R_ProgramSetStandardUniforms(r_program_id program_id)
{
	gl_program_t* program = R_CurrentSubProgram(program_id);

	if (program->standard_options & STDOPTIONS_FOG) {
		if (r_refdef2.fog_enabled) {
			R_ProgramStandardUniform3fv(program_id, r_program_std_uniform_fog_color, r_refdef2.fog_color);

			if (r_refdef2.fog_calculation == fogcalc_linear) {
				R_ProgramStandardUniform1f(program_id, r_program_std_uniform_fog_linear_start, r_refdef2.fog_linear_start);
				R_ProgramStandardUniform1f(program_id, r_program_std_uniform_fog_linear_end, r_refdef2.fog_linear_end);
			}
			else {
				R_ProgramStandardUniform1f(program_id, r_program_std_uniform_fog_density, r_refdef2.fog_density);
			}
		}
	}
}


================================================
FILE: src/gl_sdl.c
================================================
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================

*/

#include <SDL.h>
#include "quakedef.h"
#include "gl_local.h"

static void GL_SDL_SetupAttributes(const opengl_version_t* version)
{
	if (version->legacy) {
		// SDL defaults - take what we can get.  SDL rules are profile_mask == flags == 0 && majorversion < 3 => legacy profile
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 0);
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, 0);
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
	}
	else {
		int contextFlags = 0;

		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, version->majorVersion);
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, version->minorVersion);
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, version->core ? SDL_GL_CONTEXT_PROFILE_CORE : SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);

#ifdef __APPLE__
		// https://www.khronos.org/opengl/wiki/OpenGL_Context
		// Recommendation: You should use the forward compatibility bit only if you need compatibility with MacOS.
		// That API requires the forward compatibility bit to create any core profile context.
		contextFlags |= version->core ? SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG : 0;
#else
		contextFlags |= version->core && COM_CheckParm(cmdline_param_client_forwardonlyprofile) ? SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG : 0;
#endif
		contextFlags |= R_DebugProfileContext() ? SDL_GL_CONTEXT_DEBUG_FLAG : 0;
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, contextFlags);
	}
}

SDL_GLContext GL_SDL_CreateBestContext(SDL_Window* window, const opengl_version_t* versions, int count)
{
	SDL_GLContext context;
	int attempt;
#ifdef _WIN32
	int accelerated = 0;

	SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &accelerated);
#endif

	for (attempt = 0; attempt < count; ++attempt) {
		extern cvar_t vid_gl_core_profile;
		const opengl_version_t* version = &versions[attempt];

		if (vid_gl_core_profile.integer && !version->core && !version->legacy) {
			continue;
		}

		GL_SDL_SetupAttributes(version);

		context = SDL_GL_CreateContext(window);
		if (COM_CheckParm(cmdline_param_console_debug)) {
			Con_Printf("Asked for OpenGL %d.%d, got %s\n", version->majorVersion, version->minorVersion, context ? (const char*)glGetString(GL_VENDOR) : "failure");
		}

#ifdef _WIN32
		// SDL2 falls back to not even asking if it's accelerated, so we might get software :(
		if (context && (version->core || accelerated) && strstr((const char*)glGetString(GL_VENDOR), "Microsoft") != NULL) {
			if (COM_CheckParm(cmdline_param_console_debug)) {
				Con_Printf("... rejecting unaccelerated context\n");
			}
			SDL_GL_DeleteContext(context);
			context = NULL;
		}
#endif
		if (context) {
			if (glGetString(GL_VERSION) && atoi((const char*)glGetString(GL_VERSION)) >= version->majorVersion) {
				return context;
			}
			
			if (COM_CheckParm(cmdline_param_console_debug)) {
				Con_Printf("... rejecting lower OpenGL version (%d vs %d)\n", atoi((const char*)glGetString(GL_VERSION)), version->majorVersion);
			}
			SDL_GL_DeleteContext(context);
			context = NULL;
		}
	}

	return NULL;
}


================================================
FILE: src/gl_sprite3d.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// 3D sprites
#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "gl_sprite3d.h"
#include "r_sprite3d_internal.h"
#include "tr_types.h"

GLenum glPrimitiveTypes[r_primitive_count] = {
	GL_TRIANGLE_STRIP,
	GL_TRIANGLE_FAN,
	GL_TRIANGLES
};

void GL_DrawSequentialBatchImpl(gl_sprite3d_batch_t* batch, int first_batch, int last_batch, int index_offset, GLuint maximum_batch_size)
{
	int vertOffset = batch->glFirstVertices[first_batch];
	int numVertices = batch->numVertices[first_batch];
	int batch_count = last_batch - first_batch;
	void* indexes = (void*)(index_offset * sizeof(GLuint));
	int terminators = GL_Supported(R_SUPPORT_PRIMITIVERESTART) ? 1 : (numVertices % 2 == 0 ? 2 : 3);

	// Ugh!
	if (!GL_Supported(R_SUPPORT_PRIMITIVERESTART) && batch->primitive_id == r_primitive_triangle_fan) {
		maximum_batch_size = 1;
	}

	while (batch_count > maximum_batch_size) {
		GL_DrawElementsBaseVertex(glPrimitiveTypes[batch->primitive_id], maximum_batch_size * numVertices + (maximum_batch_size - 1) * terminators, GL_UNSIGNED_INT, indexes, vertOffset);
		batch_count -= maximum_batch_size;
		vertOffset += maximum_batch_size * numVertices;
	}
	if (batch_count) {
		GL_DrawElementsBaseVertex(glPrimitiveTypes[batch->primitive_id], batch_count * numVertices + (batch_count - 1) * terminators, GL_UNSIGNED_INT, indexes, vertOffset);
	}
}


================================================
FILE: src/gl_sprite3d.h
================================================

#ifndef EZQUAKE_GL_SPRITE3D_HEADER
#define EZQUAKE_GL_SPRITE3D_HEADER

#include "r_sprite3d.h"
#include "r_sprite3d_internal.h"

// GL only
extern GLenum glPrimitiveTypes[r_primitive_count];

void GL_DrawSequentialBatchImpl(gl_sprite3d_batch_t* batch, int first_batch, int last_batch, int index_offset, GLuint maximum_batch_size);

extern int indexes_start_quads;
extern int indexes_start_flashblend;
extern int indexes_start_sparks;

#endif // #ifndef EZQUAKE_GL_SPRITE3D_HEADER


================================================
FILE: src/gl_state.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// gl_state.c
// State caching for OpenGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "tr_types.h"
#include "r_state.h"
#include "r_texture.h"
#include "r_vao.h"
#include "glm_vao.h"
#include "glc_vao.h"
#include "vk_vao.h"
#include "r_matrix.h"
#include "r_buffers.h"
#include "glm_local.h"
#include "gl_texture_internal.h"
#include "r_renderer.h"
#include "r_program.h"
#include "glc_state.h"

static void GLC_ToggleAlphaTesting(const rendering_state_t* state, rendering_state_t* current);
static rendering_state_t states[r_state_count];

// Texture functions
GL_StaticProcedureDeclaration(glBindTextures, "first=%u, count=%d, format=%p", GLuint first, GLsizei count, const GLuint* format)
GL_StaticProcedureDeclaration(glBindImageTexture, "unit=%u, texture=%u, level=%d, layered=%d, layer=%d, access=%u, format=%u", GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
GL_StaticProcedureDeclaration(glActiveTexture, "target=%u", GLenum target)

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
GL_StaticProcedureDeclaration(glMultiTexCoord2f, "target=%u, s=%f, t=%f", GLenum target, GLfloat s, GLfloat t)
GL_StaticProcedureDeclaration(glClientActiveTexture, "target=%u", GLenum target)
#endif

#ifdef WITH_RENDERING_TRACE
static const char* gl_friendlyTextureTargetNames[] = {
	"GL_TEXTURE_2D",              // texture_type_2d,
	"GL_TEXTURE_2D_ARRAY",        // texture_type_2d_array,
	"GL_TEXTURE_CUBE_MAP",        // texture_type_cubemap,
	"GL_TEXTURE_2D_MULTISAMPLE"   // texture_type_2d_multisampled,
};

static const char* fogModeDescriptions[] = {
	"disabled",
	"enabled"
};
#ifdef C_ASSERT
C_ASSERT(sizeof(fogModeDescriptions) / sizeof(fogModeDescriptions[0]) == r_fogmode_count);
#endif
#endif

void R_InitialiseStates(void);

// VAOs
static r_vao_id currentVAO = vao_none;
static const char* vaoNames[] = {
	"none",
	"aliasmodel",
	"brushmodel",
	"3d-sprites",
	"hud:circles",
	"hud:images",
	"hud:lines",
	"hud:polygons",
	"post-process",
	"powerupshell",
	"brushmodel_details",
	"brushmodel_lightmap_pass",
	"brushmodel_lm_unit1",
	"brushmodel_simpletex",
	"vao_hud_images_non_glsl"
};

#ifdef C_ASSERT
C_ASSERT(sizeof(vaoNames) / sizeof(vaoNames[0]) == vao_count);
#endif

#define MAX_LOGGED_TEXTURE_UNITS 32
#define MAX_LOGGED_IMAGE_UNITS   32

typedef struct image_unit_binding_s {
	GLuint texture;
	GLint level;
	GLboolean layered;
	GLint layer;
	GLenum access;
	GLenum format;
} image_unit_binding_t;

static void GL_BindTexture(GLenum targetType, GLuint texnum, qbool warning);

/*typedef struct {
	GLenum currentTextureUnit;
	GLenum bound_texture_state[texture_type_count][MAX_LOGGED_TEXTURE_UNITS];
	image_unit_binding_t bound_images[MAX_LOGGED_IMAGE_UNITS];

	GLenum unit_texture_mode[texture_type_count][MAX_LOGGED_TEXTURE_UNITS]
	qbool texunitenabled[MAX_LOGGED_TEXTURE_UNITS];
} texture_state_t;
*/
typedef struct {
	rendering_state_t rendering_state;
	//texture_state_t textures;
} opengl_state_t;

static GLenum currentTextureUnit;
static GLuint bound_texture_state[texture_type_count][MAX_LOGGED_TEXTURE_UNITS];
static image_unit_binding_t bound_images[MAX_LOGGED_IMAGE_UNITS];

static opengl_state_t opengl;
static GLenum glDepthFunctions[] = {
	GL_LESS,   // r_depthfunc_less,
	GL_EQUAL,  // r_depthfunc_equal,
	GL_LEQUAL, // r_depthfunc_lessorequal,
};
static GLenum glReversedDepthFunctions[] = {
	GL_GREATER, // inv(r_depthfunc_less)
	GL_EQUAL,   // inv(r_depthfunc_equal)
	GL_GEQUAL   // inv(r_depthfunc_lessorequal)
};
static GLenum glCullFaceValues[] = {
	GL_FRONT,  // r_cullface_front
	GL_BACK,   // r_cullface_back
};
static GLenum glBlendFuncValuesSource[] = {
	GL_ONE, // r_blendfunc_overwrite,
	GL_ONE, // r_blendfunc_additive_blending,
	GL_ONE, // r_blendfunc_premultiplied_alpha,
	GL_DST_COLOR, // r_blendfunc_src_dst_color_dest_zero,
	GL_DST_COLOR, // r_blendfunc_src_dst_color_dest_one,
	GL_DST_COLOR, // r_blendfunc_src_dst_color_dest_src_color,
	GL_ZERO, // r_blendfunc_src_zero_dest_one_minus_src_color,
	GL_ZERO, // r_blendfunc_src_zero_dest_src_color,
	GL_ONE, // r_blendfunc_src_one_dest_zero,
	GL_ZERO, // r_blendfunc_src_zero_dest_one,
	GL_ONE, // r_blendfunc_src_one_dest_one_minus_src_color,
};
static GLenum glBlendFuncValuesDestination[] = {
	GL_ZERO, // r_blendfunc_overwrite,
	GL_ONE, // r_blendfunc_additive_blending,
	GL_ONE_MINUS_SRC_ALPHA, // r_blendfunc_premultiplied_alpha,
	GL_ZERO, // r_blendfunc_src_dst_color_dest_zero,
	GL_ONE, // r_blendfunc_src_dst_color_dest_one,
	GL_SRC_COLOR, // r_blendfunc_src_dst_color_dest_src_color,
	GL_ONE_MINUS_SRC_COLOR, // r_blendfunc_src_zero_dest_one_minus_src_color,
	GL_SRC_COLOR, // r_blendfunc_src_zero_dest_src_color,
	GL_ZERO, // r_blendfunc_src_one_dest_zero,
	GL_ONE, // r_blendfunc_src_zero_dest_one,
	GL_ONE_MINUS_SRC_COLOR, // r_blendfunc_src_one_dest_one_minus_src_color,
};
static GLenum glPolygonModeValues[] = {
	GL_FILL, // r_polygonmode_fill,
	GL_LINE, // r_polygonmode_line,
};
static GLenum glAlphaTestModeValues[] = {
	GL_ALWAYS,  // r_alphatest_func_always,
	GL_GREATER, // r_alphatest_func_greater,
};
static GLenum glTextureEnvModeValues[] = {
	GL_BLEND, GL_REPLACE, GL_MODULATE, GL_DECAL, GL_ADD
};

#ifdef C_ASSERT
C_ASSERT(sizeof(glBlendFuncValuesSource) / sizeof(glBlendFuncValuesSource[0]) == r_blendfunc_count);
C_ASSERT(sizeof(glBlendFuncValuesDestination) / sizeof(glBlendFuncValuesDestination[0]) == r_blendfunc_count);
C_ASSERT(sizeof(glTextureEnvModeValues) / sizeof(glTextureEnvModeValues[0]) == r_texunit_mode_count);
C_ASSERT(sizeof(glDepthFunctions) / sizeof(glDepthFunctions[0]) == r_depthfunc_count);
C_ASSERT(sizeof(glReversedDepthFunctions) / sizeof(glReversedDepthFunctions[0]) == r_depthfunc_count);
C_ASSERT(sizeof(glCullFaceValues) / sizeof(glCullFaceValues[0]) == r_cullface_count);
C_ASSERT(sizeof(glPolygonModeValues) / sizeof(glPolygonModeValues[0]) == r_polygonmode_count);
C_ASSERT(sizeof(glAlphaTestModeValues) / sizeof(glAlphaTestModeValues[0]) == r_alphatest_func_count);
#endif

#ifdef WITH_RENDERING_TRACE
static const char* txtDepthFunctions[] = {
	"<", // r_depthfunc_less,
	"=", // r_depthfunc_equal,
	"<=", // r_depthfunc_lessorequal,
};
static const char* txtReversedDepthFunctions[] = {
	">", // r_depthfunc_less,
	"=", // r_depthfunc_equal,
	">=", // r_depthfunc_lessorequal,
};
static const char* txtCullFaceValues[] = {
	"front", // r_cullface_front,
	"back", // r_cullface_back,
};
static const char* txtBlendFuncNames[] = {
	"overwrite", // r_blendfunc_overwrite,
	"additive",        // r_blendfunc_additive_blending,
	"premul-alpha",    // r_blendfunc_premultiplied_alpha,
	"src_dst_color_dest_zero", // r_blendfunc_src_dst_color_dest_zero
	"src_dst_color_dest_one", // r_blendfunc_src_dst_color_dest_one
	"src_dst_color_dest_src_color", // r_blendfunc_src_dst_color_dest_src_color
	"src_zero_dest_one_minus_src_color", // r_blendfunc_src_zero_dest_one_minus_src_color
	"src_zero_dest_src_color", // r_blendfunc_src_zero_dest_src_color
	"src_one_dest_zero", // r_blendfunc_src_one_dest_zero
	"src_zero_dest_one", // r_blendfunc_src_zero_dest_one
	"src_one_dest_one_minus_src_color", // "r_blendfunc_src_one_dest_one_minus_src_color"
};
static const char* txtPolygonModeValues[] = {
	"fill", // r_polygonmode_fill,
	"line", // r_polygonmode_line,
};
static const char* txtAlphaTestModeValues[] = {
	"always", // r_alphatest_func_always,
	"greater", // r_alphatest_func_greater,
};
static const char* txtTextureEnvModeValues[] = {
	"GL_BLEND", "GL_REPLACE", "GL_MODULATE", "GL_DECAL", "GL_ADD"
};

#ifdef C_ASSERT
C_ASSERT(sizeof(txtDepthFunctions) / sizeof(txtDepthFunctions[0]) == r_depthfunc_count);
C_ASSERT(sizeof(txtReversedDepthFunctions) / sizeof(txtReversedDepthFunctions[0]) == r_depthfunc_count);
C_ASSERT(sizeof(txtCullFaceValues) / sizeof(txtCullFaceValues[0]) == r_cullface_count);
C_ASSERT(sizeof(txtBlendFuncNames) / sizeof(txtCullFaceValues[0]) == r_blendfunc_count);
C_ASSERT(sizeof(txtPolygonModeValues) / sizeof(txtPolygonModeValues[0]) == r_polygonmode_count);
C_ASSERT(sizeof(txtAlphaTestModeValues) / sizeof(txtAlphaTestModeValues[0]) == r_alphatest_func_count);
C_ASSERT(sizeof(txtTextureEnvModeValues) / sizeof(txtTextureEnvModeValues[0]) == r_texunit_mode_count);
#endif
#endif

rendering_state_t* R_InitRenderingState(r_state_id id, qbool default_state, const char* name, r_vao_id vao)
{
	rendering_state_t* state = &states[id];
	SDL_Window* window = SDL_GL_GetCurrentWindow();

	strlcpy(state->name, name, sizeof(state->name));

	state->depth.func = r_depthfunc_less;
	state->depth.nearRange = 0;
	state->depth.farRange = 1;
	state->depth.test_enabled = false;
	state->depth.mask_enabled = false;

	state->blendFunc = r_blendfunc_overwrite;
	state->blendingEnabled = false;
	R_GLC_ConfigureAlphaTesting(state, false, r_alphatest_func_always, 0);

	state->currentViewportX = 0;
	state->currentViewportY = 0;
	SDL_GL_GetDrawableSize(window, &state->currentViewportWidth, &state->currentViewportHeight);

	state->cullface.enabled = false;
	state->cullface.mode = r_cullface_back;

	state->framebuffer_srgb = false;
	state->line.smooth = false;
	state->line.width = 1.0f;
	state->fog.mode = r_fogmode_disabled;
	state->polygonOffset.option = r_polygonoffset_disabled;
	state->polygonOffset.factor = 0;
	state->polygonOffset.units = 0;
	state->polygonOffset.fillEnabled = false;
	state->polygonOffset.lineEnabled = false;
	state->polygonMode = r_polygonmode_fill;
	state->clearColor[0] = state->clearColor[1] = state->clearColor[2] = state->clearColor[3] = 0;
	state->color[0] = state->color[1] = state->color[2] = state->color[3] = 1;
	state->colorMask[0] = state->colorMask[1] = state->colorMask[2] = state->colorMask[3] = true;

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	{
		int i;

		memset(state->textureUnits, 0, sizeof(state->textureUnits));

		for (i = 0; i < sizeof(state->textureUnits) / sizeof(state->textureUnits[0]); ++i) {
			state->textureUnits[i].mode = r_texunit_mode_modulate;
			state->textureUnits[i].va.size = 4;
			state->textureUnits[i].va.type = GL_FLOAT;
		}
	}

	state->vertex_array.size = 4;
	state->vertex_array.type = GL_FLOAT;

	state->color_array.size = 4;
	state->color_array.type = GL_FLOAT;

	state->normal_array.type = GL_FLOAT;
#endif

	// Not applied each time, kept distinct
	state->pack_alignment = 4;

	state->vao_id = vao;

	if (default_state) {
		state->cullface.mode = r_cullface_front;
		state->cullface.enabled = true;

		state->depth.func = r_depthfunc_lessorequal;
		R_GLC_ConfigureAlphaTesting(state, false, r_alphatest_func_greater, 0.666f);
		state->blendingEnabled = false;
		state->depth.test_enabled = true;
		state->depth.mask_enabled = true;

		state->clearColor[0] = 0;
		state->clearColor[1] = 0;
		state->clearColor[2] = 0;
		state->clearColor[3] = 1;

		state->polygonMode = r_polygonmode_fill;
		state->blendFunc = r_blendfunc_premultiplied_alpha;
		R_GLC_TextureUnitSet(state, 0, false, r_texunit_mode_replace);
		state->framebuffer_srgb = true;

		state->pack_alignment = 1;
	}

	state->initialized = true;
	return state;
}

rendering_state_t* R_Init3DSpriteRenderingState(r_state_id id, const char* name)
{
	rendering_state_t* state = R_InitRenderingState(id, true, name, vao_3dsprites);

	state->fog.mode = r_fogmode_enabled;
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->cullface.enabled = false;
	R_GLC_ConfigureAlphaTesting(state, false, r_alphatest_func_greater, 0.333f);

	return state;
}

#define GL_ApplySimpleToggle(state, current, field, option) \
	if (state->field != current->field) { \
		if (state->field) { \
			glEnable(option); \
			R_TraceLogAPICall("glEnable(" # option ")"); \
		} \
		else { \
			glDisable(option); \
			R_TraceLogAPICall("glDisable(" # option ")"); \
		} \
		current->field = state->field; \
	}

void GL_ApplyRenderingState(r_state_id id)
{
	rendering_state_t* state = &states[id];
	extern cvar_t gl_brush_polygonoffset;
	rendering_state_t* current = &opengl.rendering_state;
	float zRange[2] = {
		glConfig.reversed_depth && false ? 1.0f - state->depth.nearRange : state->depth.nearRange,
		glConfig.reversed_depth && false ? 1.0f - state->depth.farRange : state->depth.farRange,
	};

	R_TraceEnterRegion(va("GL_ApplyRenderingState(%s)", state->name), true);

	if (state->depth.func != current->depth.func) {
		current->depth.func = state->depth.func;
		if (glConfig.reversed_depth) {
			glDepthFunc(glReversedDepthFunctions[current->depth.func]);
			R_TraceLogAPICall("glDepthFunc(reversed(%s)=%s)", txtDepthFunctions[current->depth.func], txtReversedDepthFunctions[current->depth.func]);
		}
		else {
			glDepthFunc(glDepthFunctions[current->depth.func]);
			R_TraceLogAPICall("glDepthFunc(%s)", txtDepthFunctions[current->depth.func]);
		}
	}
	if (zRange[0] != current->depth.nearRange || zRange[1] != current->depth.farRange) {
		glDepthRange(
			current->depth.nearRange = zRange[0],
			current->depth.farRange = zRange[1]
		);
		R_TraceLogAPICall("glDepthRange(%f,%f)", zRange[0], zRange[1]);
	}
	if (state->cullface.mode != current->cullface.mode) {
		glCullFace(glCullFaceValues[current->cullface.mode = state->cullface.mode]);
		R_TraceLogAPICall("glCullFace(%s)", txtCullFaceValues[state->cullface.mode]);
	}
	if (state->blendFunc != current->blendFunc) {
		current->blendFunc = state->blendFunc;
		glBlendFunc(
			glBlendFuncValuesSource[state->blendFunc],
			glBlendFuncValuesDestination[state->blendFunc]
		);
		R_TraceLogAPICall("glBlendFunc(%s)", txtBlendFuncNames[state->blendFunc]);
	}
	if (state->line.width != current->line.width) {
		glLineWidth(current->line.width = state->line.width);
		R_TraceLogAPICall("glLineWidth(%f)", current->line.width);
	}
	GL_ApplySimpleToggle(state, current, depth.test_enabled, GL_DEPTH_TEST);
	if (state->depth.mask_enabled != current->depth.mask_enabled) {
		glDepthMask((current->depth.mask_enabled = state->depth.mask_enabled) ? GL_TRUE : GL_FALSE);
		R_TraceLogAPICall("glDepthMask(%s)", current->depth.mask_enabled ? "on" : "off");
	}
	if (vid_gammacorrection.integer) {
		GL_ApplySimpleToggle(state, current, framebuffer_srgb, GL_FRAMEBUFFER_SRGB);
	}
	GL_ApplySimpleToggle(state, current, cullface.enabled, GL_CULL_FACE);
	GL_ApplySimpleToggle(state, current, line.smooth, GL_LINE_SMOOTH);

	if (state->polygonOffset.option != current->polygonOffset.option || gl_brush_polygonoffset.modified) {
		R_CustomPolygonOffset(state->polygonOffset.option);

		gl_brush_polygonoffset.modified = false;
	}
	if (state->polygonMode != current->polygonMode) {
		glPolygonMode(GL_FRONT_AND_BACK, glPolygonModeValues[current->polygonMode = state->polygonMode]);

		R_TraceLogAPICall("glPolygonMode(%s)", txtPolygonModeValues[state->polygonMode]);
	}
	if (state->clearColor[0] != current->clearColor[0] || state->clearColor[1] != current->clearColor[1] || state->clearColor[2] != current->clearColor[2] || state->clearColor[3] != current->clearColor[3]) {
		glClearColor(
			current->clearColor[0] = state->clearColor[0],
			current->clearColor[1] = state->clearColor[1],
			current->clearColor[2] = state->clearColor[2],
			current->clearColor[3] = state->clearColor[3]
		);
		R_TraceLogAPICall("glClearColor(...)");
	}
	GL_ApplySimpleToggle(state, current, blendingEnabled, GL_BLEND);
	if (state->colorMask[0] != current->colorMask[0] || state->colorMask[1] != current->colorMask[1] || state->colorMask[2] != current->colorMask[2] || state->colorMask[3] != current->colorMask[3]) {
		glColorMask(
			(current->colorMask[0] = state->colorMask[0]) ? GL_TRUE : GL_FALSE,
			(current->colorMask[1] = state->colorMask[1]) ? GL_TRUE : GL_FALSE,
			(current->colorMask[2] = state->colorMask[2]) ? GL_TRUE : GL_FALSE,
			(current->colorMask[3] = state->colorMask[3]) ? GL_TRUE : GL_FALSE
		);
		R_TraceLogAPICall("glColorMask(%s,%s,%s,%s)", state->colorMask[0] ? "on" : "off", state->colorMask[1] ? "on" : "off", state->colorMask[2] ? "on" : "off", state->colorMask[3] ? "on" : "off");
	}
	if (buffers.supported && (state->vao_id != currentVAO || current->glc_vao_force_rebind)) {
		R_BindVertexArray(state->vao_id);
	}

#ifdef WITH_RENDERING_TRACE
	R_TraceDebugState();
#endif
	R_TraceLeaveRegion(true);
}

// vid_common_gl.c
// gl_texture.c
GLuint GL_TextureNameFromReference(texture_ref ref);
GLenum GL_TextureTargetFromReference(texture_ref ref);

void GL_BindTextureToTarget(GLenum textureUnit, GLenum targetType, GLuint name)
{
	GL_SelectTexture(textureUnit);
	GL_BindTexture(targetType, name, true);
}

r_texture_type_id GL_TargetTypeToTextureType(GLuint targetType)
{
	if (targetType == GL_TEXTURE_2D_ARRAY) {
		return texture_type_2d_array;
	}
	else if (targetType == GL_TEXTURE_2D) {
		return texture_type_2d;
	}
	else if (targetType == GL_TEXTURE_CUBE_MAP) {
		return texture_type_cubemap;
	}
	else if (targetType == GL_TEXTURE_2D_MULTISAMPLE) {
		return texture_type_2d_multisampled;
	}
	else {
		Sys_Error("GL_TargetTypeToTextureType(%x) - unsupported", targetType);
		return 0;
	}
}

qbool GL_IsTextureBound(GLuint unit, texture_ref reference)
{
	int unit_num = unit - GL_TEXTURE0;
	GLuint texture = GL_TextureNameFromReference(reference);
	GLenum targetType = GL_TextureTargetFromReference(reference);

	if (unit_num >= 0 && unit_num < sizeof(bound_texture_state) / sizeof(bound_texture_state[0])) {
		return bound_texture_state[GL_TargetTypeToTextureType(targetType)][unit_num] == texture;
	}
	return false;
}

static qbool GL_BindTextureUnitImpl(GLuint unit, texture_ref reference, qbool always_select_unit)
{
	int unit_num = unit - GL_TEXTURE0;
	GLuint texture = GL_TextureNameFromReference(reference);
	GLenum targetType = GL_TextureTargetFromReference(reference);

	if (unit_num >= 0 && unit_num < sizeof(bound_texture_state) / sizeof(bound_texture_state[0])) {
		qbool bound = (bound_texture_state[GL_TargetTypeToTextureType(targetType)][unit_num] == texture);
		if (bound) {
			if (always_select_unit) {
				GL_SelectTexture(unit);
			}
			return false;
		}
	}

	GL_SelectTexture(unit);
	GL_BindTexture(targetType, texture, true);
	return true;
}

#ifdef RENDERER_OPTION_MODERN_OPENGL
void GLM_ApplyRenderingState(r_state_id id)
{
	GL_ApplyRenderingState(id);
}
#endif

qbool GL_EnsureTextureUnitBound(int unit, texture_ref reference)
{
	return GL_BindTextureUnitImpl(GL_TEXTURE0 + unit, reference, false);
}

qbool GL_EnsureTextureUnitBoundAndSelect(int unit, texture_ref reference)
{
	return GL_BindTextureUnitImpl(GL_TEXTURE0 + unit, reference, true);
}

void GL_BindTextureUnit(GLuint unit, texture_ref reference)
{
	GL_BindTextureUnitImpl(unit, reference, true);
}

void R_Viewport(int x, int y, int width, int height)
{
	rendering_state_t* state = &opengl.rendering_state;

	if (x != state->currentViewportX || y != state->currentViewportY || width != state->currentViewportWidth || height != state->currentViewportHeight) {
		renderer.Viewport(x, y, width, height);

		state->currentViewportX = x;
		state->currentViewportY = y;
		state->currentViewportWidth = width;
		state->currentViewportHeight = height;
	}
}

void R_GetViewport(int* view)
{
	rendering_state_t* state = &opengl.rendering_state;

	view[0] = state->currentViewportX;
	view[1] = state->currentViewportY;
	view[2] = state->currentViewportWidth;
	view[3] = state->currentViewportHeight;
}

void R_SetFullScreenViewport(int x, int y, int width, int height)
{
	rendering_state_t* state = &opengl.rendering_state;

	state->fullScreenViewportX = x;
	state->fullScreenViewportY = y;
	state->fullScreenViewportWidth = width;
	state->fullScreenViewportHeight = height;
}

void R_GetFullScreenViewport(int* viewport)
{
	rendering_state_t* state = &opengl.rendering_state;

	viewport[0] = state->fullScreenViewportX;
	viewport[1] = state->fullScreenViewportY;
	viewport[2] = state->fullScreenViewportWidth;
	viewport[3] = state->fullScreenViewportHeight;
}

void GL_InitialiseState(void)
{
	R_InitRenderingState(r_state_default_opengl, false, "opengl", vao_none);
	opengl.rendering_state = states[r_state_default_opengl];
	R_InitialiseStates();

	R_SetIdentityMatrix(R_ProjectionMatrix());
	R_SetIdentityMatrix(R_ModelviewMatrix());

	memset(bound_texture_state, 0, sizeof(bound_texture_state));
	memset(bound_images, 0, sizeof(bound_images));

	if (buffers.supported) {
		buffers.InitialiseState();
	}
	R_ProgramInitialiseState();
}

// These functions taken from gl_texture.c
static void GL_BindTexture(GLenum targetType, GLuint texnum, qbool warning)
{
	r_texture_type_id texture_type = GL_TargetTypeToTextureType(targetType);

	assert(targetType);
	assert(texnum);

	if (bound_texture_state[texture_type][currentTextureUnit - GL_TEXTURE0] == texnum) {
		return;
	}

	R_TraceLogAPICall("glBindTexture(unit=GL_TEXTURE%d, target=%s, texnum=%u[%s])", currentTextureUnit - GL_TEXTURE0, gl_friendlyTextureTargetNames[texture_type], texnum, GL_TextureIdentifierByGLReference(texnum));

	GL_BuiltinProcedure(glBindTexture, "target=%u, texnum=%u", targetType, texnum);
	bound_texture_state[texture_type][currentTextureUnit - GL_TEXTURE0] = texnum;

	++frameStats.texture_binds;
}

void GL_SelectTexture(GLenum textureUnit)
{
	if (textureUnit == currentTextureUnit) {
		return;
	}

	R_TraceLogAPICall("glActiveTexture(GL_TEXTURE%d)", textureUnit - GL_TEXTURE0);
	if (GL_Available(glActiveTexture)) {
		GL_Procedure(glActiveTexture, textureUnit);
	}

	currentTextureUnit = textureUnit;
}

void GL_TextureInitialiseState(void)
{
	// Multi texture.
	currentTextureUnit = GL_TEXTURE0;

	memset(bound_images, 0, sizeof(bound_images));
	memset(bound_texture_state, 0, sizeof(bound_texture_state));

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	{
		int i;
		for (i = 0; i < sizeof(opengl.rendering_state.textureUnits) / sizeof(opengl.rendering_state.textureUnits[0]); ++i) {
			opengl.rendering_state.textureUnits[i].enabled = false;
			opengl.rendering_state.textureUnits[i].mode = GL_MODULATE;
		}
	}
#endif
}

void GL_InvalidateTextureReferences(GLuint texture)
{
	int i, j;

	// glDeleteTextures(texture) has been called - same reference might be re-used in future
	// If a texture that is currently bound is deleted, the binding reverts to 0 (the default texture)
	for (i = 0; i < sizeof(bound_texture_state) / sizeof(bound_texture_state[0]); ++i) {
		for (j = 0; j < sizeof(bound_texture_state[0]) / sizeof(bound_texture_state[0][0]); ++j) {
			if (bound_texture_state[i][j] == texture) {
				bound_texture_state[i][j] = 0;
			}
		}
	}

	for (i = 0; i < sizeof(bound_images) / sizeof(bound_images[0]); ++i) {
		if (bound_images[i].texture == texture) {
			bound_images[i].texture = 0;
		}
	}
}

void GL_TextureUnitMultiBind(int first, int count, texture_ref* textures)
{
	GLuint glTextures[MAX_LOGGED_TEXTURE_UNITS] = { 0 };
	GLuint postbind_texture_state[texture_type_count][MAX_LOGGED_TEXTURE_UNITS];
	qbool already_bound[MAX_LOGGED_TEXTURE_UNITS] = { false };
	//r_texture_type_id types[MAX_LOGGED_TEXTURE_UNITS] = { 0 };
	qbool multi = false;
	int i, j, first_to_change = -1;

	if (first + count > MAX_LOGGED_TEXTURE_UNITS) {
		Sys_Error("GL_TextureUnitMultiBind(first=%d, count=%d)... not supported", first, count);
		return;
	}

	// assume no change
	memcpy(postbind_texture_state, bound_texture_state, sizeof(postbind_texture_state));

	// find out which texture units we need to change
	for (i = 0; i < count; ++i) {
		int unit = first + i;

		glTextures[i] = GL_TextureNameFromReference(textures[i]);
		already_bound[i] = true;

		if (glTextures[i] == 0) {
			// unbind from all targets...
			for (j = 0; j < sizeof(postbind_texture_state) / sizeof(postbind_texture_state[0]); ++j) {
				if (postbind_texture_state[j][unit]) {
					postbind_texture_state[j][unit] = 0;
					multi = (first_to_change >= 0);
					first_to_change = (first_to_change < 0 ? i : first_to_change);
					already_bound[i] = false;
				}
			}
		}
		else {
			GLenum target = GL_TextureTargetFromReference(textures[i]);
			r_texture_type_id type = GL_TargetTypeToTextureType(target);

			already_bound[i] = (bound_texture_state[type][unit] == glTextures[i]);
			if (!already_bound[i]) {
				first_to_change = (first_to_change < 0 ? i : first_to_change);
				multi = (first_to_change >= 0);
				postbind_texture_state[type][unit] = glTextures[i];
			}
		}
	}

	if (multi && GL_Available(glBindTextures)) {
		GL_Procedure(glBindTextures, first, count, glTextures);

#ifdef WITH_RENDERING_TRACE
		if (R_TraceLoggingEnabled()) {
			static char temp[1024];

			temp[0] = '\0';
			for (i = 0; i < count; ++i) {
				if (i) {
					strlcat(temp, ",", sizeof(temp));
				}
				strlcat(temp, R_TextureIdentifier(textures[i]), sizeof(temp));
			}
			R_TraceLogAPICall("glBindTextures(GL_TEXTURE%d, %d[%s])", first, count, temp);
		}
#endif
	}
	else if (multi) {
		for (i = 0; i < count; ++i) {
			if (!already_bound[i]) {
				renderer.TextureUnitBind(first + i, textures[i]);
			}
		}
	}
	else if (first_to_change >= 0) {
		renderer.TextureUnitBind(first + first_to_change, textures[first_to_change]);
	}
	memcpy(bound_texture_state, postbind_texture_state, sizeof(bound_texture_state));
}

void GL_BindImageTexture(GLuint unit, texture_ref texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
{
	GLuint glRef = 0;

	if (R_TextureReferenceIsValid(texture)) {
		glRef = GL_TextureNameFromReference(texture);

		if (unit < MAX_LOGGED_IMAGE_UNITS) {
			if (bound_images[unit].texture == glRef && bound_images[unit].level == level && bound_images[unit].layered == layered && bound_images[unit].layer == layer && bound_images[unit].access == access && bound_images[unit].format == format) {
				return;
			}

			bound_images[unit].texture = glRef;
			bound_images[unit].level = level;
			bound_images[unit].layered = layered;
			bound_images[unit].layer = layer;
			bound_images[unit].access = access;
			bound_images[unit].format = format;
		}
	}
	else {
		if (unit < MAX_LOGGED_IMAGE_UNITS) {
			memset(&bound_images[unit], 0, sizeof(bound_images[unit]));
		}
	}

	GL_Procedure(glBindImageTexture, unit, glRef, level, layered, layer, access, format);
}

#ifdef WITH_RENDERING_TRACE
void R_TracePrintState(FILE* debug_frame_out, int debug_frame_depth)
{
// meag: disabled just for clarity, only enable if you fear the states aren't being reset correctly
//       less useful now we have all the states enumerated, the state manager should be setting everything
#if 0
	debug_frame_depth += 7;

	if (debug_frame_out) {
		rendering_state_t* current = &opengl.rendering_state;

		fprintf(debug_frame_out, "%.*s <state-dump>\n", debug_frame_depth, "                                                          ");
		fprintf(debug_frame_out, "%.*s   Z-Buffer: %s, func %s range %f=>%f [mask %s]\n", debug_frame_depth, "                                                          ", current->depth.test_enabled ? "on" : "off", txtDepthFunctions[current->depth.func], current->depth.nearRange, current->depth.farRange, current->depth.mask_enabled ? "on" : "off");
		fprintf(debug_frame_out, "%.*s   Cull-face: %s, mode %s\n", debug_frame_depth, "                                                          ", current->cullface.enabled ? "enabled" : "disabled", txtCullFaceValues[current->cullface.mode]);
		fprintf(debug_frame_out, "%.*s   Blending: %s, func %s\n", debug_frame_depth, "                                                          ", current->blendingEnabled ? "enabled" : "disabled", txtBlendFuncNames[current->blendFunc]);
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
		fprintf(debug_frame_out, "%.*s   AlphaTest: %s", debug_frame_depth, "                                                          ", current->alphaTesting.enabled ? "on" : "off");
		if (current->alphaTesting.enabled) {
			fprintf(debug_frame_out, "func %s(%f)\n", txtAlphaTestModeValues[current->alphaTesting.func], current->alphaTesting.value);
		}
		else {
			fprintf(debug_frame_out, "\n");
		}
		fprintf(debug_frame_out, "%.*s   Texture units: [", debug_frame_depth, "                                                          ");
		{
			int i;

			for (i = 0; i < sizeof(current->textureUnits) / sizeof(current->textureUnits[0]); ++i) {
				fprintf(debug_frame_out, "%s", i ? "," : "");
				if (current->textureUnits[i].enabled && bound_textures[i]) {
					fprintf(debug_frame_out, "%s(%s)", txtTextureEnvModeValues[current->textureUnits[i].mode], GL_TextureIdentifierByGLReference(bound_textures[i]));
				}
				else if (current->textureUnits[i].enabled) {
					fprintf(debug_frame_out, "%s(<null>)", txtTextureEnvModeValues[current->textureUnits[i].mode]);
				}
				else {
					fprintf(debug_frame_out, "<off>");
				}
			}
		}
		fprintf(debug_frame_out, "]\n");
		{
			float matrix[16];
			int i;

			R_GetModelviewMatrix(matrix);
			fprintf(debug_frame_out, "%.*s   Modelview matrix:\n", debug_frame_depth, "                                                          ");
			for (i = 0; i < 16; i += 4) {
				fprintf(debug_frame_out, "%.*s       [%8.5f %8.5f %8.5f %8.5f]\n", debug_frame_depth, "                                                          ", matrix[i + 0], matrix[i + 1], matrix[i + 2], matrix[i + 3]);
			}

			R_GetProjectionMatrix(matrix);
			fprintf(debug_frame_out, "%.*s   Projection matrix:\n", debug_frame_depth, "                                                          ");
			for (i = 0; i < 16; i += 4) {
				fprintf(debug_frame_out, "%.*s       [%8.5f %8.5f %8.5f %8.5f]\n", debug_frame_depth, "                                                          ", matrix[i + 0], matrix[i + 1], matrix[i + 2], matrix[i + 3]);
			}
		}
#endif
		fprintf(debug_frame_out, "%.*s   glPolygonMode: %s\n", debug_frame_depth, "                                                          ", txtPolygonModeValues[current->polygonMode]);
		fprintf(debug_frame_out, "%.*s   vao: %s\n", debug_frame_depth, "                                                          ", vaoNames[currentVAO]);
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
		if (R_VAOBound() && R_UseImmediateOpenGL()) {
			GLC_PrintVAOState(debug_frame_out, debug_frame_depth, currentVAO);
		}
#endif
		if (buffers.PrintState) {
			buffers.PrintState(debug_frame_out, debug_frame_depth);
		}
		fprintf(debug_frame_out, "%.*s </state-dump>\n", debug_frame_depth, "                                                          ");
	}
#endif
}
#endif

void GL_LoadStateFunctions(void)
{
	glConfig.supported_features &= ~(R_SUPPORT_MULTITEXTURING | R_SUPPORT_IMAGE_PROCESSING);

	GL_LoadOptionalFunction(glActiveTexture);
	glConfig.supported_features |= (GL_Available(glActiveTexture) ? R_SUPPORT_MULTITEXTURING : 0);

	if (GL_VersionAtLeast(4, 2) || SDL_GL_ExtensionSupported("GL_ARB_shader_image_load_store")) {
		GL_LoadOptionalFunction(glBindImageTexture);
		glConfig.supported_features |= (GL_Available(glBindImageTexture) ? R_SUPPORT_IMAGE_PROCESSING : 0);
	} else {
		GL_InvalidateFunction(glBindImageTexture);
	}

	// 4.4 - binds textures to consecutive texture units
	GL_InvalidateFunction(glBindTextures);
	if ((GL_VersionAtLeast(4, 4) || SDL_GL_ExtensionSupported("GL_ARB_multi_bind")) && !COM_CheckParm(cmdline_param_client_nomultibind)) {
		GL_LoadOptionalFunction(glBindTextures);

		// Invalidate if on particular drivers (see github bug #416)
		if (GL_Available(glBindTextures) && glConfig.amd_issues) {
			GL_InvalidateFunction(glBindTextures);
			glConfig.broken_features |= R_BROKEN_GLBINDTEXTURES;
		}
	}
}

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
void GLC_ClientActiveTexture(GLenum texture_unit)
{
	if (GL_Available(glClientActiveTexture)) {
		GL_Procedure(glClientActiveTexture, texture_unit);
	}
	else {
		assert(texture_unit == GL_TEXTURE0);
	}
}
#endif // RENDERER_OPTION_CLASSIC_OPENGL

void R_ApplyRenderingState(r_state_id state)
{
	assert(state != r_state_null);
	if (!state) {
		Con_Printf("ERROR: NULL rendering state\n");
		return;
	}
	assert(states[state].initialized);

	renderer.ApplyRenderingState(state);
}

void R_CustomColor(float r, float g, float b, float a)
{
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		if (!opengl.rendering_state.colorValid || opengl.rendering_state.color[0] != r || opengl.rendering_state.color[1] != g || opengl.rendering_state.color[2] != b || opengl.rendering_state.color[3] != a) {
			glColor4f(
				opengl.rendering_state.color[0] = r,
				opengl.rendering_state.color[1] = g,
				opengl.rendering_state.color[2] = b,
				opengl.rendering_state.color[3] = a
			);
			opengl.rendering_state.colorValid = true;
		}
	}
#endif
}

void R_CustomLineWidth(float width)
{
	if (width != opengl.rendering_state.line.width) {
		if (R_UseImmediateOpenGL() || R_UseModernOpenGL()) {
			glLineWidth(opengl.rendering_state.line.width = width);
			R_TraceLogAPICall("glLineWidth(%f)", width);
		}
		else if (R_UseVulkan()) {
			// Requires VK_DYNAMIC_STATE_LINE_WIDTH
			// Requires wide lines feature (if not, must be 1)

			// vkCmdSetLineWidth(commandBuffer, width)
			opengl.rendering_state.line.width = width;
		}
	}
}

void R_CustomPolygonOffset(r_polygonoffset_t mode)
{
	rendering_state_t* current = &opengl.rendering_state;

	if (mode != current->polygonOffset.option) {
		extern cvar_t gl_brush_polygonoffset, gl_brush_polygonoffset_factor;

		float factor = (mode == r_polygonoffset_standard ? bound(-1, gl_brush_polygonoffset_factor.value, 1) : 1);
		float units = (mode == r_polygonoffset_standard ? bound(0, gl_brush_polygonoffset.value, 2) : 1);
		qbool enabled = (mode == r_polygonoffset_standard || mode == r_polygonoffset_outlines) && units != 0;

		if (enabled) {
			if (!current->polygonOffset.fillEnabled) {
				glEnable(GL_POLYGON_OFFSET_FILL);
				R_TraceLogAPICall("glEnable(GL_POLYGON_OFFSET_FILL)");
				current->polygonOffset.fillEnabled = true;
			}
			if (!current->polygonOffset.lineEnabled) {
				glEnable(GL_POLYGON_OFFSET_LINE);
				R_TraceLogAPICall("glEnable(GL_POLYGON_OFFSET_LINE)");
				current->polygonOffset.lineEnabled = true;
			}

			if (current->polygonOffset.factor != factor || current->polygonOffset.units != units) {
				glPolygonOffset(factor, units);
				R_TraceLogAPICall("glPolygonOffset(factor %f, units %f)", factor, units);

				current->polygonOffset.factor = factor;
				current->polygonOffset.units = units;
			}
		}
		else {
			if (current->polygonOffset.fillEnabled) {
				glDisable(GL_POLYGON_OFFSET_FILL);
				R_TraceLogAPICall("glDisable(GL_POLYGON_OFFSET_FILL)");
				current->polygonOffset.fillEnabled = false;
			}
			if (current->polygonOffset.lineEnabled) {
				glDisable(GL_POLYGON_OFFSET_LINE);
				R_TraceLogAPICall("glDisable(GL_POLYGON_OFFSET_LINE)");
				current->polygonOffset.lineEnabled = false;
			}
		}
		current->polygonOffset.option = mode;
	}
}

void R_CustomColor4ubv(const byte* color)
{
	float r = color[0] / 255.0f;
	float g = color[1] / 255.0f;
	float b = color[2] / 255.0f;
	float a = color[3] / 255.0f;

	R_CustomColor(r, g, b, a);
}

void R_EnableScissorTest(int x, int y, int width, int height)
{
	if (R_UseImmediateOpenGL() || R_UseModernOpenGL()) {
		glEnable(GL_SCISSOR_TEST);
		glScissor(x, y, width, height);
	}
}

void R_DisableScissorTest(void)
{
	if (R_UseImmediateOpenGL() || R_UseModernOpenGL()) {
		glDisable(GL_SCISSOR_TEST);
	}
}

void R_ClearColor(float r, float g, float b, float a)
{
	if (R_UseImmediateOpenGL()) {
		glClearColor(
			opengl.rendering_state.clearColor[0] = r,
			opengl.rendering_state.clearColor[1] = g,
			opengl.rendering_state.clearColor[2] = b,
			opengl.rendering_state.clearColor[3] = a
		);
	}
	else if (R_UseModernOpenGL()) {
		glClearColor(
			opengl.rendering_state.clearColor[0] = r,
			opengl.rendering_state.clearColor[1] = g,
			opengl.rendering_state.clearColor[2] = b,
			opengl.rendering_state.clearColor[3] = a
		);
	}
}

rendering_state_t* R_CopyRenderingState(r_state_id dest_id, r_state_id source_id, const char* name)
{
	rendering_state_t* state = &states[dest_id];
	const rendering_state_t* src = &states[source_id];

	memcpy(state, src, sizeof(*state));
	strlcpy(state->name, name, sizeof(state->name));
	return state;
}

void R_InitialiseVAOState(void)
{
	currentVAO = vao_none;
}

qbool R_VertexArrayCreated(r_vao_id vao)
{
	return renderer.VertexArrayCreated(vao);
}

void R_BindVertexArray(r_vao_id vao)
{
	if (currentVAO != vao || opengl.rendering_state.glc_vao_force_rebind) {
		R_TraceEnterRegion(va("R_BindVertexArray(%s)", vaoNames[vao]), true);

		assert(vao == vao_none || R_VertexArrayCreated(vao));

		renderer.BindVertexArray(vao);

		currentVAO = vao;
		opengl.rendering_state.glc_vao_force_rebind = false;
		R_TraceLeaveRegion(true);
	}
}

void R_GenVertexArray(r_vao_id vao)
{
	renderer.GenVertexArray(vao, vaoNames[vao]);
}

qbool R_VAOBound(void)
{
	return currentVAO != vao_none;
}

void R_BindVertexArrayElementBuffer(r_buffer_id ref)
{
	if (currentVAO != vao_none) {
		renderer.BindVertexArrayElementBuffer(currentVAO, ref);
	}
}

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
void R_GLC_VertexPointer(r_buffer_id buf, qbool enabled, int size, GLenum type, int stride, void* pointer_or_offset)
{
	if (enabled) {
		glc_vertex_array_element_t* array = &opengl.rendering_state.vertex_array;

		if (R_BufferReferenceIsValid(buf)) {
			buffers.Bind(buf);
		}
		else {
			buffers.UnBind(buffertype_vertex);
		}

		if (!R_BufferReferencesEqual(buf, array->buf) || size != array->size || type != array->type || stride != array->stride || pointer_or_offset != array->pointer_or_offset) {
			glVertexPointer(array->size = size, array->type = type, array->stride = stride, array->pointer_or_offset = pointer_or_offset);
			array->buf = buf;
			R_TraceLogAPICall("glVertexPointer(size %d, type %s, stride %d, ptr %p)", size, type == GL_FLOAT ? "FLOAT" : type == GL_UNSIGNED_BYTE ? "UBYTE" : "???", stride, pointer_or_offset);
		}
		if (!opengl.rendering_state.vertex_array.enabled) {
			glEnableClientState(GL_VERTEX_ARRAY);
			R_TraceLogAPICall("glEnableClientState(GL_VERTEX_ARRAY)");
			opengl.rendering_state.vertex_array.enabled = true;
		}
	}
	else if (!enabled && opengl.rendering_state.vertex_array.enabled) {
		glDisableClientState(GL_VERTEX_ARRAY);
		R_TraceLogAPICall("glDisableClientState(GL_VERTEX_ARRAY)");
		opengl.rendering_state.vertex_array.enabled = false;
	}
}

void R_GLC_ColorPointer(r_buffer_id buf, qbool enabled, int size, GLenum type, int stride, void* pointer_or_offset)
{
	if (enabled) {
		glc_vertex_array_element_t* array = &opengl.rendering_state.color_array;

		if (R_BufferReferenceIsValid(buf)) {
			buffers.Bind(buf);
		}
		else {
			buffers.UnBind(buffertype_vertex);
		}

		if (!R_BufferReferencesEqual(buf, array->buf) || size != array->size || type != array->type || stride != array->stride || pointer_or_offset != array->pointer_or_offset) {
			glColorPointer(array->size = size, array->type = type, array->stride = stride, array->pointer_or_offset = pointer_or_offset);
			R_TraceLogAPICall("glColorPointer(size %d, type %s, stride %d, ptr %p)", size, type == GL_FLOAT ? "FLOAT" : type == GL_UNSIGNED_BYTE ? "UBYTE" : "???", stride, pointer_or_offset);
		}
		if (!opengl.rendering_state.color_array.enabled) {
			glEnableClientState(GL_COLOR_ARRAY);
			R_TraceLogAPICall("glEnableClientState(GL_COLOR_ARRAY)");
			opengl.rendering_state.colorValid = false;
			opengl.rendering_state.color_array.enabled = true;
		}
	}
	else if (!enabled && opengl.rendering_state.color_array.enabled) {
		glDisableClientState(GL_COLOR_ARRAY);
		R_TraceLogAPICall("glDisableClientState(GL_COLOR_ARRAY)");
		opengl.rendering_state.colorValid = false;
		opengl.rendering_state.color_array.enabled = false;
	}
}

void R_GLC_NormalPointer(r_buffer_id buf, qbool enabled, int size, GLenum type, int stride, void* pointer_or_offset)
{
	if (enabled) {
		glc_vertex_array_element_t* array = &opengl.rendering_state.normal_array;

		if (R_BufferReferenceIsValid(buf)) {
			buffers.Bind(buf);
		}
		else {
			buffers.UnBind(buffertype_vertex);
		}

		if (!R_BufferReferencesEqual(buf, array->buf) || size != array->size || type != array->type || stride != array->stride || pointer_or_offset != array->pointer_or_offset) {
			glNormalPointer(array->type = type, array->stride = stride, array->pointer_or_offset = pointer_or_offset);
			array->size = size;
			R_TraceLogAPICall("glColorPointer(size %d, type %s, stride %d, ptr %p)", size, type == GL_FLOAT ? "FLOAT" : type == GL_UNSIGNED_BYTE ? "UBYTE" : "???", stride, pointer_or_offset);
		}
		if (!opengl.rendering_state.normal_array.enabled) {
			glEnableClientState(GL_NORMAL_ARRAY);
			R_TraceLogAPICall("glEnableClientState(GL_NORMAL_ARRAY)");
			opengl.rendering_state.normal_array.enabled = true;
		}
	}
	else if (!enabled && opengl.rendering_state.normal_array.enabled) {
		glDisableClientState(GL_NORMAL_ARRAY);
		R_TraceLogAPICall("glDisableClientState(GL_NORMAL_ARRAY)");
		opengl.rendering_state.normal_array.enabled = false;
	}
}

void R_GLC_DisableColorPointer(void)
{
	if (opengl.rendering_state.color_array.enabled) {
		glDisableClientState(GL_COLOR_ARRAY);
		R_TraceLogAPICall("glDisableClientState(GL_COLOR_ARRAY)");
		opengl.rendering_state.colorValid = false;
		opengl.rendering_state.color_array.enabled = false;
		opengl.rendering_state.glc_vao_force_rebind = true;
	}
}

void R_GLC_DisableTexturePointer(int unit)
{
	if (unit < 0 || unit >= sizeof(opengl.rendering_state.textureUnits) / sizeof(opengl.rendering_state.textureUnits[0])) {
		return;
	}

	if (opengl.rendering_state.textureUnits[unit].va.enabled) {
		GLC_ClientActiveTexture(GL_TEXTURE0 + unit);
		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
		R_TraceLogAPICall("glDisableClientState[unit %d](GL_TEXTURE_COORD_ARRAY)", unit);
		opengl.rendering_state.textureUnits[unit].va.enabled = false;
		opengl.rendering_state.glc_vao_force_rebind = true;
	}
}

void R_GLC_TexturePointer(r_buffer_id buf, int unit, qbool enabled, int size, GLenum type, int stride, void* pointer_or_offset)
{
	if (unit < 0 || unit >= sizeof(opengl.rendering_state.textureUnits) / sizeof(opengl.rendering_state.textureUnits[0])) {
		return;
	}

	if (enabled) {
		glc_vertex_array_element_t* array = &opengl.rendering_state.textureUnits[unit].va;
		qbool pointer_call_needed = (!R_BufferReferencesEqual(buf, array->buf) || size != array->size || type != array->type || stride != array->stride || pointer_or_offset != array->pointer_or_offset);

		if (R_BufferReferenceIsValid(buf)) {
			buffers.Bind(buf);
		}
		else {
			buffers.UnBind(buffertype_vertex);
		}

		if (!array->enabled || pointer_call_needed) {
			GLC_ClientActiveTexture(GL_TEXTURE0 + unit);
		}
		if (pointer_call_needed) {
			glTexCoordPointer(array->size = size, array->type = type, array->stride = stride, array->pointer_or_offset = pointer_or_offset);
			array->buf = buf;
			R_TraceLogAPICall("glTexCoordPointer[unit %d](size %d, type %s, stride %d, ptr %p)", unit, size, type == GL_FLOAT ? "FLOAT" : type == GL_UNSIGNED_BYTE ? "UBYTE" : "???", stride, pointer_or_offset);
		}
		if (!array->enabled) {
			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
			R_TraceLogAPICall("glEnableClientState[unit %d](GL_TEXTURE_COORD_ARRAY)", unit);
			array->enabled = true;
		}
	}
	else if (!enabled) {
		R_GLC_DisableTexturePointer(unit);
	}
}

void GLC_CustomAlphaTesting(qbool enabled)
{
	rendering_state_t state;
	rendering_state_t* current = &opengl.rendering_state;

	if (enabled) {
		R_GLC_ConfigureAlphaTesting(&state, true, r_alphatest_func_greater, 0.333f);
	}
	else {
		R_GLC_ConfigureAlphaTesting(&state, false, r_alphatest_func_always, 0);
	}

	GLC_ToggleAlphaTesting(&state, current);
}

static void GLC_ToggleAlphaTesting(const rendering_state_t* state, rendering_state_t* current)
{
	GL_ApplySimpleToggle(state, current, alphaTesting.enabled, GL_ALPHA_TEST);
	if (current->alphaTesting.enabled && (state->alphaTesting.func != current->alphaTesting.func || state->alphaTesting.value != current->alphaTesting.value)) {
		glAlphaFunc(
			glAlphaTestModeValues[current->alphaTesting.func = state->alphaTesting.func],
			current->alphaTesting.value = state->alphaTesting.value
		);
		R_TraceLogAPICall("glAlphaFunc(%s %f)", txtAlphaTestModeValues[state->alphaTesting.func], state->alphaTesting.value);
	}
}

void GLC_ApplyRenderingState(r_state_id id)
{
	rendering_state_t* current = &opengl.rendering_state;
	rendering_state_t* state = &states[id];
	int i;

	GL_ProcessErrors("Pre-GLC_ApplyRenderingState()");
	R_TraceEnterRegion(va("GLC_ApplyRenderingState(%s)", state->name), true);

	// Alpha-testing
	GLC_ToggleAlphaTesting(state, current);

	// Texture units
	for (i = 0; i < sizeof(current->textureUnits) / sizeof(current->textureUnits[0]) && i < glConfig.texture_units; ++i) {
		if (state->textureUnits[i].enabled != current->textureUnits[i].enabled) {
			if ((current->textureUnits[i].enabled = state->textureUnits[i].enabled)) {
				R_TraceLogAPICall("Enabling texturing on unit %d", i);
				GL_SelectTexture(GL_TEXTURE0 + i);
				glEnable(GL_TEXTURE_2D);
				if (state->textureUnits[i].mode != current->textureUnits[i].mode) {
					R_TraceLogAPICall("texture unit mode[%d] = %s", i, txtTextureEnvModeValues[state->textureUnits[i].mode]);
					glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, glTextureEnvModeValues[current->textureUnits[i].mode = state->textureUnits[i].mode]);
				}
			}
			else {
				R_TraceLogAPICall("Disabling texturing on unit %d", i);
				GL_SelectTexture(GL_TEXTURE0 + i);
				glDisable(GL_TEXTURE_2D);
			}
		}
		else if (current->textureUnits[i].enabled && state->textureUnits[i].mode != current->textureUnits[i].mode) {
			R_TraceLogAPICall("texture unit mode[%d] = %s", i, txtTextureEnvModeValues[state->textureUnits[i].mode]);
			GL_SelectTexture(GL_TEXTURE0 + i);
			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, glTextureEnvModeValues[current->textureUnits[i].mode = state->textureUnits[i].mode]);
		}
	}
	GL_ProcessErrors("Post-GLC_ApplyRenderingState(texture-units)");

	// Color
	if (!current->colorValid || current->color[0] != state->color[0] || current->color[1] != state->color[1] || current->color[2] != state->color[2] || current->color[3] != state->color[3]) {
		glColor4f(
			current->color[0] = state->color[0],
			current->color[1] = state->color[1],
			current->color[2] = state->color[2],
			current->color[3] = state->color[3]
		);
		R_TraceLogAPICall("glColor4f(%f %f %f %f)", state->color[0], state->color[1], state->color[2], state->color[3]);
		current->colorValid = true;
	}

	// Fog
	if (r_refdef2.fog_render) {
		if (state->fog.mode == r_fogmode_disabled && current->fog.mode != r_fogmode_disabled) {
			current->fog.mode = r_fogmode_disabled;
			glDisable(GL_FOG);
			R_TraceLogAPICall("glDisable(GL_FOG)");
		}
		else if (state->fog.mode == r_fogmode_enabled) {
			if (current->fog.mode != r_fogmode_enabled) {
				current->fog.mode = r_fogmode_enabled;
				glEnable(GL_FOG);
				if (r_refdef2.fog_calculation == fogcalc_linear) {
					if (current->fog.calculation != r_refdef2.fog_calculation) {
						glFogi(GL_FOG_MODE, GL_LINEAR);
						current->fog.calculation = r_refdef2.fog_calculation;
					}
					if (current->fog.start != r_refdef2.fog_linear_start) {
						glFogf(GL_FOG_START, r_refdef2.fog_linear_start);
						current->fog.start = r_refdef2.fog_linear_start;
					}
					if (current->fog.end != r_refdef2.fog_linear_end) {
						glFogf(GL_FOG_END, r_refdef2.fog_linear_end);
						current->fog.end = r_refdef2.fog_linear_end;
					}
				}
				else if (r_refdef2.fog_calculation == fogcalc_exp) {
					if (current->fog.calculation != r_refdef2.fog_calculation) {
						glFogi(GL_FOG_MODE, GL_EXP);
						current->fog.calculation = r_refdef2.fog_calculation;
					}
					if (current->fog.density != r_refdef2.fog_density) {
						glFogf(GL_FOG_DENSITY, r_refdef2.fog_density);
						current->fog.density = r_refdef2.fog_density;
					}
				}
				else if (r_refdef2.fog_calculation == fogcalc_exp2) {
					if (current->fog.calculation != r_refdef2.fog_calculation) {
						glFogi(GL_FOG_MODE, GL_EXP2);
						current->fog.calculation = r_refdef2.fog_calculation;
					}
					if (current->fog.density != r_refdef2.fog_density) {
						glFogf(GL_FOG_DENSITY, r_refdef2.fog_density);
						current->fog.density = r_refdef2.fog_density;
					}
				}
				R_TraceLogAPICall("glEnable(GL_FOG)");
			}
			if (memcmp(current->fog.color, r_refdef2.fog_color, sizeof(current->fog.color))) {
				glFogfv(GL_FOG_COLOR, r_refdef2.fog_color);
				memcpy(current->fog.color, r_refdef2.fog_color, sizeof(current->fog.color));
				R_TraceLogAPICall("glFogfv(GL_FOG_COLOR, [%d %d %d %d])", (int)(current->fog.color[0] * 255), (int)(current->fog.color[1] * 255), (int)(current->fog.color[2] * 255), (int)(current->fog.color[3] * 255));
			}
		}
	}
	else if (current->fog.mode != r_fogmode_disabled) {
		current->fog.mode = r_fogmode_disabled;
		glDisable(GL_FOG);
		R_TraceLogAPICall("glDisable(GL_FOG)");
	}

	if (state->vao_id) {
		GLC_EnsureVAOCreated(state->vao_id);
	}

	GL_ProcessErrors("Pre-GLC_ApplyRenderingState()");
	GL_ApplyRenderingState(id);
	GL_ProcessErrors("Post-ApplyRenderingState()");

	R_TraceLeaveRegion(true);
}

void R_GLC_TextureUnitSet(rendering_state_t* state, int index, qbool enabled, r_texunit_mode_t mode)
{
	state->textureUnits[index].enabled = enabled;
	state->textureUnits[index].mode = mode;
}

void R_GLC_ConfigureAlphaTesting(rendering_state_t* state, qbool enabled, r_alphatest_func_t func, float value)
{
	state->alphaTesting.enabled = enabled;
	state->alphaTesting.func = func;
	state->alphaTesting.value = value;
}

#endif // RENDERER_OPTION_CLASSIC_OPENGL

void R_BufferInvalidateBoundState(r_buffer_id ref)
{
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	int i;

	if (R_BufferReferencesEqual(opengl.rendering_state.vertex_array.buf, ref)) {
		opengl.rendering_state.vertex_array.buf = r_buffer_none;
	}
	if (R_BufferReferencesEqual(opengl.rendering_state.color_array.buf, ref)) {
		opengl.rendering_state.color_array.buf = r_buffer_none;
	}
	if (R_BufferReferencesEqual(opengl.rendering_state.normal_array.buf, ref)) {
		opengl.rendering_state.normal_array.buf = r_buffer_none;
	}
	for (i = 0; i < sizeof(opengl.rendering_state.textureUnits) / sizeof(opengl.rendering_state.textureUnits[0]); ++i) {
		if (R_BufferReferencesEqual(opengl.rendering_state.textureUnits[i].va.buf, ref)) {
			opengl.rendering_state.textureUnits[i].va.buf = r_buffer_none;
		}
	}
#endif
}

void GL_InvalidateViewport(void)
{
	rendering_state_t* state = &opengl.rendering_state;
	state->currentViewportX = 0;
	state->currentViewportY = 0;
	state->currentViewportWidth = 0;
	state->currentViewportHeight = 0;
}

void GL_PackAlignment(int alignment_in_bytes)
{
	if (opengl.rendering_state.pack_alignment != alignment_in_bytes) {
		glPixelStorei(GL_PACK_ALIGNMENT, alignment_in_bytes);
		opengl.rendering_state.pack_alignment = alignment_in_bytes;
	}
}

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
void GLC_MultiTexCoord2f(GLenum target, float s, float t)
{
	if (GL_Available(glMultiTexCoord2f)) {
		GL_Procedure(glMultiTexCoord2f, target, s, t);
	}
}

void GL_CheckMultiTextureExtensions(void)
{
	if (!COM_CheckParm(cmdline_param_client_nomultitexturing) && (GL_VersionAtLeast(2, 0) || SDL_GL_ExtensionSupported("GL_ARB_multitexture"))) {
		GL_LoadOptionalFunction(glMultiTexCoord2f);
		if (!GL_Available(glMultiTexCoord2f)) {
			GL_LoadOptionalFunctionARB(glMultiTexCoord2f);
		}
		GL_LoadOptionalFunction(glActiveTexture);
		if (!GL_Available(glActiveTexture)) {
			GL_LoadOptionalFunctionARB(glActiveTexture);
		}
		GL_LoadOptionalFunction(glClientActiveTexture);
		if (!GL_Available(glMultiTexCoord2f) || !GL_Available(glActiveTexture) || !GL_Available(glClientActiveTexture)) {
			return;
		}
		Com_Printf_State(PRINT_OK, "Multitexture extensions found\n");
		gl_mtexable = true;
	} else {
		GL_InvalidateFunction(glMultiTexCoord2f);
		GL_InvalidateFunction(glActiveTexture);
		GL_InvalidateFunction(glClientActiveTexture);
	}

	gl_textureunits = min(glConfig.texture_units, 4);

	if (COM_CheckParm(cmdline_param_client_maximum2textureunits)) {
		gl_textureunits = min(gl_textureunits, 2);
	}

	if (gl_textureunits < 2) {
		gl_mtexable = false;
	}

	if (!gl_mtexable) {
		gl_textureunits = 1;
	}
	else {
		Com_Printf_State(PRINT_OK, "Enabled %i texture units on hardware\n", gl_textureunits);
	}
}
#else
void GL_CheckMultiTextureExtensions(void)
{
	if (GL_VersionAtLeast(2, 0) || SDL_GL_ExtensionSupported("GL_ARB_multitexture"))
	{
		GL_LoadOptionalFunction(glActiveTexture);
		if (!GL_Available(glActiveTexture)) {
			Sys_Error("Required OpenGL function not supported: glActiveTexture");
			return;
		}

		gl_textureunits = min(glConfig.texture_units, 4);
		gl_mtexable = true;
	} else {
		Sys_Error("Required extension not supported: GL_ARB_multitexture");
	}

}
#endif

#ifdef WITH_RENDERING_TRACE
static int GL_FindSpecificInEnum(GLenum value, GLenum* enum_array, int length)
{
	int i;

	for (i = 0; i < length; ++i) {
		if (value == enum_array[i]) {
			return i;
		}
	}

	return length;
}

static int GL_FindIntegerInEnum(GLenum name, GLenum* enum_array, int length)
{
	GLint glInt = 0;

	GL_BuiltinProcedure(glGetIntegerv, "name=%u, output=%p", name, &glInt);

	return GL_FindSpecificInEnum(glInt, enum_array, length);
}

static float GL_GetFloat(GLenum name)
{
	float result = NAN;

	GL_BuiltinProcedure(glGetFloatv, "name=%u, output=%p", name, &result);

	return result;
}

static r_buffer_id GL_VerifyBufferState(GLenum name)
{
	GLint glInt = 0;

	GL_BuiltinProcedure(glGetIntegerv, "name=%u, output=%p", name, &glInt);

	return r_buffer_none; // FIXME
}

static qbool GL_IsEnabled_(GLenum pname, const char* name)
{
	qbool result;

	R_TraceAPI("glIsEnabled(%s)", name);
	result = glIsEnabled(pname);
	GL_ProcessErrors(va("glIsEnabled(%s)", name));
	return result;
}

#define GL_IsEnabled(pname) GL_IsEnabled_(pname, #pname)

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
static void GLC_VerifyArray(glc_vertex_array_element_t* arr, GLenum enabled, GLenum bufferBinding, GLenum pointer, GLenum size, GLenum stride, GLenum type)
{
	if (renderer.vaos_supported) {
		arr->enabled = GL_IsEnabled(enabled);
		arr->buf = GL_VerifyBufferState(bufferBinding);
		GL_BuiltinProcedure(glGetPointerv, "name=%u, output=%p", pointer, &arr->pointer_or_offset);
		if (size) {
			GL_BuiltinProcedure(glGetIntegerv, "name=%u, output=%p", size, &arr->size);
		}
		GL_BuiltinProcedure(glGetIntegerv, "name=%u, output=%p", stride, &arr->stride);
		GL_BuiltinProcedure(glGetIntegerv, "name=%u, output=%p", type, &arr->type);
	}
	else {
		memset(arr, 0, sizeof(*arr));
		arr->size = (enabled == GL_NORMAL_ARRAY ? 0 : 4);
		arr->type = GL_FLOAT;
	}
}

static void GLC_DownloadVAOState(rendering_state_t* state)
{
	GLenum texture_modes[4] = { 0 };
	int i = 0;

	if (R_UseImmediateOpenGL()) {
		// vertex array
		GLC_VerifyArray(&state->vertex_array, GL_VERTEX_ARRAY, GL_VERTEX_ARRAY_BUFFER_BINDING, GL_VERTEX_ARRAY_POINTER, GL_VERTEX_ARRAY_SIZE, GL_VERTEX_ARRAY_STRIDE, GL_VERTEX_ARRAY_TYPE);
		// color array
		GLC_VerifyArray(&state->color_array, GL_COLOR_ARRAY, GL_COLOR_ARRAY_BUFFER_BINDING, GL_COLOR_ARRAY_POINTER, GL_COLOR_ARRAY_SIZE, GL_COLOR_ARRAY_STRIDE, GL_COLOR_ARRAY_TYPE);
		// normal array
		GLC_VerifyArray(&state->normal_array, GL_NORMAL_ARRAY, GL_NORMAL_ARRAY_BUFFER_BINDING, GL_NORMAL_ARRAY_POINTER, 0, GL_NORMAL_ARRAY_STRIDE, GL_NORMAL_ARRAY_TYPE);

		state->textureUnits[i].mode = r_texunit_mode_modulate;
		state->textureUnits[i].va.type = GL_FLOAT;
		state->textureUnits[i].enabled = false;
		for (i = 0; i < sizeof(state->textureUnits) / sizeof(state->textureUnits[0]); ++i) {
			if (i < glConfig.texture_units) {
				GLC_ClientActiveTexture(GL_TEXTURE0 + i);
				GLC_VerifyArray(&state->textureUnits[i].va, GL_TEXTURE_COORD_ARRAY, GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING, GL_TEXTURE_COORD_ARRAY_POINTER, GL_TEXTURE_COORD_ARRAY_SIZE, GL_TEXTURE_COORD_ARRAY_STRIDE, GL_TEXTURE_COORD_ARRAY_TYPE);
				GL_SelectTexture(GL_TEXTURE0 + i);
				GL_BuiltinProcedure(glGetTexEnviv, "target=%u, pname=%u, params=%p", GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &texture_modes[i]);
				state->textureUnits[i].mode = GL_FindSpecificInEnum(texture_modes[i], glTextureEnvModeValues, sizeof(glTextureEnvModeValues) / sizeof(glTextureEnvModeValues[0]));
				state->textureUnits[i].enabled = GL_IsEnabled(GL_TEXTURE_2D);
			}
			else {
				state->textureUnits[i].va.size = 4;
				state->textureUnits[i].va.type = GL_FLOAT;
			}
		}
	}
}

static void GLC_DownloadAlphaTestingState(rendering_state_t* state)
{
	if (R_UseImmediateOpenGL()) {
		state->alphaTesting.enabled = GL_IsEnabled(GL_ALPHA_TEST);
		state->alphaTesting.func = GL_FindIntegerInEnum(GL_ALPHA_TEST_FUNC, glAlphaTestModeValues, sizeof(glAlphaTestModeValues) / sizeof(glAlphaTestModeValues[0]));
		state->alphaTesting.value = GL_GetFloat(GL_ALPHA_TEST_REF);
	}
}

static qbool GLC_CompareAlphaTesting(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	if (memcmp(&expected->alphaTesting, &found->alphaTesting, sizeof(expected->alphaTesting))) {
		R_TraceAPI(
			"!ALPHA-TESTING: expected %d,%d,%f found %d,%d,%f",
			expected->alphaTesting.enabled, expected->alphaTesting.func, expected->alphaTesting.value,
			found->alphaTesting.enabled, found->alphaTesting.func, found->alphaTesting.value
		);
		return true;
	}
	return false;
}

static qbool GLC_CompareVertexArray(FILE* output, const glc_vertex_array_element_t* expected, const glc_vertex_array_element_t* found, const char* name)
{
	if (memcmp(expected, found, sizeof(*expected))) {
		R_TraceAPI("!%s: expected enabled(%d),p_offset(%p),buf(%d),size(%d),stride(%d),type(%d), found enabled(%d),p_offset(%p),buf(%d),size(%d),stride(%d),type(%d)", name,
			expected->enabled, expected->pointer_or_offset, expected->buf, expected->size, expected->stride, expected->type,
			found->enabled, found->pointer_or_offset, found->buf, found->size, found->stride, found->type
		);
		return false;
	}
	return false;
}

static qbool GLC_CompareVertexArrays(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	qbool problem = false;

	problem = GLC_CompareVertexArray(output, &expected->vertex_array, &found->vertex_array, "VertexArray") || problem;
	problem = GLC_CompareVertexArray(output, &expected->color_array, &found->color_array, "ColorArray") || problem;
	problem = GLC_CompareVertexArray(output, &expected->normal_array, &found->normal_array, "NormalArray") || problem;
	problem = GLC_CompareVertexArray(output, &expected->textureUnits[0].va, &found->textureUnits[0].va, "TextureArray0") || problem;
	problem = GLC_CompareVertexArray(output, &expected->textureUnits[1].va, &found->textureUnits[1].va, "TextureArray1") || problem;
	problem = GLC_CompareVertexArray(output, &expected->textureUnits[2].va, &found->textureUnits[2].va, "TextureArray2") || problem;
	problem = GLC_CompareVertexArray(output, &expected->textureUnits[3].va, &found->textureUnits[3].va, "TextureArray3") || problem;

	return problem;
}

// Adjust for what OpenGL doesn't know about
#define GLC_AssumeState(state) { from_gl.state = opengl.rendering_state.state; }
#else
#define GLC_DownloadAlphaTestingState(...)
#define GLC_DownloadVAOState(...)
#define GLC_CompareAlphaTesting(...) (false)
#define GLC_CompareVertexArrays(...) (false)
#define GLC_AssumeState(...)
#endif

static void GL_DownloadTextureUnitState(GLuint* bound_textures, GLuint* bound_arrays, GLuint* bound_cubemaps)
{
	int i;
	int units = min(glConfig.texture_units, MAX_LOGGED_TEXTURE_UNITS);

	for (i = 0; i < units; ++i) {
		bound_cubemaps[i] = bound_textures[i] = bound_arrays[i] = 0;

		GL_SelectTexture(GL_TEXTURE0 + i);
		glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_textures[i]);
		if (GL_Supported(R_SUPPORT_TEXTURE_ARRAYS)) {
			glGetIntegerv(GL_TEXTURE_BINDING_2D_ARRAY, &bound_arrays[i]);
		}
		if (GL_Supported(R_SUPPORT_CUBE_MAPS)) {
			glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &bound_cubemaps[i]);
		}
	}
}

static void GL_DownloadState(rendering_state_t* state, GLuint* gl_bound2d, GLuint* gl_bound3d, GLuint* gl_boundCubemaps)
{
	memset(state, 0, sizeof(*state));

	GLC_DownloadAlphaTestingState(state);

	// Blending - we use a single enum for the pairing of src & dst
	{
		GLint src, dst;
		int i;

		GL_BuiltinProcedure(glGetIntegerv, "name=%u, output=%p", GL_BLEND_SRC, &src);
		GL_BuiltinProcedure(glGetIntegerv, "name=%u, output=%p", GL_BLEND_DST, &dst);

		for (i = 0; i < sizeof(glBlendFuncValuesSource) / sizeof(glBlendFuncValuesSource[0]); ++i) {
			if (glBlendFuncValuesSource[i] == src && glBlendFuncValuesDestination[i] == dst) {
				state->blendFunc = i;
			}
		}
	}
	state->blendingEnabled = GL_IsEnabled(GL_BLEND);

	// Colors
	GL_BuiltinProcedure(glGetFloatv, "pname=%u, params=%p", GL_COLOR_CLEAR_VALUE, state->clearColor);
	{
		GLint colorMask_[4];
		GL_BuiltinProcedure(glGetIntegerv, "name=%u, output=%p", GL_COLOR_WRITEMASK, colorMask_);
		state->colorMask[0] = colorMask_[0];
		state->colorMask[1] = colorMask_[1];
		state->colorMask[2] = colorMask_[2];
		state->colorMask[3] = colorMask_[3];
	}
	if (R_UseImmediateOpenGL()) {
		GL_BuiltinProcedure(glGetFloatv, "pname=%u, params=%p", GL_CURRENT_COLOR, state->color);
	}
	else {
		state->color[0] = state->color[1] = state->color[2] = state->color[3] = 1.0f;
	}

	// cullface
	state->cullface.enabled = GL_IsEnabled(GL_CULL_FACE);
	state->cullface.mode = GL_FindIntegerInEnum(GL_CULL_FACE_MODE, glCullFaceValues, sizeof(glCullFaceValues) / sizeof(glCullFaceValues[0]));

	{
		GLint viewport[4];

		GL_BuiltinProcedure(glGetIntegerv, "pname=%u, params=%p", GL_VIEWPORT, viewport);
		state->currentViewportX = viewport[0];
		state->currentViewportY = viewport[1];
		state->currentViewportWidth = viewport[2];
		state->currentViewportHeight = viewport[3];
	}

	// depth buffer
	{
		float range[2];
		GLint glInt = 0;

		glGetFloatv(GL_DEPTH_RANGE, range);

		state->depth.farRange = range[1];
		state->depth.func = GL_FindIntegerInEnum(GL_DEPTH_FUNC, glDepthFunctions, sizeof(glDepthFunctions) / sizeof(glDepthFunctions[0]));
		glGetIntegerv(GL_DEPTH_WRITEMASK, &glInt);
		state->depth.mask_enabled = (glInt != GL_FALSE);
		state->depth.nearRange = range[0];
		state->depth.test_enabled = GL_IsEnabled(GL_DEPTH_TEST);
	}

	// fog
	if (GL_Supported(R_SUPPORT_FOG)) {
		state->fog.mode = GL_IsEnabled(GL_FOG) ? r_fogmode_enabled : r_fogmode_disabled;
	}

	//
	if (GL_Supported(R_SUPPORT_FRAMEBUFFERS_SRGB)) {
		state->framebuffer_srgb = GL_IsEnabled(GL_FRAMEBUFFER_SRGB);
	}
	else {
		state->framebuffer_srgb = false;
	}

	// TODO: GLC attributes

	// line
	state->line.smooth = GL_IsEnabled(GL_LINE_SMOOTH);
	glGetFloatv(GL_LINE_WIDTH, &state->line.width);
	GL_ProcessErrors("VerifyState[end-3]");

	// 
	{
		GLint polygonModes[2];
		glGetIntegerv(GL_POLYGON_MODE, polygonModes);
		state->polygonMode = GL_FindSpecificInEnum(polygonModes[0], glPolygonModeValues, sizeof(glPolygonModeValues) / sizeof(glPolygonModeValues[0]));
	}

	// polygon offset
	GL_BuiltinProcedure(glGetFloatv, "pname=%u, params=%p", GL_POLYGON_OFFSET_FACTOR, &state->polygonOffset.factor);
	state->polygonOffset.fillEnabled = GL_IsEnabled(GL_POLYGON_OFFSET_FILL);
	state->polygonOffset.lineEnabled = GL_IsEnabled(GL_POLYGON_OFFSET_LINE);
	GL_BuiltinProcedure(glGetFloatv, "pname=%u, params=%p", GL_POLYGON_OFFSET_UNITS, &state->polygonOffset.units);

	// pack offset
	glGetIntegerv(GL_PACK_ALIGNMENT, &state->pack_alignment);

	GL_ProcessErrors("VerifyState[end-2]");
	GLC_DownloadVAOState(state);
	GL_ProcessErrors("VerifyState[end-1]");
	GL_DownloadTextureUnitState(gl_bound2d, gl_bound3d, gl_boundCubemaps);
	GL_ProcessErrors("VerifyState[end]");
}

static qbool GL_CompareBlending(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	if (expected->blendingEnabled != found->blendingEnabled || expected->blendFunc != found->blendFunc) {
		R_TraceAPI(
			"!BLENDING: expected %d,%d found %d,%d",
			expected->blendingEnabled, expected->blendFunc,
			found->blendingEnabled, found->blendFunc
		);
		return true;
	}
	return false;
}

static qbool GL_CompareColors(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	qbool problem = false;
	if (memcmp(expected->clearColor, found->clearColor, sizeof(expected->clearColor))) {
		R_TraceAPI(
			"!CLEARCOLOR: expected %f,%f,%f,%f found %f,%f,%f,%f",
			expected->clearColor[0], expected->clearColor[1], expected->clearColor[2], expected->clearColor[3],
			found->clearColor[0], found->clearColor[1], found->clearColor[2], found->clearColor[3]
		);
		problem = true;
	}
	if (memcmp(expected->colorMask, found->colorMask, sizeof(expected->colorMask))) {
		R_TraceAPI(
			"!COLORMASK: expected %d,%d,%d,%d found %d,%d,%d,%d",
			expected->colorMask[0], expected->colorMask[1], expected->colorMask[2], expected->colorMask[3],
			found->colorMask[0], found->colorMask[1], found->colorMask[2], found->colorMask[3]
		);
		problem = true;
	}
	if (memcmp(expected->color, found->color, sizeof(expected->color))) {
		R_TraceAPI(
			"!COLOR: expected %f,%f,%f,%f found %f,%f,%f,%f",
			expected->color[0], expected->color[1], expected->color[2], expected->color[3],
			found->color[0], found->color[1], found->color[2], found->color[3]
		);
		problem = true;
	}
	return problem;
}

static qbool GL_CompareCulling(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	if (memcmp(&expected->cullface, &found->cullface, sizeof(expected->cullface))) {
		R_TraceAPI(
			"!CULLING: expected %d,%d found %d,%d",
			expected->cullface.enabled, expected->cullface.mode,
			found->cullface.enabled, found->cullface.mode
		);
		return true;
	}
	return false;
}

static qbool GL_CompareViewport(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	if (expected->currentViewportX != found->currentViewportX ||
		expected->currentViewportHeight != found->currentViewportHeight ||
		expected->currentViewportWidth != found->currentViewportWidth ||
		expected->currentViewportY != found->currentViewportY)
	{
		R_TraceAPI(
			"!VIEWPORT: expected %d,%d,%d,%d found %d,%d,%d,%d",
			expected->currentViewportX, expected->currentViewportY, expected->currentViewportWidth, expected->currentViewportHeight,
			found->currentViewportX, found->currentViewportY, found->currentViewportWidth, found->currentViewportHeight
		);
		return true;
	}
	return false;
}

static qbool GL_CompareDepth(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	if (memcmp(&expected->depth, &found->depth, sizeof(expected->depth))) {
		R_TraceAPI(
			"!DEPTH: expected %d,%d,%d,%f,%f found %d,%d,%d,%f,%f",
			expected->depth.test_enabled, expected->depth.mask_enabled, expected->depth.func, expected->depth.nearRange, expected->depth.farRange,
			found->depth.test_enabled, found->depth.mask_enabled, found->depth.func, found->depth.nearRange, found->depth.farRange
		);
		return true;
	}
	return false;
}

static qbool GL_CompareLine(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	if (expected->line.smooth != found->line.smooth || expected->line.width != found->line.width) {
		R_TraceAPI(
			"!LINE: expected %d,%f found %d,%f",
			expected->line.smooth, expected->line.width,
			found->line.smooth, found->line.width
		);
		return true;
	}
	return false;
}

static qbool GL_CompareMisc(FILE* output, const rendering_state_t* expected, const rendering_state_t* found)
{
	qbool problem = false;
	if (expected->fog.mode != found->fog.mode) {
		R_TraceAPI("!FOG: expected %s, found %s", fogModeDescriptions[expected->fog.mode], fogModeDescriptions[found->fog.mode]);
	}
	if (expected->framebuffer_srgb != found->framebuffer_srgb) {
		R_TraceAPI("!SRGB: expected %d, found %d", expected->framebuffer_srgb, found->framebuffer_srgb);
	}
	if (expected->polygonMode != found->polygonMode) {
		R_TraceAPI("!POLYMODE: expected %d, found %d", expected->polygonMode, found->polygonMode);
	}
	return problem;
}


static qbool GL_CompareBoundTextures(FILE* output, const GLuint* expected, const GLuint* found, const char* name)
{
	int units = min(MAX_LOGGED_TEXTURE_UNITS, glConfig.texture_units);
	int i;
	qbool problem = false;

	for (i = 0; i < units; ++i) {
		if (expected[i] != found[i]) {
			R_TraceAPI("!%s%d: expected %u, found %u", name, i, expected[i], found[i]);
			problem = true;
		}
	}

	return problem;
}

static void GL_CompareState(FILE* output, const rendering_state_t* found, const GLuint* gl_bound2d, const GLuint* gl_bound3d, const GLuint* gl_boundCubemap)
{
	qbool problems = false;
	const rendering_state_t* expected = &opengl.rendering_state;

	problems = GL_CompareBlending(output, expected, found) || problems;
	problems = GL_CompareColors(output, expected, found) || problems;
	problems = GL_CompareCulling(output, expected, found) || problems;
	problems = GL_CompareViewport(output, expected, found) || problems;
	problems = GL_CompareDepth(output, expected, found) || problems;
	problems = GL_CompareLine(output, expected, found) || problems;
	problems = GL_CompareMisc(output, expected, found) || problems;

	if (R_UseImmediateOpenGL()) {
		problems = GLC_CompareAlphaTesting(output, expected, found) || problems;
		problems = GLC_CompareVertexArrays(output, expected, found) || problems;
	}

	problems = GL_CompareBoundTextures(output, bound_texture_state[texture_type_2d], gl_bound2d, "2DTEXTURE") || problems;
	problems = GL_CompareBoundTextures(output, bound_texture_state[texture_type_2d_array], gl_bound3d, "TEXTUREARRAY") || problems;
	problems = GL_CompareBoundTextures(output, bound_texture_state[texture_type_cubemap], gl_boundCubemap, "CUBEMAP") || problems;

	if (problems) {
		Con_Printf("*** PROBLEM ***\n");
	}

	return;
}

void GL_VerifyState(FILE* output)
{
	rendering_state_t from_gl;
	GLuint gl_bound2d[MAX_LOGGED_TEXTURE_UNITS] = { 0 };
	GLuint gl_bound3d[MAX_LOGGED_TEXTURE_UNITS] = { 0 };
	GLuint gl_boundCubemap[MAX_LOGGED_TEXTURE_UNITS] = { 0 };

	R_TraceEnterFunctionRegion;
	GL_ProcessErrors(__func__);
	GL_DownloadState(&from_gl, gl_bound2d, gl_bound3d, gl_boundCubemap);

	GLC_AssumeState(normal_array.buf);
	GLC_AssumeState(normal_array.size);
	GLC_AssumeState(color_array.buf);
	GLC_AssumeState(vertex_array.buf);
	GLC_AssumeState(textureUnits[0].va.buf);
	GLC_AssumeState(textureUnits[1].va.buf);
	GLC_AssumeState(textureUnits[2].va.buf);
	GLC_AssumeState(textureUnits[3].va.buf);

	// Compare
	GL_CompareState(output, &from_gl, gl_bound2d, gl_bound3d, gl_boundCubemap);
	R_TraceLeaveFunctionRegion;
}
#endif


================================================
FILE: src/gl_texture.c
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: gl_texture.c,v 1.44 2007-10-05 19:06:24 johnnycz Exp $
*/

#include "quakedef.h"
#include "crc.h"
#include "image.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_renderer.h"
#include "tr_types.h"
#include "r_texture.h"
#include "r_texture_internal.h"
#include "r_brushmodel_sky.h"
#include "r_local.h"
#include "r_aliasmodel.h" // for shelltexture only
#include "r_lighting.h"
#include "gl_texture_internal.h"

const texture_ref null_texture_reference = { 0 };
static GLenum gl_solid_format = GL_RGB8, gl_alpha_format = GL_RGBA8;

extern unsigned d_8to24table2[256];

extern int anisotropy_ext;

static GLint glTextureMinificationOptions[] = {
	GL_NEAREST, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR
};
static GLint glTextureMagnificationOptions[] = {
	GL_NEAREST, GL_LINEAR
};
static GLenum glTextureTargetForType[] = {
	GL_TEXTURE_2D, GL_TEXTURE_2D_ARRAY, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_2D_MULTISAMPLE
};

#ifdef C_ASSERT
C_ASSERT(sizeof(glTextureMinificationOptions) / sizeof(glTextureMinificationOptions[0]) == texture_minification_count);
C_ASSERT(sizeof(glTextureMagnificationOptions) / sizeof(glTextureMagnificationOptions[0]) == texture_magnification_count);
C_ASSERT(sizeof(glTextureTargetForType) / sizeof(glTextureTargetForType[0]) == texture_type_count);
#endif

static int GL_InternalFormat(int mode)
{
	if (vid_gammacorrection.integer) {
		return (mode & TEX_ALPHA) ? GL_SRGB8_ALPHA8 : GL_SRGB8;
	}
	else if (mode & TEX_NOCOMPRESS) {
		return (mode & TEX_ALPHA) ? GL_RGBA8 : GL_RGB8;
	}
	else {
		return (mode & TEX_ALPHA) ? gl_alpha_format : gl_solid_format;
	}
}

static int GL_StorageFormat(int mode)
{
	if (mode & TEX_FLOAT) {
		return (mode & TEX_ALPHA) ? GL_RGBA16F : GL_RGB16F;
	}
	else if (vid_gammacorrection.integer) {
		return (mode & TEX_ALPHA) ? GL_SRGB8_ALPHA8 : GL_SRGB8;
	}
	else {
		return (mode & TEX_ALPHA) ? GL_RGBA8 : GL_RGB8;
	}
}

void GL_UploadTexture(texture_ref texture, int mode, int width, int height, byte* newdata)
{
	// Upload the main texture to OpenGL.
	GL_TexSubImage2D(GL_TEXTURE0, texture, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, newdata);
	if (mode & TEX_MIPMAP) {
		GL_TextureMipmapGenerateWithData(GL_TEXTURE0, texture, (byte*)newdata, width, height, GL_InternalFormat(mode));
	}
}

void GL_CreateTexturesWithIdentifier(r_texture_type_id type, int n, texture_ref* textures, const char* identifier)
{
	GLenum textureUnit = GL_TEXTURE0;
	GLenum target = glTextureTargetForType[type];
	GLsizei i;

	for (i = 0; i < n; ++i) {
		gltexture_t* glt = R_NextTextureSlot(type);

		GL_CreateTextureNames(textureUnit, target, 1, &glt->texnum);
		glt->type = type;
		GL_BindTextureUnit(textureUnit, glt->reference);

		textures[i] = glt->reference;

		if (identifier) {
			strlcpy(glt->identifier, identifier, sizeof(glt->identifier));
			GL_TraceObjectLabelSet(GL_TEXTURE, glt->texnum, -1, identifier);
		}
	}
}

void GL_TexturesCreate(r_texture_type_id type, int n, texture_ref* textures)
{
	GL_CreateTexturesWithIdentifier(type, n, textures, NULL);
}

// For OpenGL wrapper functions
GLuint GL_TextureNameFromReference(texture_ref ref)
{
	assert(ref.index < sizeof(gltextures) / sizeof(gltextures[0]));

	return gltextures[ref.index].texnum;
}

// For OpenGL wrapper functions
GLenum GL_TextureTargetFromReference(texture_ref ref)
{
	assert(ref.index < sizeof(gltextures) / sizeof(gltextures[0]));

	return glTextureTargetForType[gltextures[ref.index].type];
}

const char* GL_TextureIdentifierByGLReference(GLuint texnum)
{
	static char name[256];

	memset(name, 0, sizeof(name));
	GL_TraceObjectLabelGet(GL_TEXTURE, texnum, sizeof(name), NULL, name);
	if (!name[0]) {
		R_TextureFindIdentifierByReference(texnum, name, sizeof(name));
	}

	return name;
}

void GL_TextureReplace2D(
	GLenum textureUnit, GLenum target, texture_ref* ref, GLint internalformat,
	GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels
)
{
	gltexture_t* tex;

	if (!R_TextureReferenceIsValid(*ref)) {
		renderer.TexturesCreate(texture_type_2d, 1, ref);
	}

	tex = &gltextures[ref->index];
	if (tex->texture_width != width || tex->texture_height != height || glTextureTargetForType[tex->type] != target || GL_InternalFormat(tex->texmode) != internalformat) {
		gltexture_t old = *tex;
		R_DeleteTexture(ref);
		*ref = R_LoadTexturePixels(pixels, old.identifier, width, height, old.texmode);
	}
	else {
		GL_TexSubImage2D(textureUnit, *ref, 0, 0, 0, width, height, format, type, pixels);
	}
}

void GL_TextureSetFiltering(texture_ref texture, texture_minification_id minification_filter, texture_magnification_id magnification_filter)
{
	assert(minification_filter >= 0 && minification_filter < texture_minification_count);
	assert(magnification_filter >= 0 && magnification_filter < texture_magnification_count);

	if (!R_TextureReferenceIsValid(texture)) {
		return;
	}

	gltextures[texture.index].minification_filter = minification_filter;
	gltextures[texture.index].magnification_filter = magnification_filter;

	GL_TexParameteri(GL_TEXTURE0, texture, GL_TEXTURE_MIN_FILTER, glTextureMinificationOptions[minification_filter]);
	GL_TexParameteri(GL_TEXTURE0, texture, GL_TEXTURE_MAG_FILTER, glTextureMagnificationOptions[magnification_filter]);
}

void GL_TextureWrapModeClamp(texture_ref tex)
{
	if (GL_VersionAtLeast(1, 2)) {
		GL_TexParameteri(GL_TEXTURE0, tex, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		GL_TexParameteri(GL_TEXTURE0, tex, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		if (R_TextureType(tex) == texture_type_cubemap) {
			GL_TexParameteri(GL_TEXTURE0, tex, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		}
	}
	else {
		GL_TexParameteri(GL_TEXTURE0, tex, GL_TEXTURE_WRAP_S, GL_CLAMP);
		GL_TexParameteri(GL_TEXTURE0, tex, GL_TEXTURE_WRAP_T, GL_CLAMP);
	}
}

void GL_TextureSetAnisotropy(texture_ref texture, int anisotropy)
{
	if (anisotropy_ext) {
		GL_TexParameterf(GL_TEXTURE0, texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
	}
}

void GL_TextureDelete(texture_ref texture)
{
	gltexture_t* slot = &gltextures[texture.index];
	GLuint texture_num = slot->texnum;

#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nopengl-texture,free,%u,%d,%d,%d,%s\n", texture.index, slot->texture_width, slot->texture_height, slot->texture_width * slot->texture_height * max(slot->depth,1) * slot->bpp, slot->identifier);
#endif

	GL_BuiltinProcedure(glDeleteTextures, "n=%d, textures=%p", 1, &texture_num);

	// Might have been bound when deleted, update state
	GL_InvalidateTextureReferences(texture_num);
	slot->texnum = 0;
}

void GL_AllocateStorage(gltexture_t* texture)
{
	GL_TexStorage2D(texture->reference, texture->miplevels, GL_StorageFormat(texture->texmode), texture->texture_width, texture->texture_height, false);
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nopengl-texture,alloc,%u,%d,%d,%d,%s\n", texture->reference.index, texture->texture_width, texture->texture_height, texture->texture_width * texture->texture_height * texture->bpp, texture->identifier);
#endif
}

#ifdef RENDERER_OPTION_MODERN_OPENGL
qbool GLM_TextureAllocateArrayStorage(gltexture_t* slot)
{
	GLenum error;

	R_TraceAPI("Allocating %d x %d x %d, %d miplevels\n", slot->texture_width, slot->texture_height, slot->depth, slot->miplevels);
	GL_ProcessErrors("GLM_TextureAllocateArrayStorage flush");
	GL_ConsumeErrors();
	error = GL_TexStorage3D(GL_TEXTURE0, slot->reference, slot->miplevels, GL_StorageFormat(TEX_ALPHA), slot->texture_width, slot->texture_height, slot->depth, false);

	if (error != GL_NO_ERROR) {
#ifdef WITH_RENDERING_TRACE
		int array_width, array_height, array_depth;

		array_width = R_TextureWidth(slot->reference);
		array_height = R_TextureHeight(slot->reference);
		array_depth = R_TextureDepth(slot->reference);

		R_TraceAPI("!!ERROR Array allocation failed, error %X: [mip %d, %d x %d x %d]\n", error, slot->miplevels, slot->texture_width, slot->texture_height, slot->depth);
		R_TraceAPI(" > Sizes reported: %d x %d x %d\n", array_width, array_height, array_depth);
#endif
		return false;
	}

#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nopengl-texture,alloc,%u,%d,%d,%d,%s\n", slot->reference.index, slot->texture_width, slot->texture_height, slot->texture_width * slot->texture_height * slot->depth * (slot->texmode & TEX_ALPHA ? 4 : 3), slot->identifier);
#endif

	return true;
}
#endif // RENDERER_OPTION_MODERN_OPENGL

void GL_AllocateTextureNames(gltexture_t* glt)
{
	assert(glt->type >= 0 && glt->type < sizeof(glTextureTargetForType) / sizeof(glTextureTargetForType[0]));

	GL_CreateTextureNames(GL_TEXTURE0, glTextureTargetForType[glt->type], 1, &glt->texnum);
}

void GL_TextureCreate2D(texture_ref* texture, int width, int height, const char* name, qbool is_lightmap)
{
	GL_CreateTexturesWithIdentifier(texture_type_2d, 1, texture, name);
	GL_TexStorage2D(*texture, 1, GL_RGBA8, width, height, is_lightmap);
	renderer.TextureSetFiltering(*texture, texture_minification_linear, texture_magnification_linear);
	GL_TextureWrapModeClamp(*texture);
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nopengl-texture,alloc,%u,%d,%d,%d,%s\n", texture->index, width, height, width * height * 4, name);
#endif
}

void GL_TextureCompressionSet(qbool enabled)
{
	gl_alpha_format = (enabled ? GL_COMPRESSED_RGBA_ARB : GL_RGBA8);
	gl_solid_format = (enabled ? GL_COMPRESSED_RGB_ARB : GL_RGB8);
}

void GL_TextureGet(texture_ref texture, int buffer_size, byte* buffer, int bpp)
{
	GL_GetTexImage(GL_TEXTURE0, texture, 0, bpp == 3 ? GL_RGB : GL_RGBA, GL_UNSIGNED_BYTE, buffer_size, buffer);
}

void GL_TextureLoadCubemapFace(texture_ref cubemap, r_cubemap_direction_id direction, const byte* data, int width, int height)
{
	GL_TexSubImage3D(0, cubemap, 0, 0, 0, direction, width, height, 1, GL_RGBA, GL_UNSIGNED_BYTE, data);
}


================================================
FILE: src/gl_texture.h
================================================
/*
Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_GL_TEXTURE_H
#define EZQUAKE_GL_TEXTURE_H

#include "r_texture.h"
#include "r_texture_internal.h"

// External API
qbool GL_EnsureTextureUnitBound(int unit, texture_ref texture);
void GL_TextureMipmapGenerate(texture_ref texture);
void GL_TextureAnistropyChanged(texture_ref texture);
void GL_TextureGet(texture_ref tex, int buffer_size, byte* buffer, int bpp);
void GL_TextureWrapModeClamp(texture_ref tex);
void GL_UploadTexture(texture_ref texture, int mode, int width, int height, byte* newdata);
void GL_ReplaceSubImageRGBA(texture_ref ref, int offsetx, int offsety, int width, int height, byte* buffer);

// Internal
qbool GLM_TextureAllocateArrayStorage(gltexture_t* slot);
void GL_AllocateStorage(gltexture_t* texture);
void GL_AllocateTextureNames(gltexture_t* glt);

// Samplers
void GL_SamplerSetNearest(unsigned int texture_unit_number);
void GL_SamplerSetLinear(unsigned int texture_unit_number);
void GL_SamplerClear(unsigned int texture_unit_number);
void GL_DeleteSamplers(void);

#endif // EZQUAKE_GL_TEXTURE_H


================================================
FILE: src/gl_texture_functions.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// Wrapper functions over newer OpenGL texture management functions

#include <SDL.h>

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "image.h"
#include "tr_types.h"
#include "r_texture_internal.h"
#include "gl_texture_internal.h"
#include "r_trace.h"
#include "r_renderer.h"

// Samplers
static unsigned int nearest_sampler;
static unsigned int linear_sampler;

GLuint GL_TextureNameFromReference(texture_ref ref);
GLenum GL_TextureTargetFromReference(texture_ref ref);

// <DSA-functions (4.5)>
// These allow modification of textures without binding (-bind-to-edit)
GL_StaticProcedureDeclaration(glGetTextureLevelParameterfv, "texture=%u, level=%d, pname=%u, params=%p", GLuint texture, GLint level, GLenum pname, GLfloat* params)
GL_StaticProcedureDeclaration(glGetTextureLevelParameteriv, "texture=%u, level=%d, pname=%u, params=%p", GLuint texture, GLint level, GLenum pname, GLint* params)
GL_StaticProcedureDeclaration(glGenerateTextureMipmap, "texture=%u", GLuint texture)
GL_StaticProcedureDeclaration(glGetTextureImage, "texture=%u, level=%d, format=%u, type=%u, bufSize=%d, pixels=%p", GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels)
GL_StaticProcedureDeclaration(glCreateTextures, "target=%u, n=%d, textures=%p", GLenum target, GLsizei n, GLuint* textures)
GL_StaticProcedureDeclaration(glGetnTexImage, "target=%u, level=%d, format=%u, type=%u, bufSize=%d, pixels=%p", GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels)
GL_StaticProcedureDeclaration(glTextureParameteri, "texture=%u, pname=%u, param=%d", GLuint texture, GLenum pname, GLint param)
GL_StaticProcedureDeclaration(glTextureParameterf, "texture=%u, pname=%u, param=%f", GLuint texture, GLenum pname, GLfloat param)
GL_StaticProcedureDeclaration(glTextureParameterfv, "texture=%u, pname=%u, params=%p", GLuint texture, GLenum pname, const GLfloat* params)
GL_StaticProcedureDeclaration(glTextureParameteriv, "texture=%u, pname=%u, params=%p", GLuint texture, GLenum pname, const GLint* params)
GL_StaticProcedureDeclaration(glTextureStorage3D, "texture=%u, levels=%d, internalformat=%u, width=%d, height=%d, depth=%d", GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
GL_StaticProcedureDeclaration(glTextureStorage2D, "texture=%u, levels=%d, internalformat=%u, width=%d, height=%d", GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
GL_StaticProcedureDeclaration(glTextureSubImage2D, "texture=%u, level=%d, xoffset=%d, yoffset=%d, width=%d, height=%d, format=%u, type=%u, pixels=%p", GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
GL_StaticProcedureDeclaration(glTextureSubImage3D, "texture=%u, level=%d, xoffset=%d, yoffset=%d, zoffset=%d, width=%d, height=%d, depth=%d, format=%u, type=%u, pixels=%p", GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)

GL_StaticProcedureDeclaration(glTexStorage2D, "target=%u, levels=%d, internalformat=%u, width=%d, height=%d", GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
GL_StaticProcedureDeclaration(glTexSubImage3D, "target=%u, level=%d, xoffset=%d, yoffset=%d, zoffset=%d, width=%d, height=%d, depth=%d, format=%u, type=%u, pixels=%p", GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)
GL_StaticProcedureDeclaration(glTexStorage3D, "target=%u, levels=%d, internalformat=%u, width=%d, height=%d, depth=%d", GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
GL_StaticProcedureDeclaration(glTexImage3D, "target=%u, level=%d, internalformat=%d, width=%d, height=%d, depth=%d, border=%d, format=%u, type=%u, data=%p", GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* data)
GL_StaticProcedureDeclaration(glGenerateMipmap, "target=%u", GLenum target)

GL_StaticProcedureDeclaration(glGenSamplers, "n=%d, samplers=%p", GLsizei n, GLuint* samplers)
GL_StaticProcedureDeclaration(glDeleteSamplers, "n=%d, samplers=%p", GLsizei n, const GLuint* samplers)
GL_StaticProcedureDeclaration(glSamplerParameterf, "sampler=%u, pname=%u, param=%f", GLuint sampler, GLenum pname, GLfloat param)
GL_StaticProcedureDeclaration(glBindSampler, "unit=%u, sampler=%u", GLuint unit, GLuint sampler)

GL_StaticProcedureDeclaration(glGetInternalformativ, "target=%u, internalformat=%u, pname=%u, bufSize=%d, params=%p", GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)

// Multi-sampled textures
GL_StaticProcedureDeclaration(glTextureStorage2DMultisample, "texture=%d, samples=%d, internalformat=%d, width=%d, height=%d, fixedsamplelocations=%d", GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
GL_StaticProcedureDeclaration(glTexStorage2DMultisample, "target=%x, samples=%d, internalformat=%d, width=%d, height=%d, fixedsamplelocations=%d", GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
GL_StaticProcedureDeclaration(glTexImage2DMultisample, "target=%x, samples=%d, internalformat=%d, width=%d, height=%d, fixedsamplelocations=%d", GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)

void GL_LoadTextureManagementFunctions(void)
{
	glConfig.supported_features &= ~(R_SUPPORT_TEXTURE_ARRAYS | R_SUPPORT_TEXTURE_SAMPLERS);
	nearest_sampler = linear_sampler = 0;

	glConfig.preferred_format = glConfig.preferred_type = 0;
	if (GL_VersionAtLeast(4, 3) || SDL_GL_ExtensionSupported("GL_ARB_internalformat_query2")) {
		GL_LoadOptionalFunction(glGetInternalformativ);

		if (GL_Available(glGetInternalformativ)) {
			GLint tempFormat = 0, tempType = 0;

			GL_Procedure(glGetInternalformativ, GL_TEXTURE_2D, GL_RGBA8, GL_TEXTURE_IMAGE_FORMAT, 1, &tempFormat);
			GL_Procedure(glGetInternalformativ, GL_TEXTURE_2D, GL_RGBA8, GL_TEXTURE_IMAGE_TYPE, 1, &tempType);

			glConfig.preferred_format = tempFormat;
			glConfig.preferred_type = tempType;
		}
	} else {
		GL_InvalidateFunction(glGetInternalformativ);
	}

	if (GL_VersionAtLeast(4, 2) || SDL_GL_ExtensionSupported("GL_ARB_texture_storage")) {
		GL_LoadOptionalFunction(glTexStorage2D);
		GL_LoadOptionalFunction(glTexStorage3D);
	} else {
		GL_InvalidateFunction(glTexStorage2D);
		GL_InvalidateFunction(glTexStorage3D);
	}

	if (GL_VersionAtLeast(3,0) || SDL_GL_ExtensionSupported("GL_EXT_texture_array")) {
		qbool all_available = true;

		// OpenGL 1.2
		GL_LoadMandatoryFunctionExtension(glTexSubImage3D, all_available);
		GL_LoadMandatoryFunctionExtension(glTexImage3D, all_available);

		glConfig.supported_features |= (all_available ? R_SUPPORT_TEXTURE_ARRAYS : 0);
	} else {
		GL_InvalidateFunction(glTexSubImage3D);
		GL_InvalidateFunction(glTexImage3D);
	}

	if (GL_VersionAtLeast(3, 3) || SDL_GL_ExtensionSupported("GL_ARB_sampler_objects")) {
		qbool all_available = true;

		// Texture samplers in 3.3
		all_available = true;
		GL_LoadMandatoryFunctionExtension(glGenSamplers, all_available);
		GL_LoadMandatoryFunctionExtension(glDeleteSamplers, all_available);
		GL_LoadMandatoryFunctionExtension(glSamplerParameterf, all_available);
		GL_LoadMandatoryFunctionExtension(glBindSampler, all_available);
		glConfig.supported_features |= (all_available ? R_SUPPORT_TEXTURE_SAMPLERS : 0);
	} else {
		GL_InvalidateFunction(glGenSamplers);
		GL_InvalidateFunction(glDeleteSamplers);
		GL_InvalidateFunction(glSamplerParameterf);
		GL_InvalidateFunction(glBindSampler);
	}

	if (GL_VersionAtLeast(3, 0)) {
		// Core in 3.0
		GL_LoadOptionalFunction(glGenerateMipmap);
	}
	else if (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
		GL_LoadOptionalFunction(glGenerateMipmap);
		if (!GL_Available(glGenerateMipmap)) {
			GL_LoadOptionalFunctionEXT(glGenerateMipmap);
		}
	} else {
		GL_InvalidateFunction(glGenerateMipmap);
	}

	if (GL_VersionAtLeast(3, 2)) {
		GL_LoadOptionalFunction(glTextureStorage2DMultisample);
		GL_LoadOptionalFunction(glTexStorage2DMultisample);
		GL_LoadOptionalFunction(glTexImage2DMultisample);
	} else {
		GL_InvalidateFunction(glTextureStorage2DMultisample);
		GL_InvalidateFunction(glTexStorage2DMultisample);
		GL_InvalidateFunction(glTexImage2DMultisample);
	}

	if (GL_UseDirectStateAccess()) {
		GL_LoadOptionalFunction(glGenerateTextureMipmap);
		GL_LoadOptionalFunction(glGetTextureImage);
		GL_LoadOptionalFunction(glCreateTextures);
		GL_LoadOptionalFunction(glTextureParameteri);
		GL_LoadOptionalFunction(glTextureParameterf);
		GL_LoadOptionalFunction(glTextureParameterfv);
		GL_LoadOptionalFunction(glTextureParameteriv);
		GL_LoadOptionalFunction(glTextureStorage3D);
		GL_LoadOptionalFunction(glTextureStorage2D);
		GL_LoadOptionalFunction(glTextureSubImage2D);
		GL_LoadOptionalFunction(glTextureSubImage3D);
		GL_LoadOptionalFunction(glGetTextureLevelParameterfv);
		GL_LoadOptionalFunction(glGetTextureLevelParameterfv);
		GL_LoadOptionalFunction(glGetTextureLevelParameteriv);
	} else {
		GL_InvalidateFunction(glGenerateTextureMipmap);
		GL_InvalidateFunction(glGetTextureImage);
		GL_InvalidateFunction(glCreateTextures);
		GL_InvalidateFunction(glTextureParameteri);
		GL_InvalidateFunction(glTextureParameterf);
		GL_InvalidateFunction(glTextureParameterfv);
		GL_InvalidateFunction(glTextureParameteriv);
		GL_InvalidateFunction(glTextureStorage3D);
		GL_InvalidateFunction(glTextureStorage2D);
		GL_InvalidateFunction(glTextureSubImage2D);
		GL_InvalidateFunction(glTextureSubImage3D);
		GL_InvalidateFunction(glGetTextureLevelParameterfv);
		GL_InvalidateFunction(glGetTextureLevelParameterfv);
		GL_InvalidateFunction(glGetTextureLevelParameteriv);
	}

	if (GL_VersionAtLeast(3, 3)) {
		glConfig.supported_features |= R_SUPPORT_TEXTURE_ARRAYS;
	}

	if (GL_VersionAtLeast(4, 5)) {
		GL_LoadOptionalFunction(glGetnTexImage);
	} else {
		GL_InvalidateFunction(glGetnTexImage);
	}

	if (GL_VersionAtLeast(3, 2) || SDL_GL_ExtensionSupported("GL_ARB_seamless_cube_map")) {
		glConfig.supported_features |= R_SUPPORT_SEAMLESS_CUBEMAPS;
		glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
	}

	if (GL_VersionAtLeast(1, 3)) {
		glConfig.supported_features |= R_SUPPORT_CUBE_MAPS;
	}

	if (GL_VersionAtLeast(1, 4)) {
		glConfig.supported_features |= R_SUPPORT_FOG;
	}

	glConfig.max_multisampling_level = 0;
	glGetIntegerv(GL_MAX_SAMPLES, &glConfig.max_multisampling_level);
}

void GL_TexSubImage3D(
	int unit, texture_ref texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
	GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels
)
{
	GLenum target = GL_TextureTargetFromReference(texture);

	R_TraceLogAPICall("GL_TexSubImage3D(unit=GL_TEXTURE%d, texture=%u)", unit, GL_TextureNameFromReference(texture));
	if (target != GL_TEXTURE_CUBE_MAP && GL_Available(glTextureSubImage3D)) {
		GL_Procedure(glTextureSubImage3D, GL_TextureNameFromReference(texture), level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
	}
	else {
		renderer.TextureUnitBind(unit, texture);
		if (target == GL_TEXTURE_CUBE_MAP) {
			GL_BuiltinProcedure(glTexSubImage2D, "target=%u, level=%d, xoffset=%d, yoffset=%d, width=%d, height=%d, format=%u, type=%u, pixels=%p", GL_TEXTURE_CUBE_MAP_POSITIVE_X + zoffset, level, xoffset, yoffset, width, height, format, type, pixels);
		}
		else {
			GL_Procedure(glTexSubImage3D, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
		}
	}
}

void GL_TexSubImage2D(
	GLenum textureUnit, texture_ref texture, GLint level,
	GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels
)
{
	R_TraceLogAPICall("GL_TexSubImage2D(unit=GL_TEXTURE%d, texture=%u)", textureUnit - GL_TEXTURE0, GL_TextureNameFromReference(texture));
	if (GL_Available(glTextureSubImage2D)) {
		GL_Procedure(glTextureSubImage2D, GL_TextureNameFromReference(texture), level, xoffset, yoffset, width, height, format, type, pixels);
	}
	else {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		GL_BuiltinProcedure(glTexSubImage2D, "target=%u, level=%d, xoffset=%d, yoffset=%d, width=%d, height=%d, format=%u, type=%u, pixels=%p", target, level, xoffset, yoffset, width, height, format, type, pixels);
	}
}

void GL_TexStorage2DMultisample(texture_ref texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
	int tempWidth = width;
	int tempHeight = height;

	GL_ProcessErrors(va("pre-%s", __func__));

	R_TextureSizeRoundUp(tempWidth, tempHeight, &width, &height);

	if (GL_Available(glTextureStorage2DMultisample)) {
		GL_Procedure(glTextureStorage2DMultisample, GL_TextureNameFromReference(texture), samples, internalformat, width, height, fixedsamplelocations);
	}
	else {
		GLenum textureUnit = GL_TEXTURE0;
		GLenum target = GL_TextureTargetFromReference(texture);

		GL_BindTextureUnit(textureUnit, texture);
		if (GL_Available(glTexStorage2DMultisample)) {
			GL_Procedure(glTexStorage2DMultisample, target, samples, internalformat, width, height, fixedsamplelocations);
		}
		else if (GL_Available(glTexImage2DMultisample)) {
			GL_BindTextureUnit(textureUnit, texture);
			GL_Procedure(glTexImage2DMultisample, target, samples, internalformat, width, height, fixedsamplelocations);
		}
	}
	R_TextureSetDimensions(texture, width, height);
}

void GL_TexStorage2D(
	texture_ref texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, qbool is_lightmap
)
{
	int tempWidth = width;
	int tempHeight = height;

	GL_ProcessErrors(va("pre-%s", __func__));

	R_TextureSizeRoundUp(tempWidth, tempHeight, &width, &height);

	if (GL_Available(glTextureStorage2D)) {
		GL_Procedure(glTextureStorage2D, GL_TextureNameFromReference(texture), levels, internalformat, width, height);
	}
	else {
		GLenum textureUnit = GL_TEXTURE0;
		GLenum target = GL_TextureTargetFromReference(texture);

		GL_BindTextureUnit(textureUnit, texture);
		if (GL_Available(glTexStorage2D)) {
			GL_Procedure(glTexStorage2D, target, levels, internalformat, width, height);
		}
		else {
			int level;
			GLsizei level_width = width;
			GLsizei level_height = height;
			GLenum format = (internalformat == GL_RGBA8 || internalformat == GL_SRGB8_ALPHA8 || internalformat == GL_RGBA16F ? GL_RGBA : GL_RGB);
			GLenum type = (internalformat == GL_RGBA16F || internalformat == GL_RGB16F ? GL_FLOAT : GL_UNSIGNED_BYTE);

			// this might be completely useless (we don't upload data anyway) but just to keep all calls to the texture consistent
			format = ((is_lightmap && GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS)) ? GL_BGRA : format);
			type = ((is_lightmap && GL_Supported(R_SUPPORT_INT8888R_LIGHTMAPS)) ? GL_UNSIGNED_INT_8_8_8_8_REV : type);

			for (level = 0; level < levels; ++level) {
				GL_BuiltinProcedure(glTexImage2D, "target=%u, level=%d, internalformat=%d, width=%d, height=%d, border=%d, format=%u, type=%u, pixels=%p", target, level, internalformat, level_width, level_height, 0, format, type, NULL);

				level_width = max(1, level_width / 2);
				level_height = max(1, level_height / 2);
			}
		}
	}
	R_TextureSetDimensions(texture, width, height);
}

GLenum GL_TexStorage3D(GLenum textureUnit, texture_ref texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, qbool is_lightmap)
{
	if (GL_Available(glTextureStorage3D)) {
		GL_ProcedureReturnError(glTextureStorage3D, GL_TextureNameFromReference(texture), levels, internalformat, width, height, depth);
	}
	else if (GL_Available(glTexStorage3D)) {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		GL_ProcedureReturnError(glTexStorage3D, target, levels, internalformat, width, height, depth);
	}
	else {
		int level, z;
		GLenum target = GL_TextureTargetFromReference(texture);
		GLenum format = (internalformat == GL_RGBA8 || internalformat == GL_SRGB8_ALPHA8 || internalformat == GL_RGBA16F ? GL_RGBA : GL_RGB);
		GLenum type = (internalformat == GL_RGBA16F || internalformat == GL_RGB16F ? GL_FLOAT : GL_UNSIGNED_BYTE);

		// this might be completely useless (we don't upload data anyway) but just to keep all calls to the texture consistent
		format = ((is_lightmap && GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS)) ? GL_BGRA : format);
		type = ((is_lightmap && GL_Supported(R_SUPPORT_INT8888R_LIGHTMAPS)) ? GL_UNSIGNED_INT_8_8_8_8_REV : type);

		for (z = 0; z < depth; ++z) {
			GLsizei level_width = width;
			GLsizei level_height = height;

			for (level = 0; level < levels; ++level) {
				GL_ProcedureReturnIfError(glTexImage3D, target, level, internalformat, level_width, level_height, z, 0, format, type, NULL);

				level_width = max(1, level_width / 2);
				level_height = max(1, level_height / 2);
			}
		}
		return GL_NO_ERROR;
	}
}

void GL_TexParameterf(GLenum textureUnit, texture_ref texture, GLenum pname, GLfloat param)
{
	if (GL_Available(glTextureParameterf)) {
		GL_Procedure(glTextureParameterf, GL_TextureNameFromReference(texture), pname, param);
	}
	else {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		GL_BuiltinProcedure(glTexParameterf, "target=%u, pname=%u, param=%f", target, pname, param);
	}
}

void GL_TexParameterfv(GLenum textureUnit, texture_ref texture, GLenum pname, const GLfloat *params)
{
	if (GL_Available(glTextureParameterfv)) {
		GL_Procedure(glTextureParameterfv, GL_TextureNameFromReference(texture), pname, params);
	}
	else {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		GL_BuiltinProcedure(glTexParameterfv, "target=%u, pname=%u, params=%p", target, pname, params);
	}
}

void GL_TexParameteri(GLenum textureUnit, texture_ref texture, GLenum pname, GLint param)
{
	if (GL_Available(glTextureParameteri)) {
		GL_Procedure(glTextureParameteri, GL_TextureNameFromReference(texture), pname, param);
	}
	else {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		GL_BuiltinProcedure(glTexParameteri, "target=%u, pname=%u, param=%d", target, pname, param);
	}
}

void GL_TexParameteriv(GLenum textureUnit, texture_ref texture, GLenum pname, const GLint *params)
{
	if (GL_Available(glTextureParameteriv)) {
		GL_Procedure(glTextureParameteriv, GL_TextureNameFromReference(texture), pname, params);
	}
	else {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		GL_BuiltinProcedure(glTexParameteriv, "target=%u, pname=%u, params=%p", target, pname, params);
	}
}

void GL_CreateTextureNames(GLenum textureUnit, GLenum target, GLsizei n, GLuint* textures)
{
	int i;

	if (GL_Available(glCreateTextures)) {
		GL_Procedure(glCreateTextures, target, n, textures);
	}
	else {
		GL_BuiltinProcedure(glGenTextures, "n=%d, textures=%p", n, textures);
	}

	// glCreateTextures() shouldn't require this, but textures can't be sampled from buggy AMD drivers (reporting x.y.13399) otherwise
	// see https://github.com/ezQuake/ezquake-source/issues/416
	for (i = 0; i < n; ++i) {
		GL_BindTextureToTarget(textureUnit, target, textures[i]);
	}
}

void GL_GetTexLevelParameteriv(GLenum textureUnit, texture_ref texture, GLint level, GLenum pname, GLint* params)
{
	if (GL_Available(glGetTextureLevelParameteriv)) {
		GL_Procedure(glGetTextureLevelParameteriv, GL_TextureNameFromReference(texture), level, pname, params);
	}
	else {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		GL_BuiltinProcedure(glGetTexLevelParameteriv, "target=%u, level=%d, pname=%u, params=%p", target, level, pname, params);
	}
}

void GL_GetTexImage(GLenum textureUnit, texture_ref texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* buffer)
{
	GL_PackAlignment(1);
	if (GL_Available(glGetTextureImage)) {
		GL_Procedure(glGetTextureImage, GL_TextureNameFromReference(texture), level, format, type, bufSize, buffer);
	}
	else {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		if (GL_Available(glGetnTexImage)) {
			GL_Procedure(glGetnTexImage, target, level, format, type, bufSize, buffer);
		}
		else {
			GL_BuiltinProcedure(glGetTexImage, "target=%u, level=%d, format=%u, type=%u, buffer=%p", target, level, format, type, buffer);
		}
	}
}

void GL_TextureMipmapGenerateWithData(GLenum textureUnit, texture_ref texture, byte* newdata, int width, int height, GLint internal_format)
{
	if (GL_Available(glGenerateTextureMipmap)) {
		GL_Procedure(glGenerateTextureMipmap, GL_TextureNameFromReference(texture));
	}
	else {
		GLenum target = GL_TextureTargetFromReference(texture);
		GL_BindTextureUnit(textureUnit, texture);
		if (GL_Available(glGenerateMipmap)) {
			GL_Procedure(glGenerateMipmap, target);
		}
		else if (newdata) {
			int miplevel = 0;

			// Calculate the mip maps for the images.
			while (width > 1 || height > 1) {
				Image_MipReduce((byte *)newdata, (byte *)newdata, &width, &height, 4);
				miplevel++;
				GL_TexSubImage2D(GL_TEXTURE0, texture, miplevel, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, newdata);
			}
		}
	}
}

void GL_TextureMipmapGenerate(texture_ref texture)
{
	GL_TextureMipmapGenerateWithData(GL_TEXTURE0, texture, NULL, 0, 0, 0);
}

void GL_SamplerSetNearest(unsigned int texture_unit_number)
{
	if (!nearest_sampler) {
		GL_Procedure(glGenSamplers, 1, &nearest_sampler);

		GL_Procedure(glSamplerParameterf, nearest_sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		GL_Procedure(glSamplerParameterf, nearest_sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}

	GL_Procedure(glBindSampler, texture_unit_number, nearest_sampler);
}

void GL_SamplerSetLinear(unsigned int texture_unit_number)
{
	if (!linear_sampler) {
		GL_Procedure(glGenSamplers, 1, &linear_sampler);

		GL_Procedure(glSamplerParameterf, linear_sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		GL_Procedure(glSamplerParameterf, linear_sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	}

	GL_Procedure(glBindSampler, texture_unit_number, linear_sampler);
}

void GL_SamplerClear(unsigned int texture_unit_number)
{
	GL_Procedure(glBindSampler, texture_unit_number, 0);
}

void GL_DeleteSamplers(void)
{
	if (GL_Available(glDeleteSamplers)) {
		GL_Procedure(glDeleteSamplers, 1, &nearest_sampler);
	}
	nearest_sampler = 0;
}

// meag: *RGBA is bit ugly, just trying to keep OpenGL enums out of the way for now
void GL_TextureReplaceSubImageRGBA(texture_ref ref, int offsetx, int offsety, int width, int height, byte* buffer)
{
	GL_TexSubImage2D(GL_TEXTURE0, ref, 0, offsetx, offsety, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
}


================================================
FILE: src/gl_texture_internal.h
================================================
/*
Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef GL_TEXTURE_INTERNAL_HEADER
#define GL_TEXTURE_INTERNAL_HEADER

#include "r_texture.h"
#include "gl_model.h"
#include "gl_local.h"

// --------------
// Texture functions
// --------------

// Replaces top-level of a texture - if dimensions don't match then texture is reloaded
void GL_TextureReplace2D(
	GLenum textureUnit, GLenum target, texture_ref* ref, GLint internalformat,
	GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels
);
const char* GL_TextureIdentifierByGLReference(GLuint texnum);
void GL_SelectTexture(GLenum target);

void GL_CreateTexturesWithIdentifier(r_texture_type_id type, int n, texture_ref* references, const char* identifier);
void GL_TexStorage2D(texture_ref reference, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, qbool is_lightmap);
GLenum GL_TexStorage3D(GLenum textureUnit, texture_ref reference, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, qbool is_lightmap);
void GL_TexStorage2DMultisample(texture_ref texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
void GL_TextureMipmapGenerate(texture_ref reference);
void GL_TextureMipmapGenerateWithData(GLenum textureUnit, texture_ref texture, byte* newdata, int width, int height, GLint internal_format);

void GL_TexParameterf(GLenum textureUnit, texture_ref reference, GLenum pname, GLfloat param);
void GL_TexParameterfv(GLenum textureUnit, texture_ref reference, GLenum pname, const GLfloat *params);
void GL_TexParameteri(GLenum textureUnit, texture_ref reference, GLenum pname, GLint param);
void GL_TexParameteriv(GLenum textureUnit, texture_ref reference, GLenum pname, const GLint *params);
void GL_GetTexLevelParameteriv(GLenum textureUnit, texture_ref reference, GLint level, GLenum pname, GLint* params);

void GL_TexSubImage2D(GLenum textureUnit, texture_ref reference, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
void GL_TexSubImage3D(int textureUnit, texture_ref reference, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels);
void GL_GetTexImage(GLenum textureUnit, texture_ref reference, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* buffer);

void GL_BindTextureUnit(GLuint unit, texture_ref reference);
qbool GL_EnsureTextureUnitBound(int unit, texture_ref reference);

void GL_CreateTextureNames(GLenum textureUnit, GLenum target, GLsizei n, GLuint* textures);
void GL_BindTextureToTarget(GLenum textureUnit, GLenum targetType, GLuint name);

#endif // GL_TEXTURE_INTERNAL_HEADER


================================================
FILE: src/glc_aliasmodel.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// Alias model (.mdl) rendering, classic (immediate mode) GL only
// Most code taken from gl_rmain.c
#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "vx_stuff.h"
#include "vx_vertexlights.h"
#include "utils.h"
#include "qsound.h"
#include "hud.h"
#include "hud_common.h"
#include "rulesets.h"
#include "teamplay.h"
#include "r_aliasmodel.h"
#include "crc.h"
#include "r_matrix.h"
#include "r_state.h"
#include "r_texture.h"
#include "r_vao.h"
#include "glc_vao.h"
#include "r_brushmodel.h" // R_PointIsUnderwater only
#include "r_buffers.h"
#include "glc_local.h"
#include "glc_matrix.h"
#include "glc_state.h"
#include "r_program.h"
#include "tr_types.h"
#include "r_renderer.h"

static void GLC_DrawAliasModelShadowDrawCall(entity_t* ent, vec3_t shadevector);
static void GLC_DrawCachedAliasOutlineFrame(model_t* model, GLenum primitive, int firstVert, int verts, qbool weaponmodel);

extern float r_avertexnormals[NUMVERTEXNORMALS][3];

extern cvar_t    r_lerpframes;
extern cvar_t    gl_outline;
extern cvar_t    gl_program_aliasmodels;
extern cvar_t    gl_smoothmodels;

extern float     r_framelerp;

// Temporary r_lerpframes fix, unless we go for shaders-in-classic...
//   After all models loaded, this needs to be allocated enough space to hold a complete pose of verts
//   We fill it in with the lerped positions, then render model from there
// Ugly, but don't think there's another way to do this in fixed pipeline
typedef struct glc_aliasmodel_vert_s {
	float position[3];
	float texture_coords[2];
	byte color[4];
} glc_aliasmodel_vert_t;

static glc_aliasmodel_vert_t* temp_aliasmodel_buffer;
static int temp_aliasmodel_buffer_size;

static void GLC_ConfigureAliasModelState(void)
{
	extern cvar_t gl_vbo_clientmemory;

	if (gl_program_aliasmodels.integer) {
		R_GenVertexArray(vao_aliasmodel);
		GLC_VAOSetVertexBuffer(vao_aliasmodel, r_buffer_aliasmodel_vertex_data);
		GLC_VAOEnableVertexPointer(vao_aliasmodel, 3, GL_FLOAT, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, position));
		GLC_VAOEnableNormalPointer(vao_aliasmodel, 3, GL_FLOAT, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, normal));
		GLC_VAOEnableTextureCoordPointer(vao_aliasmodel, 0, 2, GL_FLOAT, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, texture_coords));
		GLC_VAOEnableTextureCoordPointer(vao_aliasmodel, 1, 3, GL_FLOAT, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, direction));
		GLC_VAOEnableCustomAttribute(vao_aliasmodel, 0, r_program_attribute_aliasmodel_std_glc_flags, 1, GL_INT, false, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, flags));
		GLC_VAOEnableCustomAttribute(vao_aliasmodel, 1, r_program_attribute_aliasmodel_shell_glc_flags, 1, GL_INT, false, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, flags));
		GLC_VAOEnableCustomAttribute(vao_aliasmodel, 2, r_program_attribute_aliasmodel_shadow_glc_flags, 1, GL_INT, false, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, flags));
		GLC_VAOEnableCustomAttribute(vao_aliasmodel, 3, r_program_attribute_aliasmodel_outline_glc_flags, 1, GL_INT, false, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, flags));
	}
	else {
		if (gl_vbo_clientmemory.integer) {
			R_GenVertexArray(vao_aliasmodel);
			GLC_VAOEnableVertexPointer(vao_aliasmodel, 3, GL_FLOAT, sizeof(temp_aliasmodel_buffer[0]), &temp_aliasmodel_buffer[0].position[0]);
			GLC_VAOEnableTextureCoordPointer(vao_aliasmodel, 0, 2, GL_FLOAT, sizeof(temp_aliasmodel_buffer[0]), &temp_aliasmodel_buffer[0].texture_coords[0]);
			GLC_VAOEnableTextureCoordPointer(vao_aliasmodel, 1, 2, GL_FLOAT, sizeof(temp_aliasmodel_buffer[0]), &temp_aliasmodel_buffer[0].texture_coords[0]);
			GLC_VAOEnableColorPointer(vao_aliasmodel, 4, GL_UNSIGNED_BYTE, sizeof(temp_aliasmodel_buffer[0]), &temp_aliasmodel_buffer[0].color[0]);
		}
		else {
			R_GenVertexArray(vao_aliasmodel);
			GLC_VAOSetVertexBuffer(vao_aliasmodel, r_buffer_aliasmodel_glc_pose_data);
			GLC_VAOEnableVertexPointer(vao_aliasmodel, 3, GL_FLOAT, sizeof(temp_aliasmodel_buffer[0]), VBO_FIELDOFFSET(glc_aliasmodel_vert_t, position));
			GLC_VAOEnableTextureCoordPointer(vao_aliasmodel, 0, 2, GL_FLOAT, sizeof(temp_aliasmodel_buffer[0]), VBO_FIELDOFFSET(glc_aliasmodel_vert_t, texture_coords));
			GLC_VAOEnableTextureCoordPointer(vao_aliasmodel, 1, 2, GL_FLOAT, sizeof(temp_aliasmodel_buffer[0]), VBO_FIELDOFFSET(glc_aliasmodel_vert_t, texture_coords));
			GLC_VAOEnableColorPointer(vao_aliasmodel, 4, GL_UNSIGNED_BYTE, sizeof(temp_aliasmodel_buffer[0]), VBO_FIELDOFFSET(glc_aliasmodel_vert_t, color));
		}

		R_GenVertexArray(vao_aliasmodel_powerupshell);
		GLC_VAOEnableVertexPointer(vao_aliasmodel_powerupshell, 3, GL_FLOAT, sizeof(temp_aliasmodel_buffer[0]), &temp_aliasmodel_buffer[0].position);
		GLC_VAOEnableTextureCoordPointer(vao_aliasmodel_powerupshell, 0, 2, GL_FLOAT, sizeof(temp_aliasmodel_buffer[0]), &temp_aliasmodel_buffer[0].texture_coords[0]);
	}
}

void GLC_AllocateAliasPoseBuffer(void)
{
	if (!gl_program_aliasmodels.integer) {
		int max_verts = 0;
		int i;

		for (i = 1; i < MAX_MODELS; ++i) {
			model_t* mod = cl.model_precache[i];

			if (mod && mod->type == mod_alias) {
				aliashdr_t* hdr = (aliashdr_t *)Mod_Extradata(mod);

				if (hdr) {
					max_verts = max(max_verts, hdr->vertsPerPose);
				}
			}
		}

		for (i = 0; i < MAX_VWEP_MODELS; i++) {
			model_t* mod = cl.vw_model_precache[i];

			if (mod && mod->type == mod_alias) {
				aliashdr_t* hdr = (aliashdr_t *)Mod_Extradata(mod);

				if (hdr) {
					max_verts = max(max_verts, hdr->vertsPerPose);
				}
			}
		}

		for (i = 0; i < custom_model_count; ++i) {
			model_t* mod = Mod_CustomModel(i, false);

			if (mod && mod->type == mod_alias) {
				aliashdr_t* hdr = (aliashdr_t *)Mod_Extradata(mod);

				if (hdr) {
					max_verts = max(max_verts, hdr->vertsPerPose);
				}
			}
		}

		if (temp_aliasmodel_buffer == NULL || temp_aliasmodel_buffer_size < max_verts) {
			Q_free(temp_aliasmodel_buffer);
			temp_aliasmodel_buffer = Q_malloc(sizeof(temp_aliasmodel_buffer[0]) * max_verts);
			temp_aliasmodel_buffer_size = max_verts;
		}

		if (R_BufferReferenceIsValid(r_buffer_aliasmodel_glc_pose_data)) {
			buffers.Resize(r_buffer_aliasmodel_glc_pose_data, sizeof(temp_aliasmodel_buffer[0]) * max_verts, NULL);
		}
		else {
			buffers.Create(r_buffer_aliasmodel_glc_pose_data, buffertype_vertex, "glc-alias-pose", sizeof(temp_aliasmodel_buffer[0]) * max_verts, NULL, bufferusage_reuse_per_frame);
		}
	}

	GLC_ConfigureAliasModelState();
}

void GLC_FreeAliasPoseBuffer(void)
{
	Q_free(temp_aliasmodel_buffer);
	temp_aliasmodel_buffer_size = 0;
}

static void GLC_AliasModelLightPoint(float color[4], entity_t* ent, vbo_model_vert_t* verts1, vbo_model_vert_t* verts2, float lerpfrac)
{
	float l;

	// VULT VERTEX LIGHTING
	if (amf_lighting_vertex.integer && !ent->full_light) {
		vec3_t lc;

		l = VLight_LerpLight(verts1->lightnormalindex, verts2->lightnormalindex, lerpfrac, ent->angles[0], ent->angles[1]);
		l *= (ent->shadelight + ent->ambientlight) / 256.0;
		l = min(l, 1);

		if (amf_lighting_colour.integer) {
			int i;
			for (i = 0; i < 3; i++) {
				lc[i] = l * ent->lightcolor[i] / 255;
				lc[i] = min(lc[i], 1);
			}
		}
		else {
			VectorSet(lc, l, l, l);
		}

		if (ent->r_modelcolor[0] < 0) {
			// normal color
			VectorCopy(lc, color);
		}
		else {
			color[0] = ent->r_modelcolor[0] * lc[0];
			color[1] = ent->r_modelcolor[1] * lc[1];
			color[2] = ent->r_modelcolor[2] * lc[2];
		}
	}
	else {
		l = FloatInterpolate(shadedots[verts1->lightnormalindex], lerpfrac, shadedots[verts2->lightnormalindex]) / 127.0;
		l = (l * ent->shadelight + ent->ambientlight) / 256.0;
		l = min(l, 1);

		if (ent->custom_model == NULL) {
			if (ent->r_modelcolor[0] < 0) {
				color[0] = color[1] = color[2] = l;
			}
			else {
				color[0] = ent->r_modelcolor[0] * l;
				color[1] = ent->r_modelcolor[1] * l;
				color[2] = ent->r_modelcolor[2] * l;
			}
		}
		else {
			color[0] = ent->custom_model->color_cvar.color[0] / 255.0f;
			color[1] = ent->custom_model->color_cvar.color[1] / 255.0f;
			color[2] = ent->custom_model->color_cvar.color[2] / 255.0f;
		}
	}

	color[0] *= ent->r_modelalpha;
	color[1] *= ent->r_modelalpha;
	color[2] *= ent->r_modelalpha;
	color[3] = ent->r_modelalpha;
}

#define DRAWFLAGS_CAUSTICS     1
#define DRAWFLAGS_TEXTURED     2
#define DRAWFLAGS_FULLBRIGHT   4
#define DRAWFLAGS_MUZZLEHACK   8
//#define DRAWFLAGS_FLATSHADING  16     // Disabled until we can specify GLSL 1.3 dynamically, MESA drivers very strict
#define DRAWFLAGS_MAXIMUM      (DRAWFLAGS_CAUSTICS | DRAWFLAGS_TEXTURED | DRAWFLAGS_FULLBRIGHT | DRAWFLAGS_MUZZLEHACK /* | DRAWFLAGS_FLATSHADING*/)

int GLC_AliasModelSubProgramIndex(qbool textured, qbool fullbright, qbool caustics, qbool muzzlehack)
{
	// gl_smoothmodels disabled for now
	return
		(textured ? DRAWFLAGS_TEXTURED : 0) | 
		(fullbright ? DRAWFLAGS_FULLBRIGHT : 0) | /*(gl_smoothmodels.integer ? 0 : DRAWFLAGS_FLATSHADING)) |*/
		(caustics ? DRAWFLAGS_CAUSTICS : 0) | 
		(muzzlehack ? DRAWFLAGS_MUZZLEHACK : 0);
}

qbool GLC_AliasModelStandardCompileSpecific(int subprogram_index)
{
	int flags = subprogram_index;

	R_ProgramSetSubProgram(r_program_aliasmodel_std_glc, subprogram_index);
	if (R_ProgramRecompileNeeded(r_program_aliasmodel_std_glc, flags)) {
		char included_definitions[512];

		included_definitions[0] = '\0';
		if (subprogram_index & DRAWFLAGS_TEXTURED) {
			strlcat(included_definitions, "#define TEXTURING_ENABLED\n", sizeof(included_definitions));
		}
		if (subprogram_index & DRAWFLAGS_FULLBRIGHT) {
			strlcat(included_definitions, "#define FULLBRIGHT_MODELS\n", sizeof(included_definitions));
		}
		if (subprogram_index & DRAWFLAGS_CAUSTICS) {
			strlcat(included_definitions, "#define DRAW_CAUSTIC_TEXTURES\n", sizeof(included_definitions));
		}
		if (subprogram_index & DRAWFLAGS_MUZZLEHACK) {
			strlcat(included_definitions, "#define EZQ_ALIASMODEL_MUZZLEHACK\n", sizeof(included_definitions));
		}
#ifdef DRAWFLAGS_FLATSHADING
		if (subprogram_index & DRAWFLAGS_FLATSHADING) {
			strlcat(included_definitions, "#define EZQ_ALIASMODEL_FLATSHADING\n", sizeof(included_definitions));
		}
#endif
		R_ProgramCompileWithInclude(r_program_aliasmodel_std_glc, included_definitions);
		R_ProgramUniform1i(r_program_uniform_aliasmodel_std_glc_texSampler, 0);
		R_ProgramUniform1i(r_program_uniform_aliasmodel_std_glc_causticsSampler, 1);
		R_ProgramSetCustomOptions(r_program_aliasmodel_std_glc, flags);
	}

	R_ProgramSetStandardUniforms(r_program_aliasmodel_std_glc);

	return R_ProgramReady(r_program_aliasmodel_std_glc);
}

// Only called from vid system startup, not from rendering loop
qbool GLC_AliasModelStandardCompile(void)
{
	int i;

	for (i = 0; i < DRAWFLAGS_MAXIMUM; ++i) {
		GLC_AliasModelStandardCompileSpecific(i);
	}

	return true;
}

qbool GLC_AliasModelShadowCompile(void)
{
	if (R_ProgramRecompileNeeded(r_program_aliasmodel_shadow_glc, 0)) {
		R_ProgramCompile(r_program_aliasmodel_shadow_glc);
	}

	R_ProgramSetStandardUniforms(r_program_aliasmodel_shadow_glc);

	return R_ProgramReady(r_program_aliasmodel_shadow_glc);
}

qbool GLC_AliasModelShellCompile(void)
{
	extern cvar_t r_lerpmuzzlehack;
	int flags = (r_lerpmuzzlehack.integer ? DRAWFLAGS_MUZZLEHACK : 0);

	if (R_ProgramRecompileNeeded(r_program_aliasmodel_shell_glc, flags)) {
		char included_definitions[512];

		included_definitions[0] = '\0';
		if (flags & DRAWFLAGS_MUZZLEHACK) {
			strlcat(included_definitions, "#define EZQ_ALIASMODEL_MUZZLEHACK\n", sizeof(included_definitions));
		}

		R_ProgramCompileWithInclude(r_program_aliasmodel_shell_glc, included_definitions);
		R_ProgramUniform1i(r_program_uniform_aliasmodel_shell_glc_texSampler, 0);
		R_ProgramSetCustomOptions(r_program_aliasmodel_shell_glc, flags);
	}

	R_ProgramSetStandardUniforms(r_program_aliasmodel_shell_glc);

	return R_ProgramReady(r_program_aliasmodel_shell_glc);
}

qbool GLC_AliasModelOutlineCompile(void)
{
	extern cvar_t r_lerpmuzzlehack;
	int flags = (r_lerpmuzzlehack.integer ? DRAWFLAGS_MUZZLEHACK : 0);

	if (R_ProgramRecompileNeeded(r_program_aliasmodel_outline_glc, flags)) {
		char included_definitions[512];

		strlcpy(included_definitions, "#define BACKFACE_PASS\n", sizeof(included_definitions));
		if (flags & DRAWFLAGS_MUZZLEHACK) {
			strlcat(included_definitions, "#define EZQ_ALIASMODEL_MUZZLEHACK\n", sizeof(included_definitions));
		}

		R_ProgramCompileWithInclude(r_program_aliasmodel_outline_glc, included_definitions);
		R_ProgramSetCustomOptions(r_program_aliasmodel_outline_glc, flags);
	}

	return R_ProgramReady(r_program_aliasmodel_outline_glc);
}

static void GLC_DrawAliasFrameImpl_Program(entity_t* ent, model_t* model, int pose1, int pose2, texture_ref texture, texture_ref fb_texture, qbool outline, int effects, int render_effects, float lerpfrac)
{
	extern cvar_t r_lerpmuzzlehack, gl_program_aliasmodels;
	aliashdr_t* paliashdr = (aliashdr_t*)Mod_Extradata(model);
	float color[4];
	qbool invalidate_texture;
	float angle_radians = -ent->angles[YAW] * M_PI / 180.0;
	vec3_t angle_vector = { cos(angle_radians), sin(angle_radians), 1 };
	int firstVert = model->vbo_start + pose1 * paliashdr->vertsPerPose;
	int subprogram;

	if (outline) {
		if (buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_AliasModelOutlineCompile()) {
			R_ProgramUse(r_program_aliasmodel_outline_glc);
			R_ProgramUniform1f(r_program_uniform_aliasmodel_outline_glc_lerpFraction, lerpfrac);
			R_ProgramUniform1f(r_program_uniform_aliasmodel_outline_glc_outlineScale, ent->outlineScale);
			GLC_DrawCachedAliasOutlineFrame(model, GL_TRIANGLES, firstVert, paliashdr->vertsPerPose, ent->renderfx & RF_WEAPONMODEL);
		}
	}
	else {
		VectorNormalize(angle_vector);
		R_AliasModelColor(ent, color, &invalidate_texture);

		subprogram = GLC_AliasModelSubProgramIndex(
			!invalidate_texture,
			gl_fb_models.integer && (ent->ambientlight == 4096 && ent->shadelight == 4096),
			r_refdef2.drawCaustics && (render_effects & RF_CAUSTICS),
			r_lerpmuzzlehack.integer && (render_effects & RF_WEAPONMODEL)
		);

		if (buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_AliasModelStandardCompileSpecific(subprogram)) {
			R_ProgramUse(r_program_aliasmodel_std_glc);
			R_ProgramUniform3fv(r_program_uniform_aliasmodel_std_glc_angleVector, angle_vector);
			R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_shadelight, ent->shadelight / 256.0f);
			R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_ambientlight, ent->ambientlight / 256.0f);
			R_ProgramUniform1i(r_program_uniform_aliasmodel_std_glc_fsTextureEnabled, invalidate_texture ? 0 : 1);
			R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_fsMinLumaMix, 1.0f - (ent->full_light ? bound(0, gl_fb_models.integer, 1) : 0));
			R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_fsCausticEffects, render_effects & RF_CAUSTICS ? 1 : 0);
			R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_lerpFraction, lerpfrac);
			R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_time, cl.time);

			if (ent->r_modelalpha < 1) {
				GLC_StateBeginDrawAliasZPass(render_effects & RF_WEAPONMODEL);
				GL_DrawArrays(GL_TRIANGLES, firstVert, paliashdr->vertsPerPose);
			}
			GLC_StateBeginDrawAliasFrameProgram(texture, underwatertexture, render_effects, ent->custom_model, ent->r_modelalpha, false);
			R_CustomColor(color[0], color[1], color[2], color[3]);
			GL_DrawArrays(GL_TRIANGLES, firstVert, paliashdr->vertsPerPose);
			if (render_effects & RF_CAUSTICS) {
				GLC_StateEndUnderwaterAliasModelCaustics();
			}
			R_ProgramUse(r_program_none);
		}
	}
}

static void GLC_DrawAliasFrameImpl_Immediate_Cache(aliashdr_t* paliashdr, entity_t* ent, vbo_model_vert_t* verts1, vbo_model_vert_t* verts2, float lerpfracDefault, qbool limit_lerp, qbool outline, qbool mtex)
{
	int i;
	vec3_t interpolated_verts;

	for (i = 0; i < paliashdr->vertsPerPose; ++i, ++verts1, ++verts2) {
		float color[4];
		float s = verts1->texture_coords[0];
		float t = verts1->texture_coords[1];
		float lerpfrac = lerpfracDefault;

		if (limit_lerp && !VectorL2Compare(verts1->position, verts2->position, ALIASMODEL_MAX_LERP_DISTANCE)) {
			lerpfrac = 1;
		}

		GLC_AliasModelLightPoint(color, ent, verts1, verts2, lerpfrac);
		if (outline) {
			vec3_t v1, v2;
			VectorMA(verts1->position, ent->outlineScale, verts1->normal, v1);
			VectorMA(verts2->position, ent->outlineScale, verts2->normal, v2);
			VectorInterpolate(v1, lerpfrac, v2, interpolated_verts);
		}
		else {
			VectorInterpolate(verts1->position, lerpfrac, verts2->position, interpolated_verts);
		}
		temp_aliasmodel_buffer[i].texture_coords[0] = s;
		temp_aliasmodel_buffer[i].texture_coords[1] = t;
		temp_aliasmodel_buffer[i].color[0] = color[0] * 255;
		temp_aliasmodel_buffer[i].color[1] = color[1] * 255;
		temp_aliasmodel_buffer[i].color[2] = color[2] * 255;
		temp_aliasmodel_buffer[i].color[3] = color[3] * 255;
		VectorCopy(interpolated_verts, temp_aliasmodel_buffer[i].position);
	}
}

static void GLC_DrawAliasFrameImpl_Immediate_TrueImmediate(aliashdr_t* paliashdr, qbool mtex)
{
	int i;

	GLC_Begin(GL_TRIANGLES);
	for (i = 0; i < paliashdr->vertsPerPose; ++i) {
		// texture coordinates come from the draw list
		float s = temp_aliasmodel_buffer[i].texture_coords[0];
		float t = temp_aliasmodel_buffer[i].texture_coords[1];
		byte* color = temp_aliasmodel_buffer[i].color;

		if (mtex) {
			GLC_MultiTexCoord2f(GL_TEXTURE0, s, t);
			GLC_MultiTexCoord2f(GL_TEXTURE1, s, t);
		}
		else {
			glTexCoord2f(s, t);
		}
		R_CustomColor4ubv(color);
		GLC_Vertex3fv(temp_aliasmodel_buffer[i].position);
	}
	GLC_End();
}

static void GLC_DrawAliasFrameImpl_Immediate(entity_t* ent, model_t* model, int pose1, int pose2, texture_ref texture, texture_ref fb_texture, qbool outline, int effects, int render_effects, float lerpfracDefault)
{
	extern cvar_t r_lerpmuzzlehack;

	aliashdr_t* paliashdr = (aliashdr_t*)Mod_Extradata(model);
	qbool cache = buffers.supported && temp_aliasmodel_buffer_size >= paliashdr->poseverts;
	qbool mtex = R_TextureReferenceIsValid(fb_texture) && gl_mtexable;
	vbo_model_vert_t* vbo_buffer = (vbo_model_vert_t*)model->temp_vbo_buffer;
	vbo_model_vert_t* verts1, * verts2;
	qbool limit_lerp = r_lerpmuzzlehack.integer && (ent->model->renderfx & RF_LIMITLERP);
	qbool alpha_blend = (render_effects & RF_ALPHABLEND) || ent->r_modelalpha < 1;
	qbool is_weapon_model = (ent->renderfx & RF_WEAPONMODEL);

	verts1 = &vbo_buffer[pose1 * paliashdr->poseverts];
	verts2 = &vbo_buffer[pose2 * paliashdr->poseverts];

	GLC_DrawAliasFrameImpl_Immediate_Cache(paliashdr, ent, verts1, verts2, lerpfracDefault, limit_lerp, outline, mtex);
	if (cache) {
		buffers.Update(r_buffer_aliasmodel_glc_pose_data, sizeof(temp_aliasmodel_buffer[0]) * paliashdr->vertsPerPose, temp_aliasmodel_buffer);
	}

	R_ProgramUse(r_program_none);
	if (alpha_blend && !outline) {
		GLC_StateBeginDrawAliasZPass(is_weapon_model);
		if (cache) {
			GL_DrawArrays(GL_TRIANGLES, 0, paliashdr->vertsPerPose);
		}
		else {
			GLC_DrawAliasFrameImpl_Immediate_TrueImmediate(paliashdr, mtex);
		}
	}

	if (outline) {
		GLC_StateBeginAliasOutlineFrame(is_weapon_model);
	}
	else if (render_effects & RF_CAUSTICS) {
		GLC_StateBeginUnderwaterAliasModelCaustics(texture, fb_texture);
	}
	else {
		GLC_StateBeginDrawAliasFrame(texture, fb_texture, mtex, alpha_blend, ent->custom_model, is_weapon_model);
	}

	if (cache) {
		GL_DrawArrays(GL_TRIANGLES, 0, paliashdr->vertsPerPose);
	}
	else {
		GLC_DrawAliasFrameImpl_Immediate_TrueImmediate(paliashdr, mtex);
	}

	if (render_effects & RF_CAUSTICS) {
		GLC_StateEndUnderwaterAliasModelCaustics();
	}
}

void GLC_DrawAliasFrame(entity_t* ent, model_t* model, int pose1, int pose2, texture_ref texture, texture_ref fb_texture, qbool outline, int effects, int render_effects, float lerpfrac)
{
	qbool draw_caustics = r_refdef2.drawCaustics && gl_mtexable && R_PointIsUnderwater(ent->origin);

	if (gl_program_aliasmodels.integer) {
		GLC_DrawAliasFrameImpl_Program(ent, model, pose1, pose2, texture, fb_texture, outline, effects, render_effects | (draw_caustics ? RF_CAUSTICS : 0), lerpfrac);
	}
	else if (outline) {
		GLC_DrawAliasFrameImpl_Immediate(ent, model, pose1, pose2, texture, fb_texture, outline, effects, render_effects, lerpfrac);
	}
	else {
		if (R_TextureReferenceIsValid(fb_texture) && gl_mtexable) {
			GLC_DrawAliasFrameImpl_Immediate(ent, model, pose1, pose2, texture, fb_texture, outline, effects, render_effects, lerpfrac);
		}
		else {
			GLC_DrawAliasFrameImpl_Immediate(ent, model, pose1, pose2, texture, null_texture_reference, outline, effects, render_effects, lerpfrac);

			if (R_TextureReferenceIsValid(fb_texture)) {
				GLC_DrawAliasFrameImpl_Immediate(ent, model, pose1, pose2, fb_texture, null_texture_reference, false, effects, render_effects | RF_ALPHABLEND, lerpfrac);
			}
		}

		if (draw_caustics) {
			GLC_DrawAliasFrameImpl_Immediate(ent, model, pose1, pose2, texture, underwatertexture, false, 0, RF_ALPHABLEND | RF_CAUSTICS, lerpfrac);
		}
	}
}

// This can be used with program or immediate mode
static void GLC_DrawCachedAliasOutlineFrame(model_t* model, GLenum primitive, int firstVert, int verts, qbool weaponmodel)
{
	GLC_StateBeginAliasOutlineFrame(weaponmodel);

	GL_DrawArrays(primitive, firstVert, verts);
}

void GLC_PowerupShellColor(int layer_no, int effects, float* color)
{
	// set color: alpha so we can see colour underneath still
	float base_level = bound(0, (layer_no == 0 ? gl_powerupshells_base1level.value : gl_powerupshells_base2level.value), 1);
	float effect_level = bound(0, (layer_no == 0 ? gl_powerupshells_effect1level.value : gl_powerupshells_effect2level.value), 1);
	float shell_alpha = bound(0, gl_powerupshells.value, 1);

	color[0] = (base_level + ((effects & EF_RED) ? effect_level : 0)) * shell_alpha;
	color[1] = (base_level + ((effects & EF_GREEN) ? effect_level : 0)) * shell_alpha;
	color[2] = (base_level + ((effects & EF_BLUE) ? effect_level : 0)) * shell_alpha;
	color[3] = shell_alpha;
}

void GLC_SetPowerupShellColor(int layer_no, int effects)
{
	float color[4];

	GLC_PowerupShellColor(layer_no, effects, color);

	R_CustomColor(color[0], color[1], color[2], color[3]);
}

const float* GLC_PowerupShell_ScrollParams(void)
{
	return r_refdef2.powerup_scroll_params;
}

static void GLC_DrawPowerupShell_Program(entity_t* ent, int pose1, float fraclerp)
{
	if (buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_AliasModelShellCompile()) {
		aliashdr_t* paliashdr = (aliashdr_t*)Mod_Extradata(ent->model);
		int firstVert = ent->model->vbo_start + pose1 * paliashdr->vertsPerPose;
		float color1[4], color2[4];

		GLC_PowerupShellColor(0, ent->effects, color1);
		GLC_PowerupShellColor(1, ent->effects, color2);

		R_ProgramUse(r_program_aliasmodel_shell_glc);
		GLC_StateBeginAliasPowerupShell(ent->renderfx & RF_WEAPONMODEL);
		GLC_BindVertexArrayAttributes(vao_aliasmodel);
		R_ProgramUniform4fv(r_program_uniform_aliasmodel_shell_glc_fsBaseColor1, color1);
		R_ProgramUniform4fv(r_program_uniform_aliasmodel_shell_glc_fsBaseColor2, color2);
		R_ProgramUniform4fv(r_program_uniform_aliasmodel_shell_glc_scroll, GLC_PowerupShell_ScrollParams());
		R_ProgramUniform1f(r_program_uniform_aliasmodel_shell_glc_lerpFraction, fraclerp);
		GL_DrawArrays(GL_TRIANGLES, firstVert, paliashdr->vertsPerPose);
		R_ProgramUse(r_program_none);
	}
}

static void GLC_DrawPowerupShell_Immediate(entity_t* ent, int pose1, int pose2, float fraclerp)
{
	ez_trivertx_t* verts1;
	ez_trivertx_t* verts2;
	int layer_no;
	int *order, count;
	vec3_t v1, v2, v;
	aliashdr_t* paliashdr = (aliashdr_t*)Mod_Extradata(ent->model);

	qbool cache = buffers.supported && temp_aliasmodel_buffer_size >= paliashdr->poseverts;
	int position;
	const float* scroll = GLC_PowerupShell_ScrollParams();

	R_ProgramUse(r_program_none);
	GLC_StateBeginAliasPowerupShell(ent->renderfx & RF_WEAPONMODEL);
	for (position = 0, layer_no = 0; layer_no <= 1; ++layer_no) {
		// get the vertex count and primitive type
		order = (int *)((byte *)paliashdr + paliashdr->commands);
		verts1 = verts2 = (ez_trivertx_t *)((byte *)paliashdr + paliashdr->posedata);
		verts1 += pose1 * paliashdr->poseverts;
		verts2 += pose2 * paliashdr->poseverts;

		for (;;) {
			GLenum drawMode = GL_TRIANGLE_STRIP;

			count = *order++;
			if (!count) {
				break;
			}

			if (count < 0) {
				count = -count;
				drawMode = GL_TRIANGLE_FAN;
			}

			if (!cache) {
				GLC_SetPowerupShellColor(layer_no, ent->effects);
				GLC_Begin(drawMode);
			}

			do {
				float s = ((float *)order)[0] * 2.0f + scroll[layer_no * 2];
				float t = ((float *)order)[1] * 2.0f + scroll[layer_no * 2 + 1];

				order += 2;

				VectorMA(verts1->v, 0.5f, r_avertexnormals[verts1->lightnormalindex], v1);
				VectorMA(verts2->v, 0.5f, r_avertexnormals[verts2->lightnormalindex], v2);
				VectorInterpolate(v1, fraclerp, v2, v);

				if (cache) {
					temp_aliasmodel_buffer[position].texture_coords[0] = s;
					temp_aliasmodel_buffer[position].texture_coords[1] = t;
					VectorCopy(v, temp_aliasmodel_buffer[position].position);
					position++;
				}
				else {
					glTexCoord2f(s, t);
					GLC_Vertex3f(v[0], v[1], v[2]);
				}

				verts1++;
				verts2++;
			} while (--count);

			if (cache) {
				int i;

				R_BindVertexArray(vao_aliasmodel_powerupshell);
				GLC_SetPowerupShellColor(0, ent->effects);
				GL_DrawArrays(drawMode, 0, position);

				// And quickly update texture-coordinates and run again...
				GLC_SetPowerupShellColor(1, ent->effects);
				for (i = 0; i < position; ++i) {
					temp_aliasmodel_buffer[i].texture_coords[0] += scroll[2] - scroll[0];
					temp_aliasmodel_buffer[i].texture_coords[1] += scroll[3] - scroll[1];
				}
				GL_DrawArrays(drawMode, 0, position);

				return;
			}
			else {
				GLC_End();
			}
		}
	}
}

static void GLC_DrawPowerupShell(entity_t* ent, maliasframedesc_t *oldframe, maliasframedesc_t *frame)
{
	int pose1, pose2;
	float lerp;

	R_AliasModelDeterminePoses(oldframe, frame, &pose1, &pose2, &lerp);

	if (gl_program_aliasmodels.integer) {
		GLC_DrawPowerupShell_Program(ent, pose1, lerp);
	}
	else {
		GLC_DrawPowerupShell_Immediate(ent, pose1, pose2, lerp);
	}
}

void GLC_DrawAliasModelShadow(entity_t* ent)
{
	float theta;
	float oldMatrix[16];
	static float shadescale = 0;
	vec3_t shadevector;

	if (!shadescale) {
		shadescale = 1 / sqrt(2);
	}
	theta = -ent->angles[1] / 180 * M_PI;

	VectorSet(shadevector, cos(theta) * shadescale, sin(theta) * shadescale, shadescale);

	R_PushModelviewMatrix(oldMatrix);
	R_TranslateModelview(ent->origin[0], ent->origin[1], ent->origin[2]);
	R_RotateModelview(ent->angles[1], 0, 0, 1);

	GLC_StateBeginAliasModelShadow();
	GLC_DrawAliasModelShadowDrawCall(ent, shadevector);
	R_PopModelviewMatrix(oldMatrix);
}

static void GLC_DrawAliasModelShadowDrawCall_Program(entity_t* ent, int pose1, float lerpfrac, float lheight, vec3_t shadevector)
{
	if (buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_AliasModelShadowCompile()) {
		const aliashdr_t* paliashdr = (aliashdr_t *)Mod_Extradata(ent->model); // locate the proper data
		int firstVert = ent->model->vbo_start + pose1 * paliashdr->vertsPerPose;

		R_ProgramUse(r_program_aliasmodel_shadow_glc);
		GLC_BindVertexArrayAttributes(vao_aliasmodel);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_shadow_glc_lerpFraction, lerpfrac);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_shadow_glc_lheight, lheight);
		R_ProgramUniform2fv(r_program_uniform_aliasmodel_shadow_glc_shadevector, shadevector);
		GL_DrawArrays(GL_TRIANGLES, firstVert, paliashdr->vertsPerPose);
		R_ProgramUse(r_program_none);
	}
}

static void GLC_DrawAliasModelShadowDrawCall_Immediate(entity_t* ent, int pose1, float lerpfrac, float lheight, vec3_t shadevector)
{
	const aliashdr_t* paliashdr = (aliashdr_t *)Mod_Extradata(ent->model); // locate the proper data
	int *order, count;
	vec3_t point;
	ez_trivertx_t *verts;
	float height = (1 - lheight);

	verts = (ez_trivertx_t *)((byte *)paliashdr + paliashdr->posedata);
	verts += pose1 * paliashdr->poseverts;
	order = (int *)((byte *)paliashdr + paliashdr->commands);

	R_ProgramUse(r_program_none);
	while ((count = *order++)) {
		// get the vertex count and primitive type
		if (count < 0) {
			count = -count;
			GLC_Begin(GL_TRIANGLE_FAN);
		}
		else {
			GLC_Begin(GL_TRIANGLE_STRIP);
		}

		do {
			//no texture for shadows
			order += 2;

			// normals and vertexes come from the frame list
			point[0] = verts->v[0] + paliashdr->scale_origin[0];
			point[1] = verts->v[1] + paliashdr->scale_origin[1];
			point[2] = verts->v[2] + paliashdr->scale_origin[2];

			point[0] -= shadevector[0] * (point[2] + lheight);
			point[1] -= shadevector[1] * (point[2] + lheight);
			point[2] = height;

			GLC_Vertex3fv(point);

			verts++;
		} while (--count);

		GLC_End();
	}
}

static void GLC_DrawAliasModelShadowDrawCall(entity_t* ent, vec3_t shadevector)
{
	const aliashdr_t* paliashdr = (aliashdr_t *)Mod_Extradata(ent->model); // locate the proper data
	const maliasframedesc_t* frame = &paliashdr->frames[ent->frame];
	const maliasframedesc_t* oldframe = &paliashdr->frames[ent->oldframe];
	float lheight = ent->origin[2] - ent->lightspot[2];
	int pose1, pose2;
	float lerpfrac;

	R_AliasModelDeterminePoses(oldframe, frame, &pose1, &pose2, &lerpfrac);

	if (gl_program_aliasmodels.integer) {
		GLC_DrawAliasModelShadowDrawCall_Program(ent, pose1, lerpfrac, lheight, shadevector);
	}
	else {
		GLC_DrawAliasModelShadowDrawCall_Immediate(ent, pose1, lerpfrac, lheight, shadevector);
	}
}

void GLC_DrawAliasModelPowerupShell(entity_t *ent)
{
	aliashdr_t* paliashdr = (aliashdr_t *)Mod_Extradata(ent->model); // locate the proper data
	maliasframedesc_t *oldframe, *frame;
	float oldMatrix[16];

	if (!(ent->effects & (EF_RED | EF_GREEN | EF_BLUE)) || !R_TextureReferenceIsValid(shelltexture)) {
		return;
	}

	// FIXME: This is all common with R_DrawAliasModel(), and if passed there, don't need to be run here...
	if (!Ruleset_AllowPowerupShell(ent->model) || R_FilterEntity(ent)) {
		return;
	}

	ent->frame = bound(0, ent->frame, paliashdr->numframes - 1);
	ent->oldframe = bound(0, ent->oldframe, paliashdr->numframes - 1);

	frame = &paliashdr->frames[ent->frame];
	oldframe = &paliashdr->frames[ent->oldframe];

	r_framelerp = 1.0;
	if (r_lerpframes.integer && ent->framelerp >= 0 && ent->oldframe != ent->frame) {
		r_framelerp = min(ent->framelerp, 1);
	}

	if (R_CullAliasModel(ent, oldframe, frame)) {
		return;
	}

	frameStats.classic.polycount[polyTypeAliasModel] += paliashdr->numtris;

	R_TraceEnterRegion(va("%s(%s)", __func__, ent->model->name), true);

	// FIXME: think need put it after caustics
	R_PushModelviewMatrix(oldMatrix);
	R_StateBeginDrawAliasModel(ent, paliashdr);
	GLC_DrawPowerupShell(ent, oldframe, frame);
	R_PopModelviewMatrix(oldMatrix);

	R_TraceLeaveRegion(true);
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_aliasmodel_mesh.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#if 0

#include "quakedef.h"
#include "gl_model.h"
#include "r_local.h"
#include "r_aliasmodel.h"

/*
=================================================================

ALIAS MODEL DISPLAY LIST GENERATION

=================================================================
*/

static byte	used[8192];

// the command list holds counts and s/t values that are valid for
// every frame
static int commands[8192];
static int numcommands;

// all frames will have their vertexes rearranged and expanded
// so they are in the order expected by the command list
static int vertexorder[8192];
static int numorder;

static int allverts, alltris;

static int stripverts[128];
static int striptris[128];
static int stripcount;

/*
================
StripLength
================
*/
static int StripLength(int starttri, int startv)
{
	int m1, m2, j, k;
	mtriangle_t *last, *check;

	used[starttri] = 2;

	last = &triangles[starttri];

	stripverts[0] = last->vertindex[(startv) % 3];
	stripverts[1] = last->vertindex[(startv + 1) % 3];
	stripverts[2] = last->vertindex[(startv + 2) % 3];

	striptris[0] = starttri;
	stripcount = 1;

	m1 = last->vertindex[(startv + 2) % 3];
	m2 = last->vertindex[(startv + 1) % 3];

	// look for a matching triangle
nexttri:
	for (j = starttri + 1, check = &triangles[starttri + 1]; j < pheader->numtris; j++, check++) {
		if (check->facesfront != last->facesfront) {
			continue;
		}
		for (k = 0; k < 3; k++) {
			if (check->vertindex[k] != m1) {
				continue;
			}
			if (check->vertindex[(k + 1) % 3] != m2) {
				continue;
			}

			// this is the next part of the fan

			// if we can't use this triangle, this tristrip is done
			if (used[j]) {
				goto done;
			}

			// the new edge
			if (stripcount & 1) {
				m2 = check->vertindex[(k + 2) % 3];
			}
			else {
				m1 = check->vertindex[(k + 2) % 3];
			}

			stripverts[stripcount + 2] = check->vertindex[(k + 2) % 3];
			striptris[stripcount] = j;
			stripcount++;

			used[j] = 2;
			goto nexttri;
		}
	}

done:
	// clear the temp used flags
	for (j = starttri + 1; j < pheader->numtris; j++) {
		if (used[j] == 2) {
			used[j] = 0;
		}
	}

	return stripcount;
}

#if 0
/*
===========
FanLength
===========
*/
static int FanLength(int starttri, int startv)
{
	int m1, m2, j, k;
	mtriangle_t	*last, *check;

	used[starttri] = 2;

	last = &triangles[starttri];

	stripverts[0] = last->vertindex[(startv) % 3];
	stripverts[1] = last->vertindex[(startv + 1) % 3];
	stripverts[2] = last->vertindex[(startv + 2) % 3];

	striptris[0] = starttri;
	stripcount = 1;

	m1 = last->vertindex[(startv + 0) % 3];
	m2 = last->vertindex[(startv + 2) % 3];

	// look for a matching triangle
nexttri:
	for (j = starttri + 1, check = &triangles[starttri + 1]; j < pheader->numtris; j++, check++) {
		if (check->facesfront != last->facesfront) {
			continue;
		}
		for (k = 0; k < 3; k++) {
			if (check->vertindex[k] != m1) {
				continue;
			}
			if (check->vertindex[(k + 1) % 3] != m2) {
				continue;
			}

			// this is the next part of the fan

			// if we can't use this triangle, this tristrip is done
			if (used[j]) {
				goto done;
			}

			// the new edge
			m2 = check->vertindex[(k + 2) % 3];

			stripverts[stripcount + 2] = m2;
			striptris[stripcount] = j;
			stripcount++;

			used[j] = 2;
			goto nexttri;
		}
	}
done:

	// clear the temp used flags
	for (j = starttri + 1; j < pheader->numtris; j++) {
		if (used[j] == 2) {
			used[j] = 0;
		}
	}

	return stripcount;
}
#endif

/*
================
BuildTris

Generate a list of trifans or strips
for the model, which holds for all frames
================
*/
static void BuildTris(void)
{
	int		i, j, k;
	int		startv;
	float	s, t;
	int		len, bestlen;
	int		bestverts[1024];
	int		besttris[1024];
	qbool duplicate = false;
	float previous_s = 0, previous_t = 0;

	//
	// build tristrips
	//
	numorder = 0;
	numcommands = 0;
	memset(used, 0, sizeof(used));
	memset(commands, 0, sizeof(commands));

	for (i = 0; i < pheader->numtris; i++) {
		// pick an unused triangle and start the trifan
		if (used[i]) {
			continue;
		}

		bestlen = 0;

		for (startv = 0; startv < 3; startv++) {
			len = StripLength(i, startv);

			if (len > bestlen) {
				bestlen = len;
				for (j = 0; j < bestlen + 2; j++) {
					bestverts[j] = stripverts[j];
				}
				for (j = 0; j < bestlen; j++) {
					besttris[j] = striptris[j];
				}
			}
		}

		// mark the tris on the best strip as used
		for (j = 0; j < bestlen; j++) {
			used[besttris[j]] = 1;
		}

		duplicate = false;
		commands[0] += bestlen + 2;
		if (numcommands) {
			// duplicate previous vertex to keep triangle strip running
			vertexorder[numorder] = vertexorder[numorder - 1];
			++numorder;

			// duplicate s & t coordinates
			*(float *)&commands[numcommands++] = previous_s;
			*(float *)&commands[numcommands++] = previous_t;
			commands[0] += 2;

			// Duplicate the current one too
			duplicate = true;
		}
		else {
			duplicate = false;
			++numcommands;
		}

		for (j = 0; j < bestlen + 2; j++) {
			// emit a vertex into the reorder buffer
			k = bestverts[j];
			vertexorder[numorder++] = k;

			// emit s/t coords into the commands stream
			s = stverts[k].s;
			t = stverts[k].t;
			if (!triangles[besttris[0]].facesfront && stverts[k].onseam) {
				s += pheader->skinwidth / 2;	// on back side
			}
			s = (s + 0.5) / pheader->skinwidth;
			t = (t + 0.5) / pheader->skinheight;

			if (duplicate) {
				*(float *)&commands[numcommands++] = s;
				*(float *)&commands[numcommands++] = t;
				vertexorder[numorder++] = k;

				if (numorder % 2 == 0) {
					*(float *)&commands[numcommands++] = s;
					*(float *)&commands[numcommands++] = t;
					vertexorder[numorder++] = k;
					++commands[0];
				}
			}
			previous_s = *(float *)&commands[numcommands++] = s;
			previous_t = *(float *)&commands[numcommands++] = t;

			duplicate = false;
		}
	}

	commands[numcommands++] = 0;		// end of list marker

	Com_DPrintf("%3i tri %3i vert %3i cmd\n", pheader->numtris, numorder, numcommands);

	allverts += numorder;
	alltris += pheader->numtris;
}

void GLC_PrepareAliasModel(model_t* m, aliashdr_t* hdr)
{
	GL_PrepareAliasModel(m, hdr);
}

#endif // #if 0


================================================
FILE: src/glc_bloom.c
================================================
/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

/**

	GL Bloom

	Ported by Cokeman, June 2007
	last edit:
	$Id: gl_bloom.c,v 1.5 2007-09-13 14:49:30 disconn3ct Exp $

*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

// glc_bloom.c: 2D lighting post process effect (immediate-mode OpenGL only)

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_texture.h"
#include "r_matrix.h"
#include "r_renderer.h"
#include "glc_local.h"
#include "tr_types.h"

/*
==============================================================================

						LIGHT BLOOMS

==============================================================================
*/

static float Diamond8x[8][8] = {
	{0.0f, 0.0f, 0.0f, 0.1f, 0.1f, 0.0f, 0.0f, 0.0f},
	{0.0f, 0.0f, 0.2f, 0.3f, 0.3f, 0.2f, 0.0f, 0.0f},
	{0.0f, 0.2f, 0.4f, 0.6f, 0.6f, 0.4f, 0.2f, 0.0f},
	{0.1f, 0.3f, 0.6f, 0.9f, 0.9f, 0.6f, 0.3f, 0.1f},
	{0.1f, 0.3f, 0.6f, 0.9f, 0.9f, 0.6f, 0.3f, 0.1f},
	{0.0f, 0.2f, 0.4f, 0.6f, 0.6f, 0.4f, 0.2f, 0.0f},
	{0.0f, 0.0f, 0.2f, 0.3f, 0.3f, 0.2f, 0.0f, 0.0f},
	{0.0f, 0.0f, 0.0f, 0.1f, 0.1f, 0.0f, 0.0f, 0.0f} };

static float Diamond6x[6][6] = {
	{0.0f, 0.0f, 0.1f, 0.1f, 0.0f, 0.0f},
	{0.0f, 0.3f, 0.5f, 0.5f, 0.3f, 0.0f},
	{0.1f, 0.5f, 0.9f, 0.9f, 0.5f, 0.1f},
	{0.1f, 0.5f, 0.9f, 0.9f, 0.5f, 0.1f},
	{0.0f, 0.3f, 0.5f, 0.5f, 0.3f, 0.0f},
	{0.0f, 0.0f, 0.1f, 0.1f, 0.0f, 0.0f} };

static float Diamond4x[4][4] = {
	{0.3f, 0.4f, 0.4f, 0.3f},
	{0.4f, 0.9f, 0.9f, 0.4f},
	{0.4f, 0.9f, 0.9f, 0.4f},
	{0.3f, 0.4f, 0.4f, 0.3f} };

static int BLOOM_SIZE;

cvar_t      r_bloom = { "r_bloom", "0", true };
cvar_t      r_bloom_alpha = { "r_bloom_alpha", "0.5", true };
cvar_t      r_bloom_diamond_size = { "r_bloom_diamond_size", "8", true };
cvar_t      r_bloom_intensity = { "r_bloom_intensity", "1", true };
cvar_t      r_bloom_darken = { "r_bloom_darken", "3", true };
cvar_t      r_bloom_sample_size = { "r_bloom_sample_size", "256", true };
cvar_t      r_bloom_fast_sample = { "r_bloom_fast_sample", "0", true };

texture_ref r_bloomscreentexture;
texture_ref r_bloomeffecttexture;
texture_ref r_bloombackuptexture;
texture_ref r_bloomdownsamplingtexture;

static int      r_screendownsamplingtexture_size;
static int      screen_texture_width, screen_texture_height;
static int      r_screenbackuptexture_size;

// Current refdef size:
static int  curView_x;
static int  curView_y;
static int  curView_width;
static int  curView_height;

// Texture coordinates of screen data inside screentexture.
static float screenText_tcw;
static float screenText_tch;

static int  sample_width;
static int  sample_height;

// Texture coordinates of adjusted textures.
static float sampleText_tcw;
static float sampleText_tch;

// This macro is in sample size workspace coordinates.
#define GLC_Bloom_SamplePass( xpos, ypos )                         \
	GLC_Begin(GL_QUADS);                                             \
	glTexCoord2f(  0,                      sampleText_tch);        \
	GLC_Vertex2f(    xpos,                   ypos);                  \
	glTexCoord2f(  0,                      0);                     \
	GLC_Vertex2f(    xpos,                   ypos+sample_height);    \
	glTexCoord2f(  sampleText_tcw,         0);                     \
	GLC_Vertex2f(    xpos+sample_width,      ypos+sample_height);    \
	glTexCoord2f(  sampleText_tcw,         sampleText_tch);        \
	GLC_Vertex2f(    xpos+sample_width,      ypos);                  \
	GLC_End();

#define GLC_Bloom_Quad( x, y, width, height, textwidth, textheight ) \
	GLC_Begin(GL_QUADS);                                             \
	glTexCoord2f(  0,          textheight);                        \
	GLC_Vertex2f(    x,          y);                                 \
	glTexCoord2f(  0,          0);                                 \
	GLC_Vertex2f(    x,          y+height);                          \
	glTexCoord2f(  textwidth,  0);                                 \
	GLC_Vertex2f(    x+width,    y+height);                          \
	glTexCoord2f(  textwidth,  textheight);                        \
	GLC_Vertex2f(    x+width,    y);                                 \
	GLC_End();

// Meag: #define DEBUG_BLOOM, if bloom enabled and you set `developer 1`,
//   for a single frame it will output copies of the intermediate textures
//   then set developer 0 again.
#ifdef DEBUG_BLOOM
static void GLC_Bloom_DebugTexture(texture_ref tex, const char* filename)
{
	if (developer.integer) {
		int buffer_size = 4 * R_TextureWidth(tex) * R_TextureHeight(tex);
		byte* buffer = Q_malloc(buffer_size);
		scr_sshot_target_t* sshot_params = Q_malloc(sizeof(scr_sshot_target_t));

		renderer.TextureGet(tex, buffer_size, buffer, 3);

		sshot_params->buffer = buffer;
		sshot_params->freeMemory = true;
		strlcpy(sshot_params->fileName, filename, sizeof(sshot_params->fileName));
		sshot_params->format = IMAGE_JPEG;
		sshot_params->width = R_TextureWidth(tex);
		sshot_params->height = R_TextureHeight(tex);
		SCR_ScreenshotWrite(sshot_params);
	}
}
#else
#define GLC_Bloom_DebugTexture(tex, filename)
#endif

//=================
// GLC_Bloom_InitBackUpTexture
// =================
static void GLC_Bloom_InitBackUpTexture(int width, int height)
{
	unsigned char *data;

	data = (unsigned char *)Q_calloc(width * height, sizeof(int));

	r_screenbackuptexture_size = width;

	r_bloombackuptexture = R_LoadTexture("***r_bloombackuptexture***", width, height, data, 0, 4);

	Q_free(data);
}

// =================
// GLC_Bloom_InitEffectTexture
// =================
static void GLC_Bloom_InitEffectTexture(void)
{
	unsigned char *data;
	float bloomsizecheck;

	if (r_bloom_sample_size.value < 32) {
		Cvar_SetValue(&r_bloom_sample_size, 32);
	}

	// Make sure bloom size is a power of 2.
	BLOOM_SIZE = r_bloom_sample_size.value;
	bloomsizecheck = (float)BLOOM_SIZE;

	while (bloomsizecheck > 1.0f) {
		bloomsizecheck /= 2.0f;
	}

	if (bloomsizecheck != 1.0f) {
		BLOOM_SIZE = 32;

		while (BLOOM_SIZE < r_bloom_sample_size.value) {
			BLOOM_SIZE *= 2;
		}
	}

	// Make sure bloom size doesn't have stupid values.
	if (BLOOM_SIZE > screen_texture_width || BLOOM_SIZE > screen_texture_height) {
		BLOOM_SIZE = min(screen_texture_width, screen_texture_height);
	}

	if (BLOOM_SIZE != r_bloom_sample_size.value) {
		Cvar_SetValue(&r_bloom_sample_size, BLOOM_SIZE);
	}

	data = (unsigned char *)Q_calloc(BLOOM_SIZE * BLOOM_SIZE, sizeof(int));

	r_bloomeffecttexture = R_LoadTexture("***r_bloomeffecttexture***", BLOOM_SIZE, BLOOM_SIZE, data, 0, 4);

	Q_free(data);
}

// =================
// GLC_Bloom_InitTextures
// =================
static void GLC_Bloom_InitTextures(void)
{
	unsigned char *data;
	int maxtexsize = glConfig.gl_max_size_default;
	size_t size;

	// Find closer power of 2 to screen size.
	for (screen_texture_width = 1; screen_texture_width < glwidth; screen_texture_width *= 2);
	for (screen_texture_height = 1; screen_texture_height < glheight; screen_texture_height *= 2);

	// Disable blooms if we can't handle a texture of that size.
	if (screen_texture_width > maxtexsize || screen_texture_height > maxtexsize) {
		screen_texture_width = screen_texture_height = 0;
		Cvar_SetValue(&r_bloom, 0);
		Com_Printf("WARNING: 'R_InitBloomScreenTexture' too high resolution for Light Bloom. Effect disabled\n");
		return;
	}

	// Init the screen texture.
	size = screen_texture_width * screen_texture_height * sizeof(int);
	data = Q_malloc(size);
	memset(data, 255, size);

	if (!R_TextureReferenceIsValid(r_bloomscreentexture) || R_TextureWidth(r_bloomscreentexture) != screen_texture_width || R_TextureHeight(r_bloomscreentexture) != screen_texture_height) {
		if (R_TextureReferenceIsValid(r_bloomscreentexture)) {
			renderer.TextureDelete(r_bloomscreentexture);
		}
		r_bloomscreentexture = R_LoadTexture("bloom:screentexture", screen_texture_width, screen_texture_height, data, TEX_NOCOMPRESS | TEX_NOSCALE | TEX_NO_TEXTUREMODE, 4);
		renderer.TextureSetFiltering(r_bloomscreentexture, texture_minification_nearest, texture_magnification_nearest);
	}

	Q_free(data);

	// Validate bloom size and init the bloom effect texture.
	GLC_Bloom_InitEffectTexture();

	// If screensize is more than 2x the bloom effect texture, set up for stepped downsampling.
	R_TextureReferenceInvalidate(r_bloomdownsamplingtexture);
	r_screendownsamplingtexture_size = 0;
	if (glwidth > (BLOOM_SIZE * 2) && !r_bloom_fast_sample.value) {
		r_screendownsamplingtexture_size = (int)(BLOOM_SIZE * 2);
		data = Q_calloc(r_screendownsamplingtexture_size * r_screendownsamplingtexture_size, sizeof(int));
		r_bloomdownsamplingtexture = R_LoadTexture("***r_bloomdownsamplingtexture***", r_screendownsamplingtexture_size, r_screendownsamplingtexture_size, data, 0, 4);
		Q_free(data);
	}

	// Init the screen backup texture.
	if (r_screendownsamplingtexture_size) {
		GLC_Bloom_InitBackUpTexture(r_screendownsamplingtexture_size, r_screendownsamplingtexture_size);
	}
	else {
		GLC_Bloom_InitBackUpTexture(BLOOM_SIZE, BLOOM_SIZE);
	}
}

// =================
// R_InitBloomTextures
// =================
void GLC_InitBloomTextures(void)
{
	BLOOM_SIZE = 0;
	if (!r_bloom.value) {
		return;
	}

	// This came from a vid_restart, where none of the textures are valid any more.
	R_TextureReferenceInvalidate(r_bloomscreentexture);
	R_TextureReferenceInvalidate(r_bloomeffecttexture);
	R_TextureReferenceInvalidate(r_bloombackuptexture);
	R_TextureReferenceInvalidate(r_bloomdownsamplingtexture);

	GLC_Bloom_InitTextures();
}

// =================
// R_Bloom_DrawEffect
// =================
static void GLC_Bloom_DrawEffect(void)
{
	GLC_StateBeginBloomDraw(r_bloomeffecttexture);

	GLC_Begin(GL_QUADS);
	glTexCoord2f(0, sampleText_tch);
	GLC_Vertex2f(curView_x, curView_y);
	glTexCoord2f(0, 0);
	GLC_Vertex2f(curView_x, curView_y + curView_height);
	glTexCoord2f(sampleText_tcw, 0);
	GLC_Vertex2f(curView_x + curView_width, curView_y + curView_height);
	glTexCoord2f(sampleText_tcw, sampleText_tch);
	GLC_Vertex2f(curView_x + curView_width, curView_y);
	GLC_End();
}

// =================
// R_Bloom_GeneratexDiamonds
//=================
static void GLC_Bloom_GeneratexDiamonds(void)
{
	int         i, j;
	static float intensity;

	// Setup sample size workspace
	R_Viewport(0, 0, sample_width, sample_height);
	R_OrthographicProjection(0, sample_width, sample_height, 0, -10, 100);
	R_IdentityModelView();

	// Copy small scene into r_bloomeffecttexture.
	renderer.TextureUnitBind(0, r_bloomeffecttexture);
	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, sample_width, sample_height);

	// Start modifying the small scene corner.

	// Darkening passes
	if (r_bloom_darken.value) {
		R_ApplyRenderingState(r_state_postprocess_bloom_darkenpass);

		for (i = 0; i < r_bloom_darken.integer; i++) {
			GLC_Bloom_SamplePass(0, 0);
		}
		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, sample_width, sample_height);
		GLC_Bloom_DebugTexture(r_bloomeffecttexture, "./qw/bloom-darkenedpass.jpg");
	}

	// Bluring passes.
	R_ApplyRenderingState(r_state_postprocess_bloom_blurpass);
	R_CustomColor(1.0f, 1.0f, 1.0f, 1.0f);

	if (r_bloom_diamond_size.value > 7 || r_bloom_diamond_size.value <= 3) {
		if (r_bloom_diamond_size.integer != 8) {
			Cvar_SetValue(&r_bloom_diamond_size, 8);
		}

		for (i = 0; i < r_bloom_diamond_size.integer; i++) {
			for (j = 0; j < r_bloom_diamond_size.integer; j++) {
				intensity = r_bloom_intensity.value * 0.3 * Diamond8x[i][j];
				if (intensity < 0.01f) {
					continue;
				}
				R_CustomColor(intensity, intensity, intensity, 1.0);
				GLC_Bloom_SamplePass(i - 4, j - 4);
			}
		}
	}
	else if (r_bloom_diamond_size.integer > 5) {
		if (r_bloom_diamond_size.integer != 6) {
			Cvar_SetValue(&r_bloom_diamond_size, 6);
		}

		for (i = 0; i < r_bloom_diamond_size.integer; i++) {
			for (j = 0; j < r_bloom_diamond_size.integer; j++) {
				intensity = r_bloom_intensity.value * 0.5 * Diamond6x[i][j];
				if (intensity < 0.01f) {
					continue;
				}
				R_CustomColor(intensity, intensity, intensity, 1.0);
				GLC_Bloom_SamplePass(i - 3, j - 3);
			}
		}
	}
	else if (r_bloom_diamond_size.value > 3) {
		if (r_bloom_diamond_size.integer != 4) {
			Cvar_SetValue(&r_bloom_diamond_size, 4);
		}

		for (i = 0; i < r_bloom_diamond_size.integer; i++) {
			for (j = 0; j < r_bloom_diamond_size.integer; j++) {
				intensity = r_bloom_intensity.value * 0.8f * Diamond4x[i][j];
				if (intensity < 0.01f) {
					continue;
				}
				R_CustomColor(intensity, intensity, intensity, 1.0);
				GLC_Bloom_SamplePass(i - 2, j - 2);
			}
		}
	}

	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, sample_width, sample_height);
	GLC_Bloom_DebugTexture(r_bloomeffecttexture, "./qw/bloom-blurred.jpg");

	// Restore full screen workspace.
	R_Viewport(0, 0, glwidth, glheight);
	R_OrthographicProjection(0, glwidth, glheight, 0, -10, 100);
	R_IdentityModelView();
}

// =================
// R_Bloom_DownsampleView
// =================
static void GLC_Bloom_DownsampleView(void)
{
	R_ApplyRenderingState(r_state_postprocess_bloom_downsample);
	R_CustomColor(1.0f, 1.0f, 1.0f, 1.0f);

	// Stepped downsample.
	if (r_screendownsamplingtexture_size) {
		int     midsample_width = r_screendownsamplingtexture_size * sampleText_tcw;
		int     midsample_height = r_screendownsamplingtexture_size * sampleText_tch;

		// Copy the screen and draw resized.
		renderer.TextureUnitBind(0, r_bloomscreentexture);
		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, curView_x, glheight - (curView_y + curView_height), curView_width, curView_height);
		GLC_Bloom_Quad(0, glheight - midsample_height, midsample_width, midsample_height, screenText_tcw, screenText_tch);

		// Now copy into Downsampling (mid-sized) texture.
		renderer.TextureUnitBind(0, r_bloomdownsamplingtexture);
		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, midsample_width, midsample_height);
		GLC_Bloom_DebugTexture(r_bloombackuptexture, "./qw/bloom-downsampled1.jpg");

		// Now draw again in bloom size.
		R_CustomColor(0.5f, 0.5f, 0.5f, 1.0f);
		GLC_Bloom_Quad(0, glheight - sample_height, sample_width, sample_height, sampleText_tcw, sampleText_tch);

		// Now blend the big screen texture into the bloom generation space (hoping it adds some blur).
		R_ApplyRenderingState(r_state_postprocess_bloom_downsample_blend);
		R_CustomColor(0.5f, 0.5f, 0.5f, 1.0f);
		renderer.TextureUnitBind(0, r_bloomscreentexture);
		GLC_Bloom_Quad(0, glheight - sample_height, sample_width, sample_height, screenText_tcw, screenText_tch);
	}
	else {
		// Downsample simple.
		renderer.TextureUnitBind(0, r_bloomscreentexture);
		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, curView_x, glheight - (curView_y + curView_height), curView_width, curView_height);
		GLC_Bloom_DebugTexture(r_bloombackuptexture, "./qw/bloom-downsampled2.jpg");
		GLC_Bloom_Quad(0, glheight - sample_height, sample_width, sample_height, screenText_tcw, screenText_tch);
	}
}

// =================
// R_BloomBlend
// =================
void GLC_BloomBlend(void)
{
	extern vrect_t	scr_vrect;

	if (!r_bloom.value) {
		return;
	}

	if (!BLOOM_SIZE || screen_texture_width < glwidth || screen_texture_height < glheight) {
		GLC_Bloom_InitTextures();
	}

	if (screen_texture_width < BLOOM_SIZE || screen_texture_height < BLOOM_SIZE) {
		return;
	}

	// Set up full screen workspace.
	R_Viewport(0, 0, glwidth, glheight);
	R_OrthographicProjection(0, glwidth, glheight, 0, -10, 100);
	R_IdentityModelView();

	R_ApplyRenderingState(r_state_postprocess_bloom1);
	R_CustomColor(1, 1, 1, 1);

	// Setup current sizes
	curView_x = scr_vrect.x * ((float)glwidth / vid.width);
	curView_y = scr_vrect.y * ((float)glheight / vid.height);
	curView_width = scr_vrect.width * ((float)glwidth / vid.width);
	curView_height = scr_vrect.height * ((float)glheight / vid.height);
	screenText_tcw = ((float)curView_width / (float)screen_texture_width);
	screenText_tch = ((float)curView_height / (float)screen_texture_height);

	if (scr_vrect.height > scr_vrect.width) {
		sampleText_tcw = ((float)scr_vrect.width / (float)scr_vrect.height);
		sampleText_tch = 1.0f;
	}
	else {
		sampleText_tcw = 1.0f;
		sampleText_tch = ((float)scr_vrect.height / (float)scr_vrect.width);
	}

	sample_width = BLOOM_SIZE * sampleText_tcw;
	sample_height = BLOOM_SIZE * sampleText_tch;

	// Copy the screen space we'll use to work into the backup texture.
	renderer.TextureUnitBind(0, r_bloombackuptexture);
	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, r_screenbackuptexture_size * sampleText_tcw, r_screenbackuptexture_size * sampleText_tch);
	GLC_Bloom_DebugTexture(r_bloombackuptexture, "./qw/bloom-copied.jpg");

	// Create the bloom image.
	GLC_Bloom_DownsampleView();
	GLC_Bloom_GeneratexDiamonds();
	//R_Bloom_GeneratexCross();

	// Restore the screen-backup to the screen.
	GLC_Bloom_DebugTexture(r_bloombackuptexture, "./qw/bloom-restored.jpg");
	R_ApplyRenderingState(r_state_postprocess_bloom_restore);
	renderer.TextureUnitBind(0, r_bloombackuptexture);
	R_CustomColor(1, 1, 1, 1);
	GLC_Bloom_Quad(0,
		glheight - (r_screenbackuptexture_size * sampleText_tch),
		r_screenbackuptexture_size * sampleText_tcw,
		r_screenbackuptexture_size * sampleText_tch,
		sampleText_tcw,
		sampleText_tch
	);

	GLC_Bloom_DrawEffect();

#ifdef DEBUG_BLOOM
	Cvar_SetValue(&developer, 0);
#endif
}

void GLC_BloomRegisterCvars(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_EYECANDY);
	Cvar_Register(&r_bloom);
	Cvar_Register(&r_bloom_darken);
	Cvar_Register(&r_bloom_alpha);
	Cvar_Register(&r_bloom_diamond_size);
	Cvar_Register(&r_bloom_intensity);
	Cvar_Register(&r_bloom_sample_size);
	Cvar_Register(&r_bloom_fast_sample);
	Cvar_ResetCurrentGroup();
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL



================================================
FILE: src/glc_brushmodel.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: gl_model.c,v 1.41 2007-10-07 08:06:33 tonik Exp $
*/
// gl_model.c  -- model loading and caching

// models are the only shared resource between a client and server running on the same machine.
#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "rulesets.h"
#include "r_framestats.h"
#include "r_texture.h"
#include "glc_state.h"
#include "glc_vao.h"
#include "r_brushmodel.h"
#include "r_brushmodel_sky.h"
#include "glc_local.h"
#include "tr_types.h"
#include "r_renderer.h"
#include "glsl/constants.glsl"
#include "r_lightmaps.h"
#include "r_trace.h"

extern glpoly_t *fullbright_polys[MAX_GLTEXTURES];
extern glpoly_t *luma_polys[MAX_GLTEXTURES];

void GLC_LightmapArrayToggle(qbool use_array);

glpoly_t *caustics_polys = NULL;
glpoly_t *detail_polys = NULL;

void GLC_EnsureVAOCreated(r_vao_id vao)
{
	if (R_VertexArrayCreated(vao)) {
		return;
	}

	if (!R_BufferReferenceIsValid(r_buffer_brushmodel_vertex_data)) {
		// TODO: vbo data in client memory
		return;
	}

	R_GenVertexArray(vao);
	GLC_VAOSetVertexBuffer(vao, r_buffer_brushmodel_vertex_data);
	// TODO: index data _not_ in client memory

	switch (vao) {
		case vao_brushmodel:
		{
			// tmus: [material, material2, lightmap]
			GLC_VAOEnableVertexPointer(vao, 3, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, position));
			GLC_VAOEnableTextureCoordPointer(vao, 0, 2, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, material_coords));
			GLC_VAOEnableTextureCoordPointer(vao, 1, 2, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, material_coords));
			GLC_VAOEnableTextureCoordPointer(vao, 2, 3, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, lightmap_coords));
			GLC_VAOEnableCustomAttribute(vao, 0, r_program_attribute_world_drawflat_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 1, r_program_attribute_world_textured_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 2, r_program_attribute_world_textured_detailCoord, 2, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, detail_coords));
			break;
		}
		case vao_brushmodel_lm_unit1:
		{
			// tmus: [material, lightmap, material2]
			GLC_VAOEnableVertexPointer(vao, 3, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, position));
			GLC_VAOEnableTextureCoordPointer(vao, 0, 2, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, material_coords));
			GLC_VAOEnableTextureCoordPointer(vao, 1, 3, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, lightmap_coords));
			GLC_VAOEnableTextureCoordPointer(vao, 2, 2, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, material_coords));
			GLC_VAOEnableCustomAttribute(vao, 0, r_program_attribute_world_drawflat_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 1, r_program_attribute_world_textured_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 2, r_program_attribute_world_textured_detailCoord, 2, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, detail_coords));
			break;
		}
		case vao_brushmodel_details:
		{
			// tmus: [details]
			GLC_VAOEnableVertexPointer(vao, 3, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, position));
			GLC_VAOEnableTextureCoordPointer(vao, 0, 2, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, detail_coords));
			GLC_VAOEnableCustomAttribute(vao, 0, r_program_attribute_world_drawflat_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 1, r_program_attribute_world_textured_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 2, r_program_attribute_world_textured_detailCoord, 2, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, detail_coords));
			break;
		}
		case vao_brushmodel_lightmap_pass:
		{
			// tmus: [lightmap]
			GLC_VAOEnableVertexPointer(vao, 3, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, position));
			GLC_VAOEnableTextureCoordPointer(vao, 0, 3, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, lightmap_coords));
			GLC_VAOEnableCustomAttribute(vao, 0, r_program_attribute_world_drawflat_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 1, r_program_attribute_world_textured_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 2, r_program_attribute_world_textured_detailCoord, 2, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, detail_coords));
			break;
		}
		case vao_brushmodel_simpletex:
		{
			// tmus: [material]
			GLC_VAOEnableVertexPointer(vao, 3, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, position));
			GLC_VAOEnableTextureCoordPointer(vao, 0, 2, GL_FLOAT, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, material_coords));
			GLC_VAOEnableCustomAttribute(vao, 0, r_program_attribute_world_drawflat_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 1, r_program_attribute_world_textured_style, 1, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, flatstyle));
			GLC_VAOEnableCustomAttribute(vao, 2, r_program_attribute_world_textured_detailCoord, 2, GL_FLOAT, GL_FALSE, sizeof(glc_vbo_world_vert_t), VBO_FIELDOFFSET(glc_vbo_world_vert_t, detail_coords));
			break;
		}
		default:
		{
			assert(false);
			break;
		}
	}
}

static void GLC_BlendLightmaps(void);
static void GLC_BlendLightmaps_GLSL(void);
void GLC_RenderFullbrights(void);
void GLC_RenderLumas(void);
void GLC_RenderLumas_GLSL(void);
void GLC_RenderFullbrights_GLSL(void);

//#define GLC_WORLD_TEXTURELESS    (1 << 0)
#define GLC_WORLD_FULLBRIGHTS    (1 << 1)
#define GLC_WORLD_LUMATEXTURES   (1 << 2)
#define GLC_WORLD_DETAIL         (1 << 3)
#define GLC_WORLD_CAUSTICS       (1 << 4)
#define GLC_WORLD_LIGHTMAPS      (1 << 5)
#define GLC_WORLD_DF_NORMAL      (1 << 6)
#define GLC_WORLD_DF_TINTED      (1 << 7)
#define GLC_WORLD_DF_BRIGHT      (1 << 8)
#define GLC_WORLD_DF_FLOORS      (1 << 9)
#define GLC_WORLD_DF_WALLS       (1 << 10)
#define GLC_WORLD_FOG_LINEAR     (1 << 11)
#define GLC_WORLD_FOG_EXP        (1 << 12)
#define GLC_WORLD_FOG_EXP2       (1 << 13)

#define GLC_USE_FULLBRIGHT_TEX  (GLC_WORLD_LUMATEXTURES | GLC_WORLD_FULLBRIGHTS)
#define GLC_USE_DRAWFLAT        (GLC_WORLD_DF_NORMAL | GLC_WORLD_DF_TINTED | GLC_WORLD_DF_BRIGHT)
#define GLC_USE_FOG             (GLC_WORLD_FOG_LINEAR | GLC_WORLD_FOG_EXP | GLC_WORLD_FOG_EXP2)

static void GLC_GLSL_AddFogOptions(char* definitions, int definitions_length, int options)
{
	if (options & GLC_USE_FOG) {
		strlcat(definitions, "#define DRAW_FOG\n", definitions_length);
		if (options & GLC_WORLD_FOG_LINEAR) {
			strlcat(definitions, "#define FOG_LINEAR\n", definitions_length);
		}
		else if (options & GLC_WORLD_FOG_EXP) {
			strlcat(definitions, "#define FOG_EXP\n", definitions_length);
		}
		else if (options & GLC_WORLD_FOG_EXP2) {
			strlcat(definitions, "#define FOG_EXP2\n", definitions_length);
		}
	}
}

qbool GLC_DrawflatProgramCompile(void)
{
	int flags = 0;

	if (R_ProgramRecompileNeeded(r_program_world_drawflat_glc, flags)) {
		char included_definitions[512];

		included_definitions[0] = '\0';
		if (glConfig.supported_features & R_SUPPORT_TEXTURE_ARRAYS) {
			strlcpy(included_definitions, "#define EZ_USE_TEXTURE_ARRAYS\n", sizeof(included_definitions));
		}
		GLC_GLSL_AddFogOptions(included_definitions, sizeof(included_definitions), flags);
		R_ProgramCompileWithInclude(r_program_world_drawflat_glc, included_definitions);

		R_ProgramSetCustomOptions(r_program_world_drawflat_glc, flags);
	}

	R_ProgramSetStandardUniforms(r_program_world_drawflat_glc);

	return R_ProgramReady(r_program_world_drawflat_glc);
}

static void GLC_SurfaceColor(const msurface_t* s, byte* desired)
{
	if (s->flags & SURF_DRAWSKY) {
		if (r_refdef2.fog_enabled) {
			desired[0] = (int)(r_refdef2.fog_skycolor[0] * 255);
			desired[1] = (int)(r_refdef2.fog_skycolor[1] * 255);
			desired[2] = (int)(r_refdef2.fog_skycolor[2] * 255);
		}
		else {
			memcpy(desired, r_skycolor.color, 3);
		}
	}
	else if (s->flags & SURF_DRAWTURB) {
		memcpy(desired, SurfaceFlatTurbColor(s->texinfo->texture), 3);
	}
	else if (s->flags & SURF_DRAWFLAT_FLOOR) {
		memcpy(desired, r_floorcolor.color, 3);
	}
	else {
		memcpy(desired, r_wallcolor.color, 3);
	}
}

static void GLC_DrawFlat_GLSL(model_t* model, qbool polygonOffset)
{
	extern cvar_t r_watercolor, r_slimecolor, r_lavacolor, r_telecolor;
	float color[4] = { 0, 0, 0, 1 };
	int index_count = 0;
	msurface_t* s;
	msurface_t* prev;
	int i;
	unsigned int lightmap_count = R_LightmapCount();
	qbool first_lightmap_surf = true;
	qbool draw_caustics = r_refdef2.drawCaustics;
	qbool clear_chains = !r_refdef2.drawWorldOutlines;

	GLC_LightmapArrayToggle(true);

	R_ProgramUse(r_program_world_drawflat_glc);
	VectorScale(r_wallcolor.color, 1.0f / 255.0f, color);
	R_ProgramUniform4fv(r_program_uniform_world_drawflat_glc_wallcolor, color);
	VectorScale(r_floorcolor.color, 1.0f / 255.0f, color);
	R_ProgramUniform4fv(r_program_uniform_world_drawflat_glc_floorcolor, color);
	VectorScale(r_refdef2.fog_skycolor, 1.0f, color);
	R_ProgramUniform4fv(r_program_uniform_world_drawflat_glc_skycolor, color);
	VectorScale(r_watercolor.color, 1.0f / 255.0f, color);
	R_ProgramUniform4fv(r_program_uniform_world_drawflat_glc_watercolor, color);
	VectorScale(r_slimecolor.color, 1.0f / 255.0f, color);
	R_ProgramUniform4fv(r_program_uniform_world_drawflat_glc_slimecolor, color);
	VectorScale(r_lavacolor.color, 1.0f / 255.0f, color);
	R_ProgramUniform4fv(r_program_uniform_world_drawflat_glc_lavacolor, color);
	VectorScale(r_telecolor.color, 1.0f / 255.0f, color);
	R_ProgramUniform4fv(r_program_uniform_world_drawflat_glc_telecolor, color);

	if (model->drawflat_chain) {
		R_ApplyRenderingState(r_state_drawflat_without_lightmaps_glc);
		R_CustomPolygonOffset(polygonOffset ? r_polygonoffset_standard : r_polygonoffset_disabled);

		// drawflat_chain has no lightmaps
		s = model->drawflat_chain;
		while (s) {
			if (s->polys) {
				glpoly_t* p;

				for (p = s->polys; p; p = p->next) {
					index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
				}

				// START shaman FIX /r_drawflat + /gl_caustics {
				if ((s->flags & SURF_UNDERWATER) && draw_caustics) {
					s->polys->caustics_chain = caustics_polys;
					caustics_polys = s->polys;
				}
			}
			// } END shaman FIX /r_drawflat + /gl_caustics

			if (clear_chains) {
				prev = s;
				s = s->drawflatchain;
				prev->drawflatchain = NULL;
			}
			else {
				s = s->drawflatchain;
			}
		}
		if (index_count) {
			GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
			index_count = 0;
		}

		if (clear_chains) {
			model->drawflat_chain = NULL;
		}
	}

	// go through lightmap chains
	for (i = 0; i < lightmap_count; ++i) {
		msurface_t* surf = R_DrawflatLightmapChain(i);

		if (surf) {
			if (first_lightmap_surf) {
				R_ApplyRenderingState(r_state_drawflat_with_lightmaps_glc);
				R_CustomPolygonOffset(polygonOffset ? r_polygonoffset_standard : r_polygonoffset_disabled);
				first_lightmap_surf = false;
			}

			if (index_count && !GLC_IsLightmapBound(0, i)) {
				GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
				index_count = 0;
			}
			GLC_SetTextureLightmap(0, i);

			while (surf) {
				glpoly_t* p;

				for (p = surf->polys; p; p = p->next) {
					index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
				}

				if (clear_chains) {
					prev = surf;
					surf = surf->drawflatchain;
					prev->drawflatchain = NULL;
				}
				else {
					surf = surf->drawflatchain;
				}
			}
			if (clear_chains) {
				R_ClearDrawflatLightmapChain(i);
			}
		}
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
		index_count = 0;
	}
	R_ProgramUse(r_program_none);
}

static void GLC_DrawFlat_Immediate(model_t* model, qbool polygonOffset)
{
	int i;
	qbool first_surf = true;
	qbool draw_caustics = r_refdef2.drawCaustics;
	qbool use_vbo = buffers.supported && modelIndexes;
	qbool clear_chains = !r_refdef2.drawWorldOutlines;
	byte current[3] = { 255, 255, 255 }, desired[4] = { 255, 255, 255, 255 };
	unsigned int lightmap_count = R_LightmapCount();
	int index_count = 0;
	msurface_t *s, *prev;
	int k;
	float *v;
	qbool sky = false;

	GLC_LightmapArrayToggle(false);

	s = model->drawflat_chain;
	R_ProgramUse(r_program_none);
	while (s) {
		qbool sky_surface = (s->flags & SURF_DRAWSKY);
		qbool sky_switch = (sky_surface != sky && r_refdef2.fog_enabled);

		GLC_SurfaceColor(s, desired);

		if (first_surf || sky_switch || (use_vbo && (desired[0] != current[0] || desired[1] != current[1] || desired[2] != current[2]))) {
			if (index_count) {
				GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
				index_count = 0;
			}
			if (first_surf || sky_switch) {
				R_ApplyRenderingState((sky_surface || !r_refdef2.fog_enabled ? r_state_drawflat_without_lightmaps_unfogged_glc : r_state_drawflat_without_lightmaps_glc));
				R_CustomPolygonOffset(polygonOffset ? r_polygonoffset_standard : r_polygonoffset_disabled);
			}
			R_CustomColor4ubv(desired);
		}

		VectorCopy(desired, current);
		first_surf = false;
		sky = sky_surface;

		{
			glpoly_t *p;
			for (p = s->polys; p; p = p->next) {
				v = p->verts[0];

				if (use_vbo) {
					index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
				}
				else {
					R_CustomColor4ubv(desired);
					GLC_Begin(GL_TRIANGLE_STRIP);
					for (k = 0; k < p->numverts; k++, v += VERTEXSIZE) {
						GLC_Vertex3fv(v);
					}
					GLC_End();
				}
			}
		}

		// START shaman FIX /r_drawflat + /gl_caustics {
		if ((s->flags & SURF_UNDERWATER) && draw_caustics) {
			s->polys->caustics_chain = caustics_polys;
			caustics_polys = s->polys;
		}
		// } END shaman FIX /r_drawflat + /gl_caustics

		if (clear_chains) {
			prev = s;
			s = s->drawflatchain;
			prev->drawflatchain = NULL;
		}
		else {
			s = s->drawflatchain;
		}
	}
	if (clear_chains) {
		model->drawflat_chain = NULL;
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
		index_count = 0;
	}

	first_surf = true;
	for (i = 0; i < lightmap_count; ++i) {
		msurface_t* surf = R_DrawflatLightmapChain(i);

		if (surf) {
			if (index_count && !GLC_IsLightmapBound(0, i)) {
				GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
				index_count = 0;
			}
			GLC_SetTextureLightmap(0, i);

			while (surf) {
				glpoly_t* p;

				GLC_SurfaceColor(surf, desired);

				if (first_surf || (use_vbo && (desired[0] != current[0] || desired[1] != current[1] || desired[2] != current[2]))) {
					if (index_count) {
						GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
						index_count = 0;
					}
					if (first_surf) {
						R_ApplyRenderingState(r_state_drawflat_with_lightmaps_glc);
						R_CustomPolygonOffset(polygonOffset ? r_polygonoffset_standard : r_polygonoffset_disabled);
					}
					R_CustomColor4ubv(desired);
				}
				VectorCopy(desired, current);
				first_surf = false;

				for (p = surf->polys; p; p = p->next) {
					v = p->verts[0];

					if (use_vbo) {
						index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
					}
					else {
						R_CustomColor4ubv(desired);
						GLC_Begin(GL_TRIANGLE_STRIP);
						for (k = 0; k < p->numverts; k++, v += VERTEXSIZE) {
							glTexCoord2f(v[5], v[6]);
							GLC_Vertex3fv(v);
						}
						GLC_End();
					}
				}

				if (clear_chains) {
					prev = surf;
					surf = surf->drawflatchain;
					prev->drawflatchain = NULL;
				}
				else {
					surf = surf->drawflatchain;
				}
			}
			if (clear_chains) {
				R_ClearDrawflatLightmapChain(i);
			}
		}
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
	}
}

static void GLC_DrawFlat(model_t *model, qbool polygonOffset)
{
	extern cvar_t gl_program_world;

	if (!model->drawflat_todo) {
		return;
	}

	R_TraceEnterFunctionRegion;

	if (gl_program_world.integer && buffers.supported && modelIndexes && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_DrawflatProgramCompile()) {
		GLC_DrawFlat_GLSL(model, polygonOffset);
	}
	else {
		GLC_DrawFlat_Immediate(model, polygonOffset);
	}

	model->drawflat_chain = NULL;
	model->drawflat_todo = false;

	// START shaman FIX /r_drawflat + /gl_caustics {
	if (r_refdef2.drawCaustics && caustics_polys) {
		GLC_EmitCausticsPolys();
	}
	caustics_polys = NULL;
	// } END shaman FIX /r_drawflat + /gl_caustics

	R_TraceLeaveFunctionRegion;
}

typedef struct texture_unit_allocation_s {
	int matTextureUnit;
	int fbTextureUnit;
	int lmTextureUnit;
	int detailTextureUnit;
	int causticTextureUnit;
	texture_ref null_fb_texture;

	int texture_unit_count;
	qbool couldUseLumaTextures;         // true if user requested lumas and is allowed
	qbool useLumaTextures;              // true if lumas could be used, and model has them
	qbool second_pass_caustics;         // draw caustics in second pass
	qbool second_pass_detail;           // draw detail/noise texture in second pass
	qbool second_pass_luma;             // draw fullbright/luma textures in second pass

	r_state_id rendering_state;         // basic rendering state
} texture_unit_allocation_t;

static void GLC_WorldAllocateTextureUnits(texture_unit_allocation_t* allocations, model_t* model, qbool program_compilation, qbool allow_lumas)
{
	extern cvar_t gl_lumatextures;
	qbool lumas;

	allocations->texture_unit_count = 1;
	allocations->null_fb_texture = null_texture_reference;
	allocations->couldUseLumaTextures = allow_lumas && gl_lumatextures.integer && r_refdef2.allow_lumas;
	allocations->useLumaTextures = allocations->couldUseLumaTextures && model->texturechains_have_lumas;
	allocations->matTextureUnit = allocations->fbTextureUnit = allocations->lmTextureUnit = allocations->detailTextureUnit = allocations->causticTextureUnit = -1;

	lumas = program_compilation ? allocations->couldUseLumaTextures : allocations->useLumaTextures;

	allocations->matTextureUnit = 0;
	if (gl_mtexable) {
		allocations->texture_unit_count = gl_textureunits >= 3 ? 3 : 2;

		if (lumas && !gl_fb_bmodels.integer) {
			// blend(material + fb, lightmap)
			allocations->rendering_state = r_state_world_material_fb_lightmap;
			allocations->null_fb_texture = solidblack_texture;
			allocations->fbTextureUnit = 1;
			allocations->lmTextureUnit = (gl_textureunits >= 3 ? 2 : -1);
		}
		else if (lumas) {
			// blend(material, lightmap) + luma
			allocations->rendering_state = r_state_world_material_lightmap_luma;
			allocations->lmTextureUnit = 1;
			allocations->fbTextureUnit = (gl_textureunits >= 3 ? 2 : -1);
			allocations->null_fb_texture = solidblack_texture; // GL_ADD adds colors, multiplies alphas
		}
		else if (gl_fb_bmodels.integer) {
			// blend(blend(material, lightmap), fb)
			allocations->rendering_state = r_state_world_material_lightmap_fb;
			allocations->lmTextureUnit = 1;
			allocations->fbTextureUnit = (gl_textureunits >= 3 ? 2 : -1);
			allocations->null_fb_texture = transparent_texture; // GL_DECAL mixes color by alpha
		}
		else {
			// blend(material, lightmap) 
			allocations->rendering_state = r_state_world_material_lightmap;
			allocations->lmTextureUnit = 1;
			allocations->fbTextureUnit = -1;
			allocations->null_fb_texture = solidblack_texture; // GL_ADD adds colors, multiplies alphas
			allocations->texture_unit_count = 2;
		}

		if (r_refdef2.drawCaustics && allocations->texture_unit_count < gl_textureunits) {
			allocations->causticTextureUnit = allocations->texture_unit_count++;
		}

		if (gl_detail.integer && R_TextureReferenceIsValid(detailtexture) && allocations->texture_unit_count < gl_textureunits) {
			allocations->detailTextureUnit = allocations->texture_unit_count++;
		}
	}
	else {
		allocations->rendering_state = r_state_world_singletexture_glc;
	}

	allocations->second_pass_caustics = r_refdef2.drawCaustics && allocations->causticTextureUnit < 0;
	allocations->second_pass_detail = R_TextureReferenceIsValid(detailtexture) && gl_detail.integer && allocations->detailTextureUnit < 0;
	allocations->second_pass_luma = lumas && allocations->fbTextureUnit < 0;
}

static void GLC_DrawTextureChains_Immediate(entity_t* ent, model_t *model, qbool caustics, qbool polygonOffset, qbool lumas_only, qbool alpha_surfaces)
{
	texture_unit_allocation_t allocations;
	extern cvar_t gl_lumatextures;
	extern cvar_t gl_textureless;
	int index_count = 0;
	texture_ref fb_texturenum = null_texture_reference;
	int i, k;
	msurface_t *s, *prev;
	float *v;

	qbool use_vbo = buffers.supported && modelIndexes;

	qbool drawfullbrights = false;
	qbool drawlumas = false;
	qbool clear_chains = !r_refdef2.drawWorldOutlines;

	qbool texture_change;
	texture_ref current_material = null_texture_reference;
	texture_ref current_material_fb = null_texture_reference;
	int current_lightmap = -1;

	texture_ref desired_textures[8] = { { 0 } };

	qbool draw_textureless = gl_textureless.integer && model->isworldmodel && !alpha_surfaces;

	GLC_WorldAllocateTextureUnits(&allocations, model, false, lumas_only);
	if (lumas_only && !allocations.useLumaTextures) {
		return;
	}

	R_TraceEnterFunctionRegion;

	GLC_LightmapArrayToggle(false);
	R_ApplyRenderingState(allocations.rendering_state);
	if (ent && ent->alpha) {
		R_CustomColor(ent->alpha, ent->alpha, ent->alpha, ent->alpha);
	}
	if (polygonOffset) {
		R_CustomPolygonOffset(r_polygonoffset_standard);
	}
	if (alpha_surfaces) {
		GLC_CustomAlphaTesting(true);
	}

	if (allocations.causticTextureUnit >= 0) {
		allocations.causticTextureUnit = -1;
		allocations.second_pass_caustics = true;
		--allocations.texture_unit_count;
	}
	if (allocations.detailTextureUnit >= 0) {
		allocations.detailTextureUnit = -1;
		allocations.second_pass_detail = true;
		--allocations.texture_unit_count;
	}

	//Tei: textureless for the world brush models (Qrack)
	if (draw_textureless) {
		if (use_vbo) {
			// meag: better to have different states for this
			R_GLC_DisableTexturePointer(0);
			if (allocations.fbTextureUnit >= 0) {
				R_GLC_DisableTexturePointer(allocations.fbTextureUnit);
			}
		}

		if (GL_Supported(R_SUPPORT_MULTITEXTURING)) {
			GLC_MultiTexCoord2f(GL_TEXTURE0, 0, 0);

			if (allocations.fbTextureUnit >= 0) {
				GLC_MultiTexCoord2f(GL_TEXTURE0 + allocations.fbTextureUnit, 0, 0);
			}
		}
		else {
			glTexCoord2f(0, 0);
		}
	}

	R_ProgramUse(r_program_none);
	for (i = 0; i < model->numtextures; i++) {
		texture_t* t;

		if (!model->textures[i] || !model->textures[i]->texturechain) {
			continue;
		}

		t = R_TextureAnimation(ent, model->textures[i]);
		if (lumas_only && !t->isLumaTexture) {
			continue;
		}
		if (alpha_surfaces != t->isAlphaTested) {
			continue;
		}

		if (allocations.useLumaTextures && t->isLumaTexture) {
			fb_texturenum = t->fb_texturenum;
		}
		else if (!t->isLumaTexture && R_TextureReferenceIsValid(t->fb_texturenum)) {
			fb_texturenum = t->fb_texturenum;
		}
		else {
			fb_texturenum = allocations.null_fb_texture;
		}

		//bind the world texture
		texture_change = !R_TextureReferenceEqual(t->gl_texturenum, current_material);
		texture_change |= !R_TextureReferenceEqual(fb_texturenum, current_material_fb);

		current_material = t->gl_texturenum;
		current_material_fb = fb_texturenum;

		desired_textures[allocations.matTextureUnit] = current_material;
		if (allocations.fbTextureUnit >= 0) {
			desired_textures[allocations.fbTextureUnit] = current_material_fb;
		}

		s = model->textures[i]->texturechain;
		while (s) {
			if (!(s->texinfo->flags & TEX_SPECIAL)) {
				if (allocations.lmTextureUnit >= 0) {
					desired_textures[allocations.lmTextureUnit] = GLC_LightmapTexture(s->lightmaptexturenum);
					texture_change |= !R_TextureReferenceEqual(desired_textures[allocations.lmTextureUnit], GLC_LightmapTexture(current_lightmap));
					current_lightmap = s->lightmaptexturenum;
				}
				else {
					GLC_AddToLightmapChain(s);
				}

				if (texture_change) {
					if (index_count) {
						GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
						index_count = 0;
					}

					renderer.TextureUnitMultiBind(0, allocations.texture_unit_count, desired_textures);
					if (r_lightmap_lateupload.integer && allocations.lmTextureUnit >= 0) {
						R_UploadLightMap(allocations.lmTextureUnit, current_lightmap);
					}

					texture_change = false;
				}

				if (use_vbo) {
					index_count = GLC_DrawIndexedPoly(s->polys, modelIndexes, modelIndexMaximum, index_count);
				}
				else {
					v = s->polys->verts[0];

					GLC_Begin(GL_TRIANGLE_STRIP);
					for (k = 0; k < s->polys->numverts; k++, v += VERTEXSIZE) {
						if (allocations.lmTextureUnit >= 0) {
							GLC_MultiTexCoord2f(GL_TEXTURE0 + allocations.lmTextureUnit, v[5], v[6]);
						}

						if (!draw_textureless) {
							if (GL_Supported(R_SUPPORT_MULTITEXTURING)) {
								GLC_MultiTexCoord2f(GL_TEXTURE0, v[3], v[4]);

								if (allocations.fbTextureUnit >= 0) {
									GLC_MultiTexCoord2f(GL_TEXTURE0 + allocations.fbTextureUnit, v[3], v[4]);
								}
							}
							else {
								glTexCoord2f(v[3], v[4]);
							}
						}
						GLC_Vertex3fv(v);
					}
					GLC_End();
				}
			}

			if (allocations.second_pass_caustics && ((s->flags & SURF_UNDERWATER) || caustics)) {
				s->polys->caustics_chain = caustics_polys;
				caustics_polys = s->polys;
			}

			if (allocations.second_pass_detail && !(s->flags & SURF_UNDERWATER)) {
				s->polys->detail_chain = detail_polys;
				detail_polys = s->polys;
			}

			if (!R_TextureReferenceEqual(fb_texturenum, allocations.null_fb_texture) && gl_fb_bmodels.integer && allocations.fbTextureUnit < 0) {
				if (allocations.useLumaTextures) {
					s->polys->luma_chain = luma_polys[fb_texturenum.index];
					luma_polys[fb_texturenum.index] = s->polys;
					drawlumas = true;
				}
				else {
					s->polys->fb_chain = fullbright_polys[fb_texturenum.index];
					fullbright_polys[fb_texturenum.index] = s->polys;
					drawfullbrights = true;
				}
			}

			if (clear_chains) {
				prev = s;
				s = s->texturechain;
				prev->texturechain = NULL;
			}
			else {
				s = s->texturechain;
			}
		}
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
	}

	if (gl_fb_bmodels.integer) {
		if (allocations.lmTextureUnit < 0) {
			GLC_BlendLightmaps();
		}
		if (drawfullbrights) {
			GLC_RenderFullbrights();
		}
		if (drawlumas) {
			GLC_RenderLumas();
		}
	}
	else {
		if (drawlumas) {
			GLC_RenderLumas();
		}
		if (allocations.lmTextureUnit < 0) {
			GLC_BlendLightmaps();
		}
		if (drawfullbrights) {
			GLC_RenderFullbrights();
		}
	}

	GLC_EmitCausticsPolys();
	GLC_EmitDetailPolys(use_vbo);

	if (alpha_surfaces) {
		GLC_CustomAlphaTesting(false);
	}

	R_TraceLeaveFunctionRegion;
}

static qbool GLC_WorldTexturedProgramCompile(texture_unit_allocation_t* allocations, model_t* model, qbool alpha_surfaces)
{
	extern cvar_t gl_lumatextures, gl_textureless;
	int options;
	qbool drawLumas = false;
	
	memset(allocations, 0, sizeof(*allocations));
	GLC_WorldAllocateTextureUnits(allocations, model, true, true);
	allocations->rendering_state = r_state_world_material_lightmap_luma;

	drawLumas = allocations->couldUseLumaTextures;

	options =
		(allocations->lmTextureUnit >= 0 ? GLC_WORLD_LIGHTMAPS : 0) |
		(drawLumas ? GLC_WORLD_LUMATEXTURES : 0) |
		(allocations->fbTextureUnit >= 0 && gl_fb_bmodels.integer ? GLC_WORLD_FULLBRIGHTS : 0) |
		(allocations->detailTextureUnit >= 0 ? GLC_WORLD_DETAIL : 0) |
		(allocations->causticTextureUnit >= 0 ? GLC_WORLD_CAUSTICS : 0) |
		(r_drawflat.integer && r_drawflat_mode.integer == 0 ? GLC_WORLD_DF_NORMAL : 0) |
		(r_drawflat.integer && r_drawflat_mode.integer == 1 ? GLC_WORLD_DF_TINTED : 0) |
		(r_drawflat.integer && r_drawflat_mode.integer == 2 ? GLC_WORLD_DF_BRIGHT : 0) |
		(r_drawflat.integer == 1 || r_drawflat.integer == 2 ? GLC_WORLD_DF_FLOORS : 0) |
		(r_drawflat.integer == 1 || r_drawflat.integer == 3 ? GLC_WORLD_DF_WALLS : 0);

	R_ProgramSetSubProgram(r_program_world_textured_glc, (alpha_surfaces ? 1 : 0));
	if (R_ProgramRecompileNeeded(r_program_world_textured_glc, options)) {
		int sampler = 0;
		char definitions[2048] = { 0 };

		allocations->matTextureUnit = 0;

		if (options & GLC_WORLD_LUMATEXTURES) {
			strlcat(definitions, "#define DRAW_LUMA_TEXTURES\n", sizeof(definitions));
		}
		if (options & GLC_WORLD_FULLBRIGHTS) {
			strlcat(definitions, "#define DRAW_FULLBRIGHT_TEXTURES\n", sizeof(definitions));
		}
		if (options & GLC_USE_FULLBRIGHT_TEX) {
			strlcat(definitions, "#define DRAW_EXTRA_TEXTURES\n", sizeof(definitions));
		}
		if (options & GLC_WORLD_CAUSTICS) {
			strlcat(definitions, "#define DRAW_CAUSTICS\n", sizeof(definitions));
		}
		if (options & GLC_WORLD_DETAIL) {
			strlcat(definitions, "#define DRAW_DETAIL\n", sizeof(definitions));
		}
		if (options & GLC_WORLD_LIGHTMAPS) {
			strlcat(definitions, "#define DRAW_LIGHTMAPS\n", sizeof(definitions));
		}
		if (glConfig.supported_features & R_SUPPORT_TEXTURE_ARRAYS) {
			strlcat(definitions, "#define EZ_USE_TEXTURE_ARRAYS\n", sizeof(definitions));
		}
		if (options & GLC_WORLD_DF_NORMAL) {
			strlcat(definitions, "#define DRAW_DRAWFLAT_NORMAL\n", sizeof(definitions));
		}
		else if (options & GLC_WORLD_DF_TINTED) {
			strlcat(definitions, "#define DRAW_DRAWFLAT_TINTED\n", sizeof(definitions));
		}
		else if (options & GLC_WORLD_DF_BRIGHT) {
			strlcat(definitions, "#define DRAW_DRAWFLAT_BRIGHT\n", sizeof(definitions));
		}
		if (options & GLC_WORLD_DF_FLOORS) {
			strlcat(definitions, "#define DRAW_FLATFLOORS\n", sizeof(definitions));
		}
		if (options & GLC_WORLD_DF_WALLS) {
			strlcat(definitions, "#define DRAW_FLATWALLS\n", sizeof(definitions));
		}
		if (alpha_surfaces) {
			strlcat(definitions, "#define DRAW_ALPHATEST_ENABLED\n", sizeof(definitions));
		}
		GLC_GLSL_AddFogOptions(definitions, sizeof(definitions), options);

		R_ProgramCompileWithInclude(r_program_world_textured_glc, definitions);

		allocations->causticTextureUnit = (options & GLC_WORLD_CAUSTICS) && allocations->causticTextureUnit >= 0 ? sampler++ : -1;
		allocations->detailTextureUnit = (options & GLC_WORLD_DETAIL) && allocations->detailTextureUnit >= 0 ? sampler++ : -1;
		allocations->lmTextureUnit = (options & GLC_WORLD_LIGHTMAPS) && allocations->lmTextureUnit >= 0 ? sampler++ : -1;
		allocations->matTextureUnit = allocations->matTextureUnit >= 0 ? sampler++ : -1;
		allocations->fbTextureUnit = (options & GLC_USE_FULLBRIGHT_TEX) && allocations->fbTextureUnit >= 0 ? sampler++ : -1;

		R_ProgramUniform1i(r_program_uniform_world_textured_glc_causticSampler, allocations->causticTextureUnit);
		R_ProgramUniform1i(r_program_uniform_world_textured_glc_detailSampler, allocations->detailTextureUnit);
		R_ProgramUniform1i(r_program_uniform_world_textured_glc_lightmapSampler, allocations->lmTextureUnit);
		R_ProgramUniform1i(r_program_uniform_world_textured_glc_texSampler, allocations->matTextureUnit);
		R_ProgramUniform1i(r_program_uniform_world_textured_glc_lumaSampler, allocations->fbTextureUnit);

		R_ProgramSetCustomOptions(r_program_world_textured_glc, options);
	}
	else {
		allocations->causticTextureUnit = R_ProgramUniformGet1i(r_program_uniform_world_textured_glc_causticSampler, -1);
		allocations->detailTextureUnit = R_ProgramUniformGet1i(r_program_uniform_world_textured_glc_detailSampler, -1);
		allocations->lmTextureUnit = R_ProgramUniformGet1i(r_program_uniform_world_textured_glc_lightmapSampler, -1);
		allocations->matTextureUnit = R_ProgramUniformGet1i(r_program_uniform_world_textured_glc_texSampler, -1);
		allocations->fbTextureUnit = R_ProgramUniformGet1i(r_program_uniform_world_textured_glc_lumaSampler, -1);

		allocations->texture_unit_count =
			(allocations->causticTextureUnit >= 0 ? 1 : 0) +
			(allocations->detailTextureUnit >= 0 ? 1 : 0) +
			(allocations->lmTextureUnit >= 0 ? 1 : 0) +
			(allocations->matTextureUnit >= 0 ? 1 : 0) +
			(allocations->fbTextureUnit >= 0 ? 1 : 0);
	}

	R_ProgramSetStandardUniforms(r_program_world_textured_glc);

	R_TraceLogAPICall("--- units      = %d", allocations->texture_unit_count);
	R_TraceLogAPICall("... caustics   = %d", allocations->causticTextureUnit);
	R_TraceLogAPICall("... detail     = %d", allocations->detailTextureUnit);
	R_TraceLogAPICall("... lightmaps  = %d", allocations->lmTextureUnit);
	R_TraceLogAPICall("... materials  = %d", allocations->matTextureUnit);
	R_TraceLogAPICall("... fullbright = %d", allocations->fbTextureUnit);

	if (R_ProgramRecompileNeeded(r_program_world_secondpass_glc, 0)) {
		// we could make multiple copies of the standard textured program,
		//  so that multiple passes use multiple textures
		R_ProgramCompile(r_program_world_secondpass_glc);

		R_ProgramUniform1i(r_program_uniform_world_textured_glc_causticSampler, 0);
	}

	R_ProgramSetStandardUniforms(r_program_world_secondpass_glc);

	return R_ProgramReady(r_program_world_textured_glc) && R_ProgramReady(r_program_world_secondpass_glc);
}

static void GLC_DrawTextureChains_GLSL(entity_t* ent, model_t *model, qbool caustics, qbool polygonOffset, texture_unit_allocation_t* allocations, qbool alpha_surfaces)
{
	extern cvar_t gl_lumatextures;
	int index_count = 0;
	int i;
	msurface_t *s, *prev;

	qbool requires_fullbright_pass = false;
	qbool requires_luma_pass = false;
	qbool clear_chains = !r_refdef2.drawWorldOutlines;

	qbool texture_change, uniform_change;
	texture_ref current_material = null_texture_reference;
	texture_ref current_material_fb = null_texture_reference;
	texture_ref desired_textures[8] = { { 0 } };
	int current_lightmap = -1;
	float current_lumaScale = -1, current_fbScale = -1;

	R_TraceEnterFunctionRegion;

	GLC_LightmapArrayToggle(true);

	R_ApplyRenderingState(allocations->rendering_state);
	if (ent && ent->alpha) {
		R_CustomColor(ent->alpha, ent->alpha, ent->alpha, ent->alpha);
	}
	if (polygonOffset) {
		R_CustomPolygonOffset(r_polygonoffset_standard);
	}

	// Common textures
	if (allocations->causticTextureUnit >= 0) {
		desired_textures[allocations->causticTextureUnit] = underwatertexture;
	}
	if (allocations->detailTextureUnit >= 0) {
		desired_textures[allocations->detailTextureUnit] = detailtexture;
	}

	for (i = 0; i < model->numtextures; i++) {
		texture_t* t;
		texture_ref fb_texturenum = null_texture_reference;
		float lumaScale = 0.0f, fbScale = 0.0f;

		if (!model->textures[i] || !model->textures[i]->texturechain) {
			continue;
		}
		if (model->textures[i]->isAlphaTested != alpha_surfaces) {
			continue;
		}

		t = R_TextureAnimation(ent, model->textures[i]);
		if (allocations->useLumaTextures && t->isLumaTexture && gl_fb_bmodels.integer) {
			fb_texturenum = t->fb_texturenum;
			lumaScale = 1.0f;
			//fbScale = 1.0f;
		}
		else if (allocations->fbTextureUnit >= 0 && R_TextureReferenceIsValid(t->fb_texturenum)) {
			fb_texturenum = t->fb_texturenum;
			lumaScale = (allocations->useLumaTextures && t->isLumaTexture && !gl_fb_bmodels.integer ? 1.0f : 0);
			fbScale = (t->isLumaTexture ? 0.0f : 1.0f);
		}
		else {
			fb_texturenum = allocations->null_fb_texture;
		}

		//bind the world texture
		texture_change = !R_TextureReferenceEqual(t->gl_texturenum, current_material);
		texture_change |= !R_TextureReferenceEqual(fb_texturenum, current_material_fb);
		current_material = t->gl_texturenum;
		current_material_fb = fb_texturenum;

		uniform_change = (current_lumaScale != lumaScale);
		uniform_change |= (current_fbScale != fbScale);

		desired_textures[allocations->matTextureUnit] = current_material;
		if (allocations->fbTextureUnit >= 0) {
			desired_textures[allocations->fbTextureUnit] = current_material_fb;
		}

		s = model->textures[i]->texturechain;
		while (s) {
			if (!(s->texinfo->flags & TEX_SPECIAL)) {
				if (allocations->lmTextureUnit >= 0) {
					texture_change |= !R_TextureReferenceEqual(GLC_LightmapTexture(s->lightmaptexturenum), GLC_LightmapTexture(current_lightmap));

					desired_textures[allocations->lmTextureUnit] = GLC_LightmapTexture(s->lightmaptexturenum);
					current_lightmap = s->lightmaptexturenum;
				}
				else {
					GLC_AddToLightmapChain(s);
				}

				if (texture_change) {
					if (index_count) {
						GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
						index_count = 0;
					}

					renderer.TextureUnitMultiBind(0, allocations->texture_unit_count, desired_textures);
					if (r_lightmap_lateupload.integer && allocations->lmTextureUnit >= 0) {
						R_UploadLightMap(allocations->lmTextureUnit, current_lightmap);
					}

					texture_change = false;
				}
				if (uniform_change) {
					if (index_count) {
						GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
						index_count = 0;
					}
					if (current_lumaScale != lumaScale) {
						R_ProgramUniform1f(r_program_uniform_world_textured_glc_lumaScale, current_lumaScale = lumaScale);
					}
					if (current_fbScale != fbScale) {
						R_ProgramUniform1f(r_program_uniform_world_textured_glc_fbScale, current_fbScale = fbScale);
					}
					uniform_change = false;
				}

				index_count = GLC_DrawIndexedPoly(s->polys, modelIndexes, modelIndexMaximum, index_count);
			}

			if (allocations->second_pass_caustics && ((s->flags & SURF_UNDERWATER) || caustics)) {
				s->polys->caustics_chain = caustics_polys;
				caustics_polys = s->polys;
			}

			if (allocations->second_pass_detail && !(s->flags & SURF_UNDERWATER)) {
				s->polys->detail_chain = detail_polys;
				detail_polys = s->polys;
			}

			if (allocations->second_pass_luma && !R_TextureReferenceEqual(fb_texturenum, allocations->null_fb_texture)) {
				if (allocations->useLumaTextures) {
					s->polys->luma_chain = luma_polys[fb_texturenum.index];
					luma_polys[fb_texturenum.index] = s->polys;
					requires_luma_pass = true;
				}
				else {
					s->polys->fb_chain = fullbright_polys[fb_texturenum.index];
					fullbright_polys[fb_texturenum.index] = s->polys;
					requires_fullbright_pass = true;
				}
			}

			if (clear_chains) {
				prev = s;
				s = s->texturechain;
				prev->texturechain = NULL;
			}
			else {
				s = s->texturechain;
			}
		}
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
	}

	if (gl_fb_bmodels.integer) {
		if (allocations->lmTextureUnit < 0) {
			GLC_BlendLightmaps_GLSL();
		}
		if (requires_fullbright_pass) {
			GLC_RenderFullbrights_GLSL();
		}
		if (requires_luma_pass) {
			GLC_RenderLumas_GLSL();
		}
	}
	else {
		if (requires_luma_pass) {
			GLC_RenderLumas_GLSL();
		}
		if (allocations->lmTextureUnit < 0) {
			GLC_BlendLightmaps_GLSL();
		}
		if (requires_fullbright_pass) {
			GLC_RenderFullbrights_GLSL();
		}
	}

	if (allocations->second_pass_caustics) {
		GLC_EmitCausticsPolys();
	}
	if (allocations->second_pass_detail) {
		GLC_EmitDetailPolys_GLSL();
	}

	R_TraceLeaveFunctionRegion;
}

static void GLC_DrawTextureChains(entity_t* ent, model_t *model, qbool caustics, qbool polygonOffset, qbool alpha_surfaces)
{
	extern cvar_t gl_program_world, gl_textureless;
	texture_unit_allocation_t allocations;

	if (alpha_surfaces) {
		// No alpha surfaces to draw
		if (!model->alphapass_todo) {
			return;
		}
	}
	else if (r_drawflat.integer == 1 && r_drawflat_mode.integer == 0 && model->isworldmodel) {
		// Guaranteed to be no texturing
		return;
	}

	if (gl_program_world.integer && buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_WorldTexturedProgramCompile(&allocations, model, alpha_surfaces)) {
		R_ProgramUse(r_program_world_textured_glc);
		R_ProgramUniform1f(r_program_uniform_world_textured_glc_time, cl.time);
		R_ProgramUniform3f(r_program_uniform_world_textured_glc_r_floorcolor, r_floorcolor.color[0] / 255.0f, r_floorcolor.color[1] / 255.0f, r_floorcolor.color[2] / 255.0f);
		R_ProgramUniform3f(r_program_uniform_world_textured_glc_r_wallcolor, r_wallcolor.color[0] / 255.0f, r_wallcolor.color[1] / 255.0f, r_wallcolor.color[2] / 255.0f);
		R_ProgramUniform1f(r_program_uniform_world_textures_glc_texture_multiplier, model->isworldmodel && gl_textureless.integer ? 0.0f : 1.0f);

		GLC_DrawTextureChains_GLSL(ent, model, caustics, polygonOffset, &allocations, alpha_surfaces);
		R_ProgramUse(r_program_none);
	}
	else {
		if (model->texturechains_have_lumas) {
			GLC_DrawTextureChains_Immediate(ent, model, caustics, polygonOffset, true, alpha_surfaces);
		}
		GLC_DrawTextureChains_Immediate(ent, model, caustics, polygonOffset, false, alpha_surfaces);
	}
}

qbool GLC_PreCompileWorldPrograms(void)
{
	extern cvar_t gl_program_world;
	texture_unit_allocation_t allocations;

	return (gl_program_world.integer && buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_WorldTexturedProgramCompile(&allocations, cl.worldmodel, false) && GLC_WorldTexturedProgramCompile(&allocations, cl.worldmodel, true));
}

// This is now very similar to GLC_DrawBrushModel, but we don't draw sky surfaces at this stage
//  (they've already been drawn)
// Also water surfaces are drawn immediately after if opaque, but after entities if not (on sub/instanced models
//   water surfaces are always drawn during the texture chaining phase, which is something to fix)
void GLC_DrawWorld(void)
{
	R_TraceEnterFunctionRegion;

	GLC_DrawTextureChains(NULL, cl.worldmodel, false, false, false);
	GLC_DrawFlat(cl.worldmodel, false);
	GLC_DrawMapOutline(cl.worldmodel);
	GLC_DrawTextureChains(NULL, cl.worldmodel, false, false, true);

	R_TraceLeaveFunctionRegion;
}

void GLC_DrawBrushModel(entity_t* e, qbool polygonOffset, qbool caustics)
{
	GLC_DrawTextureChains(e, e->model, caustics, polygonOffset, false);
	GLC_DrawFlat(e->model, polygonOffset);
	GLC_DrawMapOutline(e->model);
	GLC_SkyDrawChainedSurfaces();
	GLC_DrawTextureChains(e, e->model, caustics, polygonOffset, true);
	//GLC_DrawAlphaChain(alphachain, polyTypeBrushModel);
}

/*
// This populates VBO, splitting up by lightmap for efficient
//   rendering when not using texture arrays
int GLC_PopulateVBOForBrushModel(model_t* m, float* vbo_buffer, int vbo_pos)
{
	int i, j;
	int combinations = 0;
	int original_pos = vbo_pos;

	for (i = 0; i < m->numtextures; ++i) {
		if (m->textures[i]) {
			m->textures[i]->gl_first_lightmap = -1;
			for (j = 0; j < MAX_LIGHTMAPS; ++j) {
				m->textures[i]->gl_next_lightmap[j] = -1;
			}
		}
	}

	// Order vertices in the VBO by texture & lightmap
	for (i = 0; i < m->numtextures; ++i) {
		int lightmap = -1;
		int length = 0;
		int surface_count = 0;
		int tex_vbo_start = vbo_pos;

		if (!m->textures[i]) {
			continue;
		}

		// Find first lightmap for this texture
		for (j = 0; j < m->numsurfaces; ++j) {
			msurface_t* surf = m->surfaces + j;

			if (surf->texinfo->miptex != i) {
				continue;
			}

			if (!(surf->flags & (SURF_DRAWTURB | SURF_DRAWSKY))) {
				if (surf->texinfo->flags & TEX_SPECIAL) {
					continue;
				}
			}

			if (surf->lightmaptexturenum >= 0 && (lightmap < 0 || surf->lightmaptexturenum < lightmap)) {
				lightmap = surf->lightmaptexturenum;
			}
		}

		m->textures[i]->gl_first_lightmap = lightmap;

		// Build the VBO in order of lightmaps...
		while (lightmap >= 0) {
			int next_lightmap = -1;

			length = 0;
			m->textures[i]->gl_vbo_start[lightmap] = vbo_pos / VERTEXSIZE;
			++combinations;

			for (j = 0; j < m->numsurfaces; ++j) {
				msurface_t* surf = m->surfaces + j;
				glpoly_t* poly;

				if (surf->texinfo->miptex != i) {
					continue;
				}
				if (surf->lightmaptexturenum > lightmap && (next_lightmap < 0 || surf->lightmaptexturenum < next_lightmap)) {
					next_lightmap = surf->lightmaptexturenum;
				}

				if (surf->lightmaptexturenum == lightmap) {
					// copy verts into buffer (alternate to turn fan into triangle strip)
					for (poly = surf->polys; poly; poly = poly->next) {
						int end_vert = 0;
						int start_vert = 1;
						int output = 0;
						int material = m->textures[i]->gl_texture_index;
						float scaleS = m->textures[i]->gl_texture_scaleS;
						float scaleT = m->textures[i]->gl_texture_scaleT;

						if (!poly->numverts) {
							continue;
						}

						// Store position for drawing individual polys
						poly->vbo_start = vbo_pos / VERTEXSIZE;
						vbo_pos = CopyVertToBuffer(vbo_buffer, vbo_pos, poly->verts[0], surf->lightmaptexturenum, material, scaleS, scaleT);
						++output;

						start_vert = 1;
						end_vert = poly->numverts - 1;

						while (start_vert <= end_vert) {
							vbo_pos = CopyVertToBuffer(vbo_buffer, vbo_pos, poly->verts[start_vert], surf->lightmaptexturenum, material, scaleS, scaleT);
							++output;

							if (start_vert < end_vert) {
								vbo_pos = CopyVertToBuffer(vbo_buffer, vbo_pos, poly->verts[end_vert], surf->lightmaptexturenum, material, scaleS, scaleT);
								++output;
							}

							++start_vert;
							--end_vert;
						}

						length += poly->numverts;
						++surface_count;
					}
				}
			}

			m->textures[i]->gl_vbo_length[lightmap] = length;
			m->textures[i]->gl_next_lightmap[lightmap] = next_lightmap;
			lightmap = next_lightmap;
		}
	}

	Con_Printf("%s = %d verts, reserved %d\n", m->name, (vbo_pos - original_pos) / VERTEXSIZE, GLM_MeasureVBOSizeForBrushModel(m));
	return vbo_pos;
}
*/

static void GLC_BlendLightmaps_GLSL(void)
{
	int i;

	GLC_StateBeginBlendLightmaps(true);
	R_ProgramUse(r_program_world_secondpass_glc);

	for (i = 0; i < GLC_LightmapCount(); i++) {
		GLuint index_count = 0;
		glpoly_t *p = GLC_LightmapChain(i);

		if (p) {
			GLC_LightmapUpdate(i);
			renderer.TextureUnitBind(0, GLC_LightmapTexture(i));

			for (; p; p = p->chain) {
				index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
			}

			if (index_count) {
				GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
				index_count = 0;
			}
		}
	}

	GLC_ClearLightmapPolys();
}

static void GLC_BlendLightmaps(void)
{
	int i, j;
	glpoly_t *p;
	float *v;
	qbool use_vbo = buffers.supported && modelIndexes;

	R_ProgramUse(r_program_none);
	GLC_StateBeginBlendLightmaps(use_vbo);
	
	for (i = 0; i < GLC_LightmapCount(); i++) {
		if (!(p = GLC_LightmapChain(i))) {
			continue;
		}

		GLC_LightmapUpdate(i);
		renderer.TextureUnitBind(0, GLC_LightmapTexture(i));
		if (use_vbo) {
			GLuint index_count = 0;

			for (; p; p = p->chain) {
				index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
			}

			if (index_count) {
				GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
			}
		}
		else {
			for (; p; p = p->chain) {
				GLC_Begin(GL_TRIANGLE_STRIP);
				v = p->verts[0];
				for (j = 0; j < p->numverts; j++, v += VERTEXSIZE) {
					glTexCoord2f(v[5], v[6]);
					GLC_Vertex3fv(v);
				}
				GLC_End();
			}
		}
	}
	GLC_ClearLightmapPolys();
}

//draws transparent textures for HL world and nonworld models
void GLC_DrawAlphaChain(msurface_t* alphachain, frameStatsPolyType polyType)
{
	int k;
	msurface_t *s;
	float *v;

	if (!alphachain) {
		return;
	}

	R_ProgramUse(r_program_none);
	GLC_StateBeginAlphaChain();

	for (s = alphachain; s; s = s->texturechain) {
		++frameStats.classic.polycount[polyType];
		R_RenderDynamicLightmaps(s, false);

		GLC_StateBeginAlphaChainSurface(s);

		GLC_Begin(GL_TRIANGLE_STRIP);
		v = s->polys->verts[0];
		for (k = 0; k < s->polys->numverts; k++, v += VERTEXSIZE) {
			if (gl_mtexable) {
				GLC_MultiTexCoord2f(GL_TEXTURE0, v[3], v[4]);
				GLC_MultiTexCoord2f(GL_TEXTURE1, v[5], v[6]);
			}
			else {
				glTexCoord2f(v[3], v[4]);
			}
			GLC_Vertex3fv(v);
		}
		GLC_End();
	}
	alphachain = NULL;
}

int GLC_BrushModelCopyVertToBuffer(model_t* mod, void* vbo_buffer_, int position, float* source, int lightmap, int material, float scaleS, float scaleT, msurface_t* surf, qbool has_fb_texture, qbool has_luma_texture)
{
	glc_vbo_world_vert_t* target = (glc_vbo_world_vert_t*)vbo_buffer_ + position;

	VectorCopy(source, target->position);
	target->material_coords[0] = source[3];
	target->material_coords[1] = source[4];
	target->lightmap_coords[0] = source[5];
	target->lightmap_coords[1] = source[6];
	target->lightmap_coords[2] = lightmap;
	target->detail_coords[0] = source[7];
	target->detail_coords[1] = source[8];
	if (scaleS) {
		target->material_coords[0] *= scaleS;
	}
	if (scaleT) {
		target->material_coords[1] *= scaleT;
	}

	target->flatstyle = 0;
	if (surf->flags & SURF_DRAWSKY) {
		target->flatstyle = 1;
	}
	else if (surf->flags & SURF_DRAWTURB) {
		if (surf->texinfo->texture->turbType == TEXTURE_TURB_WATER) {
			target->flatstyle = 2;
		}
		else if (surf->texinfo->texture->turbType == TEXTURE_TURB_SLIME) {
			target->flatstyle = 4;
		}
		else if (surf->texinfo->texture->turbType == TEXTURE_TURB_LAVA) {
			target->flatstyle = 8;
		}
		else if (surf->texinfo->texture->turbType == TEXTURE_TURB_TELE) {
			target->flatstyle = 16;
		}
		else if (surf->texinfo->texture->turbType == TEXTURE_TURB_SKY) {
			target->flatstyle = 32;
		}
	}
	else if (mod->isworldmodel) {
		target->flatstyle = (surf->flags & SURF_DRAWFLAT_FLOOR ? 64 : 128);
	}

	target->flatstyle += (has_luma_texture ? 256 : 0);
	target->flatstyle += (mod->isworldmodel && (surf->flags & SURF_UNDERWATER)) ? 512 : 0;
	target->flatstyle += (has_fb_texture ? 1024 : 0);

	return position + 1;
}

void GLC_ChainBrushModelSurfaces(model_t* clmodel, entity_t* ent)
{
	extern void GLC_EmitWaterPoly(msurface_t* fa);
	qbool glc_first_water_poly = true;
	msurface_t* psurf;
	int i;
	qbool drawFlatFloors = clmodel->isworldmodel && (r_drawflat.integer == 2 || r_drawflat.integer == 1) && r_drawflat_mode.integer == 0;
	qbool drawFlatWalls = clmodel->isworldmodel && (r_drawflat.integer == 3 || r_drawflat.integer == 1) && r_drawflat_mode.integer == 0;
	extern msurface_t* skychain;
	extern msurface_t* alphachain;

	psurf = &clmodel->surfaces[clmodel->firstmodelsurface];
	for (i = 0; i < clmodel->nummodelsurfaces; i++, psurf++) {
		// find which side of the node we are on
		mplane_t* pplane = psurf->plane;
		float dot = PlaneDiff(modelorg, pplane);
		qbool isFloor = (psurf->flags & SURF_DRAWFLAT_FLOOR);

		//draw the water surfaces now, and setup sky/normal chains
		if (((psurf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
			(!(psurf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON))) {
			if (psurf->flags & SURF_DRAWSKY) {
				if (r_fastsky.integer) {
					CHAIN_SURF_B2F(psurf, clmodel->drawflat_chain);
					clmodel->drawflat_todo = true;
				}
				else {
					CHAIN_SURF_B2F(psurf, skychain);
				}
			}
			else if (psurf->flags & SURF_DRAWTURB) {
				if (glc_first_water_poly) {
					GLC_StateBeginWaterSurfaces();
					glc_first_water_poly = false;
				}
				GLC_EmitWaterPoly(psurf);
			}
			else if (psurf->flags & SURF_DRAWALPHA) {
				CHAIN_SURF_B2F(psurf, alphachain);
			}
			else {
				if (drawFlatFloors && isFloor) {
					R_AddDrawflatChainSurface(psurf, false);
					clmodel->drawflat_todo = true;
				}
				else if (drawFlatWalls && !isFloor) {
					R_AddDrawflatChainSurface(psurf, true);
					clmodel->drawflat_todo = true;
				}
				else {
					chain_surfaces_by_lightmap(&psurf->texinfo->texture->texturechain, psurf);

					clmodel->texturechains_have_lumas |= R_TextureAnimation(ent, psurf->texinfo->texture)->isLumaTexture;
					clmodel->first_texture_chained = min(clmodel->first_texture_chained, psurf->texinfo->miptex);
					clmodel->last_texture_chained = max(clmodel->last_texture_chained, psurf->texinfo->miptex);
				}
			}
		}
	}
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_draw.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 2017-2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "glm_draw.h"
#include "r_draw.h"
#include "r_state.h"
#include "r_matrix.h"
#include "r_texture.h"
#include "glc_vao.h"
#include "glsl/constants.glsl" // FIXME: remove
#include "glc_local.h"
#include "r_renderer.h"
#include "tr_types.h"
#include "gl_texture.h"

static texture_ref glc_last_texture_used;
static int extraIndexesPerImage;
extern float overall_alpha;
extern float cachedMatrix[16];

qbool GLC_ProgramHudImagesCompile(void);

void GLC_DrawDisc(void)
{

}

void GLC_HudDrawComplete(void)
{
	if (R_TextureReferenceIsValid(glc_last_texture_used)) {
		renderer.TextureSetFiltering(glc_last_texture_used, texture_minification_linear, texture_magnification_linear);
	}
}

void GLC_HudDrawCircles(texture_ref texture, int start, int end)
{
	// FIXME: Not very efficient (but rarely used either)
	int i, j;

	start = max(0, start);
	end = min(end, circleData.circleCount - 1);

	R_ProgramUse(r_program_none);
	for (i = start; i <= end; ++i) {
		GLC_StateBeginDrawAlphaPieSliceRGB(circleData.drawCircleThickness[i]);
		R_CustomColor(
			circleData.drawCircleColors[i][0],
			circleData.drawCircleColors[i][1],
			circleData.drawCircleColors[i][2],
			circleData.drawCircleColors[i][3]
		);

		GLC_Begin(circleData.drawCircleFill[i] ? GL_TRIANGLE_STRIP : GL_LINE_LOOP);
		for (j = 0; j < circleData.drawCirclePoints[i]; ++j) {
			GLC_Vertex2fv(&circleData.drawCirclePointData[i * FLOATS_PER_CIRCLE + j * 2]);
		}
		GLC_End();
	}
}

void GLC_HudPrepareCircles(void)
{

}

static void GLC_HudDrawLinesVertexArray(r_program_id program_id, texture_ref texture, int start, int end)
{
	extern cvar_t gl_vbo_clientmemory;
	uintptr_t offset = gl_vbo_clientmemory.integer ? 0 : buffers.BufferOffset(r_buffer_hud_image_vertex_data) / sizeof(imageData.images[0]);
	int i;

	R_ProgramUse(program_id);
	R_ApplyRenderingState(program_id == r_program_none ? r_state_hud_images_glc_non_glsl : r_state_hud_images_glc);
	renderer.TextureUnitBind(0, texture);
	for (i = start; i <= end; ++i) {
		R_StateBeginAlphaLineRGB(lineData.line_thickness[i]);

		GL_DrawArrays(GL_LINES, offset + lineData.imageIndex[i], 2);
	}
}

static void GLC_HudDrawLinesImmediate(texture_ref texture, int start, int end)
{
	int i;

	R_ProgramUse(r_program_none);
	R_ApplyRenderingState(r_state_hud_images_glc_non_glsl);
	renderer.TextureUnitBind(0, texture);

	for (i = start; i <= end; ++i) {
		glm_image_t* img = &imageData.images[lineData.imageIndex[i]];

		R_StateBeginAlphaLineRGB(lineData.line_thickness[i]);
		glTexCoord2f(img[0].tex[0], img[0].tex[1]);

		GLC_Begin(GL_LINES);
		R_CustomColor4ubv(img[0].colour);
		GLC_Vertex2fv(img[0].pos);
		R_CustomColor4ubv(img[1].colour);
		GLC_Vertex2fv(img[1].pos);
		GLC_End();
	}
}

void GLC_HudDrawLines(texture_ref texture, int start, int end)
{
	extern cvar_t gl_program_hud;

	if (buffers.supported && gl_program_hud.integer && GLC_ProgramHudImagesCompile()) {
		GLC_HudDrawLinesVertexArray(r_program_hud_images_glc, texture, start, end);
	}
	else if (R_VAOBound()) {
		GLC_HudDrawLinesVertexArray(r_program_none, texture, start, end);
	}
	else {
		GLC_HudDrawLinesImmediate(texture, start, end);
	}
}

static void GLC_HudDrawPolygonsImmediate(texture_ref texture, int start, int end)
{
	int i, j;

	R_ProgramUse(r_program_none);
	R_ApplyRenderingState(r_state_hud_images_glc_non_glsl);
	renderer.TextureUnitBind(0, texture);

	for (i = start; i <= end; ++i) {
		glm_image_t* img = &imageData.images[polygonData.polygonImageIndexes[i]];

		R_CustomColor4ubv(img[0].colour);
		glTexCoord2f(img[0].tex[0], img[0].tex[1]);

		GLC_Begin(GL_TRIANGLE_STRIP);
		for (j = 0; j < polygonData.polygonVerts[i]; j++) {
			GLC_Vertex2fv(img[j].pos);
		}
		GLC_End();
	}
}

static void GLC_HudDrawPolygonsVertexArray(r_program_id program_id, texture_ref texture, int start, int end)
{
	extern cvar_t gl_vbo_clientmemory;
	uintptr_t offset = gl_vbo_clientmemory.integer ? 0 : buffers.BufferOffset(r_buffer_hud_image_vertex_data) / sizeof(imageData.images[0]);
	int i;

	R_ProgramUse(program_id);
	R_ApplyRenderingState(program_id == r_program_none ? r_state_hud_images_glc_non_glsl : r_state_hud_images_glc);
	renderer.TextureUnitBind(0, texture);

	for (i = start; i <= end; ++i) {
		GL_DrawArrays(GL_TRIANGLE_STRIP, offset + polygonData.polygonImageIndexes[i], polygonData.polygonVerts[i]);
	}
}

void GLC_HudDrawPolygons(texture_ref texture, int start, int end)
{
	extern cvar_t gl_program_hud;

	if (buffers.supported && gl_program_hud.integer && GLC_ProgramHudImagesCompile()) {
		GLC_HudDrawPolygonsVertexArray(r_program_hud_images_glc, texture, start, end);
	}
	else if (R_VAOBound()) {
		GLC_HudDrawPolygonsVertexArray(r_program_none, texture, start, end);
	}
	else {
		GLC_HudDrawPolygonsImmediate(texture, start, end);
	}
}

static void GLC_SetCoordinates(glm_image_t* targ, float x1, float y1, float x2, float y2, float s, float s_width, float t, float t_height, qbool nearest)
{
	float v1[4] = { x1, y1, 0, 1 };
	float v2[4] = { x2, y2, 0, 1 };

	R_MultiplyVector(cachedMatrix, v1, v1);
	R_MultiplyVector(cachedMatrix, v2, v2);

	// TL TL BR BR
	targ[0].pos[0] = v1[0]; targ[0].tex[0] = s;
	targ[1].pos[0] = v1[0]; targ[1].tex[0] = s;
	targ[2].pos[0] = v2[0]; targ[2].tex[0] = s + s_width;
	targ[3].pos[0] = v2[0]; targ[3].tex[0] = s + s_width;
	// TL BR TL BR
	targ[0].pos[1] = v1[1]; targ[0].tex[1] = t;
	targ[1].pos[1] = v2[1]; targ[1].tex[1] = t + t_height;
	targ[2].pos[1] = v1[1]; targ[2].tex[1] = t;
	targ[3].pos[1] = v2[1]; targ[3].tex[1] = t + t_height;

	targ[0].tex[3] = targ[1].tex[3] = targ[2].tex[3] = targ[3].tex[3] = nearest ? 0.0f : 1.0f;
}

void GLC_DrawRectangle(float x, float y, float width, float height, byte* color)
{
	texture_ref solid_texture;
	float s, t;
	float alpha;
	glm_image_t* img = &imageData.images[imageData.imageCount * 4];

	if (imageData.imageCount >= MAX_MULTI_IMAGE_BATCH) {
		return;
	}

	Atlas_SolidTextureCoordinates(&solid_texture, &s, &t);
	if (!R_LogCustomImageTypeWithTexture(imagetype_image, imageData.imageCount, solid_texture)) {
		return;
	}

	alpha = (color[3] * overall_alpha / 255.0f);

	img[0].colour[0] = img[1].colour[0] = img[2].colour[0] = img[3].colour[0] = color[0] * alpha;
	img[0].colour[1] = img[1].colour[1] = img[2].colour[1] = img[3].colour[1] = color[1] * alpha;
	img[0].colour[2] = img[1].colour[2] = img[2].colour[2] = img[3].colour[2] = color[2] * alpha;
	img[0].colour[3] = img[1].colour[3] = img[2].colour[3] = img[3].colour[3] = color[3] * overall_alpha;
	GLC_SetCoordinates(img, x, y, x + width, y + height, s, 0, t, 0, false);

	++imageData.imageCount;
}

void GLC_DrawImage(float x, float y, float width, float height, float tex_s, float tex_t, float tex_width, float tex_height, byte* color, int flags)
{
	int imageIndex = imageData.imageCount * 4;
	glm_image_t* img = &imageData.images[imageData.imageCount * 4];
	float alpha = (color[3] * overall_alpha / 255.0f);

	img[0].colour[0] = img[1].colour[0] = img[2].colour[0] = img[3].colour[0] = color[0] * alpha;
	img[0].colour[1] = img[1].colour[1] = img[2].colour[1] = img[3].colour[1] = color[1] * alpha;
	img[0].colour[2] = img[1].colour[2] = img[2].colour[2] = img[3].colour[2] = color[2] * alpha;
	img[0].colour[3] = img[1].colour[3] = img[2].colour[3] = img[3].colour[3] = color[3] * overall_alpha;
	GLC_SetCoordinates(&imageData.images[imageIndex], x, y, x + width, y + height, tex_s, tex_width, tex_t, tex_height, flags & IMAGEPROG_FLAGS_NEAREST);

	imageData.images[imageData.imageCount].flags = flags;
	++imageData.imageCount;
}

void GLC_AdjustImages(int first, int last, float x_offset)
{
	int i;

	for (i = first; i < last; ++i) {
		imageData.images[i * 4 + 0].pos[0] += x_offset;
		imageData.images[i * 4 + 1].pos[0] += x_offset;
		imageData.images[i * 4 + 2].pos[0] += x_offset;
		imageData.images[i * 4 + 3].pos[0] += x_offset;
	}
}

static void GLC_CreateImageVAO(void)
{
	extern cvar_t gl_vbo_clientmemory;

	R_TraceEnterFunctionRegion;
	R_TraceAPI("clientmemory: %s", gl_vbo_clientmemory.integer ? "true" : "false");
	if (gl_vbo_clientmemory.integer) {
		R_GenVertexArray(vao_hud_images);
		GLC_VAOSetIndexBuffer(vao_hud_images, r_buffer_hud_image_index_data);
		GLC_VAOEnableVertexPointer(vao_hud_images, 2, GL_FLOAT, sizeof(glm_image_t), (GLvoid*)&imageData.images[0].pos);
		GLC_VAOEnableTextureCoordPointer(vao_hud_images, 0, 4, GL_FLOAT, sizeof(glm_image_t), (GLvoid*)&imageData.images[0].tex);
		GLC_VAOEnableColorPointer(vao_hud_images, 4, GL_UNSIGNED_BYTE, sizeof(glm_image_t), (GLvoid*)&imageData.images[0].colour);
		R_BindVertexArray(vao_none);

		// A copy of the above, but only 2 texture coordinates sent
		R_GenVertexArray(vao_hud_images_non_glsl);
		GLC_VAOSetIndexBuffer(vao_hud_images_non_glsl, r_buffer_hud_image_index_data);
		GLC_VAOEnableVertexPointer(vao_hud_images_non_glsl, 2, GL_FLOAT, sizeof(glm_image_t), (GLvoid*)&imageData.images[0].pos);
		GLC_VAOEnableTextureCoordPointer(vao_hud_images_non_glsl, 0, 2, GL_FLOAT, sizeof(glm_image_t), (GLvoid*)&imageData.images[0].tex);
		GLC_VAOEnableColorPointer(vao_hud_images_non_glsl, 4, GL_UNSIGNED_BYTE, sizeof(glm_image_t), (GLvoid*)&imageData.images[0].colour);
		R_BindVertexArray(vao_none);
	}
	else {
		R_GenVertexArray(vao_hud_images);
		GLC_VAOSetIndexBuffer(vao_hud_images, r_buffer_hud_image_index_data);
		GLC_VAOSetVertexBuffer(vao_hud_images, r_buffer_hud_image_vertex_data);
		GLC_VAOEnableVertexPointer(vao_hud_images, 2, GL_FLOAT, sizeof(glm_image_t), VBO_FIELDOFFSET(glm_image_t, pos));
		GLC_VAOEnableTextureCoordPointer(vao_hud_images, 0, 4, GL_FLOAT, sizeof(glm_image_t), VBO_FIELDOFFSET(glm_image_t, tex));
		GLC_VAOEnableColorPointer(vao_hud_images, 4, GL_UNSIGNED_BYTE, sizeof(glm_image_t), VBO_FIELDOFFSET(glm_image_t, colour));
		R_BindVertexArray(vao_none);

		// A copy of the above, but only 2 texture coordinates sent
		R_GenVertexArray(vao_hud_images_non_glsl);
		GLC_VAOSetIndexBuffer(vao_hud_images_non_glsl, r_buffer_hud_image_index_data);
		GLC_VAOSetVertexBuffer(vao_hud_images_non_glsl, r_buffer_hud_image_vertex_data);
		GLC_VAOEnableVertexPointer(vao_hud_images_non_glsl, 2, GL_FLOAT, sizeof(glm_image_t), VBO_FIELDOFFSET(glm_image_t, pos));
		GLC_VAOEnableTextureCoordPointer(vao_hud_images_non_glsl, 0, 2, GL_FLOAT, sizeof(glm_image_t), VBO_FIELDOFFSET(glm_image_t, tex));
		GLC_VAOEnableColorPointer(vao_hud_images_non_glsl, 4, GL_UNSIGNED_BYTE, sizeof(glm_image_t), VBO_FIELDOFFSET(glm_image_t, colour));
		R_BindVertexArray(vao_none);
	}
	R_TraceLeaveFunctionRegion;
}

void GLC_HudPrepareImages(void)
{
	extern cvar_t gl_vbo_clientmemory;

	R_TextureReferenceInvalidate(glc_last_texture_used);

	if (buffers.supported && !gl_vbo_clientmemory.integer) {
		if (!R_BufferReferenceIsValid(r_buffer_hud_image_vertex_data)) {
			buffers.Create(r_buffer_hud_image_vertex_data, buffertype_vertex, "image-vbo", sizeof(imageData.images), imageData.images, bufferusage_once_per_frame);
		}
		else {
			buffers.Update(r_buffer_hud_image_vertex_data, sizeof(imageData.images[0]) * imageData.imageCount * 4, imageData.images);
		}
	}

	if (buffers.supported && !R_BufferReferenceIsValid(r_buffer_hud_image_index_data)) {
		R_BindVertexArray(vao_none);
		if (!R_BufferReferenceIsValid(r_buffer_hud_image_index_data)) {
			unsigned int data[MAX_MULTI_IMAGE_BATCH * 6 * 3];
			int pos, i;

			for (i = 0, pos = 0; i < MAX_MULTI_IMAGE_BATCH * 3; ++i) {
				if (i && !GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
					data[pos++] = i * 4;
				}
				data[pos++] = i * 4;
				data[pos++] = i * 4 + 1;
				data[pos++] = i * 4 + 2;
				data[pos++] = i * 4 + 3;
				if (GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
					data[pos++] = ~(unsigned int)0;
				}
				else {
					data[pos++] = i * 4 + 3;
				}
			}
			buffers.Create(r_buffer_hud_image_index_data, buffertype_index, "hudimage-elements", pos * sizeof(unsigned int), data, bufferusage_reuse_many_frames);
			extraIndexesPerImage = GL_Supported(R_SUPPORT_PRIMITIVERESTART) ? 1 : 2;
		}
	}

	R_TraceAPI("%s pre-check: %s, %s", __func__, (buffers.supported ? "buffers-supported" : "no-buffers"), R_VertexArrayCreated(vao_hud_images) ? "vao-created" : "vao-not-created");
	if (buffers.supported && !R_VertexArrayCreated(vao_hud_images)) {
		GLC_CreateImageVAO();
	}
}

static void GLC_HudDrawImagesVertexArray(texture_ref ref, int start, int end)
{
	extern cvar_t gl_vbo_clientmemory;
	uintptr_t offset = gl_vbo_clientmemory.integer ? 0 : buffers.BufferOffset(r_buffer_hud_image_vertex_data) / (sizeof(imageData.images[0]) * 4);
	qbool nearest = (imageData.images[start].flags & IMAGEPROG_FLAGS_NEAREST);
	int i;

	R_ProgramUse(r_program_none);
	renderer.TextureSetFiltering(ref, nearest ? texture_minification_nearest : texture_minification_linear, nearest ? texture_magnification_nearest : texture_magnification_linear);
	renderer.TextureUnitBind(0, ref);
	for (i = start; i < end; ++i) {
		if (R_TextureReferenceIsValid(ref) && nearest != (imageData.images[i].flags & IMAGEPROG_FLAGS_NEAREST)) {
			if (i > start) {
				GL_DrawElements(GL_TRIANGLE_STRIP, (i - start) * (4 + extraIndexesPerImage), GL_UNSIGNED_INT, (void*)((offset + start) * (4 + extraIndexesPerImage) * sizeof(GLuint)));
			}

			nearest = (imageData.images[i].flags & IMAGEPROG_FLAGS_NEAREST);
			start = i;

			renderer.TextureSetFiltering(ref, nearest ? texture_minification_nearest : texture_minification_linear, nearest ? texture_magnification_nearest : texture_magnification_linear);
		}
	}

	GL_DrawElements(GL_TRIANGLE_STRIP, (end - start + 1) * (4 + extraIndexesPerImage), GL_UNSIGNED_INT, (void*)((offset + start) * (4 + extraIndexesPerImage) * sizeof(GLuint)));
}

#define GLC_PROGRAMFLAGS_SMOOTHCROSSHAIR     1
#define GLC_PROGRAMFLAGS_SMOOTHIMAGES        2
#define GLC_PROGRAMFLAGS_SMOOTHTEXT          4
#define GLC_PROGRAMFLAGS_ALPHAHACK           8
#define GLC_PROGRAMFLAGS_SMOOTHEVERYTHING    (GLC_PROGRAMFLAGS_SMOOTHCROSSHAIR | GLC_PROGRAMFLAGS_SMOOTHIMAGES | GLC_PROGRAMFLAGS_SMOOTHTEXT)

qbool GLC_ProgramHudImagesCompile(void)
{
	extern cvar_t r_smoothtext, r_smoothcrosshair, r_smoothimages, r_smoothalphahack;
	int flags =
		(r_smoothtext.integer ? GLC_PROGRAMFLAGS_SMOOTHTEXT : 0) |
		(r_smoothcrosshair.integer ? GLC_PROGRAMFLAGS_SMOOTHCROSSHAIR : 0) |
		(r_smoothimages.integer ? GLC_PROGRAMFLAGS_SMOOTHIMAGES : 0) |
		(r_smoothalphahack.integer ? GLC_PROGRAMFLAGS_ALPHAHACK : 0);
	
	if (R_ProgramRecompileNeeded(r_program_hud_images_glc, flags)) {
		static char included_definitions[512];
		int smooth_flags = (flags & GLC_PROGRAMFLAGS_SMOOTHEVERYTHING);
		qbool mixed_sampling = GL_Supported(R_SUPPORT_TEXTURE_SAMPLERS) && smooth_flags != 0 && smooth_flags != GLC_PROGRAMFLAGS_SMOOTHEVERYTHING;

		memset(included_definitions, 0, sizeof(included_definitions));
		if (mixed_sampling) {
			strlcat(included_definitions, "#define MIXED_SAMPLING\n", sizeof(included_definitions));
		}
		if (flags & GLC_PROGRAMFLAGS_ALPHAHACK) {
			strlcat(included_definitions, "#define PREMULT_ALPHA_HACK\n", sizeof(included_definitions));
		}

		R_ProgramCompileWithInclude(r_program_hud_images_glc, included_definitions);
		R_ProgramUniform1i(r_program_uniform_hud_images_glc_primarySampler, 0);
		if (mixed_sampling) {
			R_ProgramUniform1i(r_program_uniform_hud_images_glc_secondarySampler, 1);
		}
		R_ProgramSetCustomOptions(r_program_hud_images_glc, flags);
	}

	return R_ProgramReady(r_program_hud_images_glc);
}

static void GLC_HudDrawImagesProgram(r_program_id program_id, texture_ref ref, int start, int end)
{
	extern cvar_t gl_vbo_clientmemory;
	uintptr_t offset = gl_vbo_clientmemory.integer ? 0 : buffers.BufferOffset(r_buffer_hud_image_vertex_data) / (sizeof(imageData.images[0]) * 4);
	int i;

	R_ProgramUse(program_id);
	if (program_id != r_program_none && GL_Supported(R_SUPPORT_TEXTURE_SAMPLERS)) {
		qbool everything_nearest = (R_ProgramCustomOptions(r_program_hud_images_glc) & GLC_PROGRAMFLAGS_SMOOTHEVERYTHING) == 0;
		qbool everything_linear = (R_ProgramCustomOptions(r_program_hud_images_glc) & GLC_PROGRAMFLAGS_SMOOTHEVERYTHING) == GLC_PROGRAMFLAGS_SMOOTHEVERYTHING;

		renderer.TextureUnitBind(0, ref);
		if (everything_nearest) {
			// Everything is GL_NEAREST, no smoothing
			GL_SamplerSetNearest(0);
		}
		else if (!everything_linear) {
			// Mixed, second texture unit for GL_NEAREST
			renderer.TextureUnitBind(1, ref);
			GL_SamplerSetNearest(1);
		}

		GL_DrawElements(GL_TRIANGLE_STRIP, (end - start + 1) * (4 + extraIndexesPerImage), GL_UNSIGNED_INT, (void*)((offset + start) * (4 + extraIndexesPerImage) * sizeof(GLuint)));

		if (everything_nearest) {
			GL_SamplerClear(0);
		}
		else if (!everything_linear) {
			GL_SamplerClear(1);
		}
	}
	else {
		qbool nearest = (imageData.images[start].flags & IMAGEPROG_FLAGS_NEAREST);
		renderer.TextureSetFiltering(ref, nearest ? texture_minification_nearest : texture_minification_linear, nearest ? texture_magnification_nearest : texture_magnification_linear);
		renderer.TextureUnitBind(0, ref);
		for (i = start; i < end; ++i) {
			if (R_TextureReferenceIsValid(ref) && nearest != (imageData.images[i].flags & IMAGEPROG_FLAGS_NEAREST)) {
				GL_DrawElements(GL_TRIANGLE_STRIP, (i - start) * (4 + extraIndexesPerImage), GL_UNSIGNED_INT, (void*)((offset + start) * (4 + extraIndexesPerImage) * sizeof(GLuint)));

				nearest = (imageData.images[i].flags & IMAGEPROG_FLAGS_NEAREST);
				start = i;

				renderer.TextureSetFiltering(ref, nearest ? texture_minification_nearest : texture_minification_linear, nearest ? texture_magnification_nearest : texture_magnification_linear);
			}
		}

		GL_DrawElements(GL_TRIANGLE_STRIP, (end - start + 1) * (4 + extraIndexesPerImage), GL_UNSIGNED_INT, (void*)((offset + start) * (4 + extraIndexesPerImage) * sizeof(GLuint)));
	}
	R_ProgramUse(r_program_none);
}

static void GLC_HudDrawImages_Immediate(texture_ref ref, int start, int end)
{
	int i;
	byte current_color[4];
	qbool nearest = (imageData.images[start].flags & IMAGEPROG_FLAGS_NEAREST);

	renderer.TextureSetFiltering(ref, nearest ? texture_minification_nearest : texture_minification_linear, nearest ? texture_magnification_nearest : texture_magnification_linear);
	renderer.TextureUnitBind(0, ref);
	R_CustomColor4ubv(imageData.images[start * 4].colour);
	memcpy(current_color, imageData.images[start * 4].colour, sizeof(current_color));

	R_ProgramUse(r_program_none);
	GLC_Begin(GL_QUADS);
	for (i = start * 4; i <= 4 * end + 3; i += 4) {
		glm_image_t* next = &imageData.images[i];

		R_CustomColor4ubv(next->colour);

		if (R_TextureReferenceIsValid(ref) && nearest != (imageData.images[i / 4].flags & IMAGEPROG_FLAGS_NEAREST)) {
			GLC_End();

			nearest = (imageData.images[i / 4].flags & IMAGEPROG_FLAGS_NEAREST);
			renderer.TextureSetFiltering(ref, nearest ? texture_minification_nearest : texture_minification_linear, nearest ? texture_magnification_nearest : texture_magnification_linear);

			GLC_Begin(GL_QUADS);
		}

		glTexCoord2f(next[0].tex[0], next[0].tex[1]);
		GLC_Vertex2f(next[0].pos[0], next[0].pos[1]);
		glTexCoord2f(next[2].tex[0], next[2].tex[1]);
		GLC_Vertex2f(next[2].pos[0], next[2].pos[1]);
		glTexCoord2f(next[3].tex[0], next[3].tex[1]);
		GLC_Vertex2f(next[3].pos[0], next[3].pos[1]);
		glTexCoord2f(next[1].tex[0], next[1].tex[1]);
		GLC_Vertex2f(next[1].pos[0], next[1].pos[1]);
	}
	GLC_End();
}

void GLC_HudDrawImages(texture_ref ref, int start, int end)
{
	extern cvar_t gl_program_hud;

	R_TraceEnterFunctionRegion;
	if (R_TextureReferenceIsValid(glc_last_texture_used) && !R_TextureReferenceEqual(glc_last_texture_used, ref)) {
		renderer.TextureSetFiltering(glc_last_texture_used, texture_minification_linear, texture_magnification_linear);
	}
	glc_last_texture_used = ref;

	if (buffers.supported && gl_program_hud.integer && GLC_ProgramHudImagesCompile()) {
		GLC_StateBeginImageDraw(imageData.images[start].flags & IMAGEPROG_FLAGS_TEXT);
		GLC_HudDrawImagesProgram(r_program_hud_images_glc, ref, start, end);
	}
	else if (R_VAOBound()) {
		GLC_StateBeginImageDrawNonGLSL(imageData.images[start].flags & IMAGEPROG_FLAGS_TEXT);
		GLC_HudDrawImagesVertexArray(ref, start, end);
	}
	else {
		GLC_StateBeginImageDrawNonGLSL(imageData.images[start].flags & IMAGEPROG_FLAGS_TEXT);
		GLC_HudDrawImages_Immediate(ref, start, end);
	}
	R_TraceLeaveFunctionRegion;
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_framebuffer.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// GLM_FrameBuffer.c
// Framebuffer support in OpenGL core

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

// For the moment, also contains general framebuffer code as immediate-mode isn't supported

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "glc_local.h"
#include "gl_framebuffer.h"
#include "tr_types.h"
#include "r_buffers.h"
#include "r_state.h"
#include "r_program.h"
#include "r_renderer.h"
#include "r_matrix.h"
#include "r_texture.h"

#define POST_PROCESS_PALETTE    1
#define POST_PROCESS_3DONLY     2
#define POST_PROCESS_FXAA       4

static texture_ref non_framebuffer_screen_texture;

qbool GLC_CompilePostProcessProgram(void)
{
	extern cvar_t vid_software_palette, vid_framebuffer;
	int fxaa_preset = GL_FramebufferFxaaPreset();
	int post_process_flags =
		(vid_software_palette.integer ? POST_PROCESS_PALETTE : 0) |
		(vid_framebuffer.integer == USE_FRAMEBUFFER_3DONLY ? POST_PROCESS_3DONLY : 0) |
		(fxaa_preset > 0 ? POST_PROCESS_FXAA : 0) | (fxaa_preset << 4); // mix in preset to detect change

	if (R_ProgramRecompileNeeded(r_program_post_process_glc, post_process_flags)) {
		static char included_definitions[131072];

		memset(included_definitions, 0, sizeof(included_definitions));
		if (post_process_flags & POST_PROCESS_PALETTE) {
			strlcat(included_definitions, "#define EZ_POSTPROCESS_PALETTE\n", sizeof(included_definitions));
		}
		if (post_process_flags & POST_PROCESS_3DONLY) {
			strlcat(included_definitions, "#define EZ_POSTPROCESS_OVERLAY\n", sizeof(included_definitions));
		}
		if (post_process_flags & POST_PROCESS_FXAA) {
			qbool supported = true;
			if (glConfig.coreProfile) {
				// gpu_shader4 and gpu_shader5 functionality is core in GL 3.3+
			}
			else {
				if (!GL_VersionAtLeast(3, 0) || !SDL_GL_ExtensionSupported("GL_EXT_gpu_shader4"))
				{
					Com_Printf("WARNING: Missing GL_EXT_gpu_shader4, FXAA not available.");
					supported = false;
				}

				if (!GL_VersionAtLeast(4, 2) || !SDL_GL_ExtensionSupported("GL_ARB_gpu_shader5"))
				{
					Com_Printf("WARNING: Missing GL_ARB_gpu_shader5, FXAA not available.");
					supported = false;
				}
			}
			if (supported)
			{
				extern const unsigned char fxaa_h_glsl[];
				char buffer[64] = {0};
				const char *settings;
				if (glConfig.coreProfile) {
					settings =
						"#define EZ_POSTPROCESS_FXAA\n"
						"#define FXAA_PC 1\n"
						"#define FXAA_GLSL_130 1\n"
						"#define FXAA_GREEN_AS_LUMA 1\n";
				}
				else {
					settings =
						"#extension GL_EXT_gpu_shader4 : enable\n"
#ifndef __APPLE__
						"#extension GL_ARB_gpu_shader5 : enable\n"
#endif
						"#define EZ_POSTPROCESS_FXAA\n"
						"#define FXAA_PC 1\n"
						"#define FXAA_GLSL_120 1\n"
						"#define FXAA_GREEN_AS_LUMA 1\n";
				}
				snprintf(buffer, sizeof(buffer), "#define FXAA_QUALITY__PRESET %d\n", fxaa_preset);
				strlcat(included_definitions, settings, sizeof(included_definitions));
				strlcat(included_definitions, buffer, sizeof(included_definitions));
				strlcat(included_definitions, (const char *)fxaa_h_glsl, sizeof(included_definitions));
			}
		}

		// Initialise program for drawing image
		R_ProgramCompileWithInclude(r_program_post_process_glc, included_definitions);

		R_ProgramSetCustomOptions(r_program_post_process_glc, post_process_flags);
	}

	return R_ProgramReady(r_program_post_process_glc);
}

void GLC_RenderFramebuffers(void)
{
	qbool flip2d = GL_FramebufferEnabled2D();
	qbool flip3d = GL_FramebufferEnabled3D();

	if (GLC_CompilePostProcessProgram()) {
		extern cvar_t gl_hwblend;

		float blend_alpha = (!vid_hwgamma_enabled || !gl_hwblend.value || cl.teamfortress) ? 0 : v_blend[3];
		float blend_values[4] = {
			v_blend[0] * blend_alpha,
			v_blend[1] * blend_alpha,
			v_blend[2] * blend_alpha,
			1 - blend_alpha
		};

		R_ProgramUse(r_program_post_process_glc);
		R_ProgramUniform1f(r_program_uniform_post_process_glc_gamma, v_gamma.value);
		R_ProgramUniform4fv(r_program_uniform_post_process_glc_v_blend, blend_values);
		R_ProgramUniform1f(r_program_uniform_post_process_glc_contrast, bound(1, v_contrast.value, 3));
		R_ProgramUniform1f(r_program_uniform_post_process_glc_r_inv_width, 1.0f / (float)VID_ScaledWidth3D());
		R_ProgramUniform1f(r_program_uniform_post_process_glc_r_inv_height, 1.0f / (float)VID_ScaledHeight3D());
		R_ApplyRenderingState(r_state_default_2d);

		if (flip2d && flip3d) {
			renderer.TextureUnitBind(0, GL_FramebufferTextureReference(framebuffer_std, fbtex_standard));
			renderer.TextureUnitBind(1, GL_FramebufferTextureReference(framebuffer_hud, fbtex_standard));

			R_ProgramUniform1i(r_program_uniform_post_process_glc_base, 0);
			R_ProgramUniform1i(r_program_uniform_post_process_glc_overlay, 1);
		}
		else if (flip3d) {
			renderer.TextureUnitBind(0, GL_FramebufferTextureReference(framebuffer_std, fbtex_standard));

			R_ProgramUniform1i(r_program_uniform_post_process_glc_base, 0);
		}
		else if (flip2d) {
			renderer.TextureUnitBind(0, GL_FramebufferTextureReference(framebuffer_hud, fbtex_standard));

			R_ProgramUniform1i(r_program_uniform_post_process_glc_overlay, 0);
		}
		else {
			// Create screen texture if required
			if (!R_TextureReferenceIsValid(non_framebuffer_screen_texture) || R_TextureWidth(non_framebuffer_screen_texture) != glwidth || R_TextureHeight(non_framebuffer_screen_texture) != glheight) {
				if (R_TextureReferenceIsValid(non_framebuffer_screen_texture)) {
					renderer.TextureDelete(non_framebuffer_screen_texture);
				}
				non_framebuffer_screen_texture = R_LoadTexture("glc:postprocess", glwidth, glheight, NULL, TEX_NOCOMPRESS | TEX_NOSCALE | TEX_NO_TEXTUREMODE, 4);
				if (R_TextureReferenceIsValid(non_framebuffer_screen_texture))
					renderer.TextureSetFiltering(non_framebuffer_screen_texture, texture_minification_nearest, texture_magnification_nearest);
			}

			if (!R_TextureReferenceIsValid(non_framebuffer_screen_texture)) {
				return;
			}

			// Copy from screen to texture
			renderer.TextureUnitBind(0, non_framebuffer_screen_texture);
			GL_BuiltinProcedure(glCopyTexSubImage2D, "mode=GL_TEXTURE_2D(%u), level=%d, xoffset=%d, yoffset=%d, x=%d, y=%d, width=%d, height=%d", GL_TEXTURE_2D, 0, 0, 0, 0, 0, glwidth, glheight);
		}

		R_IdentityModelView();
		R_IdentityProjectionView();

		GLC_Begin(GL_TRIANGLE_STRIP);
		// Top left corner.
		glTexCoord2f(0, 0);
		GLC_Vertex2f(-1, -1);

		// Upper right corner.
		glTexCoord2f(0, 1);
		GLC_Vertex2f(-1, 1);

		// Bottom right corner.
		glTexCoord2f(1, 0);
		GLC_Vertex2f(1, -1);

		// Bottom left corner.
		glTexCoord2f(1, 1);
		GLC_Vertex2f(1, 1);
		GLC_End();

		R_ProgramUse(r_program_none);
	}
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_lightmaps.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_lightmaps_internal.h"
#include "r_texture.h"
#include "gl_texture_internal.h"
#include "r_renderer.h"
#include "tr_types.h"
#include "r_lightmaps.h"

// FIXME: Check required depth against GL_MAX_ARRAY_TEXTURE_LAYERS
static texture_ref lightmap_texture_array;
static unsigned int lightmap_depth = 0;

static void GLC_CreateLightmapTextureArray(void);
static void GLC_CreateLightmapTexturesIndividual(void);

void GLC_UploadLightmap(int textureUnit, int lightmapnum);

qbool GLC_IsLightmapBound(int textureUnit, int lightmap_num)
{
	if (R_TextureReferenceIsValid(lightmap_texture_array)) {
		return renderer.TextureIsUnitBound(textureUnit, lightmap_texture_array);
	}
	else {
		return renderer.TextureIsUnitBound(textureUnit, lightmaps[lightmap_num].gl_texref);
	}
}

qbool GLC_SetTextureLightmap(int textureUnit, int lightmap_num)
{
	//update lightmap if it has been modified by dynamic lights
	R_UploadLightMap(textureUnit, lightmap_num);
	if (R_TextureReferenceIsValid(lightmap_texture_array)) {
		return renderer.TextureUnitBind(textureUnit, lightmap_texture_array);
	}
	else {
		return renderer.TextureUnitBind(textureUnit, lightmaps[lightmap_num].gl_texref);
	}
}

void GLC_LightmapArrayToggle(qbool use_array)
{
	qbool array_in_use = R_TextureReferenceIsValid(lightmap_texture_array);
	use_array &= (glConfig.supported_features & R_SUPPORT_TEXTURE_ARRAYS) != 0;

	if (array_in_use == use_array) {
		return;
	}

	if (use_array && !array_in_use) {
		GLC_CreateLightmapTextureArray();
	}
	else if (array_in_use && !use_array) {
		GLC_CreateLightmapTexturesIndividual();
		R_DeleteTextureArray(&lightmap_texture_array);
		lightmap_depth = 0;
	}

	// Force all lightmaps to be updated
	R_ForceReloadLightMaps();
}

void GLC_InvalidateLightmapTextures(void)
{
	R_TextureReferenceInvalidate(lightmap_texture_array);
	lightmap_depth = 0;
}

void GLC_ClearLightmapPolys(void)
{
	int i;

	for (i = 0; i < lightmap_array_size; ++i) {
		lightmaps[i].poly_chain = NULL;
	}
}

texture_ref GLC_LightmapTexture(int index)
{
	if (R_TextureReferenceIsValid(lightmap_texture_array)) {
		return lightmap_texture_array;
	}
	else {
		if (index < 0 || index >= lightmap_array_size) {
			return lightmaps[0].gl_texref;
		}
		return lightmaps[index].gl_texref;
	}
}

static void GLC_CreateLightmapTextureArray(void)
{
	GLenum error;

	if (R_TextureReferenceIsValid(lightmap_texture_array) && lightmap_depth >= lightmap_array_size) {
		// Nothing to do
		return;
	}
	if (R_TextureReferenceIsValid(lightmap_texture_array)) {
		R_DeleteTextureArray(&lightmap_texture_array);
	}
	GL_ConsumeErrors();
	GL_CreateTexturesWithIdentifier(texture_type_2d_array, 1, &lightmap_texture_array, "lightmap_texture_array");
	error = GL_TexStorage3D(GL_TEXTURE0, lightmap_texture_array, 1, GL_RGBA8, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, lightmap_array_size, true);
	if (error != GL_NO_ERROR) {
		Sys_Error("Unable to create lightmap texture array: error %u\n", error);
		return;
	}
	R_SetTextureArraySize(lightmap_texture_array, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, lightmap_array_size, 4);
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nopengl-texture,alloc,%u,%d,%d,%d,%s\n", lightmap_texture_array.index, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT * lightmap_array_size * 4, "lightmap_texture_array");
#endif
	renderer.TextureSetFiltering(lightmap_texture_array, texture_minification_linear, texture_magnification_linear);
	renderer.TextureWrapModeClamp(lightmap_texture_array);
	lightmap_depth = lightmap_array_size;
}

static void GLC_CreateLightmapTexturesIndividual(void)
{
	int i;
	char name[64];

	for (i = 0; i < lightmap_array_size; ++i) {
		if (!R_TextureReferenceIsValid(lightmaps[i].gl_texref)) {
			snprintf(name, sizeof(name), "lightmap-%03d", i);

			renderer.TextureCreate2D(&lightmaps[i].gl_texref, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, name, true);
		}
	}
}

void GLC_CreateLightmapTextures(void)
{
	extern cvar_t gl_program_world;
	qbool supported = (glConfig.supported_features & R_SUPPORT_TEXTURE_ARRAYS);
	qbool requested = gl_program_world.integer;

	if (supported && requested) {
		GLC_CreateLightmapTextureArray();
	}
	else {
		GLC_CreateLightmapTexturesIndividual();
	}
}

void GLC_LightmapUpdate(int index)
{
	if (index >= 0 && index < lightmap_array_size) {
		if (lightmaps[index].modified) {
			GLC_UploadLightmap(0, index);
		}
	}
}

void GLC_AddToLightmapChain(msurface_t* s)
{
	s->polys->chain = lightmaps[s->lightmaptexturenum].poly_chain;
	lightmaps[s->lightmaptexturenum].poly_chain = s->polys;
}

glpoly_t* GLC_LightmapChain(int i)
{
	if (i < 0 || i >= lightmap_array_size) {
		return NULL;
	}
	return lightmaps[i].poly_chain;
}

int GLC_LightmapCount(void)
{
	return lightmap_array_size;
}

void GLC_BuildLightmap(int i)
{
	GLenum format = GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS) ? GL_BGRA : GL_RGBA;
	GLenum type = GL_Supported(R_SUPPORT_INT8888R_LIGHTMAPS) ? GL_UNSIGNED_INT_8_8_8_8_REV : GL_UNSIGNED_BYTE;

	if (R_TextureReferenceIsValid(lightmap_texture_array)) {
		GL_TexSubImage3D(0, lightmap_texture_array, 0, 0, 0, i, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, 1, format, type, lightmaps[i].rawdata);
	}
	else {
		GL_TexSubImage2D(
			GL_TEXTURE0, lightmaps[i].gl_texref, 0, 0, 0,
			LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, format, type,
			lightmaps[i].rawdata
		);
	}
}

void GLC_UploadLightmap(int textureUnit, int lightmapnum)
{
	const lightmap_data_t* lm = &lightmaps[lightmapnum];
	const void* data_source = lm->rawdata + (lm->change_area.t) * LIGHTMAP_WIDTH * 4;
	GLenum format = GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS) ? GL_BGRA : GL_RGBA;
	GLenum type = GL_Supported(R_SUPPORT_INT8888R_LIGHTMAPS) ? GL_UNSIGNED_INT_8_8_8_8_REV : GL_UNSIGNED_BYTE;

	if (R_TextureReferenceIsValid(lightmap_texture_array)) {
		GL_TexSubImage3D(textureUnit, lightmap_texture_array, 0, 0, lm->change_area.t, lightmapnum, LIGHTMAP_WIDTH, lm->change_area.h, 1, format, type, data_source);
	}
	else {
		GL_TexSubImage2D(GL_TEXTURE0 + textureUnit, lm->gl_texref, 0, 0, lm->change_area.t, LIGHTMAP_WIDTH, lm->change_area.h, format, type, data_source);
	}
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_local.h
================================================

#ifndef EZQUAKE_GLC_LOCAL_HEADER
#define EZQUAKE_GLC_LOCAL_HEADER

void GLC_FreeAliasPoseBuffer(void);
void GLC_Shutdown(r_shutdown_mode_t mode);

void GLC_PreRenderView(void);
void GLC_SetupGL(void);
void GLC_StateBeginAliasOutlineFrame(qbool weaponmodel);
void GLC_StateBeginBrightenScreen(void);
void GLC_StateBeginFastSky(qbool world);
void GLC_StateBeginSkyZBufferPass(void);
void GLC_StateBeginSingleTextureSkyDome(void);
void GLC_StateBeginSingleTextureSkyDomeCloudPass(void);
void GLC_StateBeginMultiTextureSkyDome(qbool use_program);
void GLC_StateBeginMultiTextureSkyChain(void);
void GLC_StateBeginSingleTextureSkyPass(void);
void GLC_StateBeginSingleTextureCloudPass(void);
void GLC_StateBeginRenderFullbrights(void);
void GLC_StateBeginRenderLumas(void);
void GLC_StateBeginEmitDetailPolys(void);
void GLC_StateBeginDrawMapOutline(void);
void GLC_StateBeginDrawAliasFrame(texture_ref texture, texture_ref fb_texture, qbool mtex, qbool alpha_blend, struct custom_model_color_s* custom_model, qbool weapon_model);
void GLC_StateBeginDrawAliasFrameProgram(texture_ref texture, texture_ref fb_texture, int render_effects, struct custom_model_color_s* custom_model, float ent_alpha, qbool additive_pass);
void GLC_StateBeginDrawAliasZPass(qbool weapon_model);
void GLC_StateBeginAliasModelShadow(void);
void GLC_StateBeginFastTurbPoly(byte color[4]);
void GLC_StateBeginBlendLightmaps(qbool use_buffers);
void GLC_StateBeginCausticsPolys(void);
void GLC_StateBeginUnderwaterAliasModelCaustics(texture_ref base_texture, texture_ref caustics_texture);
void GLC_StateEndUnderwaterAliasModelCaustics(void);
void GLC_StateBeginBloomDraw(texture_ref texture);
void GLC_StateBeginImageDraw(qbool is_text);
void GLC_StateBeginImageDrawNonGLSL(qbool is_text);
void GLC_StateBeginDrawAlphaPieSliceRGB(float thickness);

void GLC_Begin(GLenum primitive);
void GLC_End(void);
void GLC_Vertex2f(GLfloat x, GLfloat y);
void GLC_Vertex2fv(const GLfloat* v);
void GLC_Vertex3f(GLfloat x, GLfloat y, GLfloat z);
void GLC_Vertex3fv(const GLfloat* v);

unsigned int GLC_DrawIndexedPoly(glpoly_t* p, unsigned int* modelIndexes, unsigned int modelIndexMaximum, unsigned int index_count);

#endif


================================================
FILE: src/glc_main.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "r_renderer.h"
#include "r_buffers.h"
#include "glc_vao.h"
#include "r_brushmodel.h"
#include "r_aliasmodel.h"
#include "tr_types.h"

cvar_t gl_program_sky          = { "gl_program_sky",           "1" };
cvar_t gl_program_turbsurfaces = { "gl_program_turbsurfaces",  "1" };
cvar_t gl_program_aliasmodels  = { "gl_program_aliasmodels",   "1", CVAR_LATCH_GFX };
cvar_t gl_program_world        = { "gl_program_world",         "1" };
cvar_t gl_program_sprites      = { "gl_program_sprites",       "1" };
cvar_t gl_program_hud          = { "gl_program_hud",           "1" };

static qbool glc_program_cvars_initialized = false;
static cvar_t* gl_program_cvars[] = {
	&gl_program_sky,
	&gl_program_turbsurfaces,
	&gl_program_aliasmodels,
	&gl_program_world,
	&gl_program_sprites,
	&gl_program_hud,
};

void GL_Init(void);
qbool GLC_InitialiseVAOHandling(void);
void GL_InitialiseBufferHandling(api_buffers_t* buffers);
void GL_InitialiseState(void);

static void GLC_NoOperation(void)
{
}

static void GLC_BindVertexArrayElementBuffer(r_vao_id vao, r_buffer_id ref)
{
}

#ifndef WITH_RENDERING_TRACE
static void GLC_TextureLabelSetNull(texture_ref texture, const char* name)
{
}
#endif

qbool GLC_False(void)
{
	return false;
}

static void GLC_ScreenDrawStart(void)
{
	GL_FramebufferScreenDrawStart();
}

static void GLC_PostProcessScreen(void)
{
	GL_FramebufferPostProcessScreen();
}

static void GLC_Begin2DRendering(void)
{
	GL_Framebuffer2DSwitch();
}

#define GLC_PrintGfxInfo                   GL_PrintGfxInfo
#define GLC_Viewport                       GL_Viewport
#define GLC_InvalidateViewport             GL_InvalidateViewport
#define GLC_RenderDynamicLightmaps         R_RenderDynamicLightmaps
#define GLC_LightmapFrameInit              GLC_NoOperation
#define GLC_LightmapShutdown               GLC_NoOperation
#define GLC_ClearRenderingSurface          GL_Clear
#define GLC_EnsureFinished                 GL_EnsureFinished
#define GLC_RenderView                     GLC_NoOperation
#define GLC_Screenshot                     GL_Screenshot
#define GLC_ScreenshotWidth                GL_ScreenshotWidth
#define GLC_ScreenshotHeight               GL_ScreenshotHeight
#define GLC_InitialiseVAOState             GL_InitialiseVAOState
#define GLC_DescriptiveString              GL_DescriptiveString
#define GLC_Draw3DSprites                  GLC_NoOperation
#define GLC_Prepare3DSprites               GLC_NoOperation
#define GLC_IsFramebufferEnabled3D         GL_FramebufferEnabled3D
#define GLC_TextureDelete                  GL_TextureDelete
#define GLC_TextureMipmapGenerate          GL_TextureMipmapGenerate
#define GLC_TextureWrapModeClamp           GL_TextureWrapModeClamp
#ifdef WITH_RENDERING_TRACE
#define GLC_TextureLabelSet                GL_TextureLabelSet
#else
#define GLC_TextureLabelSet                GLC_TextureLabelSetNull
#endif
#define GLC_TextureIsUnitBound             GL_IsTextureBound
#define GLC_TextureUnitBind                GL_EnsureTextureUnitBoundAndSelect
#define GLC_TextureGet                     GL_TextureGet
#define GLC_TextureCompressionSet          GL_TextureCompressionSet
#define GLC_TextureCreate2D                GL_TextureCreate2D
#define GLC_TextureUnitMultiBind           GL_TextureUnitMultiBind
#define GLC_TexturesCreate                 GL_TexturesCreate
#define GLC_TextureReplaceSubImageRGBA     GL_TextureReplaceSubImageRGBA
#define GLC_TextureSetAnisotropy           GL_TextureSetAnisotropy
#define GLC_TextureSetFiltering            GL_TextureSetFiltering
#define GLC_TextureLoadCubemapFace         GL_TextureLoadCubemapFace
#define GLC_CvarForceRecompile             GL_CvarForceRecompile
#define GLC_ProgramsInitialise             GL_ProgramsInitialise
#define GLC_ProgramsShutdown               GL_ProgramsShutdown
#define GLC_FramebufferCreate              GL_FramebufferCreate
#define GLC_PrepareAliasModel              GL_PrepareAliasModel

#define RENDERER_METHOD(returntype, name, ...) \
{ \
	extern returntype GLC_ ## name(__VA_ARGS__); \
	renderer.name = GLC_ ## name; \
}

void GLC_Initialise(void)
{
	int i;
	extern cvar_t vid_gl_core_profile;
#include "r_renderer_structure.h"

	if (!glc_program_cvars_initialized) {
		Cvar_SetCurrentGroup(CVAR_GROUP_OPENGL);
		for (i = 0; i < sizeof(gl_program_cvars) / sizeof(gl_program_cvars[0]); ++i) {
			if (!(gl_program_cvars[i]->flags & CVAR_LATCH)) {
				Cvar_Register(gl_program_cvars[i]);
			}
		}

		Cvar_ResetCurrentGroup();
		glc_program_cvars_initialized = true;
	}

	Cvar_SetCurrentGroup(CVAR_GROUP_OPENGL);
	for (i = 0; i < sizeof(gl_program_cvars) / sizeof(gl_program_cvars[0]); ++i) {
		if (gl_program_cvars[i]->flags & CVAR_LATCH) {
			Cvar_Register(gl_program_cvars[i]);
		}
	}
	Cvar_ResetCurrentGroup();

	GL_Init();
	renderer.vaos_supported = GLC_InitialiseVAOHandling();
	GL_ProcessErrors("post-GLC_InitialiseVAOHandling");
	GL_InitialiseBufferHandling(&buffers);
	GL_ProcessErrors("post-GL_InitialiseBufferHandling");
	GL_InitialiseState();
	GL_ProcessErrors("post-GL_InitialiseState");

	if (!GL_Supported(R_SUPPORT_RENDERING_SHADERS)) {
		// GLSL not supported for some reason
		for (i = 0; i < sizeof(gl_program_cvars) / sizeof(gl_program_cvars[0]); ++i) {
			int flags = Cvar_GetFlags(gl_program_cvars[i]);
			if (flags & CVAR_LATCH) {
				Cvar_LatchedSetValue(gl_program_cvars[i], 0);
			}
			else {
				Cvar_SetValue(gl_program_cvars[i], 0);
			}
			Cvar_SetFlags(gl_program_cvars[i], flags | CVAR_ROM);
		}
		Con_Printf("&cf00ERROR&r: GLSL programs not supported.\n");
		glConfig.supported_features |= R_SUPPORT_IMMEDIATEMODE;
	}
	else if (vid_gl_core_profile.integer && buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS)) {
		// Force GLSL
		for (i = 0; i < sizeof(gl_program_cvars) / sizeof(gl_program_cvars[0]); ++i) {
			int flags = Cvar_GetFlags(gl_program_cvars[i]);
			if (flags & CVAR_LATCH) {
				Cvar_LatchedSetValue(gl_program_cvars[i], 1);
			}
			else {
				Cvar_SetValue(gl_program_cvars[i], 1);
			}
			Cvar_SetFlags(gl_program_cvars[i], flags | CVAR_ROM);
		}
		Con_Printf("&c0f0INFO&r: immediate-mode rendering disabled.\n");
	}
	else {
		// make optional
		for (i = 0; i < sizeof(gl_program_cvars) / sizeof(gl_program_cvars[0]); ++i) {
			Cvar_SetFlags(gl_program_cvars[i], Cvar_GetFlags(gl_program_cvars[i]) & ~CVAR_ROM);
		}
		if (!renderer.vaos_supported) {
			// disable aliasmodel program rendering, it requires attributes
			Cvar_LatchedSetValue(&gl_program_aliasmodels, 0);
			Cvar_SetFlags(&gl_program_aliasmodels, Cvar_GetFlags(&gl_program_aliasmodels) | CVAR_ROM);
		}
		glConfig.supported_features |= R_SUPPORT_IMMEDIATEMODE;
	}
}

void GLC_PrepareModelRendering(qbool vid_restart)
{
	if (buffers.supported) {
		R_CreateInstanceVBO();

		R_CreateAliasModelVBO();
		R_BrushModelCreateVBO();
	}

	renderer.ProgramsInitialise();
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_matrix.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_matrix.h"
#include "r_draw.h"
#include "gl_texture_internal.h"

static qbool glc_pause_updates;

void GLC_RotateModelview(float angle, float x, float y, float z)
{
	if (!glc_pause_updates) {
		R_TraceLogAPICall("%s()", __func__);
		glMatrixMode(GL_MODELVIEW);
		glRotatef(angle, x, y, z);
	}
}

void GLC_IdentityModelview(void)
{
	if (!glc_pause_updates) {
		R_TraceLogAPICall("%s()", __func__);
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
	}
}

void GLC_OrthographicProjection(float left, float right, float top, float bottom, float zNear, float zFar)
{
	R_TraceLogAPICall("%s()", __func__);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(left, right, top, bottom, zNear, zFar);
}

void GLC_IdentityProjectionView(void)
{
	R_TraceLogAPICall("%s()", __func__);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
}

void GLC_PopModelviewMatrix(const float* matrix)
{
	R_TraceLogAPICall("%s()", __func__);
	glMatrixMode(GL_MODELVIEW);
	glLoadMatrixf(matrix);
}

void GLC_PopProjectionMatrix(const float* matrix)
{
	R_TraceLogAPICall("%s()", __func__);
	glMatrixMode(GL_PROJECTION);
	glLoadMatrixf(matrix);
}

void GLC_ScaleModelview(float xScale, float yScale, float zScale)
{
	if (!glc_pause_updates) {
		R_TraceLogAPICall("%s()", __func__);
		glMatrixMode(GL_MODELVIEW);
		glScalef(xScale, yScale, zScale);
	}
}

void GLC_Frustum(double left, double right, double bottom, double top, double zNear, double zFar)
{
	R_TraceLogAPICall("%s()", __func__);
	glFrustum(left, right, bottom, top, zNear, zFar);
}

void GLC_PauseMatrixUpdate(void)
{
	glc_pause_updates = true;
}

void GLC_ResumeMatrixUpdate(void)
{
	glc_pause_updates = false;
}

void GLC_BeginCausticsTextureMatrix(void)
{
	R_TraceLogAPICall("%s()", __func__);
	GL_SelectTexture(GL_TEXTURE1);
	glMatrixMode(GL_TEXTURE);
	glLoadIdentity();
	glScalef(0.5, 0.5, 1);
	glRotatef(r_refdef2.time * 10, 1, 0, 0);
	glRotatef(r_refdef2.time * 10, 0, 1, 0);
	glMatrixMode(GL_MODELVIEW);
}

void GLC_EndCausticsTextureMatrix(void)
{
	R_TraceLogAPICall("%s()", __func__);
	GL_SelectTexture(GL_TEXTURE1);
	glMatrixMode(GL_TEXTURE);
	glLoadIdentity();
	glMatrixMode(GL_MODELVIEW);
}

void GLC_TranslateModelview(float x, float y, float z)
{
	if (!glc_pause_updates) {
		R_TraceLogAPICall("%s()", __func__);
		glMatrixMode(GL_MODELVIEW);
		glTranslatef(x, y, z);
	}
}

void GLC_LoadModelviewMatrix(void)
{
	R_TraceLogAPICall("%s()", __func__);
	glMatrixMode(GL_MODELVIEW);
	glLoadMatrixf(R_ModelviewMatrix());
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_matrix.h
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_GLC_MATRIX_HEADER
#define EZQUAKE_GLC_MATRIX_HEADER

#include "r_matrix.h"

void GLC_IdentityModelview(void);
void GLC_RotateModelview(float angle, float x, float y, float z);
void GLC_TranslateModelview(float x, float y, float z);
void GLC_PopModelviewMatrix(const float* matrix);
void GLC_LoadModelviewMatrix(void);

void GLC_IdentityProjectionView(void);
void GLC_OrthographicProjection(float left, float right, float top, float bottom, float zNear, float zFar);

void GLC_PopProjectionMatrix(const float* matrix);
void GLC_ScaleModelview(float xScale, float yScale, float zScale);
void GLC_Frustum(double left, double right, double bottom, double top, double zNear, double zFar);
void GLC_PauseMatrixUpdate(void);
void GLC_ResumeMatrixUpdate(void);
void GLC_BeginCausticsTextureMatrix(void);
void GLC_EndCausticsTextureMatrix(void);

void GLC_PauseMatrixUpdate(void);
void GLC_ResumeMatrixUpdate(void);

#endif // EZQUAKE_GLC_MATRIX_HEADER


================================================
FILE: src/glc_md3.c
================================================
/*
Copyright (C) 2011 fuh and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// Code to display MD3 models (classic GL/immediate-mode)

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "glc_local.h"
#include "r_aliasmodel_md3.h"
#include "vx_vertexlights.h" 
#include "r_matrix.h"
#include "r_state.h"
#include "r_aliasmodel.h"
#include "glc_local.h"
#include "r_renderer.h"
#include "r_program.h"
#include "tr_types.h"
#include "rulesets.h"

const float* GLC_PowerupShell_ScrollParams(void);
void GLC_SetPowerupShellColor(int layer_no, int effects);
void GLC_PowerupShellColor(int layer_no, int effects, float* color);
qbool GLC_AliasModelStandardCompileSpecific(int subprogram_index);
int GLC_AliasModelSubProgramIndex(qbool textured, qbool fullbright, qbool caustics, qbool muzzlehack);
qbool GLC_AliasModelShellCompile(void);

#if 0
// FIXME: get rid of cos/sin lookups etc
static void GLC_AliasModelLightPointMD3(float color[4], const entity_t* ent, vbo_model_vert_t* vert1, vbo_model_vert_t* vert2, float lerpfrac)
{
	float l;
	extern cvar_t amf_lighting_vertex, amf_lighting_colour;

	// VULT VERTEX LIGHTING
	/*if (amf_lighting_vertex.integer && !ent->full_light) {
		vec3_t lc;

		l = VLight_LerpLightByAngles(vert1->normal_lat, vert1->normal_lng, vert2->normal_lat, vert2->normal_lng, lerpfrac, ent->angles[0], ent->angles[1]);
		l *= (ent->shadelight + ent->ambientlight) / 256.0;
		l = min(l, 1);

		if (amf_lighting_colour.integer) {
			int i;
			for (i = 0; i < 3; i++) {
				lc[i] = l * ent->lightcolor[i] / 255;
				lc[i] = min(lc[i], 1);
			}
		}
		else {
			VectorSet(lc, l, l, l);
		}

		if (ent->r_modelcolor[0] < 0) {
			// normal color
			VectorCopy(lc, color);
		}
		else {
			color[0] = ent->r_modelcolor[0] * lc[0];
			color[1] = ent->r_modelcolor[1] * lc[1];
			color[2] = ent->r_modelcolor[2] * lc[2];
		}
	}
	else*/ {
		float yaw_rad = ent->angles[YAW] * M_PI / 180.0;
		vec3_t angleVector = { cos(-yaw_rad), sin(yaw_rad), 1 };

		VectorNormalize(angleVector);
		l = FloatInterpolate(DotProduct(angleVector, vert1->normal), lerpfrac, DotProduct(angleVector, vert2->normal));
		l = (l * ent->shadelight + ent->ambientlight) / 256.0;
		l = min(l, 1);

		if (ent->custom_model == NULL) {
			if (ent->r_modelcolor[0] < 0) {
				color[0] = color[1] = color[2] = l;
			}
			else {
				color[0] = ent->r_modelcolor[0] * l;
				color[1] = ent->r_modelcolor[1] * l;
				color[2] = ent->r_modelcolor[2] * l;
			}
		}
		else {
			color[0] = ent->custom_model->color_cvar.color[0] / 255.0f;
			color[1] = ent->custom_model->color_cvar.color[1] / 255.0f;
			color[2] = ent->custom_model->color_cvar.color[2] / 255.0f;
		}
	}

	color[0] *= ent->r_modelalpha;
	color[1] *= ent->r_modelalpha;
	color[2] *= ent->r_modelalpha;
	color[3] = ent->r_modelalpha;
}
#endif

static void GLC_DrawMD3Frame(const entity_t* ent, const float* modelColor, md3Header_t* pheader, int frame1, int frame2, float lerpfracDefault, const surfinf_t* surface_info, qbool invalidate_texture, qbool outline, qbool additive_pass)
{
	md3Surface_t *surf;
	int surfnum;
	int numverts, i;
	vbo_model_vert_t* vbo_buffer = (vbo_model_vert_t*)ent->model->temp_vbo_buffer;
	int vertsPerFrame = ent->model->vertsInVBO / pheader->numFrames;
	int first_vert_f1 = vertsPerFrame * frame1;
	int first_vert_f2 = vertsPerFrame * frame2;
	vbo_model_vert_t* verts1 = &vbo_buffer[first_vert_f1];
	vbo_model_vert_t* verts2 = &vbo_buffer[first_vert_f2];
	qbool limit_lerp = false; // r_lerpmuzzlehack.integer && (ent->model->renderfx & RF_LIMITLERP);

	if (!vbo_buffer) {
		return;
	}

	MD3_ForEachSurface(pheader, surf, surfnum) {
		vec3_t interpolated_verts;
		// FIXME: hack for not reading shader types
		qbool additive_surface = ((ent->model && ent->model->modhint & MOD_VMODEL) && surfnum >= 1);
		numverts = surf->numTriangles * 3;

		if (additive_surface != additive_pass) {
			verts1 += numverts;
			verts2 += numverts;
			continue;
		}

		if (R_TextureReferenceIsValid(surface_info[surfnum].texnum) && !invalidate_texture) {
			renderer.TextureUnitBind(0, surface_info[surfnum].texnum);
		}

		GLC_Begin(GL_TRIANGLES);
		for (i = 0; i < numverts; ++i) {
			float lerpfrac = lerpfracDefault;

			if (limit_lerp && !VectorL2Compare(verts1->position, verts2->position, ALIASMODEL_MAX_LERP_DISTANCE)) {
				lerpfrac = 1;
			}

			if (outline) {
				vec3_t v1, v2;
				VectorMA(verts1->position, ent->outlineScale, verts1->normal, v1);
				VectorMA(verts2->position, ent->outlineScale, verts2->normal, v2);
				VectorInterpolate(v1, lerpfrac, v2, interpolated_verts);
			}
			else {
				VectorInterpolate(verts1->position, lerpfrac, verts2->position, interpolated_verts);
				// FIXME: another hack!
				if (!additive_pass) {
					//GLC_AliasModelLightPointMD3(vertexColor, ent, verts1, verts2, lerpfrac);
					R_CustomColor(modelColor[0], modelColor[1], modelColor[2], modelColor[3]);
				}
				else {
					R_CustomColor(ent->r_modelalpha, ent->r_modelalpha, ent->r_modelalpha, ent->r_modelalpha);
				}
			}
			glTexCoord2f(verts1->texture_coords[0], verts1->texture_coords[1]);
			GLC_Vertex3fv(interpolated_verts);

			++verts1;
			++verts2;
		}
		GLC_End();

		frameStats.classic.polycount[polyTypeAliasModel] += surf->numTriangles;
	}
}

static void GLC_DrawAlias3ModelProgram(entity_t* ent, int frame1, qbool invalidate_texture, float* vertexColor, float lerpfrac, qbool outline, qbool additive_pass)
{
	model_t *mod = ent->model;
	md3model_t *mhead = (md3model_t *)Mod_Extradata(mod);
	md3Header_t *pheader = MD3_HeaderForModel(mhead);
	float angle_radians = -ent->angles[YAW] * M_PI / 180.0;
	vec3_t angle_vector = { cos(angle_radians), sin(angle_radians), 1 };
	int vertsPerFrame = mod->vertsInVBO / pheader->numFrames;
	int first_vert = mod->vbo_start + vertsPerFrame * frame1;
	int vert_index;
	surfinf_t* sinf = MD3_ExtraSurfaceInfoForModel(mhead);
	md3Surface_t* surf;
	int surfnum;

	if (ent->skinnum >= 0 && ent->skinnum < pheader->numSkins) {
		sinf += ent->skinnum * pheader->numSurfaces;
	}

	if (outline) {
		qbool weaponmodel = (ent->renderfx & RF_WEAPONMODEL);

		R_ProgramUse(r_program_aliasmodel_outline_glc);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_outline_glc_lerpFraction, lerpfrac);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_outline_glc_outlineScale, ent->outlineScale);
		GLC_StateBeginAliasOutlineFrame(weaponmodel);
		vert_index = first_vert;
		MD3_ForEachSurface(pheader, surf, surfnum) {
			// FIXME: hack for not reading shader types
			qbool additive_surface = ((mod->modhint & MOD_VMODEL) && surfnum >= 1);

			// don't outline these
			if (additive_surface) {
				continue;
			}

			GL_DrawArrays(GL_TRIANGLES, vert_index, 3 * surf->numTriangles);
			vert_index += 3 * surf->numTriangles;
		}
	}
	else {
		// Temporarily disable caustics
		R_ProgramUse(r_program_aliasmodel_std_glc);
		R_ProgramUniform3fv(r_program_uniform_aliasmodel_std_glc_angleVector, angle_vector);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_shadelight, ent->shadelight / 256.0f);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_ambientlight, ent->ambientlight / 256.0f);
		R_ProgramUniform1i(r_program_uniform_aliasmodel_std_glc_fsTextureEnabled, invalidate_texture ? 0 : 1);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_fsMinLumaMix, 1.0f - (ent->full_light ? bound(0, gl_fb_models.integer, 1) : 0));
		R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_fsCausticEffects, 0 /*ent->renderfx & RF_CAUSTICS ? 1 : 0*/);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_lerpFraction, lerpfrac);
		R_ProgramUniform1f(r_program_uniform_aliasmodel_std_glc_time, cl.time);

		// z-pass
		if (ent->r_modelalpha < 1) {
			GLC_StateBeginDrawAliasZPass(ent->renderfx & RF_WEAPONMODEL);
			vert_index = first_vert;
			MD3_ForEachSurface(pheader, surf, surfnum) {
				GL_DrawArrays(GL_TRIANGLES, vert_index, 3 * surf->numTriangles);
				vert_index += 3 * surf->numTriangles;
			}
		}

		GLC_StateBeginDrawAliasFrameProgram(sinf->texnum, null_texture_reference, ent->renderfx, ent->custom_model, ent->r_modelalpha, additive_pass);
		vert_index = first_vert;
		MD3_ForEachSurface(pheader, surf, surfnum) {
			// FIXME: hack for not reading shader types
			qbool additive_surface = ((mod->modhint & MOD_VMODEL) && surfnum >= 1);

			if (additive_surface == additive_pass) {
				if (additive_pass) {
					R_CustomColor(ent->r_modelalpha, ent->r_modelalpha, ent->r_modelalpha, ent->r_modelalpha);
				}
				else {
					R_CustomColor(vertexColor[0], vertexColor[1], vertexColor[2], vertexColor[3]);
				}
				if (R_TextureReferenceIsValid(sinf[surfnum].texnum) && !invalidate_texture) {
					renderer.TextureUnitBind(0, sinf[surfnum].texnum);
				}

				GL_DrawArrays(GL_TRIANGLES, vert_index, 3 * surf->numTriangles);
			}
			vert_index += 3 * surf->numTriangles;
		}
		R_ProgramUse(r_program_none);
	}
}

static void GLC_DrawAlias3ModelImmediate(entity_t* ent, int frame1, int frame2, qbool invalidate_texture, float* vertexColor, float lerpfrac, qbool outline, qbool additive_pass)
{
	model_t* mod = ent->model;
	md3model_t* mhead = (md3model_t *)Mod_Extradata(mod);
	md3Header_t* pheader = MD3_HeaderForModel(mhead);
	surfinf_t* sinf = MD3_ExtraSurfaceInfoForModel(mhead);

	if (additive_pass && outline) {
		return;
	}

	// Immediate mode
	R_ProgramUse(r_program_none);
	if (outline) {
		GLC_StateBeginAliasOutlineFrame(ent->renderfx & RF_WEAPONMODEL);
		GLC_DrawMD3Frame(ent, vertexColor, pheader, frame1, frame2, lerpfrac, sinf, true, true, additive_pass);
	}
	else {
		if (ent->skinnum >= 0 && ent->skinnum < pheader->numSkins) {
			sinf += ent->skinnum * pheader->numSurfaces;
		}
		if (ent->r_modelalpha < 1 && !additive_pass) {
			GLC_StateBeginDrawAliasZPass(ent->renderfx & RF_WEAPONMODEL);
			GLC_DrawMD3Frame(ent, vertexColor, pheader, frame1, frame2, lerpfrac, sinf, invalidate_texture, false, false);
		}
		GLC_StateBeginMD3Draw(ent->r_modelalpha, R_TextureReferenceIsValid(sinf->texnum) && !invalidate_texture, ent->renderfx & RF_WEAPONMODEL, additive_pass);
		GLC_DrawMD3Frame(ent, vertexColor, pheader, frame1, frame2, lerpfrac, sinf, invalidate_texture, false, additive_pass);
	}
}

/*
To draw, for each surface, run through the triangles, getting tex coords from s+t, 
*/
void GLC_DrawAlias3Model(entity_t *ent, qbool outline, qbool additive_pass)
{
	extern cvar_t gl_fb_models, gl_program_aliasmodels;

	float lerpfrac;
	float vertexColor[4];

	model_t *mod = ent->model;
	md3model_t *mhead = (md3model_t *)Mod_Extradata(mod);
	md3Header_t *pheader = MD3_HeaderForModel(mhead);
	qbool invalidate_texture = false;

	int frame1, frame2;
	float oldMatrix[16];
	int subprogram;
	extern cvar_t r_lerpmuzzlehack;
	int render_effects = ent->renderfx;

	R_PushModelviewMatrix(oldMatrix);
	R_AliasModelPrepare(ent, pheader->numFrames, &frame1, &frame2, &lerpfrac, &outline);
	R_AliasModelColor(ent, vertexColor, &invalidate_texture);

	subprogram = GLC_AliasModelSubProgramIndex(!invalidate_texture, ent->full_light, gl_caustics.integer && (ent->renderfx & RF_CAUSTICS), r_lerpmuzzlehack.integer && (render_effects & RF_WEAPONMODEL));

	if (gl_program_aliasmodels.integer && buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_AliasModelStandardCompileSpecific(subprogram)) {
		GLC_DrawAlias3ModelProgram(ent, frame1, invalidate_texture, vertexColor, lerpfrac, outline, additive_pass);
	}
	else if (GL_Supported(R_SUPPORT_IMMEDIATEMODE)) {
		GLC_DrawAlias3ModelImmediate(ent, frame1, frame2, invalidate_texture, vertexColor, lerpfrac, outline, additive_pass);
	}
	R_PopModelviewMatrix(oldMatrix);
}

static void GLC_DrawAlias3ModelPowerupShellProgram(model_t * mod, md3Header_t * pheader, int frame1, entity_t * ent, float lerpfrac)
{
	int vertsPerFrame = mod->vertsInVBO / pheader->numFrames;
	int first_vert = mod->vbo_start + vertsPerFrame * frame1;
	float color1[4], color2[4];

	GLC_PowerupShellColor(0, ent->effects, color1);
	GLC_PowerupShellColor(1, ent->effects, color2);

	R_ProgramUse(r_program_aliasmodel_shell_glc);
	R_ProgramUniform4fv(r_program_uniform_aliasmodel_shell_glc_fsBaseColor1, color1);
	R_ProgramUniform4fv(r_program_uniform_aliasmodel_shell_glc_fsBaseColor2, color2);
	R_ProgramUniform4fv(r_program_uniform_aliasmodel_shell_glc_scroll, GLC_PowerupShell_ScrollParams());
	R_ProgramUniform1f(r_program_uniform_aliasmodel_shell_glc_lerpFraction, lerpfrac);
	GL_DrawArrays(GL_TRIANGLES, first_vert, vertsPerFrame);
	R_ProgramUse(r_program_none);
}

static void GLC_DrawAlias3ModelPowerupShellImmediate(model_t * mod, md3Header_t * pheader, int frame1, int frame2, entity_t * ent, float lerpfrac)
{
	int layer_no;
	const int distance = MD3_INTERP_MAXDIST / MD3_XYZ_SCALE;

	R_ProgramUse(r_program_none);

	for (layer_no = 0; layer_no <= 1; ++layer_no) {
		md3Surface_t* surf;
		int surfnum;
		 
		MD3_ForEachSurface(pheader, surf, surfnum) {
			// loop through the surfaces.
			int pose1 = frame1 * surf->numVerts;
			int pose2 = frame2 * surf->numVerts;
			int numtris, i;
			unsigned int* tris;
			md3St_t* tc;
			ezMd3XyzNormal_t* verts;

			//skin texture coords.
			tc = MD3_SurfaceTextureCoords(surf);
			verts = MD3_SurfaceVertices(surf);

			tris = (unsigned int *)((char *)surf + surf->ofsTriangles);
			numtris = surf->numTriangles * 3;

			GLC_SetPowerupShellColor(layer_no, ent->effects);
			GLC_Begin(GL_TRIANGLES);
			for (i = 0; i < numtris; i++) {
				float s, t;
				vec3_t vec1pos, vec2pos, interpolated_verts;
				ezMd3XyzNormal_t *v1, *v2;

				v1 = verts + *tris + pose1;
				v2 = verts + *tris + pose2;

				s = tc[*tris].s * 2.0f + r_refdef2.powerup_scroll_params[layer_no * 2];
				t = tc[*tris].t * 2.0f + r_refdef2.powerup_scroll_params[layer_no * 2 + 1];

				lerpfrac = VectorL2Compare(v1->xyz, v2->xyz, distance) ? lerpfrac : 1;
				VectorAdd(v1->normal, v1->xyz, vec1pos);
				VectorAdd(v2->normal, v2->xyz, vec2pos);
				VectorInterpolate(vec1pos, lerpfrac, vec2pos, interpolated_verts);

				glTexCoord2f(s, t);
				GLC_Vertex3fv(interpolated_verts);

				tris++;
			}
			GLC_End();
		}
	}
}

/*
To draw, for each surface, run through the triangles, getting tex coords from s+t,
*/
void GLC_DrawAlias3ModelPowerupShell(entity_t *ent)
{
	extern cvar_t gl_fb_models, gl_program_aliasmodels;
	model_t *mod = ent->model;
	md3model_t *mhead = (md3model_t *)Mod_Extradata(mod);
	md3Header_t *pheader = MD3_HeaderForModel(mhead);
	float oldMatrix[16];
	int frame1, frame2;
	float lerpfrac;
	qbool outline = false;

	R_PushModelviewMatrix(oldMatrix);
	R_AliasModelPrepare(ent, pheader->numFrames, &frame1, &frame2, &lerpfrac, &outline);

	GLC_StateBeginAliasPowerupShell(ent->renderfx & RF_WEAPONMODEL);
	if (gl_program_aliasmodels.integer && buffers.supported && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_AliasModelShellCompile()) {
		GLC_DrawAlias3ModelPowerupShellProgram(mod, pheader, frame1, ent, lerpfrac);
	}
	else if (GL_Supported(R_SUPPORT_IMMEDIATEMODE)) {
		GLC_DrawAlias3ModelPowerupShellImmediate(mod, pheader, frame1, frame2, ent, lerpfrac);
	}

	R_PopModelviewMatrix(oldMatrix);
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_misc.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "glc_local.h"
#include "r_matrix.h"
#include "r_state.h"
#include "r_texture.h"
#include "r_renderer.h"
#include "gl_texture.h"
#include "r_program.h"

// motion blur.
void GLC_PolyBlend(float v_blend[4])
{
	color_t v_blend_color = RGBA_TO_COLOR(
		bound(0, v_blend[0], 1) * 255,
		bound(0, v_blend[1], 1) * 255,
		bound(0, v_blend[2], 1) * 255,
		bound(0, v_blend[3], 1) * 255
	);

	R_ApplyRenderingState(r_state_poly_blend);
	Draw_AlphaRectangleRGB(r_refdef.vrect.x, r_refdef.vrect.y, r_refdef.vrect.width, r_refdef.vrect.height, 0.0f, true, v_blend_color);
}

void GLC_BrightenScreen(void)
{
	float f;

	if (vid_hwgamma_enabled) {
		return;
	}
	if (v_contrast.value <= 1.0) {
		return;
	}

	f = min(v_contrast.value, 3);
	if (R_OldGammaBehaviour()) {
		extern float vid_gamma;

		f = pow(f, vid_gamma);
	}

	R_ProgramUse(r_program_none);
	GLC_StateBeginBrightenScreen();

	GLC_Begin(GL_QUADS);
	while (f > 1) {
		if (f >= 2) {
			R_CustomColor(1, 1, 1, 1);
		}
		else {
			R_CustomColor(f - 1, f - 1, f - 1, 1);
		}

		GLC_Vertex2f(-1, -1);
		GLC_Vertex2f(-1, 1);
		GLC_Vertex2f(1, 1);
		GLC_Vertex2f(1, -1);

		f *= 0.5;
	}
	GLC_End();
}

void GLC_PreRenderView(void)
{
	// TODO
}

void GLC_SetupGL(void)
{
}

void GLC_Shutdown(r_shutdown_mode_t mode)
{
	if (mode != r_shutdown_reload) {
		GLC_FreeAliasPoseBuffer();
		renderer.ProgramsShutdown(mode == r_shutdown_restart);
		GL_DeleteSamplers();
	}
	GL_FramebufferDeleteAll();
}

void GLC_TextureInitialiseState(void)
{
	GL_TextureInitialiseState();
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_particles.c
================================================
/*
Copyright (C) 2018 ezQuake team.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "gl_sprite3d.h"
#include "glm_particles.h"
#include "particles_classic.h"

void GLC_DrawClassicParticles(int particles_to_draw)
{
	extern texture_ref particletexture;
	r_sprite3d_vert_t* vert;

	R_Sprite3DInitialiseBatch(SPRITE3D_PARTICLES_CLASSIC, r_state_particles_classic, particletexture, particletexture_array_index, r_primitive_triangles);
	vert = R_Sprite3DAddEntry(SPRITE3D_PARTICLES_CLASSIC, 3 * particles_to_draw);
	if (vert) {
		extern r_sprite3d_vert_t glvertices[ABSOLUTE_MAX_PARTICLES * 3];

		memcpy(vert, glvertices, particles_to_draw * 3 * sizeof(glvertices[0]));
	}
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_performance.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: gl_rmisc.c,v 1.27 2007-09-17 19:37:55 qqshka Exp $
*/
// gl_rmisc.c

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "tr_types.h"
#include "r_renderer.h"

void GLC_TimeRefresh(void)
{
	int i;
	float start, stop, time;

	if (!GL_FramebufferEnabled2D()) {
#ifndef __APPLE__
		if (glConfig.hardwareType != GLHW_INTEL) {
			// Causes the console to flicker on Intel cards.
			GL_BuiltinProcedure(glDrawBuffer, "mode=GL_FRONT", GL_FRONT)
		}
#endif
	}

	renderer.EnsureFinished();

	start = Sys_DoubleTime();
	for (i = 0; i < 128; i++) {
		r_refdef.viewangles[1] = i * (360.0 / 128.0);
		R_SetupFrame();
		R_RenderView();
	}

	renderer.EnsureFinished();
	stop = Sys_DoubleTime();
	time = stop - start;
	Com_Printf("%f seconds (%f fps)\n", time, 128 / time);

	if (!GL_FramebufferEnabled2D()) {
#ifndef __APPLE__
		if (glConfig.hardwareType != GLHW_INTEL) {
			GL_BuiltinProcedure(glDrawBuffer, "mode=GL_BACK", GL_BACK)
		}
#endif
	}

	R_EndRendering();
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_sdl.c
================================================
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================

*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include <SDL.h>
#include "quakedef.h"
#include "gl_local.h"

static opengl_version_t versions[] = {
	{ 4, 3, false, false },
	{ 3, 2, false, false },
	{ 0, 0, false, true },
	{ 4, 3, true, false },
	{ 3, 2, true, false },
	{ 0, 0, false, true },
};

SDL_GLContext GLC_SDL_CreateContext(SDL_Window* window)
{
	return GL_SDL_CreateBestContext(window, versions, sizeof(versions) / sizeof(versions[0]));
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_sky.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_brushmodel_sky.h"
#include "glc_local.h"
#include "r_brushmodel_sky.h"
#include "r_renderer.h"
#include "tr_types.h"
#include "r_brushmodel.h"
#include "r_program.h"
#include "r_matrix.h"

#define SUBDIVISIONS 10

static float skymins[2][6], skymaxs[2][6];

static void GLC_DrawSkyBox(void);
static void GLC_DrawSkyDome(void);
static void GLC_DrawSkyFace(int axis, qbool multitexture);
static void GLC_MakeSkyVec(float s, float t, int axis);

static void R_SkyAddBoxSurface(msurface_t *fa);
static void R_SkyClearVisibleLimits(void);

static float speedscale, speedscale2;		// for sky and clouds, respectively

typedef enum {
	skypoly_mode_mtex,
	skypoly_mode_sky,
	skypoly_mode_clouds,
} skypoly_mode_id;

static void GLC_DrawSky_Program(void);
qbool GLC_SkyProgramCompile(void);
extern cvar_t gl_program_sky;

/*
==============
R_DrawSkyBox
==============
*/

// 1 = s, 2 = t, 3 = 2048
static int st_to_vec[6][3] = {
	{3,-1,2},
	{-3,1,2},

	{1,3,2},
	{-1,-3,2},

	{-2,-1,3},		// 0 degrees yaw, look straight up
	{2,-1,-3}		// look straight down
};

// s = [0]/[2], t = [1]/[2]
static int vec_to_st[6][3] = {
	{-2,3,1},
	{2,3,-1},

	{1,3,2},
	{-1,3,-2},

	{-2,-1,3},
	{-2,1,-3}
};

// s and t range from -1 to 1
static void Sky_MakeSkyVec2(float s, float t, int axis, vec3_t v)
{
	vec3_t		b;
	int			j, k;
	b[0] = s;
	b[1] = t;
	b[2] = 1;

	for (j = 0; j < 3; j++) {
		k = st_to_vec[axis][j];
		if (k < 0) {
			v[j] = -b[-k - 1];
		}
		else {
			v[j] = b[k - 1];
		}
	}
}

static void GLC_DrawFlatSkyPoly(glpoly_t* p, qbool texture)
{
	int i;

	R_TraceAPI("%s()", __func__);

	GLC_Begin(GL_TRIANGLE_STRIP);
	for (i = 0; i < p->numverts; ++i) {
		float* v = p->verts[i];
		if (texture) {
			vec3_t direction;
			
			VectorSubtract(v, r_refdef.vieworg, direction);

			glTexCoord3f(direction[0], direction[2], direction[1]);
		}
		GLC_Vertex3fv(v);
	}
	GLC_End();
}

static void GLC_DrawFastSkyChain(void)
{
	qbool use_vbo = buffers.supported && modelIndexes;
	int index_count = 0;
	msurface_t* fa;

	for (fa = skychain; fa; fa = fa->texturechain) {
		glpoly_t *p;

		for (p = fa->polys; p; p = p->next) {
			if (use_vbo) {
				index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
			}
			else {
				GLC_DrawFlatSkyPoly(p, false);
			}
		}
	}
	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
	}
}

static void GLC_EmitSkyPolys(msurface_t *fa, skypoly_mode_id mode)
{
	glpoly_t *p;
	float *v, s, t, ss = 0.0, tt = 0.0, length;
	int i;
	vec3_t dir;

	R_TraceAPI("%s()", __func__);
	for (p = fa->polys; p; p = p->next) {
		GLC_Begin(GL_TRIANGLE_STRIP);
		for (i = 0, v = p->verts[0]; i < p->numverts; i++, v += VERTEXSIZE) {
			VectorSubtract(v, r_origin, dir);
			dir[2] *= 3;	// flatten the sphere

			length = VectorLength(dir);
			length = 6 * 63 / length;

			dir[0] *= length;
			dir[1] *= length;

			s = (speedscale + dir[0]) * (1.0 / 128);
			t = (speedscale + dir[1]) * (1.0 / 128);

			ss = (speedscale2 + dir[0]) * (1.0 / 128);
			tt = (speedscale2 + dir[1]) * (1.0 / 128);

			switch (mode) {
				case skypoly_mode_mtex:
					GLC_MultiTexCoord2f(GL_TEXTURE0, s, t);
					GLC_MultiTexCoord2f(GL_TEXTURE1, ss, tt);
					break;
				case skypoly_mode_sky:
					glTexCoord2f(s, t);
					break;
				case skypoly_mode_clouds:
					glTexCoord2f(ss, tt);
					break;
			}

			GLC_Vertex3fv(v);
		}
		GLC_End();
	}
}

// This is used for brushmodel entity surfaces only
void GLC_SkyDrawChainedSurfaces(void)
{
	msurface_t *fa;

	if (!skychain) {
		return;
	}

	if (gl_program_sky.integer && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_SkyProgramCompile()) {
		GLC_DrawSky_Program();
	}
	else {
		R_ProgramUse(r_program_none);
		if (r_fastsky.integer || cl.worldmodel->bspversion == HL_BSPVERSION) {
			GLC_StateBeginFastSky(false);
			GLC_DrawFastSkyChain();
		}
		else if (gl_mtexable) {
			GLC_StateBeginMultiTextureSkyChain();

			speedscale = r_refdef2.time * 8;
			speedscale -= (int)speedscale & ~127;
			speedscale2 = r_refdef2.time * 16;
			speedscale2 -= (int)speedscale2 & ~127;

			for (fa = skychain; fa; fa = fa->texturechain) {
				GLC_EmitSkyPolys(fa, skypoly_mode_mtex);
			}
		}
		else {
			GLC_StateBeginSingleTextureSkyPass();

			speedscale = r_refdef2.time * 8;
			speedscale -= (int)speedscale & ~127;

			for (fa = skychain; fa; fa = fa->texturechain) {
				GLC_EmitSkyPolys(fa, skypoly_mode_sky);
			}

			GLC_StateBeginSingleTextureCloudPass();

			speedscale = r_refdef2.time * 16;
			speedscale -= (int)speedscale & ~127;

			for (fa = skychain; fa; fa = fa->texturechain) {
				GLC_EmitSkyPolys(fa, skypoly_mode_clouds);
			}
		}
	}

	skychain = NULL;
	skychain_tail = &skychain;
}

static qbool R_DetermineSkyLimits(qbool *ignore_z)
{
	if (r_viewleaf->contents == CONTENTS_SOLID) {
		// always draw if we're in a solid leaf (probably outside the level)
		// FIXME: we don't really want to add all six planes every time!
		int i;
		for (i = 0; i < 6; i++) {
			skymins[0][i] = skymins[1][i] = -1;
			skymaxs[0][i] = skymaxs[1][i] = 1;
		}
		*ignore_z = true;
	}
	else {
		msurface_t* fa;

		// no sky at all
		if (!skychain) {
			return false;
		}

		// figure out how much of the sky box we need to draw
		R_SkyClearVisibleLimits();
		for (fa = skychain; fa; fa = fa->texturechain) {
			R_SkyAddBoxSurface(fa);
		}

		*ignore_z = false;
	}

	return true;
}

#define PROGRAMFLAGS_SKYBOX       1
#define PROGRAMFLAGS_SKYWIND      2

qbool GLC_SkyProgramCompile(void)
{
	int flags = (r_skyboxloaded && R_UseCubeMapForSkyBox() ? PROGRAMFLAGS_SKYBOX : 0);
	if (flags && Skywind_Active()) {
		flags |= PROGRAMFLAGS_SKYWIND;
	}

	if (R_ProgramRecompileNeeded(r_program_sky_glc, flags)) {
		static char included_definitions[512];

		memset(included_definitions, 0, sizeof(included_definitions));
		if (flags & PROGRAMFLAGS_SKYBOX) {
			strlcat(included_definitions, "#define DRAW_SKYBOX\n", sizeof(included_definitions));
			if (flags & PROGRAMFLAGS_SKYWIND) {
				strlcat(included_definitions, "#define DRAW_SKYWIND\n", sizeof(included_definitions));
			}
		}

		R_ProgramCompileWithInclude(r_program_sky_glc, included_definitions);
		if (flags & PROGRAMFLAGS_SKYBOX) {
			R_ProgramUniform1i(r_program_uniform_sky_glc_skyTex, 0);
		}
		else {
			R_ProgramUniform1i(r_program_uniform_sky_glc_skyDomeTex, 0);
			R_ProgramUniform1i(r_program_uniform_sky_glc_skyDomeCloudTex, 1);
		}
		R_ProgramSetCustomOptions(r_program_sky_glc, flags);
	}

	R_ProgramSetStandardUniforms(r_program_sky_glc);

	return R_ProgramReady(r_program_sky_glc);
}

static void GLC_DrawSky_Program(void)
{
	extern msurface_t *skychain;
	float skySpeedscale = r_refdef2.time * 8;
	float skySpeedscale2 = r_refdef2.time * 16;
	float skyWind[4];

	skySpeedscale -= (int)skySpeedscale & ~127;
	skySpeedscale2 -= (int)skySpeedscale2 & ~127;

	skySpeedscale /= 128.0f;
	skySpeedscale2 /= 128.0f;

	R_TraceAPI("%s()", __func__);
	R_ProgramUse(r_program_sky_glc);
	R_ProgramUniform1f(r_program_uniform_sky_glc_speedscale, skySpeedscale);
	R_ProgramUniform1f(r_program_uniform_sky_glc_speedscale2, skySpeedscale2);
	R_ProgramUniform3fv(r_program_uniform_sky_glc_cameraPosition, r_refdef.vieworg);
	if (Skywind_GetDirectionAndPhase(skyWind, &skyWind[3])) {
		R_ProgramUniform4fv(r_program_uniform_sky_glc_skyWind, skyWind);
	}

	if (r_skyboxloaded && R_UseCubeMapForSkyBox()) {
		extern texture_ref skybox_cubeMap;

		glEnable(GL_TEXTURE_CUBE_MAP);
		R_ApplyRenderingState(r_state_skybox);
		renderer.TextureUnitBind(0, skybox_cubeMap);
		GLC_DrawFastSkyChain();
		glDisable(GL_TEXTURE_CUBE_MAP);
	}
	else {
		GLC_StateBeginMultiTextureSkyDome(true);
		GLC_DrawFastSkyChain();
	}

	R_ProgramUse(r_program_none);
	skychain = NULL;
}

void GLC_DrawSky(void)
{
	msurface_t	*fa;
	qbool		ignore_z;
	extern msurface_t *skychain;

	R_TraceAPI("%s()", __func__);
	if (gl_program_sky.integer && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_SkyProgramCompile()) {
		GLC_DrawSky_Program();
	}
	else if (r_fastsky.integer) {
		R_ProgramUse(r_program_none);
		GLC_StateBeginFastSky(true);
		GLC_DrawFastSkyChain();
	}
	else if (r_skyboxloaded && R_UseCubeMapForSkyBox()) {
		extern texture_ref skybox_cubeMap;

		R_ProgramUse(r_program_none);
		R_ApplyRenderingState(r_state_skybox);
		renderer.TextureUnitBind(0, skybox_cubeMap);
		GL_BuiltinProcedure(glEnable, "cap=GL_TEXTURE_CUBE_MAP", GL_TEXTURE_CUBE_MAP);

		for (fa = skychain; fa; fa = fa->texturechain) {
			glpoly_t *p;

			for (p = fa->polys; p; p = p->next) {
				GLC_DrawFlatSkyPoly(p, true);
			}
		}

		GL_BuiltinProcedure(glDisable, "cap=GL_TEXTURE_CUBE_MAP", GL_TEXTURE_CUBE_MAP);
	}
	else if (R_DetermineSkyLimits(&ignore_z)) {
		// draw a skybox or classic quake clouds
		R_ProgramUse(r_program_none);
		if (r_skyboxloaded) {
			GLC_DrawSkyBox();
		}
		else {
			GLC_DrawSkyDome();
		}

		// draw the sky polys into the Z buffer
		// don't need depth test yet
		if (!ignore_z) {
			GLC_StateBeginSkyZBufferPass();
			GLC_DrawFastSkyChain();
		}
	}

	skychain = NULL;
	return;
}

static void EmitSkyVert(vec3_t v, qbool multitexture)
{
	vec3_t dir;
	float length;

	VectorCopy(v, dir);
	VectorAdd(v, r_origin, v);
	//VectorSubtract(v, r_origin, dir);
	dir[2] *= 3;	// flatten the sphere

	length = VectorLength(dir);
	length = 6 * 63 / length;

	dir[0] *= length;
	dir[1] *= length;

	if (multitexture) {
		GLC_MultiTexCoord2f(GL_TEXTURE0, (speedscale + dir[0]) * (1.0 / 128), (speedscale + dir[1]) * (1.0 / 128));

		GLC_MultiTexCoord2f(GL_TEXTURE1, (speedscale2 + dir[0]) * (1.0 / 128), (speedscale2 + dir[1]) * (1.0 / 128));
	}
	else {
		glTexCoord2f((speedscale + dir[0]) * (1.0 / 128), (speedscale + dir[1]) * (1.0 / 128));
	}
	GLC_Vertex3fv(v);
}

static void GLC_MakeSkyVec2(float s, float t, int axis, float range, vec3_t v)
{
	Sky_MakeSkyVec2(s, t, axis, v);

	v[0] *= range;
	v[1] *= range;
	v[2] *= range;
}

static void GLC_DrawSkyFace(int axis, qbool multitexture)
{
	int i, j;
	vec3_t vecs[4];
	float s, t;
	int v;
	float fstep = 2.0 / SUBDIVISIONS;
	float skyrange = R_FarPlaneZ() * 0.577; // 0.577 < 1/sqrt(3)

	GLC_Begin(GL_QUADS);
	for (v = 0, i = 0; i < SUBDIVISIONS; i++, v++)
	{
		s = (float)(i*2 - SUBDIVISIONS) / SUBDIVISIONS;

		if (s + fstep < skymins[0][axis] || s > skymaxs[0][axis]) {
			continue;
		}

		for (j = 0; j < SUBDIVISIONS; j++, v++) {
			t = (float)(j * 2 - SUBDIVISIONS) / SUBDIVISIONS;

			if (t + fstep < skymins[1][axis] || t > skymaxs[1][axis]) {
				continue;
			}

			GLC_MakeSkyVec2(s, t, axis, skyrange, vecs[0]);
			GLC_MakeSkyVec2(s, t + fstep, axis, skyrange, vecs[1]);
			GLC_MakeSkyVec2(s + fstep, t + fstep, axis, skyrange, vecs[2]);
			GLC_MakeSkyVec2(s + fstep, t, axis, skyrange, vecs[3]);

			EmitSkyVert(vecs[0], multitexture);
			EmitSkyVert(vecs[1], multitexture);
			EmitSkyVert(vecs[2], multitexture);
			EmitSkyVert(vecs[3], multitexture);
		}
	}
	GLC_End();
}

static void GLC_DrawSkyDome(void)
{
	int i;

	if (gl_mtexable) {
		GLC_StateBeginMultiTextureSkyDome(false);
	}
	else {
		GLC_StateBeginSingleTextureSkyDome();
	}

	speedscale = r_refdef2.time * 8;
	speedscale -= (int)speedscale & ~127;

	speedscale2 = r_refdef2.time * 16;
	speedscale2 -= (int)speedscale2 & ~127;

	for (i = 0; i < 6; i++) {
		if ((skymins[0][i] >= skymaxs[0][i] || skymins[1][i] >= skymaxs[1][i])) {
			continue;
		}
		GLC_DrawSkyFace(i, gl_mtexable);
	}

	if (!gl_mtexable) {
		GLC_StateBeginSingleTextureSkyDomeCloudPass();

		speedscale = speedscale2;

		for (i = 0; i < 6; i++) {
			if ((skymins[0][i] >= skymaxs[0][i] || skymins[1][i] >= skymaxs[1][i])) {
				continue;
			}
			GLC_DrawSkyFace(i, false);
		}
	}
}

static void GLC_DrawSkyBox(void)
{
	static int skytexorder[MAX_SKYBOXTEXTURES] = {0,2,1,3,4,5};
	int i;

	R_ApplyRenderingState(r_state_skybox);

	if (R_UseCubeMapForSkyBox()) {
		extern texture_ref skybox_cubeMap;

		renderer.TextureUnitBind(0, skybox_cubeMap);
		glEnable(GL_TEXTURE_CUBE_MAP);
	}

	for (i = 0; i < MAX_SKYBOXTEXTURES; i++) {
		if ((skymins[0][i] >= skymaxs[0][i] || skymins[1][i] >= skymaxs[1][i])) {
			continue;
		}

		if (!R_UseCubeMapForSkyBox()) {
			renderer.TextureUnitBind(0, skyboxtextures[(int)bound(0, skytexorder[i], MAX_SKYBOXTEXTURES - 1)]);
		}

		GLC_Begin(GL_QUADS);
		GLC_MakeSkyVec(skymins[0][i], skymins[1][i], i);
		GLC_MakeSkyVec(skymins[0][i], skymaxs[1][i], i);
		GLC_MakeSkyVec(skymaxs[0][i], skymaxs[1][i], i);
		GLC_MakeSkyVec(skymaxs[0][i], skymins[1][i], i);
		GLC_End();
	}

	if (R_UseCubeMapForSkyBox()) {
		extern texture_ref skybox_cubeMap;

		renderer.TextureUnitBind(0, skybox_cubeMap);
		glDisable(GL_TEXTURE_CUBE_MAP);
	}
}

static void GLC_MakeSkyVec(float s, float t, int axis)
{
	vec3_t v, b;
	float skyrange = R_FarPlaneZ() * 0.577; // 0.577 < 1/sqrt(3)

	Sky_MakeSkyVec2(s, t, axis, b);
	VectorMA(r_origin, skyrange, b, v);

	if (R_UseCubeMapForSkyBox()) {
		glTexCoord3f(v[0], v[2], v[1]);
	}
	else {
		// avoid bilerp seam
		s = (s + 1) * 0.5;
		t = (t + 1) * 0.5;

		s = bound(1.0 / 512, s, 511.0 / 512);
		t = bound(1.0 / 512, t, 511.0 / 512);

		t = 1.0 - t;

		glTexCoord2f(s, t);
	}
	GLC_Vertex3fv(v);
}

static vec3_t skyclip[6] = {
	{ 1,1,0 },
	{ 1,-1,0 },
	{ 0,-1,1 },
	{ 0,1,1 },
	{ 1,0,1 },
	{ -1,0,1 }
};

#define skybox_range	2400.0

static void R_SkyPolygonCalcLimits(int nump, vec3_t vecs)
{
	int i, j, axis;
	vec3_t v, av;
	float s, t, dv, *vp;

	// decide which face it maps to
	VectorClear(v);
	for (i = 0, vp = vecs; i < nump; i++, vp += 3) {
		VectorAdd(vp, v, v);
	}

	av[0] = fabs(v[0]);
	av[1] = fabs(v[1]);
	av[2] = fabs(v[2]);
	if (av[0] > av[1] && av[0] > av[2]) {
		axis = (v[0] < 0) ? 1 : 0;
	}
	else if (av[1] > av[2] && av[1] > av[0]) {
		axis = (v[1] < 0) ? 3 : 2;
	}
	else {
		axis = (v[2] < 0) ? 5 : 4;
	}

	// project new texture coords
	for (i = 0; i < nump; i++, vecs += 3) {
		j = vec_to_st[axis][2];
		dv = (j > 0) ? vecs[j - 1] : -vecs[-j - 1];

		j = vec_to_st[axis][0];
		s = (j < 0) ? -vecs[-j - 1] / dv : vecs[j - 1] / dv;

		j = vec_to_st[axis][1];
		t = (j < 0) ? -vecs[-j - 1] / dv : vecs[j - 1] / dv;

		if (s < skymins[0][axis]) {
			skymins[0][axis] = s;
		}
		if (t < skymins[1][axis]) {
			skymins[1][axis] = t;
		}
		if (s > skymaxs[0][axis]) {
			skymaxs[0][axis] = s;
		}
		if (t > skymaxs[1][axis]) {
			skymaxs[1][axis] = t;
		}
	}
}

#define	MAX_CLIP_VERTS	64

static void R_SkyPolygonClip(int nump, vec3_t vecs, int stage)
{
	float *norm, *v, d, e, dists[MAX_CLIP_VERTS];
	qbool front, back;
	int sides[MAX_CLIP_VERTS], newc[2], i, j;
	vec3_t newv[2][MAX_CLIP_VERTS];

	if (nump > MAX_CLIP_VERTS - 2) {
		Sys_Error("ClipSkyPolygon: nump > MAX_CLIP_VERTS - 2");
	}
	if (stage == 6) {
		// fully clipped, so draw it
		R_SkyPolygonCalcLimits(nump, vecs);
		return;
	}

	front = back = false;
	norm = skyclip[stage];
	for (i = 0, v = vecs; i < nump; i++, v += 3) {
		d = DotProduct(v, norm);
		if (d > ON_EPSILON) {
			front = true;
			sides[i] = SIDE_FRONT;
		}
		else if (d < -ON_EPSILON) {
			back = true;
			sides[i] = SIDE_BACK;
		}
		else {
			sides[i] = SIDE_ON;
		}
		dists[i] = d;
	}

	if (!front || !back) {
		// not clipped
		R_SkyPolygonClip(nump, vecs, stage + 1);
		return;
	}

	// clip it
	sides[i] = sides[0];
	dists[i] = dists[0];
	VectorCopy(vecs, (vecs + (i * 3)));
	newc[0] = newc[1] = 0;

	for (i = 0, v = vecs; i < nump; i++, v += 3) {
		switch (sides[i]) {
			case SIDE_FRONT:
				VectorCopy(v, newv[0][newc[0]]);
				newc[0]++;
				break;
			case SIDE_BACK:
				VectorCopy(v, newv[1][newc[1]]);
				newc[1]++;
				break;
			case SIDE_ON:
				VectorCopy(v, newv[0][newc[0]]);
				newc[0]++;
				VectorCopy(v, newv[1][newc[1]]);
				newc[1]++;
				break;
		}

		if (sides[i] == SIDE_ON || sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i])
			continue;

		d = dists[i] / (dists[i] - dists[i + 1]);
		for (j = 0; j < 3; j++) {
			e = v[j] + d * (v[j + 3] - v[j]);
			newv[0][newc[0]][j] = e;
			newv[1][newc[1]][j] = e;
		}
		newc[0]++;
		newc[1]++;
	}

	// continue
	R_SkyPolygonClip(newc[0], newv[0][0], stage + 1);
	R_SkyPolygonClip(newc[1], newv[1][0], stage + 1);
}

/*
=================
R_AddSkyBoxSurface
=================
*/
static void R_SkyAddBoxSurface(msurface_t *fa)
{
	int i, j, v;
	vec3_t verts[MAX_CLIP_VERTS];
	glpoly_t *p;

	// calculate vertex values for sky box
	for (p = fa->polys; p; p = p->next) {
		// Meag: the R_SkyPolygonClip() requires verts in convex polygon order, i'm not messing
		//       with it... so we add the verts in a weird order to get back from triangle strip
		//       to verts
		VectorSubtract(p->verts[0], r_origin, verts[0]);
		for (v = 1, i = 1, j = p->numverts - 1; v < p->numverts; ++v) {
			if (v % 2) {
				VectorSubtract(p->verts[v], r_origin, verts[i]);
				++i;
			}
			else {
				VectorSubtract(p->verts[v], r_origin, verts[j]);
				--j;
			}
		}
		R_SkyPolygonClip(p->numverts, verts[0], 0);
	}
}

static void R_SkyClearVisibleLimits(void)
{
	int i;
	for (i = 0; i < 6; i++) {
		skymins[0][i] = skymins[1][i] = 9999;
		skymaxs[0][i] = skymaxs[1][i] = -9999;
	}
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_sprite3d.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

// 3D sprites
#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_local.h"
#include "r_state.h"
#include "gl_sprite3d.h"
#include "r_sprite3d_internal.h"
#include "glc_vao.h"
#include "tr_types.h"
#include "glc_local.h"
#include "r_renderer.h"
#include "r_texture.h"

static void GLC_Create3DSpriteVAO(void)
{
	if (buffers.supported) {
		R_GenVertexArray(vao_3dsprites);
		R_Sprite3DCreateVBO();
		R_Sprite3DCreateIndexBuffer();

		GLC_VAOSetIndexBuffer(vao_3dsprites, r_buffer_sprite_index_data);
		GLC_VAOSetVertexBuffer(vao_3dsprites, r_buffer_sprite_vertex_data);
		GLC_VAOEnableVertexPointer(vao_3dsprites, 3, GL_FLOAT, sizeof(r_sprite3d_vert_t), VBO_FIELDOFFSET(r_sprite3d_vert_t, position));
		GLC_VAOEnableColorPointer(vao_3dsprites, 4, GL_UNSIGNED_BYTE, sizeof(r_sprite3d_vert_t), VBO_FIELDOFFSET(r_sprite3d_vert_t, color));
		GLC_VAOEnableTextureCoordPointer(vao_3dsprites, 0, 2, GL_FLOAT, sizeof(r_sprite3d_vert_t), VBO_FIELDOFFSET(r_sprite3d_vert_t, tex));
	}
}

static void GLC_DrawSequentialBatch(gl_sprite3d_batch_t* batch, int index_offset, GLuint maximum_batch_size)
{
	if (R_TextureReferenceIsValid(batch->texture)) {
		R_ApplyRenderingState(batch->rendering_state);
		renderer.TextureUnitBind(0, batch->texture);

		// All batches are the same texture, so no issues
		GL_DrawSequentialBatchImpl(batch, 0, batch->count, index_offset, maximum_batch_size);
	}
	else {
		// Group by texture usage
		int start = 0, end = 1;

		R_ApplyRenderingState(batch->rendering_state);
		if (R_TextureReferenceIsValid(batch->textures[start])) {
			renderer.TextureUnitBind(0, batch->textures[start]);
		}
		else {
			renderer.TextureUnitBind(0, solidwhite_texture);
		}
		for (end = 1; end < batch->count; ++end) {
			if (!R_TextureReferenceEqual(batch->textures[start], batch->textures[end])) {
				GL_DrawSequentialBatchImpl(batch, start, end, index_offset, maximum_batch_size);

				R_ApplyRenderingState(batch->rendering_state);
				if (R_TextureReferenceIsValid(batch->textures[end])) {
					renderer.TextureUnitBind(0, batch->textures[end]);
				}
				else {
					renderer.TextureUnitBind(0, solidwhite_texture);
				}
				start = end;
			}
		}

		if (end > start) {
			GL_DrawSequentialBatchImpl(batch, start, end, index_offset, maximum_batch_size);
		}
	}
}

qbool GLC_CompileSpriteProgram(void)
{
	if (R_ProgramRecompileNeeded(r_program_sprites_glc, 0)) {
		char included_definitions[1024];

		memset(included_definitions, 0, sizeof(included_definitions));

		R_ProgramCompileWithInclude(r_program_sprites_glc, included_definitions);
		R_ProgramUniform1i(r_program_uniform_sprites_glc_materialSampler, 0);
		R_ProgramUniform1f(r_program_uniform_sprites_glc_alphaThreshold, 0);
	}

	R_ProgramSetStandardUniforms(r_program_sprites_glc);

	return R_ProgramReady(r_program_sprites_glc);
}

static void GLC_Draw3DSpritesVertexArray(gl_sprite3d_batch_t* batch)
{
	if (batch->count == 1) {
		R_ApplyRenderingState(batch->rendering_state);
		if (R_TextureReferenceIsValid(batch->textures[0])) {
			renderer.TextureUnitBind(0, batch->textures[0]);
		}
		else if (R_TextureReferenceIsValid(batch->texture)) {
			renderer.TextureUnitBind(0, batch->texture);
		}
		else {
			renderer.TextureUnitBind(0, solidwhite_texture);
		}
		GL_DrawArrays(glPrimitiveTypes[batch->primitive_id], batch->glFirstVertices[0], batch->numVertices[0]);
	}
	else if (GL_DrawElementsBaseVertexAvailable() && batch->allSameNumber && batch->numVertices[0] == 4 && batch->primitive_id == r_primitive_triangle_strip) {
		GLC_DrawSequentialBatch(batch, indexes_start_quads, INDEXES_MAX_QUADS);
	}
	else if (GL_DrawElementsBaseVertexAvailable() && batch->allSameNumber && batch->numVertices[0] == 9 && GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
		GLC_DrawSequentialBatch(batch, indexes_start_sparks, INDEXES_MAX_SPARKS);
	}
	else if (GL_DrawElementsBaseVertexAvailable() && batch->allSameNumber && batch->numVertices[0] == 18 && GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
		GLC_DrawSequentialBatch(batch, indexes_start_flashblend, INDEXES_MAX_FLASHBLEND);
	}
	else if (R_TextureReferenceIsValid(batch->texture)) {
		renderer.TextureUnitBind(0, batch->texture);
		R_ApplyRenderingState(batch->rendering_state);

		GL_MultiDrawArrays(glPrimitiveTypes[batch->primitive_id], batch->glFirstVertices, batch->numVertices, batch->count);
	}
	else {
		int first = 0, last = 1;

		R_ApplyRenderingState(batch->rendering_state);
		if (R_TextureReferenceIsValid(batch->textures[0])) {
			renderer.TextureUnitBind(0, batch->textures[0]);
		}
		else {
			renderer.TextureUnitBind(0, solidwhite_texture);
		}

		while (last < batch->count) {
			if (!R_TextureReferenceEqual(batch->textures[first], batch->textures[last])) {
				GL_MultiDrawArrays(glPrimitiveTypes[batch->primitive_id], batch->glFirstVertices, batch->numVertices, last - first);

				if (R_TextureReferenceIsValid(batch->textures[last])) {
					renderer.TextureUnitBind(0, batch->textures[last]);
				}
				else {
					renderer.TextureUnitBind(0, solidwhite_texture);
				}
				first = last;
			}
			++last;
		}

		GL_MultiDrawArrays(glPrimitiveTypes[batch->primitive_id], batch->glFirstVertices, batch->numVertices, last - first);
	}
}

static void GLC_Draw3DSpritesImmediate(gl_sprite3d_batch_t* batch)
{
	int j, k;

	// Immediate mode, no VBOs
	for (j = 0; j < batch->count; ++j) {
		r_sprite3d_vert_t* v;

		R_ApplyRenderingState(batch->rendering_state);
		if (R_TextureReferenceIsValid(batch->textures[j])) {
			renderer.TextureUnitBind(0, batch->textures[j]);
		}
		else {
			renderer.TextureUnitBind(0, batch->texture);
		}

		GLC_Begin(glPrimitiveTypes[batch->primitive_id]);
		v = &verts[batch->firstVertices[j]];
		for (k = 0; k < batch->numVertices[j]; ++k, ++v) {
			glTexCoord2fv(v->tex);
			R_CustomColor4ubv(v->color);
			GLC_Vertex3fv(v->position);
		}
		GLC_End();
	}
}

void GLC_Draw3DSpritesInline(void)
{
	unsigned int i;

	if (!batchCount || !vertexCount || (batchCount == 1 && !batches[0].count)) {
		return;
	}

	if (buffers.supported) {
		extern cvar_t gl_program_sprites;

		if (!R_VertexArrayCreated(vao_3dsprites)) {
			GLC_Create3DSpriteVAO();
		}
		buffers.Update(r_buffer_sprite_vertex_data, vertexCount * sizeof(verts[0]), verts);

		if (gl_program_sprites.integer && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_CompileSpriteProgram()) {
			R_ProgramUse(r_program_sprites_glc);
		}
		else {
			R_ProgramUse(r_program_none);
		}
	}
	else {
		R_ProgramUse(r_program_none);
	}

	for (i = 0; i < batchCount; ++i) {
		gl_sprite3d_batch_t* batch = &batches[i];

		if (!batch->count) {
			continue;
		}

		if (buffers.supported) {
			GLC_Draw3DSpritesVertexArray(batch);
		}
		else {
			GLC_Draw3DSpritesImmediate(batch);
		}

		batch->count = 0;
	}

	R_Sprite3DClearBatches();
	R_ProgramUse(r_program_none);
}

void GLC_DrawSimpleItem(model_t* model, int skin, vec3_t org, float sprsize, vec3_t up, vec3_t right)
{
	texture_ref simpletexture = model->simpletexture[skin];
	r_sprite3d_vert_t* vert = R_Sprite3DAddEntrySpecific(SPRITE3D_ENTITIES, 4, simpletexture, 0);

	if (vert) {
		R_Sprite3DRender(vert, org, up, right, sprsize, -sprsize, -sprsize, sprsize, 1, 1, 0);
	}
}

void GLC_DrawSpriteModel(entity_t* e)
{
	vec3_t right, up;
	mspriteframe_t *frame;
	msprite2_t *psprite;
	r_sprite3d_vert_t* vert;

	// don't even bother culling, because it's just a single
	// polygon without a surface cache
	psprite = (msprite2_t*)Mod_Extradata(e->model);	//locate the proper data
	frame = R_GetSpriteFrame(e, psprite);

	if (!frame || !R_TextureReferenceIsValid(frame->gl_texturenum))
		return;

	if (psprite->type == SPR_ORIENTED) {
		// bullet marks on walls
		AngleVectors(e->angles, NULL, right, up);
	}
	else if (psprite->type == SPR_FACING_UPRIGHT) {
		VectorSet(up, 0, 0, 1);
		right[0] = e->origin[1] - r_origin[1];
		right[1] = -(e->origin[0] - r_origin[0]);
		right[2] = 0;
		VectorNormalizeFast(right);
	}
	else if (psprite->type == SPR_VP_PARALLEL_UPRIGHT) {
		VectorSet(up, 0, 0, 1);
		VectorCopy(vright, right);
	}
	else {	// normal sprite
		VectorCopy(vup, up);
		VectorCopy(vright, right);
	}

	vert = R_Sprite3DAddEntrySpecific(SPRITE3D_ENTITIES, 4, frame->gl_texturenum, 0);
	if (vert) {
		vec3_t points[4];

		VectorMA(e->origin, frame->up, up, points[0]);
		VectorMA(points[0], frame->left, right, points[0]);
		VectorMA(e->origin, frame->down, up, points[1]);
		VectorMA(points[1], frame->left, right, points[1]);
		VectorMA(e->origin, frame->up, up, points[2]);
		VectorMA(points[2], frame->right, right, points[2]);
		VectorMA(e->origin, frame->down, up, points[3]);
		VectorMA(points[3], frame->right, right, points[3]);

		R_Sprite3DSetVert(vert++, points[0][0], points[0][1], points[0][2], 0, 0, color_white, 0);
		R_Sprite3DSetVert(vert++, points[1][0], points[1][1], points[1][2], 0, 1, color_white, 0);
		R_Sprite3DSetVert(vert++, points[2][0], points[2][1], points[2][2], 1, 0, color_white, 0);
		R_Sprite3DSetVert(vert++, points[3][0], points[3][1], points[3][2], 1, 1, color_white, 0);
	}
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_state.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_local.h"
#include "glc_state.h"
#include "glc_vao.h"
#include "r_trace.h"
#include "r_aliasmodel.h"
#include "r_matrix.h"
#include "r_renderer.h"
#include "r_program.h"

extern texture_ref solidskytexture, alphaskytexture;

void GLC_StateBeginFastTurbPoly(byte color[4])
{
	float wateralpha = r_refdef2.wateralpha;
	wateralpha = bound(0, wateralpha, 1);

	R_TraceEnterFunctionRegion;

	// START shaman FIX /gl_turbalpha + /r_fastturb {
	R_CustomColor(color[0] * wateralpha / 255.0f, color[1] * wateralpha / 255.0f, color[2] * wateralpha / 255.0f, wateralpha);
	// END shaman FIX /gl_turbalpha + /r_fastturb {

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginBlendLightmaps(qbool use_buffers)
{
	R_ApplyRenderingState(r_state_world_blend_lightmaps);
}

void GLC_StateBeginCausticsPolys(void)
{
	R_ApplyRenderingState(r_state_world_caustics);
}

// Alias models
void GLC_StateBeginUnderwaterAliasModelCaustics(texture_ref base_texture, texture_ref caustics_texture)
{
	R_ApplyRenderingState(r_state_aliasmodel_caustics);
	renderer.TextureUnitBind(0, base_texture);
	GLC_BeginCausticsTextureMatrix();
	renderer.TextureUnitBind(1, caustics_texture);
}

void GLC_StateEndUnderwaterAliasModelCaustics(void)
{
	GLC_EndCausticsTextureMatrix();
}

void GLC_StateBeginWaterSurfaces(void)
{
	extern cvar_t r_fastturb;
	float wateralpha = r_refdef2.wateralpha;

	if (r_fastturb.integer) {
		if (wateralpha < 1.0) {
			R_ApplyRenderingState(r_state_world_fast_translucent_water);
			R_CustomColor(wateralpha, wateralpha, wateralpha, wateralpha);
		}
		else {
			R_ApplyRenderingState(r_state_world_fast_opaque_water);
		}
	}
	else {
		if (wateralpha < 1.0) {
			R_ApplyRenderingState(r_state_world_translucent_water);
			R_CustomColor(wateralpha, wateralpha, wateralpha, wateralpha);
		}
		else {
			R_ApplyRenderingState(r_state_world_opaque_water);
		}
	}
}

void GLC_StateBeginAlphaChain(void)
{
	R_ApplyRenderingState(r_state_world_alpha_surfaces);
}

void GLC_StateBeginAlphaChainSurface(msurface_t* s)
{
	texture_t* t = s->texinfo->texture;

	R_TraceEnterFunctionRegion;

	//bind the world texture
	renderer.TextureUnitBind(0, t->gl_texturenum);
	if (gl_mtexable) {
		renderer.TextureUnitBind(1, GLC_LightmapTexture(s->lightmaptexturenum));
	}

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginRenderFullbrights(void)
{
	R_ApplyRenderingState(r_state_world_fullbrights);
}

void GLC_StateBeginRenderLumas(void)
{
	R_ApplyRenderingState(r_state_world_lumas);
}

void GLC_StateBeginEmitDetailPolys(void)
{
	extern texture_ref detailtexture;

	R_ApplyRenderingState(r_state_world_details);
	renderer.TextureUnitBind(0, detailtexture);
}

void GLC_StateBeginDrawMapOutline(void)
{
	R_ApplyRenderingState(r_state_world_outline);
}

void GLC_StateBeginAliasPowerupShell(qbool weapon)
{
	extern texture_ref shelltexture;

	R_ApplyRenderingState(weapon ? r_state_weaponmodel_powerupshell : r_state_aliasmodel_powerupshell);
	renderer.TextureUnitBind(0, shelltexture);
}

void GLC_StateBeginMD3Draw(float alpha, qbool textured, qbool weapon, qbool additive_pass)
{
	qbool transparent = (alpha < 1);

	if (additive_pass) {
		R_ApplyRenderingState(weapon ? r_state_weaponmodel_singletexture_additive : textured ? r_state_aliasmodel_singletexture_additive : r_state_aliasmodel_notexture_additive);
	}
	else if (weapon) {
		R_ApplyRenderingState(transparent ? r_state_weaponmodel_singletexture_transparent : r_state_weaponmodel_singletexture_opaque);
	}
	else if (textured) {
		R_ApplyRenderingState(transparent ? r_state_aliasmodel_singletexture_transparent : r_state_aliasmodel_singletexture_opaque);
	}
	else {
		R_ApplyRenderingState(transparent ? r_state_aliasmodel_notexture_transparent : r_state_aliasmodel_notexture_opaque);
	}
}

void GLC_StateBeginDrawAliasZPass(qbool weapon_model)
{
	R_ApplyRenderingState(weapon_model ? r_state_weaponmodel_transparent_zpass : r_state_aliasmodel_transparent_zpass);
}

void GLC_StateBeginDrawAliasFrameProgram(texture_ref texture, texture_ref fb_texture, int render_effects, struct custom_model_color_s* custom_model, float ent_alpha, qbool additive_pass)
{
	qbool weapon_model = render_effects & RF_WEAPONMODEL;
	qbool alpha_blend = (render_effects & RF_ALPHABLEND) || ent_alpha < 1;
	qbool no_texture = !weapon_model && (!R_TextureReferenceIsValid(texture) || (custom_model && custom_model->fullbright_cvar.integer));
	qbool multi_texture = custom_model == NULL && R_TextureReferenceIsValid(fb_texture);

	R_TraceEnterFunctionRegion;

	if (no_texture) {
		R_ApplyRenderingState(additive_pass ? r_state_aliasmodel_notexture_additive : alpha_blend ? r_state_aliasmodel_notexture_transparent : r_state_aliasmodel_notexture_opaque);
	}
	else if (multi_texture) {
		// meag: no additive_pass here yet as .mdl has multitexture, .md3 has additive surfaces
		if (weapon_model) {
			R_ApplyRenderingState(alpha_blend ? r_state_weaponmodel_multitexture_transparent : r_state_weaponmodel_multitexture_opaque);
		}
		else {
			R_ApplyRenderingState(alpha_blend ? r_state_aliasmodel_multitexture_transparent : r_state_aliasmodel_multitexture_opaque);
		}
		renderer.TextureUnitBind(0, texture);
		if (render_effects & RF_CAUSTICS) {
			GLC_BeginCausticsTextureMatrix();
		}
		renderer.TextureUnitBind(1, fb_texture);
	}
	else {
		if (weapon_model) {
			R_ApplyRenderingState(additive_pass ? r_state_weaponmodel_singletexture_additive : alpha_blend ? r_state_weaponmodel_singletexture_transparent : r_state_weaponmodel_singletexture_opaque);
		}
		else {
			R_ApplyRenderingState(additive_pass ? r_state_aliasmodel_singletexture_additive : alpha_blend ? r_state_aliasmodel_singletexture_transparent : r_state_aliasmodel_singletexture_opaque);
		}
		renderer.TextureUnitBind(0, texture);
	}

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginDrawAliasFrame(texture_ref texture, texture_ref fb_texture, qbool mtex, qbool alpha_blend, struct custom_model_color_s* custom_model, qbool weapon_model)
{
	R_TraceEnterFunctionRegion;

	if (!weapon_model && (!R_TextureReferenceIsValid(texture) || (custom_model && (custom_model->fullbright_cvar.integer || custom_model->disable_texturing)))) {
		R_ApplyRenderingState(alpha_blend ? r_state_aliasmodel_notexture_transparent : r_state_aliasmodel_notexture_opaque);
	}
	else if (custom_model == NULL && R_TextureReferenceIsValid(fb_texture) && mtex) {
		R_ApplyRenderingState(weapon_model ? (alpha_blend ? r_state_weaponmodel_multitexture_transparent : r_state_weaponmodel_multitexture_opaque) : (alpha_blend ? r_state_aliasmodel_multitexture_transparent : r_state_aliasmodel_multitexture_opaque));
		renderer.TextureUnitBind(0, texture);
		renderer.TextureUnitBind(1, fb_texture);
	}
	else {
		R_ApplyRenderingState(weapon_model ? (alpha_blend ? r_state_weaponmodel_singletexture_transparent : r_state_weaponmodel_singletexture_opaque) : (alpha_blend ? r_state_aliasmodel_singletexture_transparent : r_state_aliasmodel_singletexture_opaque));
		renderer.TextureUnitBind(0, texture);
	}

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginAliasModelShadow(void)
{
	R_ApplyRenderingState(r_state_aliasmodel_shadows);
}

#ifdef WITH_RENDERING_TRACE
static int glcVertsPerPrimitive = 0;
static int glcBaseVertsPerPrimitive = 0;
static int glcVertsSent = 0;
static const char* glcPrimitiveName = "?";
#endif

void GLC_Begin(GLenum primitive)
{
#ifdef WITH_RENDERING_TRACE
	glcVertsSent = 0;
	glcVertsPerPrimitive = 0;
	glcBaseVertsPerPrimitive = 0;
	glcPrimitiveName = "?";

	GL_ProcessErrors("glBegin");
	switch (primitive) {
		case GL_QUADS:
			glcVertsPerPrimitive = 4;
			glcBaseVertsPerPrimitive = 0;
			glcPrimitiveName = "GL_QUADS";
			break;
		case GL_POLYGON:
			glcVertsPerPrimitive = 0;
			glcBaseVertsPerPrimitive = 0;
			glcPrimitiveName = "GL_POLYGON";
			break;
		case GL_TRIANGLE_FAN:
			glcVertsPerPrimitive = 1;
			glcBaseVertsPerPrimitive = 2;
			glcPrimitiveName = "GL_TRIANGLE_FAN";
			break;
		case GL_TRIANGLE_STRIP:
			glcVertsPerPrimitive = 1;
			glcBaseVertsPerPrimitive = 2;
			glcPrimitiveName = "GL_TRIANGLE_STRIP";
			break;
		case GL_LINE_LOOP:
			glcVertsPerPrimitive = 1;
			glcBaseVertsPerPrimitive = 1;
			glcPrimitiveName = "GL_LINE_LOOP";
			break;
		case GL_LINES:
			glcVertsPerPrimitive = 2;
			glcBaseVertsPerPrimitive = 0;
			glcPrimitiveName = "GL_LINES";
			break;
	}
#endif

	++frameStats.draw_calls;
	glBegin(primitive);
	R_TraceLogAPICall("glBegin(%s...)", glcPrimitiveName);
}

#undef glEnd

void GLC_End(void)
{
#ifdef WITH_RENDERING_TRACE
	int primitives;
	const char* count_name = "vertices";
#endif

	glEnd();

#ifdef WITH_RENDERING_TRACE
	primitives = max(0, glcVertsSent - glcBaseVertsPerPrimitive);
	if (glcVertsPerPrimitive) {
		primitives = glcVertsSent / glcVertsPerPrimitive;
		count_name = "primitives";
	}
	R_TraceLogAPICall("glEnd(%s: %d %s)", glcPrimitiveName, primitives, count_name);
	GL_ProcessErrors("glEnd");
#endif
}

void GLC_Vertex2f(GLfloat x, GLfloat y)
{
	glVertex2f(x, y);
#ifdef WITH_RENDERING_TRACE
	++glcVertsSent;
#endif
}

void GLC_Vertex2fv(const GLfloat* v)
{
	glVertex2fv(v);
#ifdef WITH_RENDERING_TRACE
	++glcVertsSent;
#endif
}

void GLC_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
{
	glVertex3f(x, y, z);
#ifdef WITH_RENDERING_TRACE
	++glcVertsSent;
#endif
}

void GLC_Vertex3fv(const GLfloat* v)
{
	glVertex3fv(v);
#ifdef WITH_RENDERING_TRACE
	++glcVertsSent;
#endif
}

void GLC_InitialiseSkyStates(void)
{
	rendering_state_t* state;

	state = R_InitRenderingState(r_state_sky_fast, true, "fastSkyState", vao_brushmodel);
	state->depth.test_enabled = false;

	state = R_InitRenderingState(r_state_skybox, true, "glcSkyBox", vao_brushmodel);
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);

	state = R_CopyRenderingState(r_state_sky_fast_bmodel, r_state_sky_fast, "fastSkyState_bmodel");
	state->depth.test_enabled = true;

	state = R_InitRenderingState(r_state_skydome_zbuffer_pass, true, "skyDomeZPassState", vao_brushmodel);
	state->depth.test_enabled = true;
	state->blendingEnabled = true;
	state->fog.mode = r_fogmode_disabled;
	state->colorMask[0] = state->colorMask[1] = state->colorMask[2] = state->colorMask[3] = false;
	state->blendFunc = r_blendfunc_src_zero_dest_one;

	state = R_InitRenderingState(r_state_skydome_zbuffer_pass_fogged, true, "skyDomeZPassFoggedState", vao_brushmodel);
	state->depth.test_enabled = true;
	state->blendingEnabled = true;
	state->fog.mode = r_fogmode_enabled;
	state->blendFunc = r_blendfunc_src_one_dest_zero;

	state = R_InitRenderingState(r_state_skydome_background_pass, true, "skyDomeFirstPassState", vao_none);
	state->depth.test_enabled = false;
	state->blendingEnabled = false;
	state->textureUnits[0].enabled = true;
	state->textureUnits[0].mode = r_texunit_mode_replace;

	state = R_CopyRenderingState(r_state_skydome_background_pass_bmodel, r_state_skydome_background_pass, "skyDomeFirstPassState_bmodel");
	state->depth.test_enabled = true;

	state = R_InitRenderingState(r_state_skydome_cloud_pass, true, "skyDomeCloudPassState", vao_none);
	state->depth.test_enabled = false;
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->textureUnits[0].enabled = true;
	state->textureUnits[0].mode = r_texunit_mode_replace;

	state = R_CopyRenderingState(r_state_skydome_cloud_pass_bmodel, r_state_skydome_cloud_pass, "skyDomeCloudPassState_bmodel");
	state->depth.test_enabled = true;

	// Used when rendering the skydome/cloud background, prior to z-pass
	state = R_InitRenderingState(r_state_skydome_single_pass, true, "skyDomeSinglePassState", vao_brushmodel);
	state->depth.test_enabled = false;
	state->blendingEnabled = false;
	state->textureUnits[0].enabled = true;
	state->textureUnits[0].mode = r_texunit_mode_replace;
	state->textureUnits[1].enabled = true;
	state->textureUnits[1].mode = r_texunit_mode_decal;

	// Used when rendering the polys directly (like r_fastsky) but texturing
	state = R_CopyRenderingState(r_state_skydome_single_pass_program, r_state_skydome_single_pass, "skyDomeSinglePass(program)");
	state->depth.test_enabled = true;

	// Deliberately not using r_state_skydome_single_pass_program just so we can tie it to vbo etc in future
	state = R_CopyRenderingState(r_state_skydome_single_pass_bmodel, r_state_skydome_single_pass, "skyDomeSinglePass(bmodel)");
	state->depth.test_enabled = true;
}

void GLC_StateBeginFastSky(qbool world)
{
	R_TraceEnterFunctionRegion;

	R_ApplyRenderingState(world ? r_state_sky_fast : r_state_sky_fast_bmodel);
	R_CustomColor(r_refdef2.fog_skycolor[0], r_refdef2.fog_skycolor[1], r_refdef2.fog_skycolor[2], 1.0f);

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginSkyZBufferPass(void)
{
	R_TraceEnterFunctionRegion;

	if (r_refdef2.fog_render && r_refdef2.fog_sky > 0) {
		R_ApplyRenderingState(r_state_skydome_zbuffer_pass_fogged);
		R_CustomColor(r_refdef2.fog_color[0], r_refdef2.fog_color[1], r_refdef2.fog_color[2], 1);
	}
	else {
		R_ApplyRenderingState(r_state_skydome_zbuffer_pass);
	}

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginSingleTextureSkyDome(void)
{
	R_TraceEnterFunctionRegion;

	R_ApplyRenderingState(r_state_skydome_background_pass);
	renderer.TextureUnitBind(0, solidskytexture);

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginSingleTextureSkyDomeCloudPass(void)
{
	R_TraceEnterFunctionRegion;

	R_ApplyRenderingState(r_state_skydome_cloud_pass);
	renderer.TextureUnitBind(0, alphaskytexture);

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginMultiTextureSkyDome(qbool use_program)
{
	R_TraceEnterFunctionRegion;

	R_ApplyRenderingState(use_program ? r_state_skydome_single_pass_program : r_state_skydome_single_pass);
	renderer.TextureUnitBind(0, solidskytexture);
	renderer.TextureUnitBind(1, alphaskytexture);

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginMultiTextureSkyChain(void)
{
	R_TraceEnterFunctionRegion;

	R_ApplyRenderingState(r_state_skydome_single_pass_bmodel);
	renderer.TextureUnitBind(0, solidskytexture);
	renderer.TextureUnitBind(1, alphaskytexture);

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginSingleTextureSkyPass(void)
{
	R_TraceEnterFunctionRegion;

	R_ApplyRenderingState(r_state_skydome_background_pass_bmodel);
	renderer.TextureUnitBind(0, solidskytexture);

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginSingleTextureCloudPass(void)
{
	R_TraceEnterFunctionRegion;

	R_ApplyRenderingState(r_state_skydome_cloud_pass_bmodel);
	renderer.TextureUnitBind(0, alphaskytexture);

	R_TraceLeaveFunctionRegion;
}

void GLC_StateBeginBrightenScreen(void)
{
	R_ApplyRenderingState(r_state_brighten_screen);
}

void GLC_StateBeginDrawAlphaPieSliceRGB(float thickness)
{
	// Same as lineState
	R_ApplyRenderingState(r_state_line);
	if (thickness > 0.0) {
		R_CustomLineWidth(thickness);
	}
}

void GLC_StateBeginBloomDraw(texture_ref texture)
{
	R_ApplyRenderingState(r_state_postprocess_bloom_draweffect);
	R_CustomColor(r_bloom_alpha.value, r_bloom_alpha.value, r_bloom_alpha.value, 1.0f);
	renderer.TextureUnitBind(0, texture);
}

void GLC_StateBeginImageDraw(qbool is_text)
{
	extern cvar_t gl_alphafont;

	if (is_text && !gl_alphafont.integer) {
		R_ApplyRenderingState(r_state_hud_images_alphatested_glc);
	}
	else {
		R_ApplyRenderingState(r_state_hud_images_glc);
	}
}

void GLC_StateBeginImageDrawNonGLSL(qbool is_text)
{
	extern cvar_t gl_alphafont;

	if (is_text && !gl_alphafont.integer) {
		R_ApplyRenderingState(r_state_hud_images_alphatested_glc_non_glsl);
	}
	else {
		R_ApplyRenderingState(r_state_hud_images_glc_non_glsl);
	}
}

void GLC_StateBeginAliasOutlineFrame(qbool weaponmodel)
{
	R_ApplyRenderingState(weaponmodel ? r_state_weaponmodel_outline : r_state_aliasmodel_outline);
	R_GLC_DisableColorPointer();
	R_CustomColor(0, 0, 0, 1);
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_state.h
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_GLC_STATE_HEADER
#define EZQUAKE_GLC_STATE_HEADER

#include "r_state.h"

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
void R_GLC_TextureUnitSet(rendering_state_t* state, int index, qbool enabled, r_texunit_mode_t mode);
void GLC_InitialiseSkyStates(void);
void GLC_CustomAlphaTesting(qbool enabled);
void R_GLC_ConfigureAlphaTesting(rendering_state_t* state, qbool enabled, r_alphatest_func_t func, float value);
#define R_GLC_EnableAlphaTesting(state) { state->alphaTesting.enabled = true; }
#define R_GLC_DisableAlphaTesting(state) { state->alphaTesting.enabled = false; }

void R_GLC_DisableColorPointer(void);
void R_GLC_DisableTexturePointer(int unit);
#else
#define R_GLC_TextureUnitSet(...)
#define R_GLC_ConfigureAlphaTesting(...)
#define GLC_CustomAlphaTesting(...)
#define R_GLC_EnableAlphaTesting(...)
#define R_GLC_DisableAlphaTesting(...)
#endif // RENDERER_OPTION_CLASSIC_OPENGL

#endif // EZQUAKE_GLC_STATE_HEADER


================================================
FILE: src/glc_surf.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// glc_surf.c: classic surface-related refresh code
#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "rulesets.h"
#include "utils.h"
#include "tr_types.h"
#include "r_texture.h"
#include "r_vao.h"
#include "glc_local.h"
#include "r_brushmodel.h"
#include "r_renderer.h"
#include "r_program.h"
#include "r_lightmaps.h"

// This is a chain of polys, only used in classic when multi-texturing not available
glpoly_t *fullbright_polys[MAX_GLTEXTURES];
glpoly_t *luma_polys[MAX_GLTEXTURES];

extern glpoly_t *caustics_polys;
extern glpoly_t *detail_polys;

void GLC_ClearLightmapPolys(void);

void GLC_ClearTextureChains(void)
{
	GLC_ClearLightmapPolys();
	memset(fullbright_polys, 0, sizeof(fullbright_polys));
	memset(luma_polys, 0, sizeof(luma_polys));
}

void GLC_DrawChainOutline(msurface_t* surf, qbool texture_chains)
{
	msurface_t* prev;
	msurface_t* s = surf;

	while (s) {
		int front = 0, back = s->polys->numverts - 1;

		GLC_Begin(GL_LINE_LOOP);
		while (front < back) {
			GLC_Vertex3fv(s->polys->verts[front]);
			front += 2;
		}
		while (back > 0) {
			GLC_Vertex3fv(s->polys->verts[back]);
			back -= 2;
		}
		GLC_End();

		prev = s;
		if (texture_chains) {
			s = s->texturechain;
			prev->texturechain = NULL;
		}
		else {
			s = s->drawflatchain;
			prev->drawflatchain = NULL;
		}
	}
}

void GLC_DrawMapOutline(model_t *model)
{
	int i;
	unsigned int lightmap_count;

	if (!(model->isworldmodel && r_refdef2.drawWorldOutlines)) {
		return;
	}

	lightmap_count = R_LightmapCount();
	GLC_StateBeginDrawMapOutline();
	for (i = 0; i < model->numtextures; i++) {
		texture_t* t;

		if (!model->textures[i] || !model->textures[i]->texturechain) {
			continue;
		}

		t = R_TextureAnimation(NULL, model->textures[i]);
		GLC_DrawChainOutline(t->texturechain, true);
	}
	GLC_DrawChainOutline(model->drawflat_chain, false);
	for (i = 0; i < lightmap_count; ++i) {
		GLC_DrawChainOutline(R_DrawflatLightmapChain(i), false);
		R_ClearDrawflatLightmapChain(i);
	}
}

static void DrawGLPoly(glpoly_t *p)
{
	int i;
	float *v;

	GLC_Begin(GL_TRIANGLE_STRIP);
	v = p->verts[0];
	for (i = 0; i < p->numverts; i++, v += VERTEXSIZE) {
		glTexCoord2f(v[3], v[4]);
		GLC_Vertex3fv(v);
	}
	GLC_End();
}

unsigned int GLC_DrawIndexedPoly(glpoly_t* p, unsigned int* modelIndexes, unsigned int modelIndexMaximum, unsigned int index_count)
{
	int k;

	if (GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
		if (index_count + 1 + p->numverts > modelIndexMaximum) {
			GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
			index_count = 0;
		}

		if (index_count) {
			modelIndexes[index_count++] = ~(GLuint)0;
		}
	}
	else {
		if (index_count + 3 + p->numverts > modelIndexMaximum) {
			GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
			index_count = 0;
		}

		if (index_count) {
			int prev = index_count - 1;
			if (index_count % 2 == 1) {
				modelIndexes[index_count++] = modelIndexes[prev];
			}
			modelIndexes[index_count++] = modelIndexes[prev];
			modelIndexes[index_count++] = p->vbo_start;
		}
	}

	for (k = 0; k < p->numverts; ++k) {
		modelIndexes[index_count++] = p->vbo_start + k;
	}

	return index_count;
}

void GLC_RenderFullbrights_GLSL(void)
{
	int i;
	glpoly_t *p;
	texture_ref texture;

	GLC_StateBeginRenderFullbrights();
	R_ProgramUse(r_program_world_secondpass_glc);

	for (i = 1; i < MAX_GLTEXTURES; i++) {
		int index_count = 0;

		if (!fullbright_polys[i]) {
			continue;
		}

		texture.index = i;
		renderer.TextureUnitBind(0, texture);

		for (p = fullbright_polys[i]; p; p = p->fb_chain) {
			index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
		}

		if (index_count) {
			GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
			index_count = 0;
		}
		fullbright_polys[i] = NULL;
	}
}

void GLC_RenderFullbrights(void)
{
	int i;
	glpoly_t *p;
	texture_ref texture;

	GLC_StateBeginRenderFullbrights();

	for (i = 1; i < MAX_GLTEXTURES; i++) {
		if (!fullbright_polys[i]) {
			continue;
		}

		texture.index = i;
		renderer.TextureUnitBind(0, texture);
		if (R_VAOBound()) {
			int index_count = 0;

			for (p = fullbright_polys[i]; p; p = p->fb_chain) {
				index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
			}

			if (index_count) {
				GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
			}
		}
		else {
			for (p = fullbright_polys[i]; p; p = p->fb_chain) {
				DrawGLPoly(p);
			}
		}
		fullbright_polys[i] = NULL;
	}
}

void GLC_RenderLumas_GLSL(void)
{
	int i;
	glpoly_t *p;
	texture_ref texture;
	int index_count = 0;

	GLC_StateBeginRenderLumas();
	R_ProgramUse(r_program_world_secondpass_glc);

	for (i = 1; i < MAX_GLTEXTURES; i++) {
		if (!luma_polys[i]) {
			continue;
		}

		texture.index = i;
		renderer.TextureUnitBind(0, texture);

		for (p = luma_polys[i]; p; p = p->luma_chain) {
			index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
		}

		if (index_count) {
			GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
		}
		luma_polys[i] = NULL;
	}
}

void GLC_RenderLumas(void)
{
	int i;
	glpoly_t *p;
	texture_ref texture;
	qbool use_vbo = buffers.supported && modelIndexes;

	GLC_StateBeginRenderLumas();

	for (i = 1; i < MAX_GLTEXTURES; i++) {
		if (!luma_polys[i]) {
			continue;
		}

		texture.index = i;
		renderer.TextureUnitBind(0, texture);
		if (use_vbo) {
			int index_count = 0;

			for (p = luma_polys[i]; p; p = p->luma_chain) {
				index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
			}

			if (index_count) {
				GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
			}
		}
		else {
			for (p = luma_polys[i]; p; p = p->luma_chain) {
				DrawGLPoly(p);
			}
		}
		luma_polys[i] = NULL;
	}
}

void GLC_EmitDetailPolys_GLSL(void)
{
	glpoly_t *p;
	GLuint index_count = 0;

	if (!detail_polys) {
		return;
	}

	GLC_StateBeginEmitDetailPolys();
	R_ProgramUse(r_program_world_secondpass_glc);

	for (p = detail_polys; p; p = p->detail_chain) {
		index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
	}

	R_ProgramUse(r_program_none);
	detail_polys = NULL;
}

void GLC_EmitDetailPolys(qbool use_vbo)
{
	glpoly_t *p;
	int i;
	float *v;
	GLuint index_count = 0;

	if (!detail_polys) {
		return;
	}

	GLC_StateBeginEmitDetailPolys();

	for (p = detail_polys; p; p = p->detail_chain) {
		if (use_vbo) {
			index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
		}
		else {
			GLC_Begin(GL_TRIANGLE_STRIP);
			v = p->verts[0];
			for (i = 0; i < p->numverts; i++, v += VERTEXSIZE) {
				glTexCoord2f(v[7], v[8]);
				GLC_Vertex3fv(v);
			}
			GLC_End();
		}
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
	}

	detail_polys = NULL;
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_turb_surface.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// glc_turb_surface.c: surface-related refresh code
#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "glc_local.h"
#include "rulesets.h"
#include "utils.h"
#include "r_brushmodel.h"
#include "r_renderer.h"
#include "tr_types.h"
#include "r_program.h"

extern msurface_t* waterchain;
void GLC_EmitWaterPoly(msurface_t* fa);

#define TURBFLAGS_FLATCOLOR           (1 << 0)
#define TURBFLAGS_FOG_LINEAR          (1 << 1)
#define TURBFLAGS_FOG_EXP             (1 << 2)
#define TURBFLAGS_FOG_EXP2            (1 << 3)
#define TURBFLAGS_FOG_ENABLED         (TURBFLAGS_FOG_LINEAR | TURBFLAGS_FOG_EXP | TURBFLAGS_FOG_EXP2)

qbool GLC_TurbSurfaceProgramCompile(void)
{
	extern cvar_t r_fastturb;
	int option = (r_fastturb.integer ? TURBFLAGS_FLATCOLOR : 0);

	if (R_ProgramRecompileNeeded(r_program_turb_glc, option)) {
		char included_definitions[512];

		included_definitions[0] = '\0';

		if (option & TURBFLAGS_FLATCOLOR) {
			strlcat(included_definitions, "#define FLAT_COLOR\n", sizeof(included_definitions));
		}

		R_ProgramCompileWithInclude(r_program_turb_glc, included_definitions);
		R_ProgramUniform1i(r_program_uniform_turb_glc_texSampler, 0);
		R_ProgramSetCustomOptions(r_program_turb_glc, option);
	}

	R_ProgramSetStandardUniforms(r_program_turb_glc);

	return R_ProgramReady(r_program_turb_glc);
}

static void GLC_DrawWaterSurfaces_Program(void)
{
	qbool use_vbo = buffers.supported && modelIndexes;
	msurface_t* fa;
	texture_ref prev_tex = null_texture_reference;
	int index_count = 0;
	float water_alpha = r_refdef2.wateralpha;
	qbool textured = !(R_ProgramCustomOptions(r_program_turb_glc) & TURBFLAGS_FLATCOLOR);

	R_ProgramUse(r_program_turb_glc);
	if (textured) {
		R_ProgramUniform1f(r_program_uniform_turb_glc_time, cl.time);
		R_ProgramUniform1f(r_program_uniform_turb_glc_alpha, water_alpha);
	}

	for (fa = waterchain; fa; fa = fa->texturechain) {
		glpoly_t *p;

		if (!R_TextureReferenceEqual(fa->texinfo->texture->gl_texturenum, prev_tex)) {
			prev_tex = fa->texinfo->texture->gl_texturenum;

			if (index_count) {
				GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
				index_count = 0;
			}
			if (textured) {
				renderer.TextureUnitBind(0, prev_tex);
			}
			else {
				byte* base = SurfaceFlatTurbColor(fa->texinfo->texture);
				float color[4];

				color[0] = (base[0] / 255.0f) * water_alpha;
				color[1] = (base[1] / 255.0f) * water_alpha;
				color[2] = (base[2] / 255.0f) * water_alpha;
				color[3] = water_alpha;

				R_ProgramUniform4fv(r_program_uniform_turb_glc_color, color);
			}
		}

		if (use_vbo) {
			for (p = fa->polys; p; p = p->next) {
				index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
			}
		}
		else {
			GLC_EmitWaterPoly(fa);
		}
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
	}
	R_ProgramUse(r_program_none);
}

static void GLC_DrawWaterSurfaces_Immediate(void)
{
	msurface_t *s;

	for (s = waterchain; s; s = s->texturechain) {
		renderer.TextureUnitBind(0, s->texinfo->texture->gl_texturenum);

		GLC_EmitWaterPoly(s);
	}
}

void GLC_DrawWaterSurfaces(void)
{
	extern cvar_t gl_program_turbsurfaces;

	if (!waterchain) {
		return;
	}

	R_TraceEnterRegion(__func__, true);
	GLC_StateBeginWaterSurfaces();

	if (gl_program_turbsurfaces.integer && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_TurbSurfaceProgramCompile()) {
		GLC_DrawWaterSurfaces_Program();
	}
	else {
		GLC_DrawWaterSurfaces_Immediate();
	}

	R_TraceLeaveRegion(true);

	waterchain = NULL;
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_vao.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_vao.h"
#include "glc_state.h"
#include "glc_vao.h"
#include "r_buffers.h"
#include "r_program.h"

GL_StaticProcedureDeclaration(glVertexAttribPointer, "index=%u, size=%d, type=%u, normalized=%d, stride=%d, pointer=%p", GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer)
GL_StaticProcedureDeclaration(glDisableVertexAttribArray, "index=%u", GLuint index)
GL_StaticProcedureDeclaration(glEnableVertexAttribArray, "index=%u", GLuint index)

void R_GLC_TexturePointer(r_buffer_id buffer_id, int unit, qbool enabled, int size, GLenum type, int stride, void* pointer_or_offset);
void R_GLC_ColorPointer(r_buffer_id buffer_id, qbool enabled, int size, GLenum type, int stride, void* pointer_or_offset);
void R_GLC_VertexPointer(r_buffer_id buffer_id, qbool enabled, int size, GLenum type, int stride, void* pointer_or_offset);
void R_GLC_NormalPointer(r_buffer_id buffer_id, qbool enabled, int size, GLenum type, int stride, void* pointer_or_offset);

// GLC uses vertex array, all client state
typedef struct {
	qbool enabled;

	int size;
	unsigned int type;
	int stride;
	void* pointer_or_offset;
} glc_va_element;

typedef struct glc_va_attribute_s {
	qbool enabled;

	r_program_attribute_id attr_id;
	GLint size;
	GLenum type;
	GLboolean normalized;
	GLsizei stride;
	const GLvoid* pointer;
} glc_va_attribute_t;

typedef struct glc_vao_s {
	qbool initialised;
	r_buffer_id vertex_buffer;
	r_buffer_id element_index_buffer;

	glc_va_element vertex_array;
	glc_va_element normal_array;
	glc_va_element color_array;
	glc_va_element texture_array[MAX_GLC_TEXTURE_UNIT_STATES];
	glc_va_attribute_t attributes[MAX_GLC_ATTRIBUTES];
} glc_vao_t;

static glc_vao_t vaos[vao_count];

qbool GLC_InitialiseVAOHandling(void)
{
	qbool vaos_supported = true;

	memset(&vaos, 0, sizeof(vaos));

	if (COM_CheckParm(cmdline_param_client_novao)) {
		GL_InvalidateFunction(glEnableVertexAttribArray);
		GL_InvalidateFunction(glDisableVertexAttribArray);
		GL_InvalidateFunction(glVertexAttribPointer);
		return false;
	}

	// OpenGL 2.0
	GL_LoadMandatoryFunctionExtension(glEnableVertexAttribArray, vaos_supported);
	GL_LoadMandatoryFunctionExtension(glDisableVertexAttribArray, vaos_supported);
	GL_LoadMandatoryFunctionExtension(glVertexAttribPointer, vaos_supported);

	R_TraceAPI("VAOs supported: %s", vaos_supported ? "yes" : "no (!)");

	return vaos_supported;
}

static glc_attribute_t attributes[MAX_GLC_ATTRIBUTES];

void GLC_BindVertexArrayAttributes(r_vao_id vao)
{
	int i;
	for (i = 0; i < MAX_GLC_ATTRIBUTES; ++i) {
		glc_va_attribute_t* attr = &vaos[vao].attributes[i];

		if (attr->enabled && R_ProgramInUse() == R_ProgramForAttribute(attr->attr_id)) {
			GLint location = R_ProgramAttributeLocation(attr->attr_id);

			if (location >= 0) {
				GL_Procedure(glEnableVertexAttribArray, location);
				GL_Procedure(glVertexAttribPointer, location, attr->size, attr->type, attr->normalized ? GL_TRUE : GL_FALSE, attr->stride, attr->pointer);
				attributes[i].location = location;
				attributes[i].enabled = true;
			}
			else {
				GL_Procedure(glDisableVertexAttribArray, attributes[i].location);
				attributes[i].enabled = false;
			}
		}
		else {
			GL_Procedure(glDisableVertexAttribArray, attributes[i].location);
			attributes[i].enabled = false;
		}
	}
}

void GLC_BindVertexArray(r_vao_id vao)
{
	glc_va_element* vertexes = &vaos[vao].vertex_array;
	glc_va_element* colors = &vaos[vao].color_array;
	glc_va_element* normals = &vaos[vao].normal_array;
	r_buffer_id buf = vaos[vao].vertex_buffer;
	int i;

	// Unbind any active attributes
	for (i = 0; i < MAX_GLC_ATTRIBUTES; ++i) {
		if (attributes[i].enabled) {
			GL_Procedure(glDisableVertexAttribArray, attributes[i].location);
			attributes[i].enabled = false;
		}
	}

	R_GLC_VertexPointer(buf, vertexes->enabled, vertexes->size, vertexes->type, vertexes->stride, vertexes->pointer_or_offset);
	R_GLC_ColorPointer(buf, colors->enabled, colors->size, colors->type, colors->stride, colors->pointer_or_offset);
	R_GLC_NormalPointer(buf, normals->enabled, normals->size, normals->type, normals->stride, normals->pointer_or_offset);
	for (i = 0; i < sizeof(vaos[vao].texture_array) / sizeof(vaos[vao].texture_array[0]); ++i) {
		glc_va_element* textures = &vaos[vao].texture_array[i];

		if (i < gl_textureunits) {
			R_GLC_TexturePointer(buf, i, textures->enabled, textures->size, textures->type, textures->stride, textures->pointer_or_offset);
		}
	}

	for (i = 0; i < MAX_GLC_ATTRIBUTES; ++i) {
		glc_va_attribute_t* attr = &vaos[vao].attributes[i];

		if (attr->enabled && R_ProgramInUse() == R_ProgramForAttribute(attr->attr_id)) {
			GLint location = R_ProgramAttributeLocation(attr->attr_id);

			if (location >= 0) {
				GL_Procedure(glEnableVertexAttribArray, location);
				GL_Procedure(glVertexAttribPointer, location, attr->size, attr->type, attr->normalized ? GL_TRUE : GL_FALSE, attr->stride, attr->pointer);
				attributes[i].location = location;
				attributes[i].enabled = true;
			}
		}
	}

	if (R_BufferReferenceIsValid(vaos[vao].element_index_buffer)) {
		buffers.Bind(vaos[vao].element_index_buffer);
	}
	else {
		buffers.UnBind(buffertype_index);
	}
}

qbool GLC_VertexArrayCreated(r_vao_id vao)
{
	return vaos[vao].initialised;
}

void GLC_GenVertexArray(r_vao_id vao, const char* name)
{
	memset(&vaos[vao], 0, sizeof(vaos[vao]));
	vaos[vao].initialised = true;
}

void GLC_DeleteVAOs(void)
{
	memset(vaos, 0, sizeof(vaos));
}

static void GLC_VAOEnableComponent(glc_va_element* el, int size, GLenum type, GLsizei stride, GLvoid* pointer)
{
	el->enabled = true;
	el->size = size;
	el->stride = stride;
	el->type = type;
	el->pointer_or_offset = pointer;
}

static void GLC_VAODisableComponent(glc_va_element* el)
{
	el->enabled = false;
}

void GLC_VAOEnableVertexPointer(r_vao_id vao, int size, GLenum type, GLsizei stride, GLvoid* pointer)
{
	GLC_VAOEnableComponent(&vaos[vao].vertex_array, size, type, stride, pointer);
}

void GLC_VAODisableVertexPointer(r_vao_id vao)
{
	GLC_VAODisableComponent(&vaos[vao].vertex_array);
}

void GLC_VAOEnableNormalPointer(r_vao_id vao, int size, GLenum type, GLsizei stride, GLvoid* pointer)
{
	GLC_VAOEnableComponent(&vaos[vao].normal_array, size, type, stride, pointer);
}

void GLC_VAODisableNormalPointer(r_vao_id vao)
{
	GLC_VAODisableComponent(&vaos[vao].normal_array);
}

void GLC_VAOEnableColorPointer(r_vao_id vao, int size, GLenum type, GLsizei stride, GLvoid* pointer)
{
	GLC_VAOEnableComponent(&vaos[vao].color_array, size, type, stride, pointer);
}

void GLC_VAODisableColorPointer(r_vao_id vao)
{
	GLC_VAODisableComponent(&vaos[vao].color_array);
}

void GLC_VAOEnableTextureCoordPointer(r_vao_id vao, int index, int size, GLenum type, GLsizei stride, GLvoid* pointer)
{
	GLC_VAOEnableComponent(&vaos[vao].texture_array[index], size, type, stride, pointer);
}

void GLC_VAODisableTextureCoordPointer(r_vao_id vao, int index)
{
	GLC_VAODisableComponent(&vaos[vao].texture_array[index]);
}

void GLC_VAOEnableCustomAttribute(r_vao_id vao, int index, r_program_attribute_id attr_id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer)
{
	glc_va_attribute_t* attr = &vaos[vao].attributes[index];

	memset(attr, 0, sizeof(*attr));
	attr->enabled = true;
	attr->attr_id = attr_id;
	attr->size = size;
	attr->type = type;
	attr->normalized = normalized;
	attr->stride = stride;
	attr->pointer = pointer;
}

void GLC_VAODisableCustomAttribute(r_vao_id vao, int index)
{
	glc_va_attribute_t* attr = &vaos[vao].attributes[index];

	attr->enabled = false;
}

void GLC_VAOSetVertexBuffer(r_vao_id vao, r_buffer_id ref)
{
	vaos[vao].vertex_buffer = ref;
}

void GLC_VAOSetIndexBuffer(r_vao_id vao, r_buffer_id ref)
{
	vaos[vao].element_index_buffer = ref;
}

#ifdef WITH_RENDERING_TRACE
void GLC_PrintVAOState(FILE* output, int indent, r_vao_id vao)
{
	int i;

	indent += 2;
	if (vaos[vao].vertex_array.enabled) {
		glc_va_element* el = &vaos[vao].vertex_array;
		fprintf(output, "%.*s   vertex-array: enabled(type %u, size %d, stride %d, pointer %p)\n", indent, "                                                          ", el->type, el->size, el->stride, el->pointer_or_offset);
	}
	if (vaos[vao].color_array.enabled) {
		glc_va_element* el = &vaos[vao].color_array;
		fprintf(output, "%.*s   color_array: enabled(type %u, size %d, stride %d, pointer %p)\n", indent, "                                                          ", el->type, el->size, el->stride, el->pointer_or_offset);
	}
	if (vaos[vao].normal_array.enabled) {
		glc_va_element* el = &vaos[vao].normal_array;
		fprintf(output, "%.*s   normal_array: enabled(type %u, size %d, stride %d, pointer %p)\n", indent, "                                                          ", el->type, el->size, el->stride, el->pointer_or_offset);
	}
	for (i = 0; i < sizeof(vaos[vao].texture_array) / sizeof(vaos[vao].texture_array[0]); ++i) {
		glc_va_element* el = &vaos[vao].texture_array[i];
		if (el->enabled) {
			fprintf(output, "%.*s   texture-array[%d]: enabled(type %u, size %d, stride %d, pointer %p)\n", indent, "                                                          ", i, el->type, el->size, el->stride, el->pointer_or_offset);
		}
	}
}
#endif

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glc_vao.h
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_GLC_VAO_HEADER
#define EZQUAKE_GLC_VAO_HEADER

#include "gl_local.h"
#include "r_vao.h"
#include "r_program.h"

void GLC_VAOEnableVertexPointer(r_vao_id vao, int size, GLenum type, GLsizei stride, GLvoid* pointer);
void GLC_VAODisableVertexPointer(r_vao_id vao);
void GLC_VAOEnableColorPointer(r_vao_id vao, int size, GLenum type, GLsizei stride, GLvoid* pointer);
void GLC_VAODisableColorPointer(r_vao_id vao);
void GLC_VAOEnableNormalPointer(r_vao_id vao, int size, GLenum type, GLsizei stride, GLvoid* pointer);
void GLC_VAODisableNormalPointer(r_vao_id vao);
void GLC_VAOEnableTextureCoordPointer(r_vao_id vao, int index, int size, GLenum type, GLsizei stride, GLvoid* pointer);
void GLC_VAODisableTextureCoordPointer(r_vao_id vao, int index);
void GLC_VAOSetIndexBuffer(r_vao_id vao, r_buffer_id ref);
void GLC_VAOSetVertexBuffer(r_vao_id vao, r_buffer_id ref);
void GLC_VAOEnableCustomAttribute(r_vao_id vao, int index, r_program_attribute_id attr_id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer);
void GLC_VAODisableCustomAttribute(r_vao_id vao, int index);

void GLC_DeleteVAOs(void);
void GLC_GenVertexArray(r_vao_id vao, const char* name);
qbool GLC_VertexArrayCreated(r_vao_id vao);
void GLC_BindVertexArray(r_vao_id vao);
void GLC_BindVertexArrayAttributes(r_vao_id vao);
qbool GLC_InitialiseVAOHandling(void);
void GLC_EnsureVAOCreated(r_vao_id vao);

#ifdef WITH_RENDERING_TRACE
void GLC_PrintVAOState(FILE* output, int indent, r_vao_id vao);
#endif

#endif // EZQUAKE_GLC_VAO_HEADER


================================================
FILE: src/glc_warp.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifdef RENDERER_OPTION_CLASSIC_OPENGL

#include "quakedef.h"
#include "vx_stuff.h"
#include "gl_model.h"
#include "gl_local.h"
#include "glsl/constants.glsl"
#include "r_texture.h"
#include "glc_local.h"
#include "r_renderer.h"
#include "r_brushmodel.h"
#include "r_program.h"
#include "tr_types.h"

#define TURBSINSIZE 128
#define TURBSCALE ((float) TURBSINSIZE / (2 * M_PI))

static byte turbsin[TURBSINSIZE] = {
	127, 133, 139, 146, 152, 158, 164, 170, 176, 182, 187, 193, 198, 203, 208, 213, 
	217, 221, 226, 229, 233, 236, 239, 242, 245, 247, 249, 251, 252, 253, 254, 254, 
	255, 254, 254, 253, 252, 251, 249, 247, 245, 242, 239, 236, 233, 229, 226, 221, 
	217, 213, 208, 203, 198, 193, 187, 182, 176, 170, 164, 158, 152, 146, 139, 133, 
	127, 121, 115, 108, 102, 96, 90, 84, 78, 72, 67, 61, 56, 51, 46, 41, 
	37, 33, 28, 25, 21, 18, 15, 12, 9, 7, 5, 3, 2, 1, 0, 0, 
	0, 0, 0, 1, 2, 3, 5, 7, 9, 12, 15, 18, 21, 25, 28, 33, 
	37, 41, 46, 51, 56, 61, 67, 72, 78, 84, 90, 96, 102, 108, 115, 121, 
};

__inline static float SINTABLE_APPROX(float time) {
	float sinlerpf, lerptime, lerp;
	int sinlerp1, sinlerp2;

	sinlerpf = time * TURBSCALE;
	sinlerp1 = floor(sinlerpf);
	sinlerp2 = sinlerp1 + 1;
	lerptime = sinlerpf - sinlerp1;

	lerp =	turbsin[sinlerp1 & (TURBSINSIZE - 1)] * (1 - lerptime) +
		turbsin[sinlerp2 & (TURBSINSIZE - 1)] * lerptime;
	return -8 + 16 * lerp / 255.0;
}

void GLC_EmitWaterPoly(msurface_t* fa)
{
	extern cvar_t r_fastturb;
	glpoly_t *p;
	float* v;
	int i;

	if (r_fastturb.integer) {
		byte* col = SurfaceFlatTurbColor(fa->texinfo->texture);
		byte color[4] = { col[0], col[1], col[2], 255 };

		GLC_StateBeginFastTurbPoly(color);
		for (p = fa->polys; p; p = p->next) {
			GLC_Begin(GL_TRIANGLE_STRIP);
			for (i = 0, v = p->verts[0]; i < p->numverts; i++, v += VERTEXSIZE) {
				GLC_Vertex3fv(v);
			}
			GLC_End();
		}
	}
	else {
		renderer.TextureUnitBind(0, fa->texinfo->texture->gl_texturenum);
		for (p = fa->subdivided; p; p = p->next) {
			GLC_Begin(GL_TRIANGLE_STRIP);
			for (i = 0, v = p->verts[0]; i < p->numverts; i++, v += VERTEXSIZE) {
				float os = v[3];
				float ot = v[4];
				// meag: v[5] = 8 * sin(2t), v[6] = 8 * sin(2s)
				//       v[7] = 8 * cos(2t), v[8] = 8 * cos(2s)
				// was: SINTABLE_APPROX(ot * 2 + r_refdef2.time)) / 64.0f, SINTABLE_APPROX(os * 2 + r_refdef2.time)) / 64.0f
				float s = os + v[5] * r_refdef2.cos_time + v[7] * r_refdef2.sin_time;
				float t = ot + v[6] * r_refdef2.cos_time + v[8] * r_refdef2.sin_time;

				glTexCoord2f(s, t);
				GLC_Vertex3fv(v);
			}
			GLC_End();
		}
	}
}

// Caustics
qbool GLC_CausticsProgramCompile(void)
{
	if (R_ProgramRecompileNeeded(r_program_caustics_glc, 0)) {
		R_ProgramCompile(r_program_caustics_glc);
		R_ProgramUniform1i(r_program_uniform_caustics_glc_texSampler, 0);
		R_ProgramSetCustomOptions(r_program_caustics_glc, 0);
	}

	return R_ProgramReady(r_program_caustics_glc);
}

static void GLC_CalcCausticTexCoords(float *v, float *s, float *t)
{
	float os, ot;

	os = v[3];
	ot = v[4];

	*s = os + SINTABLE_APPROX(0.465 * (r_refdef2.time + ot));
	*s *= -3 * (0.5 / 64);

	*t = ot + SINTABLE_APPROX(0.465 * (r_refdef2.time + os));
	*t *= -3 * (0.5 / 64);
}

static void GLC_EmitCausticPolys_Program(glpoly_t* caustics_polys)
{
	unsigned int index_count = 0;
	glpoly_t *p;

	R_ProgramUse(r_program_caustics_glc);
	R_ProgramUniform1f(r_program_uniform_caustics_glc_time, cl.time);

	for (p = caustics_polys; p; p = p->caustics_chain) {
		index_count = GLC_DrawIndexedPoly(p, modelIndexes, modelIndexMaximum, index_count);
	}

	if (index_count) {
		GL_DrawElements(GL_TRIANGLE_STRIP, index_count, GL_UNSIGNED_INT, modelIndexes);
	}
	R_ProgramUse(r_program_none);
}

static void GLC_EmitCausticPolys_Immediate(glpoly_t* caustics_polys)
{
	glpoly_t *p;
	float s, t;
	int i;

	for (p = caustics_polys; p; p = p->caustics_chain) {
		GLC_Begin(GL_TRIANGLE_STRIP);
		for (i = 0; i < p->numverts; ++i) {
			GLC_CalcCausticTexCoords(p->verts[i], &s, &t);
			glTexCoord2f(s, t);
			GLC_Vertex3fv(p->verts[i]);
		}
		GLC_End();
	}
}

void GLC_EmitCausticsPolys(void)
{
	extern glpoly_t *caustics_polys;
	extern cvar_t gl_program_turbsurfaces;
	qbool use_vbo = buffers.supported && modelIndexes;

	if (!caustics_polys) {
		return;
	}

	R_TraceEnterRegion(__func__, true);
	GLC_StateBeginCausticsPolys();

	renderer.TextureUnitBind(0, underwatertexture);

	if (use_vbo && gl_program_turbsurfaces.integer && GL_Supported(R_SUPPORT_RENDERING_SHADERS) && GLC_CausticsProgramCompile()) {
		GLC_EmitCausticPolys_Program(caustics_polys);
	}
	else {
		GLC_EmitCausticPolys_Immediate(caustics_polys);
	}

	caustics_polys = NULL;
	R_TraceLeaveRegion(true);
}

#endif // #ifdef RENDERER_OPTION_CLASSIC_OPENGL


================================================
FILE: src/glm_aliasmodel.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// Alias model rendering (modern)
#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_aliasmodel.h"
#include "tr_types.h"
#include "glsl/constants.glsl"
#include "rulesets.h"
#include "r_matrix.h"
#include "glm_vao.h"
#include "r_texture.h"
#include "r_brushmodel.h" // R_PointIsUnderwater only
#include "r_buffers.h"
#include "r_program.h"
#include "r_renderer.h"

void GLM_StateBeginAliasModelZPassBatch(void);
void GLM_StateBeginAliasModelBatch(qbool translucent, qbool additive);
void GLM_StateBeginAliasOutlineBatch(void);

// MAX_STANDARD_ENTITIES used to be 512, so lets pretend like
// there can't be more aliasmodel entities, as that will cause
// the arrays sized according to this limit to become too big
// for caches etc. Should there be more aliasmodels than this,
// there will be an error printed.
#define MAXIMUM_ALIASMODEL_DRAWCALLS 512   // ridiculous
#define MAXIMUM_MATERIAL_SAMPLERS 32

typedef enum aliasmodel_draw_type_s {
	aliasmodel_draw_std,
	aliasmodel_draw_alpha,
	aliasmodel_draw_outlines,
	aliasmodel_draw_outlines_spec,
	aliasmodel_draw_shells,
	aliasmodel_draw_postscene,
	aliasmodel_draw_postscene_additive,
	aliasmodel_draw_postscene_shells,

	aliasmodel_draw_max
} aliasmodel_draw_type_t;

typedef struct DrawArraysIndirectCommand_s {
	GLuint count;
	GLuint instanceCount;
	GLuint first;
	GLuint baseInstance;
} DrawArraysIndirectCommand_t;

// Internal structure, filled in during initial pass over entities
typedef struct aliasmodel_draw_data_s {
	// Need to split standard & alpha model draws to cope with # of texture units available
	//   Outlines & shells are easier as they have 0 & 1 textures respectively
	DrawArraysIndirectCommand_t indirect_buffer[MAXIMUM_ALIASMODEL_DRAWCALLS];
	texture_ref bound_textures[MAXIMUM_ALIASMODEL_DRAWCALLS][MAXIMUM_MATERIAL_SAMPLERS];
	int num_textures[MAXIMUM_ALIASMODEL_DRAWCALLS];
	int num_cmds[MAXIMUM_ALIASMODEL_DRAWCALLS];
	int num_calls;
	int current_call;

	unsigned int indirect_buffer_offset;
} aliasmodel_draw_instructions_t;

static aliasmodel_draw_instructions_t alias_draw_instructions[aliasmodel_draw_max];
static int alias_draw_count;

typedef struct uniform_block_aliasmodel_s {
	float modelViewMatrix[16];
	// offset: 16 * float
	float color[4];
	float plrtopcolor[4];
	float plrbotcolor[4];
	int amFlags;
	float yaw_angle_rad;
	float shadelight;
	float ambientlight;
	int materialSamplerMapping;
	float lerpFraction;
	float minLumaMix;
	float outline_normal_scale;
} uniform_block_aliasmodel_t;

typedef struct block_aliasmodels_s {
	uniform_block_aliasmodel_t models[MAX_STANDARD_ENTITIES];
} uniform_block_aliasmodels_t;

extern float r_framelerp;

#define DRAW_DETAIL_TEXTURES      (1 << 0)
#define DRAW_CAUSTIC_TEXTURES     (1 << 1)
#define DRAW_REVERSED_DEPTH       (1 << 2)
#define DRAW_LERP_MUZZLEHACK      (1 << 3)
#define DRAW_FLAT_SHADING         (1 << 4)
#define DRAW_INSTANCED            (1 << 5)

static uniform_block_aliasmodels_t aliasdata;

static int cached_mode;

#define GET_COLOR_VALUES(colr) (float[]){(float)gl_outline_color_##colr.color[0] / 255.0f,(float)gl_outline_color_##colr.color[1] / 255.0f,(float)gl_outline_color_##colr.color[2] / 255.0f}

static void R_SetAliasModelUniforms(int mode)
{
	extern cvar_t gl_outline_use_player_color, gl_outline_color_model, gl_outline_color_team, gl_outline_color_enemy;
	float scale = RuleSets_ModelOutlineScale();
	float *color_model, *color_enemy, *color_team;
	int use_player_color = gl_outline_use_player_color.integer;
	color_model = GET_COLOR_VALUES(model);
	color_enemy = gl_outline_color_enemy.string[0] ? GET_COLOR_VALUES(enemy) : color_model;
	color_team  = gl_outline_color_team .string[0] ? GET_COLOR_VALUES(team)  : color_model;

	if (cached_mode != mode) {
		R_ProgramUniform1i(r_program_uniform_aliasmodel_drawmode, mode);
		cached_mode = mode;
	}

	R_ProgramUniform1f(r_program_uniform_aliasmodel_outline_scale, scale);
	R_ProgramUniform1i(r_program_uniform_aliasmodel_outline_use_player_color, use_player_color);
	R_ProgramUniform3fv(r_program_uniform_aliasmodel_outline_color_model, color_model);
	R_ProgramUniform3fv(r_program_uniform_aliasmodel_outline_color_enemy, color_enemy);
	R_ProgramUniform3fv(r_program_uniform_aliasmodel_outline_color_team, color_team);
}

#undef GET_COLOR_VALUES

static int material_samplers_max;
static int TEXTURE_UNIT_MATERIAL;
static int TEXTURE_UNIT_CAUSTICS;

qbool GLM_CompileAliasModelProgram(void)
{
	extern cvar_t r_lerpmuzzlehack, gl_smoothmodels;

	unsigned int drawAlias_desiredOptions =
		(r_refdef2.drawCaustics ? DRAW_CAUSTIC_TEXTURES : 0) |
		(glConfig.reversed_depth ? DRAW_REVERSED_DEPTH : 0) |
		(r_lerpmuzzlehack.integer ? DRAW_LERP_MUZZLEHACK : 0) |
		(gl_smoothmodels.integer ? 0 : DRAW_FLAT_SHADING) |
		(GL_Supported(R_SUPPORT_INSTANCED_RENDERING) ? DRAW_INSTANCED : 0);

	if (R_ProgramRecompileNeeded(r_program_aliasmodel, drawAlias_desiredOptions)) {
		static char included_definitions[1024];

		included_definitions[0] = '\0';
		if (drawAlias_desiredOptions & DRAW_CAUSTIC_TEXTURES) {
			material_samplers_max = glConfig.texture_units - 1;
			TEXTURE_UNIT_CAUSTICS = 0;
			TEXTURE_UNIT_MATERIAL = 1;

			strlcat(included_definitions, "#define DRAW_CAUSTIC_TEXTURES\n", sizeof(included_definitions));
			strlcat(included_definitions, "#define SAMPLER_CAUSTIC_TEXTURE 0\n", sizeof(included_definitions));
			strlcat(included_definitions, "#define SAMPLER_MATERIAL_TEXTURE_START 1\n", sizeof(included_definitions));
		}
		else {
			material_samplers_max = glConfig.texture_units;
			TEXTURE_UNIT_MATERIAL = 0;

			strlcat(included_definitions, "#define SAMPLER_MATERIAL_TEXTURE_START 0\n", sizeof(included_definitions));
		}

		strlcat(included_definitions, va("#define SAMPLER_COUNT %d\n", material_samplers_max), sizeof(included_definitions));
		if (drawAlias_desiredOptions & DRAW_REVERSED_DEPTH) {
			strlcat(included_definitions, "#define EZQ_REVERSED_DEPTH\n", sizeof(included_definitions));
		}
		if (drawAlias_desiredOptions & DRAW_LERP_MUZZLEHACK) {
			strlcat(included_definitions, "#define EZQ_ALIASMODEL_MUZZLEHACK\n", sizeof(included_definitions));
		}
		if (drawAlias_desiredOptions & DRAW_FLAT_SHADING) {
			strlcat(included_definitions, "#define EZQ_ALIASMODEL_FLATSHADING\n", sizeof(included_definitions));
		}

		// Initialise program for drawing image
		R_ProgramCompileWithInclude(r_program_aliasmodel, included_definitions);

		// Set sampler uniforms for GL < 4.2 (no layout(binding=N) support)
		if (!GL_VersionAtLeast(4, 2) && R_ProgramReady(r_program_aliasmodel)) {
			R_ProgramUse(r_program_aliasmodel);
			if (drawAlias_desiredOptions & DRAW_CAUSTIC_TEXTURES) {
				R_ProgramUniform1i(r_program_uniform_aliasmodel_causticstex, TEXTURE_UNIT_CAUSTICS);
			}
			R_ProgramUniform1iArrayBase(r_program_uniform_aliasmodel_samplers, material_samplers_max, TEXTURE_UNIT_MATERIAL);
		}

		R_ProgramSetCustomOptions(r_program_aliasmodel, drawAlias_desiredOptions);
	}
	cached_mode = R_ProgramUniformGet1i(r_program_uniform_aliasmodel_drawmode, 0);

	if (!R_BufferReferenceIsValid(r_buffer_aliasmodel_drawcall_indirect)) {
		buffers.Create(r_buffer_aliasmodel_drawcall_indirect, buffertype_indirect, "aliasmodel-indirect-draw", sizeof(alias_draw_instructions[0].indirect_buffer) * aliasmodel_draw_max, NULL, bufferusage_once_per_frame);
	}

	if (!R_BufferReferenceIsValid(r_buffer_aliasmodel_model_data)) {
		buffers.Create(r_buffer_aliasmodel_model_data, buffertype_storage, "alias-data", sizeof(aliasdata), NULL, bufferusage_once_per_frame);
	}

	return R_ProgramReady(r_program_aliasmodel);
}

void GLM_CreateAliasModelVAO(void)
{
	R_GenVertexArray(vao_aliasmodel);

	GLM_ConfigureVertexAttribPointer(vao_aliasmodel, r_buffer_aliasmodel_vertex_data, 0, 3, GL_FLOAT, GL_FALSE, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, position), 0);
	GLM_ConfigureVertexAttribPointer(vao_aliasmodel, r_buffer_aliasmodel_vertex_data, 1, 2, GL_FLOAT, GL_FALSE, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, texture_coords), 0);
	GLM_ConfigureVertexAttribPointer(vao_aliasmodel, r_buffer_aliasmodel_vertex_data, 2, 3, GL_FLOAT, GL_FALSE, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, normal), 0);
	GLM_ConfigureVertexAttribIPointer(vao_aliasmodel, r_buffer_instance_number, 3, 1, GL_UNSIGNED_INT, sizeof(GLuint), 0, 1);
	GLM_ConfigureVertexAttribPointer(vao_aliasmodel, r_buffer_aliasmodel_vertex_data, 4, 3, GL_FLOAT, GL_FALSE, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, direction), 0);
	GLM_ConfigureVertexAttribIPointer(vao_aliasmodel, r_buffer_aliasmodel_vertex_data, 5, 1, GL_UNSIGNED_INT, sizeof(vbo_model_vert_t), VBO_FIELDOFFSET(vbo_model_vert_t, flags), 0);

	R_BindVertexArray(vao_none);
}

static int AssignSampler(aliasmodel_draw_instructions_t* instr, texture_ref texture)
{
	int i;
	texture_ref* allocated_samplers;

	if (!R_TextureReferenceIsValid(texture)) {
		return 0;
	}
	if (instr->current_call >= sizeof(instr->bound_textures) / sizeof(instr->bound_textures[0])) {
		return -1;
	}

	allocated_samplers = instr->bound_textures[instr->current_call];
	for (i = 0; i < instr->num_textures[instr->current_call]; ++i) {
		if (R_TextureReferenceEqual(texture, allocated_samplers[i])) {
			return i;
		}
	}

	if (instr->num_textures[instr->current_call] < material_samplers_max) {
		allocated_samplers[instr->num_textures[instr->current_call]] = texture;
		return instr->num_textures[instr->current_call]++;
	}

	return -1;
}

static qbool GLM_NextAliasModelDrawCall(aliasmodel_draw_instructions_t* instr, qbool bind_default_textures)
{
	if (instr->num_calls >= sizeof(instr->num_textures) / sizeof(instr->num_textures[0])) {
		return false;
	}

	instr->current_call = instr->num_calls;
	instr->num_calls++;
	instr->num_textures[instr->current_call] = 0;
	if (bind_default_textures) {
		if (R_ProgramCustomOptions(r_program_aliasmodel) & DRAW_CAUSTIC_TEXTURES) {
			instr->bound_textures[instr->current_call][0] = underwatertexture;
			instr->num_textures[instr->current_call]++;
		}
	}
	return true;
}

static void GLM_QueueDrawCall(aliasmodel_draw_type_t type, int vbo_start, int vbo_count, int instance)
{
	int pos;
	aliasmodel_draw_instructions_t* instr = &alias_draw_instructions[type];
	DrawArraysIndirectCommand_t* indirect;

	if (!instr->num_calls) {
		GLM_NextAliasModelDrawCall(instr, false);
	}

	if (instr->num_cmds[instr->current_call] >= sizeof(instr->indirect_buffer) / sizeof(instr->indirect_buffer[0])) {
		return;
	}

	pos = instr->num_cmds[instr->current_call]++;
	indirect = &instr->indirect_buffer[pos];
	indirect->instanceCount = 1;
	indirect->baseInstance = instance;
	indirect->first = vbo_start;
	indirect->count = vbo_count;
}

static void GLM_QueueAliasModelDrawImpl(
	entity_t* ent, model_t* model, float* color, int vbo_start, int vbo_count, texture_ref texture,
	int effects, float lerpFraction, int lerpFrameVertOffset, qbool outline, int render_effects
)
{
	qbool shell = (effects & (EF_RED | EF_BLUE | EF_GREEN)) && R_TextureReferenceIsValid(shelltexture) && Ruleset_AllowPowerupShell(model);
	uniform_block_aliasmodel_t* uniform;
	aliasmodel_draw_type_t type = aliasmodel_draw_std;
	aliasmodel_draw_type_t shelltype = aliasmodel_draw_shells;
	aliasmodel_draw_instructions_t* instr;
	int textureSampler = -1;
	extern cvar_t gl_spec_xray;
	int i;

	// Compile here so we can work out how many samplers we have free to allocate per draw-call
	if (!GLM_CompileAliasModelProgram()) {
		return;
	}

	if (render_effects & RF_ADDITIVEBLEND) {
		type = aliasmodel_draw_postscene_additive;
		shell = false;
		outline = false;
	}
	else if ((render_effects & RF_WEAPONMODEL) && color[3] < 1) {
		type = aliasmodel_draw_postscene;
		shelltype = aliasmodel_draw_postscene_shells;
		outline = false;
	}
	else if (color[3] < 1) {
		type = aliasmodel_draw_alpha;
		outline = false;
	}

	instr = &alias_draw_instructions[type];

	// Should never happen...
	if (alias_draw_count >= sizeof(aliasdata.models) / sizeof(aliasdata.models[0])) {
		return;
	}

	if (!instr->num_calls) {
		GLM_NextAliasModelDrawCall(instr, true);
	}

	// Assign samplers - if we're over limit, need to flush and try again
	textureSampler = AssignSampler(instr, texture);
	if (textureSampler < 0) {
		if (!GLM_NextAliasModelDrawCall(instr, true)) {
			return;
		}

		textureSampler = AssignSampler(instr, texture);
	}

	// Store static data ready for upload
	memset(&aliasdata.models[alias_draw_count], 0, sizeof(aliasdata.models[alias_draw_count]));
	uniform = &aliasdata.models[alias_draw_count];
	R_GetModelviewMatrix(uniform->modelViewMatrix);
	uniform->amFlags =
		(effects & EF_RED ? AMF_SHELLMODEL_RED : 0) |
		(effects & EF_GREEN ? AMF_SHELLMODEL_GREEN : 0) |
		(effects & EF_BLUE ? AMF_SHELLMODEL_BLUE : 0) |
		(R_TextureReferenceIsValid(texture) ? AMF_TEXTURE_MATERIAL : 0) |
		(render_effects & RF_CAUSTICS ? AMF_CAUSTICS : 0) |
		(render_effects & RF_WEAPONMODEL ? AMF_WEAPONMODEL : 0) |
		(ent->scoreboard != NULL ? ent->scoreboard->teammate ? AMF_TEAMMATE : 0 : 0) |
		(ent->renderfx & RF_BEHINDWALL ? AMF_BEHINDWALL : 0) |
		(ent->renderfx & RF_PLAYERMODEL ? AMF_PLAYERMODEL : 0) |
		(ent->renderfx & RF_VWEPMODEL ? AMF_VWEPMODEL : 0);
	uniform->yaw_angle_rad = ent->angles[YAW] * M_PI / 180.0;
	uniform->shadelight = ent->shadelight;
	uniform->ambientlight = ent->ambientlight;
	uniform->lerpFraction = lerpFraction;
	uniform->color[0] = color[0];
	uniform->color[1] = color[1];
	uniform->color[2] = color[2];
	uniform->color[3] = color[3];
	uniform->materialSamplerMapping = textureSampler;
	uniform->minLumaMix = 1.0f - (ent->full_light ? bound(0, gl_fb_models.integer, 1) : 0);
	uniform->outline_normal_scale = ent->outlineScale;
	if(ent->scoreboard != NULL) {
		int tc = 16 * (bound(0, ent->scoreboard->topcolor, 13)) + 8;
		int bc = 16 * (bound(0, ent->scoreboard->bottomcolor, 13)) + 8;
		byte top[] = { host_basepal[tc * 3], host_basepal[tc * 3 + 1], host_basepal[tc * 3 + 2] };
		byte bot[] = { host_basepal[bc * 3], host_basepal[bc * 3 + 1], host_basepal[bc * 3 + 2] };
		for(i = 0; i < 3; i++) uniform->plrtopcolor[i] = (float)top[i] / 256.0f;
		for(i = 0; i < 3; i++) uniform->plrbotcolor[i] = (float)bot[i] / 256.0f;
	}

	// Add to queues
	GLM_QueueDrawCall(type, vbo_start, vbo_count, alias_draw_count);
	if (outline) {
		GLM_QueueDrawCall(aliasmodel_draw_outlines, vbo_start, vbo_count, alias_draw_count);
	}
	if (shell) {
		GLM_QueueDrawCall(shelltype, vbo_start, vbo_count, alias_draw_count);
	}
	if((render_effects & RF_PLAYERMODEL) && (render_effects & RF_BEHINDWALL) &&
	   (cls.demoplayback || cls.mvdplayback) && gl_spec_xray.value)
	{
		GLM_QueueDrawCall(aliasmodel_draw_outlines_spec, vbo_start, vbo_count, alias_draw_count);
	}

	alias_draw_count++;
}

// Called for .mdl & .md3
void GLM_DrawAliasModelFrame(
	entity_t* ent, model_t* model, int poseVertIndex, int poseVertIndex2, int vertsPerPose,
	texture_ref texture, qbool outline, int effects, int render_effects, float lerp_fraction
)
{
	float color[4];
	qbool invalidate_texture;

	if (lerp_fraction == 1) {
		poseVertIndex = poseVertIndex2;
		lerp_fraction = 0;
	}

	// TODO: Vertex lighting etc
	// TODO: Coloured lighting per-vertex?
	R_AliasModelColor(ent, color, &invalidate_texture);

	if (invalidate_texture) {
		R_TextureReferenceInvalidate(texture);
	}

	if (r_refdef2.drawCaustics && R_PointIsUnderwater(ent->origin)) {
		render_effects |= RF_CAUSTICS;
	}

	GLM_QueueAliasModelDrawImpl(
		ent, model, color, poseVertIndex, vertsPerPose,
		texture, effects, lerp_fraction, poseVertIndex2, outline, render_effects
	);
}

// .mdl rendering
void GLM_DrawAliasFrame(
	entity_t* ent, model_t* model, int pose1, int pose2,
	texture_ref texture, texture_ref fb_texture,
	qbool outline, int effects, int render_effects, float lerpfrac
)
{
	aliashdr_t* paliashdr = (aliashdr_t*) Mod_Extradata(model);
	int vertIndex = model->vbo_start + pose1 * paliashdr->vertsPerPose;
	int nextVertIndex = model->vbo_start + pose2 * paliashdr->vertsPerPose;

	GLM_DrawAliasModelFrame(
		ent, model, vertIndex, nextVertIndex, paliashdr->vertsPerPose,
		texture, outline, effects, render_effects, lerpfrac
	);
}

void GLM_PrepareAliasModelBatches(void)
{
	if (!GLM_CompileAliasModelProgram() || !alias_draw_count) {
		return;
	}

	R_TraceEnterNamedRegion(__func__);

	// Update VBO with data about each entity
	buffers.Update(r_buffer_aliasmodel_model_data, sizeof(aliasdata.models[0]) * alias_draw_count, aliasdata.models);
	buffers.BindRange(r_buffer_aliasmodel_model_data, EZQ_STORAGE_BLOCK_BINDING(EZQ_GL_BINDINGPOINT_ALIASMODEL_DRAWDATA), buffers.BufferOffset(r_buffer_aliasmodel_model_data), sizeof(aliasdata.models[0]) * alias_draw_count);

	// Build & update list of indirect calls
	{
		int i, j;
		int offset = 0;

		for (i = 0; i < aliasmodel_draw_max; ++i) {
			aliasmodel_draw_instructions_t* instr = &alias_draw_instructions[i];
			int total_cmds = 0;
			int size;

			if (!instr->num_calls) {
				continue;
			}

			instr->indirect_buffer_offset = offset;
			for (j = 0; j < instr->num_calls; ++j) {
				total_cmds += instr->num_cmds[j];
			}

			size = sizeof(instr->indirect_buffer[0]) * total_cmds;
			buffers.UpdateSection(r_buffer_aliasmodel_drawcall_indirect, offset, size, instr->indirect_buffer);
			offset += size;
		}
	}

	R_TraceLeaveNamedRegion();
}

// GL 4.1 fallback: no baseInstance, so use instanceOffset uniform to index correct model
static int GLM_DrawAliasModelsNoBaseInstance(aliasmodel_draw_instructions_t* instr, int cmd_start, int call_index)
{
	int j;

	for (j = 0; j < instr->num_cmds[call_index]; ++j) {
		DrawArraysIndirectCommand_t* cmd = &instr->indirect_buffer[cmd_start + j];

		// Without baseInstance support, _instanceId vertex attribute is always 0.
		// Use instanceOffset uniform so shader reads models[0 + baseInstance].
		R_ProgramUniform1i(r_program_uniform_aliasmodel_instanceOffset, cmd->baseInstance);

		GL_DrawArrays(GL_TRIANGLES, cmd->first, cmd->count);
	}

	// Reset for potential use with baseInstance path
	R_ProgramUniform1i(r_program_uniform_aliasmodel_instanceOffset, 0);

	return instr->num_cmds[call_index];
}

static void GLM_RenderPreparedEntities(aliasmodel_draw_type_t type)
{
	aliasmodel_draw_instructions_t* instr = &alias_draw_instructions[type];
	GLint mode = (type == aliasmodel_draw_shells || type == aliasmodel_draw_postscene_shells ? EZQ_ALIAS_MODE_SHELLS : EZQ_ALIAS_MODE_NORMAL);
	unsigned int extra_offset = 0;
	int i, call_start;
	qbool translucent = (type != aliasmodel_draw_std && type != aliasmodel_draw_postscene_additive);
	qbool additive = (type == aliasmodel_draw_postscene_additive);
	qbool shells = (type == aliasmodel_draw_shells || type == aliasmodel_draw_postscene_shells);
	qbool no_base_instance = !GL_Supported(R_SUPPORT_INSTANCED_RENDERING);

	if (!instr->num_calls || !GLM_CompileAliasModelProgram()) {
		return;
	}

	if (!no_base_instance) {
		buffers.Bind(r_buffer_aliasmodel_drawcall_indirect);
		extra_offset = buffers.BufferOffset(r_buffer_aliasmodel_drawcall_indirect);
	}

	R_ProgramUse(r_program_aliasmodel);
	R_SetAliasModelUniforms(mode);
	// We have prepared the draw calls earlier in the frame so very trival logic here
	if (r_refdef2.drawCaustics) {
		renderer.TextureUnitBind(TEXTURE_UNIT_CAUSTICS, underwatertexture);
	}
	if (shells) {
		renderer.TextureUnitBind(TEXTURE_UNIT_MATERIAL, shelltexture);
	}

	// Depth pre-pass to make viewmodel look good.
	if (type == aliasmodel_draw_postscene) {
		GLM_StateBeginAliasModelZPassBatch();
		call_start = 0;
		for (i = 0; i < instr->num_calls; ++i) {
			if (no_base_instance) {
				call_start += GLM_DrawAliasModelsNoBaseInstance(instr, call_start, i);
			}
			else {
				GL_MultiDrawArraysIndirect(
					GL_TRIANGLES,
					(const void*)(uintptr_t)(instr->indirect_buffer_offset + extra_offset),
					instr->num_cmds[i],
					0
				);
			}
		}
	}

	GLM_StateBeginAliasModelBatch(translucent, additive);
	call_start = 0;
	for (i = 0; i < instr->num_calls; ++i) {
		if (!shells && instr->num_textures[i]) {
			renderer.TextureUnitMultiBind(TEXTURE_UNIT_MATERIAL, instr->num_textures[i], instr->bound_textures[i]);
		}

		if (no_base_instance) {
			call_start += GLM_DrawAliasModelsNoBaseInstance(instr, call_start, i);
		}
		else {
			GL_MultiDrawArraysIndirect(
				GL_TRIANGLES,
				(const void*)(uintptr_t)(instr->indirect_buffer_offset + extra_offset),
				instr->num_cmds[i],
				0
			);
		}
	}

	if (type == aliasmodel_draw_std && alias_draw_instructions[aliasmodel_draw_outlines_spec].num_calls) {
		instr = &alias_draw_instructions[aliasmodel_draw_outlines_spec];

		R_TraceEnterNamedRegion("GLM_DrawOutlineBatch");
		R_SetAliasModelUniforms(EZQ_ALIAS_MODE_OUTLINES_SPEC);

		R_ApplyRenderingState(r_state_aliasmodel_outline_spec);

		call_start = 0;
		for (i = 0; i < instr->num_calls; ++i) {
			if (no_base_instance) {
				call_start += GLM_DrawAliasModelsNoBaseInstance(instr, call_start, i);
			}
			else {
				GL_MultiDrawArraysIndirect(
						GL_TRIANGLES,
						(const void*)(uintptr_t)(instr->indirect_buffer_offset + extra_offset),
						instr->num_cmds[i],
						0
				);
			}
		}
		R_TraceLeaveNamedRegion();
	}

	if (type == aliasmodel_draw_std && alias_draw_instructions[aliasmodel_draw_outlines].num_calls) {
		instr = &alias_draw_instructions[aliasmodel_draw_outlines];

		R_TraceEnterNamedRegion("GLM_DrawOutlineBatch");
		R_SetAliasModelUniforms(EZQ_ALIAS_MODE_OUTLINES);

		GLM_StateBeginAliasOutlineBatch();

		call_start = 0;
		for (i = 0; i < instr->num_calls; ++i) {
			if (no_base_instance) {
				call_start += GLM_DrawAliasModelsNoBaseInstance(instr, call_start, i);
			}
			else {
				GL_MultiDrawArraysIndirect(
					GL_TRIANGLES,
					(const void*)(uintptr_t)(instr->indirect_buffer_offset + extra_offset),
					instr->num_cmds[i],
					0
				);
			}
		}
		R_TraceLeaveNamedRegion();
	}
}

void GLM_DrawAliasModelBatches(void)
{
	GLM_RenderPreparedEntities(aliasmodel_draw_std);
	GLM_RenderPreparedEntities(aliasmodel_draw_alpha);
	GLM_RenderPreparedEntities(aliasmodel_draw_shells);
}

void GLM_DrawAliasModelPostSceneBatches(void)
{
	GLM_RenderPreparedEntities(aliasmodel_draw_postscene);
	GLM_RenderPreparedEntities(aliasmodel_draw_postscene_additive);
	GLM_RenderPreparedEntities(aliasmodel_draw_postscene_shells);
}

void GLM_InitialiseAliasModelBatches(void)
{
	alias_draw_count = 0;
	memset(alias_draw_instructions, 0, sizeof(alias_draw_instructions));
}

void GLM_AliasModelShadow(entity_t* ent)
{
	// MEAG: TODO
	// aliashdr_t* paliashdr = (aliashdr_t *)Mod_Extradata(ent->model); // locate the proper data
}

#endif // RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_brushmodel.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "rulesets.h"
#include "utils.h"
#include "glsl/constants.glsl"
#include "glm_brushmodel.h"
#include "tr_types.h"
#include <limits.h>
#include "glm_vao.h"
#include "r_buffers.h"
#include "r_brushmodel.h"

typedef struct vbo_world_surface_s {
	float normal[4];
	float lm_vecs0[4];
	float lm_vecs1[4];
} vbo_world_surface_t;

void GLM_CreateBrushModelVAO(void)
{
	int i;

	if (!R_BufferReferenceIsValid(r_buffer_brushmodel_vertex_data) || !R_BufferReferenceIsValid(r_buffer_brushmodel_index_data)) {
		return;
	}

	// Create vao
	R_GenVertexArray(vao_brushmodel);
	buffers.Bind(r_buffer_brushmodel_index_data);

	GLM_ConfigureVertexAttribPointer(vao_brushmodel, r_buffer_brushmodel_vertex_data, 0, 3, GL_FLOAT, GL_FALSE, sizeof(vbo_world_vert_t), VBO_FIELDOFFSET(vbo_world_vert_t, position), 0);
	GLM_ConfigureVertexAttribPointer(vao_brushmodel, r_buffer_brushmodel_vertex_data, 1, 3, GL_FLOAT, GL_FALSE, sizeof(vbo_world_vert_t), VBO_FIELDOFFSET(vbo_world_vert_t, material_coords), 0);
	GLM_ConfigureVertexAttribPointer(vao_brushmodel, r_buffer_brushmodel_vertex_data, 2, 3, GL_FLOAT, GL_FALSE, sizeof(vbo_world_vert_t), VBO_FIELDOFFSET(vbo_world_vert_t, lightmap_coords), 0);
	GLM_ConfigureVertexAttribPointer(vao_brushmodel, r_buffer_brushmodel_vertex_data, 3, 2, GL_FLOAT, GL_FALSE, sizeof(vbo_world_vert_t), VBO_FIELDOFFSET(vbo_world_vert_t, detail_coords), 0);
	// 
	GLM_ConfigureVertexAttribIPointer(vao_brushmodel, r_buffer_instance_number, 4, 1, GL_UNSIGNED_INT, sizeof(GLuint), 0, 1);
	GLM_ConfigureVertexAttribIPointer(vao_brushmodel, r_buffer_brushmodel_vertex_data, 5, 1, GL_UNSIGNED_INT, sizeof(vbo_world_vert_t), VBO_FIELDOFFSET(vbo_world_vert_t, flags), 0);
	GLM_ConfigureVertexAttribPointer(vao_brushmodel, r_buffer_brushmodel_vertex_data, 6, 3, GL_FLOAT, GL_FALSE, sizeof(vbo_world_vert_t), VBO_FIELDOFFSET(vbo_world_vert_t, flatcolor), 0);
	GLM_ConfigureVertexAttribIPointer(vao_brushmodel, r_buffer_brushmodel_vertex_data, 7, 1, GL_UNSIGNED_INT, sizeof(vbo_world_vert_t), VBO_FIELDOFFSET(vbo_world_vert_t, surface_num), 0);

	R_BindVertexArray(vao_none);

	// Create surface information SSBO
	if (cl.worldmodel) {
		vbo_world_surface_t* surfaces = (vbo_world_surface_t*) Q_malloc(cl.worldmodel->numsurfaces * sizeof(vbo_world_surface_t));
		for (i = 0; i < cl.worldmodel->numsurfaces; ++i) {
			msurface_t* surf = cl.worldmodel->surfaces + i;

			VectorCopy(surf->plane->normal, surfaces[i].normal);
			surfaces[i].normal[3] = surf->plane->dist;
			memcpy(surfaces[i].lm_vecs0, surf->lmvecs[0], sizeof(surf->lmvecs[0]));
			memcpy(surfaces[i].lm_vecs1, surf->lmvecs[1], sizeof(surf->lmvecs[1]));
			surfaces[i].lm_vecs0[3] = surf->lmvlen[0];
			surfaces[i].lm_vecs1[3] = surf->lmvlen[1];
		}
		buffers.Create(r_buffer_brushmodel_surface_data, buffertype_storage, "brushmodel-surfs", cl.worldmodel->numsurfaces * sizeof(vbo_world_surface_t), surfaces, bufferusage_constant_data);
		Q_free(surfaces);
		buffers.BindBase(r_buffer_brushmodel_surface_data, EZQ_STORAGE_BLOCK_BINDING(EZQ_GL_BINDINGPOINT_WORLDMODEL_SURFACES));
	}
}

// 'source' is from GLC's float[VERTEXSIZE]
int GLM_BrushModelCopyVertToBuffer(model_t* mod, void* vbo_buffer_, int position, float* source, int lightmap, int material, float scaleS, float scaleT, msurface_t* surf, qbool has_fb_texture, qbool has_luma_texture)
{
	vbo_world_vert_t* target = (vbo_world_vert_t*)vbo_buffer_ + position;

	VectorCopy(source, target->position);
	target->material_coords[0] = source[3] * (scaleS ? scaleS : 1);
	target->material_coords[1] = source[4] * (scaleT ? scaleT : 1);
	target->material_coords[2] = material;
	target->lightmap_coords[0] = source[5];
	target->lightmap_coords[1] = source[6];
	target->lightmap_coords[2] = lightmap;
	target->detail_coords[0] = source[7];
	target->detail_coords[1] = source[8];

	if (surf->flags & SURF_DRAWSKY) {
		target->flags = TEXTURE_TURB_SKY;
	}
	else if (surf->flags & SURF_DRAWTURB) {
		target->flags = (surf->texinfo->texture->turbType & EZQ_SURFACE_TYPE);
		if (!target->flags) {
			target->flags = TEXTURE_TURB_OTHER;
		}
	}
	else if (mod->isworldmodel) {
		target->flags = EZQ_SURFACE_WORLD;
		target->flags += (surf->flags & SURF_DRAWFLAT_FLOOR ? EZQ_SURFACE_IS_FLOOR: 0);
		target->flags += (surf->flags & SURF_UNDERWATER ? EZQ_SURFACE_UNDERWATER : 0);
	}
	else {
		target->flags = 0;
	}
	target->flags += (surf->flags & SURF_DRAWALPHA ? EZQ_SURFACE_ALPHATEST : 0);

	{
		byte rgba[4];

		COLOR_TO_RGBA(surf->texinfo->texture->flatcolor3ub, rgba);

		VectorScale(rgba, 1 / 255.0f, target->flatcolor);
	}
	target->surface_num = mod->isworldmodel ? surf - mod->surfaces : 0;

	return position + 1;
}

void GLM_ChainBrushModelSurfaces(model_t* clmodel, entity_t* ent)
{
	int i;
	msurface_t* psurf;
	qbool drawFlatFloors = r_drawflat_mode.integer == 0 && (r_drawflat.integer == 2 || r_drawflat.integer == 1) && clmodel->isworldmodel;
	qbool drawFlatWalls = r_drawflat_mode.integer == 0 && (r_drawflat.integer == 3 || r_drawflat.integer == 1) && clmodel->isworldmodel;

	// GLSL mode - always render the whole model, the surfaces will be re-used if there is
	//   another entity with the same model later in the scene
	psurf = &clmodel->surfaces[clmodel->firstmodelsurface];
	for (i = 0; i < clmodel->nummodelsurfaces; i++, psurf++) {
		if (psurf->flags & SURF_DRAWSKY) {
			// FIXME: Find an example...
			CHAIN_SURF_B2F(psurf, clmodel->drawflat_chain);
			clmodel->drawflat_todo = true;

			clmodel->first_texture_chained = min(clmodel->first_texture_chained, psurf->texinfo->miptex);
			clmodel->last_texture_chained = max(clmodel->last_texture_chained, psurf->texinfo->miptex);
		}
		else if (psurf->flags & SURF_DRAWTURB) {
			extern cvar_t r_fastturb;
			// FIXME: Find an example...
			if (r_fastturb.integer) {
				CHAIN_SURF_B2F(psurf, clmodel->drawflat_chain);
				clmodel->drawflat_todo = true;
			}
			else {
				CHAIN_SURF_B2F(psurf, psurf->texinfo->texture->texturechain);
			}

			clmodel->first_texture_chained = min(clmodel->first_texture_chained, psurf->texinfo->miptex);
			clmodel->last_texture_chained = max(clmodel->last_texture_chained, psurf->texinfo->miptex);
		}
		else {
			if (drawFlatFloors && (psurf->flags & SURF_DRAWFLAT_FLOOR)) {
				chain_surfaces_simple_drawflat(&clmodel->drawflat_chain, psurf);
				clmodel->drawflat_todo = true;
			}
			else if (drawFlatWalls && !(psurf->flags & SURF_DRAWFLAT_FLOOR)) {
				chain_surfaces_simple_drawflat(&clmodel->drawflat_chain, psurf);
				clmodel->drawflat_todo = true;
			}
			else {
				chain_surfaces_simple(&psurf->texinfo->texture->texturechain, psurf);

				clmodel->first_texture_chained = min(clmodel->first_texture_chained, psurf->texinfo->miptex);
				clmodel->last_texture_chained = max(clmodel->last_texture_chained, psurf->texinfo->miptex);
			}
		}
	}
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_brushmodel.h
================================================

#ifndef EZQUAKE_GLM_BRUSHMODEL_HEADER
#define EZQUAKE_GLM_BRUSHMODEL_HEADER

#include "r_brushmodel.h"

// Our limit, user's limit will be dictated by graphics card (glConfig.texture_units set during startup)
#define MAXIMUM_MATERIAL_SAMPLERS 32

// Cross-material textures which might be used up before we start binding materials
// May well be lower in practise, depending on configuration options enabled
// Currently lightmaps + detail + caustics + (2*skydome|1*skybox) = 5
#define MAX_STANDARD_TEXTURES 5

void GLM_CreateBrushModelVAO(void);

#endif


================================================
FILE: src/glm_draw.c
================================================
/*
Copyright (C) 2017-2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "wad.h"
#include "stats_grid.h"
#include "utils.h"
#include "sbar.h"
#include "common_draw.h"
#include "tr_types.h"
#include "glm_draw.h"
#include "glm_vao.h"
#include "r_draw.h"
#include "r_matrix.h"
#include "glsl/constants.glsl"
#include "glm_local.h"
#include "r_program.h"
#include "r_renderer.h"
#include "gl_texture.h"

void Atlas_SolidTextureCoordinates(texture_ref* ref, float* s, float* t);
qbool GLM_CreateMultiImageProgram(void);

extern float overall_alpha;
extern float cachedMatrix[16];

// Flags to detect when the user has changed settings
#define GLM_HUDIMAGES_SMOOTHTEXT        1
#define GLM_HUDIMAGES_SMOOTHCROSSHAIR   2
#define GLM_HUDIMAGES_SMOOTHIMAGES      4
#define GLM_HUDIMAGES_ALPHAHACK         8
#define GLM_HUDIMAGES_SMOOTHEVERYTHING  (GLM_HUDIMAGES_SMOOTHTEXT | GLM_HUDIMAGES_SMOOTHCROSSHAIR | GLM_HUDIMAGES_SMOOTHIMAGES)

static void GLM_SetCoordinates(glm_image_t* targ, float x1, float y1, float x2, float y2, float s, float s_width, float t, float t_height, int flags)
{
	float v1[4] = { x1, y1, 0, 1 };
	float v2[4] = { x2, y2, 0, 1 };

	R_MultiplyVector(cachedMatrix, v1, v1);
	R_MultiplyVector(cachedMatrix, v2, v2);

	// TL TL BR BR
	targ[0].pos[0] = v1[0]; targ[0].tex[0] = s;
	targ[1].pos[0] = v1[0]; targ[1].tex[0] = s;
	targ[2].pos[0] = v2[0]; targ[2].tex[0] = s + s_width;
	targ[3].pos[0] = v2[0]; targ[3].tex[0] = s + s_width;
	// TL BR TL BR
	targ[0].pos[1] = v1[1]; targ[0].tex[1] = t;
	targ[1].pos[1] = v2[1]; targ[1].tex[1] = t + t_height;
	targ[2].pos[1] = v1[1]; targ[2].tex[1] = t;
	targ[3].pos[1] = v2[1]; targ[3].tex[1] = t + t_height;

	targ[0].flags = targ[1].flags = targ[2].flags = targ[3].flags = flags;
}

void GLM_HudDrawComplete(void)
{
	if ((R_ProgramCustomOptions(r_program_hud_images) & GLM_HUDIMAGES_SMOOTHEVERYTHING) == 0) {
		GL_SamplerClear(0);
	}
	else if ((R_ProgramCustomOptions(r_program_hud_images) & GLM_HUDIMAGES_SMOOTHEVERYTHING) != GLM_HUDIMAGES_SMOOTHEVERYTHING) {
		GL_SamplerClear(1);
	}
}

void GLM_HudDrawPolygons(texture_ref texture, int start, int end)
{
	int i;
	uintptr_t offset = buffers.BufferOffset(r_buffer_hud_image_vertex_data) / sizeof(imageData.images[0]);

	GLM_StateBeginImageDraw();
	R_ProgramUse(r_program_hud_images);
	renderer.TextureUnitBind(0, texture);

	for (i = start; i <= end; ++i) {
		GL_DrawArrays(GL_TRIANGLE_STRIP, offset + polygonData.polygonImageIndexes[i], polygonData.polygonVerts[i]);
	}
}

void GLM_HudDrawLines(texture_ref texture, int start, int end)
{
	if (R_ProgramReady(r_program_hud_images) && R_VertexArrayCreated(vao_hud_images)) {
		int i;
		uintptr_t offset = buffers.BufferOffset(r_buffer_hud_image_vertex_data) / sizeof(imageData.images[0]);

		R_ApplyRenderingState(r_state_hud_images_glm);
		R_ProgramUse(r_program_hud_images);
		renderer.TextureUnitBind(0, texture);

		for (i = start; i <= end; ++i) {
			R_StateBeginAlphaLineRGB(lineData.line_thickness[i]);
			GL_DrawArrays(GL_LINES, offset + lineData.imageIndex[i], 2);
		}
	}
}

void GLM_DrawRectangle(float x, float y, float width, float height, byte* color)
{
	texture_ref solid_texture;
	float s, t, alpha;
	glm_image_t* img;

	if (imageData.imageCount >= MAX_MULTI_IMAGE_BATCH) {
		return;
	}

	Atlas_SolidTextureCoordinates(&solid_texture, &s, &t);
	if (!R_LogCustomImageTypeWithTexture(imagetype_image, imageData.imageCount, solid_texture)) {
		return;
	}

	img = &imageData.images[imageData.imageCount * 4];
	alpha = (color[3] * overall_alpha / 255.0f);

	img->colour[0] = (img + 1)->colour[0] = (img + 2)->colour[0] = (img + 3)->colour[0] = color[0] * alpha;
	img->colour[1] = (img + 1)->colour[1] = (img + 2)->colour[1] = (img + 3)->colour[1] = color[1] * alpha;
	img->colour[2] = (img + 1)->colour[2] = (img + 2)->colour[2] = (img + 3)->colour[2] = color[2] * alpha;
	img->colour[3] = (img + 1)->colour[3] = (img + 2)->colour[3] = (img + 3)->colour[3] = color[3] * overall_alpha;

	GLM_SetCoordinates(img, x, y, x + width, y + height, s, 0, t, 0, IMAGEPROG_FLAGS_TEXTURE);

	++imageData.imageCount;
}

void GLM_DrawImage(float x, float y, float width, float height, float tex_s, float tex_t, float tex_width, float tex_height, byte* color, int flags)
{
	float alpha = (color[3] * overall_alpha / 255.0f);
	glm_image_t* img = &imageData.images[imageData.imageCount * 4];

	img->colour[0] = (img + 1)->colour[0] = (img + 2)->colour[0] = (img + 3)->colour[0] = color[0] * alpha;
	img->colour[1] = (img + 1)->colour[1] = (img + 2)->colour[1] = (img + 3)->colour[1] = color[1] * alpha;
	img->colour[2] = (img + 1)->colour[2] = (img + 2)->colour[2] = (img + 3)->colour[2] = color[2] * alpha;
	img->colour[3] = (img + 1)->colour[3] = (img + 2)->colour[3] = (img + 3)->colour[3] = color[3] * overall_alpha;

	GLM_SetCoordinates(img, x, y, x + width, y + height, tex_s, tex_width, tex_t, tex_height, flags);

	++imageData.imageCount;
}

void GLM_AdjustImages(int first, int last, float x_offset)
{
	int i;

	for (i = first; i < last; ++i) {
		imageData.images[i * 4 + 0].pos[0] += x_offset;
		imageData.images[i * 4 + 1].pos[0] += x_offset;
		imageData.images[i * 4 + 2].pos[0] += x_offset;
		imageData.images[i * 4 + 3].pos[0] += x_offset;
	}
}

void GLM_HudPrepareImages(void)
{
	GLM_CreateMultiImageProgram();

	if (imageData.imageCount) {
		buffers.Update(r_buffer_hud_image_vertex_data, sizeof(imageData.images[0]) * imageData.imageCount * 4, imageData.images);
		if ((R_ProgramCustomOptions(r_program_hud_images) & GLM_HUDIMAGES_SMOOTHEVERYTHING) == 0) {
			// Everything is GL_NEAREST, no smoothing
			GL_SamplerSetNearest(0);
		}
		else if ((R_ProgramCustomOptions(r_program_hud_images) & GLM_HUDIMAGES_SMOOTHEVERYTHING) != GLM_HUDIMAGES_SMOOTHEVERYTHING) {
			// Mixed, second texture unit for GL_NEAREST
			GL_SamplerSetNearest(1);
		}
	}
}

qbool GLM_CreateMultiImageProgram(void)
{
	extern cvar_t r_smoothtext, r_smoothcrosshair, r_smoothimages, r_smoothalphahack;

	int program_flags =
		(r_smoothtext.integer ? GLM_HUDIMAGES_SMOOTHTEXT : 0) |
		(r_smoothcrosshair.integer ? GLM_HUDIMAGES_SMOOTHCROSSHAIR : 0) |
		(r_smoothimages.integer ? GLM_HUDIMAGES_SMOOTHIMAGES : 0) |
		(r_smoothalphahack.integer ? GLM_HUDIMAGES_ALPHAHACK : 0);

	if (R_ProgramRecompileNeeded(r_program_hud_images, program_flags)) {
		char included_definitions[512];
		int smooth_flags = (program_flags & GLM_HUDIMAGES_SMOOTHEVERYTHING);
		qbool mixed_sampling = smooth_flags != 0 && smooth_flags != GLM_HUDIMAGES_SMOOTHEVERYTHING;

		included_definitions[0] = '\0';

		if (mixed_sampling) {
			// depends on flags on individual elements
			strlcpy(included_definitions, "#define MIXED_SAMPLING\n", sizeof(included_definitions));
		}
		if (program_flags & GLM_HUDIMAGES_ALPHAHACK) {
			strlcpy(included_definitions, "#define PREMULT_ALPHA_HACK\n", sizeof(included_definitions));
		}

		// Initialise program for drawing image
		R_ProgramCompileWithInclude(r_program_hud_images, included_definitions);

		if (!GL_VersionAtLeast(4, 2) && R_ProgramReady(r_program_hud_images)) {
			R_ProgramUse(r_program_hud_images);
			R_ProgramUniform1i(r_program_uniform_hudimage_tex, 0);
		}

		R_ProgramSetCustomOptions(r_program_hud_images, program_flags);
	}

	if (!R_BufferReferenceIsValid(r_buffer_hud_image_vertex_data)) {
		buffers.Create(r_buffer_hud_image_vertex_data, buffertype_vertex, "image-vbo", sizeof(imageData.images), imageData.images, bufferusage_once_per_frame);
	}

	if (!R_VertexArrayCreated(vao_hud_images)) {
		R_GenVertexArray(vao_hud_images);

		if (!R_BufferReferenceIsValid(r_buffer_hud_image_index_data)) {
			GLuint i;
			int imageIndexLength = MAX_MULTI_IMAGE_BATCH * 5 * sizeof(GLuint);
			GLuint* imageIndexData = Q_malloc(imageIndexLength);

			for (i = 0; i < MAX_MULTI_IMAGE_BATCH; ++i) {
				imageIndexData[i * 5 + 0] = i * 4;
				imageIndexData[i * 5 + 1] = i * 4 + 1;
				imageIndexData[i * 5 + 2] = i * 4 + 2;
				imageIndexData[i * 5 + 3] = i * 4 + 3;
				imageIndexData[i * 5 + 4] = ~(GLuint)0;
			}

			buffers.Create(r_buffer_hud_image_index_data, buffertype_index, "image-indexes", imageIndexLength, imageIndexData, bufferusage_reuse_many_frames);
			Q_free(imageIndexData);
		}

		buffers.Bind(r_buffer_hud_image_index_data);
		GLM_ConfigureVertexAttribPointer(vao_hud_images, r_buffer_hud_image_vertex_data, 0, 2, GL_FLOAT, GL_FALSE, sizeof(imageData.images[0]), VBO_FIELDOFFSET(glm_image_t, pos), 0);
		GLM_ConfigureVertexAttribPointer(vao_hud_images, r_buffer_hud_image_vertex_data, 1, 2, GL_FLOAT, GL_FALSE, sizeof(imageData.images[0]), VBO_FIELDOFFSET(glm_image_t, tex), 0);
		GLM_ConfigureVertexAttribPointer(vao_hud_images, r_buffer_hud_image_vertex_data, 2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(imageData.images[0]), VBO_FIELDOFFSET(glm_image_t, colour), 0);
		GLM_ConfigureVertexAttribIPointer(vao_hud_images, r_buffer_hud_image_vertex_data, 3, 1, GL_INT, sizeof(imageData.images[0]), VBO_FIELDOFFSET(glm_image_t, flags), 0);
		R_BindVertexArray(vao_none);
	}

	return R_ProgramReady(r_program_hud_images);
}

void GLM_HudDrawImages(texture_ref texture, int start, int end)
{
	uintptr_t index_offset = (start * 5 * sizeof(GLuint));
	uintptr_t buffer_offset = buffers.BufferOffset(r_buffer_hud_image_vertex_data) / sizeof(imageData.images[0]);

	R_ProgramUse(r_program_hud_images);
	GLM_StateBeginImageDraw();
	if (R_TextureReferenceIsValid(texture)) {
		if ((R_ProgramCustomOptions(r_program_hud_images) & GLM_HUDIMAGES_SMOOTHEVERYTHING) != GLM_HUDIMAGES_SMOOTHEVERYTHING) {
			texture_ref textures[] = { texture, texture };

			renderer.TextureUnitMultiBind(0, 2, textures);
		}
		else {
			renderer.TextureUnitBind(0, texture);
		}
	}
	GL_DrawElementsBaseVertex(GL_TRIANGLE_STRIP, (end - start + 1) * 5, GL_UNSIGNED_INT, (GLvoid*)index_offset, buffer_offset);
}

qbool GLM_CompileHudCircleProgram(void)
{
	if (R_ProgramRecompileNeeded(r_program_hud_circles, 0)) {
		R_ProgramCompile(r_program_hud_circles);
	}

	return R_ProgramReady(r_program_hud_circles);
}

void GLM_HudPrepareCircles(void)
{
	// Build VBO
	if (!R_BufferReferenceIsValid(r_buffer_hud_circle_vertex_data)) {
		buffers.Create(r_buffer_hud_circle_vertex_data, buffertype_vertex, "circle-vbo", sizeof(circleData.drawCirclePointData), circleData.drawCirclePointData, bufferusage_once_per_frame);
	}
	else if (circleData.circleCount) {
		buffers.Update(r_buffer_hud_circle_vertex_data, circleData.circleCount * FLOATS_PER_CIRCLE * sizeof(circleData.drawCirclePointData[0]), circleData.drawCirclePointData);
	}

	// Build VAO
	if (!R_VertexArrayCreated(vao_hud_circles)) {
		R_GenVertexArray(vao_hud_circles);

		GLM_ConfigureVertexAttribPointer(vao_hud_circles, r_buffer_hud_circle_vertex_data, 0, 2, GL_FLOAT, GL_FALSE, 0, NULL, 0);
	}
}

void GLM_HudDrawCircles(texture_ref texture, int start, int end)
{
	// FIXME: Not very efficient (but rarely used either)
	int i;
	uintptr_t offset = buffers.BufferOffset(r_buffer_hud_circle_vertex_data) / (sizeof(float) * 2);

	start = max(0, start);
	end = min(end, circleData.circleCount - 1);

	R_ProgramUse(r_program_hud_circles);
	R_BindVertexArray(vao_hud_circles);
	R_ProgramUniformMatrix4fv(r_program_uniform_hud_circle_matrix, R_ProjectionMatrix());

	for (i = start; i <= end; ++i) {
		R_ProgramUniform4fv(r_program_uniform_hud_circle_color, circleData.drawCircleColors[i]);

		GL_DrawArrays(circleData.drawCircleFill[i] ? GL_TRIANGLE_STRIP : GL_LINE_LOOP, offset + i * FLOATS_PER_CIRCLE / 2, circleData.drawCirclePoints[i]);
	}
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_draw.h
================================================

#ifndef EZQUAKE_GLM_DRAW_HEADER
#define EZQUAKE_GLM_DRAW_HEADER

#define MAX_LINES_PER_FRAME 128

typedef struct glm_line_point_s {
	vec3_t position;
	byte color[4];
} glm_line_point_t;

typedef struct glm_line_framedata_s {
	float line_thickness[MAX_LINES_PER_FRAME];
	int imageIndex[MAX_LINES_PER_FRAME];
	int lineCount;
} glm_line_framedata_t;

#define CIRCLE_LINE_COUNT	40
#define FLOATS_PER_CIRCLE ((3 + 2 * CIRCLE_LINE_COUNT) * 2)
#define CIRCLES_PER_FRAME 256

typedef struct glm_circle_framedata_s {
	float drawCirclePointData[FLOATS_PER_CIRCLE * CIRCLES_PER_FRAME];
	float drawCircleColors[CIRCLES_PER_FRAME][4];
	qbool drawCircleFill[CIRCLES_PER_FRAME];
	int drawCirclePoints[CIRCLES_PER_FRAME];
	float drawCircleThickness[CIRCLES_PER_FRAME];

	int circleCount;
} glm_circle_framedata_t;

#define MAX_POLYGONS_PER_FRAME 8

typedef struct glm_polygon_framedata_s {
	int polygonVerts[MAX_POLYGONS_PER_FRAME];
	int polygonImageIndexes[MAX_POLYGONS_PER_FRAME];
	int polygonCount;
} glm_polygon_framedata_t;

#define MAX_MULTI_IMAGE_BATCH 4096
typedef enum {
	imagetype_image,
	imagetype_circle,
	imagetype_polygon,
	imagetype_line,

	imagetype_count
} r_image_type_t;

typedef struct glm_image_s {
	float pos[2];
	float tex[4];
	unsigned char colour[4];
	int flags;
} glm_image_t;

typedef struct glm_image_framedata_s {
	glm_image_t images[MAX_MULTI_IMAGE_BATCH * 4];

	int imageCount;
} glm_image_framedata_t;

extern glm_circle_framedata_t circleData;
extern glm_image_framedata_t imageData;
extern glm_polygon_framedata_t polygonData;
extern glm_line_framedata_t lineData;

qbool R_LogCustomImageType(r_image_type_t type, int index);
qbool R_LogCustomImageTypeWithTexture(r_image_type_t type, int index, texture_ref texture);
void R_HudUndoLastElement(void);

#endif


================================================
FILE: src/glm_framebuffer.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

// GLM_FrameBuffer.c
// Framebuffer support in OpenGL core

// For the moment, also contains general framebuffer code as immediate-mode isn't supported

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "gl_framebuffer.h"
#include "tr_types.h"
#include "glm_vao.h"
#include "r_buffers.h"
#include "glm_local.h"
#include "r_state.h"
#include "r_program.h"
#include "r_renderer.h"
#include "r_texture.h"

#define POST_PROCESS_PALETTE         1
#define POST_PROCESS_3DONLY          2
#define POST_PROCESS_TONEMAP         4
#define POST_PROCESS_FXAA            8

extern cvar_t vid_software_palette, vid_framebuffer, vid_framebuffer_hdr, vid_framebuffer_hdr_tonemap, vid_framebuffer_multisample;
static texture_ref non_framebuffer_screen_texture;

qbool GLM_CompilePostProcessVAO(void)
{
	if (!R_BufferReferenceIsValid(r_buffer_postprocess_vertex_data)) {
		float verts[4][5] = { { 0 } };

		VectorSet(verts[0], -1, -1, 0);
		verts[0][3] = 0;
		verts[0][4] = 0;

		VectorSet(verts[1], -1, 1, 0);
		verts[1][3] = 0;
		verts[1][4] = 1;

		VectorSet(verts[2], 1, -1, 0);
		verts[2][3] = 1;
		verts[2][4] = 0;

		VectorSet(verts[3], 1, 1, 0);
		verts[3][3] = 1;
		verts[3][4] = 1;

		buffers.Create(r_buffer_postprocess_vertex_data, buffertype_vertex, "post-process-screen", sizeof(verts), verts, bufferusage_reuse_many_frames);
	}

	if (R_BufferReferenceIsValid(r_buffer_postprocess_vertex_data) && !R_VertexArrayCreated(vao_postprocess)) {
		R_GenVertexArray(vao_postprocess);

		GLM_ConfigureVertexAttribPointer(vao_postprocess, r_buffer_postprocess_vertex_data, 0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)0, 0);
		GLM_ConfigureVertexAttribPointer(vao_postprocess, r_buffer_postprocess_vertex_data, 1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float) * 3), 0);

		R_BindVertexArray(vao_none);
	}

	return R_VertexArrayCreated(vao_postprocess);
}

// If this returns false then the framebuffer will be blitted instead
qbool GLM_CompilePostProcessProgram(void)
{
	int fxaa_preset = GL_FramebufferFxaaPreset();
	int post_process_flags =
		(vid_software_palette.integer ? POST_PROCESS_PALETTE : 0) |
		(vid_framebuffer.integer == USE_FRAMEBUFFER_3DONLY ? POST_PROCESS_3DONLY : 0) |
		(vid_framebuffer_hdr.integer && vid_framebuffer_hdr_tonemap.integer ? POST_PROCESS_TONEMAP : 0) |
		(fxaa_preset > 0 ? POST_PROCESS_FXAA : 0) | (fxaa_preset << 4); // mix in preset to detect change

	if (R_ProgramRecompileNeeded(r_program_post_process, post_process_flags)) {
		static char included_definitions[131072];

		memset(included_definitions, 0, sizeof(included_definitions));
		if (post_process_flags & POST_PROCESS_PALETTE) {
			strlcat(included_definitions, "#define EZ_POSTPROCESS_PALETTE\n", sizeof(included_definitions));
		}
		if (post_process_flags & POST_PROCESS_3DONLY) {
			strlcat(included_definitions, "#define EZ_POSTPROCESS_OVERLAY\n", sizeof(included_definitions));
		}
		if (post_process_flags & POST_PROCESS_TONEMAP) {
			strlcat(included_definitions, "#define EZ_POSTPROCESS_TONEMAP\n", sizeof(included_definitions));
		}
		if (post_process_flags & POST_PROCESS_FXAA) {
			extern const unsigned char fxaa_h_glsl[];
			char buffer[33];
			const char *settings =
					"#define EZ_POSTPROCESS_FXAA\n" \
					"#define FXAA_PC 1\n" \
					"#define FXAA_GLSL_130 1\n" \
					"#define FXAA_GREEN_AS_LUMA 1\n";
			snprintf(buffer, sizeof(buffer), "#define FXAA_QUALITY__PRESET %d\n", fxaa_preset);
			strlcat(included_definitions, settings, sizeof(included_definitions));
			strlcat(included_definitions, buffer, sizeof(included_definitions));
			strlcat(included_definitions, (const char *)fxaa_h_glsl, sizeof(included_definitions));
		}

		// Initialise program for drawing image
		R_ProgramCompileWithInclude(r_program_post_process, included_definitions);

		if (!GL_VersionAtLeast(4, 2) && R_ProgramReady(r_program_post_process)) {
			R_ProgramUse(r_program_post_process);
			R_ProgramUniform1i(r_program_uniform_postprocess_base, 0);
			R_ProgramUniform1i(r_program_uniform_postprocess_overlay, 1);
		}

		R_ProgramSetCustomOptions(r_program_post_process, post_process_flags);
	}

	return R_ProgramReady(r_program_post_process) && GLM_CompilePostProcessVAO();
}

qbool GLM_CompileSimpleProgram(void)
{
	if (R_ProgramRecompileNeeded(r_program_simple, 0)) {
		R_ProgramCompile(r_program_simple);
	}

	return R_ProgramReady(r_program_simple) && GLM_CompilePostProcessVAO();
}

void GLM_RenderFramebuffers(void)
{
	qbool flip2d = GL_FramebufferEnabled2D();
	qbool flip3d = GL_FramebufferEnabled3D();

	if (GLM_CompilePostProcessProgram()) {
		R_ProgramUse(r_program_post_process);
		R_ApplyRenderingState(r_state_default_2d);

		if (flip2d && flip3d) {
			renderer.TextureUnitBind(0, GL_FramebufferTextureReference(framebuffer_std, fbtex_standard));
			renderer.TextureUnitBind(1, GL_FramebufferTextureReference(framebuffer_hud, fbtex_standard));
		}
		else if (flip3d) {
			renderer.TextureUnitBind(0, GL_FramebufferTextureReference(framebuffer_std, fbtex_standard));
		}
		else if (flip2d) {
			renderer.TextureUnitBind(0, GL_FramebufferTextureReference(framebuffer_hud, fbtex_standard));
		}
		else {
			// Create screen texture if required
			if (!R_TextureReferenceIsValid(non_framebuffer_screen_texture) || R_TextureWidth(non_framebuffer_screen_texture) != glwidth || R_TextureHeight(non_framebuffer_screen_texture) != glheight) {
				if (R_TextureReferenceIsValid(non_framebuffer_screen_texture)) {
					renderer.TextureDelete(non_framebuffer_screen_texture);
				}
				non_framebuffer_screen_texture = R_LoadTexture("glm:postprocess", glwidth, glheight, NULL, TEX_NOCOMPRESS | TEX_NOSCALE | TEX_NO_TEXTUREMODE, 4);
				if (R_TextureReferenceIsValid(non_framebuffer_screen_texture))
					renderer.TextureSetFiltering(non_framebuffer_screen_texture, texture_minification_nearest, texture_magnification_nearest);
			}

			if (!R_TextureReferenceIsValid(non_framebuffer_screen_texture)) {
				return;
			}

			// Copy from screen to texture
			renderer.TextureUnitBind(0, non_framebuffer_screen_texture);
			glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, glwidth, glheight);
		}
		GL_DrawArrays(GL_TRIANGLE_STRIP, 0, 4);
	}
}

void GLM_BrightenScreen(void)
{
	float f;

	if (vid_hwgamma_enabled) {
		return;
	}
	if (v_contrast.value <= 1.0) {
		return;
	}

	f = min(v_contrast.value, 3);
	if (R_OldGammaBehaviour()) {
		extern float vid_gamma;

		f = pow(f, vid_gamma);
	}

	if (GLM_CompileSimpleProgram()) {
		R_ProgramUse(r_program_simple);
		R_ApplyRenderingState(r_state_brighten_screen);

		while (f > 1) {
			if (f >= 2) {
				float white[4] = { 1, 1, 1, 1 };

				R_ProgramUniform4fv(r_program_uniform_simple_color, white);
			}
			else {
				float shade[4] = { f - 1, f - 1, f - 1, f - 1 };

				R_ProgramUniform4fv(r_program_uniform_simple_color, shade);
			}

			GL_DrawArrays(GL_TRIANGLE_STRIP, 0, 4);

			f *= 0.5;
		}
	}
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_lightmaps.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "r_local.h"
#include "gl_local.h"
#include "r_lightmaps.h"
#include "r_lighting.h"
#include "r_texture.h"
#include "glsl/constants.glsl"
#include "r_lightmaps_internal.h"
#include "glm_local.h"
#include "gl_texture_internal.h"
#include "r_program.h"
#include "r_renderer.h"
#include "tr_types.h"

// Hardware lighting: flag surfaces as we add them
static texture_ref lightmap_texture_array;
static texture_ref lightmap_data_array;
static texture_ref lightmap_source_array;
static unsigned int lightmap_depth;
static unsigned int* surfaceTodoData;
static int surfaceTodoLength;
static int maximumSurfaceNumber;

texture_ref GLM_LightmapArray(void)
{
	return lightmap_texture_array;
}

qbool GLM_CompileLightmapComputeProgram(void)
{
	if (!GL_Supported(R_SUPPORT_COMPUTE_SHADERS)) {
		return false;
	}

	if (R_ProgramRecompileNeeded(r_program_lightmap_compute, 0) && R_ProgramCompile(r_program_lightmap_compute)) {
		R_ProgramComputeSetMemoryBarrierFlag(r_program_lightmap_compute, r_program_memory_barrier_image_access);
		R_ProgramComputeSetMemoryBarrierFlag(r_program_lightmap_compute, r_program_memory_barrier_texture_access);
	}

	return R_ProgramReady(r_program_lightmap_compute);
}

void GLM_ComputeLightmaps(void)
{
	int i, start;

	if (!GLM_CompileLightmapComputeProgram()) {
		return;
	}

	if (!R_BufferReferenceIsValid(r_buffer_brushmodel_lightstyles_ssbo)) {
		buffers.Create(r_buffer_brushmodel_lightstyles_ssbo, buffertype_storage, "lightstyles", sizeof(d_lightstylevalue), d_lightstylevalue, bufferusage_once_per_frame);
	}
	else {
		buffers.Update(r_buffer_brushmodel_lightstyles_ssbo, sizeof(d_lightstylevalue), d_lightstylevalue);
	}
	buffers.BindRange(r_buffer_brushmodel_lightstyles_ssbo, EZQ_STORAGE_BLOCK_BINDING(EZQ_GL_BINDINGPOINT_LIGHTSTYLES), buffers.BufferOffset(r_buffer_brushmodel_lightstyles_ssbo), sizeof(d_lightstylevalue));
	buffers.Update(r_buffer_brushmodel_surfacestolight_ssbo, surfaceTodoLength, surfaceTodoData);
	buffers.BindRange(r_buffer_brushmodel_surfacestolight_ssbo, EZQ_STORAGE_BLOCK_BINDING(EZQ_GL_BINDINGPOINT_SURFACES_TO_LIGHT), buffers.BufferOffset(r_buffer_brushmodel_surfacestolight_ssbo), surfaceTodoLength);

	GL_BindImageTexture(0, lightmap_source_array, 0, GL_TRUE, 0, GL_READ_ONLY, GL_RGBA32UI);
	GL_BindImageTexture(1, lightmap_texture_array, 0, GL_TRUE, 0, GL_WRITE_ONLY, GL_RGBA8);
	GL_BindImageTexture(2, lightmap_data_array, 0, GL_TRUE, 0, GL_READ_ONLY, GL_RGBA32I);

	start = -1;
	for (i = 0; i < lightmap_array_size; ++i) {
		if (lightmaps[i].modified) {
			if (start < 0) {
				start = i;
			}
			lightmaps[i].modified = false;
		}
		else if (start >= 0) {
			R_ProgramUniform1i(r_program_uniform_lighting_firstLightmap, start);
			R_ProgramComputeDispatch(r_program_lightmap_compute, LIGHTMAP_WIDTH / HW_LIGHTING_BLOCK_SIZE, LIGHTMAP_HEIGHT / HW_LIGHTING_BLOCK_SIZE, i - start);

			start = -1;
		}
	}

	if (start >= 0) {
		R_ProgramUniform1i(r_program_uniform_lighting_firstLightmap, start);
		R_ProgramComputeDispatch(r_program_lightmap_compute, LIGHTMAP_WIDTH / HW_LIGHTING_BLOCK_SIZE, LIGHTMAP_HEIGHT / HW_LIGHTING_BLOCK_SIZE, lightmap_array_size - start);
	}
	R_ProgramMemoryBarrier(r_program_lightmap_compute);
}

void GLM_CreateLightmapTextures(void)
{
	int i, j;

	maximumSurfaceNumber = 0;
	for (j = 1; j < MAX_MODELS; j++) {
		model_t* m = cl.model_precache[j];
		if (!m) {
			break;
		}
		if (m->name[0] == '*') {
			continue;
		}
		if (m->isworldmodel) {
			maximumSurfaceNumber = max(maximumSurfaceNumber, m->numsurfaces);
		}
	}

	// Round up to nearest 32
	surfaceTodoLength = ((maximumSurfaceNumber + 31) / 32) * sizeof(unsigned int);
	Q_free(surfaceTodoData);
	surfaceTodoData = (unsigned int*)Q_malloc(surfaceTodoLength);
	if (!R_BufferReferenceIsValid(r_buffer_brushmodel_surfacestolight_ssbo)) {
		buffers.Create(r_buffer_brushmodel_surfacestolight_ssbo, buffertype_storage, "surfaces-to-light", surfaceTodoLength, NULL, bufferusage_once_per_frame);
	}
	else {
		buffers.EnsureSize(r_buffer_brushmodel_surfacestolight_ssbo, surfaceTodoLength);
	}

	if (R_TextureReferenceIsValid(lightmap_texture_array) && lightmap_depth >= lightmap_array_size) {
		return;
	}

	if (R_TextureReferenceIsValid(lightmap_texture_array)) {
		R_DeleteTextureArray(&lightmap_texture_array);
	}

	if (R_TextureReferenceIsValid(lightmap_data_array)) {
		R_DeleteTextureArray(&lightmap_data_array);
	}

	if (R_TextureReferenceIsValid(lightmap_source_array)) {
		R_DeleteTextureArray(&lightmap_source_array);
	}

	GL_CreateTexturesWithIdentifier(texture_type_2d_array, 1, &lightmap_texture_array, "lightmap_texture_array");
	GL_TexStorage3D(GL_TEXTURE0, lightmap_texture_array, 1, GL_RGBA8, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, lightmap_array_size, true);
	R_SetTextureArraySize(lightmap_texture_array, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, lightmap_array_size, 4);
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nopengl-texture,alloc,%u,%d,%d,%d,%s\n", lightmap_texture_array.index, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT * lightmap_array_size * 4, "lightmap_texture_array");
#endif
	renderer.TextureSetFiltering(lightmap_texture_array, texture_minification_linear, texture_magnification_linear);
	renderer.TextureWrapModeClamp(lightmap_texture_array);
	lightmap_depth = lightmap_array_size;
	for (i = 0; i < lightmap_array_size; ++i) {
		lightmaps[i].gl_texref = lightmap_texture_array;
	}

	GL_CreateTexturesWithIdentifier(texture_type_2d_array, 1, &lightmap_source_array, "lightmap_source_array");
	GL_TexStorage3D(GL_TEXTURE0, lightmap_source_array, 1, GL_RGBA32UI, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, lightmap_array_size, false);
	R_SetTextureArraySize(lightmap_source_array, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, lightmap_array_size, 16);
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nopengl-texture,alloc,%u,%d,%d,%d,%s\n", lightmap_source_array.index, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT * lightmap_array_size * 16, "lightmap_source_array");
#endif

	GL_CreateTexturesWithIdentifier(texture_type_2d_array, 1, &lightmap_data_array, "lightmap_data_array");
	GL_TexStorage3D(GL_TEXTURE0, lightmap_data_array, 1, GL_RGBA32I, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, lightmap_array_size, false);
	R_SetTextureArraySize(lightmap_data_array, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, lightmap_array_size, 16);
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nopengl-texture,alloc,%u,%d,%d,%d,%s\n", lightmap_data_array.index, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT * lightmap_array_size * 16, "lightmap_data_array");
#endif
}

void GLM_InvalidateLightmapTextures(void)
{
	R_TextureReferenceInvalidate(lightmap_texture_array);
	R_TextureReferenceInvalidate(lightmap_data_array);
	R_TextureReferenceInvalidate(lightmap_source_array);
	lightmap_depth = 0;
}

void GLM_LightmapFrameInit(void)
{
	memset(surfaceTodoData, 0, surfaceTodoLength);
}

void GLM_LightmapShutdown(void)
{
	Q_free(surfaceTodoData);
	surfaceTodoLength = 0;
}

void GLM_RenderDynamicLightmaps(msurface_t* s, qbool world)
{
	R_RenderDynamicLightmaps(s, world);

	if (world && surfaceTodoData && s->surfacenum < maximumSurfaceNumber) {
		surfaceTodoData[s->surfacenum / 32] |= (1 << (s->surfacenum % 32));
		if (s->lightmaptexturenum >= 0 && s->lightmaptexturenum < lightmap_array_size) {
			lightmaps[s->lightmaptexturenum].modified = true;
		}
	}
}

void GLM_BuildLightmap(int i)
{
	GLenum format = GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS) ? GL_BGRA : GL_RGBA;
	GLenum type = GL_UNSIGNED_INT_8_8_8_8_REV;

	GL_TexSubImage3D(
		0, lightmap_texture_array, 0, 0, 0, i, LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, 1, format, type,
		lightmaps[i].rawdata
	);

	GL_TexSubImage3D(
		0, lightmap_source_array, 0, 0, 0, i,
		LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, 1, GL_RGBA_INTEGER, GL_UNSIGNED_INT,
		lightmaps[i].sourcedata
	);

	GL_TexSubImage3D(
		0, lightmap_data_array, 0, 0, 0, i,
		LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT, 1, GL_RGBA_INTEGER, GL_INT,
		lightmaps[i].computeData
	);
}

void GLM_UploadLightmap(int textureUnit, int lightmapnum)
{
	const lightmap_data_t* lm = &lightmaps[lightmapnum];
	const void* data_source = lm->rawdata + (lm->change_area.t) * LIGHTMAP_WIDTH * 4;
	GLenum format = GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS) ? GL_BGRA : GL_RGBA;
	GLenum type = GL_Supported(R_SUPPORT_INT8888R_LIGHTMAPS) ? GL_UNSIGNED_INT_8_8_8_8_REV : GL_UNSIGNED_BYTE;

	GL_TexSubImage3D(textureUnit, lightmap_texture_array, 0, 0, lm->change_area.t, lightmapnum, LIGHTMAP_WIDTH, lm->change_area.h, 1, format, type, data_source);
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_local.h
================================================

#ifndef EZQUAKE_GLM_LOCAL_HEADER
#define EZQUAKE_GLM_LOCAL_HEADER

void GLM_BuildCommonTextureArrays(qbool vid_restart);
void GLM_Shutdown(r_shutdown_mode_t mode);

// Reference cvars for 3D views...
typedef struct uniform_block_frame_constants_s {
	float modelViewMatrix[16];
	float projectionMatrix[16];

	float lightPosition[MAX_DLIGHTS][4];
	float lightColor[MAX_DLIGHTS][4];

	float position[3];
	int lightsActive;

	// Drawflat colors
	float r_wallcolor[4];
	float r_floorcolor[4];
	float r_telecolor[4];
	float r_lavacolor[4];
	float r_slimecolor[4];
	float r_watercolor[4];
	float r_skycolor[4];
	float v_blend[4];

	//
	float time;
	float gamma;
	float contrast;
	int r_alphatestfont;

	// turb settings
	float skySpeedscale;
	float skySpeedscale2;
	float r_farclip_unused;                  // NO LONGER USED, replace
	float padding;

	// animated skybox
	vec3_t windDir;
	float  windPhase;

	// drawflat toggles (combine into bitfield?)
	int r_drawflat;
	int r_fastturb;
	int r_fastsky;
	int r_textureless;

	float unused_r_texture_luma_fb_bmodels;

	// powerup shells round alias models
	float shellSize_unused;                  // IS NOW CONSTANT 0.5, replace
	float shell_base_level1;
	float shell_base_level2;
	float shell_effect_level1;
	float shell_effect_level2;
	float shell_alpha;

	// hardware lighting scale
	float lightScale;

	// [4-byte break]
	int r_width;
	int r_height;
	float r_zFar;
	float r_zNear;

	// fog parameters
	float fogColor[3];
	float fogDensity;

	float skyFogMix;
	float fogMinZ;
	float fogMaxZ;
	// camangles [0]

	float camangles[3]; // [1] [2]
	float r_inv_width;
	float r_inv_height;
} uniform_block_frame_constants_t;

#define MAX_WORLDMODEL_BATCH     64
#define MAX_SPRITE_BATCH         MAX_STANDARD_ENTITIES
#define MAX_SAMPLER_MAPPINGS    256

typedef struct sampler_mapping_s {
	int samplerIndex;
	float arrayIndex;
	int flags;
	int padding;
} sampler_mapping_t;

typedef struct uniform_block_world_calldata_s {
	float modelMatrix[16];
	float alpha;
	int samplerBase;
	int flags;
	int sampler;
} uniform_block_world_calldata_t;

typedef struct uniform_block_sprite_s {
	float modelView[16];
	float tex[2];
	int skinNumber;
	int padding;
} uniform_block_sprite_t;

typedef struct uniform_block_spritedata_s {
	uniform_block_sprite_t sprites[MAX_SPRITE_BATCH];
} uniform_block_spritedata_t;

void GLM_PreRenderView(void);
void GLM_SetupGL(void);

void GLM_InitialiseAliasModelBatches(void);
void GLM_PrepareAliasModelBatches(void);
void GLM_DrawAliasModelBatches(void);
void GLM_DrawAliasModelPostSceneBatches(void);

void GLM_StateBeginPolyBlend(void);
void GLM_StateBeginDraw3DSprites(void);
void GLM_BeginDrawWorld(qbool alpha_surfaces, qbool polygon_offset);

void GLM_UploadFrameConstants(void);

void GLM_StateBeginImageDraw(void);

typedef enum {
	opaque_world,      // also contains alpha-tested
	alpha_surfaces
} glm_brushmodel_drawcall_type;

void GLM_DrawWorldModelBatch(glm_brushmodel_drawcall_type type);
void GLM_DrawWorld(void);

#endif // EZQUAKE_GLM_LOCAL_HEADER


================================================
FILE: src/glm_main.c
================================================

#include "quakedef.h"
#include "glm_vao.h"
#include "r_renderer.h"
#include "gl_framebuffer.h"

#ifdef RENDERER_OPTION_MODERN_OPENGL

void GL_Init(void);
void GL_InitialiseBufferHandling(api_buffers_t* api);
void GL_InitialiseState(void);

static void R_Stubs_NoOperationEntity(entity_t* ent)
{
}

static void R_Stubs_NoOperation(void)
{
}

#ifndef WITH_RENDERING_TRACE
static void GLM_TextureLabelSetNull(texture_ref texture, const char* name)
{
}
#endif

static void GLM_Begin2DRendering(void)
{
	GL_Framebuffer2DSwitch();
}

#define GLM_PrintGfxInfo                   GL_PrintGfxInfo
#define GLM_Viewport                       GL_Viewport
#define GLM_InvalidateViewport             GL_InvalidateViewport
#define GLM_ClearRenderingSurface          GL_Clear
#define GLM_EnsureFinished                 GL_EnsureFinished
#define GLM_Screenshot                     GL_Screenshot
#define GLM_ScreenshotWidth                GL_ScreenshotWidth
#define GLM_ScreenshotHeight               GL_ScreenshotHeight
#define GLM_InitialiseVAOState             GL_InitialiseVAOState
#define GLM_DescriptiveString              GL_DescriptiveString
#define GLM_Draw3DSpritesInline            R_Stubs_NoOperation
#define GLM_DrawDisc                       R_Stubs_NoOperation
#define GLM_IsFramebufferEnabled3D         GL_FramebufferEnabled3D
#define GLM_DrawAliasModelShadow           R_Stubs_NoOperationEntity
#define GLM_DrawAliasModelPowerupShell     R_Stubs_NoOperationEntity
#define GLM_DrawAlias3ModelPowerupShell    R_Stubs_NoOperationEntity
#define GLM_TextureInitialiseState         GL_TextureInitialiseState
#define GLM_TextureDelete                  GL_TextureDelete
#define GLM_TextureMipmapGenerate          GL_TextureMipmapGenerate
#define GLM_TextureWrapModeClamp           GL_TextureWrapModeClamp
#ifdef WITH_RENDERING_TRACE
#define GLM_TextureLabelSet                GL_TextureLabelSet
#else
#define GLM_TextureLabelSet                GLM_TextureLabelSetNull
#endif
#define GLM_TextureUnitBind                GL_EnsureTextureUnitBound
#define GLM_TextureGet                     GL_TextureGet
#define GLM_TextureCompressionSet          GL_TextureCompressionSet
#define GLM_TextureCreate2D                GL_TextureCreate2D
#define GLM_TextureUnitMultiBind           GL_TextureUnitMultiBind
#define GLM_TexturesCreate                 GL_TexturesCreate
#define GLM_TextureReplaceSubImageRGBA     GL_TextureReplaceSubImageRGBA
#define GLM_TextureSetAnisotropy           GL_TextureSetAnisotropy
#define GLM_TextureSetFiltering            GL_TextureSetFiltering
#define GLM_TextureLoadCubemapFace         GL_TextureLoadCubemapFace
#define GLM_CvarForceRecompile             GL_CvarForceRecompile
#define GLM_ProgramsInitialise             GL_ProgramsInitialise
#define GLM_ProgramsShutdown               GL_ProgramsShutdown
#define GLM_DrawSky                        R_Stubs_NoOperation
#define GLM_PrepareAliasModel              GL_PrepareAliasModel
#define GLM_TextureIsUnitBound             GL_IsTextureBound
#define GLM_FramebufferCreate              GL_FramebufferCreate

#define RENDERER_METHOD(returntype, name, ...) \
{ \
	extern returntype GLM_ ## name(__VA_ARGS__); \
	renderer.name = GLM_ ## name; \
}

void GLM_Initialise(void)
{
#include "r_renderer_structure.h"

	GL_Init();
	renderer.vaos_supported = GLM_InitialiseVAOHandling();
	GL_InitialiseBufferHandling(&buffers);
	GL_InitialiseState();
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_md3.c
================================================
/*
Copyright (C) 2011 fuh and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// Code to display .md3 files
#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "r_aliasmodel_md3.h"
#include "r_aliasmodel.h"
#include "vx_vertexlights.h" 
#include "r_matrix.h"
#include "rulesets.h"

void GLM_DrawAlias3Model(entity_t* ent, qbool outline, qbool additive_pass)
{
	extern void R_AliasSetupLighting(entity_t* ent);

	float lerpfrac = 1;
	float oldMatrix[16];
	int v1, v2;

	model_t* mod = ent->model;
	md3model_t* md3Model = (md3model_t *)Mod_Extradata(mod);
	surfinf_t* surfaceInfo = MD3_ExtraSurfaceInfoForModel(md3Model);
	md3Header_t* pHeader = MD3_HeaderForModel(md3Model);
	md3Surface_t* surf;
	int frame1, frame2, surfnum, vertsPerFrame = 0;

	MD3_ForEachSurface(pHeader, surf, surfnum) {
		vertsPerFrame += 3 * surf->numTriangles;
	}

	if (ent->skinnum >= 0 && ent->skinnum < pHeader->numSkins) {
		surfaceInfo += ent->skinnum * pHeader->numSurfaces;
	}

	R_PushModelviewMatrix(oldMatrix);
	R_AliasModelPrepare(ent, pHeader->numFrames, &frame1, &frame2, &lerpfrac, &outline);

	v1 = mod->vbo_start + vertsPerFrame * frame1;
	v2 = mod->vbo_start + vertsPerFrame * frame2;
	MD3_ForEachSurface(pHeader, surf, surfnum) {
		// FIXME: hack for not reading different shader types
		int extra_fx = ((mod->modhint & MOD_VMODEL) && surfnum >= 1 ? RF_ADDITIVEBLEND : 0);

		GLM_DrawAliasModelFrame(
			ent, mod, v1, v2, 3 * surf->numTriangles,
			surfaceInfo[surfnum].texnum, outline, ent->effects, ent->renderfx | extra_fx, lerpfrac
		);
		v1 += 3 * surf->numTriangles;
		v2 += 3 * surf->numTriangles;
	}

	R_PopModelviewMatrix(oldMatrix);
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_misc.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "gl_framebuffer.h"
#include "tr_types.h"
#include "glsl/constants.glsl"
#include "r_lighting.h"
#include "r_matrix.h"
#include "r_buffers.h"
#include "glm_local.h"
#include "r_renderer.h"
#include "gl_texture.h"
#include "r_brushmodel_sky.h"

static uniform_block_frame_constants_t frameConstants;
static qbool frameConstantsUploaded = false;

void GLM_UploadFrameConstants(void);

#define PASS_COLOR_AS_4F(target, cvar) \
{ \
	target[0] = (cvar.color[0] * 1.0f / 255); \
	target[1] = (cvar.color[1] * 1.0f / 255); \
	target[2] = (cvar.color[2] * 1.0f / 255); \
	target[3] = 1.0f; \
}

// TODO: !?  Called as first step in 2D.  Include in frame-buffer at end of 3D scene rendering?
void GLM_PolyBlend(float v_blend[4])
{
	color_t v_blend_color = RGBA_TO_COLOR(
		bound(0, v_blend[0], 1) * 255,
		bound(0, v_blend[1], 1) * 255,
		bound(0, v_blend[2], 1) * 255,
		bound(0, v_blend[3], 1) * 255
	);

	GLM_StateBeginPolyBlend();
	Draw_AlphaRectangleRGB(r_refdef.vrect.x, r_refdef.vrect.y, r_refdef.vrect.width, r_refdef.vrect.height, 0.0f, true, v_blend_color);
}

void GLM_PreRenderView(void)
{
	extern cvar_t gl_alphafont, gl_max_size;
	extern cvar_t r_telecolor, r_lavacolor, r_slimecolor, r_watercolor, r_fastturb, r_skycolor;
	extern cvar_t gl_textureless, gl_hwblend;
	int i, active_lights = 0;
	float blend_alpha;

	// General constants
	frameConstants.time = cl.time;
	frameConstants.gamma = bound(0.3, v_gamma.value, 3);
	frameConstants.contrast = bound(1, v_contrast.value, 3);
	frameConstants.r_alphatestfont = gl_alphafont.integer ? 0 : 1;
	blend_alpha = (!vid_hwgamma_enabled || !gl_hwblend.value || cl.teamfortress) ? 0 : v_blend[3];
	frameConstants.v_blend[0] = v_blend[0] * blend_alpha;
	frameConstants.v_blend[1] = v_blend[1] * blend_alpha;
	frameConstants.v_blend[2] = v_blend[2] * blend_alpha;
	frameConstants.v_blend[3] = 1 - blend_alpha;

	// Lights
	for (i = 0; i < MAX_DLIGHTS; ++i) {
		if (cl_dlight_active[i / 32] & (1 << (i % 32))) {
			extern cvar_t gl_colorlights;

			dlight_t* light = &cl_dlights[i];
			float* lightColor = frameConstants.lightColor[active_lights];
			float* lightPosition = frameConstants.lightPosition[active_lights];
			
			VectorCopy(light->origin, lightPosition);
			lightPosition[3] = light->radius;
			if (gl_colorlights.integer) {
				if (light->type == lt_custom) {
					lightColor[0] = light->color[0] / 255.0;
					lightColor[1] = light->color[1] / 255.0;
					lightColor[2] = light->color[2] / 255.0;
				}
				else {
					lightColor[0] = dlightcolor[light->type][0] / 255.0;
					lightColor[1] = dlightcolor[light->type][1] / 255.0;
					lightColor[2] = dlightcolor[light->type][2] / 255.0;
				}
			}
			else {
				lightColor[0] = lightColor[1] = lightColor[2] = 0.5;
			}
			lightColor[3] = light->minlight;
			++active_lights;
		}
	}
	frameConstants.lightsActive = active_lights;
	frameConstants.lightScale = ((lightmode == 2 ? 1.5 : 2) * bound(0.5, gl_modulate.value, 3));

	// Draw-world constants
	frameConstants.r_textureless = gl_textureless.integer || gl_max_size.integer == 1;
	frameConstants.skySpeedscale = r_refdef2.time * 8;
	frameConstants.skySpeedscale -= (int)frameConstants.skySpeedscale & ~127;
	frameConstants.skySpeedscale /= 128.0f;
	frameConstants.skySpeedscale2 = r_refdef2.time * 16;
	frameConstants.skySpeedscale2 -= (int)frameConstants.skySpeedscale2 & ~127;
	frameConstants.skySpeedscale2 /= 128.0f;

	frameConstants.r_drawflat = r_drawflat.integer;
	PASS_COLOR_AS_4F(frameConstants.r_wallcolor, r_wallcolor);
	PASS_COLOR_AS_4F(frameConstants.r_floorcolor, r_floorcolor);

	frameConstants.r_fastturb = r_fastturb.integer;
	PASS_COLOR_AS_4F(frameConstants.r_telecolor, r_telecolor);
	PASS_COLOR_AS_4F(frameConstants.r_lavacolor, r_lavacolor);
	PASS_COLOR_AS_4F(frameConstants.r_slimecolor, r_slimecolor);
	PASS_COLOR_AS_4F(frameConstants.r_watercolor, r_watercolor);

	PASS_COLOR_AS_4F(frameConstants.r_skycolor, r_skycolor);

	// Alias models
	{
		extern cvar_t gl_powerupshells_base1level, gl_powerupshells_base2level;
		extern cvar_t gl_powerupshells_effect1level, gl_powerupshells_effect2level;

		frameConstants.shellSize_unused = 0.5f;
		frameConstants.shell_base_level1 = gl_powerupshells_base1level.value;
		frameConstants.shell_base_level2 = gl_powerupshells_base2level.value;
		frameConstants.shell_effect_level1 = gl_powerupshells_effect1level.value;
		frameConstants.shell_effect_level2 = gl_powerupshells_effect2level.value;
		frameConstants.shell_alpha = bound(0, gl_powerupshells.value, 1);
	}

	// Window constants
	frameConstants.r_width = VID_ScaledWidth3D();
	frameConstants.r_height = VID_ScaledHeight3D();
	frameConstants.r_inv_width = 1.0f / (float) frameConstants.r_width;
	frameConstants.r_inv_height = 1.0f / (float) frameConstants.r_height;
	frameConstants.r_zFar = R_FarPlaneZ();
	frameConstants.r_zNear = R_NearPlaneZ();

	// fog colors
	VectorCopy(r_refdef2.fog_color, frameConstants.fogColor);
	frameConstants.fogMinZ = r_refdef2.fog_linear_start;
	frameConstants.fogMaxZ = r_refdef2.fog_linear_end;
	frameConstants.skyFogMix = r_refdef2.fog_sky;
	frameConstants.fogDensity = r_refdef2.fog_density; // (r_refdef2.fog_calculation == fogcalc_exp2 ? r_refdef2.fog_density * r_refdef2.fog_density : r_refdef2.fog_density);

	Skywind_GetDirectionAndPhase(frameConstants.windDir, &frameConstants.windPhase);

	frameConstantsUploaded = false;
}

void GLM_SetupGL(void)
{
	memcpy(frameConstants.modelViewMatrix, R_ModelviewMatrix(), sizeof(frameConstants.modelViewMatrix));
	memcpy(frameConstants.projectionMatrix, R_ProjectionMatrix(), sizeof(frameConstants.projectionMatrix));
	VectorCopy(r_refdef.vieworg, frameConstants.position);

	frameConstants.camangles[PITCH] = DEG2RAD(r_refdef.viewangles[PITCH]);
	frameConstants.camangles[YAW] = DEG2RAD(r_refdef.viewangles[YAW]);
	frameConstants.camangles[ROLL] = DEG2RAD(r_refdef.viewangles[ROLL]);

	frameConstantsUploaded = false;
}

void GLM_UploadFrameConstants(void)
{
	if (!frameConstantsUploaded) {
		if (!R_BufferReferenceIsValid(r_buffer_frame_constants)) {
			buffers.Create(r_buffer_frame_constants, buffertype_uniform, "frameConstants", sizeof(frameConstants), &frameConstants, bufferusage_once_per_frame);
		}

		buffers.BindRange(r_buffer_frame_constants, EZQ_GL_BINDINGPOINT_FRAMECONSTANTS, buffers.BufferOffset(r_buffer_frame_constants), sizeof(frameConstants));
		buffers.Update(r_buffer_frame_constants, sizeof(frameConstants), &frameConstants);
		frameConstantsUploaded = true;
	}
}

void GLM_ScreenDrawStart(void)
{
	GL_FramebufferScreenDrawStart();
}

void GLM_PostProcessScreen(void)
{
	GL_FramebufferPostProcessScreen();
}

void GLM_Shutdown(r_shutdown_mode_t mode)
{
	if (mode != r_shutdown_reload) {
		renderer.ProgramsShutdown(mode == r_shutdown_restart);
		GL_DeleteSamplers();
	}
	GL_FramebufferDeleteAll();
}

#endif


================================================
FILE: src/glm_particles.c
================================================
/*
Copyright (C) 2018 ezQuake team.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "glm_particles.h"
#include "gl_model.h"
#include "gl_local.h"
#include "gl_texture_internal.h"
#include "gl_sprite3d.h"
#include "particles_classic.h"

extern texture_ref particletexture;
texture_ref particletexture_array;
int particletexture_array_index;
float particletexture_array_xpos_tr;
float particletexture_array_ypos_tr;
float particletexture_array_max_s = 1.0f;
float particletexture_array_max_t = 1.0f;
static float particletexture_scale_s;
static float particletexture_scale_t;

byte* Classic_CreateParticleTexture(int width, int height);

void Part_FlagTexturesForArray(texture_flag_t* texture_flags)
{
	if (R_TextureReferenceIsValid(particletexture)) {
		texture_flags[particletexture.index].flags |= (1 << TEXTURETYPES_SPRITES);
	}
}

void Part_ImportTexturesForArrayReferences(texture_flag_t* texture_flags)
{
	if (R_TextureReferenceIsValid(particletexture)) {
		texture_array_ref_t* array_ref = &texture_flags[particletexture.index].array_ref[TEXTURETYPES_SPRITES];

		if (!R_TexturesAreSameSize(array_ref->ref, particletexture)) {
			int width = R_TextureWidth(array_ref->ref);
			int height = R_TextureHeight(array_ref->ref);
			byte* data = Classic_CreateParticleTexture(width, height);

			GL_TexSubImage3D(0, array_ref->ref, 0, 0, 0, array_ref->index, width, height, 1, GL_RGBA, GL_UNSIGNED_BYTE, data);

			Q_free(data);
		}

		{
			float width = R_TextureWidth(array_ref->ref);
			float height = R_TextureHeight(array_ref->ref);

			particletexture_array = array_ref->ref;
			particletexture_array_xpos_tr = (width - 1.0f) / width;
			particletexture_array_ypos_tr = (height - 1.0f) / height;
			particletexture_array_max_s = min(width, height) / width;
			particletexture_array_max_t = min(width, height) / height;
			particletexture_array_index = array_ref->index;
			particletexture_scale_s = array_ref->scale_s;
			particletexture_scale_t = array_ref->scale_t;
		}
	}
}

void GLM_LoadParticleTextures(void)
{
	if (R_TextureReferenceIsValid(particletexture_array)) {
		int width = R_TextureWidth(particletexture_array);
		int height = R_TextureHeight(particletexture_array);
		byte* data = Classic_CreateParticleTexture(width, height);

		GL_TexSubImage3D(0, particletexture_array, 0, 0, 0, particletexture_array_index, width, height, 1, GL_RGBA, GL_UNSIGNED_BYTE, data);
		GL_TextureMipmapGenerate(particletexture_array);

		Q_free(data);
	}
}

void GLM_DrawClassicParticles(int particles_to_draw)
{
	r_sprite3d_vert_t* vert;

	R_Sprite3DInitialiseBatch(SPRITE3D_PARTICLES_CLASSIC, r_state_particles_classic, particletexture_array, particletexture_array_index, r_primitive_triangles);
	vert = R_Sprite3DAddEntry(SPRITE3D_PARTICLES_CLASSIC, 3 * particles_to_draw);
	if (vert) {
		extern r_sprite3d_vert_t glvertices[ABSOLUTE_MAX_PARTICLES * 3];

		memcpy(vert, glvertices, particles_to_draw * 3 * sizeof(glvertices[0]));
	}
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_particles.h
================================================
/*
Copyright (C) 2018 ezQuake team.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_GLM_PARTICLES_HEADER
#define EZQUAKE_GLM_PARTICLES_HEADER

#include "glm_texture_arrays.h"
#include "r_texture.h"

extern texture_ref particletexture_array;
extern int particletexture_array_index;

void GLM_LoadParticleTextures(void);
void Part_ImportTexturesForArrayReferences(texture_flag_t* texture_flags);
void Part_FlagTexturesForArray(texture_flag_t* texture_flags);

#endif // EZQUAKE_GLM_PARTICLES_HEADER


================================================
FILE: src/glm_performance.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: gl_rmisc.c,v 1.27 2007-09-17 19:37:55 qqshka Exp $
*/
// gl_rmisc.c

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "tr_types.h"
#include "r_renderer.h"

void GLM_TimeRefresh(void)
{
	int i;
	float start, stop, time;

	if (!GL_FramebufferEnabled2D()) {
#ifndef __APPLE__
		if (glConfig.hardwareType != GLHW_INTEL) {
			// Causes the console to flicker on Intel cards.
			glDrawBuffer(GL_FRONT);
		}
#endif
	}

	renderer.EnsureFinished();

	start = Sys_DoubleTime();
	for (i = 0; i < 128; i++) {
		r_refdef.viewangles[1] = i * (360.0 / 128.0);
		R_SetupFrame();
		R_RenderView();
	}

	renderer.EnsureFinished();
	stop = Sys_DoubleTime();
	time = stop - start;
	Com_Printf("%f seconds (%f fps)\n", time, 128 / time);

	if (!GL_FramebufferEnabled2D()) {
#ifndef __APPLE__
		if (glConfig.hardwareType != GLHW_INTEL) {
			glDrawBuffer(GL_BACK);
		}
#endif
	}

	R_EndRendering();
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_rmain.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "glm_local.h"
#include "glm_brushmodel.h"
#include "gl_framebuffer.h"
#include "tr_types.h"
#include "glm_vao.h"
#include "r_buffers.h"
#include "glm_local.h"
#include "r_program.h"
#include "r_renderer.h"
#include "r_aliasmodel.h"
#include "r_renderer.h"
#include "r_sprite3d.h"
#include "r_state.h"
#include "r_matrix.h"

texture_ref GL_FramebufferTextureReference(framebuffer_id id, fbtex_id tex_id);
qbool GLM_CompilePostProcessVAO(void);

// If this returns false then the framebuffer will be blitted instead
qbool GLM_CompileWorldGeometryProgram(void)
{
	int post_process_flags = 0;

	if (R_ProgramRecompileNeeded(r_program_fx_world_geometry, post_process_flags)) {
		// Initialise program for drawing image
		R_ProgramCompile(r_program_fx_world_geometry);

		if (!GL_VersionAtLeast(4, 2) && R_ProgramReady(r_program_fx_world_geometry)) {
			R_ProgramUse(r_program_fx_world_geometry);
			R_ProgramUniform1i(r_program_uniform_fxworldgeometry_normaltex, 0);
		}

		R_ProgramSetCustomOptions(r_program_fx_world_geometry, post_process_flags);
	}

	return R_ProgramReady(r_program_fx_world_geometry) && GLM_CompilePostProcessVAO();
}

static void GLM_DrawWorldOutlines(void)
{
	texture_ref normals = GL_FramebufferTextureReference(framebuffer_std, fbtex_worldnormals);

	if (R_TextureReferenceIsValid(normals) && GLM_CompileWorldGeometryProgram()) {
		int viewport[4];
		int fullscreen_viewport[4];
		extern cvar_t gl_outline_color_world, gl_outline_world_depth_threshold, gl_outline_world_normal_threshold;

		R_GetViewport(viewport);

		// If we are only rendering to a section of the screen then that is the only part of the texture that will be filled in
		if (CL_MultiviewEnabled()) {
			R_GetFullScreenViewport(fullscreen_viewport);
			R_Viewport(fullscreen_viewport[0], fullscreen_viewport[1], fullscreen_viewport[2], fullscreen_viewport[3]);
			R_EnableScissorTest(viewport[0], viewport[1], viewport[2], viewport[3]);
		} else {
			// ignore viewsize and allat crap and set the viewport size to the whole window.
			// previously the viewport was already resized, and then resized again later, making the outlines not align.
			R_Viewport(0, 0, VID_ScaledWidth3D(), VID_ScaledHeight3D());
		}

		renderer.TextureUnitBind(0, normals);

		R_ProgramUniform1f(r_program_uniform_outline_depth_threshold, bound(1, gl_outline_world_depth_threshold.value, 16));
		R_ProgramUniform1f(r_program_uniform_outline_normal_threshold, bound(0, gl_outline_world_normal_threshold.value, 0.999));
		R_ProgramUniform3f(r_program_uniform_outline_color,
                           (float)gl_outline_color_world.color[0] / 255.0f,
                           (float)gl_outline_color_world.color[1] / 255.0f,
                           (float)gl_outline_color_world.color[2] / 255.0f);

		// Scaling the outline with framebuffer resolution for consistency
		// Outline scaling factor bounds:
		// - 1:1 for upscaling a smaller FB (only one pixel needed, as they get bigger and bigger and bloat the view),
		// - 4:1 for downscaling a larger FB (max effective framebuffer scale)
		// MAX is better at high scales and mismatched x/y ratios
		// (maintains more outline at high FB scale, consistent with base res).
		// MIN/MAX makes no difference at tiny scales

		float fb_scale_x = VID_ScaledWidth3D() / glConfig.vidWidth;
		float fb_scale_y = VID_ScaledHeight3D() / glConfig.vidHeight;
		float fb_scaling = bound(1,(max(fb_scale_x, fb_scale_y)),4);
		R_ProgramUniform1f(r_program_uniform_outline_scale, fb_scaling);

		R_ProgramUse(r_program_fx_world_geometry);
		R_ApplyRenderingState(r_state_fx_world_geometry);

		GL_DrawArrays(GL_TRIANGLE_STRIP, 0, 4);

		// Restore viewport
		R_Viewport(viewport[0], viewport[1], viewport[2], viewport[3]);
		if (CL_MultiviewEnabled()) {
			R_DisableScissorTest();
		}
	}
}

void GLM_RenderView(void)
{
	GLM_UploadFrameConstants();
	R_UploadChangedLightmaps();
	GLM_PrepareWorldModelBatch();
	GLM_PrepareAliasModelBatches();
	renderer.Prepare3DSprites();

	if (GL_FramebufferStartWorldNormals(framebuffer_std)) {
		GLM_DrawWorldModelBatch(opaque_world);
		GL_FramebufferEndWorldNormals(framebuffer_std);
		GLM_DrawWorldOutlines();
	}
	else {
		GLM_DrawWorldModelBatch(opaque_world);
	}

	R_TraceEnterNamedRegion("GLM_DrawEntities");
	GLM_DrawAliasModelBatches();
	R_TraceLeaveNamedRegion();

	renderer.Draw3DSprites();

	GLM_DrawWorldModelBatch(alpha_surfaces);

	GLM_DrawAliasModelPostSceneBatches();
}

void GLM_PrepareModelRendering(qbool vid_restart)
{
	GLM_BuildCommonTextureArrays(vid_restart);

	if (cls.state != ca_disconnected) {
		R_CreateInstanceVBO();
		R_CreateAliasModelVBO();
		R_BrushModelCreateVBO();

		GLM_CreateBrushModelVAO();
	}
	renderer.ProgramsInitialise();
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL



================================================
FILE: src/glm_rsurf.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// glm_surf.c: surface-related refresh code (modern OpenGL)

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "rulesets.h"
#include "utils.h"
#include "tr_types.h"
#include "glsl/constants.glsl"
#include "glm_brushmodel.h"
#include "r_brushmodel_sky.h"
#include "r_matrix.h"
#include "glm_vao.h"
#include "glm_local.h"
#include "r_texture.h"
#include "r_brushmodel.h"
#include "r_buffers.h"
#include "r_program.h"
#include "r_renderer.h"

#define GLM_DRAWCALL_INCREMENT 8

static GLuint index_count;

typedef struct glm_worldmodel_req_s {
	// This is DrawElementsIndirectCmd, from OpenGL spec
	GLuint count;           // Number of indexes to pull
	GLuint instanceCount;   // Always 1... ?
	GLuint firstIndex;      // Position of first index in array
	GLuint baseVertex;      // Offset of vertices in VBO
	GLuint baseInstance;    // We use this to pull from array of uniforms in shader

	float mvMatrix[16];
	int flags;
	int samplerMappingBase;
	int samplerMappingCount;
	int firstTexture;
	qbool isAlphaTested;
	float alpha;
	qbool polygonOffset;
	qbool worldmodel;
	model_t* model;
	int nonDynamicSampler;
} glm_worldmodel_req_t;

typedef struct glm_brushmodel_drawcall_s {
	uniform_block_world_calldata_t calls[MAX_WORLDMODEL_BATCH];
	sampler_mapping_t mappings[MAX_SAMPLER_MAPPINGS];

	glm_worldmodel_req_t worldmodel_requests[MAX_WORLDMODEL_BATCH];
	texture_ref allocated_samplers[MAXIMUM_MATERIAL_SAMPLERS];
	int material_samplers;
	int sampler_mappings;
	int batch_count;
	GLintptr indirectDrawOffset;

	int polygonOffsetSplit;
	glm_brushmodel_drawcall_type type;

	struct glm_brushmodel_drawcall_s* next;
} glm_brushmodel_drawcall_t;

static glm_brushmodel_drawcall_t* GL_PrepareWorldModelBatch(glm_brushmodel_drawcall_type type);
static void GL_SortDrawCalls(glm_brushmodel_drawcall_t* drawcall);

static glm_brushmodel_drawcall_t* drawcalls;
static int maximum_drawcalls = 0;
static int current_drawcall = 0;

static void GLM_CheckDrawCallSize(void)
{
	if (current_drawcall >= maximum_drawcalls) {
		maximum_drawcalls += GLM_DRAWCALL_INCREMENT;
		drawcalls = Q_realloc(drawcalls, sizeof(glm_brushmodel_drawcall_t) * maximum_drawcalls);
	}
}

#define DRAW_DETAIL_TEXTURES       (1 <<  0)
#define DRAW_CAUSTIC_TEXTURES      (1 <<  1)
#define DRAW_LUMA_TEXTURES         (1 <<  2)
#define DRAW_SKYBOX                (1 <<  3)
#define DRAW_SKYDOME               (1 <<  4)
#define DRAW_FLATFLOORS            (1 <<  5)
#define DRAW_FLATWALLS             (1 <<  6)
#define DRAW_LUMA_TEXTURES_FB      (1 <<  7)
#define DRAW_TEXTURELESS           (1 <<  8)
#define DRAW_GEOMETRY              (1 <<  9)
#define DRAW_DRAWFLAT_NORMAL       (1 << 10)
#define DRAW_DRAWFLAT_TINTED       (1 << 11)
#define DRAW_DRAWFLAT_BRIGHT       (1 << 12)
#define DRAW_ALPHATESTED           (1 << 13)
#define DRAW_SKYWIND               (1 << 14)
#define DRAW_INSTANCED             (1 << 15)

static int material_samplers_max;
static int TEXTURE_UNIT_MATERIAL; // Must always be the first non-standard texture unit
static int TEXTURE_UNIT_LIGHTMAPS;
static int TEXTURE_UNIT_DETAIL;
static int TEXTURE_UNIT_CAUSTICS;
static int TEXTURE_UNIT_SKYBOX;
static int TEXTURE_UNIT_SKYDOME_TEXTURE;
static int TEXTURE_UNIT_SKYDOME_CLOUD_TEXTURE;

// We re-compile whenever certain options change, to save texture bindings/lookups
static qbool GLM_CompileDrawWorldProgramImpl(r_program_id program_id, qbool alpha_test)
{
	extern cvar_t gl_lumatextures;
	extern cvar_t gl_textureless;
	extern cvar_t gl_outline;

	qbool detail_textures = gl_detail.integer && R_TextureReferenceIsValid(detailtexture);
	qbool caustic_textures = r_refdef2.drawCaustics;
	qbool luma_textures = gl_lumatextures.integer && r_refdef2.allow_lumas;
	qbool skybox = r_skyboxloaded && !r_fastsky.integer;
	qbool skydome = !skybox && !r_fastsky.integer && R_TextureReferenceIsValid(solidskytexture);
	qbool skywind = skybox && Skywind_Active();

	int drawworld_desiredOptions =
		(detail_textures ? DRAW_DETAIL_TEXTURES : 0) |
		(caustic_textures ? DRAW_CAUSTIC_TEXTURES : 0) |
		(luma_textures ? DRAW_LUMA_TEXTURES : 0) |
		(gl_fb_bmodels.integer ? DRAW_LUMA_TEXTURES_FB : 0) |
		(skybox ? DRAW_SKYBOX : (skydome ? DRAW_SKYDOME : 0)) |
		(r_drawflat_mode.integer == 0 && r_drawflat.integer != 0 ? DRAW_DRAWFLAT_NORMAL : 0) |
		(r_drawflat_mode.integer == 1 && r_drawflat.integer != 0 ? DRAW_DRAWFLAT_TINTED : 0) |
		(r_drawflat_mode.integer == 2 && r_drawflat.integer != 0 ? DRAW_DRAWFLAT_BRIGHT : 0) |
		(r_drawflat.integer == 1 || r_drawflat.integer == 2 ? DRAW_FLATFLOORS : 0) |
		(r_drawflat.integer == 1 || r_drawflat.integer == 3 ? DRAW_FLATWALLS : 0) |
		(gl_textureless.integer ? DRAW_TEXTURELESS : 0) |
		((gl_outline.integer & 2) && GL_VersionAtLeast(4, 3) ? DRAW_GEOMETRY : 0) |
		(alpha_test ? DRAW_ALPHATESTED : 0) |
		(skywind ? DRAW_SKYWIND : 0) |
		(GL_Supported(R_SUPPORT_INSTANCED_RENDERING) ? DRAW_INSTANCED : 0);

	if (R_ProgramRecompileNeeded(program_id, drawworld_desiredOptions)) {
		static char included_definitions[2048];
		int samplers = 0;

		memset(included_definitions, 0, sizeof(included_definitions));
		if (detail_textures) {
			TEXTURE_UNIT_DETAIL = samplers++;

			strlcat(included_definitions, "#define DRAW_DETAIL_TEXTURES\n", sizeof(included_definitions));
			strlcat(included_definitions, va("#define SAMPLER_DETAIL_TEXTURE %d\n", TEXTURE_UNIT_DETAIL), sizeof(included_definitions));
		}
		if (caustic_textures) {
			TEXTURE_UNIT_CAUSTICS = samplers++;

			strlcat(included_definitions, "#define DRAW_CAUSTIC_TEXTURES\n", sizeof(included_definitions));
			strlcat(included_definitions, va("#define SAMPLER_CAUSTIC_TEXTURE %d\n", TEXTURE_UNIT_CAUSTICS), sizeof(included_definitions));
		}
		if (r_drawflat.integer != 1 || r_drawflat_mode.integer != 0) {
			if (luma_textures) {
				strlcat(included_definitions, "#define DRAW_LUMA_TEXTURES\n", sizeof(included_definitions));
			}
			if (gl_fb_bmodels.integer) {
				strlcat(included_definitions, "#define DRAW_LUMA_TEXTURES_FB\n", sizeof(included_definitions));
			}
		}
		if (drawworld_desiredOptions & DRAW_DRAWFLAT_NORMAL) {
			strlcat(included_definitions, "#define DRAW_DRAWFLAT_NORMAL\n", sizeof(included_definitions));
		}
		else if (drawworld_desiredOptions & DRAW_DRAWFLAT_TINTED) {
			strlcat(included_definitions, "#define DRAW_DRAWFLAT_TINTED\n", sizeof(included_definitions));
		}
		else if (drawworld_desiredOptions & DRAW_DRAWFLAT_BRIGHT) {
			strlcat(included_definitions, "#define DRAW_DRAWFLAT_BRIGHT\n", sizeof(included_definitions));
		}
		if (drawworld_desiredOptions & DRAW_ALPHATESTED) {
			strlcat(included_definitions, "#define DRAW_ALPHATEST_ENABLED\n", sizeof(included_definitions));
		}

		if (skybox) {
			TEXTURE_UNIT_SKYBOX = samplers++;

			strlcat(included_definitions, "#define DRAW_SKYBOX\n", sizeof(included_definitions));
			if (skywind) {
				strlcat(included_definitions, "#define DRAW_SKYWIND\n", sizeof(included_definitions));
			}
			strlcat(included_definitions, va("#define SAMPLER_SKYBOX_TEXTURE %d\n", TEXTURE_UNIT_SKYBOX), sizeof(included_definitions));

		}
		else if (skydome) {
			TEXTURE_UNIT_SKYDOME_TEXTURE = samplers++;
			TEXTURE_UNIT_SKYDOME_CLOUD_TEXTURE = samplers++;

			strlcat(included_definitions, "#define DRAW_SKYDOME\n", sizeof(included_definitions));
			strlcat(included_definitions, va("#define SAMPLER_SKYDOME_TEXTURE %d\n", TEXTURE_UNIT_SKYDOME_TEXTURE), sizeof(included_definitions));
			strlcat(included_definitions, va("#define SAMPLER_SKYDOME_CLOUDTEXTURE %d\n", TEXTURE_UNIT_SKYDOME_CLOUD_TEXTURE), sizeof(included_definitions));
		}
		if (gl_outline.integer & 2 && GL_VersionAtLeast(4, 3)) {
			strlcat(included_definitions, "#define DRAW_GEOMETRY\n", sizeof(included_definitions));
		}
		TEXTURE_UNIT_LIGHTMAPS = samplers++;
		strlcat(included_definitions, va("#define SAMPLER_LIGHTMAP_TEXTURE %d\n", TEXTURE_UNIT_LIGHTMAPS), sizeof(included_definitions));
		TEXTURE_UNIT_MATERIAL = samplers++;
		strlcat(included_definitions, va("#define SAMPLER_MATERIAL_TEXTURE_START %d\n", TEXTURE_UNIT_MATERIAL), sizeof(included_definitions));
		material_samplers_max = min(glConfig.texture_units - TEXTURE_UNIT_MATERIAL, MAXIMUM_MATERIAL_SAMPLERS);
		strlcat(included_definitions, va("#define SAMPLER_MATERIAL_TEXTURE_COUNT %d\n", material_samplers_max), sizeof(included_definitions));
		strlcat(included_definitions, va("#define MAX_INSTANCEID %d\n", MAX_WORLDMODEL_BATCH), sizeof(included_definitions));
		if (r_drawflat.integer == 1 || r_drawflat.integer == 2) {
			strlcat(included_definitions, "#define DRAW_FLATFLOORS\n", sizeof(included_definitions));
		}
		if (r_drawflat.integer == 1 || r_drawflat.integer == 3) {
			strlcat(included_definitions, "#define DRAW_FLATWALLS\n", sizeof(included_definitions));
		}
		if (gl_textureless.integer) {
			strlcat(included_definitions, "#define DRAW_TEXTURELESS\n", sizeof(included_definitions));
		}

		// Initialise program for drawing image
		R_ProgramCompileWithInclude(program_id, included_definitions);

		// Set sampler uniforms for GL < 4.2 (no layout(binding=N) support)
		if (!GL_VersionAtLeast(4, 2) && R_ProgramReady(program_id)) {
			int base = alpha_test ? r_program_uniform_brushmodel_at_detailtex : r_program_uniform_brushmodel_detailtex;
			R_ProgramUse(program_id);
			if (detail_textures) {
				R_ProgramUniform1i(base + 0, TEXTURE_UNIT_DETAIL);
			}
			if (caustic_textures) {
				R_ProgramUniform1i(base + 1, TEXTURE_UNIT_CAUSTICS);
			}
			if (skybox) {
				R_ProgramUniform1i(base + 2, TEXTURE_UNIT_SKYBOX);
			}
			else if (skydome) {
				R_ProgramUniform1i(base + 3, TEXTURE_UNIT_SKYDOME_TEXTURE);
				R_ProgramUniform1i(base + 4, TEXTURE_UNIT_SKYDOME_CLOUD_TEXTURE);
			}
			R_ProgramUniform1i(base + 5, TEXTURE_UNIT_LIGHTMAPS);
			R_ProgramUniform1iArrayBase(base + 6, material_samplers_max, TEXTURE_UNIT_MATERIAL);
		}

		R_ProgramSetCustomOptions(program_id, drawworld_desiredOptions);
	}

	if (!R_BufferReferenceIsValid(r_buffer_brushmodel_drawcall_data)) {
		buffers.Create(r_buffer_brushmodel_drawcall_data, buffertype_storage, "ssbo_worldcvars", sizeof(drawcalls[0].calls) * GLM_DRAWCALL_INCREMENT, NULL, bufferusage_once_per_frame);
	}
	if (!R_BufferReferenceIsValid(r_buffer_brushmodel_worldsamplers_ssbo)) {
		buffers.Create(r_buffer_brushmodel_worldsamplers_ssbo, buffertype_storage, "ssbo_worldsamplers", sizeof(drawcalls[0].mappings) * GLM_DRAWCALL_INCREMENT, NULL, bufferusage_once_per_frame);
	}

	if (!R_BufferReferenceIsValid(r_buffer_brushmodel_drawcall_indirect)) {
		buffers.Create(r_buffer_brushmodel_drawcall_indirect, buffertype_indirect, "world-indirect", sizeof(drawcalls[0].worldmodel_requests) * GLM_DRAWCALL_INCREMENT, NULL, bufferusage_once_per_frame);
	}

	return R_ProgramReady(program_id);
}

qbool GLM_CompileDrawWorldProgram(void)
{
	return GLM_CompileDrawWorldProgramImpl(r_program_brushmodel, false);
}

qbool GLM_CompileDrawWorldProgramAlphaTested(void)
{
	return GLM_CompileDrawWorldProgramImpl(r_program_brushmodel_alphatested, true);
}

static glm_worldmodel_req_t* GLM_CurrentRequest(void)
{
	glm_brushmodel_drawcall_t* call = &drawcalls[current_drawcall];

	return &call->worldmodel_requests[call->batch_count - 1];
}

static void GL_StartWorldBatch(qbool alphatest_enabled)
{
	texture_ref std_textures[MAX_STANDARD_TEXTURES];
	r_program_id program_id = (alphatest_enabled ? r_program_brushmodel_alphatested : r_program_brushmodel);
	int options = R_ProgramCustomOptions(program_id);

	R_ProgramUse(program_id);
	R_BindVertexArray(vao_brushmodel);

	// Bind standard textures
	std_textures[TEXTURE_UNIT_LIGHTMAPS] = GLM_LightmapArray();
	if (options & DRAW_DETAIL_TEXTURES) {
		std_textures[TEXTURE_UNIT_DETAIL] = detailtexture;
	}
	if (options & DRAW_CAUSTIC_TEXTURES) {
		std_textures[TEXTURE_UNIT_CAUSTICS] = underwatertexture;
	}
	if (options & DRAW_SKYBOX) {
		extern texture_ref skybox_cubeMap;

		std_textures[TEXTURE_UNIT_SKYBOX] = skybox_cubeMap;
	}
	else if (options & DRAW_SKYDOME) {
		extern texture_ref solidskytexture, alphaskytexture;

		std_textures[TEXTURE_UNIT_SKYDOME_TEXTURE] = solidskytexture;
		std_textures[TEXTURE_UNIT_SKYDOME_CLOUD_TEXTURE] = alphaskytexture;
	}
	renderer.TextureUnitMultiBind(0, TEXTURE_UNIT_MATERIAL, std_textures);
}

void GLM_EnterBatchedWorldRegion(void)
{
	GLM_CompileDrawWorldProgram();
	GLM_CompileDrawWorldProgramAlphaTested();

	current_drawcall = 0;
	index_count = 0;
	GLM_CheckDrawCallSize();
	memset(drawcalls, 0, sizeof(drawcalls[0]) * maximum_drawcalls);
}

static qbool GLM_AssignTexture(int texture_num, texture_t* texture)
{
	glm_worldmodel_req_t* req = GLM_CurrentRequest();
	int index = req->samplerMappingBase + texture_num;
	int i;
	int sampler = -1;
	glm_brushmodel_drawcall_t* drawcall = &drawcalls[current_drawcall];

	if (index >= sizeof(drawcall->mappings) / sizeof(drawcall->mappings[0])) {
		return false;
	}

	for (i = 0; i < drawcall->material_samplers; ++i) {
		if (R_TextureReferenceEqual(texture->gl_texture_array, drawcall->allocated_samplers[i])) {
			sampler = i;
			break;
		}
	}

	if (sampler < 0) {
		if (drawcall->material_samplers >= material_samplers_max) {
			drawcall = GL_PrepareWorldModelBatch(drawcall->type);
		}

		sampler = drawcall->material_samplers++;
		drawcall->allocated_samplers[sampler] = texture->gl_texture_array;
	}

	drawcall->mappings[index].samplerIndex = sampler;
	drawcall->mappings[index].arrayIndex = texture->gl_texture_index;
	drawcall->mappings[index].flags = R_TextureReferenceIsValid(texture->fb_texturenum) && texture->isLumaTexture ? EZQ_SURFACE_HAS_LUMA : 0;
	drawcall->mappings[index].flags |= R_TextureReferenceIsValid(texture->fb_texturenum) && !texture->isLumaTexture ? EZQ_SURFACE_HAS_FB : 0;
	drawcall->mappings[index].flags |= R_TextureReferenceIsValid(texture->fb_texturenum) && texture->isAlphaTested ? EZQ_SURFACE_ALPHATEST : 0;
	drawcall->mappings[index].flags |= texture->isLitTurb ? EZQ_SURFACE_LIT_TURB : 0;
	return true;
}

static qbool GLM_DuplicatePreviousRequest(model_t* model, float alpha, int num_textures, int first_texture, qbool polygonOffset, qbool caustics)
{
	glm_worldmodel_req_t* req;
	qbool worldmodel = model ? model->isworldmodel : false;
	int flags = (caustics ? EZQ_SURFACE_UNDERWATER : 0);
	glm_brushmodel_drawcall_t* drawcall = &drawcalls[current_drawcall];

	// If user has switched off caustics (or no texture), ignore
	if (caustics) {
		caustics &= ((R_ProgramCustomOptions(r_program_brushmodel) & DRAW_CAUSTIC_TEXTURES) == DRAW_CAUSTIC_TEXTURES);
	}

	// See if previous batch has same texture & matrix, if so just continue
	if (drawcall->batch_count) {
		req = &drawcall->worldmodel_requests[drawcall->batch_count - 1];

		if (model == req->model && req->samplerMappingCount == num_textures && req->firstTexture == first_texture && drawcall->batch_count < MAX_WORLDMODEL_BATCH) {
			// Duplicate details from previous request, but with different matrix
			glm_worldmodel_req_t* newreq = &drawcall->worldmodel_requests[drawcall->batch_count];

			memcpy(newreq, req, sizeof(*newreq));
			R_GetModelviewMatrix(newreq->mvMatrix);
			newreq->alpha = alpha;
			newreq->flags = flags;
			newreq->polygonOffset = polygonOffset;
			newreq->worldmodel = worldmodel;
			newreq->baseInstance = drawcall->batch_count;
			++drawcall->batch_count;

			return true;
		}
	}

	return false;
}

static glm_worldmodel_req_t* GLM_NextBatchRequest(model_t* model, float alpha, int num_textures, int first_texture, qbool polygonOffset, qbool caustics, qbool allow_duplicate, qbool isAlphaTested)
{
	glm_worldmodel_req_t* req;
	qbool worldmodel = model ? model->isworldmodel : false;
	int flags = (caustics ? EZQ_SURFACE_UNDERWATER : 0);
	glm_brushmodel_drawcall_t* drawcall = &drawcalls[current_drawcall];
	float mvMatrix[16];

	glm_brushmodel_drawcall_type desired_type = alpha == 0.0f ? opaque_world : alpha_surfaces;

	R_GetModelviewMatrix(mvMatrix);

	// If user has switched off caustics (or no texture), ignore
	if (caustics) {
		caustics &= ((R_ProgramCustomOptions(r_program_brushmodel) & DRAW_CAUSTIC_TEXTURES) == DRAW_CAUSTIC_TEXTURES);
	}

	if (drawcall->type != desired_type) {
		drawcall = GL_PrepareWorldModelBatch(desired_type);
	}
	else if (drawcall->batch_count && drawcall->type == opaque_world) {
		// See if previous request has same texture & matrix, if so just continue
		// as long as drawcall is not alpha as such requests must be drawn in the
		// predetermined order.
		req = &drawcall->worldmodel_requests[drawcall->batch_count - 1];

		if (allow_duplicate && model == req->model && req->samplerMappingCount == num_textures && req->firstTexture == first_texture && drawcall->batch_count < MAX_WORLDMODEL_BATCH && isAlphaTested == req->isAlphaTested) {
			// Duplicate details from previous request, but with different matrix
			glm_worldmodel_req_t* newreq = &drawcall->worldmodel_requests[drawcall->batch_count];

			memcpy(newreq, req, sizeof(*newreq));
			R_GetModelviewMatrix(newreq->mvMatrix);
			newreq->alpha = alpha;
			newreq->flags = flags;
			newreq->polygonOffset = polygonOffset;
			newreq->worldmodel = worldmodel;
			newreq->baseInstance = drawcall->batch_count;
			++drawcall->batch_count;

			return NULL;
		}

		// Try and continue the previous batch
		if (worldmodel == req->worldmodel && !memcmp(req->mvMatrix, mvMatrix, sizeof(req->mvMatrix)) && polygonOffset == req->polygonOffset && req->flags == flags && req->isAlphaTested == isAlphaTested) {
			if (num_textures == 0) {
				// We don't care about materials, so can draw with previous batch
				return req;
			}
			else if (req->samplerMappingCount == 0) {
				// Previous block didn't care about materials, allocate now
				if (drawcall->sampler_mappings < MAX_SAMPLER_MAPPINGS) {
					req->samplerMappingBase = drawcall->sampler_mappings - first_texture;
					req->samplerMappingCount = min(num_textures, MAX_SAMPLER_MAPPINGS - drawcall->sampler_mappings);
					req->firstTexture = first_texture;
					drawcall->sampler_mappings += req->samplerMappingCount;
					return req;
				}
			}
		}
	}

	if (drawcall->sampler_mappings >= MAX_SAMPLER_MAPPINGS || drawcall->batch_count >= MAX_WORLDMODEL_BATCH) {
		drawcall = GL_PrepareWorldModelBatch(drawcall->type);
	}

	req = &drawcall->worldmodel_requests[drawcall->batch_count];

	// If matrix list was full previously, will be okay now
	memcpy(req->mvMatrix, mvMatrix, sizeof(req->mvMatrix));
	req->alpha = alpha;
	req->samplerMappingBase = drawcall->sampler_mappings - first_texture;
	req->samplerMappingCount = min(num_textures, MAX_SAMPLER_MAPPINGS - drawcall->sampler_mappings);
	req->flags = flags;
	req->polygonOffset = polygonOffset;
	req->worldmodel = worldmodel;
	req->model = model;
	req->firstTexture = first_texture;
	req->isAlphaTested = isAlphaTested;

	req->count = 0;
	req->instanceCount = 1;
	req->firstIndex = index_count;
	req->baseVertex = 0;
	req->baseInstance = drawcall->batch_count;

	drawcall->sampler_mappings += req->samplerMappingCount;
	++drawcall->batch_count;
	return req;
}

void GLM_DrawWaterSurfaces(void)
{
	extern msurface_t* waterchain;
	msurface_t* surf;
	glm_worldmodel_req_t* req = NULL;
	float alpha;
	int v;

	if (!waterchain) {
		return;
	}

	alpha = r_refdef2.wateralpha;

	// Waterchain has list of alpha-blended surfaces
	R_TraceEnterNamedRegion(__func__);

	for (surf = waterchain; surf; surf = surf->texturechain) {
		glpoly_t* poly;
		texture_t* tex = R_TextureAnimation(NULL, surf->texinfo->texture);

		req = GLM_NextBatchRequest(NULL, alpha, 1, surf->texinfo->miptex, false, false, false, tex->isAlphaTested);
		GLM_AssignTexture(surf->texinfo->miptex, tex);
		for (poly = surf->polys; poly; poly = poly->next) {
			int newVerts = poly->numverts;

			if (index_count + 1 + newVerts > modelIndexMaximum) {
				// Should never happen now, we allocate enough space
				continue;
			}

			if (req->count) {
				modelIndexes[index_count++] = ~(GLuint)0;
				req->count++;
			}

			for (v = 0; v < newVerts; ++v) {
				modelIndexes[index_count++] = poly->vbo_start + v;
				req->count++;
			}
		}
	}

	R_TraceLeaveNamedRegion();

	waterchain = NULL;
}

static glm_worldmodel_req_t* GLM_DrawFlatChain(glm_worldmodel_req_t* req, msurface_t* surf)
{
	glpoly_t* poly;
	int v;

	while (surf) {
		for (poly = surf->polys; poly; poly = poly->next) {
			int newVerts = poly->numverts;

			if (index_count + 1 + newVerts > modelIndexMaximum) {
				// Should never happen now
				continue;
			}

			if (req->count) {
				modelIndexes[index_count++] = ~(GLuint)0;
				req->count++;
			}

			for (v = 0; v < newVerts; ++v) {
				modelIndexes[index_count++] = poly->vbo_start + v;
				req->count++;
			}
		}

		surf = surf->drawflatchain;
	}

	return req;
}

static glm_worldmodel_req_t* GLM_DrawTexturedChain(glm_worldmodel_req_t* req, msurface_t* surf)
{
	glpoly_t* poly;
	int v;

	while (surf) {
		for (poly = surf->polys; poly; poly = poly->next) {
			int newVerts = poly->numverts;

			if (index_count + 1 + newVerts > modelIndexMaximum) {
				// Should never happen now
				continue;
			}

			if (req->count) {
				modelIndexes[index_count++] = ~(GLuint)0;
				req->count++;
			}

			for (v = 0; v < newVerts; ++v) {
				modelIndexes[index_count++] = poly->vbo_start + v;
				req->count++;
			}
		}

		surf = surf->texturechain;
	}

	return req;
}

qbool GLM_CompilePostProcessVAO(void);

qbool GLM_CompileSimple3dProgram(void)
{
	if (R_ProgramRecompileNeeded(r_program_simple3d, 0)) {
		R_ProgramCompile(r_program_simple3d);
	}

	return R_ProgramReady(r_program_simple3d) && GLM_CompilePostProcessVAO();
}

static glm_brushmodel_drawcall_t* GL_PrepareWorldModelBatch(glm_brushmodel_drawcall_type type)
{
	glm_brushmodel_drawcall_t* prev = &drawcalls[current_drawcall];
	glm_brushmodel_drawcall_t* current;

	if (prev->batch_count == 0)	{
		prev->type = type;
		return prev;
	}

	current_drawcall++;

	GLM_CheckDrawCallSize();

	current = &drawcalls[current_drawcall];

	memset(current, 0, sizeof(*current));
	current->type = type;
	return current;
}

void GLM_PrepareWorldModelBatch(void)
{
	GLintptr drawOffset = 0;
	GLintptr indexOffset = buffers.BufferOffset(r_buffer_brushmodel_index_data) / sizeof(modelIndexes[0]);
	int samplerMappingOffset = 0;
	int batchOffset = 0;
	int draw, i;

	R_TraceEnterNamedRegion(__func__);
	buffers.Update(r_buffer_brushmodel_index_data, sizeof(modelIndexes[0]) * index_count, modelIndexes);
	buffers.EnsureSize(r_buffer_brushmodel_drawcall_indirect, sizeof(drawcalls[0].worldmodel_requests) * maximum_drawcalls);
	buffers.EnsureSize(r_buffer_brushmodel_drawcall_data, sizeof(drawcalls[0].calls) * maximum_drawcalls);
	buffers.EnsureSize(r_buffer_brushmodel_worldsamplers_ssbo, sizeof(drawcalls[0].mappings) * maximum_drawcalls);

	buffers.BindRange(r_buffer_brushmodel_drawcall_data, EZQ_STORAGE_BLOCK_BINDING(EZQ_GL_BINDINGPOINT_BRUSHMODEL_DRAWDATA), buffers.BufferOffset(r_buffer_brushmodel_drawcall_data), sizeof(drawcalls[0].calls) * maximum_drawcalls);
	buffers.BindRange(r_buffer_brushmodel_worldsamplers_ssbo, EZQ_STORAGE_BLOCK_BINDING(EZQ_GL_BINDINGPOINT_BRUSHMODEL_SAMPLERS), buffers.BufferOffset(r_buffer_brushmodel_worldsamplers_ssbo), sizeof(drawcalls[0].mappings) * maximum_drawcalls);

	for (draw = 0; draw <= current_drawcall; ++draw) {
		glm_brushmodel_drawcall_t* drawcall = &drawcalls[draw];

		if (!drawcall->batch_count) {
			break;
		}

		GL_SortDrawCalls(drawcall);

		for (i = 0; i < drawcall->batch_count; ++i) {
			drawcall->calls[i].samplerBase += samplerMappingOffset;
			drawcall->worldmodel_requests[i].baseInstance += batchOffset;
			drawcall->worldmodel_requests[i].firstIndex += indexOffset;
		}

		drawcall->indirectDrawOffset = drawOffset;
		buffers.UpdateSection(r_buffer_brushmodel_drawcall_indirect, drawOffset, sizeof(drawcall->worldmodel_requests[0]) * drawcall->batch_count, &drawcall->worldmodel_requests);
		drawOffset += sizeof(drawcall->worldmodel_requests[0]) * drawcall->batch_count;

		buffers.UpdateSection(r_buffer_brushmodel_drawcall_data, sizeof(drawcall->calls[0]) * batchOffset, sizeof(drawcall->calls[0]) * drawcall->batch_count, &drawcall->calls);
		buffers.UpdateSection(r_buffer_brushmodel_worldsamplers_ssbo, sizeof(drawcall->mappings[0]) * samplerMappingOffset, sizeof(drawcall->mappings[0]) * drawcall->sampler_mappings, &drawcall->mappings);

		batchOffset += drawcall->batch_count;
		samplerMappingOffset += drawcall->sampler_mappings;
	}

	R_TraceLeaveNamedRegion();
}

static void GLM_DrawWorldExecuteCalls(glm_brushmodel_drawcall_t* drawcall, uintptr_t offset, int begin, int count)
{
	int i;
	qbool prev_alphaTested = false;
	qbool no_base_instance = !GL_Supported(R_SUPPORT_INSTANCED_RENDERING);

	for (i = begin; i < begin + count; ++i) {
		glm_worldmodel_req_t* req = &drawcall->worldmodel_requests[i];
		int batchCount = 1;

		if (req->isAlphaTested != prev_alphaTested) {
			if (req->isAlphaTested) {
				R_ProgramUse(r_program_brushmodel_alphatested);
			}
			else {
				R_ProgramUse(r_program_brushmodel);
			}
			prev_alphaTested = req->isAlphaTested;
		}

		if (no_base_instance) {
			// GL 4.1: no baseInstance support, _instanceId is always 0
			// Use instanceOffset uniform so shader reads drawInfo[0 + baseInstance]
			// Set on both programs since either may be active (alpha surfaces start
			// with alphatested program but prev_alphaTested tracks request state)
			R_ProgramUniform1i(r_program_uniform_brushmodel_instanceOffset, req->baseInstance);
			R_ProgramUniform1i(r_program_uniform_brushmodel_alphatested_instanceOffset, req->baseInstance);
			GL_DrawElementsBaseVertex(
				GL_TRIANGLE_STRIP,
				req->count,
				GL_UNSIGNED_INT,
				(void*)(req->firstIndex * sizeof(GLuint)),
				req->baseVertex
			);
			continue;
		}

		while (i + batchCount < begin + count && drawcall->worldmodel_requests[i + batchCount].isAlphaTested == req->isAlphaTested) {
			++batchCount;
		}

		if (batchCount == 1) {
			GL_DrawElementsInstancedBaseVertexBaseInstance(
				GL_TRIANGLE_STRIP,
				req->count,
				GL_UNSIGNED_INT,
				(void*)(req->firstIndex * sizeof(GLuint)),
				req->instanceCount,
				req->baseVertex,
				req->baseInstance
			);
		}
		else {
			GL_MultiDrawElementsIndirect(GL_TRIANGLE_STRIP, GL_UNSIGNED_INT, (void*)(offset + (i - begin) * sizeof(drawcall->worldmodel_requests[0])), batchCount, sizeof(drawcall->worldmodel_requests[0]));
			i += batchCount - 1;
		}
	}
}

void GLM_DrawWorldModelBatch(glm_brushmodel_drawcall_type type)
{
	int draw;
	qbool first = true;
	unsigned int extra_offset = 0;
	qbool alphablended = (type == alpha_surfaces);

	for (draw = 0; draw <= current_drawcall; ++draw) {
		glm_brushmodel_drawcall_t* drawcall = &drawcalls[draw];

		if (!drawcall->batch_count || drawcall->type != type) {
			continue;
		}

		if (first) {
			R_TraceEnterNamedRegion(__func__);
			GL_StartWorldBatch(alphablended);
			buffers.Bind(r_buffer_brushmodel_index_data);
			buffers.Bind(r_buffer_brushmodel_drawcall_indirect);
			extra_offset = buffers.BufferOffset(r_buffer_brushmodel_drawcall_indirect);

			first = false;
		}

		R_TraceEnterNamedRegion(va("WorldModelBatch(%d/%d)", draw, current_drawcall));

		// Bind texture units
		renderer.TextureUnitMultiBind(TEXTURE_UNIT_MATERIAL, drawcall->material_samplers, drawcall->allocated_samplers);

		if (drawcall->polygonOffsetSplit >= 0 && drawcall->polygonOffsetSplit < drawcall->batch_count) {
			uintptr_t normal_offset = drawcall->indirectDrawOffset + extra_offset;
			uintptr_t polygonOffset_offset = (extra_offset + drawcall->indirectDrawOffset + sizeof(drawcall->worldmodel_requests[0]) * drawcall->polygonOffsetSplit);

			if (drawcall->polygonOffsetSplit) {
				GLM_BeginDrawWorld(alphablended, false);
				GLM_DrawWorldExecuteCalls(drawcall, normal_offset, 0, drawcall->polygonOffsetSplit);
			}

			GLM_BeginDrawWorld(alphablended, true);
			GLM_DrawWorldExecuteCalls(drawcall, polygonOffset_offset, drawcall->polygonOffsetSplit, drawcall->batch_count - drawcall->polygonOffsetSplit);
		}
		else {
			GLM_BeginDrawWorld(alphablended, false);
			GLM_DrawWorldExecuteCalls(drawcall, extra_offset + drawcall->indirectDrawOffset, 0, drawcall->batch_count);
		}

		R_TraceLeaveNamedRegion();

		frameStats.subdraw_calls += drawcall->batch_count;
		drawcall->batch_count = 0;
		drawcall->material_samplers = 0;
		drawcall->sampler_mappings = 0;
	}

	if (!first) {
		R_TraceLeaveNamedRegion();
	}
}

void GLM_DrawBrushModel(entity_t* ent, qbool polygonOffset, qbool caustics)
{
	int i;
	glm_worldmodel_req_t* req = NULL;
	model_t* model = ent->model;

	if (GLM_DuplicatePreviousRequest(model, ent->alpha, model->last_texture_chained - model->first_texture_chained + 1, model->first_texture_chained, polygonOffset, caustics)) {
		return;
	}

	if (model->drawflat_chain) {
		req = GLM_NextBatchRequest(model, ent->alpha, 0, 0, false, false, false, false);

		req = GLM_DrawFlatChain(req, model->drawflat_chain);

		model->drawflat_chain = NULL;
	}

	if (model->last_texture_chained < 0) {
		return;
	}

	for (i = model->first_texture_chained; i <= model->last_texture_chained; ++i) {
		texture_t* tex = model->textures[i];

		if (!tex || !tex->loaded || !tex->texturechain || !R_TextureReferenceIsValid(tex->gl_texture_array)) {
			continue;
		}

		req = GLM_NextBatchRequest(model, ent->alpha, 1, i, polygonOffset, caustics, false, tex->isAlphaTested);
		tex = R_TextureAnimation(ent, tex);
		if (!GLM_AssignTexture(i, tex)) {
			req = GLM_NextBatchRequest(model, ent->alpha, 1, i, polygonOffset, caustics, false, tex->isAlphaTested);
			GLM_AssignTexture(i, tex);
		}

		req = GLM_DrawTexturedChain(req, model->textures[i]->texturechain);
	}
}

static int GL_DrawCallComparison(const void* lhs_, const void* rhs_)
{
	const glm_worldmodel_req_t* lhs = (glm_worldmodel_req_t*)lhs_;
	const glm_worldmodel_req_t* rhs = (glm_worldmodel_req_t*)rhs_;

	if (lhs->polygonOffset && !rhs->polygonOffset) {
		return 1;
	}
	if (!lhs->polygonOffset && rhs->polygonOffset) {
		return -1;
	}

	if (lhs->isAlphaTested && !rhs->isAlphaTested) {
		return 1;
	}
	else if (!lhs->isAlphaTested && rhs->isAlphaTested) {
		return -1;
	}

	return lhs->nonDynamicSampler - rhs->nonDynamicSampler;
}

static void GL_SortDrawCalls(glm_brushmodel_drawcall_t* drawcall)
{
	int i;

	drawcall->polygonOffsetSplit = drawcall->batch_count;
	if (drawcall->batch_count == 0) {
		return;
	}

	for (i = 0; i < drawcall->batch_count; ++i) {
		glm_worldmodel_req_t* thisReq = &drawcall->worldmodel_requests[i];
		int mappingIndex = bound(0, thisReq->samplerMappingBase + thisReq->firstTexture, sizeof(drawcall->mappings) / sizeof(drawcall->mappings[0]) - 1);
		int sampler = drawcall->mappings[mappingIndex].samplerIndex;

		thisReq->nonDynamicSampler = sampler;

		if (thisReq->polygonOffset && drawcall->polygonOffsetSplit > i) {
			drawcall->polygonOffsetSplit = i;
		}
	}

	// Translucent bmodels are put into requests based on their distance from view and sorting here will break that order.
	if (drawcall->type == opaque_world) {
		qsort(drawcall->worldmodel_requests, drawcall->batch_count, sizeof(drawcall->worldmodel_requests[0]), GL_DrawCallComparison);
	}

	for (i = 0; i < drawcall->batch_count; ++i) {
		glm_worldmodel_req_t* thisReq = &drawcall->worldmodel_requests[i];

		drawcall->calls[i].alpha = thisReq->alpha == 0.0f ? 1.0f : thisReq->alpha;
		drawcall->calls[i].flags = thisReq->flags;
		memcpy(drawcall->calls[i].modelMatrix, thisReq->mvMatrix, sizeof(drawcall->calls[i].modelMatrix));
		drawcall->calls[i].samplerBase = thisReq->samplerMappingBase;
		drawcall->calls[i].sampler = thisReq->nonDynamicSampler;
		thisReq->baseInstance = i;
	}
}

void GLM_DrawWorld(void)
{
	entity_t ent;

	memset(&ent, 0, sizeof(ent));
	ent.model = cl.worldmodel;

	GLM_EnterBatchedWorldRegion();
	GLM_DrawBrushModel(&ent, false, false);
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_sdl.c
================================================
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================

*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include <SDL.h>
#include "quakedef.h"
#include "gl_local.h"

static opengl_version_t versions[] = {
	{ 4, 6, false },
	{ 4, 5, false },
	{ 4, 4, false },
	{ 4, 3, false },
	{ 4, 6, true },
	{ 4, 5, true },
	{ 4, 4, true },
	{ 4, 3, true },
	{ 4, 1, true },
};

SDL_GLContext GLM_SDL_CreateContext(SDL_Window* window)
{
	return GL_SDL_CreateBestContext(window, versions, sizeof(versions) / sizeof(versions[0]));
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_sprite.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "tr_types.h"
#include "gl_sprite3d.h"

// For drawing sprites in 3D space
void GLM_DrawSimpleItem(model_t* m, int skin, vec3_t origin, float scale_, vec3_t up, vec3_t right)
{
	texture_ref texture_array = m->simpletexture_array[skin];
	int texture_index = m->simpletexture_indexes[skin];
	float scale_s = m->simpletexture_scalingS[skin];
	float scale_t = m->simpletexture_scalingT[skin];
	r_sprite3d_vert_t* vert;

	vert = R_Sprite3DAddEntrySpecific(SPRITE3D_ENTITIES, 4, texture_array, texture_index);
	if (vert) {
		R_Sprite3DRender(vert, origin, up, right, scale_, -scale_, -scale_, scale_, scale_s, scale_t, texture_index);
	}
}

void GLM_DrawSpriteModel(entity_t* e)
{
	vec3_t right, up;
	mspriteframe_t *frame;
	msprite2_t *psprite;
	r_sprite3d_vert_t* vert;

	// don't even bother culling, because it's just a single
	// polygon without a surface cache
	psprite = (msprite2_t*)Mod_Extradata(e->model);	//locate the proper data
	frame = R_GetSpriteFrame(e, psprite);

	// Check for null texture after s_null sprite found
	if (!frame || !R_TextureReferenceIsValid(frame->gl_arraynum)) {
		return;
	}

	if (psprite->type == SPR_ORIENTED) {
		// bullet marks on walls
		AngleVectors(e->angles, NULL, right, up);
	}
	else if (psprite->type == SPR_FACING_UPRIGHT) {
		VectorSet(up, 0, 0, 1);
		right[0] = e->origin[1] - r_origin[1];
		right[1] = -(e->origin[0] - r_origin[0]);
		right[2] = 0;
		VectorNormalizeFast(right);
	}
	else if (psprite->type == SPR_VP_PARALLEL_UPRIGHT) {
		VectorSet(up, 0, 0, 1);
		VectorCopy(vright, right);
	}
	else {	// normal sprite
		VectorCopy(vup, up);
		VectorCopy(vright, right);
	}

	vert = R_Sprite3DAddEntrySpecific(SPRITE3D_ENTITIES, 4, frame->gl_arraynum, frame->gl_arrayindex);
	if (vert) {
		R_Sprite3DRender(vert, e->origin, up, right, frame->up, frame->down, frame->left, frame->right, frame->gl_scalingS, frame->gl_scalingT, frame->gl_arrayindex);
	}
}

void GL_BeginDrawSprites(void)
{
}

void GL_EndDrawSprites(void)
{
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_sprite3d.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

// 3D sprites
#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "gl_sprite3d.h"
#include "r_sprite3d_internal.h"
#include "glm_vao.h"
#include "tr_types.h"
#include "r_state.h"
#include "glm_local.h"
#include "r_program.h"
#include "r_renderer.h"

static void GLM_Create3DSpriteVAO(void)
{
	R_Sprite3DCreateVBO();

	if (!R_VertexArrayCreated(vao_3dsprites)) {
		R_GenVertexArray(vao_3dsprites);

		R_Sprite3DCreateIndexBuffer();
		buffers.Bind(r_buffer_sprite_index_data);

		// position
		GLM_ConfigureVertexAttribPointer(vao_3dsprites, r_buffer_sprite_vertex_data, 0, 3, GL_FLOAT, GL_FALSE, sizeof(r_sprite3d_vert_t), VBO_FIELDOFFSET(r_sprite3d_vert_t, position), 0);
		// texture coordinates
		GLM_ConfigureVertexAttribPointer(vao_3dsprites, r_buffer_sprite_vertex_data, 1, 3, GL_FLOAT, GL_FALSE, sizeof(r_sprite3d_vert_t), VBO_FIELDOFFSET(r_sprite3d_vert_t, tex), 0);
		// color
		GLM_ConfigureVertexAttribPointer(vao_3dsprites, r_buffer_sprite_vertex_data, 2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(r_sprite3d_vert_t), VBO_FIELDOFFSET(r_sprite3d_vert_t, color), 0);

		R_BindVertexArray(vao_none);
	}
}

#define DRAW_FOG_LINEAR       (1 << 0)
#define DRAW_FOG_EXP          (1 << 1)
#define DRAW_FOG_EXP2         (1 << 2)

#define DRAW_FOG              (DRAW_FOG_LINEAR | DRAW_FOG_EXP | DRAW_FOG_EXP2)

qbool GLM_Compile3DSpriteProgram(void)
{
	if (R_ProgramRecompileNeeded(r_program_sprite3d, 0)) {
		R_ProgramCompile(r_program_sprite3d);

		if (!GL_VersionAtLeast(4, 2) && R_ProgramReady(r_program_sprite3d)) {
			R_ProgramUse(r_program_sprite3d);
			R_ProgramUniform1i(r_program_uniform_sprites_materialtex, 0);
		}
	}

	return R_ProgramReady(r_program_sprite3d);
}

static qbool GLM_3DSpritesInit(void)
{
	// Create program
	GLM_Compile3DSpriteProgram();
	GLM_Create3DSpriteVAO();

	return (R_ProgramReady(r_program_sprite3d) && R_VertexArrayCreated(vao_3dsprites));
}

static void GLM_DrawSequentialBatch(gl_sprite3d_batch_t* batch, int index_offset, GLuint maximum_batch_size)
{
	if (R_TextureReferenceIsValid(batch->texture)) {
		// All batches are the same texture, so no issues
		GL_DrawSequentialBatchImpl(batch, 0, batch->count, index_offset, maximum_batch_size);
	}
	else {
		// Group by texture usage
		int start = 0, end = 1;

		renderer.TextureUnitBind(0, batch->textures[start]);
		for (end = 1; end < batch->count; ++end) {
			if (!R_TextureReferenceEqual(batch->textures[start], batch->textures[end])) {
				GL_DrawSequentialBatchImpl(batch, start, end, index_offset, maximum_batch_size);

				renderer.TextureUnitBind(0, batch->textures[end]);
				start = end;
			}
		}

		if (end > start) {
			GL_DrawSequentialBatchImpl(batch, start, end, index_offset, maximum_batch_size);
		}
	}
}

void GLM_Prepare3DSprites(void)
{
	if (!batchCount || !vertexCount) {
		return;
	}

	R_TraceEnterNamedRegion(__func__);

	GLM_Create3DSpriteVAO();

	if (R_BufferReferenceIsValid(r_buffer_sprite_vertex_data)) {
		buffers.Update(r_buffer_sprite_vertex_data, vertexCount * sizeof(verts[0]), verts);
	}

	R_TraceLeaveNamedRegion();
}

void GLM_Draw3DSprites(void)
{
	unsigned int i;
	qbool current_alpha_test = false;
	qbool first_batch = true;

	if (!batchCount || !vertexCount || (batchCount == 1 && !batches[0].count)) {
		return;
	}

	R_TraceEnterNamedRegion(__func__);

	if (!GLM_3DSpritesInit()) {
		R_TraceLeaveNamedRegion();
		return;
	}

	R_ProgramUse(r_program_sprite3d);

	for (i = 0; i < batchCount; ++i) {
		gl_sprite3d_batch_t* batch = &batches[i];
		qbool alpha_test = (batch->id == SPRITE3D_ENTITIES);

		if (!batch->count) {
			continue;
		}

		R_TraceEnterNamedRegion(batch->name);
		if (first_batch || current_alpha_test != alpha_test) {
			R_ProgramUniform1i(r_program_uniform_sprite3d_alpha_test, current_alpha_test = alpha_test);
		}
		first_batch = false;

		R_ApplyRenderingState(batch->rendering_state);
		if (R_TextureReferenceIsValid(batch->texture)) {
			renderer.TextureUnitBind(0, batch->texture);
		}
		else if (!R_TextureReferenceIsValid(batch->textures[0])) {
			extern texture_ref particletexture_array;

			renderer.TextureUnitBind(0, batch->texture = particletexture_array);
		}

		if (batch->count == 1) {
			if (R_TextureReferenceIsValid(batch->textures[0])) {
				renderer.TextureUnitBind(0, batch->textures[0]);
			}
			GL_DrawArrays(glPrimitiveTypes[batch->primitive_id], batch->glFirstVertices[0], batch->numVertices[0]);
		}
		else if (batch->allSameNumber && batch->numVertices[0] == 4 && batch->primitive_id == r_primitive_triangle_strip) {
			GLM_DrawSequentialBatch(batch, indexes_start_quads, INDEXES_MAX_QUADS);
		}
		else if (batch->allSameNumber && batch->numVertices[0] == 9 && GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
			GLM_DrawSequentialBatch(batch, indexes_start_sparks, INDEXES_MAX_SPARKS);
		}
		else if (batch->allSameNumber && batch->numVertices[0] == 18 && GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
			GLM_DrawSequentialBatch(batch, indexes_start_flashblend, INDEXES_MAX_FLASHBLEND);
		}
		else if (R_TextureReferenceIsValid(batch->texture)) {
			GL_MultiDrawArrays(glPrimitiveTypes[batch->primitive_id], batch->glFirstVertices, batch->numVertices, batch->count);
		}
		else {
			int first = 0, last = 1;
			renderer.TextureUnitBind(0, batch->textures[0]);
			while (last < batch->count) {
				if (!R_TextureReferenceEqual(batch->textures[first], batch->textures[last])) {
					GL_MultiDrawArrays(glPrimitiveTypes[batch->primitive_id], batch->glFirstVertices, batch->numVertices, last - first);

					renderer.TextureUnitBind(0, batch->textures[last]);
					first = last;
				}
				++last;
			}

			GL_MultiDrawArrays(glPrimitiveTypes[batch->primitive_id], batch->glFirstVertices, batch->numVertices, last - first);
		}

		R_TraceLeaveNamedRegion();

		batch->count = 0;
	}

	R_TraceLeaveNamedRegion();

	R_Sprite3DClearBatches();
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_state.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "r_local.h"
#include "r_trace.h"
#include "r_state.h"

void GLM_BeginDrawWorld(qbool alpha_surfaces, qbool polygon_offset)
{
	if (alpha_surfaces && polygon_offset) {
		R_ApplyRenderingState(r_state_alpha_surfaces_offset_glm);
	}
	else if (alpha_surfaces) {
		R_ApplyRenderingState(r_state_alpha_surfaces_glm);
	}
	else if (polygon_offset) {
		R_ApplyRenderingState(r_state_opaque_surfaces_offset_glm);
	}
	else {
		R_ApplyRenderingState(r_state_opaque_surfaces_glm);
	}
}

void GLM_StateBeginDraw3DSprites(void)
{
}

void GLM_StateBeginPolyBlend(void)
{
	R_ApplyRenderingState(r_state_poly_blend);
}

void GLM_StateBeginImageDraw(void)
{
	R_ApplyRenderingState(r_state_hud_images_glm);
}

void GLM_StateBeginAliasOutlineBatch(void)
{
	R_ApplyRenderingState(r_state_aliasmodel_outline);
}

void GLM_StateBeginAliasModelBatch(qbool translucent, qbool additive)
{
	if (additive) {
		R_ApplyRenderingState(r_state_aliasmodel_additive_batch);
	}
	else if (translucent) {
		R_ApplyRenderingState(r_state_aliasmodel_translucent_batch);
	}
	else {
		R_ApplyRenderingState(r_state_aliasmodel_opaque_batch);
	}
}

void GLM_StateBeginAliasModelZPassBatch(void)
{
	R_ApplyRenderingState(r_state_aliasmodel_translucent_batch_zpass);
}


================================================
FILE: src/glm_texture_arrays.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// glm_texture_arrays.c
#ifdef RENDERER_OPTION_MODERN_OPENGL

// gathers textures of common size into arrays so we can pack more references into fewer samplers

#include "quakedef.h"
#include "vx_stuff.h"
#include "vx_tracker.h"
#include "gl_model.h"
#include "gl_local.h"
#include "rulesets.h"
#ifndef  __APPLE__
#include "tr_types.h"
#endif
#include "glm_texture_arrays.h"
#include "r_texture.h"
#include "r_chaticons.h"
#include "gl_texture_internal.h"
#include "r_renderer.h"

static const texture_array_ref_t zero_array_ref[TEXTURETYPES_COUNT];
static texture_flag_t texture_flags[MAX_GLTEXTURES];
static int flagged_type = 0;

static int SortFlaggedTextures(const void* lhs_, const void* rhs_)
{
	int width_diff;
	int height_diff;
	texture_flag_t* tex1 = (texture_flag_t*)lhs_;
	texture_flag_t* tex2 = (texture_flag_t*)rhs_;

	qbool included1 = tex1->flags & (1 << flagged_type);
	qbool included2 = tex2->flags & (1 << flagged_type);

	if (included1 && !included2) {
		return -1;
	}
	else if (!included1 && included2) {
		return 1;
	}

	if (!R_TextureReferenceIsValid(tex1->ref)) {
		if (!R_TextureReferenceIsValid(tex2->ref)) {
			return 0;
		}
		return 1;
	}
	else if (!R_TextureReferenceIsValid(tex2->ref)) {
		return -1;
	}

	width_diff = R_TextureWidth(tex1->ref) - R_TextureWidth(tex2->ref);
	height_diff = R_TextureHeight(tex1->ref) - R_TextureHeight(tex2->ref);

	if (width_diff) {
		return width_diff;
	}
	if (height_diff) {
		return height_diff;
	}

	return 0;
}

static int SortTexturesByReference(const void* lhs_, const void* rhs_)
{
	texture_flag_t* tex1 = (texture_flag_t*)lhs_;
	texture_flag_t* tex2 = (texture_flag_t*)rhs_;

	if (tex1->ref.index < tex2->ref.index) {
		return -1;
	}
	return 1;
}

static int SortTexturesByArrayReference(const void* lhs_, const void* rhs_)
{
	texture_flag_t* tex1 = (texture_flag_t*)lhs_;
	texture_flag_t* tex2 = (texture_flag_t*)rhs_;

	int zero1 = !memcmp(tex1->array_ref, zero_array_ref, sizeof(zero_array_ref));
	int zero2 = !memcmp(tex2->array_ref, zero_array_ref, sizeof(zero_array_ref));

	if (zero1 && !zero2) {
		return 1;
	}
	else if (!zero1 && zero2) {
		return -1;
	}
	return 0;
}

static void GL_DeleteExistingTextureArrays(qbool delete_textures)
{
	int i;

	if (delete_textures) {
		int j;

		for (i = 0; i < MAX_GLTEXTURES; ++i) {
			if (!memcmp(zero_array_ref, texture_flags[i].array_ref, sizeof(zero_array_ref))) {
				break;
			}

			for (j = 0; j < TEXTURETYPES_COUNT; ++j) {
				if (R_TextureReferenceIsValid(texture_flags[i].array_ref[j].ref)) {
					R_DeleteTextureArray(&texture_flags[i].array_ref[j].ref);
				}
			}
		}
	}

	memset(texture_flags, 0, sizeof(texture_flags));
	for (i = 0; i < MAX_GLTEXTURES; ++i) {
		texture_flags[i].ref.index = i;
	}
}

static qbool GL_SkipTexture(model_t* mod, texture_t* tx);

static GLubyte* tempTextureBuffer;
static GLubyte* emptyTextureBuffer;
static GLuint tempTextureBufferSize;
static GLuint emptyTextureBufferSize;

/*
static qbool AliasModelIsAnySize(model_t* mod)
{
	// Technically every alias model is any size?
	// Not putting alias models in an array at the moment just because player skins are a special case
	//   and can change dynamically due to all the different skin-override settings

	return false;
}

static qbool BrushModelIsAnySize(model_t* mod)
{
	// Some brush models texture repeat and others don't - if it doesn't repeat then we should be
	//   able to insert onto a larger texture and then adjust texture coordinates so it doesn't matter

	return false;
}
*/

void GL_AddTextureToArray(texture_ref arrayTexture, int index, texture_ref tex2dname, qbool tile)
{
	int width = R_TextureWidth(tex2dname);
	int height = R_TextureHeight(tex2dname);
	int final_width = R_TextureWidth(arrayTexture);
	int final_height = R_TextureHeight(arrayTexture);

	int ratio_x = tile ? final_width / width : 0;
	int ratio_y = tile ? final_height / height : 0;
	int x, y;

	if (ratio_x == 0) {
		ratio_x = 1;
	}
	if (ratio_y == 0) {
		ratio_y = 1;
	}

	if (tempTextureBufferSize < width * height * 4 * sizeof(GLubyte)) {
		Q_free(tempTextureBuffer);
		tempTextureBufferSize = width * height * 4 * sizeof(GLubyte);
		tempTextureBuffer = Q_malloc(tempTextureBufferSize);
	}

	if (emptyTextureBufferSize < final_width * final_height * 4 * sizeof(GLubyte)) {
		Q_free(emptyTextureBuffer);
		emptyTextureBufferSize = final_width * final_height * 4 * sizeof(GLubyte);
		emptyTextureBuffer = Q_malloc(emptyTextureBufferSize);
	}

	GL_GetTexImage(GL_TEXTURE0, tex2dname, 0, GL_RGBA, GL_UNSIGNED_BYTE, tempTextureBufferSize, tempTextureBuffer);

	// Clear
	GL_TexSubImage3D(0, arrayTexture, 0, 0, 0, index, final_width, final_height, 1, GL_RGBA, GL_UNSIGNED_BYTE, emptyTextureBuffer);

	// Might need to tile multiple times
	for (x = 0; x < ratio_x; ++x) {
		for (y = 0; y < ratio_y; ++y) {
			GL_TexSubImage3D(0, arrayTexture, 0, x * width, y * height, index, width, height, 1, GL_RGBA, GL_UNSIGNED_BYTE, tempTextureBuffer);
		}
	}
}

static void GL_FlagTexturesForModel(model_t* mod)
{
	int j;

	switch (mod->type) {
	case mod_alias:
	case mod_alias3:
		for (j = 0; j < MAX_SIMPLE_TEXTURES; ++j) {
			if (R_TextureReferenceIsValid(mod->simpletexture[j])) {
				texture_flags[mod->simpletexture[j].index].flags |= (1 << TEXTURETYPES_SPRITES);
			}
		}
		break;
	case mod_sprite:
		{
			msprite2_t* psprite = (msprite2_t*)Mod_Extradata(mod);

			for (j = 0; j < psprite->numframes; ++j) {
				int offset    = psprite->frames[j].offset;
				int numframes = psprite->frames[j].numframes;
				mspriteframe_t* frame;

				if (offset < (int)sizeof(msprite2_t) || numframes < 1) {
					continue;
				}

				frame = ((mspriteframe_t*)((byte*)psprite + offset));
				if (R_TextureReferenceIsValid(frame->gl_texturenum)) {
					texture_flags[frame->gl_texturenum.index].flags |= (1 << TEXTURETYPES_SPRITES);
				}
			}
			break;
		}
	case mod_brush:
		{
			int i, j;

			// Ammo-boxes etc can be replaced with simple textures
			for (j = 0; j < MAX_SIMPLE_TEXTURES; ++j) {
				if (R_TextureReferenceIsValid(mod->simpletexture[j])) {
					texture_flags[mod->simpletexture[j].index].flags |= (1 << TEXTURETYPES_SPRITES);
				}
			}

			// Brush models can be boxes (ammo, health), static world or moving platforms
			for (i = 0; i < mod->numtextures; i++) {
				texture_t* tx = mod->textures[i];
				texture_type type = mod->isworldmodel ? TEXTURETYPES_WORLDMODEL : TEXTURETYPES_BRUSHMODEL;

				if (GL_SkipTexture(mod, tx) || !R_TextureReferenceIsValid(tx->gl_texturenum)) {
					continue;
				}

				if (R_TextureReferenceIsValid(tx->fb_texturenum) && !R_TexturesAreSameSize(tx->gl_texturenum, tx->fb_texturenum)) {
					Con_Printf("Warning: luma texture mismatch: %s (%dx%d vs %dx%d)\n", tx->name, R_TextureWidth(tx->gl_texturenum), R_TextureHeight(tx->gl_texturenum), R_TextureWidth(tx->fb_texturenum), R_TextureHeight(tx->fb_texturenum));
					R_TextureReferenceInvalidate(tx->fb_texturenum);
				}

				texture_flags[tx->gl_texturenum.index].flags |= (1 << type);
				if (R_TextureReferenceIsValid(tx->fb_texturenum)) {
					texture_flags[tx->gl_texturenum.index].subsequent = 1;
				}
			}
			break;
		}
	case mod_unknown:
		// Keep compiler happy
		break;
	}
}

static qbool GL_SkipTexture(model_t* mod, texture_t* tx)
{
	int j;

	if (!tx || !tx->loaded) {
		return true;
	}

	if (tx->anim_next) {
		return false;
	}

	for (j = 0; j < mod->numtexinfo; ++j) {
		if (mod->texinfo[j].texture == tx) {
			if (mod->texinfo[j].surfaces && !mod->texinfo[j].skippable) {
				return false;
			}
		}
	}

	return true;
}

static int GLM_CountTextureArrays(model_t* mod)
{
	int i, j;
	int num_arrays = 0;

	for (i = 0; i < mod->numtextures; ++i) {
		texture_t* tex = mod->textures[i];
		qbool seen_prev = false;

		if (!tex || !tex->loaded || !R_TextureReferenceIsValid(tex->gl_texture_array)) {
			continue;
		}

		for (j = 0; j < i; ++j) {
			texture_t* prev_tex = mod->textures[j];
			if (prev_tex && R_TextureReferenceEqual(prev_tex->gl_texture_array, tex->gl_texture_array)) {
				seen_prev = true;
				break;
			}
		}

		if (!seen_prev) {
			++num_arrays;
		}
	}

	return num_arrays;
}

static void GLM_SetTextureArrays(model_t* mod)
{
	int i, j;
	int num_arrays = 0;

	for (i = 0; i < mod->numtextures; ++i) {
		texture_t* tex = mod->textures[i];
		qbool seen_prev = false;

		if (!tex) {
			continue;
		}

		tex->next_same_size = -1;
		if (!tex->loaded || !R_TextureReferenceIsValid(tex->gl_texture_array)) {
			continue;
		}

		for (j = i - 1; j >= 0; --j) {
			texture_t* prev_tex = mod->textures[j];
			if (prev_tex && R_TextureReferenceEqual(prev_tex->gl_texture_array, tex->gl_texture_array)) {
				seen_prev = true;
				prev_tex->next_same_size = i;
				break;
			}
		}

		if (!seen_prev) {
			mod->texture_array_first[num_arrays] = i;
			mod->texture_arrays[num_arrays] = tex->gl_texture_array;
			mod->textures[i]->size_start = true;
			++num_arrays;
		}
	}
}

static void GL_ImportTexturesForModel(model_t* mod)
{
	int j;

	for (j = 0; j < MAX_SIMPLE_TEXTURES; ++j) {
		if (R_TextureReferenceIsValid(mod->simpletexture[j])) {
			texture_array_ref_t* array_ref = &texture_flags[mod->simpletexture[j].index].array_ref[TEXTURETYPES_SPRITES];

			mod->simpletexture_array[j] = array_ref->ref;
			mod->simpletexture_indexes[j] = array_ref->index;
			mod->simpletexture_scalingS[j] = array_ref->scale_s;
			mod->simpletexture_scalingT[j] = array_ref->scale_t;
		}
	}

	if (mod->type == mod_sprite) {
		msprite2_t* psprite = (msprite2_t*)Mod_Extradata(mod);

		for (j = 0; j < psprite->numframes; ++j) {
			int offset    = psprite->frames[j].offset;
			int numframes = psprite->frames[j].numframes;
			mspriteframe_t* frame;

			if (offset < (int)sizeof(msprite2_t) || numframes < 1) {
				continue;
			}

			frame = ((mspriteframe_t*)((byte*)psprite + offset));

			if (R_TextureReferenceIsValid(frame->gl_texturenum)) {
				texture_array_ref_t* array_ref = &texture_flags[frame->gl_texturenum.index].array_ref[TEXTURETYPES_SPRITES];

				frame->gl_arraynum = array_ref->ref;
				frame->gl_arrayindex = array_ref->index;
				frame->gl_scalingS = array_ref->scale_s;
				frame->gl_scalingT = array_ref->scale_t;
			}
		}
	}
	else if (mod->type == mod_brush) {
		texture_type type = mod->isworldmodel ? TEXTURETYPES_WORLDMODEL : TEXTURETYPES_BRUSHMODEL;
		int i;

		for (i = 0; i < mod->numtextures; i++) {
			texture_t* tx = mod->textures[i];
			texture_array_ref_t* array_ref;

			if (GL_SkipTexture(mod, tx) || !R_TextureReferenceIsValid(tx->gl_texturenum)) {
				continue;
			}

			array_ref = &texture_flags[tx->gl_texturenum.index].array_ref[type];
			tx->gl_texture_array = array_ref->ref;
			tx->gl_texture_index = array_ref->index;
			tx->gl_texture_scaleS = array_ref->scale_s;
			tx->gl_texture_scaleT = array_ref->scale_t;

			// fb has to be the same size and will be subsequent
			if (R_TextureReferenceIsValid(tx->fb_texturenum)) {
				GL_AddTextureToArray(array_ref->ref, array_ref->index + 1, tx->fb_texturenum, false);

				// flag so we delete the 2d version later
				texture_flags[tx->fb_texturenum.index].flags |= (1 << type);
			}
		}

		mod->texture_array_count = GLM_CountTextureArrays(mod);
		if (mod->texture_array_count >= MAX_TEXTURE_ARRAYS_PER_MODEL) {
			// FIXME: Simply fail & fallback to simple textures... or use allocated memory, don't crash the client
			Sys_Error("Model %s has >= %d texture dimensions", mod->name, MAX_TEXTURE_ARRAYS_PER_MODEL);
			return;
		}

		GLM_SetTextureArrays(mod);
	}
}

static int GLM_FindPotentialSizes(int i, int* potential_sizes, int flagged_type, qbool maximise, int* req_width, int* req_height)
{
	int size_index = 0;
	int j;
	int width = R_TextureWidth(texture_flags[i].ref);
	int height = R_TextureHeight(texture_flags[i].ref);

	potential_sizes[size_index++] = 1 + texture_flags[i].subsequent;

	// Count how many textures of the same size we have
	for (j = i + 1; j < MAX_GLTEXTURES; ++j) {
		if (!(texture_flags[j].flags & (1 << flagged_type))) {
			break;
		}

		if (maximise) {
			width = max(width, R_TextureWidth(texture_flags[j].ref));
			height = max(height, R_TextureHeight(texture_flags[j].ref));
		}
		else if (R_TextureWidth(texture_flags[j].ref) != width || R_TextureHeight(texture_flags[j].ref) != height) {
			break;
		}

		potential_sizes[size_index] = potential_sizes[size_index - 1] + 1 + texture_flags[j].subsequent;
		++size_index;
	}

	*req_width = width;
	*req_height = height;
	return size_index;
}

static void GLM_CopyTexturesToArray(texture_ref array_ref, int flagged_type, int min_index, int max_index, int width, int height)
{
	int array_index = 0;
	int k;

	// texture created ok
	if (flagged_type == TEXTURETYPES_SPRITES) {
		renderer.TextureWrapModeClamp(array_ref);
	}

	// Copy the 2D textures across
	for (k = min_index; k <= max_index; ++k) {
		texture_ref ref_2d = texture_flags[k].ref;

		// TODO: compression: flag as ANYSIZE and set scale_s/scale_t accordingly
		GL_AddTextureToArray(array_ref, array_index, ref_2d, false);
		texture_flags[k].array_ref[flagged_type].ref = array_ref;
		texture_flags[k].array_ref[flagged_type].index = array_index;
		texture_flags[k].array_ref[flagged_type].scale_s = (R_TextureWidth(ref_2d) * 1.0f) / width;
		texture_flags[k].array_ref[flagged_type].scale_t = (R_TextureHeight(ref_2d) * 1.0f) / height;

		// (subsequent are the luma textures on brush models)
		array_index += 1 + texture_flags[k].subsequent;
	}
}

static int GLM_CreateArrayFromPotentialSizes(int i, int* potential_sizes, int size_index_max, qbool return_on_failure, int width, int height)
{
	int size_attempt, depth;

	const char* textureTypeNames[] = {
		"aliasmodel",
		"brushmodel",
		"worldmodel",
		"sprites",
	};

	for (size_attempt = size_index_max - 1; size_attempt >= 0; --size_attempt) {
		// create array of desired size
		char name[64];
		texture_ref array_ref;

		R_TextureReferenceInvalidate(array_ref);
		depth = potential_sizes[size_attempt];
		snprintf(name, sizeof(name), "%s_%d[%dx%dx%d]", textureTypeNames[flagged_type], i, width, height, depth);

		array_ref = R_CreateTextureArray(name, width, height, depth, TEX_MIPMAP | TEX_ALPHA);
		if (R_TextureReferenceIsValid(array_ref)) {
			GLM_CopyTexturesToArray(array_ref, flagged_type, i, i + size_attempt, width, height);
			return size_attempt;
		}
	}

	if (!return_on_failure) {
		Sys_Error("Failed to create array size %dx%dx%d\n", width, height, potential_sizes[size_index_max - 1]);
	}
	return -1;
}

// Called from R_NewMap
void GLM_BuildCommonTextureArrays(qbool vid_restart)
{
	int i;
	int potential_sizes[MAX_GLTEXTURES];

	GL_DeleteExistingTextureArrays(!vid_restart);
	R_ClearModelTextureData();

	if (cls.state == ca_disconnected) {
		return;
	}

	for (i = 1; i < MAX_MODELS; ++i) {
		model_t* mod = cl.model_precache[i];

		if (mod && (mod == cl.worldmodel || !mod->isworldmodel)) {
			GL_FlagTexturesForModel(mod);
		}
	}

	for (i = 0; i < MAX_VWEP_MODELS; i++) {
		model_t* mod = cl.vw_model_precache[i];

		if (mod) {
			GL_FlagTexturesForModel(mod);
		}
	}

	// custom models are explicitly loaded by client, not notified by server
	for (i = 0; i < custom_model_count; ++i) {
		model_t* mod = Mod_CustomModel(i, false);

		if (mod) {
			GL_FlagTexturesForModel(mod);
		}
	}

	// Add non-model textures we need (generally sprites)
	{
		QMB_FlagTexturesForArray(texture_flags);
		R_FlagChatIconTexturesForArray(texture_flags);
		VX_FlagTexturesForArray(texture_flags);
		Part_FlagTexturesForArray(texture_flags);
	}

	for (flagged_type = 0; flagged_type < TEXTURETYPES_COUNT; ++flagged_type) {
		qsort(texture_flags, MAX_GLTEXTURES, sizeof(texture_flags[0]), SortFlaggedTextures);

		for (i = 0; i < MAX_GLTEXTURES; ++i) {
			int size_index_max = 0;
			int extra_slots_added;
			int req_width, req_height;

			if (!(texture_flags[i].flags & (1 << flagged_type))) {
				continue;
			}

			size_index_max = GLM_FindPotentialSizes(i, potential_sizes, flagged_type, flagged_type == TEXTURETYPES_SPRITES, &req_width, &req_height);
			extra_slots_added = GLM_CreateArrayFromPotentialSizes(i, potential_sizes, size_index_max, flagged_type == TEXTURETYPES_SPRITES, req_width, req_height);
			if (extra_slots_added == -1) {
				// try again without maximising
				GLM_FindPotentialSizes(i, potential_sizes, flagged_type, false, &req_width, &req_height);
				extra_slots_added = GLM_CreateArrayFromPotentialSizes(i, potential_sizes, size_index_max, false, req_width, req_height);
			}
			i += extra_slots_added;
		}
	}

	qsort(texture_flags, MAX_GLTEXTURES, sizeof(texture_flags[0]), SortTexturesByReference);

	{
		QMB_ImportTextureArrayReferences(texture_flags);
		R_ImportChatIconTextureArrayReferences(texture_flags);
		VX_ImportTextureArrayReferences(texture_flags);
		Part_ImportTexturesForArrayReferences(texture_flags);

		// Go back through all models, importing textures into arrays and creating new VBO
		for (i = 1; i < MAX_MODELS; ++i) {
			model_t* mod = cl.model_precache[i];

			if (mod) {
				GL_ImportTexturesForModel(mod);
			}
		}

		for (i = 0; i < MAX_VWEP_MODELS; i++) {
			model_t* mod = cl.vw_model_precache[i];

			if (mod) {
				GL_ImportTexturesForModel(mod);
			}
		}

		// custom models are explicitly loaded by client, not notified by server
		for (i = 0; i < custom_model_count; ++i) {
			model_t* mod = Mod_CustomModel(i, false);

			if (mod) {
				GL_ImportTexturesForModel(mod);
			}
		}
	}

	// 2nd pass through the models should have filled the arrays, so can create mipmaps now
	qsort(texture_flags, MAX_GLTEXTURES, sizeof(texture_flags[0]), SortTexturesByArrayReference);

	for (i = 0; i < MAX_GLTEXTURES; ++i) {
		int j;
		qbool any = false;

		for (j = 0; j < TEXTURETYPES_COUNT; ++j) {
			if (R_TextureReferenceIsValid(texture_flags[i].array_ref[j].ref)) {
				R_GenerateMipmapsIfNeeded(texture_flags[i].array_ref[j].ref);

				if (j == TEXTURETYPES_BRUSHMODEL) {
					R_DeleteTexture(&texture_flags[i].ref);
				}
				any = true;
			}
		}

		if (!any) {
			break;
		}
	}

	Q_free(tempTextureBuffer);
	Q_free(emptyTextureBuffer);
	emptyTextureBufferSize = tempTextureBufferSize = 0;
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_texture_arrays.h
================================================

#ifndef GLM_TEXTURE_ARRAYS_HEADER
#define GLM_TEXTURE_ARRAYS_HEADER

typedef enum {
	TEXTURETYPES_ALIASMODEL,
	TEXTURETYPES_BRUSHMODEL,
	TEXTURETYPES_WORLDMODEL,
	TEXTURETYPES_SPRITES,

	TEXTURETYPES_COUNT
} texture_type;

typedef struct texture_array_ref_s {
	texture_ref ref;
	int index;
	float scale_s;
	float scale_t;
} texture_array_ref_t;

typedef struct texture_flag_s {
	texture_ref ref;
	int subsequent;
	int flags;

	texture_array_ref_t array_ref[TEXTURETYPES_COUNT];
} texture_flag_t;

void QMB_FlagTexturesForArray(texture_flag_t* texture_flags);
void QMB_ImportTextureArrayReferences(texture_flag_t* texture_flags);

void VX_FlagTexturesForArray(texture_flag_t* texture_flags);
void VX_ImportTextureArrayReferences(texture_flag_t* texture_flags);

void Part_FlagTexturesForArray(texture_flag_t* texture_flags);
void Part_ImportTexturesForArrayReferences(texture_flag_t* texture_flags);

void R_ImportChatIconTextureArrayReferences(texture_flag_t* texture_flags);
void R_FlagChatIconTexturesForArray(texture_flag_t* texture_flags);

#endif // #ifndef GLM_TEXTURE_ARRAYS_HEADER


================================================
FILE: src/glm_vao.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_MODERN_OPENGL

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "glm_vao.h"
#include "r_buffers.h"

typedef struct r_vao_s {
	GLuint vao;

	r_buffer_id element_array_buffer;
} glm_vao_t;

static glm_vao_t vaos[vao_count];

// VAOs
GL_StaticProcedureDeclaration(glGenVertexArrays, "size=%d, arrays=%p", GLsizei n, GLuint* arrays)
GL_StaticProcedureDeclaration(glBindVertexArray, "arrayNum=%u", GLuint arrayNum)
GL_StaticProcedureDeclaration(glDeleteVertexArrays, "n=%d, arrays=%p", GLsizei n, const GLuint* arrays)
GL_StaticProcedureDeclaration(glEnableVertexAttribArray, "index=%u", GLuint index)
GL_StaticProcedureDeclaration(glVertexAttribPointer, "index=%u, size=%d, type=%u, normalized=%d, stride=%d, pointer=%p", GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer)
GL_StaticProcedureDeclaration(glVertexAttribIPointer, "index=%u, size=%d, type=%u, stride=%d, pointer=%p", GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
GL_StaticProcedureDeclaration(glVertexAttribDivisor, "index=%u, divisor=%u", GLuint index, GLuint divisor)

qbool GLM_InitialiseVAOHandling(void)
{
	qbool vaos_supported = true;

	// VAOs: OpenGL 3.0
	if (GL_VersionAtLeast(3, 0) || SDL_GL_ExtensionSupported("GL_ARB_vertex_array_object")) {
		GL_LoadMandatoryFunctionExtension(glGenVertexArrays, vaos_supported);
		GL_LoadMandatoryFunctionExtension(glBindVertexArray, vaos_supported);
		GL_LoadMandatoryFunctionExtension(glDeleteVertexArrays, vaos_supported);
	}
	else {
		vaos_supported = false;
	}

	// OpenGL 2.0
	GL_LoadMandatoryFunctionExtension(glEnableVertexAttribArray, vaos_supported);
	GL_LoadMandatoryFunctionExtension(glVertexAttribPointer, vaos_supported);

	// OpengGL 3.0
	GL_LoadMandatoryFunctionExtension(glVertexAttribIPointer, vaos_supported);

	if (GL_VersionAtLeast(3, 3) ||SDL_GL_ExtensionSupported("GL_ARB_instanced_arrays")) {
		GL_LoadMandatoryFunctionExtension(glVertexAttribDivisor, vaos_supported);
	}
	else {
		vaos_supported = false;
	}

	return vaos_supported;
}

void GLM_BindVertexArray(r_vao_id vao)
{
	GL_Procedure(glBindVertexArray, vaos[vao].vao);
	if (vao) {
		buffers.SetElementArray(vaos[vao].element_array_buffer);
	}
}

void GLM_ConfigureVertexAttribPointer(r_vao_id vao, r_buffer_id vbo, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer, int divisor)
{
	assert(vao);
	assert(vaos[vao].vao);

	R_BindVertexArray(vao);
	if (R_BufferReferenceIsValid(vbo)) {
		buffers.Bind(vbo);
	}
	else {
		buffers.UnBind(buffertype_vertex);
	}

	GL_Procedure(glEnableVertexAttribArray, index);
	GL_Procedure(glVertexAttribPointer, index, size, type, normalized, stride, pointer);
	GL_Procedure(glVertexAttribDivisor, index, divisor);
}

void GLM_ConfigureVertexAttribIPointer(r_vao_id vao, r_buffer_id vbo, GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer, int divisor)
{
	assert(vao);
	assert(vaos[vao].vao);

	R_BindVertexArray(vao);
	if (R_BufferReferenceIsValid(vbo)) {
		buffers.Bind(vbo);
	}
	else {
		buffers.UnBind(buffertype_vertex);
	}

	GL_Procedure(glEnableVertexAttribArray, index);
	GL_Procedure(glVertexAttribIPointer, index, size, type, stride, pointer);
	GL_Procedure(glVertexAttribDivisor, index, divisor);
}

void GLM_SetVertexArrayElementBuffer(r_vao_id vao, r_buffer_id ibo)
{
	assert(vao);
	assert(vaos[vao].vao);

	R_BindVertexArray(vao);
	if (R_BufferReferenceIsValid(ibo)) {
		buffers.Bind(ibo);
	}
	else {
		buffers.UnBind(buffertype_index);
	}
}

void GLM_GenVertexArray(r_vao_id vao, const char* name)
{
	if (vaos[vao].vao) {
		GL_Procedure(glDeleteVertexArrays, 1, &vaos[vao].vao);
	}
	GL_Procedure(glGenVertexArrays, 1, &vaos[vao].vao);
	R_BindVertexArray(vao);
	GL_TraceObjectLabelSet(GL_VERTEX_ARRAY, vaos[vao].vao, -1, name);
	buffers.SetElementArray(r_buffer_none);
}

void GLM_DeleteVAOs(void)
{
	r_vao_id id;

	if (GL_Available(glBindVertexArray)) {
		GL_Procedure(glBindVertexArray, 0);
	}

	for (id = 0; id < vao_count; ++id) {
		if (vaos[id].vao) {
			if (GL_Available(glDeleteVertexArrays)) {
				GL_Procedure(glDeleteVertexArrays, 1, &vaos[id].vao);
			}
			vaos[id].vao = 0;
		}
	}
}

qbool GLM_VertexArrayCreated(r_vao_id vao)
{
	return vaos[vao].vao != 0;
}

void GLM_BindVertexArrayElementBuffer(r_vao_id vao, r_buffer_id ref)
{
	if (vaos[vao].vao) {
		vaos[vao].element_array_buffer = ref;
	}
}

#endif // #ifdef RENDERER_OPTION_MODERN_OPENGL


================================================
FILE: src/glm_vao.h
================================================
/*
Copyright (C) 2018 ezQuake team.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_GLM_VAO_HEADER
#define EZQUAKE_GLM_VAO_HEADER

#include "gl_local.h"
#include "r_vao.h"

void GLM_BindVertexArray(r_vao_id vao);
void GLM_GenVertexArray(r_vao_id vao, const char* name);
void GLM_SetVertexArrayElementBuffer(r_vao_id vao, r_buffer_id ibo);
void GLM_DeleteVAOs(void);

qbool GLM_InitialiseVAOHandling(void);
qbool GLM_VertexArrayCreated(r_vao_id vao);

void GLM_ConfigureVertexAttribPointer(r_vao_id vao, r_buffer_id vbo, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer, int divisor);
void GLM_ConfigureVertexAttribIPointer(r_vao_id vao, r_buffer_id vbo, GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer, int divisor);

void GLM_BindVertexArrayElementBuffer(r_vao_id, r_buffer_id ref);

#endif // EZQUAKE_GLM_VAO_HEADER


================================================
FILE: src/glsl/common.glsl
================================================

// This file included in all .glsl files (inserted at #ezquake-definitions point)

#define MAX_DLIGHTS 32

EZ_SSBO_LAYOUT(std140, EZQ_GL_BINDINGPOINT_FRAMECONSTANTS) uniform GlobalState {
	mat4 modelViewMatrix;
	mat4 projectionMatrix;

	vec4 lightPositions[MAX_DLIGHTS];
	vec4 lightColors[MAX_DLIGHTS];

	vec3 cameraPosition;
	int lightsActive;

	// drawflat colours
	vec4 r_wallcolor;
	vec4 r_floorcolor;
	vec4 r_telecolor;
	vec4 r_lavacolor;
	vec4 r_slimecolor;
	vec4 r_watercolor;
	vec4 r_skycolor;
	vec4 v_blend;

	float time;
	float gamma;
	float contrast;
	int r_alphatestfont;

	// sky
	float skySpeedscale;
	float skySpeedscale2;
	float r_farclip_unused;              // Replace
	float padding;

	// animated skybox
	vec4  skyWind;

	// drawflat toggles
	int r_drawflat;
	int r_fastturb;
	int r_fastsky;
	int r_textureless;

	// [4-byte break]
	float r_lerpmodels;

	// powerup shells round alias models
	float shellSize_unused;               // Replace
	float shell_base_level1;
	float shell_base_level2;
	float shell_effect_level1;
	float shell_effect_level2;
	float shell_alpha;

	// lighting
	float lightScale;

	// [4-byte break]
	int r_width;
	int r_height;
	float r_zFar;
	float r_zNear;

	// fog parameters
	vec3 fogColor;
	float fogDensity;

	float skyFogMix;
	float fogMinZ;
	float fogMaxZ;
	// camAngles.x

	vec3 camAngles; // camAngles.yz
	float r_inv_width;
	float r_inv_height;
};

struct WorldDrawInfo {
	mat4 mvMatrix;
	float alpha;
	int samplerBase;
	int drawFlags;
	int sampler;
};

struct SamplerMapping {
	int sampler;
	float layer;
	int flags;
};

struct AliasModelVert {
	float x, y, z;
	float nx, ny, nz;
	float dx, dy, dz;
	float s, t;
	int padding;
};

struct AliasModel {
	mat4 modelView;
	vec4 color;
	vec4 topcolor;
	vec4 bottomcolor;
	int flags;
	float yaw_angle_rad;
	float shadelight;
	float ambientlight;
	int materialTextureMapping;
	float lerpFraction;
	float minLumaMix;
	float outlineNormalScale;
};

struct model_surface {
	vec4 normal;
	vec4 vecs0;
	vec4 vecs1;
};


================================================
FILE: src/glsl/constants.glsl
================================================

// This file included in all .glsl files (inserted at #ezquake-definitions point)
//   and also .c source files.  For compile-time constants only

#ifndef MAX_LIGHTSTYLES
#define MAX_LIGHTSTYLES         64
#endif

// Alias-model flags
#define AMF_SHELLMODEL_RED      1
#define AMF_SHELLMODEL_BLUE     2
#define AMF_SHELLMODEL_GREEN    4
#define AMF_CAUSTICS            8
#define AMF_TEXTURE_MATERIAL   16
#define AMF_TEXTURE_LUMA       32
#define AMF_WEAPONMODEL        64
#define AMF_PLAYERMODEL       128
#define AMF_TEAMMATE          256
#define AMF_BEHINDWALL        512
#define AMF_VWEPMODEL        1024
#define AMF_SHELLFLAGS       (AMF_SHELLMODEL_RED | AMF_SHELLMODEL_BLUE | AMF_SHELLMODEL_GREEN)

#define AM_VERTEX_NOLERP        1 // the alias model vertex should not be lerped, and always use lerpfraction 1 (meag: update shader if value no longer 1)
#define AM_VERTEX_NORMALFIXED   2 // set after the alias model pose has been checked for matching vertices with different normals

// Brush-model flags
#define EZQ_SURFACE_TYPE   7    // must cover all bits required for TEXTURE_TURB_*
#define TEXTURE_TURB_WATER 1
#define TEXTURE_TURB_SLIME 2
#define TEXTURE_TURB_LAVA  3
#define TEXTURE_TURB_TELE  4
#define TEXTURE_TURB_OTHER 5
#define TEXTURE_TURB_SKY   6

#define EZQ_SURFACE_IS_FLOOR   8    // should be drawn as floor for r_drawflat
#define EZQ_SURFACE_UNDERWATER 16   // requires caustics, if enabled
#define EZQ_SURFACE_HAS_LUMA   32   // surface has luma texture in next array index
#define EZQ_SURFACE_WORLD      64   // world-surface (should have detail textures applied, r_drawflat applied)
#define EZQ_SURFACE_ALPHATEST  128  // alpha-testing should take place when rendering
#define EZQ_SURFACE_HAS_FB     256  // surface has fb texture in next array index
#define EZQ_SURFACE_LIT_TURB   512  // turb surface has lightmap

#define MAX_SAMPLER_MAPPINGS 256

// SSBO/UBO bindings
#define EZQ_GL_BINDINGPOINT_FRAMECONSTANTS      0

// Storage buffer binding points (SSBO on 4.3+, UBO on 4.1)
// In GLSL: offset by 1 when used as UBOs to avoid conflict with GlobalState at 0
// In C code: EZQ_STORAGE_BLOCK_BINDING() macro applies the offset at runtime
#define EZQ_GL_BINDINGPOINT_WORLDMODEL_SURFACES 0
#define EZQ_GL_BINDINGPOINT_ALIASMODEL_DRAWDATA 1
#define EZQ_GL_BINDINGPOINT_BRUSHMODEL_DRAWDATA 2
#define EZQ_GL_BINDINGPOINT_BRUSHMODEL_SAMPLERS 3
#define EZQ_GL_BINDINGPOINT_LIGHTSTYLES         4
#define EZQ_GL_BINDINGPOINT_SURFACES_TO_LIGHT   5

// Alias models
#define EZQ_ALIAS_MODE_NORMAL        0
#define EZQ_ALIAS_MODE_SHELLS        1
#define EZQ_ALIAS_MODE_OUTLINES      2
#define EZQ_ALIAS_MODE_OUTLINES_SPEC 4

// 8x8 block
#define HW_LIGHTING_BLOCK_SIZE 4

// HUD rendering
#define IMAGEPROG_FLAGS_TEXTURE     1    // Texture the image (otherwise colored rectangle)
#define IMAGEPROG_FLAGS_ALPHATEST   2    // Enable alpha-testing when rendering
#define IMAGEPROG_FLAGS_TEXT        4    // Use r_alphatestfont to determine alpha-testing
#define IMAGEPROG_FLAGS_NEAREST     8    // Simulate GL_NEAREST when sampling texture


================================================
FILE: src/glsl/draw_aliasmodel.fragment.glsl
================================================
#ezquake-definitions

uniform int mode;
uniform vec3 outline_color;
uniform vec3 outline_color_team;
uniform vec3 outline_color_enemy;
uniform int outline_use_player_color;

#ifdef DRAW_CAUSTIC_TEXTURES
EZ_LAYOUT_BINDING(SAMPLER_CAUSTIC_TEXTURE) uniform sampler2D causticsTex;
#endif
EZ_LAYOUT_BINDING(SAMPLER_MATERIAL_TEXTURE_START) uniform sampler2D samplers[SAMPLER_COUNT];

in vec2 fsTextureCoord;
in vec2 fsAltTextureCoord;
#ifdef EZQ_ALIASMODEL_FLATSHADING
flat in vec4 fsBaseColor;
#else
in vec4 fsBaseColor;
#endif
flat in int fsFlags;
flat in int fsTextureEnabled;
flat in int fsMaterialSampler;
flat in float fsMinLumaMix;
flat in vec4 plrtopcolor;
flat in vec4 plrbotcolor;

out vec4 frag_colour;

bool texture_coord_is_on_legs() {
	// both front and back legs at the same y level on the texture
	if(fsTextureCoord.y >= 0.42 && fsTextureCoord.y <= 1)
	           /*                   front legs                  */    /*                   back legs                   */
		return fsTextureCoord.x >= 0.19 && fsTextureCoord.x <= 0.4 || fsTextureCoord.x >= 0.69 && fsTextureCoord.x <= 0.9;

	return false;
}

void main()
{
	if((fsFlags & AMF_PLAYERMODEL) != 0) {
		if(outline_use_player_color != 0) {
			if((fsFlags & AMF_VWEPMODEL) != 0) { // vwep model is top color
				frag_colour = vec4(plrtopcolor.rgb, 1.0f);
			} else {
				if (texture_coord_is_on_legs())
					frag_colour = vec4(plrbotcolor.rgb, 1.0f);
				else
					frag_colour = vec4(plrtopcolor.rgb, 1.0f);
			}
		} else {
			if((fsFlags & AMF_TEAMMATE) != 0)
				frag_colour = vec4(outline_color_team, 1.0f);
			else
				frag_colour = vec4(outline_color_enemy, 1.0f);
		}
	} else {
		frag_colour = vec4(outline_color, 1.0f);
	}

	if (mode != EZQ_ALIAS_MODE_OUTLINES && mode != EZQ_ALIAS_MODE_OUTLINES_SPEC) {
		vec4 tex = texture(samplers[fsMaterialSampler], fsTextureCoord.st);
		vec4 altTex = texture(samplers[fsMaterialSampler], fsAltTextureCoord.st);
#ifdef DRAW_CAUSTIC_TEXTURES
		vec4 caustic = texture(
			causticsTex,
			vec2(
				// Using multipler of 3 here - not in other caustics logic but range
				//   isn't enough otherwise, effect too subtle
				(fsTextureCoord.s + sin(0.465 * (time + fsTextureCoord.t))) * 3 * -0.1234375,
				(fsTextureCoord.t + sin(0.465 * (time + fsTextureCoord.s))) * 3 * -0.1234375
			)
		);
#endif

		if (mode == EZQ_ALIAS_MODE_SHELLS) {
			vec4 color1 = vec4(
				shell_base_level1 + ((fsFlags & AMF_SHELLMODEL_RED) != 0 ? shell_effect_level1 : 0),
				shell_base_level1 + ((fsFlags & AMF_SHELLMODEL_GREEN) != 0 ? shell_effect_level1 : 0),
				shell_base_level1 + ((fsFlags & AMF_SHELLMODEL_BLUE) != 0 ? shell_effect_level1 : 0),
				0
			);
			vec4 color2 = vec4(
				shell_base_level2 + ((fsFlags & AMF_SHELLMODEL_RED) != 0 ? shell_effect_level2 : 0),
				shell_base_level2 + ((fsFlags & AMF_SHELLMODEL_GREEN) != 0 ? shell_effect_level2 : 0),
				shell_base_level2 + ((fsFlags & AMF_SHELLMODEL_BLUE) != 0 ? shell_effect_level2 : 0),
				0
			);

			frag_colour = color1 * tex + color2 * altTex;
#ifdef DRAW_FOG
			frag_colour = applyFogBlend(frag_colour, gl_FragCoord.z / gl_FragCoord.w);
#endif
			frag_colour *= shell_alpha;
		}
		else {
			frag_colour = vec4(fsBaseColor.rgb, 1);
			if (fsTextureEnabled != 0) {
				frag_colour = vec4(mix(tex.rgb, tex.rgb * fsBaseColor.rgb, max(fsMinLumaMix, tex.a)), 1);
			}
#ifdef DRAW_CAUSTIC_TEXTURES
			if ((fsFlags & AMF_CAUSTICS) == AMF_CAUSTICS) {
				// FIXME: Do proper GL_DECAL etc
				frag_colour = vec4(caustic.rgb * frag_colour.rgb * 1.8, 1);
			}
#endif
#ifdef DRAW_FOG
			frag_colour = applyFog(frag_colour, gl_FragCoord.z / gl_FragCoord.w);
#endif
			frag_colour *= fsBaseColor.a;
		}
	} else {
#ifdef DRAW_FOG
		frag_colour = applyFog(frag_colour, gl_FragCoord.z / gl_FragCoord.w);
#endif
	}
}


================================================
FILE: src/glsl/draw_aliasmodel.vertex.glsl
================================================
#ezquake-definitions

uniform int mode;
uniform float outline_scale;
#ifndef DRAW_INSTANCED
uniform int instanceOffset;
#endif

layout(location = 0) in vec3 vboPosition;
layout(location = 1) in vec2 vboTex;
layout(location = 2) in vec3 vboNormalCoords;
layout(location = 3) in int _instanceId;
layout(location = 4) in vec3 vboDirection;
layout(location = 5) in int vboFlags;

EZ_SSBO_LAYOUT(std140, EZQ_GL_BINDINGPOINT_ALIASMODEL_DRAWDATA) EZ_SSBO(AliasModelData) {
	AliasModel models[EZ_SSBO_ARRAY_SIZE(64)];
};

out vec2 fsTextureCoord;
out vec2 fsAltTextureCoord;
#ifdef EZQ_ALIASMODEL_FLATSHADING
flat out vec4 fsBaseColor;
#else
out vec4 fsBaseColor;
#endif
flat out int fsFlags;
flat out int fsTextureEnabled;
flat out int fsMaterialSampler;
flat out float fsMinLumaMix;
flat out vec4 plrtopcolor;
flat out vec4 plrbotcolor;

void main()
{
#ifndef DRAW_INSTANCED
	uint modelId = _instanceId + instanceOffset;
#else
	uint modelId = _instanceId;
#endif
	float lerpFrac = models[modelId].lerpFraction;

	vec3 position = vboPosition;
	vec2 tex = vboTex;
	vec3 normalCoords = vboNormalCoords;

	fsFlags = models[modelId].flags;
	fsMinLumaMix = models[modelId].minLumaMix;

	plrtopcolor = models[modelId].topcolor;
	plrbotcolor = models[modelId].bottomcolor;

#ifdef EZQ_ALIASMODEL_MUZZLEHACK
	lerpFrac = sign(lerpFrac) * max(lerpFrac, (vboFlags & AM_VERTEX_NOLERP));
#endif
	position = position + vboDirection * lerpFrac;
	fsMaterialSampler = models[modelId].materialTextureMapping;

	if (mode == EZQ_ALIAS_MODE_NORMAL) {
		gl_Position = projectionMatrix * models[modelId].modelView * vec4(position, 1);

		fsAltTextureCoord = fsTextureCoord = vec2(tex.s, tex.t);
		fsTextureEnabled = (models[modelId].flags & AMF_TEXTURE_MATERIAL);

		// Lighting: this is rough approximation
		//   Credit to mh @ http://forums.insideqc.com/viewtopic.php?f=3&t=2983
		if (models[modelId].shadelight < 1000) {
			float l = 1;
			vec3 angleVector = normalize(vec3(cos(-models[modelId].yaw_angle_rad), sin(-models[modelId].yaw_angle_rad), 1));

			l = floor((dot(normalCoords, angleVector) + 1) * 127) / 127;
			l = min((l * models[modelId].shadelight + models[modelId].ambientlight) / 256.0, 1);

			fsBaseColor = vec4(models[modelId].color.rgb * l, models[modelId].color.a);
		}
		else {
			fsBaseColor = models[modelId].color;
		}
	}
	else if (mode == EZQ_ALIAS_MODE_OUTLINES || mode == EZQ_ALIAS_MODE_OUTLINES_SPEC) {
		gl_Position = projectionMatrix * models[modelId].modelView * vec4(position + /*models[modelId].outlineNormalScale **/ normalCoords * outline_scale, 1);
		fsTextureCoord = vec2(tex.x, tex.y);
	}
	else {
		gl_Position = projectionMatrix * models[modelId].modelView * vec4(position + normalCoords * 0.5, 1);
		fsTextureCoord = vec2(tex.s * 2 + cos(time * 1.5), tex.t * 2 + sin(time * 1.1));
		fsAltTextureCoord = vec2(tex.s * 2 + cos(time * -0.5), tex.t * 2 + sin(time * -0.5));
		fsTextureEnabled = 1;
		fsMaterialSampler = 0;
	}

	if ((fsFlags & AMF_WEAPONMODEL) != 0) {
#ifdef EZQ_REVERSED_DEPTH
		gl_Position.z *= 1 / 0.3;
#else
		gl_Position.z *= 0.3;
#endif
	}
}


================================================
FILE: src/glsl/draw_sprites.fragment.glsl
================================================
#ezquake-definitions

EZ_LAYOUT_BINDING(0) uniform sampler2DArray materialTex;
uniform bool alpha_test;

in vec3 TextureCoord;
in vec4 fsColor;

out vec4 frag_color;

void main()
{
	frag_color = texture(materialTex, TextureCoord);

	frag_color *= fsColor;

	if (alpha_test && frag_color.a < 0.3) {
		discard;
	}

#ifdef DRAW_FOG
	frag_color = applyFogBlend(frag_color, gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/draw_sprites.vertex.glsl
================================================
#ezquake-definitions

layout(location=0) in vec3 position;
layout(location=1) in vec3 texCoord;
layout(location=2) in vec4 colour;

out vec3 TextureCoord;
out vec4 fsColor;

void main()
{
	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1);
	TextureCoord = texCoord;
	fsColor = colour;
}


================================================
FILE: src/glsl/draw_world.fragment.glsl
================================================
#ezquake-definitions

uniform int draw_outlines;

#ifdef DRAW_DETAIL_TEXTURES
EZ_LAYOUT_BINDING(SAMPLER_DETAIL_TEXTURE) uniform sampler2D detailTex;
#endif
#ifdef DRAW_CAUSTIC_TEXTURES
EZ_LAYOUT_BINDING(SAMPLER_CAUSTIC_TEXTURE) uniform sampler2D causticsTex;
#endif
#if defined(DRAW_SKYBOX)
EZ_LAYOUT_BINDING(SAMPLER_SKYBOX_TEXTURE) uniform samplerCube skyTex;
#elif defined(DRAW_SKYDOME)
EZ_LAYOUT_BINDING(SAMPLER_SKYDOME_TEXTURE) uniform sampler2D skyDomeTex;
EZ_LAYOUT_BINDING(SAMPLER_SKYDOME_CLOUDTEXTURE) uniform sampler2D skyDomeCloudTex;
#endif
EZ_LAYOUT_BINDING(SAMPLER_LIGHTMAP_TEXTURE) uniform sampler2DArray lightmapTex;
EZ_LAYOUT_BINDING(SAMPLER_MATERIAL_TEXTURE_START) uniform sampler2DArray materialTex[SAMPLER_MATERIAL_TEXTURE_COUNT];

in vec3 TextureCoord;
centroid in vec3 TexCoordLightmap;
#ifdef DRAW_DETAIL_TEXTURES
in vec2 DetailCoord;
#endif
#if defined(DRAW_LUMA_TEXTURES) || defined(DRAW_LUMA_TEXTURES_FB)
in vec3 LumaCoord;
#endif
in vec3 FlatColor;
flat in int Flags;
#if defined(DRAW_SKYBOX) || defined(DRAW_SKYDOME)
in vec3 Direction;
#endif
#ifdef DRAW_GEOMETRY
in vec3 Normal;
in vec4 UnClipped;
#endif

#ifdef DRAW_FLATFLOORS
in float mix_floor;
#endif
#ifdef DRAW_FLATWALLS
in float mix_wall;
#endif
#ifdef DRAW_ALPHATEST_ENABLED
in float alpha;
#endif
flat in int SamplerNumber;

layout(location=0) out vec4 frag_colour;
#ifdef DRAW_GEOMETRY
layout(location=1) out vec4 normal_texture;
#endif

// Drawflat mode TINTED... Amend texture color based on floor/wall
// FIXME: common with glsl, do some kind of #include support
#ifdef DRAW_DRAWFLAT_TINTED
vec4 applyColorTinting(vec4 frag_colour)
{
#if defined(DRAW_FLATFLOORS) && defined(DRAW_FLATWALLS)
	vec3 inter = mix(frag_colour.rgb, frag_colour.rgb * r_floorcolor.rgb, mix_floor);
	frag_colour = vec4(mix(inter, inter * r_wallcolor.rgb, mix_wall), frag_colour.a);
#elif defined(DRAW_FLATWALLS)
	frag_colour = vec4(mix(frag_colour.rgb, frag_colour.rgb * r_wallcolor.rgb, mix_wall), frag_colour.a);
#elif defined(DRAW_FLATFLOORS)
	frag_colour = vec4(mix(frag_colour.rgb, frag_colour.rgb * r_floorcolor.rgb, mix_floor), frag_colour.a);
#endif
	return frag_colour;
}
#elif defined(DRAW_DRAWFLAT_BRIGHT)
vec4 applyColorTinting(vec4 frag_colour)
{
	// evaluate brightness as per lightmap scaling ("// kudos to Darel Rex Finley for his HSP color model")
	float brightness = sqrt(frag_colour.r * frag_colour.r * 0.241 + frag_colour.g * frag_colour.g * 0.691 + frag_colour.b * frag_colour.b * 0.068);

#if defined(DRAW_FLATWALLS)
	frag_colour = vec4(mix(frag_colour.rgb, r_wallcolor.rgb * brightness, mix_wall), frag_colour.a);
#endif
#if defined(DRAW_FLATFLOORS)
	frag_colour = vec4(mix(frag_colour.rgb, r_floorcolor.rgb * brightness, mix_floor), frag_colour.a);
#endif

	return frag_colour;
}
#else
#define applyColorTinting(x) (x)
#endif

#if defined(DRAW_TEXTURELESS) && defined(DRAW_ALPHATEST_ENABLED)
// We pass the original coordinates in TextureCoord & use them for alpha-test, but this is where color should come from
out vec3 TextureLessCoord;
#endif

void main()
{
	vec4 texColor;
	vec4 lmColor;
	int turbType;

#ifdef DRAW_GEOMETRY
	int surface = Flags & EZQ_SURFACE_TYPE;
	// if the texture is a turb, force outline between it and regular textures, but not between other turbs of the same type
	float depth = (surface != 0) ? -float(surface) : abs(UnClipped.z / r_zFar);
	normal_texture = vec4(Normal, depth);
#endif

	if (draw_outlines == 1) {
		frag_colour = vec4(0.5, 0.5, 0.5, 1);
		return;
	}

#ifdef DRAW_DETAIL_TEXTURES
	vec4 detail = texture(detailTex, DetailCoord);
#endif
#ifdef DRAW_CAUSTIC_TEXTURES
	vec4 caustic = texture(
		causticsTex,
		vec2(
			(TextureCoord.s + sin(0.465 * (time + TextureCoord.t))) * -0.1234375,
			(TextureCoord.t + sin(0.465 * (time + TextureCoord.s))) * -0.1234375
		)
	);
#endif
#if defined(DRAW_LUMA_TEXTURES) || defined(DRAW_LUMA_TEXTURES_FB)
	vec4 lumaColor = texture(materialTex[SamplerNumber], LumaCoord);
#endif

	vec3 tex = TextureCoord;

	tex.s = mix(TextureCoord.s, TextureCoord.s + (sin((TextureCoord.t + time) * 1.5) * 0.125), min(1, Flags & EZQ_SURFACE_TYPE));
	tex.t = mix(TextureCoord.t, TextureCoord.t + (sin((TextureCoord.s + time) * 1.5) * 0.125), min(1, Flags & EZQ_SURFACE_TYPE));

	lmColor = texture(lightmapTex, TexCoordLightmap);
	texColor = texture(materialTex[SamplerNumber], tex);

#ifdef DRAW_ALPHATEST_ENABLED
	#ifdef DRAW_TEXTURELESS
		texColor = vec4(texture(materialTex[SamplerNumber], TextureLessCoord).rgb, texColor.a);
	#endif
	if ((Flags & EZQ_SURFACE_ALPHATEST) == EZQ_SURFACE_ALPHATEST && texColor.a < 0.5) {
		discard;
	}
#endif

#if defined(DRAW_ALPHATEST_ENABLED) || defined(DRAW_FOG)
	// Avoid black artifacts at border at edge of fence textures and guarantee that
	// fog function doesn't multiply with zero.
	texColor = vec4(texColor.rgb, 1.0);
#endif

	turbType = Flags & EZQ_SURFACE_TYPE;
	if (turbType != 0) {
		// Turb surface
		if (turbType != TEXTURE_TURB_SKY && r_fastturb != 0) {
			if (turbType == TEXTURE_TURB_WATER) {
				frag_colour = r_watercolor;
			}
			else if (turbType == TEXTURE_TURB_SLIME) {
				frag_colour = r_slimecolor;
			}
			else if (turbType == TEXTURE_TURB_LAVA) {
				frag_colour = r_lavacolor;
			}
			else if (turbType == TEXTURE_TURB_TELE) {
				frag_colour = r_telecolor;
			}
			else {
				frag_colour = vec4(FlatColor, 1);
			}
#ifdef DRAW_FOG
			frag_colour = applyFog(frag_colour, gl_FragCoord.z / gl_FragCoord.w);
#endif
#ifdef DRAW_ALPHATEST_ENABLED
			frag_colour *= alpha;
#endif
		}
		else if (turbType == TEXTURE_TURB_SKY) {
#if defined(DRAW_SKYBOX)
			frag_colour = texture(skyTex, Direction);
#if defined(DRAW_SKYWIND)
			float t1 = skyWind.w;
			float t2 = fract(t1) - 0.5;
			float blend = abs(t1 * 2.0);
			vec3 dir = normalize(Direction);
			vec4 layer1 = texture(skyTex, dir + t1 * skyWind.xyz);
			vec4 layer2 = texture(skyTex, dir + t2 * skyWind.xyz);
			layer1.a *= 1.0 - blend;
			layer2.a *= blend;
			layer1.rgb *= layer1.a;
			layer2.rgb *= layer2.a;
			vec4 combined = layer1 + layer2;
			frag_colour = vec4(frag_colour.rgb * (1.0 - combined.a) + combined.rgb, 1);
#endif
#elif defined(DRAW_SKYDOME)
			const float len = 3.09375;
			// Flatten it out
			vec3 dir = normalize(vec3(Direction.x, Direction.y, 3 * Direction.z));

			vec4 skyColor = texture(skyDomeTex, vec2(skySpeedscale + dir.x * len, skySpeedscale + dir.y * len));
			vec4 cloudColor = texture(skyDomeCloudTex, vec2(skySpeedscale2 + dir.x * len, skySpeedscale2 + dir.y * len));

			frag_colour = mix(skyColor, cloudColor, cloudColor.a);
#else
			frag_colour = r_skycolor;
#endif
#ifdef DRAW_FOG
			frag_colour = vec4(mix(frag_colour.rgb, fogColor, skyFogMix), frag_colour.a);
#endif
		}
		else {
			frag_colour = texColor;
			if ((Flags & EZQ_SURFACE_LIT_TURB) > 0) {
				frag_colour = vec4(lmColor.rgb, 1) * frag_colour;
			}
#ifdef DRAW_FOG
			frag_colour = applyFog(frag_colour, gl_FragCoord.z / gl_FragCoord.w);
#endif
#ifdef DRAW_ALPHATEST_ENABLED
			frag_colour *= alpha;
#endif
		}
	}
	else {
		// Typical material
#if defined(DRAW_DRAWFLAT_NORMAL) && defined(DRAW_FLATFLOORS) && defined(DRAW_FLATWALLS)
		texColor = vec4(mix(mix(texColor.rgb, r_floorcolor.rgb, mix_floor), r_wallcolor.rgb, mix_wall), texColor.a);
	#ifdef DRAW_LUMA_TEXTURES
		lumaColor = vec4(0, 0, 0, 0);
	#endif
#elif defined(DRAW_DRAWFLAT_NORMAL) && defined(DRAW_FLATFLOORS)
		texColor = vec4(mix(texColor.rgb, r_floorcolor.rgb, mix_floor), texColor.a);
	#ifdef DRAW_LUMA_TEXTURES
		lumaColor = mix(lumaColor, vec4(0, 0, 0, 0), mix_floor);
	#endif
#elif defined(DRAW_DRAWFLAT_NORMAL) && defined(DRAW_FLATWALLS)
		texColor = vec4(mix(texColor.rgb, r_wallcolor.rgb, mix_wall), texColor.a);
	#ifdef DRAW_LUMA_TEXTURES
		lumaColor = mix(lumaColor, vec4(0, 0, 0, 0), mix_wall);
	#endif
#endif

#if defined(DRAW_LUMA_TEXTURES) && !defined(DRAW_LUMA_TEXTURES_FB)
		texColor = vec4(mix(texColor.rgb, texColor.rgb + lumaColor.rgb, min(1, Flags & EZQ_SURFACE_HAS_LUMA)), texColor.a);
#endif
		texColor = applyColorTinting(texColor);
		frag_colour = vec4(lmColor.rgb, 1) * texColor;
#if defined(DRAW_LUMA_TEXTURES) && defined(DRAW_LUMA_TEXTURES_FB)
		lumaColor = applyColorTinting(lumaColor);
		frag_colour = vec4(mix(frag_colour.rgb, frag_colour.rgb + lumaColor.rgb, min(1, Flags & EZQ_SURFACE_HAS_LUMA)), frag_colour.a);
		frag_colour = vec4(mix(frag_colour.rgb, lumaColor.rgb, min(1, Flags & EZQ_SURFACE_HAS_FB) * lumaColor.a), frag_colour.a);
#elif !defined(DRAW_LUMA_TEXTURES) && defined(DRAW_LUMA_TEXTURES_FB)
		// GL_DECAL
		lumaColor = applyColorTinting(lumaColor);
		frag_colour = vec4(mix(frag_colour.rgb, lumaColor.rgb, min(1, Flags & EZQ_SURFACE_HAS_FB) * lumaColor.a), frag_colour.a);
#endif

#ifdef DRAW_CAUSTIC_TEXTURES
		frag_colour = vec4(mix(frag_colour.rgb, caustic.rgb * frag_colour.rgb * 2.0, min(1, Flags & EZQ_SURFACE_UNDERWATER)), frag_colour.a);
#endif

#ifdef DRAW_DETAIL_TEXTURES
		frag_colour = vec4(mix(frag_colour.rgb, detail.rgb * frag_colour.rgb * 2.0, min(1, Flags & EZQ_SURFACE_WORLD)), frag_colour.a);
#endif

#ifdef DRAW_FOG
		frag_colour = applyFog(frag_colour, gl_FragCoord.z / gl_FragCoord.w);
#endif

#ifdef DRAW_ALPHATEST_ENABLED
		frag_colour *= alpha;
#endif
	}
}


================================================
FILE: src/glsl/draw_world.vertex.glsl
================================================
#ezquake-definitions

layout(location = 0) in vec3 position;
layout(location = 1) in vec3 tex;
layout(location = 2) in vec3 lightmapCoord;
layout(location = 3) in vec2 detailCoord;
layout(location = 4) in int _instanceId;
layout(location = 5) in int vboFlags;
layout(location = 6) in vec3 flatColor;
layout(location = 7) in int surfaceNumber;

#ifndef DRAW_INSTANCED
uniform int instanceOffset;
#endif

centroid out vec3 TexCoordLightmap;
out vec3 TextureCoord;
#ifdef DRAW_TEXTURELESS
out vec3 TextureLessCoord;
#endif
#if defined(DRAW_LUMA_TEXTURES) || defined(DRAW_LUMA_TEXTURES_FB)
out vec3 LumaCoord;
#endif
#ifdef DRAW_DETAIL_TEXTURES
out vec2 DetailCoord;
#endif
out vec3 FlatColor;
flat out int Flags;
#if defined(DRAW_SKYBOX) || defined(DRAW_SKYDOME)
out vec3 Direction;
#endif
#ifdef DRAW_GEOMETRY
out vec3 Normal;
out vec4 UnClipped;

EZ_SSBO_LAYOUT(std140, EZQ_GL_BINDINGPOINT_WORLDMODEL_SURFACES) EZ_SSBO(surface_data) {
	model_surface surfaces[EZ_SSBO_ARRAY_SIZE(8192)];
};
#endif

#ifdef DRAW_FLATFLOORS
out float mix_floor;
#endif
#ifdef DRAW_FLATWALLS
out float mix_wall;
#endif
#ifdef DRAW_ALPHATEST_ENABLED
out float alpha;
#endif
flat out int SamplerNumber;

EZ_SSBO_LAYOUT(std140, EZQ_GL_BINDINGPOINT_BRUSHMODEL_DRAWDATA) EZ_SSBO(WorldCvars) {
	WorldDrawInfo drawInfo[EZ_SSBO_ARRAY_SIZE(64)];
};
EZ_SSBO_LAYOUT(std140, EZQ_GL_BINDINGPOINT_BRUSHMODEL_SAMPLERS) EZ_SSBO(SamplerMappingsBuffer) {
	SamplerMapping samplerMapping[EZ_SSBO_ARRAY_SIZE(256)];
};


void main()
{
#ifndef DRAW_INSTANCED
	int modelId = _instanceId + instanceOffset;
#else
	int modelId = _instanceId;
#endif
	int materialNumber = int(tex.z);
	float materialArrayIndex = samplerMapping[drawInfo[modelId].samplerBase + materialNumber].layer;
	int drawCallFlags = drawInfo[modelId].drawFlags;
	int textureFlags = samplerMapping[drawInfo[modelId].samplerBase + materialNumber].flags;
#ifdef DRAW_ALPHATEST_ENABLED
	alpha = drawInfo[modelId].alpha;
#endif
	SamplerNumber = drawInfo[modelId].sampler;

	gl_Position = projectionMatrix * drawInfo[modelId].mvMatrix * vec4(position, 1.0);
#ifdef DRAW_GEOMETRY
	Normal = surfaces[surfaceNumber].normal.xyz;
	UnClipped = drawInfo[modelId].mvMatrix * vec4(position, 1.0);
#endif

	FlatColor = flatColor;
	Flags = vboFlags | drawCallFlags | textureFlags;

	if (lightmapCoord.z < 0) {
		TextureCoord = vec3(tex.xy, materialArrayIndex);
		TexCoordLightmap = vec3(0, 0, 0);
#if defined(DRAW_SKYBOX) || defined(DRAW_SKYDOME)
		Direction = (position - cameraPosition);
#if defined(DRAW_SKYBOX)
		Direction = vec3(-Direction.y, Direction.z, Direction.x);
#endif
#endif
#ifdef DRAW_DETAIL_TEXTURES
		DetailCoord = vec2(0, 0);
#endif
#if defined(DRAW_LUMA_TEXTURES) || defined(DRAW_LUMA_TEXTURES_FB)
		LumaCoord = TextureCoord;
#endif

#ifdef DRAW_FLATFLOORS
		mix_floor = 0;
#endif
#ifdef DRAW_FLATWALLS
		mix_wall = 0;
#endif
	}
	else {
#if defined(DRAW_TEXTURELESS) && !defined(DRAW_ALPHATEST_ENABLED)
		TextureCoord = vec3(mix(tex.xy, vec2(0, 0), min(Flags & EZQ_SURFACE_WORLD, 1)), materialArrayIndex);
#elif defined(DRAW_TEXTURELESS)
		TextureLessCoord = vec3(mix(tex.xy, vec2(0, 0), min(Flags & EZQ_SURFACE_WORLD, 1)), materialArrayIndex);
		TextureCoord = vec3(tex.xy, materialArrayIndex);
#else
		TextureCoord = vec3(tex.xy, materialArrayIndex);
#endif

#if defined(DRAW_LUMA_TEXTURES) || defined(DRAW_LUMA_TEXTURES_FB)
		LumaCoord = (Flags & (EZQ_SURFACE_HAS_LUMA | EZQ_SURFACE_HAS_FB)) != 0 ? vec3(TextureCoord.st, TextureCoord.z + 1) : TextureCoord;
#endif
		TexCoordLightmap = lightmapCoord;
#ifdef DRAW_DETAIL_TEXTURES
		DetailCoord = detailCoord;
#endif

#ifdef DRAW_FLATFLOORS
		mix_floor = min(1, (Flags & EZQ_SURFACE_WORLD) * (Flags & EZQ_SURFACE_IS_FLOOR));
#endif
#ifdef DRAW_FLATWALLS
		mix_wall = min(1, (Flags & EZQ_SURFACE_WORLD) * (1 - mix_floor));
#endif
	}
}


================================================
FILE: src/glsl/fx_world_geometry.fragment.glsl
================================================
#ezquake-definitions

EZ_LAYOUT_BINDING(0) uniform sampler2D normal_texture;

uniform vec3 outline_color;
uniform float outline_scale;
uniform float outline_depth_threshold;
uniform float outline_normal_threshold;

in vec2 TextureCoord;
out vec4 frag_colour;

bool vec_nequ(vec3 a, vec3 b) {
	return dot(a, b) < outline_normal_threshold;
}

void main()
{
	ivec2 coords = ivec2(TextureCoord.x * r_width, TextureCoord.y * r_height);

	// Scale the sampling offsets by outline_scale
	ivec2 offset_x = ivec2(int(outline_scale), 0);
	ivec2 offset_y = ivec2(0, int(outline_scale));

	vec4 center = texelFetch(normal_texture, coords, 0);
	vec4 left   = texelFetch(normal_texture, coords - offset_x, 0);
	vec4 right  = texelFetch(normal_texture, coords + offset_x, 0);
	vec4 up     = texelFetch(normal_texture, coords - offset_y, 0);
	vec4 down   = texelFetch(normal_texture, coords + offset_y, 0);

	bool ignore = center.a == left.a && center.a == right.a && center.a == up.a && center.a == down.a;
	if(ignore) {
		frag_colour = vec4(0);
		return;
	}

	if(center.a == 0) {
		frag_colour = vec4(0);
		return;
	}

	if ((left.a  != 0 && vec_nequ(center.rgb, left.rgb )) ||
		(right.a != 0 && vec_nequ(center.rgb, right.rgb)) ||
		(up.a    != 0 && vec_nequ(center.rgb, up.rgb   )) ||
		(down.a  != 0 && vec_nequ(center.rgb, down.rgb ))
	) {
		frag_colour.rgb = outline_color;
		frag_colour.a = 1;
		return;
	}

	bool z_diff = r_zFar * abs((right.a - center.a) - (center.a - left.a)) > outline_depth_threshold;
	bool z_diff2 = r_zFar * abs((down.a - center.a) - (center.a - up.a)) > outline_depth_threshold;

	if (center.a != 0 && (
	(left.a  != 0 && right.a != 0 && z_diff) ||
	(down.a  != 0 && up.a    != 0 && z_diff2)
	)) {
		frag_colour = vec4(outline_color, 1.0f);
		return;
	}
	frag_colour = vec4(0.0f);
}


================================================
FILE: src/glsl/fx_world_geometry.vertex.glsl
================================================
#ezquake-definitions

layout(location = 0) in vec2 inPosition;
layout(location = 1) in vec2 inTextureCoord;

out vec2 TextureCoord;

void main()
{
	gl_Position = vec4(inPosition, 0, 1);
	TextureCoord = inTextureCoord;
}


================================================
FILE: src/glsl/glc/glc_aliasmodel_shadow.fragment.glsl
================================================
#version 120

#ezquake-definitions

void main()
{
	gl_FragColor = vec4(0, 0, 0, 0.5);

#ifdef DRAW_FOG
	gl_FragColor = applyFog(gl_FragColor, gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/glc/glc_aliasmodel_shadow.vertex.glsl
================================================
#version 120

#ezquake-definitions

attribute float flags;

uniform float lerpFraction;
uniform vec2 shadevector;
uniform float lheight;

void main()
{
	float lerpFrac = lerpFraction;

#ifdef EZQ_ALIASMODEL_MUZZLEHACK
	// #define AM_VERTEX_NOLERP 1 - no bittest in glsl 1.2
	lerpFrac = sign(lerpFrac) * max(lerpFrac, mod(flags, 2));
#endif

	vec4 pos = gl_Vertex + lerpFrac * vec4(gl_MultiTexCoord1.xyz, 0);

	pos.x -= shadevector[0] * (pos[2] + lheight);
	pos.y -= shadevector[1] * (pos[2] + lheight);
	pos.z = (1 - lheight);

	gl_Position = gl_ModelViewProjectionMatrix * pos;
}


================================================
FILE: src/glsl/glc/glc_aliasmodel_shell.fragment.glsl
================================================
#version 120

#ezquake-definitions

uniform sampler2D texSampler;
uniform vec4 fsBaseColor1;
uniform vec4 fsBaseColor2;

varying vec2 fsTextureCoord;
varying vec2 fsAltTextureCoord;

void main()
{
	vec4 tex = texture2D(texSampler, fsTextureCoord);
	vec4 alt = texture2D(texSampler, fsAltTextureCoord);

	gl_FragColor = tex * fsBaseColor1 + alt * fsBaseColor2;

#ifdef DRAW_FOG
	gl_FragColor = applyFog(gl_FragColor, gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/glc/glc_aliasmodel_shell.vertex.glsl
================================================
#version 120

#ezquake-definitions

attribute float flags;

varying vec2 fsTextureCoord;
varying vec2 fsAltTextureCoord;
uniform float lerpFraction;      // 0 to 1
uniform vec4 scroll;

void main()
{
	float lerpFrac = lerpFraction;

#ifdef EZQ_ALIASMODEL_MUZZLEHACK
	// #define AM_VERTEX_NOLERP 1 - no bittest in glsl 1.2
	lerpFrac = sign(lerpFrac) * max(lerpFrac, mod(flags, 2));
#endif

	gl_Position = gl_ModelViewProjectionMatrix * ((gl_Vertex + lerpFrac * vec4(gl_MultiTexCoord1.xyz, 0)) + vec4(gl_Normal * 0.5, 0));
	fsTextureCoord = vec2(gl_MultiTexCoord0.s * 2 + scroll.x, gl_MultiTexCoord0.t * 2 + scroll.y);
	fsAltTextureCoord = vec2(gl_MultiTexCoord0.s * 2 + scroll.z, gl_MultiTexCoord0.t * 2 + scroll.a);
}


================================================
FILE: src/glsl/glc/glc_aliasmodel_std.fragment.glsl
================================================
#version 120

#ezquake-definitions

#ifdef TEXTURING_ENABLED
uniform sampler2D texSampler;
uniform float fsMinLumaMix;
#endif

#ifdef DRAW_CAUSTIC_TEXTURES
uniform sampler2D causticsSampler;
uniform float time;
uniform float fsCausticEffects;
#endif

#if defined(TEXTURING_ENABLED) || defined(DRAW_CAUSTIC_TEXTURES)
varying vec2 fsTextureCoord;
#endif

#ifdef EZQ_ALIASMODEL_FLATSHADING
varying flat vec4 fsBaseColor;
#else
varying vec4 fsBaseColor;
#endif

void main()
{
#ifdef BACKFACE_PASS
	gl_FragColor = fsBaseColor;
#else
	#ifdef TEXTURING_ENABLED
		vec4 tex = texture2D(texSampler, fsTextureCoord);
		vec3 texMix = mix(tex.rgb, tex.rgb * fsBaseColor.rgb, max(fsMinLumaMix, tex.a));

		gl_FragColor = vec4(texMix, fsBaseColor.a);
	#else
		gl_FragColor = fsBaseColor;
	#endif

	#ifdef DRAW_CAUSTIC_TEXTURES
		vec4 causticCoord = vec4(
			// Using multipler of 3 here - not in other caustics logic but range
			//   isn't enough otherwise, effect too subtle
			(fsTextureCoord.s + sin(0.465 * (time + fsTextureCoord.t))) * 3 * -0.1234375,
			(fsTextureCoord.t + sin(0.465 * (time + fsTextureCoord.s))) * 3 * -0.1234375,
			0,
			1
		);
		vec4 caustic = texture2D(causticsSampler, (gl_TextureMatrix[1] * causticCoord).st);

		// FIXME: Do proper GL_DECAL etc
		gl_FragColor = vec4(caustic.rgb * gl_FragColor.rgb * 1.8, gl_FragColor.a);
	#endif
#endif // BACKFACE_PASS

#ifdef DRAW_FOG
	gl_FragColor = applyFog(gl_FragColor, gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/glc/glc_aliasmodel_std.vertex.glsl
================================================
#version 120

#ezquake-definitions

attribute float flags;

#ifdef BACKFACE_PASS

// for outline
uniform float outlineScale;

#else

#if defined(TEXTURING_ENABLED) || defined(DRAW_CAUSTIC_TEXTURES)
varying vec2 fsTextureCoord;
#endif

#ifndef FULLBRIGHT_MODELS
uniform vec3 angleVector;        // normalized
uniform float shadelight;        // divided by 256 in C
uniform float ambientlight;      // divided by 256 in C
#endif

#endif // BACKFACE_PASS (outlining)

uniform float lerpFraction;      // 0 to 1
#ifdef EZQ_ALIASMODEL_FLATSHADING
varying flat vec4 fsBaseColor;
#else
varying vec4 fsBaseColor;
#endif


#define AM_VERTEX_NOLERP 1

void main()
{
	float lerpFrac = lerpFraction;
#ifdef EZQ_ALIASMODEL_MUZZLEHACK
	lerpFrac = sign(lerpFrac) * max(lerpFrac, mod(flags, 2));
#endif

#ifdef BACKFACE_PASS
	gl_Position = gl_ModelViewProjectionMatrix * (gl_Vertex + lerpFrac * vec4(gl_MultiTexCoord1.xyz, 0) + vec4(outlineScale * gl_Normal, 0));
	// gl_Position += gl_ModelViewProjectionMatrix * 
	fsBaseColor = gl_Color;
#else
		gl_Position = gl_ModelViewProjectionMatrix * (gl_Vertex + lerpFrac * vec4(gl_MultiTexCoord1.xyz, 0));
	#if defined(TEXTURING_ENABLED) || defined(DRAW_CAUSTIC_TEXTURES)
		fsTextureCoord = gl_MultiTexCoord0.st;
	#endif // TEXTURING

	#ifdef FULLBRIGHT_MODELS
		fsBaseColor = gl_Color;
	#else
		// Lighting: this is rough approximation
		//   Credit to mh @ http://forums.insideqc.com/viewtopic.php?f=3&t=2983
		float l = (1 - step(1000, shadelight)) * min((dot(gl_Normal, angleVector) + 1) * shadelight + ambientlight, 1);

		fsBaseColor = vec4(gl_Color.rgb * l, gl_Color.a);
	#endif // FULLBRIGHT_MODELS
#endif // BACKFACE_PASS
}


================================================
FILE: src/glsl/glc/glc_caustics.fragment.glsl
================================================
#version 120

#ezquake-definitions

uniform sampler2D texSampler;
uniform float time;

varying vec2 TextureCoord;

void main()
{
	vec2 tex;

	tex.s = (TextureCoord.s + 8 * sin((TextureCoord.t + time) * 0.465)) * 0.0234375;
	tex.t = (TextureCoord.t + 8 * sin((TextureCoord.s + time) * 0.465)) * 0.0234375;

	gl_FragColor = texture2D(texSampler, tex);
}


================================================
FILE: src/glsl/glc/glc_caustics.vertex.glsl
================================================
#version 120

#ezquake-definitions

varying vec2 TextureCoord;

void main()
{
	gl_Position = ftransform();
	TextureCoord = gl_MultiTexCoord0.st;
}


================================================
FILE: src/glsl/glc/glc_draw_sprites.fragment.glsl
================================================
#version 120

#ezquake-definitions

uniform sampler2D materialSampler;
uniform float alphaThreshold;

varying vec2 TextureCoord;
varying vec4 fsColor;

void main()
{
	gl_FragColor = texture2D(materialSampler, TextureCoord) * fsColor;

#ifdef DRAW_FOG
	gl_FragColor = applyFogBlend(gl_FragColor, gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/glc/glc_draw_sprites.vertex.glsl
================================================
#version 120

#ezquake-definitions

varying vec2 TextureCoord;
varying vec4 fsColor;

void main()
{
	gl_Position = ftransform();
	TextureCoord = gl_MultiTexCoord0.st;
	fsColor = gl_Color;
}


================================================
FILE: src/glsl/glc/glc_hud_images.fragment.glsl
================================================
#version 120

#ezquake-definitions

uniform sampler2D primarySampler;
#ifdef MIXED_SAMPLING
uniform sampler2D secondarySampler;
#endif

varying vec4 TextureCoord;
varying vec4 fsColor;

void main()
{
	gl_FragColor = texture2D(primarySampler, TextureCoord.st);

#ifdef MIXED_SAMPLING
	gl_FragColor *= TextureCoord.a;
	gl_FragColor += texture2D(secondarySampler, TextureCoord.st) * (1 - TextureCoord.a);
#endif

#ifdef PREMULT_ALPHA_HACK
	// Some people prefer the smoothing effect from ezQuake < 3.5,
	//   caused by the alpha being blended incorrectly & effectively applied twice
	gl_FragColor.r *= gl_FragColor.a;
	gl_FragColor.g *= gl_FragColor.a;
	gl_FragColor.b *= gl_FragColor.a;
#endif

	gl_FragColor *= fsColor;
}


================================================
FILE: src/glsl/glc/glc_hud_images.vertex.glsl
================================================
#version 120

#ezquake-definitions

varying vec4 TextureCoord;
varying vec4 fsColor;

void main()
{
	gl_Position = ftransform();
	TextureCoord = gl_MultiTexCoord0;
	fsColor = gl_Color;
}


================================================
FILE: src/glsl/glc/glc_post_process_screen.fragment.glsl
================================================
#version 120

#ezquake-definitions

uniform sampler2D base;
#ifdef EZ_POSTPROCESS_OVERLAY
uniform sampler2D overlay;
#endif

uniform float gamma;
uniform vec4 v_blend;
uniform float contrast;
uniform float r_inv_width;
uniform float r_inv_height;

varying vec2 TextureCoord;

vec4 sampleBase(void)
{
#ifdef EZ_POSTPROCESS_FXAA
	// This is technically not the correct place to apply FXAA as it should sample
	// a tonemapped, and gamma adjusted texture. However, the rendering pipeline
	// prohibits this as this post_process_screen shader performs both tonemapping
	// gamma, as well as combining HUD and world textures, so placing FXAA after
	// this shader would apply FXAA to the HUD as well, which is detrimental.
	// As it happens, applying FXAA to the world before tonemapping and gamma still
	// looks ok, so it's still valuable without shuffling around shaders.
	// Should world tonemap and gamma be broken out to a separate shader at some point
	// that shader would ideally then also populate luma in the alpha channel, to be
	// used by the FXAA algorithm instead of relying on green channel.
	return FxaaPixelShader(
		TextureCoord,                       // FxaaFloat2 pos,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f), // FxaaFloat4 fxaaConsolePosPos,
		base,                               // FxaaTex tex,
		base,                               // FxaaTex fxaaConsole360TexExpBiasNegOne,
		base,                               // FxaaTex fxaaConsole360TexExpBiasNegTwo,
		vec2(r_inv_width, r_inv_height),    // FxaaFloat2 fxaaQualityRcpFrame,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f), // FxaaFloat4 fxaaConsoleRcpFrameOpt,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f), // FxaaFloat4 fxaaConsoleRcpFrameOpt2,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f), // FxaaFloat4 fxaaConsole360RcpFrameOpt2,
		0.75f,                              // FxaaFloat fxaaQualitySubpix (default),
		0.166f,                             // FxaaFloat fxaaQualityEdgeThreshold (default),
		0.0f,                               // FxaaFloat fxaaQualityEdgeThresholdMin (default if green as luma),
		0.0f,                               // FxaaFloat fxaaConsoleEdgeSharpness,
		0.0f,                               // FxaaFloat fxaaConsoleEdgeThreshold,
		0.0f,                               // FxaaFloat fxaaConsoleEdgeThresholdMin,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f)  // FxaaFloat4 fxaaConsole360ConstDir,
	);
#else
	return texture2D(base, TextureCoord);
#endif
}


void main()
{
	vec4 frag_colour = sampleBase();

#ifdef EZ_POSTPROCESS_OVERLAY
	vec4 add = texture2D(overlay, TextureCoord);
	frag_colour *= 1 - add.a;
	frag_colour += add;
#endif

#ifdef EZ_POSTPROCESS_PALETTE
	// apply blend & contrast
	frag_colour = vec4((frag_colour.rgb * v_blend.a + v_blend.rgb) * contrast, 1);

	// apply gamma
	frag_colour = vec4(pow(frag_colour.rgb, vec3(gamma)), 1);
#endif

	gl_FragColor = frag_colour;
}


================================================
FILE: src/glsl/glc/glc_post_process_screen.vertex.glsl
================================================
#ezquake-definitions

varying vec2 TextureCoord;

void main()
{
	gl_Position = gl_Vertex;
	TextureCoord = gl_MultiTexCoord0.xy;
}


================================================
FILE: src/glsl/glc/glc_sky.fragment.glsl
================================================
#version 120

#ezquake-definitions

#ifdef DRAW_SKYBOX
uniform samplerCube skyTex;
#ifdef DRAW_SKYWIND
uniform vec4 skyWind;
#endif
#else
uniform sampler2D skyDomeTex;
uniform sampler2D skyDomeCloudTex;
#endif

#ifdef DRAW_FOG
uniform float skyFogMix;
#endif

uniform float skySpeedscale;
uniform float skySpeedscale2;

varying vec3 Direction;

void main()
{
#if defined(DRAW_SKYBOX)
	gl_FragColor = textureCube(skyTex, Direction);
#if defined(DRAW_SKYWIND)
	float t1 = skyWind.w;
	float t2 = fract(t1) - 0.5;
	float blend = abs(t1 * 2.0);
	vec3 dir = normalize(Direction);
	vec4 layer1 = textureCube(skyTex, dir + t1 * skyWind.xyz);
	vec4 layer2 = textureCube(skyTex, dir + t2 * skyWind.xyz);
	layer1.a *= 1.0 - blend;
	layer2.a *= blend;
	layer1.rgb *= layer1.a;
	layer2.rgb *= layer2.a;
	vec4 combined = layer1 + layer2;
	gl_FragColor = vec4(gl_FragColor.rgb * (1.0 - combined.a) + combined.rgb, 1);
#endif
#else
	const float len = 3.09375;
	// Flatten it out
	vec3 dir = normalize(vec3(Direction.x, Direction.y, 3 * Direction.z));

	vec4 skyColor = texture2D(skyDomeTex, vec2(skySpeedscale + dir.x * len, skySpeedscale + dir.y * len));
	vec4 cloudColor = texture2D(skyDomeCloudTex, vec2(skySpeedscale2 + dir.x * len, skySpeedscale2 + dir.y * len));

	gl_FragColor = mix(skyColor, cloudColor, cloudColor.a);
#endif

#ifdef DRAW_FOG
	gl_FragColor = vec4(mix(gl_FragColor.rgb, fogColor, skyFogMix), gl_FragColor.a);
#endif
}


================================================
FILE: src/glsl/glc/glc_sky.vertex.glsl
================================================
#version 120

#ezquake-definitions

uniform vec3 cameraPosition;

varying vec3 Direction;

void main()
{
	gl_Position = ftransform();
	Direction = (gl_Vertex.xyz - cameraPosition);
#if defined(DRAW_SKYBOX)
	Direction = vec3(-Direction.y, Direction.z, Direction.x);
#endif
}


================================================
FILE: src/glsl/glc/glc_turbsurface.fragment.glsl
================================================
#version 120

#ezquake-definitions

#ifdef FLAT_COLOR
uniform vec4 color;
#else
uniform sampler2D texSampler;
varying vec2 TextureCoord;
uniform float alpha;
uniform float time;
#endif

void main()
{
#ifdef FLAT_COLOR
	gl_FragColor = color;
#else
	vec2 tex;

	tex.s = TextureCoord.s + (sin((TextureCoord.t + time) * 1.5) * 0.125);
	tex.t = TextureCoord.t + (sin((TextureCoord.s + time) * 1.5) * 0.125);

	gl_FragColor = texture2D(texSampler, tex);
	gl_FragColor *= alpha;
#endif

#ifdef DRAW_FOG
	gl_FragColor = applyFog(gl_FragColor, gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/glc/glc_turbsurface.vertex.glsl
================================================
#version 120

#ezquake-definitions

#ifndef FLAT_COLOR
varying vec2 TextureCoord;
#endif

void main()
{
	gl_Position = ftransform();
#ifndef FLAT_COLOR
	TextureCoord = gl_MultiTexCoord0.st;
#endif
}


================================================
FILE: src/glsl/glc/glc_world_drawflat.fragment.glsl
================================================
#version 120

#ezquake-definitions

#ifdef EZ_USE_TEXTURE_ARRAYS
#extension GL_EXT_texture_array : enable
uniform sampler2DArray texSampler;
centroid varying vec3 TextureCoord;
#else
uniform sampler2D texSampler;
centroid varying vec2 TextureCoord;
#endif

varying float lightmapScale;
varying float fogScale;

varying vec4 color;

void main()
{
	// lightmap
#ifdef EZ_USE_TEXTURE_ARRAYS
	vec4 lightmap = vec4(1, 1, 1, 1 + lightmapScale) - lightmapScale * texture2DArray(texSampler, TextureCoord);
#else
	vec4 lightmap = vec4(1, 1, 1, 1 + lightmapScale) - lightmapScale * texture2D(texSampler, TextureCoord);
#endif

	gl_FragColor = color * lightmap;

#ifdef DRAW_FOG
	gl_FragColor = applyFog(gl_FragColor, fogScale * gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/glc/glc_world_drawflat.vertex.glsl
================================================
#version 120

#ezquake-definitions

attribute float style;
varying vec4 color;
#ifdef EZ_USE_TEXTURE_ARRAYS
centroid varying vec3 TextureCoord;
#else
centroid varying vec2 TextureCoord;
#endif
varying float lightmapScale;
varying float fogScale;

uniform vec4 wallcolor;
uniform vec4 floorcolor;
uniform vec4 skycolor;
uniform vec4 watercolor;
uniform vec4 slimecolor;
uniform vec4 lavacolor;
uniform vec4 telecolor;

void main()
{
	gl_Position = ftransform();
#ifdef EZ_USE_TEXTURE_ARRAYS
	TextureCoord = gl_MultiTexCoord0.xyz;
#else
	TextureCoord = gl_MultiTexCoord0.st;
#endif

	lightmapScale = step(64, mod(style, 256));

	color = vec4(0, 0, 0, 1);
	color += mod(style, 2) * skycolor;
	color += mod(floor(style / 2), 2) * watercolor;
	color += mod(floor(style / 4), 2) * slimecolor;
	color += mod(floor(style / 8), 2) * lavacolor;
	color += mod(floor(style / 16), 2) * telecolor;
	color += mod(floor(style / 32), 2) * skycolor;
	color += mod(floor(style / 64), 2) * floorcolor;
	color += mod(floor(style / 128), 2) * wallcolor;
	color.a = 1;

	// don't apply z-fog to the sky
	fogScale = 1 - mod(style, 2);
}


================================================
FILE: src/glsl/glc/glc_world_secondpass.fragment.glsl
================================================
#version 120

#ezquake-definitions

uniform sampler2D texSampler;
varying vec2 TextureCoord;

void main()
{
	gl_FragColor = texture2D(texSampler, TextureCoord);
}


================================================
FILE: src/glsl/glc/glc_world_secondpass.vertex.glsl
================================================
#version 120

#ezquake-definitions

varying vec2 TextureCoord;

void main()
{
	gl_Position = ftransform();
	TextureCoord = gl_MultiTexCoord0.st;
}


================================================
FILE: src/glsl/glc/glc_world_textured.fragment.glsl
================================================
#version 120

#ezquake-definitions

#ifdef EZ_USE_TEXTURE_ARRAYS
#extension GL_EXT_texture_array : enable
#endif

varying float mix_floor;
varying float mix_wall;

uniform vec3 r_wallcolor;
uniform vec3 r_floorcolor;

// Drawflat mode TINTED... Amend texture color based on floor/wall
// FIXME: common with glsl, do some kind of #include support
#ifdef DRAW_DRAWFLAT_TINTED
vec4 applyColorTinting(vec4 frag_colour)
{
#if defined(DRAW_FLATFLOORS) && defined(DRAW_FLATWALLS)
	vec3 inter = mix(frag_colour.rgb, frag_colour.rgb * r_floorcolor.rgb, mix_floor);
	frag_colour = vec4(mix(inter, inter * r_wallcolor.rgb, mix_wall), frag_colour.a);
#elif defined(DRAW_FLATWALLS)
	frag_colour = vec4(mix(frag_colour.rgb, frag_colour.rgb * r_wallcolor.rgb, mix_wall), frag_colour.a);
#elif defined(DRAW_FLATFLOORS)
	frag_colour = vec4(mix(frag_colour.rgb, frag_colour.rgb * r_floorcolor.rgb, mix_floor), frag_colour.a);
#endif
	return frag_colour;
}
#elif defined(DRAW_DRAWFLAT_BRIGHT)
vec4 applyColorTinting(vec4 frag_colour)
{
	// evaluate brightness as per lightmap scaling ("// kudos to Darel Rex Finley for his HSP color model")
	float brightness = sqrt(frag_colour.r * frag_colour.r * 0.241 + frag_colour.g * frag_colour.g * 0.691 + frag_colour.b * frag_colour.b * 0.068);

#if defined(DRAW_FLATWALLS)
	frag_colour = vec4(mix(frag_colour.rgb, r_wallcolor.rgb * brightness, mix_wall), frag_colour.a);
#endif
#if defined(DRAW_FLATFLOORS)
	frag_colour = vec4(mix(frag_colour.rgb, r_floorcolor.rgb * brightness, mix_floor), frag_colour.a);
#endif

	return frag_colour;
}
#elif defined(DRAW_DRAWFLAT_NORMAL)
vec4 applyColorTinting(vec4 frag_colour)
{
#if defined(DRAW_FLATFLOORS) && defined(DRAW_FLATWALLS)
	frag_colour = vec4(mix(mix(frag_colour.rgb, r_wallcolor.rgb, mix_wall), r_floorcolor.rgb, mix_floor), frag_colour.a);
#elif defined(DRAW_FLATWALLS)
	frag_colour = vec4(mix(frag_colour.rgb, r_wallcolor.rgb, mix_wall), frag_colour.a);
#elif defined(DRAW_FLATFLOORS)
	frag_colour = vec4(mix(frag_colour.rgb, r_floorcolor.rgb, mix_floor), frag_colour.a);
#endif
	return frag_colour;
}
#else
#define applyColorTinting(x) (x)
#endif

uniform sampler2D texSampler;
varying vec2 TextureCoord;

#ifdef DRAW_LIGHTMAPS
#ifdef EZ_USE_TEXTURE_ARRAYS
uniform sampler2DArray lightmapSampler;
centroid varying vec3 LightmapCoord;
#else
uniform sampler2D lightmapSampler;
centroid varying vec2 LightmapCoord;
#endif
#endif

#ifdef DRAW_EXTRA_TEXTURES
uniform sampler2D lumaSampler;
varying float lumaScale;
varying float fbScale;
#endif

#ifdef DRAW_CAUSTICS
uniform sampler2D causticsSampler;
varying float causticsScale;
uniform float time;
#endif

#ifdef DRAW_DETAIL
uniform sampler2D detailSampler;
varying vec2 DetailCoord;
#endif

#if defined(DRAW_ALPHATEST_ENABLED)
// 0 for textureless, 1 for normal
uniform float texture_multiplier;
#endif

void main()
{
	gl_FragColor = texture2D(texSampler, TextureCoord);
#ifdef DRAW_ALPHATEST_ENABLED
	gl_FragColor = vec4(texture2D(texSampler, TextureCoord * texture_multiplier).rgb, gl_FragColor.a);

	if (gl_FragColor.a < 0.333) {
		discard;
	}

	gl_FragColor = vec4(gl_FragColor.rgb, 1.0);
#endif

#ifdef DRAW_EXTRA_TEXTURES
	vec4 lumaColor = texture2D(lumaSampler, TextureCoord);
#endif

#ifdef DRAW_LUMA_TEXTURES
#ifndef DRAW_FULLBRIGHT_TEXTURES
	// Luma textures enabled but fullbright bmodels disabled - so we mix in the luma texture pre-lightmap (qqshka 2008)
	gl_FragColor = vec4(mix(gl_FragColor.rgb, gl_FragColor.rgb + lumaColor.rgb, lumaScale * lumaColor.a), gl_FragColor.a);
#endif
#endif

	// Apply color tinting
	gl_FragColor = applyColorTinting(gl_FragColor);

#ifdef DRAW_LIGHTMAPS
#ifdef EZ_USE_TEXTURE_ARRAYS
	// Apply lightmap from texture array
	gl_FragColor *= (vec4(1, 1, 1, 2) - texture2DArray(lightmapSampler, LightmapCoord));
#else
	// Apply lightmap from simple atlas
	gl_FragColor *= (vec4(1, 1, 1, 2) - texture2D(lightmapSampler, LightmapCoord));
#endif
#endif

#ifdef DRAW_LUMA_TEXTURES
#ifdef DRAW_FULLBRIGHT_TEXTURES
	// Apply color tinting before merging
	lumaColor = applyColorTinting(lumaColor);
	// Lumas enabled, fullbrights enabled - mix in the luma post-lightmap
	gl_FragColor = vec4(mix(gl_FragColor.rgb, gl_FragColor.rgb + lumaColor.rgb, lumaScale * lumaColor.a), gl_FragColor.a);
	// Fullbrights - simple mix no add
	gl_FragColor = vec4(mix(gl_FragColor.rgb, lumaColor.rgb, fbScale * lumaColor.a), gl_FragColor.a);
#endif
#else
#ifdef DRAW_FULLBRIGHT_TEXTURES
	// Apply color tinting before merging
	lumaColor = applyColorTinting(lumaColor);
	// Fullbrights, lumas disabled (GL_DECAL)
	gl_FragColor = vec4(mix(gl_FragColor.rgb, lumaColor.rgb, fbScale * lumaColor.a), gl_FragColor.a);
#endif
#endif

#ifdef DRAW_CAUSTICS
	vec2 causticsCoord = vec2(
		(TextureCoord.s + sin(0.465 * (time + TextureCoord.t))) * -0.1234375,
		(TextureCoord.t + sin(0.465 * (time + TextureCoord.s))) * -0.1234375
	);
	vec4 caustic = texture2D(causticsSampler, causticsCoord);

	gl_FragColor = vec4(mix(gl_FragColor.rgb, caustic.rgb * gl_FragColor.rgb * 2.0, causticsScale), gl_FragColor.a);
#endif

#ifdef DRAW_DETAIL
	vec4 detail = texture2D(detailSampler, DetailCoord);

	gl_FragColor = vec4(detail.rgb * gl_FragColor.rgb * 2.0, gl_FragColor.a);
#endif

#ifdef DRAW_FOG
	gl_FragColor = applyFog(gl_FragColor, gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/glc/glc_world_textured.vertex.glsl
================================================
#version 120

#ezquake-definitions

varying vec2 TextureCoord;
attribute float style;

#ifdef DRAW_LIGHTMAPS
#ifdef EZ_USE_TEXTURE_ARRAYS
centroid varying vec3 LightmapCoord;
#else
centroid varying vec2 LightmapCoord;
#endif
#endif
#ifdef DRAW_EXTRA_TEXTURES
uniform float lumaMultiplier;
uniform float fbMultiplier;
varying float lumaScale;
varying float fbScale;
#endif
#ifdef DRAW_DETAIL
attribute vec2 detailCoordInput;
varying vec2 DetailCoord;
#endif
#ifdef DRAW_CAUSTICS
attribute vec2 causticsCoord;
varying float causticsScale;
#endif

// 0 for textureless, 1 for normal
uniform float texture_multiplier;

varying float mix_floor;
varying float mix_wall;

void main()
{
	gl_Position = ftransform();
#ifdef DRAW_ALPHATEST_ENABLED
	TextureCoord = gl_MultiTexCoord0.st;
#else
	TextureCoord = gl_MultiTexCoord0.st * texture_multiplier;
#endif

#ifdef DRAW_LIGHTMAPS
#ifdef EZ_USE_TEXTURE_ARRAYS
	LightmapCoord = gl_MultiTexCoord1.xyz;
#else
	LightmapCoord = gl_MultiTexCoord1.st;
#endif
#endif

#ifdef DRAW_EXTRA_TEXTURES
	lumaScale = lumaMultiplier * mod(floor(style / 256), 2);
	fbScale = fbMultiplier * mod(floor(style / 1024), 2);
#endif
#ifdef DRAW_CAUSTICS
	causticsScale = mod(floor(style / 512), 2);
#endif
#ifdef DRAW_DETAIL
	DetailCoord = detailCoordInput;
#endif

	mix_floor = mod(floor(style / 64), 2);
	mix_wall = mod(floor(style / 128), 2);
}


================================================
FILE: src/glsl/hud_draw_circle.fragment.glsl
================================================
#ezquake-definitions

uniform vec4 color;

out vec4 frag_colour;

void main(void)
{
	frag_colour = color;
}


================================================
FILE: src/glsl/hud_draw_circle.vertex.glsl
================================================
#ezquake-definitions

layout(location = 0) in vec2 position;

uniform mat4 matrix;

void main(void)
{
	gl_Position = matrix * vec4(position, 0, 1);
}


================================================
FILE: src/glsl/hud_draw_image.fragment.glsl
================================================
#ezquake-definitions

#ifdef MIXED_SAMPLING
EZ_LAYOUT_BINDING(0) uniform sampler2D tex[2];
#else
EZ_LAYOUT_BINDING(0) uniform sampler2D tex;
#endif

in vec2 TextureCoord;
in vec4 Colour;
in float AlphaTest;
#ifdef MIXED_SAMPLING
flat in int IsNearest;
#endif

out vec4 frag_colour;

void main()
{
	vec4 texColor;

#ifdef MIXED_SAMPLING
	texColor = texture(tex[IsNearest], TextureCoord);
#else
	texColor = texture(tex, TextureCoord);
#endif

	if (AlphaTest != 0 && texColor.a < 0.666) {
		discard;
	}

#ifdef PREMULT_ALPHA_HACK
	// Some people prefer the smoothing effect from ezQuake < 3.5,
	//   caused by the alpha being blended incorrectly & effectively applied twice
	texColor.r *= texColor.a;
	texColor.g *= texColor.a;
	texColor.b *= texColor.a;
#endif

	frag_colour = texColor * Colour;
}


================================================
FILE: src/glsl/hud_draw_image.geometry.glsl
================================================
#ezquake-definitions

// Converts a single point to a quad with correct texture co-ords for character

layout(points) in;
layout(triangle_strip, max_vertices = 4) out;

in vec4 gPositionTL[1];
in vec4 gPositionBR[1];
in vec2 gTexCoordTL[1];
in vec2 gTexCoordBR[1];
in vec4 gColour[1];
in float gAlphaTest[1];

out vec2 TextureCoord;
out vec4 Colour;
out float AlphaTest;

void main()
{
	Colour = gColour[0];
	AlphaTest = gAlphaTest[0];

	gl_Position = gPositionTL[0];
	TextureCoord = gTexCoordTL[0];
	EmitVertex();

	gl_Position = vec4(gPositionTL[0].x, gPositionBR[0].y, 0, 1);
	TextureCoord = vec2(gTexCoordTL[0].s, gTexCoordBR[0].t);
	EmitVertex();

	gl_Position = vec4(gPositionBR[0].x, gPositionTL[0].y, 0, 1);
	TextureCoord = vec2(gTexCoordBR[0].s, gTexCoordTL[0].t);
	EmitVertex();

	gl_Position = gPositionBR[0];
	TextureCoord = gTexCoordBR[0];
	EmitVertex();

	EndPrimitive();
}


================================================
FILE: src/glsl/hud_draw_image.vertex.glsl
================================================
#ezquake-definitions

layout(location = 0) in vec2 inPosition;
layout(location = 1) in vec2 inTexCoord;
layout(location = 2) in vec4 inColour;
layout(location = 3) in int inFlags;

out vec2 TextureCoord;
out vec4 Colour;
out float AlphaTest;
#ifdef MIXED_SAMPLING
flat out int IsNearest;
#endif

void main()
{
	gl_Position = vec4(inPosition, 0, 1);
	TextureCoord = inTexCoord;
	Colour = inColour;
#ifdef MIXED_SAMPLING
	IsNearest = (inFlags & IMAGEPROG_FLAGS_NEAREST) != 0 ? 1 : 0;
#endif
	AlphaTest = (inFlags & IMAGEPROG_FLAGS_TEXT) * r_alphatestfont + (inFlags & IMAGEPROG_FLAGS_ALPHATEST);
}


================================================
FILE: src/glsl/hud_draw_line.fragment.glsl
================================================
#ezquake-definitions

in vec4 inColor;
out vec4 color;

void main(void)
{
	color = inColor;
}


================================================
FILE: src/glsl/hud_draw_line.vertex.glsl
================================================
#ezquake-definitions

layout(location=0) in vec3 position;
layout(location=1) in vec4 color;

out vec4 inColor;

void main(void)
{
	gl_Position = vec4(position, 1);
	inColor = color;
}


================================================
FILE: src/glsl/hud_draw_polygon.fragment.glsl
================================================
#ezquake-definitions

uniform vec4 color;

out vec4 frag_colour;

void main(void)
{
	frag_colour = color;
}


================================================
FILE: src/glsl/hud_draw_polygon.vertex.glsl
================================================
#ezquake-definitions

layout(location = 0) in vec3 position;

void main(void)
{
	gl_Position = vec4(position, 1);
}


================================================
FILE: src/glsl/lighting.compute.glsl
================================================
#ezquake-definitions

layout(local_size_x = HW_LIGHTING_BLOCK_SIZE, local_size_y = HW_LIGHTING_BLOCK_SIZE) in;
EZ_LAYOUT_BINDING(0) layout(rgba32ui) uniform uimage2DArray sourceBlocklights;
EZ_LAYOUT_BINDING(1) layout(rgba8)    uniform image2DArray  destinationLightmap;
EZ_LAYOUT_BINDING(2) layout(rgba32i)  uniform iimage2DArray sourceLightmapData;

EZ_SSBO_LAYOUT(std140, EZQ_GL_BINDINGPOINT_WORLDMODEL_SURFACES) EZ_SSBO(surface_data) {
	model_surface surfaces[EZ_SSBO_ARRAY_SIZE(8192)];
};
EZ_SSBO_LAYOUT(std430, EZQ_GL_BINDINGPOINT_LIGHTSTYLES) EZ_SSBO(lightstyle_data) {
	uint dlightstyles[MAX_LIGHTSTYLES];
};
EZ_SSBO_LAYOUT(std430, EZQ_GL_BINDINGPOINT_SURFACES_TO_LIGHT) EZ_SSBO(todolist_data) {
	uint surfaces_to_light[EZ_SSBO_ARRAY_SIZE(8192)];
};

uniform int firstLightmap;

void main()
{
	int i;

	ivec3 coord = ivec3(gl_WorkGroupID.xy * HW_LIGHTING_BLOCK_SIZE + gl_LocalInvocationID.xy, gl_WorkGroupID.z + firstLightmap);
	uvec4 blocklight = imageLoad(sourceBlocklights, coord);
	ivec4 srcData = imageLoad(sourceLightmapData, coord);

	int surfaceNumber = srcData.x;
	if (surfaceNumber >= 0) {

		if ((surfaces_to_light[surfaceNumber / 32] & (1 << (surfaceNumber % 32))) != 0) {
			float sdelta = float(srcData.y);
			float tdelta = float(srcData.z);
			uvec4 mapIndexes = uvec4(
				(blocklight.a >> 24) & 0xFF,
				(blocklight.a >> 16) & 0xFF,
				(blocklight.a >> 8) & 0xFF,
				(blocklight.a >> 0) & 0xFF
			);
			blocklight.a = 0;

			vec4 Plane = surfaces[surfaceNumber].normal;
			vec4 PlaneMins0 = surfaces[surfaceNumber].vecs0;
			vec4 PlaneMins1 = surfaces[surfaceNumber].vecs1;

			float vlen0 = PlaneMins0.w;
			float vlen1 = PlaneMins1.w;

			// Build static lights: default to black
			vec4 baseLightmap = vec4(0, 0, 0, 0);
			if (mapIndexes.a < 64) {
				baseLightmap = (blocklight & 0xFF) * dlightstyles[mapIndexes.a];
				if (mapIndexes.b < 64) {
					blocklight >>= 8;
					baseLightmap += (blocklight & 0xFF) * dlightstyles[mapIndexes.b];
					if (mapIndexes.g < 64) {
						blocklight >>= 8;
						baseLightmap += (blocklight & 0xFF) * dlightstyles[mapIndexes.g];
						if (mapIndexes.r < 64) {
							blocklight >>= 8;
							baseLightmap += (blocklight & 0xFF) * dlightstyles[mapIndexes.r];
						}
					}
				}
			}
			baseLightmap *= 1.0 / (256.0 * 256.0);

			// Dynamic lights
			for (i = 0; i < lightsActive; ++i) {
				float dist = dot(lightPositions[i].xyz, Plane.xyz) - Plane.a;
				float rad = lightPositions[i].a - abs(dist);
				float minlight = lightColors[i].a;

				if (rad >= minlight) {
					minlight = rad - minlight;

					vec3 impact = lightPositions[i].xyz - Plane.xyz * dist;
					vec2 local = vec2(dot(impact, PlaneMins0.xyz), dot(impact, PlaneMins1.xyz));

					int sd = int(abs(local[0] - sdelta) * vlen0); // sdelta = s * (1 << surf->lmshift) + surf->texturemins[0] - surf->lmvecs[0][3];
					int td = int(abs(local[1] - tdelta) * vlen1); // tdelta = t * (1 << surf->lmshift) + surf->texturemins[1] - surf->lmvecs[1][3];

					if (sd > td) {
						dist = sd + (td >> 1);
					}
					else {
						dist = td + (sd >> 1);
					}
					if (dist < minlight) {
						// Increase blocklights...
						float increase = (rad - dist) / 128.0f;

						baseLightmap.r += increase * lightColors[i].r;
						baseLightmap.g += increase * lightColors[i].g;
						baseLightmap.b += increase * lightColors[i].b;
					}
				}
			}

			// Scale back... if we do simple scaling colour ratios will be lost
			//   (red 1.5 green 1.0 would become ... whatever red+green is)
			baseLightmap *= lightScale;
			baseLightmap /= max(1, max(baseLightmap.r, max(baseLightmap.g, baseLightmap.b)));
			baseLightmap.a = 1;

			imageStore(destinationLightmap, coord, baseLightmap);
		}
	}
}


================================================
FILE: src/glsl/post_process_screen.fragment.glsl
================================================
#ezquake-definitions

in vec2 TextureCoord;
out vec4 frag_colour;

EZ_LAYOUT_BINDING(0) uniform sampler2D base;
#ifdef EZ_POSTPROCESS_OVERLAY
EZ_LAYOUT_BINDING(1) uniform sampler2D overlay;
#endif // EZ_POSTPROCESS_OVERLAY

vec4 sampleBase(void)
{
#ifdef EZ_POSTPROCESS_FXAA
	// This is technically not the correct place to apply FXAA as it should sample
	// a tonemapped, and gamma adjusted texture. However, the rendering pipeline
	// prohibits this as this post_process_screen shader performs both tonemapping
	// gamma, as well as combining HUD and world textures, so placing FXAA after
	// this shader would apply FXAA to the HUD as well, which is detrimental.
	// As it happens, applying FXAA to the world before tonemapping and gamma still
	// looks ok, so it's still valuable without shuffling around shaders.
	// Should world tonemap and gamma be broken out to a separate shader at some point
	// that shader would ideally then also populate luma in the alpha channel, to be
	// used by the FXAA algorithm instead of relying on green channel.
	return FxaaPixelShader(
		TextureCoord,                       // FxaaFloat2 pos,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f), // FxaaFloat4 fxaaConsolePosPos,
		base,                               // FxaaTex tex,
		base,                               // FxaaTex fxaaConsole360TexExpBiasNegOne,
		base,                               // FxaaTex fxaaConsole360TexExpBiasNegTwo,
		vec2(r_inv_width, r_inv_height),    // FxaaFloat2 fxaaQualityRcpFrame,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f), // FxaaFloat4 fxaaConsoleRcpFrameOpt,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f), // FxaaFloat4 fxaaConsoleRcpFrameOpt2,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f), // FxaaFloat4 fxaaConsole360RcpFrameOpt2,
		0.75f,                              // FxaaFloat fxaaQualitySubpix (default),
		0.166f,                             // FxaaFloat fxaaQualityEdgeThreshold (default),
		0.0f,                               // FxaaFloat fxaaQualityEdgeThresholdMin (default if green as luma),
		0.0f,                               // FxaaFloat fxaaConsoleEdgeSharpness,
		0.0f,                               // FxaaFloat fxaaConsoleEdgeThreshold,
		0.0f,                               // FxaaFloat fxaaConsoleEdgeThresholdMin,
		FxaaFloat4(0.0f, 0.0f, 0.0f, 0.0f)  // FxaaFloat4 fxaaConsole360ConstDir,
	);
#else
	return texture(base, TextureCoord);
#endif
}

#ifdef EZ_POSTPROCESS_OVERLAY
vec4 sampleOverlay(void)
{
	return texture(overlay, TextureCoord);
}
#endif // EZ_POSTPROCESS_OVERLAY

void main()
{
	vec4 result = sampleBase();
#ifdef EZ_POSTPROCESS_TONEMAP
	result.r = result.r / (result.r + 1);
	result.g = result.g / (result.g + 1);
	result.b = result.b / (result.b + 1);
#endif
#ifdef EZ_POSTPROCESS_OVERLAY
	vec4 add = sampleOverlay();
	result *= 1 - add.a;
	result += add;
#endif

#ifdef EZ_POSTPROCESS_PALETTE
	// apply blend & contrast
	result = vec4((result.rgb * v_blend.a + v_blend.rgb) * contrast, 1);

	// apply gamma
	result = vec4(pow(result.rgb, vec3(gamma)), 1);
#endif

	frag_colour = result;
}


================================================
FILE: src/glsl/post_process_screen.vertex.glsl
================================================
#ezquake-definitions

layout(location = 0) in vec2 inPosition;
layout(location = 1) in vec2 inTextureCoord;

out vec2 TextureCoord;

void main()
{
	gl_Position = vec4(inPosition, 0, 1);
	TextureCoord = inTextureCoord;
}


================================================
FILE: src/glsl/shared/fxaa.h.glsl
================================================
//----------------------------------------------------------------------------------
// File:        es3-kepler\FXAA/FXAA3_11.h
// SDK Version: v3.00 
// Email:       gameworks@nvidia.com
// Site:        http://developer.nvidia.com/
//
// Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//----------------------------------------------------------------------------------
/*============================================================================


                    NVIDIA FXAA 3.11 by TIMOTHY LOTTES

------------------------------------------------------------------------------
                           INTEGRATION CHECKLIST
------------------------------------------------------------------------------
(1.)
In the shader source, setup defines for the desired configuration.
When providing multiple shaders (for different presets),
simply setup the defines differently in multiple files.
Example,

  #define FXAA_PC 1
  #define FXAA_HLSL_5 1
  #define FXAA_QUALITY__PRESET 12

Or,

  #define FXAA_360 1
  
Or,

  #define FXAA_PS3 1
  
Etc.

(2.)
Then include this file,

  #include "Fxaa3_11.h"

(3.)
Then call the FXAA pixel shader from within your desired shader.
Look at the FXAA Quality FxaaPixelShader() for docs on inputs.
As for FXAA 3.11 all inputs for all shaders are the same 
to enable easy porting between platforms.

  return FxaaPixelShader(...);

(4.)
Insure pass prior to FXAA outputs RGBL (see next section).
Or use,

  #define FXAA_GREEN_AS_LUMA 1

(5.)
Setup engine to provide the following constants
which are used in the FxaaPixelShader() inputs,

  FxaaFloat2 fxaaQualityRcpFrame,
  FxaaFloat4 fxaaConsoleRcpFrameOpt,
  FxaaFloat4 fxaaConsoleRcpFrameOpt2,
  FxaaFloat4 fxaaConsole360RcpFrameOpt2,
  FxaaFloat fxaaQualitySubpix,
  FxaaFloat fxaaQualityEdgeThreshold,
  FxaaFloat fxaaQualityEdgeThresholdMin,
  FxaaFloat fxaaConsoleEdgeSharpness,
  FxaaFloat fxaaConsoleEdgeThreshold,
  FxaaFloat fxaaConsoleEdgeThresholdMin,
  FxaaFloat4 fxaaConsole360ConstDir

Look at the FXAA Quality FxaaPixelShader() for docs on inputs.

(6.)
Have FXAA vertex shader run as a full screen triangle,
and output "pos" and "fxaaConsolePosPos" 
such that inputs in the pixel shader provide,

  // {xy} = center of pixel
  FxaaFloat2 pos,

  // {xy__} = upper left of pixel
  // {__zw} = lower right of pixel
  FxaaFloat4 fxaaConsolePosPos,

(7.)
Insure the texture sampler(s) used by FXAA are set to bilinear filtering.


------------------------------------------------------------------------------
                    INTEGRATION - RGBL AND COLORSPACE
------------------------------------------------------------------------------
FXAA3 requires RGBL as input unless the following is set, 

  #define FXAA_GREEN_AS_LUMA 1

In which case the engine uses green in place of luma,
and requires RGB input is in a non-linear colorspace.

RGB should be LDR (low dynamic range).
Specifically do FXAA after tonemapping.

RGB data as returned by a texture fetch can be non-linear,
or linear when FXAA_GREEN_AS_LUMA is not set.
Note an "sRGB format" texture counts as linear,
because the result of a texture fetch is linear data.
Regular "RGBA8" textures in the sRGB colorspace are non-linear.

If FXAA_GREEN_AS_LUMA is not set,
luma must be stored in the alpha channel prior to running FXAA.
This luma should be in a perceptual space (could be gamma 2.0).
Example pass before FXAA where output is gamma 2.0 encoded,

  color.rgb = ToneMap(color.rgb); // linear color output
  color.rgb = sqrt(color.rgb);    // gamma 2.0 color output
  return color;

To use FXAA,

  color.rgb = ToneMap(color.rgb);  // linear color output
  color.rgb = sqrt(color.rgb);     // gamma 2.0 color output
  color.a = dot(color.rgb, FxaaFloat3(0.299, 0.587, 0.114)); // compute luma
  return color;

Another example where output is linear encoded,
say for instance writing to an sRGB formated render target,
where the render target does the conversion back to sRGB after blending,

  color.rgb = ToneMap(color.rgb); // linear color output
  return color;

To use FXAA,

  color.rgb = ToneMap(color.rgb); // linear color output
  color.a = sqrt(dot(color.rgb, FxaaFloat3(0.299, 0.587, 0.114))); // compute luma
  return color;

Getting luma correct is required for the algorithm to work correctly.


------------------------------------------------------------------------------
                          BEING LINEARLY CORRECT?
------------------------------------------------------------------------------
Applying FXAA to a framebuffer with linear RGB color will look worse.
This is very counter intuitive, but happends to be true in this case.
The reason is because dithering artifacts will be more visiable 
in a linear colorspace.


------------------------------------------------------------------------------
                             COMPLEX INTEGRATION
------------------------------------------------------------------------------
Q. What if the engine is blending into RGB before wanting to run FXAA?

A. In the last opaque pass prior to FXAA,
   have the pass write out luma into alpha.
   Then blend into RGB only.
   FXAA should be able to run ok
   assuming the blending pass did not any add aliasing.
   This should be the common case for particles and common blending passes.

A. Or use FXAA_GREEN_AS_LUMA.

============================================================================*/

/*============================================================================

                             INTEGRATION KNOBS

============================================================================*/
//
// FXAA_PS3 and FXAA_360 choose the console algorithm (FXAA3 CONSOLE).
// FXAA_360_OPT is a prototype for the new optimized 360 version.
//
// 1 = Use API.
// 0 = Don't use API.
//
/*--------------------------------------------------------------------------*/
#ifndef FXAA_PS3
    #define FXAA_PS3 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_360
    #define FXAA_360 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_360_OPT
    #define FXAA_360_OPT 0
#endif
/*==========================================================================*/
#ifndef FXAA_PC
    //
    // FXAA Quality
    // The high quality PC algorithm.
    //
    #define FXAA_PC 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_PC_CONSOLE
    //
    // The console algorithm for PC is included
    // for developers targeting really low spec machines.
    // Likely better to just run FXAA_PC, and use a really low preset.
    //
    #define FXAA_PC_CONSOLE 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_GLSL_120
    #define FXAA_GLSL_120 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_GLSL_130
    #define FXAA_GLSL_130 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_HLSL_3
    #define FXAA_HLSL_3 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_HLSL_4
    #define FXAA_HLSL_4 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_HLSL_5
    #define FXAA_HLSL_5 0
#endif
/*==========================================================================*/
#ifndef FXAA_GREEN_AS_LUMA
    //
    // For those using non-linear color,
    // and either not able to get luma in alpha, or not wanting to,
    // this enables FXAA to run using green as a proxy for luma.
    // So with this enabled, no need to pack luma in alpha.
    //
    // This will turn off AA on anything which lacks some amount of green.
    // Pure red and blue or combination of only R and B, will get no AA.
    //
    // Might want to lower the settings for both,
    //    fxaaConsoleEdgeThresholdMin
    //    fxaaQualityEdgeThresholdMin
    // In order to insure AA does not get turned off on colors 
    // which contain a minor amount of green.
    //
    // 1 = On.
    // 0 = Off.
    //
    #define FXAA_GREEN_AS_LUMA 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_EARLY_EXIT
    //
    // Controls algorithm's early exit path.
    // On PS3 turning this ON adds 2 cycles to the shader.
    // On 360 turning this OFF adds 10ths of a millisecond to the shader.
    // Turning this off on console will result in a more blurry image.
    // So this defaults to on.
    //
    // 1 = On.
    // 0 = Off.
    //
    #define FXAA_EARLY_EXIT 1
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_DISCARD
    //
    // Only valid for PC OpenGL currently.
    // Probably will not work when FXAA_GREEN_AS_LUMA = 1.
    //
    // 1 = Use discard on pixels which don't need AA.
    //     For APIs which enable concurrent TEX+ROP from same surface.
    // 0 = Return unchanged color on pixels which don't need AA.
    //
    #define FXAA_DISCARD 0
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_FAST_PIXEL_OFFSET
    //
    // Used for GLSL 120 only.
    //
    // 1 = GL API supports fast pixel offsets
    // 0 = do not use fast pixel offsets
    //
    #ifdef GL_EXT_gpu_shader4
        #define FXAA_FAST_PIXEL_OFFSET 1
    #endif
    #ifdef GL_NV_gpu_shader5
        #define FXAA_FAST_PIXEL_OFFSET 1
    #endif
    #ifdef GL_ARB_gpu_shader5
        #define FXAA_FAST_PIXEL_OFFSET 1
    #endif
    #ifndef FXAA_FAST_PIXEL_OFFSET
        #define FXAA_FAST_PIXEL_OFFSET 0
    #endif
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_GATHER4_ALPHA
    //
    // 1 = API supports gather4 on alpha channel.
    // 0 = API does not support gather4 on alpha channel.
    //
    #if (FXAA_HLSL_5 == 1)
        #define FXAA_GATHER4_ALPHA 1
    #endif
    #ifdef GL_ARB_gpu_shader5
        #define FXAA_GATHER4_ALPHA 1
    #endif
    #ifdef GL_NV_gpu_shader5
        #define FXAA_GATHER4_ALPHA 1
    #endif
    #ifndef FXAA_GATHER4_ALPHA
        #define FXAA_GATHER4_ALPHA 0
    #endif
#endif

/*============================================================================
                      FXAA CONSOLE PS3 - TUNING KNOBS
============================================================================*/
#ifndef FXAA_CONSOLE__PS3_EDGE_SHARPNESS
    //
    // Consoles the sharpness of edges on PS3 only.
    // Non-PS3 tuning is done with shader input.
    //
    // Due to the PS3 being ALU bound,
    // there are only two safe values here: 4 and 8.
    // These options use the shaders ability to a free *|/ by 2|4|8.
    //
    // 8.0 is sharper
    // 4.0 is softer
    // 2.0 is really soft (good for vector graphics inputs)
    //
    #if 1
        #define FXAA_CONSOLE__PS3_EDGE_SHARPNESS 8.0
    #endif
    #if 0
        #define FXAA_CONSOLE__PS3_EDGE_SHARPNESS 4.0
    #endif
    #if 0
        #define FXAA_CONSOLE__PS3_EDGE_SHARPNESS 2.0
    #endif
#endif
/*--------------------------------------------------------------------------*/
#ifndef FXAA_CONSOLE__PS3_EDGE_THRESHOLD
    //
    // Only effects PS3.
    // Non-PS3 tuning is done with shader input.
    //
    // The minimum amount of local contrast required to apply algorithm.
    // The console setting has a different mapping than the quality setting.
    //
    // This only applies when FXAA_EARLY_EXIT is 1.
    //
    // Due to the PS3 being ALU bound,
    // there are only two safe values here: 0.25 and 0.125.
    // These options use the shaders ability to a free *|/ by 2|4|8.
    //
    // 0.125 leaves less aliasing, but is softer
    // 0.25 leaves more aliasing, and is sharper
    //
    #if 1
        #define FXAA_CONSOLE__PS3_EDGE_THRESHOLD 0.125
    #else
        #define FXAA_CONSOLE__PS3_EDGE_THRESHOLD 0.25
    #endif
#endif

/*============================================================================
                        FXAA QUALITY - TUNING KNOBS
------------------------------------------------------------------------------
NOTE the other tuning knobs are now in the shader function inputs!
============================================================================*/
#ifndef FXAA_QUALITY__PRESET
    //
    // Choose the quality preset.
    // This needs to be compiled into the shader as it effects code.
    // Best option to include multiple presets is to 
    // in each shader define the preset, then include this file.
    // 
    // OPTIONS
    // -----------------------------------------------------------------------
    // 10 to 15 - default medium dither (10=fastest, 15=highest quality)
    // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)
    // 39       - no dither, very expensive 
    //
    // NOTES
    // -----------------------------------------------------------------------
    // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)
    // 13 = about same speed as FXAA 3.9 and better than 12
    // 23 = closest to FXAA 3.9 visually and performance wise
    //  _ = the lowest digit is directly related to performance
    // _  = the highest digit is directly related to style
    // 
    #define FXAA_QUALITY__PRESET 12
#endif


/*============================================================================

                           FXAA QUALITY - PRESETS

============================================================================*/

/*============================================================================
                     FXAA QUALITY - MEDIUM DITHER PRESETS
============================================================================*/
#if (FXAA_QUALITY__PRESET == 10)
    #define FXAA_QUALITY__PS 3
    #define FXAA_QUALITY__P0 1.5
    #define FXAA_QUALITY__P1 3.0
    #define FXAA_QUALITY__P2 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 11)
    #define FXAA_QUALITY__PS 4
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 3.0
    #define FXAA_QUALITY__P3 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 12)
    #define FXAA_QUALITY__PS 5
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 4.0
    #define FXAA_QUALITY__P4 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 13)
    #define FXAA_QUALITY__PS 6
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 4.0
    #define FXAA_QUALITY__P5 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 14)
    #define FXAA_QUALITY__PS 7
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 4.0
    #define FXAA_QUALITY__P6 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 15)
    #define FXAA_QUALITY__PS 8
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 2.0
    #define FXAA_QUALITY__P6 4.0
    #define FXAA_QUALITY__P7 12.0
#endif

/*============================================================================
                     FXAA QUALITY - LOW DITHER PRESETS
============================================================================*/
#if (FXAA_QUALITY__PRESET == 20)
    #define FXAA_QUALITY__PS 3
    #define FXAA_QUALITY__P0 1.5
    #define FXAA_QUALITY__P1 2.0
    #define FXAA_QUALITY__P2 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 21)
    #define FXAA_QUALITY__PS 4
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 22)
    #define FXAA_QUALITY__PS 5
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 23)
    #define FXAA_QUALITY__PS 6
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 24)
    #define FXAA_QUALITY__PS 7
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 3.0
    #define FXAA_QUALITY__P6 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 25)
    #define FXAA_QUALITY__PS 8
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 2.0
    #define FXAA_QUALITY__P6 4.0
    #define FXAA_QUALITY__P7 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 26)
    #define FXAA_QUALITY__PS 9
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 2.0
    #define FXAA_QUALITY__P6 2.0
    #define FXAA_QUALITY__P7 4.0
    #define FXAA_QUALITY__P8 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 27)
    #define FXAA_QUALITY__PS 10
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 2.0
    #define FXAA_QUALITY__P6 2.0
    #define FXAA_QUALITY__P7 2.0
    #define FXAA_QUALITY__P8 4.0
    #define FXAA_QUALITY__P9 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 28)
    #define FXAA_QUALITY__PS 11
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 2.0
    #define FXAA_QUALITY__P6 2.0
    #define FXAA_QUALITY__P7 2.0
    #define FXAA_QUALITY__P8 2.0
    #define FXAA_QUALITY__P9 4.0
    #define FXAA_QUALITY__P10 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 29)
    #define FXAA_QUALITY__PS 12
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.5
    #define FXAA_QUALITY__P2 2.0
    #define FXAA_QUALITY__P3 2.0
    #define FXAA_QUALITY__P4 2.0
    #define FXAA_QUALITY__P5 2.0
    #define FXAA_QUALITY__P6 2.0
    #define FXAA_QUALITY__P7 2.0
    #define FXAA_QUALITY__P8 2.0
    #define FXAA_QUALITY__P9 2.0
    #define FXAA_QUALITY__P10 4.0
    #define FXAA_QUALITY__P11 8.0
#endif

/*============================================================================
                     FXAA QUALITY - EXTREME QUALITY
============================================================================*/
#if (FXAA_QUALITY__PRESET == 39)
    #define FXAA_QUALITY__PS 12
    #define FXAA_QUALITY__P0 1.0
    #define FXAA_QUALITY__P1 1.0
    #define FXAA_QUALITY__P2 1.0
    #define FXAA_QUALITY__P3 1.0
    #define FXAA_QUALITY__P4 1.0
    #define FXAA_QUALITY__P5 1.5
    #define FXAA_QUALITY__P6 2.0
    #define FXAA_QUALITY__P7 2.0
    #define FXAA_QUALITY__P8 2.0
    #define FXAA_QUALITY__P9 2.0
    #define FXAA_QUALITY__P10 4.0
    #define FXAA_QUALITY__P11 8.0
#endif



/*============================================================================

                                API PORTING

============================================================================*/
#if (FXAA_GLSL_120 == 1) || (FXAA_GLSL_130 == 1)
    #define FxaaBool bool
    #define FxaaDiscard discard
    #define FxaaFloat float
    #define FxaaFloat2 vec2
    #define FxaaFloat3 vec3
    #define FxaaFloat4 vec4
    #define FxaaHalf float
    #define FxaaHalf2 vec2
    #define FxaaHalf3 vec3
    #define FxaaHalf4 vec4
    #define FxaaInt2 ivec2
    #define FxaaSat(x) clamp(x, 0.0, 1.0)
    #define FxaaTex sampler2D
#else
    #define FxaaBool bool
    #define FxaaDiscard clip(-1)
    #define FxaaFloat float
    #define FxaaFloat2 float2
    #define FxaaFloat3 float3
    #define FxaaFloat4 float4
    #define FxaaHalf half
    #define FxaaHalf2 half2
    #define FxaaHalf3 half3
    #define FxaaHalf4 half4
    #define FxaaSat(x) saturate(x)
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_GLSL_120 == 1)
    // Requires,
    //  #version 120
    // And at least,
    //  #extension GL_EXT_gpu_shader4 : enable
    //  (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)
    #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)
    #if (FXAA_FAST_PIXEL_OFFSET == 1)
        #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)
    #else
        #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)
    #endif
    #if (FXAA_GATHER4_ALPHA == 1)
        // use #extension GL_ARB_gpu_shader5 : enable
        #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
        #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
        #define FxaaTexGreen4(t, p) textureGather(t, p, 1)
        #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
    #endif
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_GLSL_130 == 1)
    // Requires "#version 130" or better
    #define FxaaTexTop(t, p) textureLod(t, p, 0.0)
    #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)
    #if (FXAA_GATHER4_ALPHA == 1)
        // use #extension GL_ARB_gpu_shader5 : enable
        #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
        #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
        #define FxaaTexGreen4(t, p) textureGather(t, p, 1)
        #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
    #endif
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_HLSL_3 == 1) || (FXAA_360 == 1) || (FXAA_PS3 == 1)
    #define FxaaInt2 float2
    #define FxaaTex sampler2D
    #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))
    #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_HLSL_4 == 1)
    #define FxaaInt2 int2
    struct FxaaTex { SamplerState smpl; Texture2D tex; };
    #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)
    #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_HLSL_5 == 1)
    #define FxaaInt2 int2
    struct FxaaTex { SamplerState smpl; Texture2D tex; };
    #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)
    #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)
    #define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)
    #define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)
    #define FxaaTexGreen4(t, p) t.tex.GatherGreen(t.smpl, p)
    #define FxaaTexOffGreen4(t, p, o) t.tex.GatherGreen(t.smpl, p, o)
#endif


/*============================================================================
                   GREEN AS LUMA OPTION SUPPORT FUNCTION
============================================================================*/
#if (FXAA_GREEN_AS_LUMA == 0)
    FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }
#else
    FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }
#endif    




/*============================================================================

                             FXAA3 QUALITY - PC

============================================================================*/
#if (FXAA_PC == 1)
/*--------------------------------------------------------------------------*/
FxaaFloat4 FxaaPixelShader(
    //
    // Use noperspective interpolation here (turn off perspective interpolation).
    // {xy} = center of pixel
    FxaaFloat2 pos,
    //
    // Used only for FXAA Console, and not used on the 360 version.
    // Use noperspective interpolation here (turn off perspective interpolation).
    // {xy__} = upper left of pixel
    // {__zw} = lower right of pixel
    FxaaFloat4 fxaaConsolePosPos,
    //
    // Input color texture.
    // {rgb_} = color in linear or perceptual color space
    // if (FXAA_GREEN_AS_LUMA == 0)
    //     {___a} = luma in perceptual color space (not linear)
    FxaaTex tex,
    //
    // Only used on the optimized 360 version of FXAA Console.
    // For everything but 360, just use the same input here as for "tex".
    // For 360, same texture, just alias with a 2nd sampler.
    // This sampler needs to have an exponent bias of -1.
    FxaaTex fxaaConsole360TexExpBiasNegOne,
    //
    // Only used on the optimized 360 version of FXAA Console.
    // For everything but 360, just use the same input here as for "tex".
    // For 360, same texture, just alias with a 3nd sampler.
    // This sampler needs to have an exponent bias of -2.
    FxaaTex fxaaConsole360TexExpBiasNegTwo,
    //
    // Only used on FXAA Quality.
    // This must be from a constant/uniform.
    // {x_} = 1.0/screenWidthInPixels
    // {_y} = 1.0/screenHeightInPixels
    FxaaFloat2 fxaaQualityRcpFrame,
    //
    // Only used on FXAA Console.
    // This must be from a constant/uniform.
    // This effects sub-pixel AA quality and inversely sharpness.
    //   Where N ranges between,
    //     N = 0.50 (default)
    //     N = 0.33 (sharper)
    // {x___} = -N/screenWidthInPixels  
    // {_y__} = -N/screenHeightInPixels
    // {__z_} =  N/screenWidthInPixels  
    // {___w} =  N/screenHeightInPixels 
    FxaaFloat4 fxaaConsoleRcpFrameOpt,
    //
    // Only used on FXAA Console.
    // Not used on 360, but used on PS3 and PC.
    // This must be from a constant/uniform.
    // {x___} = -2.0/screenWidthInPixels  
    // {_y__} = -2.0/screenHeightInPixels
    // {__z_} =  2.0/screenWidthInPixels  
    // {___w} =  2.0/screenHeightInPixels 
    FxaaFloat4 fxaaConsoleRcpFrameOpt2,
    //
    // Only used on FXAA Console.
    // Only used on 360 in place of fxaaConsoleRcpFrameOpt2.
    // This must be from a constant/uniform.
    // {x___} =  8.0/screenWidthInPixels  
    // {_y__} =  8.0/screenHeightInPixels
    // {__z_} = -4.0/screenWidthInPixels  
    // {___w} = -4.0/screenHeightInPixels 
    FxaaFloat4 fxaaConsole360RcpFrameOpt2,
    //
    // Only used on FXAA Quality.
    // This used to be the FXAA_QUALITY__SUBPIX define.
    // It is here now to allow easier tuning.
    // Choose the amount of sub-pixel aliasing removal.
    // This can effect sharpness.
    //   1.00 - upper limit (softer)
    //   0.75 - default amount of filtering
    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)
    //   0.25 - almost off
    //   0.00 - completely off
    FxaaFloat fxaaQualitySubpix,
    //
    // Only used on FXAA Quality.
    // This used to be the FXAA_QUALITY__EDGE_THRESHOLD define.
    // It is here now to allow easier tuning.
    // The minimum amount of local contrast required to apply algorithm.
    //   0.333 - too little (faster)
    //   0.250 - low quality
    //   0.166 - default
    //   0.125 - high quality 
    //   0.063 - overkill (slower)
    FxaaFloat fxaaQualityEdgeThreshold,
    //
    // Only used on FXAA Quality.
    // This used to be the FXAA_QUALITY__EDGE_THRESHOLD_MIN define.
    // It is here now to allow easier tuning.
    // Trims the algorithm from processing darks.
    //   0.0833 - upper limit (default, the start of visible unfiltered edges)
    //   0.0625 - high quality (faster)
    //   0.0312 - visible limit (slower)
    // Special notes when using FXAA_GREEN_AS_LUMA,
    //   Likely want to set this to zero.
    //   As colors that are mostly not-green
    //   will appear very dark in the green channel!
    //   Tune by looking at mostly non-green content,
    //   then start at zero and increase until aliasing is a problem.
    FxaaFloat fxaaQualityEdgeThresholdMin,
    // 
    // Only used on FXAA Console.
    // This used to be the FXAA_CONSOLE__EDGE_SHARPNESS define.
    // It is here now to allow easier tuning.
    // This does not effect PS3, as this needs to be compiled in.
    //   Use FXAA_CONSOLE__PS3_EDGE_SHARPNESS for PS3.
    //   Due to the PS3 being ALU bound,
    //   there are only three safe values here: 2 and 4 and 8.
    //   These options use the shaders ability to a free *|/ by 2|4|8.
    // For all other platforms can be a non-power of two.
    //   8.0 is sharper (default!!!)
    //   4.0 is softer
    //   2.0 is really soft (good only for vector graphics inputs)
    FxaaFloat fxaaConsoleEdgeSharpness,
    //
    // Only used on FXAA Console.
    // This used to be the FXAA_CONSOLE__EDGE_THRESHOLD define.
    // It is here now to allow easier tuning.
    // This does not effect PS3, as this needs to be compiled in.
    //   Use FXAA_CONSOLE__PS3_EDGE_THRESHOLD for PS3.
    //   Due to the PS3 being ALU bound,
    //   there are only two safe values here: 1/4 and 1/8.
    //   These options use the shaders ability to a free *|/ by 2|4|8.
    // The console setting has a different mapping than the quality setting.
    // Other platforms can use other values.
    //   0.125 leaves less aliasing, but is softer (default!!!)
    //   0.25 leaves more aliasing, and is sharper
    FxaaFloat fxaaConsoleEdgeThreshold,
    //
    // Only used on FXAA Console.
    // This used to be the FXAA_CONSOLE__EDGE_THRESHOLD_MIN define.
    // It is here now to allow easier tuning.
    // Trims the algorithm from processing darks.
    // The console setting has a different mapping than the quality setting.
    // This only applies when FXAA_EARLY_EXIT is 1.
    // This does not apply to PS3, 
    // PS3 was simplified to avoid more shader instructions.
    //   0.06 - faster but more aliasing in darks
    //   0.05 - default
    //   0.04 - slower and less aliasing in darks
    // Special notes when using FXAA_GREEN_AS_LUMA,
    //   Likely want to set this to zero.
    //   As colors that are mostly not-green
    //   will appear very dark in the green channel!
    //   Tune by looking at mostly non-green content,
    //   then start at zero and increase until aliasing is a problem.
    FxaaFloat fxaaConsoleEdgeThresholdMin,
    //    
    // Extra constants for 360 FXAA Console only.
    // Use zeros or anything else for other platforms.
    // These must be in physical constant registers and NOT immedates.
    // Immedates will result in compiler un-optimizing.
    // {xyzw} = float4(1.0, -1.0, 0.25, -0.25)
    FxaaFloat4 fxaaConsole360ConstDir
) {
/*--------------------------------------------------------------------------*/
    FxaaFloat2 posM;
    posM.x = pos.x;
    posM.y = pos.y;
    #if (FXAA_GATHER4_ALPHA == 1)
        #if (FXAA_DISCARD == 0)
            FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
            #if (FXAA_GREEN_AS_LUMA == 0)
                #define lumaM rgbyM.w
            #else
                #define lumaM rgbyM.y
            #endif
        #endif
        #if (FXAA_GREEN_AS_LUMA == 0)
            FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);
            FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));
        #else
            FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);
            FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));
        #endif
        #if (FXAA_DISCARD == 1)
            #define lumaM luma4A.w
        #endif
        #define lumaE luma4A.z
        #define lumaS luma4A.x
        #define lumaSE luma4A.y
        #define lumaNW luma4B.w
        #define lumaN luma4B.z
        #define lumaW luma4B.x
    #else
        FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
        #if (FXAA_GREEN_AS_LUMA == 0)
            #define lumaM rgbyM.w
        #else
            #define lumaM rgbyM.y
        #endif
        FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));
        FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));
        FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));
        FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));
    #endif
/*--------------------------------------------------------------------------*/
    FxaaFloat maxSM = max(lumaS, lumaM);
    FxaaFloat minSM = min(lumaS, lumaM);
    FxaaFloat maxESM = max(lumaE, maxSM);
    FxaaFloat minESM = min(lumaE, minSM);
    FxaaFloat maxWN = max(lumaN, lumaW);
    FxaaFloat minWN = min(lumaN, lumaW);
    FxaaFloat rangeMax = max(maxWN, maxESM);
    FxaaFloat rangeMin = min(minWN, minESM);
    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
    FxaaFloat range = rangeMax - rangeMin;
    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
    FxaaBool earlyExit = range < rangeMaxClamped;
/*--------------------------------------------------------------------------*/
    if(earlyExit)
        #if (FXAA_DISCARD == 1)
            FxaaDiscard;
        #else
            return rgbyM;
        #endif
/*--------------------------------------------------------------------------*/
    #if (FXAA_GATHER4_ALPHA == 0)
        FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));
        FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));
        FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));
        FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
    #else
        FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));
        FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
    #endif
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaNS = lumaN + lumaS;
    FxaaFloat lumaWE = lumaW + lumaE;
    FxaaFloat subpixRcpRange = 1.0/range;
    FxaaFloat subpixNSWE = lumaNS + lumaWE;
    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;
    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaNESE = lumaNE + lumaSE;
    FxaaFloat lumaNWNE = lumaNW + lumaNE;
    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaNWSW = lumaNW + lumaSW;
    FxaaFloat lumaSWSE = lumaSW + lumaSE;
    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;
    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;
/*--------------------------------------------------------------------------*/
    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;
    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;
    FxaaBool horzSpan = edgeHorz >= edgeVert;
    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
/*--------------------------------------------------------------------------*/
    if(!horzSpan) lumaN = lumaW;
    if(!horzSpan) lumaS = lumaE;
    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;
    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;
/*--------------------------------------------------------------------------*/
    FxaaFloat gradientN = lumaN - lumaM;
    FxaaFloat gradientS = lumaS - lumaM;
    FxaaFloat lumaNN = lumaN + lumaM;
    FxaaFloat lumaSS = lumaS + lumaM;
    FxaaBool pairN = abs(gradientN) >= abs(gradientS);
    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));
    if(pairN) lengthSign = -lengthSign;
    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
/*--------------------------------------------------------------------------*/
    FxaaFloat2 posB;
    posB.x = posM.x;
    posB.y = posM.y;
    FxaaFloat2 offNP;
    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
    if(!horzSpan) posB.x += lengthSign * 0.5;
    if( horzSpan) posB.y += lengthSign * 0.5;
/*--------------------------------------------------------------------------*/
    FxaaFloat2 posN;
    posN.x = posB.x - offNP.x * FXAA_QUALITY__P0;
    posN.y = posB.y - offNP.y * FXAA_QUALITY__P0;
    FxaaFloat2 posP;
    posP.x = posB.x + offNP.x * FXAA_QUALITY__P0;
    posP.y = posB.y + offNP.y * FXAA_QUALITY__P0;
    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;
    FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));
    FxaaFloat subpixE = subpixC * subpixC;
    FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));
/*--------------------------------------------------------------------------*/
    if(!pairN) lumaNN = lumaSS;
    FxaaFloat gradientScaled = gradient * 1.0/4.0;
    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;
    FxaaFloat subpixF = subpixD * subpixE;
    FxaaBool lumaMLTZero = lumaMM < 0.0;
/*--------------------------------------------------------------------------*/
    lumaEndN -= lumaNN * 0.5;
    lumaEndP -= lumaNN * 0.5;
    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;
    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;
    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P1;
    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P1;
    FxaaBool doneNP = (!doneN) || (!doneP);
    if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P1;
    if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P1;
/*--------------------------------------------------------------------------*/
    if(doneNP) {
        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
        doneN = abs(lumaEndN) >= gradientScaled;
        doneP = abs(lumaEndP) >= gradientScaled;
        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P2;
        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P2;
        doneNP = (!doneN) || (!doneP);
        if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P2;
        if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P2;
/*--------------------------------------------------------------------------*/
        #if (FXAA_QUALITY__PS > 3)
        if(doneNP) {
            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
            doneN = abs(lumaEndN) >= gradientScaled;
            doneP = abs(lumaEndP) >= gradientScaled;
            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P3;
            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P3;
            doneNP = (!doneN) || (!doneP);
            if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P3;
            if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P3;
/*--------------------------------------------------------------------------*/
            #if (FXAA_QUALITY__PS > 4)
            if(doneNP) {
                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
                doneN = abs(lumaEndN) >= gradientScaled;
                doneP = abs(lumaEndP) >= gradientScaled;
                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P4;
                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P4;
                doneNP = (!doneN) || (!doneP);
                if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P4;
                if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P4;
/*--------------------------------------------------------------------------*/
                #if (FXAA_QUALITY__PS > 5)
                if(doneNP) {
                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
                    doneN = abs(lumaEndN) >= gradientScaled;
                    doneP = abs(lumaEndP) >= gradientScaled;
                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P5;
                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P5;
                    doneNP = (!doneN) || (!doneP);
                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P5;
                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P5;
/*--------------------------------------------------------------------------*/
                    #if (FXAA_QUALITY__PS > 6)
                    if(doneNP) {
                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
                        doneN = abs(lumaEndN) >= gradientScaled;
                        doneP = abs(lumaEndP) >= gradientScaled;
                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P6;
                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P6;
                        doneNP = (!doneN) || (!doneP);
                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P6;
                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P6;
/*--------------------------------------------------------------------------*/
                        #if (FXAA_QUALITY__PS > 7)
                        if(doneNP) {
                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
                            doneN = abs(lumaEndN) >= gradientScaled;
                            doneP = abs(lumaEndP) >= gradientScaled;
                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P7;
                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P7;
                            doneNP = (!doneN) || (!doneP);
                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P7;
                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P7;
/*--------------------------------------------------------------------------*/
    #if (FXAA_QUALITY__PS > 8)
    if(doneNP) {
        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
        doneN = abs(lumaEndN) >= gradientScaled;
        doneP = abs(lumaEndP) >= gradientScaled;
        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P8;
        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P8;
        doneNP = (!doneN) || (!doneP);
        if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P8;
        if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P8;
/*--------------------------------------------------------------------------*/
        #if (FXAA_QUALITY__PS > 9)
        if(doneNP) {
            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
            doneN = abs(lumaEndN) >= gradientScaled;
            doneP = abs(lumaEndP) >= gradientScaled;
            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P9;
            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P9;
            doneNP = (!doneN) || (!doneP);
            if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P9;
            if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P9;
/*--------------------------------------------------------------------------*/
            #if (FXAA_QUALITY__PS > 10)
            if(doneNP) {
                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
                doneN = abs(lumaEndN) >= gradientScaled;
                doneP = abs(lumaEndP) >= gradientScaled;
                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P10;
                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P10;
                doneNP = (!doneN) || (!doneP);
                if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P10;
                if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P10;
/*--------------------------------------------------------------------------*/
                #if (FXAA_QUALITY__PS > 11)
                if(doneNP) {
                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
                    doneN = abs(lumaEndN) >= gradientScaled;
                    doneP = abs(lumaEndP) >= gradientScaled;
                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P11;
                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P11;
                    doneNP = (!doneN) || (!doneP);
                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P11;
                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P11;
/*--------------------------------------------------------------------------*/
                    #if (FXAA_QUALITY__PS > 12)
                    if(doneNP) {
                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
                        doneN = abs(lumaEndN) >= gradientScaled;
                        doneP = abs(lumaEndP) >= gradientScaled;
                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P12;
                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P12;
                        doneNP = (!doneN) || (!doneP);
                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P12;
                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P12;
/*--------------------------------------------------------------------------*/
                    }
                    #endif
/*--------------------------------------------------------------------------*/
                }
                #endif
/*--------------------------------------------------------------------------*/
            }
            #endif
/*--------------------------------------------------------------------------*/
        }
        #endif
/*--------------------------------------------------------------------------*/
    }
    #endif
/*--------------------------------------------------------------------------*/
                        }
                        #endif
/*--------------------------------------------------------------------------*/
                    }
                    #endif
/*--------------------------------------------------------------------------*/
                }
                #endif
/*--------------------------------------------------------------------------*/
            }
            #endif
/*--------------------------------------------------------------------------*/
        }
        #endif
/*--------------------------------------------------------------------------*/
    }
/*--------------------------------------------------------------------------*/
    FxaaFloat dstN = posM.x - posN.x;
    FxaaFloat dstP = posP.x - posM.x;
    if(!horzSpan) dstN = posM.y - posN.y;
    if(!horzSpan) dstP = posP.y - posM.y;
/*--------------------------------------------------------------------------*/
    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
    FxaaFloat spanLength = (dstP + dstN);
    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
    FxaaFloat spanLengthRcp = 1.0/spanLength;
/*--------------------------------------------------------------------------*/
    FxaaBool directionN = dstN < dstP;
    FxaaFloat dst = min(dstN, dstP);
    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;
    FxaaFloat subpixG = subpixF * subpixF;
    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;
    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;
/*--------------------------------------------------------------------------*/
    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);
    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;
    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;
    #if (FXAA_DISCARD == 1)
        return FxaaTexTop(tex, posM);
    #else
        return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);
    #endif
}
/*==========================================================================*/
#endif




/*============================================================================

                         FXAA3 CONSOLE - PC VERSION
                         
------------------------------------------------------------------------------
Instead of using this on PC, I'd suggest just using FXAA Quality with
    #define FXAA_QUALITY__PRESET 10
Or 
    #define FXAA_QUALITY__PRESET 20
Either are higher qualilty and almost as fast as this on modern PC GPUs.
============================================================================*/
#if (FXAA_PC_CONSOLE == 1)
/*--------------------------------------------------------------------------*/
FxaaFloat4 FxaaPixelShader(
    // See FXAA Quality FxaaPixelShader() source for docs on Inputs!
    FxaaFloat2 pos,
    FxaaFloat4 fxaaConsolePosPos,
    FxaaTex tex,
    FxaaTex fxaaConsole360TexExpBiasNegOne,
    FxaaTex fxaaConsole360TexExpBiasNegTwo,
    FxaaFloat2 fxaaQualityRcpFrame,
    FxaaFloat4 fxaaConsoleRcpFrameOpt,
    FxaaFloat4 fxaaConsoleRcpFrameOpt2,
    FxaaFloat4 fxaaConsole360RcpFrameOpt2,
    FxaaFloat fxaaQualitySubpix,
    FxaaFloat fxaaQualityEdgeThreshold,
    FxaaFloat fxaaQualityEdgeThresholdMin,
    FxaaFloat fxaaConsoleEdgeSharpness,
    FxaaFloat fxaaConsoleEdgeThreshold,
    FxaaFloat fxaaConsoleEdgeThresholdMin,
    FxaaFloat4 fxaaConsole360ConstDir
) {
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaNw = FxaaLuma(FxaaTexTop(tex, fxaaConsolePosPos.xy));
    FxaaFloat lumaSw = FxaaLuma(FxaaTexTop(tex, fxaaConsolePosPos.xw));
    FxaaFloat lumaNe = FxaaLuma(FxaaTexTop(tex, fxaaConsolePosPos.zy));
    FxaaFloat lumaSe = FxaaLuma(FxaaTexTop(tex, fxaaConsolePosPos.zw));
/*--------------------------------------------------------------------------*/
    FxaaFloat4 rgbyM = FxaaTexTop(tex, pos.xy);
    #if (FXAA_GREEN_AS_LUMA == 0)
        FxaaFloat lumaM = rgbyM.w;
    #else
        FxaaFloat lumaM = rgbyM.y;
    #endif
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaMaxNwSw = max(lumaNw, lumaSw);
    lumaNe += 1.0/384.0;
    FxaaFloat lumaMinNwSw = min(lumaNw, lumaSw);
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaMaxNeSe = max(lumaNe, lumaSe);
    FxaaFloat lumaMinNeSe = min(lumaNe, lumaSe);
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaMax = max(lumaMaxNeSe, lumaMaxNwSw);
    FxaaFloat lumaMin = min(lumaMinNeSe, lumaMinNwSw);
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaMaxScaled = lumaMax * fxaaConsoleEdgeThreshold;
/*--------------------------------------------------------------------------*/
    FxaaFloat lumaMinM = min(lumaMin, lumaM);
    FxaaFloat lumaMaxScaledClamped = max(fxaaConsoleEdgeThresholdMin, lumaMaxScaled);
    FxaaFloat lumaMaxM = max(lumaMax, lumaM);
    FxaaFloat dirSwMinusNe = lumaSw - lumaNe;
    FxaaFloat lumaMaxSubMinM = lumaMaxM - lumaMinM;
    FxaaFloat dirSeMinusNw = lumaSe - lumaNw;
    if(lumaMaxSubMinM < lumaMaxScaledClamped) return rgbyM;
/*--------------------------------------------------------------------------*/
    FxaaFloat2 dir;
    dir.x = dirSwMinusNe + dirSeMinusNw;
    dir.y = dirSwMinusNe - dirSeMinusNw;
/*--------------------------------------------------------------------------*/
    FxaaFloat2 dir1 = normalize(dir.xy);
    FxaaFloat4 rgbyN1 = FxaaTexTop(tex, pos.xy - dir1 * fxaaConsoleRcpFrameOpt.zw);
    FxaaFloat4 rgbyP1 = FxaaTexTop(tex, pos.xy + dir1 * fxaaConsoleRcpFrameOpt.zw);
/*--------------------------------------------------------------------------*/
    FxaaFloat dirAbsMinTimesC = min(abs(dir1.x), abs(dir1.y)) * fxaaConsoleEdgeSharpness;
    FxaaFloat2 dir2 = clamp(dir1.xy / dirAbsMinTimesC, -2.0, 2.0);
/*--------------------------------------------------------------------------*/
    FxaaFloat4 rgbyN2 = FxaaTexTop(tex, pos.xy - dir2 * fxaaConsoleRcpFrameOpt2.zw);
    FxaaFloat4 rgbyP2 = FxaaTexTop(tex, pos.xy + dir2 * fxaaConsoleRcpFrameOpt2.zw);
/*--------------------------------------------------------------------------*/
    FxaaFloat4 rgbyA = rgbyN1 + rgbyP1;
    FxaaFloat4 rgbyB = ((rgbyN2 + rgbyP2) * 0.25) + (rgbyA * 0.25);
/*--------------------------------------------------------------------------*/
    #if (FXAA_GREEN_AS_LUMA == 0)
        FxaaBool twoTap = (rgbyB.w < lumaMin) || (rgbyB.w > lumaMax);
    #else
        FxaaBool twoTap = (rgbyB.y < lumaMin) || (rgbyB.y > lumaMax);
    #endif
    if(twoTap) rgbyB.xyz = rgbyA.xyz * 0.5;
    return rgbyB; }
/*==========================================================================*/
#endif



/*============================================================================

                      FXAA3 CONSOLE - 360 PIXEL SHADER 

------------------------------------------------------------------------------
This optimized version thanks to suggestions from Andy Luedke.
Should be fully tex bound in all cases.
As of the FXAA 3.11 release, I have still not tested this code,
however I fixed a bug which was in both FXAA 3.9 and FXAA 3.10.
And note this is replacing the old unoptimized version.
If it does not work, please let me know so I can fix it.
============================================================================*/
#if (FXAA_360 == 1)
/*--------------------------------------------------------------------------*/
[reduceTempRegUsage(4)]
float4 FxaaPixelShader(
    // See FXAA Quality FxaaPixelShader() source for docs on Inputs!
    FxaaFloat2 pos,
    FxaaFloat4 fxaaConsolePosPos,
    FxaaTex tex,
    FxaaTex fxaaConsole360TexExpBiasNegOne,
    FxaaTex fxaaConsole360TexExpBiasNegTwo,
    FxaaFloat2 fxaaQualityRcpFrame,
    FxaaFloat4 fxaaConsoleRcpFrameOpt,
    FxaaFloat4 fxaaConsoleRcpFrameOpt2,
    FxaaFloat4 fxaaConsole360RcpFrameOpt2,
    FxaaFloat fxaaQualitySubpix,
    FxaaFloat fxaaQualityEdgeThreshold,
    FxaaFloat fxaaQualityEdgeThresholdMin,
    FxaaFloat fxaaConsoleEdgeSharpness,
    FxaaFloat fxaaConsoleEdgeThreshold,
    FxaaFloat fxaaConsoleEdgeThresholdMin,
    FxaaFloat4 fxaaConsole360ConstDir
) {
/*--------------------------------------------------------------------------*/
    float4 lumaNwNeSwSe;
    #if (FXAA_GREEN_AS_LUMA == 0)
        asm { 
            tfetch2D lumaNwNeSwSe.w___, tex, pos.xy, OffsetX = -0.5, OffsetY = -0.5, UseComputedLOD=false
            tfetch2D lumaNwNeSwSe._w__, tex, pos.xy, OffsetX =  0.5, OffsetY = -0.5, UseComputedLOD=false
            tfetch2D lumaNwNeSwSe.__w_, tex, pos.xy, OffsetX = -0.5, OffsetY =  0.5, UseComputedLOD=false
            tfetch2D lumaNwNeSwSe.___w, tex, pos.xy, OffsetX =  0.5, OffsetY =  0.5, UseComputedLOD=false
        };
    #else
        asm { 
            tfetch2D lumaNwNeSwSe.y___, tex, pos.xy, OffsetX = -0.5, OffsetY = -0.5, UseComputedLOD=false
            tfetch2D lumaNwNeSwSe._y__, tex, pos.xy, OffsetX =  0.5, OffsetY = -0.5, UseComputedLOD=false
            tfetch2D lumaNwNeSwSe.__y_, tex, pos.xy, OffsetX = -0.5, OffsetY =  0.5, UseComputedLOD=false
            tfetch2D lumaNwNeSwSe.___y, tex, pos.xy, OffsetX =  0.5, OffsetY =  0.5, UseComputedLOD=false
        };
    #endif
/*--------------------------------------------------------------------------*/
    lumaNwNeSwSe.y += 1.0/384.0;
    float2 lumaMinTemp = min(lumaNwNeSwSe.xy, lumaNwNeSwSe.zw);
    float2 lumaMaxTemp = max(lumaNwNeSwSe.xy, lumaNwNeSwSe.zw);
    float lumaMin = min(lumaMinTemp.x, lumaMinTemp.y);
    float lumaMax = max(lumaMaxTemp.x, lumaMaxTemp.y);
/*--------------------------------------------------------------------------*/
    float4 rgbyM = tex2Dlod(tex, float4(pos.xy, 0.0, 0.0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        float lumaMinM = min(lumaMin, rgbyM.w);
        float lumaMaxM = max(lumaMax, rgbyM.w);
    #else
        float lumaMinM = min(lumaMin, rgbyM.y);
        float lumaMaxM = max(lumaMax, rgbyM.y);
    #endif        
    if((lumaMaxM - lumaMinM) < max(fxaaConsoleEdgeThresholdMin, lumaMax * fxaaConsoleEdgeThreshold)) return rgbyM;
/*--------------------------------------------------------------------------*/
    float2 dir;
    dir.x = dot(lumaNwNeSwSe, fxaaConsole360ConstDir.yyxx);
    dir.y = dot(lumaNwNeSwSe, fxaaConsole360ConstDir.xyxy);
    dir = normalize(dir);
/*--------------------------------------------------------------------------*/
    float4 dir1 = dir.xyxy * fxaaConsoleRcpFrameOpt.xyzw;
/*--------------------------------------------------------------------------*/
    float4 dir2;
    float dirAbsMinTimesC = min(abs(dir.x), abs(dir.y)) * fxaaConsoleEdgeSharpness;
    dir2 = saturate(fxaaConsole360ConstDir.zzww * dir.xyxy / dirAbsMinTimesC + 0.5);
    dir2 = dir2 * fxaaConsole360RcpFrameOpt2.xyxy + fxaaConsole360RcpFrameOpt2.zwzw;
/*--------------------------------------------------------------------------*/
    float4 rgbyN1 = tex2Dlod(fxaaConsole360TexExpBiasNegOne, float4(pos.xy + dir1.xy, 0.0, 0.0));
    float4 rgbyP1 = tex2Dlod(fxaaConsole360TexExpBiasNegOne, float4(pos.xy + dir1.zw, 0.0, 0.0));
    float4 rgbyN2 = tex2Dlod(fxaaConsole360TexExpBiasNegTwo, float4(pos.xy + dir2.xy, 0.0, 0.0));
    float4 rgbyP2 = tex2Dlod(fxaaConsole360TexExpBiasNegTwo, float4(pos.xy + dir2.zw, 0.0, 0.0));
/*--------------------------------------------------------------------------*/
    float4 rgbyA = rgbyN1 + rgbyP1;
    float4 rgbyB = rgbyN2 + rgbyP2 + rgbyA * 0.5;
/*--------------------------------------------------------------------------*/
    float4 rgbyR = ((FxaaLuma(rgbyB) - lumaMax) > 0.0) ? rgbyA : rgbyB; 
    rgbyR = ((FxaaLuma(rgbyB) - lumaMin) > 0.0) ? rgbyR : rgbyA; 
    return rgbyR; }
/*==========================================================================*/
#endif



/*============================================================================

         FXAA3 CONSOLE - OPTIMIZED PS3 PIXEL SHADER (NO EARLY EXIT)

==============================================================================
The code below does not exactly match the assembly.
I have a feeling that 12 cycles is possible, but was not able to get there.
Might have to increase register count to get full performance.
Note this shader does not use perspective interpolation.

Use the following cgc options,

  --fenable-bx2 --fastmath --fastprecision --nofloatbindings

------------------------------------------------------------------------------
                             NVSHADERPERF OUTPUT
------------------------------------------------------------------------------
For reference and to aid in debug, output of NVShaderPerf should match this,

Shader to schedule:
  0: texpkb h0.w(TRUE), v5.zyxx, #0
  2: addh h2.z(TRUE), h0.w, constant(0.001953, 0.000000, 0.000000, 0.000000).x
  4: texpkb h0.w(TRUE), v5.xwxx, #0
  6: addh h0.z(TRUE), -h2, h0.w
  7: texpkb h1.w(TRUE), v5, #0
  9: addh h0.x(TRUE), h0.z, -h1.w
 10: addh h3.w(TRUE), h0.z, h1
 11: texpkb h2.w(TRUE), v5.zwzz, #0
 13: addh h0.z(TRUE), h3.w, -h2.w
 14: addh h0.x(TRUE), h2.w, h0
 15: nrmh h1.xz(TRUE), h0_n
 16: minh_m8 h0.x(TRUE), |h1|, |h1.z|
 17: maxh h4.w(TRUE), h0, h1
 18: divx h2.xy(TRUE), h1_n.xzzw, h0_n
 19: movr r1.zw(TRUE), v4.xxxy
 20: madr r2.xz(TRUE), -h1, constant(cConst5.x, cConst5.y, cConst5.z, cConst5.w).zzww, r1.zzww
 22: minh h5.w(TRUE), h0, h1
 23: texpkb h0(TRUE), r2.xzxx, #0
 25: madr r0.zw(TRUE), h1.xzxz, constant(cConst5.x, cConst5.y, cConst5.z, cConst5.w), r1
 27: maxh h4.x(TRUE), h2.z, h2.w
 28: texpkb h1(TRUE), r0.zwzz, #0
 30: addh_d2 h1(TRUE), h0, h1
 31: madr r0.xy(TRUE), -h2, constant(cConst5.x, cConst5.y, cConst5.z, cConst5.w).xyxx, r1.zwzz
 33: texpkb h0(TRUE), r0, #0
 35: minh h4.z(TRUE), h2, h2.w
 36: fenct TRUE
 37: madr r1.xy(TRUE), h2, constant(cConst5.x, cConst5.y, cConst5.z, cConst5.w).xyxx, r1.zwzz
 39: texpkb h2(TRUE), r1, #0
 41: addh_d2 h0(TRUE), h0, h2
 42: maxh h2.w(TRUE), h4, h4.x
 43: minh h2.x(TRUE), h5.w, h4.z
 44: addh_d2 h0(TRUE), h0, h1
 45: slth h2.x(TRUE), h0.w, h2
 46: sgth h2.w(TRUE), h0, h2
 47: movh h0(TRUE), h0
 48: addx.c0 rc(TRUE), h2, h2.w
 49: movh h0(c0.NE.x), h1

IPU0 ------ Simplified schedule: --------
Pass |  Unit  |  uOp |  PC:  Op
-----+--------+------+-------------------------
   1 | SCT0/1 |  mov |   0:  TXLr h0.w, g[TEX1].zyxx, const.xxxx, TEX0;
     |    TEX |  txl |   0:  TXLr h0.w, g[TEX1].zyxx, const.xxxx, TEX0;
     |   SCB1 |  add |   2:  ADDh h2.z, h0.--w-, const.--x-;
     |        |      |
   2 | SCT0/1 |  mov |   4:  TXLr h0.w, g[TEX1].xwxx, const.xxxx, TEX0;
     |    TEX |  txl |   4:  TXLr h0.w, g[TEX1].xwxx, const.xxxx, TEX0;
     |   SCB1 |  add |   6:  ADDh h0.z,-h2, h0.--w-;
     |        |      |
   3 | SCT0/1 |  mov |   7:  TXLr h1.w, g[TEX1], const.xxxx, TEX0;
     |    TEX |  txl |   7:  TXLr h1.w, g[TEX1], const.xxxx, TEX0;
     |   SCB0 |  add |   9:  ADDh h0.x, h0.z---,-h1.w---;
     |   SCB1 |  add |  10:  ADDh h3.w, h0.---z, h1;
     |        |      |
   4 | SCT0/1 |  mov |  11:  TXLr h2.w, g[TEX1].zwzz, const.xxxx, TEX0;
     |    TEX |  txl |  11:  TXLr h2.w, g[TEX1].zwzz, const.xxxx, TEX0;
     |   SCB0 |  add |  14:  ADDh h0.x, h2.w---, h0;
     |   SCB1 |  add |  13:  ADDh h0.z, h3.--w-,-h2.--w-;
     |        |      |
   5 |   SCT1 |  mov |  15:  NRMh h1.xz, h0;
     |    SRB |  nrm |  15:  NRMh h1.xz, h0;
     |   SCB0 |  min |  16:  MINh*8 h0.x, |h1|, |h1.z---|;
     |   SCB1 |  max |  17:  MAXh h4.w, h0, h1;
     |        |      |
   6 |   SCT0 |  div |  18:  DIVx h2.xy, h1.xz--, h0;
     |   SCT1 |  mov |  19:  MOVr r1.zw, g[TEX0].--xy;
     |   SCB0 |  mad |  20:  MADr r2.xz,-h1, const.z-w-, r1.z-w-;
     |   SCB1 |  min |  22:  MINh h5.w, h0, h1;
     |        |      |
   7 | SCT0/1 |  mov |  23:  TXLr h0, r2.xzxx, const.xxxx, TEX0;
     |    TEX |  txl |  23:  TXLr h0, r2.xzxx, const.xxxx, TEX0;
     |   SCB0 |  max |  27:  MAXh h4.x, h2.z---, h2.w---;
     |   SCB1 |  mad |  25:  MADr r0.zw, h1.--xz, const, r1;
     |        |      |
   8 | SCT0/1 |  mov |  28:  TXLr h1, r0.zwzz, const.xxxx, TEX0;
     |    TEX |  txl |  28:  TXLr h1, r0.zwzz, const.xxxx, TEX0;
     | SCB0/1 |  add |  30:  ADDh/2 h1, h0, h1;
     |        |      |
   9 |   SCT0 |  mad |  31:  MADr r0.xy,-h2, const.xy--, r1.zw--;
     |   SCT1 |  mov |  33:  TXLr h0, r0, const.zzzz, TEX0;
     |    TEX |  txl |  33:  TXLr h0, r0, const.zzzz, TEX0;
     |   SCB1 |  min |  35:  MINh h4.z, h2, h2.--w-;
     |        |      |
  10 |   SCT0 |  mad |  37:  MADr r1.xy, h2, const.xy--, r1.zw--;
     |   SCT1 |  mov |  39:  TXLr h2, r1, const.zzzz, TEX0;
     |    TEX |  txl |  39:  TXLr h2, r1, const.zzzz, TEX0;
     | SCB0/1 |  add |  41:  ADDh/2 h0, h0, h2;
     |        |      |
  11 |   SCT0 |  min |  43:  MINh h2.x, h5.w---, h4.z---;
     |   SCT1 |  max |  42:  MAXh h2.w, h4, h4.---x;
     | SCB0/1 |  add |  44:  ADDh/2 h0, h0, h1;
     |        |      |
  12 |   SCT0 |  set |  45:  SLTh h2.x, h0.w---, h2;
     |   SCT1 |  set |  46:  SGTh h2.w, h0, h2;
     | SCB0/1 |  mul |  47:  MOVh h0, h0;
     |        |      |
  13 |   SCT0 |  mad |  48:  ADDxc0_s rc, h2, h2.w---;
     | SCB0/1 |  mul |  49:  MOVh h0(NE0.xxxx), h1;
 
Pass   SCT  TEX  SCB
  1:   0% 100%  25%
  2:   0% 100%  25%
  3:   0% 100%  50%
  4:   0% 100%  50%
  5:   0%   0%  50%
  6: 100%   0%  75%
  7:   0% 100%  75%
  8:   0% 100% 100%
  9:   0% 100%  25%
 10:   0% 100% 100%
 11:  50%   0% 100%
 12:  50%   0% 100%
 13:  25%   0% 100%

MEAN:  17%  61%  67%

Pass   SCT0  SCT1   TEX  SCB0  SCB1
  1:    0%    0%  100%    0%  100%
  2:    0%    0%  100%    0%  100%
  3:    0%    0%  100%  100%  100%
  4:    0%    0%  100%  100%  100%
  5:    0%    0%    0%  100%  100%
  6:  100%  100%    0%  100%  100%
  7:    0%    0%  100%  100%  100%
  8:    0%    0%  100%  100%  100%
  9:    0%    0%  100%    0%  100%
 10:    0%    0%  100%  100%  100%
 11:  100%  100%    0%  100%  100%
 12:  100%  100%    0%  100%  100%
 13:  100%    0%    0%  100%  100%

MEAN:   30%   23%   61%   76%  100%
Fragment Performance Setup: Driver RSX Compiler, GPU RSX, Flags 0x5
Results 13 cycles, 3 r regs, 923,076,923 pixels/s
============================================================================*/
#if (FXAA_PS3 == 1) && (FXAA_EARLY_EXIT == 0)
/*--------------------------------------------------------------------------*/
#pragma regcount 7
#pragma disablepc all
#pragma option O3
#pragma option OutColorPrec=fp16
#pragma texformat default RGBA8
/*==========================================================================*/
half4 FxaaPixelShader(
    // See FXAA Quality FxaaPixelShader() source for docs on Inputs!
    FxaaFloat2 pos,
    FxaaFloat4 fxaaConsolePosPos,
    FxaaTex tex,
    FxaaTex fxaaConsole360TexExpBiasNegOne,
    FxaaTex fxaaConsole360TexExpBiasNegTwo,
    FxaaFloat2 fxaaQualityRcpFrame,
    FxaaFloat4 fxaaConsoleRcpFrameOpt,
    FxaaFloat4 fxaaConsoleRcpFrameOpt2,
    FxaaFloat4 fxaaConsole360RcpFrameOpt2,
    FxaaFloat fxaaQualitySubpix,
    FxaaFloat fxaaQualityEdgeThreshold,
    FxaaFloat fxaaQualityEdgeThresholdMin,
    FxaaFloat fxaaConsoleEdgeSharpness,
    FxaaFloat fxaaConsoleEdgeThreshold,
    FxaaFloat fxaaConsoleEdgeThresholdMin,
    FxaaFloat4 fxaaConsole360ConstDir
) {
/*--------------------------------------------------------------------------*/
// (1)
    half4 dir;
    half4 lumaNe = h4tex2Dlod(tex, half4(fxaaConsolePosPos.zy, 0, 0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        lumaNe.w += half(1.0/512.0);
        dir.x = -lumaNe.w;
        dir.z = -lumaNe.w;
    #else
        lumaNe.y += half(1.0/512.0);
        dir.x = -lumaNe.y;
        dir.z = -lumaNe.y;
    #endif
/*--------------------------------------------------------------------------*/
// (2)
    half4 lumaSw = h4tex2Dlod(tex, half4(fxaaConsolePosPos.xw, 0, 0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        dir.x += lumaSw.w;
        dir.z += lumaSw.w;
    #else
        dir.x += lumaSw.y;
        dir.z += lumaSw.y;
    #endif        
/*--------------------------------------------------------------------------*/
// (3)
    half4 lumaNw = h4tex2Dlod(tex, half4(fxaaConsolePosPos.xy, 0, 0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        dir.x -= lumaNw.w;
        dir.z += lumaNw.w;
    #else
        dir.x -= lumaNw.y;
        dir.z += lumaNw.y;
    #endif
/*--------------------------------------------------------------------------*/
// (4)
    half4 lumaSe = h4tex2Dlod(tex, half4(fxaaConsolePosPos.zw, 0, 0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        dir.x += lumaSe.w;
        dir.z -= lumaSe.w;
    #else
        dir.x += lumaSe.y;
        dir.z -= lumaSe.y;
    #endif
/*--------------------------------------------------------------------------*/
// (5)
    half4 dir1_pos;
    dir1_pos.xy = normalize(dir.xyz).xz;
    half dirAbsMinTimesC = min(abs(dir1_pos.x), abs(dir1_pos.y)) * half(FXAA_CONSOLE__PS3_EDGE_SHARPNESS);
/*--------------------------------------------------------------------------*/
// (6)
    half4 dir2_pos;
    dir2_pos.xy = clamp(dir1_pos.xy / dirAbsMinTimesC, half(-2.0), half(2.0));
    dir1_pos.zw = pos.xy;
    dir2_pos.zw = pos.xy;
    half4 temp1N;
    temp1N.xy = dir1_pos.zw - dir1_pos.xy * fxaaConsoleRcpFrameOpt.zw;
/*--------------------------------------------------------------------------*/
// (7)
    temp1N = h4tex2Dlod(tex, half4(temp1N.xy, 0.0, 0.0));
    half4 rgby1;
    rgby1.xy = dir1_pos.zw + dir1_pos.xy * fxaaConsoleRcpFrameOpt.zw;
/*--------------------------------------------------------------------------*/
// (8)
    rgby1 = h4tex2Dlod(tex, half4(rgby1.xy, 0.0, 0.0));
    rgby1 = (temp1N + rgby1) * 0.5;
/*--------------------------------------------------------------------------*/
// (9)
    half4 temp2N;
    temp2N.xy = dir2_pos.zw - dir2_pos.xy * fxaaConsoleRcpFrameOpt2.zw;
    temp2N = h4tex2Dlod(tex, half4(temp2N.xy, 0.0, 0.0));
/*--------------------------------------------------------------------------*/
// (10)
    half4 rgby2;
    rgby2.xy = dir2_pos.zw + dir2_pos.xy * fxaaConsoleRcpFrameOpt2.zw;
    rgby2 = h4tex2Dlod(tex, half4(rgby2.xy, 0.0, 0.0));
    rgby2 = (temp2N + rgby2) * 0.5;
/*--------------------------------------------------------------------------*/
// (11)
    // compilier moves these scalar ops up to other cycles
    #if (FXAA_GREEN_AS_LUMA == 0)
        half lumaMin = min(min(lumaNw.w, lumaSw.w), min(lumaNe.w, lumaSe.w));
        half lumaMax = max(max(lumaNw.w, lumaSw.w), max(lumaNe.w, lumaSe.w));
    #else
        half lumaMin = min(min(lumaNw.y, lumaSw.y), min(lumaNe.y, lumaSe.y));
        half lumaMax = max(max(lumaNw.y, lumaSw.y), max(lumaNe.y, lumaSe.y));
    #endif        
    rgby2 = (rgby2 + rgby1) * 0.5;
/*--------------------------------------------------------------------------*/
// (12)
    #if (FXAA_GREEN_AS_LUMA == 0)
        bool twoTapLt = rgby2.w < lumaMin;
        bool twoTapGt = rgby2.w > lumaMax;
    #else
        bool twoTapLt = rgby2.y < lumaMin;
        bool twoTapGt = rgby2.y > lumaMax;
    #endif
/*--------------------------------------------------------------------------*/
// (13)
    if(twoTapLt || twoTapGt) rgby2 = rgby1;
/*--------------------------------------------------------------------------*/
    return rgby2; }
/*==========================================================================*/
#endif



/*============================================================================

       FXAA3 CONSOLE - OPTIMIZED PS3 PIXEL SHADER (WITH EARLY EXIT)

==============================================================================
The code mostly matches the assembly.
I have a feeling that 14 cycles is possible, but was not able to get there.
Might have to increase register count to get full performance.
Note this shader does not use perspective interpolation.

Use the following cgc options,

 --fenable-bx2 --fastmath --fastprecision --nofloatbindings

Use of FXAA_GREEN_AS_LUMA currently adds a cycle (16 clks).
Will look at fixing this for FXAA 3.12.
------------------------------------------------------------------------------
                             NVSHADERPERF OUTPUT
------------------------------------------------------------------------------
For reference and to aid in debug, output of NVShaderPerf should match this,

Shader to schedule:
  0: texpkb h0.w(TRUE), v5.zyxx, #0
  2: addh h2.y(TRUE), h0.w, constant(0.001953, 0.000000, 0.000000, 0.000000).x
  4: texpkb h1.w(TRUE), v5.xwxx, #0
  6: addh h0.x(TRUE), h1.w, -h2.y
  7: texpkb h2.w(TRUE), v5.zwzz, #0
  9: minh h4.w(TRUE), h2.y, h2
 10: maxh h5.x(TRUE), h2.y, h2.w
 11: texpkb h0.w(TRUE), v5, #0
 13: addh h3.w(TRUE), -h0, h0.x
 14: addh h0.x(TRUE), h0.w, h0
 15: addh h0.z(TRUE), -h2.w, h0.x
 16: addh h0.x(TRUE), h2.w, h3.w
 17: minh h5.y(TRUE), h0.w, h1.w
 18: nrmh h2.xz(TRUE), h0_n
 19: minh_m8 h2.w(TRUE), |h2.x|, |h2.z|
 20: divx h4.xy(TRUE), h2_n.xzzw, h2_n.w
 21: movr r1.zw(TRUE), v4.xxxy
 22: maxh h2.w(TRUE), h0, h1
 23: fenct TRUE
 24: madr r0.xy(TRUE), -h2.xzzw, constant(cConst5.x, cConst5.y, cConst5.z, cConst5.w).zwzz, r1.zwzz
 26: texpkb h0(TRUE), r0, #0
 28: maxh h5.x(TRUE), h2.w, h5
 29: minh h5.w(TRUE), h5.y, h4
 30: madr r1.xy(TRUE), h2.xzzw, constant(cConst5.x, cConst5.y, cConst5.z, cConst5.w).zwzz, r1.zwzz
 32: texpkb h2(TRUE), r1, #0
 34: addh_d2 h2(TRUE), h0, h2
 35: texpkb h1(TRUE), v4, #0
 37: maxh h5.y(TRUE), h5.x, h1.w
 38: minh h4.w(TRUE), h1, h5
 39: madr r0.xy(TRUE), -h4, constant(cConst5.x, cConst5.y, cConst5.z, cConst5.w).xyxx, r1.zwzz
 41: texpkb h0(TRUE), r0, #0
 43: addh_m8 h5.z(TRUE), h5.y, -h4.w
 44: madr r2.xy(TRUE), h4, constant(cConst5.x, cConst5.y, cConst5.z, cConst5.w).xyxx, r1.zwzz
 46: texpkb h3(TRUE), r2, #0
 48: addh_d2 h0(TRUE), h0, h3
 49: addh_d2 h3(TRUE), h0, h2
 50: movh h0(TRUE), h3
 51: slth h3.x(TRUE), h3.w, h5.w
 52: sgth h3.w(TRUE), h3, h5.x
 53: addx.c0 rc(TRUE), h3.x, h3
 54: slth.c0 rc(TRUE), h5.z, h5
 55: movh h0(c0.NE.w), h2
 56: movh h0(c0.NE.x), h1

IPU0 ------ Simplified schedule: --------
Pass |  Unit  |  uOp |  PC:  Op
-----+--------+------+-------------------------
   1 | SCT0/1 |  mov |   0:  TXLr h0.w, g[TEX1].zyxx, const.xxxx, TEX0;
     |    TEX |  txl |   0:  TXLr h0.w, g[TEX1].zyxx, const.xxxx, TEX0;
     |   SCB0 |  add |   2:  ADDh h2.y, h0.-w--, const.-x--;
     |        |      |
   2 | SCT0/1 |  mov |   4:  TXLr h1.w, g[TEX1].xwxx, const.xxxx, TEX0;
     |    TEX |  txl |   4:  TXLr h1.w, g[TEX1].xwxx, const.xxxx, TEX0;
     |   SCB0 |  add |   6:  ADDh h0.x, h1.w---,-h2.y---;
     |        |      |
   3 | SCT0/1 |  mov |   7:  TXLr h2.w, g[TEX1].zwzz, const.xxxx, TEX0;
     |    TEX |  txl |   7:  TXLr h2.w, g[TEX1].zwzz, const.xxxx, TEX0;
     |   SCB0 |  max |  10:  MAXh h5.x, h2.y---, h2.w---;
     |   SCB1 |  min |   9:  MINh h4.w, h2.---y, h2;
     |        |      |
   4 | SCT0/1 |  mov |  11:  TXLr h0.w, g[TEX1], const.xxxx, TEX0;
     |    TEX |  txl |  11:  TXLr h0.w, g[TEX1], const.xxxx, TEX0;
     |   SCB0 |  add |  14:  ADDh h0.x, h0.w---, h0;
     |   SCB1 |  add |  13:  ADDh h3.w,-h0, h0.---x;
     |        |      |
   5 |   SCT0 |  mad |  16:  ADDh h0.x, h2.w---, h3.w---;
     |   SCT1 |  mad |  15:  ADDh h0.z,-h2.--w-, h0.--x-;
     |   SCB0 |  min |  17:  MINh h5.y, h0.-w--, h1.-w--;
     |        |      |
   6 |   SCT1 |  mov |  18:  NRMh h2.xz, h0;
     |    SRB |  nrm |  18:  NRMh h2.xz, h0;
     |   SCB1 |  min |  19:  MINh*8 h2.w, |h2.---x|, |h2.---z|;
     |        |      |
   7 |   SCT0 |  div |  20:  DIVx h4.xy, h2.xz--, h2.ww--;
     |   SCT1 |  mov |  21:  MOVr r1.zw, g[TEX0].--xy;
     |   SCB1 |  max |  22:  MAXh h2.w, h0, h1;
     |        |      |
   8 |   SCT0 |  mad |  24:  MADr r0.xy,-h2.xz--, const.zw--, r1.zw--;
     |   SCT1 |  mov |  26:  TXLr h0, r0, const.xxxx, TEX0;
     |    TEX |  txl |  26:  TXLr h0, r0, const.xxxx, TEX0;
     |   SCB0 |  max |  28:  MAXh h5.x, h2.w---, h5;
     |   SCB1 |  min |  29:  MINh h5.w, h5.---y, h4;
     |        |      |
   9 |   SCT0 |  mad |  30:  MADr r1.xy, h2.xz--, const.zw--, r1.zw--;
     |   SCT1 |  mov |  32:  TXLr h2, r1, const.xxxx, TEX0;
     |    TEX |  txl |  32:  TXLr h2, r1, const.xxxx, TEX0;
     | SCB0/1 |  add |  34:  ADDh/2 h2, h0, h2;
     |        |      |
  10 | SCT0/1 |  mov |  35:  TXLr h1, g[TEX0], const.xxxx, TEX0;
     |    TEX |  txl |  35:  TXLr h1, g[TEX0], const.xxxx, TEX0;
     |   SCB0 |  max |  37:  MAXh h5.y, h5.-x--, h1.-w--;
     |   SCB1 |  min |  38:  MINh h4.w, h1, h5;
     |        |      |
  11 |   SCT0 |  mad |  39:  MADr r0.xy,-h4, const.xy--, r1.zw--;
     |   SCT1 |  mov |  41:  TXLr h0, r0, const.zzzz, TEX0;
     |    TEX |  txl |  41:  TXLr h0, r0, const.zzzz, TEX0;
     |   SCB0 |  mad |  44:  MADr r2.xy, h4, const.xy--, r1.zw--;
     |   SCB1 |  add |  43:  ADDh*8 h5.z, h5.--y-,-h4.--w-;
     |        |      |
  12 | SCT0/1 |  mov |  46:  TXLr h3, r2, const.xxxx, TEX0;
     |    TEX |  txl |  46:  TXLr h3, r2, const.xxxx, TEX0;
     | SCB0/1 |  add |  48:  ADDh/2 h0, h0, h3;
     |        |      |
  13 | SCT0/1 |  mad |  49:  ADDh/2 h3, h0, h2;
     | SCB0/1 |  mul |  50:  MOVh h0, h3;
     |        |      |
  14 |   SCT0 |  set |  51:  SLTh h3.x, h3.w---, h5.w---;
     |   SCT1 |  set |  52:  SGTh h3.w, h3, h5.---x;
     |   SCB0 |  set |  54:  SLThc0 rc, h5.z---, h5;
     |   SCB1 |  add |  53:  ADDxc0_s rc, h3.---x, h3;
     |        |      |
  15 | SCT0/1 |  mul |  55:  MOVh h0(NE0.wwww), h2;
     | SCB0/1 |  mul |  56:  MOVh h0(NE0.xxxx), h1;
 
Pass   SCT  TEX  SCB
  1:   0% 100%  25%
  2:   0% 100%  25%
  3:   0% 100%  50%
  4:   0% 100%  50%
  5:  50%   0%  25%
  6:   0%   0%  25%
  7: 100%   0%  25%
  8:   0% 100%  50%
  9:   0% 100% 100%
 10:   0% 100%  50%
 11:   0% 100%  75%
 12:   0% 100% 100%
 13: 100%   0% 100%
 14:  50%   0%  50%
 15: 100%   0% 100%

MEAN:  26%  60%  56%

Pass   SCT0  SCT1   TEX  SCB0  SCB1
  1:    0%    0%  100%  100%    0%
  2:    0%    0%  100%  100%    0%
  3:    0%    0%  100%  100%  100%
  4:    0%    0%  100%  100%  100%
  5:  100%  100%    0%  100%    0%
  6:    0%    0%    0%    0%  100%
  7:  100%  100%    0%    0%  100%
  8:    0%    0%  100%  100%  100%
  9:    0%    0%  100%  100%  100%
 10:    0%    0%  100%  100%  100%
 11:    0%    0%  100%  100%  100%
 12:    0%    0%  100%  100%  100%
 13:  100%  100%    0%  100%  100%
 14:  100%  100%    0%  100%  100%
 15:  100%  100%    0%  100%  100%

MEAN:   33%   33%   60%   86%   80%
Fragment Performance Setup: Driver RSX Compiler, GPU RSX, Flags 0x5
Results 15 cycles, 3 r regs, 800,000,000 pixels/s
============================================================================*/
#if (FXAA_PS3 == 1) && (FXAA_EARLY_EXIT == 1)
/*--------------------------------------------------------------------------*/
#pragma regcount 7
#pragma disablepc all
#pragma option O2
#pragma option OutColorPrec=fp16
#pragma texformat default RGBA8
/*==========================================================================*/
half4 FxaaPixelShader(
    // See FXAA Quality FxaaPixelShader() source for docs on Inputs!
    FxaaFloat2 pos,
    FxaaFloat4 fxaaConsolePosPos,
    FxaaTex tex,
    FxaaTex fxaaConsole360TexExpBiasNegOne,
    FxaaTex fxaaConsole360TexExpBiasNegTwo,
    FxaaFloat2 fxaaQualityRcpFrame,
    FxaaFloat4 fxaaConsoleRcpFrameOpt,
    FxaaFloat4 fxaaConsoleRcpFrameOpt2,
    FxaaFloat4 fxaaConsole360RcpFrameOpt2,
    FxaaFloat fxaaQualitySubpix,
    FxaaFloat fxaaQualityEdgeThreshold,
    FxaaFloat fxaaQualityEdgeThresholdMin,
    FxaaFloat fxaaConsoleEdgeSharpness,
    FxaaFloat fxaaConsoleEdgeThreshold,
    FxaaFloat fxaaConsoleEdgeThresholdMin,
    FxaaFloat4 fxaaConsole360ConstDir
) {
/*--------------------------------------------------------------------------*/
// (1)
    half4 rgbyNe = h4tex2Dlod(tex, half4(fxaaConsolePosPos.zy, 0, 0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        half lumaNe = rgbyNe.w + half(1.0/512.0);
    #else
        half lumaNe = rgbyNe.y + half(1.0/512.0);
    #endif
/*--------------------------------------------------------------------------*/
// (2)
    half4 lumaSw = h4tex2Dlod(tex, half4(fxaaConsolePosPos.xw, 0, 0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        half lumaSwNegNe = lumaSw.w - lumaNe;
    #else
        half lumaSwNegNe = lumaSw.y - lumaNe;
    #endif
/*--------------------------------------------------------------------------*/
// (3)
    half4 lumaNw = h4tex2Dlod(tex, half4(fxaaConsolePosPos.xy, 0, 0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        half lumaMaxNwSw = max(lumaNw.w, lumaSw.w);
        half lumaMinNwSw = min(lumaNw.w, lumaSw.w);
    #else
        half lumaMaxNwSw = max(lumaNw.y, lumaSw.y);
        half lumaMinNwSw = min(lumaNw.y, lumaSw.y);
    #endif
/*--------------------------------------------------------------------------*/
// (4)
    half4 lumaSe = h4tex2Dlod(tex, half4(fxaaConsolePosPos.zw, 0, 0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        half dirZ =  lumaNw.w + lumaSwNegNe;
        half dirX = -lumaNw.w + lumaSwNegNe;
    #else
        half dirZ =  lumaNw.y + lumaSwNegNe;
        half dirX = -lumaNw.y + lumaSwNegNe;
    #endif
/*--------------------------------------------------------------------------*/
// (5)
    half3 dir;
    dir.y = 0.0;
    #if (FXAA_GREEN_AS_LUMA == 0)
        dir.x =  lumaSe.w + dirX;
        dir.z = -lumaSe.w + dirZ;
        half lumaMinNeSe = min(lumaNe, lumaSe.w);
    #else
        dir.x =  lumaSe.y + dirX;
        dir.z = -lumaSe.y + dirZ;
        half lumaMinNeSe = min(lumaNe, lumaSe.y);
    #endif
/*--------------------------------------------------------------------------*/
// (6)
    half4 dir1_pos;
    dir1_pos.xy = normalize(dir).xz;
    half dirAbsMinTimes8 = min(abs(dir1_pos.x), abs(dir1_pos.y)) * half(FXAA_CONSOLE__PS3_EDGE_SHARPNESS);
/*--------------------------------------------------------------------------*/
// (7)
    half4 dir2_pos;
    dir2_pos.xy = clamp(dir1_pos.xy / dirAbsMinTimes8, half(-2.0), half(2.0));
    dir1_pos.zw = pos.xy;
    dir2_pos.zw = pos.xy;
    #if (FXAA_GREEN_AS_LUMA == 0)
        half lumaMaxNeSe = max(lumaNe, lumaSe.w);
    #else
        half lumaMaxNeSe = max(lumaNe, lumaSe.y);
    #endif
/*--------------------------------------------------------------------------*/
// (8)
    half4 temp1N;
    temp1N.xy = dir1_pos.zw - dir1_pos.xy * fxaaConsoleRcpFrameOpt.zw;
    temp1N = h4tex2Dlod(tex, half4(temp1N.xy, 0.0, 0.0));
    half lumaMax = max(lumaMaxNwSw, lumaMaxNeSe);
    half lumaMin = min(lumaMinNwSw, lumaMinNeSe);
/*--------------------------------------------------------------------------*/
// (9)
    half4 rgby1;
    rgby1.xy = dir1_pos.zw + dir1_pos.xy * fxaaConsoleRcpFrameOpt.zw;
    rgby1 = h4tex2Dlod(tex, half4(rgby1.xy, 0.0, 0.0));
    rgby1 = (temp1N + rgby1) * 0.5;
/*--------------------------------------------------------------------------*/
// (10)
    half4 rgbyM = h4tex2Dlod(tex, half4(pos.xy, 0.0, 0.0));
    #if (FXAA_GREEN_AS_LUMA == 0)
        half lumaMaxM = max(lumaMax, rgbyM.w);
        half lumaMinM = min(lumaMin, rgbyM.w);
    #else
        half lumaMaxM = max(lumaMax, rgbyM.y);
        half lumaMinM = min(lumaMin, rgbyM.y);
    #endif
/*--------------------------------------------------------------------------*/
// (11)
    half4 temp2N;
    temp2N.xy = dir2_pos.zw - dir2_pos.xy * fxaaConsoleRcpFrameOpt2.zw;
    temp2N = h4tex2Dlod(tex, half4(temp2N.xy, 0.0, 0.0));
    half4 rgby2;
    rgby2.xy = dir2_pos.zw + dir2_pos.xy * fxaaConsoleRcpFrameOpt2.zw;
    half lumaRangeM = (lumaMaxM - lumaMinM) / FXAA_CONSOLE__PS3_EDGE_THRESHOLD;
/*--------------------------------------------------------------------------*/
// (12)
    rgby2 = h4tex2Dlod(tex, half4(rgby2.xy, 0.0, 0.0));
    rgby2 = (temp2N + rgby2) * 0.5;
/*--------------------------------------------------------------------------*/
// (13)
    rgby2 = (rgby2 + rgby1) * 0.5;
/*--------------------------------------------------------------------------*/
// (14)
    #if (FXAA_GREEN_AS_LUMA == 0)
        bool twoTapLt = rgby2.w < lumaMin;
        bool twoTapGt = rgby2.w > lumaMax;
    #else
        bool twoTapLt = rgby2.y < lumaMin;
        bool twoTapGt = rgby2.y > lumaMax;
    #endif
    bool earlyExit = lumaRangeM < lumaMax;
    bool twoTap = twoTapLt || twoTapGt;
/*--------------------------------------------------------------------------*/
// (15)
    if(twoTap) rgby2 = rgby1;
    if(earlyExit) rgby2 = rgbyM;
/*--------------------------------------------------------------------------*/
    return rgby2; }
/*==========================================================================*/
#endif


================================================
FILE: src/glsl/simple.fragment.glsl
================================================
#ezquake-definitions

uniform vec4 color;
out vec4 frag_color;

void main(void)
{
	frag_color = color;
}


================================================
FILE: src/glsl/simple.vertex.glsl
================================================
#ezquake-definitions

layout(location = 0) in vec2 position;

void main(void)
{
	gl_Position = vec4(position, 0, 1);
}


================================================
FILE: src/glsl/simple3d.fragment.glsl
================================================
#ezquake-definitions

uniform vec4 color;
out vec4 frag_color;

void main(void)
{
	frag_color = color;

#ifdef DRAW_FOG
	frag_color = applyFog(frag_color, gl_FragCoord.z / gl_FragCoord.w);
#endif
}


================================================
FILE: src/glsl/simple3d.vertex.glsl
================================================
#ezquake-definitions

layout(location = 0) in vec3 position;
layout(location = 6) in int _instanceId;

EZ_SSBO_LAYOUT(std140, EZQ_GL_BINDINGPOINT_BRUSHMODEL_DRAWDATA) EZ_SSBO(WorldCvars) {
	WorldDrawInfo drawInfo[EZ_SSBO_ARRAY_SIZE(64)];
};

void main(void)
{
	gl_Position = projectionMatrix * drawInfo[_instanceId].mvMatrix * vec4(position, 1.0);
}


================================================
FILE: src/hash.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifdef SERVERONLY

#include "qwsvdef.h"

#else

#include <stdio.h> // <-- only needed for Hash_BucketStats
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "quakedef.h"
#include "q_shared.h"
#include "hash.h"

#endif

hashtable_t *Hash_InitTable(int numbucks)
{
	hashtable_t *table;

	table = Q_malloc(sizeof(*table));

	table->bucket = (bucket_t**)Q_calloc(numbucks, sizeof(bucket_t *));
	table->numbuckets = numbucks;

	return table;
}

void Hash_ShutdownTable(hashtable_t* table)
{
	int i;

	if (!table) {
		return;
	}

	for (i = 0; i < table->numbuckets; ++i) {
		bucket_t* list = table->bucket[i];

		while (list) {
			bucket_t* next = list->next;
			if (list->flags & HASH_BUCKET_KEYSTRING_OWNED) {
				Q_free(list->keystring);
			}
			Q_free(list);
			list = next;
		}
	}

	Q_free(table->bucket);
	Q_free(table);
}

/* http://www.cse.yorku.ca/~oz/hash.html
 * djb2
 * This algorithm (k=33) was first reported by dan bernstein many years ago
 * in comp.lang.c. another version of this algorithm (now favored by bernstein)
 * uses xor: hash(i) = hash(i - 1) * 33 ^ str[i]; the magic of number 33 (why
 * it works better than many other constants, prime or not) has never been 
 * adequately explained.
 */
int Hash_Key(char *name, int modulus) {
	unsigned int key = 5381;

	for (key = 5381; *name; name++)
		key = ((key << 5) + key) + *name; /* key * 33 + c */

	return (int) (key % modulus);
}

int Hash_KeyInsensitive(const char *name, int modulus) {
	unsigned int key = 5381;

	for (key = 5381; *name; name++)
		key = ((key << 5) + key) + tolower(*name); /* key * 33 + c */

	return (int) (key % modulus);
}

#if 0
int Hash_Key(char *name, int modulus)
{	//fixme: optimize.
	unsigned int key;
	for (key=0;*name; name++)
		key += ((key<<3) + (key>>28) + *name);
		
	return (int)(key%modulus);
}
int Hash_KeyInsensitive(char *name, int modulus)
{	//fixme: optimize.
	unsigned int key;
	for (key=0;*name; name++)
	{
		if (*name >= 'A' && *name <= 'Z')
			key += ((key<<3) + (key>>28) + (*name-'A'+'a'));
		else
			key += ((key<<3) + (key>>28) + *name);
	}
		
	return (int)(key%modulus);
}
#endif

void *Hash_Get(hashtable_t *table, char *name)
{
	int bucknum = Hash_Key(name, table->numbuckets);
	bucket_t *buck;

	buck = table->bucket[bucknum];

	while(buck)
	{
		if (!STRCMP(name, buck->keystring))
			return buck->data;

		buck = buck->next;
	}
	return NULL;
}

void *Hash_GetInsensitive(hashtable_t *table, const char *name)
{
	int bucknum = Hash_KeyInsensitive(name, table->numbuckets);
	bucket_t *buck;

	buck = table->bucket[bucknum];

	while(buck)
	{
		if (!strcasecmp(name, buck->keystring))
			return buck->data;

		buck = buck->next;
	}
	return NULL;
}

void *Hash_GetKey(hashtable_t *table, char *key)
{
	int bucknum = ((uintptr_t) key) % table->numbuckets;
	bucket_t *buck;

	buck = table->bucket[bucknum];

	while(buck)
	{
		if (buck->keystring == key)
			return buck->data;

		buck = buck->next;
	}
	return NULL;
}

void *Hash_GetNext(hashtable_t *table, char *name, void *old)
{
	int bucknum = Hash_Key(name, table->numbuckets);
	bucket_t *buck;

	buck = table->bucket[bucknum];

	while(buck)
	{
		if (!STRCMP(name, buck->keystring))
		{
			if (buck->data == old)	//found the old one
				break;
		}

		buck = buck->next;
	}
	if (!buck)
		return NULL;

	buck = buck->next;//don't return old
	while(buck)
	{
		if (!STRCMP(name, buck->keystring))
			return buck->data;

		buck = buck->next;
	}
	return NULL;
}

void *Hash_GetNextInsensitive(hashtable_t *table, char *name, void *old)
{
	int bucknum = Hash_KeyInsensitive(name, table->numbuckets);
	bucket_t *buck;

	buck = table->bucket[bucknum];

	while(buck)
	{
		if (!STRCMP(name, buck->keystring))
		{
			if (buck->data == old)	//found the old one
				break;
		}

		buck = buck->next;
	}
	if (!buck)
		return NULL;

	buck = buck->next;//don't return old
	while(buck)
	{
		if (!STRCMP(name, buck->keystring))
			return buck->data;

		buck = buck->next;
	}
	return NULL;
}

void *Hash_Add(hashtable_t *table, char *name, void *data) 
{
	int bucknum = Hash_Key(name, table->numbuckets);

	bucket_t *buck = (bucket_t *) Q_malloc(sizeof(bucket_t));
	char *keystring = Q_strdup(name);

	buck->data = data;
	buck->keystring = keystring;
	buck->next = table->bucket[bucknum];
	buck->flags = HASH_BUCKET_KEYSTRING_OWNED;
	table->bucket[bucknum] = buck;

	return buck;
}

void *Hash_AddInsensitive(hashtable_t *table, char *name, void *data) 
{
	int bucknum = Hash_KeyInsensitive(name, table->numbuckets);

	bucket_t *buck = (bucket_t *) Q_malloc(sizeof(bucket_t));
	char *keystring = Q_strdup(name);

	buck->data = data;
	buck->keystring = keystring;
	buck->next = table->bucket[bucknum];
	buck->flags = HASH_BUCKET_KEYSTRING_OWNED;
	table->bucket[bucknum] = buck;

	return buck;
}

void *Hash_AddKey(hashtable_t *table, char *key, void *data, bucket_t *buck)
{
	int bucknum = ((uintptr_t) key) % table->numbuckets;

	buck->data = data;
	buck->keystring = key;
	buck->next = table->bucket[bucknum];
	table->bucket[bucknum] = buck;

	return buck;
}

void Hash_Remove(hashtable_t *table, char *name)
{
	int bucknum = Hash_Key(name, table->numbuckets);
	bucket_t *buck, *to_remove;

	buck = table->bucket[bucknum];

	if (!STRCMP(name, buck->keystring))
	{
		table->bucket[bucknum] = buck->next;
		Q_free(buck->keystring);
		Q_free(buck);
		return;
	}


	while(buck->next)
	{
		if (!STRCMP(name, buck->next->keystring))
		{
			to_remove = buck->next;
			buck->next = to_remove->next;
			Q_free(to_remove->keystring);
			Q_free(to_remove);
			return;
		}

		buck = buck->next;
	}
	return;
}

void Hash_RemoveData(hashtable_t *table, char *name, void *data)
{
	int bucknum = Hash_Key(name, table->numbuckets);
	bucket_t *buck;	

	buck = table->bucket[bucknum];

	if (buck->data == data)
		if (!STRCMP(name, buck->keystring))
		{
			table->bucket[bucknum] = buck->next;
			Q_free(buck->keystring);
			Q_free(buck);
			return;
		}


	while(buck->next)
	{
		if (buck->next->data == data)
			if (!STRCMP(name, buck->next->keystring))
			{
				buck->next = buck->next->next;
				Q_free(buck->next->keystring);
				Q_free(buck->next);
				return;
			}

		buck = buck->next;
	}
	return;
}

void Hash_RemoveKey(hashtable_t *table, char *key)
{
	int bucknum = ((uintptr_t) key) % table->numbuckets;
	bucket_t *buck, *to_remove;

	buck = table->bucket[bucknum];

	if (buck->keystring == key)
	{
		table->bucket[bucknum] = buck->next;
		Q_free(buck->keystring);
		Q_free(buck);
		return;
	}


	while(buck->next)
	{
		if (buck->next->keystring == key)
		{
			to_remove = buck->next;
			buck->next = to_remove->next;
			Q_free(to_remove->keystring);
			Q_free(to_remove);
			return;
		}

		buck = buck->next;
	}
	return;
}

void Hash_Flush(hashtable_t *table) 
{
	int i;
	for (i = 0; i < table->numbuckets; i++)
	{
		bucket_t *bucket, *next;
		bucket = table->bucket[i];
		table->bucket[i] = NULL;
		
		while (bucket)
		{
			next = bucket->next;
			Q_free(bucket->keystring);
			Q_free(bucket);
			bucket = next;
		}
	}
	return;
}

#if 0
void Hash_BucketStats(hashtable_t *table)
{
	int i;
	bucket_t *buck;	
	int bucket_count;

	for (i = 0; i < table->numbuckets; i++) {
		bucket_count = 0;
		for (buck = table->bucket[i]; buck; buck = buck->next) {
			bucket_count++;
		}
		printf("table[%d] = %d\n", i, bucket_count);
	}
}
#endif


================================================
FILE: src/hash.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
//=============================
//David's hash tables
//string based.

#ifndef __HASH_H__
#define __HASH_H__

#define STRCMP(s1,s2) (((*s1)!=(*s2)) || strcmp(s1+1,s2+1))	//saves about 2-6 out of 120 - expansion of idea from fastqcc
typedef struct bucket_s {
	void *data;
	char *keystring;
	struct bucket_s *next;
	int flags;
} bucket_t;

#define HASH_BUCKET_KEYSTRING_OWNED 1

typedef struct hashtable_s {
	int numbuckets;
	bucket_t **bucket;
} hashtable_t;

hashtable_t *Hash_InitTable(int numbucks);
void Hash_ShutdownTable(hashtable_t* table);

int Hash_Key(char *name, int modulus);
void *Hash_Get(hashtable_t *table, char *name);
void *Hash_GetInsensitive(hashtable_t *table, const char *name);
void *Hash_GetKey(hashtable_t *table, char *key);
void *Hash_GetNext(hashtable_t *table, char *name, void *old);
void *Hash_GetNextInsensitive(hashtable_t *table, char *name, void *old);
void *Hash_Add(hashtable_t *table, char *name, void *data); 
void *Hash_AddInsensitive(hashtable_t *table, char *name, void *data); 
void Hash_Remove(hashtable_t *table, char *name);
void Hash_RemoveData(hashtable_t *table, char *name, void *data);
void Hash_RemoveKey(hashtable_t *table, char *key);
void *Hash_AddKey(hashtable_t *table, char *key, void *data, bucket_t *buck);
void Hash_Flush(hashtable_t *table);

#if 0
/* Print some stats on the bucket distrubution */
void Hash_BucketStats(hashtable_t *table);
#endif

#endif // __HASH_H__


================================================
FILE: src/help.c
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: help.c,v 1.16 2007-09-30 22:59:23 disconn3ct Exp $
*/

/*
 * Variables and commands help system
 */

// for QuakeWorld Tutorial menu, look into help_files.c

#include "quakedef.h"
#include <jansson.h>

extern void CharsToBrown(char*, char*);
extern char* CharsToBrownStatic(char* in);

typedef enum {
	t_boolean,
	t_enum,         // "value1, value2, value_wih_spaces"
	t_integer,      // "min max"
	t_float,        // "min max"
	t_string,       // "max length"
	t_unknown       // (missing from docs)
} cvartype_t;

enum {
	helpdoc_variables,
	helpdoc_commands,
	helpdoc_cmdlineparams,
	helpdoc_macros,

	helpdoc_count
};

#define CONSOLE_HELP_MARGIN 2
static json_t* document_root[helpdoc_count];

typedef struct json_variable_s
{
	const char *name;
	const char *default_value;
	const char *description;
	int value_type;
	const json_t* values;
	const char *remarks;
	const char* group_id;
	json_t* json;
} json_variable_t;

typedef struct json_command_s
{
	const char *name;
	const char *description;
	const char *syntax;
	const json_t* arguments;
	const char *remarks;
} json_command_t;

typedef struct json_mapping_s {
	const char* name;
	int value;
} json_mapping_t;

static json_mapping_t variabletype_mappings[] = {
	{ "string", t_string },
	{ "integer", t_integer },
	{ "float", t_float },
	{ "boolean", t_boolean },
	{ "bool", t_boolean },
	{ "enum", t_enum }
};

#define CMDLINEPARAM_FLAGS_NONE       0
#define CMDLINEPARAM_FLAGS_INCOMPLETE 1

static json_mapping_t cmdlineparam_flags_mappings[] = {
	{ "incomplete", CMDLINEPARAM_FLAGS_INCOMPLETE }
};

#define CMDLINEPARAM_BUILDS_DEBUG     1
#define CMDLINEPARAM_BUILDS_RELEASE   2
#define CMDLINEPARAM_BUILDS_ALL       (CMDLINEPARAM_BUILDS_DEBUG | CMDLINEPARAM_BUILDS_RELEASE)

static json_mapping_t cmdlineparam_build_mappings[] = {
	{ "debug", CMDLINEPARAM_BUILDS_DEBUG },
	{ "release", CMDLINEPARAM_BUILDS_RELEASE }
};

#define CMDLINEPARAM_SYSTEMS_WINDOWS  1
#define CMDLINEPARAM_SYSTEMS_LINUX    2
#define CMDLINEPARAM_SYSTEMS_OSX      4
#define CMDLINEPARAM_SYSTEMS_ALL      (CMDLINEPARAM_SYSTEMS_WINDOWS | CMDLINEPARAM_SYSTEMS_LINUX | CMDLINEPARAM_SYSTEMS_OSX)

static json_mapping_t cmdlineparam_systems_mappings[] = {
	{ "windows", CMDLINEPARAM_SYSTEMS_WINDOWS },
	{ "linux", CMDLINEPARAM_SYSTEMS_LINUX },
	{ "osx", CMDLINEPARAM_SYSTEMS_OSX }
};

typedef struct json_cmdlineparam_s {
	const char* name;
	const char* description;
	const char* remarks;
	int systems;
	int builds;
	int flags;
	const char* arguments;
} json_cmdlineparam_t;

#define MACROS_FLAGS_NONE             0
#define MACROS_FLAGS_SPECTATORONLY    1

static json_mapping_t macros_flags_mappings[] = {
	{ "spectator-only", MACROS_FLAGS_SPECTATORONLY }
};

typedef struct json_macro_s {
	const char* name;
	const char* description;
	const char* remarks;
	const char* type;
	const json_t* related_cvars;
	int flags;

	json_t* json;
} json_macro_t;

#define HelpReadBitField(json, array_name, default_value, mappings) (JSON_ReadBitField(json_object_get(json, array_name), default_value, mappings, sizeof(mappings) / sizeof(mappings[0])))

static qbool JSON_MapValue(const char* string, json_mapping_t* mappings, int mapping_count, int* value)
{
	int i;

	if (string && string[0]) {
		for (i = 0; i < mapping_count; ++i) {
			if (!strcmp(string, mappings[i].name)) {
				*value = mappings[i].value;
				return true;
			}
		}
	}

	return false;
}

static int JSON_ReadBitField(const json_t* arr, int empty_value, json_mapping_t* mappings, int mapping_count)
{
	if (!json_is_array(arr)) {
		if (json_is_string(arr)) {
			int result = 0;

			if (JSON_MapValue(json_string_value(arr), mappings, mapping_count, &result)) {
				return result;
			}

			// error: name not valid
			return empty_value;
		}
		// else error: specified but not string|array
		return empty_value;
	}
	else if (json_array_size(arr) == 0) {
		return empty_value;
	}
	else {
		size_t index;
		const json_t* value;
		int result = 0;

		json_array_foreach(arr, index, value)
		{
			if (json_is_string(value)) {
				const char* stringvalue = json_string_value(value);
				int flagvalue = 0;

				if (JSON_MapValue(stringvalue, mappings, mapping_count, &flagvalue)) {
					result |= flagvalue;
				}
				// else error: string not valid
			}
			// else error: expected string
		}

		return result;
	}
}

static void Help_DescribeCmd(const json_command_t *cmd)
{
	if (!cmd) 
		return;

    // description
    con_margin = CONSOLE_HELP_MARGIN;
    Com_Printf("%s\n", cmd->description);
    con_margin = 0;

    // syntax
    Com_Printf("\n");
	if (cmd->syntax) {
		con_ormask = 128;
		Com_Printf ("syntax\n");
		con_ormask = 0;
		con_margin = CONSOLE_HELP_MARGIN;
		Com_Printf ("%s %s\n", cmd->name, cmd->syntax);
		con_margin = 0;
	}

    // arguments
    if (cmd->arguments)
    {
		size_t i = 0;
		size_t argCount = json_array_size(cmd->arguments);

        Com_Printf("\n");
        con_ormask = 128;
        Com_Printf("arguments\n");
        con_ormask = 0;

		for (i = 0; i < argCount; ++i) { 
			json_t* arg = json_array_get(cmd->arguments, i);

            con_ormask = 128;
            con_margin = CONSOLE_HELP_MARGIN;
            Com_Printf("%s", json_string_value(json_object_get(arg, "name")));
            con_ormask = 0;
            con_margin += CONSOLE_HELP_MARGIN;
            Com_Printf(" - %s\n", json_string_value(json_object_get(arg, "description")));
            con_margin = 0;
        }
    }

    // remarks
    if (cmd->remarks)
    {
        Com_Printf("\n");
        con_ormask = 128;
        Com_Printf("remarks\n");
        con_ormask = 0;
        con_margin = CONSOLE_HELP_MARGIN;
        Com_Printf("%s\n", cmd->remarks);
        con_margin = 0;
    }
}

static void Help_DescribeVar(const json_variable_t *var)
{
	if (!var) 
		return;

	// description
	if (var->description && strlen(var->description))
	{
		con_margin = CONSOLE_HELP_MARGIN;
		Com_Printf("%s\n", var->description);
		con_margin = 0;
	}

    // value
	if (var->values)
	{
		size_t valueCount = json_array_size(var->values);
		size_t i = 0;

		Com_Printf("\n");
		con_ormask = 128;
		Com_Printf("values\n");
		con_ormask = 0;
		con_margin = CONSOLE_HELP_MARGIN;
		for (i = 0; i < valueCount; ++i) {
			const json_t* value       = json_array_get(var->values, i);
			const char*   name        = json_string_value(json_object_get(value, "name"));
			const char*   description = json_string_value(json_object_get(value, "description"));
			// if value is *, just show basic description
			if (strcmp(name, "*")) {
				con_ormask = 128;
				if (var->value_type == t_boolean && !strcmp(name, "false")) {
					Com_Printf("0");
				}
				else if (var->value_type == t_boolean && !strcmp(name, "true")) {
					Com_Printf("1");
				}
				else {
					Com_Printf("%s", name);
				}
				con_ormask = 0;
				con_margin += CONSOLE_HELP_MARGIN;
				Com_Printf(" - %s\n", description);
				con_margin -= CONSOLE_HELP_MARGIN;
			}
			else {
				Com_Printf("%s\n", description);
			}
		}
		con_margin = 0;
	}
	else if (var->value_type == t_boolean)
	{
		con_margin += CONSOLE_HELP_MARGIN;
		Com_Printf("Boolean value. Use ");
		con_ormask = 128;
		Com_Printf("0 or 1");
		con_ormask = 0;
		Com_Printf(" as a value.\n");
		con_margin -= CONSOLE_HELP_MARGIN;
	}

    // remarks
	if (var->remarks && strlen(var->remarks))
    {
        Com_Printf("\n");
        con_ormask = 128;
        Com_Printf("remarks\n");
        con_ormask = 0;
        con_margin = CONSOLE_HELP_MARGIN;
        Com_Printf("%s\n", var->remarks);
        con_margin = 0;
    }
}

static void Help_DescribeMacro(const json_macro_t* macro)
{
	if (!macro) {
		return;
	}

	// description
	if (macro->description && strlen(macro->description)) {
		con_margin = CONSOLE_HELP_MARGIN;
		Com_Printf("%s\n", macro->description);
		con_margin = 0;
	}

	// value
	if (macro->type && strlen(macro->type)) {
		con_ormask = 128;
		Com_Printf("Type: ");
		con_ormask = 0;

		Com_Printf("%s\n", macro->type);
	}

	// remarks
	if ((macro->remarks && macro->remarks[0]) || macro->flags) {
		Com_Printf("\n");
		con_ormask = 128;
		Com_Printf("remarks\n");
		con_ormask = 0;
		con_margin = CONSOLE_HELP_MARGIN;
		if (macro->flags & MACROS_FLAGS_SPECTATORONLY) {
			Com_Printf("Limited to spectator mode only\n");
		}
		if (macro->remarks && macro->remarks[0]) {
			Com_Printf("%s\n", macro->remarks);
		}
		con_margin = 0;
	}

	if (macro->related_cvars) {
		int i;
		const json_t* cvar;

		Com_Printf("\n");
		con_ormask = 128;
		Com_Printf("related cvars:\n");
		con_ormask = 0;
		con_margin = CONSOLE_HELP_MARGIN;
		json_array_foreach(macro->related_cvars, i, cvar) {
			if (json_is_string(cvar)) {
				Com_Printf("%s\n", json_string_value(cvar));
			}
		}
		con_margin = 0;
	}
}

static void Help_DescribeCommandLineParam(const json_cmdlineparam_t* param)
{
	qbool system_comment = false;

	if (!param) {
		return;
	}

#if defined(_WIN32)
	system_comment = !(param->systems & CMDLINEPARAM_SYSTEMS_WINDOWS);
#elif defined(__APPLE__)
	system_comment = !(param->systems & CMDLINEPARAM_SYSTEMS_OSX);
#else
	system_comment = !(param->systems & CMDLINEPARAM_SYSTEMS_LINUX);
#endif

	// description
	if (param->description && strlen(param->description)) {
		con_margin = CONSOLE_HELP_MARGIN;
		Com_Printf("%s\n", param->description);
		con_margin = 0;
	}

	if (param->arguments && param->arguments[0]) {
		Com_Printf("\n");
		con_ormask = 128;
		Com_Printf("arguments: ");
		con_ormask = 0;
		Com_Printf("%s\n", param->arguments);
	}

	// remarks
	if ((param->remarks && param->remarks[0]) || param->flags || system_comment) {
		Com_Printf("\n");
		con_ormask = 128;
		Com_Printf("remarks\n");
		con_ormask = 0;
		con_margin = CONSOLE_HELP_MARGIN;
		if (system_comment) {
			Com_Printf("(not supported on this operating system)\n");
		}
		if (param->flags & CMDLINEPARAM_FLAGS_INCOMPLETE) {
			Com_Printf("(this documentation is flagged as incomplete)\n");
		}
		if (param->remarks && param->remarks[0]) {
			Com_Printf("%s\n", param->remarks);
		}
		con_margin = 0;
	}
}

static const json_command_t* JSON_Command_Load(const char* name)
{
	static json_command_t result;
	const json_t* command = NULL;

	command = json_object_get(document_root[helpdoc_commands], name);
	if (command == NULL)
		return NULL;

	memset(&result, 0, sizeof(result));
	result.name = name;
	result.description = json_string_value(json_object_get(command, "description"));
	result.syntax = json_string_value(json_object_get(command, "syntax"));
	result.remarks = json_string_value(json_object_get(command, "remarks"));
	result.arguments = json_object_get(command, "arguments");
	if (!json_is_array(result.arguments))
		result.arguments = NULL;

	return &result;
}

static const json_variable_t* JSON_Variable_Load(const char* name)
{
	static json_variable_t result;
	const json_t* varsObj = NULL;
	json_t* variable = NULL;
	const char* variableType = NULL;

	varsObj = json_object_get(document_root[helpdoc_variables], "vars");
	if (varsObj == NULL) {
		return NULL;
	}

	variable = json_object_get(varsObj, name);
	if (variable == NULL) {
		return NULL;
	}
	variableType = json_string_value(json_object_get(variable, "type"));

	memset(&result, 0, sizeof(result));
	result.default_value = json_string_value(json_object_get(variable, "default"));
	result.description = json_string_value(json_object_get(variable, "desc"));
	result.name = name;
	result.remarks = json_string_value(json_object_get(variable, "remarks"));
	if (!JSON_MapValue(variableType, variabletype_mappings, sizeof(variabletype_mappings) / sizeof(variabletype_mappings[0]), &result.value_type)) {
		result.value_type = t_unknown;
	}
	result.values = json_object_get(variable, "values");
	if (!json_is_array(result.values)) {
		result.values = NULL;
	}
	result.group_id = json_string_value(json_object_get(variable, "group_id"));
	result.json = variable;

	return &result;
}

const json_cmdlineparam_t* JSON_CommandLineParam_Load(const char* name)
{
	static json_cmdlineparam_t result;
	const json_t* json = NULL;

	json = json_object_get(document_root[helpdoc_cmdlineparams], name);
	if (json == NULL) {
		return NULL;
	}

	memset(&result, 0, sizeof(result));
	result.name = name;
	result.description = json_string_value(json_object_get(json, "description"));
	result.remarks = json_string_value(json_object_get(json, "remarks"));
	result.builds = HelpReadBitField(json, "builds", CMDLINEPARAM_BUILDS_ALL, cmdlineparam_build_mappings);
	result.systems = HelpReadBitField(json, "systems", CMDLINEPARAM_SYSTEMS_ALL, cmdlineparam_systems_mappings);
	result.flags = HelpReadBitField(json, "flags", CMDLINEPARAM_FLAGS_NONE, cmdlineparam_flags_mappings);
	result.arguments = json_string_value(json_object_get(json, "arguments"));

	return &result;
}

const json_macro_t* JSON_Macro_Load(const char* name)
{
	static json_macro_t result;
	json_t* json = NULL;

	json = json_object_get(document_root[helpdoc_macros], name);
	if (json == NULL) {
		return NULL;
	}

	memset(&result, 0, sizeof(result));
	result.name = name;
	result.description = json_string_value(json_object_get(json, "description"));
	result.remarks = json_string_value(json_object_get(json, "remarks"));
	result.flags = HelpReadBitField(json, "flags", 0, macros_flags_mappings);
	result.related_cvars = json_object_get(json, "related-cvars");
	if (!json_is_array(result.related_cvars) || json_array_size(result.related_cvars) == 0) {
		result.related_cvars = NULL;
	}
	result.json = json;

	return &result;
}

void Help_DescribeCvar (cvar_t *v)
{
	Help_DescribeVar(JSON_Variable_Load(v->name));
}

void Help_VarDescription (const char *varname, char* buf, size_t bufsize)
{
	extern cvar_t menu_advanced;
	const json_variable_t *var;

	var = JSON_Variable_Load (varname);
	
	if(menu_advanced.integer && strlen(varname)){
		strlcat(buf, CharsToBrownStatic("Variable Name: "), bufsize);
		strlcat(buf, varname, bufsize);
		strlcat(buf, "\n", bufsize);

		if (var->default_value) {
			strlcat(buf, CharsToBrownStatic("Default: "), bufsize);
			strlcat(buf, var->default_value, bufsize);
			strlcat(buf, "\n", bufsize);
		}
	}
	
	if (!var)
		return;

	if (var->description && strlen (var->description) > 1) {
		strlcat (buf, var->description, bufsize);
		strlcat (buf, "\n", bufsize);
	}

	if (var->values)
	{
		size_t valueCount = json_array_size(var->values);
		size_t i = 0;

		strlcat (buf, "\n", bufsize);
		strlcat (buf, CharsToBrownStatic("values"), bufsize);
		strlcat (buf, "\n", bufsize);
		for (i = 0; i < valueCount; ++i) {
			const json_t* value = json_array_get(var->values, i);
			const char*   name = json_string_value(json_object_get(value, "name"));
			const char*   description = json_string_value(json_object_get(value, "description"));

			switch (var->value_type)
			{
			case t_string:
			case t_integer:
			case t_float:
				strlcat (buf, description, bufsize);
				strlcat (buf, "\n", bufsize);
				break;
			case t_boolean:
			case t_enum:
			default:
				if (var->value_type == t_boolean && !strcmp(name, "false"))
					strlcat (buf, CharsToBrownStatic("0"), bufsize);
				else if (var->value_type == t_boolean && !strcmp(name, "true"))
					strlcat (buf, CharsToBrownStatic("1"), bufsize);
				else
					strlcat (buf, CharsToBrownStatic((char*)name), bufsize);

				strlcat (buf, " - ", bufsize);
				strlcat (buf, description, bufsize);
				strlcat (buf, "\n", bufsize);
				break;
			}
		}
	}

	if (var->remarks) {
		strlcat(buf, CharsToBrownStatic("remarks"), bufsize);
		strlcat(buf, "\n", bufsize);
		strlcat(buf, var->remarks, bufsize);
		strlcat(buf, "\n", bufsize);
	}
}

static void Help_UnloadDocument(json_t** root)
{
	if (*root != NULL) {
		json_decref(*root);
		*root = NULL;
	}
}

static void Help_UnloadDocuments(void)
{
	int i;

	for (i = 0; i < helpdoc_count; ++i) {
		Help_UnloadDocument(&document_root[i]);
	}
}

#define DeclareHelpDocument(id, docname) \
{ \
	extern unsigned char docname ## _json[]; \
	extern unsigned int docname ## _json_len; \
\
	document_names[helpdoc_ ## id] = #docname; \
	document_content[helpdoc_ ## id] = docname ## _json; \
	document_length[helpdoc_ ## id] = docname ## _json_len; \
}

static void Help_LoadDocuments(void)
{
	json_error_t error;
	const char* document_names[helpdoc_count] = { 0 };
	unsigned char* document_content[helpdoc_count] = { 0 };
	unsigned int document_length[helpdoc_count] = { 0 };
	int i;

	DeclareHelpDocument(macros, help_macros)
	DeclareHelpDocument(commands, help_commands)
	DeclareHelpDocument(variables, help_variables)
	DeclareHelpDocument(cmdlineparams, help_cmdline_params)

	for (i = 0; i < helpdoc_count; ++i) {
		Help_UnloadDocument(&document_root[i]);

		document_root[i] = json_loadb((char*)document_content[i], document_length[i], 0, &error);
		if (document_root[i] == NULL) {
			Com_Printf("\020%s\021: JSON error on line %d: %s\n", document_names[i], error.line, error.text);
		}
		else if (!json_is_object(document_root[i])) {
			Com_Printf("\020%s\021: invalid JSON, root is not an object\n", document_names[i]);
			Help_UnloadDocument(&document_root[i]);
		}
	}
}

void Help_Describe_f(void)
{
    qbool found = false;
    char *name;

    if (Cmd_Argc() != 2)
    {
        Com_Printf("usage: /describe <command|variable>\ne.g. /describe ignore\n");
        return;
    }

    name = Cmd_Argv(1);
    
    // check for command
	{
		const json_command_t* cmd = JSON_Command_Load(name);
		if (cmd) {
			found = true;

			// name
			con_ormask = 128;
			Com_Printf("%s is a command\n", cmd->name);
			con_ormask = 0;

			Help_DescribeCmd(cmd);
		}
	}

    // check for variable
	{
		const json_variable_t* var = JSON_Variable_Load(name);
		if (var) {
			if (found) {
				Com_Printf("\n\n\n");
			}
			found = true;

			// name
			con_ormask = 128;
			Com_Printf("%s is a variable\n", var->name);
			con_ormask = 0;

			Help_DescribeVar(var);
		}
	}

	// check for macro
	{
		const json_macro_t* macro = JSON_Macro_Load(name);
		if (macro) {
			if (found) {
				Com_Printf("\n\n\n");
			}
			found = true;

			// name
			con_ormask = 128;
			Com_Printf("%s is a macro\n", macro->name);
			con_ormask = 0;

			Help_DescribeMacro(macro);
		}
	}

	// check for commandline arg
	{
		const json_cmdlineparam_t* param = JSON_CommandLineParam_Load(name);
		if (param) {
			if (found) {
				Com_Printf("\n\n\n");
			}
			found = true;

			// name
			con_ormask = 128;
			Com_Printf("%s is a command-line parameter\n", param->name);
			con_ormask = 0;

			Help_DescribeCommandLineParam(param);
		}
	}

    // if not found
	if (!found) {
		Com_Printf("Nothing found.\n");
	}
}

static qbool Help_VariableIgnoreByCvar(cvar_t* cvar)
{
	if (Cvar_GetFlags(cvar) & CVAR_USER_CREATED) {
		return true;
	}

	// don't expect complete documentation right now (tighten this in future)
	return (!strncmp(cvar->name, "hud_", 4) || !strncmp(cvar->name, "sv_", 3));
}

static qbool Help_VariableIgnoreByGroup(const json_variable_t* var, const json_t* groupsObj)
{
	// ignore documentation for server variables (tighten this in future)
	{
		const char* group_id = var->group_id;
		int i;

		for (i = 0; i < json_array_size(groupsObj); ++i) {
			const char* id = json_string_value(json_object_get(json_array_get(groupsObj, i), "id"));
			const char* major_group = json_string_value(json_object_get(json_array_get(groupsObj, i), "major-group"));

			if (id && group_id && !strcmp(id, group_id) && major_group) {
				if (!strcmp(major_group, "Server") || !strcmp(major_group, "Obselete")) {
					return true;
				}
			}
		}
	}

	return false;
}

// Check all variable values against help files
static void Help_VerifyConfig_f(void)
{
	json_t* varsObj = NULL;
	int num_errors = 0;
	const char* name = NULL;
	json_t* variable = NULL;

	if (!document_root[helpdoc_variables]) {
		return;
	}

	varsObj = json_object_get(document_root[helpdoc_variables], "vars");
	if (!varsObj) {
		return;
	}

	json_object_foreach(varsObj, name, variable)
	{
		cvar_t* cvar        = Cvar_Find(name);
		const char* type    = json_string_value(json_object_get(variable, "type"));
		json_t* examples    = json_object_get(variable, "values");
		size_t num_examples = json_is_array(examples) ? json_array_size(examples) : 0;

		// obsolete cvars might be in documentation so people can see notes using /describe
		if (cvar == NULL) {
			continue;
		}

		if (!strcmp("boolean", type) && cvar->value != 0 && cvar->value != 1) {
			con_ormask = 128;
			Com_Printf ("%s", name);
			con_ormask = 0;
			Com_Printf(": boolean, value %f\n", cvar->value);
			++num_errors;
		}
		else if (!strcmp("enum", type) && num_examples > 0) {
			qbool found = false;
			int i;

			for (i = 0; i < num_examples; ++i) {
				const json_t* value = json_array_get(examples, i);
				const char*   name = json_string_value(json_object_get(value, "name"));

				found |= !strcmp(name, cvar->string);
			}

			if (!found) {
				con_ormask = 128;
				Con_Printf("%s", name);
				con_ormask = 0;
				Con_Printf(": enum, value %s\n", cvar->string);
			}
		}
	}

	Con_Printf("%d variables with values that don't match documentation.\n", num_errors);
}

static void Help_FindConsoleVariableIssues(qbool generate)
{
	extern cvar_t* cvar_vars;
	cvar_t* cvar;

	int num_errors = 0;
	const json_variable_t* jsonVar;
	const json_t* groupsJsonObj = json_object_get(document_root[helpdoc_variables], "groups");
	json_t* variableJsonObj = json_object_get(document_root[helpdoc_variables], "vars");

	if (!variableJsonObj) {
		Con_Printf("'vars' missing from help_variables.json\n");
		return;
	}

	if (!groupsJsonObj) {
		Con_Printf("'Groups' missing from help_variables.json\n");
		return;
	}

	if (!generate) {
		Con_Printf("Variables with issues:\n");
		con_margin = CONSOLE_HELP_MARGIN;
	}

	for (cvar = cvar_vars; cvar; cvar = cvar->next) {
		if (Help_VariableIgnoreByCvar(cvar)) {
			continue;
		}

		jsonVar = JSON_Variable_Load(cvar->name);
		if (!jsonVar) {
			if (generate) {
				json_t* obj = json_object();
				json_object_set(obj, "group-id", json_string("0"));
				json_object_set(obj, "system-generated", json_boolean(1));
				json_object_set_new(obj, "default", json_string(cvar->defaultvalue));
				json_object_set_new(variableJsonObj, cvar->name, obj);
				++num_errors;
			}
			else {
				con_ormask = 128;
				Con_Printf("%s", cvar->name);
				con_ormask = 0;
				Con_Printf(": missing from help\n", cvar->name);
				++num_errors;
			}
			continue;
		}

		if (generate) {
			json_object_set_new(jsonVar->json, "default", json_string(cvar->defaultvalue));
			continue;
		}

		if (Help_VariableIgnoreByGroup(jsonVar, groupsJsonObj)) {
			continue;
		}

		{
			const char* desc = jsonVar->description;
			qbool valid_desc = (desc && desc[0]);
			qbool valid_type, enum_without_examples;
			size_t num_examples;

			valid_type = (jsonVar->value_type != t_unknown);
			num_examples = jsonVar->values ? json_array_size(jsonVar->values) : 0;
			enum_without_examples = (jsonVar->value_type == t_enum && num_examples == 0);
			if (!valid_type || !(valid_desc || num_examples) || enum_without_examples) {
				con_ormask = 128;
				Con_Printf("%s", cvar->name);
				con_ormask = 0;
				Con_Printf(":");
				if (!valid_type) {
					Con_Printf("invalid type");
				}
				else if (enum_without_examples) {
					Con_Printf("invalid examples for enum");
				}
				else if (!valid_desc && num_examples == 0) {
					Con_Printf("invalid description/examples");
				}
				else if (!valid_desc) {
					Con_Printf("invalid description");
				}
				else {
					Con_Printf("invalid examples");
				}
				Con_Printf("\n");
				++num_errors;
			}
		}
	}
	con_margin = 0;
	Con_Printf("Number of variables with issues: %d\n", num_errors);
}

static void Help_FindCommandIssues(qbool generate)
{
	extern cmd_function_t *cmd_functions;
	cmd_function_t *cmd_func = 0;
	int num_errors = 0;

	for (cmd_func = cmd_functions; cmd_func; (cmd_func = cmd_func->next)) {
		const json_command_t* help_cmd = JSON_Command_Load(cmd_func->name);
		extern void HUD_Plus_f(void);
		extern void HUD_Minus_f(void);
		extern void HUD_Func_f(void);

		if (cmd_func->function == HUD_Plus_f || cmd_func->function == HUD_Minus_f || cmd_func->function == HUD_Func_f) {
			// not interested in hud's system-generated commands for the moment
			continue;
		}

		if (!help_cmd) {
			// missing
			if (generate) {
				json_t* obj = json_object();
				json_object_set(obj, "system-generated", json_boolean(1));
				json_object_set_new(document_root[helpdoc_commands], cmd_func->name, obj);
			}
			else {
				if (num_errors == 0) {
					Con_Printf("Commands with issues:\n");
					con_margin = CONSOLE_HELP_MARGIN;
				}

				con_ormask = 128;
				Con_Printf("%s", cmd_func->name);
				con_ormask = 0;
				Con_Printf(": missing from documentation\n");
			}
			++num_errors;
		}
	}

	con_margin = 0;
	Con_Printf("Number of commands with issues: %d\n", num_errors);
}

static void Help_FindMacroIssues(qbool generate)
{
	int i;
	int issues = 0;

	for (i = 0; i < num_macros; i++) {
		const char* name = Cmd_MacroName(i);
		const json_macro_t* help_macro = JSON_Macro_Load(name);
		qbool teamplay = Cmd_MacroTeamplayRestricted(i);

		if (help_macro && generate) {
			json_object_set_new(help_macro->json, "teamplay-restricted", json_boolean(teamplay ? 1 : 0));
		}
		else if (generate) {
			json_t* obj = json_object();
			json_object_set(obj, "system-generated", json_boolean(1));
			json_object_set(obj, "teamplay-restricted", json_boolean(teamplay ? 1 : 0));
			json_object_set_new(document_root[helpdoc_macros], name, obj);
			++issues;
		}
		else if (!help_macro) {
			if (issues == 0) {
				Con_Printf("Macros with issues:\n");
				con_margin = CONSOLE_HELP_MARGIN;
			}

			con_ormask = 128;
			Con_Printf("%s", name);
			con_ormask = 0;
			Con_Printf(": missing from documentation\n");
			++issues;
		}
	}

	con_margin = 0;
	Con_Printf("Number of macros with issues: %d\n", issues);
}

static void Help_FindCommandLineParamIssues(qbool generate)
{
	int i;
	int issues = 0;

	for (i = 0; i < num_cmdline_params; i++) {
		const char* name = Cmd_CommandLineParamName(i);
		const json_cmdlineparam_t* help_param = JSON_CommandLineParam_Load(name);

		if (help_param) {
			continue;
		}

		if (generate) {
			json_t* obj = json_object();
			json_object_set(obj, "system-generated", json_boolean(1));
			json_object_set_new(document_root[helpdoc_cmdlineparams], name, obj);
			++issues;
		}
		else {
			if (issues == 0) {
				Con_Printf("Command-line parameters with issues:\n");
				con_margin = CONSOLE_HELP_MARGIN;
			}
			con_ormask = 128;
			Con_Printf("%s", name);
			con_ormask = 0;
			Con_Printf(": missing from documentation\n");
			++issues;
		}
	}

	con_margin = 0;
	Con_Printf("Number of command-line params with issues: %d\n", issues);
}

static void Help_Issues_f(void)
{
	qbool generate = Cmd_Argc() >= 1 && !strcmp(Cmd_Argv(1), "generate");

	Help_FindConsoleVariableIssues(generate);
	Help_FindCommandIssues(generate);
	Help_FindMacroIssues(generate);
	Help_FindCommandLineParamIssues(generate);

	if (generate) {
		json_dump_file(document_root[helpdoc_variables], "qw/help_variables.json", JSON_ENSURE_ASCII | JSON_SORT_KEYS | JSON_INDENT(2));
		json_dump_file(document_root[helpdoc_commands], "qw/help_commands.json", JSON_ENSURE_ASCII | JSON_SORT_KEYS | JSON_INDENT(2));
		json_dump_file(document_root[helpdoc_macros], "qw/help_macros.json", JSON_ENSURE_ASCII | JSON_SORT_KEYS | JSON_INDENT(2));
		json_dump_file(document_root[helpdoc_cmdlineparams], "qw/help_cmdline_params.json", JSON_ENSURE_ASCII | JSON_SORT_KEYS | JSON_INDENT(2));
	}
}

void Help_Init(void)
{
	Cmd_AddCommand("describe", Help_Describe_f);
	if (IsDeveloperMode()) {
		Cmd_AddCommand("dev_help_verify_config", Help_VerifyConfig_f);
		Cmd_AddCommand("dev_help_issues", Help_Issues_f);
	}

	Help_LoadDocuments();
}

void Help_Shutdown(void)
{
	Help_UnloadDocuments();
}


================================================
FILE: src/help.h
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: help.h,v 1.6 2007-09-30 22:59:23 disconn3ct Exp $
*/

#ifndef __HELP_H__
#define __HELP_H__

// variable description
void Help_VarDescription (const char *varname, char* buf, size_t bufsize);

// initialize help system
void Help_Init (void);
void Help_Shutdown (void);

// help menu
void Menu_Help_Init (void);
void Menu_Help_Draw (int x, int y, int w, int h);
void Menu_Help_Key (int key, wchar unichar);
qbool Menu_Help_Mouse_Event (const mouse_state_t *ms);

void Menu_Help_Shutdown(void);
void Menu_Demo_Shutdown(void);
void Menu_Options_Shutdown(void);
void Menu_Ingame_Shutdown(void);
void Menu_MultiPlayer_Shutdown(void);

#endif // __HELP_H__


================================================
FILE: src/help_files.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
 * Help menu
 *  - browser tab
 *  - index tab
 *  - tutorials tab
 */

// maybe rename this file to menu_help.c

#include "quakedef.h"
#include "menu.h"
#include "EX_FileList.h"
#include "expat.h"
#include "xsd.h"
#include "document_rendering.h"
#include "Ctrl_PageViewer.h"
#include "Ctrl_Tab.h"

enum {
    HELPM_BROWSER,
	HELPM_INDEX,
    HELPM_TUTORIALS
};

CTab_t help_tab;

CPageViewer_t help_viewer;

void Help_Browser_Init(void)
{
    CPageViewer_Init(&help_viewer);
    CPageViewer_GoUrl(&help_viewer, "help/index.xml");
}

void Help_Browser_Shutdown(void)
{
	CPageViewer_Free(&help_viewer);
}

int Help_Browser_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
    return CPageViewer_Key(&help_viewer, key, unichar);
}

void Help_Browser_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
    CPageViewer_Draw(&help_viewer, x, y, w, h);
}

void Help_Browser_Focus(void)
{
    CTab_SetCurrentId(&help_tab, HELPM_BROWSER);
}

static qbool Help_Browser_Mouse_Event(const mouse_state_t *ms)
{
	return true;
}

filelist_t help_index_fl;
filelist_t help_tutorials_fl;

static void Help_Index_Init(void)
{
    FL_Init(&help_index_fl,	"./ezquake/help/manual");
    FL_AddFileType(&help_index_fl, 0, ".xml");
	FL_SetDirUpOption(&help_index_fl, false);
	FL_SetDirsOption(&help_index_fl, false);
}

static void Help_Tutorials_Init(void)
{
    FL_Init(&help_tutorials_fl,	"./ezquake/help/manual/demos");
    FL_AddFileType(&help_tutorials_fl, 0, ".mvd");
	FL_SetDirUpOption(&help_tutorials_fl, false);
	FL_SetDirsOption(&help_tutorials_fl, false);
}

static int Help_Index_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
    qbool processed;

    processed = FL_Key(&help_index_fl, key);

    if (!processed)
    {
        if (key == K_ENTER || key == K_MOUSE1)
        {
            CPageViewer_Go(&help_viewer, FL_GetCurrentPath(&help_index_fl), NULL);
            Help_Browser_Focus();

            processed = true;
        }
    }

    return processed;
}

static void Help_Index_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
    FL_Draw(&help_index_fl, x, y, w, h);
}

static qbool Help_Index_Mouse_Event(const mouse_state_t *ms)
{
    if (FL_Mouse_Event(&help_index_fl, ms)) {
        return true;
    } else if (ms->button_up >= 1 && ms->button_up <= 2) {
        Help_Index_Key(K_MOUSE1 - 1 + ms->button_up, 0, &help_tab, help_tab.pages + HELPM_INDEX);
        return true;
    }

    // this specially "eats" button_up event, there is no reason to process other events anyway
	return true;
}


static int Help_Tutorials_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
    qbool processed;

    processed = FL_Key(&help_tutorials_fl, key);

    if (!processed)
    {
        if (key == K_ENTER || key == K_MOUSE1)
        {
			M_LeaveMenus();
			Cbuf_AddText(va("playdemo \"%s\"\n", FL_GetCurrentPath(&help_tutorials_fl)));

            processed = true;
        }
    }

    return processed;
}

static void Help_Tutorials_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
    FL_Draw(&help_tutorials_fl, x, y, w, h);
}

static qbool Help_Tutorials_Mouse_Event(const mouse_state_t *ms)
{
    if (FL_Mouse_Event(&help_tutorials_fl, ms)) {
        return true;
    } else if (ms->button_up >= 1 && ms->button_up <= 2) {
        Help_Tutorials_Key(K_MOUSE1 - 1 + ms->button_up, 0, &help_tab, help_tab.pages + HELPM_TUTORIALS);
        return true;
    }

    // this specially "eats" button_up event, there is no reason to process other events anyway
	return true;
}


CTabPage_Handlers_t help_browser_handlers = {
	Help_Browser_Draw,
	Help_Browser_Key,
	NULL,
	Help_Browser_Mouse_Event
};

CTabPage_Handlers_t help_index_handlers = {
	Help_Index_Draw,
	Help_Index_Key,
	NULL,
	Help_Index_Mouse_Event
};

CTabPage_Handlers_t help_tutorials_handlers = {
	Help_Tutorials_Draw,
	Help_Tutorials_Key,
	NULL,
	Help_Tutorials_Mouse_Event
};


void Menu_Help_Init(void)
{
    // initialize tab control
    CTab_Init(&help_tab);

    Help_Browser_Init();
    Help_Index_Init();
	Help_Tutorials_Init();

    CTab_AddPage(&help_tab, "Browser", HELPM_BROWSER, &help_browser_handlers);
	CTab_AddPage(&help_tab, "Index", HELPM_INDEX, &help_index_handlers);
	CTab_AddPage(&help_tab, "Tutorials", HELPM_TUTORIALS, &help_tutorials_handlers);

    CTab_SetCurrentId(&help_tab, HELPM_BROWSER);
}

void Menu_Help_Shutdown(void)
{
	Help_Browser_Shutdown();
	FL_Shutdown(&help_index_fl);
	FL_Shutdown(&help_tutorials_fl);
}

void Menu_Help_Key(int key, wchar unichar)
{
	extern void M_Menu_Main_f (void);

    int handled = CTab_Key(&help_tab, key, unichar);

    if (!handled)
    {
        if (key == K_ESCAPE || key == K_MOUSE2)
        {
            M_Menu_Main_f();
        }
    }
}

void Menu_Help_Draw(int x, int y, int w, int h)
{
    CTab_Draw(&help_tab, x, y, w, h);
}

qbool Menu_Help_Mouse_Event(const mouse_state_t *ms)
{
	mouse_state_t nms = *ms;

    if (ms->button_up == 2) {
        Menu_Help_Key(K_MOUSE2, 0);
        return true;
    }

	// we are sending relative coordinates
	nms.x -= OPTPADDING;
	nms.y -= OPTPADDING;
	nms.x_old -= OPTPADDING;
	nms.y_old -= OPTPADDING;

	if (nms.x < 0 || nms.y < 0) return false;

	return CTab_Mouse_Event(&help_tab, &nms);
}


================================================
FILE: src/host.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
	$Id: host.c,v 1.60 2007-10-17 17:07:08 dkure Exp $
*/
// this should be the only file that includes both server.h and client.h

#include <setjmp.h>

#ifdef __FreeBSD__
#include <sys/types.h>
#include <sys/sysctl.h>
#include <osreldate.h>
#include <sys/time.h>
#include <machine/cpufunc.h>
#endif
#ifdef __APPLE__
#include <sys/types.h>
#include <sys/sysctl.h>
#endif
#include <SDL.h>
#include "quakedef.h"
#include "EX_browser.h"
#include "fs.h"
#include "gl_model.h"
#include "rulesets.h"
#include "teamplay.h"
#include "pmove.h"
#include "version.h"
#include "qsound.h"
#include "keys.h"
#include "config_manager.h"
#include "EX_qtvlist.h"
#include "r_renderer.h"
#include "central.h"
#include <curl/curl.h>

double		curtime;

static int	host_hunklevel;
static void	*host_membase;

qbool	host_initialized;	// true if into command execution
qbool	host_everything_loaded;	// true if OnChange() applied to every var, end of Host_Init()
int		host_memsize;

static jmp_buf 	host_abort;

extern void COM_StoreOriginalCmdline(int argc, char **argv);

char f_system_string[1024] = "";

char * SYSINFO_GetString(void)
{
	return f_system_string;
}

unsigned long long	SYSINFO_memory = 0;
int					SYSINFO_MHz = 0;
char				*SYSINFO_processor_description = NULL;
char				*SYSINFO_3D_description        = NULL;

static void SYSINFO_Shutdown(void)
{
	Q_free(SYSINFO_processor_description);
	Q_free(SYSINFO_3D_description);
}

#ifdef _WIN32
typedef BOOL (WINAPI *PGMSE)(LPMEMORYSTATUSEX);

void SYSINFO_Init(void)
{
	LONG  ret;
	HKEY  hKey;
	PGMSE pGMSE;

	const char *gl_renderer = renderer.DescriptiveString();

	// Get memory size.
	if ((pGMSE = (PGMSE)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GlobalMemoryStatusEx")) != NULL) {
		MEMORYSTATUSEX	memstat;
		memstat.dwLength = sizeof(memstat);
		pGMSE(&memstat);
		SYSINFO_memory = memstat.ullTotalPhys;
	} else {
		// Win9x doesn't have GlobalMemoryStatusEx.
		MEMORYSTATUS memstat;
		GlobalMemoryStatus(&memstat);
		SYSINFO_memory = memstat.dwTotalPhys;
	}

	// Get processor info.
	ret = RegOpenKey(
	          HKEY_LOCAL_MACHINE,
	          "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
	          &hKey);

	if (ret == ERROR_SUCCESS) {
		DWORD type;
		byte  data[1024];
		DWORD datasize;

		datasize = 1024;
		ret = RegQueryValueEx(
		          hKey,
		          "~MHz",
		          NULL,
		          &type,
		          data,
		          &datasize);

		if (ret == ERROR_SUCCESS  &&  datasize > 0  &&  type == REG_DWORD)
			SYSINFO_MHz = *((DWORD *)data);

		datasize = 1024;
		ret = RegQueryValueEx(
		          hKey,
		          "ProcessorNameString",
		          NULL,
		          &type,
		          data,
		          &datasize);

		if (ret == ERROR_SUCCESS  &&  datasize > 0  &&  type == REG_SZ)
			SYSINFO_processor_description = Q_strdup((char *) data);

		RegCloseKey(hKey);
	}

	if (gl_renderer && gl_renderer[0]) {
		if (SYSINFO_3D_description != NULL) {
			Q_free(SYSINFO_3D_description);
		}
		SYSINFO_3D_description = Q_strdup(gl_renderer);
	}

	//
	// Create the f_system string.
	//
	
	snprintf(f_system_string, sizeof(f_system_string), "%uMiB", (unsigned)((SYSINFO_memory / (double) 1048576u)+0.5));

	if (SYSINFO_processor_description) {
		strlcat(f_system_string, ", ", sizeof(f_system_string));
		strlcat(f_system_string, SYSINFO_processor_description, sizeof(f_system_string));
	}

	if (SYSINFO_MHz) {
		strlcat(f_system_string, va(" %dMHz", SYSINFO_MHz), sizeof(f_system_string));
	}

	if (SYSINFO_3D_description) {
		strlcat(f_system_string, ", ", sizeof(f_system_string));
		strlcat(f_system_string, SYSINFO_3D_description, sizeof(f_system_string));
	}
}
#elif defined(__linux__)
void SYSINFO_Init(void)
{
	// disconnect: which way is best(MEM/CPU-MHZ/CPU-MODEL)?
	f_system_string[0] = 0;
	char buffer[1024] = {0};
	char cpu_model[255] = {0};
	char *match;
	FILE *f;

	const char *gl_renderer = renderer.DescriptiveString();

	// MEM
	f = fopen("/proc/meminfo", "r");
	if (f) {
		if (fscanf (f, "%*s %llu %*s\n", &SYSINFO_memory) != 1) {
			Com_Printf ("could not read /proc/meminfo!\n");
		} else {
			SYSINFO_memory /= 1024;
		}
		fclose (f);
	} else {
		Com_Printf ("could not open /proc/meminfo!\n");
		SYSINFO_memory = 0;
	}

	//CPU-MHZ
	f = fopen("/proc/cpuinfo", "r");
	if (f) {
		buffer[fread (buffer, 1, sizeof(buffer) - 1, f)] = '\0';
		fclose (f);
		match = strstr (buffer, "cpu MHz");
		if (match) {
			sscanf (match, "cpu MHz : %i", &SYSINFO_MHz);
		}
	} else {
		Com_Printf ("could not open /proc/cpuinfo!\n");
	}

	//CPU-MODEL
	f = fopen("/proc/cpuinfo", "r");
	if (f) {
		while (!feof(f)) {
			if (fgets (buffer, sizeof(buffer), f) == NULL && !feof(f)) {	// disconnect: sizeof(buffer) - 1 ?
				Com_Printf("Error reading /proc/cpuinfo\n");
				break;
			}
			if (!strncmp( buffer, "model name", 10)) {
				match = strchr( buffer, ':' );
				match++;
				while (isspace(*match)) match++;
				memcpy(cpu_model, match, sizeof(cpu_model));
				cpu_model[strlen(cpu_model) - 1] = '\0';
				SYSINFO_processor_description= Q_strdup (cpu_model);
				break;
			}
		}
		fclose(f);	
	} else {
		Com_Printf("could not open /proc/cpuinfo!\n");
	}


	if (gl_renderer && gl_renderer[0]) {
		if (SYSINFO_3D_description != NULL) {
			free(SYSINFO_3D_description);
		}
		SYSINFO_3D_description = Q_strdup(gl_renderer);
	}

	snprintf(f_system_string, sizeof(f_system_string), "%dMB", (int)(SYSINFO_memory));

	if (SYSINFO_processor_description) {
		strlcat(f_system_string, ", ", sizeof(f_system_string));
		strlcat(f_system_string, SYSINFO_processor_description, sizeof(f_system_string));
	}
	if (SYSINFO_MHz) {
		strlcat(f_system_string, va(" %dMHz", SYSINFO_MHz), sizeof(f_system_string));
	}
	if (SYSINFO_3D_description) {
		strlcat(f_system_string, ", ", sizeof(f_system_string));
		strlcat(f_system_string, SYSINFO_3D_description, sizeof(f_system_string));
	}
}
#elif defined(__APPLE__)
void SYSINFO_Init(void)
{
	int mib[2];
	mib[0] = CTL_HW;
	mib[1] = HW_MEMSIZE;
	int64_t memsize_value;
	int cpu_frequency_value;
	size_t length = sizeof(memsize_value);
	char cpu_brand_string[100] = {0};
	size_t cpu_brand_string_len = sizeof(cpu_brand_string) - 1; /* Don't trust Apple, make sure its NULL terminated */

	const char *gl_renderer = renderer.DescriptiveString();

	if (sysctl(mib, 2, &memsize_value, &length, NULL, 0) != -1) {
		SYSINFO_memory = memsize_value;
	}

	if (sysctlbyname("machdep.cpu.brand_string", &cpu_brand_string, &cpu_brand_string_len, NULL, 0) != -1) {
		SYSINFO_processor_description = Q_strdup(cpu_brand_string);
	}

	mib[0] = CTL_HW;
	mib[1] = HW_CPU_FREQ;
	length = sizeof(cpu_frequency_value);
	if (sysctl(mib, 2, &cpu_frequency_value, &length, NULL, 0) != -1) {
		SYSINFO_MHz = cpu_frequency_value / 1000. / 1000. + .5;
	}


	if (gl_renderer && gl_renderer[0]) {
		if (SYSINFO_3D_description != NULL) {
			Q_free(SYSINFO_3D_description);
		}
		SYSINFO_3D_description = Q_strdup(gl_renderer);
	}

	snprintf(f_system_string, sizeof(f_system_string), "%dMB", (int)(SYSINFO_memory / 1024. / 1024. + .5));

	if (SYSINFO_processor_description) {
		strlcat(f_system_string, ", ", sizeof(f_system_string));
		strlcat(f_system_string, SYSINFO_processor_description, sizeof(f_system_string));
	}
	if (SYSINFO_MHz) {
		strlcat(f_system_string, va(" %dMHz", SYSINFO_MHz), sizeof(f_system_string));
	}
	if (SYSINFO_3D_description) {
		strlcat(f_system_string, ", ", sizeof(f_system_string));
		strlcat(f_system_string, SYSINFO_3D_description, sizeof(f_system_string));
	}
}
#elif defined(__FreeBSD__)
void SYSINFO_Init(void)
{
	char cpu_model[256];

	int mib[2], val;
	unsigned long val_ul;
	size_t len;
	unsigned long long old_tsc, tsc_freq;
	struct timeval tp, old_tp;
	const char *gl_renderer = renderer.DescriptiveString();

	mib[0] = CTL_HW;
	mib[1] =
#if __FreeBSD_version >= 500000
		HW_REALMEM;
#else
		HW_PHYSMEM;
#endif
// VVD: We can use HW_REALMEM (hw.realmem) for RELENG_5/6/7 for getting exact result,
// but RELENG_4 have only HW_PHYSMEM (hw.physmem).
	len = sizeof(val);
	sysctl(mib, sizeof(mib) / sizeof(mib[0]), &val_ul, &len, NULL, 0);

	SYSINFO_memory = val_ul;

	mib[0] = CTL_HW;
	mib[1] = HW_MODEL;
	len = sizeof(cpu_model);
	sysctl(mib, sizeof(mib) / sizeof(mib[0]), cpu_model, &len, NULL, 0);
	cpu_model[sizeof(cpu_model) - 1] = '\0';

	SYSINFO_processor_description = cpu_model;

	gettimeofday(&old_tp, NULL);
#ifdef __powerpc__
	__asm__ __volatile__("mfspr %%r3, 268": "=r" (old_tsc));
#else
	old_tsc = rdtsc();
#endif
	do {
		gettimeofday(&tp, NULL);
	} while ((tp.tv_sec - old_tp.tv_sec) * 1000000. + tp.tv_usec - old_tp.tv_usec < 1000000.);
#ifdef __powerpc__
	__asm__ __volatile__("mfspr %%r3, 268": "=r" (tsc_freq));
#else
	tsc_freq = rdtsc();
#endif
	SYSINFO_MHz = (int)((tsc_freq - old_tsc) /
						(tp.tv_sec - old_tp.tv_sec + (tp.tv_usec - old_tp.tv_usec) / 1000000.) /
						1000000. + .5);
// VVD: We can use sysctl hw.clockrate, but it don't work on i486 - always 0.
// Must work on Pentium 1/2/3; tested on Pentium 4. And RELENG_4 have no this sysctl.

	if (gl_renderer  &&  gl_renderer[0]) {
		if (SYSINFO_3D_description != NULL) {
			Q_free(SYSINFO_3D_description);
		}
		SYSINFO_3D_description = Q_strdup(gl_renderer);
	}

	snprintf(f_system_string, sizeof(f_system_string), "%dMB", (int)(SYSINFO_memory / 1024. / 1024. + .5));

	if (SYSINFO_processor_description) {
		strlcat(f_system_string, ", ", sizeof(f_system_string));
		strlcat(f_system_string, SYSINFO_processor_description, sizeof(f_system_string));
	}
	if (SYSINFO_MHz) {
		strlcat(f_system_string, va(" (%dMHz)", SYSINFO_MHz), sizeof(f_system_string));
	}
	if (SYSINFO_3D_description) {
		strlcat(f_system_string, ", ", sizeof(f_system_string));
		strlcat(f_system_string, SYSINFO_3D_description, sizeof(f_system_string));
	}
}
#else
void SYSINFO_Init(void)
{
	strlcpy(f_system_string, "Unknown system.", sizeof(f_system_string));
}
#endif

void Host_Abort (void)
{
	longjmp (host_abort, 1);
}

void Host_EndGame (void)
{
#ifndef CLIENTONLY
	SV_Shutdown ("Server was killed");
#endif
	CL_Disconnect();
	// clear disconnect messages from loopback
	CL_ClearQueuedPackets();
	NET_ClearLoopback();
}

//This shuts down both the client and server
void Host_Error (char *error, ...)
{
	va_list argptr;
	char string[1024];
	static qbool inerror = false;

	if (inerror)
		Sys_Error ("Host_Error: recursively entered");
	inerror = true;

	va_start (argptr,error);
	vsnprintf (string, sizeof(string), error, argptr);
	va_end (argptr);

	Com_Printf ("\n===========================\n");
	Com_Printf ("Host_Error: %s\n",string);
	Com_Printf ("===========================\n\n");

#ifndef CLIENTONLY
	SV_Shutdown (va("server crashed: %s\n", string));
#endif
	CL_Disconnect ();

	if (!host_initialized)
		Sys_Error ("Host_Error: %s", string);

	inerror = false;

	Host_Abort ();
}

//memsize is the recommended amount of memory to use for hunk
void Host_InitMemory (int memsize)
{
	int t;

	if (COM_CheckParm (cmdline_param_host_memory_minimum))
		memsize = MINIMUM_MEMORY;

	if ((t = COM_CheckParm (cmdline_param_host_memory_kb)) != 0 && t + 1 < COM_Argc())
		memsize = Q_atoi (COM_Argv(t + 1)) * 1024;

	if ((t = COM_CheckParm (cmdline_param_host_memory_mb)) != 0 && t + 1 < COM_Argc())
		memsize = Q_atoi (COM_Argv(t + 1)) * 1024 * 1024;

	if (memsize < MINIMUM_MEMORY)
		Sys_Error ("Only %4.1f megs of memory reported, can't execute game", memsize / (float)0x100000);

	host_memsize = memsize;
	host_membase = Q_malloc (host_memsize);
	Memory_Init (host_membase, host_memsize);
}

//Free hunk memory up to host_hunklevel
//Can only be called when changing levels!
void Host_ClearMemory (void)
{
	// FIXME, move to CL_ClearState
	Mod_ClearAll ();

	CM_InvalidateMap ();

	// any data previously allocated on hunk is no longer valid
	Hunk_FreeToLowMark (host_hunklevel);
}

void Host_Frame (double time)
{
	if (setjmp (host_abort))
		return;			// something bad happened, or the server disconnected

	curtime += time;

	CL_Frame (time);	// will also call SV_Frame

	Central_ProcessResponses();
}

char *Host_PrintBars(char *s, int len)
{
	static char temp[512];
	unsigned int i, count;

	temp[0] = 0;

	count = (len - 2 - 2 - strlen (s)) / 2;
	if (count > sizeof (temp) / 2 - 8)
		return temp;

	strlcat (temp, "\x1d", sizeof (temp));

	for (i = 0; i < count; i++)
		strlcat(temp, "\x1e", sizeof (temp));

	strlcat (temp, " ", sizeof (temp));
	strlcat (temp, s, sizeof (temp));
	strlcat (temp, " ", sizeof (temp));

	for (i = 0; i < count; i++)
		strlcat(temp, "\x1e", sizeof (temp));

	strlcat(temp, "\x1f", sizeof (temp));
	strlcat(temp, "\n\n", sizeof (temp));

	return temp;
}

static void Commands_For_Configs_Init (void)
{
	extern void SV_Floodprot_f (void);
	extern void SV_Floodprotmsg_f (void);
	extern void TP_MsgTrigger_f (void);
	extern void TP_MsgFilter_f (void);
	extern void TP_Took_f (void);
	extern void TP_Pickup_f (void);
	extern void TP_Point_f (void);
	extern void MT_AddMapGroups (void);
	extern void MT_MapGroup_f (void);
	extern void MT_AddSkyGroups (void);
	extern void MT_SkyGroup_f (void);
	extern void SB_SourceUnmarkAll(void);
	extern void SB_SourceMark(void);
	extern void LoadConfig_f(void);

	//disconnect: fix it if i forgot something
#ifndef CLIENTONLY
	Cmd_AddCommand ("floodprot", SV_Floodprot_f);
	Cmd_AddCommand ("floodprotmsg", SV_Floodprotmsg_f);
#endif
	Cmd_AddCommand ("msg_trigger", TP_MsgTrigger_f);
	Cmd_AddCommand ("filter", TP_MsgFilter_f);
	Cmd_AddCommand ("tp_took", TP_Took_f);
	Cmd_AddCommand ("tp_pickup", TP_Pickup_f);
	Cmd_AddCommand ("tp_point", TP_Point_f);

	MT_AddMapGroups ();
	Cmd_AddCommand ("mapgroup", MT_MapGroup_f);

	MT_AddSkyGroups ();
	Cmd_AddCommand ("skygroup", MT_SkyGroup_f);
	Cmd_AddCommand ("allskins", Skin_AllSkins_f);

	Cmd_AddCommand ("sb_sourceunmarkall", SB_SourceUnmarkAll);
	Cmd_AddCommand ("sb_sourcemark", SB_SourceMark);
}

// meag: try to move all renamed cvars here so they exist prior to config load, and
//       eventually old configs will set the new values
// fixme: would be better to have these all in the format of v_gamma, or (dream) all built-in cvars as enumerated type
static void Host_RegisterLegacyCvars(void)
{
	// Sound
	Cmd_AddLegacyCommand("nosound", "s_nosound");
	Cmd_AddLegacyCommand("precache", "s_precache");
	Cmd_AddLegacyCommand("loadas8bit", "s_loadas8bit");
	Cmd_AddLegacyCommand("ambient_level", "s_ambientlevel");
	Cmd_AddLegacyCommand("ambient_fade", "s_ambientfade");
	Cmd_AddLegacyCommand("snd_show", "s_show");
	Cmd_AddLegacyCommand("cl_chatsound", "s_chat_custom");

	// Weaponstats
	Cmd_AddLegacyCommand("scr_weaponstats_order", "hud_weaponstats_format");
	Cmd_AddLegacyCommand("scr_weaponstats_frame_color", "hud_weaponstats_frame_color");
	Cmd_AddLegacyCommand("scr_weaponstats_scale", "hud_weaponstats_scale");
	Cmd_AddLegacyCommand("scr_weaponstats_y", "hud_weaponstats_y");
	Cmd_AddLegacyCommand("scr_weaponstats_x", "hud_weaponstats_x");

	// Drawing (now r_smoothtext/images/crosshair)
	Cmd_AddLegacyCommand("gl_smoothfont", "r_smoothtext");

	// Typo
	Cmd_AddLegacyCommand("gl_lighting_colour", "gl_lighting_color");

	Cmd_AddLegacyCommand("cl_truelightning", "cl_fakeshaft");
	Cmd_AddLegacyCommand("demotimescale", "cl_demospeed");

	Cmd_AddLegacyCommand("gamma", v_gamma.name);
	Cmd_AddLegacyCommand("contrast", v_contrast.name);
	Cmd_AddLegacyCommand("gl_gammacorrection", "vid_gammacorrection");

	// if you don't like renaming things in this way, let's have some talk with tea - johnnycz
	Cmd_AddLegacyCommand("con_sound_mm1_file", "s_mm1_file");
	Cmd_AddLegacyCommand("con_sound_mm2_file", "s_mm2_file");
	Cmd_AddLegacyCommand("con_sound_spec_file", "s_spec_file");
	Cmd_AddLegacyCommand("con_sound_other_file", "s_otherchat_file");
	Cmd_AddLegacyCommand("con_sound_mm1_volume", "s_mm1_volume");
	Cmd_AddLegacyCommand("con_sound_mm2_volume", "s_mm2_volume");
	Cmd_AddLegacyCommand("con_sound_spec_volume", "s_spec_volume");
	Cmd_AddLegacyCommand("con_sound_other_volume", "s_otherchat_volume");
}

void Startup_Place(void)
{
    extern cvar_t cl_onload;
	extern cvar_t cl_startupdemo;

	if (cl_startupdemo.string[0]) {
		Cbuf_AddText(va("playdemo %s\n", cl_startupdemo.string));
		if (!strcmp(cl_onload.string, "menu")) {
			key_dest = key_startupdemo_menu;
		}
		else if (!strcmp(cl_onload.string, "browser")) {
			key_dest = key_startupdemo_browser;
		}
		else if (!strcmp(cl_onload.string, "console")) {
			key_dest = key_startupdemo_console;
		}
		else {
			key_dest = key_startupdemo_game;
		}
	}
	else if (!strcmp (cl_onload.string, "menu")) {
		Cbuf_AddText ("togglemenu\n");
	}
	else if (!strcmp (cl_onload.string, "browser")) {
		Cbuf_AddText ("menu_slist\n");
	}
	else if (!strcmp (cl_onload.string, "console")) {
		key_dest = key_console;
	}
	else {
		key_dest = key_console;
		Cbuf_AddText (va ("%s\n", cl_onload.string));
	}
}

void Host_Init (int argc, char **argv, int default_memsize)
{
	vfsfile_t *vf;
	cvar_t *v;
	char cfg[MAX_PATH] = {0};
	int i;
	char *cfg_name;

	// central, version check etc
	curl_global_init(CURL_GLOBAL_DEFAULT);

	COM_InitArgv (argc, argv);
	COM_StoreOriginalCmdline(argc, argv);

	if (SDL_Init(0) != 0)
	{
		fprintf(stderr, "Failed to initialize SDL: %s\n", SDL_GetError());
		exit(EXIT_FAILURE);
	}
	atexit(SDL_Quit);

	Host_InitMemory (default_memsize);

	Cbuf_Init ();
	Cmd_Init ();
	Cvar_Init ();
	COM_Init ();
	Key_Init ();

	FS_InitFilesystem ();
	NET_Init ();

#ifdef WITH_RENDERING_TRACE
	// Start immediately: (have to wait until filesystem is started up so we know where to save files)
	if (COM_CheckParm(cmdline_param_client_video_r_trace)) {
		Dev_VidFrameStart();
	}
#endif

	Commands_For_Configs_Init ();
	Host_RegisterLegacyCvars();
	Browser_Init2();
	ConfigManager_Init();
	ResetBinds();
	Cfg_ExecuteDefaultConfig();
	Cbuf_Execute();

	i = COM_FindParm("+cfg_load");

	if (i && (i + 1 < COM_Argc())) {
		cfg_name = COM_Argv(i + 1);
	}
	else {
		cfg_name = MAIN_CONFIG_FILENAME;
	}
	snprintf(cfg, sizeof(cfg), "%s", cfg_name);
	COM_ForceExtensionEx (cfg, ".cfg", sizeof (cfg));
	Cbuf_AddText(va("cfg_load %s\n", cfg));
	Cbuf_Execute();

	Cbuf_AddEarlyCommands ();
	Cbuf_Execute ();

	Con_Init ();
	NET_InitClient ();
	Netchan_Init ();

	Sys_Init ();
	Sys_CvarInit();
	CM_Init ();
	Mod_Init ();
	VersionCheck_Init();

#ifndef CLIENTONLY
	SV_Init ();
#endif
	CL_Init ();
	Central_Init();

	Cvar_CleanUpTempVars ();

	SYSINFO_Init();

	Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
	host_hunklevel = Hunk_LowMark ();

	host_initialized = true;

	// walk through all vars and force OnChange event if cvar was modified,
	// also apply that to variables which mirrored in userinfo because of cl_parsefunchars wasn't applied at this moment,
	// same for serverinfo and maybe this fix something also.
	for ( v = NULL; (v = Cvar_Next ( v )); ) {
		char val[2048];

//		if ( !v->modified )
//			continue; // not modified even that strange at this moment

		if ( Cvar_GetFlags( v ) & (CVAR_ROM | CVAR_INIT) )
			continue;

		snprintf(val, sizeof(val), "%s", v->string);
		Cvar_Set(v, val);
	}
	
	Hud_262LoadOnFirstStart();

	Com_Printf_State (PRINT_INFO, "Exe: "__DATE__" "__TIME__"\n");
	Com_Printf_State (PRINT_INFO, "Hunk allocation: %4.1f MB\n", (float) host_memsize / (1024 * 1024));
	Com_Printf("\n");
	Com_Printf(EZ_VERSION_WEBSITE "\n");
	Com_Printf("\n");
//	Com_Printf(Host_PrintBars("ezQuake\x9c" "SourceForge\x9c" "net", 38));
	Com_Printf("ezQuake %s\n", VersionStringColour());
	Com_Printf("\n");
	Com_Printf(Host_PrintBars("&c1e1ezQuake Initialized&r", 38));
	Com_Printf("\n");
	Com_Printf("Type /help to access the manual.\nUse /describe for help on commands.\n\n", VersionString());

	if ((vf = FS_OpenVFS("autoexec.cfg", "rb", FS_ANY))) {
		Cbuf_AddText ("exec autoexec.cfg\n\n");
		VFS_CLOSE(vf);
	}

	Cmd_StuffCmds_f ();		// process command line arguments
	Cbuf_AddText("cl_warncmd 1\n");

	Sys_CheckQWProtocolHandler();

	// Check if a qtv/demo file is specified as the first argument, in that case play that
	// otherwise, do some more checks of what to show at startup.
	{
		char cmd[1024] = {0};

		if (COM_CheckArgsForPlayableFiles(cmd, sizeof(cmd))) {
			Cbuf_AddText(cmd);
		}
		else {
			Startup_Place();
		}
	}

	// Trigger changes config has made to defaults
	Cbuf_Flush(&cbuf_main);
	Cvar_ExecuteQueuedChanges();
	Cbuf_Execute();

	host_everything_loaded = true;
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nevent,init\n");
#endif
}

//FIXME: this is a callback from Sys_Quit and Sys_Error.  It would be better
//to run quit through here before the final handoff to the sys code.
void Host_Shutdown (void)
{
	static qbool isdown = false;

	if (isdown) {
		printf ("recursive shutdown\n");
		return;
	}
	isdown = true;

	// on low-end systems quit process may last long time (was about 1 minute for me on old compo),
	// at the same time may repeats repeats repeats some sounds, trying preventing this
	S_StopAllSounds();
	S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin);

#ifndef CLIENTONLY
	SV_Shutdown ("Server quit\n");
#endif

	Central_Shutdown();
	CL_Shutdown ();
	NET_Shutdown ();
	Con_Shutdown();
	qtvlist_deinit();
	Cvar_Shutdown();
	FS_Shutdown();
	SYSINFO_Shutdown();
	Q_free(com_args_original);

	VersionCheck_Shutdown();

	curl_global_cleanup();
}

void Host_Quit (void)
{
#ifdef DEBUG_MEMORY_ALLOCATIONS
	Sys_Printf("\nevent,quit\n");
#endif

	// execute user's trigger
	TP_ExecTrigger ("f_exit");
	Cbuf_Execute();
	
	// save config (conditional)
	Config_QuitSave();

	// turn off
	Host_Shutdown ();

	Q_free(host_membase);

	Sys_Quit ();
}


================================================
FILE: src/hud.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
//
// HUD commands
//


#include "quakedef.h"
#include "common_draw.h"
#include "keys.h"
#include "hud.h"
#include "hud_common.h"
#include "hud_editor.h"
#include "utils.h"
#include "sbar.h"
#include "rulesets.h"

static qbool HUD_ShouldShow(const hud_t* hud)
{
	if (hud->show->integer == 2 || hud->show->integer == 3) {
		return ((hud->show->integer == 2) == Ruleset_IsLocalSinglePlayerGame());
	}
	return (hud->show->integer != 0);
}

static qbool HUD_ShouldDraw(const hud_t* hud)
{
	// 0 = don't draw, 1 = always, 2 = single player only, 3 = multiplayer only
	if (hud->draw->integer == 2 || hud->draw->integer == 3) {
		return ((hud->draw->integer == 2) == Ruleset_IsLocalSinglePlayerGame());
	}
	return (hud->draw->integer != 0);
}

#define sbar_last_width 320  // yeah yeah I know, *garbage* -> leave it be :>

char *align_strings_x[] = {
	"left",
	"center",
	"right",
	"before",
	"after"
};
#define  num_align_strings_x  (sizeof(align_strings_x) / sizeof(align_strings_x[0]))

char *align_strings_y[] = {
	"top",
	"center",
	"bottom",
	"before",
	"after",
	"console"
};
#define  num_align_strings_y  (sizeof(align_strings_y) / sizeof(align_strings_y[0]))

char *snap_strings[] = {
	"screen",
	"top",
	"view",
	"sbar",
	"ibar",
	"hbar",
	"sfree",
	"ifree",
	"hfree",
};
#define  num_snap_strings  (sizeof(snap_strings) / sizeof(snap_strings[0]))

// Hud elements list.
hud_t *hud_huds = NULL;

//
// Hud plus func - show element.
//
void HUD_Plus_f(void)
{
	char *t;
	hud_t *hud;

	if (Cmd_Argc() < 1)
		return;

	t = Cmd_Argv(0);
	if (strncmp(t, "+hud_", 5))
		return;

	hud = HUD_Find(t + 5);
	if (!hud)
	{
		// This should never happen...
		return;
	}

	if (!hud->show)
	{
		// This should never happen...
		return;
	}

	Cvar_Set(hud->show, "1");
}

//
// Hud minus func - hide element.
//
void HUD_Minus_f(void)
{
	char *t;
	hud_t *hud;

	if (Cmd_Argc() < 1)
		return;

	t = Cmd_Argv(0);
	if (strncmp(t, "-hud_", 5))
		return;

	hud = HUD_Find(t + 5);
	if (!hud)
	{
		// this should never happen...
		return;
	}

	if (!hud->show)
	{
		// this should never happen...
		return;
	}

	Cvar_Set(hud->show, "0");
}

//
// Hud element func - describe it
// this also solves the TAB completion problem
//
void HUD_Func_f(void)
{
	int i;
	hud_t *hud;

	hud = HUD_Find(Cmd_Argv(0));

	if (!hud)
	{
		// This should never happen...
		Com_Printf("Hud element not found\n");
		return;
	}

	if (Cmd_Argc() > 1)
	{
		char buf[512];

		snprintf(buf, sizeof(buf), "hud_%s_%s", hud->name, Cmd_Argv(1));
		if (Cvar_Find(buf) != NULL)
		{
			Cbuf_AddText(buf);
			if (Cmd_Argc() > 2)
			{
				Cbuf_AddText(" ");
				Cbuf_AddText(Cmd_Argv(2));
			}
			Cbuf_AddText("\n");
		}
		else
		{
			Com_Printf("Trying \"%s\" - no such variable\n", buf);
		}
		return;
	}

	// Description.
	Com_Printf("%s\n\n", hud->description);

	// Show status.
	if (hud->show != NULL && hud->draw != NULL)
	{
		Com_Printf("Current status: %s, %s\n", HUD_ShouldShow(hud) ? "shown" : "hidden", HUD_ShouldDraw(hud) ? "drawn" : "no content");
	}

	if (hud->frame != NULL)
	{
		Com_Printf("Frame:          %s\n\n", hud->frame->string);
	}

	if (hud->frame_color != NULL)
	{
		Com_Printf("Frame color:          %s\n\n", hud->frame_color->string);
	}

	// Placement.
	Com_Printf("Placement:        %s\n", hud->place->string);

	// Alignment.
	Com_Printf("Alignment (x y):  %s %s\n", hud->align_x->string, hud->align_y->string);

	// Position.
	Com_Printf("Offset (x y):     %d %d\n", (int)(hud->pos_x->value), (int)(hud->pos_y->value));

	// Ordering.
	Com_Printf("Draw Order (z):   %d\n", (int)hud->order->value);

	// Additional parameters.
	if (hud->num_params > 0)
	{
		int prefix_l = strlen(va("hud_%s_", hud->name));
		Com_Printf("\nParameters:\n");
		for (i=0; i < hud->num_params; i++)
		{
			if (strlen(hud->params[i]->name) > prefix_l)
				Com_Printf("  %-15s %s\n", hud->params[i]->name + prefix_l,
					hud->params[i]->string);
		}
	}
}

//
// Find the elements with the max and min z-order.
//
void HUD_FindMaxMinOrder(int *max, int *min)
{
	hud_t *hud = hud_huds;

	while(hud)
	{
		(*min) = ((int)hud->order->value < (*min)) ? (int)hud->order->value : (*min);
		(*max) = ((int)hud->order->value > (*max)) ? (int)hud->order->value : (*max);

		hud = hud->next;
	}
}

//
// Find hud placement by string
// return 0 if error
//
int HUD_FindPlace(hud_t *hud)
{
	int i;
	hud_t *par;
	qbool out;
	char *t;

	// First try standard strings.
	for (i=0; i < num_snap_strings; i++)
	{
		if (!strcasecmp(hud->place->string, snap_strings[i]))
		{
			break;
		}
	}

	if (i < num_snap_strings)
	{
		// Found.
		hud->place_num = i+1;
		hud->place_hud = NULL;
		return 1;
	}

	// then try another HUD element
	out = true;
	t = hud->place->string;
	if (hud->place->string[0] == '@')
	{
		// place inside
		out = false;
		t++;
	}

	par = hud_huds;
	while (par)
	{
		if (par != hud && !strcmp(t, par->name))
		{
			hud->place_outside = out;
			hud->place_hud = par;
			hud->place_num = HUD_PLACE_SCREEN;
			return 1;
		}
		par = par->next;
	}

	// No way.
	hud->place_num = HUD_PLACE_SCREEN;
	hud->place_hud = NULL;
	return 0;
}

//
// Find hud alignment by strings
// return 0 if error
//
int HUD_FindAlignX(hud_t *hud)
{
	int i;

	// First try standard strings.
	for (i=0; i < num_align_strings_x; i++)
	{
		if (!strcasecmp(hud->align_x->string, align_strings_x[i]))
		{
			break;
		}
	}

	if (i < num_align_strings_x)
	{
		// Found.
		hud->align_x_num = i+1;
		return 1;
	}
	else
	{
		// Error.
		hud->align_x_num = HUD_ALIGN_LEFT; // left
		return 0;
	}
}

//
// Find the alignment for a hud element.
//
int HUD_FindAlignY(hud_t *hud)
{
	int i;

	// First try standard strings.
	for (i=0; i < num_align_strings_y; i++)
	{
		if (!strcasecmp(hud->align_y->string, align_strings_y[i]))
		{
			break;
		}
	}

	if (i < num_align_strings_y)
	{
		// Found.
		hud->align_y_num = i + 1;
		return 1;
	}
	else
	{
		// Error.
		hud->align_y_num = HUD_ALIGN_TOP; // Left.
		return 0;
	}
}

int Hud_HudCompare (const void *p1, const void *p2)
{
	return strcmp((*((hud_t **) p1))->name, (*((hud_t **) p2))->name);
}

//
// List hud elements
//
void HUD_List (void)
{
	static hud_t *sorted_huds[256];
	int i, count;
	hud_t *hud;

#define MAX_SORTED_HUDS (sizeof (sorted_huds) / sizeof (sorted_huds[0]))

	for (hud = hud_huds, count = 0; hud && count < MAX_SORTED_HUDS; hud = hud->next, count++)
		sorted_huds[count] = hud;
	qsort (sorted_huds, count, sizeof (hud_t *), Hud_HudCompare);

	if (count == MAX_SORTED_HUDS)
		assert(!"count == MAX_SORTED_HUDS");

	Com_Printf("name            status\n");
	Com_Printf("--------------- ------\n");
	for (i = 0; i < count; i++) {
		hud = sorted_huds[i];

		Com_Printf("%-15s %s\n", hud->name, HUD_ShouldShow(hud) ? "shown" : "hidden");
	}
}

//
// Show the specified hud element.
//
void HUD_Show_f (void)
{
	hud_t *hud;

	if (Cmd_Argc() != 2)
	{
		Com_Printf("Usage: show [<name> | all]\n");
		Com_Printf("Show given HUD element.\n");
		Com_Printf("use \"show all\" to show all elements.\n");
		Com_Printf("Current elements status:\n\n");
		HUD_List();
		return;
	}

	if (!strcasecmp(Cmd_Argv(1), "all"))
	{
		hud = hud_huds;
		while (hud)
		{
			Cvar_SetValue(hud->show, 1);
			hud = hud->next;
		}
	}
	else
	{
		hud = HUD_Find(Cmd_Argv(1));

		if (!hud)
		{
			Com_Printf("No such element: %s\n", Cmd_Argv(1));
			return;
		}

		Cvar_SetValue(hud->show, 1);
	}
}


//
// Hide the specified hud element.
//
void HUD_Hide_f (void)
{
	hud_t *hud;

	if (Cmd_Argc() != 2)
	{
		Com_Printf("Usage: hide [<name> | all]\n");
		Com_Printf("Hide given HUD element\n");
		Com_Printf("use \"hide all\" to hide all elements.\n");
		Com_Printf("Current elements status:\n\n");
		HUD_List();
		return;
	}

	if (!strcasecmp(Cmd_Argv(1), "all"))
	{
		hud = hud_huds;
		while (hud)
		{
			Cvar_SetValue(hud->show, 0);
			hud = hud->next;
		}
	}
	else
	{
		hud = HUD_Find(Cmd_Argv(1));

		if (!hud)
		{
			Com_Printf("No such element: %s\n", Cmd_Argv(1));
			return;
		}

		Cvar_SetValue(hud->show, 0);
	}
}

//
// Toggles specified hud element.
//
void HUD_Toggle_f (void)
{
	hud_t *hud;

	if (Cmd_Argc() != 2)
	{
		Com_Printf("Usage: togglehud <name> | <variable>\n");
		Com_Printf("Show/hide given HUD element, or toggles variable value.\n");
		return;
	}

	hud = HUD_Find(Cmd_Argv(1));

	if (!hud)
	{
		// look for cvar
		cvar_t *var = Cvar_Find(Cmd_Argv(1));
		if (!var)
		{
			Com_Printf("No such element or variable: %s\n", Cmd_Argv(1));
			return;
		}

		Cvar_Set (var, var->value ? "0" : "1");
		return;
	}

	Cvar_Set (hud->show, HUD_ShouldShow(hud) ? "0" : "1");
}

//
// Move the specified hud element relative to placement/alignment.
//
void HUD_Move_f (void)
{
	hud_t *hud;

	if (Cmd_Argc() != 4 &&  Cmd_Argc() != 2)
	{
		Com_Printf("Usage: move <name> [<x> <y>]\n");
		Com_Printf("Set offset for given HUD element\n");
		return;
	}

	hud = HUD_Find(Cmd_Argv(1));

	if (!hud)
	{
		Com_Printf("No such element: %s\n", Cmd_Argv(1));
		return;
	}

	if (Cmd_Argc() == 2)
	{
		Com_Printf("Current %s offset is:\n", Cmd_Argv(1));
		Com_Printf("  x:  %s\n", hud->pos_x->string);
		Com_Printf("  y:  %s\n", hud->pos_y->string);
		return;
	}

	Cvar_SetValue(hud->pos_x, atof(Cmd_Argv(2)));
	Cvar_SetValue(hud->pos_y, atof(Cmd_Argv(3)));
}

//
// Resets a hud item to the center of the screen.
//
void HUD_Reset_f (void)
{
	hud_t *hud = NULL;
	char *hudname = NULL;

	if (Cmd_Argc() != 2)
	{
		Com_Printf("Usage: reset <name>\n");
		Com_Printf("Resets the position of the given HUD element to the center of the screen.\n");
		return;
	}

	hudname = Cmd_Argv(1);

	hud = HUD_Find(hudname);

	if (!hud)
	{
		Com_Printf("No such HUD element %s.\n", hudname);
		return;
	}
	
	Cbuf_AddText(va("place %s screen\n", hudname));
	Cbuf_AddText(va("move %s 0 0\n", hudname));
	Cbuf_AddText(va("align %s center center\n", hudname));
}

//
// Reorders children so that they are place infront of their parent.
//
void HUD_ReorderChildren(void)
{
	hud_t *hud = hud_huds;

	// Give all children a higher Z-order.
	while(hud)
	{
		if(hud->place_hud && hud->order->value <= hud->place_hud->order->value)
		{
			Cvar_SetValue(hud->order, hud->place_hud->order->value + 1);
		}

		hud = hud->next;
	}
}

//
// Place the specified hud element.
//
void HUD_Place_f (void)
{
	hud_t *hud;
	char temp[512];

	if (Cmd_Argc() < 2 || Cmd_Argc() > 3)
	{
		Com_Printf("Usage: move <name> [<area>]\n");
		Com_Printf("Place HUD element at given area.\n");
		Com_Printf("\nPossible areas are:\n");
		Com_Printf("  screen - screen area\n");
		Com_Printf("  top    - screen minus status bar\n");
		Com_Printf("  view   - view\n");
		Com_Printf("  sbar   - status bar\n");
		Com_Printf("  ibar   - inventory bar\n");
		Com_Printf("  hbar   - health bar\n");
		Com_Printf("  sfree  - status bar free area\n");
		Com_Printf("  ifree  - inventory bar free area\n");
		Com_Printf("  hfree  - health bar free area\n");
		Com_Printf("You can also use any other HUD element as a base alignment. In such case you should specify area as:\n");
		Com_Printf("  @elem  - if you want to place\n");
		Com_Printf("           it inside elem\n");
		Com_Printf("   elem  - if you want to place\n");
		Com_Printf("           it outside elem\n");
		Com_Printf("Examples:\n");
		Com_Printf("  place fps view\n");
		Com_Printf("  place fps @ping\n");
		return;
	}

	hud = HUD_Find(Cmd_Argv(1));

	if (!hud)
	{
		Com_Printf("No such element: %s\n", Cmd_Argv(1));
		return;
	}

	if (Cmd_Argc() == 2)
	{
		Com_Printf("Current %s placement: %s\n", hud->name, hud->place->string);
		return;
	}

	// Place with helper.
	strlcpy(temp, hud->place->string, sizeof(temp));
	Cvar_Set(hud->place, Cmd_Argv(2));
	if (!HUD_FindPlace(hud))
	{
		Com_Printf("place: invalid area argument: %s\n", Cmd_Argv(2));
		Cvar_Set(hud->place, temp); // Restore old value.
	}
	else
	{
		HUD_ReorderChildren();
	}
}

//
// Sets the z-order of a HUD element.
//
void HUD_Order_f (void)
{
	int max = 0;
	int min = 0;
	char *option = NULL;
	hud_t *hud = NULL;

	if (Cmd_Argc() < 2 || Cmd_Argc() > 3)
	{
		Com_Printf("Usage: order <name> [<option>]\n");
		Com_Printf("Set HUD element draw order\n");
		Com_Printf("\nPossible values for option:\n");
		Com_Printf("  #         - An integer representing the order.\n");
		Com_Printf("  backward  - Send the element backwards in the order.\n");
		Com_Printf("  forward   - Send the element forward in the order.\n");
		Com_Printf("  front     - Bring the element to the front.\n");
		Com_Printf("  back      - Put the element at the far back.\n");
		return;
	}

	hud = HUD_Find (Cmd_Argv(1));

	if (!hud)
	{
		Com_Printf("No such element: %s\n", Cmd_Argv(1));
		return;
	}

	if (Cmd_Argc() == 2)
	{
		Com_Printf("Current order for %s is:\n", Cmd_Argv(1));
		Com_Printf("  order:  %d\n", (int)hud->order->value);
		return;
	}

	option = Cmd_Argv(2);

	HUD_FindMaxMinOrder (&max, &min);

	if (!strncasecmp (option, "backward", 8))
	{
		// Send backward one step.
		Cvar_SetValue(hud->order, (int)hud->order->value - 1);
	}
	else if (!strncasecmp (option, "forward", 7))
	{
		// Move forward one step.
		Cvar_SetValue(hud->order, (int)hud->order->value + 1);
	}
	else if (!strncasecmp (option, "front", 5))
	{
		// Bring to front.
		Cvar_SetValue(hud->order, max + 1);
	}
	else if (!strncasecmp (option, "back", 8))
	{
		// Send to far back.
		Cvar_SetValue(hud->order, min - 1);
	}
	else
	{
		// Order #
		Cvar_SetValue (hud->order, atoi(Cmd_Argv(2)));
	}
}

//
// Align the specified hud element
//
void HUD_Align_f (void)
{
	hud_t *hud;

	if (Cmd_Argc() != 4  &&  Cmd_Argc() != 2)
	{
		Com_Printf("Usage: align <name> [<ax> <ay>]\n");
		Com_Printf("Set HUD element alignment\n");
		Com_Printf("\nPossible values for ax are:\n");
		Com_Printf("  left    - left area edge\n");
		Com_Printf("  center  - area center\n");
		Com_Printf("  right   - right area edge\n");
		Com_Printf("  before  - before area (left)\n");
		Com_Printf("  after   - after area (right)\n");
		Com_Printf("\nPossible values for ay are:\n");
		Com_Printf("  top     - screen top\n");
		Com_Printf("  center  - screen center\n");
		Com_Printf("  bottom  - screen bottom\n");
		Com_Printf("  before  - before area (top)\n");
		Com_Printf("  after   - after area (bottom)\n");
		Com_Printf("  console - below console\n");
		return;
	}

	hud = HUD_Find(Cmd_Argv(1));

	if (!hud)
	{
		Com_Printf("No such element: %s\n", Cmd_Argv(1));
		return;
	}

	if (Cmd_Argc() == 2)
	{
		Com_Printf("Current alignment for %s is:\n", Cmd_Argv(1));
		Com_Printf("  horizontal (x):  %s\n", hud->align_x->string);
		Com_Printf("  vertical (y):    %s\n", hud->align_y->string);
		return;
	}

	// validate and set
	Cvar_Set(hud->align_x, Cmd_Argv(2));
	if (!HUD_FindAlignX(hud))
		Com_Printf("align: invalid X alignment: %s\n", Cmd_Argv(2));

	Cvar_Set(hud->align_y, Cmd_Argv(3));
	if (!HUD_FindAlignY(hud))
		Com_Printf("align: invalid Y alignment: %s\n", Cmd_Argv(3));
}

//
// Recalculate all elements
// should be called if some HUD parameters (like place)
// were changed directly by vars, not comands (like place)
// - after execing cfg or sth
//
void HUD_Recalculate(void)
{
	hud_t *hud = hud_huds;

	while (hud)
	{
		HUD_FindPlace(hud);
		HUD_FindAlignX(hud);
		HUD_FindAlignY(hud);

		hud = hud->next;
	}
}
void HUD_Recalculate_f(void)
{
	HUD_Recalculate();
}

//
// Initialize HUD.
//
void HUD_Init(void)
{
	// from hud.c, doesn't suit anywhere
	void HUD_Inputlag_hit_f(void);

	// Commands.
	Cmd_AddCommand ("show", HUD_Show_f);
	Cmd_AddCommand ("hide", HUD_Hide_f);
	Cmd_AddCommand ("move", HUD_Move_f);
	Cmd_AddCommand ("place", HUD_Place_f);
	Cmd_AddCommand ("reset", HUD_Reset_f);
	Cmd_AddCommand ("order", HUD_Order_f);
	Cmd_AddCommand ("togglehud", HUD_Toggle_f);
	Cmd_AddCommand ("align", HUD_Align_f);
	Cmd_AddCommand ("hud_recalculate", HUD_Recalculate_f);

	// Variables.
	Cvar_SetCurrentGroup(CVAR_GROUP_HUD);
	Cvar_ResetCurrentGroup();

	// Register the hud items.
	CommonDraw_Init();

	// Sort the elements.
	HUD_Sort();
}

//
// Calculate frame extents.
//
void HUD_CalcFrameExtents(hud_t *hud, int width, int height,									// In.
						  int *frame_left, int *frame_right, int *frame_top, int *frame_bottom) // Out.
{
	if ((hud->flags & HUD_NO_GROW) && hud->frame->value != 2)
	{
		*frame_left = *frame_right = *frame_top = *frame_bottom = 0;
		return;
	}

	if (hud->frame->value == 2) // Treat text box separately.
	{
		int ax			= (width % 16);
		int ay			= (height % 8);
		*frame_left		= 8 + ax / 2;
		*frame_top		= 8 + ay / 2;
		*frame_right	= 8 + ax - ax / 2;
		*frame_bottom	= 8 + ay - ay / 2;
	}
	else if (hud->frame->value > 0  &&  hud->frame->value <= 1)
	{
		int frame_x, frame_y;
		frame_x = 2;
		frame_y = 2;

		if (width > 8)
		{
			frame_x <<= 1;
		}

		if (height > 8)
		{
			frame_y <<= 1;
		}

		*frame_left		= frame_x;
		*frame_right	= frame_x;
		*frame_top		= frame_y;
		*frame_bottom	= frame_y;
	}
	else
	{
		// No frame at all.
		*frame_left = *frame_right = *frame_top = *frame_bottom = 0;
	}
}

void HUD_OnChangeFrameColor(cvar_t *var, char *newval, qbool *cancel)
{
	// Converts "red" into "255 0 0", etc. or returns input as it was.
	char *new_color = ColorNameToRGBString (newval);
	char buf[256], buf2[MAX_COM_TOKEN];
	size_t hudname_len;
	hud_t* hud_elem;
	byte* b_colors;

	hudname_len = min (sizeof (buf), strlen (var->name) - strlen ("_frame_color") - strlen ("hud_") + 1);
	strlcpy (buf, var->name + 4, hudname_len);
	hud_elem = HUD_Find (buf);

	strlcpy(buf2,new_color,sizeof(buf2));
	b_colors = StringToRGB (buf2);

	memcpy (hud_elem->frame_color_cache, b_colors, sizeof (byte) * 3);
}

//
// Draw frame for HUD element.
//
void HUD_DrawFrame(hud_t *hud, int x, int y, int width, int height)
{
	if (hud->frame_hide) {
		return;
	}

	if (!hud->frame->value)
		return;

	if (hud->frame->value > 0  &&  hud->frame->value <= 1)
	{
		hud->frame_color_cache[3] = (byte)(255 * hud->frame->value);

		Draw_AlphaFillRGB(x, y, width, height, RGBAVECT_TO_COLOR(hud->frame_color_cache));
		return;
	}
	else
	{
		switch ((int)(hud->frame->value))
		{
		case 2:     // Text box.
			Draw_TextBox(x, y, width/8-2, height/8-2);
			break;
		default:    // More will probably come.
			break;
		}
	}
}

//
// Calculate element placement.
//
qbool HUD_PrepareDrawByName(char *name, int width, int height,	// In.
							int *ret_x, int *ret_y)				// Out (Position).
{
	hud_t *hud = HUD_Find(name);
	if (hud == NULL)
	{
		return false; // error in C code
	}

	return HUD_PrepareDraw(hud, width, height, ret_x, ret_y);
}

//
// Calculate object extents and draws frame if needed.
//
qbool HUD_PrepareDraw(hud_t *hud, int width, int height, // In.
					  int *ret_x, int *ret_y)			 // Out (Position).
{
	extern vrect_t scr_vrect;
	int x, y;
	int frame_left, frame_right, frame_top, frame_bottom;	// Frame left, right, top and bottom.
	int area_x, area_y, area_width, area_height;			// Area coordinates & sizes to align.
	int bounds_x, bounds_y, bounds_width, bounds_height;	// Bounds to draw within.
	qbool draw;
	qbool show = HUD_ShouldShow(hud);

	// Don't show the hud element.
	if (cls.state < hud->min_state || !show) {
		return false;
	}

	draw = HUD_ShouldDraw(hud);

	HUD_CalcFrameExtents(hud, width, height, &frame_left, &frame_right, &frame_top, &frame_bottom);

	width  += frame_left + frame_right;
	height += frame_top + frame_bottom;

	//
	// Placement.
	//
	switch (hud->place_num)
	{
		default:
		case HUD_PLACE_SCREEN:
			bounds_x = bounds_y = 0;
			bounds_width = vid.width;
			bounds_height = vid.height;
			break;
		case HUD_PLACE_TOP: // Top = screen - sbar
			bounds_x = bounds_y = 0;
			bounds_width = vid.width;
			bounds_height = vid.height - sb_lines;
			break;
		case HUD_PLACE_VIEW:
			bounds_x = scr_vrect.x;
			bounds_y = scr_vrect.y;
			bounds_width = scr_vrect.width;
			bounds_height = scr_vrect.height;
			break;
		case HUD_PLACE_SBAR:
			bounds_x = 0;
			bounds_y = vid.height - sb_lines;
			bounds_width = sbar_last_width;
			bounds_height = sb_lines;
			break;
		case HUD_PLACE_IBAR:
			bounds_width = sbar_last_width;
			bounds_height = max(sb_lines - SBAR_HEIGHT, 0);
			bounds_x = 0;
			bounds_y = vid.height - sb_lines;
			break;
		case HUD_PLACE_HBAR:
			bounds_width = sbar_last_width;
			bounds_height = min(SBAR_HEIGHT, sb_lines);
			bounds_x = 0;
			bounds_y = vid.height - bounds_height;
			break;
		case HUD_PLACE_SFREE:
			bounds_x = sbar_last_width;
			bounds_y = vid.height - sb_lines;
			bounds_width = vid.width - sbar_last_width;
			bounds_height = sb_lines;
			break;
		case HUD_PLACE_IFREE:
			bounds_width = vid.width - sbar_last_width;
			bounds_height = max(sb_lines - SBAR_HEIGHT, 0);
			bounds_x = sbar_last_width;
			bounds_y = vid.height - sb_lines;
			break;
		case HUD_PLACE_HFREE:
			bounds_width = vid.width - sbar_last_width;
			bounds_height = min(SBAR_HEIGHT, sb_lines);
			bounds_x = sbar_last_width;
			bounds_y = vid.height - bounds_height;
			break;
	}

	if (hud->place_hud == NULL)
	{
		// Accepted boundaries are our area.
		area_x		= bounds_x;
		area_y		= bounds_y;
		area_width	= bounds_width;
		area_height	= bounds_height;
	}
	else
	{
		// Out area is our parent area.
		area_x		= hud->place_hud->lx;
		area_y		= hud->place_hud->ly;
		area_width	= hud->place_hud->lw;
		area_height = hud->place_hud->lh;

		if (hud->place_outside)
		{
			area_x		-= hud->place_hud->al;
			area_y		-= hud->place_hud->at;
			area_width	+= hud->place_hud->al + hud->place_hud->ar;
			area_height += hud->place_hud->at + hud->place_hud->ab;
		}
	}

	//
	// Horizontal pos.
	//
	switch (hud->align_x_num)
	{
		default:
		case HUD_ALIGN_LEFT:
			x = area_x;
			break;
		case HUD_ALIGN_CENTER:
			x = area_x + (area_width - width) / 2;
			break;
		case HUD_ALIGN_RIGHT:
			x = area_x + area_width - width;
			break;
		case HUD_ALIGN_BEFORE:
			x = area_x - width;
			break;
		case HUD_ALIGN_AFTER:
			x = area_x + area_width;
			break;
	}

	x += hud->pos_x->value;

	//
	// Vertical pos.
	//
	switch (hud->align_y_num)
	{
		default:
		case HUD_ALIGN_TOP:
			y = area_y;
			break;
		case HUD_ALIGN_CENTER:
			y = area_y + (area_height - height) / 2;
			break;
		case HUD_ALIGN_BOTTOM:
			y = area_y + area_height - height;
			break;
		case HUD_ALIGN_BEFORE:
			y = area_y - height;
			break;
		case HUD_ALIGN_AFTER:
			y = area_y + area_height;
			break;
		case HUD_ALIGN_CONSOLE:
			y = max(area_y, scr_con_current);
			break;
	}

	y += hud->pos_y->value;

	// Draw frame.
	if (draw) {
		HUD_DrawFrame(hud, x, y, width, height);
	}

	// Assign values.
	*ret_x = x + frame_left;
	*ret_y = y + frame_top;

	// Remember values for children.
	hud->lx = x + frame_left;
	hud->ly = y + frame_top;
	hud->lw = width - frame_left - frame_right;
	hud->lh = height - frame_top - frame_bottom;
	hud->al = frame_left;
	hud->ar = frame_right;
	hud->at = frame_top;
	hud->ab = frame_bottom;

	// Check if we're supposed to draw the entire item or just the outline/frame.
	// (If we're in hud editor align/place mode)
	if (!HUD_Editor_ConfirmDraw(hud)) {
		return false;
	}

	// Remember drawing sequence.
	hud->last_draw_sequence = host_screenupdatecount;
	return draw;
}

//
// Creates a HUD variable based on a name.
//
cvar_t * HUD_CreateVar(char *hud_name, char *subvar, char *value)
{
	cvar_t *var;
	char buf[128];

	snprintf (buf, sizeof (buf), "hud_%s_%s", hud_name, subvar);
	var = (cvar_t *)Q_malloc(sizeof(cvar_t));
	memset(var, 0, sizeof(cvar_t));

	// Set name.
	var->name = Q_strdup(buf);

	// Default. Cvar_Register will dup this string so we don't need to.
	var->string = value;

	Cvar_SetCurrentGroup(CVAR_GROUP_HUD);
	Cvar_Register(var);
	Cvar_ResetCurrentGroup();
	return var;
}

//
// Onchange for when z-order changes for a hud element. Resorts the elements.
//
void HUD_OnChangeOrder(cvar_t *var, char *val, qbool *cancel)
{
	Cvar_SetValue (var, atoi(val));

	HUD_ReorderChildren();

	HUD_Sort();
}

//
// Registers a new HUD element to the list of HUD elements.
//
hud_t * HUD_Register(char *name, char *var_alias, char *description,
					 int flags, cactive_t min_state, int draw_order,
					 hud_func_type draw_func,
					 char *show, char *place, char *align_x, char *align_y,
					 char *pos_x, char *pos_y, char *frame, char *frame_color,
					 char *item_opacity,
					 char *params, ...)
{
	int i;
	va_list     argptr;
	hud_t		*hud;
	char		*subvar;

	// We want to include Frame, frame_color, item_opacity in the list of
	// available cvar's for the user also. If any additional cvars that
	// common for all hud elements are added this needs to be increased.
	int			num_params = 3;

	// Allocate room for the HUD.
	hud = (hud_t *) Q_malloc(sizeof(hud_t));
	memset(hud, 0, sizeof(hud_t));
	hud->next = hud_huds;
	hud_huds = hud;
	hud->min_state = min_state;
	hud->draw_func = draw_func;

	// Name.
	hud->name = (char *) Q_malloc(strlen(name)+1);
	strcpy(hud->name, name);

	// Description.
	hud->description = (char *) Q_malloc(strlen(description)+1);
	strcpy(hud->description, description);

	// Count the number of params.
	subvar = params;
	va_start (argptr, params);
	while(subvar)
	{
		num_params++;
		subvar = va_arg(argptr, char *);
	}
	va_end (argptr);

	// Allocate the params array.
	hud->params = Q_calloc(num_params, sizeof(cvar_t *));

	// Set flags.
	hud->flags = flags;

	Cmd_AddCommand(name, HUD_Func_f);

	//
	// Create standard variables.
	//

	//
	// Ordering
	//
	{
		char order[18];
		snprintf (order, sizeof(order), "%d", draw_order);
		hud->order = HUD_CreateVar(name, "order", order);
		hud->order->OnChange = HUD_OnChangeOrder;
	}

	//
	// Place.
	//
	hud->place = HUD_CreateVar(name, "place", place);
	i = HUD_FindPlace(hud);
	if (i == 0)
	{
		// Probably parent should be registered earlier.
		// (This doesn't matter, since we'll re-place all elements after
		// all the elements have been registered)
		hud->place_num = 0;
		hud->place_hud = NULL;
	}

	//
	// Show.
	//
	if (show)
	{
		hud->show = HUD_CreateVar(name, "show", show);

		if (flags & HUD_PLUSMINUS)
		{
			char cmdname[128];

			strlcpy(cmdname, "+hud_", sizeof(cmdname));
			strlcat(cmdname, name, sizeof(cmdname));
			Cmd_AddRemCommand(cmdname, HUD_Plus_f);

			cmdname[0] = '-';
			Cmd_AddRemCommand(cmdname, HUD_Minus_f);

			// Add plus and minus commands.
			//Cmd_AddCommand(Q_strdup(va("+hud_%s", name)), HUD_Plus_f);
			//Cmd_AddCommand(Q_strdup(va("-hud_%s", name)), HUD_Minus_f);
		}
	}
	else
	{
		hud->flags |= HUD_NO_SHOW;
	}

	//
	// X align & pos.
	//
	if (pos_x  &&  align_x)
	{
		hud->pos_x = HUD_CreateVar(name, "pos_x", pos_x);
		hud->align_x = HUD_CreateVar(name, "align_x", align_x);
	}
	else
	{
		hud->flags |= HUD_NO_POS_X;
	}

	//
	// Y align & pos.
	//
	if (pos_y  &&  align_y)
	{
		hud->pos_y = HUD_CreateVar(name, "pos_y", pos_y);
		hud->align_y = HUD_CreateVar(name, "align_y", align_y);
	}
	else
	{
		hud->flags |= HUD_NO_POS_Y;
	}

	//
	// Frame.
	//
	if (frame)
	{
		hud->frame = HUD_CreateVar(name, "frame", frame);
		hud->params[hud->num_params++] = hud->frame;

		hud->frame_color = HUD_CreateVar(name, "frame_color", frame_color);
		hud->frame_color->OnChange = HUD_OnChangeFrameColor;
		hud->params[hud->num_params++] = hud->frame_color;
	}
	else
	{
		hud->flags |= HUD_NO_FRAME;
	}

	//
	// Item Opacity.
	//
	{
		hud->opacity = HUD_CreateVar(name, "item_opacity", (item_opacity) ? item_opacity : "1");
		hud->flags |= HUD_OPACITY;
		hud->params[hud->num_params++] = hud->opacity;
	}

	// Draw... if not set, will be measured (unlike ->show) but nothing rendered (assuming it follows standard pattern)
	hud->draw = HUD_CreateVar(name, "draw", "1");

	//
	// Create parameters.
	//
	subvar = params;
	va_start (argptr, params);

	while (subvar) {
		char *value = va_arg(argptr, char *);
		if (value == NULL || hud->num_params >= HUD_MAX_PARAMS || hud->num_params >= num_params) {
			Sys_Error("HUD_Register: HUD_MAX_PARAMS overflow");
		}

		hud->params[hud->num_params] = HUD_CreateVar(name, subvar, value);
		hud->num_params++;
		subvar = va_arg(argptr, char *);
	}

	va_end (argptr);

	return hud;
}

//
// Find element in list.
//
hud_t * HUD_Find(char *name)
{
	hud_t *hud = hud_huds;

	while (hud)
	{
		if (!strcasecmp(hud->name, name))
		{
			return hud;
		}

		hud = hud->next;
	}
	return NULL;
}

//
// Retrieve hud cvar.
//
cvar_t *HUD_FindVar(hud_t *hud, char *subvar)
{
	int i;
	char buf[128];

	snprintf(buf, sizeof(buf), "hud_%s_%s", hud->name, subvar);

	for (i=0; i < hud->num_params; i++)
	{
		if (!strcmp(buf, hud->params[i]->name))
		{
			return hud->params[i];
		}
	}

	return NULL;
}

//
// HUD_FindInitTextColorVar searches for a HUD element by name.
//
// If not found, returns NULL (same as HUD_FindVar).
//
// If found, apply the CVAR_COLOR flag to indicate the value should be parsed as
// a color.
//
// If the variable has a value, it is re-assigned to trigger correct color
// parsing.
cvar_t *HUD_FindInitTextColorVar(hud_t *hud, char *name)
{
	cvar_t *cvar;

	if ((cvar = HUD_FindVar(hud, name)) == NULL)
	{
		return NULL;
	}

	Cvar_SetFlags(cvar, Cvar_GetFlags(cvar) | CVAR_COLOR);

	if (strlen(cvar->string) > 0)
	{
		Cvar_Set(cvar, cvar->string);
	}

	return cvar;
}

//
// Draws single HUD element.
//
void HUD_DrawObject(hud_t *hud)
{
	extern qbool sb_showscores, sb_showteamscores;

	// Already tried to draw this frame.
	if (hud->last_try_sequence == host_screenupdatecount)
	{
		return;
	}

	hud->last_try_sequence = host_screenupdatecount;

	// Check if we should show this.
	if (!HUD_ShouldShow(hud)) {
		return;
	}

	if (cls.state < hud->min_state)
	{
		return;
	}


	if(hud->flags & HUD_NO_DRAW) {
		// draw only during specified events (e.g. HUD_ON_INTERMISSION)
		qbool draw = false;

		if (cl.intermission == 1 && (hud->flags & HUD_ON_INTERMISSION))
			draw = true;

		else if (cl.intermission == 2 && !(hud->flags & HUD_ON_FINALE))
			draw = true;

		else if ((sb_showscores || sb_showteamscores) && (hud->flags & HUD_ON_SCORES))
			draw = true;

		//else if (???????? && (hud->flags & HUD_ON_DIALOG))
		//	draw = true;

		if(!draw)
			return;

	} else {
		if (cl.intermission == 1 && !(hud->flags & HUD_ON_INTERMISSION))
			return;

		if (cl.intermission == 2 && !(hud->flags & HUD_ON_FINALE))
			return;

		if ((sb_showscores || sb_showteamscores) && !(hud->flags & HUD_ON_SCORES))
			return;
	}

	if (hud->place_hud)
	{
		// Parent should be drawn it should be first.
		HUD_DrawObject(hud->place_hud);

		// If parent was not drawn, we refuse to draw too
		if (hud->place_hud->last_draw_sequence < host_screenupdatecount)
		{
			return;
		}
	}

	//
	// Let the HUD element draw itself - updates last_draw_sequence itself.
	//
	Draw_SetOverallAlpha(hud->opacity->value);
	hud->draw_func(hud);
	Draw_SetOverallAlpha(1.0);

	// last_draw_sequence is update by HUD_PrepareDraw
	// if object was succesfully drawn (wasn't outside area etc..)
}

//
// Draw all active elements.
//
void HUD_Draw(void)
{
	extern cvar_t scr_newHud;
	hud_t *hud;

	// Only draw the hud once in multiview.
	if (cl_multiview.integer && cls.mvdplayback)
	{
		if (CL_MultiviewCurrentView() != 1)
		{
			return;
		}
	}

	if (mvd_autohud.integer && !autohud_loaded)
	{
		HUD_AutoLoad_MVD((int) mvd_autohud.value);
		Com_DPrintf("Loading AUTOHUD...\n");
		autohud_loaded = true;
	}

	if (scr_newHud.value == 0)
	{
		return;
	}

	hud = hud_huds;

	HUD_BeforeDraw();

	while (hud)
	{
		// Draw.
		HUD_DrawObject(hud);

		// Go to next.
		hud = hud->next;
	}

	HUD_AfterDraw();
}

//
// Compares two hud elements.
//
int HUD_OrderFunc(const void * p_h1, const void * p_h2)
{
	const hud_t *h1 = *((hud_t **)p_h1);
	const hud_t *h2 = *((hud_t **)p_h2);

	return (int)h1->order->value - (int)h2->order->value;
}

//
// Last phase of initialization.
//
void HUD_Sort(void)
{
	// Sort elements based on their draw order.
	int i;
	hud_t *huds[MAX_HUD_ELEMENTS];
	int count = 0;
	hud_t *hud;

	// Copy to table.
	hud = hud_huds;
	while (hud)
	{
		huds[count++] = hud;
		hud = hud->next;
	}

	if (count <= 0)
		return;

	// Sort table.
	qsort(huds, count, sizeof(huds[0]), HUD_OrderFunc);

	// Back to list.
	hud_huds = huds[0];
	hud = hud_huds;
	hud->next = NULL;
	for (i=1; i < count; i++)
	{
		hud->next = huds[i];
		hud = hud->next;
		hud->next = NULL;
	}

	// Recalculate elements so vars are parsed.
	HUD_Recalculate();
}

#define HUD_FreeVar(var) \
	if ((var)) { \
		Cvar_Delete(var->name); \
		(var) = NULL; \
	}

void HUD_Shutdown(void)
{
	hud_t* hud = hud_huds;
	int i;

	while (hud) {
		hud_t* next = hud->next;

		Q_free(hud->description);
		HUD_FreeVar(hud->order);
		HUD_FreeVar(hud->place);
		HUD_FreeVar(hud->show);
		HUD_FreeVar(hud->draw);
		HUD_FreeVar(hud->pos_x);
		HUD_FreeVar(hud->align_x);
		HUD_FreeVar(hud->pos_y);
		HUD_FreeVar(hud->align_y);

		// don't delete hud->frame/frame_color/opacity, they're in params array
		for (i = 0; i < hud->num_params; ++i) {
			HUD_FreeVar(hud->params[i]);
		}
		Q_free(hud->params);
		Q_free(hud->name);
		Q_free(hud);

		hud = next;
	}
	hud_huds = NULL;
}


================================================
FILE: src/hud.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
//
// HUD commands
//

#ifndef __hud_h__
#define __hud_h__

// flags
#define HUD_NO_DRAW            (1 <<  0)  // draw only during specified events (e.g. elements with flags = HUD_NO_DRAW | HUD_ON_INTERMISSION
                                          // will only draw during the intermission)
#define HUD_NO_SHOW            (1 <<  1)  // doesn't support show/hide
#define HUD_NO_POS_X           (1 <<  2)  // doesn't support x positioning
#define HUD_NO_POS_Y           (1 <<  3)  // doesn't support y positioning
#define HUD_NO_FRAME           (1 <<  4)  // don't add frame
#define HUD_ON_DIALOG          (1 <<  5)  // draw on dialog too
#define HUD_ON_INTERMISSION    (1 <<  6)  // draw on intermission too
#define HUD_ON_FINALE          (1 <<  7)  // draw on finale too
#define HUD_ON_SCORES          (1 <<  8)  // draw on +showscores too
#define HUD_NO_GROW            (1 <<  9)  // no frame grow
#define HUD_PLUSMINUS          (1 << 10)  // auto add +/- commands
#define HUD_OPACITY				(1 << 11)

#define HUD_INVENTORY          (HUD_NO_GROW)   // aply for sbar elements

#define HUD_MAX_PARAMS  32

#define	HUD_REGEXP_OFFSET_COUNT	20

// Placement
#define HUD_PLACE_SCREEN		1
#define HUD_PLACE_TOP			2
#define HUD_PLACE_VIEW			3
#define HUD_PLACE_SBAR			4
#define HUD_PLACE_IBAR			5
#define HUD_PLACE_HBAR			6
#define HUD_PLACE_SFREE			7
#define HUD_PLACE_IFREE			8
#define HUD_PLACE_HFREE			9

// Alignment
#define HUD_ALIGN_LEFT			1
#define HUD_ALIGN_TOP			1
#define HUD_ALIGN_CENTER		2
#define HUD_ALIGN_RIGHT			3
#define HUD_ALIGN_BOTTOM		3
#define HUD_ALIGN_BEFORE		4
#define HUD_ALIGN_AFTER			5
#define HUD_ALIGN_CONSOLE		6

typedef struct hud_s
{
    char *name;							// Element name.
    char *description;					// Little help.

    void (*draw_func) (struct hud_s *);	// Drawing function.

	cvar_t *order;						// Higher it is, later this element will be drawn
										// and more probable that will be on top.

    cvar_t* show;                       // Show cvar.
    cvar_t* draw;                       // Draw cvar
    cvar_t* frame;                      // Frame cvar.
    cvar_t* frame_color;                // Frame color cvar.
    byte    frame_color_cache[4];       // Cache for parsed frame color.
    qbool   frame_hide;                 // Toggle whether frame should be displayed or not.

	cvar_t *opacity;					// The overall opacity of the entire HUD element.

    // placement
    cvar_t *place;						// Place string, parsed to:
    struct hud_s *place_hud;			// if snapped to hud element
    qbool place_outside;				// if hud: inside ot outside
    int place_num;						// place number (our or parent if hud)
										// note: item is placed at another HUD element
										// if place_hud != NULL

    cvar_t *align_x;					// Alignment cvars (left, right, ...)
    cvar_t *align_y;
    int    align_x_num;					// Parsed alignment.
    int    align_y_num;

    cvar_t *pos_x;						// Position cvars.
    cvar_t *pos_y;

	cvar_t **params;					// Registered parameters for the HUD element.
    int num_params;

    cactive_t  min_state;				// At least this state is required
										// to draw this element.

    unsigned   flags;

    // Last draw parameters (mostly used by children)
    int lx, ly, lw, lh;					// Last position.
    int al, ar, at, ab;					// Last frame params.

    int last_try_sequence;				// Sequence, at which object tried to draw itself.
    int last_draw_sequence;				// Sequence, at which it was last drawn successfully.

    struct hud_s *next;					// Next HUD in the list.
} hud_t;

typedef  void (*hud_func_type) (struct hud_s *);

#define MAX_HUD_ELEMENTS 256

//
// Initialize
// 
void HUD_Init(void);

//
// Add element to list
// parameter format: "name1", "default1", ..., "nameX", "defaultX", NULL
//
hud_t * HUD_Register(char *name, char *var_alias, char *description,
                     int flags, cactive_t min_state, int draw_order,
                     hud_func_type draw_func,
                     char *show, char *place, char *align_x, char *align_y,
                     char *pos_x, char *pos_y, char *frame, char *frame_color,
                     char *item_opacity, char *params, ...);


//
// Draw all active elements.
//
void HUD_Draw(void);

//
// Retrieve hud cvar.
//
cvar_t *HUD_FindVar(hud_t *hud, char *subvar);

//
// Retrieve hud cvar by name and apply text color flags and parsing.
//
cvar_t *HUD_FindInitTextColorVar(hud_t *hud, char *name);

//
// Find element in list.
//
hud_t * HUD_Find(char *name);

//
// Calculate screen position of element.
// return value:
//    true  - draw it
//    false - don't draw, it is off screen (mayby partially)
//
qbool HUD_PrepareDraw(
			hud_t *hud, int width, int height,		// In.
			int *ret_x, int *ret_y);				// Out.

qbool HUD_PrepareDrawByName(
			char *element, int width, int height,	// In.
			int *ret_x, int *ret_y);				// Out.


// Sort all HUD Elements.
void HUD_Sort(void);

void HUD_Shutdown(void);

// Recalculate the position of all hud elements.
void HUD_Recalculate(void);

// when show pre-selected weapon/ammo? 1) player uses this system 2) not dead 3) when playing
#define ShowPreselectedWeap()  (cl_weaponpreselect.value && cl.stats[STAT_HEALTH] > 0 && !cls.demoplayback && !cl.spectator)

#define HUD_SHOW_ONLY_IN_TEAMPLAY		1
#define HUD_SHOW_ONLY_IN_DEMOPLAYBACK	2

qbool HUD_ShowInDemoplayback(int val);

// Returns the total damage a player can sustain (stack)
float SCR_HUD_TotalStrength(float health, float armorValue, float armorType);

// Converts stats[STAT_ITEM] to armor %
float SCR_HUD_ArmorType(int items);

// Radar functions
void Radar_HudInit(void);
void HUD_NewRadarMap(void);

#endif // __hud_h__


================================================
FILE: src/hud_262.c
================================================
/*
Copyright (C) 1996-2003 Id Software, Inc., A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// Moved from cl_screen.c
/// declarations may be found in screen.h

#include "quakedef.h"
#include <time.h>
#include "keys.h"
#include "hud.h"
#include "hud_common.h"
#include "hud_editor.h"
#include "utils.h"
#include "gl_model.h"
#include "teamplay.h"
#include "input.h"
#include "utils.h"
#include "sbar.h"
#include "menu.h"
#include "image.h"

qbool CachePic_RemoveByPic(mpic_t* pic);

static char *hud262_load_buff = NULL;

extern cvar_t cl_hud;

/**************************************** 262 HUD *****************************/
// QW262 -->
hud_element_t *hud_list = NULL;
hud_element_t *prev;

char *Macro_BestAmmo(void); // Teamplay.c
void Draw_AlphaRectangle(int x, int y, int w, int h, int c, float thickness, qbool fill, float alpha); // gl_draw.c

void SCR_OnChangeMVHudPos(cvar_t *var, char *newval, qbool *cancel);

void Hud_262LoadOnFirstStart(void)
{
	if (hud262_load_buff != NULL) {
		Cbuf_AddText(hud262_load_buff);
		Cbuf_Execute();
	}
	Q_free(hud262_load_buff);
}
// <-- QW262

hud_element_t *Hud_FindElement(const char *name)
{
	hud_element_t *elem;

	prev = NULL;
	for (elem = hud_list; elem; elem = elem->next) {
		if (!strcasecmp(name, elem->name))
			return elem;
		prev = elem;
	}

	return NULL;
}

qbool Hud_ElementExists(const char* name)
{
	return Hud_FindElement(name) != NULL;
}

static hud_element_t* Hud_NewElement(void)
{
	hud_element_t*	elem;
	elem = (hud_element_t *)Q_malloc(sizeof(hud_element_t));
	elem->next = hud_list;
	hud_list = elem;
	elem->name = Q_strdup(Cmd_Argv(1));
	return elem;
}

static void Hud_DeleteElement(hud_element_t *elem)
{
	if (elem->flags & (HUD_STRING))
		Q_free(elem->contents);
	if (elem->flags & (HUD_IMAGE))
		CachePic_RemoveByPic(elem->contents);
	if (elem->f_hover)
		Q_free(elem->f_hover);
	if (elem->f_button)
		Q_free(elem->f_button);
	Q_free(elem->name);
	Q_free(elem);
}

typedef void Hud_Elem_func(hud_element_t*);

void Hud_ReSearch_do(Hud_Elem_func f)
{
	hud_element_t *elem;

	for (elem = hud_list; elem; elem = elem->next) {
		if (ReSearchMatch(elem->name))
			f(elem);
	}
}

void Hud_Add_f(void)
{
	hud_element_t*	elem;
	struct hud_element_s*	next = NULL;	// Sergio
	qbool	hud_restore = false;	// Sergio
	cvar_t		*var;
	char		*a2, *a3;
	//Hud_Func	func;
	unsigned	old_coords = 0;
	unsigned	old_width = 0;
	float		old_alpha = 1;
	qbool	old_enabled = true;

	if (Cmd_Argc() != 4)
		Com_Printf("Usage: hud_add <name> <type> <param>\n");
	else {
		if ((elem = Hud_FindElement(Cmd_Argv(1)))) {
			if (elem) {
				old_coords = *((unsigned*)&(elem->coords));
				old_width = elem->width;
				old_alpha = elem->alpha;
				old_enabled = elem->flags & HUD_ENABLED;
				next = elem->next; // Sergio
				if (prev) {
					prev->next = elem->next;
					hud_restore = true; // Sergio
				}
				else
					hud_list = elem->next;
				Hud_DeleteElement(elem);
			}
		}

		a2 = Cmd_Argv(2);
		a3 = Cmd_Argv(3);

		if (!strcasecmp(a2, "cvar")) {
			if ((var = Cvar_Find(a3))) {
				elem = Hud_NewElement();
				elem->contents = var;
				elem->flags = HUD_CVAR | HUD_ENABLED;
			}
			else {
				Com_Printf("cvar \"%s\" not found\n", a3);
				return;
			}
		}
		else if (!strcasecmp(a2, "str")) {
			elem = Hud_NewElement();
			elem->contents = Q_strdup(a3);
			elem->flags = HUD_STRING | HUD_ENABLED;
		}
		else if (!strcasecmp(a2, "img")) {
			char* pic_path = Q_strdup(a3);
			mpic_t* tmp_pic;
			if (pic_path && strlen(pic_path) > 0) {
				// Try loading the pic.
				if (!(tmp_pic = Draw_CachePicSafe(pic_path, false, true))) {
					Com_Printf("Couldn't load picture %s for '%s'\n", pic_path, a2);
					return;
				}
				elem = Hud_NewElement();
				elem->contents = tmp_pic;
				elem->flags = HUD_IMAGE | HUD_ENABLED;
			}
		}
		else {
			Com_Printf("\"%s\" is not a valid hud type\n", a2);
			return;
		}

		*((unsigned*)&(elem->coords)) = old_coords;
		elem->width = old_width;
		elem->alpha = old_alpha;
		if (!old_enabled)
			elem->flags &= ~HUD_ENABLED;

		// Sergio -->
		// Restoring old hud place in hud_list
		if (hud_restore) {
			hud_list = elem->next;
			elem->next = next;
			prev->next = elem;
		}
		// <-- Sergio
	}
}

void Hud_Elem_Remove(hud_element_t *elem)
{
	if (prev)
		prev->next = elem->next;
	else
		hud_list = elem->next;
	Hud_DeleteElement(elem);
}

void Hud_Remove_f(void)
{
	hud_element_t	*elem, *next_elem;
	char			*name;
	int				i;

	for (i = 1; i < Cmd_Argc(); i++) {
		name = Cmd_Argv(i);
		if (IsRegexp(name)) {
			if (!ReSearchInit(name))
				return;
			prev = NULL;
			for (elem = hud_list; elem; ) {
				if (ReSearchMatch(elem->name)) {
					next_elem = elem->next;
					Hud_Elem_Remove(elem);
					elem = next_elem;
				}
				else {
					prev = elem;
					elem = elem->next;
				}
			}
			ReSearchDone();
		}
		else {
			if ((elem = Hud_FindElement(name)))
				Hud_Elem_Remove(elem);
			else
				Com_Printf("HudElement \"%s\" not found\n", name);
		}
	}
}

void Hud_Position_f(void)
{
	hud_element_t *elem;

	if (Cmd_Argc() != 5) {
		Com_Printf("Usage: hud_position <name> <pos_type> <x> <y>\n");
		return;
	}
	if (!(elem = Hud_FindElement(Cmd_Argv(1)))) {
		Com_Printf("HudElement \"%s\" not found\n", Cmd_Argv(1));
		return;
	}

	elem->coords[0] = atoi(Cmd_Argv(2));
	elem->coords[1] = atoi(Cmd_Argv(3));
	elem->coords[2] = atoi(Cmd_Argv(4));
}

void Hud_Elem_Bg(hud_element_t *elem)
{
	elem->coords[3] = atoi(Cmd_Argv(2));
}

void Hud_Bg_f(void)
{
	hud_element_t *elem;
	char	*name = Cmd_Argv(1);

	if (Cmd_Argc() != 3)
		Com_Printf("Usage: hud_bg <name> <bgcolor>\n");
	else if (IsRegexp(name)) {
		if (!ReSearchInit(name))
			return;
		Hud_ReSearch_do(Hud_Elem_Bg);
		ReSearchDone();
	}
	else {
		if ((elem = Hud_FindElement(name)))
			Hud_Elem_Bg(elem);
		else
			Com_Printf("HudElement \"%s\" not found\n", name);
	}
}

void Hud_Elem_Move(hud_element_t *elem)
{
	elem->coords[1] += atoi(Cmd_Argv(2));
	elem->coords[2] += atoi(Cmd_Argv(3));
}

void Hud262_Move_f(void)
{
	hud_element_t *elem;
	char	*name = Cmd_Argv(1);

	if (Cmd_Argc() != 4)
		Com_Printf("Usage: hud_move <name> <dx> <dy>\n");
	else if (IsRegexp(name)) {
		if (!ReSearchInit(name))
			return;
		Hud_ReSearch_do(Hud_Elem_Move);
		ReSearchDone();
	}
	else {
		if ((elem = Hud_FindElement(name)))
			Hud_Elem_Move(elem);
		else
			Com_Printf("HudElement \"%s\" not found\n", name);
	}
}

void Hud_Elem_Width(hud_element_t *elem)
{
	if (elem->flags & HUD_IMAGE) {
		mpic_t *pic = elem->contents;
		int width = atoi(Cmd_Argv(2)) * 8;
		int height = width * pic->height / pic->width;
		pic->height = height;
		pic->width = width;
	}
	elem->width = max(min(atoi(Cmd_Argv(2)), 128), 0);
}

void Hud_Width_f(void)
{
	hud_element_t *elem;
	char	*name = Cmd_Argv(1);

	if (Cmd_Argc() != 3)
		Com_Printf("Usage: hud_width <name> <width>\n");
	else if (IsRegexp(name)) {
		if (!ReSearchInit(name))
			return;
		Hud_ReSearch_do(Hud_Elem_Width);
		ReSearchDone();
	}
	else {
		if ((elem = Hud_FindElement(name)))
			Hud_Elem_Width(elem);
		else
			Com_Printf("HudElement \"%s\" not found\n", name);
	}
}

void Hud_Elem_Alpha(hud_element_t *elem)
{
	float alpha = atof(Cmd_Argv(2));
	elem->alpha = bound(0, alpha, 1);
}

void Hud_Alpha_f(void)
{
	hud_element_t *elem;
	char	*name = Cmd_Argv(1);

	if (Cmd_Argc() != 3) {
		Com_Printf("hud_alpha <name> <value> : set HUD transparency (0..1)\n");
		return;
	}
	if (IsRegexp(name)) {
		if (!ReSearchInit(name))
			return;
		Hud_ReSearch_do(Hud_Elem_Alpha);
		ReSearchDone();
	}
	else {
		if ((elem = Hud_FindElement(name)))
			Hud_Elem_Alpha(elem);
		else
			Com_Printf("HudElement \"%s\" not found\n", name);
	}
}

void Hud_Elem_Blink(hud_element_t *elem)
{
	double		blinktime;
	unsigned	mask;

	blinktime = atof(Cmd_Argv(2)) / 1000.0;
	mask = atoi(Cmd_Argv(3));

	if (mask > 3) return; // bad mask
	if (blinktime < 0.0 || blinktime > 5.0) return;

	elem->blink = blinktime;
	elem->flags = (elem->flags & (~(HUD_BLINK_F | HUD_BLINK_B))) | (mask << 3);
}

void Hud_Blink_f(void)
{
	hud_element_t *elem;
	char	*name = Cmd_Argv(1);

	if (Cmd_Argc() != 4)
		Com_Printf("Usage: hud_blink <name> <ms> <mask>\n");
	else if (IsRegexp(name)) {
		if (!ReSearchInit(name))
			return;
		Hud_ReSearch_do(Hud_Elem_Blink);
		ReSearchDone();
	}
	else {
		if ((elem = Hud_FindElement(name)))
			Hud_Elem_Blink(elem);
		else
			Com_Printf("HudElement \"%s\" not found\n", name);
	}
}

void Hud_Elem_Disable(hud_element_t *elem)
{
	elem->flags &= ~HUD_ENABLED;
}

void Hud_Disable_f(void)
{
	hud_element_t	*elem;
	char			*name;
	int				i;

	for (i = 1; i < Cmd_Argc(); i++) {
		name = Cmd_Argv(i);
		if (IsRegexp(name)) {
			if (!ReSearchInit(name))
				return;
			Hud_ReSearch_do(Hud_Elem_Disable);
			ReSearchDone();
		}
		else {
			if ((elem = Hud_FindElement(name)))
				Hud_Elem_Disable(elem);
			else
				Com_Printf("HudElement \"%s\" not found\n", name);
		}
	}
}

void Hud_Elem_Enable(hud_element_t *elem)
{
	elem->flags |= HUD_ENABLED;
}

void Hud_Enable_f(void)
{
	hud_element_t	*elem;
	char			*name;
	int				i;

	for (i = 1; i < Cmd_Argc(); i++) {
		name = Cmd_Argv(i);
		if (IsRegexp(name)) {
			if (!ReSearchInit(name))
				return;
			Hud_ReSearch_do(Hud_Elem_Enable);
			ReSearchDone();
		}
		else {
			if ((elem = Hud_FindElement(name)))
				Hud_Elem_Enable(elem);
			else
				Com_Printf("HudElement \"%s\" not found\n", name);
		}
	}
}

void Hud_List_f(void)
{
	hud_element_t	*elem;
	char			*type;
	char			*param;
	int				c, i, m;

	c = Cmd_Argc();
	if (c > 1)
		if (!ReSearchInit(Cmd_Argv(1)))
			return;

	Com_Printf("List of hud elements:\n");
	for (elem = hud_list, i = m = 0; elem; elem = elem->next, i++) {
		if (c == 1 || ReSearchMatch(elem->name)) {
			if (elem->flags & HUD_CVAR) {
				type = "cvar";
				param = ((cvar_t*)elem->contents)->name;
			}
			else if (elem->flags & HUD_STRING) {
				type = "str";
				param = elem->contents;
			}
			else if (elem->flags & HUD_FUNC) {
				type = "std";
				param = "***";
			}
			else if (elem->flags & HUD_IMAGE) {
				type = "img";
				param = "***";
			}
			else {
				type = "invalid type";
				param = "***";
			}
			m++;
			Com_Printf("%s : %s : %s\n", elem->name, type, param);
		}
	}

	Com_Printf("------------\n%i/%i hud elements\n", m, i);
	if (c > 1)
		ReSearchDone();
}

void Hud_BringToFront_f(void)
{
	hud_element_t *elem, *start, *end;

	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: hud_bringtofront <name>\n");
		return;
	}

	end = Hud_FindElement(Cmd_Argv(1));
	if (end) {
		if (end->next) {
			start = hud_list;
			hud_list = end->next;
			end->next = NULL;
			for (elem = hud_list; elem->next; elem = elem->next) {}
			elem->next = start;
		}
	}
	else {
		Com_Printf("HudElement \"%s\" not found\n", Cmd_Argv(1));
	}
}

static qbool Hud_TranslateCoords(hud_element_t *elem, int *x, int *y)
{
	int l;

	if (!elem->scr_width || !elem->scr_height)
		return false;

	l = elem->scr_width / 8;

	switch (elem->coords[0]) {
	case 1:	*x = elem->coords[1] * 8 + 1;					// top left
		*y = elem->coords[2] * 8;
		break;
	case 2:	*x = vid.conwidth - (elem->coords[1] + l) * 8 - 1;	// top right
		*y = elem->coords[2] * 8;
		break;
	case 3:	*x = vid.conwidth - (elem->coords[1] + l) * 8 - 1;	// bottom right
		*y = vid.conheight - sb_lines - (elem->coords[2] + 1) * 8;
		break;
	case 4:	*x = elem->coords[1] * 8 + 1;					// bottom left
		*y = vid.conheight - sb_lines - (elem->coords[2] + 1) * 8;
		break;
	case 5:	*x = vid.conwidth / 2 - l * 4 + elem->coords[1] * 8;// top center
		*y = elem->coords[2] * 8;
		break;
	case 6:	*x = vid.conwidth / 2 - l * 4 + elem->coords[1] * 8;// bottom center
		*y = vid.conheight - sb_lines - (elem->coords[2] + 1) * 8;
		break;
	default:
		return false;
	}
	return true;
}

void SCR_DrawHud(void)
{
	hud_element_t* elem;
	int x, y;
	unsigned int l;
	char buf[1024];
	char *st = NULL;
	Hud_Func func;
	double tblink = 0.0;
	mpic_t *img = NULL;

	if (hud_list && cl_hud.value && !((cls.demoplayback || cl.spectator) && cl_restrictions.value)) {
		for (elem = hud_list; elem; elem = elem->next) {
			if (!(elem->flags & HUD_ENABLED)) {
				continue; // do not draw disabled elements
			}

			elem->scr_height = 8;

			if (elem->flags & HUD_CVAR) {
				st = ((cvar_t*)elem->contents)->string;
				strlcpy(buf, st, sizeof(buf));
				st = buf;
				l = strlen_color(st);
			}
			else if (elem->flags & HUD_STRING) {
				Cmd_ExpandString(elem->contents, buf); //, sizeof(buf));
				st = TP_ParseMacroString(buf);
				st = TP_ParseFunChars(st, false);
				l = strlen_color(st);
			}
			else if (elem->flags & HUD_FUNC) {
				func = (Hud_Func)elem->contents;
				st = (*func)();
				l = strlen(st);
			} else if (elem->flags & HUD_IMAGE) {
				img = (mpic_t*)elem->contents;
				l = img->width/8;
				elem->scr_height = img->height;
			}
			else {
				continue;
			}

			if (elem->width && !(elem->flags & (HUD_FUNC | HUD_IMAGE))) {
				if (elem->width < l) {
					l = elem->width;
					st[l] = '\0';
				}
				else {
					while (elem->width > l) {
						st[l++] = ' ';
					}
					st[l] = '\0';
				}
			}
			elem->scr_width = l * 8;

			if (!Hud_TranslateCoords(elem, &x, &y)) {
				continue;
			}

			if (elem->flags & (HUD_BLINK_B | HUD_BLINK_F)) {
				tblink = fmod(cls.realtime, elem->blink) / elem->blink;
			}

			if (!(elem->flags & HUD_BLINK_B) || tblink < 0.5) {
				if (elem->coords[3]) {
					if (elem->alpha < 1) {
						Draw_AlphaFill(x, y, elem->scr_width, elem->scr_height, (unsigned char)elem->coords[3], elem->alpha);
					}
					else {
						Draw_Fill(x, y, elem->scr_width, elem->scr_height, (unsigned char)elem->coords[3]);
					}
				}
			}
			if (!(elem->flags & HUD_BLINK_F) || tblink < 0.5) {
				if (!(elem->flags & HUD_IMAGE)) {
					/*
					int std_charset = char_textures[0];
					if (elem->charset) {
						char_textures[0] = elem->charset;
					}*/
					if (elem->alpha < 1) {
						Draw_AlphaString(x, y, st, elem->alpha);
					}
					else {
						Draw_String(x, y, st);
					}
					//char_textures[0] = std_charset;
				}
				else {
					if (elem->alpha < 1) {
						Draw_AlphaPic(x, y, img, elem->alpha);
					}
					else {
						Draw_Pic(x, y, img);
					}
				}
			}
		}
	}
}

// QW262 -->
void Hud_262Init(void)
{
	//
	// register hud commands
	//
	Cmd_AddCommand("hud262_add", Hud_Add_f);
	Cmd_AddCommand("hud262_remove", Hud_Remove_f);
	Cmd_AddCommand("hud262_position", Hud_Position_f);
	Cmd_AddCommand("hud262_bg", Hud_Bg_f);
	Cmd_AddCommand("hud262_move", Hud262_Move_f);
	Cmd_AddCommand("hud262_width", Hud_Width_f);
	Cmd_AddCommand("hud262_alpha", Hud_Alpha_f);
	Cmd_AddCommand("hud262_blink", Hud_Blink_f);
	Cmd_AddCommand("hud262_disable", Hud_Disable_f);
	Cmd_AddCommand("hud262_enable", Hud_Enable_f);
	Cmd_AddCommand("hud262_list", Hud_List_f);
	Cmd_AddCommand("hud262_bringtofront", Hud_BringToFront_f);
}

void Hud_262CatchStringsOnLoad(char *line)
{
	char *tmpbuff;

	if (Utils_RegExpMatch("^((\\s+)?(?i)hud262_(add|alpha|bg|blink|disable|enable|position|width))", line)) {
		if (hud262_load_buff == NULL) {
			hud262_load_buff = (char*)Q_malloc((strlen(line) + 2) * sizeof(char));
			snprintf(hud262_load_buff, strlen(line) + 2, "%s\n", line);
		}
		else {
			tmpbuff = (char *)Q_malloc(strlen(hud262_load_buff) + 1);
			strcpy(tmpbuff, hud262_load_buff);
			hud262_load_buff = (char *)Q_realloc(hud262_load_buff, (strlen(tmpbuff) + strlen(line) + 2) * sizeof(char));
			snprintf(hud262_load_buff, strlen(tmpbuff) + strlen(line) + 2, "%s%s\n", tmpbuff, line);
			Q_free(tmpbuff);
		}
	}
}


================================================
FILE: src/hud_ammo.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
//
// common HUD elements
// like clock etc..
//

#include "quakedef.h"
#include "gl_model.h"
#include "hud.h"
#include "hud_common.h"
#include "fonts.h"

extern cvar_t hud_tp_need;
extern cvar_t tp_need_shells, tp_need_nails, tp_need_rockets, tp_need_cells;

static int TP_TeamFortressEngineerSpanner(void)
{
	if (cl.teamfortress) {
		// MEAG: Fixme!
		char *player_skin = Info_ValueForKey(cl.players[cl.playernum].userinfo, "skin");
		char *model_name = cl.model_precache[CL_WeaponModelForView()->current.modelindex]->name;
		if (player_skin && (strcasecmp(player_skin, "tf_eng") == 0) && model_name && (strcasecmp(model_name, "progs/v_span.mdl") == 0)) {
			return 1;
		}
	}
	return 0;
}

static int State_AmmoNumForWeapon(int weapon)
{	// returns ammo number (shells = 1, nails = 2, rox = 3, cells = 4) for given weapon
	switch (weapon) {
		case 2: case 3: return 1;
		case 4: case 5: return 2;
		case 6: case 7: return 3;
		case 8: return 4;
		default: return 0;
	}
}

static int State_AmmoForWeapon(int weapon)
{	// returns ammo amount for given weapon
	int ammon = State_AmmoNumForWeapon(weapon);

	if (ammon)
		return cl.stats[STAT_SHELLS + ammon - 1];
	else
		return 0;
}

static int TP_IsAmmoLow(int weapon)
{
	int ammo = State_AmmoForWeapon(weapon);
	switch (weapon) {
		case 2:
		case 3:  return ammo <= tp_need_shells.value;
		case 4:
		case 5:  return ammo <= tp_need_nails.value;
		case 6:
		case 7:  return ammo <= tp_need_rockets.value;
		case 8:  return ammo <= tp_need_cells.value;
		default: return 0;
	}
}

int HUD_AmmoLowByWeapon(int weapon)
{
	if (hud_tp_need.value) {
		return TP_IsAmmoLow(weapon);
	}
	else {
		int a;
		switch (weapon) {
			case 2:
			case 3:
				a = STAT_SHELLS; break;
			case 4:
			case 5:
				a = STAT_NAILS; break;
			case 6:
			case 7:
				a = STAT_ROCKETS; break;
			case 8:
				a = STAT_CELLS; break;
			default:
				return false;
		}
		return (HUD_Stats(a) <= 10);
	}
}

static void SCR_HUD_DrawAmmo(
	hud_t *hud, int num, float scale, int style, int digits, char *s_align, qbool proportional, qbool always,
	byte *text_color_low, byte *text_color_normal
)
{
	extern mpic_t sb_ib_ammo[4];
	int value, num_old;
	qbool low;

	num_old = num;
	if (num < 1 || num > 4) {	// draw 'current' ammo, which one is it?
		if (ShowPreselectedWeap()) {
			// using weapon pre-selection so show info for current best pre-selected weapon ammo
			num = State_AmmoNumForWeapon(IN_BestWeapon(true));
		}
		else {
			// not using weapon pre-selection or player is dead so show current selected ammo
			if (HUD_Stats(STAT_ITEMS) & IT_SHELLS) {
				num = 1;
			}
			else if (HUD_Stats(STAT_ITEMS) & IT_NAILS) {
				num = 2;
			}
			else if (HUD_Stats(STAT_ITEMS) & IT_ROCKETS) {
				num = 3;
			}
			else if (HUD_Stats(STAT_ITEMS) & IT_CELLS) {
				num = 4;
			}
			else if (TP_TeamFortressEngineerSpanner()) {
				num = 4;
			}
			else {
				num = 0;
			}
		}
	}

	// 'New HUD' used to just return - instead draw blank space so other objects can be placed
	// If user has specified 'show_always', carry on and show current value of STAT_AMMO
	if (!num && !always) {
		if (style < 2 || style == 3) {
			// use this to calculate sizes, but draw_content is false
			SCR_HUD_DrawNum2(hud, 0, false, scale, style, digits, s_align, proportional, false, text_color_low, text_color_normal);
		}
		else {
			int x_, y;

			// calculate sizes but draw nothing
			HUD_PrepareDraw(hud, 42 * scale, 11 * scale, &x_, &y);
		}
		return;
	}

	low = HUD_AmmoLowByWeapon(num * 2);
	if (num < 1 || num > 4 || (num_old == 0 && (!ShowPreselectedWeap() || cl.standby))) {
		// this check is here to display a feature from KTPRO/KTX where you can see received damage in prewar
		// also we make sure this applies only to 'ammo' element
		// weapon preselection must always use HUD_Stats()
		value = cl.stats[STAT_AMMO];
	}
	else {
		value = HUD_Stats(STAT_SHELLS + num - 1);
	}

	if (style < 2 || style == 3) {
		// simply draw number
		SCR_HUD_DrawNum2(hud, value, style == 3 ? false : low, scale, style, digits, s_align, proportional, true, text_color_low, text_color_normal);
	}
	else {
		// else - draw classic ammo-count box with background
		char buf[8];
		int  x_, y;
		float x;
		text_alignment_t align;

		align = text_align_right;
		switch (tolower(s_align[0])) {
			case 'l':   // 'l'eft
				align = text_align_left; break;
			case 'c':   // 'c'enter
				align = text_align_center; break;
			default:
			case 'r':   // 'r'ight
				align = text_align_right; break;
		}

		scale = max(scale, 0.01);
		if (!HUD_PrepareDraw(hud, 42 * scale, 11 * scale, &x_, &y)) {
			return;
		}

		x = x_;
		if (num >= 1 && num <= sizeof(sb_ib_ammo) / sizeof(sb_ib_ammo[0]) && R_TextureReferenceIsValid(sb_ib_ammo[num - 1].texnum)) {
			Draw_SPic(x, y, &sb_ib_ammo[num - 1], scale);
		}

		snprintf(buf, sizeof(buf), "%d", value);

		// convert to nicer numbers
		buf[0] = buf[0] >= '0' ? 18 + buf[0] - '0' : buf[0];
		buf[1] = buf[1] >= '0' ? 18 + buf[1] - '0' : buf[1];
		buf[2] = buf[2] >= '0' ? 18 + buf[2] - '0' : buf[2];

		Draw_SStringAligned(x, y, buf, scale, 1.0f, proportional, align, x + 30 * scale);
	}
}

void SCR_HUD_DrawAmmoCurrent(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *proportional, *always, *text_color_low, *text_color_normal;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		proportional = HUD_FindVar(hud, "proportional");
		always = HUD_FindVar(hud, "show_always");
		text_color_low = HUD_FindInitTextColorVar(hud, "text_color_low");
		text_color_normal = HUD_FindInitTextColorVar(hud, "text_color_normal");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmo(hud, 0, scale->value, style->value, digits->value, align->string,
			proportional->integer, always->integer,
			strlen(text_color_low->string) == 0 ? NULL : text_color_low->color,
			strlen(text_color_normal->string) == 0 ? NULL : text_color_normal->color);
	}
}

void SCR_HUD_DrawAmmo1(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *proportional, *text_color_low, *text_color_normal;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		proportional = HUD_FindVar(hud, "proportional");
		text_color_low = HUD_FindInitTextColorVar(hud, "text_color_low");
		text_color_normal = HUD_FindInitTextColorVar(hud, "text_color_normal");
	}

	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmo(hud, 1, scale->value, style->value, digits->value, align->string,
			proportional->integer, true,
			strlen(text_color_low->string) == 0 ? NULL : text_color_low->color,
			strlen(text_color_normal->string) == 0 ? NULL : text_color_normal->color);
	}
}

void SCR_HUD_DrawAmmo2(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *proportional, *text_color_low, *text_color_normal;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		proportional = HUD_FindVar(hud, "proportional");
		text_color_low = HUD_FindInitTextColorVar(hud, "text_color_low");
		text_color_normal = HUD_FindInitTextColorVar(hud, "text_color_normal");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmo(hud, 2, scale->value, style->value, digits->value, align->string,
			proportional->integer, true,
			strlen(text_color_low->string) == 0 ? NULL : text_color_low->color,
			strlen(text_color_normal->string) == 0 ? NULL : text_color_normal->color);
	}
}

void SCR_HUD_DrawAmmo3(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *proportional, *text_color_low, *text_color_normal;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		proportional = HUD_FindVar(hud, "proportional");
		text_color_low = HUD_FindInitTextColorVar(hud, "text_color_low");
		text_color_normal = HUD_FindInitTextColorVar(hud, "text_color_normal");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmo(hud, 3, scale->value, style->value, digits->value, align->string,
			proportional->integer, true,
			strlen(text_color_low->string) == 0 ? NULL : text_color_low->color,
			strlen(text_color_normal->string) == 0 ? NULL : text_color_normal->color);
	}
}

void SCR_HUD_DrawAmmo4(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *proportional, *text_color_low, *text_color_normal;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		proportional = HUD_FindVar(hud, "proportional");
		text_color_low = HUD_FindInitTextColorVar(hud, "text_color_low");
		text_color_normal = HUD_FindInitTextColorVar(hud, "text_color_normal");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmo(hud, 4, scale->value, style->value, digits->value, align->string,
			proportional->integer, true,
			strlen(text_color_low->string) == 0 ? NULL : text_color_low->color,
			strlen(text_color_normal->string) == 0 ? NULL : text_color_normal->color);
	}
}

// icons - active ammo, armor, face etc..
void SCR_HUD_DrawAmmoIcon(hud_t *hud, int num, float scale, int style)
{
	extern mpic_t *sb_ammo[4];
	int   x, y, width, height;

	scale = max(scale, 0.01);

	width = height = (style ? 8 : 24) * scale;

	if (cl.spectator == cl.autocam) {
		if (!HUD_PrepareDraw(hud, width, height, &x, &y) || num == 0)
			return;

		if (style) {
			switch (num) {
				case 1: Draw_SAlt_String(x, y, "s", scale, false); break;
				case 2: Draw_SAlt_String(x, y, "n", scale, false); break;
				case 3: Draw_SAlt_String(x, y, "r", scale, false); break;
				case 4: Draw_SAlt_String(x, y, "c", scale, false); break;
			}
		}
		else {
			Draw_SPic(x, y, sb_ammo[num - 1], scale);
		}
	}
}

void SCR_HUD_DrawAmmoIconCurrent(hud_t *hud)
{
	int num;
	static cvar_t *scale = NULL, *style;

	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
	}

	if (ShowPreselectedWeap()) {
		// using weapon pre-selection so show info for current best pre-selected weapon ammo
		num = State_AmmoNumForWeapon(IN_BestWeapon(true));
	}
	else {
		// not using weapon pre-selection or player is dead so show current selected ammo
		if (HUD_Stats(STAT_ITEMS) & IT_SHELLS)
			num = 1;
		else if (HUD_Stats(STAT_ITEMS) & IT_NAILS)
			num = 2;
		else if (HUD_Stats(STAT_ITEMS) & IT_ROCKETS)
			num = 3;
		else if (HUD_Stats(STAT_ITEMS) & IT_CELLS)
			num = 4;
		else if (TP_TeamFortressEngineerSpanner())
			num = 4;
		else
			num = 0;
	}

	SCR_HUD_DrawAmmoIcon(hud, num, scale->value, style->value);
}

void SCR_HUD_DrawAmmoIcon1(hud_t *hud)
{
	static cvar_t *scale = NULL, *style;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmoIcon(hud, 1, scale->value, style->value);
	}
}

void SCR_HUD_DrawAmmoIcon2(hud_t *hud)
{
	static cvar_t *scale = NULL, *style;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmoIcon(hud, 2, scale->value, style->value);
	}
}

void SCR_HUD_DrawAmmoIcon3(hud_t *hud)
{
	static cvar_t *scale = NULL, *style;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmoIcon(hud, 3, scale->value, style->value);
	}
}

void SCR_HUD_DrawAmmoIcon4(hud_t *hud)
{
	static cvar_t *scale = NULL, *style;
	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawAmmoIcon(hud, 4, scale->value, style->value);
	}
}

void Ammo_HudInit(void)
{
	// ammo/s
	HUD_Register(
		"ammo", NULL, "Part of your inventory - ammo for active weapon.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmoCurrent,
		"1", "health", "after", "center", "32", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "3",
		"proportional", "0",
		"show_always", "0",
		"text_color_low", "",
		"text_color_normal", "",
		 NULL
	);

	HUD_Register("ammo1", NULL, "Part of your inventory - ammo - shells.",
				 HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmo1,
				 "0", "ibar", "left", "top", "0", "0", "0", "0 0 0", NULL,
				 "style", "0",
				 "scale", "1",
				 "align", "right",
				 "digits", "3",
				 "proportional", "0",
				 "text_color_low", "",
				 "text_color_normal", "",
				 NULL);
	HUD_Register("ammo2", NULL, "Part of your inventory - ammo - nails.",
				 HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmo2,
				 "0", "ammo1", "after", "top", "0", "0", "0", "0 0 0", NULL,
				 "style", "0",
				 "scale", "1",
				 "align", "right",
				 "digits", "3",
				 "proportional", "0",
				 "text_color_low", "",
				 "text_color_normal", "",
				 NULL);
	HUD_Register("ammo3", NULL, "Part of your inventory - ammo - rockets.",
				 HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmo3,
				 "0", "ammo2", "after", "top", "0", "0", "0", "0 0 0", NULL,
				 "style", "0",
				 "scale", "1",
				 "align", "right",
				 "digits", "3",
				 "proportional", "0",
				 "text_color_low", "",
				 "text_color_normal", "",
				 NULL);
	HUD_Register("ammo4", NULL, "Part of your inventory - ammo - cells.",
				 HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmo4,
				 "0", "ammo3", "after", "top", "0", "0", "0", "0 0 0", NULL,
				 "style", "0",
				 "scale", "1",
				 "align", "right",
				 "digits", "3",
				 "proportional", "0",
				 "text_color_low", "",
				 "text_color_normal", "",
				 NULL);

	// ammo icon/s
	HUD_Register(
		"iammo", NULL, "Part of your inventory - ammo icon.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmoIconCurrent,
		"1", "ammo", "before", "center", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"show_always", "0",
		NULL
	);

	HUD_Register("iammo1", NULL, "Part of your inventory - ammo icon.",
				 HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmoIcon1,
				 "0", "ibar", "left", "top", "0", "0", "0", "0 0 0", NULL,
				 "style", "2",
				 "scale", "1",
				 NULL);
	HUD_Register("iammo2", NULL, "Part of your inventory - ammo icon.",
				 HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmoIcon2,
				 "0", "iammo1", "after", "top", "0", "0", "0", "0 0 0", NULL,
				 "style", "2",
				 "scale", "1",
				 NULL);
	HUD_Register("iammo3", NULL, "Part of your inventory - ammo icon.",
				 HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmoIcon3,
				 "0", "iammo2", "after", "top", "0", "0", "0", "0 0 0", NULL,
				 "style", "2",
				 "scale", "1",
				 NULL);
	HUD_Register("iammo4", NULL, "Part of your inventory - ammo icon.",
				 HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawAmmoIcon4,
				 "0", "iammo3", "after", "top", "0", "0", "0", "0 0 0", NULL,
				 "style", "2",
				 "scale", "1",
				 NULL);
}

================================================
FILE: src/hud_armor.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "fonts.h"
#include "teamplay.h"
#include "vx_stuff.h"

static int TP_IsArmorLow(void)
{
	extern cvar_t tp_need_ra, tp_need_ya, tp_need_ga;

	if ((cl.stats[STAT_ARMOR] > 0) && (cl.stats[STAT_ITEMS] & IT_ARMOR3)) {
		return cl.stats[STAT_ARMOR] <= tp_need_ra.value;
	}
	if ((cl.stats[STAT_ARMOR] > 0) && (cl.stats[STAT_ITEMS] & IT_ARMOR2)) {
		return cl.stats[STAT_ARMOR] <= tp_need_ya.value;
	}
	if ((cl.stats[STAT_ARMOR] > 0) && (cl.stats[STAT_ITEMS] & IT_ARMOR1)) {
		return cl.stats[STAT_ARMOR] <= tp_need_ga.value;
	}
	return 1;
}

static qbool HUD_ArmorLow(void)
{
	extern cvar_t hud_tp_need;

	if (hud_tp_need.value) {
		return (TP_IsArmorLow());
	}
	else {
		return (HUD_Stats(STAT_ARMOR) <= 25);
	}
}

static void SCR_HUD_DrawArmor(hud_t *hud)
{
	int level;
	qbool low;
	static cvar_t *scale = NULL, *style, *digits, *align, *pent_666, *proportional, *hidezero;

	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		pent_666 = HUD_FindVar(hud, "pent_666"); // Show 666 or armor value when carrying pentagram
		proportional = HUD_FindVar(hud, "proportional");
		hidezero = HUD_FindVar(hud, "hidezero"); //Hide armor number if zero
	}

	if (HUD_Stats(STAT_HEALTH) > 0) {
		if ((HUD_Stats(STAT_ITEMS) & IT_INVULNERABILITY) && pent_666->integer) {
			level = 666;
			low = true;
		}
		else {
			level = HUD_Stats(STAT_ARMOR);
			low = HUD_ArmorLow();
		}
	}
	else {
		level = 0;
		low = true;
	}
	if (level == 0 && hidezero->integer == 1) return;
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawNum(hud, level, low, scale->value, style->value, digits->value, align->string, proportional->integer);
	}
}

static void SCR_HUD_DrawArmorIcon(hud_t *hud)
{
	extern mpic_t  *sb_armor[3];
	extern mpic_t  *draw_disc;
	int   x, y, height;

	int style;
	float scale;

	static cvar_t *v_scale = NULL, *v_style, *v_proportional;
	if (v_scale == NULL) {
		// first time called
		v_scale = HUD_FindVar(hud, "scale");
		v_style = HUD_FindVar(hud, "style");
		v_proportional = HUD_FindVar(hud, "proportional");
	}

	scale = max(v_scale->value, 0.01);
	style = (int)(v_style->value);

	height = (style ? 8 : 24) * scale;

	if (cl.spectator == cl.autocam) {
		if (style) {
			int c;

			if (!HUD_PrepareDraw(hud, FontFixedWidth(1, scale, 0, v_proportional->integer), height, &x, &y)) {
				return;
			}

			if (HUD_Stats(STAT_ITEMS) & IT_INVULNERABILITY) {
				c = '@';
			}
			else  if (HUD_Stats(STAT_ITEMS) & IT_ARMOR3) {
				c = 'r';
			}
			else if (HUD_Stats(STAT_ITEMS) & IT_ARMOR2) {
				c = 'y';
			}
			else if (HUD_Stats(STAT_ITEMS) & IT_ARMOR1) {
				c = 'g';
			}
			else {
				return;
			}

			c += 128;

			Draw_SCharacterP(x, y, c, scale, v_proportional->integer);
		}
		else {
			mpic_t* pic;

			if (!HUD_PrepareDraw(hud, 24 * scale, height, &x, &y)) {
				return;
			}

			if (HUD_Stats(STAT_ITEMS) & IT_INVULNERABILITY) {
				pic = draw_disc;
			}
			else  if (HUD_Stats(STAT_ITEMS) & IT_ARMOR3) {
				pic = sb_armor[2];
			}
			else if (HUD_Stats(STAT_ITEMS) & IT_ARMOR2) {
				pic = sb_armor[1];
			}
			else if (HUD_Stats(STAT_ITEMS) & IT_ARMOR1) {
				pic = sb_armor[0];
			}
			else {
				return;
			}

			Draw_SPic(x, y, pic, scale);
		}
	}
}

static void SCR_HUD_DrawArmorDamage(hud_t *hud)
{
	Draw_AMFStatLoss(STAT_ARMOR, hud);
}

void SCR_HUD_DrawBarArmor(hud_t *hud)
{
	static	cvar_t *width = NULL, *height, *direction, *color_noarmor, *color_ga, *color_ga_over, *color_ya, *color_ra, *color_unnatural;
	int		x, y;
	int		armor = HUD_Stats(STAT_ARMOR);
	qbool	alive = cl.stats[STAT_HEALTH] > 0;

	if (width == NULL) {
		// first time called
		width = HUD_FindVar(hud, "width");
		height = HUD_FindVar(hud, "height");
		direction = HUD_FindVar(hud, "direction");
		color_noarmor = HUD_FindVar(hud, "color_noarmor");
		color_ga_over = HUD_FindVar(hud, "color_ga_over");
		color_ga = HUD_FindVar(hud, "color_ga");
		color_ya = HUD_FindVar(hud, "color_ya");
		color_ra = HUD_FindVar(hud, "color_ra");
		color_unnatural = HUD_FindVar(hud, "color_unnatural");
	}

	if (HUD_PrepareDraw(hud, width->integer, height->integer, &x, &y) && (cl.spectator == cl.autocam)) {
		if (!width->integer || !height->integer) {
			return;
		}

		if (HUD_Stats(STAT_ITEMS) & IT_INVULNERABILITY && alive) {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_unnatural->color, x, y, width->integer, height->integer);
		}
		else if (HUD_Stats(STAT_ITEMS) & IT_ARMOR3 && alive) {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_noarmor->color, x, y, width->integer, height->integer);
			SCR_HUD_DrawBar(direction->integer, armor, 200.0, color_ra->color, x, y, width->integer, height->integer);
		}
		else if (HUD_Stats(STAT_ITEMS) & IT_ARMOR2 && alive) {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_noarmor->color, x, y, width->integer, height->integer);
			SCR_HUD_DrawBar(direction->integer, armor, 150.0, color_ya->color, x, y, width->integer, height->integer);
		}
		else if (HUD_Stats(STAT_ITEMS) & IT_ARMOR1 && alive) {
			if (armor > 100) {
				SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_ga->color, x, y, width->integer, height->integer);
				SCR_HUD_DrawBar(direction->integer, armor - 100.0, 100.0, color_ga_over->color, x, y, width->integer, height->integer);
			} else {
				SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_noarmor->color, x, y, width->integer, height->integer);
				SCR_HUD_DrawBar(direction->integer, armor, 100.0, color_ga->color, x, y, width->integer, height->integer);
			}
		}
		else {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_noarmor->color, x, y, width->integer, height->integer);
		}
	}
}

void Armor_HudInit(void)
{
	// armor count
	HUD_Register(
		"armor", NULL, "Part of your inventory - armor level.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawArmor,
		"1", "face", "before", "center", "-32", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "3",
		"pent_666", "1",  // Show 666 instead of armor value
		"proportional", "0",
		"hidezero", "0", // Hide armor number if 0
		NULL
	);

	// armor icon
	HUD_Register(
		"iarmor", NULL, "Part of your inventory - armor icon.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawArmorIcon,
		"1", "armor", "before", "center", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);

	// armordamage
	HUD_Register(
		"armordamage", NULL, "Shows amount of damage done to your armour.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawArmorDamage,
		"0", "armor", "left", "before", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "3",
		"duration", "0.8",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"bar_armor", NULL, "Armor bar.",
		HUD_PLUSMINUS, ca_active, 0, SCR_HUD_DrawBarArmor,
		"0", "armor", "left", "center", "0", "0", "0", "0 0 0", NULL,
		"height", "16",
		"width", "64",
		"direction", "1",
		"color_noarmor", "128 128 128 64",
		"color_ga_over", "48 160 0 128",
		"color_ga", "32 128 0 128",
		"color_ya", "192 128 0 128",
		"color_ra", "128 0 0 128",
		"color_unnatural", "255 255 255 128",
		NULL
	);
}


================================================
FILE: src/hud_autoid.c
================================================
/*
Copyright (C) 1996-2003 Id Software, Inc., A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: cl_screen.c,v 1.156 2007-10-29 00:56:47 qqshka Exp $
*/

#include "quakedef.h"
#include "gl_model.h"
#include "teamplay.h"
#include "fonts.h"
#include "r_matrix.h"
#include "r_local.h"

/*********************************** AUTOID ***********************************/

// Not static so it can be toggled in menu
cvar_t scr_autoid                                  = { "scr_autoid", "5" };
static cvar_t scr_autoid_weapons                   = { "scr_autoid_weapons", "2" };
static cvar_t scr_autoid_namelength                = { "scr_autoid_namelength", "0" };
static cvar_t scr_autoid_barlength                 = { "scr_autoid_barlength", "16" };
static cvar_t scr_autoid_weaponicon                = { "scr_autoid_weaponicon", "1" };
static cvar_t scr_autoid_scale                     = { "scr_autoid_scale", "1" };
static cvar_t scr_autoid_proportional              = { "scr_autoid_proportional", "0" };

// These aren't static as they're also used for multiview hud
cvar_t scr_autoid_healthbar_bg_color               = { "scr_autoid_healthbar_bg_color", "180 115 115 100", CVAR_COLOR };
cvar_t scr_autoid_healthbar_normal_color           = { "scr_autoid_healthbar_normal_color", "80 0 0 255", CVAR_COLOR };
cvar_t scr_autoid_healthbar_mega_color             = { "scr_autoid_healthbar_mega_color", "255 0 0 255", CVAR_COLOR };
cvar_t scr_autoid_healthbar_two_mega_color         = { "scr_autoid_healthbar_two_mega_color", "255 100 0 255", CVAR_COLOR };
cvar_t scr_autoid_healthbar_unnatural_color        = { "scr_autoid_healthbar_unnatural_color", "255 255 255 255", CVAR_COLOR };

static cvar_t scr_autoid_armorbar_green_armor      = { "scr_autoid_armorbar_green_armor", "25 170 0 255", CVAR_COLOR };
static cvar_t scr_autoid_armorbar_yellow_armor     = { "scr_autoid_armorbar_yellow_armor", "255 220 0 255", CVAR_COLOR };
static cvar_t scr_autoid_armorbar_red_armor        = { "scr_autoid_armorbar_red_armor", "255 0 0 255", CVAR_COLOR };

typedef struct player_autoid_s {
	float x, y;
	player_info_t* player;

	// antilag indicators (debugging antilag queries)
	float rewind_x1, rewind_y1; // as rewound by server
	float rewind_x2, rewind_y2; // current position, for rewound line
	float client_x1, client_y1; // as claimed by the client
	float client_x2, client_y2; // current position, for client line
	qbool rewind_valid, client_valid;
} autoid_player_t;

// For 2-pass multiview... [<view-num>][<other-player>]
static autoid_player_t saved_autoids[4][MAX_CLIENTS];
static int saved_autoid_count[4];

static autoid_player_t autoids[MAX_CLIENTS];
static int autoid_count;

#define AUTOID_HEALTHBAR_OFFSET_Y			16

#define AUTOID_ARMORBAR_OFFSET_Y			(AUTOID_HEALTHBAR_OFFSET_Y + 5)
#define AUTOID_ARMORNAME_OFFSET_Y			(AUTOID_ARMORBAR_OFFSET_Y + 8 + 2)
#define AUTOID_ARMORNAME_OFFSET_X			8

#define AUTOID_WEAPON_OFFSET_Y				AUTOID_HEALTHBAR_OFFSET_Y
#define AUTOID_WEAPON_OFFSET_X				2

void SCR_SaveAutoID(void)
{
	int view_num = CL_MultiviewCurrentView() - 1;

	if (view_num >= 0 && view_num < 4) {
		memcpy(saved_autoids[view_num], autoids, sizeof(saved_autoids[view_num]));
		saved_autoid_count[view_num] = autoid_count;
	}
}

void SCR_RestoreAutoID(void)
{
	int view_num = CL_MultiviewCurrentView() - 1;

	if (view_num >= 0 && view_num < 4) {
		memcpy(autoids, saved_autoids[view_num], sizeof(autoids));
		autoid_count = saved_autoid_count[view_num];
	}
}

void SCR_SetupAutoID(void)
{
	int j, tracknum = -1;
	float winz, *origin;
	player_state_t *state;
	player_info_t *info;
	centity_t *cent;
	item_vis_t visitem;
	autoid_player_t *id;

	autoid_count = 0;

	if (!scr_autoid.value) {
		return;
	}

	if (cls.state != ca_active || !cl.validsequence || cl.intermission) {
		return;
	}

	if (!cls.demoplayback && !cl.spectator) {
		return;
	}

	if (cl.spectator) {
		tracknum = Cam_TrackNum();
	}

	VectorCopy(vpn, visitem.forward);
	VectorCopy(vright, visitem.right);
	VectorCopy(vup, visitem.up);
	VectorCopy(r_origin, visitem.vieworg);

	state = cl.frames[cl.parsecount & UPDATE_MASK].playerstate;
	info = cl.players;
	cent = &cl_entities[1];

	for (j = 0; j < MAX_CLIENTS; j++, info++, state++, cent++) {
		if (state->messagenum != cl.parsecount || j == cl.playernum || j == tracknum || info->spectator) {
			continue;
		}

		if ((state->modelindex == cl_modelindices[mi_player] && ISDEAD(state->frame)) ||
			state->modelindex == cl_modelindices[mi_h_player]) {
			continue;
		}

		origin = cent->lerp_origin;

		// FIXME: In multiview, this will detect some players being outside of the view even though
		// he's visible on screen, this only happens in some cases.
		if (R_CullSphere(origin, 0)) {
			continue;
		}

		VectorCopy(origin, visitem.entorg);
		visitem.entorg[2] += 27;
		VectorSubtract(visitem.entorg, visitem.vieworg, visitem.dir);
		visitem.dist = DotProduct(visitem.dir, visitem.forward);
		visitem.radius = 25;

		if (!TP_IsItemVisible(&visitem)) {
			continue;
		}

		id = &autoids[autoid_count];
		id->player = info;
		if (R_Project3DCoordinates(origin[0], origin[1], origin[2] + 28, &id->x, &id->y, &winz)) {
			autoid_count++;

			id->rewind_valid = id->client_valid = false;
			if (state->antilag_flags & dbg_antilag_rewind_present) {
				id->rewind_valid = R_Project3DCoordinates(state->rewind_origin[0], state->rewind_origin[1], state->rewind_origin[2] + 16, &id->rewind_x1, &id->rewind_y1, &winz);
				id->rewind_valid &= R_Project3DCoordinates(origin[0], origin[1], origin[2] + 16, &id->rewind_x2, &id->rewind_y2, &winz);
			}
			if (state->antilag_flags & dbg_antilag_client_present) {
				id->client_valid = R_Project3DCoordinates(state->client_origin[0], state->client_origin[1], state->client_origin[2] + 18, &id->client_x1, &id->client_y1, &winz);
				id->client_valid &= R_Project3DCoordinates(origin[0], origin[1], origin[2] + 18, &id->client_x2, &id->client_y2, &winz);
			}
		}
	}
}

static void SCR_DrawAutoIDStatus(autoid_player_t *autoid_p, int x, int y, float scale, qbool proportional)
{
	char armor_name[20];
	char weapon_name[20];
	int bar_length;

	if (scr_autoid_barlength.integer > 0) {
		bar_length = scr_autoid_barlength.integer;
	}
	else if (scr_autoid_namelength.integer >= 1) {
		float fixed = FontFixedWidth(scr_autoid_namelength.integer, false, scale, proportional);
		float particular = Draw_StringLength(autoid_p->player->name, -1, scale, proportional);

		bar_length = min(fixed, particular) * 0.5;
	}
	else {
		bar_length = Draw_StringLength(autoid_p->player->name, -1, scale, proportional) * 0.5;
	}

	// Draw health above the name.
	if (scr_autoid.integer >= 2) {
		int health;
		int health_length;

		health = autoid_p->player->stats[STAT_HEALTH];
		health = min(100, health);
		health_length = Q_rint((bar_length / 100.0) * health);

		// Normal health.
		Draw_AlphaFillRGB(x - bar_length * scale, y - AUTOID_HEALTHBAR_OFFSET_Y * scale, bar_length * 2 * scale, 4 * scale, RGBAVECT_TO_COLOR(scr_autoid_healthbar_bg_color.color));
		Draw_AlphaFillRGB(x - bar_length * scale, y - AUTOID_HEALTHBAR_OFFSET_Y * scale, health_length * 2 * scale, 4 * scale, RGBAVECT_TO_COLOR(scr_autoid_healthbar_normal_color.color));

		health = autoid_p->player->stats[STAT_HEALTH];

		// Mega health
		if (health > 100 && health <= 200) {
			health_length = Q_rint((bar_length / 100.0) * (health - 100));
			Draw_AlphaFillRGB(x - bar_length * scale, y - AUTOID_HEALTHBAR_OFFSET_Y * scale, health_length * 2 * scale, 4 * scale, RGBAVECT_TO_COLOR(scr_autoid_healthbar_mega_color.color));
		}
		else if (health > 200 && health <= 250) {
			// Super health.
			health_length = Q_rint((bar_length / 100.0) * (health - 200));
			Draw_AlphaFillRGB(x - bar_length * scale, y - AUTOID_HEALTHBAR_OFFSET_Y * scale, bar_length * 2 * scale, 4 * scale, RGBAVECT_TO_COLOR(scr_autoid_healthbar_mega_color.color));
			Draw_AlphaFillRGB(x - bar_length * scale, y - AUTOID_HEALTHBAR_OFFSET_Y * scale, health_length * 2 * scale, 4 * scale, RGBAVECT_TO_COLOR(scr_autoid_healthbar_two_mega_color.color));
		}
		else if (health > 250) {
			// Crazy health.
			// This will never happen during a normal game.
			Draw_AlphaFillRGB(x - bar_length * scale, y - AUTOID_HEALTHBAR_OFFSET_Y * scale, bar_length * 2 * scale, 4 * scale, RGBAVECT_TO_COLOR(scr_autoid_healthbar_unnatural_color.color));
		}
	}

	// Draw armor.
	if (scr_autoid.integer >= 2) {
		int armor;
		int armor_length;
		cvar_t* armor_color = NULL;

		armor = autoid_p->player->stats[STAT_ARMOR];
		armor = min(100, armor);
		armor_length = Q_rint((bar_length / 100.0) * armor);

		if (autoid_p->player->stats[STAT_ITEMS] & IT_ARMOR1) {
			armor_color = &scr_autoid_armorbar_green_armor;
		}
		else if (autoid_p->player->stats[STAT_ITEMS] & IT_ARMOR2) {
			armor_color = &scr_autoid_armorbar_yellow_armor;
		}
		else if (autoid_p->player->stats[STAT_ITEMS] & IT_ARMOR3) {
			armor_color = &scr_autoid_armorbar_red_armor;
		}

		if (armor_color != NULL) {
			color_t background = RGBA_TO_COLOR(armor_color->color[0], armor_color->color[1], armor_color->color[2], 50);
			color_t foreground = RGBAVECT_TO_COLOR(armor_color->color);

			Draw_AlphaFillRGB(x - bar_length * scale, y - AUTOID_ARMORBAR_OFFSET_Y * scale, bar_length * 2 * scale, 4 * scale, background);
			Draw_AlphaFillRGB(x - bar_length * scale, y - AUTOID_ARMORBAR_OFFSET_Y * scale, armor_length * 2 * scale, 4 * scale, foreground);
		}
	}

	// Draw the name of the armor type.
	if (scr_autoid.integer >= 3 && scr_autoid.integer < 6 && autoid_p->player->stats[STAT_ITEMS] & (IT_ARMOR1 | IT_ARMOR2 | IT_ARMOR3)) {
		if (autoid_p->player->stats[STAT_ITEMS] & IT_ARMOR1) {
			strlcpy(armor_name, "&c0f0GA", sizeof(armor_name));
		}
		else if (autoid_p->player->stats[STAT_ITEMS] & IT_ARMOR2) {
			strlcpy(armor_name, "&cff0YA", sizeof(armor_name));
		}
		else {
			strlcpy(armor_name, "&cf00RA", sizeof(armor_name));
		}

		Draw_SColoredStringBasic(
			x - AUTOID_ARMORNAME_OFFSET_X * scale,
			y - AUTOID_ARMORNAME_OFFSET_Y * scale,
			armor_name, 0, scale, proportional
		);
	}

	if (scr_autoid_weapons.integer > 0 && (scr_autoid.integer >= 4)) {
		// Draw the players weapon.
		int best_weapon = -1;
		extern mpic_t *sb_weapons[7][8];
		mpic_t *weapon_pic = NULL;

		best_weapon = BestWeaponFromStatItems(autoid_p->player->stats[STAT_ITEMS]);

		switch (best_weapon) {
			case IT_SHOTGUN:
				weapon_pic = sb_weapons[0][0];
				strlcpy(weapon_name, "SG", sizeof(weapon_name));
				break;
			case IT_SUPER_SHOTGUN:
				weapon_pic = sb_weapons[0][1];
				strlcpy(weapon_name, "BS", sizeof(weapon_name));
				break;
			case IT_NAILGUN:
				weapon_pic = sb_weapons[0][2];
				strlcpy(weapon_name, "NG", sizeof(weapon_name));
				break;
			case IT_SUPER_NAILGUN:
				weapon_pic = sb_weapons[0][3];
				strlcpy(weapon_name, "SN", sizeof(weapon_name));
				break;
			case IT_GRENADE_LAUNCHER:
				weapon_pic = sb_weapons[0][4];
				strlcpy(weapon_name, "GL", sizeof(weapon_name));
				break;
			case IT_ROCKET_LAUNCHER:
				weapon_pic = sb_weapons[0][5];
				strlcpy(weapon_name, "RL", sizeof(weapon_name));
				break;
			case IT_LIGHTNING:
				weapon_pic = sb_weapons[0][6];
				strlcpy(weapon_name, "LG", sizeof(weapon_name));
				break;
			default:
				// No weapon.
				break;
		}

		if (weapon_pic != NULL && best_weapon > 0 && ((scr_autoid.integer == 4 && best_weapon == 7) || (scr_autoid.integer > 4 && best_weapon >= scr_autoid_weapons.integer))) {
			if (scr_autoid_weaponicon.value) {
				Draw_SSubPic(
					x - (bar_length + weapon_pic->width + AUTOID_WEAPON_OFFSET_X) * scale,
					y - (AUTOID_HEALTHBAR_OFFSET_Y + Q_rint((weapon_pic->height / 2.0))) * scale,
					weapon_pic,
					0,
					0,
					weapon_pic->width,
					weapon_pic->height,
					scale
				);
			}
			else {
				Draw_SColoredStringBasic(
					x - (bar_length + 16 + AUTOID_WEAPON_OFFSET_X) * scale,
					y - (AUTOID_HEALTHBAR_OFFSET_Y + 4) * scale,
					weapon_name, 1, scale, proportional
				);
			}
		}
	}
}

void SCR_DrawAntilagIndicators(void)
{
	int i;
	extern cvar_t cl_debug_antilag_lines;
	extern cvar_t cl_debug_antilag_view;

	if (!cl_debug_antilag_lines.integer || (!cls.demoplayback && !cl.spectator) || cl.intermission) {
		return;
	}

	for (i = 0; i < autoid_count; ++i) {
		color_t r_color = RGBA_TO_COLOR(255, 0, 0, 255);
		color_t c_color = RGBA_TO_COLOR(0, 255, 0, 255);
		color_t rc_color = RGBA_TO_COLOR(0, 0, 255, 255);
		float r_x1 = autoids[i].rewind_x1 * vid.width / glwidth;
		float r_y1 = (glheight - autoids[i].rewind_y1) * vid.height / glheight;
		float r_x2 = autoids[i].rewind_x2 * vid.width / glwidth;
		float r_y2 = (glheight - autoids[i].rewind_y2) * vid.height / glheight;
		float c_x1 = autoids[i].client_x1 * vid.width / glwidth;
		float c_y1 = (glheight - autoids[i].client_y1) * vid.height / glheight;
		float c_x2 = autoids[i].client_x2 * vid.width / glwidth;
		float c_y2 = (glheight - autoids[i].client_y2) * vid.height / glheight;

		if (cl_debug_antilag_view.integer == 0) {
			// player shown in current server position, draw from rewound & client
			if (autoids[i].rewind_valid) {
				Draw_AlphaLineRGB(r_x1, r_y1, r_x2, r_y2, 2, r_color);
			}
			if (autoids[i].client_valid) {
				Draw_AlphaLineRGB(c_x1, c_y1, c_x2, c_y2, 2, c_color);
			}
		}
		else if (cl_debug_antilag_view.integer == 1) {
			// player shown in rewound position, draw from current & client
			if (autoids[i].rewind_valid) {
				Draw_AlphaLineRGB(r_x1, r_y1, r_x2, r_y2, 2, r_color);
			}
			if (autoids[i].rewind_valid && autoids[i].client_valid) {
				Draw_AlphaLineRGB(c_x1, c_y1, r_x1, r_y1, 2, rc_color);
			}
		}
		else if (cl_debug_antilag_view.integer == 2) {
			// player shown in client position, draw to current & rewound
			if (autoids[i].rewind_valid && autoids[i].client_valid) {
				Draw_AlphaLineRGB(r_x1, r_y1, c_x1, c_y1, 2, rc_color);
			}
			if (autoids[i].client_valid) {
				Draw_AlphaLineRGB(c_x1, c_y1, c_x2, c_y2, 2, c_color);
			}
		}
	}
}

void SCR_DrawAutoID(void)
{
	int i, x, y;
	float scale;
	qbool proportional = scr_autoid_proportional.integer;

	if (!scr_autoid.value || (!cls.demoplayback && !cl.spectator) || cl.intermission) {
		return;
	}

	for (i = 0; i < autoid_count; i++) {
		x = autoids[i].x * vid.width / glwidth;
		y = (glheight - autoids[i].y) * vid.height / glheight;
		scale = (scr_autoid_scale.value > 0 ? scr_autoid_scale.value : 1.0);

		if (scr_autoid.integer) {
			if (scr_autoid_namelength.integer >= 1 && scr_autoid_namelength.integer < MAX_SCOREBOARDNAME) {
				char name[MAX_SCOREBOARDNAME];

				strlcpy(name, autoids[i].player->name, sizeof(name));
				name[scr_autoid_namelength.integer] = 0;
				Draw_SString(x - Draw_StringLength(name, -1, 0.5 * scale, proportional), y - 8 * scale, name, scale, proportional);
			}
			else {
				Draw_SString(x - Draw_StringLength(autoids[i].player->name, -1, 0.5 * scale, proportional), y - 8 * scale, autoids[i].player->name, scale, proportional);
			}
		}

		// We only have health/armor info for all players when in demo playback.
		if (cls.mvdplayback && scr_autoid.value >= 2) {
			SCR_DrawAutoIDStatus(&autoids[i], x, y, scale, proportional);
		}
	}
}

void SCR_RegisterAutoIDCvars(void)
{
	if (!host_initialized) {
		Cvar_Register(&scr_autoid);
		Cvar_Register(&scr_autoid_weapons);
		Cvar_Register(&scr_autoid_namelength);
		Cvar_Register(&scr_autoid_barlength);
		Cvar_Register(&scr_autoid_weaponicon);
		Cvar_Register(&scr_autoid_scale);
		Cvar_Register(&scr_autoid_healthbar_bg_color);
		Cvar_Register(&scr_autoid_healthbar_normal_color);
		Cvar_Register(&scr_autoid_healthbar_mega_color);
		Cvar_Register(&scr_autoid_healthbar_two_mega_color);
		Cvar_Register(&scr_autoid_healthbar_unnatural_color);
		Cvar_Register(&scr_autoid_proportional);

		Cvar_Register(&scr_autoid_armorbar_green_armor);
		Cvar_Register(&scr_autoid_armorbar_yellow_armor);
		Cvar_Register(&scr_autoid_armorbar_red_armor);
	}
}


================================================
FILE: src/hud_centerprint.c
================================================
/*
Copyright (C) 1996-2003 Id Software, Inc., A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: cl_screen.c,v 1.156 2007-10-29 00:56:47 qqshka Exp $
*/

#include "quakedef.h"
#include "keys.h"
#include "menu.h"
#include "hud.h"

static cvar_t scr_centertime  = { "scr_centertime",  "2" };
static cvar_t scr_centershift = { "scr_centershift", "0" };
static cvar_t scr_centerspeed = { "scr_centerspeed", "8" };

/**************************** CENTER PRINTING ********************************/

static char	 scr_centerstring_lines[1024][41];

static float scr_centertime_start;   // for slow victory printing
static float scr_centertime_off;
static int   scr_center_lines;
static int   scr_erase_lines;
static int   scr_erase_center;

void SCR_CenterPrint_Clear(void)
{
	// Make sure no centerprint messages are left from previous level.
	scr_centertime_off = 0;
	memset(scr_centerstring_lines, 0, sizeof(scr_centerstring_lines));
}

void SCR_CenterPrint_Init(void)
{
	if (!host_initialized) {
		Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
		Cvar_Register(&scr_centertime);
		Cvar_Register(&scr_centershift);
		Cvar_Register(&scr_centerspeed);
		Cvar_ResetCurrentGroup();

		Cmd_AddLegacyCommand("scr_printspeed", "scr_centerspeed");
	}
}

// Called for important messages that should stay in the center of the screen for a few moments
void SCR_CenterPrint(const char *str)
{
	scr_centertime_off = scr_centertime.value;
	scr_centertime_start = cl.time;
	memset(scr_centerstring_lines, 0, sizeof(scr_centerstring_lines));

	// count the number of lines for centering
	scr_center_lines = 0;
	while (*str) {
		const char* endl = strchr(str, '\n');
		if (!endl) {
			strlcpy(scr_centerstring_lines[scr_center_lines], str, sizeof(scr_centerstring_lines[scr_center_lines]));
			++scr_center_lines;
			break;
		}
		else {
			int len = endl - str;
			len = min(len, sizeof(scr_centerstring_lines[scr_center_lines]) - 1);
			strlcpy(scr_centerstring_lines[scr_center_lines], str, sizeof(scr_centerstring_lines[scr_center_lines]));
			scr_centerstring_lines[scr_center_lines][len] = '\0';
			++scr_center_lines;

			str = endl + 1;
		}
	}
}

static void SCR_DrawCenterString(float x, float y, float scale, qbool proportional, float speed)
{
	// the finale prints the characters one at a time
	int remaining = cl.intermission ? speed * (cl.time - scr_centertime_start) : -1;
	int l;
	float max_width = (sizeof(scr_centerstring_lines[l]) - 1) * 8 * scale;

	scale = max(scale, 0.1);
	scr_erase_center = 0;
	if (remaining == 0) {
		return;
	}

	for (l = 0; l < scr_center_lines; ++l) {
		if (remaining >= 0 && remaining < strlen(scr_centerstring_lines[l])) {
			// Can't use standard centering here... we center to the full line, we might print less than that...
			char temp[1024];
			int len;

			strlcpy(temp, scr_centerstring_lines[l], sizeof(temp));
			temp[remaining] = '\0';
			len = Draw_StringLength(scr_centerstring_lines[l], -1, scale, proportional);

			Draw_SString(x + (max_width - len) / 2, y, temp, scale, proportional);
		}
		else {
			Draw_SStringAligned(x, y, scr_centerstring_lines[l], scale, 1.0f, proportional, text_align_center, x + max_width);
		}

		if (remaining >= 0) {
			remaining -= strlen(scr_centerstring_lines[l]);
			if (remaining <= 0) {
				break;
			}
		}
		y += 8 * scale;
	}
}

static qbool SCR_CheckDrawCenterString(void)
{
	scr_copytop = 1;
	if (scr_center_lines > scr_erase_lines) {
		scr_erase_lines = scr_center_lines;
	}

	if (!scr_center_lines) {
		return false;
	}

	scr_centertime_off -= cls.frametime;
	if (scr_centertime_off <= 0 && !cl.intermission) {
		return false;
	}

	// condition says: "Draw center string only when in game or in proxy menu, otherwise leave."
	if (key_dest != key_game && ((key_dest != key_menu) || (m_state != m_proxy))) {
		return false;
	}

	return true;
}

void SCR_CenterString_Draw(void)
{
	float y;
	float max_width;
	float scale = 1.0f;
	qbool proportional = false;
	extern cvar_t scr_newHud;
	static cvar_t* hud_draw = NULL;

	if (!SCR_CheckDrawCenterString()) {
		return;
	}

	if (hud_draw == NULL) {
		hud_draw = Cvar_Find("hud_centerprint_show");
	}

	if (scr_newHud.integer > 0 && hud_draw && hud_draw->integer) {
		return;
	}

	// shift all centerprint but not proxy menu - more user-friendly way
	y = ((scr_center_lines <= 4) ? vid.height * 0.35 : 48);
	if (m_state != m_proxy) {
		y += scr_centershift.value * 8 * scale;
	}
	max_width = (sizeof(scr_centerstring_lines[0]) - 1) * 8 * scale;

	SCR_DrawCenterString((vid.width - max_width) / 2, y, scale, proportional, max(scr_centerspeed.value, 1));
}

void SCR_EraseCenterString(void)
{
	int y;

	if (scr_erase_center++ > vid.numpages) {
		scr_erase_lines = 0;
		return;
	}

	y = (scr_center_lines <= 4) ? vid.height * 0.35 : 48;

	scr_copytop = 1;
	Draw_TileClear(0, y, vid.width, min(8 * scr_erase_lines, vid.height - y - 1));
}

static void SCR_HUD_DrawCenterPrint(hud_t* hud)
{
	int x = 0, y = 0;
	float width = 0, height = 0;

	static cvar_t
		*hud_scale = NULL,
		*hud_proportional,
		*hud_speed;

	if (!SCR_CheckDrawCenterString()) {
		return;
	}

	if (!hud_scale) {
		hud_scale = HUD_FindVar(hud, "scale");
		hud_proportional = HUD_FindVar(hud, "proportional");
		hud_speed = HUD_FindVar(hud, "speed");
	}

	width = 40 * 8 * hud_scale->value;
	height = 12 * 8 * hud_scale->value;

	if (height > 0 && width > 0 && HUD_PrepareDraw(hud, ceil(width), ceil(height), &x, &y)) {
		SCR_DrawCenterString(x, y, hud_scale->value, hud_proportional->value, max(hud_speed->integer, 1));
	}
}

void CenterPrint_HudInit(void)
{
	HUD_Register(
		"centerprint", NULL, "Shows alerts from server, countdowns etc.",
		HUD_PLUSMINUS | HUD_ON_FINALE, ca_active, 0, SCR_HUD_DrawCenterPrint,
		"0", "screen", "center", "center", "0", "0", "0", "0 0 0", NULL,
		"scale", "1",
		"proportional", "0",
		"speed", "8",
		NULL
	);
}


================================================
FILE: src/hud_clock.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// HUD: clock, democlock, gameclock etc

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "utils.h"
#include "fonts.h"

void SCR_DrawBigClock(int x, int y, int style, int blink, float scale, const char *t);
void SCR_DrawSmallClock(int x, int y, int style, int blink, float scale, const char *t, qbool proportional);

extern cvar_t scr_newHud;

static const char *SCR_HUD_ClockFormat(int format)
{
	switch (format) {
		case 1: return "%I:%M %p";
		case 2: return "%I:%M:%S %p";
		case 3: return "%H:%M";
		default: case 0: return "%H:%M:%S";
	}
}

//---------------------
//
// draw HUD clock
//
static void SCR_HUD_DrawClock(hud_t *hud)
{
	int width, height;
	int x, y;
	const char *t;

	static cvar_t
		*hud_clock_big = NULL,
		*hud_clock_style,
		*hud_clock_blink,
		*hud_clock_scale,
		*hud_clock_format,
		*hud_clock_proportional,
		*hud_clock_content;

	if (hud_clock_big == NULL) {
		// first time
		hud_clock_big = HUD_FindVar(hud, "big");
		hud_clock_style = HUD_FindVar(hud, "style");
		hud_clock_blink = HUD_FindVar(hud, "blink");
		hud_clock_scale = HUD_FindVar(hud, "scale");
		hud_clock_format = HUD_FindVar(hud, "format");
		hud_clock_proportional = HUD_FindVar(hud, "proportional");
		hud_clock_content = HUD_FindVar(hud, "content");
	}

	if (hud_clock_content->integer == 1) {
		t = SCR_GetTimeString(TIMETYPE_HOSTCLOCK, SCR_HUD_ClockFormat(hud_clock_format->integer));
	}
	else if (hud_clock_content->integer == 2) {
		t = SCR_GetTimeString(TIMETYPE_CONNECTEDCLOCK, SCR_HUD_ClockFormat(hud_clock_format->integer));
	}
	else {
		t = SCR_GetTimeString(TIMETYPE_CLOCK, SCR_HUD_ClockFormat(hud_clock_format->integer));
	}
	width = SCR_GetClockStringWidth(t, hud_clock_big->integer, hud_clock_scale->value, hud_clock_proportional->integer);
	height = SCR_GetClockStringHeight(hud_clock_big->integer, hud_clock_scale->value);

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		if (hud_clock_big->value) {
			SCR_DrawBigClock(x, y, hud_clock_style->value, hud_clock_blink->value, hud_clock_scale->value, t);
		}
		else {
			SCR_DrawSmallClock(x, y, hud_clock_style->value, hud_clock_blink->value, hud_clock_scale->value, t, hud_clock_proportional->integer);
		}
	}
}

//---------------------
//
// draw HUD gameclock
//
static void SCR_HUD_DrawGameClock(hud_t *hud)
{
	int width, height;
	int x, y;
	int timetype;
	const char *t;

	static cvar_t
		*hud_gameclock_big = NULL,
		*hud_gameclock_style,
		*hud_gameclock_blink,
		*hud_gameclock_countdown,
		*hud_gameclock_scale,
		*hud_gameclock_offset,
		*hud_gameclock_proportional;

	if (hud_gameclock_big == NULL)    // first time
	{
		hud_gameclock_big = HUD_FindVar(hud, "big");
		hud_gameclock_style = HUD_FindVar(hud, "style");
		hud_gameclock_blink = HUD_FindVar(hud, "blink");
		hud_gameclock_countdown = HUD_FindVar(hud, "countdown");
		hud_gameclock_scale = HUD_FindVar(hud, "scale");
		hud_gameclock_offset = HUD_FindVar(hud, "offset");
		hud_gameclock_proportional = HUD_FindVar(hud, "proportional");
		gameclockoffset = &hud_gameclock_offset->integer;
	}

	timetype = (hud_gameclock_countdown->value) ? TIMETYPE_GAMECLOCKINV : TIMETYPE_GAMECLOCK;
	t = SCR_GetTimeString(timetype, NULL);
	width = SCR_GetClockStringWidth(t, hud_gameclock_big->integer, hud_gameclock_scale->value, hud_gameclock_proportional->integer);
	height = SCR_GetClockStringHeight(hud_gameclock_big->integer, hud_gameclock_scale->value);

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		if (hud_gameclock_big->value) {
			SCR_DrawBigClock(x, y, hud_gameclock_style->value, hud_gameclock_blink->value, hud_gameclock_scale->value, t);
		}
		else {
			SCR_DrawSmallClock(x, y, hud_gameclock_style->value, hud_gameclock_blink->value, hud_gameclock_scale->value, t, hud_gameclock_proportional->integer);
		}
	}
}

//---------------------
//
// draw HUD democlock
//
static void SCR_HUD_DrawDemoClock(hud_t *hud)
{
	int width = 0;
	int height = 0;
	int x = 0;
	int y = 0;
	const char *t;
	static cvar_t
		*hud_democlock_big = NULL,
		*hud_democlock_style,
		*hud_democlock_blink,
		*hud_democlock_scale,
		*hud_democlock_proportional;

	if (!cls.demoplayback || cls.mvdplayback == QTV_PLAYBACK) {
		HUD_PrepareDraw(hud, width, height, &x, &y);
		return;
	}

	if (hud_democlock_big == NULL) {
		// first time
		hud_democlock_big = HUD_FindVar(hud, "big");
		hud_democlock_style = HUD_FindVar(hud, "style");
		hud_democlock_blink = HUD_FindVar(hud, "blink");
		hud_democlock_scale = HUD_FindVar(hud, "scale");
		hud_democlock_proportional = HUD_FindVar(hud, "proportional");
	}

	t = SCR_GetTimeString(TIMETYPE_DEMOCLOCK, NULL);
	width = SCR_GetClockStringWidth(t, hud_democlock_big->integer, hud_democlock_scale->value, hud_democlock_proportional->integer);
	height = SCR_GetClockStringHeight(hud_democlock_big->integer, hud_democlock_scale->value);

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		if (hud_democlock_big->value) {
			SCR_DrawBigClock(x, y, hud_democlock_style->value, hud_democlock_blink->value, hud_democlock_scale->value, t);
		}
		else {
			SCR_DrawSmallClock(x, y, hud_democlock_style->value, hud_democlock_blink->value, hud_democlock_scale->value, t, hud_democlock_proportional->integer);
		}
	}
}

static void SCR_HUD_DrawScoreClock(hud_t *hud) {
	int width, height;
	int x, y;
	static cvar_t
			*hud_scoreclock_format = NULL,
			*hud_scoreclock_scale = NULL,
			*hud_scoreclock_proportional = NULL;

	if (hud_scoreclock_format == NULL) {
		hud_scoreclock_format = HUD_FindVar(hud, "format");
		hud_scoreclock_scale = HUD_FindVar(hud, "scale");
		hud_scoreclock_proportional = HUD_FindVar(hud, "proportional");
	}

	if(!hud_scoreclock_format->string)
		return;

	time_t t;
	struct tm *ptm;
	char datestr[256] = "bad date";
	time(&t);
	if ((ptm = localtime(&t)))
		strftime(datestr, sizeof(datestr) - 1, hud_scoreclock_format->string, ptm);

	width = Draw_StringLengthColors(datestr, -1, hud_scoreclock_scale->value, hud_scoreclock_proportional->integer);
	height = SCR_GetClockStringHeight(false, hud_scoreclock_scale->value);

	if(!width)
		return;

	if (!HUD_PrepareDraw(hud, width, height, &x, &y))
		return;

	Draw_SString(x, y, datestr, hud_scoreclock_scale->value, hud_scoreclock_proportional->integer);
}

///
/// cl_screen.c clock module: to be merged
///
// non-static for menu
cvar_t scr_clock = { "cl_clock", "0" };
static cvar_t scr_clock_format = { "cl_clock_format", "0" };
static cvar_t scr_clock_x = { "cl_clock_x", "0" };
static cvar_t scr_clock_y = { "cl_clock_y", "-1" };

// non-static for menu
cvar_t scr_gameclock = { "cl_gameclock", "0" };
static cvar_t scr_gameclock_x = { "cl_gameclock_x", "0" };
static cvar_t scr_gameclock_y = { "cl_gameclock_y", "-3" };
static cvar_t scr_gameclock_offset = { "cl_gameclock_offset", "0" };
static cvar_t scr_gameclock_style = { "cl_gameclock_style", "0" };

static cvar_t scr_democlock = { "cl_democlock", "0" };
static cvar_t scr_democlock_x = { "cl_democlock_x", "0" };
static cvar_t scr_democlock_y = { "cl_democlock_y", "-2" };

static void SCR_DrawClock(void)
{
	int x, y;
	char str[64];

	if (!scr_clock.integer || scr_newHud.integer == 1) {
		// newHud has its own clock
		return;
	}

	if (scr_clock.integer == 2) {
		strlcpy(str, SCR_GetTimeString(TIMETYPE_CLOCK, SCR_HUD_ClockFormat(scr_clock_format.integer)), sizeof(str));
	}
	else if (scr_clock.integer == 3) {
		strlcpy(str, SCR_GetTimeString(TIMETYPE_HOSTCLOCK, SCR_HUD_ClockFormat(scr_clock_format.integer)), sizeof(str));
	}
	else {
		strlcpy(str, SCR_GetTimeString(TIMETYPE_CONNECTEDCLOCK, SCR_HUD_ClockFormat(scr_clock_format.integer)), sizeof(str));
	}

	x = ELEMENT_X_COORD(scr_clock);
	y = ELEMENT_Y_COORD(scr_clock);
	Draw_String(x, y, str);
}

static void SCR_DrawGameClock(void)
{
	int x, y, i, style = scr_gameclock_style.integer;
	char str[80], *s;
	float timelimit;

	if (!scr_gameclock.value || scr_newHud.value == 1) {
		// newHud has its own gameclock
		return;
	}

	if (scr_gameclock.value == 2 || scr_gameclock.value == 4) {
		timelimit = 60 * cl.timelimit + 1;
	}
	else {
		timelimit = 0;
	}

	if (cl.countdown || cl.standby) {
		strlcpy(str, SecondsToHourString(timelimit), sizeof(str));
	}
	else {
		strlcpy(str, SecondsToHourString((int)fabs(timelimit - cl.gametime + scr_gameclock_offset.value)), sizeof(str));
	}

	if ((scr_gameclock.value == 3 || scr_gameclock.value == 4) && (s = strchr(str, ':'))) {
		// or just use SecondsToMinutesString() ...
		s++;
	}
	else {
		s = str;
	}

	if (style) {
		for (i = 0; i < strlen(s); i++) {
			// only recolor ':' for red numbers
			if (style != 1 && s[i] == ':')
				continue;

			switch (style) {
			case 1:
				// red numbers
				s[i] += 128;
				break;
			case 2:
				// high bit green numbers
				s[i] += 98;
				break;
			case 3:
				// low bit green numbers
				s[i] -= 30;
				break;
			}
		}
	}

	x = ELEMENT_X_COORD(scr_gameclock);
	y = ELEMENT_Y_COORD(scr_gameclock);
	Draw_String(x, y, s);
}

static void SCR_DrawDemoClock(void)
{
	int x, y;
	char str[80];

	if (!cls.demoplayback || cls.mvdplayback == QTV_PLAYBACK || !scr_democlock.value || scr_newHud.value == 1) {
		// newHud has its own democlock
		return;
	}

	if (scr_democlock.value == 2) {
		strlcpy(str, SecondsToHourString((int)(cls.demotime)), sizeof(str));
	}
	else {
		strlcpy(str, SecondsToHourString((int)(cls.demotime - demostarttime)), sizeof(str));
	}

	x = ELEMENT_X_COORD(scr_democlock);
	y = ELEMENT_Y_COORD(scr_democlock);
	Draw_String(x, y, str);
}

void SCR_DrawClocks(void)
{
	SCR_DrawClock();
	SCR_DrawGameClock();
	SCR_DrawDemoClock();
}

/// Initialisation
void Clock_HudInit(void)
{
	Cvar_Register(&scr_clock_x);
	Cvar_Register(&scr_clock_y);
	Cvar_Register(&scr_clock_format);
	Cvar_Register(&scr_clock);

	Cvar_Register(&scr_gameclock_style);
	Cvar_Register(&scr_gameclock_offset);
	Cvar_Register(&scr_gameclock_x);
	Cvar_Register(&scr_gameclock_y);
	Cvar_Register(&scr_gameclock);

	Cvar_Register(&scr_democlock_x);
	Cvar_Register(&scr_democlock_y);
	Cvar_Register(&scr_democlock);

	// init clock
	HUD_Register(
		"clock", NULL, "Shows current local time (hh:mm:ss).",
		HUD_PLUSMINUS, ca_disconnected, 8, SCR_HUD_DrawClock,
		"0", "top", "right", "console", "0", "0", "0", "0 0 0", NULL,
		"big", "1",
		"style", "0",
		"scale", "1",
		"blink", "1",
		"format", "0",
		"proportional", "0",
		"content", "0",
		NULL
	);

	// init democlock
	HUD_Register(
		"democlock", NULL, "Shows current demo time (hh:mm:ss).",
		HUD_PLUSMINUS, ca_disconnected, 7, SCR_HUD_DrawDemoClock,
		"1", "top", "right", "console", "0", "8", "0", "0 0 0", NULL,
		"big", "0",
		"style", "0",
		"scale", "1",
		"blink", "0",
		"proportional", "0",
		NULL
	);

	// init gameclock
	HUD_Register(
		"gameclock", NULL, "Shows current game time (hh:mm:ss).",
		HUD_PLUSMINUS, ca_disconnected, 8, SCR_HUD_DrawGameClock,
		"1", "top", "right", "console", "0", "0", "0", "0 0 0", NULL,
		"big", "1",
		"style", "0",
		"scale", "1",
		"blink", "1",
		"countdown", "0",
		"offset", "0",
		"proportional", "0",
		NULL
	);

	// init scoreclock
	HUD_Register(
			"scoreclock", NULL, "Shows current date and time on the scoreboard",
			HUD_NO_DRAW | HUD_ON_INTERMISSION | HUD_ON_SCORES | HUD_ON_FINALE, ca_disconnected, 8, SCR_HUD_DrawScoreClock,
			"1", "screen", "center", "bottom", "0", "-10", "0", "0 0 0", NULL,
			"scale", "1",
			"format", "%d-%m-%Y %H:%M:%S",
			"proportional", "0",
			NULL
	);
}

//
// ------------------
// draw BIG clock
// style:
//  0 - normal
//  1 - red
void SCR_DrawBigClock(int x, int y, int style, int blink, float scale, const char *t)
{
	extern  mpic_t  *sb_nums[2][11];
	extern  mpic_t  *sb_colon/*, *sb_slash*/;
	qbool lblink = blink && ((int)(curtime * 10)) % 10 < 5;

	style = bound(0, style, 1);

	while (*t) {
		if (*t >= '0'  &&  *t <= '9') {
			Draw_STransPic(x, y, sb_nums[style][*t - '0'], scale);
			x += 24 * scale;
		}
		else if (*t == ':') {
			if (lblink || !blink) {
				Draw_STransPic(x, y, sb_colon, scale);
			}

			x += 16 * scale;
		}
		else {
			Draw_SCharacter(x, y, *t + (style ? 128 : 0), 3 * scale);
			x += 24 * scale;
		}
		t++;
	}
}

// ------------------
// draw SMALL clock
// style:
//  0 - small white
//  1 - small red
//  2 - small yellow/white
//  3 - small yellow/red
void SCR_DrawSmallClock(int x, int y, int style, int blink, float scale, const char *t, qbool proportional)
{
	qbool lblink = blink && ((int)(curtime * 10)) % 10 < 5;
	int c;

	style = bound(0, style, 3);

	while (*t) {
		c = (int)*t;
		if (c >= '0'  &&  c <= '9') {
			if (style == 1) {
				c += 128;
			}
			else if (style == 2 || style == 3) {
				c -= 30;
			}
		}
		else if (c == ':') {
			if (style == 1 || style == 3) {
				c += 128;
			}
			if (lblink || !blink) {
				;
			}
			else {
				c = ' ';
			}
		}
		x += Draw_SCharacterP(x, y, c, scale, proportional);
		t++;
	}
}


================================================
FILE: src/hud_common.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
//
// common HUD elements
// like clock etc..
//

#include "quakedef.h"
#include "common_draw.h"
#ifdef WITH_PNG
#include <png.h>
#endif
#include "image.h"
#include "stats_grid.h"
#include "vx_stuff.h"
#include "gl_model.h"
#include "tr_types.h"
#include "rulesets.h"
#include "utils.h"
#include "sbar.h"
#include "hud.h"
#include "hud_common.h"
#include "Ctrl.h"
#include "console.h"
#include "teamplay.h"
#include "mvd_utils.h"
#include "mvd_utils_common.h"
#include "fonts.h"

void TeamHold_DrawPercentageBar(
	int x, int y, int width, int height,
	float team1_percent, float team2_percent,
	int team1_color, int team2_color,
	int show_text, int vertical,
	int vertical_text, float opacity, float scale,
	qbool proportional
);

#ifndef STAT_MINUS
#define STAT_MINUS		10
#endif

void SCR_HUD_DrawTracker(hud_t* hud);
void SCR_HUD_WeaponStats(hud_t *hud);
void WeaponStats_HUDInit(void);
void TeamInfo_HudInit(void);
void Speed_HudInit(void);
void TeamHold_HudInit(void);
void Clock_HudInit(void);
void Ammo_HudInit(void);
void Items_HudInit(void);
void Net_HudInit(void);
void Guns_HudInit(void);
void Groups_HudInit(void);
void Armor_HudInit(void);
void Health_HudInit(void);
void GameSummary_HudInit(void);
void Performance_HudInit(void);
void Scores_HudInit(void);
void Face_HudInit(void);
void Frags_HudInit(void);
void Tracking_HudInit(void);
void CenterPrint_HudInit(void);
void Qtv_HudInit(void);

hud_t *hud_netgraph = NULL;

// Items to be filtered out
static int itemsclock_filter = 0;

// ----------------
// HUD planning
//

struct
{
	// this is temporary storage place for some of user's settings
	// hud_* values will be dumped into config file
	int old_multiview;
	int old_fov;
	int old_newhud;

	qbool active;
} autohud;

void OnAutoHudChange(cvar_t *var, char *value, qbool *cancel);
static void OnRemovePrefixesChange(cvar_t* var, char* value, qbool* cancel);
qbool autohud_loaded = false;
cvar_t hud_planmode = {"hud_planmode",   "0"};
cvar_t mvd_autohud = {"mvd_autohud", "0", 0, OnAutoHudChange};
cvar_t hud_digits_trim = {"hud_digits_trim", "1"};
static cvar_t hud_name_remove_prefixes = { "hud_name_remove_prefixes", "", 0, OnRemovePrefixesChange };

sort_players_info_t		sorted_players_by_frags[MAX_CLIENTS];
sort_players_info_t		sorted_players[MAX_CLIENTS];
sort_teams_info_t		sorted_teams[MAX_CLIENTS];
int       n_teams;
int       n_players;
int       n_spectators;
int       active_player_position = -1;
int       active_team_position = -1;

int hud_stats[MAX_CL_STATS];

extern void DumpHUD(char *);
extern char *Macro_MatchType(void);

int HUD_Stats(int stat_num)
{
	if (hud_planmode.value)
		return hud_stats[stat_num];
	else
		return cl.stats[stat_num];
}

// ----------------
// HUD low levels
//

cvar_t hud_tp_need = {"hud_tp_need",   "0"};

/* tp need levels
   int TP_IsHealthLow(void);
   int TP_IsArmorLow(void);
   int TP_IsAmmoLow(int weapon); */
extern cvar_t tp_need_health, tp_need_ra, tp_need_ya, tp_need_ga,
       tp_weapon_order, tp_need_weapon, tp_need_shells,
       tp_need_nails, tp_need_rockets, tp_need_cells;

int TP_IsWeaponLow(void)
{
	char *s = tp_weapon_order.string;
	while (*s  &&  *s != tp_need_weapon.string[0])
	{
		if (cl.stats[STAT_ITEMS] & (IT_SHOTGUN << (*s-'0'-2)))
			return false;
		s++;
	}
	return true;
}

void R_MQW_NetGraph(int outgoing_sequence, int incoming_sequence, int *packet_latency,
		int lost, int minping, int avgping, int maxping, int devping,
		int posx, int posy, int width, int height, int revx, int revy);
// ----------------
// Netgraph
void SCR_HUD_Netgraph(hud_t *hud)
{
	static cvar_t
		*par_width = NULL, *par_height,
		*par_swap_x, *par_swap_y,
		*par_ploss;

	if (par_width == NULL)  // first time
	{
		par_width  = HUD_FindVar(hud, "width");
		par_height = HUD_FindVar(hud, "height");
		par_swap_x = HUD_FindVar(hud, "swap_x");
		par_swap_y = HUD_FindVar(hud, "swap_y");
		par_ploss  = HUD_FindVar(hud, "ploss");
	}

	R_MQW_NetGraph(cls.netchan.outgoing_sequence, cls.netchan.incoming_sequence,
			packet_latency, par_ploss->value ? CL_CalcNet() : -1, -1, -1, -1, -1, -1,
			-1, (int)par_width->value, (int)par_height->value,
			(int)par_swap_x->value, (int)par_swap_y->value);
}

//---------------------
//
// draw HUD notify
//

void SCR_HUD_DrawNotify(hud_t* hud)
{
	static cvar_t* hud_notify_rows = NULL;
	static cvar_t* hud_notify_scale;
	static cvar_t* hud_notify_time;
	static cvar_t* hud_notify_cols;
	static cvar_t* hud_notify_proportional;

	int x;
	int y;
	int width;
	int height;
	int chars_per_line;

	if (hud_notify_rows == NULL) // First time.
	{
		hud_notify_rows  = HUD_FindVar(hud, "rows");
		hud_notify_cols  = HUD_FindVar(hud, "cols");
		hud_notify_scale = HUD_FindVar(hud, "scale");
		hud_notify_time  = HUD_FindVar(hud, "time");
		hud_notify_proportional = HUD_FindVar(hud, "proportional");
	}

	// Deliberately leaving this alone for the moment, not doing FontFixedWidth()...
	chars_per_line = (hud_notify_cols->integer > 0 ? hud_notify_cols->integer : con_linewidth);
	height = Q_rint ((con_linewidth / chars_per_line) * hud_notify_rows->integer * 8 * hud_notify_scale->value);
	width = 8 * chars_per_line * hud_notify_scale->value;

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		SCR_DrawNotify(x, y, hud_notify_scale->value, hud_notify_time->integer, hud_notify_rows->integer, chars_per_line, hud_notify_proportional->integer);
	}
}

// =======================================================
//
//  s t a t u s   b a r   e l e m e n t s
//
//

// status numbers
void SCR_HUD_DrawNum2(
	hud_t *hud, int num, qbool low,
	float scale, int style, int digits, char *s_align, qbool proportional, qbool draw_content,
	byte *text_color_low, byte *text_color_normal
)
{
	extern mpic_t *sb_nums[2][11];

	int  i;
	char buf[sizeof(int) * 3]; // each byte need <= 3 chars
	int  len;

	int width, height, x, y;
	int size;
	int align;

	clrinfo_t clr = { .i = 0 };

	clamp(num, -99999, 999999);
	scale = max(scale, 0.01);
	if (digits > 0) {
		clamp(digits, 1, 6);
	}
	else {
		digits = 0; // auto-resize
	}

	align = 2;
	switch (tolower(s_align[0])) {
		default:
		case 'l':   // 'l'eft
			align = 0;
			break;
		case 'c':   // 'c'enter
			align = 1;
			break;
		case 'r':   // 'r'ight
			align = 2;
			break;
	}

	snprintf(buf, sizeof (buf), "%d", (style == 2 || style == 3) ? num : abs(num));
	if (digits) {
		switch (hud_digits_trim.integer) {
			case 0: // 10030 -> 999
				len = strlen(buf);
				if (len > digits) {
					char *p = buf;
					if (num < 0) {
						*p++ = '-';
					}
					for (i = (num < 0) ? 1 : 0; i < digits; i++) {
						*p++ = '9';
					}
					*p = 0;
					len = digits;
				}
				break;
			default:
			case 1: // 10030 -> 030
				len = strlen(buf);
				if(len > digits) {
					char *p = buf;
					memmove(p, p + (len - digits), digits);
					buf[digits] = '\0';
					len = strlen(buf);
				}
				break;
			case 2: // 10030 -> 100
				buf[digits] = '\0';
				len = strlen(buf);
				break;
		}
	}
	else {
		len = strlen(buf);
	}

	switch (style)
	{
		case 1:
		case 3:
			size = 8;
			break;
		case 0:
		case 2:
		default:
			size = 24;
			break;
	}

	if (digits) {
		if (size == 8) {
			width = FontFixedWidth(digits, scale, true, proportional);
		}
		else {
			width = digits * size * scale;
		}
	}
	else {
		if (size == 8) {
			width = FontFixedWidth(len, scale, true, proportional);
		}
		else {
			width = len * size * scale;
		}
	}

	height = size * scale;

	switch (style)
	{
		case 1:
		case 3:
			if (!HUD_PrepareDraw(hud, width, height, &x, &y) || !draw_content) {
				return;
			}
			switch (align)
			{
				case 0: break;
				case 1: x += width / 2 - Draw_StringLength(buf, -1, scale, proportional) / 2; break;
				case 2: x += width - Draw_StringLength(buf, -1, scale, proportional); break;
			}

			if (low) {
				if (text_color_low != NULL)
				{
					clr.c = RGBAVECT_TO_COLOR(text_color_low);
					Draw_SColoredAlphaString(x, y, buf, &clr, 1, 0, scale, 1.0, proportional);
				}
				else
				{
					Draw_SAlt_String(x, y, buf, scale, proportional);
				}
			}
			else {
				if(style == 3) {
					// golden numbers
					for(i = 0; i < len; i++) {
						if(isdigit(buf[i])) {
							buf[i] = 18 + buf[i] - '0';
						}
					}
				}

				if (text_color_normal != NULL)
				{
					clr.c = RGBAVECT_TO_COLOR(text_color_normal);
					Draw_SColoredAlphaString(x, y, buf, &clr, 1, 0, scale, 1.0, proportional);
				}
				else
				{
					Draw_SString(x, y, buf, scale, proportional);
				}
			}
			break;

		case 0:
		case 2:
		default:
			if (!HUD_PrepareDraw(hud, width, height, &x, &y) || !draw_content) {
				return;
			}

			switch (align) {
				case 0: break;
				case 1: x += (width - size * len * scale) / 2; break;
				case 2: x += (width - size * len * scale); break;
			}

			for (i = 0; i < len; i++) {
				if(buf[i] == '-' && style == 2) {
					Draw_STransPic (x, y, sb_nums[low ? 1 : 0][STAT_MINUS], scale);
					x += 24 * scale;
				}
				else {
					Draw_STransPic (x, y, sb_nums[low ? 1 : 0][buf[i] - '0'], scale);
					x += 24 * scale;
				}
			}
			break;
	}
}

void SCR_HUD_DrawNum(
	hud_t* hud, int num, qbool low,
	float scale, int style, int digits, char* s_align, qbool proportional
)
{
	SCR_HUD_DrawNum2(hud, num, low, scale, style, digits, s_align, proportional, true, NULL, NULL);
}

#define TEMPHUD_NAME "_temphud"
#define TEMPHUD_FULLPATH "configs/"TEMPHUD_NAME".cfg"

// will check if user wants to un/load external MVD HUD automatically
void HUD_AutoLoad_MVD(int autoload) {
	char *cfg_suffix = "custom";
	extern cvar_t scr_fov;
	extern cvar_t scr_newHud;
	extern void Cmd_Exec_f (void);
	extern void DumpConfig(char *name);

	if (autoload && cls.mvdplayback) {
		// Turn autohud ON here

		Com_DPrintf("Loading MVD Hud\n");
		// Store current settings.
		if (!autohud.active)
		{
			extern cvar_t cfg_save_cmdline, cfg_save_cvars, cfg_save_cmds, cfg_save_aliases, cfg_save_binds;

			// Save old cfg_save values so that we don't screw the users
			// settings when saving the temp config.
			int old_cmdline = cfg_save_cmdline.value;
			int old_cvars	= cfg_save_cvars.value;
			int old_cmds	= cfg_save_cmds.value;
			int old_aliases = cfg_save_aliases.value;
			int old_binds	= cfg_save_binds.value;

			autohud.old_fov = (int) scr_fov.value;
			autohud.old_multiview = (int) cl_multiview.value;
			autohud.old_newhud = (int) scr_newHud.value;

			// Make sure everything current settings are saved.
			Cvar_SetValue(&cfg_save_cmdline,	1);
			Cvar_SetValue(&cfg_save_cvars,		1);
			Cvar_SetValue(&cfg_save_cmds,		1);
			Cvar_SetValue(&cfg_save_aliases,	1);
			Cvar_SetValue(&cfg_save_binds,		1);

			// Save a temporary config.
			DumpConfig(TEMPHUD_NAME".cfg");

			Cvar_SetValue(&cfg_save_cmdline,	old_cmdline);
			Cvar_SetValue(&cfg_save_cvars,		old_cvars);
			Cvar_SetValue(&cfg_save_cmds,		old_cmds);
			Cvar_SetValue(&cfg_save_aliases,	old_aliases);
			Cvar_SetValue(&cfg_save_binds,		old_binds);
		}

		// load MVD HUD config
		switch ((int) autoload) {
			case 1: // load 1on1 or 4on4 or custom according to $matchtype
				if (!strncmp(Macro_MatchType(), "duel", 4)) {
					cfg_suffix = "1on1";
				} else if (!strncmp(Macro_MatchType(), "4on4", 4)) {
					cfg_suffix = "4on4";
				} else {
					cfg_suffix = "custom";
				}
				break;
			default:
			case 2:
				cfg_suffix = "custom";
				break;
		}

		Cbuf_AddText(va("exec cfg/mvdhud_%s.cfg\n", cfg_suffix));

		autohud.active = true;
		return;
	}

	if ((!cls.mvdplayback || !autoload) && autohud.active) {
		// either user decided to turn mvd autohud off or mvd playback is over
		// -> Turn autohud OFF here
		FILE *tempfile;
		char *fullname = va("%s/ezquake/"TEMPHUD_FULLPATH, com_basedir);

		Com_DPrintf("Unloading MVD Hud\n");
		// load stored settings
		Cvar_SetValue(&scr_fov, autohud.old_fov);
		Cvar_SetValue(&cl_multiview, autohud.old_multiview);
		Cvar_SetValue(&scr_newHud, autohud.old_newhud);
		//Cmd_TokenizeString("exec "TEMPHUD_FULLPATH);
		Cmd_TokenizeString("cfg_load "TEMPHUD_FULLPATH);
		Cmd_Exec_f();

		// delete temp config with hud_* settings
		if ((tempfile = fopen(fullname, "rb")) && (fclose(tempfile) != EOF))
			unlink(fullname);

		autohud.active = false;
		return;
	}
}

void OnAutoHudChange(cvar_t *var, char *value, qbool *cancel) {
	HUD_AutoLoad_MVD(Q_atoi(value));
}

// Is run when a new map is loaded.
void HUD_NewMap(void) {
#if defined(WITH_PNG)
	HUD_NewRadarMap();
#endif // WITH_PNG

	autohud_loaded = false;
}

qbool HUD_ShowInDemoplayback(int val)
{
	if(!cl.teamplay && val == HUD_SHOW_ONLY_IN_TEAMPLAY)
	{
		return false;
	}
	else if(!cls.demoplayback && val == HUD_SHOW_ONLY_IN_DEMOPLAYBACK)
	{
		return false;
	}
	else if(!cl.teamplay && !cls.demoplayback
			&& val == HUD_SHOW_ONLY_IN_TEAMPLAY + HUD_SHOW_ONLY_IN_DEMOPLAYBACK)
	{
		return false;
	}

	return true;
}

void SCR_Hud_StackBar(hud_t* hud)
{
	int x, y;
	int height = 8;
	int width = 0;

	static cvar_t
		*hud_stackbar_style = NULL,
		*hud_stackbar_opacity,
		*hud_stackbar_width,
		*hud_stackbar_height,
		*hud_stackbar_vertical,
		*hud_stackbar_show_text,
		*hud_stackbar_vertical_text,
		*hud_stackbar_onlytp,
		*hud_stackbar_scale,
		*hud_stackbar_proportional;

	if (hud_stackbar_style == NULL)    // first time
	{
		hud_stackbar_style               = HUD_FindVar(hud, "style");
		hud_stackbar_opacity             = HUD_FindVar(hud, "opacity");
		hud_stackbar_width               = HUD_FindVar(hud, "width");
		hud_stackbar_height              = HUD_FindVar(hud, "height");
		hud_stackbar_vertical            = HUD_FindVar(hud, "vertical");
		hud_stackbar_show_text           = HUD_FindVar(hud, "show_text");
		hud_stackbar_vertical_text       = HUD_FindVar(hud, "vertical_text");
		hud_stackbar_onlytp              = HUD_FindVar(hud, "onlytp");
		hud_stackbar_scale               = HUD_FindVar(hud, "scale");
		hud_stackbar_proportional        = HUD_FindVar(hud, "proportional");
	}

	height = max(1, hud_stackbar_height->value);
	width = max(0, hud_stackbar_width->value);

	// Don't show when not in teamplay/demoplayback.
	if (!HUD_ShowInDemoplayback(hud_stackbar_onlytp->value)) {
		HUD_PrepareDraw(hud, width , height, &x, &y);
		return;
	}

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		// Get stack for each team, convert to %
		int stack1 = sorted_teams[0].stack;
		int stack2 = sorted_teams[1].stack;

		if (stack1 + stack2 > 0) {
			float percent1 = (stack1 * 1.0f) / (stack1 + stack2);

			TeamHold_DrawPercentageBar(
				x, y, width, height,
				percent1, 1.0f - percent1,
				sorted_teams[0].bottom,
				sorted_teams[1].bottom,
				hud_stackbar_show_text->value,
				hud_stackbar_vertical->value,
				hud_stackbar_vertical_text->value,
				hud_stackbar_opacity->value,
				hud_stackbar_scale->value,
				hud_stackbar_proportional->integer
			);
		}
		else {
			Draw_AlphaFill(x, y, hud_stackbar_width->value, height, 0, hud_stackbar_opacity->value * 0.5);
		}
	}
}

void ItemsClock_OnChangeItemFilter(cvar_t* var, char *s, qbool *cancel)
{
	int new_filter = 0;

	new_filter |= Utils_RegExpMatch("RL", s) ? IT_ROCKET_LAUNCHER : 0;
	new_filter |= Utils_RegExpMatch("QUAD",	s) ? IT_QUAD : 0;
	new_filter |= Utils_RegExpMatch("RING",	s) ? IT_INVISIBILITY : 0;
	new_filter |= Utils_RegExpMatch("PENT",	s) ? IT_INVULNERABILITY : 0;
	new_filter |= Utils_RegExpMatch("SUIT", s) ? IT_SUIT : 0;
	new_filter |= Utils_RegExpMatch("LG", s) ? IT_LIGHTNING : 0;
	new_filter |= Utils_RegExpMatch("GL", s) ? IT_GRENADE_LAUNCHER : 0;
	new_filter |= Utils_RegExpMatch("SNG", s) ? IT_SUPER_NAILGUN : 0;
	new_filter |= Utils_RegExpMatch("MH", s) ? IT_SUPERHEALTH : 0;
	new_filter |= Utils_RegExpMatch("RA", s) ? IT_ARMOR3 : 0;
	new_filter |= Utils_RegExpMatch("YA", s) ? IT_ARMOR2 : 0;
	new_filter |= Utils_RegExpMatch("GA", s) ? IT_ARMOR1 : 0;

	itemsclock_filter = new_filter;
}

void SCR_HUD_DrawItemsClock(hud_t *hud)
{
	extern qbool hud_editor;
	int width, height;
	int x, y;
	static cvar_t
		*hud_itemsclock_timelimit = NULL,
		*hud_itemsclock_style = NULL,
		*hud_itemsclock_scale = NULL,
		*hud_itemsclock_filter = NULL,
		*hud_itemsclock_proportional = NULL,
		*hud_itemsclock_backpacks = NULL;

	if (hud_itemsclock_timelimit == NULL) {
		char val[256];

		hud_itemsclock_timelimit = HUD_FindVar(hud, "timelimit");
		hud_itemsclock_style = HUD_FindVar(hud, "style");
		hud_itemsclock_scale = HUD_FindVar(hud, "scale");
		hud_itemsclock_filter = HUD_FindVar(hud, "filter");
		hud_itemsclock_proportional = HUD_FindVar(hud, "proportional");
		hud_itemsclock_backpacks = HUD_FindVar(hud, "backpacks");

		// Unecessary to parse the item filter string on each frame.
		hud_itemsclock_filter->OnChange = ItemsClock_OnChangeItemFilter;

		// Parse the item filter the first time (trigger the OnChange function above).
		strlcpy(val, hud_itemsclock_filter->string, sizeof(val));
		Cvar_Set(hud_itemsclock_filter, val);
	}

	MVD_ClockList_TopItems_DimensionsGet(hud_itemsclock_timelimit->value, hud_itemsclock_style->integer, &width, &height, hud_itemsclock_scale->value, hud_itemsclock_backpacks->integer, hud_itemsclock_proportional->integer);

	if (hud_editor)
		HUD_PrepareDraw(hud, width, LETTERHEIGHT * hud_itemsclock_scale->value, &x, &y);

	if (!height)
		return;

	if (!HUD_PrepareDraw(hud, width, height, &x, &y))
		return;

	MVD_ClockList_TopItems_Draw(hud_itemsclock_timelimit->value, hud_itemsclock_style->integer, x, y, hud_itemsclock_scale->value, itemsclock_filter, hud_itemsclock_backpacks->integer, hud_itemsclock_proportional->integer);
}

#ifdef WITH_PNG

void SCR_HUD_DrawKeys(hud_t *hud)
{
	char line1[4], line2[4];
	int width, height, x, y;
	usermainbuttons_t b;
	int i;
	static cvar_t* vscale = NULL;
	static cvar_t* player = NULL;
	float scale;
	int player_slot = -1;

	if (!vscale) {
		vscale = HUD_FindVar(hud, "scale");
		player = HUD_FindVar(hud, "player");
	}

	if (cls.demoplayback && !cls.nqdemoplayback && !cls.mvdplayback && player->string[0]) {
		player_slot = Player_GetSlot(player->string, false);
	}
	else if (cls.mvdplayback) {
		if (player->string[0]) {
			player_slot = Player_GetSlot(player->string, false);
		}
		else {
			// returns -1 if not tracking
			player_slot = Cam_TrackNum();
		}
	}

	b = CL_GetLastCmd(player_slot);

	scale = vscale->value;
	scale = max(0, scale);

	i = 0;
	line1[i++] = b.attack  ? (char)('x' + 128) : 'x';
	line1[i++] = b.forward ? (char)('^' + 128) : '^';
	line1[i++] = b.jump    ? (char)('J' + 128) : 'J';
	line1[i++] = '\0';
	i = 0;
	line2[i++] = b.left    ? (char)('<' + 128) : '<';
	line2[i++] = b.back    ? (char)('_' + 128) : '_';
	line2[i++] = b.right   ? (char)('>' + 128) : '>';
	line2[i++] = '\0';

	width = LETTERWIDTH * strlen(line1) * scale;
	height = LETTERHEIGHT * 2 * scale;

	if (!HUD_PrepareDraw(hud, width ,height, &x, &y))
		return;

	Draw_SString(x, y, line1, scale, false);
	Draw_SString(x, y + LETTERHEIGHT*scale, line2, scale, false);
}

#endif // WITH_PNG

//---------------------
//
// draw HUD static text
//
void SCR_HUD_DrawStaticText(hud_t *hud)
{
	const char *in;
	int alignment = 0;

	static cvar_t
		*hud_statictext_big = NULL,
		*hud_statictext_scale,
		*hud_statictext_text,
		*hud_statictext_textalign,
		*hud_statictext_proportional;

	if (hud_statictext_big == NULL) {
		// first time
		hud_statictext_big = HUD_FindVar(hud, "big");
		hud_statictext_scale = HUD_FindVar(hud, "scale");
		hud_statictext_text = HUD_FindVar(hud, "text");
		hud_statictext_textalign = HUD_FindVar(hud, "textalign");
		hud_statictext_proportional = HUD_FindVar(hud, "proportional");
	}

	// Static text valid for demos/qtv only
	if (!cls.demoplayback) {
		int x, y;
		HUD_PrepareDraw(hud, 0, 0, &x, &y);
		return;
	}

	alignment = 0;
	if (!strcmp(hud_statictext_textalign->string, "right")) {
		alignment = 1;
	}
	else if (!strcmp(hud_statictext_textalign->string, "center")) {
		alignment = 2;
	}

	// convert special characters
	in = hud_statictext_text->string;
	if (strlen(in) >= MAX_MACRO_STRING) {
		in = "error: input string too long";
	}
	in = TP_ParseFunChars(in, false);

	SCR_HUD_MultiLineString(hud, in, hud_statictext_big->integer, alignment, hud_statictext_scale->value, hud_statictext_proportional->integer);
}

void SCR_HUD_MultiLineString(hud_t* hud, const char* in, qbool large_font, int alignment, float scale, qbool proportional)
{
	// find carriage returns
	int x, y;
	const char *line_start = in;
	int max_length = Draw_StringLengthColorsByTerminator(line_start, -1, scale, proportional, '\r');
	char* line_end;
	int lines = 0;
	int character_height;

	while ((line_end = strchr(line_start, '\r'))) {
		int line_length;

		line_start = line_end + 1;
		line_length = Draw_StringLengthColorsByTerminator(line_start, -1, scale, proportional, '\r');
		max_length = max(max_length, line_length);

		++lines;
	}

	if (*line_start) {
		++lines;
	}

	// collapse to invisible if nothing to display
	if (max_length == 0) {
		lines = 0;
	}

	character_height = 8 * scale;
	if (large_font) {
		character_height = 24 * scale;
	}

	if (HUD_PrepareDraw(hud, max_length, lines * character_height, &x, &y)) {
		for (line_start = in; *line_start; line_start = line_end + 1) {
			int line_x = x;
			line_end = strchr(line_start, '\r');

			if (line_end) {
				*line_end = '\0';
			}

			if (alignment == 1) {
				// Right-justified
				line_x += (max_length - Draw_StringLengthColors(line_start, -1, scale, proportional));
			}
			else if (alignment == 2) {
				// Centered
				line_x += (max_length - Draw_StringLengthColors(line_start, -1, scale, proportional)) / 2;
			}

			if (large_font) {
				SCR_DrawWadString(line_x, y, scale, line_start); 
			}
			else {
				Draw_SString(line_x, y, line_start, scale, proportional);
			}

			y += character_height;
			if (!line_end)
				break;
		}
	}
}

float SCR_HUD_TotalStrength(float health, float armorValue, float armorType)
{
	return max(0, min(
		health / (1 - armorType),
		health + armorValue
	));
}

float SCR_HUD_ArmorType(int items)
{
	if (items & IT_INVULNERABILITY) {
		return 0.99f;
	}
	else if (items & IT_ARMOR3) {
		return 0.8f;
	}
	else if (items & IT_ARMOR2) {
		return 0.6f;
	}
	else if (items & IT_ARMOR1) {
		return 0.3f;
	}
	return 0.0f;
}

//
// Run before HUD elements are drawn.
// Place stuff that is common for HUD elements here.
//
void HUD_BeforeDraw(void)
{
	// Only sort once per draw.
	HUD_Sort_Scoreboard (HUD_SCOREBOARD_ALL);
}

//
// Run after HUD elements are drawn.
// Place stuff that is common for HUD elements here.
//
void HUD_AfterDraw(void)
{
}

// ----------------
// Init
// and add some common elements to hud (clock etc)
//

void CommonDraw_Init(void)
{
	int i;

	// variables
	Cvar_SetCurrentGroup(CVAR_GROUP_HUD);
	Cvar_Register(&hud_planmode);
	Cvar_Register(&hud_tp_need);
	Cvar_Register(&hud_digits_trim);
	Cvar_Register(&hud_name_remove_prefixes);
	Cvar_ResetCurrentGroup();

	Cvar_SetCurrentGroup(CVAR_GROUP_MVD);
	Cvar_Register (&mvd_autohud);
	Cvar_ResetCurrentGroup();

	// init HUD STAT table
	for (i=0; i < MAX_CL_STATS; i++)
		hud_stats[i] = 0;
	hud_stats[STAT_HEALTH]  = 200;
	hud_stats[STAT_AMMO]    = 100;
	hud_stats[STAT_ARMOR]   = 200;
	hud_stats[STAT_SHELLS]  = 200;
	hud_stats[STAT_NAILS]   = 200;
	hud_stats[STAT_ROCKETS] = 100;
	hud_stats[STAT_CELLS]   = 100;
	hud_stats[STAT_ACTIVEWEAPON] = 32;
	hud_stats[STAT_ITEMS] = 0xffffffff - IT_ARMOR2 - IT_ARMOR1;

	autohud.active = 0;

	HUD_Register(
		"tracker", NULL, "Shows deaths, frag streaks etc",
		0, ca_active, 0, SCR_HUD_DrawTracker,
		"0", "screen", "left", "top", "0", "48", "0", "0 0 0", NULL,
		"scale", "1",
		"proportional", "0",
		"name_width", "0",
		"align_right", "0",
		"image_scale", "1",
		NULL
	);

	HUD_Register(
		"notify", NULL, "Shows last console lines",
		HUD_PLUSMINUS, ca_disconnected, 8, SCR_HUD_DrawNotify,
		"0", "top", "left", "top", "0", "0", "0", "0 0 0", NULL,
		"rows", "4",
		"cols", "30",
		"scale", "1",
		"time", "4",
		"proportional", "0",
		NULL
	);

#ifdef WITH_PNG
	HUD_Register(
		"keys", NULL, "Shows which keys user does press at the moment",
		0, ca_active, 1, SCR_HUD_DrawKeys,
		"0", "screen", "right", "center", "0", "0", "0.5", "20 20 20", NULL,
		"scale", "2", "player", "",
		NULL
	);
#endif

	HUD_Register(
		"itemsclock", NULL, "Displays upcoming item respawns",
		0, ca_active, 1, SCR_HUD_DrawItemsClock,
		"0", "screen", "right", "center", "0", "0", "0", "0 0 0", NULL,
		"timelimit", "5",
		"style", "0",
		"scale", "1",
		"filter", "",
		"proportional", "0",
		"backpacks", "0",
		NULL
	);

	HUD_Register(
		"static_text", NULL, "Static text (demos only).",
		0, ca_active, 0, SCR_HUD_DrawStaticText,
		"0", "screen", "left", "top", "0", "0", "0", "0 0 0", NULL,
		"big", "0",
		"style", "0",
		"scale", "1",
		"text", "",
		"textalign", "left",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"teamstackbar", NULL, "Shows relative stacks of each team.",
		HUD_PLUSMINUS, ca_active, 0, SCR_Hud_StackBar,
		"0", "top", "left", "bottom", "0", "0", "0", "0 0 0", NULL,
		"opacity", "0.8",
		"width", "200",
		"height", "8",
		"vertical", "0",
		"vertical_text", "0",
		"show_text", "1",
		"onlytp", "0",
		"scale", "1",
		"simpleitems", "1",
		"proportional", "0",
		NULL
	);

	Performance_HudInit();
	Guns_HudInit();
	Groups_HudInit();
	Items_HudInit();
	Ammo_HudInit();
	Armor_HudInit();
	Scores_HudInit();
	Face_HudInit();
	GameSummary_HudInit();
	Net_HudInit();
	Clock_HudInit();
	Speed_HudInit();
	Radar_HudInit();
	WeaponStats_HUDInit();
	TeamInfo_HudInit();
	TeamHold_HudInit();
	Health_HudInit();
	Frags_HudInit();
	Tracking_HudInit();
	CenterPrint_HudInit();
	Qtv_HudInit();
}

const char* HUD_FirstTeam(void)
{
	if (!cl.teamlock1_teamname[0] && n_teams) {
		// setting for the first time when we have teams
		strlcpy(cl.teamlock1_teamname, sorted_teams[0].name, sizeof(cl.teamlock1_teamname));
	}
	else if (n_teams) {
		// check that the team still exists
		int i;
		for (i = 0; i < n_teams; ++i) {
			if (!strcmp(sorted_teams[i].name, cl.teamlock1_teamname)) {
				return cl.teamlock1_teamname; // found
			}
		}
		// not found, reset to first time
		strlcpy(cl.teamlock1_teamname, sorted_teams[0].name, sizeof(cl.teamlock1_teamname));
	}
	else {
		// no teams, clear and set again in the future
		memset(cl.teamlock1_teamname, 0, sizeof(cl.teamlock1_teamname));
	}
	return cl.teamlock1_teamname;
}

void CL_RemovePrefixFromName(int player)
{
	size_t skip;
	char* prefixes, * prefix, * name;
	char normalized_list[256];
	char normalized_name[MAX_SCOREBOARDNAME];
	const char* prefixes_list = hud_name_remove_prefixes.string;

	strlcpy(cl.players[player].shortname, cl.players[player].name, sizeof(cl.players[player].shortname));

	if (!prefixes_list || !prefixes_list[0]) {
		return;
	}

	skip = 0;

	strlcpy(normalized_list, prefixes_list, sizeof(normalized_list));
	prefixes = Q_normalizetext(normalized_list);
	prefix = strtok(prefixes, " ");
	strlcpy(normalized_name, cl.players[player].name, sizeof(normalized_name));
	name = Q_normalizetext(normalized_name);

	while (prefix != NULL) {
		if (strlen(prefix) > skip && strlen(name) > strlen(prefix) && strncasecmp(prefix, name, strlen(prefix)) == 0) {
			skip = strlen(prefix);
			// remove spaces from the new start of the name
			while (name[skip] == ' ') {
				skip++;
			}
			// if it would skip the whole name, just use the whole name
			if (name[skip] == 0) {
				skip = 0;
				break;
			}
		}
		prefix = strtok(NULL, " ");
	}

	strlcpy(cl.players[player].shortname, cl.players[player].name + skip, sizeof(cl.players[player].shortname));
}

static void OnRemovePrefixesChange(cvar_t* var, char* value, qbool* cancel)
{
	int i;

	Cvar_SetIgnoreCallback(var, value);

	for (i = 0; i < sizeof(cl.players) / sizeof(cl.players[0]); ++i) {
		CL_RemovePrefixFromName(i);
	}
}


================================================
FILE: src/hud_common.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
//
// common HUD elements
// like clock etc..
//

#ifndef __HUD_COMMON__H__
#define __HUD_COMMON__H__

extern hud_t *hud_netgraph;

void SCR_HUD_Netgraph(hud_t *hud);
void SCR_HUD_DrawNetStats(hud_t *hud);

void HUD_NewMap(void);
void HUD_NewRadarMap(void);
void SCR_HUD_DrawRadar(hud_t *hud);

void HudCommon_Init(void);
void SCR_HUD_DrawNum(hud_t *hud, int num, qbool low, float scale, int style, int digits, char *s_align, qbool proportional);
void SCR_HUD_DrawNum2(hud_t* hud, int num, qbool low, float scale, int style, int digits, char* s_align, qbool proportional, qbool draw_content, byte *text_color_low, byte *text_color_normal);

extern qbool autohud_loaded;
extern cvar_t mvd_autohud;
void HUD_AutoLoad_MVD(int autoload);

// player sorting
// for frags and players
typedef struct sort_teams_info_s {
	char *name;
	int  frags;
	int  min_ping;
	int  avg_ping;
	int  max_ping;
	int  nplayers;
	int  top, bottom;   // leader colours
	int  rlcount;       // Number of RLs present in the team. (Cokeman 2006-05-27)
	int  lgcount;       // number of LGs present in the team
	int  weapcount;     // number of players with weapons (RLs | LGs) in the team
	int  ra_taken;      // Total red armors taken
	int  ya_taken;      // Total yellow armors taken
	int  ga_taken;      // Total green armors taken
	int  mh_taken;      // Total megahealths taken
	int  quads_taken;   // Total quads taken
	int  pents_taken;   // Total pents taken
	int  rings_taken;   // Total rings taken
	int  stack;         // Total damage the team can take
	float ra_lasttime;  // last time ra taken
	float ya_lasttime;  // last time ya taken
	float ga_lasttime;  // last time ga taken
	float mh_lasttime;  // last time mh taken
	float q_lasttime;   // last time quad taken
	float p_lasttime;   // last time pent taken
	float r_lasttime;   // last time ring taken
}
sort_teams_info_t;

typedef struct sort_players_info_s {
	int playernum;
	sort_teams_info_t *team;
}
sort_players_info_t;

extern sort_players_info_t sorted_players_by_frags[MAX_CLIENTS];
extern sort_players_info_t sorted_players[MAX_CLIENTS];
extern sort_teams_info_t   sorted_teams[MAX_CLIENTS];
extern int n_teams;
extern int n_players;
extern int n_spectators;

int HUD_Stats(int stat_num);
extern cvar_t cl_weaponpreselect;

#define HUD_SCOREBOARD_ALL			0xffffffff
#define HUD_SCOREBOARD_SORT_TEAMS	(1 << 0)
#define HUD_SCOREBOARD_SORT_PLAYERS	(1 << 1)
#define HUD_SCOREBOARD_UPDATE		(1 << 2)
#define HUD_SCOREBOARD_AVG_PING		(1 << 3)
void HUD_Sort_Scoreboard(int flags);

extern int active_player_position;
extern int active_team_position;

void SCR_HUD_MultiLineString(hud_t* hud, const char* in, qbool large_font, int alignment, float scale, qbool proportional);

float SCR_HUD_TotalStrength(float health, float armorValue, float armorType);

float SCR_HUD_ArmorType(int items);

#endif // __HUD_COMMON__H__


================================================
FILE: src/hud_editor.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
	HUD Editor module

	Initial concept code jogihoogi, rewritten by Cokeman, Feb 2007
*/

#include "quakedef.h"
#include "qsound.h"
#include "utils.h"
#include "menu.h"
#include "keys.h"
#include "Ctrl.h"
#include "ez_controls.h"
#include "ez_button.h"
#include "ez_label.h"
#include "ez_scrollbar.h"
#include "ez_scrollpane.h"
#include "ez_slider.h"
#include "ez_listview.h"
#include "ez_window.h"
#include "hud.h"
#include "hud_editor.h"

// Returns true if a point is on the same side of a line as a third point
static qbool PointSameSide(vec3_t test_point, vec3_t a, vec3_t b, vec3_t control_point)
{
	vec3_t a_b, a_test, a_control;
	vec3_t cp1, cp2;

	VectorSubtract(b, a, a_b);
	VectorSubtract(test_point, a, a_test);
	VectorSubtract(control_point, a, a_control);

	CrossProduct(a_b, a_test, cp1);
	CrossProduct(a_b, a_control, cp2);

	return DotProduct(cp1, cp2) >= 0;
}

// Returns true if point is in a polygon
// Replaced previous version in mathlib.c as this will cope with being passed a triangle strip
static qbool IsPointInPolygon(int npol, vec3_t *v, float x, float y)
{
	int i;
	vec3_t test_point = { x, y, 0 };

	for (i = 2; i < npol; ++i) {
		float* a = v[i - 2];
		float* b = v[i - 1];
		float* c = v[i];

		if (PointSameSide(test_point, a, b, c) && PointSameSide(test_point, b, c, a) && PointSameSide(test_point, c, a, b)) {
			return true;
		}
	}

	return false;
}

ez_tree_t help_control_tree;

extern mpic_t		*scr_cursor_icon;	// cl_screen.c
extern cvar_t		hud_planmode;		// hud_common.c

mpic_t				*hud_editor_move_icon	= NULL;
mpic_t				*hud_editor_resize_icon	= NULL;
mpic_t				*hud_editor_align_icon	= NULL;
mpic_t				*hud_editor_place_icon	= NULL;

cvar_t				hud_editor_allowresize	= {"hud_editor_allowresize", "1"};	// Show resize handles / allow resizing.
cvar_t				hud_editor_allowmove	= {"hud_editor_allowmove", "1"};	// Allow moving...
cvar_t				hud_editor_allowplace	= {"hud_editor_allowplace", "1"};	// Allow placing HUDs.
cvar_t				hud_editor_allowalign	= {"hud_editor_allowalign", "1"};	// Allow aligning HUDs.

extern hud_t		*hud_huds;										// The list of HUDs..
hud_t				*selected_hud			= NULL;					// The currently selected HUD.

qbool				hud_editor				= false;				// If we're in HUD editor mode or not.
hud_editor_mode_t	hud_editor_mode			= hud_editmode_off;		// The current mode the HUD editor is in.
hud_editor_mode_t	hud_editor_prevmode		= hud_editmode_off;		// The previous mode the HUD editor was in.

qbool				hud_editor_showhelp		= false;				// Show the help plaque or not?
qbool				hud_editor_showoutlines	= true;					// Show guidelines around the HUD elements.

float				hud_mouse_x;									// The screen coordinates of the mouse cursor.
float				hud_mouse_y;

// Macros for what mouse buttons are clicked.
#define MOUSEDOWN			( keydown[K_MOUSE1] ||  keydown[K_MOUSE2]|| keydown[K_MOUSE3])
#define MOUSEDOWN_1_2		( keydown[K_MOUSE1] &&  keydown[K_MOUSE2])
#define MOUSEDOWN_1_3		( keydown[K_MOUSE1] &&  keydown[K_MOUSE3])
#define MOUSEDOWN_1_2_3		( keydown[K_MOUSE1] &&  keydown[K_MOUSE2] &&  keydown[K_MOUSE3])
#define MOUSEDOWN_1_ONLY	( keydown[K_MOUSE1] && !keydown[K_MOUSE2] && !keydown[K_MOUSE3])
#define MOUSEDOWN_2_ONLY	(!keydown[K_MOUSE1] &&  keydown[K_MOUSE2] && !keydown[K_MOUSE3])
#define MOUSEDOWN_3_ONLY	(!keydown[K_MOUSE1] && !keydown[K_MOUSE2] &&  keydown[K_MOUSE3])
#define MOUSEDOWN_1_2_ONLY	( keydown[K_MOUSE1] &&  keydown[K_MOUSE2] && !keydown[K_MOUSE3])
#define MOUSEDOWN_1_3_ONLY	( keydown[K_MOUSE1] && !keydown[K_MOUSE2] &&  keydown[K_MOUSE3])
#define MOUSEDOWN_2_3_ONLY	(!keydown[K_MOUSE1] &&  keydown[K_MOUSE2] &&  keydown[K_MOUSE3])
#define MOUSEDOWN_NONE		(!keydown[K_MOUSE1] && !keydown[K_MOUSE2] && !keydown[K_MOUSE3])

#define HUD_CENTER_X(h)		((h)->lx + (h)->lw / 2)	// Gets the coordinates for the center point of the specified hud.
#define HUD_CENTER_Y(h)		((h)->ly + (h)->lh / 2)

//
// HUD align polygons.
//
#define HUD_ALIGN_POLYCOUNT_CORNER	5
#define HUD_ALIGN_POLYCOUNT_EDGE	4
#define HUD_ALIGN_POLYCOUNT_CENTER	8
#define HUD_ALIGN_POLYCOUNT_CONSOLE	4

vec3_t *hud_align_current_poly = NULL;	// The current alignment polygon when in alignment mode.
int hud_align_current_polycount = 0;	// Number of vertices in teh polygon.

vec3_t hud_align_topright_poly[HUD_ALIGN_POLYCOUNT_CORNER];
vec3_t hud_align_top_poly[HUD_ALIGN_POLYCOUNT_EDGE];
vec3_t hud_align_topleft_poly[HUD_ALIGN_POLYCOUNT_CORNER];
vec3_t hud_align_left_poly[HUD_ALIGN_POLYCOUNT_EDGE];
vec3_t hud_align_bottomleft_poly[HUD_ALIGN_POLYCOUNT_CORNER];
vec3_t hud_align_bottom_poly[HUD_ALIGN_POLYCOUNT_EDGE];
vec3_t hud_align_bottomright_poly[HUD_ALIGN_POLYCOUNT_CORNER];
vec3_t hud_align_right_poly[HUD_ALIGN_POLYCOUNT_EDGE];
vec3_t hud_align_center_poly[HUD_ALIGN_POLYCOUNT_CENTER];

vec3_t hud_align_consoleleft_poly[HUD_ALIGN_POLYCOUNT_CONSOLE];
vec3_t hud_align_console_poly[HUD_ALIGN_POLYCOUNT_CONSOLE];
vec3_t hud_align_consoleright_poly[HUD_ALIGN_POLYCOUNT_CONSOLE];

typedef enum hud_alignmode_s
{
	hud_align_center,
	hud_align_top,
	hud_align_topleft,
	hud_align_left,
	hud_align_bottomleft,
	hud_align_bottom,
	hud_align_bottomright,
	hud_align_right,
	hud_align_topright,
	hud_align_consoleleft,
	hud_align_consoleright,
	hud_align_console
	// Not including before/after for now.
} hud_alignmode_t;

hud_alignmode_t	hud_alignmode = hud_align_center;

// Possible positions for a grep handle.
typedef enum hud_greppos_s
{
	pos_visible,	// On screen.
	pos_top,
	pos_left,
	pos_bottom,
	pos_right
} hud_greppos_t;

// A Grep handle for when a HUD goes offscreen.
typedef struct hud_grephandle_s
{
	hud_t					*hud;			// HUD associated with this grep handle.
	int						x;				// The position in screen coordinates for the grephandle.
	int						y;
	int						width;
	int						height;
	qbool					highlighted;	// Should this grephandle be drawn highlighted?
	hud_greppos_t			pos;			// The offscreen position of the HUD associated with this handle.
	struct hud_grephandle_s	*next;
	struct hud_grephandle_s	*previous;
} hud_grephandle_t;

hud_grephandle_t	*hud_greps = NULL;					// The list of "grep handles" that are shown if a HUD element is moved offscreen.

hud_grephandle_t	*hud_hoverlist = NULL;				// The list of HUDs the mouse is hovering.
int					hud_hoverlist_count = 0;			// The number of hovered HUDs...
qbool				hud_hoverlist_pos_is_set = false;	// Has the coordinates been set for the hoverlist yet?
float				hud_hoverlist_x;					// The x position of the hover list.
float				hud_hoverlist_y;					// The y position of the hover list.
hud_grephandle_t	hud_containers[MAX_HUD_ELEMENTS];	// List of HUDs which have been hovered.

//
// Change in cursor's X position since last frame
//
static float HUD_CursorDeltaX(void)
{
	return (scr_pointer_state.x - scr_pointer_state.x_old);
}

//
// Change in cursor's Y position since last frame
//
static float HUD_CursorDeltaY(void)
{
	return (scr_pointer_state.y - scr_pointer_state.y_old);
}

//
// Adds a new HUD to the list of HUDs that are being hovered.
//
static void HUD_Editor_AddHoverHud(hud_grephandle_t *hud_container)
{
	// Nothing to add.
	if(!hud_container)
	{
		return;
	}

	hud_container->next = hud_hoverlist;
	if(hud_hoverlist)
	{
		hud_hoverlist->previous = hud_container;
	}

	hud_hoverlist = hud_container;

	hud_hoverlist_count++;
}

//
// Associates ("Creates") a HUD with a HUD container.
//
static hud_grephandle_t *HUD_Editor_CreateHoverHud(hud_t *hud)
{
	static int i = 0;
	int j = 0;

	if(i >= MAX_HUD_ELEMENTS - 1)
	{
		return NULL;
	}

	// Check if the HUD already exists and use that one if that's the case...
	for(j = 0; j < MAX_HUD_ELEMENTS && hud_containers[j].hud; j++)
	{
		if(hud_containers[j].hud == hud)
		{
			hud_containers[j].next = NULL;
			hud_containers[j].previous = NULL;
			return &hud_containers[j];
		}
	}

	// The HUD wasn't found so add it to the end of the list.
	hud_containers[i].hud = hud;
	hud_containers[i].next = NULL;
	hud_containers[i].previous = NULL;
	i++;

	return &hud_containers[i - 1];
}

//
// Find the HUD that is being selected in the hover list.
//
static hud_t *HUD_Editor_FindHoverListSelection(hud_grephandle_t *list)
{
	hud_t *match = NULL;
	hud_grephandle_t *hud_iter = list;

	while(hud_iter)
	{
		if(hud_iter->hud
			&& hud_mouse_x > hud_iter->x
			&& hud_mouse_x < (hud_iter->x + hud_iter->width)
			&& hud_mouse_y > hud_iter->y
			&& hud_mouse_y < (hud_iter->y + hud_iter->height))
		{
			hud_iter->highlighted = true;
			match = hud_iter->hud;
		}
		else
		{
			hud_iter->highlighted = false;
		}

		hud_iter = hud_iter->next;
	}

	return match;
}

//
// Draw the hover list...
//
static qbool HUD_Editor_DrawHoverList(int x, int y, hud_grephandle_t *list)
{
	#define PADDING 5
	#define LINEGAP	1
	int width = 0;
	int height = 0;
	int i = 0;
	clrinfo_t color, highlight;
	hud_grephandle_t *hud_iter = list;

	// No point in showing a list if there's only one hud under the cursor
	// or if the user hasn't right-clicked.
	if (hud_hoverlist_count <= 1 || hud_editor_mode != hud_editmode_hoverlist)
	{
		return false;
	}

	// Get the width of to draw with.
	while (hud_iter)
	{
		width = max(width, (PADDING + 2 + strlen(hud_iter->hud->name)) * 8);
		hud_iter = hud_iter->next;
	}

	// Draw the background fill.
	height = ((hud_hoverlist_count - 1) * (8 + LINEGAP)) + (2 * PADDING);
	Draw_AlphaFillRGB(x, y - height, width, height, RGBA_TO_COLOR(0, 0, 0, 255));

	hud_iter = list;

	// Highlight color (yellow)...
	highlight.c = RGBA_TO_COLOR(0, 255, 0, 255);
	highlight.i = 0;

	// Orange.
	color.c = RGBA_TO_COLOR(255, 150, 0, 255);
	color.i = 0;

	// Draw the list items.
	while(hud_iter)
	{
		// Calculate the size and position of the HUD in the list.
		hud_iter->x = x;
		hud_iter->y = y - height + (i * 8) + LINEGAP;
		hud_iter->width = width;
		hud_iter->height = 8;

		// Draw the z-order + name of the HUD.
		Draw_ColoredString3(hud_iter->x, hud_iter->y,
			va("%2d - %s", hud_iter->hud->order->integer, hud_iter->hud->name),
			(hud_iter->highlighted ? &highlight : &color), 1, 0);

		hud_iter = hud_iter->next;
		i++;
	}

	return true;
}

//
// Sets a new HUD Editor mode (and saves the previous one).
//
static void HUD_Editor_SetMode(hud_editor_mode_t newmode)
{
	hud_editor_prevmode = hud_editor_mode;
	hud_editor_mode = newmode;
}

//
// Draws a tool tip with a background next to the cursor.
//
static void HUD_Editor_DrawTooltip(int x, int y, char *string, color_t color) //float r, float g, float b, float a)
{
	int len = strlen(string) * 8;

	y -= 9;

	// Make sure we're drawing within the screen.
	if (x + len > vid.width)
	{
		x -= len;
	}

	if (y + 9 > vid.height)
	{
		y -= 9;
	}

	Draw_AlphaFillRGB(x, y, len, 8, color);
	Draw_String(x, y, string);
}

//
// Gets an alignment string for a specified alignmode enum.
//
static char *HUD_Editor_GetAlignmentString(hud_alignmode_t align)
{
	switch(hud_alignmode)
	{
		case hud_align_center :		return "center center";
		case hud_align_top :		return "center top";
		case hud_align_topleft :	return "left top";
		case hud_align_left :		return "left center";
		case hud_align_bottomleft :	return "left bottom";
		case hud_align_bottom :		return "center bottom";
		case hud_align_bottomright :return "right bottom";
		case hud_align_right :		return "right center";
		case hud_align_topright :	return "right top";
		case hud_align_consoleleft :return "left console";
		case hud_align_console :	return "center console";
		case hud_align_consoleright:return "right console";
		default :					return "";
	}
}

//
// Returns an alignment enum based on a specified alignment string.
//
static hud_alignmode_t HUD_Editor_GetAlignmentFromString(char *alignstr)
{
	if(!strcmp(alignstr, "center center"))
	{
		return hud_align_center;
	}
	else if(!strcmp(alignstr, "center top"))
	{
		return hud_align_top;
	}
	else if(!strcmp(alignstr, "left top"))
	{
		return hud_align_topleft;
	}
	else if(!strcmp(alignstr, "left center"))
	{
		return hud_align_left;
	}
	else if(!strcmp(alignstr, "left bottom"))
	{
		return hud_align_bottomleft;
	}
	else if(!strcmp(alignstr, "center bottom"))
	{
		return hud_align_bottom;
	}
	else if(!strcmp(alignstr, "right bottom"))
	{
		return hud_align_bottomright;
	}
	else if(!strcmp(alignstr, "right center"))
	{
		return hud_align_right;
	}
	else if(!strcmp(alignstr, "right top"))
	{
		return hud_align_topright;
	}
	else if(!strcmp(alignstr, "left console"))
	{
		return hud_align_consoleleft;
	}
	else if(!strcmp(alignstr, "center console"))
	{
		return hud_align_console;
	}
	else if(!strcmp(alignstr, "right console"))
	{
		return hud_align_consoleright;
	}

	return hud_align_center;
}

//
// Returns the alignment we are trying to align the selected HUD to at it's placement
// when in alignment mode.
//
static hud_alignmode_t HUD_Editor_GetAlignment(int x, int y, hud_t *hud_element)
{
	// For less clutter.
	float	mid_x		= 0.0;
	float	mid_y		= 0.0;
	int		offset_x	= 0;
	int		offset_y	= 0;

	if(hud_element)
	{
		// Aligns for HUD elements.
		offset_x = hud_element->lx;
		offset_y = hud_element->ly;
		mid_x = hud_element->lw / 2.0;
		mid_y = hud_element->lh / 2.0;
	}
	else
	{
		// Aligns for Screen.
		offset_x = 0;
		offset_y = (int)(vid.height * 0.05);
		mid_x = vid.width / 2.0;
		mid_y = (vid.height + offset_y) / 2.0;
	}

	if(!hud_element)
	{
		// Console left.
		{
			hud_align_consoleleft_poly[0][0] = 0;
			hud_align_consoleleft_poly[0][1] = 0;
			hud_align_consoleleft_poly[0][2] = 0;

			hud_align_consoleleft_poly[1][0] = 0;
			hud_align_consoleleft_poly[1][1] = offset_y;
			hud_align_consoleleft_poly[1][2] = 0;

			hud_align_consoleleft_poly[2][0] = mid_x / 2.0;
			hud_align_consoleleft_poly[2][1] = 0;
			hud_align_consoleleft_poly[2][2] = 0;

			hud_align_consoleleft_poly[3][0] = mid_x / 2.0;
			hud_align_consoleleft_poly[3][1] = offset_y;
			hud_align_consoleleft_poly[3][2] = 0;

			if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_CONSOLE, hud_align_consoleleft_poly, x, y))
			{
				hud_align_current_poly = hud_align_consoleleft_poly;
				hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CONSOLE;
				return hud_align_consoleleft;
			}
		}

		// Console.
		{
			hud_align_console_poly[0][0] = mid_x / 2.0;
			hud_align_console_poly[0][1] = 0;
			hud_align_console_poly[0][2] = 0;

			hud_align_console_poly[1][0] = mid_x / 2.0;
			hud_align_console_poly[1][1] = offset_y;
			hud_align_console_poly[1][2] = 0;

			hud_align_console_poly[2][0] = mid_x + (mid_x / 2.0);
			hud_align_console_poly[2][1] = 0;
			hud_align_console_poly[2][2] = 0;

			hud_align_console_poly[3][0] = mid_x + (mid_x / 2.0);
			hud_align_console_poly[3][1] = offset_y;
			hud_align_console_poly[3][2] = 0;

			if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_CONSOLE, hud_align_console_poly, x, y))
			{
				hud_align_current_poly = hud_align_console_poly;
				hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CONSOLE;
				return hud_align_console;
			}
		}

		// Console right.
		{
			hud_align_consoleright_poly[0][0] = mid_x + (mid_x / 2.0);
			hud_align_consoleright_poly[0][1] = 0;
			hud_align_consoleright_poly[0][2] = 0;

			hud_align_consoleright_poly[1][0] = mid_x + (mid_x / 2.0);
			hud_align_consoleright_poly[1][1] = offset_y;
			hud_align_consoleright_poly[1][2] = 0;

			hud_align_consoleright_poly[2][0] = 2 * mid_x;
			hud_align_consoleright_poly[2][1] = 0;
			hud_align_consoleright_poly[2][2] = 0;

			hud_align_consoleright_poly[3][0] = 2 * mid_x;
			hud_align_consoleright_poly[3][1] = offset_y;
			hud_align_consoleright_poly[3][2] = 0;

			if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_CONSOLE, hud_align_consoleright_poly, x, y))
			{
				hud_align_current_poly = hud_align_consoleright_poly;
				hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CONSOLE;
				return hud_align_consoleright;
			}
		}
	}

	// Top right.
	{
		hud_align_topright_poly[0][0] = mid_x + (mid_x / 4.0);
		hud_align_topright_poly[0][1] = mid_y - (mid_y / 2.0);
		hud_align_topright_poly[0][2] = 0;

		hud_align_topright_poly[1][0] = mid_x + (mid_x / 2.0);
		hud_align_topright_poly[1][1] = mid_y - (mid_y / 4.0);
		hud_align_topright_poly[1][2] = 0;

		hud_align_topright_poly[2][0] = mid_x + (mid_x / 2.0);
		hud_align_topright_poly[2][1] = 0;
		hud_align_topright_poly[2][2] = 0;

		hud_align_topright_poly[3][0] = 2 * mid_x;
		hud_align_topright_poly[3][1] = mid_y - (mid_y / 2.0);
		hud_align_topright_poly[3][2] = 0;

		hud_align_topright_poly[4][0] = 2 * mid_x;
		hud_align_topright_poly[4][1] = 0;
		hud_align_topright_poly[4][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_CORNER, hud_align_topright_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_topright_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CORNER;
			return hud_align_topright;
		}
	}

	// Top.
	{
		hud_align_top_poly[0][0] = mid_x / 2.0;
		hud_align_top_poly[0][1] = 0;
		hud_align_top_poly[0][2] = 0;

		hud_align_top_poly[1][0] = mid_x - (mid_x / 4.0);
		hud_align_top_poly[1][1] = mid_y - (mid_y / 2.0);
		hud_align_top_poly[1][2] = 0;

		hud_align_top_poly[2][0] = mid_x + (mid_x / 2.0);
		hud_align_top_poly[2][1] = 0;
		hud_align_top_poly[2][2] = 0;

		hud_align_top_poly[3][0] = mid_x + (mid_x / 4.0);
		hud_align_top_poly[3][1] = mid_y - (mid_y / 2.0);
		hud_align_top_poly[3][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_EDGE, hud_align_top_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_top_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_EDGE;
			return hud_align_top;
		}
	}

	// Top Left.
	{
		hud_align_topleft_poly[0][0] = 0;
		hud_align_topleft_poly[0][1] = mid_y - (mid_y / 2.0);
		hud_align_topleft_poly[0][2] = 0;

		hud_align_topleft_poly[1][0] = 0;
		hud_align_topleft_poly[1][1] = 0;
		hud_align_topleft_poly[1][2] = 0;

		hud_align_topleft_poly[2][0] = mid_x - (mid_x / 2.0);
		hud_align_topleft_poly[2][1] = mid_y - (mid_y / 4.0);
		hud_align_topleft_poly[2][2] = 0;

		hud_align_topleft_poly[3][0] = mid_x - (mid_x / 2.0);
		hud_align_topleft_poly[3][1] = 0;
		hud_align_topleft_poly[3][2] = 0;

		hud_align_topleft_poly[4][0] = mid_x - (mid_x / 4.0);
		hud_align_topleft_poly[4][1] = mid_y - (mid_y / 2.0);
		hud_align_topleft_poly[4][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_CORNER, hud_align_topleft_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_topleft_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CORNER;
			return hud_align_topleft;
		}
	}

	// Left.
	{
		hud_align_left_poly[0][0] = 0;
		hud_align_left_poly[0][1] = mid_y / 2.0;
		hud_align_left_poly[0][2] = 0;

		hud_align_left_poly[1][0] = 0;
		hud_align_left_poly[1][1] = mid_y + (mid_y / 2.0);
		hud_align_left_poly[1][2] = 0;

		hud_align_left_poly[2][0] = mid_x / 2.0;
		hud_align_left_poly[2][1] = mid_y - (mid_y / 4.0);
		hud_align_left_poly[2][2] = 0;

		hud_align_left_poly[3][0] = mid_x / 2.0;
		hud_align_left_poly[3][1] = mid_y + (mid_y / 4.0);
		hud_align_left_poly[3][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_EDGE, hud_align_left_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_left_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_EDGE;
			return hud_align_left;
		}
	}

	// Bottom Left.
	{
		hud_align_bottomleft_poly[0][0] = 0;
		hud_align_bottomleft_poly[0][1] = 2 * mid_y;
		hud_align_bottomleft_poly[0][2] = 0;

		hud_align_bottomleft_poly[1][0] = 0;
		hud_align_bottomleft_poly[1][1] = mid_y + (mid_y / 2.0);
		hud_align_bottomleft_poly[1][2] = 0;

		hud_align_bottomleft_poly[2][0] = mid_x / 2.0;
		hud_align_bottomleft_poly[2][1] = 2 * mid_y;
		hud_align_bottomleft_poly[2][2] = 0;

		hud_align_bottomleft_poly[3][0] = mid_x / 2.0;
		hud_align_bottomleft_poly[3][1] = mid_y + (mid_y / 4.0);
		hud_align_bottomleft_poly[3][2] = 0;

		hud_align_bottomleft_poly[4][0] = mid_x - (mid_x / 4.0);
		hud_align_bottomleft_poly[4][1] = mid_y + (mid_y / 2.0);
		hud_align_bottomleft_poly[4][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_CORNER, hud_align_bottomleft_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_bottomleft_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CORNER;
			return hud_align_bottomleft;
		}
	}

	// Bottom.
	{
		hud_align_bottom_poly[0][0] = mid_x - (mid_x / 4.0);
		hud_align_bottom_poly[0][1] = mid_y + (mid_y / 2.0);
		hud_align_bottom_poly[0][2] = 0;

		hud_align_bottom_poly[1][0] = mid_x - (mid_x / 2.0);
		hud_align_bottom_poly[1][1] = 2 * mid_y;
		hud_align_bottom_poly[1][2] = 0;

		hud_align_bottom_poly[2][0] = mid_x + (mid_x / 4.0);
		hud_align_bottom_poly[2][1] = mid_y + (mid_y / 2.0);
		hud_align_bottom_poly[2][2] = 0;

		hud_align_bottom_poly[3][0] = mid_x + (mid_x / 2.0);
		hud_align_bottom_poly[3][1] = 2 * mid_y;
		hud_align_bottom_poly[3][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_EDGE, hud_align_bottom_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_bottom_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_EDGE;
			return hud_align_bottom;
		}
	}

	// Bottom Right.
	{
		hud_align_bottomright_poly[0][0] = 2 * mid_x;
		hud_align_bottomright_poly[0][1] = 2 * mid_y;
		hud_align_bottomright_poly[0][2] = 0;

		hud_align_bottomright_poly[1][0] = mid_x + (mid_x / 2.0);
		hud_align_bottomright_poly[1][1] = 2 * mid_y;
		hud_align_bottomright_poly[1][2] = 0;

		hud_align_bottomright_poly[2][0] = 2 * mid_x;
		hud_align_bottomright_poly[2][1] = mid_y + (mid_y / 2.0);
		hud_align_bottomright_poly[2][2] = 0;

		hud_align_bottomright_poly[3][0] = mid_x + (mid_x / 4.0);
		hud_align_bottomright_poly[3][1] = mid_y + (mid_y / 2.0);
		hud_align_bottomright_poly[3][2] = 0;

		hud_align_bottomright_poly[4][0] = mid_x + (mid_x / 2.0);
		hud_align_bottomright_poly[4][1] = mid_y + (mid_y / 4.0);
		hud_align_bottomright_poly[4][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_CORNER, hud_align_bottomright_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_bottomright_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CORNER;
			return hud_align_bottomright;
		}
	}

	// Right.
	{
		hud_align_right_poly[0][0] = mid_x + (mid_x / 2.0);
		hud_align_right_poly[0][1] = mid_y - (mid_y / 4.0);
		hud_align_right_poly[0][2] = 0;

		hud_align_right_poly[1][0] = mid_x + (mid_x / 2.0);
		hud_align_right_poly[1][1] = mid_y + (mid_y / 4.0);
		hud_align_right_poly[1][2] = 0;

		hud_align_right_poly[2][0] = 2 * mid_x;
		hud_align_right_poly[2][1] = mid_y / 2.0;
		hud_align_right_poly[2][2] = 0;

		hud_align_right_poly[3][0] = 2 * mid_x;
		hud_align_right_poly[3][1] = mid_y + (mid_y / 2.0);
		hud_align_right_poly[3][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_EDGE, hud_align_right_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_right_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_EDGE;
			return hud_align_right;
		}
	}

	// Center.
	{
		float x0 = mid_x / 2.0;
		float x1 = mid_x - (mid_x / 4.0);
		float x2 = mid_x + (mid_x / 4.0);
		float x3 = mid_x + (mid_x / 2.0);
		float y0 = mid_y / 2.0;
		float y1 = mid_y - (mid_y / 4.0);
		float y2 = mid_y + (mid_y / 4.0);
		float y3 = mid_y + (mid_y / 2.0);

		hud_align_center_poly[0][0] = x0;
		hud_align_center_poly[0][1] = y1;
		hud_align_center_poly[0][2] = 0;

		hud_align_center_poly[1][0] = x0;
		hud_align_center_poly[1][1] = y2;
		hud_align_center_poly[1][2] = 0;

		hud_align_center_poly[2][0] = x1;
		hud_align_center_poly[2][1] = y0;
		hud_align_center_poly[2][2] = 0;

		hud_align_center_poly[3][0] = x1;
		hud_align_center_poly[3][1] = y3;
		hud_align_center_poly[3][2] = 0;

		hud_align_center_poly[4][0] = x2;
		hud_align_center_poly[4][1] = y0;
		hud_align_center_poly[4][2] = 0;

		hud_align_center_poly[5][0] = x2;
		hud_align_center_poly[5][1] = y3;
		hud_align_center_poly[5][2] = 0;

		hud_align_center_poly[6][0] = x3;
		hud_align_center_poly[6][1] = y1;
		hud_align_center_poly[6][2] = 0;

		hud_align_center_poly[7][0] = x3;
		hud_align_center_poly[7][1] = y2;
		hud_align_center_poly[7][2] = 0;

		if (IsPointInPolygon(HUD_ALIGN_POLYCOUNT_CENTER, hud_align_center_poly, x - offset_x, y - offset_y))
		{
			hud_align_current_poly = hud_align_center_poly;
			hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CENTER;
			return hud_align_center;
		}
	}

	// Default to center.
	hud_align_current_poly = hud_align_center_poly;
	hud_align_current_polycount = HUD_ALIGN_POLYCOUNT_CENTER;
	return hud_align_center;
}

//
// Finds the next child of the specified HUD element.
//
static hud_t *HUD_Editor_FindNextChild(hud_t *hud_element)
{
	static hud_t	*hud_it = NULL;
	static hud_t	*parent = NULL;
	hud_t			*hud_result = NULL;

	// Reset everything if we're given a NULL argument.
	if(!hud_element)
	{
		hud_it = NULL;
		parent = NULL;
		return NULL;
	}

	// There's a new parent so start searching from the beginning.
	if(!parent || strcmp(parent->name, hud_element->name))
	{
		parent = hud_element;
		hud_it = hud_huds;
	}

	while(hud_it)
	{
		// Check if this HUD is placed at the parent, if so we've found a child.
		if(hud_it->place_hud && !strcmp(hud_it->place_hud->name, parent->name))
		{
			hud_result = hud_it;
			hud_it = hud_it->next;
			return hud_result;
		}

		hud_it = hud_it->next;
	}

	parent = NULL;

	// No children found.
	return NULL;
}

//
// Moves a HUD element.
//
static void HUD_Editor_Move(float dx, float dy, hud_t *hud_element)
{
	if(!hud_element)
	{
		return;
	}

	Cvar_SetValue(hud_element->pos_x, hud_element->pos_x->value + dx);
	Cvar_SetValue(hud_element->pos_y, hud_element->pos_y->value + dy);
}

//
// Draw the current alignment.
//
static void HUD_Editor_DrawAlignment(hud_t *hud_parent)
{
	extern void Draw_Polygon(int x, int y, vec3_t *vertices, int num_vertices, color_t color);
	color_t c = RGBA_TO_COLOR(255, 255, 0, 50);

	if (hud_parent) {
		Draw_Polygon(hud_parent->lx, hud_parent->ly, hud_align_current_poly, hud_align_current_polycount, c);
	}
	else {
		Draw_Polygon(0, 0, hud_align_current_poly, hud_align_current_polycount, c);
	}
}

typedef struct hud_resize_handle_s
{
	int x;
	int y;
	int width;
	int height;
} hud_resize_handle_t;

#define HUD_RESIZEHANDLE_THICKNESS		5
#define HUD_RESIZEHANDLE_SIZEFACTOR		0.3
#define HUD_RESIZEHANDLE_COUNT			8
#define HUD_RESIZE_MAGICSCALE			200 // HACK : This seems to work nice though...

#define HUD_RESIZEHANDLE_NONE			-1
#define HUD_RESIZEHANDLE_TOPLEFT		0
#define HUD_RESIZEHANDLE_TOP			1
#define HUD_RESIZEHANDLE_TOPRIGHT		2
#define HUD_RESIZEHANDLE_RIGHT			3
#define HUD_RESIZEHANDLE_BOTTOMRIGHT	4
#define HUD_RESIZEHANDLE_BOTTOM			5
#define HUD_RESIZEHANDLE_BOTTOMLEFT		6
#define HUD_RESIZEHANDLE_LEFT			7

//
// Resizes the height/width of a HUD element by a delta size and alignment.
//
static void HUD_Editor_ResizeDelta(cvar_t *size, float delta_size, hud_alignmode_t alignment)
{
	if(!size)
	{
		return;
	}

	switch(alignment)
	{
		case hud_align_right :
		case hud_align_bottom :
			Cvar_SetValue(size, size->value + delta_size);
			break;
		case hud_align_left :
		case hud_align_top :
			Cvar_SetValue(size, size->value - delta_size);
			break;
		// unhandled
		case hud_align_center:
		case hud_align_topleft:
		case hud_align_bottomleft:
		case hud_align_bottomright:
		case hud_align_topright:
		case hud_align_consoleleft:
		case hud_align_consoleright:
		case hud_align_console:
			break;
	}
}

//
// Scales a HUD element.
//
static void HUD_EditorScaleDelta(cvar_t *scale, float delta_scale, hud_alignmode_t alignment)
{
	if(!scale)
	{
		return;
	}

	switch(alignment)
	{
		case hud_align_topleft :
		case hud_align_bottomleft :
			Cvar_SetValue(scale, scale->value - delta_scale);
			break;
		case hud_align_topright :
		case hud_align_bottomright :
			Cvar_SetValue(scale, scale->value + delta_scale);
			break;
		// unhandled
		case hud_align_center:
		case hud_align_top:
		case hud_align_left:
		case hud_align_bottom:
		case hud_align_right:
		case hud_align_consoleleft:
		case hud_align_consoleright:
		case hud_align_console:
			break;
	}

	if(scale->value < 0)
	{
		Cvar_SetValue(scale, 0);
	}
}

//
// Checks if the HUD element we're hovering has any dimension variables
// and handles resizing for it if it does by drawing resize handles
// that the user can click.
//
static qbool HUD_Editor_Resizing(hud_t *hud_hover)
{
	int i					= 0;
	qbool found_handle		= false;	// Did we find any handle under the cursor?
	static cvar_t *width	= NULL;
	static cvar_t *height	= NULL;
	static cvar_t *scale	= NULL;
	hud_resize_handle_t *resize_handles[HUD_RESIZEHANDLE_COUNT];
	static int last_resize_handle = HUD_RESIZEHANDLE_NONE;

	float mouse_x = HUD_CursorDeltaX();
	float mouse_y = HUD_CursorDeltaY();

	// Is this mode turned on?
	if(!hud_editor_allowresize.value)
	{
		return false;
	}

	// Select a HUD if it hasn't already been done.
	if(hud_hover && hud_editor_mode == hud_editmode_move_resize
		&& !selected_hud && hud_hover)
	{
		selected_hud = hud_hover;
		return true;
	}

	memset(resize_handles, 0, sizeof(resize_handles));

	// Try getting any available dimension variables
	// that are available for this HUD element, these
	// aren't mandatory for all HUD elements, so only
	// some will have them.
	if(hud_hover)
	{
		width	= HUD_FindVar(hud_hover, "width");
		height	= HUD_FindVar(hud_hover, "height");
		scale	= HUD_FindVar(hud_hover, "scale");

		if(width)
		{
			// Right & left.
			static hud_resize_handle_t right;
			static hud_resize_handle_t left;

			right.width		= HUD_RESIZEHANDLE_THICKNESS;
			right.height	= hud_hover->lh * HUD_RESIZEHANDLE_SIZEFACTOR;
			right.x			= hud_hover->lw - right.width;
			right.y			= (hud_hover->lh - right.height) / 2;
			resize_handles[HUD_RESIZEHANDLE_RIGHT] = &right;

			left.width		= HUD_RESIZEHANDLE_THICKNESS;
			left.height		= hud_hover->lh * HUD_RESIZEHANDLE_SIZEFACTOR;
			left.x			= 0;
			left.y			= (hud_hover->lh - left.height) / 2;
			resize_handles[HUD_RESIZEHANDLE_LEFT] = &left;
		}

		if(height)
		{
			// Top & bottom
			static hud_resize_handle_t top;
			static hud_resize_handle_t bottom;

			top.width		= hud_hover->lw * HUD_RESIZEHANDLE_SIZEFACTOR;
			top.height		= HUD_RESIZEHANDLE_THICKNESS;
			top.x			= (hud_hover->lw - top.width) / 2;
			top.y			= 0;
			resize_handles[HUD_RESIZEHANDLE_TOP] = &top;

			bottom.width		= hud_hover->lw * HUD_RESIZEHANDLE_SIZEFACTOR;
			bottom.height		= HUD_RESIZEHANDLE_THICKNESS;
			bottom.x			= (hud_hover->lw - bottom.width) / 2;
			bottom.y			= hud_hover->lh - bottom.height;
			resize_handles[HUD_RESIZEHANDLE_BOTTOM] = &bottom;
		}

		if(scale)
		{
			// Top left, top right, bottom left & bottom right.
			static hud_resize_handle_t topleft;
			static hud_resize_handle_t bottomleft;
			static hud_resize_handle_t topright;
			static hud_resize_handle_t bottomright;

			topleft.width		= HUD_RESIZEHANDLE_THICKNESS;
			topleft.height		= HUD_RESIZEHANDLE_THICKNESS;
			topleft.x			= 0;
			topleft.y			= 0;
			resize_handles[HUD_RESIZEHANDLE_TOPLEFT] = &topleft;

			bottomleft.width	= HUD_RESIZEHANDLE_THICKNESS;
			bottomleft.height	= HUD_RESIZEHANDLE_THICKNESS;
			bottomleft.x		= 0;
			bottomleft.y		= hud_hover->lh - bottomleft.height;
			resize_handles[HUD_RESIZEHANDLE_BOTTOMLEFT] = &bottomleft;

			topright.width		= HUD_RESIZEHANDLE_THICKNESS;
			topright.height		= HUD_RESIZEHANDLE_THICKNESS;
			topright.x			= hud_hover->lw - topright.width;
			topright.y			= 0;
			resize_handles[HUD_RESIZEHANDLE_TOPRIGHT] = &topright;

			bottomright.width	= HUD_RESIZEHANDLE_THICKNESS;
			bottomright.height	= HUD_RESIZEHANDLE_THICKNESS;
			bottomright.x		= hud_hover->lw - bottomright.width;
			bottomright.y		= hud_hover->lh - bottomright.height;
			resize_handles[HUD_RESIZEHANDLE_BOTTOMRIGHT] = &bottomright;
		}
	}

	for(i = 0; i < HUD_RESIZEHANDLE_COUNT; i++)
	{
		// Non existant for this HUD element.
		if(!resize_handles[i])
		{
			continue;
		}

		if(hud_editor_mode == hud_editmode_move_resize)
		{
			// We're in resize mode, so check if we're clicking any of the
			// resize handles.

			if((selected_hud && (last_resize_handle == i)) ||
				  (hud_mouse_x >= (selected_hud->lx + resize_handles[i]->x)
				&& (hud_mouse_x <= (selected_hud->lx + resize_handles[i]->x + resize_handles[i]->width))
				&& (hud_mouse_y >= (selected_hud->ly + resize_handles[i]->y))
				&& (hud_mouse_y <= (selected_hud->ly + resize_handles[i]->y + resize_handles[i]->height))))
			{
				// Keep track of which resize handle we're grabbing
				// so that it doesn't matter if the mouse "slips" outside
				// it's bounding box as long as the mouse is still pressed.
				if(last_resize_handle < 0 || last_resize_handle != i)
				{
					last_resize_handle = i;
				}

				found_handle = true;

				// Draw the resize handle highlighted.
				Draw_AlphaFillRGB(
					selected_hud->lx + resize_handles[last_resize_handle]->x,
					selected_hud->ly + resize_handles[last_resize_handle]->y,
					resize_handles[last_resize_handle]->width,
					resize_handles[last_resize_handle]->height,
					RGBA_TO_COLOR(255, 255, 0, 125));

				// Check which resize handle that has been selected
				// and resize the HUD element accordingly.
				switch(i)
				{
					case HUD_RESIZEHANDLE_RIGHT :
						HUD_Editor_ResizeDelta(width, mouse_x, hud_align_right);
						break;
					case HUD_RESIZEHANDLE_LEFT :
						HUD_Editor_ResizeDelta(width, mouse_x, hud_align_left);
						break;
					case HUD_RESIZEHANDLE_TOP :
						HUD_Editor_ResizeDelta(height, mouse_y, hud_align_top);
						break;
					case HUD_RESIZEHANDLE_BOTTOM :
						HUD_Editor_ResizeDelta(height, mouse_y, hud_align_bottom);
						break;
					case HUD_RESIZEHANDLE_TOPRIGHT :
						// HACK : Dividing by 200 seems to work fine, but this could probably be done a lot nicer.
						HUD_EditorScaleDelta(scale, (mouse_x - mouse_y) / HUD_RESIZE_MAGICSCALE, hud_align_topright);
						break;
					case HUD_RESIZEHANDLE_BOTTOMRIGHT :
						HUD_EditorScaleDelta(scale, (mouse_x + mouse_y) / HUD_RESIZE_MAGICSCALE, hud_align_bottomright);
						break;
					case HUD_RESIZEHANDLE_TOPLEFT :
						HUD_EditorScaleDelta(scale, (mouse_x + mouse_y) / HUD_RESIZE_MAGICSCALE, hud_align_topleft);
						break;
					case HUD_RESIZEHANDLE_BOTTOMLEFT :
						HUD_EditorScaleDelta(scale, (mouse_x - mouse_y) / HUD_RESIZE_MAGICSCALE, hud_align_bottomleft);
						break;
				}

				// Recalculate all HUD elements.
				HUD_Recalculate();
				return true;
			}
		}
		else if(hud_editor_prevmode == hud_editmode_move_resize)
		{
			// We left resize mode.
			selected_hud = NULL;
			last_resize_handle = HUD_RESIZEHANDLE_NONE;
		}
		else if(hud_hover)
		{
			// If we're hovering a HUD, always draw all it's resize handles.
			if((hud_mouse_x >= (hud_hover->lx + resize_handles[i]->x)
				&& hud_mouse_x <= (hud_hover->lx + resize_handles[i]->x + resize_handles[i]->width)
				&& hud_mouse_y >= (hud_hover->ly + resize_handles[i]->y)
				&& hud_mouse_y <= (hud_hover->ly + resize_handles[i]->y + resize_handles[i]->height)))
			{
				// Highlight the resize handle under the cursor.
				Draw_AlphaFillRGB(hud_hover->lx + resize_handles[i]->x, hud_hover->ly + resize_handles[i]->y,
					resize_handles[i]->width, resize_handles[i]->height,
					RGBA_TO_COLOR(255, 255, 0, 125));

				// Set the resize cursor icon since we're hovering a resize handle.
				scr_cursor_icon = hud_editor_resize_icon;
				found_handle = true;
			}
			else
			{
				// Normal resize handle.
				Draw_AlphaFillRGB(hud_hover->lx + resize_handles[i]->x, hud_hover->ly + resize_handles[i]->y,
				resize_handles[i]->width, resize_handles[i]->height,
				RGBA_TO_COLOR(255, 255, 0, 50));
			}
		}
	}

	// We didn't hover any resize handle so show no icon.
	if(!found_handle)
	{
		scr_cursor_icon = NULL;
	}

	// We didn't perform any action, so let others try.
	return false;
}

static qbool hud_editor_locked_axis_is_x = true;	// Are we locking X- or Y-axis movement?
static qbool hud_editor_lockaxis_found= false;		// Have we found what axist to lock on to?
static qbool hud_editor_finding_lockaxis = false;	// Are we in the process of finding the lock axis?

//
// Check if we're supposed to be moving anything.
//
static qbool HUD_Editor_Moving(hud_t *hud_hover)
{
	// Mouse delta
	float mouse_x = HUD_CursorDeltaX();
	float mouse_y = HUD_CursorDeltaY();

	// Is this mode allowed?
	if(!hud_editor_allowmove.value)
	{
		return false;
	}

	// Set the move cursor icon if we're hovering a HUD element
	// unless it's not already set (resize may have set it if
	// a resize handle is being hovered).
	if(hud_hover && !scr_cursor_icon)
	{
		scr_cursor_icon = hud_editor_move_icon;
	}
	else if(!hud_hover)
	{
		// Not hovering anything so show no cursor.
		scr_cursor_icon = NULL;
	}

	// Left mousebutton down = lets move it !
	if (hud_editor_mode == hud_editmode_move_resize || hud_editor_mode == hud_editmode_move_lockedaxis)
	{
		// If we just entered movement mode, nothing is selected
		// so select the hud we're hovering to start with.
		if(!selected_hud && hud_hover)
		{
			selected_hud = hud_hover;
			return true;
		}

		if(selected_hud)
		{
			// Move using the mouse delta instead of the absolute
			// mouse cursor coordinates on the screen.

			// Lock the movement to the axis that the user starts
			// dragging the HUD element along if we're in locked-axis mode.
			if(hud_editor_mode == hud_editmode_move_lockedaxis)
			{
				// We haven't found the axis.
				if(!hud_editor_lockaxis_found)
				{
					static float last_mouse_x = 0.0;
					static float last_mouse_y = 0.0;

					if(!hud_editor_finding_lockaxis)
					{
						// Start trying to find the lock axis.
						hud_editor_finding_lockaxis = true;
						last_mouse_x = 0;
						last_mouse_y = 0;
					}
					else
					{
						// Get the delta of the mouse movement from when the
						// user clicked the mouse button and started dragging.
						float mouse_delta_x = fabs(last_mouse_x - mouse_x);
						float mouse_delta_y = fabs(last_mouse_y - mouse_y);

						// Increment the mouse movement since last frame.
						last_mouse_x += mouse_x;
						last_mouse_y += mouse_y;

						// If the mouse has moved more than 5 pixels in any
						// direction we decide to lock onto that axis.
						if(mouse_delta_x > 5 || mouse_delta_y > 5)
						{
							hud_editor_locked_axis_is_x = (mouse_delta_x > mouse_delta_y);
							hud_editor_lockaxis_found = true;
						}
					}
				}

				// Move while locked to the axis.
				if(hud_editor_locked_axis_is_x)
				{
					// Move only along X-axis.
					HUD_Editor_Move(mouse_x, 0, hud_hover);
				}
				else
				{
					// Move only along Y-axis.
					HUD_Editor_Move(0, mouse_y, hud_hover);
				}
			}
			else
			{
				// Ordinary move.
				HUD_Editor_Move(mouse_x, mouse_y, hud_hover);
			}

			HUD_Recalculate();
			return true;
		}
	}
	else if((hud_editor_prevmode == hud_editmode_move_resize && hud_editor_mode != hud_editmode_move_lockedaxis)
		 || (hud_editor_prevmode == hud_editmode_move_lockedaxis && hud_editor_mode != hud_editmode_move_resize))
	{
		// Only deselect if we're going from a move mode to a non-move mode (Such as align/place).

		// We've left move mode, so deselect.
		selected_hud = NULL;
		hud_editor_lockaxis_found = false;
		hud_editor_finding_lockaxis = false;
	}

	// We haven't handled the input.
	return false;
}

//
// Handles input from mouse if in alignment mode.
//
static qbool HUD_Editor_Aligning(hud_t *hud_hover)
{
	// Is this mode allowed?
	if(!hud_editor_allowalign.value)
	{
		return false;
	}

	if(hud_editor_mode == hud_editmode_align)
	{
		// If we just entered alignment mode, nothing is selected
		// so select the hud we're hovering to start with.
		if(!selected_hud && hud_hover)
		{
			selected_hud = hud_hover;
			return true;
		}

		// Set the align icon for the cursor.
		scr_cursor_icon = hud_editor_align_icon;

		// We have something selected so show some visual
		// feedback for when aligning to the user.
		if(selected_hud)
		{
			if(selected_hud->place_hud)
			{
				// Placed at another HUD, so align onto that.
				hud_alignmode = HUD_Editor_GetAlignment(hud_mouse_x, hud_mouse_y, selected_hud->place_hud);
				HUD_Editor_DrawAlignment(selected_hud->place_hud);
			}
			else
			{
				// Placed on the screen.
				hud_alignmode = HUD_Editor_GetAlignment(hud_mouse_x, hud_mouse_y, NULL);
				HUD_Editor_DrawAlignment(NULL);
			}
		}
	}
	else if(hud_editor_prevmode == hud_editmode_align && keydown[K_ALT])
	{
		// The user just released the mousebutton but is still holding
		// down ALT. If the user releases ALT before the mouse button
		// the operation will be cancelled. So commit the users actions.

		// We must have something to align.
		if(selected_hud)
		{
			// Reset position.
			Cvar_Set(selected_hud->pos_x, "0");
			Cvar_Set(selected_hud->pos_y, "0");

			// Align to the area the mouse is placed over (previously set in hud_alignmode).
			Cbuf_AddText(va("align %s %s\n", selected_hud->name, HUD_Editor_GetAlignmentString(hud_alignmode)));
			HUD_Recalculate();

			// Free selection.
			selected_hud = NULL;
			return true;
		}
	}

	return false;
}

//
// Handles feedback/commiting of actions when in placement mode.
//
static qbool HUD_Editor_Placing(hud_t *hud_hover)
{
	// Is this mode allowed?
	if(!hud_editor_allowplace.value)
	{
		return false;
	}

	// Show the place icon at the cursor if ctrl is pressed
	// while hovering a HUD element.
	if(hud_hover && keydown[K_CTRL])
	{
		// Set the place cursor icon.
		scr_cursor_icon = hud_editor_place_icon;
	}
	else if(!hud_hover)
	{
		scr_cursor_icon = NULL;
	}

	if(hud_editor_mode == hud_editmode_place)
	{
		// If we just entered placement mode, nothing is selected
		// so select the hud we're hovering to start with.
		if(!selected_hud && hud_hover)
		{
			selected_hud = hud_hover;
			return true;
		}

		// Set the place cursor icon.
		scr_cursor_icon = hud_editor_place_icon;

		if(selected_hud)
		{
			// Find the center of the selected HUD so we know where
			// to draw the line from.

			if(hud_hover)
			{
				// We're trying to place the HUD on itself or on the HUD it's already placed at.
				if(hud_hover == selected_hud || (selected_hud->place_hud && selected_hud->place_hud == hud_hover))
				{
					// Red "not allowed".
					Draw_AlphaRectangleRGB(hud_hover->lx, hud_hover->ly, hud_hover->lw, hud_hover->lh, 1, true, RGBA_TO_COLOR(255, 0, 0, 25));
					Draw_AlphaRectangleRGB(hud_hover->lx, hud_hover->ly, hud_hover->lw, hud_hover->lh, 1, false, RGBA_TO_COLOR(255, 0, 0, 255));
				}
				else
				{
					// Green "allowed" placement.
					Draw_AlphaRectangleRGB(hud_hover->lx, hud_hover->ly, hud_hover->lw, hud_hover->lh, 1, true, RGBA_TO_COLOR(0, 255, 0, 25));
				}

				return true;
			}

			// Placement at the screen (We don't care about stuff like IFREE, HBAR, SBAR and so on).
			if(!strcmp(selected_hud->place->string, "screen"))
			{
				// Not allowed, already placed there.
				Draw_AlphaRectangleRGB(0, 0, vid.width, vid.height, 1, true, RGBA_TO_COLOR(255, 0, 0, 25));
			}
			else
			{
				// Allowed.
				Draw_AlphaRectangleRGB(0, 0, vid.width, vid.height, 1, true, RGBA_TO_COLOR(0, 255, 0, 25));
			}
		}
	}
	else if(hud_editor_prevmode == hud_editmode_place && keydown[K_CTRL])
	{
		// We've just exited placement mode, but control is still pressed,
		// that means we should place the selected_hud.
		// (If you release ctrl before you release Mouse 1, you cancel the place operation).

		if(selected_hud)
		{
			// If we're hovering a HUD place it there.
			if(hud_hover)
			{
				// We're trying to place the HUD on itself or on the HUD it's already placed at so do nothing.
				if(hud_hover == selected_hud || (selected_hud->place_hud && selected_hud->place_hud == hud_hover))
				{
					return true;
				}

				// Place at other HUD.
				Cvar_Set(selected_hud->align_x, "center");
				Cvar_Set(selected_hud->align_y, "center");
				Cvar_Set(selected_hud->pos_x, "0");
				Cvar_Set(selected_hud->pos_y, "0");
				Cvar_Set(selected_hud->place, hud_hover->name);

				// Make sure the child has a higher order.
				if((int)selected_hud->order->value <= (int)hud_hover->order->value)
				{
					Cvar_SetValue(selected_hud->order, hud_hover->order->value + 1);
				}

				HUD_Recalculate();

				// Free selection.
				selected_hud = NULL;
				return true;
			}
			else
			{
				// Mouse button was released on on the "screen".

				if(!strcmp(selected_hud->place->string, "screen"))
				{
					return false;
				}

				// Place at other HUD.
				Cvar_Set(selected_hud->align_x, "center");
				Cvar_Set(selected_hud->align_y, "center");
				Cvar_Set(selected_hud->pos_x, "0");
				Cvar_Set(selected_hud->pos_y, "0");
				Cvar_Set(selected_hud->place, "screen");
				HUD_Recalculate();

				// Free selection.
				selected_hud = NULL;
				return true;
			}
		}
	}

	// We weren't placing something so check other states also.
	return false;
}

// =============================================================================
//							HUD Editor Grep Handles.
// =============================================================================
// These show up when a HUD element is moved completly offscreen (by accident
// most likely), so that the user can still grab it and move it back onto the
// screen again.
// =============================================================================

//
// Finds a HUD grephandle (if the hud element has gone offscreen).
//
static hud_grephandle_t *HUD_Editor_FindGrep(hud_t *hud_element)
{
	hud_grephandle_t *greps_it = NULL;
	greps_it = hud_greps;

	while(greps_it)
	{
		if(!strcmp(greps_it->hud->name, hud_element->name))
		{
			return greps_it;
		}

		greps_it = greps_it->next;
	}

	return NULL;
}

//
// Returns an "offscreen" arrow in the correct direction based on where
// offscreen the HUD element is located.
//
static char *HUD_Editor_GetGrepArrow(hud_grephandle_t *grep)
{
	switch(grep->pos)
	{
		case pos_top :		return "/\\";
		case pos_bottom :	return "\\/";
		case pos_left :		return "<<<";
		case pos_right :	return ">>>";
		default :			return "";
	}
}

//
// Draws the grephandles.
//
static void HUD_Editor_DrawGreps(void)
{
	clrinfo_t color, highlight;
	hud_grephandle_t *greps_it = NULL;
	greps_it = hud_greps;

	// Highlight color (yellow).
	highlight.c = RGBA_TO_COLOR(0, 255, 0, 255);
	highlight.i = 0;

	// Orange.
	color.c = RGBA_TO_COLOR(255, 150, 0, 255);
	color.i = 0;

	while(greps_it)
	{
		Draw_ColoredString3(greps_it->x, greps_it->y,
			va("%s %s", HUD_Editor_GetGrepArrow(greps_it), greps_it->hud->name),
			(greps_it->highlighted ? &highlight : &color), 1, 0);

		greps_it = greps_it->next;
	}
}

//
// Get's the position offscreen for a HUD element
// left/right/top/bottom or visible if it's not offscreen.
//
static hud_greppos_t HUD_Editor_GetHudGrepPosition(hud_t *hud)
{
	if(hud->lx + hud->lw <= 0)
	{
		return pos_left;
	}
	else if(hud->lx >= (signed)vid.width)
	{
		return pos_right;
	}
	else if(hud->ly + hud->lh <= 0)
	{
		return pos_top;
	}
	else if(hud->ly >= (signed)vid.height)
	{
		return pos_bottom;
	}

	return pos_visible;
}

//
// Positions a grephandle based on it's position and where the HUD element
// it's associated with is located.
//
static void HUD_Editor_PositionGrep(hud_t *hud_element, hud_grephandle_t *grep)
{
	// Get the position of the grephandle.
	grep->pos = HUD_Editor_GetHudGrepPosition(hud_element);

	// Position the grephandle on screen.
	switch(grep->pos)
	{
		case pos_top :
			grep->x	= hud_element->lx;
			grep->y	= 5;
			break;
		case pos_bottom :
			grep->x	= hud_element->lx;
			grep->y	= vid.height - grep->height - 5;
			break;
		case pos_left :
			grep->x = 5;
			grep->y = hud_element->ly;
			break;
		case pos_right :
			grep->x = vid.width - grep->width - 5;
			grep->y = hud_element->ly;
			break;
		default :
			grep->x = hud_element->lx;
			grep->y = hud_element->ly;
			break;
	}
}

//
// Creates a new grephandle and associates it with a HUD element that is offscreen.
//
static hud_grephandle_t *HUD_Editor_CreateGrep(hud_t *hud_element)
{
	hud_grephandle_t *grep = NULL;

	grep			= Q_malloc(sizeof(hud_grephandle_t));
	memset(grep, 0, sizeof(*grep));

	grep->width		= 8 * (4 + strlen(hud_element->name));
	grep->height	= 8;
	grep->hud		= hud_element;
	grep->previous	= NULL;
	grep->next		= hud_greps;
	if(hud_greps)
	{
		hud_greps->previous = grep;
	}

	hud_greps = grep;

	HUD_Editor_PositionGrep(hud_element, grep);

	return grep;
}

//
// Destroys a grephandle (called if it's no longer offscreen).
//
static void HUD_Editor_DestroyGrep(hud_grephandle_t *grep)
{
	// Already destroyed.
	if(!grep)
	{
		return;
	}

	// Relink any neighbours in the list.
	if(grep->next && grep->previous)
	{
		grep->previous->next = grep->next;
		grep->next->previous = grep->previous;
	}
	else if(grep->next)
	{
		grep->next->previous = NULL;
		hud_greps = grep->next;
	}
	else if(grep->previous)
	{
		grep->previous->next = NULL;
	}
	else
	{
		hud_greps = NULL;
	}

	memset(grep, 0, sizeof(*grep));

	Q_free(grep);
}

//
// Finds a HUD element associated with the grephandle under the mouse cursor.
//
static hud_t *HUD_Editor_FindHudByGrep(void)
{
	hud_grephandle_t *greps_it = NULL;
	greps_it = hud_greps;

	while(greps_it)
	{
		if (greps_it->hud
			&& hud_mouse_x >= greps_it->x
			&& hud_mouse_x <= (greps_it->x + greps_it->width)
			&& hud_mouse_y >= greps_it->y
			&& hud_mouse_y <= (greps_it->y + greps_it->height))
		{
			greps_it->highlighted = true;
			return greps_it->hud;
		}

		greps_it->highlighted = false;

		greps_it = greps_it->next;
	}

	return NULL;
}

//
// Draws the outline of the visible HUD elements.
//
static void HUD_Editor_DrawOutlines(void)
{
	hud_t *temp_hud	= hud_huds;

	if(!temp_hud || !hud_editor_showoutlines)
	{
		return;
	}

	while(temp_hud->next)
	{
		// Check if the item is visible.
		if (!temp_hud->show->value || (temp_hud->place_hud && !temp_hud->place_hud->show->value))
		{
			temp_hud = temp_hud->next;
			continue;
		}

		// Draw an outline for all hud elements (faint).
		Draw_AlphaRectangleRGB(temp_hud->lx, temp_hud->ly, temp_hud->lw, temp_hud->lh, 1, false, RGBA_TO_COLOR(0, 255, 0, 25));

		temp_hud = temp_hud->next;
	}
}

//
// Finds if there's any HUD under the cursor and draws outlines for all HUD elements.
//
static qbool HUD_Editor_FindHudUnderCursor(hud_t **hud)
{
	hud_grephandle_t	*grep		= NULL;
	hud_greppos_t		pos			= pos_visible;
	hud_t				*temp_hud	= hud_huds;
	qbool				found		= false;

	if(!temp_hud)
	{
		return false;
	}

	// Check if we already had something selected since last time and was moving.
	if(selected_hud && (hud_editor_mode == hud_editmode_move_resize || hud_editor_mode == hud_editmode_move_lockedaxis))
	{
		found = true;
		(*hud) = selected_hud;
	}

	// If the hover list is being showed, only look for HUDs in that
	// not the HUD's that are below the cursor.
	if(hud_editor_mode == hud_editmode_hoverlist && hud_hoverlist_count > 0)
	{
		(*hud) = HUD_Editor_FindHoverListSelection(hud_hoverlist);
		return (hud != NULL);
	}

	// Reset the hoverlist since we might be hovering something new.
	hud_hoverlist_count = 0;
	hud_hoverlist = NULL;

	while(temp_hud)
	{
		// Not visible.
		if (!temp_hud->show->value || (temp_hud->place_hud && !temp_hud->place_hud->show->value))
		{
			temp_hud = temp_hud->next;
			continue;
		}

		// We found one.
		if (hud_mouse_x >= temp_hud->lx
			&& hud_mouse_x <= (temp_hud->lx + temp_hud->lw)
			&& hud_mouse_y >= temp_hud->ly
			&& hud_mouse_y <= (temp_hud->ly + temp_hud->lh))
		{
			// If we're moving/resizing something only continue checking for
			// more HUD elements we have the mouse over if we haven't already
			// found one. If we don't do this when you drag a HUD element
			// over another HUD element that has a greater Z-order the selection
			// will jump to that HUD element, and you'll start moving that instead.
			//
			// Vice versa if we would skip any HUD item after we've found one
			// when not already moving an item, it would mean that we could only
			// select HUD elements that are topmost in the Z-order, so an item
			// placed within another item would not be selectable.
			if(((hud_editor_mode == hud_editmode_move_resize || hud_editor_mode == hud_editmode_move_lockedaxis) && !found)
				|| (hud_editor_mode != hud_editmode_move_resize && hud_editor_mode != hud_editmode_move_lockedaxis))
			{
				found = true;
				(*hud) = temp_hud;

				// Add this HUD to the list of HUDs under the cursor.
				HUD_Editor_AddHoverHud(HUD_Editor_CreateHoverHud(temp_hud));
			}
		}

		// Check if the hud element is offscreen and
		// if there's any grep handle for this hud element
		{
			pos = HUD_Editor_GetHudGrepPosition(temp_hud);
			grep = HUD_Editor_FindGrep(temp_hud);

			if(pos != pos_visible)
			{
				// We didn't find any grep handle so create one.
				if(!grep)
				{
					grep = HUD_Editor_CreateGrep(temp_hud);
				}

				// Position the grep if we got one.
				if(grep)
				{
					HUD_Editor_PositionGrep(temp_hud, grep);
				}
			}
			else
			{
				// The HUD element is visbile, so no need for a grep handle for it.
				HUD_Editor_DestroyGrep(grep);
			}
		}

		temp_hud = temp_hud->next;
	}

	// We didn't find any HUD's under the cursor, but
	// what about "grep handles" (for offscreen HUDs).
	if(!found)
	{
		temp_hud = HUD_Editor_FindHudByGrep();

		if(temp_hud)
		{
			found = true;
			(*hud) = temp_hud;
		}
	}

	// Nothing found, make sure result is NULL.
	if (!found)
	{
		(*hud) = NULL;
	}

	return found;
}

//
// Returns the point a HUD is aligned to on it's parent in screen coordinates.
//
static void HUD_Editor_GetAlignmentPoint(hud_t *hud, int *x, int *y)
{
	extern float scr_con_current; // Console height. console.c
	int parent_x = 0;
	int parent_y = 0;
	int parent_w = 0;
	int parent_h = 0;
	hud_alignmode_t alignmode = HUD_Editor_GetAlignmentFromString(va("%s %s", hud->align_x->string, hud->align_y->string));

	if(hud->place_hud)
	{
		// Placed at another HUD.
		parent_x = hud->place_hud->lx;
		parent_y = hud->place_hud->ly;
		parent_w = hud->place_hud->lw;
		parent_h = hud->place_hud->lh;

		(*x) = HUD_CENTER_X(hud->place_hud);
		(*y) = HUD_CENTER_Y(hud->place_hud);
	}
	else
	{
		// Placed at "screen".
		parent_x = 0;
		parent_y = 0;
		parent_w = vid.width;
		parent_h = vid.height;

		(*x) = vid.width / 2;
		(*y) = vid.height / 2;
	}

	switch(alignmode)
	{
		default:
		case hud_align_center:
			// Already set.
			break;
		case hud_align_right:
			(*x) = parent_x + parent_w;
			(*y) = parent_y + (parent_h / 2);
			break;
		case hud_align_topright:
			(*x) = parent_x + parent_w;
			(*y) = parent_y;
			break;
		case hud_align_top:
			(*x) = parent_x + (parent_w / 2);
			(*y) = parent_y;
			break;
		case hud_align_topleft:
			(*x) = parent_x;
			(*y) = parent_y;
			break;
		case hud_align_left:
			(*x) = parent_x;
			(*y) = parent_y + (parent_h / 2);
			break;
		case hud_align_bottomleft:
			(*x) = parent_x;
			(*y) = parent_y + parent_h;
			break;
		case hud_align_bottom:
			(*x) = parent_x + (parent_w / 2);
			(*y) = parent_y + parent_h;
			break;
		case hud_align_bottomright:
			(*x) = parent_x + parent_w;
			(*y) = parent_y + parent_h;
			break;
		case hud_align_consoleleft:
			(*x) = parent_x;
			(*y) = scr_con_current;
			break;
		case hud_align_console:
			(*x) = parent_x + (parent_w / 2);
			(*y) = scr_con_current;
			break;
		case hud_align_consoleright:
			(*x) = parent_x + parent_w;
			(*y) = scr_con_current;
			break;
	}
}

//
// Draws a green line to each corner of a HUD element from a specified point.
//
/*
static void HUD_Editor_DrawLinesToEachCorner(hud_t *hud, int x, int y)
{
	Draw_AlphaLineRGB(hud->lx, hud->ly,						x, y, 1, RGBA_TO_COLOR(0, 255, 0, 25));
	Draw_AlphaLineRGB(hud->lx, hud->ly + hud->lh,			x, y, 1, RGBA_TO_COLOR(0, 255, 0, 25));
	Draw_AlphaLineRGB(hud->lx + hud->lw, hud->ly,			x, y, 1, RGBA_TO_COLOR(0, 255, 0, 25));
	Draw_AlphaLineRGB(hud->lx + hud->lw, hud->ly + hud->lh, x, y, 1, RGBA_TO_COLOR(0, 255, 0, 25));
}
*/

//
// Draws connections to/from a HUD element.
//
static void HUD_Editor_DrawConnections(hud_t *hud_hover)
{
	hud_t *child = NULL;
	int align_x = 0.0;
	int align_y = 0.0;

	if (!hud_hover || !hud_editor_showoutlines)
	{
		return;
	}

	// Get the alignment point at the parent in screen coordinates.
	HUD_Editor_GetAlignmentPoint(hud_hover, &align_x, &align_y);

	// Draw a line to the parent of the HUD we're hovering.
	Draw_AlphaLineRGB(HUD_CENTER_X(hud_hover), HUD_CENTER_Y(hud_hover), align_x, align_y, 1, RGBA_TO_COLOR(0, 255, 0, 25));

	// Draw a line to all children of the HUD we're hovering.
	while((child = HUD_Editor_FindNextChild(hud_hover)))
	{
		// Don't bother with hidden children.
		if(!child->show->value)
		{
			continue;
		}

		// Draw a line from the alignment point on the parent to the child.
		HUD_Editor_GetAlignmentPoint(child, &align_x, &align_y);
		Draw_AlphaLineRGB(align_x, align_y, HUD_CENTER_X(child), HUD_CENTER_Y(child), 1, RGBA_TO_COLOR(0, 255, 0, 25));
	}
}

//
// Evaluates the current mouse/keyboard state and sets the appropriate mode.
//
static void HUD_Editor_EvaluateState(hud_t *hud_hover)
{
	// Mouse 1			= Move + Resize
	// Mouse 2			= Toggle menu
	// Ctrl  + Mouse 1	= Place
	// Alt	 + Mouse 1	= Align
	// Shift + Mouse 1	= Lock moving to one axis (If you start dragging along x-axis, it will stick to that)

	if (MOUSEDOWN)
	{
		// Turn of help on mouse click.
		hud_editor_showhelp = false;
	}

	if (hud_editor_mode == hud_editmode_hoverlist)
	{
		if (!MOUSEDOWN)
		{
			// Stay in hoverlist mode until the user clicks something.
			return;
		}
	}

	if (hud_hover && MOUSEDOWN_1_ONLY && keydown[K_SHIFT])
	{
		// Move (Locked to an axis).
		HUD_Editor_SetMode(hud_editmode_move_lockedaxis);
	}
	else if ((hud_hover || hud_editor_prevmode == hud_editmode_place) && MOUSEDOWN_1_ONLY && keydown[K_CTRL])
	{
		// Place.
		HUD_Editor_SetMode(hud_editmode_place);
	}
	else if ((hud_hover || hud_editor_prevmode == hud_editmode_align) && MOUSEDOWN_1_ONLY && keydown[K_ALT])
	{
		// Align.
		HUD_Editor_SetMode(hud_editmode_align);
	}
	else if ((hud_hover || selected_hud) && MOUSEDOWN_1_ONLY)
	{
		// Move + resize.
		HUD_Editor_SetMode(hud_editmode_move_resize);
	}
	else if (hud_hoverlist_count > 1 && MOUSEDOWN_2_ONLY)
	{
		// Hover list for when hovering more than one HUD.
		HUD_Editor_SetMode(hud_editmode_hoverlist);
	}
	else if (hud_hover && MOUSEDOWN_2_ONLY)
	{
		// HUD element menu for the HUD element we have the mouse over.
		HUD_Editor_SetMode(hud_editmode_hudmenu);
	}
	else if (MOUSEDOWN_2_ONLY)
	{
		// Main menu for adding HUDs if we right click non-occupied space.
		HUD_Editor_SetMode(hud_editmode_menu);
	}
	else
	{
		// Nothing special happening.
		HUD_Editor_SetMode(hud_editmode_normal);
	}
}

//
// Draws the tooltips for a HUD element based on the state we're in.
//
static void HUD_Editor_DrawTooltips(hud_t *hud_hover)
{
	char *message = NULL;
	byte color[4] = {0, 0, 0, 0};

	if(!hud_hover)
	{
		return;
	}

	if (selected_hud)
	{
		switch(hud_editor_mode)
		{
			case hud_editmode_move_lockedaxis :
			case hud_editmode_move_resize :
			{
				message = va("(%d, %d) moving %s", (int)selected_hud->pos_x->value, (int)selected_hud->pos_y->value, selected_hud->name);
				color[0] = 255;
				color[3] = 125;
				break;
			}
			case hud_editmode_align :
			{
				char *align = NULL;

				align = HUD_Editor_GetAlignmentString(hud_alignmode);

				message = va("align %s to %s", selected_hud->name, align);
				color[1] = 255;
				color[2] = 255;
				color[3] = 125;

				break;
			}
			case hud_editmode_place :
			{
				message = va("placing %s", selected_hud->name);
				color[0] = 255;
				color[3] = 125;
				break;
			}
			case hud_editmode_normal :
			{
				message = hud_hover->name;
				color[2] = 255;
				color[3] = 125;
				break;
			}
			// unhandled
			case hud_editmode_off:
			case hud_editmode_resize:
			case hud_editmode_hudmenu:
			case hud_editmode_menu:
			case hud_editmode_hoverlist:
				break;
		}
	}

	if(!message)
	{
		message = hud_hover->name;
		color[2] = 255;
		color[3] = 125;
	}

	HUD_Editor_DrawTooltip(hud_mouse_x, hud_mouse_y, message, RGBA_TO_COLOR(color[0], color[1], color[2], color[3]));
}

//
// Draws a help window.
//
static void HUD_Editor_DrawHelp(void)
{
	#define HUD_EDITOR_HELP_BORDER	32
	#define HUD_EDITOR_HELP_WIDTH	min(vid.conwidth - (2 * HUD_EDITOR_HELP_BORDER), 500)
	#define HUD_EDITOR_HELP_HEIGHT	(vid.conheight - (2 * HUD_EDITOR_HELP_BORDER))
	#define HUD_EDITOR_HELP_X		((vid.conwidth - HUD_EDITOR_HELP_WIDTH) / 2)
	#define HUD_EDITOR_HELP_Y		HUD_EDITOR_HELP_BORDER
	#define HUD_EDITOR_HELP_TITLE	"&cfd0HUD EDITOR HELP"

	Draw_TextBox(HUD_EDITOR_HELP_X, HUD_EDITOR_HELP_Y, HUD_EDITOR_HELP_WIDTH / 8, HUD_EDITOR_HELP_HEIGHT / 8);

	Draw_ColoredString(
		HUD_EDITOR_HELP_X + ((HUD_EDITOR_HELP_WIDTH - strlen(HUD_EDITOR_HELP_TITLE) * 8) / 2),
		HUD_EDITOR_HELP_Y + 10,
		HUD_EDITOR_HELP_TITLE, 1, false);

	UI_PrintTextBlock(
		HUD_EDITOR_HELP_X + 10,
		HUD_EDITOR_HELP_Y + 30,
		HUD_EDITOR_HELP_WIDTH,
		HUD_EDITOR_HELP_HEIGHT - 30,
		"The HUD Editor helps you to customize your Heads Up Display. "
		"When you move the cursor over a HUD element it will be "
		"highlighted and it's name will be shown. When hovering a HUD "
		"you can perform the following actions:\n"
		"\n"
		"&cfd0MOVE&r relative to the HUD elements parent/alignment by "
		"holding down &c0dfMOUSE 1&r and &c0dfdragging&r.\n"
		"(Lock movement to a specific axis by holding down &c0dfSHIFT&r).\n"
		"\n"
		"&cfd0RESIZE&r the HUD element by clicking on one of the "
		"&c0dfresize handles&r that appears when hovering and item and "
		"&c0dfdragging&r. (Not all HUD elements are resizeable/scaleable).\n"
		"\n"
		"&cfd0PLACE&r the HUD element at another HUD element or a location "
		"such as the screen/console by holding down &c0dfCTRL&r when "
		"dragging. The target that the element will be placed in "
		"will turn green if you can place it there, red otherwise.\n"
		"\n"
		"&cfd0ALIGN&r the HUD element in different ways to it's parent by "
		"holding down &c0dfALT&r when dragging. Doing this will show "
		"yellow highlights at the position you're about to align to.\n"
		"\n"
		"  &cfd0Keyboard shortcuts:\n"
		"  &c0dfP&r      Toggle HUD planmode on/off (default on).\n"
		"  &c0dfH&r      Toggle this help.\n"
		"  &c0dfF1&r     Toggle if moving should be allowed.\n"
		"  &c0dfF2&r     Toggle resizing.\n"
		"  &c0dfF3&r     Toggle aligning.\n"
		"  &c0dfF4&r     Toggle placing.\n"
		"  &c0dfSPACE&r  Toggle outlines/guidelines.\n",
		0);
}

int Test_OnGotFocus(ez_control_t *self, void *payload, void *ext_event_info)
{
	EZ_control_SetBackgroundColor(self, self->background_color[0], self->background_color[1], self->background_color[2], 200);
	return 0;
}

int Test_OnLostFocus(ez_control_t *self, void *payload, void *ext_event_info)
{
	EZ_control_SetBackgroundColor(self, self->background_color[0], self->background_color[1], self->background_color[2], 100);
	return 0;
}

ez_control_t *root = NULL;
ez_control_t *child1 = NULL;
ez_control_t *child2 = NULL;
ez_button_t *button = NULL;
ez_label_t *label = NULL;
ez_label_t *label2 = NULL;
ez_slider_t *slider = NULL;
ez_scrollbar_t *scrollbar = NULL;
ez_scrollpane_t *scrollpane = NULL;
ez_listview_t *listview = NULL;
ez_window_t *window = NULL;

int Test_OnButtonDraw(ez_control_t *self, void *payload, void *ext_event_info)
{
	int x, y;
	EZ_control_GetDrawingPosition(self, &x, &y);

	return 0;
}

int Test_OnSliderPositionChanged(ez_control_t *self, void *payload, void *ext_event_info)
{
	ez_slider_t *slider = (ez_slider_t *)self;

	int slider_pos = EZ_slider_GetPosition(slider);

	EZ_label_SetText(label2, va("%i", slider_pos));

	return 0;
}

int Test_OnControlDraw(ez_control_t *self, void *payload, void *ext_event_info)
{
	int x, y; //, i;
	EZ_control_GetDrawingPosition(self, &x, &y);

	/*for (i = 0; i < 30; i++)
	{
		Draw_String(x, y + i*8, va("%d%d%d%d", i, i, i, i));
	}*/

	/*
	{
		char str[] = "Hello this is a sentence that's supposed to fit within a box of stuff, I hope this works...";
		char line[1024];
		int last_index = 0;
		int i = 0;

		while (Util_GetNextWordwrapString(str, line, last_index, &last_index, sizeof(str) / sizeof(char), self->width, 8))
		{
			Draw_String(x, y + i*8, line);
			i++;
		}
	}
	*/

	/*{
		clrinfo_t color;
		color.i = 0;
		color.c = RGBA_TO_COLOR(0, 255, 0, 255);
		Draw_BigString(x, y, "Hej", &color, 1, 1, 1, 0);
	}*/

	return 0;
}

static hud_t *hud_hover = NULL;

//
// Main HUD Editor function.
//
static void HUD_Editor(void)
{
	qbool found = false;

	// If we just entered hoverlist mode we want to keep the mouse coordinates
	// so we know where to draw the list until the user has picked a HUD.
	if (!hud_hoverlist_pos_is_set
		&& hud_editor_mode == hud_editmode_hoverlist
		&& hud_editor_prevmode != hud_editmode_hoverlist)
	{
		hud_hoverlist_x = cursor_x;
		hud_hoverlist_y = cursor_y;
		hud_hoverlist_pos_is_set = true;
	}
	else if (hud_editor_mode != hud_editmode_hoverlist)
	{
		hud_hoverlist_pos_is_set = false;
	}

	// Find the HUD we're moving or have the cursor over.
	found = HUD_Editor_FindHudUnderCursor(&hud_hover);

	// Draw faint outlines for all visible hud elements.
	HUD_Editor_DrawOutlines();

	// Draw the "grep handles" for offscreen HUDs.
	HUD_Editor_DrawGreps();

	// Draw a rectangle around the currently active HUD element.
	if(found && hud_hover)
	{
		Draw_AlphaRectangleRGB(hud_hover->lx, hud_hover->ly, hud_hover->lw, hud_hover->lh, 1, false, RGBA_TO_COLOR(0, 255, 0, 255));
	}

	// If we are realigning draw a green outline for the selected hud element.
	if (selected_hud)
	{
		Draw_AlphaRectangleRGB(selected_hud->lx, selected_hud->ly, selected_hud->lw, selected_hud->lh, 2, false, RGBA_TO_COLOR(0, 255, 0, 255));
	}

	// Check the mouse/keyboard states and if we're hovering above a hud or not.
	HUD_Editor_EvaluateState(hud_hover);

	// Draw the child/parent connections the hud we're hovering has.
	HUD_Editor_DrawConnections(hud_hover);

	// Draw a red line from selected hud to cursor.
	if (selected_hud)
	{
		Draw_AlphaLineRGB(hud_mouse_x, hud_mouse_y, HUD_CENTER_X(selected_hud), HUD_CENTER_Y(selected_hud), 1, RGBA_TO_COLOR(255, 0, 0, 255));
	}

	// Check if we're performing any action.
	// (Only perform one at any given time).
	(void)
	(HUD_Editor_DrawHoverList(hud_hoverlist_x, hud_hoverlist_y, hud_hoverlist)
		 || HUD_Editor_Resizing(hud_hover)
		 || HUD_Editor_Moving(hud_hover)
		 || HUD_Editor_Placing(hud_hover)
		 || HUD_Editor_Aligning(hud_hover));

	// Draw tooltips for the HUD.
	HUD_Editor_DrawTooltips(hud_hover);

	// Show the help window?
	if(hud_editor_showhelp)
	{
		HUD_Editor_DrawHelp();
	}

	EZ_tree_EventLoop(&help_control_tree);
}

//
// Toggles the HUD Editor on or off.
//
void HUD_Editor_Toggle_f(void)
{
	extern cvar_t scr_newHud;
	// static keydest_t key_dest_prev = key_game;
	static int old_hud_planmode = 0;

	if (cls.state != ca_active)
	{
		// We can't turn on the hud editor when disconnected.
		if(!hud_editor)
		{
			Com_Printf("You need to be in game to use the HUD editor.\n");
		}

		// If the hud editor managed to still be on while disconnected.
		hud_editor = false;
	}
	else if (!scr_newHud.value)
	{
		Com_Printf("You have to have scr_newHud turned on to use the HUD editor.\n");
		hud_editor = false;
	}
	else
	{
		// Toggle.
		hud_editor = !hud_editor;
		S_LocalSound("misc/basekey.wav");
	}

	if (hud_editor)
	{
		// Start HUD Editor.

		key_dest = key_hudeditor;
		HUD_Editor_SetMode(hud_editmode_normal);

		// Set planmode by default.
		old_hud_planmode = hud_planmode.value;
		Cvar_SetValue(&hud_planmode, 1.0);

		// Start showing the help plaque so the user learns the controls.
		hud_editor_showhelp = true;
	}
	else
	{
		// Exit the HUD Editor.

		key_dest = key_game;
		key_dest_beforecon = key_game;
		HUD_Editor_SetMode(hud_editmode_off);
		scr_cursor_icon = NULL;

		// Reset to the old value for HUD planmode.
		Cvar_SetValue(&hud_planmode, old_hud_planmode);
	}
}

//
// Handles mouse events sent to the HUD editor.
//
qbool HUD_Editor_MouseEvent(mouse_state_t *ms)
{
	// Updating cursor location.
	if(hud_editor_mode == hud_editmode_move_lockedaxis)
	{
		// Don't update the HUD Editor cursor if the axis is locked
		// so that we avoid explicit checks for that.
		// The cursor will still move around the screen properly.
		if(hud_editor_locked_axis_is_x)
		{
			hud_mouse_x = ms->x;

			// Draw a line that indicates that the movement is locked to the X-axis.
			if (selected_hud)
			{
				Draw_AlphaLineRGB(0, HUD_CENTER_Y(selected_hud), vid.width, HUD_CENTER_Y(selected_hud), 1, RGBA_TO_COLOR(255, 0, 0, 75));
			}
		}
		else
		{
			hud_mouse_y = ms->y;

			if (selected_hud)
			{
				Draw_AlphaLineRGB(HUD_CENTER_X(selected_hud), 0, HUD_CENTER_X(selected_hud), vid.height, 1, RGBA_TO_COLOR(255, 0, 0, 75));
			}
		}
	}
	else
	{
		// Normal operation, always update cursor.
		hud_mouse_x = ms->x;
		hud_mouse_y = ms->y;
	}

	return EZ_tree_MouseEvent(&help_control_tree, ms);
}

//
// Handles key events sent to the HUD editor.
//
void HUD_Editor_Key(int key, int unichar, qbool down)
{
	static int planmode = 1;
	int togglekeys[2];

	EZ_tree_KeyEvent(&help_control_tree, key, unichar, down);

	M_FindKeysForCommand("toggleconsole", togglekeys);
	if (Key_IsConsoleToggle(key) || (key == togglekeys[0]) || (key == togglekeys[1])) {
		HUD_Editor_Toggle_f();
		Con_ToggleConsole_f();
		return;
	}

	if (down)
	{
		switch (key)
		{
			case K_ESCAPE:
				HUD_Editor_Toggle_f();
				break;
			case 'p' :
				// Toggle HUD plan mode.
				planmode = !planmode;
				Cvar_SetValue(&hud_planmode, planmode);
				break;
			case 'h' :
				// Toggle the help window.
				hud_editor_showhelp = !hud_editor_showhelp;
				break;
			case K_SPACE :
				// Toggle hud element outlines.
				hud_editor_showoutlines = !hud_editor_showoutlines;
				break;
			case K_F1 :
				// Toggle moving.
				Cvar_SetValue(&hud_editor_allowmove, !hud_editor_allowmove.value);
				break;
			case K_F2 :
				// Toggle resizing.
				Cvar_SetValue(&hud_editor_allowresize, !hud_editor_allowresize.value);
				break;
			case K_F3 :
				// Toggle aligning.
				Cvar_SetValue(&hud_editor_allowalign, !hud_editor_allowalign.value);
				break;
			case K_F4 :
				// Toggle placing.
				Cvar_SetValue(&hud_editor_allowplace, !hud_editor_allowplace.value);
				break;
			case K_UPARROW :
				// TODO : Add "nudging" in hud editor.
				break;
			case K_DOWNARROW :
				// TODO : Add "nudging" in hud editor.
				break;
			case K_LEFTARROW :
				// TODO : Add "nudging" in hud editor.
				break;
			case K_RIGHTARROW :
				// TODO : Add "nudging" in hud editor.
				break;
		}
	}
}

//
// Inits HUD Editor.
//
void HUD_Editor_Init(void)
{
	extern mpic_t *SCR_LoadCursorImage(char *cursorimage);

#if 0
	clrinfo_t color;

	color.c = RGBA_TO_COLOR(255, 255, 255, 255);
	color.i = 0;

	// Root
	{
		root = EZ_control_Create(&help_control_tree, NULL, "Test window", "Test", 50, 50, 400, 400, control_focusable | control_movable | control_resize_h | control_resize_v);
		EZ_control_SetBackgroundColor(root, 0, 0, 0, 100);
		EZ_control_SetSize(root, 400, 400);
	}

	// Child 1
	{
		child1 = EZ_control_Create(&help_control_tree, root, "Child 1", "Test", 10, 10, 50, 50, control_focusable | control_movable | control_contained | control_scrollable | control_resizeable);

		EZ_control_AddOnGotFocus(child1, Test_OnGotFocus, NULL);
		EZ_control_AddOnLostFocus(child1, Test_OnLostFocus, NULL);
		EZ_control_AddOnDraw(child1, Test_OnControlDraw, NULL);

		EZ_control_SetMinVirtualSize(child1, child1->width * 3, child1->height * 3);
		//EZ_control_SetVirtualSize(child1, child1->width * 4, child1->height * 2);

		EZ_control_SetBackgroundColor(child1, 150, 150, 0, 100);
	}

	// Child 2
	{
		child2 = EZ_control_Create(&help_control_tree, root, "Child 2", "Test", 30, 50, 50, 20, control_focusable | control_contained);

		EZ_control_AddOnGotFocus(child2, Test_OnGotFocus, NULL);
		EZ_control_AddOnLostFocus(child2, Test_OnLostFocus, NULL);

		EZ_control_SetBackgroundColor(child2, 150, 150, 200, 100);
	}

	// Button.
	{
		button = EZ_button_Create(&help_control_tree, child1, "button", "A crazy button!", 15, -15, 80, 60, control_contained | control_resizeable);
		EZ_control_AddOnDraw((ez_control_t *)button, Test_OnButtonDraw, NULL);

		EZ_button_SetFocusedColor(button, 255, 0, 0, 255);
		EZ_button_SetNormalColor(button, 255, 255, 0, 100);
		EZ_button_SetPressedColor(button, 255, 255, 0, 255);
		EZ_button_SetHoverColor(button, 255, 0, 0, 150);

		EZ_button_SetToggleable(button, true);

		EZ_button_SetText(button, "Button");
		EZ_button_SetTextAlignment(button, middle_center);

		EZ_control_SetAnchor((ez_control_t *)button, (anchor_left | anchor_right | anchor_bottom));
	}

	// Label.
	{
		label = EZ_label_Create(&help_control_tree, root,
			"label", "A crazy label!", 200, 200, 250, 80,
			control_focusable | control_contained | control_resizeable | control_scrollable /*| control_movable */ | control_resize_h | control_resize_v,
			label_wraptext | label_autosize,
			"Hello\nthis is a test are you fine because I am bla bla bla this is a very long string and it's plenty of fun haha!");

		EZ_label_SetTextScale(label, 2.0);
		//EZ_label_SetTextFlags(label, LABEL_READONLY);

		EZ_control_SetBackgroundColor((ez_control_t *)label, 150, 150, 0, 50);
		//EZ_control_SetAnchor((ez_control_t *)label, anchor_top | anchor_right | anchor_bottom);
	}

	// Label 2.
	{
		label2 = EZ_label_Create(&help_control_tree, root,
			"label2", "A crazy label!", 100, 50, 32, 16,
			control_focusable | control_contained | control_resizeable,
			0, "");
	}

	// Slider.
	{
		slider = EZ_slider_Create(&help_control_tree, root,
			"slider", "Slider omg", 50, 100, 150, 8, control_focusable | control_contained | control_resizeable);

		EZ_control_SetAnchor((ez_control_t *)slider, anchor_left | anchor_right);

		EZ_slider_SetMax(slider, 100);
		EZ_slider_SetMin(slider, 50);
		EZ_slider_SetPosition(slider, 5);
		EZ_slider_SetScale(slider, 1.0);

		EZ_slider_AddOnSliderPositionChanged(slider, Test_OnSliderPositionChanged, NULL);
	}

	/*
	// Scrollbar.
	{
		ez_control_t *label_ctrl = (ez_control_t *)label;

		scrollbar = EZ_scrollbar_Create(&help_control_tree, root, "Scrollbar", "",
			30, 150, 10, 150, control_anchor_viewport);

		EZ_scrollbar_SetTargetParent(scrollbar, false);
		//EZ_control_SetContained((ez_control_t *)scrollbar, false);
		EZ_control_SetAnchor((ez_control_t *)scrollbar, anchor_right | anchor_top | anchor_bottom);
		EZ_control_SetMovable((ez_control_t *)scrollbar, false);
	}
	*/

	// Listview
	{
		listview = EZ_listview_Create(&help_control_tree, root, "Listview", "", 50, 50, 200, 200,
			control_resize_h | control_resize_v | control_resizeable);

		EZ_listview_SetHeaderText(listview, 0, "Hej");
		EZ_listview_SetHeaderText(listview, 1, "Hej 2");

		EZ_listview_SetColumnWidth(listview, 0, 80);
		EZ_listview_SetColumnWidth(listview, 1, 50);
	}

	// Scrollpane
	{
		scrollpane = EZ_scrollpane_Create(&help_control_tree, root, "Scrollpane", "", -10, -20, 150, 150,
			control_resize_h | control_resize_v | control_resizeable);

		EZ_control_SetBackgroundColor((ez_control_t *)scrollpane, 255, 0, 0, 100);

		//EZ_scrollpane_SetTarget(scrollpane, child1);
		EZ_scrollpane_SetTarget(scrollpane, (ez_control_t *)listview);
	}

	// Window.
	{
		window = EZ_window_Create(&help_control_tree, root, "Window", NULL, 20, 20, 150, 150,
			control_movable | control_focusable | control_resize_h | control_resize_v | control_contained);

		EZ_control_SetBackgroundColor((ez_control_t *)window, 0, 100, 0, 100);

		EZ_window_SetWindowAreaMinVirtualSize(window, 200, 200);

		//EZ_window_AddChild(window, (ez_control_t *)scrollpane);
	}

	/*
	// Test.
	{
		ez_control_t *c = EZ_control_Create(&help_control_tree, root, "C test 1", "Test", 10, 10, 150, 150,
			control_resize_h | control_focusable | control_movable | control_contained | control_scrollable | control_resizeable);

		ez_control_t *c2 = EZ_control_Create(&help_control_tree, c, "C test 1", "Test", 0, 10, 30, 10,
			control_focusable | control_movable | control_contained | control_scrollable | control_resizeable);

		EZ_control_SetAnchor(c2, anchor_top | anchor_right);
		EZ_control_SetBackgroundColor(c2, 150, 0, 20, 100);

		EZ_control_SetBackgroundColor(c, 50, 40, 50, 100);
	}
	*/

	EZ_tree_Refresh(&help_control_tree);

#endif

	// Register commands.
	Cmd_AddCommand("hud_editor", HUD_Editor_Toggle_f);

	// Register variables.
	Cvar_SetCurrentGroup(CVAR_GROUP_HUD);
	Cvar_Register(&hud_editor_allowresize);
	Cvar_Register(&hud_editor_allowmove);
	Cvar_Register(&hud_editor_allowplace);
	Cvar_Register(&hud_editor_allowalign);
    Cvar_ResetCurrentGroup();

	// Load HUD editor cursor icons.
	hud_editor_move_icon = SCR_LoadCursorImage("gfx/hud_move_icon");
	hud_editor_resize_icon = SCR_LoadCursorImage("gfx/hud_resize_icon");
	hud_editor_align_icon = SCR_LoadCursorImage("gfx/hud_align_icon");
	hud_editor_place_icon = SCR_LoadCursorImage("gfx/hud_place_icon");

	hud_editor = false;
	HUD_Editor_SetMode(hud_editmode_off);
}

//
// Draws the HUD Editor if it's on.
//
void HUD_Editor_Draw(void)
{
	if (!hud_editor)
		return;

	HUD_Editor();
}

//
// Should this HUD element be fully drawn or not when in align mode
// when using the HUD editor?
//
qbool HUD_Editor_ConfirmDraw(hud_t *hud)
{
	if(hud_editor_mode == hud_editmode_align || hud_editor_mode == hud_editmode_place)
	{
		// If this is the selected hud, or the parent of the selected hud then draw it.
		if((selected_hud && !strcmp(selected_hud->name, hud->name))
			|| (selected_hud && hud->place_hud && !strcmp(selected_hud->name, hud->place_hud->name)))
		{
			return true;
		}

		return false;
	}

	return true;
}



================================================
FILE: src/hud_editor.h
================================================
/*
HUD Editor module

Copyright (C) 2007 Cokeman

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __HUD_EDITOR_H__
#define __HUD_EDITOR_H__

// hud editor drawing function
void HUD_Editor_Draw(void);

// hud editor initialization
void HUD_Editor_Init(void);

// Mouse processing.
qbool HUD_Editor_MouseEvent (mouse_state_t *ms);

// Key press processing function.
void HUD_Editor_Key(int key, int unichar, qbool down);

//
// Should this HUD element be fully drawn or not when in align mode
// when using the HUD editor.
//
qbool HUD_Editor_ConfirmDraw(hud_t *hud);

typedef enum
{
	hud_editmode_off,
	hud_editmode_align,
	hud_editmode_place,
	hud_editmode_move_resize,
	hud_editmode_resize,
	hud_editmode_move_lockedaxis,
	hud_editmode_hudmenu,
	hud_editmode_menu,
	hud_editmode_hoverlist,
	hud_editmode_normal
} hud_editor_mode_t;

extern hud_editor_mode_t	hud_editor_mode;
extern hud_t				*selected_hud;

#endif // __HUD_EDITOR_H__


================================================
FILE: src/hud_face.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"

// face
void SCR_HUD_DrawFace(hud_t *hud)
{
	extern mpic_t  *sb_faces[5][2]; // 0 is dead, 1-4 are alive
									// 0 is static, 1 is temporary animation
	extern mpic_t  *sb_face_invis;
	extern mpic_t  *sb_face_quad;
	extern mpic_t  *sb_face_invuln;
	extern mpic_t  *sb_face_invis_invuln;

	int     f, anim;
	int     x, y;
	float   scale;

	static cvar_t *v_scale = NULL;
	if (v_scale == NULL)  // first time called
	{
		v_scale = HUD_FindVar(hud, "scale");
	}

	scale = max(v_scale->value, 0.01);

	if (cl.spectator != cl.autocam)
		return;
	
	if (!HUD_PrepareDraw(hud, 24 * scale, 24 * scale, &x, &y))
		return;

	if ((HUD_Stats(STAT_ITEMS) & (IT_INVISIBILITY | IT_INVULNERABILITY))
		== (IT_INVISIBILITY | IT_INVULNERABILITY)) {
		Draw_SPic(x, y, sb_face_invis_invuln, scale);
		return;
	}
	if (HUD_Stats(STAT_ITEMS) & IT_QUAD) {
		Draw_SPic(x, y, sb_face_quad, scale);
		return;
	}
	if (HUD_Stats(STAT_ITEMS) & IT_INVISIBILITY) {
		Draw_SPic(x, y, sb_face_invis, scale);
		return;
	}
	if (HUD_Stats(STAT_ITEMS) & IT_INVULNERABILITY) {
		Draw_SPic(x, y, sb_face_invuln, scale);
		return;
	}

	if (HUD_Stats(STAT_HEALTH) >= 100)
		f = 4;
	else
		f = max(0, HUD_Stats(STAT_HEALTH)) / 20;

	if (cl.time <= cl.faceanimtime)
		anim = 1;
	else
		anim = 0;
	Draw_SPic(x, y, sb_faces[f][anim], scale);
}

void Face_HudInit(void)
{
	// player face (health indicator)
	HUD_Register(
		"face", NULL, "Your bloody face.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawFace,
		"1", "screen", "center", "bottom", "0", "0", "0", "0 0 0", NULL,
		"scale", "1",
		NULL
	);
}


================================================
FILE: src/hud_frags.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "hud.h"
#include "hud_common.h"
#include "utils.h"
#include "sbar.h"
#include "fonts.h"

#define MAX_FRAGS_NAME 32
#define FRAGS_HEALTH_SPACING 1

#define	TEAMFRAGS_EXTRA_SPEC_NONE	0
#define TEAMFRAGS_EXTRA_SPEC_BEFORE	1
#define	TEAMFRAGS_EXTRA_SPEC_ONTOP	2
#define TEAMFRAGS_EXTRA_SPEC_NOICON 3
#define TEAMFRAGS_EXTRA_SPEC_RLTEXT 4

#define FRAGS_HEALTHBAR_NORMAL_COLOR	75
#define FRAGS_HEALTHBAR_MEGA_COLOR		251
#define	FRAGS_HEALTHBAR_TWO_MEGA_COLOR	238
#define	FRAGS_HEALTHBAR_UNNATURAL_COLOR	144

static qbool hud_frags_extra_spec_info = true;
static qbool hud_frags_show_rl = true;
static qbool hud_frags_show_lg = true;
static qbool hud_frags_show_armor = true;
static qbool hud_frags_show_health = true;
static qbool hud_frags_show_powerup = true;
static qbool hud_frags_textonly = false;
static qbool hud_frags_horiz_health = false;
static qbool hud_frags_horiz_power = false;

static void Frags_DrawHorizontalHealthBar(player_info_t* info, int x, int y, int width, int height, qbool flip, qbool use_power)
{
	static cvar_t* health_color_nohealth = NULL;
	static cvar_t* health_color_normal = NULL;
	static cvar_t* health_color_mega = NULL;
	static cvar_t* health_color_twomega = NULL;
	static cvar_t* health_color_unnatural = NULL;
	static cvar_t* armor_color_noarmor = NULL;
	static cvar_t* armor_color_ga_over = NULL;
	static cvar_t* armor_color_ga = NULL;
	static cvar_t* armor_color_ya = NULL;
	static cvar_t* armor_color_ra = NULL;
	static cvar_t* armor_color_unnatural = NULL;

	int armor = info->stats[STAT_ARMOR];
	int items = info->stats[STAT_ITEMS];
	int health;
	int true_health = info->stats[STAT_HEALTH];
	float max_health = (use_power ? 450 : 250);
	float max_armor = 200;
	float armorType;
	float health_width, armor_width;
	float max_health_width, max_health_value;
	int health_height = (height * 3) / 4;
	int armor_height = height - health_height;
	color_t armor_color = 0;
	color_t health_color = 0;
	double now = (cls.mvdplayback ? cls.demotime : cl.time);
	qbool prewar = cl.standby || cl.countdown;

	float drop_wait_time = 3.0f;
	float drop_speed = 300.0f;

	byte* bk;
	color_t border_color;

	// Use other hud elements to get range of colours
	if (health_color_nohealth == NULL) {
		health_color_nohealth = Cvar_Find("hud_bar_health_color_nohealth");
		health_color_normal = Cvar_Find("hud_bar_health_color_normal");
		health_color_mega = Cvar_Find("hud_bar_health_color_mega");
		health_color_twomega = Cvar_Find("hud_bar_health_color_twomega");
		health_color_unnatural = Cvar_Find("hud_bar_health_color_unnatural");

		armor_color_noarmor = Cvar_Find("hud_bar_armor_color_noarmor");
		armor_color_ga_over = Cvar_Find("hud_bar_armor_color_ga_over");
		armor_color_ga = Cvar_Find("hud_bar_armor_color_ga");
		armor_color_ya = Cvar_Find("hud_bar_armor_color_ya");
		armor_color_ra = Cvar_Find("hud_bar_armor_color_ra");
		armor_color_unnatural = Cvar_Find("hud_bar_armor_color_unnatural");
	}

	bk = (byte*)&health_color_nohealth->color;
	border_color = RGBA_TO_COLOR(
		max(bk[0], 24) - 24,
		max(bk[1], 24) - 24,
		max(bk[2], 24) - 24,
		min(bk[3], 128) + 127
	);

	if (health_color_nohealth == NULL || armor_color_noarmor == NULL) {
		return;
	}

	// work out colours
	armorType = true_health >= 1 ? SCR_HUD_ArmorType(items) : 0;
	if (items & IT_INVULNERABILITY && true_health >= 1) {
		armor_color = RGBAVECT_TO_COLOR(armor_color_unnatural->color);
	}
	else if (items & IT_ARMOR3 && true_health >= 1) {
		armor_color = RGBAVECT_TO_COLOR(armor_color_ra->color);
		max_armor = 200;
	}
	else if (items & IT_ARMOR2 && true_health >= 1) {
		armor_color = RGBAVECT_TO_COLOR(armor_color_ya->color);
		max_armor = 150;
	}
	else if (items & IT_ARMOR1 && true_health >= 1) {
		if (armor > 100) {
			armor_color = RGBAVECT_TO_COLOR(armor_color_ga_over->color);
		} else {
			armor_color = RGBAVECT_TO_COLOR(armor_color_ga->color);
		}
		max_armor = 100;
	}

	if (use_power) {
		health = prewar ? 0 : SCR_HUD_TotalStrength(true_health, armor, armorType);
		if (health <= 110) {
			health_color = RGBAVECT_TO_COLOR(health_color_normal->color);
		}
		else if (health <= 220) {
			health_color = RGBAVECT_TO_COLOR(health_color_mega->color);
		}
		else if (health <= 450) {
			health_color = RGBAVECT_TO_COLOR(health_color_twomega->color);
		}
		else {
			health_color = RGBAVECT_TO_COLOR(health_color_unnatural->color);
		}
	}
	else {
		health = prewar ? 0 : true_health;
		if (health <= 100) {
			health_color = RGBAVECT_TO_COLOR(health_color_normal->color);
		}
		else if (health <= 200) {
			health_color = RGBAVECT_TO_COLOR(health_color_mega->color);
		}
		else if (health <= 250) {
			health_color = RGBAVECT_TO_COLOR(health_color_twomega->color);
		}
		else {
			health_color = RGBAVECT_TO_COLOR(health_color_unnatural->color);
		}
	}

	// Background
	Draw_AlphaRectangleRGB(x, y, width, health_height, 1.0, false, border_color);
	Draw_AlphaFillRGB(x, y + health_height, width, armor_height, RGBAVECT_TO_COLOR(armor_color_noarmor->color));
	x += 1;
	width -= 2;
	y += 1;
	health_height -= 2;
	Draw_AlphaFillRGB(x, y, width, health_height, RGBAVECT_TO_COLOR(health_color_nohealth->color));

	// Calculate figures
	health = min(health, max_health);
	if (info->prev_health > health && info->prev_health > 0) {
		// Decrease health bar to current health
		double dropTime = now - info->prev_health_last_set;
		int new_health = health;

		health = max(health, info->prev_health - dropTime * drop_speed);
		if (health == new_health) {
			info->prev_health = health;
			info->prev_health_last_set = now;
		}
	}
	else if (info->prev_health < health && info->prev_health > 0) {
		// Increase health bar to current health
		double dropTime = now - info->prev_health_last_set;
		int new_health = health;

		health = min(health, info->prev_health + dropTime * drop_speed);
		if (health == new_health) {
			info->prev_health = health;
			info->prev_health_last_set = now;
		}
	}
	else {
		info->prev_health = (prewar && health == max_health ? 0 : health);
		info->prev_health_last_set = now;
	}

	// Decrease the maximum health
	max_health_value = min(info->max_health, max_health);
	if (info->max_health_last_set && info->max_health_last_set < now - drop_wait_time) {
		double dropTime = now - info->max_health_last_set - drop_wait_time;

		if (health < info->max_health && info->prev_health > 0) {
			max_health_value = max(health, info->max_health - dropTime * drop_speed);
			if (max_health_value == health) {
				info->max_health = max_health_value = health;
				info->max_health_last_set = 0;
			}
		}
		else {
			info->max_health = max_health_value = (prewar ? 0 : health);
			info->max_health_last_set = 0;
		}
	}
	else if (health >= info->max_health) {
		info->max_health = (prewar ? 0 : health);
		info->max_health_last_set = 0;
	}
	else if (health < info->prev_health && !cls.mvdplayback) {
		info->max_health_last_set = now;
	}
	else if (prewar) {
		info->max_health = max_health_value = 0;
	}

	// Draw a health bar.
	health_width = prewar ? width : Q_rint((width / max_health) * health);
	health_width = (health_width > 0.0 && health_width < 1.0) ? 1 : health_width;
	health_width = max(health_width, 0);

	armor = min(armor, max_armor);
	armor_width = Q_rint((width / max_armor) * armor);
	armor_width = (armor_width > 0.0 && armor_width < 1.0) ? 1 : armor_width;
	armor_width = max(armor_width, 0);

	max_health_width = 0;
	if (info->max_health_last_set && health < max_health_value) {
		max_health_width = Q_rint((width / max_health) * max_health_value);
		max_health_width -= health_width;
		max_health_width = (max_health_width > 0.0 && max_health_width < 1.0) ? 1 : max_health_width;
		max_health_width = max(max_health_width, 0);
	}

	if (flip) {
		Draw_AlphaFillRGB(x + width - (int)health_width, y, health_width, health_height, health_color);
		if (max_health_width) {
			Draw_AlphaFillRGB(x + width - (int)health_width - (int)max_health_width, y, max_health_width, health_height, RGBA_TO_COLOR(255, 0, 0, 128));
		}

		Draw_AlphaFillRGB(x, y + health_height, width, armor_height, RGBAVECT_TO_COLOR(armor_color_noarmor->color));
		if (armor_width > 0 && health > 0) {
			Draw_AlphaFillRGB(x + width - (int)armor_width, y + health_height, armor_width, armor_height, armor_color);
		}
	}
	else {
		Draw_AlphaFillRGB(x, y, health_width, health_height, health_color);
		if (max_health_width) {
			Draw_AlphaFillRGB(x + health_width, y, max_health_width, health_height, RGBA_TO_COLOR(255, 0, 0, 128));
		}

		Draw_AlphaFillRGB(x, y + health_height, width, armor_height, RGBAVECT_TO_COLOR(armor_color_noarmor->color));
		if (armor_width > 0 && health > 0) {
			Draw_AlphaFillRGB(x, y + health_height, armor_width, armor_height, armor_color);
		}
	}
}

static void Frags_DrawColors(
	int x, int y, int width, int height,
	int top_color, int bottom_color, float color_alpha,
	int frags, int drawBrackets, int style,
	float bignum, float scale, qbool proportional, 
	int wipeout, int hidefrags, int isdead, int timetospawn
)
{
	char buf[32];
	clrinfo_t color;
	int posy = 0;
	int char_size = (bignum > 0) ? Q_rint(24 * bignum) : 8 * scale;
	qbool use_wipeout = (check_ktx_ca_wo() && wipeout);
	qbool norespawn = (use_wipeout && (isdead == 2));
	float wo_alpha = (use_wipeout && (isdead == 1)) ? 0.5 : 1.0;
	float bignum_alpha = (use_wipeout && isdead) ? 0.25 : 1.0;

	Draw_AlphaFill(x, y, width, height / 2, norespawn ? 3 : top_color, color_alpha * wo_alpha);
	Draw_AlphaFill(x, y + height / 2, width, height - height / 2, norespawn ? 3 : bottom_color, color_alpha * wo_alpha);

	posy = y + (height - char_size) / 2;
	color.i = 0;

	if ((bignum > 0) && !hidefrags) {
		//
		// Scaled big numbers for frags.
		//
		extern  mpic_t *sb_nums[2][11];
		char *t = buf;
		int char_x;
		int char_y;
		snprintf(buf, sizeof(buf), "%d", frags);
		
		char_x = max(x, x + (width - (int)strlen(buf) * char_size) / 2);
		char_y = max(y, posy);

		while (*t) {
			if (*t >= '0' && *t <= '9') {
				Draw_SAlphaPic(char_x, char_y, sb_nums[0][*t - '0'], bignum_alpha, bignum);
				char_x += char_size;
			}
			else if (*t == '-') {
				Draw_SAlphaPic(char_x, char_y, sb_nums[0][STAT_MINUS], bignum_alpha, bignum);
				char_x += char_size;
			}

			t++;
		}
	}
	else {
		if (use_wipeout) {
			if (isdead == 1 && timetospawn > 0 && timetospawn < 999) {
				color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0x00, (byte)(1 * 255));
			} 
			else if (isdead == 2) {
				color.c = RGBA_TO_COLOR(0x33, 0x33, 0x33, (byte)(1 * 255));
			} 
			else {
				color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(1 * 255));
			}
		}
		else {
			color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(1 * 255));
		}

		// Determine snprintf content
		if (use_wipeout && isdead == 1 && timetospawn > 0 && timetospawn < 999) {
			snprintf(buf, sizeof(buf), "%d", timetospawn);
		} 
		else if (use_wipeout && hidefrags) {
			snprintf(buf, sizeof(buf), "%s", " ");
		} 
		else {
			snprintf(buf, sizeof(buf), "%d", frags);
		}

		// Normal text size. (meag: why -3?)
		Draw_SColoredAlphaString(x + (width - Draw_StringLength(buf, -1, scale, proportional)) / 2, posy, buf, &color, 1, 0, scale, 1, proportional);
	}

	if (drawBrackets && width) {
		// Brackets [] are not available scaled, so use normal size even
		// if we're drawing big frag nums.
		int brack_posy = y + (height - 8 * scale) / 2;
		int d = (width >= 32) ? 0 : 1;

		switch (style) {
			case 1:
				Draw_SCharacterP(x - FontCharacterWidth(13, scale, proportional) * 0.5f, posy, 13, scale, proportional);
				break;
			case 2:
				// Red outline.
				Draw_Fill(x, y - 1, width, 1, 0x4f);
				Draw_Fill(x, y - 1, 1, height + 2, 0x4f);
				Draw_Fill(x + width - 1, y - 1, 1, height + 2, 0x4f);
				Draw_Fill(x, y + height, width, 1, 0x4f);
				break;
			case 3:
				// Draw nothing
				break;
			case 0:
			default:
				Draw_SCharacterP(x - 2 - 2 * d, brack_posy, 16, scale, proportional); // [
				Draw_SCharacterP(x + width - 8 + 1 + d, brack_posy, 17, scale, proportional); // ]
				break;
		}
	}
}

static void Frags_DrawHealthBar(int original_health, int x, int y, int height, int width, qbool horizontal, qbool flip)
{
	int health;

	// Get the health.
	health = original_health;
	health = min(100, health);

	// Draw a health bar.
	if (horizontal) {
		float health_width = Q_rint((width / 100.0) * health);
		health_width = (health_width > 0.0 && health_width < 1.0) ? 1 : health_width;
		health_width = (health_width < 0.0) ? 0.0 : health_width;

		if (flip) {
			Draw_Fill(x + width - (int)health_width, y, health_width, (height * 3) / 4, FRAGS_HEALTHBAR_NORMAL_COLOR);
		}
		else {
			Draw_Fill(x, y, x + (int)health_width, (height * 3) / 4, FRAGS_HEALTHBAR_NORMAL_COLOR);
		}
	}
	else {
		float health_height = Q_rint((height / 100.0) * health);
		health_height = (health_height > 0.0 && health_height < 1.0) ? 1 : health_height;
		health_height = (health_height < 0.0) ? 0.0 : health_height;
		Draw_Fill(x, y + height - (int)health_height, 3, (int)health_height, FRAGS_HEALTHBAR_NORMAL_COLOR);

		// Get the health again to check if health is more than 100.
		health = original_health;
		if (health > 100 && health <= 200) {
			float health_height = (int)Q_rint((height / 100.0) * (health - 100));
			Draw_Fill(x, y + height - health_height, width, health_height, FRAGS_HEALTHBAR_MEGA_COLOR);
		}
		else if (health > 200 && health <= 250) {
			float health_height = (int)Q_rint((height / 100.0) * (health - 200));
			Draw_Fill(x, y, width, height, FRAGS_HEALTHBAR_MEGA_COLOR);
			Draw_Fill(x, y + height - health_height, width, health_height, FRAGS_HEALTHBAR_TWO_MEGA_COLOR);
		}
		else if (health > 250) {
			// This will never happen during a normal game.
			Draw_Fill(x, y, width, health_height, FRAGS_HEALTHBAR_UNNATURAL_COLOR);
		}
	}
}

static int TeamFrags_DrawExtraSpecInfo(int num, int px, int py, int width, int height, int style)
{
	extern mpic_t *sb_weapons[7][8]; // sbar.c
	mpic_t rl_picture = *sb_weapons[0][5];

	// Only allow this for spectators.
	if (!(cls.demoplayback || cl.spectator)
		|| style > TEAMFRAGS_EXTRA_SPEC_RLTEXT
		|| style <= TEAMFRAGS_EXTRA_SPEC_NONE
		|| !style) {
		return px;
	}

	// Check if the team has any RL's.
	if (sorted_teams[num].rlcount > 0) {
		int y_pos = py;

		//
		// Draw the RL + count depending on style.
		//

		if ((style == TEAMFRAGS_EXTRA_SPEC_BEFORE || style == TEAMFRAGS_EXTRA_SPEC_NOICON)
			&& style != TEAMFRAGS_EXTRA_SPEC_RLTEXT) {
			y_pos = Q_rint(py + (height / 2.0) - 4);
			Draw_ColoredString(px, y_pos, va("%d", sorted_teams[num].rlcount), 0, false);
			px += 8 + 1;
		}

		if (style != TEAMFRAGS_EXTRA_SPEC_NOICON && style != TEAMFRAGS_EXTRA_SPEC_RLTEXT) {
			y_pos = Q_rint(py + (height / 2.0) - (rl_picture.height / 2.0));
			Draw_SSubPic(px, y_pos, &rl_picture, 0, 0, rl_picture.width, rl_picture.height, 1);
			px += rl_picture.width + 1;
		}

		if (style == TEAMFRAGS_EXTRA_SPEC_ONTOP && style != TEAMFRAGS_EXTRA_SPEC_RLTEXT) {
			y_pos = Q_rint(py + (height / 2.0) - 4);
			Draw_ColoredString(px - 14, y_pos, va("%d", sorted_teams[num].rlcount), 0, false);
		}

		if (style == TEAMFRAGS_EXTRA_SPEC_RLTEXT) {
			y_pos = Q_rint(py + (height / 2.0) - 4);
			Draw_ColoredString(px, y_pos, va("&ce00RL&cfff%d", sorted_teams[num].rlcount), 0, false);
			px += 8 * 3 + 1;
		}
	}
	else {
		// If the team has no RL's just pad with nothing.
		if (style == TEAMFRAGS_EXTRA_SPEC_BEFORE) {
			// Draw the rl count before the rl icon.
			px += rl_picture.width + 8 + 1 + 1;
		}
		else if (style == TEAMFRAGS_EXTRA_SPEC_ONTOP) {
			// Draw the rl count on top of the RL instead of infront.
			px += rl_picture.width + 1;
		}
		else if (style == TEAMFRAGS_EXTRA_SPEC_NOICON) {
			// Only draw the rl count.
			px += 8 + 1;
		}
		else if (style == TEAMFRAGS_EXTRA_SPEC_RLTEXT) {
			px += 8 * 3 + 1;
		}
	}

	return px;
}

static void Frags_OnChangeExtraSpecInfo(cvar_t *var, char *s, qbool *cancel)
{
	// Parse the extra spec info.
	hud_frags_show_rl = Utils_RegExpMatch("RL|ALL", s);
	hud_frags_show_lg = Utils_RegExpMatch("LG|ALL", s);
	hud_frags_show_armor = Utils_RegExpMatch("ARMOR|ALL", s);
	hud_frags_show_health = Utils_RegExpMatch("HEALTH|ALL", s);
	hud_frags_show_powerup = Utils_RegExpMatch("POWERUP|ALL", s);
	hud_frags_textonly = Utils_RegExpMatch("TEXT", s);
	hud_frags_horiz_health = Utils_RegExpMatch("HMETER", s);
	hud_frags_horiz_power = Utils_RegExpMatch("PMETER", s);

	hud_frags_extra_spec_info = (hud_frags_show_rl || hud_frags_show_lg || hud_frags_show_armor || hud_frags_show_health || hud_frags_show_powerup);
}

static int Frags_DrawExtraSpecInfo(player_info_t *info,
	int px, int py,
	int cell_width, int cell_height,
	int space_x, int space_y, int flip
)
{
	extern mpic_t *sb_weapons[7][8];		// sbar.c ... Used for displaying the RL.
	mpic_t *rl_picture = sb_weapons[0][5];	// Picture of RL.
	mpic_t *lg_picture = sb_weapons[0][6];	// Picture of LG.

	float	armor_height = 0.0;
	int		armor = 0;
	int		armor_bg_color = 0;
	float	armor_bg_power = 0;
	int		weapon_width = 0;

	// Only allow this for spectators.
	if (!(cls.demoplayback || cl.spectator)) {
		return px;
	}

	// Set width based on text or picture.
	if (hud_frags_show_armor || hud_frags_show_rl || hud_frags_show_lg || hud_frags_show_powerup) {
		if (hud_frags_show_rl && hud_frags_show_lg) {
			weapon_width = (!hud_frags_textonly ? rl_picture->width + lg_picture->width : 24 * 2);
		}
		else if (hud_frags_show_rl) {
			weapon_width = (!hud_frags_textonly ? rl_picture->width : 24);
		}
		else {
			weapon_width = (!hud_frags_textonly ? lg_picture->width : 24);
		}
	}

	// Draw health bar. (flipped)
	if (flip && hud_frags_show_health) {
		Frags_DrawHealthBar(info->stats[STAT_HEALTH], px, py, cell_height, 3, false, false);
		px += 3 + FRAGS_HEALTH_SPACING;
	}

	armor = info->stats[STAT_ARMOR];

	// If the player has any armor, draw it in the appropriate color.
	if (info->stats[STAT_ITEMS] & IT_ARMOR1) {
		armor_bg_power = 100;
		armor_bg_color = 178; // Green armor.
	}
	else if (info->stats[STAT_ITEMS] & IT_ARMOR2) {
		armor_bg_power = 150;
		armor_bg_color = 111; // Yellow armor.
	}
	else if (info->stats[STAT_ITEMS] & IT_ARMOR3) {
		armor_bg_power = 200;
		armor_bg_color = 79; // Red armor.
	}

	// Only draw the armor if the current player has one and if the style allows it.
	if (armor_bg_power && hud_frags_show_armor) {
		armor_height = Q_rint((cell_height / armor_bg_power) * armor);

		Draw_AlphaFill(px,												// x
			py + cell_height - (int)armor_height,			// y (draw from bottom up)
			weapon_width,									// width
			(int)armor_height,								// height
			armor_bg_color,									// color
			0.3);											// alpha
	}

	// Draw the rl if the current player has it and the style allows it.
	if (info->stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER && hud_frags_show_rl) {
		if (!hud_frags_textonly) {
			// Draw the rl-pic.
			Draw_SSubPic(
				px,
				py + Q_rint((cell_height / 2.0)) - (rl_picture->height / 2.0),
				rl_picture, 0, 0,
				rl_picture->width,
				rl_picture->height, 1
			);
		}
		else {
			// Just print "RL" instead.
			Draw_String(px + 12 - 8, py + Q_rint((cell_height / 2.0)) - 4, "RL");
		}
	}

	// Draw the lg if the current player has it and the style allows it.
	if ((info->stats[STAT_ITEMS] & IT_LIGHTNING) && hud_frags_show_lg) {
		if (!hud_frags_textonly) {
			// Draw the lg-pic.
			Draw_SSubPic(
				hud_frags_show_rl ? px + rl_picture->width + 24 : px,
				py + Q_rint((cell_height / 2.0)) - (lg_picture->height / 2.0),
				lg_picture, 0, 0,
				lg_picture->width,
				lg_picture->height, 1
			);
		}
		else {
			// Just print "LG" instead.
			Draw_String(hud_frags_show_rl ? px + 8 + 24 : px + 12 - 8, py + Q_rint((cell_height / 2.0)) - 4, "LG");
		}
	}

	// Only draw powerups if the current player has one and the style allows it.
	if (hud_frags_show_powerup) {
		//float powerups_x = px + (spec_extra_weapon_w / 2.0);
		float powerups_x = px + (weapon_width / 2.0);

		if (info->stats[STAT_ITEMS] & IT_INVULNERABILITY
			&& info->stats[STAT_ITEMS] & IT_INVISIBILITY
			&& info->stats[STAT_ITEMS] & IT_QUAD) {
			Draw_ColoredString(Q_rint(powerups_x - 10), py, "&c0ffQ&cf00P&cff0R", 0, false);
		}
		else if (info->stats[STAT_ITEMS] & IT_QUAD
			&& info->stats[STAT_ITEMS] & IT_INVULNERABILITY) {
			Draw_ColoredString(Q_rint(powerups_x - 8), py, "&c0ffQ&cf00P", 0, false);
		}
		else if (info->stats[STAT_ITEMS] & IT_QUAD
			&& info->stats[STAT_ITEMS] & IT_INVISIBILITY) {
			Draw_ColoredString(Q_rint(powerups_x - 8), py, "&c0ffQ&cff0R", 0, false);
		}
		else if (info->stats[STAT_ITEMS] & IT_INVULNERABILITY
			&& info->stats[STAT_ITEMS] & IT_INVISIBILITY) {
			Draw_ColoredString(Q_rint(powerups_x - 8), py, "&cf00P&cff0R", 0, false);
		}
		else if (info->stats[STAT_ITEMS] & IT_QUAD) {
			Draw_ColoredString(Q_rint(powerups_x - 4), py, "&c0ffQ", 0, false);
		}
		else if (info->stats[STAT_ITEMS] & IT_INVULNERABILITY) {
			Draw_ColoredString(Q_rint(powerups_x - 4), py, "&cf00P", 0, false);
		}
		else if (info->stats[STAT_ITEMS] & IT_INVISIBILITY) {
			Draw_ColoredString(Q_rint(powerups_x - 4), py, "&cff0R", 0, false);
		}
	}

	px += weapon_width + FRAGS_HEALTH_SPACING;

	// Draw health bar. (not flipped)
	if (!flip && hud_frags_show_health) {
		Frags_DrawHealthBar(info->stats[STAT_HEALTH], px, py, cell_height, 3, false, false);
		px += 3 + FRAGS_HEALTH_SPACING;
	}

	return px;
}

static void Frags_DrawBackground(
	int px, int py, int cell_width, int cell_height,
	int space_x, int space_y, int max_name_length, int max_team_length,
	int bg_color, int shownames, int showteams, int drawBrackets, int style
)
{
	int bg_width = cell_width + space_x;
	//int bg_color = Sbar_BottomColor(info);
	float bg_alpha = 0.3;

	if (style == 4
		|| style == 6
		|| style == 8)
		bg_alpha = 0;

	if (shownames)
		bg_width += max_name_length * 8 + space_x;

	if (showteams)
		bg_width += max_team_length * 8 + space_x;

	if (drawBrackets)
		bg_alpha = 0.7;

	if (style == 7 || style == 8)
		bg_color = 0x4f;

	Draw_AlphaFill(px - 1, py - space_y / 2, bg_width, cell_height + space_y, bg_color, bg_alpha);

	if (drawBrackets && (style == 5 || style == 6)) {
		Draw_Fill(px - 1, py - 1 - space_y / 2, bg_width, 1, 0x4f);

		Draw_Fill(px - 1, py - space_y / 2, 1, cell_height + space_y, 0x4f);
		Draw_Fill(px + bg_width - 1, py - 1 - space_y / 2, 1, cell_height + 1 + space_y, 0x4f);

		Draw_Fill(px - 1, py + cell_height + space_y / 2, bg_width + 1, 1, 0x4f);
	}
}

static int Frags_DrawText(
	int px, int py,
	int cell_width, int cell_height,
	int space_x, int space_y,
	int max_name_length, int max_team_length,
	int flip, int pad,
	int shownames, int showteams,
	char* name, char* team, float scale, qbool proportional,
	int wipeout, int isdead, int timetospawn
)
{
	char _name[MAX_FRAGS_NAME + 1];
	char _team[MAX_FRAGS_NAME + 1];
	float team_length = 0;
	int name_length = 0;
	float char_size = 8 * scale;
	int y_pos;
	clrinfo_t color;
	qbool use_wipeout = (check_ktx_ca_wo() && wipeout);

	color.i = 0;
	y_pos = Q_rint(py + (cell_height / 2.0) - 4 * scale);

	if (use_wipeout && (isdead == 1) && (timetospawn > 0) && (timetospawn < 999)){
		color.c = RGBA_TO_COLOR(0x55, 0x55, 0x55, (byte)(1 * 255));
	}
	else if (use_wipeout && (isdead == 2)){
		color.c = RGBA_TO_COLOR(0x33, 0x33, 0x33, (byte)(1 * 255));
	}
	else {
		color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(1 * 255));
	}

	// Draw team
	if (showteams && cl.teamplay) {
		strlcpy(_team, team, clamp(max_team_length, 0, sizeof(_team)));
		team_length = Draw_StringLength(_team, -1, scale, proportional);

		if (!flip) {
			px += space_x;
		}

		if (pad && flip) {
			Draw_SColoredAlphaString(px + max_team_length * char_size - team_length, y_pos, _team, &color, 1, 0, scale, 1, proportional);
			px += max_team_length * char_size;
		}
		else if (pad) {
			Draw_SColoredAlphaString(px, y_pos, _team, &color, 1, 0, scale, 1, proportional);
			px += max_team_length * char_size;
		}
		else {
			px += Draw_SColoredAlphaString(px, y_pos, _team, &color, 1, 0, scale, 1, proportional);
		}

		if (flip) {
			px += space_x;
		}
	}

	if (shownames) {
		// Draw name
		strlcpy(_name, name, clamp(max_name_length, 0, sizeof(_name)));
		name_length = Draw_StringLength(_name, -1, scale, proportional);

		if (flip && pad) {
			Draw_SColoredAlphaString(px + max_name_length * char_size - name_length, y_pos, _name, &color, 1, 0, scale, 1, proportional);
			px += max_name_length * char_size;
		}
		else if (pad) {
			Draw_SColoredAlphaString(px, y_pos, _name, &color, 1, 0, scale, 1, proportional);
			px += max_name_length * char_size;
		}
		else {
			px += Draw_SColoredAlphaString(px, y_pos, _name, &color, 1, 0, scale, 1, proportional);
		}

		px += space_x;
	}

	return px;
}

static void SCR_HUD_DrawFrags(hud_t *hud)
{
	int width = 0, height = 0;
	int x, y;
	int max_team_length = 0;
	int max_name_length = 0;

	int rows, cols, cell_width, cell_height, space_x, space_y;
	int a_rows, a_cols; // actual
	qbool any_labels_or_info;
	qbool two_lines;

	extern ti_player_t ti_clients[MAX_CLIENTS];

	static cvar_t
		*hud_frags_cell_width = NULL,
		*hud_frags_cell_height,
		*hud_frags_rows,
		*hud_frags_cols,
		*hud_frags_space_x,
		*hud_frags_space_y,
		*hud_frags_vertical,
		*hud_frags_strip,
		*hud_frags_shownames,
		*hud_frags_hidefrags,
		*hud_frags_wipeout,
		*hud_frags_teams,
		*hud_frags_padtext,
		*hud_frags_extra_spec,
		*hud_frags_fliptext,
		*hud_frags_style,
		*hud_frags_bignum,
		*hud_frags_colors_alpha,
		*hud_frags_maxname,
		*hud_frags_notintp,
		*hud_frags_fixedwidth,
		*hud_frags_scale,
		*hud_frags_proportional;

	extern mpic_t *sb_weapons[7][8]; // sbar.c ... Used for displaying the RL.
	mpic_t *rl_picture;				 // Picture of RL.
	rl_picture = sb_weapons[0][5];

	if (hud_frags_cell_width == NULL) {   // first time
		char specval[256];

		hud_frags_cell_width = HUD_FindVar(hud, "cell_width");
		hud_frags_cell_height = HUD_FindVar(hud, "cell_height");
		hud_frags_rows = HUD_FindVar(hud, "rows");
		hud_frags_cols = HUD_FindVar(hud, "cols");
		hud_frags_space_x = HUD_FindVar(hud, "space_x");
		hud_frags_space_y = HUD_FindVar(hud, "space_y");
		hud_frags_strip = HUD_FindVar(hud, "strip");
		hud_frags_vertical = HUD_FindVar(hud, "vertical");
		hud_frags_shownames = HUD_FindVar(hud, "shownames");
		hud_frags_hidefrags = HUD_FindVar(hud, "hidefrags");
		hud_frags_wipeout = HUD_FindVar(hud, "wipeout");
		hud_frags_teams = HUD_FindVar(hud, "showteams");
		hud_frags_padtext = HUD_FindVar(hud, "padtext");
		hud_frags_extra_spec = HUD_FindVar(hud, "extra_spec_info");
		hud_frags_fliptext = HUD_FindVar(hud, "fliptext");
		hud_frags_style = HUD_FindVar(hud, "style");
		hud_frags_bignum = HUD_FindVar(hud, "bignum");
		hud_frags_colors_alpha = HUD_FindVar(hud, "colors_alpha");
		hud_frags_maxname = HUD_FindVar(hud, "maxname");
		hud_frags_notintp = HUD_FindVar(hud, "notintp");
		hud_frags_fixedwidth = HUD_FindVar(hud, "fixedwidth");
		hud_frags_scale = HUD_FindVar(hud, "scale");
		hud_frags_proportional = HUD_FindVar(hud, "proportional");

		// Set the OnChange function for extra spec info.
		hud_frags_extra_spec->OnChange = Frags_OnChangeExtraSpecInfo;
		strlcpy(specval, hud_frags_extra_spec->string, sizeof(specval));
		Cvar_Set(hud_frags_extra_spec, specval);
	}

	// Don't draw the frags if we're in teamplay.
	if (hud_frags_notintp->value && cl.teamplay) {
		HUD_PrepareDraw(hud, width, height, &x, &y);
		return;
	}

	//
	// Clamp values to be "sane".
	//
	{
		rows = hud_frags_rows->value;
		clamp(rows, 1, MAX_CLIENTS);

		cols = hud_frags_cols->value;
		clamp(cols, 1, MAX_CLIENTS);

		// Some users doesn't want to show the actual frags, just
		// extra_spec_info stuff + names.
		cell_width = hud_frags_cell_width->value * hud_frags_scale->value;
		clamp(cell_width, 0, 128);

		cell_height = hud_frags_cell_height->value * hud_frags_scale->value;
		clamp(cell_height, 7, 32);

		space_x = hud_frags_space_x->value * hud_frags_scale->value;
		clamp(space_x, 0, 128);

		space_y = hud_frags_space_y->value * hud_frags_scale->value;
		clamp(space_y, 0, 128);
	}

	if (hud_frags_strip->integer) {
		// Auto set the number of rows / cols based on the number of players.
		// (This is kinda fucked up, but I won't mess with it for the sake of backwards compability).
		if (hud_frags_vertical->value == 1) {
			a_cols = min((n_players + rows - 1) / rows, cols);
			a_rows = min(rows, n_players);
		}
		else if (hud_frags_vertical->value == 2) {
			a_cols = min(n_teams, cols);
			a_rows = min(rows, ((n_players % a_cols) ? n_players/a_cols + 1 : n_players/a_cols));
		}
		else {
			a_rows = min((n_players + cols - 1) / cols, rows);
			a_cols = min(cols, n_players);
		}
	}
	else {
		a_rows = rows;
		a_cols = cols;
	}

	width = (a_cols * cell_width) + ((a_cols + 1) * space_x);
	height = (a_rows * cell_height) + ((a_rows + 1) * space_y);

	// Get the longest name/team name for padding.
	if (hud_frags_shownames->value || hud_frags_teams->value) {
		int cur_length = 0;
		int n;

		// If the user has set a limit on how many chars that
		// are allowed to be shown for a name/teamname.
		if (hud_frags_fixedwidth->value) {
			max_name_length = min(max(0, (int)hud_frags_maxname->value) + 1, MAX_FRAGS_NAME);
			max_team_length = min(max(0, (int)hud_frags_maxname->value) + 1, MAX_FRAGS_NAME);
		}
		else {
			for (n = 0; n < n_players; n++) {
				player_info_t *info = &cl.players[sorted_players[n].playernum];
				cur_length = strlen(info->name);

				// Name.
				if (cur_length >= max_name_length) {
					max_name_length = cur_length + 1;
				}

				cur_length = strlen(info->team);

				// Team name.
				if (cur_length >= max_team_length) {
					max_team_length = cur_length + 1;
				}
			}

			max_name_length = min(max(0, (int)hud_frags_maxname->value), max_name_length) + 1;
			max_team_length = min(max(0, (int)hud_frags_maxname->value), max_team_length) + 1;
		}

		// We need a wider box to draw in if we show the names.
		if (hud_frags_shownames->value) {
			width += (a_cols * FontFixedWidth(max_name_length, hud_frags_scale->value, false, hud_frags_proportional->integer)) + ((a_cols + 1) * space_x);
		}

		if (cl.teamplay && hud_frags_teams->value) {
			width += (a_cols * FontFixedWidth(max_team_length, hud_frags_scale->value, false, hud_frags_proportional->integer)) + ((a_cols + 1) * space_x);
		}
	}

	// Make room for the extra spectator stuff.
	if (hud_frags_extra_spec_info && (cls.demoplayback || cl.spectator)) {
		if (hud_frags_show_health) {
			width += a_cols * (3 + FRAGS_HEALTH_SPACING);
		}
		if (hud_frags_show_armor || hud_frags_show_powerup || hud_frags_show_rl) {
			width += a_cols * (!hud_frags_textonly ? rl_picture->width : 24 * hud_frags_scale->value);
		}
	}

	any_labels_or_info = hud_frags_shownames->value || hud_frags_teams->value || hud_frags_extra_spec_info;
	two_lines = (cls.demoplayback || cl.spectator) && any_labels_or_info && (hud_frags_horiz_health || hud_frags_horiz_power);

	if (two_lines) {
		height *= 2;
	}

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		int i = 0;
		int player_x = 0;
		int player_y = 0;
		int num = 0;
		int drawBrackets = 0;

		// The number of players that are to be visible.
		int limit = min(n_players, a_rows * a_cols);

		num = 0;
		num = (num <= limit || num >= n_players) ? 0 : num;

		//
		// Loop through all the positions that should be drawn (columns * rows or number of players).
		//
		// Start drawing player "num", usually the first player in the array, but if
		// showself_always is set this might be someone else (since we need to make sure the current
		// player is always shown).
		//
		for (i = 0; i < limit; i++) {
			player_info_t *info;
			ti_player_t *ti_cl;

			// Always include the current player's position
			if (active_player_position >= 0 && i == limit - 1 && num < active_player_position) {
				num = active_player_position;
			}

			info = &cl.players[sorted_players[num].playernum]; // FIXME! johnnycz; causes crashed on some demos
			ti_cl = &ti_clients[sorted_players[num].playernum];

			//
			// Set the coordinates where to draw the next element.
			//
			if (hud_frags_vertical->value) {
				if (i % a_rows == 0) {
					// We're drawing a new column.
					int element_width = cell_width + space_x;

					// Get the width of all the stuff that is shown, the name, frag cell and so on.
					if (hud_frags_shownames->value) {
						element_width += (max_name_length) * 8 * hud_frags_scale->value;
					}

					if (hud_frags_teams->value) {
						element_width += (max_team_length) * 8 * hud_frags_scale->value;
					}

					if (hud_frags_extra_spec_info && (cls.demoplayback || cl.spectator)) {
						element_width += (!hud_frags_textonly ? rl_picture->width : 24 * hud_frags_scale->value);
					}

					player_x = x + space_x + ((i / a_rows) * element_width);

					// New column.
					player_y = y + space_y;
				}
			}
			else if (i % a_cols == 0) {
				// Drawing new row.
				player_x = x + space_x;
				player_y = y + space_y + (i / a_cols) * (cell_height * (two_lines ? 2 : 1) + space_y);
			}

			drawBrackets = 0;

			// Bug fix. Before the wrong player would be higlighted
			// during qwd-playback, since you ARE the player that you're
			// being spectated (you're not a spectator).
			if (cls.demoplayback && !cl.spectator && !cls.mvdplayback) {
				drawBrackets = (sorted_players[num].playernum == cl.playernum);
			}
			else if (cls.demoplayback || cl.spectator) {
				drawBrackets = (cl.spec_track == sorted_players[num].playernum && Cam_TrackNum() >= 0);
			}
			else {
				drawBrackets = (sorted_players[num].playernum == cl.playernum);
			}

			// Don't draw any brackets in multiview since we're tracking several players.
			if (CL_MultiviewEnabled() && !CL_MultiviewInsetEnabled()) {
				drawBrackets = 0;
			}

			if (any_labels_or_info) {
				// Relative x coordinate where we draw the subitems.
				int rel_player_x = player_x;
				qbool odd_column = (hud_frags_vertical->value ? (i / a_rows) : (i % a_cols));
				qbool fliptext = hud_frags_fliptext->integer == 1;

				fliptext |= hud_frags_fliptext->integer == 2 && !odd_column;
				fliptext |= hud_frags_fliptext->integer == 3 && odd_column;

				if (hud_frags_style->value >= 4 && hud_frags_style->value <= 8) {
					// Draw background based on the style.
					Frags_DrawBackground(
						player_x, player_y, cell_width, cell_height, space_x, space_y,
						max_name_length, max_team_length, Sbar_BottomColor(info),
						hud_frags_shownames->value, hud_frags_teams->value, drawBrackets,
						hud_frags_style->value
					);
				}

				if (fliptext) {
					//
					// Flip the text
					// NAME | TEAM | FRAGS | EXTRA_SPEC_INFO
					//
					if (two_lines) {
						Frags_DrawHorizontalHealthBar(info, rel_player_x, player_y, max_name_length * 8 * hud_frags_scale->value, cell_height, fliptext, hud_frags_horiz_power);
					}

					// Draw name.
					rel_player_x = Frags_DrawText(
						rel_player_x, player_y + (two_lines ? cell_height : 0), cell_width, cell_height,
						space_x, space_y, max_name_length, max_team_length,
						fliptext, hud_frags_padtext->value,
						hud_frags_shownames->value, 0,
						info->name, info->team, hud_frags_scale->value, hud_frags_proportional->integer,
						hud_frags_wipeout->value,
						ti_cl->isdead,
						ti_cl->timetospawn
					);

					// Draw team.
					rel_player_x = Frags_DrawText(
						rel_player_x, player_y + (two_lines ? cell_height : 0), cell_width, cell_height,
						space_x, space_y, max_name_length, max_team_length,
						fliptext, hud_frags_padtext->value,
						0, hud_frags_teams->value,
						info->name, info->team, hud_frags_scale->value, hud_frags_proportional->integer,
						hud_frags_wipeout->value,
						ti_cl->isdead,
						ti_cl->timetospawn
					);

					Frags_DrawColors(
						rel_player_x, player_y, cell_width, cell_height * (two_lines ? 2 : 1),
						Sbar_TopColor(info), Sbar_BottomColor(info), hud_frags_colors_alpha->value,
						info->frags,
						drawBrackets,
						hud_frags_style->value,
						hud_frags_bignum->value,
						hud_frags_scale->value,
						hud_frags_proportional->integer,
						hud_frags_wipeout->value,
						hud_frags_hidefrags->value,
						ti_cl->isdead,
						ti_cl->timetospawn
					);

					rel_player_x += cell_width + space_x;

					// Show extra information about all the players if spectating:
					// - What armor they have.
					// - How much health.
					// - If they have RL or not.
					rel_player_x = Frags_DrawExtraSpecInfo(info, rel_player_x, player_y, cell_width, cell_height,
						space_x, space_y,
						fliptext
					);
				}
				else {
					//
					// Don't flip the text
					// EXTRA_SPEC_INFO | FRAGS | TEAM | NAME
					//
					rel_player_x = Frags_DrawExtraSpecInfo(info, rel_player_x, player_y, cell_width, cell_height,
						space_x, space_y,
						fliptext
					);

					Frags_DrawColors(rel_player_x, player_y, cell_width, cell_height * (two_lines ? 2 : 1),
						Sbar_TopColor(info), Sbar_BottomColor(info), hud_frags_colors_alpha->value,
						info->frags,
						drawBrackets,
						hud_frags_style->value,
						hud_frags_bignum->value,
						hud_frags_scale->value,
						hud_frags_proportional->integer,
						hud_frags_wipeout->value,
						hud_frags_hidefrags->value,
						ti_cl->isdead,
						ti_cl->timetospawn
					);

					rel_player_x += cell_width + space_x;

					if (two_lines) {
						Frags_DrawHorizontalHealthBar(info, rel_player_x, player_y, max_name_length * 8 * hud_frags_scale->value, cell_height, fliptext, hud_frags_horiz_power);
					}

					// Draw team.
					rel_player_x = Frags_DrawText(rel_player_x, player_y + (two_lines ? cell_height : 0), cell_width, cell_height,
						space_x, space_y, max_name_length, max_team_length,
						fliptext, hud_frags_padtext->value,
						0, hud_frags_teams->value,
						info->name, info->team, hud_frags_scale->value, hud_frags_proportional->integer,
						hud_frags_wipeout->value,
						ti_cl->isdead,
						ti_cl->timetospawn
					);

					// Draw name.
					rel_player_x = Frags_DrawText(
						rel_player_x, player_y + (two_lines ? cell_height : 0), cell_width, cell_height,
						space_x, space_y, max_name_length, max_team_length,
						fliptext, hud_frags_padtext->value,
						hud_frags_shownames->value, 0,
						info->name, info->team, hud_frags_scale->value, hud_frags_proportional->integer,
						hud_frags_wipeout->value,
						ti_cl->isdead,
						ti_cl->timetospawn
					);
				}

				if (hud_frags_vertical->value) {
					// Next row.
					player_y += cell_height * (two_lines ? 2 : 1) + space_y;
				}
				else {
					// Next column.
					player_x = rel_player_x + space_x;
				}
			}
			else {
				// Only showing the frags, no names or extra spec info.

				Frags_DrawColors(
					player_x, player_y, cell_width, cell_height,
					Sbar_TopColor(info), Sbar_BottomColor(info), hud_frags_colors_alpha->value,
					info->frags,
					drawBrackets,
					hud_frags_style->value,
					hud_frags_bignum->value,
					hud_frags_scale->value,
					hud_frags_proportional->integer,
					hud_frags_wipeout->value,
					hud_frags_hidefrags->value,
					ti_cl->isdead,
					ti_cl->timetospawn
				);

				if (hud_frags_vertical->value) {
					// Next row.
					player_y += cell_height + space_y;
				}
				else {
					// Next column.
					player_x += cell_width + space_x;
				}
			}

			// Next player.
			num++;
		}
	}
}

static void SCR_HUD_DrawTeamFrags(hud_t *hud)
{
	int width = 0, height = 0;
	int x, y;
	int max_team_length = 0, num = 0;
	int rows, cols, cell_width, cell_height, space_x, space_y;
	int a_rows, a_cols; // actual

	static cvar_t
		*hud_teamfrags_cell_width,
		*hud_teamfrags_cell_height,
		*hud_teamfrags_rows,
		*hud_teamfrags_cols,
		*hud_teamfrags_space_x,
		*hud_teamfrags_space_y,
		*hud_teamfrags_vertical,
		*hud_teamfrags_strip,
		*hud_teamfrags_shownames,
		*hud_teamfrags_fliptext,
		*hud_teamfrags_padtext,
		*hud_teamfrags_style,
		*hud_teamfrags_extra_spec,
		*hud_teamfrags_onlytp,
		*hud_teamfrags_bignum,
		*hud_teamfrags_colors_alpha,
		*hud_teamfrags_scale,
		*hud_teamfrags_proportional;

	extern mpic_t *sb_weapons[7][8]; // sbar.c
	mpic_t rl_picture = *sb_weapons[0][5];

	if (hud_teamfrags_cell_width == 0)    // first time
	{
		hud_teamfrags_cell_width = HUD_FindVar(hud, "cell_width");
		hud_teamfrags_cell_height = HUD_FindVar(hud, "cell_height");
		hud_teamfrags_rows = HUD_FindVar(hud, "rows");
		hud_teamfrags_cols = HUD_FindVar(hud, "cols");
		hud_teamfrags_space_x = HUD_FindVar(hud, "space_x");
		hud_teamfrags_space_y = HUD_FindVar(hud, "space_y");
		hud_teamfrags_strip = HUD_FindVar(hud, "strip");
		hud_teamfrags_vertical = HUD_FindVar(hud, "vertical");
		hud_teamfrags_shownames = HUD_FindVar(hud, "shownames");
		hud_teamfrags_fliptext = HUD_FindVar(hud, "fliptext");
		hud_teamfrags_padtext = HUD_FindVar(hud, "padtext");
		hud_teamfrags_style = HUD_FindVar(hud, "style");
		hud_teamfrags_extra_spec = HUD_FindVar(hud, "extra_spec_info");
		hud_teamfrags_onlytp = HUD_FindVar(hud, "onlytp");
		hud_teamfrags_bignum = HUD_FindVar(hud, "bignum");
		hud_teamfrags_colors_alpha = HUD_FindVar(hud, "colors_alpha");
		hud_teamfrags_scale = HUD_FindVar(hud, "scale");
		hud_teamfrags_proportional = HUD_FindVar(hud, "proportional");
	}

	// Don't draw the frags if we're not in teamplay.
	if (hud_teamfrags_onlytp->value && !cl.teamplay) {
		HUD_PrepareDraw(hud, width, height, &x, &y);
		return;
	}

	rows = hud_teamfrags_rows->value;
	clamp(rows, 1, MAX_CLIENTS);
	cols = hud_teamfrags_cols->value;
	clamp(cols, 1, MAX_CLIENTS);
	cell_width = hud_teamfrags_cell_width->value;
	clamp(cell_width, 28, 128);
	cell_height = hud_teamfrags_cell_height->value;
	clamp(cell_height, 7, 32);
	space_x = hud_teamfrags_space_x->value;
	clamp(space_x, 0, 128);
	space_y = hud_teamfrags_space_y->value;
	clamp(space_y, 0, 128);

	if (hud_teamfrags_strip->value) {
		if (hud_teamfrags_vertical->value) {
			a_cols = min((n_teams + rows - 1) / rows, cols);
			a_rows = min(rows, n_teams);
		}
		else {
			a_rows = min((n_teams + cols - 1) / cols, rows);
			a_cols = min(cols, n_teams);
		}
	}
	else {
		a_rows = rows;
		a_cols = cols;
	}

	width = a_cols * cell_width + (a_cols + 1)*space_x;
	height = a_rows * cell_height + (a_rows + 1)*space_y;

	// Get the longest team name for padding.
	if (hud_teamfrags_shownames->value || hud_teamfrags_extra_spec->value) {
		int rlcount_width = 0;

		int cur_length = 0;
		int n;

		for (n = 0; n < n_teams; n++) {
			if (hud_teamfrags_shownames->value) {
				cur_length = strlen(sorted_teams[n].name);

				// Team name
				if (cur_length >= max_team_length) {
					max_team_length = cur_length + 1;
				}
			}
		}

		// Calculate the length of the extra spec info.
		if (hud_teamfrags_extra_spec->value && (cls.demoplayback || cl.spectator)) {
			if (hud_teamfrags_extra_spec->value == TEAMFRAGS_EXTRA_SPEC_BEFORE) {
				// Draw the rl count before the rl icon.
				rlcount_width = rl_picture.width + 8 + 1 + 1;
			}
			else if (hud_teamfrags_extra_spec->value == TEAMFRAGS_EXTRA_SPEC_ONTOP) {
				// Draw the rl count on top of the RL instead of infront.
				rlcount_width = rl_picture.width + 1;
			}
			else if (hud_teamfrags_extra_spec->value == TEAMFRAGS_EXTRA_SPEC_NOICON) {
				// Only draw the rl count.
				rlcount_width = 8 + 1;
			}
			else if (hud_teamfrags_extra_spec->value == TEAMFRAGS_EXTRA_SPEC_RLTEXT) {
				rlcount_width = 8 * 3 + 1;
			}
		}

		width += a_cols * max_team_length * 8 + (a_cols + 1) * space_x + a_cols * rlcount_width;
	}

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		int i;
		int px = 0;
		int py = 0;
		int drawBrackets;
		int limit = min(n_teams, a_rows*a_cols);

		for (i = 0; i < limit; i++) {
			if (hud_teamfrags_vertical->value) {
				if (i % a_rows == 0) {
					px = x + space_x + (i / a_rows) * (cell_width + space_x);
					py = y + space_y;
				}
			}
			else {
				if (i % a_cols == 0) {
					px = x + space_x;
					py = y + space_y + (i / a_cols) * (cell_height + space_y);
				}
			}

			drawBrackets = 0;

			// Bug fix. Before the wrong player would be higlighted
			// during qwd-playback, since you ARE the player that you're
			// being spectated.
			if (cls.demoplayback && !cl.spectator && !cls.mvdplayback) {
				// QWD Playback.
				if (!strcmp(sorted_teams[num].name, cl.players[cl.playernum].team)) {
					drawBrackets = 1;
				}
			}
			else if (cls.demoplayback || cl.spectator) {
				// MVD playback / spectating.
				if (!strcmp(cl.players[cl.spec_track].team, sorted_teams[num].name) && Cam_TrackNum() >= 0) {
					drawBrackets = 1;
				}
			}
			else {
				// Normal player.
				if (!strcmp(sorted_teams[num].name, cl.players[cl.playernum].team)) {
					drawBrackets = 1;
				}
			}

			if (hud_teamfrags_shownames->value || hud_teamfrags_extra_spec->value) {
				int _px = px;
				qbool text_lhs = hud_teamfrags_fliptext->integer == 1;
				text_lhs |= hud_teamfrags_fliptext->integer == 2 && ((i % a_cols) % 2 == 0);
				text_lhs |= hud_teamfrags_fliptext->integer == 3 && ((i % a_cols) % 2 == 1);

				// Draw a background if the style tells us to.
				if (hud_teamfrags_style->value >= 4 && hud_teamfrags_style->value <= 8) {
					Frags_DrawBackground(
						px, py, cell_width, cell_height, space_x, space_y,
						0, max_team_length, sorted_teams[num].bottom,
						0, hud_teamfrags_shownames->value, drawBrackets,
						hud_teamfrags_style->value
					);
				}

				// Draw the text on the left or right side of the score?
				if (text_lhs) {
					// Draw team.
					_px = Frags_DrawText(
						_px, py, cell_width, cell_height,
						space_x, space_y, 0, max_team_length,
						true, hud_teamfrags_padtext->value,
						0, hud_teamfrags_shownames->value,
						"", sorted_teams[num].name, hud_teamfrags_scale->value, hud_teamfrags_proportional->integer,
						0,
						0,
						0
					);

					Frags_DrawColors(
						_px, py, cell_width, cell_height,
						sorted_teams[num].top,
						sorted_teams[num].bottom,
						hud_teamfrags_colors_alpha->value,
						sorted_teams[num].frags,
						drawBrackets,
						hud_teamfrags_style->value,
						hud_teamfrags_bignum->value,
						hud_teamfrags_scale->value,
						hud_teamfrags_proportional->integer,
						0,
						0,
						0,
						0
					);

					_px += cell_width + space_x;

					// Draw the rl if the current player has it and the style allows it.
					_px = TeamFrags_DrawExtraSpecInfo(num, _px, py, cell_width, cell_height, hud_teamfrags_extra_spec->value);
				}
				else {
					// Draw the rl if the current player has it and the style allows it.
					_px = TeamFrags_DrawExtraSpecInfo(num, _px, py, cell_width, cell_height, hud_teamfrags_extra_spec->value);

					Frags_DrawColors(
						_px, py, cell_width, cell_height,
						sorted_teams[num].top,
						sorted_teams[num].bottom,
						hud_teamfrags_colors_alpha->value,
						sorted_teams[num].frags,
						drawBrackets,
						hud_teamfrags_style->value,
						hud_teamfrags_bignum->value,
						hud_teamfrags_scale->value,
						hud_teamfrags_proportional->integer,
						0,
						0,
						0,
						0
					);

					_px += cell_width + space_x;

					// Draw team.
					_px = Frags_DrawText(
						_px, py, cell_width, cell_height,
						space_x, space_y, 0, max_team_length,
						false, hud_teamfrags_padtext->value,
						0, hud_teamfrags_shownames->value,
						"", sorted_teams[num].name,
						hud_teamfrags_scale->value,
						hud_teamfrags_proportional->integer,
						0,
						0,
						0
					);
				}

				if (hud_teamfrags_vertical->value) {
					py += cell_height + space_y;
				}
				else {
					px = _px + space_x;
				}
			}
			else {
				Frags_DrawColors(
					px, py, cell_width, cell_height,
					sorted_teams[num].top,
					sorted_teams[num].bottom,
					hud_teamfrags_colors_alpha->value,
					sorted_teams[num].frags,
					drawBrackets,
					hud_teamfrags_style->value,
					hud_teamfrags_bignum->value,
					hud_teamfrags_scale->value,
					hud_teamfrags_proportional->integer,
					0,
					0,
					0,
					0
				);

				if (hud_teamfrags_vertical->value) {
					py += cell_height + space_y;
				}
				else {
					px += cell_width + space_x;
				}
			}
			num++;
		}
	}
}

void Frags_HudInit(void)
{
	HUD_Register(
		"frags", NULL, "Show list of player frags in short form.",
		0, ca_active, 0, SCR_HUD_DrawFrags,
		"0", "top", "right", "bottom", "0", "0", "0", "0 0 0", NULL,
		"cell_width", "32",
		"cell_height", "8",
		"rows", "1",
		"cols", "4",
		"space_x", "1",
		"space_y", "1",
		"teamsort", "0",
		"strip", "1",
		"vertical", "0",
		"hidefrags", "0",
		"shownames", "0",
		"showteams", "0",
		"wipeout", "1",
		"padtext", "1",
		"showself_always", "1",
		"extra_spec_info", "ALL",
		"fliptext", "0",
		"style", "0",
		"bignum", "0",
		"colors_alpha", "1.0",
		"maxname", "16",
		"notintp", "0",
		"fixedwidth", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"teamfrags", NULL, "Show list of team frags in short form.",
		0, ca_active, 0, SCR_HUD_DrawTeamFrags,
		"1", "ibar", "center", "before", "0", "0", "0", "0 0 0", NULL,
		"cell_width", "32",
		"cell_height", "8",
		"rows", "1",
		"cols", "2",
		"space_x", "1",
		"space_y", "1",
		"strip", "1",
		"vertical", "0",
		"shownames", "0",
		"padtext", "1",
		"fliptext", "1",
		"style", "0",
		"extra_spec_info", "1",
		"onlytp", "0",
		"bignum", "0",
		"colors_alpha", "1.0",
		"maxname", "16",
		"scale", "1",
		"proportional", "0",
		NULL
	);
}


================================================
FILE: src/hud_gamesummary.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "gl_model.h"
#include "hud.h"
#include "hud_common.h"

static void SCR_Hud_GameSummary(hud_t* hud)
{
	int x, y;
	int height = 8;
	int width = 0;
	char* format_string;
	int icon_size = 32;

	static cvar_t
		*hud_gamesummary_style = NULL,
		*hud_gamesummary_onlytp,
		*hud_gamesummary_scale,
		*hud_gamesummary_format,
		*hud_gamesummary_circles,
		*hud_gamesummary_ratio,
		*hud_gamesummary_flash,
		*hud_gamesummary_proportional;

	if (hud_gamesummary_style == NULL) {
		// first time
		hud_gamesummary_style = HUD_FindVar(hud, "style");
		hud_gamesummary_onlytp = HUD_FindVar(hud, "onlytp");
		hud_gamesummary_scale = HUD_FindVar(hud, "scale");
		hud_gamesummary_format = HUD_FindVar(hud, "format");
		hud_gamesummary_circles = HUD_FindVar(hud, "circles");
		hud_gamesummary_ratio = HUD_FindVar(hud, "ratio");
		hud_gamesummary_flash = HUD_FindVar(hud, "flash");
		hud_gamesummary_proportional = HUD_FindVar(hud, "proportional");
	}

	// Don't show when not in teamplay/demoplayback.
	if (!cls.mvdplayback || !HUD_ShowInDemoplayback(hud_gamesummary_onlytp->value)) {
		HUD_PrepareDraw(hud, 0, 0, &x, &y);
		return;
	}

	// Measure for width
	icon_size = 8 * bound(1, hud_gamesummary_ratio->value, 8);
	width = strlen(hud_gamesummary_format->string) * icon_size * hud_gamesummary_scale->value;
	height = (icon_size + (hud_gamesummary_style->integer ? 8 : 0)) * hud_gamesummary_scale->value;

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		int text_offset = hud_gamesummary_scale->value * (icon_size / 2 - 4);
		int icon_offset = 0;

		if (hud_gamesummary_style->integer == 1) {
			text_offset = icon_size * hud_gamesummary_scale->value;
		}
		else if (hud_gamesummary_style->integer == 2) {
			text_offset = 0;
			icon_offset = 8 * hud_gamesummary_scale->value;
		}

		for (format_string = hud_gamesummary_format->string; *format_string; ++format_string) {
			int team = isupper(format_string[0]) ? 0 : 1;
			mpic_t* background_tex = NULL;
			int value = 0;
			float alpha = 1.0f;
			float last_taken = 0.0f;
			byte* background_color = NULL;
			byte mega_color[] = { 0xFF, 0x8C, 0x00 };
			byte ra_color[] = { 0xFF, 0x00, 0x00 };
			byte ya_color[] = { 0xFF, 0xFF, 0x00 };
			byte ga_color[] = { 0x00, 0xBF, 0x00 };
			byte rl_color[] = { 0xFF, 0x1F, 0x3F };
			byte lg_color[] = { 0x2F, 0xAA, 0xAA };
			byte quad_color[] = { 0x00, 0x5F, 0xFF };
			byte pent_color[] = { 0xFF, 0x00, 0x00 };
			byte ring_color[] = { 0xFF, 0xFF, 0x00 };

			switch (tolower(format_string[0])) {
				case 'm':
					background_tex = Mod_SimpleTextureForHint(MOD_MEGAHEALTH, 0);
					value = sorted_teams[team].mh_taken;
					background_color = mega_color;
					last_taken = sorted_teams[team].mh_lasttime;
					break;
				case 'r':
					background_tex = Mod_SimpleTextureForHint(MOD_ARMOR, 2);
					value = sorted_teams[team].ra_taken;
					background_color = ra_color;
					last_taken = sorted_teams[team].ra_lasttime;
					break;
				case 'y':
					background_tex = Mod_SimpleTextureForHint(MOD_ARMOR, 1);
					value = sorted_teams[team].ya_taken;
					background_color = ya_color;
					last_taken = sorted_teams[team].ya_lasttime;
					break;
				case 'g':
					background_tex = Mod_SimpleTextureForHint(MOD_ARMOR, 0);
					value = sorted_teams[team].ga_taken;
					background_color = ga_color;
					last_taken = sorted_teams[team].ga_lasttime;
					break;
				case 'o':
					background_tex = Mod_SimpleTextureForHint(MOD_ROCKETLAUNCHER, 0);
					value = sorted_teams[team].rlcount;
					background_color = rl_color;
					last_taken = value ? -1 : 0;
					break;
				case 'l':
					background_tex = Mod_SimpleTextureForHint(MOD_LIGHTNINGGUN, 0);
					value = sorted_teams[team].lgcount;
					background_color = lg_color;
					last_taken = value ? -1 : 0;
					break;
				case 'w':
					background_tex = Mod_SimpleTextureForHint(MOD_ROCKETLAUNCHER, 0);
					value = sorted_teams[team].weapcount;
					background_color = rl_color;
					last_taken = value ? -1 : 0;
					break;
				case 'q':
					background_tex = Mod_SimpleTextureForHint(MOD_QUAD, 0);
					value = sorted_teams[team].quads_taken;
					background_color = quad_color;
					last_taken = sorted_teams[team].q_lasttime;
					break;
				case 'p':
					background_tex = Mod_SimpleTextureForHint(MOD_PENT, 0);
					value = sorted_teams[team].pents_taken;
					background_color = pent_color;
					last_taken = sorted_teams[team].p_lasttime;
					break;
				case 'e':
					background_tex = Mod_SimpleTextureForHint(MOD_RING, 0);
					value = sorted_teams[team].rings_taken;
					background_color = ring_color;
					last_taken = sorted_teams[team].r_lasttime;
					break;
			}

			alpha = last_taken == -1 ? 1.0f : 0.3f;
			if (last_taken > 0 && cls.demotime >= last_taken) {
				if (hud_gamesummary_flash->integer && cls.demotime - last_taken <= 1.0f) {
					// Flash for first second
					alpha = (int)((cls.demotime - last_taken) * 10) % 4 >= 2 ? 0.5f : 1.0f;
				}
				else if (cls.demotime - last_taken <= 2.3f) {
					// Then solid colour
					alpha = 1.0f;
				}
				else if (cls.demotime - last_taken <= 3.0f) {
					// Then fade back to normal
					alpha = bound(0.3f, 1.0f - (cls.demotime - last_taken - 2.3f), 1.0f);
				}
			}

			{
				char buffer[10];

				snprintf(buffer, sizeof(buffer), "%d", value);

				if (hud_gamesummary_circles->integer && background_color) {
					float half_width = icon_size * 0.5f * hud_gamesummary_scale->value;

					alpha /= 2;

					Draw_AlphaCircleFillRGB(x + half_width, y + icon_offset + half_width, half_width, RGBA_TO_COLOR(background_color[0] * alpha, background_color[1] * alpha, background_color[2] * alpha, alpha * 255));
				}
				else if (background_tex && R_TextureReferenceIsValid(background_tex->texnum)) {
					Draw_FitPicAlpha(x, y + icon_offset, icon_size * hud_gamesummary_scale->value, icon_size * hud_gamesummary_scale->value, background_tex, alpha);
				}

				if (value) {
					Draw_SStringAligned(x, y + text_offset, buffer, hud_gamesummary_scale->value, 1.0f, hud_gamesummary_proportional->integer, text_align_center, x + icon_size * hud_gamesummary_scale->value);
				}
			}

			x += icon_size * hud_gamesummary_scale->value;
		}
	}
}

static void SCR_HUD_DrawScoreMapName(hud_t *hud) {
	static cvar_t *proportional = NULL, *scale, *style;
	int w, h, x, y;
	char str[256];

	if (proportional == NULL)
	{
		proportional = HUD_FindVar(hud, "proportional");
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
	}

	switch (style->integer)
	{
		case 1:
			snprintf(str, sizeof(str), "%s", cl.levelname);
			break;
		case 2:
			snprintf(str, sizeof(str), "%s", host_mapname.string);
			break;
		default:
			snprintf(str, sizeof(str), "%s (%s)", cl.levelname, host_mapname.string);
			break;
	}

	w = Draw_StringLengthColors(str, -1, scale->value, proportional->integer);
	h = scale->value * 8;

	if (!HUD_PrepareDraw(hud, w, h, &x, &y))
		return;

	Draw_SString(x, y, str, scale->value, proportional->integer);
}

void GameSummary_HudInit(void)
{
	HUD_Register(
		"gamesummary", NULL, "Shows total pickups & current weapons.",
		HUD_PLUSMINUS, ca_active, 0, SCR_Hud_GameSummary,
		"0", "top", "left", "top", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"onlytp", "0",
		"scale", "1",
		"format", "RYM myr",
		"circles", "0",
		"ratio", "4",
		"flash", "1",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"scoremapname", NULL, "Shows map name on the scoreboard",
		HUD_NO_DRAW | HUD_ON_INTERMISSION | HUD_ON_SCORES | HUD_ON_FINALE, ca_disconnected, 8, SCR_HUD_DrawScoreMapName,
		"0", "screen", "right", "bottom", "0", "-10", "0", "0 0 0", NULL,
		"style", "0",
		"proportional", "0",
		"scale", "1",
		NULL
	);
}


================================================
FILE: src/hud_groups.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "rulesets.h"

// ============================================================================0
// Groups
// ============================================================================0
#define HUD_NUM_GROUPS 9
#define HUD_GROUP_SCALEMODE_TILE		1
#define HUD_GROUP_SCALEMODE_STRETCH		2
#define HUD_GROUP_SCALEMODE_GROW		3
#define HUD_GROUP_SCALEMODE_CENTER		4

#define HUD_GROUP_PIC_BASEPATH	"gfx/%s"

static mpic_t *hud_group_pics[HUD_NUM_GROUPS];
static qbool hud_group_pics_is_loaded[HUD_NUM_GROUPS];

/* Workaround to reload pics on vid_restart
* since cache (where they are stored) is flushed
*/
void HUD_Common_Reset_Group_Pics(void)
{
	memset(hud_group_pics, 0, sizeof(hud_group_pics));
	memset(hud_group_pics_is_loaded, 0, sizeof(hud_group_pics_is_loaded));
}

static void SCR_HUD_DrawGroup(hud_t *hud, int width, int height, mpic_t *pic, int pic_scalemode, float pic_alpha)
{
	int x, y;

	clamp(width, 1, 99999);
	clamp(height, 1, 99999);

	// Set it to this, because 1.0 will make the colors
	// completly saturated, and no semi-transparency will show.
	pic_alpha = (pic_alpha) >= 1.0 ? 1 : pic_alpha;

	// Grow the group if necessary.
	if (pic_scalemode == HUD_GROUP_SCALEMODE_GROW
		&& pic != NULL && pic->height > 0 && pic->width > 0) {
		width = max(pic->width, width);
		height = max(pic->height, height);
	}

	if (!HUD_PrepareDraw(hud, width, height, &x, &y)) {
		return;
	}

	// Draw the picture if it's set.
	if (pic != NULL && pic->height > 0) {
		int pw, ph;

		if (pic_scalemode == HUD_GROUP_SCALEMODE_TILE) {
			// Tile.
			int cx = 0, cy = 0;
			while (cy < height) {
				while (cx < width) {
					pw = min(pic->width, width - cx);
					ph = min(pic->height, height - cy);

					if (pw >= pic->width  &&  ph >= pic->height) {
						Draw_AlphaPic(x + cx, y + cy, pic, pic_alpha);
					}
					else {
						Draw_AlphaSubPic(x + cx, y + cy, pic, 0, 0, pw, ph, pic_alpha);
					}

					cx += pic->width;
				}

				cx = 0;
				cy += pic->height;
			}
		}
		else if (pic_scalemode == HUD_GROUP_SCALEMODE_STRETCH) {
			// Stretch or shrink the picture to fit.
			float scale_x = (float)width / pic->width;
			float scale_y = (float)height / pic->height;

			Draw_SAlphaSubPic2(x, y, pic, 0, 0, pic->width, pic->height, scale_x, scale_y, pic_alpha);
		}
		else if (pic_scalemode == HUD_GROUP_SCALEMODE_CENTER) {
			// Center the picture in the group.
			int pic_x = x + (width - pic->width) / 2;
			int pic_y = y + (height - pic->height) / 2;

			int src_x = 0;
			int src_y = 0;

			if (x > pic_x) {
				src_x = x - pic_x;
				pic_x = x;
			}

			if (y > pic_y) {
				src_y = y - pic_y;
				pic_y = y;
			}

			Draw_AlphaSubPic(pic_x, pic_y, pic, src_x, src_y, min(width, pic->width), min(height, pic->height), pic_alpha);
		}
		else {
			// Normal. Draw in the top left corner.
			Draw_AlphaSubPic(x, y, pic, 0, 0, min(width, pic->width), min(height, pic->height), pic_alpha);
		}
	}
}

static qbool SCR_HUD_LoadGroupPic(cvar_t *var, unsigned int grp_id, char *newpic)
{
	char pic_path[MAX_PATH];
	mpic_t *tmp_pic = NULL;

	if (newpic && strlen(newpic) > 0) {
		/* Create path for new pic */
		snprintf(pic_path, sizeof(pic_path), HUD_GROUP_PIC_BASEPATH, newpic);

		// Try loading the pic.
		if (!(tmp_pic = Draw_CachePicSafe(pic_path, false, true))) {
			Com_Printf("Couldn't load picture %s for '%s'\n", newpic, var->name);
			return false;
		}
	}

	hud_group_pics[grp_id] = tmp_pic;

	return true;
}

static void SCR_HUD_OnChangePic_GroupX(cvar_t *var, char *newpic, qbool *cancel)
{
	int idx;
	int res;
	res = sscanf(var->name, "hud_group%d_picture", &idx);
	if (res == 0 || res == EOF) {
		Com_Printf("Failed to parse group number (OnChange func)\n");
		*cancel = true;
	}
	else {
		idx--; /* group1 is on index 0 etc */
		*cancel = Ruleset_BlockHudPicChange() || !SCR_HUD_LoadGroupPic(var, idx, newpic);
	}
}

static void SCR_HUD_Groups_Draw(hud_t *hud)
{
	/* FIXME: Perhaps make some nice structs... */
	static cvar_t *width[HUD_NUM_GROUPS];
	static cvar_t *height[HUD_NUM_GROUPS];
	static cvar_t *picture[HUD_NUM_GROUPS];
	static cvar_t *pic_alpha[HUD_NUM_GROUPS];
	static cvar_t *pic_scalemode[HUD_NUM_GROUPS];
	int res;
	int idx;

	res = sscanf(hud->name, "group%d", &idx);
	if (res == 0 || res == EOF) {
		Com_Printf("Failed to parse group number from \"%s\"\n", hud->name);
		return;
	}
	idx--;

	/* First init */
	if (width[idx] == NULL) { // first time called
		width[idx] = HUD_FindVar(hud, "width");
		height[idx] = HUD_FindVar(hud, "height");
		picture[idx] = HUD_FindVar(hud, "picture");
		pic_alpha[idx] = HUD_FindVar(hud, "pic_alpha");
		pic_scalemode[idx] = HUD_FindVar(hud, "pic_scalemode");

		picture[idx]->OnChange = SCR_HUD_OnChangePic_GroupX;
	}

	if (!hud_group_pics_is_loaded[idx]) {
		SCR_HUD_LoadGroupPic(picture[idx], idx, picture[idx]->string);
		hud_group_pics_is_loaded[idx] = true;
	}

	SCR_HUD_DrawGroup(hud, width[idx]->value, height[idx]->value, hud_group_pics[idx], pic_scalemode[idx]->value, pic_alpha[idx]->value);
}

void Groups_HudInit(void)
{
	// groups
	HUD_Register(
		"group1", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "left", "top", "0", "0", ".5", "0 0 0", NULL,
		"name", "group1",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
	HUD_Register(
		"group2", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "center", "top", "0", "0", ".5", "0 0 0", NULL,
		"name", "group2",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
	HUD_Register(
		"group3", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "right", "top", "0", "0", ".5", "0 0 0", NULL,
		"name", "group3",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
	HUD_Register(
		"group4", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "left", "center", "0", "0", ".5", "0 0 0", NULL,
		"name", "group4",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
	HUD_Register(
		"group5", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "center", "center", "0", "0", ".5", "0 0 0", NULL,
		"name", "group5",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
	HUD_Register(
		"group6", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "right", "center", "0", "0", ".5", "0 0 0", NULL,
		"name", "group6",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
	HUD_Register(
		"group7", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "left", "bottom", "0", "0", ".5", "0 0 0", NULL,
		"name", "group7",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
	HUD_Register(
		"group8", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "center", "bottom", "0", "0", ".5", "0 0 0", NULL,
		"name", "group8",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
	HUD_Register(
		"group9", NULL, "Group element.",
		HUD_NO_GROW, ca_disconnected, 0, SCR_HUD_Groups_Draw,
		"0", "screen", "right", "bottom", "0", "0", ".5", "0 0 0", NULL,
		"name", "group9",
		"width", "64",
		"height", "64",
		"picture", "",
		"pic_alpha", "1.0",
		"pic_scalemode", "0",
		NULL
	);
}


================================================
FILE: src/hud_guns.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "fonts.h"
#include "teamplay.h"
#include "utils.h"

// -----------
// gunz
//
static void SCR_HUD_DrawGunByNum(hud_t *hud, int num, float scale, int style, int wide, qbool proportional)
{
	extern mpic_t *sb_weapons[7][8];  // sbar.c
	int i = num - 2;
	int width, height;
	int x, y;
	char *tmp;

	scale = max(scale, 0.01);

	switch (style) {
		case 3: // opposite colors of case 1
		case 1:     // text, gold inactive, white active
			width = FontFixedWidth(2, scale, false, proportional);
			height = 8 * scale;
			if (!HUD_PrepareDraw(hud, width, height, &x, &y)) {
				return;
			}
			if (HUD_Stats(STAT_ITEMS) & (IT_SHOTGUN << i)) {
				qbool weapon_active = (HUD_Stats(STAT_ACTIVEWEAPON) == (IT_SHOTGUN << i));

				switch (num) {
					case 2: tmp = "sg"; break;
					case 3: tmp = "bs"; break;
					case 4: tmp = "ng"; break;
					case 5: tmp = "sn"; break;
					case 6: tmp = "gl"; break;
					case 7: tmp = "rl"; break;
					case 8: tmp = "lg"; break;
					default: tmp = "";
				}

				if ((weapon_active && style == 1) || (!weapon_active && style == 3)) {
					Draw_SString(x, y, tmp, scale, proportional);
				}
				else {
					Draw_SAlt_String(x, y, tmp, scale, proportional);
				}
			}
			break;
		case 4: // opposite colors of case 2
		case 2: // numbers, gold inactive, white active
			width = FontFixedWidth(1, scale, true, proportional);;
			height = 8 * scale;
			if (!HUD_PrepareDraw(hud, width, height, &x, &y))
				return;
			if (HUD_Stats(STAT_ITEMS) & (IT_SHOTGUN << i)) {
				if (HUD_Stats(STAT_ACTIVEWEAPON) == (IT_SHOTGUN << i)) {
					num += '0' + (style == 4 ? 128 : 0);
				}
				else {
					num += '0' + (style == 4 ? 0 : 128);
				}
				Draw_SCharacterP(x, y, num, scale, proportional);
			}
			break;
		case 5: // COLOR active, gold inactive
		case 7: // COLOR active, white inactive
		case 6: // white active, COLOR inactive
		case 8: // gold active, COLOR inactive
			width = FontFixedWidth(2, scale, false, proportional);
			height = 8 * scale;

			if (!HUD_PrepareDraw(hud, width, height, &x, &y)) {
				return;
			}

			if (HUD_Stats(STAT_ITEMS) & (IT_SHOTGUN << i)) {
				if (HUD_Stats(STAT_ACTIVEWEAPON) == (IT_SHOTGUN << i)) {
					if ((style == 5) || (style == 7)) { // strip {}
						char *weap_str = TP_ItemName((IT_SHOTGUN << i));
						char weap_white_stripped[32];
						Util_SkipChars(weap_str, "{}", weap_white_stripped, 32);
						Draw_SString(x, y, weap_white_stripped, scale, false);
					}
					else {
						//Strip both &cRGB and {}
						char inactive_weapon_buf[16];
						char inactive_weapon_buf_nowhite[16];
						Util_SkipEZColors(inactive_weapon_buf, TP_ItemName(IT_SHOTGUN << i), sizeof(inactive_weapon_buf));
						Util_SkipChars(inactive_weapon_buf, "{}", inactive_weapon_buf_nowhite, sizeof(inactive_weapon_buf_nowhite));

						if (style == 8) {
							// gold active
							Draw_SAlt_String(x, y, inactive_weapon_buf_nowhite, scale, proportional);
						}
						else if (style == 6) {
							// white active
							Draw_SString(x, y, inactive_weapon_buf_nowhite, scale, proportional);
						}
					}
				}
				else {
					if ((style == 5) || (style == 7)) { //Strip both &cRGB and {}
						char inactive_weapon_buf[16];
						char inactive_weapon_buf_nowhite[16];
						Util_SkipEZColors(inactive_weapon_buf, TP_ItemName(IT_SHOTGUN << i), sizeof(inactive_weapon_buf));
						Util_SkipChars(inactive_weapon_buf, "{}", inactive_weapon_buf_nowhite, sizeof(inactive_weapon_buf_nowhite));

						if (style == 5) {
							// gold inactive
							Draw_SAlt_String(x, y, inactive_weapon_buf_nowhite, scale, proportional);
						}
						else if (style == 7) {
							// white inactive
							Draw_SString(x, y, inactive_weapon_buf_nowhite, scale, proportional);
						}
					}
					else if ((style == 6) || (style == 8)) { // strip only {}
						char *weap_str = TP_ItemName((IT_SHOTGUN << i));
						char weap_white_stripped[32];
						Util_SkipChars(weap_str, "{}", weap_white_stripped, 32);
						Draw_SString(x, y, weap_white_stripped, scale, proportional);
					}
				}
			}
			break;
		default:    // classic - pictures
			width = scale * (wide ? 48 : 24);
			height = scale * 16;

			if (!HUD_PrepareDraw(hud, width, height, &x, &y)) {
				return;
			}

			if (HUD_Stats(STAT_ITEMS) & (IT_SHOTGUN << i)) {
				float   time;
				int     flashon;

				time = cl.item_gettime[i];
				flashon = (int)((cl.time - time) * 10);
				if (flashon < 0) {
					flashon = 0;
				}
				if (flashon >= 10) {
					flashon = (HUD_Stats(STAT_ACTIVEWEAPON) == (IT_SHOTGUN << i)) ? 1 : 0;
				}
				else {
					flashon = (flashon % 5) + 2;
				}

				if (wide || num != 8) {
					Draw_SPic(x, y, sb_weapons[flashon][i], scale);
				}
				else {
					Draw_SSubPic(x, y, sb_weapons[flashon][i], 0, 0, 24, 16, scale);
				}
			}
			break;
	}
}

static void SCR_HUD_DrawGun2(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional, *frame_hide;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawGunByNum(hud, 2, scale->value, style->value, 0, proportional->integer);
	}

	frame_hide = HUD_FindVar(hud, "frame_hide");
	hud->frame_hide = frame_hide->value && !(HUD_Stats(STAT_ITEMS) & IT_SHOTGUN)
		? true
		: false;
}

static void SCR_HUD_DrawGun3(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional, *frame_hide;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawGunByNum(hud, 3, scale->value, style->value, 0, proportional->integer);
	}

	frame_hide = HUD_FindVar(hud, "frame_hide");
	hud->frame_hide = frame_hide->value && !(HUD_Stats(STAT_ITEMS) & IT_SUPER_SHOTGUN)
		? true
		: false;
}

static void SCR_HUD_DrawGun4(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional, *frame_hide;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawGunByNum(hud, 4, scale->value, style->value, 0, proportional->integer);
	}

	frame_hide = HUD_FindVar(hud, "frame_hide");
	hud->frame_hide = frame_hide->value && !(HUD_Stats(STAT_ITEMS) & IT_NAILGUN)
		? true
		: false;
}

static void SCR_HUD_DrawGun5(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional, *frame_hide;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawGunByNum(hud, 5, scale->value, style->value, 0, proportional->integer);
	}

	frame_hide = HUD_FindVar(hud, "frame_hide");
	hud->frame_hide = frame_hide->value && !(HUD_Stats(STAT_ITEMS) & IT_SUPER_NAILGUN)
		? true
		: false;
}

static void SCR_HUD_DrawGun6(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional, *frame_hide;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawGunByNum(hud, 6, scale->value, style->value, 0, proportional->integer);
	}

	frame_hide = HUD_FindVar(hud, "frame_hide");
	hud->frame_hide = frame_hide->value && !(HUD_Stats(STAT_ITEMS) & IT_GRENADE_LAUNCHER)
		? true
		: false;
}

static void SCR_HUD_DrawGun7(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional, *frame_hide;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawGunByNum(hud, 7, scale->value, style->value, 0, proportional->integer);
	}

	frame_hide = HUD_FindVar(hud, "frame_hide");
	hud->frame_hide = frame_hide->value && !(HUD_Stats(STAT_ITEMS) & IT_ROCKET_LAUNCHER)
		? true
		: false;
}

static void SCR_HUD_DrawGun8(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *wide, *proportional, *frame_hide;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		wide = HUD_FindVar(hud, "wide");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawGunByNum(hud, 8, scale->value, style->value, wide->value, proportional->integer);
	}

	frame_hide = HUD_FindVar(hud, "frame_hide");
	hud->frame_hide = frame_hide->value && !(HUD_Stats(STAT_ITEMS) & IT_LIGHTNING)
		? true
		: false;
}

static void SCR_HUD_DrawGunCurrent(hud_t *hud)
{
	int gun;
	static cvar_t *scale = NULL, *style, *wide, *proportional;

	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		wide = HUD_FindVar(hud, "wide");
		proportional = HUD_FindVar(hud, "proportional");
	}

	if (ShowPreselectedWeap()) {
		// using weapon pre-selection so show info for current best pre-selected weapon
		gun = IN_BestWeapon(true);
		if (gun < 2) {
			return;
		}
	}
	else {
		// not using weapon pre-selection or player is dead so show current selected weapon
		switch (HUD_Stats(STAT_ACTIVEWEAPON)) {
			case IT_SHOTGUN << 0:   gun = 2; break;
			case IT_SHOTGUN << 1:   gun = 3; break;
			case IT_SHOTGUN << 2:   gun = 4; break;
			case IT_SHOTGUN << 3:   gun = 5; break;
			case IT_SHOTGUN << 4:   gun = 6; break;
			case IT_SHOTGUN << 5:   gun = 7; break;
			case IT_SHOTGUN << 6:   gun = 8; break;
			default: return;
		}
	}

	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawGunByNum(hud, gun, scale->value, style->value, wide->value, proportional->integer);
	}
}

void Guns_HudInit(void)
{
	// init guns
	HUD_Register("gun", NULL, "Part of your inventory - current weapon.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawGunCurrent,
		"0", "ibar", "center", "bottom", "0", "0", "0", "0 0 0", NULL,
		"wide", "0",
		"style", "0",
		"scale", "1",
		"proportional", "0",
		"frame_hide", "0",
		NULL);
	HUD_Register("gun2", NULL, "Part of your inventory - shotgun.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawGun2,
		"1", "ibar", "left", "bottom", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		"frame_hide", "0",
		NULL);
	HUD_Register("gun3", NULL, "Part of your inventory - super shotgun.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawGun3,
		"1", "gun2", "after", "center", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		"frame_hide", "0",
		NULL);
	HUD_Register("gun4", NULL, "Part of your inventory - nailgun.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawGun4,
		"1", "gun3", "after", "center", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		"frame_hide", "0",
		NULL);
	HUD_Register("gun5", NULL, "Part of your inventory - super nailgun.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawGun5,
		"1", "gun4", "after", "center", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		"frame_hide", "0",
		NULL);
	HUD_Register("gun6", NULL, "Part of your inventory - grenade launcher.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawGun6,
		"1", "gun5", "after", "center", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		"frame_hide", "0",
		NULL);
	HUD_Register("gun7", NULL, "Part of your inventory - rocket launcher.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawGun7,
		"1", "gun6", "after", "center", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		"frame_hide", "0",
		NULL);
	HUD_Register("gun8", NULL, "Part of your inventory - thunderbolt.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawGun8,
		"1", "gun7", "after", "center", "0", "0", "0", "0 0 0", NULL,
		"wide", "0",
		"style", "0",
		"scale", "1",
		"proportional", "0",
		"frame_hide", "0",
		NULL);
}


================================================
FILE: src/hud_health.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "vx_stuff.h"

static int TP_IsHealthLow(void)
{
	extern cvar_t tp_need_health;

	return cl.stats[STAT_HEALTH] <= tp_need_health.value;
}

static qbool HUD_HealthLow(void)
{
	extern cvar_t hud_tp_need;

	if (hud_tp_need.value) {
		return TP_IsHealthLow();
	}
	else {
		return HUD_Stats(STAT_HEALTH) <= 25;
	}
}

static void SCR_HUD_DrawHealth(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *proportional;
	static int value;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		proportional = HUD_FindVar(hud, "proportional");
	}

	value = HUD_Stats(STAT_HEALTH);
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawNum(hud, (value < 0 ? 0 : value), HUD_HealthLow(), scale->value, style->value, digits->value, align->string, proportional->integer);
	}
}

static void SCR_HUD_DrawHealthDamage(hud_t *hud)
{
	Draw_AMFStatLoss(STAT_HEALTH, hud);

	if (HUD_Stats(STAT_HEALTH) <= 0) {
		Amf_Reset_DamageStats();
	}
}

static void SCR_HUD_DrawBarHealth(hud_t *hud)
{
	static	cvar_t *width = NULL, *height, *direction, *color_nohealth, *color_normal, *color_mega, *color_twomega, *color_unnatural;
	int		x, y;
	int		health = cl.stats[STAT_HEALTH];

	if (width == NULL) {
		// first time called
		width = HUD_FindVar(hud, "width");
		height = HUD_FindVar(hud, "height");
		direction = HUD_FindVar(hud, "direction");
		color_nohealth = HUD_FindVar(hud, "color_nohealth");
		color_normal = HUD_FindVar(hud, "color_normal");
		color_mega = HUD_FindVar(hud, "color_mega");
		color_twomega = HUD_FindVar(hud, "color_twomega");
		color_unnatural = HUD_FindVar(hud, "color_unnatural");
	}

	if (HUD_PrepareDraw(hud, width->integer, height->integer, &x, &y) && (cl.spectator == cl.autocam)) {
		if (!width->integer || !height->integer) {
			return;
		}

		if (health > 250) {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_unnatural->color, x, y, width->integer, height->integer);
		}
		else if (health > 200) {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_normal->color, x, y, width->integer, height->integer);
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_mega->color, x, y, width->integer, height->integer);
			SCR_HUD_DrawBar(direction->integer, health - 200, 100.0, color_twomega->color, x, y, width->integer, height->integer);
		}
		else if (health > 100) {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_normal->color, x, y, width->integer, height->integer);
			SCR_HUD_DrawBar(direction->integer, health - 100, 100.0, color_mega->color, x, y, width->integer, height->integer);
		}
		else if (health > 0) {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_nohealth->color, x, y, width->integer, height->integer);
			SCR_HUD_DrawBar(direction->integer, health, 100.0, color_normal->color, x, y, width->integer, height->integer);
		}
		else {
			SCR_HUD_DrawBar(direction->integer, 100, 100.0, color_nohealth->color, x, y, width->integer, height->integer);
		}
	}
}

void Health_HudInit(void)
{
	HUD_Register(
		"bar_health", NULL, "Health bar.",
		HUD_PLUSMINUS, ca_active, 0, SCR_HUD_DrawBarHealth,
		"0", "health", "right", "center", "0", "0", "0", "0 0 0", NULL,
		"height", "16",
		"width", "64",
		"direction", "0",
		"color_nohealth", "128 128 128 64",
		"color_normal", "32 64 128 128",
		"color_mega", "64 96 128 128",
		"color_twomega", "128 128 255 128",
		"color_unnatural", "255 255 255 128",
		NULL
	);

	// health
	HUD_Register(
		"health", NULL, "Part of your status - health level.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawHealth,
		"1", "face", "after", "center", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "3",
		"proportional", "0",
		NULL
	);

	// healthdamage
	HUD_Register(
		"healthdamage", NULL, "Shows amount of damage done to your health.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawHealthDamage,
		"0", "health", "left", "before", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "3",
		"duration", "0.8",
		"proportional", "0",
		NULL
	);
}


================================================
FILE: src/hud_items.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "fonts.h"

// ----------------
// powerzz
//
static void SCR_HUD_DrawPowerup(hud_t *hud, int num, float scale, int style, qbool proportional)
{
	extern mpic_t *sb_items[32];
	int    x, y, width, height;
	int    c;

	scale = max(scale, 0.01);

	if (cl.spectator == cl.autocam) {
		switch (style) {
		case 1:     // letter
			width = FontFixedWidth(1, scale, false, proportional);
			height = 8 * scale;
			if (!HUD_PrepareDraw(hud, width, height, &x, &y)) {
				return;
			}
			if (HUD_Stats(STAT_ITEMS) & (1 << (17 + num))) {
				switch (num) {
					case 0: c = '1'; break;
					case 1: c = '2'; break;
					case 2: c = 'r'; break;
					case 3: c = 'p'; break;
					case 4: c = 's'; break;
					case 5: c = 'q'; break;
					default: c = '?';
				}
				Draw_SCharacterP(x, y, c, scale, proportional);
			}
			break;
		default:    // classic - pics
			width = height = scale * 16;
			if (!HUD_PrepareDraw(hud, width, height, &x, &y)) {
				return;
			}
			if (HUD_Stats(STAT_ITEMS) & (1 << (17 + num))) {
				Draw_SPic(x, y, sb_items[num], scale);
			}
			break;
		}
	}
}

static void SCR_HUD_DrawKey1(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawPowerup(hud, 0, scale->value, style->value, proportional->integer);
	}
}

static void SCR_HUD_DrawKey2(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawPowerup(hud, 1, scale->value, style->value, proportional->integer);
	}
}

static void SCR_HUD_DrawRing(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawPowerup(hud, 2, scale->value, style->value, proportional->integer);
	}
}

static void SCR_HUD_DrawPent(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawPowerup(hud, 3, scale->value, style->value, proportional->integer);
	}
}

static void SCR_HUD_DrawSuit(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawPowerup(hud, 4, scale->value, style->value, proportional->integer);
	}
}

static void SCR_HUD_DrawQuad(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawPowerup(hud, 5, scale->value, style->value, proportional->integer);
	}
}

// -----------
// sigils
//
static void SCR_HUD_DrawSigil(hud_t *hud, int num, float scale, int style, qbool proportional)
{
	extern mpic_t *sb_sigil[4];
	int     x, y;

	scale = max(scale, 0.01);
	if (cl.spectator == cl.autocam) {
		switch (style) {
		case 1:     // sigil number
			if (!HUD_PrepareDraw(hud, 8 * scale, 8 * scale, &x, &y)) {
				return;
			}
			if (HUD_Stats(STAT_ITEMS) & (1 << (28 + num))) {
				Draw_SCharacterP(x, y, num + '0' + 1, scale, proportional);
			}
			break;
		default:    // classic - picture
			if (!HUD_PrepareDraw(hud, 8 * scale, 16 * scale, &x, &y)) {
				return;
			}
			if (HUD_Stats(STAT_ITEMS) & (1 << (28 + num))) {
				Draw_SPic(x, y, sb_sigil[num], scale);
			}
			break;
		}
	}
}

static void SCR_HUD_DrawSigil1(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawSigil(hud, 0, scale->value, style->value, proportional->integer);
	}
}

void SCR_HUD_DrawSigil2(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawSigil(hud, 1, scale->value, style->value, proportional->integer);
	}
}

static void SCR_HUD_DrawSigil3(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawSigil(hud, 2, scale->value, style->value, proportional->integer);
	}
}

static void SCR_HUD_DrawSigil4(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *proportional;
	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		proportional = HUD_FindVar(hud, "proportional");
	}
	if (cl.spectator == cl.autocam) {
		SCR_HUD_DrawSigil(hud, 3, scale->value, style->value, proportional->integer);
	}
}

void Items_HudInit(void)
{
	// init powerzz
	HUD_Register(
		"key1", NULL, "Part of your inventory - silver key.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawKey1,
		"1", "ibar", "top", "left", "0", "64", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	HUD_Register(
		"key2", NULL, "Part of your inventory - gold key.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawKey2,
		"1", "key1", "left", "after", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	HUD_Register(
		"ring", NULL, "Part of your inventory - invisibility.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawRing,
		"1", "key2", "left", "after", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	HUD_Register(
		"pent", NULL, "Part of your inventory - invulnerability.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawPent,
		"1", "ring", "left", "after", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	HUD_Register(
		"suit", NULL, "Part of your inventory - biosuit.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawSuit,
		"1", "pent", "left", "after", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	HUD_Register(
		"quad", NULL, "Part of your inventory - quad damage.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawQuad,
		"1", "suit", "left", "after", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	// sigilzz
	HUD_Register(
		"sigil1", NULL, "Part of your inventory - sigil 1.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawSigil1,
		"0", "ibar", "left", "top", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	HUD_Register(
		"sigil2", NULL, "Part of your inventory - sigil 2.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawSigil2,
		"0", "sigil1", "after", "top", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	HUD_Register(
		"sigil3", NULL, "Part of your inventory - sigil 3.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawSigil3,
		"0", "sigil2", "after", "top", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
	HUD_Register(
		"sigil4", NULL, "Part of your inventory - sigil 4.",
		HUD_INVENTORY, ca_active, 0, SCR_HUD_DrawSigil4,
		"0", "sigil3", "after", "top", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
}


================================================
FILE: src/hud_net.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "fonts.h"

//---------------------
//
// network statistics
//
void SCR_HUD_DrawNetStats(hud_t *hud)
{
	int width, height;
	int x, y;

	static cvar_t *hud_net_period = NULL;
	static cvar_t *hud_net_proportional = NULL;
	static cvar_t *hud_net_scale = NULL;

	if (hud_net_period == NULL) {
		// first time
		hud_net_period = HUD_FindVar(hud, "period");
		hud_net_proportional = HUD_FindVar(hud, "proportional");
		hud_net_scale = HUD_FindVar(hud, "scale");
	}

	width = FontFixedWidth(16, hud_net_scale->value, false, hud_net_proportional->integer);
	height = (12 + 8 + 8 + 8 + 8 + 16 + 8 + 8 + 8 + 8 + 16 + 8 + 8 + 8) * hud_net_scale->value;

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		float period = hud_net_period->value;
		char line[128];
		double t;

		// static data
		static double last_calculated;
		static int    ping_min, ping_max, ping_avg;
		static float  ping_dev;
		static float  f_min, f_max, f_avg;
		static int    lost_lost, lost_delta, lost_rate, lost_total;
		static int    size_all, size_in, size_out;
		static int    bandwidth_all, bandwidth_in, bandwidth_out;
		static int    with_delta;

		if (cls.state != ca_active) {
			return;
		}

		if (period < 0) {
			period = 0;
		}

		t = curtime;
		if (t - last_calculated > period) {
			// recalculate
			net_stat_result_t result;

			last_calculated = t;

			CL_CalcNetStatistics(
				period,             // period of time
				network_stats,      // samples table
				NETWORK_STATS_SIZE, // number of samples in table
				&result             // results
			);

			if (result.samples == 0) {
				return; // error calculating net
			}

			ping_avg = (int)(result.ping_avg + 0.5);
			ping_min = (int)(result.ping_min + 0.5);
			ping_max = (int)(result.ping_max + 0.5);
			ping_dev = result.ping_dev;

			clamp(ping_avg, 0, 999);
			clamp(ping_min, 0, 999);
			clamp(ping_max, 0, 999);
			clamp(ping_dev, 0, 99.9);

			f_avg = (int)(result.ping_f_avg + 0.5);
			f_min = (int)(result.ping_f_min + 0.5);
			f_max = (int)(result.ping_f_max + 0.5);

			clamp(f_avg, 0, 99.9);
			clamp(f_min, 0, 99.9);
			clamp(f_max, 0, 99.9);

			lost_lost = (int)(result.lost_lost + 0.5);
			lost_rate = (int)(result.lost_rate + 0.5);
			lost_delta = (int)(result.lost_delta + 0.5);
			lost_total = (int)(result.lost_lost + result.lost_rate + result.lost_delta + 0.5);

			clamp(lost_lost, 0, 100);
			clamp(lost_rate, 0, 100);
			clamp(lost_delta, 0, 100);
			clamp(lost_total, 0, 100);

			size_in = (int)(result.size_in + 0.5);
			size_out = (int)(result.size_out + 0.5);
			size_all = (int)(result.size_in + result.size_out + 0.5);

			bandwidth_in = (int)(result.bandwidth_in + 0.5);
			bandwidth_out = (int)(result.bandwidth_out + 0.5);
			bandwidth_all = (int)(result.bandwidth_in + result.bandwidth_out + 0.5);

			clamp(size_in, 0, 999);
			clamp(size_out, 0, 999);
			clamp(size_all, 0, 999);
			clamp(bandwidth_in, 0, 99999);
			clamp(bandwidth_out, 0, 99999);
			clamp(bandwidth_all, 0, 99999);

			with_delta = result.delta;
		}

		Draw_Alt_String(x + (width - Draw_StringLength("latency", 7, hud_net_scale->value, hud_net_proportional->integer)) / 2, y, "latency", hud_net_scale->value, hud_net_proportional->integer);
		y += 12 * hud_net_scale->value;

		Draw_SString(x, y, "min", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%4.1f %3d ms", f_min, ping_min);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 8 * hud_net_scale->value;

		Draw_SString(x, y, "avg", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%4.1f %3d ms", f_avg, ping_avg);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 8 * hud_net_scale->value;

		Draw_SString(x, y, "max", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%4.1f %3d ms", f_max, ping_max);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 8 * hud_net_scale->value;

		Draw_SString(x, y, "dev", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%5.2f ms", ping_dev);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 12 * hud_net_scale->value;

		Draw_Alt_String(x + (width - Draw_StringLength("packet loss", 11, hud_net_scale->value, hud_net_proportional->integer)) / 2, y, "packet loss", hud_net_scale->value, hud_net_proportional->integer);
		y += 12 * hud_net_scale->value;

		Draw_SString(x, y, "lost", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%3d %%", lost_lost);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 8 * hud_net_scale->value;

		Draw_SString(x, y, "rate cut", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%3d %%", lost_rate);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 8 * hud_net_scale->value;

		if (with_delta) {
			Draw_SString(x, y, "bad delta", hud_net_scale->value, hud_net_proportional->integer);
			snprintf(line, sizeof(line), "%3d %%", lost_delta);
			Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		}
		else {
			Draw_SString(x, y, "no delta compr", hud_net_scale->value, hud_net_proportional->integer);
		}
		y += 8 * hud_net_scale->value;

		Draw_SString(x, y, "total", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%3d %%", lost_total);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 12 * hud_net_scale->value;

		Draw_Alt_String(x + (width - Draw_StringLength("packet size/BPS", 15, hud_net_scale->value, hud_net_proportional->integer)) / 2, y, "packet size/BPS", hud_net_scale->value, hud_net_proportional->integer);
		y += 12 * hud_net_scale->value;

		Draw_SString(x, y, "out", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%3d %5d", size_out, bandwidth_out);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 8 * hud_net_scale->value;

		Draw_SString(x, y, "in", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%3d %5d", size_in, bandwidth_in);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 8 * hud_net_scale->value;

		Draw_SString(x, y, "total", hud_net_scale->value, hud_net_proportional->integer);
		snprintf(line, sizeof(line), "%3d %5d", size_all, bandwidth_all);
		Draw_SString(x + width - Draw_StringLength(line, -1, hud_net_scale->value, hud_net_proportional->integer), y, line, hud_net_scale->value, hud_net_proportional->integer);
		y += 8 * hud_net_scale->value;
	}
}

// Problem icon, Net
static void SCR_HUD_NetProblem(hud_t *hud)
{
	extern mpic_t *scr_net;
	static cvar_t *scale = NULL;
	int x, y;
	extern qbool hud_editor;

	if (scale == NULL) {
		scale = HUD_FindVar(hud, "scale");
	}

	if ((cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged < UPDATE_BACKUP - 1) || cls.demoplayback) {
		if (hud_editor)
			HUD_PrepareDraw(hud, scr_net->width, scr_net->height, &x, &y);
		return;
	}

	if (!HUD_PrepareDraw(hud, scr_net->width, scr_net->height, &x, &y))
		return;

	Draw_SPic(x, y, scr_net, scale->value);
}

//---------------------
//
// draw HUD ping
//
static void SCR_HUD_DrawPing(hud_t *hud)
{
	double t;
	static double last_calculated;
	static int ping_avg, pl, ping_min, ping_max;
	static float ping_dev;

	int width, height;
	int x, y;
	char buf[512];

	static cvar_t
		*hud_ping_period = NULL,
		*hud_ping_show_pl,
		*hud_ping_show_dev,
		*hud_ping_show_min,
		*hud_ping_show_max,
		*hud_ping_style,
		*hud_ping_blink,
		*hud_ping_scale,
		*hud_ping_proportional;

	if (hud_ping_period == NULL)    // first time
	{
		hud_ping_period = HUD_FindVar(hud, "period");
		hud_ping_show_pl = HUD_FindVar(hud, "show_pl");
		hud_ping_show_dev = HUD_FindVar(hud, "show_dev");
		hud_ping_show_min = HUD_FindVar(hud, "show_min");
		hud_ping_show_max = HUD_FindVar(hud, "show_max");
		hud_ping_style = HUD_FindVar(hud, "style");
		hud_ping_blink = HUD_FindVar(hud, "blink");
		hud_ping_scale = HUD_FindVar(hud, "scale");
		hud_ping_proportional = HUD_FindVar(hud, "proportional");
	}

	t = curtime;
	if (t - last_calculated > hud_ping_period->value) {
		// recalculate
		net_stat_result_t result;
		float period;

		last_calculated = t;

		period = max(hud_ping_period->value, 0);

		CL_CalcNetStatistics(
			period,             // period of time
			network_stats,      // samples table
			NETWORK_STATS_SIZE, // number of samples in table
			&result);           // results

		if (result.samples == 0)
			return; // error calculating net

		ping_avg = (int)(result.ping_avg + 0.5);
		ping_min = (int)(result.ping_min + 0.5);
		ping_max = (int)(result.ping_max + 0.5);
		ping_dev = result.ping_dev;
		pl = result.lost_lost;

		clamp(ping_avg, 0, 999);
		clamp(ping_min, 0, 999);
		clamp(ping_max, 0, 999);
		clamp(ping_dev, 0, 99.9);
		clamp(pl, 0, 100);
	}

	buf[0] = 0;

	// blink
	if (hud_ping_blink->value)   // add dot
		strlcat(buf, (last_calculated + hud_ping_period->value / 2 > cls.realtime) ? "\x8f" : " ", sizeof(buf));

	// min ping
	if (hud_ping_show_min->value)
		strlcat(buf, va("%d\xf", ping_min), sizeof(buf));

	// ping
	strlcat(buf, va("%d", ping_avg), sizeof(buf));

	// max ping
	if (hud_ping_show_max->value)
		strlcat(buf, va("\xf%d", ping_max), sizeof(buf));

	// unit
	strlcat(buf, " ms", sizeof(buf));

	// standard deviation
	if (hud_ping_show_dev->value)
		strlcat(buf, va(" (%.1f)", ping_dev), sizeof(buf));

	// pl
	if (hud_ping_show_pl->value)
		strlcat(buf, va(" \x8f %d%%", pl), sizeof(buf));

	// display that on screen
	width = Draw_StringLength(buf, -1, hud_ping_scale->value, hud_ping_proportional->integer);
	height = 8 * hud_ping_scale->value;

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		if (hud_ping_style->value) {
			Draw_SAlt_String(x, y, buf, hud_ping_scale->value, hud_ping_proportional->integer);
		}
		else {
			Draw_SString(x, y, buf, hud_ping_scale->value, hud_ping_proportional->integer);
		}
	}
}

void Net_HudInit(void)
{
	// init net
	HUD_Register(
		"net", NULL, "Shows network statistics, like latency, packet loss, average packet sizes and bandwidth. Shown only when you are connected to a server.",
		HUD_PLUSMINUS, ca_active, 7, SCR_HUD_DrawNetStats,
		"0", "top", "left", "center", "0", "0", "0.2", "0 0 0", NULL,
		"period", "1",
		"scale", "1",
		"proportional", "0",
		NULL
	);

	// netproblem icon
	HUD_Register(
		"netproblem", NULL, "Shows an icon if you are experiencing network problems",
		HUD_NO_FRAME, ca_active, 0, SCR_HUD_NetProblem,
		"1", "top", "left", "top", "0", "0", "0", "0 0 0", NULL,
		"scale", "1",
		NULL
	);

	// init ping
	HUD_Register(
		"ping", NULL, "Shows most important net conditions, like ping and pl. Shown only when you are connected to a server.",
		HUD_PLUSMINUS, ca_active, 9, SCR_HUD_DrawPing,
		"0", "screen", "left", "bottom", "0", "0", "0", "0 0 0", NULL,
		"period", "1",
		"show_pl", "1",
		"show_min", "0",
		"show_max", "0",
		"show_dev", "0",
		"style", "0",
		"blink", "1",
		"scale", "1",
		"proportional", "0",
		NULL
	);
}


================================================
FILE: src/hud_performance.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "tr_types.h"
#include "r_framestats.h"
#include "screen.h"
#include "vx_stuff.h"

cvar_t	show_fps = { "show_fps", "0" };
static cvar_t	show_fps_x = { "show_fps_x", "-5" };
static cvar_t	show_fps_y = { "show_fps_y", "-1" };

r_frame_stats_t prevFrameStats;
r_frame_stats_t frameStats;

// ----------------
// DrawFPS
static void SCR_HUD_DrawFPS(hud_t *hud)
{
	int x, y;
	char st[128];
	qbool drop_triggered = false;
	extern cvar_t cl_maxfps;

	static cvar_t
		*hud_fps_show_min = NULL,
		*hud_fps_style,
		*hud_fps_title,
		*hud_fps_drop,
		*hud_fps_scale,
		*hud_fps_proportional;

	if (hud_fps_show_min == NULL) {
		// first time called
		hud_fps_show_min = HUD_FindVar(hud, "show_min");
		hud_fps_style = HUD_FindVar(hud, "style");
		hud_fps_title = HUD_FindVar(hud, "title");
		hud_fps_drop = HUD_FindVar(hud, "drop");
		hud_fps_scale = HUD_FindVar(hud, "scale");
		hud_fps_proportional = HUD_FindVar(hud, "proportional");
	}

	drop_triggered = (hud_fps_drop->integer > 0 && (hud_fps_drop->value) >= cls.fps);
	drop_triggered |= (hud_fps_drop->integer < 0 && cl_maxfps.integer && (cl_maxfps.integer + hud_fps_drop->value) >= cls.fps);

	if (hud_fps_show_min->value) {
		snprintf(st, sizeof(st), "%3d\xf%3d", (int)(cls.min_fps + 0.25), (int)(cls.fps + 0.25));
	}
	else {
		snprintf(st, sizeof(st), "%3d", (int)(cls.fps + 0.25));
	}

	if (hud_fps_title->value) {
		strlcat(st, " fps", sizeof(st));
	}

	if (HUD_PrepareDraw(hud, Draw_StringLength(st, -1, hud_fps_scale->value, hud_fps_proportional->integer), 8 * hud_fps_scale->value, &x, &y)) {
		switch (hud_fps_style->integer) {
			case 1:
				Draw_SAlt_String(x, y, st, hud_fps_scale->value, hud_fps_proportional->integer);;
				break;
			case 2:
				// if fps is less than a user-set value, then show it
				if (drop_triggered) {
					Draw_SString(x, y, st, hud_fps_scale->value, hud_fps_proportional->integer);
				}
				break;
			case 3:
				// if fps is less than a user-set value, then show it
				if (drop_triggered) {
					Draw_SAlt_String(x, y, st, hud_fps_scale->value, hud_fps_proportional->integer);
				}
				break;
			default:
				Draw_SString(x, y, st, hud_fps_scale->value, hud_fps_proportional->integer);
				break;
		}
	}
}

// DrawFrameTime
static void SCR_HUD_DrawFrameTime(hud_t* hud)
{
	int x, y;
	char st[128];

	static cvar_t
		* hud_frametime_show_max = NULL,
		* hud_frametime_style,
		* hud_frametime_title,
		* hud_frametime_spike,
		* hud_frametime_scale,
		* hud_frametime_proportional;

	if (hud_frametime_show_max == NULL) {
		// first time called
		hud_frametime_show_max = HUD_FindVar(hud, "show_max");
		hud_frametime_style = HUD_FindVar(hud, "style");
		hud_frametime_title = HUD_FindVar(hud, "title");
		hud_frametime_spike = HUD_FindVar(hud, "spike");
		hud_frametime_scale = HUD_FindVar(hud, "scale");
		hud_frametime_proportional = HUD_FindVar(hud, "proportional");
	}

	if (hud_frametime_show_max->value) {
		snprintf(st, sizeof(st), "%3.1f\xf%3.1f", cls.max_frametime * 1000, cls.avg_frametime * 1000);
	}
	else {
		snprintf(st, sizeof(st), "%3.1f", cls.avg_frametime * 1000);
	}

	if (hud_frametime_title->value) {
		strlcat(st, " ms", sizeof(st));
	}

	if (HUD_PrepareDraw(hud, Draw_StringLength(st, -1, hud_frametime_scale->value, hud_frametime_proportional->integer), 8 * hud_frametime_scale->value, &x, &y)) {
		switch (hud_frametime_style->integer) {
		case 1:
			Draw_SAlt_String(x, y, st, hud_frametime_scale->value, hud_frametime_proportional->integer);;
			break;
		case 2:
			// if frametime is greater than a user-set value, then show it
			if ((hud_frametime_spike->value) <= cls.max_frametime * 1000) {
				Draw_SString(x, y, st, hud_frametime_scale->value, hud_frametime_proportional->integer);
			}
			break;
		case 3:
			// if frametime is greater than a user-set value, then show it
			if ((hud_frametime_spike->value) <= cls.max_frametime * 1000) {
				Draw_SAlt_String(x, y, st, hud_frametime_scale->value, hud_frametime_proportional->integer);
			}
			break;
		default:
			Draw_SString(x, y, st, hud_frametime_scale->value, hud_frametime_proportional->integer);
			break;
		}
	}
}

static void SCR_HUD_DrawVidLag(hud_t *hud)
{
	int x, y;
	char st[128];
	static cvar_t *hud_vidlag_style = NULL;
	static cvar_t *hud_vidlag_scale = NULL;
	static cvar_t *hud_vidlag_proportional = NULL;

	extern qbool VID_VSyncIsOn(void);
	extern double vid_vsync_lag;
	static double old_lag;

	if (VID_VSyncIsOn() || glConfig.displayFrequency) {
		// take the average of last two values, otherwise it
		// changes very fast and is hard to read
		double current, avg;
		if (VID_VSyncIsOn()) {
			current = vid_vsync_lag;
		}
		else {
			current = min(cls.trueframetime, 1.0 / glConfig.displayFrequency) * 0.5;
		}
		avg = (current + old_lag) * 0.5;
		old_lag = current;
		snprintf(st, sizeof(st), "%2.1f", avg * 1000);
	}
	else {
		strcpy(st, "?");
	}

	if (hud_vidlag_style == NULL) {
		// first time called
		hud_vidlag_style = HUD_FindVar(hud, "style");
		hud_vidlag_scale = HUD_FindVar(hud, "scale");
		hud_vidlag_proportional = HUD_FindVar(hud, "proportional");
	}

	strlcat(st, " ms", sizeof(st));

	if (HUD_PrepareDraw(hud, Draw_StringLength(st, -1, hud_vidlag_scale->value, hud_vidlag_proportional->integer), 8 * hud_vidlag_scale->value, &x, &y)) {
		if (hud_vidlag_style->value) {
			Draw_SAlt_String(x, y, st, hud_vidlag_scale->value, hud_vidlag_proportional->integer);
		}
		else {
			Draw_SString(x, y, st, hud_vidlag_scale->value, hud_vidlag_proportional->integer);
		}
	}
}

#define MAX_FRAMESTATS_LINES 32
static char content[MAX_FRAMESTATS_LINES][2][64];

static void FrameStats_AddLine(int* line, const char* name, int value)
{
	if (*line < 0 || *line >= MAX_FRAMESTATS_LINES) {
		return;
	}

	strlcpy(content[*line][0], name, sizeof(content[*line][0]));
	if (name[0]) {
		snprintf(content[*line][1], sizeof(content[*line][1]), "%4d", value);
	}
	else {
		memset(content[*line][1], 0, sizeof(content[*line][1]));
	}
	++(*line);
}

static void FrameStats_DrawElement(hud_t *hud)
{
	static cvar_t
		*hud_frameStats_style = NULL,
		*hud_frameStats_scale,
		*hud_frameStats_proportional,
		*hud_frameStats_amfstats;

	int height = 8;
	int width = 0;
	int x = 0;
	int y = 0;
	int lines = 0;
	int i;
	int max_field_length;
	int max_value_length;
	int value_length[MAX_FRAMESTATS_LINES];

	if (hud_frameStats_style == NULL) {
		// first time
		hud_frameStats_style = HUD_FindVar(hud, "style");
		hud_frameStats_scale = HUD_FindVar(hud, "scale");
		hud_frameStats_proportional = HUD_FindVar(hud, "proportional");
		hud_frameStats_amfstats = HUD_FindVar(hud, "amfstats");
	}

	FrameStats_AddLine(&lines, "Draw calls:", prevFrameStats.draw_calls);
	FrameStats_AddLine(&lines, "Sub-draw calls:", prevFrameStats.subdraw_calls);
	FrameStats_AddLine(&lines, "Texture switches:", prevFrameStats.texture_binds);
	FrameStats_AddLine(&lines, "Lightmap uploads:", prevFrameStats.lightmap_updates);
	if (frameStats.classic.polycount[polyTypeWorldModel]) {
		FrameStats_AddLine(&lines, "", 0);
		FrameStats_AddLine(&lines, "World-model polys:", frameStats.classic.polycount[polyTypeWorldModel]);
		if (cl.standby || com_serveractive) {
			FrameStats_AddLine(&lines, "Alias-model polys:", frameStats.classic.polycount[polyTypeAliasModel]);
			FrameStats_AddLine(&lines, "Brush-model polys:", frameStats.classic.polycount[polyTypeBrushModel]);
		}
	}
#ifdef DEBUG_MEMORY_ALLOCATIONS
	FrameStats_AddLine(&lines, "Mallocs:", prevFrameStats.mallocs);
	FrameStats_AddLine(&lines, "HotMallocs:", prevFrameStats.hotloop_mallocs);
#endif

	FrameStats_AddLine(&lines, "Particles:", prevFrameStats.particle_count);
	if (hud_frameStats_amfstats->integer) {
		FrameStats_AddLine(&lines, "", 0);
		FrameStats_AddLine(&lines, "AMF particle count:", ParticleCount);
		FrameStats_AddLine(&lines, "AMF particle peak:", ParticleCountHigh);
		FrameStats_AddLine(&lines, "Corona count:", CoronaCount);
		FrameStats_AddLine(&lines, "Corona peak:", CoronaCountHigh);
	}

	height = lines * 8 * hud_frameStats_scale->value;
	max_field_length = max_value_length = 0;
	for (i = 0; i < lines; ++i) {
		int name_length = Draw_StringLength(content[i][0], -1, hud_frameStats_scale->value, hud_frameStats_proportional->integer);
		value_length[i] = Draw_StringLength(content[i][1], -1, hud_frameStats_scale->value, hud_frameStats_proportional->integer);

		max_field_length = max(max_field_length, name_length);
		max_value_length = max(max_value_length, value_length[i]);
	}

	width = max_field_length + 8 * hud_frameStats_scale->value + max_value_length;
	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		for (i = 0; i < lines; ++i, y += 8 * hud_frameStats_scale->value) {
			if (content[i][0][0]) {
				Draw_SString(x, y, content[i][0], hud_frameStats_scale->value, hud_frameStats_proportional->integer);
				Draw_SString(x + width - value_length[i], y, content[i][1], hud_frameStats_scale->value, hud_frameStats_proportional->integer);
			}
		}
	}
}

void Performance_HudInit(void)
{
	// fps
	HUD_Register(
		"fps", NULL,
		"Shows your current framerate in frames per second (fps)."
		"This can also show the minimum framerate that occured in the last measured period.",
		HUD_PLUSMINUS, ca_active, 9, SCR_HUD_DrawFPS,
		"1", "gameclock", "center", "after", "0", "0", "0", "0 0 0", NULL,
		"show_min", "0",
		"style", "0",
		"title", "1",
		"scale", "1",
		"drop", "70",
		"proportional", "0",
		NULL
	);

	// frametime
	HUD_Register(
		"frametime", NULL,
		"Shows your current frametime in ms."
		"This can also show the maximum frametime that occured in the last measured period.",
		HUD_PLUSMINUS, ca_active, 9, SCR_HUD_DrawFrameTime,
		"0", "fps", "center", "after", "0", "0", "0", "0 0 0", NULL,
		"show_max", "1",
		"style", "0",
		"title", "1",
		"scale", "1",
		"spike", "10",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"vidlag", NULL,
		"Shows the delay between the time a frame is rendered and the time it's displayed.",
		HUD_PLUSMINUS, ca_active, 9, SCR_HUD_DrawVidLag,
		"0", "top", "right", "top", "0", "0", "0", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"framestats", NULL,
		"Shows information about the renderer's status & workload.",
		HUD_PLUSMINUS, ca_active, 0, FrameStats_DrawElement,
		"0", "top", "left", "bottom", "0", "0", "0", "0 0 0", NULL,
		"scale", "1",
		"proportional", "0",
		"amfstats", "0",
		NULL
	);

	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register(&show_fps);
	Cvar_Register(&show_fps_x);
	Cvar_Register(&show_fps_y);
	Cvar_ResetCurrentGroup();
}

void SCR_DrawFPS(void)
{
	int x, y;
	char str[80];
	extern cvar_t scr_newHud;

	if (!show_fps.integer || scr_newHud.integer == 1) {
		// HUD -> hexum - newHud has its own fps
		return;
	}

	snprintf(str, sizeof(str), "%3.1f", cls.fps + 0.05);

	x = ELEMENT_X_COORD(show_fps);
	y = ELEMENT_Y_COORD(show_fps);
	Draw_String(x, y, str);
}


================================================
FILE: src/hud_qtv.c
================================================
/*
Copyright (C) 1996-2003 Id Software, Inc., A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: cl_screen.c,v 1.156 2007-10-29 00:56:47 qqshka Exp $
*/

#include "quakedef.h"
#include "hud.h"
#include "qtv.h"

static cvar_t scr_qtvbuffer   = { "scr_qtvbuffer",        "0" };
static cvar_t scr_qtvbuffer_x = { "scr_qtvbuffer_x",      "0" };
static cvar_t scr_qtvbuffer_y = { "scr_qtvbuffer_y",    "-10" };

void SCR_DrawQTVBuffer(void)
{
	extern double Demo_GetSpeed(void);

	int x, y;
	int ms, len;
	char str[64];

	if (!SCR_QTVBufferToBeDrawn(scr_qtvbuffer.integer)) {
		return;
	}

	len = Demo_BufferSize(&ms);
	snprintf(str, sizeof(str), "%6dms %5db %2.3f", ms, len, Demo_GetSpeed());

	x = ELEMENT_X_COORD(scr_qtvbuffer);
	y = ELEMENT_Y_COORD(scr_qtvbuffer);
	Draw_String(x, y, str);
}

static void SCR_HUD_DrawQTVBuffer(hud_t* hud)
{
	extern double Demo_GetSpeed(void);

	int x, y;
	int ms, len;
	char str[64];
	float draw_len;

	static cvar_t *hud_scale, *hud_proportional;

	if (hud_scale == NULL) {
		hud_scale = HUD_FindVar(hud, "scale");
		hud_proportional = HUD_FindVar(hud, "proportional");
	}

	if (!SCR_QTVBufferToBeDrawn(hud->show->integer)) {
		return;
	}

	len = Demo_BufferSize(&ms);
	snprintf(str, sizeof(str), "%6dms %5db %2.3f", ms, len, Demo_GetSpeed());
	
	draw_len = Draw_StringLength(str, -1, hud_scale->value, hud_proportional->integer);
	if (HUD_PrepareDraw(hud, draw_len, 8 * hud_scale->value, &x, &y)) {
		Draw_SString(x, y, str, hud_scale->value, hud_proportional->integer);
	}
}

void Qtv_HudInit(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register(&scr_qtvbuffer_x);
	Cvar_Register(&scr_qtvbuffer_y);
	Cvar_Register(&scr_qtvbuffer);
	Cvar_ResetCurrentGroup();

	HUD_Register(
		"qtv_buffer", NULL, "QTV buffering status.",
		0, ca_active, 0, SCR_HUD_DrawQTVBuffer,
		"0", "screen", "left", "top", "0", "0", "0", "0 0 0", NULL,
		"scale", "1",
		"proportional", "0",
		NULL
	);
}


================================================
FILE: src/hud_radar.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "stats_grid.h"
#include "utils.h"
#include "hud.h"
#include "gl_model.h"
#include "image.h"
#if defined(WITH_PNG)
#include <png.h>
#endif
#include "sbar.h"
#include "r_texture.h"
#include "r_renderer.h"

// What stats to draw.
#define HUD_RADAR_STATS_NONE				0
#define HUD_RADAR_STATS_BOTH_TEAMS_HOLD		1
#define HUD_RADAR_STATS_TEAM1_HOLD			2
#define HUD_RADAR_STATS_TEAM2_HOLD			3
#define HUD_RADAR_STATS_BOTH_TEAMS_DEATHS	4
#define HUD_RADAR_STATS_TEAM1_DEATHS		5
#define HUD_RADAR_STATS_TEAM2_DEATHS		6

// The skinnum property in the entity_s structure is used
// for determening what type of armor to draw on the radar.
#define HUD_RADAR_GA					0
#define HUD_RADAR_YA					1
#define HUD_RADAR_RA					2

#define HUD_RADAR_HIGHLIGHT_NONE			0
#define HUD_RADAR_HIGHLIGHT_TEXT_ONLY		1
#define HUD_RADAR_HIGHLIGHT_OUTLINE			2
#define HUD_RADAR_HIGHLIGHT_FIXED_OUTLINE	3
#define HUD_RADAR_HIGHLIGHT_CIRCLE			4
#define HUD_RADAR_HIGHLIGHT_FIXED_CIRCLE	5
#define HUD_RADAR_HIGHLIGHT_ARROW_BOTTOM	6
#define HUD_RADAR_HIGHLIGHT_ARROW_CENTER	7
#define HUD_RADAR_HIGHLIGHT_ARROW_TOP		8
#define HUD_RADAR_HIGHLIGHT_CROSS_CORNERS	9
#define HUD_RADAR_HIGHLIGHT_BRIGHT_VIEW    10

// Radar filters.
#define RADAR_SHOW_WEAPONS (radar_show_ssg || radar_show_ng || radar_show_sng || radar_show_gl || radar_show_rl || radar_show_lg)
static qbool radar_show_ssg = false;
static qbool radar_show_ng = false;
static qbool radar_show_sng = false;
static qbool radar_show_gl = false;
static qbool radar_show_rl = false;
static qbool radar_show_lg = false;

#define RADAR_SHOW_ITEMS (radar_show_backpacks || radar_show_health || radar_show_ra || radar_show_ya || radar_show_ga || radar_show_rockets || radar_show_nails || radar_show_cells || radar_show_shells || radar_show_quad || radar_show_pent || radar_show_ring || radar_show_suit)
static qbool radar_show_backpacks = false;
static qbool radar_show_health = false;
static qbool radar_show_ra = false;
static qbool radar_show_ya = false;
static qbool radar_show_ga = false;
static qbool radar_show_rockets = false;
static qbool radar_show_nails = false;
static qbool radar_show_cells = false;
static qbool radar_show_shells = false;
static qbool radar_show_quad = false;
static qbool radar_show_pent = false;
static qbool radar_show_ring = false;
static qbool radar_show_suit = false;
static qbool radar_show_mega = false;

#define RADAR_SHOW_OTHER (radar_show_gibs || radar_show_explosions || radar_show_nails_p || radar_show_rockets_p || radar_show_shaft_p || radar_show_teleport || radar_show_shotgun)
static qbool radar_show_nails_p = false;
static qbool radar_show_rockets_p = false;
static qbool radar_show_shaft_p = false;
static qbool radar_show_gibs = false;
static qbool radar_show_explosions = false;
static qbool radar_show_teleport = false;
static qbool radar_show_shotgun = false;

#define HUD_COLOR_DEFAULT_TRANSPARENCY	75

byte hud_radar_highlight_color[4] = { 255, 255, 0, HUD_COLOR_DEFAULT_TRANSPARENCY };

extern temp_entity_list_t temp_entities;

#ifdef WITH_PNG

// Map picture to draw for the mapoverview hud control.
mpic_t radar_pic;
static qbool radar_pic_found = false;

// The conversion formula used for converting from quake coordinates to pixel coordinates
// when drawing on the map overview.
static float map_x_slope;
static float map_x_intercept;
static float map_y_slope;
static float map_y_intercept;
static qbool conversion_formula_found = false;

// Used for drawing the height of the player.
static float map_height_diff = 0.0;

#define RADAR_BASE_PATH_FORMAT	"radars/%s.png"

//
// Is run when a new map is loaded.
//
void HUD_NewRadarMap(void)
{
	int i = 0;
	int len = 0;
	int n_textcount = 0;
	mpic_t *radar_pic_p = NULL;
	png_textp txt = NULL;
	char *radar_filename = NULL;

	if (!cl.worldmodel)
		return; // seems we are not ready to do that

	// Reset the radar pic status.
	memset (&radar_pic, 0, sizeof(radar_pic));
	radar_pic_found = false;
	conversion_formula_found = false;

	// Allocate a string for the path to the radar image.
	len = strlen (RADAR_BASE_PATH_FORMAT) + strlen (host_mapname.string);
	radar_filename = Q_calloc (len, sizeof(char));
	snprintf (radar_filename, len, RADAR_BASE_PATH_FORMAT, host_mapname.string);

	// Load the map picture.
	if ((radar_pic_p = R_LoadPicImage (radar_filename, host_mapname.string, 0, 0, TEX_ALPHA)) != NULL) {
		radar_pic = *radar_pic_p;
		radar_pic_found = true;

		renderer.TextureWrapModeClamp(radar_pic.texnum);

		// Calculate the height of the map.
		map_height_diff = fabs((float)(cl.worldmodel->maxs[2] - cl.worldmodel->mins[2]));

		// Get the comments from the PNG.
		txt = Image_LoadPNG_Comments(radar_filename, &n_textcount);

		// Check if we found any comments.
		if(txt != NULL)
		{
			int found_count = 0;

			// Find the conversion formula in the comments found in the PNG.
			for(i = 0; i < n_textcount; i++)
			{
				if(!strcmp(txt[i].key, "QWLMConversionSlopeX"))
				{
					map_x_slope = atof(txt[i].text);
					found_count++;
				}
				else if(!strcmp(txt[i].key, "QWLMConversionInterceptX"))
				{
					map_x_intercept = atof(txt[i].text);
					found_count++;
				}
				else if(!strcmp(txt[i].key, "QWLMConversionSlopeY"))
				{
					map_y_slope = atof(txt[i].text);
					found_count++;
				}
				else if(!strcmp(txt[i].key, "QWLMConversionInterceptY"))
				{
					map_y_intercept = atof(txt[i].text);
					found_count++;
				}

				Q_free(txt[i].key);
				Q_free(txt[i].text);

				conversion_formula_found = (found_count == 4);
			}

			// Free the text chunks.
			Q_free(txt);
		}
		else
		{
			conversion_formula_found = false;
			Con_Printf("No conversion formula found\n");
		}
	}
	else
	{
		// No radar pic found.
		memset (&radar_pic, 0, sizeof(radar_pic));
		radar_pic_found = false;
		conversion_formula_found = false;
	}

	// Free the path string to the radar png.
	Q_free (radar_filename);
}

static void Radar_DrawGrid(stats_weight_grid_t *grid, int x, int y, float scale, int pic_width, int pic_height, int style)
{
	int row, col;

	// Don't try to draw anything if we got no data.
	if(grid == NULL || grid->cells == NULL || style == HUD_RADAR_STATS_NONE)
	{
		return;
	}

	// Go through all the cells and draw them based on their weight.
	for(row = 0; row < grid->row_count; row++)
	{
		// Just to be safe if something went wrong with the allocation.
		if(grid->cells[row] == NULL)
		{
			continue;
		}

		for(col = 0; col < grid->col_count; col++)
		{
			float weight = 0.0;
			int color = 0;

			float tl_x, tl_y;			// The pixel coordinate of the top left corner of a grid cell.
			float p_cell_length_x;		// The pixel length of a cell.
			float p_cell_length_y;		// The pixel "length" on the Y-axis. We calculate this
										// seperatly because we'll get errors when converting from
										// quake coordinates -> pixel coordinates.

			// Calculate the pixel coordinates of the top left corner of the current cell.
			// (This is times 8 because the conversion formula was calculated from a .loc-file)
			tl_x = (map_x_slope * (8.0 * grid->cells[row][col].tl_x) + map_x_intercept) * scale;
			tl_y = (map_y_slope * (8.0 * grid->cells[row][col].tl_y) + map_y_intercept) * scale;

			// Calculate the cell length in pixel length.
			p_cell_length_x = map_x_slope*(8.0 * grid->cell_length) * scale;
			p_cell_length_y = map_y_slope*(8.0 * grid->cell_length) * scale;

			// Add rounding errors (so that we don't get weird gaps in the grid).
			p_cell_length_x += tl_x - Q_rint(tl_x);
			p_cell_length_y += tl_y - Q_rint(tl_y);

			// Don't draw the stats stuff outside the picture.
			if(tl_x + p_cell_length_x > pic_width || tl_y + p_cell_length_y > pic_height || x + tl_x < x || y + tl_y < y)
			{
				continue;
			}

			//
			// Death stats.
			//
			if(grid->cells[row][col].teams[STATS_TEAM1].death_weight + grid->cells[row][col].teams[STATS_TEAM2].death_weight > 0)
			{
				weight = 0;

				if(style == HUD_RADAR_STATS_BOTH_TEAMS_DEATHS || style == HUD_RADAR_STATS_TEAM1_DEATHS)
				{
					weight = grid->cells[row][col].teams[STATS_TEAM1].death_weight;
				}

				if(style == HUD_RADAR_STATS_BOTH_TEAMS_DEATHS || style == HUD_RADAR_STATS_TEAM2_DEATHS)
				{
					weight += grid->cells[row][col].teams[STATS_TEAM2].death_weight;
				}

				color = 79;
			}

			//
			// Team stats.
			//
			{
				// No point in drawing if we have no weight.
				if(grid->cells[row][col].teams[STATS_TEAM1].weight + grid->cells[row][col].teams[STATS_TEAM2].weight <= 0
					&& (style == HUD_RADAR_STATS_BOTH_TEAMS_HOLD
						||	style == HUD_RADAR_STATS_TEAM1_HOLD
						||	style == HUD_RADAR_STATS_TEAM2_HOLD))
				{
					continue;
				}

				// Get the team with the highest weight for this cell.
				if(grid->cells[row][col].teams[STATS_TEAM1].weight > grid->cells[row][col].teams[STATS_TEAM2].weight
					&& (style == HUD_RADAR_STATS_BOTH_TEAMS_HOLD
						||	style == HUD_RADAR_STATS_TEAM1_HOLD))
				{
					weight = grid->cells[row][col].teams[STATS_TEAM1].weight;
					color = stats_grid->teams[STATS_TEAM1].color;
				}
				else if(style == HUD_RADAR_STATS_BOTH_TEAMS_HOLD ||	style == HUD_RADAR_STATS_TEAM2_HOLD)
				{
					weight = grid->cells[row][col].teams[STATS_TEAM2].weight;
					color = stats_grid->teams[STATS_TEAM2].color;
				}
			}

			// Draw the cell in the color of the team with the
			// biggest weight for this cell. Or draw deaths.
			Draw_AlphaFill(
				x + Q_rint(tl_x),			// X.
				y + Q_rint(tl_y),			// Y.
				Q_rint(p_cell_length_x),		// Width.
				Q_rint(p_cell_length_y),		// Height.
				color,						// Color.
				weight);					// Alpha.
		}
	}
}

static void Radar_OnChangeWeaponFilter(cvar_t *var, char *newval, qbool *cancel)
{
	// Parse the weapon filter.
	radar_show_ssg		= Utils_RegExpMatch("SSG|SUPERSHOTGUN|ALL",			newval);
	radar_show_ng		= Utils_RegExpMatch("([^S]|^)NG|NAILGUN|ALL",		newval); // Yes very ugly, but we don't want to match SNG.
	radar_show_sng		= Utils_RegExpMatch("SNG|SUPERNAILGUN|ALL",			newval);
	radar_show_rl		= Utils_RegExpMatch("RL|ROCKETLAUNCHER|ALL",		newval);
	radar_show_gl		= Utils_RegExpMatch("GL|GRENADELAUNCHER|ALL",		newval);
	radar_show_lg		= Utils_RegExpMatch("LG|SHAFT|LIGHTNING|ALL",		newval);
}

static void Radar_OnChangeItemFilter(cvar_t *var, char *newval, qbool *cancel)
{
	// Parse the item filter.
	radar_show_backpacks		= Utils_RegExpMatch("BP|BACKPACK|ALL",					newval);
	radar_show_health			= Utils_RegExpMatch("HP|HEALTH|ALL",					newval);
	radar_show_ra				= Utils_RegExpMatch("RA|REDARMOR|ARMOR|ALL",			newval);
	radar_show_ya				= Utils_RegExpMatch("YA|YELLOWARMOR|ARMOR|ALL",			newval);
	radar_show_ga				= Utils_RegExpMatch("GA|GREENARMOR|ARMOR|ALL",			newval);
	radar_show_rockets			= Utils_RegExpMatch("ROCKETS|ROCKS|AMMO|ALL",			newval);
	radar_show_nails			= Utils_RegExpMatch("NAILS|SPIKES|AMMO|ALL",			newval);
	radar_show_cells			= Utils_RegExpMatch("CELLS|BATTERY|AMMO|ALL",			newval);
	radar_show_shells			= Utils_RegExpMatch("SHELLS|AMMO|ALL",					newval);
	radar_show_quad				= Utils_RegExpMatch("QUAD|POWERUPS|ALL",				newval);
	radar_show_pent				= Utils_RegExpMatch("PENT|PENTAGRAM|666|POWERUPS|ALL",	newval);
	radar_show_ring				= Utils_RegExpMatch("RING|INVISIBLE|EYES|POWERUPS|ALL",	newval);
	radar_show_suit				= Utils_RegExpMatch("SUIT|POWERUPS|ALL",				newval);
	radar_show_mega				= Utils_RegExpMatch("MH|MEGA|MEGAHEALTH|100\\+|ALL",	newval);
}

static void Radar_OnChangeOtherFilter(cvar_t *var, char *newval, qbool *cancel)
{
	// Parse the "other" filter.
	radar_show_nails_p			= Utils_RegExpMatch("NAILS|PROJECTILES|ALL",	newval);
	radar_show_rockets_p		= Utils_RegExpMatch("ROCKETS|PROJECTILES|ALL",	newval);
	radar_show_shaft_p			= Utils_RegExpMatch("SHAFT|PROJECTILES|ALL",	newval);
	radar_show_gibs				= Utils_RegExpMatch("GIBS|ALL",					newval);
	radar_show_explosions		= Utils_RegExpMatch("EXPLOSIONS|ALL",			newval);
	radar_show_teleport			= Utils_RegExpMatch("TELE|ALL",					newval);
	radar_show_shotgun			= Utils_RegExpMatch("SHOTGUN|SG|BUCK|ALL",		newval);
}

static void Radar_OnChangeHighlightColor(cvar_t *var, char *newval, qbool *cancel)
{
	char *new_color;
	char buf[MAX_COM_TOKEN];

	// Translate a colors name to RGB values.
	new_color = ColorNameToRGBString(newval);

	// Parse the colors.
	//color = StringToRGB(new_color);
	strlcpy(buf,new_color,sizeof(buf));
	memcpy(hud_radar_highlight_color, StringToRGB(buf), sizeof(byte) * 4);

	// Set the cvar to contain the new color string
	// (if the user entered "red" it will be "255 0 0").
	Cvar_Set(var, new_color);
}

static void Radar_DrawEntities(int x, int y, float scale, float player_size, int show_hold_areas, float text_scale, qbool simple_items, qbool proportional)
{
	int i;

	// Entities (weapons and such). cl_main.c
	extern visentlist_t cl_visents;

	// Go through all the entities and draw the ones we're supposed to.
	for (i = 0; i < cl_visents.count; i++) {
		entity_t* currententity = &cl_visents.list[i].ent;
		texture_ref simpletexture;
		qbool simple_valid;

		int entity_q_x = 0;
		int entity_q_y = 0;
		int entity_p_x = 0;
		int entity_p_y = 0;

		// Find simple texture for entity
		if (currententity->skinnum < 0 || currententity->skinnum >= MAX_SIMPLE_TEXTURES) {
			simpletexture = currententity->model->simpletexture[0]; // ah...
		}
		else {
			simpletexture = currententity->model->simpletexture[currententity->skinnum];
		}
		simple_valid = R_TextureReferenceIsValid(simpletexture);

		// Get quake coordinates (times 8 to get them in the same format as .locs).
		entity_q_x = currententity->origin[0] * 8;
		entity_q_y = currententity->origin[1] * 8;

		// Convert from quake coordiantes -> pixel coordinates.
		entity_p_x = x + Q_rint((map_x_slope*entity_q_x + map_x_intercept) * scale);
		entity_p_y = y + Q_rint((map_y_slope*entity_q_y + map_y_intercept) * scale);

		// TODO: Replace all model name comparison below with MOD_HINT's instead for less comparisons (create new ones in Mod_LoadAliasModel() in r_model.c and gl_model.c/.h for the ones that don't have one already).

		//
		// Powerups.
		//

		if (radar_show_pent && currententity->model->modhint == MOD_PENT) {
			// Pentagram.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SColoredStringBasic(entity_p_x, entity_p_y, "&cf00P", 0, text_scale, proportional);
			}
		}
		else if (radar_show_quad && currententity->model->modhint == MOD_QUAD) {
			// Quad.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SColoredStringBasic(entity_p_x, entity_p_y, "&c0ffQ", 0, text_scale, proportional);
			}
		}
		else if (radar_show_ring && currententity->model->modhint == MOD_RING) {
			// Ring.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SColoredStringBasic(entity_p_x, entity_p_y, "&cff0R", 0, text_scale, proportional);
			}
		}
		else if (radar_show_suit && currententity->model->modhint == MOD_SUIT) {
			// Suit.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SColoredStringBasic(entity_p_x, entity_p_y, "&c0f0S", 0, text_scale, proportional);
			}
		}

		//
		// Show RL, LG and backpacks.
		//
		if (radar_show_rl && currententity->model->modhint == MOD_ROCKETLAUNCHER) {
			// RL.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SString(entity_p_x - (2 * 8) / 2, entity_p_y - 4, "RL", text_scale, proportional);
			}
		}
		else if (radar_show_lg && currententity->model->modhint == MOD_LIGHTNINGGUN) {
			// LG.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SString(entity_p_x - (2 * 8) / 2, entity_p_y - 4, "LG", text_scale, proportional);
			}
		}
		else if (radar_show_backpacks && currententity->model->modhint == MOD_BACKPACK) {
			// Back packs.
			float back_pack_size = 0;

			back_pack_size = max(player_size * 0.5, 0.05);

			Draw_AlphaCircleFill(entity_p_x, entity_p_y, back_pack_size, 114, 1);
			Draw_AlphaCircleOutline(entity_p_x, entity_p_y, back_pack_size, 1.0, 0, 1);
		}

		if (currententity->model->modhint == MOD_ARMOR) {
			//
			// Show armors.
			//
			if (radar_show_ga && currententity->skinnum == HUD_RADAR_GA) {
				// GA.
				if (simple_valid && simple_items) {
					Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
				}
				else {
					Draw_AlphaCircleFill(entity_p_x, entity_p_y, 3.0, 178, 1.0);
					Draw_AlphaCircleOutline(entity_p_x, entity_p_y, 3.0, 1.0, 0, 1.0);
				}
			}
			else if (radar_show_ya && currententity->skinnum == HUD_RADAR_YA) {
				// YA.
				if (simple_valid && simple_items) {
					Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
				}
				else {
					Draw_AlphaCircleFill(entity_p_x, entity_p_y, 3.0, 192, 1.0);
					Draw_AlphaCircleOutline(entity_p_x, entity_p_y, 3.0, 1.0, 0, 1.0);
				}
			}
			else if (radar_show_ra && currententity->skinnum == HUD_RADAR_RA) {
				// RA.
				if (simple_valid && simple_items) {
					Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
				}
				else {
					Draw_AlphaCircleFill(entity_p_x, entity_p_y, 3.0, 251, 1.0);
					Draw_AlphaCircleOutline(entity_p_x, entity_p_y, 3.0, 1.0, 0, 1.0);
				}
			}
		}

		if (radar_show_mega && currententity->model->modhint == MOD_MEGAHEALTH) {
			//
			// Show megahealth.
			//
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				// Draw a red border around the cross.
				Draw_AlphaRectangleRGB(entity_p_x - 3, entity_p_y - 3, 8, 8, 1, false, RGBA_TO_COLOR(200, 0, 0, 200));

				// Draw a black outline cross.
				Draw_AlphaFill(entity_p_x - 3, entity_p_y - 1, 8, 4, 0, 1);
				Draw_AlphaFill(entity_p_x - 1, entity_p_y - 3, 4, 8, 0, 1);

				// Draw a 2 pixel cross.
				Draw_AlphaFill(entity_p_x - 2, entity_p_y, 6, 2, 79, 1);
				Draw_AlphaFill(entity_p_x, entity_p_y - 2, 2, 6, 79, 1);
			}
		}

		if (radar_show_ssg && !strcmp(currententity->model->name, "progs/g_shot.mdl")) {
			// SSG.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SString(entity_p_x - (3 * 8) / 2, entity_p_y - 4, "SSG", text_scale, proportional);
			}
		}
		else if (radar_show_ng && !strcmp(currententity->model->name, "progs/g_nail.mdl")) {
			// NG.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SString(entity_p_x - (2 * 8) / 2, entity_p_y - 4, "NG", text_scale, proportional);
			}
		}
		else if (radar_show_sng && !strcmp(currententity->model->name, "progs/g_nail2.mdl")) {
			// SNG.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SString(entity_p_x - (3 * 8) / 2, entity_p_y - 4, "SNG", text_scale, proportional);
			}
		}
		else if (radar_show_gl && currententity->model->modhint == MOD_GRENADELAUNCHER) {
			// GL.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_SString(entity_p_x - (2 * 8) / 2, entity_p_y - 4, "GL", text_scale, proportional);
			}
		}

		if (radar_show_gibs && currententity->model->modhint == MOD_GIB) {
			//
			// Gibs.
			//

			Draw_AlphaCircleFill(entity_p_x, entity_p_y, 2.0, 251, 1);
		}

		if (radar_show_health
			&& (!strcmp(currententity->model->name, "maps/b_bh25.bsp")
			|| !strcmp(currententity->model->name, "maps/b_bh10.bsp"))) {
			//
			// Health.
			//

			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				// Draw a black outline cross.
				Draw_AlphaFill(entity_p_x - 3, entity_p_y - 1, 7, 3, 0, 1);
				Draw_AlphaFill(entity_p_x - 1, entity_p_y - 3, 3, 7, 0, 1);

				// Draw a cross.
				Draw_AlphaFill(entity_p_x - 2, entity_p_y, 5, 1, 79, 1);
				Draw_AlphaFill(entity_p_x, entity_p_y - 2, 1, 5, 79, 1);
			}
		}

		//
		// Ammo.
		//
		if (radar_show_rockets
			&& (!strcmp(currententity->model->name, "maps/b_rock0.bsp")
			|| !strcmp(currententity->model->name, "maps/b_rock1.bsp"))) {
			//
			// Rockets.
			//

			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				// Draw a black outline.
				Draw_AlphaFill(entity_p_x - 1, entity_p_y - 6, 3, 5, 0, 1);
				Draw_AlphaFill(entity_p_x - 2, entity_p_y - 1, 5, 5, 0, 1);

				// The brown rocket.
				Draw_AlphaFill(entity_p_x, entity_p_y - 5, 1, 5, 120, 1);
				Draw_AlphaFill(entity_p_x - 1, entity_p_y, 1, 3, 120, 1);
				Draw_AlphaFill(entity_p_x + 1, entity_p_y, 1, 3, 120, 1);
			}
		}

		if (radar_show_cells
			&& (!strcmp(currententity->model->name, "maps/b_batt0.bsp")
			|| !strcmp(currententity->model->name, "maps/b_batt1.bsp"))) {
			//
			// Cells.
			//

			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				// Draw a black outline.
				Draw_AlphaLine(entity_p_x - 3, entity_p_y, entity_p_x + 4, entity_p_y - 5, 3, 0, 1);
				Draw_AlphaLine(entity_p_x - 3, entity_p_y, entity_p_x + 3, entity_p_y, 3, 0, 1);
				Draw_AlphaLine(entity_p_x + 3, entity_p_y, entity_p_x - 3, entity_p_y + 4, 3, 0, 1);

				// Draw a yellow lightning!
				Draw_AlphaLine(entity_p_x - 2, entity_p_y, entity_p_x + 3, entity_p_y - 4, 1, 111, 1);
				Draw_AlphaLine(entity_p_x - 2, entity_p_y, entity_p_x + 2, entity_p_y, 1, 111, 1);
				Draw_AlphaLine(entity_p_x + 2, entity_p_y, entity_p_x - 2, entity_p_y + 3, 1, 111, 1);
			}
		}

		if (radar_show_nails
			&& (!strcmp(currententity->model->name, "maps/b_nail0.bsp")
			|| !strcmp(currententity->model->name, "maps/b_nail1.bsp"))) {
			//
			// Nails.
			//

			// Draw a black outline.
			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				Draw_AlphaFill(entity_p_x - 3, entity_p_y - 3, 7, 3, 0, 1);
				Draw_AlphaFill(entity_p_x - 2, entity_p_y - 2, 5, 3, 0, 0.5);
				Draw_AlphaFill(entity_p_x - 1, entity_p_y, 3, 3, 0, 1);
				Draw_AlphaFill(entity_p_x - 1, entity_p_y + 3, 1, 1, 0, 0.5);
				Draw_AlphaFill(entity_p_x + 1, entity_p_y + 3, 1, 1, 0, 0.5);
				Draw_AlphaFill(entity_p_x, entity_p_y + 4, 1, 1, 0, 1);

				Draw_AlphaFill(entity_p_x - 2, entity_p_y - 2, 5, 1, 6, 1);
				Draw_AlphaFill(entity_p_x - 1, entity_p_y - 1, 3, 1, 6, 0.5);
				Draw_AlphaFill(entity_p_x, entity_p_y, 1, 4, 6, 1);
			}
		}

		if (radar_show_shells
			&& (!strcmp(currententity->model->name, "maps/b_shell0.bsp")
			|| !strcmp(currententity->model->name, "maps/b_shell1.bsp"))) {
			//
			// Shells.
			//

			if (simple_valid && simple_items) {
				Draw_2dAlphaTexture(entity_p_x - 3.0, entity_p_y - 3.0, 6.0, 6.0, simpletexture, 1.0f);
			}
			else {
				// Draw a black outline.
				Draw_AlphaFill(entity_p_x - 2, entity_p_y - 3, 5, 9, 0, 1);

				// Draw 2 shotgun shells.
				Draw_AlphaFill(entity_p_x - 1, entity_p_y - 2, 1, 4, 73, 1);
				Draw_AlphaFill(entity_p_x - 1, entity_p_y - 2 + 5, 1, 2, 104, 1);

				Draw_AlphaFill(entity_p_x + 1, entity_p_y - 2, 1, 4, 73, 1);
				Draw_AlphaFill(entity_p_x + 1, entity_p_y - 2 + 5, 1, 2, 104, 1);
			}
		}

		//
		// Show projectiles (rockets, grenades, nails, shaft).
		//

		if (radar_show_nails_p && currententity->model->modhint == MOD_SPIKE) {
			//
			// Spikes from SNG and NG.
			//

			Draw_AlphaFill(entity_p_x, entity_p_y, 1, 1, 254, 1);
		}
		else if (radar_show_rockets_p &&
			(currententity->model->modhint == MOD_ROCKET || currententity->model->modhint == MOD_GRENADE)
			) {
			//
			// Rockets and grenades.
			//

			float entity_angle = 0;
			int x_line_end = 0;
			int y_line_end = 0;

			// Get the entity angle in radians.
			entity_angle = DEG2RAD(currententity->angles[1]);

			x_line_end = entity_p_x + 5 * cos(entity_angle) * scale;
			y_line_end = entity_p_y - 5 * sin(entity_angle) * scale;

			// Draw the rocket/grenade showing it's angle also.
			Draw_AlphaLine(entity_p_x, entity_p_y, x_line_end, y_line_end, 1.0, 254, 1);
		}
		else if (radar_show_shaft_p && currententity->model->modhint == MOD_THUNDERBOLT) {
			//
			// Shaft beam.
			//

			float entity_angle = 0;
			float shaft_length = 0;
			float x_line_end = 0;
			float y_line_end = 0;

			// Get the length and angle of the shaft.
			shaft_length = currententity->model->maxs[1];
			entity_angle = (currententity->angles[1] * M_PI) / 180;

			// Calculate where the shaft beam's ending point.
			x_line_end = entity_p_x + shaft_length * cos(entity_angle);
			y_line_end = entity_p_y - shaft_length * sin(entity_angle);

			// Draw the shaft beam.
			Draw_AlphaLine(entity_p_x, entity_p_y, x_line_end, y_line_end, 1.0, 254, 1);
		}
	}

	// Show corpses (cl_deadbodyfilter might mean they aren't in visible entity list)
	{
		int entity_q_x = 0;
		int entity_q_y = 0;
		int entity_p_x = 0;
		int entity_p_y = 0;
		packet_entities_t *pack = &cl.frames[cl.validsequence & UPDATE_MASK].packet_entities;
		char buffer[MAX_SCOREBOARDNAME + 8];

		for (i = 0; i < pack->num_entities; ++i) {
			entity_state_t *state = &pack->entities[i];

			// must be body or gibbed head
			if (state->modelindex != cl_modelindices[mi_player] && state->modelindex != cl_modelindices[mi_h_player]) {
				continue;
			}

			if (state->colormap <= 0 || state->colormap > MAX_CLIENTS) {
				continue;
			}

			// Get quake coordinates (times 8 to get them in the same format as .locs).
			entity_q_x = state->origin[0] * 8;
			entity_q_y = state->origin[1] * 8;

			// Convert from quake coordiantes -> pixel coordinates.
			entity_p_x = x + Q_rint((map_x_slope * entity_q_x + map_x_intercept) * scale);
			entity_p_y = y + Q_rint((map_y_slope * entity_q_y + map_y_intercept) * scale);

			{
				int player_color = Sbar_BottomColor(&cl.players[state->colormap - 1]);

				byte red = host_basepal[player_color * 3];
				byte green = host_basepal[player_color * 3 + 1];
				byte blue = host_basepal[player_color * 3 + 2];

				snprintf(buffer, sizeof(buffer), "&c%x%x%x%s",
					(unsigned int)(red / 16),
					(unsigned int)(green / 16),
					(unsigned int)(blue / 16),
					"X"
				);

				Draw_SColoredStringBasic(entity_p_x - 4, entity_p_y - 4, buffer, 0, 0.75f, proportional);
			}
		}
	}

	// Draw a circle around "hold areas", the grid cells within this circle
	// are the ones that are counted for that particular hold area. The team
	// that has the most percentage of these cells is considered to hold that area.
	if (show_hold_areas && stats_important_ents != NULL && stats_important_ents->list != NULL) {
		int entity_p_x = 0;
		int entity_p_y = 0;

		for (i = 0; i < stats_important_ents->count; i++) {
			entity_p_x = x + Q_rint((map_x_slope * 8 * stats_important_ents->list[i].origin[0] + map_x_intercept) * scale);
			entity_p_y = y + Q_rint((map_y_slope * 8 * stats_important_ents->list[i].origin[1] + map_y_intercept) * scale);

			Draw_SColoredStringBasic(entity_p_x - Draw_StringLength(stats_important_ents->list[i].name, -1, text_scale, proportional) / 2.0, entity_p_y - 4,
				va("&c55f%s", stats_important_ents->list[i].name), 0, text_scale, proportional);

			Draw_AlphaCircleOutline(entity_p_x, entity_p_y, map_x_slope * 8 * stats_important_ents->hold_radius * scale, 1.0, 15, 0.2);
		}
	}

	//
	// Draw temp entities (explosions, blood, teleport effects).
	//
	for (i = 0; i < MAX_TEMP_ENTITIES; i++) {
		float time_diff = 0.0;

		int entity_q_x = 0;
		int entity_q_y = 0;
		int entity_p_x = 0;
		int entity_p_y = 0;

		// Get the time since the entity spawned.
		if (cls.demoplayback) {
			time_diff = cls.demotime - temp_entities.list[i].time;
		}
		else {
			time_diff = cls.realtime - temp_entities.list[i].time;
		}

		// Don't show temp entities for long.
		if (time_diff < 0.25) {
			float radius = 0.0;
			radius = (time_diff < 0.125) ? (time_diff * 32.0) : (time_diff * 32.0) - time_diff;
			radius *= scale;
			radius = min(max(radius, 0), 200);

			// Get quake coordinates (times 8 to get them in the same format as .locs).
			entity_q_x = temp_entities.list[i].pos[0] * 8;
			entity_q_y = temp_entities.list[i].pos[1] * 8;

			entity_p_x = x + Q_rint((map_x_slope*entity_q_x + map_x_intercept) * scale);
			entity_p_y = y + Q_rint((map_y_slope*entity_q_y + map_y_intercept) * scale);

			if (radar_show_explosions
				&& (temp_entities.list[i].type == TE_EXPLOSION
				|| temp_entities.list[i].type == TE_TAREXPLOSION)) {
				//
				// Explosions.
				//

				Draw_AlphaCircleFill(entity_p_x, entity_p_y, radius, 235, 0.8);
			}
			else if (radar_show_teleport && temp_entities.list[i].type == TE_TELEPORT) {
				//
				// Teleport effect.
				//

				radius *= 1.5;
				Draw_AlphaCircleFill(entity_p_x, entity_p_y, radius, 244, 0.8);
			}
			else if (radar_show_shotgun && temp_entities.list[i].type == TE_GUNSHOT) {
				//
				// Shotgun fire.
				//

#define SHOTGUN_SPREAD 10
				int spread_x = 0;
				int spread_y = 0;
				int n = 0;

				for (n = 0; n < 10; n++) {
					spread_x = (int)(rand() / (((double)RAND_MAX + 1) / SHOTGUN_SPREAD));
					spread_y = (int)(rand() / (((double)RAND_MAX + 1) / SHOTGUN_SPREAD));

					Draw_AlphaFill(entity_p_x + spread_x - (SHOTGUN_SPREAD / 2), entity_p_y + spread_y - (SHOTGUN_SPREAD / 2), 1, 1, 8, 0.9);
				}
			}
		}
	}
}

void Radar_DrawPlayers(int x, int y, int width, int height, float scale,
	float show_height, float show_powerups,
	float player_size, float show_names,
	float fade_players, float highlight,
	char *highlight_color, float text_scale, qbool team_colours_for_name, qbool proportional)
{
	int i;
	player_state_t *state;
	player_info_t *info;

	// Get player state so we can know where he is (or on rare occassions, she).
	state = cl.frames[cl.parsecount & UPDATE_MASK].playerstate;

	// Get the info for the player.
	info = cl.players;

	//
	// Draw the players.
	//
	for (i = 0; i < MAX_CLIENTS; i++, info++, state++)
	{
		// Players quake coordinates
		// (these are multiplied by 8, since the conversion formula was
		// calculated using the coordinates in a .loc-file, which are in
		// the format quake-coordainte*8).
		int player_q_x = 0;
		int player_q_y = 0;

		// The height of the player.
		float player_z = 1.0;
		float player_z_relative = 1.0;

		// Players pixel coordinates.
		int player_p_x = 0;
		int player_p_y = 0;

		// Used for drawing the the direction the
		// player is looking at.
		float player_angle = 0;
		int x_line_start = 0;
		int y_line_start = 0;
		int x_line_end = 0;
		int y_line_end = 0;

		// Color and opacity of the player.
		int player_color = 0;
		float player_alpha = 1.0;
		qbool player_cross = false;
		float player_outline = 1.0f;
		qbool has_weapon = false;

		// Make sure we're not drawing any ghosts.
		if(!info->name[0])
		{
			continue;
		}

		if (state->messagenum == cl.parsecount)
		{
			// TODO: Implement lerping to get smoother drawing.

			// Get the quake coordinates. Multiply by 8 since
			// the conversion formula has been calculated using
			// a .loc-file which is in that format.
			player_q_x = state->origin[0]*8;
			player_q_y = state->origin[1]*8;

			// Get the players view angle.
			player_angle = cls.demoplayback ? state->viewangles[1] : cl.simangles[1];

			// Convert from quake coordiantes -> pixel coordinates.
			player_p_x = Q_rint((map_x_slope*player_q_x + map_x_intercept) * scale);
			player_p_y = Q_rint((map_y_slope*player_q_y + map_y_intercept) * scale);

			player_color = Sbar_BottomColor(info);

			has_weapon = (info->stats[STAT_ITEMS] & (IT_ROCKET_LAUNCHER | IT_LIGHTNING));

			// Calculate the height of the player.
			if(show_height)
			{
				player_z = state->origin[2];
				player_z += (player_z >= 0) ? fabs(cl.worldmodel->mins[2]) : fabs(cl.worldmodel->maxs[2]);
				player_z_relative = min(fabs(player_z / map_height_diff), 1.0);
				player_z_relative = max(player_z_relative, 0.2);
			}

			// Make the players fade out as they get less armor/health.
			if (fade_players == 1 || fade_players == 3) {
				int stack = bound(0, SCR_HUD_TotalStrength(info->stats[STAT_HEALTH], info->stats[STAT_ARMOR], SCR_HUD_ArmorType(info->stats[STAT_ITEMS])), 220);

				// Don't let the players get completly transparent so add 0.2 to the final value.
				player_alpha = bound(0, 0.3f + (stack / 315.0f), 1.0f);
			}
			else if (fade_players == 2) {
				// Players are faded if they don't have weapon
				player_alpha = has_weapon ? 1.0f : 0.3f;
			}

			// Turn dead people into crosses.
			if (info->stats[STAT_HEALTH] <= 0) {
				player_alpha = 1.0;
				player_cross = true;
			}

			if (fade_players == 1 && has_weapon) {
				player_outline = 2.5f;
			}
			else if (fade_players == 2) {
				float armorType = SCR_HUD_ArmorType(info->stats[STAT_ITEMS]);
				int stack = bound(0, SCR_HUD_TotalStrength(info->stats[STAT_HEALTH], info->stats[STAT_ARMOR], armorType), 360);

				player_outline = stack < 80 ? 0.0f : stack < 110 ? 1.0f : stack < 200 ? 2.0f : stack < 300 ? 3.0f : 4.0f;
			}

			// Draw a ring around players with powerups if it's enabled.
			if (show_powerups) {
				if (info->stats[STAT_ITEMS] & IT_INVISIBILITY) {
					Draw_AlphaCircleFill (x + player_p_x, y + player_p_y, player_size*2*player_z_relative, 161, 0.2);
				}

				if (info->stats[STAT_ITEMS] & IT_INVULNERABILITY) {
					Draw_AlphaCircleFill (x + player_p_x, y + player_p_y, player_size*2*player_z_relative, 79, 0.5);
				}

				if (info->stats[STAT_ITEMS] & IT_QUAD) {
					Draw_AlphaCircleFill (x + player_p_x, y + player_p_y, player_size*2*player_z_relative, 244, 0.2);
				}
			}

			// Draw a circle around the tracked player.
			if (highlight != HUD_RADAR_HIGHLIGHT_NONE && Cam_TrackNum() >= 0 && info->userid == cl.players[Cam_TrackNum()].userid)
			{
				color_t higlight_color = RGBAVECT_TO_COLOR(hud_radar_highlight_color);

				// Draw the highlight.
				switch ((int)highlight)
				{
				case HUD_RADAR_HIGHLIGHT_CROSS_CORNERS :
				{
					// Top left
					Draw_AlphaLineRGB (x, y, x + player_p_x, y + player_p_y, 2, higlight_color);

					// Top right.
					Draw_AlphaLineRGB (x + width, y, x + player_p_x, y + player_p_y, 2, higlight_color);

					// Bottom left.
					Draw_AlphaLineRGB (x, y + height, x + player_p_x, y + player_p_y, 2, higlight_color);

					// Bottom right.
					Draw_AlphaLineRGB (x + width, y + height, x + player_p_x, y + player_p_y, 2, higlight_color);
					break;
				}
				case HUD_RADAR_HIGHLIGHT_ARROW_TOP :
				{
					// Top center.
					Draw_AlphaLineRGB (x + width / 2, y, x + player_p_x, y + player_p_y, 2, higlight_color);
					break;
				}
				case HUD_RADAR_HIGHLIGHT_ARROW_CENTER :
				{
					// Center.
					Draw_AlphaLineRGB (x + width / 2, y + height / 2, x + player_p_x, y + player_p_y, 2, higlight_color);
					break;
				}
				case HUD_RADAR_HIGHLIGHT_ARROW_BOTTOM :
				{
					// Bottom center.
					Draw_AlphaLineRGB (x + width / 2, y + height, x + player_p_x, y + player_p_y, 2, higlight_color);
					break;
				}
				case HUD_RADAR_HIGHLIGHT_FIXED_CIRCLE :
				{
					Draw_AlphaCircleRGB (x + player_p_x, y + player_p_y, player_size * 1.5, 1.0, true, higlight_color);
					break;
				}
				case HUD_RADAR_HIGHLIGHT_CIRCLE :
				{
					Draw_AlphaCircleRGB (x + player_p_x, y + player_p_y, player_size * player_z_relative * 2.0, 1.0, true, higlight_color);
					break;
				}
				case HUD_RADAR_HIGHLIGHT_FIXED_OUTLINE :
				{
					Draw_AlphaCircleOutlineRGB (x + player_p_x, y + player_p_y, player_size * 1.5, 1.0, higlight_color);
					break;
				}
				case HUD_RADAR_HIGHLIGHT_OUTLINE :
				{
					Draw_AlphaCircleOutlineRGB (x + player_p_x, y + player_p_y, player_size * player_z_relative * 2.0, 1.0, higlight_color);
					break;
				}
				case HUD_RADAR_HIGHLIGHT_TEXT_ONLY :
				default :
				{
					break;
				}
				}
			}

			// Draw the actual player and a line showing what direction the player is looking in.
			if (!player_cross) {
				float lhs_angle = DEG2RAD(player_angle - 45);
				float rhs_angle = DEG2RAD(player_angle + 45);

				qbool highlight_player = highlight == HUD_RADAR_HIGHLIGHT_BRIGHT_VIEW && Cam_TrackNum() >= 0 && info->userid == cl.players[Cam_TrackNum()].userid;

				x_line_start = x + player_p_x;
				y_line_start = y + player_p_y;

				Draw_AlphaPieSlice(x_line_start, y_line_start, player_size * 2 * player_z_relative + 1, lhs_angle, rhs_angle, 1.0f, true, 15, highlight_player ? 0.4f : 0.1f);

				// Draw the player on the map.
				Draw_AlphaCircleFill(x + player_p_x, y + player_p_y, player_size * player_z_relative + player_outline, 0, 1.0f);
				Draw_AlphaCircleFill(x + player_p_x, y + player_p_y, player_size * player_z_relative, player_color, 1.0f);
				Draw_AlphaCircleFill(x + player_p_x, y + player_p_y, player_size * player_z_relative, 0, 1.0f - player_alpha);

				if (fade_players == 3 && has_weapon) {
					Draw_AlphaCircleFill(x + player_p_x, y + player_p_y, player_size * player_z_relative * 0.5f, 0, 1.0f);
				}
			}
			else {
				float size = (player_size * player_z_relative);

				x_line_start = x + player_p_x - size;
				y_line_start = y + player_p_y - size;

				x_line_end = x_line_start + 2 * size;
				y_line_end = y_line_start + 2 * size;

				Draw_AlphaLine(x_line_start, y_line_start, x_line_end, y_line_end, 3.0, player_color, player_alpha);
				Draw_AlphaLine(x_line_start, y_line_end, x_line_end, y_line_start, 3.0, player_color, player_alpha);
			}

			// Draw the players name.
			if (show_names)
			{
				int name_x = 0;
				int name_y = 0;
				int text_length = Draw_StringLength(info->name, -1, text_scale, proportional);

				name_x = x + player_p_x;
				name_y = y + player_p_y;

				// Make sure we're not too far right.
				if (name_x + text_length > x + width) {
					name_x -= (name_x + text_length - (x + width));
				}

				// Make sure we're not outside the radar to the left.
				name_x = max(name_x, x);

				// Draw the name.
				if (highlight >= HUD_RADAR_HIGHLIGHT_TEXT_ONLY && info->userid == cl.players[Cam_TrackNum()].userid) {
					char buffer[MAX_SCOREBOARDNAME + 8];

					snprintf(buffer, sizeof(buffer), "&c%x%x%x%s",
						(unsigned int)(hud_radar_highlight_color[0] / 16),
						(unsigned int)(hud_radar_highlight_color[1] / 16),
						(unsigned int)(hud_radar_highlight_color[2] / 16),
						info->name
					);

					// Draw the tracked players name in the user specified color.
					Draw_SColoredStringBasic(name_x, name_y, buffer, 0, text_scale, proportional);
				}
				else if (team_colours_for_name) {
					char buffer[MAX_SCOREBOARDNAME + 8];

					byte red = host_basepal[player_color * 3];
					byte green = host_basepal[player_color * 3 + 1];
					byte blue = host_basepal[player_color * 3 + 2];

					snprintf(buffer, sizeof(buffer), "&c%x%x%x%s",
						(unsigned int)(red / 16),
						(unsigned int)(green / 16),
						(unsigned int)(blue / 16),
						info->name
					);

					// Draw the tracked players name in the user specified color.
					Draw_SColoredStringBasic(name_x, name_y, buffer, 0, text_scale, proportional);
				}
				else {
					// Draw other players in normal character color.
					Draw_SString (name_x, name_y, info->name, text_scale, proportional);
				}
			}

			// Show if a person lost an RL-pack.
			if (info->stats[STAT_HEALTH] <= 0 && info->stats[STAT_ACTIVEWEAPON] == IT_ROCKET_LAUNCHER)
			{
				Draw_AlphaCircleOutline (x + player_p_x, y + player_p_y, player_size*player_z_relative*2, 1.0, 254, player_alpha);
				Draw_SColoredStringBasic (x + player_p_x, y + player_p_y, va("&cf00PACK!"), 1, text_scale, proportional);
			}
		}
	}
}

//
// Draws a map of the current level and plots player movements on it.
//
void SCR_HUD_DrawRadar(hud_t *hud)
{
	int width, height, x, y;
	float width_limit, height_limit;
	float scale;
	float x_scale;
	float y_scale;

	static cvar_t
		*hud_radar_opacity = NULL,
		*hud_radar_width,
		*hud_radar_height,
		*hud_radar_autosize,
		*hud_radar_fade_players,
		*hud_radar_show_powerups,
		*hud_radar_show_names,
		*hud_radar_highlight,
		*hud_radar_highlight_color,
		*hud_radar_player_size,
		*hud_radar_show_height,
		*hud_radar_show_stats,
		*hud_radar_show_hold,
		*hud_radar_weaponfilter,
		*hud_radar_itemfilter,
		*hud_radar_onlytp,
		*hud_radar_otherfilter,
		*hud_radar_scale,
		*hud_radar_simple,
		*hud_radar_colour_names,
		*hud_radar_proportional;

	if (hud_radar_opacity == NULL)    // first time
	{
		char checkval[256];

		hud_radar_opacity			= HUD_FindVar(hud, "opacity");
		hud_radar_width				= HUD_FindVar(hud, "width");
		hud_radar_height			= HUD_FindVar(hud, "height");
		hud_radar_autosize			= HUD_FindVar(hud, "autosize");
		hud_radar_fade_players		= HUD_FindVar(hud, "fade_players");
		hud_radar_show_powerups		= HUD_FindVar(hud, "show_powerups");
		hud_radar_show_names		= HUD_FindVar(hud, "show_names");
		hud_radar_player_size		= HUD_FindVar(hud, "player_size");
		hud_radar_show_height		= HUD_FindVar(hud, "show_height");
		hud_radar_show_stats		= HUD_FindVar(hud, "show_stats");
		hud_radar_show_hold			= HUD_FindVar(hud, "show_hold");
		hud_radar_weaponfilter		= HUD_FindVar(hud, "weaponfilter");
		hud_radar_itemfilter		= HUD_FindVar(hud, "itemfilter");
		hud_radar_otherfilter		= HUD_FindVar(hud, "otherfilter");
		hud_radar_onlytp			= HUD_FindVar(hud, "onlytp");
		hud_radar_highlight			= HUD_FindVar(hud, "highlight");
		hud_radar_highlight_color	= HUD_FindVar(hud, "highlight_color");
		hud_radar_scale             = HUD_FindVar(hud, "scale");
		hud_radar_simple            = HUD_FindVar(hud, "simpleitems");
		hud_radar_colour_names      = HUD_FindVar(hud, "colornames");
		hud_radar_proportional      = HUD_FindVar(hud, "proportional");

		//
		// Only parse the the filters when they change, not on each frame.
		//

		// Weapon filter.
		hud_radar_weaponfilter->OnChange = Radar_OnChangeWeaponFilter;
		strlcpy(checkval, hud_radar_weaponfilter->string, sizeof(checkval));
		Cvar_Set(hud_radar_weaponfilter, checkval);

		// Item filter.
		hud_radar_itemfilter->OnChange = Radar_OnChangeItemFilter;
		strlcpy(checkval, hud_radar_itemfilter->string, sizeof(checkval));
		Cvar_Set(hud_radar_itemfilter, checkval);

		// Other filter.
		hud_radar_otherfilter->OnChange = Radar_OnChangeOtherFilter;
		strlcpy(checkval, hud_radar_otherfilter->string, sizeof(checkval));
		Cvar_Set(hud_radar_otherfilter, checkval);

		// Highlight color.
		hud_radar_highlight_color->OnChange = Radar_OnChangeHighlightColor;
		strlcpy(checkval, hud_radar_highlight_color->string, sizeof(checkval));
		Cvar_Set(hud_radar_highlight_color, checkval);
	}

	// Don't show anything if it's a normal player.
	if(!(cls.demoplayback || cl.spectator))
	{
		HUD_PrepareDraw(hud, hud_radar_width->value, hud_radar_height->value, &x, &y);
		return;
	}

	// Don't show when not in teamplay/demoplayback.
	if(!HUD_ShowInDemoplayback(hud_radar_onlytp->value))
	{
		HUD_PrepareDraw(hud, hud_radar_width->value, hud_radar_height->value, &x, &y);
		return;
	}

	// Save the width and height of the HUD. We're using these because
	// if autosize is on these will be altered and we don't want to change
	// the settings that the user set, if we try, and the user turns off
	// autosize again the size of the HUD will remain "autosized" until the user
	// resets it by hand again.
	width_limit = hud_radar_width->value;
	height_limit = hud_radar_height->value;

	// we support also sizes specified as a percentage of total screen width/height
	if (strchr(hud_radar_width->string, '%')) {
		width_limit = width_limit * vid.conwidth / 100.0;
	}
	if (strchr(hud_radar_height->string, '%')) {
		height_limit = hud_radar_height->value * vid.conheight / 100.0;
	}

	// This map doesn't have a map pic.
	if (!radar_pic_found) {
		if (HUD_PrepareDraw(hud, Q_rint(width_limit), Q_rint(height_limit), &x, &y)) {
			Draw_SString(x, y, "No radar picture found!", hud_radar_scale->value, hud_radar_proportional->integer);
		}
		return;
	}

	// Make sure we can translate the coordinates.
	if (!conversion_formula_found) {
		if (HUD_PrepareDraw(hud, Q_rint(width_limit), Q_rint(height_limit), &x, &y)) {
			Draw_SString(x, y, "No conversion formula found!", hud_radar_scale->value, hud_radar_proportional->integer);
		}
		return;
	}

	x = 0;
	y = 0;

	scale = 1;

	if (hud_radar_autosize->value) {
		//
		// Autosize the hud element based on the size of the radar picture.
		//

		width = width_limit = radar_pic.width;
		height = height_limit = radar_pic.height;
	}
	else {
		//
		// Size the picture so that it fits inside the hud element.
		//

		// Set the scaling based on the picture dimensions.
		x_scale = (width_limit / radar_pic.width);
		y_scale = (height_limit / radar_pic.height);

		scale = (x_scale < y_scale) ? x_scale : y_scale;

		width = radar_pic.width * scale;
		height = radar_pic.height * scale;
	}

	if (HUD_PrepareDraw(hud, Q_rint(width_limit), Q_rint(height_limit), &x, &y)) {
		float player_size = 1.0;
		static int lastframecount = -1;

		// Place the map picture in the center of the HUD element.
		x += Q_rint((width_limit / 2.0) - (width / 2.0));
		x = max(0, x);
		x = min(x + width, x);

		y += Q_rint((height_limit / 2.0) - (height / 2.0));
		y = max(0, y);
		y = min(y + height, y);

		// Draw the radar background.
		Draw_SAlphaPic(x, y, &radar_pic, hud_radar_opacity->value, scale);

		// Only draw once per frame.
		if (cls.framecount == lastframecount) {
			return;
		}
		lastframecount = cls.framecount;

		if (!cl.oldparsecount || !cl.parsecount || cls.state < ca_active) {
			return;
		}

		// Scale the player size after the size of the radar.
		player_size = hud_radar_player_size->value * scale;

		// Draw team stats.
		if (hud_radar_show_stats->value) {
			Radar_DrawGrid(stats_grid, x, y, scale, width, height, hud_radar_show_stats->value);
		}

		// Draw entities such as powerups, weapons and backpacks.
		if (RADAR_SHOW_WEAPONS || RADAR_SHOW_ITEMS || RADAR_SHOW_OTHER) {
			Radar_DrawEntities(
				x, y, scale, player_size,
				hud_radar_show_hold->value, hud_radar_scale->value, hud_radar_simple->value, hud_radar_proportional->integer
			);
		}

		// Draw the players.
		Radar_DrawPlayers(
			x, y, width, height, scale,
			hud_radar_show_height->value,
			hud_radar_show_powerups->value,
			player_size,
			hud_radar_show_names->value,
			hud_radar_fade_players->value,
			hud_radar_highlight->value,
			hud_radar_highlight_color->string,
			hud_radar_scale->value,
			hud_radar_colour_names->integer,
			hud_radar_proportional->integer
		);
	}
}

#endif // WITH_PNG

void Radar_HudInit(void)
{
#ifdef WITH_PNG
	HUD_Register("radar", NULL, "Plots the players on a picture of the map. (Only when watching MVD's or QTV).",
		HUD_PLUSMINUS, ca_active, 0, SCR_HUD_DrawRadar,
		"0", "top", "left", "bottom", "0", "0", "0", "0 0 0", NULL,
		"opacity", "0.5",
		"width", "30%",
		"height", "25%",
		"autosize", "0",
		"show_powerups", "1",
		"show_names", "0",
		"highlight_color", "yellow",
		"highlight", "0",
		"player_size", "10",
		"show_height", "1",
		"show_stats", "1",
		"fade_players", "1",
		"show_hold", "0",
		"weaponfilter", "gl rl lg",
		"itemfilter", "backpack quad pent armor mega",
		"otherfilter", "projectiles gibs explosions shotgun",
		"onlytp", "0",
		"scale", "1",
		"simpleitems", "1",
		"colornames", "0",
		"proportional", "0",
		NULL);
#endif
}



================================================
FILE: src/hud_scores.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"
#include "hud_common.h"
#include "teamplay.h"
#include "Ctrl.h"
#include "vx_stuff.h"
#include "mvd_utils_common.h"
#include "sbar.h"

qbool TP_ReadMacroFormat(char* s, int* fixed_width, int* alignment, char** new_s);
char* TP_AlignMacroText(char* text, int fixed_width, int alignment);

static cvar_t hud_sortrules_teamsort = { "hud_sortrules_teamsort", "0" };
static cvar_t hud_sortrules_playersort = { "hud_sortrules_playersort", "1" };
static cvar_t hud_sortrules_includeself = { "hud_sortrules_includeself", "1" };

static int playersort_rules;
static int teamsort_rules;

static int HUD_ComparePlayers(const void *vp1, const void *vp2)
{
	const sort_players_info_t *p1 = vp1;
	const sort_players_info_t *p2 = vp2;

	int r = 0;
	player_info_t *i1 = &cl.players[p1->playernum];
	player_info_t *i2 = &cl.players[p2->playernum];

	if (i1->spectator && !i2->spectator) {
		r = -1;
	}
	else if (!i1->spectator && i2->spectator) {
		r = 1;
	}
	else if (i1->spectator && i2->spectator) {
		r = Q_strcmp2(i1->name, i2->name);
	}
	else {
		//
		// Both are players.
		//
		if ((playersort_rules & 2) && cl.teamplay && p1->team && p2->team) {
			// Leading team on top, sort players inside of the teams.

			// Teamsort 1, first sort on team frags.
			if (teamsort_rules == 1) {
				r = p1->team->frags - p2->team->frags;
			}

			// sort on team name only.
			r = (r == 0) ? -Q_strcmp2(p1->team->name, p2->team->name) : r;
		}

		if (playersort_rules & 1) {
			r = (r == 0) ? i1->frags - i2->frags : r;
		}
		r = (r == 0) ? -Q_strcmp2(i1->name, i2->name) : r;
	}

	r = (r == 0) ? (p1->playernum - p2->playernum) : r;

	// qsort() sorts ascending by default, we want descending.
	// So negate the result.
	return -r;
}

static int HUD_CompareTeams(const void *vt1, const void *vt2)
{
	int r = 0;
	const sort_teams_info_t *t1 = vt1;
	const sort_teams_info_t *t2 = vt2;

	if (hud_sortrules_teamsort.integer == 1) {
		r = (t1->frags - t2->frags);
	}
	r = !r ? -Q_strcmp2(t1->name, t2->name) : r;

	// qsort() sorts ascending by default, we want descending.
	// So negate the result.
	return -r;
}

void HUD_Sort_Scoreboard(int flags)
{
	int i;
	int team;
	int active_player = -1;
	qbool common_fragcounts = cl.teamfortress && cl.teamplay && cl.scoring_system == SCORING_SYSTEM_DEFAULT;

	active_player_position = -1;
	active_team_position = -1;

	n_teams = 0;
	n_players = 0;
	n_spectators = 0;

	playersort_rules = hud_sortrules_playersort.integer;
	teamsort_rules = hud_sortrules_teamsort.integer;

	// This taken from score_bar logic
	if (cls.demoplayback && !cl.spectator && !cls.mvdplayback) {
		active_player = cl.playernum;
	}
	else if ((cls.demoplayback || cl.spectator) && Cam_TrackNum() >= 0) {
		active_player = cl.spec_track;
	}
	else {
		active_player = cl.playernum;
	}

	// Set team properties.
	if (flags & HUD_SCOREBOARD_UPDATE) {
		memset(sorted_teams, 0, sizeof(sorted_teams));

		for (i = 0; i < MAX_CLIENTS; i++) {
			if (cl.players[i].name[0] && !cl.players[i].spectator) {
				if (cl.players[i].frags == 0 && cl.players[i].team[0] == '\0' && !strcmp(cl.players[i].name, "[ServeMe]")) {
					continue;
				}

				// Find players team
				for (team = 0; team < n_teams; team++) {
					if (cl.teamplay && !strcmp(cl.players[i].team, sorted_teams[team].name) && sorted_teams[team].name[0]) {
						break;
					}
					if (!cl.teamplay && !strcmp(cl.players[i].name, sorted_teams[team].name) && sorted_teams[team].name[0]) {
						break;
					}
				}

				// The team wasn't found in the list of existing teams
				// so add a new team.
				if (team == n_teams) {
					team = n_teams++;
					sorted_teams[team].min_ping = 999;
					sorted_teams[team].top = Sbar_TopColor(&cl.players[i]);
					sorted_teams[team].bottom = Sbar_BottomColor(&cl.players[i]);
					if (cl.teamplay) {
						sorted_teams[team].name = cl.players[i].team;
					}
					else {
						sorted_teams[team].name = cl.players[i].name;
					}
				}

				if (sorted_teams[team].nplayers >= 1) {
					common_fragcounts &= (sorted_teams[team].frags / sorted_teams[team].nplayers == cl.players[i].frags);
				}

				sorted_teams[team].nplayers++;
				if (cl.scoring_system == SCORING_SYSTEM_TEAMFRAGS) {
					if (sorted_teams[team].nplayers == 1) {
						sorted_teams[team].frags = cl.players[i].frags;
					}
					else {
						sorted_teams[team].frags = max(cl.players[i].frags, sorted_teams[team].frags);
					}
				}
				else {
					sorted_teams[team].frags += cl.players[i].frags;
				}
				sorted_teams[team].avg_ping += cl.players[i].ping;
				sorted_teams[team].min_ping = min(sorted_teams[team].min_ping, cl.players[i].ping);
				sorted_teams[team].max_ping = max(sorted_teams[team].max_ping, cl.players[i].ping);
				sorted_teams[team].stack += SCR_HUD_TotalStrength(cl.players[i].stats[STAT_HEALTH], cl.players[i].stats[STAT_ARMOR], SCR_HUD_ArmorType(cl.players[i].stats[STAT_ITEMS]));

				// The total RL count for the players team.
				if (cl.players[i].stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER) {
					sorted_teams[team].rlcount++;
				}
				if (cl.players[i].stats[STAT_ITEMS] & IT_LIGHTNING) {
					sorted_teams[team].lgcount++;
				}
				if (cl.players[i].stats[STAT_ITEMS] & (IT_ROCKET_LAUNCHER | IT_LIGHTNING)) {
					sorted_teams[team].weapcount++;
				}

				if (cls.mvdplayback) {
					mvd_new_info_t* stats = MVD_StatsForPlayer(&cl.players[i]);
					sort_teams_info_t* t = &sorted_teams[team];

					if (stats) {
						t->quads_taken += stats->mvdinfo.itemstats[QUAD_INFO].count;
						t->pents_taken += stats->mvdinfo.itemstats[PENT_INFO].count;
						t->rings_taken += stats->mvdinfo.itemstats[RING_INFO].count;
						t->ga_taken += stats->mvdinfo.itemstats[GA_INFO].count;
						t->ya_taken += stats->mvdinfo.itemstats[YA_INFO].count;
						t->ra_taken += stats->mvdinfo.itemstats[RA_INFO].count;
						t->mh_taken += stats->mvdinfo.itemstats[MH_INFO].count;
						t->q_lasttime = max(t->q_lasttime, stats->mvdinfo.itemstats[QUAD_INFO].starttime);
						t->p_lasttime = max(t->p_lasttime, stats->mvdinfo.itemstats[PENT_INFO].starttime);
						t->r_lasttime = max(t->r_lasttime, stats->mvdinfo.itemstats[RING_INFO].starttime);
						t->ga_lasttime = max(t->ga_lasttime, stats->mvdinfo.itemstats[GA_INFO].starttime);
						t->ya_lasttime = max(t->ya_lasttime, stats->mvdinfo.itemstats[YA_INFO].starttime);
						t->ra_lasttime = max(t->ra_lasttime, stats->mvdinfo.itemstats[RA_INFO].starttime);
						t->mh_lasttime = max(t->mh_lasttime, stats->mvdinfo.itemstats[MH_INFO].starttime);
					}
				}

				// Set player data.
				sorted_players[n_players + n_spectators].playernum = i;
				if (i == active_player && !cl.players[i].spectator) {
					active_player_position = n_players + n_spectators;
				}

				// Increase the count.
				if (cl.players[i].spectator) {
					n_spectators++;
				}
				else {
					n_players++;
				}
			}
		}
	}

	// Calc avg ping.
	if (flags & HUD_SCOREBOARD_AVG_PING) {
		for (team = 0; team < n_teams; team++) {
			sorted_teams[team].avg_ping /= sorted_teams[team].nplayers;
		}
	}

	// Adjust team scores for team fortress scoring (required so it matches +showteamscores)
	if (cl.teamfortress && common_fragcounts) {
		for (team = 0; team < n_teams; ++team) {
			if (sorted_teams[team].nplayers) {
				sorted_teams[team].frags /= sorted_teams[team].nplayers;
			}
		}
	}

	// Sort teams.
	if (flags & HUD_SCOREBOARD_SORT_TEAMS) {
		active_team_position = -1;

		qsort(sorted_teams, n_teams, sizeof(sort_teams_info_t), HUD_CompareTeams);

		// if set, need to make sure that the player's team is first or second position
		if (hud_sortrules_includeself.integer && active_player_position >= 0) {
			player_info_t *player = &cl.players[sorted_players[active_player_position].playernum];
			sorted_players[active_player_position].team = NULL;

			// Find players team.
			for (team = 0; team < n_teams; team++) {
				const char* team_name = (cl.teamplay ? player->team : player->name);
				if (!strcmp(team_name, sorted_teams[team].name) && sorted_teams[team].name[0]) {
					if (hud_sortrules_includeself.integer == 1 && team > 0) {
						sort_teams_info_t temp = sorted_teams[0];
						sorted_teams[0] = sorted_teams[team];
						sorted_teams[team] = temp;
					}
					else if (hud_sortrules_includeself.integer == 2 && team > 1) {
						sort_teams_info_t temp = sorted_teams[1];
						sorted_teams[1] = sorted_teams[team];
						sorted_teams[team] = temp;
					}
					break;
				}
			}
		}

		// BUGFIX, this needs to happen AFTER the team array has been sorted, otherwise the
		// players might be pointing to the incorrect team address.
		for (i = 0; i < MAX_CLIENTS; i++) {
			player_info_t *player = &cl.players[sorted_players[i].playernum];
			sorted_players[i].team = NULL;

			// Find players team.
			for (team = 0; team < n_teams; team++) {
				if (!strcmp(player->team, sorted_teams[team].name) && sorted_teams[team].name[0]) {
					sorted_players[i].team = &sorted_teams[team];
					if (sorted_players[i].playernum == active_player) {
						active_team_position = team;
					}
					break;
				}
			}
		}
	}

	// Sort players by frags only
	if (flags & HUD_SCOREBOARD_SORT_PLAYERS) {
		int oldrules = playersort_rules;

		playersort_rules = 1;
		qsort(sorted_players, n_players + n_spectators, sizeof(sort_players_info_t), HUD_ComparePlayers);
		playersort_rules = oldrules;

		memcpy(sorted_players_by_frags, sorted_players, sizeof(sorted_players_by_frags));
	}

	// Sort players.
	if (flags & HUD_SCOREBOARD_SORT_PLAYERS) {
		qsort(sorted_players, n_players + n_spectators, sizeof(sort_players_info_t), HUD_ComparePlayers);

		if (!cl.teamplay) {
			// Re-find player
			active_player_position = -1;
			for (i = 0; i < n_players + n_spectators; ++i) {
				if (sorted_players[i].playernum == active_player) {
					active_player_position = i;
					if (hud_sortrules_includeself.integer == 1 && i > 0) {
						sort_players_info_t temp = sorted_players[0];
						sorted_players[0] = sorted_players[i];
						sorted_players[i] = temp;
						active_player_position = 0;
					}
					else if (hud_sortrules_includeself.integer == 2 && i > 1) {
						sort_players_info_t temp = sorted_players[1];
						sorted_players[1] = sorted_players[i];
						sorted_players[i] = temp;
						active_player_position = 1;
					}
				}
			}
		}
	}
}

static qbool SCR_Hud_GetScores(int* team, int* enemy, char** teamName, char** enemyName)
{
	qbool swap = false;

	*team = *enemy = 0;
	*teamName = *enemyName = NULL;

	if (cl.teamplay) {
		*team = sorted_teams[0].frags;
		*teamName = sorted_teams[0].name;

		if (n_teams > 1) {
			if (hud_sortrules_includeself.integer >= 1 && active_team_position > 1) {
				*enemy = sorted_teams[active_team_position].frags;
				*enemyName = sorted_teams[active_team_position].name;
			}
			else {
				*enemy = sorted_teams[1].frags;
				*enemyName = sorted_teams[1].name;
			}

			swap = (hud_sortrules_includeself.integer == 1 && active_team_position > 0);
		}
	}
	else if (cl.deathmatch) {
		*team = cl.players[sorted_players[0].playernum].frags;
		*teamName = cl.players[sorted_players[0].playernum].name;

		if (n_players > 1) {
			if (hud_sortrules_includeself.integer >= 1 && active_player_position > 1) {
				*enemy = cl.players[sorted_players[active_player_position].playernum].frags;
				*enemyName = cl.players[sorted_players[active_player_position].playernum].name;
			}
			else {
				*enemy = cl.players[sorted_players[1].playernum].frags;
				*enemyName = cl.players[sorted_players[1].playernum].name;
			}

			swap = (hud_sortrules_includeself.integer == 1 && active_player_position > 0);
		}
	}

	if (!*teamName) {
		*teamName = "T";
	}
	if (!*enemyName) {
		*enemyName = "E";
	}

	if (swap) {
		int temp_frags = *team;
		char* temp_name = *teamName;

		*team = *enemy;
		*teamName = *enemyName;
		*enemy = temp_frags;
		*enemyName = temp_name;
	}

	return swap;
}

//
// TODO: decide what to do in freefly mode (and how to catch it?!), now all score_* hud elements just draws "0"
//
static void SCR_HUD_DrawScoresTeam(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *colorize, *proportional;
	int teamFrags = 0, enemyFrags = 0;
	char* teamName = 0, *enemyName = 0;

	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		colorize = HUD_FindVar(hud, "colorize");
		proportional = HUD_FindVar(hud, "proportional");
	}

	SCR_Hud_GetScores(&teamFrags, &enemyFrags, &teamName, &enemyName);

	SCR_HUD_DrawNum(hud, teamFrags, (colorize->integer) ? (teamFrags < 0 || colorize->integer > 1) : false, scale->value, style->value, digits->value, align->string, proportional->integer);
}

static void SCR_HUD_DrawScoresEnemy(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *colorize, *proportional;
	int teamFrags = 0, enemyFrags = 0;
	char* teamName = 0, *enemyName = 0;

	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		colorize = HUD_FindVar(hud, "colorize");
		proportional = HUD_FindVar(hud, "proportional");
	}

	SCR_Hud_GetScores(&teamFrags, &enemyFrags, &teamName, &enemyName);

	if (!cl.teamplay) {
		// Ignore enemyFrags now, and go by highest opponent that isn't current player
		if (n_players > 1) {
			if (!strcmp(cl.players[sorted_players_by_frags[0].playernum].name, teamName)) {
				enemyFrags = cl.players[sorted_players_by_frags[1].playernum].frags;
				enemyName = cl.players[sorted_players_by_frags[1].playernum].name;
			}
			else {
				enemyFrags = cl.players[sorted_players_by_frags[0].playernum].frags;
				enemyName = cl.players[sorted_players_by_frags[0].playernum].name;
			}
		}
	}

	SCR_HUD_DrawNum(hud, enemyFrags, (colorize->integer) ? (enemyFrags < 0 || colorize->integer > 1) : false, scale->value, style->value, digits->value, align->string, proportional->integer);
}

static void SCR_HUD_DrawScoresDifference(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *colorize, *proportional;
	int teamFrags = 0, enemyFrags = 0;
	char* teamName = 0, *enemyName = 0;

	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		colorize = HUD_FindVar(hud, "colorize");
		proportional = HUD_FindVar(hud, "proportional");
	}

	SCR_Hud_GetScores(&teamFrags, &enemyFrags, &teamName, &enemyName);

	if (!cl.teamplay) {
		// Ignore enemyFrags now, and go by highest opponent that isn't current player
		if (n_players > 1) {
			if (!strcmp(cl.players[sorted_players_by_frags[0].playernum].name, teamName)) {
				enemyFrags = cl.players[sorted_players_by_frags[1].playernum].frags;
				enemyName = cl.players[sorted_players_by_frags[1].playernum].name;
			}
			else {
				enemyFrags = cl.players[sorted_players_by_frags[0].playernum].frags;
				enemyName = cl.players[sorted_players_by_frags[0].playernum].name;
			}
		}
	}

	SCR_HUD_DrawNum(hud, teamFrags - enemyFrags, (colorize->integer) ? ((teamFrags - enemyFrags) < 0 || colorize->integer > 1) : false, scale->value, style->value, digits->value, align->string, proportional->integer);
}

static void SCR_HUD_DrawScoresPosition(hud_t *hud)
{
	static cvar_t *scale = NULL, *style, *digits, *align, *colorize, *proportional;
	int teamFrags = 0, enemyFrags = 0, position = 0, i = 0;
	char* teamName = 0, *enemyName = 0;

	if (scale == NULL) {
		// first time called
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		digits = HUD_FindVar(hud, "digits");
		align = HUD_FindVar(hud, "align");
		colorize = HUD_FindVar(hud, "colorize");
		proportional = HUD_FindVar(hud, "proportional");
	}

	SCR_Hud_GetScores(&teamFrags, &enemyFrags, &teamName, &enemyName);

	position = 1;
	if (cl.teamplay) {
		for (i = 0; i < n_teams; ++i) {
			if (sorted_teams[i].frags > teamFrags) {
				++position;
			}
		}
	}
	else {
		for (i = 0; i < n_players + n_spectators; ++i) {
			if (cl.players[sorted_players[i].playernum].frags > teamFrags) {
				++position;
			}
		}
	}

	SCR_HUD_DrawNum(hud, position, (colorize->integer) ? (position != 1 || colorize->integer > 1) : false, scale->value, style->value, digits->value, align->string, proportional->integer);
}

/*
	ezQuake's analogue of +scores of KTX
	( t:x e:x [x] )
*/
static void SCR_HUD_DrawScoresBar(hud_t *hud)
{
	static	cvar_t *scale = NULL, *style, *format_big, *format_small, *frag_length, *reversed_big, *reversed_small, *proportional;
	int		width = 0, height = 0, x, y;
	int		i = 0;

	int		s_team = 0, s_enemy = 0, s_difference = 0;
	char	*n_team = "T", *n_enemy = "E";
	qbool   swappedOrder = false;

	char	buf[MAX_MACRO_STRING];
	char	c, *out, *temp, *in;
	int     frag_digits = 1;

	if (scale == NULL)  // first time called
	{
		scale = HUD_FindVar(hud, "scale");
		style = HUD_FindVar(hud, "style");
		format_big = HUD_FindVar(hud, "format_big");
		format_small = HUD_FindVar(hud, "format_small");
		frag_length = HUD_FindVar(hud, "frag_length");
		reversed_big = HUD_FindVar(hud, "format_reversed_big");
		reversed_small = HUD_FindVar(hud, "format_reversed_small");
		proportional = HUD_FindVar(hud, "proportional");
	}

	frag_digits = max(1, min(frag_length->value, 4));

	swappedOrder = SCR_Hud_GetScores(&s_team, &s_enemy, &n_team, &n_enemy);
	s_difference = s_team - s_enemy;

	// two pots of delicious customized copypasta from math_tools.c
	switch (style->integer) {
		// Big
		case 1:
			in = TP_ParseFunChars(swappedOrder && reversed_big->string[0] ? reversed_big->string : format_big->string, false);
			buf[0] = 0;
			out = buf;

			while ((c = *in++) && (out - buf < MAX_MACRO_STRING - 1)) {
				if ((c == '%') && *in) {
					switch ((c = *in++)) {
						// c = colorize, r = reset
						case 'd':
							temp = va("%d", s_difference);
							width += (s_difference >= 0) ? strlen(temp) * 24 : ((strlen(temp) - 1) * 24) + 16;
							break;
						case 'D':
							temp = va("c%dr", s_difference);
							width += (s_difference >= 0) ? (strlen(temp) - 2) * 24 : ((strlen(temp) - 3) * 24) + 16;
							break;
						case 'e':
							temp = va("%d", s_enemy);
							width += (s_enemy >= 0) ? strlen(temp) * 24 : ((strlen(temp) - 1) * 24) + 16;
							break;
						case 'E':
							temp = va("c%dr", s_enemy);
							width += (s_enemy >= 0) ? (strlen(temp) - 2) * 24 : ((strlen(temp) - 3) * 24) + 16;
							break;
						case 'p':
							temp = va("%d", i + 1);
							width += 24;
							break;
						case 't':
							temp = va("%d", s_team);
							width += (s_team >= 0) ? strlen(temp) * 24 : ((strlen(temp) - 1) * 24) + 16;
							break;
						case 'T':
							temp = va("c%dr", s_team);
							width += (s_team >= 0) ? (strlen(temp) - 2) * 24 : ((strlen(temp) - 3) * 24) + 16;
							break;
						case 'z':
							if (s_difference >= 0) {
								temp = va("%d", s_difference);
								width += strlen(temp) * 24;
							}
							else {
								temp = va("c%dr", -(s_difference));
								width += (strlen(temp) - 2) * 24;
							}
							break;
						case 'Z':
							if (s_difference >= 0) {
								temp = va("c%dr", s_difference);
								width += (strlen(temp) - 2) * 24;
							}
							else {
								temp = va("%d", -(s_difference));
								width += strlen(temp) * 24;
							}
							break;
						default:
							temp = NULL;
							break;
					}

					if (temp != NULL) {
						strlcpy(out, temp, sizeof(buf) - (out - buf));
						out += strlen(temp);
					}
				}
				else if (c == ':' || c == '/' || c == '-' || c == ' ') {
					width += 16;
					*out++ = c;
				}
			}
			*out = 0;
			break;

			// Small
		case 0:
		default:
			in = TP_ParseFunChars(swappedOrder && reversed_small->string[0] ? reversed_small->string : format_small->string, false);
			buf[0] = 0;
			out = buf;

			while ((c = *in++) && (out - buf < MAX_MACRO_STRING - 1)) {
				if ((c == '%') && *in) {
					int fixed_width = 0, alignment = 0;

					if (in[0] == '<') {
						--in;
						TP_ReadMacroFormat(in, &fixed_width, &alignment, &in);
						++in;
					}

					switch ((c = *in++)) {
						case '%':
							temp = "%";
							break;
						case 't':
							temp = va("%*d", frag_digits, s_team);
							break;
						case 'e':
							temp = va("%*d", frag_digits, s_enemy);
							break;
						case 'd':
							temp = va("%d", s_difference);
							break;
						case 'p':
							temp = va("%d", i + 1);
							break;
						case 'T':
							temp = n_team;
							break;
						case 'E':
							temp = n_enemy;
							break;
						case 'D':
							temp = va("%+d", s_difference);
							break;
						default:
							temp = va("%%%c", c);
							break;
					}
					if (fixed_width) {
						temp = TP_AlignMacroText(temp, fixed_width, alignment);
					}
					strlcpy(out, temp, sizeof(buf) - (out - buf));
					out += strlen(temp);
				}
				else {
					*out++ = c;
				}
			}
			*out = 0;
			break;
	}

	switch (style->integer) {
		// Big
		case 1:
			width *= scale->value;
			height = 24 * scale->value;

			if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
				SCR_DrawWadString(x, y, scale->value, buf);
			}
			break;

			// Small
		case 0:
		default:
			width = Draw_StringLengthColors(buf, -1, scale->value, proportional->integer);
			height = 8 * scale->value;

			if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
				Draw_SString(x, y, buf, scale->value, proportional->integer);
			}
			break;
	}
}

static void SCR_HUD_DrawOwnFrags(hud_t *hud)
{
	// not implemented yet: scale, color
	// fixme: add appropriate opengl functions that will add alpha, scale and color
	int width;
	int height = LETTERHEIGHT;
	int x, y;
	double alpha;
	static cvar_t
		*hud_ownfrags_timeout = NULL,
		*hud_ownfrags_scale = NULL,
		*hud_ownfrags_proportional = NULL;
	extern qbool hud_editor;

	if (hud_ownfrags_timeout == NULL) {
		// first time
		hud_ownfrags_scale = HUD_FindVar(hud, "scale");
		hud_ownfrags_timeout = HUD_FindVar(hud, "timeout");
		hud_ownfrags_proportional = HUD_FindVar(hud, "proportional");
	}

	if (hud_editor) {
		HUD_PrepareDraw(hud, 10 * LETTERWIDTH, height * hud_ownfrags_scale->value, &x, &y);
	}

	width = VX_OwnFragTextLen(hud_ownfrags_scale->value, hud_ownfrags_proportional->integer);
	if (!width) {
		return;
	}

	if (VX_OwnFragTime() > hud_ownfrags_timeout->value) {
		return;
	}

	height *= hud_ownfrags_scale->value;

	alpha = 2 - hud_ownfrags_timeout->value / VX_OwnFragTime() * 2;
	alpha = bound(0, alpha, 1);

	if (!HUD_PrepareDraw(hud, width, height, &x, &y)) {
		return;
	}

	if (VX_OwnFragTime() < hud_ownfrags_timeout->value) {
		Draw_SString(x, y, VX_OwnFragText(), hud_ownfrags_scale->value, hud_ownfrags_proportional->integer);
	}
}

void Scores_HudInit(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_HUD);
	Cvar_Register(&hud_sortrules_playersort);
	Cvar_Register(&hud_sortrules_teamsort);
	Cvar_Register(&hud_sortrules_includeself);
	Cvar_ResetCurrentGroup();

	HUD_Register(
		"score_team", NULL, "Own scores or team scores.",
		0, ca_active, 0, SCR_HUD_DrawScoresTeam,
		"0", "screen", "left", "bottom", "0", "0", "0.5", "4 8 32", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "0",
		"colorize", "0",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"score_enemy", NULL, "Scores of enemy or enemy team.",
		0, ca_active, 0, SCR_HUD_DrawScoresEnemy,
		"0", "score_team", "after", "bottom", "0", "0", "0.5", "32 4 0", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "0",
		"colorize", "0",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"score_difference", NULL, "Difference between teamscores and enemyscores.",
		0, ca_active, 0, SCR_HUD_DrawScoresDifference,
		"0", "score_enemy", "after", "bottom", "0", "0", "0.5", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "0",
		"colorize", "1",
		"proportional", "0",
		NULL
	);

	HUD_Register("score_position", NULL, "Position on scoreboard.",
		0, ca_active, 0, SCR_HUD_DrawScoresPosition,
		"0", "score_difference", "after", "bottom", "0", "0", "0.5", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"align", "right",
		"digits", "0",
		"colorize", "1",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"score_bar", NULL, "Team, enemy, and difference scores together.",
		HUD_PLUSMINUS, ca_active, 0, SCR_HUD_DrawScoresBar,
		"0", "screen", "center", "console", "0", "0", "0.5", "0 0 0", NULL,
		"style", "0",
		"scale", "1",
		"format_small", "&c69f%T&r:%t &cf10%E&r:%e $[%D$]",
		"format_big", "%t:%e:%Z",
		"format_reversed_big", "",
		"format_reversed_small", "",
		"frag_length", "0",
		"proportional", "0",
		NULL
	);

	HUD_Register(
		"ownfrags" /* jeez someone give me a better name please */,
		NULL, "Highlights your own frags",
		0, ca_active, 1, SCR_HUD_DrawOwnFrags,
		"1", "screen", "center", "top", "0", "50", "0.2", "0 0 100", NULL,
		/*
		"color", "255 255 255",
		*/
		"timeout", "3",
		"scale", "1.5",
		"proportional", "0",
		NULL
	);
}


================================================
FILE: src/hud_speed.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "hud.h"

static cvar_t show_speed   = { "show_speed", "0" };
static cvar_t show_speed_x = { "show_speed_x", "-1" };
static cvar_t show_speed_y = { "show_speed_y", "1" };

#define SPEED_GREEN				"52"
#define SPEED_BROWN_RED			"100"
#define SPEED_DARK_RED			"72"
#define SPEED_BLUE				"216"
#define SPEED_RED				"229"

#define	SPEED_STOPPED			SPEED_GREEN
#define	SPEED_NORMAL			SPEED_BROWN_RED
#define	SPEED_FAST				SPEED_DARK_RED
#define	SPEED_FASTEST			SPEED_BLUE
#define	SPEED_INSANE			SPEED_RED

#define SPEED_TAG_LENGTH		2
#define SPEED_OUTLINE_SPACING	SPEED_TAG_LENGTH
#define SPEED_FILL_SPACING		SPEED_OUTLINE_SPACING + 1
#define SPEED_WHITE				10
#define SPEED_TEXT_ONLY			1

#define	SPEED_TEXT_ALIGN_NONE	0
#define SPEED_TEXT_ALIGN_CLOSE	1
#define SPEED_TEXT_ALIGN_CENTER	2
#define SPEED_TEXT_ALIGN_FAR	3

#define	HUD_SPEED2_ORIENTATION_UP		0
#define	HUD_SPEED2_ORIENTATION_DOWN		1
#define	HUD_SPEED2_ORIENTATION_RIGHT	2
#define	HUD_SPEED2_ORIENTATION_LEFT		3

// 'speed' hud element
static void SCR_DrawHUDSpeed(
	int x, int y, int width, int height,
	int type,
	float tick_spacing,
	float opacity,
	int vertical,
	int vertical_text,
	int text_align,
	byte color_stopped,
	byte color_normal,
	byte color_fast,
	byte color_fastest,
	byte color_insane,
	int style,
	float scale,
	qbool proportional
)
{
	byte color_offset;
	byte color1, color2;
	int player_speed;
	vec_t *velocity;
	qbool split;
	char speed_text[20];

	if (scr_con_current == vid.height) {
		return;     // console is full screen
	}

	split = (style == 2 || style == 3);
	style = style & 1;

	// Get the velocity.
	if (cl.players[cl.playernum].spectator && Cam_TrackNum() >= 0) {
		velocity = cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].playerstate[Cam_TrackNum()].velocity;
	}
	else {
		velocity = cl.simvel;
	}

	// Calculate the speed
	if (!type) {
		// Based on XY.
		player_speed = sqrt(velocity[0] * velocity[0]
							+ velocity[1] * velocity[1]);
	}
	else {
		// Based on XYZ.
		player_speed = sqrt(velocity[0] * velocity[0]
							+ velocity[1] * velocity[1]
							+ velocity[2] * velocity[2]);
	}

	// Calculate the color offset for the "background color".
	if (vertical) {
		color_offset = height * (player_speed % 500) / 500;
	}
	else {
		color_offset = width * (player_speed % 500) / 500;
	}

	// Set the color based on the speed.
	switch (player_speed / 500) {
		case 0:
			color1 = color_stopped;
			color2 = color_normal;
			break;
		case 1:
			color1 = color_normal;
			color2 = color_fast;
			break;
		case 2:
			color1 = color_fast;
			color2 = color_fastest;
			break;
		default:
			color1 = color_fastest;
			color2 = color_insane;
			break;
	}

	// Draw tag marks.
	if (tick_spacing > 0.0 && style != SPEED_TEXT_ONLY) {
		float f;

		for (f = tick_spacing; f < 1.0; f += tick_spacing) {
			if (vertical) {
				// Left.
				Draw_AlphaFill(
					x           ,           // x
					y + (int)(f * height),  // y
					SPEED_TAG_LENGTH,       // Width
					1,                      // Height
					SPEED_WHITE,            // Color
					opacity                 // Opacity
				);

				// Right.
				Draw_AlphaFill(
					x + width - SPEED_TAG_LENGTH + 1,
					y + (int)(f * height),
					SPEED_TAG_LENGTH,
					1,
					SPEED_WHITE,
					opacity
				);
			}
			else {
				// Above.
				Draw_AlphaFill(
					x + (int)(f * width),
					y,
					1,
					SPEED_TAG_LENGTH,
					SPEED_WHITE,
					opacity
				);

				// Below.
				Draw_AlphaFill(
					x + (int)(f * width),
					y + height - SPEED_TAG_LENGTH + 1,
					1,
					SPEED_TAG_LENGTH,
					SPEED_WHITE,
					opacity
				);
			}
		}
	}

	//
	// Draw outline.
	//
	if (style != SPEED_TEXT_ONLY) {
		if (vertical) {
			// Left.
			Draw_AlphaFill(
				x + SPEED_OUTLINE_SPACING,
				y,
				1,
				height,
				SPEED_WHITE,
				opacity
			);

			// Right.
			Draw_AlphaFill(
				x + width - SPEED_OUTLINE_SPACING,
				y,
				1,
				height,
				SPEED_WHITE,
				opacity
			);
		}
		else {
			// Above.
			Draw_AlphaFill(
				x,
				y + SPEED_OUTLINE_SPACING,
				width,
				1,
				SPEED_WHITE,
				opacity
			);

			// Below.
			Draw_AlphaFill(
				x,
				y + height - SPEED_OUTLINE_SPACING,
				width,
				1,
				SPEED_WHITE,
				opacity
			);
		}
	}

	//
	// Draw fill.
	//
	if (style != SPEED_TEXT_ONLY) {
		if (vertical) {
			// Draw the right color (slower).
			Draw_AlphaFill(
				x + SPEED_FILL_SPACING,
				y,
				width - (2 * SPEED_FILL_SPACING),
				height - color_offset,
				color1,
				opacity
			);

			// Draw the left color (faster).
			Draw_AlphaFill(
				x + SPEED_FILL_SPACING,
				y + height - color_offset,
				width - (2 * SPEED_FILL_SPACING),
				color_offset,
				color2,
				opacity
			);
		}
		else {
			// Draw the right color (slower).
			Draw_AlphaFill(
				x + color_offset,
				y + SPEED_FILL_SPACING,
				width - color_offset,
				height - (2 * SPEED_FILL_SPACING),
				color1,
				opacity
			);

			// Draw the left color (faster).
			Draw_AlphaFill(
				x,
				y + SPEED_FILL_SPACING,
				color_offset,
				height - (2 * SPEED_FILL_SPACING),
				color2,
				opacity
			);
		}
	}

	if (text_align == SPEED_TEXT_ALIGN_NONE) {
		return;
	}

	if (split) {
		snprintf(speed_text, sizeof(speed_text), "%4d %4d %4d", (int)velocity[0], (int)velocity[1], (int)velocity[2]);
	}
	else {
		snprintf(speed_text, sizeof(speed_text), "%4d", player_speed);
	}

	// Draw the speed text.
	if (vertical && vertical_text) {
		int i = 1;
		int len = 0;

		// Align the text accordingly.
		switch (text_align) {
			case SPEED_TEXT_ALIGN_NONE:		return;
			case SPEED_TEXT_ALIGN_FAR:		y = y + height - 4 * 8; break;
			case SPEED_TEXT_ALIGN_CENTER:	y = Q_rint(y + height / 2.0 - 16); break;
			case SPEED_TEXT_ALIGN_CLOSE:
			default: break;
		}

		len = strlen(va("%d", player_speed));

		// 10^len
		while (len > 0) {
			i *= 10;
			len--;
		}

		// Write one number per row.
		for (; i > 1; i /= 10) {
			int next;
			next = (i / 10);

			// Really make sure we don't try division by zero :)
			if (next <= 0) {
				break;
			}

			Draw_SString(Q_rint(x + width / 2.0 - 4 * scale), y, va("%1d", (player_speed % i) / next), scale, proportional);
			y += 8;
		}
	}
	else {
		text_alignment_t alignment = text_align_left;

		if (text_align == SPEED_TEXT_ALIGN_FAR) {
			alignment = text_align_right;
		}
		else if (text_align == SPEED_TEXT_ALIGN_CENTER) {
			alignment = text_align_center;
		}

		Draw_SStringAligned(x, y + height / 2.0 - 4 * scale, speed_text, scale, 1.0f, proportional, alignment, x + width);
	}
}

static void SCR_HUD_DrawSpeed(hud_t *hud)
{
	int width, height;
	int x, y;

	static cvar_t *hud_speed_xyz = NULL,
		*hud_speed_width,
		*hud_speed_height,
		*hud_speed_tick_spacing,
		*hud_speed_opacity,
		*hud_speed_color_stopped,
		*hud_speed_color_normal,
		*hud_speed_color_fast,
		*hud_speed_color_fastest,
		*hud_speed_color_insane,
		*hud_speed_vertical,
		*hud_speed_vertical_text,
		*hud_speed_text_align,
		*hud_speed_style,
		*hud_speed_scale,
		*hud_speed_proportional;

	if (hud_speed_xyz == NULL)    // first time
	{
		hud_speed_xyz = HUD_FindVar(hud, "xyz");
		hud_speed_width = HUD_FindVar(hud, "width");
		hud_speed_height = HUD_FindVar(hud, "height");
		hud_speed_tick_spacing = HUD_FindVar(hud, "tick_spacing");
		hud_speed_opacity = HUD_FindVar(hud, "opacity");
		hud_speed_color_stopped = HUD_FindVar(hud, "color_stopped");
		hud_speed_color_normal = HUD_FindVar(hud, "color_normal");
		hud_speed_color_fast = HUD_FindVar(hud, "color_fast");
		hud_speed_color_fastest = HUD_FindVar(hud, "color_fastest");
		hud_speed_color_insane = HUD_FindVar(hud, "color_insane");
		hud_speed_vertical = HUD_FindVar(hud, "vertical");
		hud_speed_vertical_text = HUD_FindVar(hud, "vertical_text");
		hud_speed_text_align = HUD_FindVar(hud, "text_align");
		hud_speed_style = HUD_FindVar(hud, "style");
		hud_speed_scale = HUD_FindVar(hud, "scale");
		hud_speed_proportional = HUD_FindVar(hud, "proportional");
	}

	width = max(0, hud_speed_width->value) * hud_speed_scale->value;
	height = max(0, hud_speed_height->value) * hud_speed_scale->value;

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		SCR_DrawHUDSpeed(
			x, y, width, height,
			hud_speed_xyz->value,
			hud_speed_tick_spacing->value,
			hud_speed_opacity->value,
			hud_speed_vertical->value,
			hud_speed_vertical_text->value,
			hud_speed_text_align->value,
			hud_speed_color_stopped->value,
			hud_speed_color_normal->value,
			hud_speed_color_fast->value,
			hud_speed_color_fastest->value,
			hud_speed_color_insane->value,
			hud_speed_style->integer,
			hud_speed_scale->value,
			hud_speed_proportional->integer
		);
	}
}

// speed2
static void SCR_HUD_DrawSpeed2(hud_t *hud)
{
	int width, height;
	int x, y;
	char player_speed_text[20];
	float text_length;

	static cvar_t *hud_speed2_xyz = NULL,
		*hud_speed2_opacity,
		*hud_speed2_color_stopped,
		*hud_speed2_color_normal,
		*hud_speed2_color_fast,
		*hud_speed2_color_fastest,
		*hud_speed2_color_insane,
		*hud_speed2_radius,
		*hud_speed2_wrapspeed,
		*hud_speed2_orientation,
		*hud_speed2_scale,
		*hud_speed2_proportional;

	if (hud_speed2_xyz == NULL)    // first time
	{
		hud_speed2_xyz = HUD_FindVar(hud, "xyz");
		hud_speed2_opacity = HUD_FindVar(hud, "opacity");
		hud_speed2_color_stopped = HUD_FindVar(hud, "color_stopped");
		hud_speed2_color_normal = HUD_FindVar(hud, "color_normal");
		hud_speed2_color_fast = HUD_FindVar(hud, "color_fast");
		hud_speed2_color_fastest = HUD_FindVar(hud, "color_fastest");
		hud_speed2_color_insane = HUD_FindVar(hud, "color_insane");
		hud_speed2_radius = HUD_FindVar(hud, "radius");
		hud_speed2_wrapspeed = HUD_FindVar(hud, "wrapspeed");
		hud_speed2_orientation = HUD_FindVar(hud, "orientation");
		hud_speed2_scale = HUD_FindVar(hud, "scale");
		hud_speed2_proportional = HUD_FindVar(hud, "proportional");
	}

	// Calculate the height and width based on the radius.
	switch ((int)hud_speed2_orientation->value) {
		case HUD_SPEED2_ORIENTATION_LEFT:
		case HUD_SPEED2_ORIENTATION_RIGHT:
			height = max(0, 2 * hud_speed2_radius->value);
			width = max(0, (hud_speed2_radius->value));
			break;
		case HUD_SPEED2_ORIENTATION_DOWN:
		case HUD_SPEED2_ORIENTATION_UP:
		default:
			// Include the height of the speed text in the height.
			height = max(0, (hud_speed2_radius->value));
			width = max(0, 2 * hud_speed2_radius->value);
			break;
	}

	width *= hud_speed2_scale->value;
	height *= hud_speed2_scale->value;

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		float radius;
		int player_speed;
		int arc_length;
		int color1, color2;
		int text_x = x;
		int text_y = y;
		vec_t *velocity;

		// Start and end points for the needle
		int needle_start_x = 0;
		int needle_start_y = 0;
		int needle_end_x = 0;
		int needle_end_y = 0;

		// The length of the arc between the zero point
		// and where the needle is pointing at.
		int needle_offset = 0;

		// The angle between the zero point and the position
		// that the needle is drawn on.
		float needle_angle = 0.0;

		// The angle where to start drawing the half circle and where to end.
		// This depends on the orientation of the circle (left, right, up, down).
		float circle_startangle = 0.0;
		float circle_endangle = 0.0;

		// Avoid divison by zero.
		if (hud_speed2_radius->value <= 0) {
			return;
		}

		// Get the velocity.
		if (cl.players[cl.playernum].spectator && Cam_TrackNum() >= 0) {
			velocity = cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].playerstate[Cam_TrackNum()].velocity;
		}
		else {
			velocity = cl.simvel;
		}

		// Calculate the speed
		if (!hud_speed2_xyz->value) {
			// Based on XY.
			player_speed = sqrt(velocity[0] * velocity[0]
								+ velocity[1] * velocity[1]);
		}
		else {
			// Based on XYZ.
			player_speed = sqrt(velocity[0] * velocity[0]
								+ velocity[1] * velocity[1]
								+ velocity[2] * velocity[2]);
		}

		snprintf(player_speed_text, sizeof(player_speed_text), "%d", player_speed);
		text_length = Draw_StringLength(player_speed_text, -1, hud_speed2_scale->value, hud_speed2_proportional->integer);

		// Set the color based on the wrap speed.
		switch ((int)(player_speed / hud_speed2_wrapspeed->value)) {
			case 0:
				color1 = hud_speed2_color_stopped->integer;
				color2 = hud_speed2_color_normal->integer;
				break;
			case 1:
				color1 = hud_speed2_color_normal->integer;
				color2 = hud_speed2_color_fast->integer;
				break;
			case 2:
				color1 = hud_speed2_color_fast->integer;
				color2 = hud_speed2_color_fastest->integer;
				break;
			default:
				color1 = hud_speed2_color_fastest->integer;
				color2 = hud_speed2_color_insane->integer;
				break;
		}

		// Set some properties how to draw the half circle, needle and text
		// based on the orientation of the hud item.
		switch ((int)hud_speed2_orientation->value) {
			case HUD_SPEED2_ORIENTATION_LEFT:
			{
				x += width;
				y += height / 2;
				circle_startangle = M_PI / 2.0;
				circle_endangle = (3 * M_PI) / 2.0;

				text_x = x - text_length;
				text_y = y - 8 * hud_speed2_scale->value * 0.5;
				break;
			}
			case HUD_SPEED2_ORIENTATION_RIGHT:
			{
				y += height / 2;
				circle_startangle = (3 * M_PI) / 2.0;
				circle_endangle = (5 * M_PI) / 2.0;
				needle_end_y = y + hud_speed2_radius->value * sin(needle_angle);

				text_x = x;
				text_y = y - 8 * hud_speed2_scale->value * 0.5;
				break;
			}
			case HUD_SPEED2_ORIENTATION_DOWN:
			{
				x += width / 2;
				circle_startangle = M_PI;
				circle_endangle = 2 * M_PI;
				needle_end_y = y + hud_speed2_radius->value * sin(needle_angle);

				text_x = x - 0.5 * text_length;
				text_y = y;
				break;
			}
			case HUD_SPEED2_ORIENTATION_UP:
			default:
			{
				x += width / 2;
				y += height;
				circle_startangle = 0;
				circle_endangle = M_PI;
				needle_end_y = y - hud_speed2_radius->value * sin(needle_angle);

				text_x = x - 0.5 * text_length;
				text_y = y - 8 * hud_speed2_scale->value;
				break;
			}
		}

		//
		// Calculate the offsets and angles.
		//
		{
			// Calculate the arc length of the half circle background.
			arc_length = fabs((circle_endangle - circle_startangle) * hud_speed2_radius->value);

			// Calculate the angle where the speed needle should point.
			needle_offset = arc_length * (player_speed % Q_rint(hud_speed2_wrapspeed->value)) / Q_rint(hud_speed2_wrapspeed->value);
			needle_angle = needle_offset / hud_speed2_radius->value;

			// Draw from the center of the half circle.
			needle_start_x = x;
			needle_start_y = y;
		}

		radius = hud_speed2_radius->value * hud_speed2_scale->value;

		// Set the needle end point depending on the orientation of the hud item.
		switch ((int)hud_speed2_orientation->value) {
			case HUD_SPEED2_ORIENTATION_LEFT:
			{
				needle_end_x = x - radius * sin(needle_angle);
				needle_end_y = y + radius * cos(needle_angle);
				break;
			}
			case HUD_SPEED2_ORIENTATION_RIGHT:
			{
				needle_end_x = x + radius * sin(needle_angle);
				needle_end_y = y - radius * cos(needle_angle);
				break;
			}
			case HUD_SPEED2_ORIENTATION_DOWN:
			{
				needle_end_x = x + radius * cos(needle_angle);
				needle_end_y = y + radius * sin(needle_angle);
				break;
			}
			case HUD_SPEED2_ORIENTATION_UP:
			default:
			{
				needle_end_x = x - radius * cos(needle_angle);
				needle_end_y = y - radius * sin(needle_angle);
				break;
			}
		}

		// Draw the speed-o-meter background.
		Draw_AlphaPieSlice(
			x, y,                            // Position
			radius,                          // Radius
			circle_startangle,               // Start angle
			circle_endangle - needle_angle,  // End angle
			1,                               // Thickness
			true,                            // Fill
			color1,                          // Color
			hud_speed2_opacity->value        // Opacity
		);

		// Draw a pie slice that shows the "color" of the speed.
		Draw_AlphaPieSlice(
			x, y,                               // Position
			radius,                             // Radius
			circle_endangle - needle_angle,     // Start angle
			circle_endangle,                    // End angle
			1,                                  // Thickness
			true,                               // Fill
			color2,                             // Color
			hud_speed2_opacity->value           // Opacity
		);

		// Draw the "needle attachment" circle.
		Draw_AlphaCircle(x, y, 2.0, 1, true, 15, hud_speed2_opacity->value);

		// Draw the speed needle.
		Draw_AlphaLineRGB(needle_start_x, needle_start_y, needle_end_x, needle_end_y, 1, RGBA_TO_COLOR(250, 250, 250, 255 * hud_speed2_opacity->value));

		// Draw the speed.
		Draw_SString(text_x, text_y, player_speed_text, hud_speed2_scale->value, hud_speed2_proportional->integer);
	}
}

void Speed_HudInit(void)
{
	// init speed
	HUD_Register("speed", NULL, "Shows your current running speed. It is measured over XY or XYZ axis depending on \'xyz\' property.",
		HUD_PLUSMINUS, ca_active, 7, SCR_HUD_DrawSpeed,
		"0", "top", "center", "bottom", "0", "-5", "0", "0 0 0", NULL,
		"xyz", "0",
		"width", "160",
		"height", "15",
		"opacity", "1.0",
		"tick_spacing", "0.2",
		"color_stopped", SPEED_STOPPED,
		"color_normal", SPEED_NORMAL,
		"color_fast", SPEED_FAST,
		"color_fastest", SPEED_FASTEST,
		"color_insane", SPEED_INSANE,
		"vertical", "0",
		"vertical_text", "1",
		"text_align", "1",
		"style", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);

	// Init speed2 (half circle thingie).
	HUD_Register("speed2", NULL, "Shows your current running speed. It is measured over XY or XYZ axis depending on \'xyz\' property.",
		HUD_PLUSMINUS, ca_active, 7, SCR_HUD_DrawSpeed2,
		"0", "top", "center", "bottom", "0", "0", "0", "0 0 0", NULL,
		"xyz", "0",
		"opacity", "1.0",
		"color_stopped", SPEED_STOPPED,
		"color_normal", SPEED_NORMAL,
		"color_fast", SPEED_FAST,
		"color_fastest", SPEED_FASTEST,
		"color_insane", SPEED_INSANE,
		"radius", "50.0",
		"wrapspeed", "500",
		"orientation", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);

	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register(&show_speed);
	Cvar_Register(&show_speed_x);
	Cvar_Register(&show_speed_y);
	Cvar_ResetCurrentGroup();
}

void SCR_DrawSpeed(void)
{
	double t;
	int x, y, mynum;
	char str[80];
	vec3_t vel;
	float speed;
	static float maxspeed = 0, display_speed = -1;
	static double lastframetime = 0;
	static int lastmynum = -1;
	extern cvar_t scr_newHud;

	if (!show_speed.integer || scr_newHud.integer == 1) {
		// newHud has its own speed
		return;
	}

	t = curtime;
	if (!cl.spectator || (mynum = Cam_TrackNum()) == -1) {
		mynum = cl.playernum;
	}

	if (mynum != lastmynum) {
		lastmynum = mynum;
		lastframetime = t;
		display_speed = -1;
		maxspeed = 0;
	}

	if (!cl.spectator || cls.demoplayback || mynum == cl.playernum) {
		VectorCopy(cl.simvel, vel);
	}
	else {
		VectorCopy(cl.frames[cl.validsequence & UPDATE_MASK].playerstate[mynum].velocity, vel);
	}

	vel[2] = 0;
	speed = VectorLength(vel);

	maxspeed = max(maxspeed, speed);

	if (display_speed >= 0) {
		snprintf(str, sizeof(str), "%3d%s", (int)display_speed, show_speed.value == 2 ? " SPD" : "");
		x = ELEMENT_X_COORD(show_speed);
		y = ELEMENT_Y_COORD(show_speed);
		Draw_String(x, y, str);
	}

	if (t - lastframetime >= 0.1) {
		lastframetime = t;
		display_speed = maxspeed;
		maxspeed = 0;
	}
}


================================================
FILE: src/hud_teaminfo.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// hud_teaminfo.c

#include "quakedef.h"
#include "hud.h"
#include "teamplay.h"
#include "hud_common.h"
#include "vx_stuff.h"
#include "utils.h"
// Get rid of these once we remove matrix scaling from cl_screen.c version...
#include "gl_model.h"
#include "fonts.h"

#define FONT_WIDTH 8

static void Update_TeamInfo(void);
mpic_t* SCR_GetWeaponIconByFlag(int flag);

static cvar_t scr_shownick_order           = { "scr_shownick_order", "%p%n %a/%H %w" };
static cvar_t scr_shownick_frame_color     = { "scr_shownick_frame_color", "10 0 0 120", CVAR_COLOR };
static cvar_t scr_shownick_scale           = { "scr_shownick_scale",		"1" };
static cvar_t scr_shownick_y               = { "scr_shownick_y",			"0" };
static cvar_t scr_shownick_x               = { "scr_shownick_x",			"0" };
static cvar_t scr_shownick_name_width      = { "scr_shownick_name_width",	"6" };
static cvar_t scr_shownick_time            = { "scr_shownick_time",		"0.8" };
static cvar_t scr_shownick_proportional    = { "scr_shownick_proportional", "0" };
static cvar_t scr_shownick_show_ammo	   = { "scr_shownick_show_ammo", "0" };

static cvar_t scr_teaminfo_order           = { "scr_teaminfo_order", "%p%n $x10%l$x11 %a/%H %w", CVAR_NONE };
static cvar_t scr_teaminfo_align_right     = { "scr_teaminfo_align_right", "1" };
static cvar_t scr_teaminfo_frame_color     = { "scr_teaminfo_frame_color", "10 0 0 120", CVAR_COLOR };
static cvar_t scr_teaminfo_scale           = { "scr_teaminfo_scale",       "1" };
static cvar_t scr_teaminfo_y               = { "scr_teaminfo_y",           "0" };
static cvar_t scr_teaminfo_x               = { "scr_teaminfo_x",           "0" };
static cvar_t scr_teaminfo_loc_width       = { "scr_teaminfo_loc_width",   "5" };
static cvar_t scr_teaminfo_name_width      = { "scr_teaminfo_name_width",  "6" };
static cvar_t scr_teaminfo_low_health      = { "scr_teaminfo_low_health",  "25" };
static cvar_t scr_teaminfo_armor_style     = { "scr_teaminfo_armor_style", "3" };
static cvar_t scr_teaminfo_powerup_style   = { "scr_teaminfo_powerup_style", "1" };
static cvar_t scr_teaminfo_flag_style      = { "scr_teaminfo_flag_style",  "1" };
static cvar_t scr_teaminfo_weapon_style    = { "scr_teaminfo_weapon_style","1" };
static cvar_t scr_teaminfo_show_ammo	   = { "scr_teaminfo_show_ammo","0" };
static cvar_t scr_teaminfo_show_countdown  = { "scr_teaminfo_show_countdown","1" };
static cvar_t scr_teaminfo_show_enemies    = { "scr_teaminfo_show_enemies","0" };
static cvar_t scr_teaminfo_show_self       = { "scr_teaminfo_show_self",   "2" };
static cvar_t scr_teaminfo_proportional    = { "scr_teaminfo_proportional", "0"};
cvar_t scr_teaminfo                        = { "scr_teaminfo",             "1" };   // non-static for menu

static int SCR_HudDrawTeamInfoPlayer(ti_player_t *ti_cl, float x, int y, int maxname, int maxloc, qbool width_only, float scale, const char* layout, int weapon_style, int show_ammo, int show_countdown, int armor_style, int powerup_style, int flag_style, int low_health, qbool proportional);

static int HUD_CompareTeamInfoSlots(const void* lhs_, const void* rhs_)
{
	int lhs = *(const int*)lhs_;
	int rhs = *(const int*)rhs_;
	int lhs_pos = -1;
	int rhs_pos = -1;
	int i;

	for (i = 0; i < n_players; ++i) {
		if (sorted_players[i].playernum == lhs) {
			lhs_pos = i;
		}
		if (sorted_players[i].playernum == rhs) {
			rhs_pos = i;
		}
	}

	return lhs_pos - rhs_pos;
}

void SCR_HUD_DrawTeamInfo(hud_t *hud)
{
	int x, y, _y, width, height;
	int i, j, k, slots[MAX_CLIENTS], slots_num, maxname, maxloc;
	char tmp[1024], *nick;
	float header_spacing;

	// Used for hud_teaminfo, data is collected in screen.c / scr_teaminfo
	extern ti_player_t ti_clients[MAX_CLIENTS];

	extern qbool hud_editor;

	static cvar_t
		*hud_teaminfo_weapon_style = NULL,
		*hud_teaminfo_align_right,
		*hud_teaminfo_loc_width,
		*hud_teaminfo_name_width,
		*hud_teaminfo_show_ammo,
		*hud_teaminfo_show_countdown,
		*hud_teaminfo_show_enemies,
		*hud_teaminfo_show_self,
		*hud_teaminfo_show_headers,
		*hud_teaminfo_scale,
		*hud_teaminfo_armor_style,
		*hud_teaminfo_powerup_style,
		*hud_teaminfo_flag_style,
		*hud_teaminfo_low_health,
		*hud_teaminfo_layout,
		*hud_teaminfo_proportional,
		*hud_teaminfo_header_spacing;

	if (hud_teaminfo_weapon_style == NULL) {
		// first time
		hud_teaminfo_weapon_style = HUD_FindVar(hud, "weapon_style");
		hud_teaminfo_align_right = HUD_FindVar(hud, "align_right");
		hud_teaminfo_loc_width = HUD_FindVar(hud, "loc_width");
		hud_teaminfo_name_width = HUD_FindVar(hud, "name_width");
		hud_teaminfo_show_ammo = HUD_FindVar(hud, "show_ammo");
		hud_teaminfo_show_enemies = HUD_FindVar(hud, "show_enemies");
		hud_teaminfo_show_self = HUD_FindVar(hud, "show_self");
		hud_teaminfo_show_headers = HUD_FindVar(hud, "show_headers");
		hud_teaminfo_show_countdown = HUD_FindVar(hud, "show_countdown");
		hud_teaminfo_scale = HUD_FindVar(hud, "scale");
		hud_teaminfo_armor_style = HUD_FindVar(hud, "armor_style");
		hud_teaminfo_powerup_style = HUD_FindVar(hud, "powerup_style");
		hud_teaminfo_flag_style = HUD_FindVar(hud, "flag_style");
		hud_teaminfo_low_health = HUD_FindVar(hud, "low_health");
		hud_teaminfo_layout = HUD_FindVar(hud, "layout");
		hud_teaminfo_proportional = HUD_FindVar(hud, "proportional");
		hud_teaminfo_header_spacing = HUD_FindVar(hud, "header_spacing");
	}

	// Don't update hud item unless first view is beeing displayed
	if (CL_MultiviewCurrentView() != 1 && CL_MultiviewCurrentView() != 0) {
		return;
	}

	if (cls.mvdplayback) {
		Update_TeamInfo();
	}

	// fill data we require to draw teaminfo
	for (maxloc = maxname = slots_num = i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator || !ti_clients[i].time || ti_clients[i].time + 5 < r_refdef2.time) {
			continue;
		}

		// do not show enemy players unless it's MVD and user wishes to show them
		if (VX_TrackerIsEnemy(i) && (!cls.mvdplayback || !hud_teaminfo_show_enemies->integer)) {
			continue;
		}

		// do not show tracked player to spectator
		if ((cl.spectator && Cam_TrackNum() == i) && hud_teaminfo_show_self->integer == 0) {
			continue;
		}

		// dynamically guess max length of name/location
		nick = (ti_clients[i].nick[0] ? ti_clients[i].nick : cl.players[i].name); // we use nick or name
		maxname = max(maxname, strlen(TP_ParseFunChars(nick, false)));

		strlcpy(tmp, TP_LocationName(ti_clients[i].org), sizeof(tmp));
		maxloc = max(maxloc, strlen(TP_ParseFunChars(tmp, false)));

		slots[slots_num++] = i;
	}

	qsort(slots, slots_num, sizeof(slots[0]), HUD_CompareTeamInfoSlots);

	// well, better use fixed loc length
	maxloc = bound(0, hud_teaminfo_loc_width->integer, 100);
	// limit name length
	maxname = bound(0, maxname, hud_teaminfo_name_width->integer);

	header_spacing = max(0, hud_teaminfo_header_spacing->value);

	// this doesn't draw anything, just calculate width
	width = SCR_HudDrawTeamInfoPlayer(&ti_clients[0], 0, 0, maxname, maxloc, true, hud_teaminfo_scale->value, hud_teaminfo_layout->string, hud_teaminfo_weapon_style->integer, hud_teaminfo_show_ammo->integer, hud_teaminfo_show_countdown->integer, hud_teaminfo_armor_style->integer, hud_teaminfo_powerup_style->integer, hud_teaminfo_flag_style->integer, hud_teaminfo_low_health->integer, hud_teaminfo_proportional->integer);
	height = FONTWIDTH * hud_teaminfo_scale->value * (hud_teaminfo_show_enemies->integer && hud_teaminfo_show_headers->integer ? slots_num + max(2 * n_teams - 1, 0) * header_spacing : slots_num);

	if (hud_editor) {
		HUD_PrepareDraw(hud, width, FONTWIDTH, &x, &y);
	}

	if (!slots_num) {
		return;
	}

	if (!cl.teamplay) {
		// non teamplay mode
		return;
	}

	if (!HUD_PrepareDraw(hud, width, height, &x, &y)) {
		return;
	}

	_y = y;
	x = (hud_teaminfo_align_right->value ? x - (width * (FONTWIDTH * hud_teaminfo_scale->value)) : x);

	// If multiple teams are displayed then sort the display and print team header on overlay
	k = 0;
	if (hud_teaminfo_show_enemies->integer) {
		while (sorted_teams[k].name) {
			// hmx : different name/scores alignment options are possible in the header
			// in which case, make sure to differentiate name width vs teaminfo width
			// i.e int name_width = Draw_SString()
			if (hud_teaminfo_show_headers->integer) {
				if (k > 0) { // separator between teams
					_y += FONTWIDTH * hud_teaminfo_scale->value * header_spacing;
				}

				Draw_SString(x, _y, sorted_teams[k].name, hud_teaminfo_scale->value, hud_teaminfo_proportional->integer);
				snprintf(tmp, sizeof(tmp), "%s %4i", TP_ParseFunChars("$.", false), sorted_teams[k].frags);
				Draw_SStringAligned(x, _y, tmp, hud_teaminfo_scale->value, 1.0f, hud_teaminfo_proportional->integer, text_align_right, x + width);
				_y += FONTWIDTH * hud_teaminfo_scale->value;
			}
			for (j = 0; j < slots_num; j++) {
				i = slots[j];
				if (!strcmp(cl.players[i].team, sorted_teams[k].name)) {
					SCR_HudDrawTeamInfoPlayer(&ti_clients[i], x, _y, maxname, maxloc, false, hud_teaminfo_scale->value, hud_teaminfo_layout->string, hud_teaminfo_weapon_style->integer, hud_teaminfo_show_ammo->integer, hud_teaminfo_show_countdown->integer, hud_teaminfo_armor_style->integer, hud_teaminfo_powerup_style->integer, hud_teaminfo_flag_style->integer, hud_teaminfo_low_health->integer, hud_teaminfo_proportional->integer);
					_y += FONTWIDTH * hud_teaminfo_scale->value;
				}
			}
			k++;
		}
	}
	else {
		for (j = 0; j < slots_num; j++) {
			i = slots[j];
			SCR_HudDrawTeamInfoPlayer(&ti_clients[i], x, _y, maxname, maxloc, false, hud_teaminfo_scale->value, hud_teaminfo_layout->string, hud_teaminfo_weapon_style->integer, hud_teaminfo_show_ammo->integer, hud_teaminfo_show_countdown->integer, hud_teaminfo_armor_style->integer, hud_teaminfo_powerup_style->integer, hud_teaminfo_flag_style->integer, hud_teaminfo_low_health->integer, hud_teaminfo_proportional->integer);
			_y += FONTWIDTH * hud_teaminfo_scale->value;
		}
	}
}

qbool Has_Both_RL_and_LG(int flags)
{
	return (flags & IT_ROCKET_LAUNCHER) && (flags & IT_LIGHTNING);
}

static int SCR_HudDrawTeamInfoPlayer(ti_player_t *ti_cl, float x, int y, int maxname, int maxloc, qbool width_only, float scale, const char* layout, int weapon_style, int show_ammo, int show_countdown, int armor_style, int powerup_style, int flag_style, int low_health, qbool proportional)
{
	extern cvar_t tp_name_rlg;
	char *s, *loc, tmp[1024], tmp2[MAX_MACRO_STRING], *aclr, *txtclr;
	float x_in = x; // save x
	int i, a;
	qbool isDeadCA, isRespawning;
	mpic_t *pic;
	float width;
	float font_width = scale * FONT_WIDTH;
	float alpha;

	extern mpic_t *sb_face_invis, *sb_face_quad, *sb_face_invuln;
	extern mpic_t *sb_armor[3];
	extern mpic_t *sb_items[32];

	if (!ti_cl) {
		return 0;
	}

	txtclr = "&cfff";
	isDeadCA = ti_cl->isdead;
	isRespawning = isDeadCA && ti_cl->timetospawn > 0 && ti_cl->timetospawn < 999;
	
	if (isDeadCA) {
		alpha = 0.25;
	}
	else {
		alpha = 1.0;
	}

	i = ti_cl->client;
	if (i < 0 || i >= MAX_CLIENTS) {
		Com_DPrintf("SCR_Draw_TeamInfoPlayer: wrong client %d\n", i);
		return 0;
	}

	// this limit len of string because TP_ParseFunChars() do not check overflow
	strlcpy(tmp2, layout, sizeof(tmp2));
	strlcpy(tmp2, TP_ParseFunChars(tmp2, false), sizeof(tmp2));
	s = tmp2;

	switch (BestWeaponFromStatItems(ti_cl->items)){
		case IT_LIGHTNING:
			a = ti_cl->cells;
			break;
		case IT_ROCKET_LAUNCHER:
		case IT_GRENADE_LAUNCHER:
			a = ti_cl->rockets;
			break;
		case IT_SUPER_NAILGUN:
		case IT_NAILGUN:
			a = ti_cl->nails;
			break;
		default:
			a = ti_cl->shells;
			break;
	}

	//
	// parse/draw string like this "%n %h:%a %l %p %w"
	//
	for (; *s; s++) {
		switch ((int)s[0]) {
			case '%':
				s++; // advance

				switch ((int)s[0]) {
					case 'n': // draw name
						width = maxname * font_width;
						if (!width_only) {
							char *nick = TP_ParseFunChars(ti_cl->nick[0] ? ti_cl->nick : cl.players[i].shortname, false);
							snprintf(tmp, sizeof(tmp), "%s%s", txtclr, nick);
							Draw_SStringAligned(x, y, tmp, scale, alpha, proportional, text_align_right, x + width);
						}
						x += width;
						break;
					case 'w': // draw "best" weapon icon/name
					case 'W': // draw "best" weapon icon/name
						switch (weapon_style) {
							case 1:
								if (!width_only) {
									char *weap_str;
									if (Has_Both_RL_and_LG(ti_cl->items)) {
										weap_str = tp_name_rlg.string;
									} 
									else {
										weap_str = TP_ItemName(BestWeaponFromStatItems(ti_cl->items));
									}
									char weap_white_stripped[32];
									Util_SkipChars(weap_str, "{}", weap_white_stripped, 32);
									snprintf(tmp, sizeof(tmp), "%s%s", txtclr, isDeadCA ? "--" : weap_white_stripped);
									Draw_SStringAligned(x, y, tmp, scale, alpha, proportional, ((s[0] == 'W' || show_ammo) ? text_align_right : text_align_left), x + 3 * font_width);
								}
								x += 3 * font_width;
								break;
							default: // draw image by default
								if (!width_only) {
									if (!isDeadCA && (pic = SCR_GetWeaponIconByFlag(BestWeaponFromStatItems(ti_cl->items)))) {
										Draw_SAlphaPic(x, y, pic, alpha, 0.5 * scale);
									}
								}
								x += 2 * font_width;
								break;
						}
						if (show_ammo) {
							if (!width_only) {
								if (isDeadCA){
									snprintf(tmp, sizeof(tmp), "%s", txtclr);
								} 
								else {
									snprintf(tmp, sizeof(tmp), "%s:%d", txtclr, a);
								}
								
								Draw_SStringAligned(x, y, tmp, scale, alpha, proportional, text_align_left, x + 4 * font_width);
								
							}
							x += 4 * font_width;
						}
						break;
					case 'k': // draw ammo
					case 'K': // draw ammo
						if (!width_only) {
							snprintf(tmp, sizeof(tmp), "%s%d", txtclr, a);
							Draw_SStringAligned(x, y, tmp, scale, alpha, proportional, (s[0] == 'C' ? text_align_right : text_align_left), x + 3 * font_width);
						}
						x += 3 * font_width;
						break;
					case 'r': // draw respawn time
					case 'R': // draw respawn time
						if (!width_only) {
							if (isRespawning)
							{
								snprintf(tmp, sizeof(tmp), "&cfa0%d", ti_cl->timetospawn);
							}
							else
							{
								snprintf(tmp, sizeof(tmp), "%s", " ");
							}
							Draw_SStringAligned(x, y, tmp, scale * 0.75, 1.0, proportional, (s[0] == 'r' ? text_align_right : text_align_left), x + 2 * font_width);
						}
						x += 2 * font_width;
						break;
					case 'h': // draw health, padding with space on left side
					case 'H': // draw health, padding with space on right side
						if (!width_only) {
							if (isDeadCA){
								snprintf(tmp, sizeof(tmp), "%s--", txtclr); // print dashes if dead
							}
							else {
								snprintf(tmp, sizeof(tmp), "%s%d", (ti_cl->health < low_health ? "&cf00" : txtclr), ti_cl->health);
							}
							Draw_SStringAligned(x, y, tmp, scale, alpha, proportional, (s[0] == 'h' ? text_align_right : text_align_left), x + 3 * font_width);
						}
						x += 3 * font_width;
						break;

					case 'f': // draw frags, space on left side
					case 'F': // draw frags, space on right side
						if (!width_only) {
							snprintf(tmp, sizeof(tmp), (s[0] == 'f' ? "%s%3d" : "%s%-3d"), txtclr, cl.players[i].frags);
							Draw_SStringAligned(x, y, tmp, scale, alpha, proportional, (s[0] == 'f' ? text_align_right : text_align_left), x + 3 * font_width);
						}
						x += 3 * FONTWIDTH * scale;
						break;

					case 'a': // draw armor, padded with space on left side
					case 'A': // draw armor, padded with space on right side
						//
						// different styles of armor
						//
						aclr = txtclr;
						switch (armor_style) {
							case 1: // image prefixed armor value
								if (!width_only) {
									if (ti_cl->items & IT_ARMOR3)
										Draw_SAlphaPic(x, y, sb_armor[2], alpha, 1.0 / 3 * scale);
									else if (ti_cl->items & IT_ARMOR2)
										Draw_SAlphaPic(x, y, sb_armor[1], alpha, 1.0 / 3 * scale);
									else if (ti_cl->items & IT_ARMOR1)
										Draw_SAlphaPic(x, y, sb_armor[0], alpha, 1.0 / 3 * scale);
								}
								x += font_width;
								break;
							case 2: // colored background of armor value
								/*
									if (!width_only) {
										byte col[4] = {255, 255, 255, 0};

										if (ti_cl->items & IT_ARMOR3) {
											col[0] = 255; col[1] =   0; col[2] =   0; col[3] = 255;
										}
										else if (ti_cl->items & IT_ARMOR2) {
											col[0] = 255; col[1] = 255; col[2] =   0; col[3] = 255;
										}
										else if (ti_cl->items & IT_ARMOR1) {
											col[0] =   0; col[1] = 255; col[2] =   0; col[3] = 255;
										}
									}
								*/
								break;
							case 3: // colored armor value
								if (!width_only) {
									if (ti_cl->items & IT_ARMOR3) {
										aclr = "&cf00";
									}
									else if (ti_cl->items & IT_ARMOR2) {
										aclr = "&cff0";
									}
									else if (ti_cl->items & IT_ARMOR1) {
										aclr = "&c0f0";
									}
								}
								break;
							case 4: // armor value prefixed with letter
								if (!width_only) {
									if (ti_cl->items & IT_ARMOR3)
										Draw_SStringAlpha(x, y, "r", scale, alpha, proportional);
									else if (ti_cl->items & IT_ARMOR2)
										Draw_SStringAlpha(x, y, "y", scale, alpha, proportional);
									else if (ti_cl->items & IT_ARMOR1)
										Draw_SStringAlpha(x, y, "g", scale, alpha, proportional);
								}
								x += font_width;
								break;
						}

						if (!width_only) {
							// value drawn no matter which style
							if (isDeadCA){
								snprintf(tmp, sizeof(tmp), "%s--", txtclr); // print dashes if dead
							}
							else {
								snprintf(tmp, sizeof(tmp), "%s%d", aclr, ti_cl->armor);
							}
							Draw_SStringAligned(x, y, tmp, scale, alpha, proportional, s[0] == 'A' ? text_align_left : text_align_right, x + 3 * font_width);
						}
						x += 3 * font_width;
						break;

					case 'l': // draw location
						width = maxloc * font_width;
						if (!width_only) {
							loc = TP_LocationName(ti_cl->org);
							if (!loc[0]) {
								loc = "unknown";
							}
							loc = TP_ParseFunChars(loc, false);
							if (isDeadCA){
								snprintf(tmp, sizeof(tmp), "%sdead", txtclr);
							}
							else {
								snprintf(tmp, sizeof(tmp), "%s%s", txtclr, loc);
							}
							Draw_SStringAligned(x, y, tmp, scale, alpha, proportional, text_align_right, x + width);
						}
						x += width;
						break;

					case 'p': // draw powerups
						if (show_countdown && check_ktx_ca_wo())
						{
							if (!width_only) {
								if (isRespawning)
								{
									snprintf(tmp, sizeof(tmp), "&cfa0%d ", ti_cl->timetospawn);
								}
								else
								{
									snprintf(tmp, sizeof(tmp), "%s", " ");
								}
								Draw_SStringAligned(x, y, tmp, scale * 0.75, 1.0, proportional, text_align_right, x + 3 * font_width);
							}
							x += 3 * font_width;
							break;
						}
						else {
							switch (powerup_style) {
								case 1: // quad/pent/ring image
									if (!width_only) {
										if (ti_cl->items & IT_QUAD) {
											Draw_SPic(x, y, sb_items[5], scale / 2);
										}
										x += font_width;
										if (ti_cl->items & IT_INVULNERABILITY) {
											Draw_SPic(x, y, sb_items[3], scale / 2);
										}
										x += font_width;
										if (ti_cl->items & IT_INVISIBILITY) {
											Draw_SPic(x, y, sb_items[2], scale / 2);
										}
										x += font_width;
									}
									else { 
										x += 3 * font_width;
									}
									break;

								case 2: // player powerup face
									if (!width_only) {
										if (sb_face_quad && (ti_cl->items & IT_QUAD)) {
											Draw_SPic(x, y, sb_face_quad, scale / 3);
										}
										x += font_width;
										if (sb_face_invuln && (ti_cl->items & IT_INVULNERABILITY)) {
											Draw_SPic(x, y, sb_face_invuln, scale / 3);
										}
										x += font_width;
										if (sb_face_invis && (ti_cl->items & IT_INVISIBILITY)) {
											Draw_SPic(x, y, sb_face_invis, scale / 3);
										}
										x += font_width;
									}
									else {
										x += 3 * font_width;
									}
									break;

								case 3: // colored font (QPR)
									if (!width_only) {
										if (ti_cl->items & IT_QUAD) {
											Draw_SString(x, y, "&c03fQ", scale, proportional);
										}
										x += font_width;
										if (ti_cl->items & IT_INVULNERABILITY) {
											Draw_SString(x, y, "&cf00P", scale, proportional);
										}
										x += font_width;
										if (ti_cl->items & IT_INVISIBILITY) {
											Draw_SString(x, y, "&cff0R", scale, proportional);
										}
										x += font_width;
									}
									else {
										x += 3 * font_width;
									}
									break;
							}
						}
						break;

					case 't':
						if (!width_only) {
							sprintf(tmp, "%s%i", txtclr, Player_GetTrackId(cl.players[ti_cl->client].userid));
							Draw_SStringAlpha(x, y, tmp, scale, alpha, proportional);
						}
						x += (Player_GetTrackId(cl.players[ti_cl->client].userid) >= 10 ? 2 : 1) * font_width;
						break;

					case 'c':
						switch (flag_style) {
							case 1:
								if (!width_only) {
									if (ti_cl->items & IT_KEY1) {
										Draw_SPic(x, y, sb_items[0], scale / 2);
									} else if (ti_cl->items & IT_KEY2) {
										Draw_SPic(x, y, sb_items[1], scale / 2);
									}
								}
								break;
							case 2:
								if (!width_only) {
									if (ti_cl->items & IT_KEY1) {
										Draw_SString(x, y, "&cf00B", scale, proportional);
									} else if (ti_cl->items & IT_KEY2) {
										Draw_SString(x, y, "&c00fR", scale, proportional);
									}
								}
								break;
						}
						x += font_width;
						break;

					case '%': // wow, %% result in one %, how smart
						if (!width_only) {
							snprintf(tmp, sizeof(tmp), "%s%s", txtclr, "%");
							Draw_SStringAlpha(x, y, tmp, scale, alpha, proportional);
						}
						x += font_width;
						break;

					default: // print %x - that mean sequence unknown
						if (!width_only) {
							snprintf(tmp, sizeof(tmp), "%%%c", s[0]);
							Draw_SStringAlpha(x, y, tmp, scale, alpha, proportional);
						}
						x += (s[0] ? 2 : 1) * font_width;
						break;
				}

				break;

			default: // print x
				if (!width_only) {
					snprintf(tmp, sizeof(tmp), "%s%c", txtclr, s[0]);
					if (s[0] != ' ') {
						// inhuman smart optimization, do not print space!
						Draw_SStringAlpha(x, y, tmp, scale, alpha, proportional);
					}
				}
				x += font_width;
				break;
		}
	}

	return (x - x_in); // return width
}


// ORIGINAL teaminfo (cl_screen.c)

// scr_teaminfo 
// Variable ti_clients and related functions also used by hud_teaminfo in hud_common.c
ti_player_t ti_clients[MAX_CLIENTS];

void SCR_ClearTeamInfo(void)
{
	memset(ti_clients, 0, sizeof(ti_clients));
}

void SCR_Draw_TeamInfo(void)
{
	int x, y, w, h;
	int i, j, slots[MAX_CLIENTS], slots_num, maxname, maxloc;
	char tmp[1024], *nick;

	float	scale = bound(0.1, scr_teaminfo_scale.value, 10);

	if (!cl.teamplay || !scr_teaminfo.integer) {
		// non teamplay mode
		return;
	}

	if (cls.mvdplayback) {
		Update_TeamInfo();
	}

	// fill data we require to draw teaminfo
	for (maxloc = maxname = slots_num = i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator
			|| !ti_clients[i].time || ti_clients[i].time + TI_TIMEOUT < r_refdef2.time
			)
			continue;

		// do not show enemy players unless it's MVD and user wishes to show them
		if (VX_TrackerIsEnemy(i) && (!cls.mvdplayback || !scr_teaminfo_show_enemies.integer))
			continue;

		// do not show tracked player to spectator
		if ((cl.spectator && Cam_TrackNum() == i) && !TEAMINFO_SHOWSELF())
			continue;

		// dynamically guess max length of name/location
		nick = (ti_clients[i].nick[0] ? ti_clients[i].nick : cl.players[i].name); // we use nick or name
		maxname = max(maxname, strlen(TP_ParseFunChars(nick, false)));

		strlcpy(tmp, TP_LocationName(ti_clients[i].org), sizeof(tmp));
		maxloc = max(maxloc, strlen(TP_ParseFunChars(tmp, false)));

		slots[slots_num++] = i;
	}

	// well, better use fixed loc length
	maxloc = bound(0, scr_teaminfo_loc_width.integer, 100);
	// limit name length
	maxname = bound(0, maxname, scr_teaminfo_name_width.integer);

	if (!slots_num) {
		return;
	}

	y = vid.height * 0.6 + scr_teaminfo_y.value;

	// this does't draw anything, just calculate width
	w = SCR_HudDrawTeamInfoPlayer(&ti_clients[0], 0, 0, maxname, maxloc, true, scr_teaminfo_scale.value, scr_teaminfo_order.string, scr_teaminfo_weapon_style.integer, scr_teaminfo_show_ammo.integer, scr_teaminfo_show_countdown.integer, scr_teaminfo_armor_style.integer, scr_teaminfo_powerup_style.integer, scr_teaminfo_flag_style.integer, scr_teaminfo_low_health.integer, scr_teaminfo_proportional.integer);
	h = slots_num * scale;

	for (j = 0; j < slots_num; j++) {
		i = slots[j];

		x = (scr_teaminfo_align_right.value ? (vid.width - w) - FONTWIDTH : FONTWIDTH);
		x += scr_teaminfo_x.value;

		if (!j) { // draw frame
			byte	*col = scr_teaminfo_frame_color.color;

			Draw_AlphaRectangleRGB(x, y, w, h * FONTWIDTH, 0, true, RGBAVECT_TO_COLOR(col));
		}

		SCR_HudDrawTeamInfoPlayer(&ti_clients[i], x, y, maxname, maxloc, false, scr_teaminfo_scale.value, scr_teaminfo_order.string, scr_teaminfo_weapon_style.integer, scr_teaminfo_show_ammo.integer, scr_teaminfo_show_countdown.integer, scr_teaminfo_armor_style.integer, scr_teaminfo_powerup_style.integer, scr_teaminfo_flag_style.integer, scr_teaminfo_low_health.integer, scr_teaminfo_proportional.integer);

		y += FONTWIDTH * scale;
	}
}

#define FLAGS_RUNES_MASK (IT_SIGIL1 | IT_SIGIL2 | IT_SIGIL3 | IT_SIGIL4 | IT_KEY1 | IT_KEY2)

static int Filter_FlagsAndRunes(int client, int stats)
{
	if (!Stats_IsFlagsParsed()) {
		return stats;
	}
	return (ti_clients[client].items & FLAGS_RUNES_MASK) | (stats & ~FLAGS_RUNES_MASK);
}

void Parse_TeamInfo(char *s)
{
	int		client;

	Cmd_TokenizeString(s);

	client = atoi(Cmd_Argv(1));

	if (client < 0 || client >= MAX_CLIENTS) {
		Com_DPrintf("Parse_TeamInfo: wrong client %d\n", client);
		return;
	}

	ti_clients[client].client = client; // no, its not stupid

	ti_clients[client].time = r_refdef2.time;

	ti_clients[client].org[0] = atoi(Cmd_Argv(2));
	ti_clients[client].org[1] = atoi(Cmd_Argv(3));
	ti_clients[client].org[2] = atoi(Cmd_Argv(4));
	ti_clients[client].health = atoi(Cmd_Argv(5));
	ti_clients[client].armor = atoi(Cmd_Argv(6));
	ti_clients[client].items = Filter_FlagsAndRunes(client, atoi(Cmd_Argv(7)));
	strlcpy(ti_clients[client].nick, Cmd_Argv(8), TEAMINFO_NICKLEN); // nick is optional
	ti_clients[client].shells = atoi(Cmd_Argv(9));
	ti_clients[client].nails = atoi(Cmd_Argv(10));
	ti_clients[client].rockets = atoi(Cmd_Argv(11));
	ti_clients[client].cells = atoi(Cmd_Argv(12));
}

void Parse_CAInfo(char *s)
{
	int		client;

	Cmd_TokenizeString(s);
	client = atoi(Cmd_Argv(1));

	if (client < 0 || client >= MAX_CLIENTS) {
		Com_DPrintf("Parse_CAInfo: wrong client %d\n", client);
		return;
	}

	if (!cls.mvdplayback) {
		ti_clients[client].client = client; // no, its not stupid
		ti_clients[client].time = r_refdef2.time;
		ti_clients[client].org[0] = atoi(Cmd_Argv(2));
		ti_clients[client].org[1] = atoi(Cmd_Argv(3));
		ti_clients[client].org[2] = atoi(Cmd_Argv(4));
		ti_clients[client].health = atoi(Cmd_Argv(5));
		ti_clients[client].armor = atoi(Cmd_Argv(6));
		ti_clients[client].items = atoi(Cmd_Argv(7));
		strlcpy(ti_clients[client].nick, Cmd_Argv(8), TEAMINFO_NICKLEN); // nick is optional
		ti_clients[client].shells = atoi(Cmd_Argv(9));
		ti_clients[client].nails = atoi(Cmd_Argv(10));
		ti_clients[client].rockets = atoi(Cmd_Argv(11));
		ti_clients[client].cells = atoi(Cmd_Argv(12));
	}
	
	ti_clients[client].camode = atoi(Cmd_Argv(13));
	ti_clients[client].isdead = atoi(Cmd_Argv(14));
	ti_clients[client].timetospawn = atoi(Cmd_Argv(15));
	ti_clients[client].round_kills = atoi(Cmd_Argv(16));
	ti_clients[client].round_deaths = atoi(Cmd_Argv(17));
}

void Update_FlagStatus(int player_num, char *team, qbool got_flag)
{
	int flag = IT_KEY1 | IT_KEY2;
	if (!strcmp(team, "blue")) {
		flag = IT_KEY2;
	} else if (!strcmp(team, "red")) {
		flag = IT_KEY1;
	}

	if (got_flag) {
		ti_clients[player_num].items |= flag;
	} else {
		ti_clients[player_num].items &= ~flag;
	}
}

static void Update_TeamInfo(void)
{
	int		i;
	int		*st;

	static double lastupdate = 0;

	if (!cls.mvdplayback) {
		return;
	}

	// don't update each frame - it's less disturbing
	if (cls.realtime - lastupdate < 1)
		return;

	lastupdate = cls.realtime;

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].spectator || !cl.players[i].name[0])
			continue;

		st = cl.players[i].stats;

		ti_clients[i].client = i; // no, its not stupid

		ti_clients[i].time = r_refdef2.time;

		VectorCopy(cl.frames[cl.parsecount & UPDATE_MASK].playerstate[i].origin, ti_clients[i].org);

		ti_clients[i].health = bound(0, st[STAT_HEALTH], 999);
		ti_clients[i].armor = bound(0, st[STAT_ARMOR], 999);
		ti_clients[i].items = Filter_FlagsAndRunes(i, st[STAT_ITEMS]);
		ti_clients[i].shells = bound(0, st[STAT_SHELLS], 999);
		ti_clients[i].nails = bound(0, st[STAT_NAILS], 999);
		ti_clients[i].rockets = bound(0, st[STAT_ROCKETS], 999);
		ti_clients[i].cells = bound(0, st[STAT_CELLS], 999);
		ti_clients[i].nick[0] = 0; // sad, we don't have nick, will use name
	}
}

void TeamInfo_HudInit(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register(&scr_shownick_order);
	Cvar_Register(&scr_shownick_frame_color);
	Cvar_Register(&scr_shownick_scale);
	Cvar_Register(&scr_shownick_y);
	Cvar_Register(&scr_shownick_x);
	Cvar_Register(&scr_shownick_name_width);
	Cvar_Register(&scr_shownick_time);
	Cvar_Register(&scr_shownick_proportional);
	Cvar_Register(&scr_shownick_show_ammo);

	Cvar_Register(&scr_teaminfo_order);
	Cvar_Register(&scr_teaminfo_align_right);
	Cvar_Register(&scr_teaminfo_frame_color);
	Cvar_Register(&scr_teaminfo_scale);
	Cvar_Register(&scr_teaminfo_y);
	Cvar_Register(&scr_teaminfo_x);
	Cvar_Register(&scr_teaminfo_loc_width);
	Cvar_Register(&scr_teaminfo_name_width);
	Cvar_Register(&scr_teaminfo_low_health);
	Cvar_Register(&scr_teaminfo_armor_style);
	Cvar_Register(&scr_teaminfo_powerup_style);
	Cvar_Register(&scr_teaminfo_flag_style);
	Cvar_Register(&scr_teaminfo_weapon_style);
	Cvar_Register(&scr_teaminfo_show_ammo);
	Cvar_Register(&scr_teaminfo_show_countdown);
	Cvar_Register(&scr_teaminfo_show_enemies);
	Cvar_Register(&scr_teaminfo_show_self);
	Cvar_Register(&scr_teaminfo_proportional);
	Cvar_Register(&scr_teaminfo);

	HUD_Register(
		"teaminfo", NULL, "Show information about your team in short form.",
		0, ca_active, 0, SCR_HUD_DrawTeamInfo,
		"0", "", "right", "center", "0", "0", "0.2", "20 20 20", NULL,
		"layout", "%p%n $x10%l$x11 %a/%H %w",
		"align_right", "0",
		"loc_width", "5",
		"name_width", "6",
		"low_health", "25",
		"armor_style", "3",
		"weapon_style", "0",
		"show_ammo", "0",
		"show_countdown", "1",
		"show_enemies", "0",
		"show_self", "1",
		"show_headers", "1",
		"scale", "1",
		"powerup_style", "1",
		"flag_style", "1",
		"proportional", "0",
		"header_spacing", "1",
		NULL
	);
}



// SHOWNICK


/***************************** customizeable shownick *************************/

static ti_player_t shownick;

void SCR_ClearShownick(void)
{
	memset(&shownick, 0, sizeof(shownick));
}

void Parse_Shownick(char *s)
{
	int		client, version, arg;

	Cmd_TokenizeString(s);

	arg = 1;

	version = atoi(Cmd_Argv(arg++));

	switch (version) {
		case 1:
		{
			client = atoi(Cmd_Argv(arg++));

			if (client < 0 || client >= MAX_CLIENTS) {
				Com_DPrintf("Parse_Shownick: wrong client %d\n", client);
				return;
			}

			shownick.client = client;

			shownick.time = r_refdef2.time;

			shownick.org[0] = atoi(Cmd_Argv(arg++));
			shownick.org[1] = atoi(Cmd_Argv(arg++));
			shownick.org[2] = atoi(Cmd_Argv(arg++));
			shownick.health = atoi(Cmd_Argv(arg++));
			shownick.armor = atoi(Cmd_Argv(arg++));
			shownick.items = atoi(Cmd_Argv(arg++));
			strlcpy(shownick.nick, Cmd_Argv(arg++), TEAMINFO_NICKLEN); // nick is optional
			shownick.shells = atoi(Cmd_Argv(arg++));
			shownick.nails = atoi(Cmd_Argv(arg++));
			shownick.rockets = atoi(Cmd_Argv(arg++));
			shownick.cells = atoi(Cmd_Argv(arg++));

			return;
		}

		default:
			Com_DPrintf("Parse_Shownick: unsupported version %d\n", version);
			return;
	}
}

static void Update_Shownick(void)
{
	int		i;
	int		*st;

	if (!cls.mvdplayback) {
		return;
	}

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].spectator || !cl.players[i].name[0])
			continue;

		if (i != shownick.client)
			continue;
			
		st = cl.players[i].stats;

		shownick.client = i; // no, its not stupid

		VectorCopy(cl.frames[cl.parsecount & UPDATE_MASK].playerstate[i].origin, shownick.org);

		shownick.health = bound(0, st[STAT_HEALTH], 999);
		shownick.armor = bound(0, st[STAT_ARMOR], 999);
		shownick.items = st[STAT_ITEMS];
		shownick.shells = bound(0, st[STAT_SHELLS], 999);
		shownick.nails = bound(0, st[STAT_NAILS], 999);
		shownick.rockets = bound(0, st[STAT_ROCKETS], 999);
		shownick.cells = bound(0, st[STAT_CELLS], 999);
		shownick.nick[0] = 0; // sad, we don't have nick, will use name
	}
}

void SCR_Draw_ShowNick(void)
{
	qbool	scr_shownick_align_right = false;
	int		x, y, w, h;
	int		maxname, maxloc;
	byte	*col;
	float	scale = bound(0.1, scr_shownick_scale.value, 10);

	// check do we have something do draw
	if (!shownick.time || shownick.time + bound(0.1, scr_shownick_time.value, 3) < r_refdef2.time) {
		return;
	}

	if (cls.mvdplayback) {
		Update_Shownick();
	}

	// loc is unused
	maxloc = 0;

	// limit name length
	maxname = 999;
	maxname = bound(0, maxname, scr_shownick_name_width.integer);

	y = vid.height * 0.6 + scr_shownick_y.value;

	// this does't draw anything, just calculate width
	w = SCR_HudDrawTeamInfoPlayer(&shownick, 0, 0, maxname, maxloc, true, scale, scr_shownick_order.string, scr_teaminfo_weapon_style.integer, scr_shownick_show_ammo.integer, 0, scr_teaminfo_armor_style.integer, scr_teaminfo_powerup_style.integer, scr_teaminfo_flag_style.integer, scr_teaminfo_low_health.integer, scr_shownick_proportional.integer);
	h = FONTWIDTH * scale;

	x = (scr_shownick_align_right ? (vid.width - w) - FONTWIDTH : FONTWIDTH);
	x += scr_shownick_x.value;

	// draw frame
	col = scr_shownick_frame_color.color;

	Draw_AlphaRectangleRGB(x, y, w, h, 0, true, RGBAVECT_TO_COLOR(col));

	// draw shownick
	SCR_HudDrawTeamInfoPlayer(&shownick, x, y, maxname, maxloc, false, scale, scr_shownick_order.string, scr_teaminfo_weapon_style.integer, scr_shownick_show_ammo.integer, 0, scr_teaminfo_armor_style.integer, scr_teaminfo_powerup_style.integer, scr_teaminfo_flag_style.integer, scr_teaminfo_low_health.integer, scr_shownick_proportional.integer);
}


================================================
FILE: src/hud_tracking.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "hud.h"
#include "hud_common.h"
#include "sbar.h"
#include "utils.h"

// Tracking text.
// "Tracking: [team] name, JUMP for next", "Tracking:" and "JUMP" are brown. default: "Tracking %t %n, [JUMP] for next"
static cvar_t scr_tracking         = { "scr_tracking", "\xD4\xF2\xE1\xE3\xEB\xE9\xEE\xE7\xBA %t %n, \xCA\xD5\xCD\xD0 for next" };
static cvar_t scr_spectatorMessage = { "scr_spectatorMessage", "1" };

#define MAX_TRACKING_STRING		512

static void SCR_HUD_DrawTracking(hud_t *hud)
{
	int x = 0, y = 0, width = 0, height = 0;
	char track_string[MAX_TRACKING_STRING];
	int player = cl.spec_track;

	static cvar_t
		*hud_tracking_format = NULL,
		*hud_tracking_scale,
		*hud_tracking_proportional;

	if (!hud_tracking_format) {
		hud_tracking_format = HUD_FindVar(hud, "format");
		hud_tracking_scale = HUD_FindVar(hud, "scale");
		hud_tracking_proportional = HUD_FindVar(hud, "proportional");
	}

	strlcpy(track_string, hud_tracking_format->string, sizeof(track_string));
	Replace_In_String(track_string, sizeof(track_string), '%', 2,
		"n", cl.players[player].name,						// Replace %n with player name.
		"t", cl.teamplay ? cl.players[player].team : "");	// Replace %t with player team if teamplay is on.
	height = 8 * hud_tracking_scale->value;
	width = Draw_StringLength(track_string, -1, hud_tracking_scale->value, hud_tracking_proportional->integer);

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		if (cl.spectator && cl.autocam == CAM_TRACK) {
			// Normal
			Draw_SString(x, y, track_string, hud_tracking_scale->value, hud_tracking_proportional->integer);
		}
	}
}

void Tracking_HudInit(void)
{
	// Tracking JohnNy_cz (Contains name of the player who's player we're watching at the moment)
	HUD_Register(
		"tracking", NULL, "Shows the name of tracked player.",
		HUD_PLUSMINUS, ca_active, 9, SCR_HUD_DrawTracking,
		"1", "face", "center", "before", "0", "0", "0", "0 0 0", NULL,
		"format", "\xD4\xF2\xE1\xE3\xEB\xE9\xEE\xE7\xBA %t %n, \xCA\xD5\xCD\xD0 for next", //"Tracking: team name, JUMP for next", "Tracking:" and "JUMP" are brown. default: "Tracking %t %n, [JUMP] for next"
		"scale", "1", "proportional", "0",
		NULL
	);

	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register(&scr_tracking);
	Cvar_Register(&scr_spectatorMessage);
	Cvar_ResetCurrentGroup();
}

void Sbar_DrawSpectatorMessage(void)
{
	extern mpic_t* sb_scorebar;

	if (scr_spectatorMessage.value != 0) {
		Sbar_DrawPic(0, 0, sb_scorebar);
		Sbar_DrawString(160 - 7 * 8, 4, "SPECTATOR MODE");
		Sbar_DrawString(160 - 14 * 8 + 4, 12, "Press [ATTACK] for AutoCamera");
	}
}

void Sbar_DrawTrackingString(void)
{
	char st[512];
	extern cvar_t scr_tracking, scr_newHud;

	// If showing ammo on top of status, display higher up
	int y_coordinate = (Sbar_IsStandardBar() ? SBAR_HEIGHT - sb_lines : 0) - 8;

	if (sb_lines > 0 && scr_newHud.value != 1 && cl.spectator && cl.autocam == CAM_TRACK) {
		strlcpy(st, scr_tracking.string, sizeof(st));

		Replace_In_String(st, sizeof(st), '%', 2, "n", cl.players[cl.spec_track].name, "t", cl.teamplay ? cl.players[cl.spec_track].team : "");

		// Multiview
		// Fix displaying "tracking .." for both players with inset on
		if (cl_multiview.value != 2 || !cls.mvdplayback) {
			Sbar_DrawString(0, y_coordinate, st);
		}
		else if (CL_MultiviewCurrentView() == 1 && cl_mvinset.value) {
			Sbar_DrawString(0, y_coordinate, st);
		}
	}
}



================================================
FILE: src/hud_weapon_stats.c
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "teamplay.h"
#include "hud.h"
#include "hud_common.h"

typedef enum
{
	wpNONE = 0,
	wpAXE,
	wpSG,
	wpSSG,
	wpNG,
	wpSNG,
	wpGL,
	wpRL,
	wpLG,
	wpMAX
} weaponName_t;

typedef struct wpType_s {
	int hits;			// hits with this weapon, for SG and SSG this is count of bullets
	int attacks;		// all attacks with this weapon, for SG and SSG this is count of bullets
} wpType_t;

typedef struct ws_player_s {
	int 		client;

	wpType_t	wpn[wpMAX];
} ws_player_t;

static ws_player_t ws_clients[MAX_CLIENTS];

static weaponName_t WS_NameToNum(const char *name)
{
	if ( !strcmp(name, "axe") )
		return wpAXE;
	if ( !strcmp(name, "sg") )
		return wpSG;
	if ( !strcmp(name, "ssg") )
		return wpSSG;
	if ( !strcmp(name, "ng") )
		return wpNG;
	if ( !strcmp(name, "sng") )
		return wpSNG;
	if ( !strcmp(name, "gl") )
		return wpGL;
	if ( !strcmp(name, "rl") )
		return wpRL;
	if ( !strcmp(name, "lg") )
		return wpLG;

	return wpNONE;
}

// reads weapon stats string from server/demo
void Parse_WeaponStats(char *s)
{
	int		client, arg;
	weaponName_t wp;

	Cmd_TokenizeString( s );

	arg = 1;

	client = atoi( Cmd_Argv( arg++ ) );

	if (client < 0 || client >= MAX_CLIENTS)
	{
		Com_DPrintf("Parse_WeaponStats: wrong client %d\n", client);
		return;
	}

	ws_clients[ client ].client = client; // no, its not stupid

	wp = WS_NameToNum( Cmd_Argv( arg++ ) );

	if ( wp == wpNONE )
	{
		Com_DPrintf("Parse_WeaponStats: wrong weapon\n");
		return;
	}

	ws_clients[ client ].wpn[wp].attacks = atoi( Cmd_Argv( arg++ ) );
	ws_clients[ client ].wpn[wp].hits    = atoi( Cmd_Argv( arg++ ) );
}

// called when new map spawned
void SCR_ClearWeaponStats(void)
{
	memset(ws_clients, 0, sizeof(ws_clients));
}

// 
static void SCR_CreateWeaponStatsPlayerText(ws_player_t *ws_cl, char* input_string, char* output_string, int max_length)
{
	char *s, tmp2[MAX_MACRO_STRING];
	int new_length = 0;

	*output_string = '\0';
	if (!ws_cl) {
		return;
	}

	// this limit len of string because TP_ParseFunChars() do not check overflow
	strlcpy(tmp2, input_string , sizeof(tmp2));
	strlcpy(tmp2, TP_ParseFunChars(tmp2, false), sizeof(tmp2));

	for (s = tmp2; *s && new_length < max_length - 1; ++s) {
		int wp;
		qbool percentage = (*s == '%');

		if (*s != '%' && *s != '#') {
			output_string[new_length++] = *s;
			continue;
		}

		if (*s == s[1]) {
			output_string[new_length++] = *s;
			++s;
			continue;
		}

		++s;
		wp = (int)s[0] - '0'; 
		if (wp <= wpNONE || wp >= wpMAX) {
			continue; // unsupported weapon
		}

		if (percentage) {
			float accuracy = (ws_cl->wpn[wp].attacks ? 100.0f * ws_cl->wpn[wp].hits / ws_cl->wpn[wp].attacks : 0);

			new_length += snprintf(output_string + new_length, max_length - new_length - 1, "%.1f", accuracy);
		}
		else {
			new_length += snprintf(output_string + new_length, max_length - new_length - 1, "%d", ws_cl->wpn[wp].hits);
		}
	}
	output_string[new_length] = '\0';
}

void SCR_HUD_WeaponStats(hud_t *hud)
{
	char content[128];
	int x, y;
	int i;
	int alignment = 0;

	static cvar_t
		*hud_weaponstats_format = NULL,
		*hud_weaponstats_textalign,
		*hud_weaponstats_scale,
		*hud_weaponstats_proportional;

	if (hud_weaponstats_format == NULL) {
		// first time
		hud_weaponstats_format = HUD_FindVar(hud, "format");
		hud_weaponstats_textalign = HUD_FindVar(hud, "textalign");
		hud_weaponstats_scale = HUD_FindVar(hud, "scale");
		hud_weaponstats_proportional = HUD_FindVar(hud, "proportional");
	}

	if (!strcmp(hud_weaponstats_textalign->string, "right")) {
		alignment = 1;
	}
	else if (!strcmp(hud_weaponstats_textalign->string, "center")) {
		alignment = 2;
	}

	i = (cl.spectator ? Cam_TrackNum() : cl.playernum);
	if (i < 0 || i >= MAX_CLIENTS) {
		HUD_PrepareDraw(hud, 0, 0, &x, &y);
		return;
	}

	SCR_CreateWeaponStatsPlayerText(&ws_clients[i], hud_weaponstats_format->string, content, sizeof(content));

	SCR_HUD_MultiLineString(hud, content, false, alignment, hud_weaponstats_scale->value, hud_weaponstats_proportional->integer);
}

void OnChange_scr_weaponstats (cvar_t *var, char *value, qbool *cancel)
{
	extern void CL_UserinfoChanged (char *key, char *value);

	// do not allow set "wpsx" to "0" instead set it to ""
	CL_UserinfoChanged("wpsx", strcmp(value, "0") ? value : "");
}

static void SCR_MvdWeaponStatsOn_f(void)
{
	cvar_t* show = Cvar_Find("hud_weaponstats_show");
	if (show) {
		Cvar_Set (show, "1");
	}
}

static void SCR_MvdWeaponStatsOff_f(void)
{
	cvar_t* show = Cvar_Find("hud_weaponstats_show");
	if (show) {
		Cvar_Set (show, "0");
	}
}

void WeaponStats_HUDInit(void)
{
	cvar_t* show_cvar;

	HUD_Register(
		"weaponstats", NULL, "Weapon stats",
		0, ca_active, 0, SCR_HUD_WeaponStats,
		"0", "screen", "center", "bottom", "0", "0", "0", "0 0 0", NULL,
		"format", "&c990sg&r:%2 &c099ssg&r:%3 &c900rl&r:#7 &c009lg&r:%8",
		"textalign", "center",
		"scale", "1",
		"proportional", "0",
		NULL
	);

	show_cvar = Cvar_Find("hud_weaponstats_show");
	if (show_cvar) {
		show_cvar->OnChange = OnChange_scr_weaponstats;
	}
}

void WeaponStats_CommandInit(void)
{
	if (!host_initialized) {
		Cmd_AddCommand("+cl_wp_stats", SCR_MvdWeaponStatsOn_f);
		Cmd_AddCommand("-cl_wp_stats", SCR_MvdWeaponStatsOff_f);
	}
}


================================================
FILE: src/ignore.c
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: ignore.c,v 1.7 2007-03-11 06:01:40 disconn3ct Exp $
*/

#include "quakedef.h"
#include "ignore.h"
#include "utils.h"
#include "teamplay.h"


#define MAX_TEAMIGNORELIST	4
#define	FLOODLIST_SIZE		10

cvar_t		ignore_spec				= {"ignore_spec", "0"};		
cvar_t		ignore_qizmo_spec		= {"ignore_qizmo_spec", "0"};
cvar_t      ignore_qtv              = {"ignore_qtv", "0"};
cvar_t		ignore_mode				= {"ignore_mode", "0"};
cvar_t		ignore_flood_duration	= {"ignore_flood_duration", "4"};
cvar_t		ignore_flood			= {"ignore_flood", "0"};		
cvar_t		ignore_opponents		= {"ignore_opponents", "0"};
cvar_t		ignore_no_weapon		= {"ignore_no_weapon", "0"};
cvar_t		ignore_not_enough_ammo		= {"ignore_not_enough_ammo", "0"};

char ignoreteamlist[MAX_TEAMIGNORELIST][16 + 1];

typedef struct flood_s {
	char data[2048];
	float time;
} flood_t;

static flood_t floodlist[FLOODLIST_SIZE];
static int		floodindex;

extern void PaddedPrint (char *s);

static qbool IsIgnored(int slot) {
	return cl.players[slot].ignored;
}

static void Display_Ignorelist(void) {
	int i;

	Com_Printf ("\x02" "User Ignore List:\n");
	for (i = 0; i < MAX_CLIENTS; i++)
		if (cl.players[i].name[0] && cl.players[i].ignored)
			PaddedPrint(cl.players[i].name);
	if (con.x)
		Com_Printf ("\n");

#ifdef FTE_PEXT2_VOICECHAT
	Com_Printf ("\x02" "VOIP Ignore List:\n");
	for (i = 0; i < MAX_CLIENTS; i++)
		if (cl.players[i].name[0] && cl.players[i].vignored && !cl.players[i].ignored)
			PaddedPrint(cl.players[i].name);
	if (con.x)
		Com_Printf ("\n");
#endif

	Com_Printf ("\x02" "Team Ignore List:\n");
	for (i = 0; i < MAX_TEAMIGNORELIST && ignoreteamlist[i][0]; i++)
		PaddedPrint(ignoreteamlist[i]);
	if (con.x)
		Com_Printf ("\n");

	if (ignore_opponents.value)
		Com_Printf("\x02" "Opponents are Ignored\n");

	if (ignore_spec.value == 2 || (ignore_spec.value == 1 && !cl.spectator))
		Com_Printf ("\x02" "Spectators are Ignored\n");

	if (ignore_qizmo_spec.value)
		Com_Printf("\x02" "Qizmo spectators are Ignored\n");

	if (ignore_qtv.integer)
		Com_Printf("\x02" "QuakeTV observers are Ignored\n");

	Com_Printf("\n");
}

static qbool Ignorelist_Add(int slot) {
	if (IsIgnored(slot))
		return false;

	cl.players[slot].ignored = true;
#ifdef FTE_PEXT2_VOICECHAT
	cl.players[slot].vignored = true;
	S_Voip_Ignore(slot, true);
#endif
	return true;
}

static qbool Ignorelist_Del (int slot)
{
#ifdef FTE_PEXT2_VOICECHAT
	if (cl.players[slot].vignored) {
		cl.players[slot].vignored = false;
		S_Voip_Ignore (slot, false);
	}
#endif

	if (cl.players[slot].ignored == false)
		return false;

	cl.players[slot].ignored = false;
	return true;
}

static void Ignore_f(void) {
	int c, slot;

	if ((c = Cmd_Argc()) == 1) {
		Display_Ignorelist();
		return;
	} else if (c != 2) {
		Com_Printf("Usage: %s [userid | name]\n", Cmd_Argv(0));
		return;
	}

	if ((slot = Player_StringtoSlot(Cmd_Argv(1), true, true)) == PLAYER_ID_NOMATCH) {
		Com_Printf("%s : no player with userid %d\n", Cmd_Argv(0), Q_atoi(Cmd_Argv(1)));
	}
	else if (slot == PLAYER_NAME_NOMATCH) {
		Com_Printf("%s : no player with name %s\n", Cmd_Argv(0), Cmd_Argv(1));
	}
	else if (Ignorelist_Add (slot)) {
		Com_Printf ("Added user %s to ignore list\n", cl.players[slot].name);
	}
	else {
		Com_Printf ("User %s is already ignored\n", cl.players[slot].name);
	}
}

static void IgnoreList_f(void) {
	if (Cmd_Argc() != 1)
		Com_Printf("%s : no arguments expected\n", Cmd_Argv(0));
	else
		Display_Ignorelist();
}

static void Ignore_ID_f(void) {
	int c, userid, i, slot;
	char *arg;

	if ((c = Cmd_Argc()) == 1) {
		Display_Ignorelist();
		return;
	} else if (c != 2) {
		Com_Printf("Usage: %s [userid]\n", Cmd_Argv(0));
		return;
	}
	arg = Cmd_Argv(1);
	for (i = 0; arg[i]; i++) {
		if (!isdigit(arg[i])) {
			Com_Printf("Usage: %s [userid]\n", Cmd_Argv(0));
			return;
		}
	}
	userid = Q_atoi(arg);
	if ((slot = Player_IdtoSlot(userid)) == PLAYER_ID_NOMATCH) {
		Com_Printf("%s : no player with userid %d\n", Cmd_Argv(0), userid);
		return;
	}
	if (Ignorelist_Add(slot))
		Com_Printf("Added user %s to ignore list\n", cl.players[slot].name);
	else
		Com_Printf ("User %s is already ignored\n", cl.players[slot].name);
}

static void Unignore_f(void) {
	int c, slot;

	if ((c = Cmd_Argc()) == 1) {
		Display_Ignorelist();
		return;
	} else if (c != 2) {
		Com_Printf("Usage: %s [userid | name]\n", Cmd_Argv(0));
		return;
	}

	if ((slot = Player_StringtoSlot(Cmd_Argv(1), true, true)) == PLAYER_ID_NOMATCH) {
		Com_Printf("%s : no player with userid %d\n", Cmd_Argv(0), Q_atoi(Cmd_Argv(1)));
	} else if (slot == PLAYER_NAME_NOMATCH) {
		Com_Printf("%s : no player with name %s\n", Cmd_Argv(0), Cmd_Argv(1));
	} else {		
		if (Ignorelist_Del(slot))
			Com_Printf("Removed user %s from ignore list\n", cl.players[slot].name);
		else
			Com_Printf("User %s is not being ignored\n", cl.players[slot].name);
	}
}

static void Unignore_ID_f(void) {
	int c, i, userid, slot;
	char *arg;

	if ((c = Cmd_Argc()) == 1) {
		Display_Ignorelist();
		return;
	} else if (c != 2) {
		Com_Printf("Usage: %s [userid]\n", Cmd_Argv(0));
		return;
	}
	arg = Cmd_Argv(1);
	for (i = 0; arg[i]; i++) {
		if (!isdigit(arg[i])) {
			Com_Printf("Usage: %s [userid]\n", Cmd_Argv(0));
			return;
		}
	}
	userid = Q_atoi(arg);
	if ((slot = Player_IdtoSlot(userid)) == PLAYER_ID_NOMATCH) {
		Com_Printf("%s : no player with userid %d\n", Cmd_Argv(0), userid);
		return;
	}
	if (Ignorelist_Del(slot))
		Com_Printf("Removed user %s from ignore list\n", cl.players[slot].name);
	else
		Com_Printf("User %s is not being ignored\n", cl.players[slot].name);
}

static void Ignoreteam_f(void) {
	int c, i, j;
	char *arg;

	c = Cmd_Argc();
	if (c == 1) {
		Display_Ignorelist();
		return;
	} else if (c != 2) {
		Com_Printf("Usage: %s [team]\n", Cmd_Argv(0));
		return;
	}
	arg = Cmd_Argv(1);
	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0] && !cl.players[i].spectator && !strcmp(arg, cl.players[i].team)) {
			for (j = 0; j < MAX_TEAMIGNORELIST && ignoreteamlist[j][0]; j++) {
				if (!strncmp(arg, ignoreteamlist[j], sizeof(ignoreteamlist[j]) - 1)) {
					Com_Printf ("Team %s is already ignored\n", arg);
					return;
				}
			}
			if (j == MAX_TEAMIGNORELIST)
				Com_Printf("You cannot ignore more than %d teams\n", MAX_TEAMIGNORELIST);
			strlcpy(ignoreteamlist[j], arg, sizeof(ignoreteamlist[j]));
			if (j + 1 < MAX_TEAMIGNORELIST)
				ignoreteamlist[j + 1][0] = 0;			
			Com_Printf("Added team %s to ignore list\n", arg);
			return;
		}
	}
	Com_Printf("%s : no team with name %s\n", Cmd_Argv(0), arg);
}

static void Unignoreteam_f(void) {
	int i, c, j;
	char *arg;

	c = Cmd_Argc();
	if (c == 1) {
		Display_Ignorelist();
		return;
	} else if (c != 2) {
		Com_Printf("Usage: %s [team]\n", Cmd_Argv(0));
		return;
	}	
	arg = Cmd_Argv(1);
	for (i = 0; i < MAX_TEAMIGNORELIST && ignoreteamlist[i][0]; i++) {
		if (!strncmp(arg, ignoreteamlist[i], sizeof(ignoreteamlist[i]) - 1)) {
			for (j = i; j < MAX_TEAMIGNORELIST && ignoreteamlist[j][0]; j++) 
				;
			if ( --j >  i)
				strlcpy(ignoreteamlist[i], ignoreteamlist[j], sizeof(ignoreteamlist[i]));
			ignoreteamlist[j][0] = 0;			
			Com_Printf("Removed team %s from ignore list\n", arg);
			return;
		}
	}
	Com_Printf("Team %s is not being ignored\n", arg);
}

static void UnignoreAll_f (void) {
	int i;

	if (Cmd_Argc() != 1) {
		Com_Printf("%s : no arguments expected\n", Cmd_Argv(0));
		return;
	}
	for (i = 0; i < MAX_CLIENTS; i++)
		cl.players[i].ignored = false;
	Com_Printf("User ignore list cleared\n");
}

static void UnignoreteamAll_f (void) {
	if (Cmd_Argc() != 1) {
		Com_Printf("%s : no arguments expected\n", Cmd_Argv(0));
		return;
	}
	ignoreteamlist[0][0] = 0;
	Com_Printf("Team ignore list cleared\n");
}

char Ignore_Check_Flood(char *s, int flags, int offset) {
	int i, p, q, len;
	char name[MAX_INFO_STRING];

	if ( !(  
	 ( (ignore_flood.value == 1 && (flags == msgtype_normal || flags == msgtype_spec)) ||
	 (ignore_flood.value == 2 && flags != msgtype_unknown) )
	   )  )
		return NO_IGNORE_NO_ADD;

	if (flags == msgtype_normal || flags == msgtype_spec) {
		p = 0;
		q = offset - 3;
	} else if (flags == msgtype_team) {
		p = 1;
		q = offset - 4;
	} else if (flags == msgtype_specteam) {
		p = 7;
		q = offset -3;
	} else
		return NO_IGNORE_NO_ADD;

	len = bound (0, q - p + 1, MAX_INFO_STRING - 1);

	strlcpy(name, s + p, len + 1);
	if (!cls.demoplayback && !strcmp(name, Player_MyName())) {
		return NO_IGNORE_NO_ADD;
	}
	for (i = 0; i < FLOODLIST_SIZE; i++) {
		if (floodlist[i].data[0] && !strncmp(floodlist[i].data, s, sizeof(floodlist[i].data) - 1) &&
			cls.realtime - floodlist[i].time < ignore_flood_duration.value) {
			return IGNORE_NO_ADD;
		}
	}
	return NO_IGNORE_ADD;
}

void Ignore_Flood_Add(char *s) {

	floodlist[floodindex].data[0] = 0;
	strlcpy(floodlist[floodindex].data, s, sizeof(floodlist[floodindex].data));
	floodlist[floodindex].time = cls.realtime;
	floodindex++;
	if (floodindex == FLOODLIST_SIZE)
		floodindex = 0;
}


qbool Ignore_Message(char *s, int flags, int offset) {
	int slot, i, p, q, len;	
	char name[32];

	if (!ignore_mode.value && (flags & msgtype_team))
		return false;		


	if (ignore_spec.value == 2 && (flags == msgtype_spec || flags == msgtype_specteam))
		return true;
	else if (ignore_spec.value == 1 && (flags == msgtype_spec) && !cl.spectator)
		return true;
	else if (ignore_qtv.integer && (flags & msgtype_qtv))
		return true;

	if (flags == msgtype_normal || flags == msgtype_spec) {
		p = 0;
		q = offset - 3;
	} else if (flags == msgtype_team) {
		p = 1;
		q = offset - 4;
	} else if (flags == msgtype_specteam) {
		p = 7;
		q = offset - 3;
	} else {
		return false;
	}

	len = bound (0, q - p + 1, sizeof(name) - 1);
	strlcpy(name, s + p, len + 1);

	if ((slot = Player_NametoSlot(name)) == PLAYER_NAME_NOMATCH)
		return false;	

	if (cl.players[slot].ignored)
		return true;
	

	if (ignore_opponents.value && (
			(int) ignore_opponents.value == 1 ||
			(cls.state >= ca_connected && !cl.standby && !cls.demoplayback && !cl.spectator) // match?
			) && 
		flags == msgtype_normal && !cl.spectator && slot != cl.playernum &&
		(!cl.teamplay || strcmp(cl.players[slot].team, cl.players[cl.playernum].team))
		)
		return true;


	if (!cl.teamplay)
		return false;

	if (cl.players[slot].spectator || !strcmp(Player_MyName(), name))
		return false;	

	for (i = 0; i < MAX_TEAMIGNORELIST && ignoreteamlist[i][0]; i++) {
		if (!strncmp(cl.players[slot].team, ignoreteamlist[i], sizeof(ignoreteamlist[i]) - 1))
			return true;
	}

	return false;
}

void Ignore_ResetFloodList(void) {
	int i;

	for (i = 0; i < FLOODLIST_SIZE; i++)
		floodlist[i].data[0] = 0;
	floodindex = 0;
}

#ifdef FTE_PEXT2_VOICECHAT
static qbool Ignorelist_VAdd(int slot)
{
	if (cl.players[slot].vignored)
		return false;

	cl.players[slot].vignored = true;
	S_Voip_Ignore(slot, true);
	return true;
}

static qbool IgnoreList_VDel (int slot)
{
	if (!cl.players[slot].vignored)
		return false;

	cl.players[slot].vignored = false;
	S_Voip_Ignore(slot, false);
	return true;
}

static void VIgnoreToggleCommand (qbool ignore)
{
	int c, slot;

	if ((c = Cmd_Argc()) == 1) {
		Display_Ignorelist();
		return;
	}
	else if (c != 2) {
		Con_Printf("Usage: %s [userid | name]\n", Cmd_Argv(0));
		return;
	}

	if ((slot = Player_StringtoSlot(Cmd_Argv(1), true, true)) == PLAYER_ID_NOMATCH) {
		Con_Printf("%s : no player with userid %d\n", Cmd_Argv(0), Q_atoi(Cmd_Argv(1)));
	}
	else if (slot == PLAYER_NAME_NOMATCH) {
		Con_Printf("%s : no player with name %s\n", Cmd_Argv(0), Cmd_Argv(1));
	}
	else if (ignore ? (Ignorelist_VAdd (slot)) : (IgnoreList_VDel (slot))) {
		Con_Printf ("%s user %s %s ignore list\n", ignore ? "Added" : "Removed", cl.players[slot].name, ignore ? "to" : "from");
	}
	else {
		Con_Printf ("User %s is %s ignored\n", cl.players[slot].name, ignore ? "already" : "not");
	}
}

static void VIgnore_f(void)
{
	VIgnoreToggleCommand (true);
}

static void VUnignore_f (void)
{
	VIgnoreToggleCommand (false);
}
#endif

void Ignore_Init(void) {
	int i;

	for (i = 0; i < MAX_TEAMIGNORELIST; i++)
		ignoreteamlist[i][0] = 0;
	Ignore_ResetFloodList();

	Cvar_SetCurrentGroup(CVAR_GROUP_CHAT);
	Cvar_Register (&ignore_flood_duration);
	Cvar_Register (&ignore_flood);
	Cvar_Register (&ignore_spec);
	Cvar_Register (&ignore_qizmo_spec);
	Cvar_Register (&ignore_qtv);
	Cvar_Register (&ignore_mode);
	Cvar_Register (&ignore_opponents);
	Cvar_Register (&ignore_no_weapon);
	Cvar_Register (&ignore_not_enough_ammo);

	Cvar_ResetCurrentGroup();

#ifdef FTE_PEXT2_VOICECHAT
	Cmd_AddCommand ("ignore_voip", VIgnore_f);
	Cmd_AddCommand ("unignore_voip", VUnignore_f);
#endif
	Cmd_AddCommand ("ignore", Ignore_f);					
	Cmd_AddCommand ("ignorelist", IgnoreList_f);			
	Cmd_AddCommand ("unignore", Unignore_f);				
	Cmd_AddCommand ("ignore_team", Ignoreteam_f);		
	Cmd_AddCommand ("unignore_team", Unignoreteam_f);	
	Cmd_AddCommand ("unignoreAll", UnignoreAll_f);			
	Cmd_AddCommand ("unignoreAll_team", UnignoreteamAll_f);	
	Cmd_AddCommand ("unignore_id", Unignore_ID_f);		
	Cmd_AddCommand ("ignore_id", Ignore_ID_f);			
}


================================================
FILE: src/ignore.h
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef __IGNORE_H_

#define __IGNORE_H_	


#define NO_IGNORE_NO_ADD	0
#define	NO_IGNORE_ADD		1
#define	IGNORE_NO_ADD		2

void Ignore_Init(void);
qbool Ignore_Message(char *s, int flags, int offset);
char Ignore_Check_Flood(char *s, int flags, int offset);
void Ignore_Flood_Add(char *s);
void Ignore_ResetFloodList(void);

#endif


================================================
FILE: src/image.c
================================================
/*
Copyright (C) 1996-2003 A Nourai, Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef __FreeBSD__
#include <dlfcn.h>
#endif
#include "quakedef.h"
#include "image.h"

#ifdef WITH_PNG
#include "png.h"
/*#ifdef _WIN32
#pragma comment(lib, "libs/libpng.lib")
#endif*/
#endif

#ifdef WITH_JPEG
#if defined(_MSC_VER)
#pragma warning(disable: 4005)
#endif
#include <jpeglib.h>
#include <jerror.h>
#if defined(_MSC_VER)
#pragma warning(default: 4005)
#endif
/*#ifdef _WIN32
#pragma comment(lib, "libs/libjpeg.lib")
#endif*/
#endif

#define IMAGE_MAX_DIMENSIONS 4096

cvar_t image_png_compression_level = {"image_png_compression_level", "1"};
cvar_t image_jpeg_quality_level = {"image_jpeg_quality_level", "75"};

/***************************** IMAGE RESAMPLING ******************************/

static void Image_Resample32LerpLine (byte *in, byte *out, int inwidth, int outwidth) 
{
	int j, xi, oldx = 0, f, fstep, endx, lerp;

	fstep = (int) (inwidth * 65536.0f / outwidth);
	endx = (inwidth - 1);
	for (j = 0, f = 0; j < outwidth; j++, f += fstep) {
		xi = (int) f >> 16;
		if (xi != oldx) {
			in += (xi - oldx) * 4;
			oldx = xi;
		}
		if (xi < endx) {
			lerp = f & 0xFFFF;
			*out++ = (byte) ((((in[4] - in[0]) * lerp) >> 16) + in[0]);
			*out++ = (byte) ((((in[5] - in[1]) * lerp) >> 16) + in[1]);
			*out++ = (byte) ((((in[6] - in[2]) * lerp) >> 16) + in[2]);
			*out++ = (byte) ((((in[7] - in[3]) * lerp) >> 16) + in[3]);
		} else  {
			*out++ = in[0];
			*out++ = in[1];
			*out++ = in[2];
			*out++ = in[3];
		}
	}
}

static void Image_Resample24LerpLine (byte *in, byte *out, int inwidth, int outwidth) 
{
	int j, xi, oldx = 0, f, fstep, endx, lerp;

	fstep = (int) (inwidth * 65536.0f / outwidth);
	endx = (inwidth - 1);
	for (j = 0, f = 0; j < outwidth; j++, f += fstep) {
		xi = (int) f >> 16;
		if (xi != oldx) {
			in += (xi - oldx) * 3;
			oldx = xi;
		}
		if (xi < endx) {
			lerp = f & 0xFFFF;
			*out++ = (byte) ((((in[3] - in[0]) * lerp) >> 16) + in[0]);
			*out++ = (byte) ((((in[4] - in[1]) * lerp) >> 16) + in[1]);
			*out++ = (byte) ((((in[5] - in[2]) * lerp) >> 16) + in[2]);
		} else  {
			*out++ = in[0];
			*out++ = in[1];
			*out++ = in[2];
		}
	}
}

#define LERPBYTE(i) r = row1[i]; out[i] = (byte) ((((row2[i] - r) * lerp) >> 16) + r)
#define NOLERPBYTE(i) *out++ = inrow[f + i]

static void Image_Resample32 (void *indata, int inwidth, int inheight,
								void *outdata, int outwidth, int outheight, int quality) 
{
	if (quality) 
	{
		int i, j, r, yi, oldy, f, fstep, endy = (inheight - 1), lerp;
		int inwidth4 = inwidth * 4, outwidth4 = outwidth * 4;
		byte *inrow, *out, *row1, *row2, *memalloc;

		out = outdata;
		fstep = (int) (inheight * 65536.0f / outheight);

		memalloc = (byte *) Q_malloc(2 * outwidth4);
		row1 = memalloc;
		row2 = memalloc + outwidth4;
		inrow = (byte *) indata;
		oldy = 0;
		Image_Resample32LerpLine (inrow, row1, inwidth, outwidth);
		Image_Resample32LerpLine (inrow + inwidth4, row2, inwidth, outwidth);
		
		for (i = 0, f = 0; i < outheight; i++, f += fstep)	
		{
			yi = f >> 16;

			if (yi < endy) 
			{
				lerp = f & 0xFFFF;

				if (yi != oldy)
				{
					inrow = (byte *) indata + inwidth4 * yi;
					if (yi == oldy + 1)
						memcpy(row1, row2, outwidth4);
					else
						Image_Resample32LerpLine (inrow, row1, inwidth, outwidth);
					Image_Resample32LerpLine (inrow + inwidth4, row2, inwidth, outwidth);
					oldy = yi;
				}

				j = outwidth - 4;

				while(j >= 0)
				{
					LERPBYTE(0); LERPBYTE(1); LERPBYTE(2); LERPBYTE(3);
					LERPBYTE(4); LERPBYTE(5); LERPBYTE(6); LERPBYTE(7);
					LERPBYTE(8); LERPBYTE(9); LERPBYTE(10); LERPBYTE(11);
					LERPBYTE(12); LERPBYTE(13); LERPBYTE(14); LERPBYTE(15);
					out += 16;
					row1 += 16;
					row2 += 16;
					j -= 4;
				}

				if (j & 2) 
				{
					LERPBYTE(0); LERPBYTE(1); LERPBYTE(2); LERPBYTE(3);
					LERPBYTE(4); LERPBYTE(5); LERPBYTE(6); LERPBYTE(7);
					out += 8;
					row1 += 8;
					row2 += 8;
				}

				if (j & 1)
				{
					LERPBYTE(0); LERPBYTE(1); LERPBYTE(2); LERPBYTE(3);
					out += 4;
					row1 += 4;
					row2 += 4;
				}
				row1 -= outwidth4;
				row2 -= outwidth4;
			} 
			else 
			{
				if (yi != oldy) 
				{
					inrow = (byte *) indata + inwidth4 * yi;
					if (yi == oldy+1)
						memcpy(row1, row2, outwidth4);
					else
						Image_Resample32LerpLine (inrow, row1, inwidth, outwidth);
					oldy = yi;
				}
				memcpy(out, row1, outwidth4);
			}
		}

		Q_free(memalloc);
	}
	else 
	{
		int i, j;
		unsigned int frac, fracstep, *inrow, *out;

		out = outdata;

		fracstep = inwidth * 0x10000 / outwidth;
		for (i = 0; i < outheight; i++)
		{
			inrow = (unsigned int *) indata + inwidth * (i * inheight / outheight);
			frac = fracstep >> 1;
			j = outwidth - 4;
		
			while (j >= 0)
			{
				out[0] = inrow[frac >> 16]; frac += fracstep;
				out[1] = inrow[frac >> 16]; frac += fracstep;
				out[2] = inrow[frac >> 16]; frac += fracstep;
				out[3] = inrow[frac >> 16]; frac += fracstep;
				out += 4;
				j -= 4;
			}

			if (j & 2)
			{
				out[0] = inrow[frac >> 16]; frac += fracstep;
				out[1] = inrow[frac >> 16]; frac += fracstep;
				out += 2;
			}

			if (j & 1) 
			{
				out[0] = inrow[frac >> 16]; frac += fracstep;
				out += 1;
			}
		}
	}
}

static void Image_Resample24 (void *indata, int inwidth, int inheight,
					 void *outdata, int outwidth, int outheight, int quality)
{
	if (quality)
	{
		int i, j, r, yi, oldy, f, fstep, endy = (inheight - 1), lerp;
		int inwidth3 = inwidth * 3, outwidth3 = outwidth * 3;
		byte *inrow, *out, *row1, *row2, *memalloc;

		out = outdata;
		fstep = (int) (inheight * 65536.0f / outheight);

		memalloc = (byte *) Q_malloc(2 * outwidth3);
		row1 = memalloc;
		row2 = memalloc + outwidth3;
		inrow = (byte *) indata;
		oldy = 0;
		Image_Resample24LerpLine (inrow, row1, inwidth, outwidth);
		Image_Resample24LerpLine (inrow + inwidth3, row2, inwidth, outwidth);
		
		for (i = 0, f = 0; i < outheight; i++, f += fstep)	
		{
			yi = f >> 16;
			if (yi < endy) {
				lerp = f & 0xFFFF;
				if (yi != oldy)
				{
					inrow = (byte *) indata + inwidth3 * yi;
					if (yi == oldy + 1)
						memcpy(row1, row2, outwidth3);
					else
						Image_Resample24LerpLine (inrow, row1, inwidth, outwidth);
					Image_Resample24LerpLine (inrow + inwidth3, row2, inwidth, outwidth);
					oldy = yi;
				}

				j = outwidth - 4;

				while(j >= 0)
				{
					LERPBYTE(0); LERPBYTE(1); LERPBYTE(2);
					LERPBYTE(3); LERPBYTE(4); LERPBYTE(5);
					LERPBYTE(6); LERPBYTE(7); LERPBYTE(8);
					LERPBYTE(9); LERPBYTE(10); LERPBYTE(11);
					out += 12;
					row1 += 12;
					row2 += 12;
					j -= 4;
				}

				if (j & 2) 
				{
					LERPBYTE(0); LERPBYTE(1); LERPBYTE(2);
					LERPBYTE(3); LERPBYTE(4); LERPBYTE(5);
					out += 6;
					row1 += 6;
					row2 += 6;
				}

				if (j & 1) 
				{
					LERPBYTE(0); LERPBYTE(1); LERPBYTE(2);
					out += 3;
					row1 += 3;
					row2 += 3;
				}
				row1 -= outwidth3;
				row2 -= outwidth3;
			} 
			else
			{
				if (yi != oldy) 
				{
					inrow = (byte *) indata + inwidth3 * yi;
					if (yi == oldy+1)
						memcpy(row1, row2, outwidth3);
					else
						Image_Resample24LerpLine (inrow, row1, inwidth, outwidth);
					oldy = yi;
				}

				memcpy(out, row1, outwidth3);
			}
		}

		Q_free(memalloc);
	} 
	else 
	{
		int i, j, f;
		unsigned int frac, fracstep, inwidth3 = inwidth * 3;
		byte *inrow, *out;

		out = outdata;

		fracstep = inwidth * 0x10000 / outwidth;
		for (i = 0; i < outheight; i++) 
		{
			inrow = (byte *) indata + inwidth3 * (i * inheight / outheight);
			frac = fracstep >> 1;
			j = outwidth - 4;

			while (j >= 0) 
			{
				f = (frac >> 16) * 3; NOLERPBYTE(0); NOLERPBYTE(1); NOLERPBYTE(2); frac += fracstep;
				f = (frac >> 16) * 3; NOLERPBYTE(0); NOLERPBYTE(1); NOLERPBYTE(2); frac += fracstep;
				f = (frac >> 16) * 3; NOLERPBYTE(0); NOLERPBYTE(1); NOLERPBYTE(2); frac += fracstep;
				f = (frac >> 16) * 3; NOLERPBYTE(0); NOLERPBYTE(1); NOLERPBYTE(2); frac += fracstep;
				j -= 4;
			}

			if (j & 2) 
			{
				f = (frac >> 16) * 3; NOLERPBYTE(0); NOLERPBYTE(1); NOLERPBYTE(2); frac += fracstep;
				f = (frac >> 16) * 3; NOLERPBYTE(0); NOLERPBYTE(1); NOLERPBYTE(2); frac += fracstep;
				out += 2;
			}

			if (j & 1)
			{
				f = (frac >> 16) * 3; NOLERPBYTE(0); NOLERPBYTE(1); NOLERPBYTE(2); frac += fracstep;
				out += 1;
			}
		}
	}
}

void Image_Resample (void *indata, int inwidth, int inheight,
					 void *outdata, int outwidth, int outheight, int bpp, int quality) 
{
	if (bpp == 4)
		Image_Resample32(indata, inwidth, inheight, outdata, outwidth, outheight, quality);
	else if (bpp == 3)
		Image_Resample24(indata, inwidth, inheight, outdata, outwidth, outheight, quality);
	else
		Sys_Error("Image_Resample: unsupported bpp (%d)", bpp);
}

void Image_MipReduce (const byte *in, byte *out, int *width, int *height, int bpp) 
{
	const byte *inrow;
	int x, y, nextrow;

	inrow = in;
	nextrow = *width * bpp;

	if (*width > 1) 
	{
		*width >>= 1;

		if (*height > 1) 
		{
			// reduce both (width and height)
			*height >>= 1;
		
			if (bpp == 4)
			{
				for (y = 0; y < *height; y++, inrow += nextrow * 2)
				{
					for (in = inrow, x = 0; x < *width; x++)
					{
						out[0] = (byte) ((in[0] + in[4] + in[nextrow] + in[nextrow + 4]) >> 2);
						out[1] = (byte) ((in[1] + in[5] + in[nextrow + 1] + in[nextrow + 5]) >> 2);
						out[2] = (byte) ((in[2] + in[6] + in[nextrow + 2] + in[nextrow + 6]) >> 2);
						out[3] = (byte) ((in[3] + in[7] + in[nextrow + 3] + in[nextrow + 7]) >> 2);
						out += 4;
						in += 8;
					}
				}
			} 
			else if (bpp == 3) 
			{
				for (y = 0; y < *height; y++, inrow += nextrow * 2)
				{
					for (in = inrow, x = 0; x < *width; x++)
					{
						out[0] = (byte) ((in[0] + in[3] + in[nextrow] + in[nextrow + 3]) >> 2);
						out[1] = (byte) ((in[1] + in[4] + in[nextrow + 1] + in[nextrow + 4]) >> 2);
						out[2] = (byte) ((in[2] + in[5] + in[nextrow + 2] + in[nextrow + 5]) >> 2);
						out += 3;
						in += 6;
					}
				}
			} 
			else 
			{
				Sys_Error("Image_MipReduce: unsupported bpp (%d)", bpp);
			}
		} 
		else 
		{
			// reduce width
			if (bpp == 4)
			{
				for (y = 0; y < *height; y++, inrow += nextrow)
				{
					for (in = inrow, x = 0; x < *width; x++)
					{
						out[0] = (byte) ((in[0] + in[4]) >> 1);
						out[1] = (byte) ((in[1] + in[5]) >> 1);
						out[2] = (byte) ((in[2] + in[6]) >> 1);
						out[3] = (byte) ((in[3] + in[7]) >> 1);
						out += 4;
						in += 8;
					}
				}
			} 
			else if (bpp == 3) 
			{
				for (y = 0; y < *height; y++, inrow += nextrow)
				{
					for (in = inrow, x = 0; x < *width; x++)
					{
						out[0] = (byte) ((in[0] + in[3]) >> 1);
						out[1] = (byte) ((in[1] + in[4]) >> 1);
						out[2] = (byte) ((in[2] + in[5]) >> 1);
						out += 3;
						in += 6;
					}
				}
			} 
			else 
			{
				Sys_Error("Image_MipReduce: unsupported bpp (%d)", bpp);
			}
		}
	}
	else if (*height > 1)
	{
		// reduce height
		*height >>= 1;

		if (bpp == 4) 
		{
			for (y = 0; y < *height; y++, inrow += nextrow * 2)
			{
				for (in = inrow, x = 0; x < *width; x++)
				{
					out[0] = (byte) ((in[0] + in[nextrow]) >> 1);
					out[1] = (byte) ((in[1] + in[nextrow + 1]) >> 1);
					out[2] = (byte) ((in[2] + in[nextrow + 2]) >> 1);
					out[3] = (byte) ((in[3] + in[nextrow + 3]) >> 1);
					out += 4;
					in += 4;
				}
			}
		}
		else if (bpp == 3) 
		{
			for (y = 0; y < *height; y++, inrow += nextrow * 2)
			{
				for (in = inrow, x = 0; x < *width; x++)
				{
					out[0] = (byte) ((in[0] + in[nextrow]) >> 1);
					out[1] = (byte) ((in[1] + in[nextrow + 1]) >> 1);
					out[2] = (byte) ((in[2] + in[nextrow + 2]) >> 1);
					out += 3;
					in += 3;
				}
			}
		} 
		else 
		{
			Sys_Error("Image_MipReduce: unsupported bpp (%d)", bpp);
		}
	} 
	else
	{
		Sys_Error("Image_MipReduce: Input texture has dimensions %dx%d", width, height);
	}
}

/************************************ PNG ************************************/
#ifdef WITH_PNG

#ifdef WITH_APNG
#undef WITH_APNG
#endif

#ifdef PNG_IO_STATE_SUPPORTED
#define WITH_APNG
#endif

#ifdef WITH_APNG
static vfsfile_t* apng_fp;
static png_structp apng_ptr;
static png_infop apng_info_ptr;
static int apng_framenumber;
static int apng_compression;
#endif

static void PNG_IO_user_read_data(png_structp png_ptr, png_bytep data, png_size_t length) {
	vfsfile_t *v = (vfsfile_t *) png_get_io_ptr(png_ptr);
	vfserrno_t err;
	VFS_READ(v, data, (int)length, &err);
}

static void PNG_IO_user_write_data(png_structp png_ptr, png_bytep data, png_size_t length) {
	vfsfile_t *v = (vfsfile_t *) png_get_io_ptr(png_ptr);

	VFS_WRITE(v, data, (int)length);
}

#ifdef WITH_APNG
static byte* apng_data = NULL;
static size_t apng_data_limit = 0;
static size_t apng_data_length = 0;

static void PNG_IO_user_write_data_apng_discard(png_structp png_ptr, png_bytep data, png_size_t length)
{
	// do nothing
}

static void PNG_IO_user_flush_data_apng_discard(png_structp png_ptr)
{
	// do nothing
}

static void PNG_IO_user_write_data_apng(png_structp png_ptr, png_bytep data, png_size_t length)
{
	if ((png_get_io_state(png_ptr) & PNG_IO_MASK_LOC) == PNG_IO_CHUNK_DATA) {
		if (!apng_data) {
			apng_data_limit = 256 * 1024;
			apng_data_length = 0;
			apng_data = Q_malloc(apng_data_limit);
		}

		if (apng_data_length + length > apng_data_limit) {
			apng_data_limit += max(length + 4, 64 * 1024);
			apng_data = Q_realloc(apng_data, apng_data_limit);
		}

		if (apng_data_length == 0) {
			*(unsigned int*)apng_data = htonl(apng_framenumber);
			apng_data_length += 4;
		}

		memcpy(apng_data + apng_data_length, data, length);
		apng_data_length += length;
	}
}
#endif

static void PNG_IO_user_flush_data(png_structp png_ptr)
{
	vfsfile_t *v = (vfsfile_t *) png_get_io_ptr(png_ptr);
	VFS_FLUSH(v);
}

#define PNG_HEADER_LENGTH	8
#define PNG_LOAD_TEXT		1
#define PNG_LOAD_DATA		2

static qbool PNG_HasHeader (vfsfile_t *fin)
{
	byte header[PNG_HEADER_LENGTH];
	vfserrno_t err;

	VFS_READ(fin, header, PNG_HEADER_LENGTH, &err);
	if (png_sig_cmp(header, 0, PNG_HEADER_LENGTH)) 
	{
		VFS_CLOSE(fin);
		fin = NULL;
		return false;
	}

	return true;
}

static void Image_PngErrorHandler(png_structp png_ptr, png_const_charp error_msg)
{
	const char* filename = (const char*)png_get_error_ptr(png_ptr);

	if (filename == NULL || !filename[0]) {
		filename = "(unknown path)";
	}
	if (error_msg == NULL || !error_msg[0]) {
		error_msg = "unknown error";
	}

	Sys_Error("Invalid PNG detected: %s (%s)\n", filename, error_msg);
}

static void Image_PngWarningHandler(png_structp png_ptr, png_const_charp error_msg)
{
	const char* filename = (const char*)png_get_error_ptr(png_ptr);

	if (filename == NULL || !filename[0]) {
		filename = "(unknown path)";
	}
	if (error_msg == NULL || !error_msg[0]) {
		error_msg = "unknown error";
	}
	if (strstr(error_msg, "known incorrect sRGB profile")) {
		return; // only matters if we would subsequently save the .png
	}

	Con_Printf("&cdd0libpng&r: %s (%s)\n", filename, error_msg);
}

png_data *Image_LoadPNG_All (vfsfile_t *fin, const char *filename, int matchwidth, int matchheight, int loadflag, int *real_width, int *real_height)
{
	byte **rowpointers = NULL;
	byte *data = NULL;
	png_structp png_ptr = NULL;
	png_infop pnginfo = NULL;			
	png_textp textchunks = NULL;		// Actual text chunks that will be returned.
	png_textp png_text_ptr = NULL;		// Text chunks are read into this (will be scrapped by libpng).
	png_data *png_return_val = NULL;	// Return struct containing data + text chunks.
	int n_textcount = 0;				// Number of text chunks.
	int y, width, height, bitdepth, colortype, interlace, compression, filter, bytesperpixel;
	png_size_t rowbytes;

	// Check if we were given a non-null file pointer
	// if so then use it, otherwise try to open the specified filename.
	if (!fin && !(fin = FS_OpenVFS(filename, "rb", FS_ANY)))
	{
		return NULL;
	}

	// Check if the loaded file contains a PNG header.
	if (!PNG_HasHeader (fin))
	{
		Com_DPrintf ("Invalid PNG image %s\n", COM_SkipPath(filename));
		return NULL;
	}

	// Try creating a PNG structure for reading the file.
	if (!(png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (void*)filename, Image_PngErrorHandler, Image_PngWarningHandler))) 
	{
		VFS_CLOSE(fin);
		fin = NULL;
		return NULL;
	}

	// Create a structure for reading the characteristics of the image.
	if (!(pnginfo = png_create_info_struct(png_ptr))) 
	{
		png_destroy_read_struct(&png_ptr, &pnginfo, NULL);
		VFS_CLOSE(fin);
		fin = NULL;
		return NULL;
	}

	// Set the return address that PNGLib should return to if
	// an error occurs during reading.
#if 0
	if (setjmp(png_ptr->jmpbuf)) 
	{
		png_destroy_read_struct(&png_ptr, &pnginfo, NULL);
		VFS_CLOSE(fin);
		fin = NULL;
		return NULL;
	}
#endif

	// Set the read function that should be used.
    png_set_read_fn(png_ptr, fin, PNG_IO_user_read_data);

	// Tell PNG-lib that we have already handled the first <num_bytes> magic bytes.
	// Handling more than 8 bytes from the beginning of the file is an error.
	png_set_sig_bytes(png_ptr, PNG_HEADER_LENGTH);

	// Read all the file information until the actual image data.
	png_read_info(png_ptr, pnginfo);

	// Get the IHDR info and set transformations based on it's contents
	// suc as pallete type / bit depth.
	//
	// The IHDR chunk contains the width, height, bpp, colortype, 
	// filter method and compression type used.
	// This must be the first chunk in the file.
	{
		png_get_IHDR(png_ptr, pnginfo, (png_uint_32 *) &width, (png_uint_32 *) &height, &bitdepth,
			&colortype, &interlace, &compression, &filter);

		// Return the width and height.
		if (real_width)
			(*real_width) = width;

		if (real_height)
			(*real_height) = height;

		// Too big?
		if (width > IMAGE_MAX_DIMENSIONS || height > IMAGE_MAX_DIMENSIONS) 
		{
			Com_DPrintf ("PNG image %s exceeds maximum supported dimensions\n", COM_SkipPath(filename));
			png_destroy_read_struct(&png_ptr, &pnginfo, NULL);
			VFS_CLOSE(fin);
			fin = NULL;
			return NULL;
		}

		// If the caller wanted the image to be a specific size
		// make sure it is that size, otherwise cleanup and return.
		if ((matchwidth && width != matchwidth) || (matchheight && height != matchheight)) 
		{
			png_destroy_read_struct(&png_ptr, &pnginfo, NULL);
			VFS_CLOSE(fin);
			fin = NULL;
			return NULL;
		}

		if (colortype == PNG_COLOR_TYPE_PALETTE) 
		{
			png_set_palette_to_rgb(png_ptr);
			png_set_filler(png_ptr, 255, PNG_FILLER_AFTER);		
		}

		if (colortype == PNG_COLOR_TYPE_GRAY && bitdepth < 8) 
		{
#if PNG_LIBPNG_VER >= 10209
			png_set_expand_gray_1_2_4_to_8(png_ptr);
#else
			png_set_gray_1_2_4_to_8(png_ptr);
#endif
		}
		
		if (png_get_valid(png_ptr, pnginfo, PNG_INFO_tRNS))	
		{
			png_set_tRNS_to_alpha(png_ptr);
		}

		if (colortype == PNG_COLOR_TYPE_GRAY || colortype == PNG_COLOR_TYPE_GRAY_ALPHA)
		{
			png_set_gray_to_rgb(png_ptr);
		}

		if (colortype != PNG_COLOR_TYPE_RGBA)
		{
			png_set_filler(png_ptr, 255, PNG_FILLER_AFTER);
		}

		if (bitdepth < 8)
		{
			png_set_expand (png_ptr);
		}
		else if (bitdepth == 16)
		{
			png_set_strip_16(png_ptr);
		}

		// Update the pnginfo structure with our transformation changes.
		png_read_update_info(png_ptr, pnginfo);
	}

	//
	// Read the text chunks before the image data.
	//
	if (loadflag & PNG_LOAD_TEXT)
	{
		// Get the text chunks found before the image data.
		n_textcount = 0;
		png_get_text(png_ptr, pnginfo, &png_text_ptr, &n_textcount);
	}

	//
	// Read the image data.
	//
	{
		// Get the number of bytes a row will use / number of channels / bitdepth.
		rowbytes = png_get_rowbytes(png_ptr, pnginfo);
		bytesperpixel = png_get_channels(png_ptr, pnginfo);
		bitdepth = png_get_bit_depth(png_ptr, pnginfo);

		// We don't support some formats.
		if (bitdepth != 8 || (bytesperpixel != 4 && bytesperpixel != 1)) 
		{
			Com_DPrintf ("Unsupported PNG image %s: Bad color depth and/or bpp\n", COM_SkipPath(filename));
			png_destroy_read_struct(&png_ptr, &pnginfo, NULL);
			VFS_CLOSE(fin);
			fin = NULL;
			return NULL;
		}

		// Allocate a byte array for the actual image data.
		data = (byte *) Q_malloc_named(height * rowbytes, filename);

		// Even though we just allocated the memory for all the image data
		// PNG lib wants this in the form of rowpointers.
		rowpointers = (byte **) Q_malloc(height * sizeof(*rowpointers));
		for (y = 0; y < height; y++)
		{
			rowpointers[y] = data + y * rowbytes;
		}

		// Read the actual image data.
		png_read_image(png_ptr, rowpointers);
		png_read_end(png_ptr, pnginfo);

		Q_free(rowpointers);
	}
	
	//
	// Read the text chunks after the image data.
	//
	if (loadflag & PNG_LOAD_TEXT)
	{
		// Read text chunks after the image data also.
		png_get_text(png_ptr, pnginfo, &png_text_ptr, &n_textcount);
	
		// Return the text chunks if we found any.
		if(n_textcount > 0)
		{
			int i = 0;
			int len = 0;
			textchunks = (png_textp)Q_calloc(n_textcount, sizeof(png_text));

			for(i = 0; i < n_textcount; i++)
			{
				len = strlen(png_text_ptr[i].key);

				textchunks[i].key = (char *)Q_calloc(len + 1, sizeof(char));
				textchunks[i].text = (char *)Q_calloc(png_text_ptr[i].text_length + 1, sizeof(char));

				strlcpy (textchunks[i].key, png_text_ptr[i].key, len + 1);
				strlcpy (textchunks[i].text, png_text_ptr[i].text, png_text_ptr[i].text_length + 1);
				
				textchunks[i].text_length = png_text_ptr[i].text_length;
				textchunks[i].compression = png_text_ptr[i].compression;
			}
		}
		else
		{
			textchunks = NULL;
		}
	}

	// Clean up.
	png_destroy_read_struct (&png_ptr, &pnginfo, NULL);
	VFS_CLOSE(fin);
	fin = NULL;

	// If we don't care about the data.
	if (!(loadflag & PNG_LOAD_DATA))
	{
		Q_free (data);
	}

	// Gather up the return data.
	png_return_val = (png_data *)Q_malloc(sizeof(png_data));	
	png_return_val->data = data;
	png_return_val->textchunks = textchunks;
	png_return_val->text_count = n_textcount;

	return png_return_val;
}

png_textp Image_LoadPNG_Comments (char *filename, int *text_count)
{
	png_textp textchunks = NULL;
	png_data *pdata = NULL;

	pdata = Image_LoadPNG_All (NULL, filename, 0, 0, PNG_LOAD_TEXT, NULL, NULL);

	if (pdata)
	{		
		// Return text chunks + count.
		(*text_count) = (int)pdata->text_count;
		textchunks = pdata->textchunks;

		Q_free(pdata->data);
		Q_free(pdata);
	}

	return textchunks;
}

byte *Image_LoadPNG (vfsfile_t *fin, const char *filename, int matchwidth, int matchheight, int *real_width, int *real_height) 
{
	byte *data = NULL;
	png_data *pdata;
	
	// Load the actual image.
	pdata = Image_LoadPNG_All (fin, filename, matchwidth, matchheight, PNG_LOAD_DATA, real_width, real_height);
	
	if (pdata)
	{
		// Save the data and free the rest.
		data = pdata->data;
		Q_free(pdata);
	}
	
	return data;
}

int Image_WritePNG(char *filename, int compression, byte *pixels, size_t width, size_t height)
{
	char name[MAX_PATH];
	int i, bpp = 3, pngformat;
	vfsfile_t *fp;

	png_structp png_ptr;
	png_infop info_ptr;
	png_byte **rowpointers;
	snprintf (name, sizeof(name), "%s", filename);

	if (!(fp = FS_OpenVFS(name, "wb", FS_NONE_OS))) {
		FS_CreatePath (name);
		if (!(fp = FS_OpenVFS(name, "wb", FS_NONE_OS)))
			return false;
	}

	if (!(png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL))) {
		VFS_CLOSE(fp);
		return false;
	}

	if (!(info_ptr = png_create_info_struct(png_ptr))) {
		png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
		VFS_CLOSE(fp);
		return false;
	}

#if 0
	if (setjmp(png_ptr->jmpbuf)) {
		png_destroy_write_struct(&png_ptr, &info_ptr);
		VFS_CLOSE(fp);
		return false;
	}
#endif

    png_set_write_fn(png_ptr, fp, PNG_IO_user_write_data, PNG_IO_user_flush_data);
	png_set_compression_level(png_ptr, bound(Z_NO_COMPRESSION, compression, Z_BEST_COMPRESSION));

	pngformat = (bpp == 4) ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB;
	png_set_IHDR(png_ptr, info_ptr, (png_uint_32)width, (png_uint_32)height, 8, pngformat,
		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

	png_write_info(png_ptr, info_ptr);

	rowpointers = (png_byte **) Q_malloc (height * sizeof(*rowpointers));
	for (i = 0; i < height; i++) {
		rowpointers[i] = pixels + (height - i - 1) * width * bpp;
	}
	png_write_image(png_ptr, rowpointers);
	png_write_end(png_ptr, info_ptr);
	Q_free(rowpointers);
	png_destroy_write_struct(&png_ptr, &info_ptr);
	VFS_CLOSE(fp);
	return true;
}

#ifdef WITH_APNG
qbool Image_OpenAPNG(char* filename, int compression, int width, int height, int frames)
{
	char name[MAX_PATH];
	int bpp = 3, pngformat;

	snprintf(name, sizeof(name), "%s", filename);

	width = abs(width);

	if (!(apng_fp = FS_OpenVFS(name, "wb", FS_NONE_OS))) {
		FS_CreatePath(name);
		if (!(apng_fp = FS_OpenVFS(name, "wb", FS_NONE_OS))) {
			return false;
		}
	}

	if (!(apng_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL))) {
		VFS_CLOSE(apng_fp);
		apng_fp = NULL;
		return false;
	}

	if (!(apng_info_ptr = png_create_info_struct(apng_ptr))) {
		png_destroy_write_struct(&apng_ptr, (png_infopp)NULL);
		VFS_CLOSE(apng_fp);
		apng_fp = NULL;
		return false;
	}

	png_set_write_fn(apng_ptr, apng_fp, PNG_IO_user_write_data, PNG_IO_user_flush_data);
	png_set_compression_level(apng_ptr, bound(Z_NO_COMPRESSION, compression, Z_BEST_COMPRESSION));
	pngformat = (bpp == 4) ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB;
	png_set_IHDR(apng_ptr, apng_info_ptr, width, height, 8, pngformat, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
	png_write_info(apng_ptr, apng_info_ptr);

	// write acTL block
	{
		byte acTL[] = { 'a', 'c', 'T', 'L' };
		unsigned int actldata[2] = { htonl(frames), htonl(0) };

		png_write_chunk(apng_ptr, acTL, (png_const_bytep) actldata, sizeof(actldata));
	}

	apng_framenumber = 0;
	apng_compression = compression;
	return true;
}

qbool Image_WriteAPNGFrame(byte* pixels, size_t width, size_t height, int fps)
{
	png_byte **rowpointers = (png_byte **)Q_malloc(height * sizeof(*rowpointers));
	int i, bpp = 3;

	// Write fcTL chunk
	{
		struct {
			unsigned int sequence_number;
			unsigned int width;
			unsigned int height;
			unsigned int x_offset;
			unsigned int y_offset;
			unsigned short delay_num;
			unsigned short delay_den;
			byte dispose_op;
			byte blend_op;
		} fcTL_chunk;
		byte header[4] = { 'f', 'c', 'T', 'L' };

		fcTL_chunk.sequence_number = htonl(apng_framenumber);
		fcTL_chunk.width = htonl((u_long)width);
		fcTL_chunk.height = htonl((u_long)height);
		fcTL_chunk.x_offset = htonl(0);
		fcTL_chunk.y_offset = htonl(0);
		fcTL_chunk.delay_num = htons(1);
		fcTL_chunk.delay_den = htons(fps);
		fcTL_chunk.dispose_op = 0;       // APNG_DISPOSE_OP_NONE
		fcTL_chunk.blend_op = 0;         // APNG_BLEND_OP_SOURCE

		png_write_chunk(apng_ptr, header, (png_const_bytep)&fcTL_chunk, 26);

		++apng_framenumber;
	}

	for (i = 0; i < height; i++) {
		rowpointers[i] = pixels + (height - i - 1) * width * bpp;
	}
	if (apng_framenumber >= 2) {
		// Create a pretend 'new' .png so the IDAT is correct
		byte fdAT[4] = { 'f', 'd', 'A', 'T' };
		{
			png_structp fake_apng_ptr;
			png_infop fake_apng_info_ptr;

			fake_apng_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
			fake_apng_info_ptr = png_create_info_struct(fake_apng_ptr);

			png_set_write_fn(fake_apng_ptr, NULL, PNG_IO_user_write_data_apng_discard, PNG_IO_user_flush_data_apng_discard);
			png_set_compression_level(fake_apng_ptr, bound(Z_NO_COMPRESSION, apng_compression, Z_BEST_COMPRESSION));
			png_set_IHDR(fake_apng_ptr, fake_apng_info_ptr, (png_uint_32)width, (png_uint_32)height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
			png_write_info(fake_apng_ptr, fake_apng_info_ptr);

			png_write_flush(fake_apng_ptr);
			png_set_write_fn(fake_apng_ptr, NULL, PNG_IO_user_write_data_apng, PNG_IO_user_flush_data);
			apng_data_length = 0;
			png_write_image(fake_apng_ptr, rowpointers);
			png_write_flush(fake_apng_ptr);
			png_destroy_write_struct(&fake_apng_ptr, &fake_apng_info_ptr);
		}

		png_write_chunk(apng_ptr, fdAT, apng_data, apng_data_length);

		++apng_framenumber;
	}
	else {
		byte IDAT[4] = { 'I', 'D', 'A', 'T' };

		png_write_flush(apng_ptr);
		png_set_write_fn(apng_ptr, apng_fp, PNG_IO_user_write_data_apng, PNG_IO_user_flush_data);
		apng_data_length = 0;
		png_write_image(apng_ptr, rowpointers);
		png_write_flush(apng_ptr);
		png_set_write_fn(apng_ptr, apng_fp, PNG_IO_user_write_data, PNG_IO_user_flush_data);

		// Skip first four bytes, contains our sequence number
		png_write_chunk(apng_ptr, IDAT, apng_data + 4, apng_data_length - 4);
	}

	apng_data_length = 0;
	return true;
}

qbool Image_CloseAPNG(void)
{
	png_write_end(apng_ptr, apng_info_ptr);
	png_destroy_write_struct(&apng_ptr, &apng_info_ptr);
	VFS_CLOSE(apng_fp);
	apng_fp = NULL;
	Q_free(apng_data);
	apng_data_limit = apng_data_length = 0;

	return true;
}
#endif // WITH_APNG
#endif // WITH_PNG

#ifndef WITH_APNG
// This might be because IO-state isn't supported, or we're building without PNG support
qbool Image_OpenAPNG(char* filename, int compression, int width, int height, int frames)
{
	return false;
}

qbool Image_WriteAPNGFrame(byte* pixels, size_t width, size_t height, int fps)
{
	return false;
}

qbool Image_CloseAPNG(void)
{
	return false;
}
#endif

/************************************ TGA ************************************/

// Definitions for image types
#define TGA_MAPPED		1	// Uncompressed, color-mapped images
#define TGA_MAPPED_RLE	9	// Runlength encoded color-mapped images
#define TGA_RGB			2	// Uncompressed, RGB images
#define TGA_RGB_RLE		10	// Runlength encoded RGB images
#define TGA_MONO		3	// Uncompressed, black and white images
#define TGA_MONO_RLE	11	// Compressed, black and white images

// Custom definitions to simplify code
#define MYTGA_MAPPED	80
#define MYTGA_RGB15		81
#define MYTGA_RGB24		82
#define MYTGA_RGB32		83
#define MYTGA_MONO8		84
#define MYTGA_MONO16	85

typedef struct TGAHeader_s 
{
	byte			idLength, colormapType, imageType;
	unsigned short	colormapIndex, colormapLength;
	byte			colormapSize;
	unsigned short	xOrigin, yOrigin, width, height;
	byte			pixelSize, attributes;
} TGAHeader_t;


static void TGA_upsample15(byte *dest, byte *src, qbool alpha) 
{
	dest[2] = (byte) ((src[0] & 0x1F) << 3);
	dest[1] = (byte) ((((src[1] & 0x03) << 3) + ((src[0] & 0xE0) >> 5)) << 3);
	dest[0] = (byte) (((src[1] & 0x7C) >> 2) << 3);
	dest[3] = (alpha && !(src[1] & 0x80)) ? 0 : 255;
}

static void TGA_upsample24(byte *dest, byte *src) 
{
	dest[2] = src[0];
	dest[1] = src[1];
	dest[0] = src[2];
	dest[3] = 255;
}

static void TGA_upsample32(byte *dest, byte *src) 
{
	dest[2] = src[0];
	dest[1] = src[1];
	dest[0] = src[2];
	dest[3] = src[3];
}


#define TGA_ERROR(msg)	{if (msg) {Com_DPrintf((msg), COM_SkipPath(filename));} Q_free(fileBuffer); return NULL;}

byte *Image_LoadTGA(vfsfile_t *fin, const char *filename, int matchwidth, int matchheight, int *real_width, int *real_height) 
{
	TGAHeader_t header;
	int i, x, y, bpp, alphabits, compressed, mytype, row_inc, runlen, readpixelcount;
	int image_width = -1, image_height = -1;
	byte *fileBuffer, *in, *out, *data, *enddata, rgba[4], palette[256 * 4];
	int filesize;

	if (!fin && !(fin = FS_OpenVFS(filename, "rb", FS_ANY)))
		return NULL;
	filesize = VFS_GETLEN(fin);
	fileBuffer = (byte *) Q_malloc(filesize);

	VFS_READ(fin, fileBuffer, filesize, NULL);
	VFS_CLOSE(fin);

	if (filesize < 19)
		TGA_ERROR(NULL);

	header.idLength = fileBuffer[0];
	header.colormapType = fileBuffer[1];
	header.imageType = fileBuffer[2];

	header.colormapIndex = BuffLittleShort(fileBuffer + 3);
	header.colormapLength = BuffLittleShort(fileBuffer + 5);
	header.colormapSize = fileBuffer[7];
	header.xOrigin = BuffLittleShort(fileBuffer + 8);
	header.yOrigin = BuffLittleShort(fileBuffer + 10);
	header.width = image_width = BuffLittleShort(fileBuffer + 12);
	header.height = image_height = BuffLittleShort(fileBuffer + 14);
	header.pixelSize = fileBuffer[16];
	header.attributes = fileBuffer[17];

	// Return the width and height.
	if (real_width)
		(*real_width) = image_width;

	if (real_height)
		(*real_height) = image_height;

	if (image_width > IMAGE_MAX_DIMENSIONS || image_height > IMAGE_MAX_DIMENSIONS || image_width <= 0 || image_height <= 0)
		TGA_ERROR(NULL);
	if ((matchwidth && image_width != matchwidth) || (matchheight && image_height != matchheight))
		TGA_ERROR(NULL);

	bpp = (header.pixelSize + 7) >> 3;
	alphabits = (header.attributes & 0x0F);
	compressed = (header.imageType & 0x08);

	in = fileBuffer + 18 + header.idLength;
	enddata = fileBuffer + filesize;

	// error check the image type's pixel size
	if (header.imageType == TGA_RGB || header.imageType == TGA_RGB_RLE) {
		if (!(header.pixelSize == 15 || header.pixelSize == 16 || header.pixelSize == 24 || header.pixelSize == 32))
			TGA_ERROR("Unsupported TGA image %s: Bad pixel size for RGB image\n");
		mytype = (header.pixelSize == 24) ? MYTGA_RGB24 : (header.pixelSize == 32) ? MYTGA_RGB32 : MYTGA_RGB15;
	} else if (header.imageType == TGA_MAPPED || header.imageType == TGA_MAPPED_RLE) {
		if (header.pixelSize != 8)
			TGA_ERROR("Unsupported TGA image %s: Bad pixel size for color-mapped image.\n");
		if (!(header.colormapSize == 15 || header.colormapSize == 16 || header.colormapSize == 24 || header.colormapSize == 32))
			TGA_ERROR("Unsupported TGA image %s: Bad colormap size.\n");
		if (header.colormapType != 1 || header.colormapLength * 4 > sizeof(palette))
			TGA_ERROR("Unsupported TGA image %s: Bad colormap type and/or length for color-mapped image.\n");

		// read in the palette
		if (header.colormapSize == 15 || header.colormapSize == 16) {
			for (i = 0, out = palette; i < header.colormapLength; i++, in += 2, out += 4)
				TGA_upsample15(out, in, alphabits == 1);
		} else if (header.colormapSize == 24) {
			for (i = 0, out = palette; i < header.colormapLength; i++, in += 3, out += 4)
				TGA_upsample24(out, in);
		} else if (header.colormapSize == 32) {
			for (i = 0, out = palette; i < header.colormapLength; i++, in += 4, out += 4)
				TGA_upsample32(out, in);
		}
		mytype = MYTGA_MAPPED;
	} else if (header.imageType == TGA_MONO || header.imageType == TGA_MONO_RLE) {
		if (!(header.pixelSize == 8 || (header.pixelSize == 16 && alphabits == 8)))
			TGA_ERROR("Unsupported TGA image %s: Bad pixel size for grayscale image.\n");
		mytype = (header.pixelSize == 8) ? MYTGA_MONO8 : MYTGA_MONO16;
	} else {
		TGA_ERROR("Unsupported TGA image %s: Bad image type.\n");
	}

	if (header.attributes & 0x10)
		TGA_ERROR("Unsupported TGA image %s: Pixel data spans right to left.\n");

	data = (byte *) Q_malloc(image_width * image_height * 4);

	// if bit 5 of attributes isn't set, the image has been stored from bottom to top
	if ((header.attributes & 0x20)) {
		out = data;
		row_inc = 0;
	} else {
		out = data + (image_height - 1) * image_width * 4;
		row_inc = -image_width * 4 * 2;
	}

	x = y = 0;
	rgba[0] = rgba[1] = rgba[2] = rgba[3] = 255;

	while (y < image_height) {
		// decoder is mostly the same whether it's compressed or not
		readpixelcount = runlen = 0x7FFFFFFF;
		if (compressed && in < enddata) {
			runlen = *in++;
			// high bit indicates this is an RLE compressed run
			if (runlen & 0x80)
				readpixelcount = 1;
			runlen = 1 + (runlen & 0x7F);
		}

		while (runlen-- && y < image_height) {
			if (readpixelcount > 0) {
				readpixelcount--;
				rgba[0] = rgba[1] = rgba[2] = rgba[3] = 255;

				if (in + bpp <= enddata) {
					switch(mytype) {
					case MYTGA_MAPPED:
						for (i = 0; i < 4; i++)
							rgba[i] = palette[in[0] * 4 + i];
						break;
					case MYTGA_RGB15:
						TGA_upsample15(rgba, in, alphabits == 1);
						break;
					case MYTGA_RGB24:
						TGA_upsample24(rgba, in);
						break;
					case MYTGA_RGB32:
						TGA_upsample32(rgba, in);
						break;
					case MYTGA_MONO8:
						rgba[0] = rgba[1] = rgba[2] = in[0];
						break;
					case MYTGA_MONO16:
						rgba[0] = rgba[1] = rgba[2] = in[0];
						rgba[3] = in[1];
						break;
					}
					in += bpp;
				}
			}
			for (i = 0; i < 4; i++)
				*out++ = rgba[i];
			if (++x == image_width) {
				// end of line, advance to next
				x = 0;
				y++;
				out += row_inc;
			}
		}
	}

	Q_free(fileBuffer);
	return data;
}

int Image_WriteTGA (char *filename, byte *pixels, size_t width, size_t height)
{
	char name[MAX_PATH];
	byte buffer[18] = { 0 };
	vfsfile_t *outfile;

	buffer[2] = 2;          // uncompressed type
	buffer[12] = width & 255;
	buffer[13] = (width >> 8) & 0xFF;
	buffer[14] = height & 255;
	buffer[15] = (height >> 8) & 0xFF;
	buffer[16] = 24;

	snprintf (name, sizeof(name), "%s", filename);
	if (!(outfile = FS_OpenVFS(filename, "wb", FS_NONE_OS))) {
		FS_CreatePath (name);
		if (!(outfile = FS_OpenVFS(name, "wb", FS_NONE_OS))) {
			return false;
		}
	}

	VFS_WRITE(outfile, buffer, sizeof(buffer));
	VFS_WRITE(outfile, pixels, (int)(width * height * 3));
	VFS_CLOSE(outfile);
	return true;
}

/*********************************** JPEG ************************************/

#ifdef WITH_JPEG
#ifndef jpeg_create_compress
#define jpeg_create_compress(cinfo) \
    jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_compress_struct))
#endif

typedef struct 
{
  struct jpeg_destination_mgr pub; 
  vfsfile_t *outfile;
  JOCTET *buffer;
} my_destination_mgr;

typedef my_destination_mgr *my_dest_ptr;

#define JPEG_OUTPUT_BUF_SIZE  4096

static qbool jpeg_in_error = false;

static void JPEG_IO_init_destination(j_compress_ptr cinfo)
{
	my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
	dest->buffer = (JOCTET *) (cinfo->mem->alloc_small)
		((j_common_ptr) cinfo, JPOOL_IMAGE, JPEG_OUTPUT_BUF_SIZE * sizeof(JOCTET));
	dest->pub.next_output_byte = dest->buffer;
	dest->pub.free_in_buffer = JPEG_OUTPUT_BUF_SIZE;
}

static boolean JPEG_IO_empty_output_buffer (j_compress_ptr cinfo) 
{
	my_dest_ptr dest = (my_dest_ptr) cinfo->dest;

	if (VFS_WRITE(dest->outfile, dest->buffer, JPEG_OUTPUT_BUF_SIZE) != JPEG_OUTPUT_BUF_SIZE)
	{
		jpeg_in_error = true;
		return (boolean)false;
	}
	dest->pub.next_output_byte = dest->buffer;
	dest->pub.free_in_buffer = JPEG_OUTPUT_BUF_SIZE;
	return (boolean)true;
}

static void JPEG_IO_term_destination (j_compress_ptr cinfo)
{
	my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
	size_t datacount = JPEG_OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;

	if (datacount > 0) {
		if (((size_t) VFS_WRITE(dest->outfile, dest->buffer, (int)datacount)) != datacount)
		{
			jpeg_in_error = true;
			return;
		}
	}
	VFS_FLUSH(dest->outfile);
}

static void JPEG_IO_set_dest (j_compress_ptr cinfo, vfsfile_t *outfile)
{
	my_dest_ptr dest;

	if (!cinfo->dest) {
		cinfo->dest = (struct jpeg_destination_mgr *) (cinfo->mem->alloc_small)(
							(j_common_ptr) cinfo,JPOOL_PERMANENT, sizeof(my_destination_mgr));
	}

	dest = (my_dest_ptr) cinfo->dest;
	dest->pub.init_destination = JPEG_IO_init_destination;
	dest->pub.empty_output_buffer = JPEG_IO_empty_output_buffer;
	dest->pub.term_destination = JPEG_IO_term_destination;
	dest->outfile = outfile;
}

typedef struct my_error_mgr 
{
	struct jpeg_error_mgr pub;
	jmp_buf setjmp_buffer;
} jpeg_error_mgr_wrapper;

void jpeg_error_exit (j_common_ptr cinfo)
{	
	longjmp(((jpeg_error_mgr_wrapper *) cinfo->err)->setjmp_buffer, 1);
}

int Image_WriteJPEG(char *filename, int quality, byte *pixels, int width, int height) 
{
	char name[MAX_PATH];
	vfsfile_t *outfile;

	jpeg_error_mgr_wrapper jerr;
	struct jpeg_compress_struct cinfo;
	JSAMPROW row_pointer[1];

	snprintf (name, sizeof(name), "%s", filename);  
	if (!(outfile = FS_OpenVFS(name, "wb", FS_NONE_OS))) {
		FS_CreatePath (name);
		if (!(outfile = FS_OpenVFS(name, "wb", FS_NONE_OS)))
			return false;
	}
	cinfo.err = jpeg_std_error(&jerr.pub);
	jerr.pub.error_exit = jpeg_error_exit;
	if (setjmp(jerr.setjmp_buffer)) {
		VFS_CLOSE(outfile);
		return false;
	}
	jpeg_create_compress(&cinfo);

	jpeg_in_error = false;
	JPEG_IO_set_dest(&cinfo, outfile);

	cinfo.image_width = abs(width); 	
	cinfo.image_height = height;
	cinfo.input_components = 3;
	cinfo.in_color_space = JCS_RGB;
	jpeg_set_defaults(&cinfo);
	jpeg_set_quality (&cinfo, bound(0, quality, 100), (boolean)true);
	jpeg_start_compress(&cinfo, (boolean)true);

	while (cinfo.next_scanline < height) {
	    *row_pointer = &pixels[(int)cinfo.next_scanline * width * 3];
	    jpeg_write_scanlines(&cinfo, row_pointer, 1);
		if (jpeg_in_error)
			break;
	}

	jpeg_finish_compress(&cinfo);
	VFS_CLOSE(outfile);
	jpeg_destroy_compress(&cinfo);
	return true;
}


//
// jpeg loading
// stolen from Spikes FTE
//

typedef struct my_error_mgr * my_error_ptr;

// Here's the routine that will replace the standard error_exit method:
METHODDEF(void)
my_error_exit (j_common_ptr cinfo)
{
	// cinfo->err really points to a my_error_mgr struct, so coerce pointer
	my_error_ptr myerr = (my_error_ptr) cinfo->err;

	// Always display the message.
	// We could postpone this until after returning, if we chose.
	(*cinfo->err->output_message) (cinfo);

	// Return control to the setjmp point 
	longjmp(myerr->setjmp_buffer, 1);
}

//
// Sample routine for JPEG decompression.  We assume that the source file name
// is passed in.  We want to return 1 on success, 0 on error.
//

// Expanded data source object for stdio input 

typedef struct 
{
	struct jpeg_source_mgr pub;	// Public fields.

	byte * infile;				// Source stream.
	int currentpos;
	int maxlen;
	JOCTET * buffer;			// Start of buffer.
	boolean start_of_file;		// Have we gotten any data yet?
} my_source_mgr;

typedef my_source_mgr * my_src_ptr;

#define INPUT_BUF_SIZE  4096	// Choose an efficiently fread'able size.

/*METHODDEF(void)
init_source (j_decompress_ptr cinfo)
{
  my_src_ptr src = (my_src_ptr) cinfo->src;

  src->start_of_file = TRUE;
}

METHODDEF(boolean)
fill_input_buffer (j_decompress_ptr cinfo)
{
	my_source_mgr *src = (my_source_mgr*) cinfo->src;
	size_t nbytes;
  
	nbytes = src->maxlen - src->currentpos;
	if (nbytes > INPUT_BUF_SIZE)
		nbytes = INPUT_BUF_SIZE;
	memcpy(src->buffer, &src->infile[src->currentpos], nbytes);
	src->currentpos+=nbytes;

	if (nbytes <= 0) 
	{
		if (src->start_of_file)	// Treat empty input file as fatal error.
			ERREXIT(cinfo, JERR_INPUT_EMPTY);
		
		WARNMS(cinfo, JWRN_JPEG_EOF);
		
		// Insert a fake EOI marker.
		src->buffer[0] = (JOCTET) 0xFF;
		src->buffer[1] = (JOCTET) JPEG_EOI;
		nbytes = 2;
	}

	src->pub.next_input_byte = src->buffer;
	src->pub.bytes_in_buffer = nbytes;
	src->start_of_file = FALSE;

	return TRUE;
}


METHODDEF(void)
skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
	my_source_mgr *src = (my_source_mgr*) cinfo->src;

	if (num_bytes > 0) 
	{
		while (num_bytes > (long) src->pub.bytes_in_buffer) 
		{
			num_bytes -= (long) src->pub.bytes_in_buffer;
			(void) fill_input_buffer(cinfo);
		}
		src->pub.next_input_byte += (size_t) num_bytes;
		src->pub.bytes_in_buffer -= (size_t) num_bytes;
	}
}

METHODDEF(void)
term_source (j_decompress_ptr cinfo)
{
}

GLOBAL(void)
jpeg_mem_src (j_decompress_ptr cinfo, byte * infile, int maxlen)
{
	my_source_mgr *src;

	if (cinfo->src == NULL) 
	{	
		// First time for this JPEG object?
		cinfo->src = (struct jpeg_source_mgr *)(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(my_source_mgr));
		
		src = (my_source_mgr*) cinfo->src;
		
		src->buffer = (JOCTET *)(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, INPUT_BUF_SIZE * sizeof(JOCTET));
	}

	src = (my_source_mgr*) cinfo->src;
	src->pub.init_source = init_source;
	src->pub.fill_input_buffer = fill_input_buffer;
	src->pub.skip_input_data = skip_input_data;
	src->pub.resync_to_restart = jpeg_resync_to_restart; // Use default method.
	src->pub.term_source = term_source;
	src->infile = infile;
	src->pub.bytes_in_buffer = 0; // Forces fill_input_buffer on first read.
	src->pub.next_input_byte = NULL; // until buffer loaded.

	src->currentpos = 0;
	src->maxlen = maxlen;
}
*/

byte *Image_LoadJPEG(vfsfile_t *fin, const char *filename, int matchwidth, int matchheight, int *real_width, int *real_height)
{
	byte *mem = NULL, *in, *out;
	int i, image_width, image_height;

	byte *infile = NULL;
	int length;
	int filesize;

	// This struct contains the JPEG decompression parameters and pointers to
	// working space (which is allocated as needed by the JPEG library).
	struct jpeg_decompress_struct cinfo;
	
	// We use our private extension JPEG error handler.
	// Note that this struct must live as long as the main JPEG parameter
	// struct, to avoid dangling-pointer problems.
	struct my_error_mgr jerr;
	
	// More stuff 
	JSAMPARRAY buffer;		// Output row buffer.
	int size_stride;		// physical row width in output buffer.

	if (!fin && !(fin = FS_OpenVFS(filename, "rb", FS_ANY)))
		return NULL;
	filesize = VFS_GETLEN(fin);

	infile = (byte *) Q_malloc(length = filesize);
	if (VFS_READ(fin, infile, filesize, NULL) != filesize) 
	{
		Com_DPrintf ("Image_LoadJPEG: fread() failed on %s\n", COM_SkipPath(filename));
		VFS_CLOSE(fin);
		Q_free(infile);
		return NULL;
	}

	VFS_CLOSE(fin);

	// Step 1: allocate and initialize JPEG decompression object.

	// We set up the normal JPEG error routines, then override error_exit. 
	cinfo.err = jpeg_std_error(&jerr.pub);
	jerr.pub.error_exit = my_error_exit;

	// Establish the setjmp return context for my_error_exit to use. */
	if (setjmp(jerr.setjmp_buffer)) 
	{
		// If we get here, the JPEG code has signaled an error.

badjpeg:

		jpeg_destroy_decompress(&cinfo);    

		Q_free(infile);
		Q_free(mem);
		Com_DPrintf ("Image_LoadJPEG: badjpeg %s, len %d\n", COM_SkipPath(filename), length);
		return 0;
	}

	jpeg_create_decompress(&cinfo);

	jpeg_mem_src(&cinfo, infile, length);

	(void) jpeg_read_header(&cinfo, TRUE);  

	(void) jpeg_start_decompress(&cinfo);

	image_width  = cinfo.output_width;
	image_height = cinfo.output_height;

	// Return the width and height.
	if (real_width)
		(*real_width) = image_width;

	if (real_height)
		(*real_height) = image_height;

	if (image_width > IMAGE_MAX_DIMENSIONS || image_height > IMAGE_MAX_DIMENSIONS || image_width <= 0 || image_height <= 0)
	{
		Com_Printf("Bad actual dimensions %dx%d in jpeg %s\n", image_width, image_height, COM_SkipPath(filename));
		goto badjpeg;
	}

	if ((matchwidth && image_width != matchwidth) || (matchheight && image_height != matchheight))
	{
		Com_Printf("Bad match dimensions %dx%d vs %dx%d in jpeg %s\n", image_width, image_height, matchwidth, matchheight, COM_SkipPath(filename));
		goto badjpeg; 
	}

	if (cinfo.output_components!=3)
	{
		Com_Printf("Bad number of componants in jpeg %s\n", COM_SkipPath(filename));
		goto badjpeg;
	}

	size_stride = cinfo.output_width * cinfo.output_components;
	// Make a one-row-high sample array that will go away when done with image.
	buffer = (*cinfo.mem->alloc_sarray)
		((j_common_ptr) &cinfo, JPOOL_IMAGE, size_stride, 1);

	out = mem = Q_malloc(cinfo.output_height*cinfo.output_width*4);
	memset(out, 0, cinfo.output_height*cinfo.output_width*4);

	while (cinfo.output_scanline < cinfo.output_height) 
	{
		(void) jpeg_read_scanlines(&cinfo, buffer, 1);    

		in = buffer[0];
		for (i = 0; i < cinfo.output_width; i++)
		{
			// RGB to RGBA
			*out++ = *in++;
			*out++ = *in++;
			*out++ = *in++;
			*out++ = 255;	
		}	
	}

	(void) jpeg_finish_decompress(&cinfo);

	jpeg_destroy_decompress(&cinfo);

	Q_free(infile);
	return mem;
}
#endif // WITH_JPEG

/************************************ PCX ************************************/

typedef struct pcx_s 
{
    char			manufacturer;
    char			version;
    char			encoding;
    char			bits_per_pixel;
    unsigned short	xmin,ymin,xmax,ymax;
    unsigned short	hres,vres;
    byte			palette[48];
    char			reserved;
    char			color_planes;
    unsigned short	bytes_per_line;
    unsigned short	palette_type;
    char			filler[58];
    byte			data;		
} pcx_t;

byte *Image_LoadPCX (vfsfile_t *fin, const char *filename, int matchwidth, int matchheight, int *real_width, int *real_height) 
{
	pcx_t *pcx;
	byte *pcxbuf, *data, *out, *pix;
	int x, y, dataByte, runLength, width, height;
	int filesize;

	if (!fin && !(fin = FS_OpenVFS(filename, "rb", FS_ANY)))
		return NULL;
	filesize = VFS_GETLEN(fin);

	pcxbuf = (byte *) Q_malloc(filesize);
	if (VFS_READ(fin, pcxbuf, filesize, NULL) != filesize) 
	{
		Com_DPrintf ("Image_LoadPCX: fread() failed on %s\n", COM_SkipPath(filename));
		VFS_CLOSE(fin);
		Q_free(pcxbuf);
		return NULL;
	}
	VFS_CLOSE(fin);

	pcx = (pcx_t *) pcxbuf;
	pcx->xmax = LittleShort (pcx->xmax);
	pcx->xmin = LittleShort (pcx->xmin);
	pcx->ymax = LittleShort (pcx->ymax);
	pcx->ymin = LittleShort (pcx->ymin);
	pcx->hres = LittleShort (pcx->hres);
	pcx->vres = LittleShort (pcx->vres);
	pcx->bytes_per_line = LittleShort (pcx->bytes_per_line);
	pcx->palette_type = LittleShort (pcx->palette_type);

	pix = &pcx->data;

	if (pcx->manufacturer != 0x0a || pcx->version != 5 || pcx->encoding != 1 || pcx->bits_per_pixel != 8) 
	{
		Com_DPrintf ("Invalid PCX image %s\n", COM_SkipPath(filename));
		Q_free(pcxbuf);
		return NULL;
	}

	width = pcx->xmax + 1;
	height = pcx->ymax + 1;

	// Return the width and height.
	if (real_width)
		(*real_width) = width;

	if (real_height)
		(*real_height) = height;

	if (width > IMAGE_MAX_DIMENSIONS || height > IMAGE_MAX_DIMENSIONS)
	{
		Com_DPrintf ("PCX image %s exceeds maximum supported dimensions\n", COM_SkipPath(filename));
		Q_free(pcxbuf);
		return NULL;
	}

	if ((matchwidth && width != matchwidth) || (matchheight && height != matchheight))
	{
		Q_free(pcxbuf);
		return NULL;
	}
 
	data = out = (byte *) Q_malloc (width * height);

	for (y = 0; y < height; y++, out += width)
	{
		for (x = 0; x < width; ) 
		{
			if (pix - (byte *) pcx > filesize) 
			{
				Com_DPrintf ("Malformed PCX image %s\n", COM_SkipPath(filename));
				Q_free(pcxbuf);
				Q_free(data);
				return NULL;
			}

			dataByte = *pix++;

			if ((dataByte & 0xC0) == 0xC0)
			{
				runLength = dataByte & 0x3F;
				if (pix - (byte *) pcx > filesize)
				{
					Com_DPrintf ("Malformed PCX image %s\n", COM_SkipPath(filename));
					Q_free(pcxbuf);
					Q_free(data);
					return NULL;
				}
				dataByte = *pix++;
			}
			else 
			{
				runLength = 1;
			}

			if (runLength + x > width + 1) 
			{
				Com_DPrintf ("Malformed PCX image %s\n", COM_SkipPath(filename));
				Q_free(pcxbuf);
				Q_free(data);
				return NULL;
			}

			while (runLength-- > 0)
				out[x++] = dataByte;
		}
	}

	if (pix - (byte *) pcx > filesize) 
	{
		Com_DPrintf ("Malformed PCX image %s\n", COM_SkipPath(filename));
		Q_free(pcxbuf);
		Q_free(data);
		return NULL;
	}

	Q_free(pcxbuf);
	return data;
}

// This does't load 32bit pcx, just convert 8bit color buffer to 32bit buffer, so we can make from this texture.
byte *Image_LoadPCX_As32Bit (vfsfile_t *fin, const char *filename, int matchwidth, int matchheight, int *real_width, int *real_height)
{
	int image_width, image_height;
	unsigned *out;
	int size, i;
	byte *pix = Image_LoadPCX (fin, filename, matchwidth, matchheight, &image_width, &image_height);

	if (!pix)
		return NULL;

	if (real_width)
		(*real_width) = image_width;

	if (real_height)
		(*real_height) = image_height;

	size = image_width * image_height;
	out = Q_malloc(size * sizeof(unsigned));

	for (i = 0; i < size; i++)
		out[i] = d_8to24table[pix[i]];

	Q_free(pix);

	return (byte*) out;
}

int Image_WritePCX (char *filename, byte *data, int width, int height, byte *palette)
{
	int rowbytes = width;
	
	int i, j, length;
	byte *pack;
	pcx_t *pcx;

	if (!(pcx = (pcx_t *) Q_malloc (width * height * 2 + 1000)))
		return false;

	pcx->manufacturer = 0x0a;
	pcx->version = 5;		
 	pcx->encoding = 1;		
	pcx->bits_per_pixel = 8;
	pcx->xmin = 0;
	pcx->ymin = 0;
	pcx->xmax = LittleShort((short) (width - 1));
	pcx->ymax = LittleShort((short) (height - 1));
	pcx->hres = LittleShort((short) width);
	pcx->vres = LittleShort((short) height);
	memset (pcx->palette, 0, sizeof(pcx->palette));
	pcx->color_planes = 1;		
	pcx->bytes_per_line = LittleShort((short) width);
	pcx->palette_type = LittleShort(1);		
	memset (pcx->filler, 0, sizeof(pcx->filler));

	pack = &pcx->data;

	for (i = 0; i < height; i++) 
	{
		for (j = 0; j < width; j++) 
		{
			if ((*data & 0xc0) != 0xc0)
				*pack++ = *data++;
			else {
				*pack++ = 0xc1;
				*pack++ = *data++;
			}
		}
		data += rowbytes - width;
	}

	*pack++ = 0x0c;	
	for (i = 0; i < 768; i++)
		*pack++ = *palette++;

	length = pack - (byte *) pcx;
	if (!(FS_WriteFile_2 (filename, pcx, length)))
	{
		Q_free(pcx);
		return false;
	}

	Q_free(pcx);
	return true;
}

/*********************************** INIT ************************************/

void Image_Init(void) 
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SCREENSHOTS);

	#ifdef WITH_PNG
	Cvar_Register (&image_png_compression_level);
	#endif // WITH_PNG

	#ifdef WITH_JPEG
	Cvar_Register (&image_jpeg_quality_level);
	#endif // WITH_JPEG

	Cvar_ResetCurrentGroup();
}




================================================
FILE: src/image.h
================================================
/*

Copyright (C) 1996-2003 A Nourai, Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef _IMAGE_H

#define _IMAGE_H

#if defined(WITH_PNG) && !defined(WITH_ZLIB)
#error WITH_PNG requires WITH_ZLIB
#endif

void Image_Init(void);

void Image_Resample (void *indata, int inwidth, int inheight,
					 void *outdata, int outwidth, int outheight, int bpp, int quality);
void Image_MipReduce (const byte *in, byte *out, int *width, int *height, int bpp);

#if defined(WITH_PNG)
#include <png.h>

typedef struct
{
	byte *data;
	png_textp textchunks;
	size_t text_count;
} png_data;

png_textp Image_LoadPNG_Comments (char *filename, int *text_count);
png_data *Image_LoadPNG_All (vfsfile_t *vin, const char *filename, int matchwidth, int matchheight, int loadflag, int *real_width, int *real_height);
#endif

byte *Image_LoadPNG (vfsfile_t *v, const char *path, int matchwidth, int matchheight, int *real_width, int *real_height);
byte *Image_LoadTGA (vfsfile_t *v, const char *path, int matchwidth, int matchheight, int *real_width, int *real_height);
byte *Image_LoadPCX (vfsfile_t *v, const char *path, int matchwidth, int matchheight, int *real_width, int *real_height);
byte *Image_LoadJPEG(vfsfile_t *v, const char *path, int matchwidth, int matchheight, int *real_width, int *real_height);
// this does't load 32bit pcx, just convert 8bit color buffer to 32bit buffer, so we can make from this texture
byte *Image_LoadPCX_As32Bit (vfsfile_t *v, const char *path, int matchwidth, int matchheight, int *real_width, int *real_height);

int Image_WritePNG(char *filename, int compression, byte *pixels, size_t width, size_t height);
int Image_WriteTGA(char *filename, byte *pixels, size_t width, size_t height);
int Image_WriteJPEG(char *filename, int quality, byte *pixels, int width, int height);
int Image_WritePCX(char *filename, byte *data, int width, int height, byte *palette);

qbool Image_OpenAPNG(char* filename, int compression, int width, int height, int frames);
qbool Image_WriteAPNGFrame(byte* pixels, size_t width, size_t height, int fps);
qbool Image_CloseAPNG(void);

extern cvar_t image_jpeg_quality_level, image_png_compression_level;

#endif	//_IMAGE_H



================================================
FILE: src/in_osx.h
================================================
/*
 Copyright (C) 2011 Florian Zwoch
 Copyright (C) 2011 Mark Olsen
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
 See the GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

int OSX_Mouse_Init(void);
void OSX_Mouse_Shutdown(void);
void OSX_Mouse_GetMouseMovement(int *mouse_x, int *mouse_y);


================================================
FILE: src/in_osx.m
================================================
/*
Copyright (C) 2011 Florian Zwoch
Copyright (C) 2011 Mark Olsen

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#import <SDL.h>
#import <GameController/GameController.h>
#import "common.h"

static id mouseAddedObserver = nil;
static id mouseRemovedObserver = nil;
static SDL_mutex *mouse_mutex = NULL;
static float mouse_x = 0;
static float mouse_y = 0;

static void OSX_RegisterMouseMovedHandler(GCMouse *mouse)
{
	mouse.mouseInput.mouseMovedHandler = ^(GCMouseInput *input, float deltaX, float deltaY) {
		SDL_LockMutex(mouse_mutex);
		mouse_x += deltaX;
		mouse_y += deltaY;
		SDL_UnlockMutex(mouse_mutex);
	};
}

static void OSX_CreateMouseObserver(void)
{
	mouseAddedObserver = [[NSNotificationCenter defaultCenter]
					 addObserverForName:GCMouseDidConnectNotification
								 object:nil
								  queue:nil
							 usingBlock:^(NSNotification *note) {
								 OSX_RegisterMouseMovedHandler(note.object);
							 }
	];
	mouseRemovedObserver = [[NSNotificationCenter defaultCenter]
			addObserverForName:GCMouseDidDisconnectNotification
						object:nil
						 queue:nil
					usingBlock:^(NSNotification *note) {
						GCMouse *mouse = note.object;
						mouse.mouseInput.mouseMovedHandler = nil;
					}
	];
}

int OSX_Mouse_Init(void)
{
	mouse_x = 0;
	mouse_y = 0;

	if (mouse_mutex != NULL) {
		return 0;
	}

	mouse_mutex = SDL_CreateMutex();
	OSX_CreateMouseObserver();

	return 0;
}

void OSX_Mouse_Shutdown(void)
{
	if (mouse_mutex == NULL) {
		return;
	}

	[[NSNotificationCenter defaultCenter] removeObserver:mouseAddedObserver];
	mouseAddedObserver = nil;
	[[NSNotificationCenter defaultCenter] removeObserver:mouseRemovedObserver];
	mouseRemovedObserver = nil;

	SDL_DestroyMutex(mouse_mutex);
	mouse_mutex = NULL;
}

void OSX_Mouse_GetMouseMovement(int *m_x, int *m_y)
{
	SDL_LockMutex(mouse_mutex);

	*m_x = (int)mouse_x;
	*m_y = (int)mouse_y;

	mouse_x = 0;
	mouse_y = 0;

	SDL_UnlockMutex(mouse_mutex);
}


================================================
FILE: src/in_sdl2.c
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include <stdint.h>

#include "SDL.h"
#include "SDL_joystick.h"
#include "common.h"
#include "cvar.h"
#include "quakedef.h"
#include "input.h"
#include "keys.h"
#include "movie.h"

#ifndef _WIN32
#include <sys/time.h>
#endif

#ifdef __APPLE__
#include "in_osx.h"
#endif

static void in_joystick_callback(cvar_t *var, char *value, qbool *cancel);

cvar_t	m_filter        = {"m_filter",       "0", CVAR_SILENT};
cvar_t	cl_keypad       = {"cl_keypad",      "1", CVAR_SILENT};

/*  Joystick cvars.  */
cvar_t	in_joystick		= {"joystick",			"0",	CVAR_SILENT, in_joystick_callback };
cvar_t	joy_index		= {"joyindex",			"0",	CVAR_SILENT };
cvar_t	joy_name		= {"joyname",			"joystick", CVAR_SILENT };
cvar_t	joy_advanced		= {"joyadvanced",		"0",	CVAR_SILENT };
cvar_t	joy_advaxisx		= {"joyadvaxisx",		"0",	CVAR_SILENT };
cvar_t	joy_advaxisy		= {"joyadvaxisy",		"0",	CVAR_SILENT };
cvar_t	joy_advaxisz		= {"joyadvaxisz",		"0",	CVAR_SILENT };
cvar_t	joy_advaxisr		= {"joyadvaxisr",		"0",	CVAR_SILENT };
cvar_t	joy_advaxisu		= {"joyadvaxisu",		"0",	CVAR_SILENT };
cvar_t	joy_advaxisv		= {"joyadvaxisv",		"0",	CVAR_SILENT };
cvar_t	joy_forwardthreshold	= {"joyforwardthreshold",	"0.15",	CVAR_SILENT };
cvar_t	joy_sidethreshold	= {"joysidethreshold",		"0.15",	CVAR_SILENT };
cvar_t	joy_flythreshold	= {"joyflythreshold",		"0.15",	CVAR_SILENT };
cvar_t	joy_pitchthreshold	= {"joypitchthreshold",		"0.15",	CVAR_SILENT };
cvar_t	joy_yawthreshold	= {"joyyawthreshold",		"0.15",	CVAR_SILENT };
cvar_t	joy_flysensitivity	= {"joyflysensitivity",		"-1.0",	CVAR_SILENT };
cvar_t	joy_forwardsensitivity	= {"joyforwardsensitivity",	"-1.0",	CVAR_SILENT };
cvar_t	joy_sidesensitivity	= {"joysidesensitivity",	"-1.0",	CVAR_SILENT };
cvar_t	joy_pitchsensitivity	= {"joypitchsensitivity",	"1.0",	CVAR_SILENT };
cvar_t	joy_yawsensitivity	= {"joyyawsensitivity",		"-1.0",	CVAR_SILENT };


extern cvar_t	movie_steadycam, movie_fps;
extern int	mx, my;
extern qbool	mouseinitialized;

extern void IN_StartupMouse(void);
extern void IN_DeactivateMouse(void);
extern void IN_Restart_f(void);


/***************************************************************************
 * Mouse-y things.
 */
void IN_MouseMove (usercmd_t *cmd)
{
	static int old_mouse_x = 0, old_mouse_y = 0;

	if (!mouseinitialized)
		return;

	//
	// Do not move the player if we're in HUD editor or menu mode.
	// And don't apply ingame sensitivity, since that will make movements jerky.
	//
	if (! IN_MouseTrackingRequired())
	{
		// Normal game mode.
		float mouse_x, mouse_y;

		if (m_filter.value) {
			float filterfrac = bound (0.0f, m_filter.value, 1.0f) / 2.0f;
			mouse_x = (mx * (1.0f - filterfrac) + old_mouse_x * filterfrac);
			mouse_y = (my * (1.0f - filterfrac) + old_mouse_y * filterfrac);
		} else {
			mouse_x = mx;
			mouse_y = my;
		}

		old_mouse_x = mx;
		old_mouse_y = my;

		if (m_accel.value > 0.0f) {
			float accelsens = sensitivity.value;
			float mousespeed = (sqrt (mx * mx + my * my)) / (1000.0f * (float) cls.trueframetime);

			mousespeed -= m_accel_offset.value;
			if (mousespeed > 0) {
				mousespeed *= m_accel.value;
				if (m_accel_power.value > 1) {
					accelsens += exp((m_accel_power.value - 1) * log(mousespeed));
				} else {
					accelsens = 1;
				}
			}
			if (m_accel_senscap.value > 0 && accelsens > m_accel_senscap.value) {
				accelsens = m_accel_senscap.value;
			}

			mouse_x *= accelsens;
			mouse_y *= accelsens;
		} else {
			mouse_x *= sensitivity.value;
			mouse_y *= sensitivity.value;
		}

		// add mouse X/Y movement to cmd
		if ((in_strafe.state & 1) || (lookstrafe.value && mlook_active))
			cmd->sidemove += m_side.value * mouse_x;
		else if (!cl.paused || cls.demoplayback || cl.spectator)
			cl.viewangles[YAW] -= m_yaw.value * mouse_x;

		if (mlook_active)
			V_StopPitchDrift ();

		if (mlook_active && !(in_strafe.state & 1))
		{
			if (!cl.paused || cls.demoplayback || cl.spectator) {
				cl.viewangles[PITCH] += m_pitch.value * mouse_y;
			}
			if (cl.viewangles[PITCH] > cl.maxpitch)
				cl.viewangles[PITCH] = cl.maxpitch;
			if (cl.viewangles[PITCH] < cl.minpitch)
				cl.viewangles[PITCH] = cl.minpitch;
		} else {
			cmd->forwardmove -= m_forward.value * mouse_y;
		}
	}
	else {
		old_mouse_x = mx * cursor_sensitivity.value;
		old_mouse_y = my * cursor_sensitivity.value;
	}

	mx = my = 0; // clear for next update
}


/***************************************************************************
 * Stick-y things.
 */
enum joy_axes {
	JOY_AXIS_X = 0,
	JOY_AXIS_Y,
	JOY_AXIS_Z,
	JOY_AXIS_R,
	JOY_AXIS_U,
	JOY_AXIS_V,
	JOY_MAX_AXES,

	JOY_ABSOLUTE_AXIS = 0x0000,		// control like a joystick
	JOY_RELATIVE_AXIS = 0x0100,		// control like a mouse, spinner, trackball
};

enum _ControlList {
	AXIS__NONE = 0,
	AXIS_FORWARD,
	AXIS_LOOK,
	AXIS_SIDE,
	AXIS_TURN,
	AXIS_FLY,
};

static SDL_Joystick	*joy_dev;
static uint32_t		joy_prevbuttons;
static uint16_t		axis_map[JOY_MAX_AXES];
static uint16_t		control_map[JOY_MAX_AXES];
static uint16_t		joy_numbuttons,
			joy_numaxes;
static int16_t		joy_devidx = -1;
static uint8_t		joy_prevpov;
static qbool		joy_avail, joy_haspov, joy_advancedinit;

static void in_joystick_callback(cvar_t *var, char *value, qbool *cancel)
{
  if ((var == &in_joystick) && (atoi(value) != in_joystick.value)) {
    Cvar_SetValue(&in_joystick, atoi(value));
    IN_Restart_f();
  }
}

/*
 * The user needs to invoke this command after changing the 'joyadv*' cvars.
 */
static void
Joy_AdvancedUpdate_f (void)
{
	// Called once by IN_ReadJoystick and by user whenever an update is needed
	// cvars are now available.
	int		i;
	uint16_t	val;

	// initialize all the maps
	for (i = 0;  i < JOY_MAX_AXES;  ++i) {
		axis_map[i]	= AXIS__NONE;
		control_map[i]	= JOY_ABSOLUTE_AXIS;
		//pdwRawValue[i] = RawValuePointer(i);
	}

	if (!joy_advanced.integer) {
		// Default joystick initialization
		// 2 axes only with joystick control.
		axis_map[JOY_AXIS_X] = AXIS_TURN;
		// dwControlMap[JOY_AXIS_X] = JOY_ABSOLUTE_AXIS;
		axis_map[JOY_AXIS_Y] = AXIS_FORWARD;
		// dwControlMap[JOY_AXIS_Y] = JOY_ABSOLUTE_AXIS;
	}
	else
	{
		if (strcmp (joy_name.string, "joystick")) {
			// Notify user of advanced controller.
			Com_Printf ("\n%s configured\n\n", joy_name.string);
		}

		// Advanced initialization here
		// data supplied by user via joy_axisn cvars.
		// Axis index in bits 7:0.  Relative/absolute flag
		// is bit 8.
		val = joy_advaxisx.integer;
		axis_map[JOY_AXIS_X] = val & 0x00ff;
		control_map[JOY_AXIS_X] = val & JOY_RELATIVE_AXIS;
		val = joy_advaxisy.integer;
		axis_map[JOY_AXIS_Y] = val & 0x00ff;
		control_map[JOY_AXIS_Y] = val & JOY_RELATIVE_AXIS;
		val = joy_advaxisz.integer;
		axis_map[JOY_AXIS_Z] = val & 0x00ff;
		control_map[JOY_AXIS_Z] = val & JOY_RELATIVE_AXIS;
		val = joy_advaxisr.integer;
		axis_map[JOY_AXIS_R] = val & 0x00ff;
		control_map[JOY_AXIS_R] = val & JOY_RELATIVE_AXIS;
		val = joy_advaxisu.integer;
		axis_map[JOY_AXIS_U] = val & 0x00ff;
		control_map[JOY_AXIS_U] = val & JOY_RELATIVE_AXIS;
		val = joy_advaxisv.integer;
		axis_map[JOY_AXIS_V] = val & 0x00ff;
		control_map[JOY_AXIS_V] = val & JOY_RELATIVE_AXIS;
	}

	/*
	 * If the requested joystick device index has changed, try opening it.
	 */
	if (joy_devidx != joy_index.integer) {
		SDL_Joystick *newdev;

		newdev = SDL_JoystickOpen (joy_index.integer);
		if (newdev) {
			if (joy_dev) {
				/*  Close the old one.  */
				SDL_JoystickClose (joy_dev);
			}
			joy_dev		= newdev;
			joy_devidx	= joy_index.integer;
			joy_numaxes	= SDL_JoystickNumAxes (joy_dev);
			joy_numbuttons	= SDL_JoystickNumButtons (joy_dev);
			joy_haspov	= (SDL_JoystickNumHats (joy_dev) > 0);
			if (joy_numbuttons > sizeof (joy_prevbuttons) * 8) {
				/*  We can't handle more than 32 buttons.  */
				joy_numbuttons = sizeof (joy_prevbuttons) * 8;
			}
			Con_Printf ("Opened joystick index %d: \"%s\"\n",
			            joy_index.integer, SDL_JoystickName (joy_dev));
		} else {
			Con_Printf ("Failed to open joystick index %d\n", joy_index.integer);
		}
	}
}

void
IN_Commands (void)
{
	uint32_t	buttonstate, buttonmask;
	int		i, base_key;

	if (!joy_avail  ||  !joy_dev  ||  !in_joystick.integer)
		return;

	/*
	 * Loop through the joystick buttons
	 * First four buttons are mapped to K_JOY[1-4].  Buttons after that are
	 * mapped to K_AUX1+.  POV directions are mapped to K_JOYPOV{UP,RT,DN,LT}.
	 */
	buttonstate = 0;
	for (i = 0;  i < joy_numbuttons;  ++i) {
		uint8_t val = SDL_JoystickGetButton (joy_dev, i);

		buttonstate |= val << i;
		buttonmask = 1 << i;

		if ((buttonstate ^ joy_prevbuttons) & buttonmask) {
			base_key = i < 4 ?  K_JOY1 :  K_AUX1 - 4;
			Key_Event (base_key + i, val != 0);
		}
	}
	joy_prevbuttons = buttonstate;

	if (joy_haspov) {
		/*
		 * SDL_JoystickGetHat() returns a bitmask of the four cardinal
		 * directions in up/right/down/left order from bit 0.  Only
		 * the first POV hat is used.
		 */
		uint8_t povstate = SDL_JoystickGetHat (joy_dev, 0);
		uint8_t povmask;

		for (i = 0;  i < 4;  ++i) {
			povmask = 1 << i;

			if ((povstate ^ joy_prevpov) & povmask) {
				Key_Event (K_JOYPOVUP + i, !!(povstate & povmask));
			}
		}
		joy_prevpov = povstate;
	}
}

static void
IN_JoyMove (usercmd_t *cmd)
{
	float	speed, aspeed, frametime;
	float	axisval;
	int	i;

	if (!in_joystick.integer) return;

	if (Movie_IsCapturing()  &&  movie_steadycam.value) {
		frametime = movie_fps.value > 0 ?  1.0 / movie_fps.value
		                                :  1.0 / 30.0;
	} else {
		frametime = cls.trueframetime;
	}

	// Complete initialization if first time in
	// this is needed as cvars are not available at initialization time.
	if (!joy_advancedinit)
	{
		Joy_AdvancedUpdate_f();
		joy_advancedinit = true;
	}

	// Verify joystick is available and that the user wants to use it.
	if (!joy_avail  ||  !joy_dev)
		return;

	speed = (in_speed.state & 1) ? cl_movespeedkey.value : 1.0;
	aspeed = speed * frametime;

	// Loop through the axes.
	for (i = 0;  i < JOY_MAX_AXES;  ++i)
	{
		if (axis_map[i] == AXIS__NONE  ||  i >= joy_numaxes) {
			continue;
		}
		axisval = SDL_JoystickGetAxis (joy_dev, i);

		// Convert range from -32768..32767 to -1..1
		axisval /= 32768.0;

		switch (axis_map[i]) {
		case AXIS_FORWARD:
			if (joy_advanced.integer == 0  &&  mlook_active)
			{
				// user wants forward control to become look control
				if (fabs (axisval) > joy_pitchthreshold.value) {
					// if mouse invert is on, invert the joystick pitch value
					// only absolute control support here (joy_advanced is false)
					if (m_pitch.value < 0.0)
						cl.viewangles[PITCH] -= (axisval * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
					else
						cl.viewangles[PITCH] += (axisval * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
					V_StopPitchDrift();
				} else {
					// no pitch movement
					// disable pitch return-to-center unless requested by user
					// *** this code can be removed when the lookspring bug is fixed
					// *** the bug always has the lookspring feature on
					if (lookspring.value == 0.0)
						V_StopPitchDrift();
				}
			} else {
				// user wants forward control to be forward control
				if (fabs (axisval) > joy_forwardthreshold.value)
					cmd->forwardmove += (axisval * joy_forwardsensitivity.value) * speed * cl_forwardspeed.value;
			}
			break;

		case AXIS_SIDE:
			if (fabs (axisval) > joy_sidethreshold.value)
				cmd->sidemove += (axisval * joy_sidesensitivity.value) * speed * cl_sidespeed.value;
			break;

		case AXIS_FLY:
			if (fabs (axisval) > joy_flythreshold.value)
				cmd->upmove += (axisval * joy_flysensitivity.value) * speed * cl_upspeed.value;
			break;

		case AXIS_TURN:
			if ((in_strafe.state & 1)  ||  (lookstrafe.value  &&  mlook_active)) {
				// user wants turn control to become side control
				if (fabs (axisval) > joy_sidethreshold.value)
					cmd->sidemove -= (axisval * joy_sidesensitivity.value) * speed * cl_sidespeed.value;
			} else {
				// user wants turn control to be turn control
				if (fabs (axisval) > joy_yawthreshold.value) {
					if (control_map[i] == JOY_ABSOLUTE_AXIS)
						cl.viewangles[YAW] += (axisval * joy_yawsensitivity.value) * aspeed * cl_yawspeed.value;
					else
						cl.viewangles[YAW] += (axisval * joy_yawsensitivity.value) * speed * 180.0;
				}
			}
			break;

		case AXIS_LOOK:
			if (mlook_active)
			{
				if (fabs (axisval) > joy_pitchthreshold.value)
				{
					// pitch movement detected and pitch movement desired by user
					if (control_map[i] == JOY_ABSOLUTE_AXIS)
						cl.viewangles[PITCH] += (axisval * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
					else
						cl.viewangles[PITCH] += (axisval * joy_pitchsensitivity.value) * speed * 180.0;
					V_StopPitchDrift();
				}
				else
				{
					// no pitch movement
					// disable pitch return-to-center unless requested by user
					// *** this code can be removed when the lookspring bug is fixed
					// *** the bug always has the lookspring feature on
					if (lookspring.value == 0.0)
						V_StopPitchDrift();
				}
			}
			break;

		default:
			break;
		}
	}

	// Bounds check pitch
	//cl.viewangles[PITCH] = bound (-70, cl.viewangles[PITCH], 80);
	if (cl.viewangles[PITCH] > cl.maxpitch)
		cl.viewangles[PITCH] = cl.maxpitch;
	if (cl.viewangles[PITCH] < cl.minpitch)
		cl.viewangles[PITCH] = cl.minpitch;
}

static void
IN_StartupJoystick (void)
{
	SDL_Joystick	*jdev;
	int		numdevs, i;

	//COM_CheckParm ("-joystick");
	
	if (!host_initialized) {
		Cvar_SetCurrentGroup (CVAR_GROUP_INPUT_JOYSTICK);
		Cvar_Register (&in_joystick);
		Cvar_Register (&joy_index);
		Cvar_Register (&joy_name);
		Cvar_Register (&joy_advanced);
		Cvar_Register (&joy_advaxisx);
		Cvar_Register (&joy_advaxisy);
		Cvar_Register (&joy_advaxisz);
		Cvar_Register (&joy_advaxisr);
		Cvar_Register (&joy_advaxisu);
		Cvar_Register (&joy_advaxisv);
		Cvar_Register (&joy_forwardthreshold);
		Cvar_Register (&joy_sidethreshold);
		Cvar_Register (&joy_flythreshold);
		Cvar_Register (&joy_pitchthreshold);
		Cvar_Register (&joy_yawthreshold);
		Cvar_Register (&joy_flysensitivity);
		Cvar_Register (&joy_forwardsensitivity);
		Cvar_Register (&joy_sidesensitivity);
		Cvar_Register (&joy_pitchsensitivity);
		Cvar_Register (&joy_yawsensitivity);
		Cvar_ResetCurrentGroup();

		Cmd_AddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);
	}

	if (!in_joystick.value) return;

	if (SDL_WasInit (SDL_INIT_JOYSTICK) == 0) {
		int ret = SDL_InitSubSystem (SDL_INIT_JOYSTICK);
		if (ret == -1) {
			Com_Printf ("\nSDL joystick subsystem init failed.\n");
			return;
		}
	}

	/*  See if there are any joysticks at all.  */
	numdevs = SDL_NumJoysticks();
	if (!numdevs) {
		Com_Printf ("\nno joysticks detected by SDL\n\n");
		return;
	}

	/*  Check if we can open any of them.  */
	for (i = 0;  i < numdevs;  ++i) {
		jdev = SDL_JoystickOpen (i);
		if (jdev) {
			Com_Printf ("Detected joystick %d: %d axes, %d buttons: \"%s\"\n",
			            i,
			            SDL_JoystickNumAxes (jdev),
			            SDL_JoystickNumButtons (jdev),
			            SDL_JoystickName (jdev));
			SDL_JoystickClose (jdev);
			joy_avail = true;
		}
	}
}

void
IN_DeactivateJoystick (void)
{
	// Close the device here.
	return;
}

void IN_Move (usercmd_t *cmd)
{
	IN_MouseMove (cmd);
	IN_JoyMove (cmd);
}

void IN_Init (void)
{
	Cvar_SetCurrentGroup (CVAR_GROUP_INPUT_MOUSE);
	Cvar_Register (&m_filter);

	Cvar_SetCurrentGroup (CVAR_GROUP_INPUT_KEYBOARD);
	Cvar_Register (&cl_keypad);
	Cvar_ResetCurrentGroup ();

	if (!host_initialized) {
		Cmd_AddCommand("in_restart", IN_Restart_f);
	}

	IN_StartupMouse ();
	IN_StartupJoystick();
}

void IN_Shutdown(void)
{
	IN_DeactivateMouse(); // btw we trying de init this in video shutdown too...

#ifdef __APPLE__
	OSX_Mouse_Shutdown(); // Safe to call, will just return if it's not running
#endif

	mouseinitialized = false;
}



================================================
FILE: src/input.h
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
// input.h -- external (non-keyboard) input devices

#ifndef __INPUT_H__
#define __INPUT_H__

void IN_Init (void);
void IN_Shutdown (void);
void IN_Commands (void); // oportunity for devices to stick commands on the script buffer
void IN_Move (usercmd_t *cmd); // add additional movement on top of the keyboard move cmd
void IN_ClearProtectedKeys (void); // reset player movement

//
// cl_input.c
//
typedef struct
{
	int		down[2];		// key nums holding it down
	int		state;			// low bit is down state
	double	downtime;		// when KeyDown() last time called for that button
	double	uptime;			// when KeyUp() last time called for that button
} kbutton_t;

extern kbutton_t in_mlook, in_klook;
extern kbutton_t in_strafe;
extern kbutton_t in_speed;

void CL_InitInput (void);
void CL_SendClientCommand(qbool reliable, char *format, ...);
void CL_SendCmd (void);
void CL_BaseMove (usercmd_t *cmd);
float CL_KeyState (kbutton_t *key, qbool lookbutton);
qbool Key_TryMovementProtected(const char *cmd, qbool down, int key);

extern cvar_t	allow_scripts;

extern cvar_t	cl_upspeed;
extern cvar_t	cl_forwardspeed;
extern cvar_t	cl_backspeed;
extern cvar_t	cl_sidespeed;
extern cvar_t	cl_movespeedkey;
extern cvar_t	cl_anglespeedkey;
extern cvar_t	cl_yawspeed;
extern cvar_t	cl_pitchspeed;
extern cvar_t	cl_keypad;

extern cvar_t	freelook;
extern cvar_t	sensitivity;
extern cvar_t	cursor_sensitivity;
extern cvar_t	lookspring;
extern cvar_t	lookstrafe;

extern cvar_t	m_pitch;
extern cvar_t	m_yaw;
extern cvar_t	m_forward;
extern cvar_t	m_side;
extern cvar_t	m_accel;
extern cvar_t	m_accel_power;
extern cvar_t	m_accel_senscap;
extern cvar_t	m_accel_offset;
extern cvar_t	m_filter;
extern cvar_t	_windowed_mouse;

#define mlook_active	(freelook.value || (in_mlook.state&1))

#endif /* __INPUT_H__ */


================================================
FILE: src/irc.c
================================================
/*
Copyright (C) 2011 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifdef WITH_IRC

#include "quakedef.h"
#include "libircclient.h"
#include "libirc_rfcnumeric.h"
#include "version.h"
#include "textencoding.h"
#include "irc_filter.h"

// because of MAX_MACRO_STRING
#include "teamplay.h"

cvar_t irc_server_address = {"irc_server_address", "194.124.229.59"}; // quakenet
cvar_t irc_server_port = {"irc_server_port", "6667"};
cvar_t irc_server_password = {"irc_server_password", ""};
cvar_t irc_user_nick = {"irc_user_nick", ""};
cvar_t irc_user_username = {"irc_user_username", "ezQuake"};
cvar_t irc_user_realname = {"irc_user_realname", ""};

#define MAX_TARGET_LEN 128
#define MAX_CHANS 100

typedef struct
{
	unsigned int size;
	unsigned int current;
	char *list[MAX_CHANS];
} irc_chanlist;

typedef struct
{
	irc_chanlist chanlist;
	char nick[MAX_TARGET_LEN];
} irc_ctx_t;

extern cvar_t name;

static irc_callbacks_t callbacks;
static irc_session_t * irc_singlesession;
static irc_ctx_t irc_ctx;
static fd_set irc_fd_in, irc_fd_out;
static int irc_maxfd = 0;

#define MAXPRINTMSG     4096 // should be moved from common.c to common.h

int utf8ToWc(char* str, wchar* c) {
        int i, n;
		unsigned char c1, c2;
        unsigned char c0 = (unsigned char)str[0];
        *c = '_';
        if (c0 & 0x80) {                                                                 // 1xxx xxxx
                if(c0 & 0x40) {                                                         // 11xx xxxx
                        if(c0 & 0x20) {                                                 // 111x xxxx
                                if(c0 & 0x10) {                                         // 1111 xxxx
                                        n = 4;
                                        if(c0 & 0x08) {                                 // 1111 1xxx
                                                n = 5;
                                                if(c0 & 0x04) {                         // 1111 11xx
                                                        if(c0 & 0x02) {                 // 1111 111x
                                                                return 1;
                                                        }
                                                        n = 6;
                                                }
                                        }
                                        i = 1;
                                        while(i < n && (str[i] & 0x80) == 0x80)
                                                ++i;
                                        return i;
                                } else {                // 1110xxxx
                                        c1 = (unsigned char)str[1];
                                        if((c1 & (0x80 | 0x40)) != 0x80)
                                                return 1;

                                        c2 = (unsigned char)str[2];
                                        if((c2 & (0x80 | 0x40)) != 0x80)
                                                return 2;

                                        *c = (((wchar)c0 & 0x0f) << 12) |
                                                (((wchar)c1 & 0x3f) << 6) |
                                                ((wchar)c2 & 0x3f);

                                        // Ugly utf-16 surrogate catch (D800-DFFF)
                                        if ((unsigned short)(c - 0xD800) < 0x800) {
                                                *c = '_';
                                        }

                                        return 3;
                                }
                        } else {                                // 110xxxxx
                                c1 = (unsigned char)str[1];
                                if((c1 & (0x80 | 0x40)) != 0x80)
                                        return 1;

                                *c = (((wchar)c0 & 0x1f) << 6) |
                                        ((wchar)c1 & 0x3f);
                                return 2;
                        }
                } else {                                        // 10xxxxxx
                        return 1;
                }
        } else {                                                // 0xxxxxxx
                *c = c0;
                return 1;
        }
}

int wcToUtf8(wchar c, char *dst) {
        if(c >= 0x0800) {
                dst[0] = (char)(0x80 | 0x40 | 0x20  | (c >> 12));
                dst[1] = (char)(0x80 | ((c >> 6) & 0x3f));
                dst[2] = (char)(0x80 | (c & 0x3f));
				return 3;
        } else if(c >= 0x0080) {
                dst[0] = (char)(0x80 | 0x40 | (c >> 6));
                dst[1] = (char)(0x80 | (c & 0x3f));
				return 2;
        } else {
                dst[0] = (char)c;
				return 1;
        }
}

char* encode_utf8(wchar *wmsg)
{
	static char buffer[MAXPRINTMSG];
	int src, dst;
	for (src = dst = 0; wmsg[src]; src++) {
		dst += wcToUtf8(wmsg[src], &(buffer[dst]));
	}
	buffer[dst] = 0;
	return buffer;
}

void IRC_Printf(char *fmt, ...)
{
	wchar *wmsg;
	char utf8_ok = 1;
	size_t dst, src, len;

	va_list argptr;
	char msg[MAXPRINTMSG];

	va_start (argptr, fmt);
	vsnprintf (msg, sizeof(msg), fmt, argptr);
	va_end (argptr);
	
	len = strlen(msg);
	wmsg = (wchar*) Q_malloc((len+1) * sizeof(wchar));
	for (src = dst = 0; src < len; dst++) {
		int numc = utf8ToWc(&(msg[src]), &(wmsg[dst]));
		if (wmsg[dst] == '_' && msg[src] != '_') utf8_ok = 0;
		src += numc;
	}
	wmsg[dst] = 0;

#ifdef _WIN32 // todo: fixme. don't know to convert from single-byte system codepage. sorry, *nix: you will read only utf-8
	if (!utf8_ok) {
		// fix some cp1251/etc bastard
		MultiByteToWideChar(CP_ACP, 0, msg, len, wmsg, len);
	}
#endif
	Con_PrintW(wmsg);
	Q_free(wmsg);
}

void IRC_Chanlist_Add(irc_chanlist *list, const char* chan)
{
	int i;

	for (i = 0; i < list->size; ++i) {
		if (strcmp(list->list[i], chan) == 0) {
			return;
		}
	}

	if (list->size < MAX_CHANS) {
		list->list[list->size] = Q_strdup(chan);
		list->current = list->size++;
	}
	else {
		Com_Printf("Maximum amount of IRC channels reached\n");
	}
}

qbool IRC_Chanlist_Remove(irc_chanlist *list, const char* chan)
{
	int i;

	for (i = 0; i < list->size; i++) {
		if (strcmp(list->list[i], chan) == 0) {
			Q_free(list->list[i]);
			if (list->size > 1) {
				list->list[i] = list->list[list->size-1];
			}
			list->size--;

			if (list->current >= list->size) {
				// don't select the next window as the removed one was the last one
				// so select the previous one, or none if list is empty
				list->current = list->size ? list->size - 1 : 0;
			}

			return true;
		}
	}

	return false;
}

static char *IRC_Chanlist_GetCurrent(irc_chanlist *list)
{
	if (list->size) {
		return list->list[list->current];
	}
	else {
		return "";
	}
}

char* IRC_GetCurrentChan(void)
{
	return IRC_Chanlist_GetCurrent(&irc_ctx.chanlist);
}

static void IRC_Chanlist_ChooseNext(irc_chanlist *list)
{
	list->current++;
	if (list->current >= list->size) {
		list->current = 0;
	}
}

void IRC_NextChan(void) {
	IRC_Chanlist_ChooseNext(&irc_ctx.chanlist);
}

static void IRC_Chanlist_ChoosePrev(irc_chanlist *list)
{
	if (list->current) {
		list->current--;
	}
	else {
		list->current = list->size - 1;
	}
}

void IRC_PrevChan(void) {
	IRC_Chanlist_ChoosePrev(&irc_ctx.chanlist);
}

char *Cmd_ArgLine(unsigned int starting_from_arg)
{
	static char args[MAX_MACRO_STRING];
	int i;

	args[0] = '\0';

	for (i = starting_from_arg; i < Cmd_Argc(); i++) {
		if (i > starting_from_arg)
			strlcat (args, " ", MAX_MACRO_STRING);

		strlcat (args, Cmd_Argv(i), MAX_MACRO_STRING);
	}

	return args;
}

char* IRC_mask_to_nick(const char* mask)
{
	static char masktonickbuf[255];
	irc_target_get_nick(mask, masktonickbuf, sizeof(masktonickbuf));
	return masktonickbuf;
}

void IRC_event_ctcp_req(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	IRC_Printf("IRC: CTCP Request %s from %s\n", params[0], IRC_mask_to_nick(origin));

	if (strcmp(params[0], "VERSION") == 0) {
		irc_cmd_ctcp_reply(session, IRC_mask_to_nick(origin), "VERSION ezQuake " VERSION_NUMBER);
		Com_Printf("- replied\n");
	}
	Com_Printf("- ignored\n");
}

void IRC_event_notice(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
    if (!IRC_filter_show_notice_messages())
        return;
    
	IRC_Printf("IRC: *%s* (%s): %s\n", origin, params[0], count > 1 ? params[1] : "");
}

void IRC_event_topic(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
    if (!IRC_filter_show_chanop_messages())
        return;
    
	if (count > 1) {
		IRC_Printf("IRC: %s changes topic on %s to %s\n", origin, params[0], params[1]);
	}
	else {
		IRC_Printf("IRC: %s changes topic on %s\n", origin, params[0]);
	}
}

void IRC_event_mode(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
    if (!IRC_filter_show_chanop_messages())
        return;
    
    IRC_Printf("IRC: %s (%s) sets mode %s%s%s\n", IRC_mask_to_nick(origin), params[0], params[1],
               (count > 2 ? " " : ""), (count > 2 ? params[3] : ""));
}

void IRC_event_kick(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
    if (!IRC_filter_show_chanop_messages())
        return;
    
    IRC_Printf("IRC: %s has been kicked from %s by %s (%s)\n", params[1], params[0], IRC_mask_to_nick(origin), params[2]);
}

void IRC_event_privmsg(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	irc_ctx_t *ctx = (irc_ctx_t *) irc_get_ctx(session);

	if (count > 1) {
        if (IRC_filter_show_private_messages()) {
            IRC_Printf("IRC: (Privmsg) <%s> %s\n", IRC_mask_to_nick(origin), params[1]);
        }
		IRC_Chanlist_Add(&ctx->chanlist, IRC_mask_to_nick(origin));
	}
}

void IRC_event_channel (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
    if (!IRC_filter_show_chanop_messages())
        return;
        
	if (count > 1) {
		IRC_Printf("IRC: (%s) <%s> %s\n", params[0], IRC_mask_to_nick(origin), params[1]);
	}
}

void IRC_event_join (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	irc_ctx_t *ctx = (irc_ctx_t *) irc_get_ctx(session);
	
	if ( !origin )
		return;

	// We need to know whether WE are joining the channel, or someone else.
	// To do this, we compare the origin with our nick.
    // Note that we have set LIBIRC_OPTION_STRIPNICKS to obtain 'parsed' nicks.
	if ( !strcmp(IRC_mask_to_nick(origin), ctx->nick)) {
		IRC_Printf("IRC: You've joined %s\n", params[0]);
		IRC_Chanlist_Add(&ctx->chanlist, params[0]);		
	}
	else {
        if (IRC_filter_show_chanop_messages()) {
            IRC_Printf("IRC: %s &c0f0joined&cfff %s\n", IRC_mask_to_nick(origin), params[0]);
        }
	}
}

void IRC_event_part (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	irc_ctx_t *ctx = (irc_ctx_t *) irc_get_ctx(session);

	if (strcmp(IRC_mask_to_nick(origin), ctx->nick) == 0) {
		IRC_Chanlist_Remove(&ctx->chanlist, params[0]);
		IRC_Printf("IRC: You have left %s\n", params[0]);
	}
	else {
    if (IRC_filter_show_chanop_messages()) {
      IRC_Printf("IRC: %s has &c888left&cfff %s\n", IRC_mask_to_nick(origin), params[0]);
    }
	}
}

void IRC_event_quit (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
    if (!IRC_filter_show_connection_messages())
        return;
    
    IRC_Printf("IRC: %s Quit: %s\n", IRC_mask_to_nick(origin), count > 1 ? params[0] : "-");
}

void IRC_event_nick (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
    if (!IRC_filter_show_connection_messages())
        return;

    Com_Printf("IRC: Nick event\n");
}

void IRC_event_connect (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	Com_Printf("IRC: Connected\n");
}

void IRC_event_numeric (irc_session_t * session, unsigned int event, const char * origin, const char ** params, unsigned int count)
{
	if ( event > 400 )
	{
		IRC_Printf ("IRC ERROR %d: %s: %s %s %s %s\n", 
				event,
				origin ? origin : "unknown",
				params[0],
				count > 1 ? params[1] : "",
				count > 2 ? params[2] : "",
				count > 3 ? params[3] : "");
	}
	else {
		int i;

		switch (event) {
			case LIBIRC_RFC_RPL_WELCOME:
				IRC_Printf("IRC: Welcome to the Internet Relay Network %s\n", params[0]);
				break;

			case LIBIRC_RFC_RPL_MOTDSTART:
				Com_Printf("IRC: Message of the day:\n");
				break;

			case LIBIRC_RFC_RPL_MOTD:
				IRC_Printf("IRC: %s\n", params[1]);
				break;

			case LIBIRC_RFC_RPL_ENDOFMOTD:
				Com_Printf("IRC: End of MOTD\n");
				break;

			case LIBIRC_RFC_RPL_NAMREPLY:
				Com_Printf("IRC: Names:\n");
				for (i = 2; i < count; ++i) {
					IRC_Printf(" %s", params[i]);
				}
				Com_Printf("\n");
				break;

			case LIBIRC_RFC_RPL_TOPIC:
				Com_Printf("IRC: Topic:\n");
				for (i = 2; i < count; ++i) {
					IRC_Printf(" %s", params[i]);
				}
				Com_Printf("\n");
				break;

			default:
				Com_Printf("IRC: Event %d\n", event);
				break;
		}
	}
}

void IRC_event_universal (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	char buf[512];
	int cnt;

	buf[0] = '\0';

	for ( cnt = 0; cnt < count; cnt++ )
	{
		if ( cnt )
			strcat (buf, "|");

		strcat (buf, params[cnt]);
	}


	IRC_Printf ("Event \"%s\", origin: \"%s\", params: %d [%s]\n", event, origin ? origin : "NULL", cnt, buf);
}

void normalise_channel_name(char * channel, char * output)
{
    if (channel[0] == '#') {
        strcpy(output, channel);
    } else {
        strcpy(output, "#");
        strcat(output, channel);
    }
}

static void IRC_irc_f(void)
{
	irc_ctx_t *ctx = (irc_ctx_t *) irc_get_ctx(irc_singlesession);

	if (Cmd_Argc() < 2) {
		Com_Printf("Usage: irc <command>\n");
		return;
	}

	if (strcmp(Cmd_Argv(1), "connect") == 0) {
		// use quake name by default
		const char *nick = irc_user_nick.string[0] ? irc_user_nick.string : name.string;

		if (irc_connect (irc_singlesession, irc_server_address.string, irc_server_port.integer,
			irc_server_password.string[0] ? irc_server_password.string : NULL,
			nick, irc_user_username.string, irc_user_realname.string)
		) {
			IRC_Printf ("IRC: Could not connect: %s\n", irc_strerror (irc_errno(irc_singlesession)));
		}
		else {
			strlcpy(ctx->nick, nick, MAX_TARGET_LEN);
			
			// multithreading is not good for us (lots of things are not thread-safe)
			// we use single-threaded variant
			// Sys_CreateThread(IRC_Run, NULL);

			Com_Printf("IRC: Connecting...\n");
		}
	}
	else if (strcmp(Cmd_Argv(1), "disconnect") == 0) {
		irc_disconnect(irc_singlesession);
	}
	else if (strcmp(Cmd_Argv(1), "say") == 0) {
		char *chan = IRC_Chanlist_GetCurrent(&ctx->chanlist);
		if (chan) {
			char *msg = Cmd_ArgLine(2);
			wchar *wmsg = decode_string(msg);
			irc_cmd_msg(irc_singlesession, chan, encode_utf8(wmsg));
			Com_Printf("IRC: (%s) <%s> ", chan, ctx->nick);
			Con_PrintW(wmsg);
			Com_Printf("\n");
		}
		else {
			Com_Printf("No current channel selected\n");
		}
	}
	else if (strcmp(Cmd_Argv(1), "query") == 0) {
		if (Cmd_Argc() < 3) {
			Com_Printf("Too few arguments\n");
		}
		else {
			char *msg = Cmd_ArgLine(3);
			char *targetnick = Cmd_Argv(2);

			IRC_Chanlist_Add(&ctx->chanlist, targetnick);
			irc_cmd_msg(irc_singlesession, targetnick, msg);
			Com_Printf("IRC: (%s) <%s> %s\n", targetnick, ctx->nick, msg);
		}
	}
	else if (strcmp(Cmd_Argv(1), "window") == 0) {
		if (Cmd_Argc() < 3) {
		}
		else {
			if (strcmp(Cmd_Argv(2), "next") == 0) {
				IRC_NextChan();
			}
			else if (strcmp(Cmd_Argv(2), "prev") == 0) {
				IRC_PrevChan();
			}
			else if (strcmp(Cmd_Argv(2), "close") == 0) {
				IRC_Chanlist_Remove(&ctx->chanlist, IRC_GetCurrentChan());
			}
			else {
				Com_Printf("Uknown argument. Valid arguments: next, prev, close\n");
			}
		}
		IRC_Printf("IRC: Current window: %s\n", IRC_GetCurrentChan());
	}
	else if (strcmp(Cmd_Argv(1), "nick") == 0) {
		if (Cmd_Argc() >= 3) {
			irc_cmd_nick(irc_singlesession, Cmd_Argv(2));
			
			// fixme
			// we presume here that the change will succeed
			// that may cause lots of troubles
			strlcpy(ctx->nick, Cmd_Argv(2), MAX_TARGET_LEN);
		}
	}
    else if ((strcmp(Cmd_Argv(1), "join") == 0) ||
             (strcmp(Cmd_Argv(1), "part") == 0)) {
        char *normalised_channel = malloc(strlen(Cmd_Argv(2) + 1));
        normalise_channel_name(Cmd_Argv(2), normalised_channel);
        
        if (strcmp(Cmd_Argv(1), "join") == 0) {
            irc_cmd_join(irc_singlesession, normalised_channel, Cmd_Argv(3));
        } else {
            irc_cmd_part(irc_singlesession, normalised_channel);
        }
        
        free(normalised_channel);
    }
	else {
		char *cmd = Cmd_ArgLine(1);
		wchar *wcmd = decode_string(cmd);
		irc_send_raw(irc_singlesession, "%s", encode_utf8(wcmd));
		Com_Printf("IRC: ");
		Con_PrintW(wcmd);
		Com_Printf("\n");
	}
}

void IRC_Update(void)
{
	struct timeval timeout = { 0, 0 };
	int r;

	if (irc_singlesession && irc_is_connected(irc_singlesession)) {
		FD_ZERO(&irc_fd_in);
		FD_ZERO(&irc_fd_out);
		r = irc_add_select_descriptors(irc_singlesession, &irc_fd_in, &irc_fd_out, &irc_maxfd);
		if (r != 0) {
			Com_Printf("Could not set IRC socket descriptors:\n");
			IRC_Printf("- %s\n", irc_strerror(r));
		}

		r = select(irc_maxfd+1, &irc_fd_in, &irc_fd_out, 0, &timeout);
		if (r == -1) {
			Com_Printf("IRC: select() failed\n");
		} else if (r == 0) {
			// no data ready
		}
		else {
			r = irc_process_select_descriptors(irc_singlesession, &irc_fd_in, &irc_fd_out);
			if (r) {
				Com_Printf("IRC: Error processing select descriptors:\n");
				IRC_Printf("- %s\n", irc_strerror(r));
			}
		}
	}
}

void IRC_Init(void)
{
	callbacks.event_connect = IRC_event_connect;
	callbacks.event_join = IRC_event_join;
	callbacks.event_numeric = IRC_event_numeric;
	callbacks.event_ctcp_req = IRC_event_ctcp_req;
	callbacks.event_privmsg = IRC_event_privmsg;
	callbacks.event_channel = IRC_event_channel;
	callbacks.event_nick = IRC_event_nick;
	callbacks.event_part = IRC_event_part;
	callbacks.event_ctcp_action = IRC_event_universal;
	callbacks.event_ctcp_rep = IRC_event_universal;
	// callbacks.event_dcc_chat_req = IRC_event_universal;
	// callbacks.event_dcc_send_req = IRC_event_universal;
	callbacks.event_invite = IRC_event_universal;
	callbacks.event_kick = IRC_event_kick;
	callbacks.event_mode = IRC_event_mode;
	callbacks.event_notice = IRC_event_notice;
	callbacks.event_quit = IRC_event_quit;
	callbacks.event_umode = IRC_event_universal;
	callbacks.event_unknown = IRC_event_universal;
	callbacks.event_topic = IRC_event_topic;

	irc_singlesession = irc_create_session (&callbacks);
	if (!irc_singlesession) {
		Com_Printf ("Could not create IRC session\n");
		return;
	}

	irc_ctx.chanlist.size = 0;
	irc_ctx.chanlist.current = 0;
	irc_set_ctx (irc_singlesession, &irc_ctx);

	Cmd_AddCommand("irc", IRC_irc_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_CHAT);
	Cvar_Register(&irc_server_address);
	Cvar_Register(&irc_server_port);
	Cvar_Register(&irc_server_password);
	Cvar_Register(&irc_user_nick);
	Cvar_Register(&irc_user_username);
	Cvar_Register(&irc_user_realname);
  IRC_filter_register_cvars();

	Cvar_ResetCurrentGroup();
}

void IRC_Deinit(void)
{
	irc_destroy_session(irc_singlesession);
}
#endif



================================================
FILE: src/irc.h
================================================
/*
Internet Relay Chat Support

Copyright (C) 2009 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifdef WITH_IRC
/// initializes the IRC module, creates libircclient session 
void IRC_Init(void);

/// process new data waiting on the socket
void IRC_Update(void);

/// return the name of the active (currently selected) channel from the channel list
char* IRC_GetCurrentChan(void);

/// select following channel from the channels list as the current channel
void IRC_NextChan(void);

/// select previous channel from the channels list as the current channel
void IRC_PrevChan(void);
#endif



================================================
FILE: src/irc_filter.c
================================================
/*
 Internet Relay Chat filtering methods
 
 Copyright (C) 2011 Andrew 'dies-el' Donaldson
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifdef WITH_IRC

#include "quakedef.h"

cvar_t irc_filter_join_part_messages = {"irc_filter_join_part_messages", "0"};
cvar_t irc_filter_quit_messages = {"irc_filter_quit_messages", "0"};
cvar_t irc_filter_private_messages = {"irc_filter_private_messages", "0"};
cvar_t irc_filter_notice_messages = {"irc_filter_notice_messages", "0"};
 
void IRC_filter_register_cvars() {
  Cvar_Register(&irc_filter_join_part_messages);
  Cvar_Register(&irc_filter_quit_messages);
  Cvar_Register(&irc_filter_private_messages);
  Cvar_Register(&irc_filter_notice_messages);
}

// These methods are deliberately a lot broader than the cvars above.

int IRC_filter_show_chanop_messages() {
  return (irc_filter_join_part_messages.integer == 0);
}

int IRC_filter_show_connection_messages() {
  return (irc_filter_quit_messages.integer == 0);
}

int IRC_filter_show_private_messages() {
  return (irc_filter_private_messages.integer == 0);
}

int IRC_filter_show_notice_messages() {
  return (irc_filter_notice_messages.integer == 0);
}

#endif


================================================
FILE: src/irc_filter.h
================================================
/*
 Internet Relay Chat filtering methods
 
 Copyright (C) 2011 Andrew 'dies-el' Donaldson
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifdef WITH_IRC

// Registers the cvars that these filters rely on.
void IRC_filter_register_cvars(void);

// Returns true if chanop messages (join/parts/etc) are to be shown
int IRC_filter_show_chanop_messages(void);

// Returns true if connection messages (quits) are to be shown
int IRC_filter_show_connection_messages(void);

// Returns true if private messages are to be shown
int IRC_filter_show_private_messages(void);

// Returns true if notices are to be shown
int IRC_filter_show_notice_messages(void);

#endif


================================================
FILE: src/keys.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: keys.c,v 1.80 2007-09-26 13:53:42 tonik Exp $

*/

#include <wchar.h>
#include "quakedef.h"
#include "textencoding.h"
#include "menu.h"
#include "keys.h"
#include "input.h"

#ifdef _WIN32
#include <windows.h>
#endif

#include "gl_model.h"
#include "tr_types.h"

#include "hud.h"
#include "hud_common.h"
#include "hud_editor.h"
#include "demo_controls.h"
#include "irc.h"
#include "qtv.h"
#include "utils.h"

extern cvar_t sys_disable_alt_enter;

//key up events are sent even if in console mode

cvar_t cl_chatmode                  = {"cl_chatmode", "2"};
cvar_t con_funchars_mode            = {"con_funchars_mode", "0"};
cvar_t con_tilde_mode               = {"con_tilde_mode", "0"};
// values: old style, current + default values , current only, default only, current + default if changed, none.
cvar_t con_completion_format        = {"con_completion_format", "2"};
cvar_t con_hide_chat_input          = {"con_hide_chat_input", "1"};
cvar_t con_completion_changed_mark  = {"con_completion_changed_mark", "1"};
cvar_t con_bindphysical             = {"con_bindphysical", "0"};
cvar_t in_builtinkeymap             = {"in_builtinkeymap", "0"};

char* escape_regex(char* string);
void OnChange_con_prompt_charcode(cvar_t *var, char *string, qbool *cancel);
void OnChange_con_completion_color(cvar_t *var, char *string, qbool *cancel);
cvar_t con_prompt_charcode					= {"con_prompt_charcode", "93", CVAR_NONE, OnChange_con_prompt_charcode};
cvar_t con_completion_color_name			= {"con_completion_color_name", "8ff", CVAR_NONE, OnChange_con_completion_color};
cvar_t con_completion_color_value_current	= {"con_completion_color_value_current", "fff", CVAR_NONE, OnChange_con_completion_color};
cvar_t con_completion_color_value_default	= {"con_completion_color_value_default", "fff", CVAR_NONE, OnChange_con_completion_color};
cvar_t con_completion_color_quotes_current	= {"con_completion_color_quotes_current", "ff8", CVAR_NONE, OnChange_con_completion_color};
cvar_t con_completion_color_quotes_default	= {"con_completion_color_quotes_default", "ff8", CVAR_NONE, OnChange_con_completion_color};
cvar_t con_completion_color_colon			= {"con_completion_color_colon", "fff", CVAR_NONE, OnChange_con_completion_color};
cvar_t con_completion_color_title			= {"con_completion_color_title", "ff3", CVAR_NONE, OnChange_con_completion_color};
cvar_t con_completion_color_changed_mark	= {"con_completion_color_changed_mark", "f30", CVAR_NONE, OnChange_con_completion_color};
cvar_t con_completion_padding				= {"con_completion_padding", "2"};

cvar_t	cl_savehistory = {"cl_savehistory", "1"};
#define		HISTORY_FILE_NAME	"ezquake/.ezquake_history"

wchar	key_lines[CMDLINES][MAXCMDLINE];
int		key_linepos;
int		key_lastpress;

int		edit_line=0;
int		history_line=0;

int del_removes;
int key_lineposorig;
int old_keyline_length;
int last_cmd_length = 0;
int called_second = 0;
int try = 0;
int count = 0;
int count_cmd = 0;
int count_cvar = 0;
int count_alias = 0;

keydest_t	key_dest, key_dest_beforemm, key_dest_beforecon;

char	*keybindings[UNKNOWN + 256];
qbool	consolekeys[UNKNOWN + 256];	// if true, can't be rebound while in console
qbool	hudeditorkeys[UNKNOWN + 256];	// if true, can't be rebound while in hud editor
qbool	democontrolskey[UNKNOWN + 256];
int		keyshift[UNKNOWN + 256];		// key to map to if shift held down in console
int		key_repeats[UNKNOWN + 256];	// if > 1, it is autorepeating
qbool	keydown[UNKNOWN + 256];
qbool	keyactive[UNKNOWN + 256];

// SDL2 sends a KEYDOWN event and then an optional TEXTINPUT event for the actual character generated
// This stores the last quake key (K_*) from the KEYDOWN, or 0 if any subsequent TEXTINPUT event should be ignored.
static int lastKeyDown = 0;
static qbool lastKeyGeneratedCharacter = false;

typedef struct
{
	char *name;
	char *type;
} jogi_avail_complete_t;


typedef struct {
	char	*name;
	int		keynum;
} keyname_t;

keyname_t keynames[] = {
	{"TAB", K_TAB},
	{"ENTER", K_ENTER},
	{"ESCAPE", K_ESCAPE},
	{"SPACE", K_SPACE},
	{"BACKSPACE", K_BACKSPACE},

	{"CAPSLOCK",K_CAPSLOCK},
	{"PRINTSCR", K_PRINTSCR},
	{"PRINTSCRN", K_PRINTSCR},
	{"PRINTSCREEN", K_PRINTSCR},
	{"SCRLCK", K_SCRLCK},
	{"SCROLLLOCK", K_SCRLCK},
	{"SCROLLOCK", K_SCRLCK},	// misspelled; kept for compatibility

#ifdef __APPLE__
	{"COMMAND", K_CMD},
	{"PARA", K_PARA},
	{"F13", K_F13},
	{"F14", K_F14},
	{"F15", K_F15},
	{"KP_EQUAL", KP_EQUAL},
#endif

	{"PAUSE", K_PAUSE},

	{"UPARROW", K_UPARROW},
	{"DOWNARROW", K_DOWNARROW},
	{"LEFTARROW", K_LEFTARROW},
	{"RIGHTARROW", K_RIGHTARROW},

	{"ALT", K_ALT},
	{"LALT", K_LALT},
	{"RALT", K_RALT},

	{"ALTGR", K_RALT},
	{"ALTCHAR", K_RALT},

	{"CTRL", K_CTRL},
	{"LCTRL", K_LCTRL},
	{"RCTRL", K_RCTRL},
	{"SHIFT", K_SHIFT},
	{"LSHIFT", K_LSHIFT},
	{"RSHIFT", K_RSHIFT},

	{"WINKEY", K_WIN},
	{"LWINKEY", K_LWIN},
	{"RWINKEY", K_RWIN},
	{"POPUPMENU", K_MENU}, //???

	// special keys
	{"WIN", K_WIN},
	{"LWIN", K_LWIN},
	{"RWIN", K_RWIN},
	{"SUPER", K_WIN},
	{"LSUPER", K_LWIN},
	{"RSUPER", K_RWIN},
	{"MENU", K_MENU},
	{"ISO", K_ISO},

	// Keypad stuff..

	{"NUMLOCK", KP_NUMLOCK},
	{"KP_NUMLCK", KP_NUMLOCK},
	{"KP_NUMLOCK", KP_NUMLOCK},
	{"KP_SLASH", KP_SLASH},
	{"KP_DIVIDE", KP_SLASH},
	{"KP_STAR", KP_STAR},
	{"KP_MULTIPLY", KP_STAR},

	{"KP_MINUS", KP_MINUS},

	{"KP_HOME", KP_HOME},
	{"KP_7", KP_HOME},
	{"KP_UPARROW", KP_UPARROW},
	{"KP_8", KP_UPARROW},
	{"KP_PGUP", KP_PGUP},
	{"KP_9", KP_PGUP},
	{"KP_PLUS", KP_PLUS},

	{"KP_LEFTARROW", KP_LEFTARROW},
	{"KP_4", KP_LEFTARROW},
	{"KP_5", KP_5},
	{"KP_RIGHTARROW", KP_RIGHTARROW},
	{"KP_6", KP_RIGHTARROW},

	{"KP_END", KP_END},
	{"KP_1", KP_END},
	{"KP_DOWNARROW", KP_DOWNARROW},
	{"KP_2", KP_DOWNARROW},
	{"KP_PGDN", KP_PGDN},
	{"KP_3", KP_PGDN},

	{"KP_INS", KP_INS},
	{"KP_0", KP_INS},
	{"KP_DEL", KP_DEL},
	{"KP_ENTER", KP_ENTER},

	{"F1", K_F1},
	{"F2", K_F2},
	{"F3", K_F3},
	{"F4", K_F4},
	{"F5", K_F5},
	{"F6", K_F6},
	{"F7", K_F7},
	{"F8", K_F8},
	{"F9", K_F9},
	{"F10", K_F10},
	{"F11", K_F11},
	{"F12", K_F12},

	{"INS", K_INS},
	{"DEL", K_DEL},
	{"PGDN", K_PGDN},
	{"PGUP", K_PGUP},
	{"HOME", K_HOME},
	{"END", K_END},

	{"MOUSE1", K_MOUSE1},
	{"MOUSE2", K_MOUSE2},
	{"MOUSE3", K_MOUSE3},
	{"MOUSE4", K_MOUSE4},
	{"MOUSE5", K_MOUSE5},
	{"MOUSE6", K_MOUSE6},
	{"MOUSE7", K_MOUSE7},
	{"MOUSE8", K_MOUSE8},

	{"JOY1", K_JOY1},
	{"JOY2", K_JOY2},
	{"JOY3", K_JOY3},
	{"JOY4", K_JOY4},

	{"JOYPOVUP", K_JOYPOVUP},
	{"JOYPOVRT", K_JOYPOVRT},
	{"JOYPOVDN", K_JOYPOVDN},
	{"JOYPOVLT", K_JOYPOVLT},

	{"AUX1", K_AUX1},
	{"AUX2", K_AUX2},
	{"AUX3", K_AUX3},
	{"AUX4", K_AUX4},
	{"AUX5", K_AUX5},
	{"AUX6", K_AUX6},
	{"AUX7", K_AUX7},
	{"AUX8", K_AUX8},
	{"AUX9", K_AUX9},
	{"AUX10", K_AUX10},
	{"AUX11", K_AUX11},
	{"AUX12", K_AUX12},
	{"AUX13", K_AUX13},
	{"AUX14", K_AUX14},
	{"AUX15", K_AUX15},
	{"AUX16", K_AUX16},
	{"AUX17", K_AUX17},
	{"AUX18", K_AUX18},
	{"AUX19", K_AUX19},
	{"AUX20", K_AUX20},
	{"AUX21", K_AUX21},
	{"AUX22", K_AUX22},
	{"AUX23", K_AUX23},
	{"AUX24", K_AUX24},
	{"AUX25", K_AUX25},
	{"AUX26", K_AUX26},
	{"AUX27", K_AUX27},
	{"AUX28", K_AUX28},

	{"MWHEELUP", K_MWHEELUP},
	{"MWHEELDOWN", K_MWHEELDOWN},

	{"SEMICOLON", ';'},	// because a raw semicolon separates commands

	{"SECTION", K_SECTION},
	{"ACUTE", K_ACUTE},
	{"DIAERESIS", K_DIAERESIS},
	{"ARING", K_ARING},
	{"ADIAERESIS", K_ADIAERESIS},
	{"ODIAERESIS", K_ODIAERESIS},
	{"WAKE_UP", K_WAKE_UP},

	{NULL,0}
};

mouse_state_t scr_pointer_state;

/*
   ==============================================================================
   Flushing my array
   ==============================================================================
   */
void CompleteCommandNew_Reset (void)
{
	if ((del_removes) || (key_linepos == key_lineposorig))
	{
		del_removes = 0;
		called_second = 0;
		try = 0;
	}
}

/*
   ==============================================================================
   LINE TYPING INTO THE CONSOLE
   ==============================================================================
   */

qbool CheckForCommand (void) 
{
	char command[256], *s;

	strlcpy(command, wcs2str(key_lines[edit_line] + 1), sizeof(command));
	for (s = command; *s > ' '; s++)
		;
	*s = 0;

	return command[0] && (Cvar_Find(command) || Cmd_FindCommand(command) || Cmd_FindAlias(command) || Cmd_IsLegacyCommand(command));
}

//===================================================================
//  Advanced command completion

#define COLUMNWIDTH 20
#define MINCOLUMNWIDTH 18	// the last column may be slightly smaller


void PaddedPrint (char *s) 
{
	extern int con_linewidth;
	extern char *str_repeat (char *str, int amount);
	char *pad = NULL;
	int nextcolx = 0;

	if (con_completion_format.integer)  // plain list
	{
		pad = str_repeat(" ", con_completion_padding.integer);
		Com_Printf ("%s&c%s%s&r\n", pad, con_completion_color_name.string, s);
		Q_free(pad);
	}
	else
	{
		if (con.x)
			nextcolx = (int)((con.x + COLUMNWIDTH)/COLUMNWIDTH)*COLUMNWIDTH;

		if (nextcolx > con_linewidth - MINCOLUMNWIDTH || (con.x && nextcolx + strlen(s) >= con_linewidth))
			Com_Printf ("\n");

		if (con.x)
			Com_Printf (" ");
		while (con.x % COLUMNWIDTH)
			Com_Printf (" ");
		Com_Printf ("%s", s);
	}
}

void PaddedPrintMarkAndPad (qbool mark)
{
	extern char *str_repeat (char *str, int amount);

	char* s;
	int padding = con_completion_padding.integer;

	if (mark)
	{
		Com_Printf ("&c%s*", con_completion_color_changed_mark.string);
		padding -= 1;
	}

	s = str_repeat(" ", padding);
	Com_Printf ("%s", s);
	Q_free(s);
}

void PaddedPrintValue (char *s, char *v, char *dv)  // name, value, default value
{
	qbool changed = (strcmp(s, dv) != 0) && (strcmp(dv, v) != 0);
	qbool add_mark = (con_completion_changed_mark.integer > 0) && changed;

	switch (con_completion_format.integer)
	{
		case 1:	// current + default
			if (strcmp(s, dv))
			{
				PaddedPrintMarkAndPad (add_mark);
				Com_Printf ("&c%s%s &c%s:&r &c%s\"&c%s%s&c%s\"&r &c%s:&r &c%s\"&c%s%s&c%s\"&r\n",
						con_completion_color_name.string, s , con_completion_color_colon.string,
						con_completion_color_quotes_current.string, con_completion_color_value_current.string, v,
						con_completion_color_quotes_current.string, con_completion_color_colon.string,
						con_completion_color_quotes_default.string, con_completion_color_value_default.string, dv,
						con_completion_color_quotes_default.string);
			}
			else
			{
				PaddedPrintMarkAndPad (false);
				Com_Printf ("&c%s%s &c%s: &c%s\"&c%s%s&c%s\"&r\n",
						con_completion_color_name.string, s , con_completion_color_colon.string,
						con_completion_color_quotes_current.string, con_completion_color_value_current.string, v,
						con_completion_color_quotes_current.string);
			}
			break;

		case 2:	// current only
			PaddedPrintMarkAndPad (add_mark);
			Com_Printf ("&c%s%s &c%s: &c%s\"&c%s%s&c%s\"&r\n",
					con_completion_color_name.string, s , con_completion_color_colon.string,
					con_completion_color_quotes_current.string, con_completion_color_value_current.string, v,
					con_completion_color_quotes_current.string);
			break;

		case 3:	// default only
			PaddedPrintMarkAndPad (add_mark);
			Com_Printf ("&c%s%s &c%s:&r &c%s\"&c%s%s&c%s\"&r\n",
					con_completion_color_name.string, s, con_completion_color_colon.string,
					con_completion_color_quotes_default.string, con_completion_color_value_default.string,
					dv, con_completion_color_quotes_default.string);
			break;

		case 4:	// current + default if changed
			if(changed)
			{
				if (strcmp(s, dv))
				{
					PaddedPrintMarkAndPad (add_mark);
					Com_Printf ("&c%s%s &c%s:&r &c%s\"&c%s%s&c%s\"&r &c%s:&r &c%s\"&c%s%s&c%s\"&r\n",
							con_completion_color_name.string, s , con_completion_color_colon.string,
							con_completion_color_quotes_current.string, con_completion_color_value_current.string, v,
							con_completion_color_quotes_current.string, con_completion_color_colon.string,
							con_completion_color_quotes_default.string, con_completion_color_value_default.string, dv,
							con_completion_color_quotes_default.string);
				}
				else
				{
					PaddedPrintMarkAndPad (false);
					Com_Printf ("&c%s%s &c%s: &c%s\"&c%s%s&c%s\"&r\n",
							con_completion_color_name.string, s , con_completion_color_colon.string,
							con_completion_color_quotes_current.string, con_completion_color_value_current.string, v,
							con_completion_color_quotes_current.string);
				}
			}
			else
			{
				PaddedPrintMarkAndPad (add_mark);
				Com_Printf ("&c%s%s &c%s: &c%s\"&c%s%s&c%s\"&r\n",
						con_completion_color_name.string, s , con_completion_color_colon.string,
						con_completion_color_quotes_current.string, con_completion_color_value_current.string, v,
						con_completion_color_quotes_current.string);
			}
			break;

		case 5:	// none
			PaddedPrintMarkAndPad (add_mark);
			Com_Printf ("&c%s%s&r\n",
					con_completion_color_name.string, s);
			break;

		default: // old completion
			PaddedPrint(s);
			break;
	}
}

static char	compl_common[64];
static int	compl_clen;
static int	compl_len;

static void FindCommonSubString (char *s) 
{
	if (!compl_clen)
	{
		strlcpy (compl_common, s, sizeof(compl_common));
		compl_clen = strlen (compl_common);
	} 
	else
	{
		while (compl_clen > compl_len && strncasecmp(s, compl_common, compl_clen))
			compl_clen--;
	}
}

int Cmd_CompleteCountPossible (char *partial);
int Cmd_AliasCompleteCountPossible (char *partial);
int Cvar_CompleteCountPossible (char *partial);
void CompleteName(void);

extern cmd_function_t *cmd_functions;
extern cmd_alias_t *cmd_alias;
extern cvar_t *cvar_vars;

void CompleteCommandNew (void)
{
	char *cmd, token[MAXCMDLINE], *s, *escaped;
	wchar temp[MAXCMDLINE];
	int c, a, v, start, end, i, diff_len, size, my_string_length;

	char completebuff[MAXCMDLINE];
	cmd_alias_t *s_a;
	cmd_function_t *s_c;
	cvar_t *s_v;
	int s_count;

	static cmd_alias_t *sorted_aliases[4096];
	static cmd_function_t *sorted_cmds[4096];
	static cvar_t *sorted_cvars[4096];
	static jogi_avail_complete_t jogi_avail_complete[4096];

#define MAX_SORTED_ALIASES (sizeof(sorted_aliases) / sizeof(sorted_aliases[0]))
#define MAX_SORTED_CVARS (sizeof (sorted_cvars) / sizeof (sorted_cvars[0]))
#define MAX_SORTED_CMDS (sizeof (sorted_cmds) / sizeof (sorted_cmds[0]))

	extern int Cmd_AliasCompare (const void *,const void *);
	extern int Cmd_CommandCompare (const void *, const void *);
	extern int Cvar_CvarCompare (const void *, const void *);

	if (!
			(key_linepos < 2
			 || isspace (key_lines[edit_line][key_linepos - 1]))
			&&  !called_second)
	{

		count = 0;
		count_cmd = 0;
		count_cvar = 0;
		count_alias = 0;
		memset(jogi_avail_complete, 0, sizeof(jogi_avail_complete));

		called_second = 1;
		if (key_linepos < 2 || isspace (key_lines[edit_line][key_linepos - 1]))
			return;

		for (start = key_linepos - 1;
				start >= 1 && !isspace (key_lines[edit_line][start]);
				start--)
			;
		if (start == 0)
			start = 1;
		if (isspace (key_lines[edit_line][start]))
			start++;
		end = key_linepos - 1;

		size = min (end - start + 1, sizeof (token) - 1);
		memcpy (token, wcs2str(&key_lines[edit_line][start]), size);
		token[size] = 0;

		s = token;
		if (*s == '\\' || *s == '/' || *s == '$')
		{
			s++;
			start++;
		}
		if (start > end)
			return;

		compl_len = strlen (s);
		compl_clen = 0;

		c = Cmd_CompleteCountPossible (s);
		a = Cmd_AliasCompleteCountPossible (s);
		v = Cvar_CompleteCountPossible (s);

		if (c + a + v > 1)
		{
			Com_Printf ("\n");

			if (c)
			{
				legacycmd_t* lcmd;

				if (con_completion_format.integer) {
					Com_Printf("&c%sCommands (%d):&r\n", con_completion_color_title.string, c);
				}
				else {
					Com_Printf("\x02" "Commands (%d):\n", c);
				}

				escaped = escape_regex(s);
				snprintf(completebuff, sizeof(completebuff), "^((?i)%s)", escaped);
				Q_free(escaped);

				for (s_c = cmd_functions, s_count = 0; s_c && s_count < MAX_SORTED_CMDS; s_c = s_c->next) {
					if (Utils_RegExpMatch(completebuff, s_c->name)) {
						sorted_cmds[s_count++] = s_c;
					}
				}

				// Legacy commands
				for (lcmd = legacycmds; lcmd; lcmd = lcmd->next) {
					if (Utils_RegExpMatch(completebuff, lcmd->dummy_cmd.name)) {
						sorted_cmds[s_count++] = &lcmd->dummy_cmd;
					}
				}

				qsort(sorted_cmds, s_count, sizeof (cmd_function_t *), Cmd_CommandCompare);

				for (i = 0; i < s_count; i++) {
					PaddedPrint (sorted_cmds[i]->name);
					FindCommonSubString (sorted_cmds[i]->name);
					jogi_avail_complete[count].name = sorted_cmds[i]->name;
					jogi_avail_complete[count].type = "command";
					count++;
					count_cmd++;
				}

				if (con.x)
					Com_Printf ("\n");
			}

			if (v)
			{
				if (con_completion_format.integer)
					Com_Printf ("&c%sVariables (%d):&r\n", con_completion_color_title.string, v);
				else
					Com_Printf ("\x02" "Variables (%d):\n", v);

				escaped = escape_regex(s);
				snprintf(completebuff, sizeof(completebuff), "^((?i)%s)", escaped);
				Q_free(escaped);

				for (s_v = cvar_vars, s_count = 0; s_v && s_count < MAX_SORTED_CVARS; s_v = s_v->next) {
					if (Utils_RegExpMatch(completebuff, s_v->name)) {
						sorted_cvars[s_count++] = s_v;
					}
				}

				qsort(sorted_cvars, s_count, sizeof (cvar_t *), Cvar_CvarCompare);

				for (i = 0; i < s_count; i++) {
					PaddedPrintValue (sorted_cvars[i]->name, sorted_cvars[i]->string, sorted_cvars[i]->defaultvalue);
					FindCommonSubString (sorted_cvars[i]->name);
					jogi_avail_complete[count].name = sorted_cvars[i]->name;
					jogi_avail_complete[count].type = "variable";
					count++;
					count_cvar++;
				}

				if (con.x)
					Com_Printf ("\n");
			}

			if (a)
			{
				if (con_completion_format.integer)
					Com_Printf ("&c%sAliases (%d):&r\n", con_completion_color_title.string, a);
				else
					Com_Printf ("\x02" "Aliases (%d):\n", a);

				escaped = escape_regex(s);
				snprintf(completebuff, sizeof(completebuff), "^((?i)%s)", escaped);
				Q_free(escaped);

				for (s_a = cmd_alias, s_count = 0; s_a && s_count < MAX_SORTED_ALIASES; s_a = s_a->next) {
					if (Utils_RegExpMatch(completebuff, s_a->name)) {
						sorted_aliases[s_count++] = s_a;
					}
				}

				qsort(sorted_aliases, s_count, sizeof (cmd_alias_t *), Cmd_AliasCompare);				

				for (i = 0; i < s_count; i++) {
					PaddedPrintValue(sorted_aliases[i]->name, sorted_aliases[i]->value, sorted_aliases[i]->name);
					FindCommonSubString(sorted_aliases[i]->name);
					jogi_avail_complete[count].name = sorted_aliases[i]->name;
					jogi_avail_complete[count].type = "alias";
					count++;
					count_alias++;
				}

				if (con.x) {
					Com_Printf("\n");
				}
			}
		}

		if (c + a + v == 1)
		{
			cmd = Cmd_CompleteCommand (s);
			if (!cmd)
				cmd = Cvar_CompleteVariable (s);
			if (!cmd)
				return;	// this should never happen
		}
		else if (compl_clen)
		{
			compl_common[compl_clen] = 0;
			cmd = compl_common;
		}
		else
		{
			CompleteName ();
			return;
		}

		diff_len = strlen (cmd) - (end - start + 1);
		qwcslcpy (temp, key_lines[edit_line] + end + 1, sizeof(temp)/sizeof(temp[0]));
		qwcslcpy (key_lines[edit_line] + end + 1 + diff_len, temp, MAXCMDLINE - (end + 1 + diff_len));

		for (i = 0; start + i < MAXCMDLINE && i < strlen (cmd); i++)
		{
			key_lines[edit_line][start + i] = char2wc(cmd[i]);
		}

		key_linepos += diff_len;
		key_lines[edit_line][min
			(key_linepos + qwcslen(temp),
			 MAXCMDLINE - 1)] = 0;
		if (start == 1 && key_linepos + qwcslen(temp) < MAXCMDLINE - 1)
		{
			for (i = key_linepos + qwcslen(temp); i > 0; i--)
			{
				key_lines[edit_line][i + 1] = key_lines[edit_line][i];
			}
			key_lines[edit_line][1] = '/';
			key_linepos++;
		}
		if (c + a + v == 1 && !key_lines[edit_line][key_linepos] && key_linepos < MAXCMDLINE - 1)
		{
			key_lines[edit_line][key_linepos] = ' ';
			key_lines[edit_line][++key_linepos] = 0;
		}

		while (!(isspace (key_lines[edit_line][key_linepos])) && (key_lines[edit_line][key_linepos] != '\0'))
		{
			qwcscpy (key_lines[edit_line] + key_linepos,
					key_lines[edit_line] + key_linepos + 1);
		}

		key_lineposorig = key_linepos;
		try = 0;
		last_cmd_length = 0;
		old_keyline_length = qwcslen( key_lines[edit_line] );
	}
	else if ((key_linepos >= 2
				|| isspace (key_lines[edit_line][key_linepos - 1]))
			&&  called_second
			&& (key_linepos == key_lineposorig) && (old_keyline_length == (int) qwcslen(key_lines[edit_line])))
	{
		if (count != try)
		{
			int len;
			char text[50];
			int test;
			int testvar;
			try++;
			//Com_Printf("%i\n",try);
			test = try - 1;
			testvar = key_linepos;

			while ((testvar != 0)
					&& !(isspace (key_lines[edit_line][testvar]))
					&& (key_lines[edit_line][testvar] != '\\')
					&& (key_lines[edit_line][testvar] != '$')
					&& (key_lines[edit_line][testvar] != '/'))
			{
				testvar--;
			}

			testvar = key_linepos - testvar;

			my_string_length =	strlen (jogi_avail_complete[test].name);

			memset(text, 0, sizeof(text));

			for (i = 0; i < bound(0, my_string_length-testvar+1, sizeof(text)); i++)
			{
				text[i] = jogi_avail_complete[test].name[i + testvar -1 ];
			}

			len = strlen (text);

			memmove (key_lines[edit_line] + key_linepos + len,
					key_lines[edit_line] + key_linepos +
					last_cmd_length,
					(MAXCMDLINE - key_linepos + 1 -
					 last_cmd_length)*sizeof(wchar));
			memcpy (key_lines[edit_line] + key_linepos, str2wcs(text),
					len * sizeof(wchar));

			del_removes = 1;
			last_cmd_length = strlen (text);
		}
		else if (count == try)
		{
			try = 0;
		}
		old_keyline_length = qwcslen( key_lines[edit_line] );
	}
	else if ((key_linepos >= 2
				|| isspace (key_lines[edit_line][key_linepos - 1]))
			&& called_second
			&& (key_linepos != key_lineposorig))
	{
		try = 0;
		called_second = 0;
		del_removes = 0;
		CompleteCommandNew ();
	}
}

static void CompleteName_InsertNick(const char *name, wchar *s, wchar *p, wchar *q)
{
	int i, diff;
	wchar t[MAXCMDLINE];

	qwcslcpy(t, str2wcs(name), sizeof(t)/sizeof(t[0]));

	for (i = 0; t[i]; i++)
	{
		if ((127 & t[i]) == ' ')
		{
			int k;

			if ((k = qwcslen(t)) < MAXCMDLINE - 2)
			{
				memmove(t + 1, t, (k + 1)*sizeof(wchar));
				t[k + 2] = 0;
				t[k + 1] = t[0] = '\"';
			}
			break;
		}
	}
	diff = qwcslen(t) - qwcslen(s);

	memmove(q + diff, q, (qwcslen(q) + 1)*sizeof(wchar));
	memmove(p, t, qwcslen(t)*sizeof(wchar));
	key_linepos += diff;
	if (!key_lines[edit_line][key_linepos] && key_linepos < MAXCMDLINE - 1)
	{
		key_lines[edit_line][key_linepos] = ' ';
		key_lines[edit_line][++key_linepos] = 0;
	}
}


void CompleteName(void)
{
	extern const char disallowed_in_nick[]; // utils.c

	wchar s[MAXCMDLINE], *p, *q;
	char name[128] = {0};

	p = q = key_lines[edit_line] + key_linepos;
	while (--p >= key_lines[edit_line] + 1)
		if (!(  (*(signed short *)p >= 32) && !strchr(disallowed_in_nick, wc2char(*p)) ))
			break;
	p++;
	if (q - p <= 0)
		return;

	qwcslcpy (s, p, q - p + 1);

	if (FindBestNick(wcs2str(s), 0, name, sizeof(name)))
		CompleteName_InsertNick(name, s, p, q);
}

//===================================================================

static void AdjustConsoleHeight (int delta) {
	extern cvar_t scr_consize;
	int height;

	if (cls.state != ca_active && !cl.intermission)
		return;
	height = (scr_consize.value * vid.height + delta + 5) / 10;
	height *= 10;
	if (delta < 0 && height < 30)
		height = 30;
	if (delta > 0 && height > vid.height - 10)
		height = vid.height - 10;
	Cvar_SetValue (&scr_consize, (float)height / vid.height);
}

static qbool yellowchars = false;
qbool con_redchars    = false;


// 1) clear any typing
// 2) put what was typed in console to the history if any
void Key_ClearTyping (void)
{
	//if new input is the same as previous one or the line is empty
	// do not increment edit_line
	if((wcscmp ((wchar_t*)key_lines[edit_line], (wchar_t*)key_lines[(edit_line - 1) & (CMDLINES - 1)]))
			&& key_lines[edit_line][1])
		edit_line = (edit_line + 1) & (CMDLINES - 1);

	history_line = edit_line;
	key_lines[edit_line][0] = con_prompt_charcode.integer;
	key_lines[edit_line][1] = 0;
	key_linepos = 1;
}

void Key_Console_Backspace(void)
{
	if (key_linepos > 1)
	{
		qwcscpy(key_lines[edit_line] + key_linepos - 1, key_lines[edit_line] + key_linepos);
		key_linepos--;
	}
}

//
// Interactive line editing and console scrollback.
//
void Key_Console (int key, int unichar)
{
	int i, len;
	qbool print_in_console = true;

	switch (key)
	{
		case 'M': case 'm': case 'J': case 'j':		//^M,^J = Enter
			{
				if (!keydown[K_CTRL])
					break;
				// Fall through.
			}
		case K_ENTER:
			{
				CompleteCommandNew_Reset ();
				con_redchars = false;

				// Backslash text are commands.
				if (key_lines[edit_line][1] != '/' || key_lines[edit_line][2] != '/')
				{
					qbool no_lf = true;

					// If Ctrl+enter was pressed, regard the chat as a team message.
					if (((keydown[K_CTRL] && key == K_ENTER) || keydown[K_SHIFT]) && cls.state >= ca_connected)
					{
						// Do we have something to say?
						if (*(key_lines[edit_line] + 1)) 
						{
							Cbuf_AddText ((keydown[K_CTRL] && key == K_ENTER) ? "say_team \"" : "say \"");
							Cbuf_AddText (encode_say(key_lines[edit_line] + 1));
							Cbuf_AddText ("\"");
						}
						else
						{
							no_lf = false;									
						}
					}
					else
					{
						if (key_lines[edit_line][1] == '\\' || key_lines[edit_line][1] == '/')
						{
							Cbuf_AddText (encode_say(key_lines[edit_line] + 2));	// skip the ]/
						}
						else
						{
							// Check if it's a chat message or a command.
							if (cls.state == ca_disconnected || (cl_chatmode.value != 1 && CheckForCommand()))
							{
								Cbuf_AddText (encode_say(key_lines[edit_line] + 1));	// Valid command.
							}
							else
							{
								// It's a chat message.
								if (cls.state >= ca_connected)	// Can happen if cl_chatmode is 1
								{
									if (cl_chatmode.value == 2 || cl_chatmode.value == 1)
									{
										if (*(key_lines[edit_line] + 1)) // Do we have something to say?
										{
											Cbuf_AddText ("say \"");
											Cbuf_AddText (encode_say(key_lines[edit_line] + 1));
											Cbuf_AddText ("\"");

											if (con_hide_chat_input.integer)
												print_in_console = false;
										}
										else
										{
											no_lf = false;									
										}
									}
									else
									{
										Cbuf_AddText (encode_say(key_lines[edit_line] + 1));	// skip the ]
									}
								}
								else
								{
									no_lf = false;
								}
							}
						}
					}
					if (no_lf)
					{
						Cbuf_AddText ("\n");
					}
				}

				// cut'n'paste rocks!
				if (!print_in_console)
					Print_flags[Print_current] |= PR_SKIP;

				Con_PrintW (key_lines[edit_line]);	// FIXME logging

				// cut'n'paste rocks!
				if (!print_in_console)
					Print_flags[Print_current] |= PR_SKIP;

				Con_PrintW (str2wcs("\n"));

				Key_ClearTyping ();

				if (cls.state == ca_disconnected)
					SCR_UpdateScreen ();	// force an update, because the command
				// may take some time
				return;
			}
		case K_TAB:
			{
				// Command completion
				if (!(keydown[K_SHIFT]) && keydown[K_CTRL])
				{
					CompleteName ();
				}
				else
				{
					CompleteCommandNew ();
				}
				return;
			}
		case 'H': case 'h':		// ^H = BACKSPACE
			{
				if (!keydown[K_CTRL] || keydown[K_ALT])
				{
					break;
				}
			}
		case K_BACKSPACE:
			{
				// added by jogi start
				CompleteCommandNew_Reset();
				// added by jogi stop

				// removes word before cursor
				if(keydown[K_CTRL])
				{
					len = 0;

					while(key_linepos > 1 && key_lines[edit_line][key_linepos - 1] == ' ')
					{
						key_linepos--;
						len++;
					}

					while(key_linepos > 1 && key_lines[edit_line][key_linepos - 1] != ' ')
					{
						key_linepos--;
						len++;
					}

					// remove spaces after this word leaving only last one
					while(key_linepos < qwcslen(key_lines[edit_line]) && key_lines[edit_line][key_linepos - 1] == ' ' && key_lines[edit_line][key_linepos - 2] == ' ')
					{
						key_linepos--;
						len++;
					}

					qwcscpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + len);
				}
				else
				{
					Key_Console_Backspace();
				}

				// disable red chars mode if the last character was deleted
				if(key_linepos == 1 && qwcslen(key_lines[edit_line]) == 1)
					con_redchars = false;

				return;
			}
		case K_DEL:
			{
				// added by jogi start
				if((del_removes) && (key_linepos == key_lineposorig))
				{
					qwcscpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + last_cmd_length);

					del_removes = 0;
					called_second = 0;
					try = 0;
				}
				// added by jogi stopp

				// removes word after cursor
				if(keydown[K_CTRL])
				{
					i = key_linepos;
					len = 0;				

					while(key_linepos < qwcslen(key_lines[edit_line]) && key_lines[edit_line][i] == ' ')
					{
						i++;
						len++;
					}

					// don't remove regular chars if we removed spaces before
					if(len == 0)
					{
						while(key_linepos < qwcslen(key_lines[edit_line]) && key_lines[edit_line][i] != ' ' && key_lines[edit_line][i] != 0)
						{
							i++;
							len++;
						}

						// remove spaces after this word
						while(key_linepos < qwcslen(key_lines[edit_line]) && key_lines[edit_line][i] == ' ')
						{
							i++;
							len++;
						}
					}

					qwcscpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + len);
				}
				else
				{
					if(key_linepos < qwcslen(key_lines[edit_line]))
					{
						qwcscpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + 1);
					}
				}

				// disable red chars mode if the last character was deleted
				if (key_linepos == 1 && qwcslen(key_lines[edit_line]) == 1)
					con_redchars = false;

				return;
			}
		case K_RIGHTARROW:
			{
				if (keydown[K_CTRL])
				{
					// word right
					i = qwcslen(key_lines[edit_line]);
					while (key_linepos < i
							&& key_lines[edit_line][key_linepos] != ' ')
						key_linepos++;
					while (key_linepos < i
							&& key_lines[edit_line][key_linepos] == ' ')
						key_linepos++;
					return;
				}
				// added by jogi start
				CompleteCommandNew_Reset();
				// added by jogi stop
				if (key_linepos < qwcslen(key_lines[edit_line]))
					key_linepos++;
				return;
			}
		case K_LEFTARROW:
			{
				if (keydown[K_CTRL])
				{
					// word left
					while (key_linepos > 1
							&& key_lines[edit_line][key_linepos - 1] ==
							' ')
						key_linepos--;
					while (key_linepos > 1
							&& key_lines[edit_line][key_linepos - 1] !=
							' ')
						key_linepos--;
					return;
				}
				// addeded by jogi start
				CompleteCommandNew_Reset();
				// addeded by jogi start

				if (key_linepos > 1)
					key_linepos--;
				return;
			}
		case 'P': case 'p':		// ^P = back in history
			{
				if (!keydown[K_CTRL] || keydown[K_ALT])
				{
					break;
				}
			}
		case K_UPARROW:
			{
				if (key == K_UPARROW && keydown[K_CTRL])
				{
					AdjustConsoleHeight (-10);
					return;
				}

				do
				{
					history_line = (history_line - 1) & (CMDLINES - 1);
				} while (history_line != edit_line && !key_lines[history_line][1]);

				if (history_line == edit_line)
				{
					history_line = (edit_line + 1) & (CMDLINES - 1);
				}

				qwcscpy(key_lines[edit_line], key_lines[history_line]);
				key_linepos = qwcslen(key_lines[edit_line]);
				return;
			}
		case 'N': case 'n':		// ^N = forward in history
			{
				if (!keydown[K_CTRL] || keydown[K_ALT])
				{
					break;
				}
			}
		case K_DOWNARROW:
			{
				if (key == K_DOWNARROW && keydown[K_CTRL])
				{
					AdjustConsoleHeight (10);
					return;
				}

				if (history_line == edit_line)
				{
					return;
				}

				do
				{
					history_line = (history_line + 1) & (CMDLINES - 1);
				} while (history_line != edit_line && !key_lines[history_line][1]);

				if (history_line == edit_line)
				{
					key_lines[edit_line][0] = con_prompt_charcode.integer;
					key_lines[edit_line][1] = 0;
					key_linepos = 1;
				}
				else
				{
					qwcscpy(key_lines[edit_line], key_lines[history_line]);
					key_linepos = qwcslen(key_lines[edit_line]);
				}
				return;
			}
		case K_PGUP:
		case K_MWHEELUP:
			{
				if (keydown[K_CTRL] && key == K_PGUP)
				{
					con.display -= ((int)scr_conlines - 22) >> 3;
				}
				else
				{
					con.display -= 2;
				}

				if (con.display - con.current + con.numlines < 0)
				{
					con.display = con.current - con.numlines;
				}
				return;
			}
		case K_MWHEELDOWN:
		case K_PGDN:
			{
				if (keydown[K_CTRL] && key == K_PGDN)
				{
					con.display += ((int)scr_conlines - 22) >> 3;
				}
				else
				{
					con.display += 2;
				}

				if (con.display - con.current > 0)
				{
					con.display = con.current;
				}
				return;
			}
		case K_HOME:
			{
				if (keydown[K_CTRL])
				{
					con.display = con.current - con.numlines;
				}
				else
				{
					key_linepos = 1;
				}
				return;
			}
		case K_END:
			{
				if (keydown[K_CTRL])
				{
					con.display = con.current;
				}
				else
				{
					key_linepos = qwcslen(key_lines[edit_line]);
				}
				return;
			}
	}

	if (((key == 'V' || key == 'v') && 
#ifndef __APPLE__
				keydown[K_CTRL]
#else
				keydown[K_CMD]
#endif
				&& !keydown[K_ALT])
			|| ((key == K_INS || key == KP_INS) && keydown[K_SHIFT]))
	{
		wchar *clipText;

		if ((clipText = Sys_GetClipboardTextW()))
		{
			len = qwcslen(clipText);
			if (len + qwcslen(key_lines[edit_line]) > MAXCMDLINE - 1)
			{
				len = MAXCMDLINE - 1 - qwcslen(key_lines[edit_line]);
			}

			if (len > 0)
			{
				// Insert the string.
				memmove (key_lines[edit_line] + key_linepos + len,
						key_lines[edit_line] + key_linepos, (qwcslen(key_lines[edit_line]) - key_linepos + 1)*sizeof(wchar));
				memcpy (key_lines[edit_line] + key_linepos, clipText, len*sizeof(wchar));
				key_linepos += len;
			}
		}
		return;
	}

	if (key == 'u' && keydown[K_CTRL] && !keydown[K_ALT])
	{
		if (key_linepos > 1)
		{
			qwcscpy(key_lines[edit_line] + 1, key_lines[edit_line] + key_linepos);
			key_linepos = 1;
		}
		return;
	}

	if (!unichar)
		return;	// non printable

	if (con_funchars_mode.value)
	{
		// CTRL+y toggles yellowchars
		if (keydown[K_CTRL] && key == 'y' && !keydown[K_RALT] && !keydown[K_ALT]) {
			yellowchars = !yellowchars;
			con_redchars    = false;
			Com_Printf( "input of yellow numbers is now o%s!\n", yellowchars ? "n" : "ff" );
			return;
		}

		// CTRL+r toggles red chars
		if (keydown[K_CTRL] && key == 'r' && !keydown[K_RALT] && !keydown[K_ALT]) {
			con_redchars    = !con_redchars;
			if ( yellowchars )
			{
				Com_Printf( "input of yellow numbers is now off!\n" );
			}
			yellowchars = false;
			return;
		}
	}

	if ( yellowchars || (keydown[K_CTRL] && !(con_funchars_mode.value)))
	{
		if (unichar >= '0' && unichar <= '9')
		{
			unichar = unichar - '0' + 0x12;	// yellow number
		}
		else
		{
			switch (unichar)
			{
				case '[': unichar = 0x10; break;
				case ']': unichar = 0x11; break;
				case 'g': unichar = 0x86; break; // ctrl+g green led
				case 'r': unichar = 0x87; break; // ctrl+r red led
				case 'y': unichar = 0x88; break; // ctrl+y yellow led
				case 'b': unichar = 0x89; break; // ctrl+b blue led
				case 'w': unichar = 0x84; break; // ctrl+w white led
				case '(': unichar = 0x80; break;
				case '=': unichar = 0x81; break;
				case ')': unichar = 0x82; break;
				case 'a': unichar = 0x83; break;
				case '<': unichar = 0x1d; break;
				case '-': unichar = 0x1e; break;
				case '>': unichar = 0x1f; break;
				case ',': unichar = 0x1c; break;
				case '.': unichar = 0x9c; break;
				case 'B': unichar = 0x8b; break;
				case 'C': unichar = 0x8d; break;
			}
		}
	}

	if (con_redchars || (keydown[K_ALT] && !(con_funchars_mode.value)))
	{
		unichar |= 128;		// red char
	}

	i = qwcslen(key_lines[edit_line]);
	if (i >= MAXCMDLINE-1)
	{
		return;
	}

	// This also moves the ending \0
	memmove (key_lines[edit_line]+key_linepos+1, key_lines[edit_line]+key_linepos, (i-key_linepos+1)*sizeof(wchar));
	key_lines[edit_line][key_linepos] = unichar;
	key_linepos++;
	CompleteCommandNew_Reset ();
	lastKeyGeneratedCharacter = true;
}

//============================================================================

chat_type chat_team;

qbool chat_observers;	// added by jogi
qbool chat_server;		// added by jogi
wchar		chat_buffer[MAXCMDLINE];
int			chat_linepos = 0;

void Key_Message (int key, wchar unichar) {
	int len;

	switch (key)
	{
		case K_ENTER:
			if (chat_buffer[0])
			{
				qbool irccommand = false;
				switch (chat_team) {
					case chat_mm2: Cbuf_AddText("say_team \""); break;
					case chat_qtvtogame: 
						       if (cls.mvdplayback == QTV_PLAYBACK) {
							       Cbuf_AddText("say \"say_game ");  // QTV parses the text, no say_game command has been implemented
						       } else {
							       Cbuf_AddText("// "); // silence output to remove "unknown command" error message
							       Com_Printf("&cf00Error&r: &c090messagemodeqtvtogame&r requires you to be connected to a &c666QTV&r server\n");
						       }
						       break;
#ifdef WITH_IRC
					case chat_irc:
						       if (chat_buffer[0] == '/') {
							       irccommand = true;
							       Cbuf_AddText("irc ");	
						       }
						       else {
							       Cbuf_AddText("irc say \"");
						       }
						       break;
#endif

					default:
					case chat_mm1: Cbuf_AddText("say \""); break;
				}

				if (irccommand) {
					Cbuf_AddText(encode_say(chat_buffer+1));
				}
				else {
					Cbuf_AddText(encode_say(chat_buffer));
					Cbuf_AddText("\"\n");
				}
			}

			if (key_dest_beforemm != key_message && key_dest_beforemm != key_console)
				key_dest = key_dest_beforemm;
			else
				key_dest = key_game;

			chat_linepos = 0;
			chat_buffer[0] = 0;
			return;

		case K_ESCAPE:
			if (key_dest_beforemm != key_message && key_dest_beforemm != key_console)
				key_dest = key_dest_beforemm;
			else
				key_dest = key_game;

			chat_buffer[0] = 0;
			chat_linepos = 0;
			return;

		case K_HOME:
			chat_linepos = 0;
			return;

		case K_END:
			chat_linepos = qwcslen(chat_buffer);
			return;

		case K_LEFTARROW:
			if (chat_linepos > 0)
				chat_linepos--;
			return;

		case K_RIGHTARROW:
			if (chat_linepos < qwcslen(chat_buffer))
				chat_linepos++;
			return;

		case K_BACKSPACE:
			if (chat_linepos > 0)
			{
				qwcscpy(chat_buffer + chat_linepos - 1, chat_buffer + chat_linepos);
				chat_linepos--;
			}
			return;

		case K_DEL:
			if (chat_buffer[chat_linepos])
				qwcscpy(chat_buffer + chat_linepos, chat_buffer + chat_linepos + 1);
			return;

		case K_PGDN:
#ifdef WITH_IRC
			if (chat_team == chat_irc) {
				IRC_NextChan();
			}
#endif
			break;

		case K_PGUP:
#ifdef WITH_IRC
			if (chat_team == chat_irc) {
				IRC_PrevChan();
			}
#endif
			break;
	}

	if (((key == 'V' || key == 'v') && keydown[K_CTRL] && !keydown[K_ALT])
			|| ((key == K_INS || key == KP_INS) && keydown[K_SHIFT]))
	{
		wchar *clipText;

		if ((clipText = Sys_GetClipboardTextW()))
		{
			len = qwcslen(clipText);
			if (len + qwcslen(chat_buffer) > MAXCMDLINE - 1)
				len = MAXCMDLINE - 1 - qwcslen(chat_buffer);
			if (len > 0)
			{
				// insert the string
				memmove (chat_buffer + chat_linepos + len,
						chat_buffer + chat_linepos, (qwcslen(chat_buffer) - chat_linepos + 1)*sizeof(wchar));
				memcpy (chat_buffer + chat_linepos, clipText, len * sizeof(wchar));
				chat_linepos += len;
			}
		}
		return;
	}

	if (!unichar)
		return;	// non printable

	len = qwcslen(chat_buffer);

	if (len >= sizeof(chat_buffer)/sizeof(wchar) - 1)
		return; // all full

	// This also moves the ending \0
	memmove (chat_buffer+chat_linepos+1, chat_buffer+chat_linepos, (len - chat_linepos + 1)*sizeof(wchar));
	chat_buffer[chat_linepos++] = unichar;
	lastKeyGeneratedCharacter = true;
}

//============================================================================

//Returns a key number to be used to index keybindings[] by looking at the given string.
//Single ascii characters return themselves, while the K_* names are matched up.
#define UNKNOWN_S "UNKNOWN"

byte Key_CharacterToQuakeCode(char ch);

int Key_StringToKeynum (const char *str)
{
	keyname_t *kn;

	if (!str || !str[0])
		return -1;

	if (!str[1] && !con_bindphysical.value)
	{
		int value = Key_CharacterToQuakeCode(str[0]);

		if (value != 0)
			return value;
	}

	if (!str[1])
		return (int)(unsigned char)str[0];

	for (kn = keynames; kn->name; kn++) {
		if (!strcasecmp (str,kn->name))
			return kn->keynum;
	}

	return -1;
}

//FIXME: handle quote special (general escape sequence?)
char *Key_KeynumToString (int keynum) {
	keyname_t *kn;
	static char tinystr[2];

	if (keynum == -1)
		return "<KEY NOT FOUND>";
	if (keynum > 32 && keynum < 127) {	// printable ascii
		tinystr[0] = keynum;
		tinystr[1] = 0;
		return tinystr;
	}

	for (kn=keynames ; kn->name ; kn++)
		if (keynum == kn->keynum)
			return kn->name;

	return "<UNKNOWN KEYNUM>";
}

void Key_SetBinding (int keynum, const char *binding) {
	if (keynum == -1)
		return;

#ifndef __APPLE__
	if (keynum == K_CTRL || keynum == K_ALT || keynum == K_SHIFT || keynum == K_WIN) {
		Key_SetBinding(keynum + 1, binding);
		Key_SetBinding(keynum + 2, binding);
		return;
	}
#endif

	// free (and hence Q_free) is safe to call with a NULL argument
	Q_free (keybindings[keynum]);
	keybindings[keynum] = Q_strdup(binding);
}

void Key_Unbind (int keynum) {
	if (keynum == -1)
		return;

	if (keynum == K_CTRL || keynum == K_ALT || keynum == K_SHIFT || keynum == K_WIN) {
		Key_Unbind(keynum + 1);
		Key_Unbind(keynum + 2);
		return;
	}

	// free (and hence Q_free) is safe to call with a NULL argument
	Q_free (keybindings[keynum]);
	keybindings[keynum] = NULL;
}

void Key_Unbind_f (void) {
	int b;

	if (Cmd_Argc() != 2) {
		Com_Printf ("Usage:  %s <key> : remove commands from a key\n", Cmd_Argv(0));
		return;
	}

	b = Key_StringToKeynum (Cmd_Argv(1));
	if (b == -1) {
		Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
		return;
	}

	Key_Unbind (b);
}

void Key_Unbindall_f (void) {
	int i;

	for (i = 0; i < sizeof(keybindings) / sizeof(*keybindings); i++)
		if (keybindings[i])
			Key_Unbind (i);
}

static void Key_PrintBindInfo(int keynum, char *keyname) {
	if (!keyname)
		keyname = Key_KeynumToString(keynum);

	if (keynum == -1) {
		Com_Printf ("\"%s\" isn't a valid key\n", keyname);
		return;
	}

	if (keybindings[keynum])
		Com_Printf ("\"%s\" = \"%s\"\n", keyname, keybindings[keynum]);
	else
		Com_Printf ("\"%s\" is not bound\n", keyname);
}

//checks if LCTRL and RCTRL are both bound and bound to the same thing
qbool Key_IsLeftRightSameBind(int b) {
	if (b < 0 || b >= (sizeof(keybindings) / sizeof(*keybindings)) - 2)
		return false;

	return	(b == K_CTRL || b == K_ALT || b == K_SHIFT || b == K_WIN) &&
		(keybindings[b + 1] && keybindings[b + 2] && !strcmp(keybindings[b + 1], keybindings[b + 2]));
}

void Key_Bind_f (void) {
	int c, b;

	c = Cmd_Argc();

	if (c < 2) {
		Com_Printf ("Usage: %s <key> [command] : attach a command to a key\n", Cmd_Argv(0));
		return;
	}
	b = Key_StringToKeynum (Cmd_Argv(1));
	if (b == -1) {
		Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
		return;
	}
	if (c == 2) {
#ifndef __APPLE__
		if ((b == K_CTRL || b == K_ALT || b == K_SHIFT || b == K_WIN) && (keybindings[b + 1] || keybindings[b + 2])) {

			if (keybindings[b + 1] && keybindings[b + 2] && !strcmp(keybindings[b + 1], keybindings[b + 2])) {
				Com_Printf ("\"%s\" = \"%s\"\n", Cmd_Argv(1), keybindings[b + 1]);
			} else {
				Key_PrintBindInfo(b + 1, NULL);
				Key_PrintBindInfo(b + 2, NULL);
			}
		} else
#endif
		{

			//		and the following should print "ctrl (etc) is not bound" since K_CTRL cannot be bound
			Key_PrintBindInfo(b, Cmd_Argv(1));
		}
		return;
	}

	// copy the rest of the command line
	Key_SetBinding (b, Cmd_MakeArgs(2));
}

void Key_BindList_f (void) {
	int i;

	for (i = 0; i < (sizeof(keybindings) / sizeof(*keybindings)); i++) {
		if (Key_IsLeftRightSameBind(i)) {
			Com_Printf ("%s \"%s\"\n", Key_KeynumToString(i), keybindings[i + 1]);
			i += 2;
		} else {
			if (keybindings[i])
				Com_Printf ("%s \"%s\"\n", Key_KeynumToString(i), keybindings[i]);
		}
	}
}

void Key_BindEdit_f(void) {
	char *keybinding, final_string[MAXCMDLINE - 1];
	int keynum, argc = Cmd_Argc();

	if(argc < 2) {
		Com_Printf("%s <key> : modify a bind\n", Cmd_Argv(0));
		Com_Printf("bindlist : list all binds\n");
		return;
	}

	keynum = Key_StringToKeynum(Cmd_Argv(1));
	if(keynum == -1) {
		Com_Printf("\"%s\" isn't a valid key\n", Cmd_Argv(1));
		return;
	}

	keybinding = keybindings[keynum] ? keybindings[keynum] : "";
	strlcpy(final_string, "/bind \"", sizeof(final_string));
	strlcat(final_string, Cmd_Argv(1), sizeof(final_string));
	strlcat(final_string, "\" \"", sizeof(final_string));
	strlcat(final_string, keybinding, sizeof(final_string));
	strlcat(final_string, "\"", sizeof(final_string));
	Key_ClearTyping();
	key_linepos = 8 + (int)strlen(Cmd_Argv(1)) + 3; // move to where the commands are in the bind
	memcpy(key_lines[edit_line] + 1, str2wcs(final_string), (strlen(final_string) + 1) * sizeof(wchar));
}

void History_Init (void)
{
	int i, c;
	FILE *hf;

	Cvar_SetCurrentGroup(CVAR_GROUP_CONSOLE);
	Cvar_Register (&cl_savehistory);
	Cvar_ResetCurrentGroup();

	for (i = 0; i < CMDLINES; i++) 
	{
		key_lines[i][0] = con_prompt_charcode.integer;
		key_lines[i][1] = 0;
	}
	key_linepos = 1;

	if (cl_savehistory.value)
	{
		char filename[MAX_OSPATH] = {0};

		snprintf(&filename[0], sizeof(filename), "%s/" HISTORY_FILE_NAME, com_basedir);
		if ((hf = fopen(filename, "rt")))
		{
			do
			{
				i = 1;
				do
				{
					c = fgetc(hf);
					key_lines[edit_line][i++] = c;
				} while (c != '\n' && c != EOF && i < MAXCMDLINE);
				key_lines[edit_line][i - 1] = 0;
				edit_line = (edit_line + 1) & (CMDLINES - 1);
			} while (c != EOF && edit_line < CMDLINES);
			fclose(hf);

			history_line = edit_line = (edit_line - 1) & (CMDLINES - 1);
			key_lines[edit_line][0] = con_prompt_charcode.integer;
			key_lines[edit_line][1] = 0;
		}
	}
}

void History_Shutdown (void)
{
	int i;
	FILE *hf;

	if (cl_savehistory.value)
	{
		char filename[MAX_OSPATH] = {0};

		snprintf(&filename[0], sizeof(filename), "%s/" HISTORY_FILE_NAME, com_basedir);
		if ((hf = fopen(filename, "wt")))
		{
			i = edit_line;
			do
			{
				i = (i + 1) & (CMDLINES - 1);
			} while (i != edit_line && !key_lines[i][1]);

			do
			{
				fprintf(hf, "%s\n", /*wcs2str*/encode_say(key_lines[i] + 1));
				i = (i + 1) & (CMDLINES - 1);
			} while (i != edit_line && key_lines[i][1]);
			fclose(hf);
		}
	}
}
// } Added by VVD

void Key_Init (void) {
	int i;

	// init ascii characters in console mode
	for (i = 32; i < 128; i++)
		consolekeys[i] = true;
	consolekeys[K_ENTER] = true;
	consolekeys[K_TAB] = true;
	consolekeys[K_LEFTARROW] = true;
	consolekeys[K_RIGHTARROW] = true;
	consolekeys[K_UPARROW] = true;
	consolekeys[K_DOWNARROW] = true;
	consolekeys[K_BACKSPACE] = true;
	consolekeys[K_INS] = true;
	consolekeys[K_DEL] = true;
	consolekeys[K_HOME] = true;
	consolekeys[K_END] = true;
	consolekeys[K_PGUP] = true;
	consolekeys[K_PGDN] = true;
	consolekeys[K_ALT] = true;
	consolekeys[K_LALT] = true;
	consolekeys[K_RALT] = true;
	consolekeys[K_CTRL] = true;
	consolekeys[K_LCTRL] = true;
	consolekeys[K_RCTRL] = true;
	consolekeys[K_SHIFT] = true;
	consolekeys[K_LSHIFT] = true;
	consolekeys[K_RSHIFT] = true;
#ifdef __APPLE__
	consolekeys[K_CMD] = true;
#endif
	consolekeys[K_MWHEELUP] = true;
	consolekeys[K_MWHEELDOWN] = true;
	consolekeys[K_WIN] = true;
	consolekeys[K_LWIN] = true;
	consolekeys[K_RWIN] = true;
	consolekeys[K_MENU] = true;
	consolekeys['`'] = false;
	consolekeys['~'] = false;

	for (i = 0; i < sizeof(keyshift) / sizeof(*keyshift); i++)
		keyshift[i] = i;
	for (i = 'a'; i <= 'z'; i++)
		keyshift[i] = i - 'a' + 'A';
	keyshift['1'] = '!';
	keyshift['2'] = '@';
	keyshift['3'] = '#';
	keyshift['4'] = '$';
	keyshift['5'] = '%';
	keyshift['6'] = '^';
	keyshift['7'] = '&';
	keyshift['8'] = '*';
	keyshift['9'] = '(';
	keyshift['0'] = ')';
	keyshift['-'] = '_';
	keyshift['='] = '+';
	keyshift[','] = '<';
	keyshift['.'] = '>';
	keyshift['/'] = '?';
	keyshift[';'] = ':';
	keyshift['\''] = '"';
	keyshift['['] = '{';
	keyshift[']'] = '}';
	keyshift['`'] = '~';
	keyshift['\\'] = '|';

	memset(hudeditorkeys, true, 512 * sizeof(qbool));
	hudeditorkeys[K_ALT] = true;
	hudeditorkeys[K_LALT] = true;
	hudeditorkeys[K_SHIFT] = true;
	hudeditorkeys[K_LSHIFT] = true;
	hudeditorkeys[K_CTRL] = true;
	hudeditorkeys[K_LCTRL] = true;
	hudeditorkeys['h'] = true;
	hudeditorkeys['p'] = true;
	hudeditorkeys[K_SPACE] = true;
	hudeditorkeys[K_F1] = true;
	hudeditorkeys[K_F2] = true;
	hudeditorkeys[K_F3] = true;
	hudeditorkeys[K_F4] = true;
	hudeditorkeys[K_MOUSE1] = true;
	hudeditorkeys[K_MOUSE2] = true;
	hudeditorkeys[K_MOUSE3] = true;

	memset(&scr_pointer_state, 0, sizeof(mouse_state_t));

	// register our functions
	Cmd_AddCommand("bindlist",Key_BindList_f);
	Cmd_AddCommand("bind",Key_Bind_f);
	Cmd_AddCommand("bindedit", Key_BindEdit_f);
	Cmd_AddCommand("unbind",Key_Unbind_f);
	Cmd_AddCommand("unbindall",Key_Unbindall_f);
	Cvar_SetCurrentGroup(CVAR_GROUP_CONSOLE);
	Cvar_Register(&cl_chatmode);
	Cvar_Register(&con_funchars_mode);
	Cvar_Register(&con_tilde_mode);
	Cvar_Register(&con_completion_format);
	Cvar_Register(&con_completion_color_value_current);
	Cvar_Register(&con_completion_color_value_default);
	Cvar_Register(&con_completion_color_name);
	Cvar_Register(&con_completion_color_quotes_current);
	Cvar_Register(&con_completion_color_quotes_default);
	Cvar_Register(&con_completion_color_colon);
	Cvar_Register(&con_completion_color_changed_mark);
	Cvar_Register(&con_prompt_charcode);
	Cvar_Register(&con_hide_chat_input);
	Cvar_Register(&con_completion_padding);
	Cvar_Register(&con_completion_color_title);
	Cvar_Register(&con_completion_changed_mark);
	Cvar_Register(&con_bindphysical);
	Cvar_Register(&in_builtinkeymap);

	Cvar_ResetCurrentGroup();
}

// sends new mouse state message to active module and it's windows
// returns:
//   true: message was received and handled
//   false: message wasn't handled by any window
static qbool Mouse_EventDispatch(void)
{
	qbool mouse_handled = false;

	// Send mouse cursor status to appropriate windows
	switch (key_dest) 
	{
		case key_menu: 
			mouse_handled = Menu_Mouse_Event(&scr_pointer_state);
			break;
		case key_hudeditor: 
			mouse_handled = HUD_Editor_MouseEvent(&scr_pointer_state);
			break;
		case key_demo_controls:
			mouse_handled = DemoControls_MouseEvent(&scr_pointer_state);
			break;
		default:
			break;
			// unhandled
		case key_game:
		case key_console:
		case key_message:
			break;
	}

	return mouse_handled;
}

// called by Key_Event, updates button states
qbool Mouse_ButtonEvent(int key, qbool down)
{
	if (key >= K_MOUSE1 && key <= K_MOUSE8)
	{	// in this case we convert the button number to the range 1..8
		key = key - K_MOUSE1 + 1;   // get the button number, starting from 1
		key = bound(1, key, 8);
		scr_pointer_state.buttons[key] = down;
	}
	else if (key != K_MWHEELDOWN && key != K_MWHEELUP)
	{
		// not a mouse button received
		return false;
	}

	scr_pointer_state.button_down = down ? key : 0;
	scr_pointer_state.button_up   = down ? 0 : key;

	// report if the button event has been handled or not
	return Mouse_EventDispatch();
}

// called by cl_screen.c each time it figures out that the mouse has moved
void Mouse_MoveEvent(void)
{
	// no button has been pressed
	scr_pointer_state.button_down = 0;
	scr_pointer_state.button_up = 0;

	// the rest of scr_pointer_state has already been updated by cl_screen module

	Mouse_EventDispatch();  // so just dispatch the message with new state
}

qbool Key_IsConsoleToggle (int key)
{
	return (key == '`' || key == '~');
}

// Will tell if the key should be currently translated into a command bound to it
// or send it to some client module.
static qbool Key_ConsoleKey(int key)
{
	// This makes it possible to type chars under tilde key into the console.
	qbool con_toggle = Key_IsConsoleToggle(key);
	qbool con_key = (con_tilde_mode.integer && con_toggle && (con_tilde_mode.integer == 1 || !CONSOLE_LINE_EMPTY())) ? true : consolekeys[key];
	qbool hud_key = (con_tilde_mode.integer && con_toggle) ? true : hudeditorkeys[key];
	qbool demo_controls_key = (con_tilde_mode.integer && con_toggle) ? true : democontrolskey[key];
	qbool con_keypad_key = cl_keypad.integer && key >= KP_HOME && key <= KP_ENTER;

	if (key_dest == key_menu && Menu_ExecuteKey(key))
		return false;

	if ((key_dest == key_console || key_dest == key_message) && !con_key && !con_keypad_key)
		return false;

	if (key_dest == key_game && (cls.state == ca_active || !con_key))
		return false;

	if (key_dest == key_hudeditor && !hud_key)
		return false;

	if (key_dest == key_demo_controls && !demo_controls_key)
		return false;

	return true;
}

// Called by the system between frames for both key up and key down events Should NOT be called during an interrupt!
void Key_EventEx (int key, wchar unichar, qbool down)
{
	char *kb, cmd[1024];

	// FIXME: disconnect: really FIXME CTRL+r or CTRL+[ with in_builinkeymap 1 cause to unichar < 32 
	if (/*unichar < 32 ||*/ (unichar > 127 && unichar <= 256))
		unichar = 0;

	if (key == K_LALT || key == K_RALT)
		Key_Event (K_ALT, down);
	else if (key == K_LCTRL || key == K_RCTRL)
		Key_Event (K_CTRL, down);
	else if (key == K_LSHIFT || key == K_RSHIFT)
		Key_Event (K_SHIFT, down);
	else if (key == K_LWIN || key == K_RWIN)
		Key_Event (K_WIN, down);

	keydown[key] = down;

	if (!down)
		key_repeats[key] = 0;

	key_lastpress = key;

	// update auto-repeat status
	if (down) 
	{
		key_repeats[key]++;

		if (key_repeats[key] > 1) 
		{
			if ((key != K_BACKSPACE && key != K_DEL
						&& key != K_LEFTARROW && key != K_RIGHTARROW
						&& key != K_UPARROW && key != K_DOWNARROW
						&& key != K_PGUP && key != K_PGDN && (key < 32 || key > 126 || key == '`'))
					|| (key_dest == key_game && cls.state == ca_active))
			{
				return;	// ignore most autorepeats
			}
		}
	}

	// Handle escape specialy, so the user can never unbind it.
	if (key == K_ESCAPE)
	{
		if (!down)
		{
			return;
		}

		if (KeyDestStartupDemo(key_dest)) {
			Cbuf_AddText("togglemenu\n");
			return;
		}

		switch (key_dest) 
		{
			case key_message:
				Key_Message (key, unichar);
				break;
			case key_menu:
				M_Keydown (key, unichar);
				break;
			case key_game:
				M_ToggleMenu_f ();
				break;
			case key_console:
				if (!SCR_NEED_CONSOLE_BACKGROUND) {
					Con_ToggleConsole_f();
				}
				else {
					M_ToggleMenu_f();
				}
				break;
			case key_hudeditor:
				HUD_Editor_Key(key, unichar, down);
				break;
			case key_demo_controls:
				DemoControls_KeyEvent(key, unichar, down);
				break;

			default:
				assert(!"Bad key_dest");
		}

		return;
	}

	// Special case for accessing the menu via mouse when in console in disconnected mode:
	if (key == K_MOUSE2 && key_dest == key_game && cls.state == ca_disconnected)
	{
		M_ToggleMenu_f();
	}

	if (!down)
	{
		// Key up event.
		if (key_dest == key_hudeditor) 
		{
			HUD_Editor_Key(key, unichar, down);
		}
		else if (key_dest == key_demo_controls)
		{
			DemoControls_KeyEvent(key, unichar, down);
		}

		// Key up events only generate commands if the game key binding is a button command (leading + sign).
		// These will occur even in console mode, to keep the character from continuing an action started before a
		// console switch.  Button commands include the kenum as a parameter, so multiple downs can be matched with ups
		{
			kb = keybindings[key];
			if (kb)
			{
				if (Key_TryMovementProtected(kb, down, key)) {
					// this was a protected movement binding and was executed
					return;
				}

				if (kb[0] == '+' && keyactive[key]) 
				{
					snprintf (cmd, sizeof (cmd), "-%s %i\n", kb+1, key);
					Cbuf_AddText (cmd);
					keyactive[key] = false;
				}
			}
			if (keyshift[key] != key) 
			{
				kb = keybindings[keyshift[key]];
				if (kb && kb[0] == '+' && keyactive[keyshift[key]]) 
				{
					snprintf (cmd, sizeof (cmd), "-%s %i\n", kb+1, key);
					Cbuf_AddText (cmd);
					keyactive[keyshift[key]] = false;
				}
			}
		}

		return;
	}

	// switch windowed<->fullscreen if pressed alt+enter, I succeed only with left alt, dunno why...
	if (key == K_ENTER && !sys_disable_alt_enter.integer && keydown[K_ALT] && (key_dest == key_console || key_dest == key_game))
	{
		Key_ClearStates(); // Zzzz
		con_suppress = true;
		Cvar_SetValue( &r_fullscreen, !r_fullscreen.integer );
		Cbuf_AddText( "vid_restart\n" );
		Cbuf_Execute();
		con_suppress = false;
		return;
	}

	// if not a consolekey, send to the interpreter no matter what mode is
	if (!Key_ConsoleKey(key)) 
	{
		kb = keybindings[key];

		if (kb) 
		{
			if (Key_TryMovementProtected(kb, down, key)) {
				// this was a protected movement binding and was executed
				return;
			}

			if (kb[0] == '+')
			{	
				// Button commands add keynum as a parm.
				snprintf (cmd, sizeof (cmd), "%s %i\n", kb, key);
				Cbuf_AddText (cmd);
				keyactive[key] = true;
			} 
			else 
			{
				Cbuf_AddText (kb);
				Cbuf_AddText ("\n");
			}
		}

		return;
	}

	if (!down) {
		return;	 // Other systems only care about key down events.
	}

#ifdef _WIN32
	{
		extern cvar_t con_toggle_deadkey;

		if (Key_IsConsoleToggle (key) && con_toggle_deadkey.integer) {
			Sys_CancelDeadKey ();
		}
	}
#endif

	if (keydown[K_SHIFT])
		key = keyshift[key];

	// Key down event.
	switch (key_dest) 
	{
		case key_message:
			Key_Message (key, unichar);
			break;

		case key_menu:
			M_Keydown (key, unichar);
			break;

		case key_game:
		case key_console:
			Key_Console (key, unichar);
			break;

		case key_hudeditor:
			HUD_Editor_Key(key, unichar, down);
			break;

		case key_demo_controls:
			DemoControls_KeyEvent(key, unichar, down);
			break;

		case key_startupdemo_browser:
			Cbuf_AddText("menu_slist\n");
			break;
		case key_startupdemo_console:
		case key_startupdemo_game:
			key_dest = key_console;
			break;
		case key_startupdemo_menu:
			Cbuf_AddText("togglemenu\n");
			break;

		default:
			assert(!"Bad key_dest");
	}
}

void Key_Event (int key, qbool down)
{
	qbool processTextInput = (key_dest == key_console || key_dest == key_message);
	qbool consoleToggle = (key == '`' || key == '~') && !con_tilde_mode.integer;
	wchar unichar = 0;

	assert (key >= 0 && key <= 255);

	if (key >= K_MOUSE1 && key <= K_MOUSE8)
	{
		// if the Mouse_ButtonEvent return true means that the window which received
		// a mouse click handled it and we do not have to send old
		// K_MOUSE* key event
		if (Mouse_ButtonEvent(key, down)) 
			return;
	}

	if (key == K_MWHEELDOWN || key == K_MWHEELUP) {
		// same logic applies here as for handling K_MOUSE1..8 buttons
		if (Mouse_ButtonEvent(key, down)) 
			return;
	}

	// Caps lock shouldn't trigger bind in chat/console
	if (key == K_CAPSLOCK && processTextInput) {
		return;
	}

	lastKeyGeneratedCharacter = false;
	unichar = keydown[K_SHIFT] ? keyshift[key] : key;
	if (unichar < 32 || unichar > 127)
		unichar = 0;

	Key_EventEx (key, unichar, down);

	// Store this as we may need it for subsequent SDL_TextInput event
	lastKeyDown = 0;
	if (down && processTextInput && !consoleToggle)
		lastKeyDown = key;
}

void Key_Event_TextInput(wchar unichar)
{
	if (in_builtinkeymap.value)
		return;
	if (!lastKeyDown)
		return;

	if (key_dest == key_message)
	{
		if (lastKeyGeneratedCharacter)
			Key_Message(K_BACKSPACE, K_BACKSPACE);
		Key_Message(lastKeyDown, unichar);
	}
	else if (key_dest == key_console)
	{
		if (lastKeyGeneratedCharacter)
			Key_Console_Backspace();
		Key_Console(lastKeyDown, unichar);
	}
}

void Key_ClearStates (void) 
{
	int		i;

	for (i = 0; i < sizeof(keydown) / sizeof(*keydown); i++) 
	{
		if (keydown[i])
			Key_Event(i, false);

		keydown[i] = false;
		key_repeats[i] = false;
	}
}

void OnChange_con_prompt_charcode (cvar_t *var, char *string, qbool *cancel)
{	
	int i, charcode = Q_atoi(string);
	*cancel = true;

	if ((charcode > 31) && (charcode <= 255) && (charcode != con_prompt_charcode.integer))
	{
		// changes prompt in current line
		key_lines[edit_line][0] = charcode;

		// changes prompt in all lines
		for (i = 0; i < CMDLINES; i++)
		{
			if (qwcslen(key_lines[i]) > 1)
				key_lines[i][0] = charcode;
		}

		*cancel = false;
	}
}

void OnChange_con_completion_color (cvar_t *var, char *string, qbool *cancel)
{
	if (!Utils_RegExpMatch("^[0-9a-fA-F]{3}$", string))
		*cancel = true;
}

char* escape_regex(char* string)
{
	// TODO: Rename and move this to a more appropriate place so other functions may use it (utils.c ?)
	int i, j, len;
	char *out = "";

	len = strlen(string);
	out = (char*) Q_malloc((len * 2 + 1) * sizeof(char));

	for(i = 0, j = 0; i < len; i++)
	{
		switch(string[i])
		{
			case '+':
			case '.':
			case '[':
			case ']':
				out[j++] = '\\';
				out[j++] = string[i];
				break;
			default:
				out[j++] = string[i];
				break;
		}
	}

	out[j++] = '\0';

	return out;
}

void Key_Shutdown(void)
{
	int i;

	for (i = 0; i < sizeof(keybindings) / sizeof(keybindings[0]); ++i) {
		Q_free(keybindings[i]);
	}
}


================================================
FILE: src/keys.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: keys.h,v 1.16 2007-05-28 10:47:34 johnnycz Exp $

*/

// these are the key numbers that should be passed to Key_Event

#ifndef _KEYS_H_
#define _KEYS_H_
 
typedef enum {
	K_TAB = 9,
	K_ENTER = 13,
	K_ESCAPE = 27,
	K_SPACE	= 32,

// normal keys should be passed as lowercased ascii

	K_BACKSPACE = 127,

	K_CAPSLOCK,
	K_PRINTSCR,
	K_SCRLCK,		//130
	K_PAUSE,

	K_UPARROW,
	K_DOWNARROW,
	K_LEFTARROW,
	K_RIGHTARROW,

	
	K_ALT,
	K_LALT,
	K_RALT,
	K_CTRL,			//140
	K_LCTRL,
	K_RCTRL,
	K_SHIFT,
	K_LSHIFT,
	K_RSHIFT,
#ifdef __APPLE__
	K_CMD,
	K_PARA,
#endif
	K_F1,
	K_F2,
	K_F3,
	K_F4,
	K_F5,			//150
	K_F6,
	K_F7,
	K_F8,
	K_F9,
	K_F10,
	K_F11,
	K_F12,
#ifdef __APPLE__
	K_F13,
	K_F14,
	K_F15,
#endif
	K_INS,
	K_DEL,
	K_PGDN,			//160
	K_PGUP,
	K_HOME,
	K_END,

	K_WIN,
	K_LWIN,
	K_RWIN,
	K_MENU,
	K_ISO,

//
// Keypad stuff..
//

	KP_NUMLOCK,
	KP_SLASH,
	KP_STAR,		//170

	KP_HOME,
	KP_UPARROW,
	KP_PGUP,
	KP_MINUS,

	KP_LEFTARROW,
	KP_5,
	KP_RIGHTARROW,
	KP_PLUS,

	KP_END,
	KP_DOWNARROW,	//180
	KP_PGDN,

	KP_INS,
	KP_DEL,
	KP_ENTER,

#ifdef __APPLE__
	// macintosh keypad
	KP_EQUAL,

	KP_7=KP_HOME,
	KP_8=KP_UPARROW,
	KP_9=KP_PGUP,

	KP_4=KP_LEFTARROW,
	KP_6=KP_RIGHTARROW,

	KP_1=KP_END,
	KP_2=KP_DOWNARROW,
	KP_3=KP_PGDN,

	KP_0=KP_INS,
	KP_DOT=KP_DEL,
#endif

	K_SECTION,
	K_ACUTE,
	K_DIAERESIS,
	K_ARING,
	K_ADIAERESIS,
	K_ODIAERESIS,
	K_WAKE_UP,		//191

//
// mouse buttons generate virtual keys
//
	K_MOUSE1 = 200,
	K_MOUSE2,
	K_MOUSE3,
	K_MOUSE4,
	K_MOUSE5,
	K_MOUSE6,
	K_MOUSE7,
	K_MOUSE8,

//
// joystick generic buttons
//
	K_JOY1,
	K_JOY2,
	K_JOY3,			//210
	K_JOY4,

//
// joystick POV/hat buttons
//
	K_JOYPOVUP,
	K_JOYPOVRT,
	K_JOYPOVDN,
	K_JOYPOVLT,

//
// aux keys are for multi-buttoned joysticks to generate so they can use
// the normal binding process
//
	K_AUX1,
	K_AUX2,
	K_AUX3,
	K_AUX4,
	K_AUX5,			//220
	K_AUX6,
	K_AUX7,
	K_AUX8,
	K_AUX9,
	K_AUX10,
	K_AUX11,
	K_AUX12,
	K_AUX13,
	K_AUX14,
	K_AUX15,		//230
	K_AUX16,
	K_AUX17,
	K_AUX18,
	K_AUX19,
	K_AUX20,
	K_AUX21,
	K_AUX22,
	K_AUX23,
	K_AUX24,
	K_AUX25,		//240
	K_AUX26,
	K_AUX27,
	K_AUX28,

// JACK: Intellimouse(c) Mouse Wheel Support

	K_MWHEELUP = 244,
	K_MWHEELDOWN,	//245

	UNKNOWN = 256

} keynum_t;


typedef enum {
	key_game,
	key_console,
	key_message,
	key_menu,
	key_hudeditor,
	key_demo_controls,
	key_startupdemo_menu,
	key_startupdemo_console,
	key_startupdemo_game,
	key_startupdemo_browser
} keydest_t;

#define KeyDestStartupDemo(x) ((x) >= key_startupdemo_menu && (x) <= key_startupdemo_browser)

extern keydest_t	key_dest, key_dest_beforemm, key_dest_beforecon;
extern char 	*keybindings[UNKNOWN + 256];
extern int		key_repeats[UNKNOWN + 256];
extern qbool	keydown[UNKNOWN + 256];
extern int		key_lastpress;

#ifdef WITH_IRC
	typedef enum { chat_mm1, chat_mm2, chat_irc, chat_qtvtogame }	chat_type;
#else
	typedef enum { chat_mm1, chat_mm2, chat_qtvtogame }	chat_type;
#endif

extern wchar 	chat_buffer[];
extern int 		chat_linepos;
extern chat_type chat_team;


// this is message type sent across windows that accept mouse pointer
typedef struct mouse_state_s {
	double x;           // current mouse pointer horisontal position
	double y;           // current mouse pointer vertical position
	double x_old;	    // previous mouse pointer positions
	double y_old;
    qbool buttons[9];   // button states .. omit button 0
    int button_down;    // number of the button that just has been pressed down
    int button_up;      // number of the button that just has been released
} mouse_state_t;

// exported only to be changed in the cl_screen.c module where mouse position gets updated
// do not access this variable anywhere else, prefer "window-messages" system
extern mouse_state_t scr_pointer_state;

// used in cl_screen module which is responsible for updating the mouse pointer position
void Mouse_MoveEvent(void);

void History_Init (void);
void History_Shutdown (void);

// this will clear any typping in console
void Key_ClearTyping (void);

void Key_Event (int key, qbool down);
void Key_EventEx (int key, wchar unichar, qbool down);
void Key_Init (void);
void Key_Shutdown(void);
void Key_SetBinding (int keynum, const char *binding);
void Key_Unbind (int keynum);
void Key_ClearStates (void);
int	 Key_StringToKeynum (const char *str);
char *Key_KeynumToString (int keynum);
void Key_Unbindall_f (void);

// should not be public actually but...
// {
#define		CMDLINES	(1<<8)
#define		MAXCMDLINE	256

extern wchar	key_lines[CMDLINES][MAXCMDLINE];
extern int		key_linepos;
extern int		edit_line;
extern qbool	con_redchars;

extern cvar_t	con_bindphysical;

#define CONSOLE_LINE_EMPTY() (!key_lines[edit_line][1])

// }

#if defined(_WIN32) && !defined(WITHOUT_WINKEYHOOK)
#define WINDOWS_LWINDOWSKEY (1 << 0)
#define WINDOWS_RWINDOWSKEY (1 << 1)
#define WINDOWS_MENU        (1 << 2)
#define WINDOWS_PRINTSCREEN (1 << 3)
#define WINDOWS_CAPSLOCK    (1 << 4)

extern unsigned int windows_keys_down, windows_keys_up;
#endif

qbool Key_IsConsoleToggle(int key);

#endif // _KEYS_H_ 


================================================
FILE: src/linux_signals.c
================================================
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================

    $Id: linux_signals.c,v 1.4 2007-06-15 12:26:07 johnnycz Exp $

*/
#include <signal.h>

#include "quakedef.h"
#include "input.h"

static qbool signalcaught = false;

static void signal_handler(int sig) // bk010104 - replace this... (NOTE TTimo huh?)
{
	if (signalcaught)
	{
		printf("DOUBLE SIGNAL FAULT: Received signal %d, exiting...\n", sig);
		Sys_Quit();
		exit(0);
	}

	signalcaught = true;
	printf("Received signal %d, exiting...\n", sig);

//
// client related things
//
	VID_Shutdown(false);  // bk010104 - shouldn't this be CL_Shutdown

	Sys_Quit();
	exit(0);
}

void InitSig(void)
{
	signal(SIGHUP,  signal_handler);
	signal(SIGINT,  signal_handler); // btw, q3 do not have this signal handling
	signal(SIGQUIT, signal_handler);
	signal(SIGILL,  signal_handler);
	signal(SIGTRAP, signal_handler);
	signal(SIGIOT,  signal_handler);
	signal(SIGBUS,  signal_handler);
	signal(SIGFPE,  signal_handler);
	signal(SIGSEGV, signal_handler);
	signal(SIGTERM, signal_handler);
}


================================================
FILE: src/localtime.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __LOCALTIME_H__
#define __LOCALTIME_H__

#ifdef _WIN32

#include <windows.h> // FIXME: we should include it only at winquake.h
#include <time.h>

#else

#include <time.h>

typedef struct SYSTEMTIME_s
{
    int wYear;
    int wMonth;
    int wDay;
    int wDayOfWeek;
    int wHour;
    int wMinute;
    int wSecond;
    int wMilliseconds;
} SYSTEMTIME;

void GetLocalTime(SYSTEMTIME *);

#endif


int  GetFileLocalTime(char *, SYSTEMTIME *);
void UnixtimeToWintime(SYSTEMTIME *, struct tm *);
int  SYSTEMTIMEcmp(const SYSTEMTIME *, const SYSTEMTIME *);

#endif // __LOCALTIME_H__










================================================
FILE: src/localtime_posix.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <time.h>
#include <sys/stat.h>
#include "localtime.h"

// helper
void UnixtimeToWintime(SYSTEMTIME *wintime, struct tm* time)
{
    wintime->wYear      = time->tm_year + 1900;
    wintime->wMonth     = time->tm_mon + 1;
    wintime->wDay       = time->tm_mday;
    wintime->wDayOfWeek = time->tm_wday;
    wintime->wHour      = time->tm_hour;
    wintime->wMinute    = time->tm_min;
    wintime->wSecond    = time->tm_sec;
}


void GetLocalTime(SYSTEMTIME *wintime)
{
    struct tm * lintime;
    time_t t;
    
    time(&t);
    lintime = localtime(&t);

    UnixtimeToWintime(wintime, lintime);    
}


int  GetFileLocalTime(char *path, SYSTEMTIME *wintime)
{
    struct stat statbuf;
    struct tm * lintime;
    
    if (stat(path, &statbuf) != 0)
        return 0;
    lintime = localtime(&statbuf.st_mtime);

    UnixtimeToWintime(wintime, lintime);

    return 1;
}

static int intcmp(int i1, int i2)
{
    if (i1 > i2)
    return 1;
    if (i1 < i2)
    return -1;
    return 0;
}

int SYSTEMTIMEcmp(const SYSTEMTIME *t1, const SYSTEMTIME *t2)
{
    return intcmp( t1->wSecond, t2->wSecond )
    +  intcmp( t1->wMinute, t2->wMinute ) * 2
    +  intcmp( t1->wHour,   t2->wHour   ) * 4
    +  intcmp( t1->wDay,    t2->wDay    ) * 8
    +  intcmp( t1->wMonth,  t2->wMonth  ) * 16
    +  intcmp( t1->wYear,   t2->wYear   ) * 32;
}


















================================================
FILE: src/localtime_win.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <windows.h>
#include "localtime.h"

// localtime built-in
// void GetLocalTime(SYSTEMTIME *wintime);


// local file time
int  GetFileLocalTime(char *path, SYSTEMTIME *wintime)
{
    // update time
    HANDLE hFile;
//    OFSTRUCT of;
    FILETIME ft1, ft2;

    hFile = CreateFile(path, 0, FILE_SHARE_READ,
        NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == (HANDLE)ERROR_INVALID_HANDLE)
        return 0;
        
    GetFileTime(hFile, NULL, NULL, &ft1);
    FileTimeToLocalFileTime(&ft1, &ft2);
    FileTimeToSystemTime(&ft2, wintime);
    CloseHandle(hFile);
    return 1;
}

int intcmp(int i1, int i2)
{
    if (i1 > i2)
	return 1;
    if (i1 < i2)
	return -1;
    return 0;
}

int SYSTEMTIMEcmp(const SYSTEMTIME *t1, const SYSTEMTIME *t2)
{
    return intcmp( t1->wSecond, t2->wSecond ) * 2
        +  intcmp( t1->wMinute, t2->wMinute ) * 4
        +  intcmp( t1->wHour,   t2->wHour   ) * 8
        +  intcmp( t1->wDay,    t2->wDay    ) * 16
        +  intcmp( t1->wMonth,  t2->wMonth  ) * 32
        +  intcmp( t1->wYear,   t2->wYear   ) * 64;
}


================================================
FILE: src/logging.c
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: logging.c,v 1.13 2007-10-11 05:55:47 dkure Exp $
*/

#include "quakedef.h"
#include "logging.h"
#include "utils.h"
#include "hash.h"
#include "vfs.h"
#include <curl/curl.h>


static void OnChange_log_dir(cvar_t *var, char *string, qbool *cancel);

cvar_t		log_dir			= {"log_dir", "", 0, OnChange_log_dir};
cvar_t		log_readable	= {"log_readable", "1"};

#define			LOG_FILENAME_MAXSIZE	(MAX_PATH)
#define			LOGFILEBUFFER			(128*1024)

static FILE       *logfile;     // opened file with log, writing is not performed until logging is stopped to avoid fps spikes
static vfsfile_t  *memlogfile;  // allocated memory where the log is being written
static char       logfilename[LOG_FILENAME_MAXSIZE];

static qbool autologging = false;

const char *MT_Challenge_GetToken(void);
const char *MT_Challenge_GetLadderId(void);
const char *MT_Challenge_GetHash(void);
qbool MT_Challenge_IsOn(void);
void Log_UploadTemp(void);

qbool Log_IsLogging(void) {
	return logfile ? true : false;
}

static char *Log_LogDirectory(void) {
	static char dir[LOG_FILENAME_MAXSIZE];

	strlcpy(dir, FS_LegacyDir(log_dir.string), sizeof(dir));
	return dir;
}

static void Log_Stop(void) {
	int read;
	vfserrno_t err;
	char buf[1024];
	int size;

	if (!Log_IsLogging())
		return;

	size = (int) VFS_TELL(memlogfile);

	VFS_SEEK(memlogfile, 0, SEEK_SET);
	while (size > 0 && (read = VFS_READ(memlogfile, buf, 1024, &err))) {
		fwrite(buf, 1, min(read, size), logfile);
		size -= read;
	}

	VFS_CLOSE(memlogfile);
	fclose(logfile);

	logfile = NULL;
	memlogfile = NULL;
}

static void OnChange_log_dir(cvar_t *var, char *string, qbool *cancel) {
	if (!string[0])
		return;

	Util_Process_FilenameEx(string, cl_mediaroot.integer == 2);

	if (!Util_Is_Valid_FilenameEx(string, cl_mediaroot.integer == 2)) {
		Com_Printf(Util_Invalid_Filename_Msg(var->name));
		*cancel = true;
		return;
	}
}

static void Log_log_f(void) {
	char *fulllogname;
	FILE *templog;
	void *buf;

	switch (Cmd_Argc()) {
	case 1:
		if (autologging)
			Com_Printf("Auto console logging is in progress\n");
		else if (Log_IsLogging())
			Com_Printf("Logging to %s\n", logfilename);
		else
			Com_Printf("Not logging\n");
		return;
	case 2:
		if (!strcasecmp(Cmd_Argv(1), "stop")) {
			if (autologging) {
				Log_AutoLogging_StopMatch();
			} else {
				if (Log_IsLogging()) {
					Log_Stop();
					Com_Printf("Stopped logging to %s\n", logfilename);
				} else {
					Com_Printf("Not logging\n");
				}
			}
			return;
		}

		if (autologging) {
			Com_Printf("Auto console logging must be stopped first!\n");
			return;
		}

		if (Log_IsLogging()) {
			Log_Stop();
			Com_Printf("Stopped logging to %s\n", logfilename);
		}

		strlcpy(logfilename, Cmd_Argv(1), sizeof(logfilename) - 4);
		Util_Process_Filename(logfilename);
		if (!Util_Is_Valid_Filename(logfilename)) {
			Com_Printf(Util_Invalid_Filename_Msg("filename"));
			return;
		}
		COM_ForceExtensionEx (logfilename, ".log", sizeof (logfilename));
		fulllogname = va("%s/%s", Log_LogDirectory(), logfilename);
		if (!(templog = fopen (fulllogname, log_readable.value ? "w" : "wb"))) {
			FS_CreatePath(fulllogname);
			if (!(templog = fopen (fulllogname, log_readable.value ? "w" : "wb"))) {
				Com_Printf("Error: Couldn't open %s\n", logfilename);
				return;
			}
		}
		buf = Q_calloc(1, LOGFILEBUFFER);
		if (!buf) {
			Com_Printf("Not enough memory to allocate log buffer\n");
			fclose(templog);
			return;
		}
		memlogfile = FSMMAP_OpenVFS(buf, LOGFILEBUFFER);
		Com_Printf("Logging to %s\n", logfilename);
		logfile = templog;
		break;
	default:
		Com_Printf("Usage: %s [filename | stop]\n", Cmd_Argv(0));
		return;
	}
}

void Log_Init(void) {
	Cvar_SetCurrentGroup(CVAR_GROUP_CONSOLE);
	Cvar_Register (&log_dir);
	Cvar_Register (&log_readable);

	Cvar_ResetCurrentGroup();

	Cmd_AddCommand("log", Log_log_f);
}

void Log_Shutdown(void) {
	if (Log_IsLogging())	
		Log_Stop();
}

void Log_Write(char *s) {
	if (!Log_IsLogging())
		return;
	
	VFS_WRITE(memlogfile, s, strlen(s));
	// fprintf(logfile, "%s", s);
}

//=============================================================================
//							AUTO CONSOLE LOGGING
//=============================================================================



static char	auto_matchname[2 * MAX_OSPATH];
static qbool temp_log_ready = false;
static float auto_starttime;

char *MT_TempDirectory(void);

extern cvar_t match_auto_logconsole, match_auto_minlength;

void Log_AutoLogging_StopMatch(void) {
	if (!autologging) {
		return;
	}

	autologging = false;
	Log_Stop();
	temp_log_ready = true;

	if (match_auto_logconsole.value == 2)
		Log_AutoLogging_SaveMatch(true);
	else {
		Com_Printf ("Auto console logging completed\n");
		if (MT_Challenge_Log_IsUploadAllowed()) {
			Log_UploadTemp();
		}
	}
}


void Log_AutoLogging_CancelMatch(void) {
	if (!autologging)
		return;

	autologging = false;
	Log_Stop();
	temp_log_ready = true;

	if (match_auto_logconsole.value == 2) {
		if (cls.realtime - auto_starttime > match_auto_minlength.value) {
			Log_AutoLogging_SaveMatch(true);
		}
		else {
			Com_Printf("Auto console logging cancelled\n");
		}
	} else if (match_auto_logconsole.integer == 1 || MT_ChallengeSpecified()) {
		Com_Printf ("Auto console logging completed\n");
		if (MT_Challenge_Log_IsUploadAllowed()) {
			Log_UploadTemp();
		}
	} else {
		Com_Printf ("Auto console logging completed\n");
	}
}


void Log_AutoLogging_StartMatch(char *logname) {
	char extendedname[MAX_OSPATH * 2], *fullname;
	FILE *templog;
	void *buf;

	temp_log_ready = false;

	if (!match_auto_logconsole.integer && !MT_ChallengeSpecified()) {
		return;
	}

	if (Log_IsLogging()) {
		if (autologging) {		
			autologging = false;
			Log_Stop();
		}
		else {
			Com_Printf("Auto console logging skipped (already logging)\n");
			return;
		}
	}

	strlcpy(auto_matchname, logname, sizeof(auto_matchname));

	strlcpy(extendedname, TEMP_LOG_NAME, sizeof(extendedname));
	COM_ForceExtensionEx (extendedname, ".log", sizeof (extendedname));
	fullname = va("%s/%s", MT_TempDirectory(), extendedname);

	if (!(templog = fopen (fullname, log_readable.value ? "w" : "wb"))) {
		FS_CreatePath(fullname);
		if (!(templog = fopen (fullname, log_readable.value ? "w" : "wb"))) {
			Com_Printf("Error: Couldn't open %s\n", fullname);
			return;
		}
	}

	buf = Q_calloc(1, LOGFILEBUFFER);
	if (!buf) {
		Com_Printf("Not enough memory to allocate log buffer\n");
		fclose(templog);
		return;
	}
	memlogfile = FSMMAP_OpenVFS(buf, LOGFILEBUFFER);

	Com_Printf ("Auto console logging commenced\n");

	logfile = templog;
	autologging = true;
	auto_starttime = cls.realtime;
}

qbool Log_AutoLogging_Status(void) {
	return temp_log_ready ? 2 : autologging ? 1 : 0;
}

void Log_AutoLogging_SaveMatch(qbool allow_upload) {
	int error, num;
	FILE *f;
	char *dir, *tempname, savedname[2 * MAX_OSPATH], *fullsavedname, *exts[] = {"log", NULL};

	if (!temp_log_ready) {
		return;
	}

	if (Log_TempLogUploadPending()) {
		Com_Printf("Error: Can't save the log. Log upload is still pending.\n");
		return;
	}

	temp_log_ready = false;

	dir = Log_LogDirectory();
	tempname = va("%s/%s", MT_TempDirectory(), TEMP_LOG_NAME);

	fullsavedname = va("%s/%s", dir, auto_matchname);
	if ((num = Util_Extend_Filename(fullsavedname, exts)) == -1) {
		Com_Printf("Error: no available filenames\n");
		return;
	}
	snprintf (savedname, sizeof(savedname), "%s_%03i.log", auto_matchname, num);

	fullsavedname = va("%s/%s", dir, savedname);

	
	if (!(f = fopen(tempname, "rb")))
		return;
	fclose(f);

	if ((error = rename(tempname, fullsavedname))) {
		FS_CreatePath(fullsavedname);
		error = rename(tempname, fullsavedname);
	}

	if (!error) {
		Com_Printf("Match console log saved to %s\n", savedname);
		if (allow_upload && MT_Challenge_Log_IsUploadAllowed()) {
			// note: we allow the client to be a spectator, so that spectators
			// can submit logs for matches they spec in case players don't do it
			Log_AutoLogging_Upload(fullsavedname);
		}
	}
}


================================================
FILE: src/logging.h
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef __LOGGING_H_

#define __LOGGING_H_

qbool Log_IsLogging(void);
void Log_Init(void);
void Log_Shutdown(void);
void Log_Write(char *s);

void Log_AutoLogging_StopMatch(void);
void Log_AutoLogging_CancelMatch(void);
void Log_AutoLogging_StartMatch(char *logname);
qbool Log_AutoLogging_Status(void);
void Log_AutoLogging_SaveMatch(qbool allow_upload);
qbool Log_TempLogUploadPending(void);
qbool MT_Challenge_Log_IsUploadAllowed(void);
void Log_AutoLogging_Upload(const char *filename);
qbool MT_ChallengeSpecified(void);

#define TEMP_LOG_NAME "_!_temp_!_.log"

extern cvar_t log_readable;
extern cvar_t log_dir;

#endif


================================================
FILE: src/macro_definitions.h
================================================

#ifndef EZQUAKE_MACRO_DEFINITIONS_H
#define EZQUAKE_MACRO_DEFINITIONS_H

#define MACRO_DEF(x) macro_ ## x

typedef enum {
#include "macro_ids.h"
	num_macros
} macro_id;

#undef MACRO_DEF

#endif // EZQUAKE_MACRO_DEFINITIONS_H


================================================
FILE: src/macro_ids.h
================================================

MACRO_DEF(health),
MACRO_DEF(armortype),
MACRO_DEF(armor),
MACRO_DEF(colored_armor),
MACRO_DEF(colored_powerups),
MACRO_DEF(colored_short_powerups),
MACRO_DEF(tp_powerups),
MACRO_DEF(shells),
MACRO_DEF(nails),
MACRO_DEF(rockets),
MACRO_DEF(cells),
MACRO_DEF(weapons),
MACRO_DEF(ammo),
MACRO_DEF(bestweapon),
MACRO_DEF(bestammo),
MACRO_DEF(powerups),
MACRO_DEF(location),
MACRO_DEF(deathloc),
MACRO_DEF(tookatloc),
MACRO_DEF(tookloc),
MACRO_DEF(took),
MACRO_DEF(pointatloc),
MACRO_DEF(pointloc),
MACRO_DEF(point),
MACRO_DEF(need),
MACRO_DEF(droploc),
MACRO_DEF(droptime),
MACRO_DEF(ledpoint),
MACRO_DEF(ledstatus),
MACRO_DEF(lastloc),
MACRO_DEF(lastpowerup),
MACRO_DEF(cam_pos_x),
MACRO_DEF(cam_pos_y),
MACRO_DEF(cam_pos_z),
MACRO_DEF(cam_pos),
MACRO_DEF(cam_angles_pitch),
MACRO_DEF(cam_angles_yaw),
MACRO_DEF(cam_angles_roll),
MACRO_DEF(cam_angles),
MACRO_DEF(demoname),
MACRO_DEF(demolength),
MACRO_DEF(connectiontype),
MACRO_DEF(demoplayback),
MACRO_DEF(demotime),
MACRO_DEF(rand),
MACRO_DEF(matchstatus),
MACRO_DEF(serverip),
MACRO_DEF(conwidth),
MACRO_DEF(conheight),
MACRO_DEF(matchname),
MACRO_DEF(matchtype),
MACRO_DEF(mp3info),
MACRO_DEF(mp3_volume),
MACRO_DEF(lastip),
MACRO_DEF(qt),
MACRO_DEF(latency),
MACRO_DEF(ping),
MACRO_DEF(time),
MACRO_DEF(timestamp),
MACRO_DEF(date),
MACRO_DEF(dateiso),
MACRO_DEF(weaponnum),
MACRO_DEF(weapon),
MACRO_DEF(tf_skin),
MACRO_DEF(gamedir),
MACRO_DEF(triggermatch),
MACRO_DEF(team1),
MACRO_DEF(team2),

// leave trailing ,


================================================
FILE: src/match_tools.c
================================================
/*

Copyright (C) 2002-2003       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: match_tools.c,v 1.32 2007-10-13 01:59:54 himan Exp $
*/


#include "quakedef.h"
#include <time.h>
#include "logging.h"
#include "gl_model.h"
#include "teamplay.h"
#include "utils.h"
#include <curl/curl.h>
#include "sha1.h"
#include <time.h>

void MT_Challenge_StartMatch(void);
void MT_Challenge_Cancel(void);
void MT_Challenge_InitCvars(void);

#define MAX_STATIC_STRING 1024

cvar_t match_format_solo = {"match_format_solo", "solo/%n - [%M]"};
cvar_t match_format_coop = {"match_format_coop", "coop/%n - [%C_player_coop] - [%M]"};
cvar_t match_format_race = {"match_format_race", "race/%n - [race] - [%M]"};

cvar_t match_format_duel = {"match_format_duel", "duel/%n - %p%v%e - [dmm%D] - [%M]"};
cvar_t match_format_ffa = {"match_format_ffa", "ffa/%n - [%C_player_ffa] - [%M]"};
cvar_t match_format_2on2 = {"match_format_2on2", "2on2/%n - [%k%v%l] - [%M]"};
cvar_t match_format_3on3 = {"match_format_3on3", "tdm/%n - [%Oon%E_%t%v%e] - [%M]"};
cvar_t match_format_4on4 = {"match_format_4on4", "tdm/%n - [%Oon%E_%t%v%e] - [%M]"};
cvar_t match_format_tdm = {"match_format_tdm", "tdm/%n - [%Oon%E_%t%v%e] - [%M]"};
cvar_t match_format_multiteam = {"match_format_multiteam", "tdm/%n - [%a_%b] - [%M]"};

cvar_t match_format_arena = {"match_format_arena", "arena/%n - %p%v%e - [%F_frags] - [%M]"};
cvar_t match_format_tf_duel = {"match_format_tf_duel", "tfduel/%n - %p%v%e [%M]"};
cvar_t match_format_tf_clanwar = {"match_format_tf_clanwar", "tfwar/%n - [%Oon%E_%t%v%e] - [%M]"};

cvar_t match_name_and = {"match_name_and", "_&_"};			
cvar_t match_name_versus = {"match_name_versus", "_vs_"};	
cvar_t match_name_on = {"match_name_on", "on"};				
cvar_t match_name_nick = {"match_name_nick", ""};			
cvar_t match_name_spec = {"match_name_spec", "(SPEC)"};		

char *CL_DemoDirectory(void);

static char *MT_CleanString(char *string, qbool allow_spaces_and_slashes) {
	byte *in, *out, c, d, *disallowed;
	static byte buf[MAX_STATIC_STRING], badchars[] = {' ', '\\', '/', '?', '*', ':', '<', '>', '"', '|', '\0'};
	extern char readableChars[];

	disallowed = allow_spaces_and_slashes ? badchars + 3 : badchars;

	#define CLEANCHAR(c) \
		((readableChars[(byte) c] < ' ' || strchr((char *)disallowed, readableChars[(byte) c])) ? '_' : readableChars[(byte) c])

	in = (byte *) string;
	out = buf;

	while ((c = *in++) && out - buf < sizeof(buf) - 1) {
		d = CLEANCHAR(c);
		*out++ = d;
		if (d == '_') {
			for ( ; *in && CLEANCHAR(*in) == '_'; in++)
				;
		}
	}

	#undef CLEANCHAR

	*out = 0;
	Util_Process_Filename((char *) buf);
	return (char *) buf;
}

char* MT_PlayerName(void)
{
	return TP_PlayerName();
}

char* MT_PlayerTeam(void)
{
	return TP_PlayerTeam();
}

char* MT_EnemyName(void)
{
	int i;
	char *myname, *name;
	static char	enemyname[MAX_INFO_STRING];

	enemyname[0] = 0;
	myname = MT_PlayerName ();

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0] && !cl.players[i].spectator) {
			name = Info_ValueForKey(cl.players[i].userinfo, "name");
			if (strcmp(name, myname)) {
				strlcpy(enemyname, name, sizeof (enemyname));
				return enemyname;
			}
		}
	}
	return enemyname;
}

static char *MT_EnemyTeam(void) {
	int i;
	char *myteam, *team;
	static char	enemyteam[MAX_INFO_STRING];

	enemyteam[0] = 0;
	myteam = MT_PlayerTeam();

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0] && !cl.players[i].spectator) {
			team = cl.players[i].team;
			if (team[0] && strcmp(team, myteam)) {
				strlcpy (enemyteam, team, sizeof (enemyteam));
				return enemyteam;
			}
		}
	}
	return enemyteam;
}

int MT_CountPlayers(void)
{
	return TP_CountPlayers();
}

static int MT_CountTeamMembers(char *team)
{
	int i, count = 0;

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator)
			continue;
		if (!strcmp(cl.players[i].team, team))
			count++;
	}
	return count;
}

static char *MT_NameAndClean_TeamMembers(char *team) {
	static char namebuf[MAX_STATIC_STRING];
	int i;

	namebuf[0] = 0;
	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator)
			continue;
		if (!strcmp(cl.players[i].team, team)) {
			if (namebuf[0])
				strlcat(namebuf, match_name_and.string, sizeof (namebuf) - strlen (namebuf));

			strlcat(namebuf, MT_CleanString(cl.players[i].name, false), sizeof (namebuf) - strlen (namebuf));
		}
	}
	return namebuf;
}

static char *MT_MapName(void) {
	static char buf[MAX_OSPATH];

	strlcpy(buf, TP_MapName(), sizeof(buf));
	return buf;
}

static void MT_GetPlayerNames(char *name1, char *name2) {
	int i;
	char *s1 = NULL, *s2 = NULL;

	name1[0] = name2[0] = 0;

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator)
			continue;
		if (!s1) {
			s1 = cl.players[i].name;
		} else {
			s2 = cl.players[i].name;
			break;
		}
	}
	if (s1)
		strcpy(name1, s1);
	if (s2)
		strcpy(name2, s2);
}

static int MT_GetTeamNames(char teams[][MAX_INFO_STRING], int max) {
	int i, j, count = 0;

	memset(teams, 0, sizeof(*teams));

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator)
			continue;

		for (j = 0; j < i; j++) {
			if (!cl.players[j].name[0] || cl.players[j].spectator)
				continue;

			if (!strcmp(cl.players[i].team, cl.players[j].team))
				break;
		}
		if (j == i) {
			strlcpy (teams[count], cl.players[i].team, MAX_INFO_STRING);
			count++;
		}
		if (count == max)
			break;
	}
	return count;
}

static char *MT_Serverinfo_Race(void) {
	static char buf[MAX_OSPATH];

	strlcpy(buf, Info_ValueForKey(cl.serverinfo, "race"), sizeof(buf));
	return buf;
}


typedef enum {
	mt_duel, mt_ffa,
	mt_2on2, mt_3on3, mt_4on4, mt_tdm,
	mt_multiteam,
	mt_arena,
	mt_tf_duel, mt_tf_clanwar,
	mt_solo,		
	mt_coop,		
	mt_race,		
	mt_empty,		
	mt_unknown_gamedir,
	mt_unknown,
	mt_numtypes,
} matchtype_t;

typedef struct matchcvar_s {
	matchtype_t matchtype;
	char		*nickname;
	cvar_t		*format;
	qbool	autosshot;
} matchcvar_t;

static matchcvar_t matchcvars[mt_numtypes] = {
	{mt_duel, "duel", &match_format_duel, true},
	{mt_ffa, "ffa", &match_format_ffa, true},
	{mt_2on2, "2on2", &match_format_2on2, true},
	{mt_3on3, "3on3", &match_format_3on3, true},
	{mt_4on4, "4on4", &match_format_4on4, true},
	{mt_tdm, "tdm", &match_format_tdm, true},
	{mt_multiteam, "tdm", &match_format_multiteam, true},
	{mt_arena, "arena", &match_format_arena, true},
	{mt_tf_duel, "tfduel", &match_format_tf_duel, true},
	{mt_tf_clanwar, "tfclanwar", &match_format_tf_clanwar, true},
	{mt_solo, "solo", &match_format_solo, false},
	{mt_coop, "coop", &match_format_coop, false},
	{mt_race, "race", &match_format_race, false},
	{mt_empty, "empty", NULL, false},
	{mt_unknown_gamedir, "unknown", NULL, false},
	{mt_unknown, "unknown", NULL, false},
};

typedef struct matchinfo_s {
	qbool spectator;
	char myname[MAX_INFO_STRING];
	char player1[MAX_INFO_STRING];
	char player2[MAX_INFO_STRING];
	char team1[MAX_INFO_STRING];
	char team2[MAX_INFO_STRING];
	int team1count;
	int team2count;
	int numteams;
	char team1names[MAX_STATIC_STRING];	
	char team2names[MAX_STATIC_STRING];	
	char multiteamnames[MAX_STATIC_STRING];	
	char multiteamcounts[128];				
	int maxteamsize;
	int numplayers;
	int timelimit;
	int fraglimit;
	int teamplay;
	int maxclients;
	int deathmatch;
	char mapname[MAX_OSPATH];
	char gamedir[MAX_OSPATH];
	matchtype_t matchtype;
	char day[8];
	char month[8];
	char year[8];
	char bigyear[8];
	char hour[8];
	char minute[8];
	char second[8];
} matchinfo_t;

static matchtype_t MT_GetMatchType(matchinfo_t *matchinfo) {

	if (matchinfo->numplayers < 1)
		return mt_empty;


	if (!strcasecmp(matchinfo->gamedir, "qw") && !strcmp(MT_Serverinfo_Race(), matchinfo->mapname))
		return mt_race;


	if (matchinfo->numplayers < 2)
		return mt_solo;


	if (cl.teamfortress) {
		return	(matchinfo->numplayers == 2) ? mt_tf_duel : 
				(matchinfo->numteams < 2) ? mt_unknown : mt_tf_clanwar;
	}

	if (strstr(matchinfo->gamedir, "arena"))
		return mt_arena;

	if (!matchinfo->deathmatch)
		return mt_coop;


	if (matchinfo->numplayers == 2)
		return (!matchinfo->teamplay || matchinfo->numteams == 2) ? mt_duel : mt_unknown;

	if (!matchinfo->teamplay || matchinfo->maxteamsize <= 1)
		return mt_ffa;


	if (matchinfo->numteams !=  2)
		return (matchinfo->numteams > 2) ? mt_multiteam : mt_unknown;

	switch (matchinfo->maxteamsize) {
		case 2: return mt_2on2;
		case 3: return mt_3on3;
		case 4: return mt_4on4;
		default: return mt_tdm;
	}
}

static matchinfo_t *MT_GetMatchInfo(void) {
	static matchinfo_t matchinfo;
	char teamnames[MAX_CLIENTS][MAX_INFO_STRING];
	int i, numteams, maxteamsize, teamsize;
	time_t t;
	struct tm *ptm;

	memset(&matchinfo, 0, sizeof(matchinfo));
	numteams = MT_GetTeamNames(teamnames, MAX_CLIENTS);

	matchinfo.spectator = cl.spectator;
	strlcpy(matchinfo.myname, MT_PlayerName(), sizeof(matchinfo.myname));

	if (cl.spectator) {
		MT_GetPlayerNames(matchinfo.player1, matchinfo.player2);
		strlcpy(matchinfo.team1, teamnames[0], sizeof(matchinfo.team1));
		strlcpy(matchinfo.team2, teamnames[1], sizeof(matchinfo.team2));
	} else {
		strlcpy(matchinfo.player1, MT_PlayerName(), sizeof(matchinfo.player1));
		strlcpy(matchinfo.player2, MT_EnemyName(), sizeof(matchinfo.player2));
		strlcpy(matchinfo.team1, MT_PlayerTeam(), sizeof(matchinfo.team1));
		strlcpy(matchinfo.team2, MT_EnemyTeam(), sizeof(matchinfo.team2));
	}


	matchinfo.team1count = MT_CountTeamMembers(matchinfo.team1);
	matchinfo.team2count = MT_CountTeamMembers(matchinfo.team2);
	matchinfo.numteams = numteams;
	strlcpy(matchinfo.team1names, MT_NameAndClean_TeamMembers(matchinfo.team1), sizeof(matchinfo.team1names));
	strlcpy(matchinfo.team2names, MT_NameAndClean_TeamMembers(matchinfo.team2), sizeof(matchinfo.team2names));


#define CLEANFIELD(x) strlcpy(matchinfo.x, MT_CleanString(matchinfo.x, false), sizeof(matchinfo.x));	
	CLEANFIELD(myname);
	CLEANFIELD(player1);
	CLEANFIELD(player2);
	CLEANFIELD(team1);
	CLEANFIELD(team2);
#undef CLEANFIELD

#define BUF matchinfo.multiteamnames
	for (i = 0; i < numteams; i++) {
		strlcat (BUF, MT_CleanString(teamnames[i], false), sizeof (BUF) - strlen (BUF));
		if (i < numteams - 1)
			strlcat (BUF, match_name_versus.string, sizeof (BUF) - strlen (BUF));
	}
#undef BUF

	maxteamsize = 0;
#define BUF matchinfo.multiteamcounts
	for (i = 0; i < numteams; i++) {
		teamsize = MT_CountTeamMembers(teamnames[i]);
		if (*teamnames[i])
			maxteamsize = max(maxteamsize, teamsize);
		strlcat (BUF, va("%d", teamsize), sizeof (BUF) - strlen (BUF));
		if (i < numteams - 1)
			strlcat(BUF, match_name_on.string, sizeof (BUF) - strlen (BUF));
	}
	matchinfo.maxteamsize = maxteamsize;
#undef BUF

	matchinfo.numplayers = MT_CountPlayers();

	matchinfo.timelimit = Q_atoi(Info_ValueForKey(cl.serverinfo, "timelimit"));
	matchinfo.fraglimit = Q_atoi(Info_ValueForKey(cl.serverinfo, "fraglimit"));
	matchinfo.teamplay = Q_atoi(Info_ValueForKey(cl.serverinfo, "teamplay"));
	matchinfo.maxclients = Q_atoi(Info_ValueForKey(cl.serverinfo, "maxclients"));
	matchinfo.deathmatch = cl.deathmatch;

	strlcpy(matchinfo.mapname, MT_MapName(), sizeof(matchinfo.mapname));
	strlcpy(matchinfo.gamedir, cls.gamedirfile, sizeof(matchinfo.gamedir));

	matchinfo.matchtype = MT_GetMatchType(&matchinfo);

	time(&t);
	if ((ptm = localtime(&t))) {
		strftime (matchinfo.day, sizeof(matchinfo.day) - 1, "%d", ptm);
		strftime (matchinfo.month, sizeof(matchinfo.month) - 1, "%m", ptm);
		strftime (matchinfo.year, sizeof(matchinfo.year) - 1, "%y", ptm);
		strftime (matchinfo.bigyear, sizeof(matchinfo.bigyear) - 1, "%Y", ptm);
		strftime (matchinfo.hour, sizeof(matchinfo.hour) - 1, "%H", ptm);
		strftime (matchinfo.minute, sizeof(matchinfo.minute) - 1, "%M", ptm);
		strftime (matchinfo.second, sizeof(matchinfo.second) - 1, "%S", ptm);
	}

	return &matchinfo;
}

void MT_Macrolist_f(void) {
	int argc;

	switch((argc = Cmd_Argc())) {
	case 1:
		Com_Printf("\x02The following macros can be used to name your matches\n");
		Com_Printf("\x02The square brackets apply when spectating a match\n\n");
		Com_Printf("\x02%%n"); Com_Printf(" - your nick [followed by match_name_spec]\n");
		Com_Printf("\x02%%p"); Com_Printf(" - your name [player1's name]\n");
		Com_Printf("\x02%%t"); Com_Printf(" - your team [team1's name]\n");
		Com_Printf("\x02%%e"); Com_Printf(" - enemy nick in duels, enemy team in tp [player2/team2]\n");

		Com_Printf("\x02%%k"); Com_Printf(" - names of players on your team [team1]\n");
		Com_Printf("\x02%%l"); Com_Printf(" - names of players on enemy team [team2]\n");

		Com_Printf("\x02%%O"); Com_Printf(" - number of teammates [number on team1]\n");
		Com_Printf("\x02%%E"); Com_Printf(" - number of enemies [number on team2]\n");
		Com_Printf("\x02%%C"); Com_Printf(" - number of players on the server\n");

		Com_Printf("\x02%%a"); Com_Printf(" - team counts separated by match_name_on (eg 4on3on4)\n");
		Com_Printf("\x02%%b"); Com_Printf(" - team names separated by match_name_versus\n");
		Com_Printf("\x02%%v"); Com_Printf(" - shortcut for $match_name_versus\n");

		Com_Printf("\x02%%T"); Com_Printf(" - timelimit on the server\n");
		Com_Printf("\x02%%F"); Com_Printf(" - fraglimit n the server\n");
		Com_Printf("\x02%%p"); Com_Printf(" - teamplay setting on the server\n");
		Com_Printf("\x02%%D"); Com_Printf(" - deathmatch mode on the server\n");

		Com_Printf("\x02%%M"); Com_Printf(" - mapname\n");
		Com_Printf("\x02%%G"); Com_Printf(" - gamedir (eg. qw, fortress, arena, etc)\n");

		Com_Printf("\x02%%d"); Com_Printf(" - day\n");
		Com_Printf("\x02%%m"); Com_Printf(" - month\n");
		Com_Printf("\x02%%y"); Com_Printf(" - year (without century)\n");
		Com_Printf("\x02%%Y"); Com_Printf(" - year (with century)\n");

		Com_Printf("\x02%%H"); Com_Printf(" - hour\n");
		Com_Printf("\x02%%Q"); Com_Printf(" - minute\n");
		Com_Printf("\x02%%S"); Com_Printf(" - second\n");

		break;
	default:
		Com_Printf("%s : no arguments expected\n", Cmd_Argv(0));
		break;
	}
}

static char *MT_ParseFormat(char *format, matchinfo_t *matchinfo) {
	static char buf[MAX_STATIC_STRING];
	char c, *out, *in, *temp;

	buf[0] = 0;
	out = buf;
	in = format;

	while ((c = *in++) && (out - buf < MAX_STATIC_STRING - 1)) {
		if ((c == '%') && *in) {
			switch((c = *in++)) {
				case '%':
					temp = "%"; break;
				case 'n':
					temp = match_name_nick.string[0] ? match_name_nick.string : matchinfo->myname;
					temp = cl.spectator ? va("%s%s", temp, match_name_spec.string) : temp;
					break;
				case 'p':
					temp = matchinfo->player1; break;
				case 't':
					temp = matchinfo->team1; break;
				case 'e':
					temp = matchinfo->numplayers == 2 ? matchinfo->player2 : matchinfo->team2; break;
				case 'k':
					temp = matchinfo->team1names; break;
				case 'l':
					temp = matchinfo->team2names; break;
				case 'O':
					temp = matchinfo->teamplay ? va("%d", matchinfo->team1count) : "1"; break;
				case 'E':
					temp = va("%d", matchinfo->teamplay ? matchinfo->team2count : matchinfo->numplayers - 1); break;
				case 'C':
					temp = va("%d", matchinfo->numplayers); break;
				case 'a':
					temp = matchinfo->multiteamcounts; break;
				case 'b':
					temp = matchinfo->multiteamnames; break;
				case 'v':
					temp = match_name_versus.string; break;
				case 'T':
					temp = va("%d", matchinfo->timelimit); break;
				case 'F':
					temp = va("%d", matchinfo->fraglimit); break;
				case 'N':
					temp = va("%d", matchinfo->teamplay); break;
				case 'D':
					temp = va("%d", matchinfo->deathmatch); break;
				case 'M':
					temp = matchinfo->mapname; break;
				case 'G':
					temp = matchinfo->gamedir; break;
				case 'd':
					temp = matchinfo->day; break;
				case 'm':
					temp =  matchinfo->month; break;
				case 'y':
					temp = matchinfo->year; break;
				case 'Y':
					temp = matchinfo->bigyear; break;
				case 'H':
					temp = matchinfo->hour; break;
				case 'Q':
					temp = matchinfo->minute; break;
				case 'S':
					temp = matchinfo->second; break;
				default:
					temp = va("%%%c", c); break;
			}
			strlcpy(out, temp, sizeof(buf) - (out - buf));
			out += strlen(temp);
		} else {
			*out++ = c;
		}
	}

	*out = 0;
	return buf;
}

static char *MT_NameForMatchInfo(matchinfo_t *matchinfo) {
	char *format = NULL;

	switch (matchinfo->matchtype) {
	case mt_empty:
		format = "%n - [%M]"; break;
	case mt_unknown_gamedir:
		format = "%n - [gamedir - %G, %C players] - [%M]"; break;
	case mt_unknown:
		format = "%n - [Unknown Game, gamedir - %G, %C players] - [%M]"; break;
	default:
		if (matchinfo->matchtype < mt_numtypes) {
			format = matchcvars[matchinfo->matchtype].format->string;
		} else {
			Sys_Error("Macro_Matchdesc : Unknown match type %d", matchinfo->matchtype);
		}
		break;
	}
	if (!format)
		Sys_Error("MT_NameForMatchInfo: NULL format");

	return MT_CleanString(MT_ParseFormat(format, matchinfo), true);
}

char *Macro_MatchName(void) {
	return (cls.state < ca_active) ? "No match in progress" : MT_NameForMatchInfo(MT_GetMatchInfo());
}

char *MT_MatchName(void) {
	static char buf[MAX_STATIC_STRING];

	strlcpy(buf, Macro_MatchName(), sizeof(buf));
	return buf;
}

char *MT_ShortStatus(void)
{
	int maxclients = Q_atoi(Info_ValueForKey(cl.serverinfo, "maxclients"));
	char *mapname = TP_MapName();

	return va("%d/%d - %s", TP_CountPlayers(), maxclients, mapname);
}

#define MT_SCOREBOARD_SHOWIME	4

void MT_TakeScreenshot(void);

cvar_t match_auto_record = {"match_auto_record", "0"};
cvar_t match_auto_logconsole = {"match_auto_logconsole", "1"};
cvar_t match_auto_sshot = {"match_auto_sshot", "0"};
cvar_t match_auto_minlength = {"match_auto_minlength", "30"};
cvar_t match_auto_spectating = {"match_auto_spectating", "0"};
cvar_t match_auto_unminimize = {"match_auto_unminimize", "1"};

typedef struct mt_matchtstate_s {
	qbool standby;
	int intermission;
	int status;
	float starttime;
	float endtime;
	char matchname[2 * MAX_OSPATH];
	matchtype_t matchtype;
} mt_matchstate_t;

static mt_matchstate_t matchstate;

static void MT_Delayed_EndMatch(void) {
	matchstate.endtime = 0;

	Log_AutoLogging_StopMatch();
	CL_AutoRecord_StopMatch();
}

static void MT_EndMatch(void) {
	MT_TakeScreenshot();

	if (!matchstate.status)
		return;

	matchstate.starttime = 0;
	matchstate.status = 0;
 	matchstate.endtime = cls.realtime;
}

static void MT_CancelMatch(void) {
	if (matchstate.endtime) {
		MT_Delayed_EndMatch();
	}

	if (!matchstate.status)
		return;

	matchstate.starttime = 0;
	matchstate.status = 0;
	matchstate.endtime = 0;	

	Log_AutoLogging_CancelMatch();
	CL_AutoRecord_CancelMatch();
	MT_Challenge_Cancel();
}

static void MT_StartMatch(void)
{
	if (matchstate.endtime) {
		MT_Delayed_EndMatch();
	}

	if (matchstate.status) {
		MT_CancelMatch();
	}

	matchstate.status = 1;
	matchstate.starttime = cls.realtime;
	matchstate.endtime = 0;

	// disconnect: match_forcestart resets gameclock
	cl.standby = false;
	cl.countdown = false;
	cl.gametime = 0;
	cl.gamestarttime = Sys_DoubleTime();

	if (cls.state < ca_active) {
		matchstate.matchtype = mt_empty;
		strlcpy(matchstate.matchname, "No match in progress", sizeof(matchstate.matchname));
	} else {
		matchinfo_t *matchinfo = MT_GetMatchInfo();
		matchstate.matchtype = matchinfo->matchtype;
		strlcpy(matchstate.matchname, MT_NameForMatchInfo(matchinfo), sizeof(matchstate.matchname));
	}

	MT_Challenge_StartMatch();

	CL_AutoRecord_StartMatch(matchstate.matchname);
	Log_AutoLogging_StartMatch(matchstate.matchname);

	Stats_Reset();
}

static void MT_ClearClientState(void)
{
	memset(&matchstate, 0, sizeof(matchstate));
	cl.gamestarttime = Sys_DoubleTime();
	cl.gamepausetime = 0;
}

void MT_Frame(void)
{
	if (matchstate.endtime && cls.realtime >= matchstate.endtime + MT_SCOREBOARD_SHOWIME) {
		MT_Delayed_EndMatch();
	}

	if (cls.state != ca_active || cls.demoplayback) {
		return;
	}

	if (matchstate.standby && !cl.standby && !cl.intermission) {
		if (!cl.spectator || match_auto_spectating.value) {
			MT_StartMatch();
		}

		if (match_auto_unminimize.integer == 2 || (match_auto_unminimize.integer == 1 && !cl.spectator)) {
			VID_Restore();
		}
	}

	if (!matchstate.intermission && cl.intermission) {
		MT_EndMatch();
	}
	else if (matchstate.status && !matchstate.standby && cl.standby) {
		MT_CancelMatch();
	}

	matchstate.standby = cl.standby;
	matchstate.intermission = cl.intermission;
}

void MT_NewMap(void)
{
	MT_CancelMatch();
	MT_ClearClientState();
}

void MT_Disconnect(void)
{
	MT_CancelMatch();
	MT_ClearClientState();
}

char* MT_TempDirectory(void)
{
	static char dir[MAX_OSPATH * 2] = {0};

	if (!dir[0]) {
		snprintf(dir, sizeof(dir), "%s/temp", com_homedir);
	}
	return dir;
}

char *MT_TempDemoDirectory(void)
{
	static char dir[MAX_OSPATH * 2] = {0};

	if (!dir[0])
		snprintf(dir, sizeof(dir), "%s/temp", CL_DemoDirectory());
	return dir;
}

void MT_SaveMatch_f(void)
{
	int demo_status, log_status;

	demo_status = CL_AutoRecord_Status();
	log_status = Log_AutoLogging_Status();

	if (Log_TempLogUploadPending()) {
		Com_Printf("Log upload is still in progress\n");
		return;
	}

	if ((demo_status & 2) || (log_status & 2)) {
		Com_Printf("\x02Saving match...\n");
		CL_AutoRecord_SaveMatch();
		Log_AutoLogging_SaveMatch(false);
	}
	else {
		if ((demo_status & 1) || (log_status & 1)) {
			if ((demo_status & 1) && (log_status & 1)) {
				Com_Printf("Auto demo recording and console logging still in progress\n");
			}
			else if ((demo_status & 1)) {
				Com_Printf("Auto demo recording still in progress\n");
			}
			else if ((log_status & 1)) {
				Com_Printf("Auto console logging still in progress\n");
			}
		}
		else {
			Com_Printf("Nothing to save!\n");
		}
	}
}

void MT_Match_ForceStart_f(void)
{
	switch (Cmd_Argc()) {
	case 1:
		if (cls.state != ca_active || cls.demoplayback) {
			Com_Printf("You must be connected to a server before using \"%s\"\n", Cmd_Argv(0));
			return;
		}
		MT_StartMatch();
		break;
	default:
		Com_Printf("%s : no arguments expected\n", Cmd_Argv(0));
		break;
	}
}

void MT_TakeScreenshot(void)
{
	int i;
	qbool have_opponent;

	if (!match_auto_sshot.value || (cl.spectator && !match_auto_spectating.value))
		return;

	//don't bother screen-shotting solo games etc
	if (!matchcvars[matchstate.matchtype].autosshot)
		return;

	//make sure there are actually some frags on the board, and somebody besides us
	have_opponent = false;
	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator)
			continue;
		if (i != cl.playernum)
			have_opponent = true;		
	}
	if (!have_opponent) {
		Com_Printf("Auto screenshot cancelled\n");
		return;
	}

	if (!matchstate.status) {
		matchinfo_t *matchinfo = MT_GetMatchInfo();
		matchstate.matchtype = matchinfo->matchtype;
		strlcpy(matchstate.matchname, MT_NameForMatchInfo(matchinfo), sizeof(matchstate.matchname));
	}
	SCR_AutoScreenshot(matchstate.matchname);
}

#define MAX_GROUP_MEMBERS	36

typedef struct mapgroup_s {
	char groupname[MAX_QPATH];
	char members[MAX_GROUP_MEMBERS][MAX_QPATH];
	struct mapgroup_s *next, *prev;
	qbool system;
	int nummembers;
} mapgroup_t;

static mapgroup_t *mapgroups = NULL;	
static mapgroup_t *last_system_mapgroup = NULL;
static qbool mapgroups_init = false;	

#define FIRSTUSERGROUP (last_system_mapgroup ? last_system_mapgroup->next : mapgroups)

static mapgroup_t *GetGroupWithName(char *groupname) {
	mapgroup_t *node;

	for (node = mapgroups; node; node = node->next) {
		if (!strcasecmp(node->groupname, groupname))
			return node;
	}
	return NULL;
}

static mapgroup_t *GetGroupWithMember(char *member) {
	int j;
	mapgroup_t *node;

	for (node = mapgroups; node; node = node->next) {
		for (j = 0; j < node->nummembers; j++) {
			if (!strcasecmp(node->members[j], member))
				return node;
		}
	}
	return NULL;
}

static void DeleteMapGroup(mapgroup_t *group) {
	if (!group)
		return;

	if (group->prev)
		group->prev->next = group->next;
	if (group->next)
		group->next->prev = group->prev;

	
	if (group == mapgroups) {
		mapgroups = mapgroups->next;		
		if (group == last_system_mapgroup)
			last_system_mapgroup = NULL;
	} else if (group == last_system_mapgroup) {
		last_system_mapgroup = last_system_mapgroup->prev;
	}

	Q_free(group);
}

static void ResetGroupMembers(mapgroup_t *group) {
	int i;

	if (!group)
		return;

	for (i = 0; i < group->nummembers; i++)
		group->members[i][0] = 0;

	group->nummembers = 0;
}

static void DeleteGroupMember(mapgroup_t *group, char *member) {
	int i;

	if (!group)
		return;

	for (i = 0; i < group->nummembers; i++) {
		if (!strcasecmp(member, group->members[i]))
			break;
	}

	if (i == group->nummembers)	
		return;

	if (i < group->nummembers - 1)
		memmove(group->members[i], group->members[i + 1], (group->nummembers - 1 - i) * sizeof(group->members[0]));

	group->nummembers--;
}

static void AddGroupMember(mapgroup_t *group, char *member) {
	int i;

	if (!group || group->nummembers == MAX_GROUP_MEMBERS)
		return;

	for (i = 0; i < group->nummembers; i++) {		
		if (!strcasecmp(member, group->members[i]))
			return;
	}

	strlcpy(group->members[group->nummembers], member, sizeof(group->members[group->nummembers]));
	group->nummembers++;
}

void MT_MapGroup_f(void) {
	int i, c, j;
	qbool removeflag = false;
	mapgroup_t *node, *group, *tempnode;
	char *groupname, *member;

	if ((c = Cmd_Argc()) == 1) {		
		if (!FIRSTUSERGROUP) {
			Com_Printf("No map groups defined\n");
		} else {
			for (node = FIRSTUSERGROUP; node; node = node->next) {
				Com_Printf("\x02%s: ", node->groupname);
				for (j = 0; j < node->nummembers; j++)
					Com_Printf("%s ", node->members[j]);
				Com_Printf("\n");
			}
		}
		return;
	}

	groupname = Cmd_Argv(1);

	if (c == 2 && !strcasecmp(groupname, "clear")) {	
		for (node = FIRSTUSERGROUP; node; node = tempnode) {
			tempnode = node->next;
			DeleteMapGroup(node);
		}
		return;
	}

	if (Util_Is_Valid_Filename(groupname) == false) {
		Com_Printf("Error: %s is not a valid map group name\n", groupname);
		return;
	}

	group = GetGroupWithName(groupname);

	if (c == 2) {	
		if (!group) {
			Com_Printf("No map group named \"%s\"\n", groupname);
		} else {
			Com_Printf("\x02%s: ", groupname);
			for (j = 0; j < group->nummembers; j++)
				Com_Printf("%s ", group->members[j]);
			Com_Printf("\n");
		}
		return;
	}

	if (group && group->system) {
		Com_Printf("Cannot modify system group \"%s\"\n", groupname);
		return;
	}

	if (c == 3 && !strcasecmp(Cmd_Argv(2), "clear")) {	
		if (!group)
			Com_Printf("\"%s\" is not a map group name\n", groupname);
		else
			DeleteMapGroup(group);
		return;
	}

	if (!group) {	
		group = (mapgroup_t *) Q_calloc(1, sizeof(mapgroup_t));
		strlcpy(group->groupname, groupname, sizeof(group->groupname));
		group->system = !mapgroups_init;
		if (mapgroups) {	
			for (tempnode = mapgroups; tempnode->next; tempnode = tempnode->next)
				;
			tempnode->next = group;
			group->prev = tempnode;
		} else {
			mapgroups = group;
		}
	} else {		
		member = Cmd_Argv(2);
		if (member[0] != '+' && member[0] != '-')
			ResetGroupMembers(group);
	}

	for (i = 2; i < c; i++) {
		member = Cmd_Argv(i);
		if (member[0] == '+') {
			removeflag = false;
			member++;
		} else if (member[0] == '-') {
			removeflag = true;
			member++;
		}

		if (!removeflag && (tempnode = GetGroupWithMember(member)) && tempnode != group) {
			if (cl_warncmd.integer || developer.integer)
				Com_Printf("Warning: \"%s\" is already a member of group \"%s\"...ignoring\n", member, tempnode->groupname);
			continue;
		}

		if (removeflag)
			DeleteGroupMember(group, member);
		else
			AddGroupMember(group, member);
	}

	if (!group->nummembers)	
		DeleteMapGroup(group);
}

void MT_AddMapGroups(void) {
	char exmy_group[256] = {0}, exmy_map[6] = {'e', 0, 'm', 0, ' ', 0};
	int i, j;
	mapgroup_t *tempnode;

	strlcat (exmy_group, "mapgroup exmy start ", sizeof (exmy_group));
	for (i = 1; i <= 4; i++) {
		for (j = 1; j <= 8; j++) {		
			exmy_map[1] = i + '0';
			exmy_map[3] = j + '0';
			strlcat(exmy_group, exmy_map, sizeof (exmy_group));
		}
	}
	Cmd_TokenizeString(exmy_group);
	MT_MapGroup_f();
	for (tempnode = mapgroups; tempnode->next; tempnode = tempnode->next)
		;
	last_system_mapgroup = tempnode;
	mapgroups_init = true;
}

char *MT_GetMapGroupName(char *mapname, qbool *system) {
	mapgroup_t *group;

	group = GetGroupWithMember(mapname);
	if (group && strcmp(mapname, group->groupname)) {
		if (system)
			*system = group->system;
		return group->groupname;
	} else {
		return NULL;
	}
}

void DumpMapGroups(FILE *f) {
	mapgroup_t *node;
	int j;

	if (!FIRSTUSERGROUP) {
		fprintf(f, "mapgroup clear\n");
		return;
	}
	for (node = FIRSTUSERGROUP; node; node = node->next) {
		fprintf(f, "mapgroup %s ", node->groupname);
		for (j = 0; j < node->nummembers; j++)
			fprintf(f, "%s ", node->members[j]);
		fprintf(f, "\n");
	}
}

char *Macro_MatchType(void) {
	matchinfo_t *matchinfo;

	if (cls.state < ca_active)
		return "No match in progress";

	matchinfo = MT_GetMatchInfo();

	return matchcvars[matchinfo->matchtype].nickname;
}

void MT_Init(void)
{
	char tmp_path[MAX_OSPATH] = {0};

	snprintf(&tmp_path[0], sizeof(tmp_path), "%s/ezquake/temp", com_basedir);
	Sys_mkdir(tmp_path);

	MT_ClearClientState();

	Cmd_AddMacro(macro_matchname, Macro_MatchName);
	Cmd_AddMacro(macro_matchtype, Macro_MatchType);

	Cmd_AddCommand("match_format_macrolist", MT_Macrolist_f);
	Cmd_AddCommand("match_forcestart", MT_Match_ForceStart_f);
	Cmd_AddCommand("match_save", MT_SaveMatch_f);

	Cvar_SetCurrentGroup(CVAR_GROUP_MATCH_TOOLS);

	Cvar_Register(&match_format_solo);
	Cvar_Register(&match_format_coop);
	Cvar_Register(&match_format_race);
	Cvar_Register(&match_format_duel);
	Cvar_Register(&match_format_ffa);
	Cvar_Register(&match_format_2on2);
	Cvar_Register(&match_format_3on3);
	Cvar_Register(&match_format_4on4);
	Cvar_Register(&match_format_tdm);
	Cvar_Register(&match_format_multiteam);
	Cvar_Register(&match_format_arena);
	Cvar_Register(&match_format_tf_duel);
	Cvar_Register(&match_format_tf_clanwar);

	Cvar_Register(&match_name_and);
	Cvar_Register(&match_name_versus);
	Cvar_Register(&match_name_on);

	Cvar_Register(&match_name_nick);
	Cvar_Register(&match_name_spec);

	Cvar_Register(&match_auto_record);
	Cvar_Register(&match_auto_logconsole);
	Cvar_Register(&match_auto_sshot);
	Cvar_Register(&match_auto_minlength);
	Cvar_Register(&match_auto_spectating);
	Cvar_Register(&match_auto_unminimize);

	Cvar_ResetCurrentGroup();

	MT_Challenge_InitCvars();
}

void MT_Shutdown(void)
{
	mapgroup_t* group = mapgroups;

	while (group) {
		mapgroup_t* next = group->next;
		Q_free(group);
		group = next;
	}
}


================================================
FILE: src/match_tools_challenge.c
================================================
/*
Copyright (C) 2002-2003       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "teamplay.h"
#include "utils.h"
#include <curl/curl.h>
#include "sha1.h"
#include <time.h>
#include "logging.h"

char* MT_PlayerName(void);
char* MT_PlayerTeam(void);
char* MT_EnemyName(void);
int MT_CountPlayers(void);
char* MT_TempDirectory(void);

static qbool temp_log_upload_pending = false;

void MT_ChallengeMode_Change(cvar_t *cvar, char *value, qbool *cancel)
{
	if (cls.state != ca_disconnected && !cl.standby && !cl.spectator) {
		*cancel = true;
		Com_Printf("Challenge mode cannot be toggled during the match\n");
		return;
	}
}

static cvar_t match_auto_logupload       = { "match_auto_logupload", "0" };
static cvar_t match_auto_logupload_token = { "match_auto_logupload_token", "", 0, MT_ChallengeMode_Change };
static cvar_t match_auto_logurl          = { "match_auto_logurl", "http://stats.quakeworld.nu/logupload" };
static cvar_t match_challenge            = { "match_challenge", "0", 0, MT_ChallengeMode_Change };
static cvar_t match_challenge_url        = { "match_challenge_url", "http://stats.quakeworld.nu/post-challenge", 0, MT_ChallengeMode_Change };
static cvar_t match_ladder_id            = { "match_ladder_id", "1" };

typedef enum challenge_status_e {
	challenge_start,
	challenge_end
} challenge_status_e;

typedef struct challenge_data_s {
	challenge_status_e status;
	char *ladderid;
	int players_count;
	char *token;
	char *player1;
	char *player2;
	char *server;
	char *map;
	char *url;
	char *hash;
} challenge_data_t;

static challenge_data_t *last_challenge = NULL;

qbool MT_Challenge_IsOn(void)
{
	return last_challenge != NULL;
}

const char *MT_Challenge_GetLadderId(void)
{
	if (last_challenge == NULL) {
		return "";
	}

	return last_challenge->ladderid;
}

const char *MT_Challenge_GetHash(void)
{
	if (last_challenge == NULL) {
		return "";
	}

	return last_challenge->hash;
}

const char *MT_Challenge_GetToken(void)
{
	if (last_challenge == NULL) {
		return "";
	}

	return last_challenge->token;
}

const char* MT_Challenge_StatusName(challenge_status_e status)
{
	switch (status) {
		case challenge_start: return "start";
		case challenge_end: return "end";
		default:
			Com_Printf("ERROR: MT_Challenge_StatusName: Unknown challenge status");
			return "";
	}
}

size_t MT_Curl_Write_Void(void *ptr, size_t size, size_t nmemb, void *userdata)
{
	return size * nmemb;
}

static const char *MT_Challenge_GenerateHash(void)
{
	static unsigned char hash[DIGEST_SIZE];
	SHA1_CTX context;
	char* hostname = Info_ValueForKey(cl.serverinfo, "hostname");
	double curtime = Sys_DoubleTime();

	SHA1Init(&context);

	SHA1Update(&context, (unsigned char *)match_ladder_id.string, strlen(match_ladder_id.string));
	SHA1Update(&context, (unsigned char *)match_auto_logupload_token.string, strlen(match_auto_logupload_token.string));
	SHA1Update(&context, (unsigned char *)MT_PlayerName(), strlen(MT_PlayerName()));
	SHA1Update(&context, (unsigned char *)MT_EnemyName(), strlen(MT_EnemyName()));
	SHA1Update(&context, (unsigned char *)hostname, strlen(hostname));
	SHA1Update(&context, (unsigned char *)host_mapname.string, strlen(host_mapname.string));
	SHA1Update(&context, (unsigned char *)match_challenge_url.string, strlen(match_challenge_url.string));
	SHA1Update(&context, (unsigned char *)&curtime, sizeof(double));

	SHA1Final(hash, &context);

	return bin2hex(hash);
}

challenge_data_t *MT_Challenge_Create(challenge_status_e status, int players_count,
	const char *ladderid, const char *token, const char *player1, const char *player2,
	const char *server, const char *map, const char *url, const char *hash)
{
	challenge_data_t *retval = (challenge_data_t *)Q_malloc(sizeof(challenge_data_t));
	retval->status = status;
	retval->players_count = players_count;
	retval->ladderid = Q_strdup(ladderid);
	retval->token = Q_strdup(token);
	retval->player1 = Q_strdup(player1);
	retval->player2 = Q_strdup(player2);
	retval->server = Q_strdup(server);
	retval->map = Q_strdup(map);
	retval->url = Q_strdup(url);
	retval->hash = Q_strdup(hash);

	return retval;
}

void MT_Challenge_Destroy(challenge_data_t *challenge)
{
	Q_free(challenge->ladderid);
	Q_free(challenge->token);
	Q_free(challenge->player1);
	Q_free(challenge->player2);
	Q_free(challenge->server);
	Q_free(challenge->map);
	Q_free(challenge->url);
	Q_free(challenge->hash);
	Q_free(challenge);
}

challenge_data_t *MT_Challenge_Init(challenge_status_e status)
{
	return MT_Challenge_Create(status, MT_CountPlayers(), match_ladder_id.string, match_auto_logupload_token.string,
		MT_PlayerName(), MT_EnemyName(), Info_ValueForKey(cl.serverinfo, "hostname"), host_mapname.string,
		match_challenge_url.string, MT_Challenge_GenerateHash());
}

challenge_data_t *MT_Challenge_Copy(const challenge_data_t *orig)
{
	return MT_Challenge_Create(orig->status, orig->players_count, orig->ladderid, orig->token, orig->player1, orig->player2,
		orig->server, orig->map, orig->url, orig->hash);
}

int MT_Challenge_StartSend_Thread(void *arg)
{
	challenge_data_t *challenge_data = (challenge_data_t *)arg;

	CURL *curl;
	CURLcode res;
	struct curl_httppost *post = NULL;
	struct curl_httppost *last = NULL;
	struct curl_slist *headers = NULL;
	char errorbuffer[CURL_ERROR_SIZE] = "";

	curl = curl_easy_init();

	headers = curl_slist_append(headers, "Content-Type: text/plain");

	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "status",
		CURLFORM_COPYCONTENTS, MT_Challenge_StatusName(challenge_data->status),
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "ladderid",
		CURLFORM_COPYCONTENTS, challenge_data->ladderid,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "hash",
		CURLFORM_COPYCONTENTS, challenge_data->hash,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "token",
		CURLFORM_COPYCONTENTS, challenge_data->token,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "players_count",
		CURLFORM_COPYCONTENTS, va("%d", challenge_data->players_count),
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "player1",
		CURLFORM_COPYCONTENTS, challenge_data->player1,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "player2",
		CURLFORM_COPYCONTENTS, challenge_data->player2,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "server",
		CURLFORM_COPYCONTENTS, challenge_data->server,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "map",
		CURLFORM_COPYCONTENTS, challenge_data->map,
		CURLFORM_END);

	curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
	curl_easy_setopt(curl, CURLOPT_URL, challenge_data->url);
	curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorbuffer);
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, MT_Curl_Write_Void);

	res = curl_easy_perform(curl); /* post away! */

	curl_formfree(post);
	curl_easy_cleanup(curl);

	if (res != CURLE_OK) {
		Com_Printf("Challenge announcement upload failed:\n%s\n", curl_easy_strerror(res));
		Com_Printf("%s\n", errorbuffer);
	}
	else {
		Com_Printf("Challenge %s announced\n", MT_Challenge_StatusName(challenge_data->status));
	}

	MT_Challenge_Destroy(challenge_data);

	return 0;
}

static void MT_Challenge_BreakSend(void)
{
	challenge_data_t *thread_data;

	if (last_challenge != NULL) {
		// normal situation - reuse the challenge we announced on start
		thread_data = MT_Challenge_Copy(last_challenge);
		thread_data->status = challenge_end;
		thread_data->players_count = MT_CountPlayers();

		MT_Challenge_Destroy(last_challenge);
		last_challenge = NULL;
	}
	else {
		// weird situation, we didn't send the start of the challenge (perhaps late-join of the match)
		// but we now want to send the break of the challenge.. we will do our best-effort here
		// - simply generate new challenge and say we break it; it is up to the challenge server
		// what it will do with this message
		thread_data = MT_Challenge_Init(challenge_end);
	}

	if (Sys_CreateDetachedThread(MT_Challenge_StartSend_Thread, thread_data) < 0) {
		Com_Printf("Failed to create MT Challenge BreakSend thread\n");
	}
}

static void MT_Challenge_StartSend(void)
{
	challenge_data_t *thread_data;

	last_challenge = MT_Challenge_Init(challenge_start);

	thread_data = MT_Challenge_Copy(last_challenge);

	if (Sys_CreateDetachedThread(MT_Challenge_StartSend_Thread, thread_data) < 0) {
		Com_Printf("Failed to create MT Challenge StartSend thread\n");
	}
}

void MT_Challenge_Cancel(void)
{
	if (match_challenge.integer) {
		MT_Challenge_BreakSend();
	}
}

void MT_Challenge_StartMatch(void)
{
	if (last_challenge != NULL) {
		MT_Challenge_Destroy(last_challenge);
		last_challenge = NULL;
	}

	if (match_challenge.integer) {
		Cbuf_AddText("play items/protect.wav\n");
		Cbuf_AddText("say Challenge mode: on\n");
		MT_Challenge_StartSend();
	}
}

void MT_Challenge_InitCvars(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_MATCH_TOOLS);
	Cvar_Register(&match_auto_logupload);
	Cvar_Register(&match_auto_logurl);
	Cvar_Register(&match_auto_logupload_token);
	Cvar_Register(&match_challenge);
	Cvar_Register(&match_challenge_url);
	Cvar_Register(&match_ladder_id);
	Cvar_ResetCurrentGroup();
}

qbool MT_Challenge_Log_IsUploadAllowed(void)
{
	extern cvar_t match_auto_logconsole;

	return (match_challenge.integer || (match_auto_logupload.integer && match_auto_logconsole.integer))
		&& !cls.demoplayback
		&& cls.server_adr.type != NA_LOOPBACK;
}

typedef struct log_upload_job_s {
	qbool challenge_mode;
	char *challenge_hash;
	char *player_name;
	char *token;
	char *hostname;
	char *filename;
	char *url;
	char *mapname;
	char *ladderid;
} log_upload_job_t;

static log_upload_job_t* Log_Upload_Job_Prepare(qbool challenge_mode, const char *challenge_hash,
	const char *filename, const char *hostname,
	const char* player_name, const char *token, const char *url,
	const char *mapname, const char *ladderid)
{
	log_upload_job_t *job = (log_upload_job_t *)Q_malloc(sizeof(log_upload_job_t));

	job->challenge_mode = challenge_mode;
	job->challenge_hash = Q_strdup(challenge_hash);
	job->filename = Q_strdup(filename);
	job->hostname = Q_strdup(hostname);
	job->player_name = Q_strdup(player_name);
	job->token = Q_strdup(token);
	job->url = Q_strdup(url);
	job->mapname = Q_strdup(mapname);
	job->ladderid = Q_strdup(ladderid);

	return job;
}

static void Log_Upload_Job_Free(log_upload_job_t *job)
{
	Q_free(job->filename);
	Q_free(job->hostname);
	Q_free(job->challenge_hash);
	Q_free(job->player_name);
	Q_free(job->token);
	Q_free(job->url);
	Q_free(job->mapname);
	Q_free(job);
}

static size_t Log_Curl_Write_Void(void *ptr, size_t size, size_t nmemb, void *userdata)
{
	return size * nmemb;
}

int Log_AutoLogging_Upload_Thread(void *vjob)
{
	log_upload_job_t *job = (log_upload_job_t *)vjob;
	CURL *curl;
	CURLcode res;
	struct curl_httppost *post = NULL;
	struct curl_httppost *last = NULL;
	struct curl_slist *headers = NULL;
	char errorbuffer[CURL_ERROR_SIZE] = "";

	curl = curl_easy_init();

	headers = curl_slist_append(headers, "Content-Type: text/plain");

	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "name",
		CURLFORM_COPYCONTENTS, job->player_name,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "challenge",
		CURLFORM_COPYCONTENTS, job->challenge_mode ? "1" : "0",
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "challenge_hash",
		CURLFORM_COPYCONTENTS, job->challenge_hash,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "token",
		CURLFORM_COPYCONTENTS, job->token,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "host",
		CURLFORM_COPYCONTENTS, job->hostname,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "map",
		CURLFORM_COPYCONTENTS, job->mapname,
		CURLFORM_END);
	curl_formadd(&post, &last,
		CURLFORM_COPYNAME, "log",
		CURLFORM_FILE, job->filename,
		CURLFORM_CONTENTHEADER, headers,
		CURLFORM_END);

	curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
	curl_easy_setopt(curl, CURLOPT_URL, job->url);
	curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorbuffer);
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, Log_Curl_Write_Void);

	res = curl_easy_perform(curl); /* post away! */

	curl_formfree(post);
	curl_easy_cleanup(curl);

	if (res != CURLE_OK) {
		Com_Printf("Uploading of log failed:\n%s\n", curl_easy_strerror(res));
		Com_Printf("%s\n", errorbuffer);
	}
	else {
		Com_Printf("Match log uploaded\n");
	}

	Log_Upload_Job_Free(job);
	temp_log_upload_pending = false;
	return 0;
}

void Log_AutoLogging_Upload(const char *filename)
{
	log_upload_job_t *job = Log_Upload_Job_Prepare(
		MT_Challenge_IsOn(),
		MT_Challenge_GetHash(),
		filename,
		Info_ValueForKey(cl.serverinfo, "hostname"),
		cl.players[cl.playernum].name,
		MT_Challenge_GetToken(),
		match_auto_logurl.string,
		host_mapname.string,
		MT_Challenge_GetLadderId());

	Com_Printf("Uploading match log...\n");
	if (Sys_CreateDetachedThread(Log_AutoLogging_Upload_Thread, (void *)job) < 0) {
		Com_Printf("Failed to create AutoLogging_Upload thread\n");
	}
}

qbool Log_TempLogUploadPending(void)
{
	return temp_log_upload_pending;
}

void Log_UploadTemp(void)
{
	char *tempname = va("%s/%s", MT_TempDirectory(), TEMP_LOG_NAME);
	temp_log_upload_pending = true;
	Log_AutoLogging_Upload(tempname);
}

void CL_QWURL_ProcessChallenge(const char *parameters)
{
	extern cvar_t match_auto_logupload_token;
	extern cvar_t match_challenge;

	// parameters is expected to be of the format "?token=<string>&otherparam=<string>&..."
	char info_buf[1024];
	char *wp = info_buf;
	const char *rp = parameters;
	size_t write_len = 0;
	ctxinfo_t ctx;
	char *token;
	memset(&ctx, 0, sizeof(ctxinfo_t));
	ctx.max = 20;

	while (*rp && write_len < 1022) {
		char c = *rp++;
		if (c == '?') {
			c = '\\';
		}
		else if (c == '&') {
			c = '\\';
		}
		else if (c == '=') {
			c = '\\';
		}

		*wp++ = c;
		write_len++;
	}

	*wp++ = '\0';

	Info_Convert(&ctx, info_buf);

	token = Info_Get(&ctx, "token");

	Info_RemoveAll(&ctx);

	if (*token) {
		Cvar_Set(&match_auto_logupload_token, token);
		Cvar_Set(&match_challenge, "1");
		Com_Printf("Joining challenge ...\n");
	}
	else {
		Com_Printf("Challenge token not found in the URL\n");
	}
}

qbool MT_ChallengeSpecified(void)
{
	extern cvar_t match_challenge;

	return match_challenge.integer != 0;
}


================================================
FILE: src/mathlib.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


*/
// mathlib.c -- math primitives

#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "common.h"
#endif

vec3_t vec3_origin = { 0, 0, 0 };

int  _mathlib_temp_int1, _mathlib_temp_int2, _mathlib_temp_int3;
float _mathlib_temp_float1, _mathlib_temp_float2, _mathlib_temp_float3;
vec3_t _mathlib_temp_vec1, _mathlib_temp_vec2, _mathlib_temp_vec3;

void ProjectPointOnPlane(vec3_t dst, const vec3_t p, const vec3_t normal) {
	float d, inv_denom;
	vec3_t n;

	inv_denom = 1.0F / DotProduct(normal, normal);

	d = DotProduct(normal, p) * inv_denom;

	VectorScale(normal, inv_denom, n);
	VectorMA(p, -d, n, dst);
}

void PerpendicularVector(vec3_t dst, const vec3_t src) {
	if (!src[0]) {
		VectorSet(dst, 1, 0, 0);
	}
	else if (!src[1]) {
		VectorSet(dst, 0, 1, 0);
	}
	else if (!src[2]) {
		VectorSet(dst, 0, 0, 1);
	}
	else {
		VectorSet(dst, -src[1], src[0], 0);
		VectorNormalizeFast(dst);
	}
}

void VectorVectors(vec3_t forward, vec3_t right, vec3_t up) {
	PerpendicularVector(right, forward);
	CrossProduct(right, forward, up);
}

void MakeNormalVectors (/* in */ vec3_t forward, /* out */ vec3_t right, vec3_t up)
{
	float d;

	// this rotate and negate guarantees a vector
	// not colinear with the original
	right[1] = -forward[0];
	right[2] = forward[1];
	right[0] = forward[2];

	d = DotProduct (right, forward);
	VectorMA (right, -d, forward, right);
	VectorNormalize (right);
	CrossProduct (right, forward, up);
}

void RotatePointAroundVector(vec3_t dst, const vec3_t dir, const vec3_t point, float degrees) {
	float t0, t1, angle, c, s;
	vec3_t vr, vu, vf;

	angle = DEG2RAD(degrees);
	c = cos(angle);
	s = sin(angle);
	VectorCopy(dir, vf);
	VectorVectors(vf, vr, vu);

	t0 = vr[0] *  c + vu[0] * -s;
	t1 = vr[0] *  s + vu[0] *  c;
	dst[0] = (t0 * vr[0] + t1 * vu[0] + vf[0] * vf[0]) * point[0]
		+ (t0 * vr[1] + t1 * vu[1] + vf[0] * vf[1]) * point[1]
		+ (t0 * vr[2] + t1 * vu[2] + vf[0] * vf[2]) * point[2];

	t0 = vr[1] *  c + vu[1] * -s;
	t1 = vr[1] *  s + vu[1] *  c;
	dst[1] = (t0 * vr[0] + t1 * vu[0] + vf[1] * vf[0]) * point[0]
		+ (t0 * vr[1] + t1 * vu[1] + vf[1] * vf[1]) * point[1]
		+ (t0 * vr[2] + t1 * vu[2] + vf[1] * vf[2]) * point[2];

	t0 = vr[2] *  c + vu[2] * -s;
	t1 = vr[2] *  s + vu[2] *  c;
	dst[2] = (t0 * vr[0] + t1 * vu[0] + vf[2] * vf[0]) * point[0]
		+ (t0 * vr[1] + t1 * vu[1] + vf[2] * vf[1]) * point[1]
		+ (t0 * vr[2] + t1 * vu[2] + vf[2] * vf[2]) * point[2];
}

void BOPS_Error (void)
{
	Sys_Error ("BoxOnPlaneSide:  Bad signbits");
}

//Returns 1, 2, or 1 + 2
int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct mplane_s *p) {
	//the following optimisation is performed by BOX_ON_PLANE_SIDE macro
	//if (p->type < 3)
	//	return ((emaxs[p->type] >= p->dist) | ((emins[p->type] < p->dist) << 1));
	switch(p->signbits) {
	default:
	case 0:
		return  (((p->normal[0] * emaxs[0] + p->normal[1] * emaxs[1] + p->normal[2] * emaxs[2]) >= p->dist) |
		        (((p->normal[0] * emins[0] + p->normal[1] * emins[1] + p->normal[2] * emins[2]) < p->dist) << 1));
	case 1:
		return  (((p->normal[0] * emins[0] + p->normal[1] * emaxs[1] + p->normal[2] * emaxs[2]) >= p->dist) |
		        (((p->normal[0] * emaxs[0] + p->normal[1] * emins[1] + p->normal[2] * emins[2]) < p->dist) << 1));
	case 2:
		return  (((p->normal[0] * emaxs[0] + p->normal[1] * emins[1] + p->normal[2] * emaxs[2]) >= p->dist) |
		        (((p->normal[0] * emins[0] + p->normal[1] * emaxs[1] + p->normal[2] * emins[2]) < p->dist) << 1));
	case 3:
		return  (((p->normal[0] * emins[0] + p->normal[1] * emins[1] + p->normal[2] * emaxs[2]) >= p->dist) |
		        (((p->normal[0] * emaxs[0] + p->normal[1] * emaxs[1] + p->normal[2] * emins[2]) < p->dist) << 1));
	case 4:
		return  (((p->normal[0] * emaxs[0] + p->normal[1] * emaxs[1] + p->normal[2] * emins[2]) >= p->dist) |
		        (((p->normal[0] * emins[0] + p->normal[1] * emins[1] + p->normal[2] * emaxs[2]) < p->dist) << 1));
	case 5:
		return  (((p->normal[0] * emins[0] + p->normal[1] * emaxs[1] + p->normal[2] * emins[2]) >= p->dist) |
		        (((p->normal[0] * emaxs[0] + p->normal[1] * emins[1] + p->normal[2] * emaxs[2]) < p->dist) << 1));
	case 6:
		return  (((p->normal[0] * emaxs[0] + p->normal[1] * emins[1] + p->normal[2] * emins[2]) >= p->dist) |
		        (((p->normal[0] * emins[0] + p->normal[1] * emaxs[1] + p->normal[2] * emaxs[2]) < p->dist) << 1));
	case 7:
		return  (((p->normal[0] * emins[0] + p->normal[1] * emins[1] + p->normal[2] * emins[2]) >= p->dist) |
		        (((p->normal[0] * emaxs[0] + p->normal[1] * emaxs[1] + p->normal[2] * emaxs[2]) < p->dist) << 1));
	}
}

void AngleVectors (vec3_t angles, vec3_t forward, vec3_t right, vec3_t up)
{
	float angle, sr, sp, sy, cr, cp, cy, temp;

	if (angles[YAW]) {
		angle = DEG2RAD(angles[YAW]);
		sy = sin(angle);
		cy = cos(angle);
	} else {
		sy = 0;
		cy = 1;
	}

	if (angles[PITCH]) {
		angle = DEG2RAD(angles[PITCH]);
		sp = sin(angle);
		cp = cos(angle);
	} else {
		sp = 0;
		cp = 1;
	}

	if (forward) {
		forward[0] = cp * cy;
		forward[1] = cp * sy;
		forward[2] = -sp;
	}

	if (right || up) {
		if (angles[ROLL]) {
			angle = DEG2RAD(angles[ROLL]);
			sr = sin(angle);
			cr = cos(angle);

			if (right) {
				temp = sr * sp;
				right[0] = -1 * temp * cy + cr * sy;
				right[1] = -1 * temp * sy - cr * cy;
				right[2] = -1 * sr * cp;
			}

			if (up) {
				temp = cr * sp;
				up[0] = (temp * cy + sr * sy);
				up[1] = (temp * sy - sr * cy);
				up[2] = cr * cp;
			}
		}
		else {
			if (right) {
				right[0] = sy;
				right[1] = -cy;
				right[2] = 0;
			}

			if (up) {
				up[0] = sp * cy ;
				up[1] = sp * sy;
				up[2] = cp;
			}
		}
	}
}

//VULT COLLISION
void AngleVectorsFLU (const vec3_t angles, vec3_t forward, vec3_t left, vec3_t up)
{
	double angle, sr, sp, sy, cr, cp, cy;

	angle = angles[YAW] * (M_PI*2 / 360);
	sy = sin(angle);
	cy = cos(angle);
	angle = angles[PITCH] * (M_PI*2 / 360);
	sp = sin(angle);
	cp = cos(angle);
	if (forward)
	{
		forward[0] = cp*cy;
		forward[1] = cp*sy;
		forward[2] = -sp;
	}
	if (left || up)
	{
		angle = angles[ROLL] * (M_PI*2 / 360);
		sr = sin(angle);
		cr = cos(angle);
		if (left)
		{
			left[0] = sr*sp*cy+cr*-sy;
			left[1] = sr*sp*sy+cr*cy;
			left[2] = sr*cp;
		}
		if (up)
		{
			up[0] = cr*sp*cy+-sr*-sy;
			up[1] = cr*sp*sy+-sr*cy;
			up[2] = cr*cp;
		}
	}
}

vec_t VectorLength (vec3_t v) {
	float length;

	length = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
	return sqrt(length);
}

float VectorNormalize (vec3_t v) {
	float length;

	length = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
	length = sqrt (length);

	if (length) {
		VectorScale(v, 1 / length, v);
	}

	return length;
}

void R_ConcatRotations (float in1[3][3], float in2[3][3], float out[3][3]) {
	out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +	in1[0][2] * in2[2][0];
	out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +	in1[0][2] * in2[2][1];
	out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +	in1[0][2] * in2[2][2];
	out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +	in1[1][2] * in2[2][0];
	out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +	in1[1][2] * in2[2][1];
	out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +	in1[1][2] * in2[2][2];
	out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +	in1[2][2] * in2[2][0];
	out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +	in1[2][2] * in2[2][1];
	out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +	in1[2][2] * in2[2][2];
}

void R_ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4]) {
	out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +	in1[0][2] * in2[2][0];
	out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +	in1[0][2] * in2[2][1];
	out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +	in1[0][2] * in2[2][2];
	out[0][3] = in1[0][0] * in2[0][3] + in1[0][1] * in2[1][3] +	in1[0][2] * in2[2][3] + in1[0][3];
	out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +	in1[1][2] * in2[2][0];
	out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +	in1[1][2] * in2[2][1];
	out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +	in1[1][2] * in2[2][2];
	out[1][3] = in1[1][0] * in2[0][3] + in1[1][1] * in2[1][3] +	in1[1][2] * in2[2][3] + in1[1][3];
	out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +	in1[2][2] * in2[2][0];
	out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +	in1[2][2] * in2[2][1];
	out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +	in1[2][2] * in2[2][2];
	out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] +	in1[2][2] * in2[2][3] + in1[2][3];
}

//Returns mathematically correct (floor-based) quotient and remainder for numer and denom, both of
//which should contain no fractional part. The quotient must fit in 32 bits.
void FloorDivMod (double numer, double denom, int *quotient, int *rem)
{
	int q, r;
	double x;

#ifndef PARANOID
	if (denom <= 0.0) {
		Sys_Error("FloorDivMod: bad denominator %d", denom);
	}
#endif

	if (numer >= 0.0) {
		x = floor(numer / denom);
		q = (int) x;
		r = (int) floor(numer - (x * denom));
	}
	else {
		// perform operations with positive values, and fix mod to make floor-based
		x = floor(-numer / denom);
		q = -(int)x;
		r = (int)floor(-numer - (x * denom));
		if (r != 0) {
			q--;
			r = (int)denom - r;
		}
	}
	*quotient = q;
	*rem = r;
}

int GreatestCommonDivisor (int i1, int i2)
{
	if (i1 > i2) {
		if (i2 == 0)
			return (i1);
		return GreatestCommonDivisor (i2, i1 % i2);
	}
	else {
		if (i1 == 0)
			return (i2);
		return GreatestCommonDivisor (i1, i2 % i1);
	}
}

//
// From: http://www.cse.ucsc.edu/~pang/160/f98/Gems/GemsIV/centroid.c
// polyCentroid: Calculates the centroid (xCentroid, yCentroid) and area
// of a polygon, given its vertices (x[0], y[0]) ... (x[n-1], y[n-1]). It
// is assumed that the contour is closed, i.e., that the vertex following
// (x[n-1], y[n-1]) is (x[0], y[0]).  The algebraic sign of the area is
// positive for counterclockwise ordering of vertices in x-y plane;
// otherwise negative.
//
// Returned values:  0 for normal execution;  1 if the polygon is
// degenerate (number of vertices < 3);  and 2 if area = 0 (and the centroid is undefined).
int GetPolyCentroid(vec3_t *v, int n, float *xCentroid, float *yCentroid, float *area)
{
	register int i, j;
	float ai, atmp = 0, xtmp = 0, ytmp = 0;

	if (n < 3)
	{
		return 1;
	}

	for (i = n - 1, j = 0; j < n; i = j, j++)
	{
		ai = v[i][0] * v[j][1] - v[j][0] * v[i][1];
		atmp += ai;
		xtmp += (v[j][0] + v[i][0]) * ai;
		ytmp += (v[j][1] + v[i][1]) * ai;
	}

	*area = atmp / 2;

	if (atmp != 0)
	{
		*xCentroid =	xtmp / (3 * atmp);
		*yCentroid =	ytmp / (3 * atmp);
		return 0;
	}
	return 2;
}

//Inverts an 8.24 value to a 16.16 value
fixed16_t Invert24To16(fixed16_t val)
{
	if (val < 256) {
		return (0xFFFFFFFF);
	}

	return (fixed16_t) (((double) 0x10000 * (double) 0x1000000 / (double) val) + 0.5);
}

/*
Init rotation matrix 'out', 'angle' in radians, 'v' should be normilized vector.
*/
void Matrix3x3_CreateRotate (matrix3x3_t out, float angle, const vec3_t v)
{
	float c = cos(angle);
	float s = sin(angle);

	out[0][0] = v[0] * v[0] + c * (1 - v[0] * v[0]);
	out[1][0] = v[0] * v[1] * (1 - c) + v[2] * s;
	out[2][0] = v[2] * v[0] * (1 - c) - v[1] * s;

	out[0][1] = v[0] * v[1] * (1 - c) - v[2] * s;
	out[1][1] = v[1] * v[1] + c * (1 - v[1] * v[1]);
	out[2][1] = v[1] * v[2] * (1 - c) + v[0] * s;

	out[0][2] = v[2] * v[0] * (1 - c) + v[1] * s;
	out[1][2] = v[1] * v[2] * (1 - c) - v[0] * s;
	out[2][2] = v[2] * v[2] + c * (1 - v[2] * v[2]);
}

/*
Multiply matrix 'in' by vector 'v', note what 'out' is vector.
*/
void Matrix3x3_MultiplyByVector (vec3_t out, const matrix3x3_t in, const vec3_t v)
{
	out[0] = in[0][0] * v[0] + in[0][1] * v[1] + in[0][2] * v[2];
	out[1] = in[1][0] * v[0] + in[1][1] * v[1] + in[1][2] * v[2];
	out[2] = in[2][0] * v[0] + in[2][1] * v[1] + in[2][2] * v[2];
}

float VectorDistance(const vec3_t x, const vec3_t y)
{
	vec3_t diff = { x[0] - y[0], x[1] - y[1], x[2] - y[2] };

	return VectorLength(diff);
}

float VectorDistanceQuick(const vec3_t x, const vec3_t y)
{
	vec3_t diff = { x[0] - y[0], x[1] - y[1], x[2] - y[2] };

	return diff[0] * diff[0] + diff[1] * diff[1] + diff[2] * diff[2];
}


================================================
FILE: src/mathlib.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/
// mathlib.h
#ifndef __MATHLIB_H__
#define __MATHLIB_H__

#define	PITCH   0 // up / down
#define	YAW     1 // left / right
#define	ROLL    2 // fall over

typedef float vec_t;
typedef vec_t vec3_t[3];
typedef vec_t vec5_t[5];

typedef	int	fixed4_t;
typedef	int	fixed8_t;
typedef	int	fixed16_t;

typedef vec_t matrix3x3_t[3][3];

struct mplane_s;

#ifndef M_PI
#define M_PI 3.14159265358979323846  // matches value in gcc v2 math.h
#endif

#define DEG2RAD(a) (((a) * M_PI) / 180.0F)
#define RAD2DEG(a) (((a) * 180.0F) / M_PI)

#define NANMASK   (255<<23)
#define IS_NAN(x) (((*(int *)&x)&NANMASK)==NANMASK)

#ifndef Q_rint
#define Q_rint(x) ((x) > 0 ? (int)((x) + 0.5) : (int)((x) - 0.5))
#endif

#define DotProduct(x,y)         ((x)[0] * (y)[0] + (x)[1] * (y)[1] + (x)[2] * (y)[2])
#define VectorSubtract(a,b,c)   ((c)[0] = (a)[0] - (b)[0], (c)[1] = (a)[1] - (b)[1], (c)[2] = (a)[2] - (b)[2])
#define VectorAdd(a,b,c)        ((c)[0] = (a)[0] + (b)[0], (c)[1] = (a)[1] + (b)[1], (c)[2] = (a)[2] + (b)[2])
#define VectorCopy(a,b)         ((b)[0] = (a)[0], (b)[1] = (a)[1], (b)[2] = (a)[2])
#define VectorClear(a)          ((a)[0] = (a)[1] = (a)[2] = 0)
#define VectorNegate(a,b)       ((b)[0] = -(a)[0], (b)[1] = -(a)[1], (b)[2] = -(a)[2])
#define VectorSet(v, x, y, z)   ((v)[0] = (x), (v)[1] = (y), (v)[2] = (z))

#define CrossProduct(v1, v2, x)							\
	((x)[0] = (v1)[1] * (v2)[2] - (v1)[2] * (v2)[1],	\
	(x)[1] = (v1)[2] * (v2)[0] - (v1)[0] * (v2)[2],		\
	(x)[2] = (v1)[0] * (v2)[1] - (v1)[1] * (v2)[0])

#define VectorSupCompare(v, w, m)						\
	(_mathlib_temp_float1 = m,							\
	(v)[0] - (w)[0] > -_mathlib_temp_float1 && (v)[0] - (w)[0] < _mathlib_temp_float1 &&	\
	(v)[1] - (w)[1] > -_mathlib_temp_float1 && (v)[1] - (w)[1] < _mathlib_temp_float1 &&	\
	(v)[2] - (w)[2] > -_mathlib_temp_float1 && (v)[2] - (w)[2] < _mathlib_temp_float1)

#define VectorL2Compare(v, w, m)						\
	(_mathlib_temp_float1 = (m) * (m),						\
	_mathlib_temp_vec1[0] = (v)[0] - (w)[0], _mathlib_temp_vec1[1] = (v)[1] - (w)[1], _mathlib_temp_vec1[2] = (v)[2] - (w)[2],	\
	_mathlib_temp_vec1[0] * _mathlib_temp_vec1[0] +		\
	_mathlib_temp_vec1[1] * _mathlib_temp_vec1[1] +		\
	_mathlib_temp_vec1[2] * _mathlib_temp_vec1[2] < _mathlib_temp_float1)

#define VectorCompare(v, w)	((v)[0] == (w)[0] && (v)[1] == (w)[1] && (v)[2] == (w)[2])

#define VectorMA(a, _f, b, c)							\
do {													\
	_mathlib_temp_float1 = (_f);						\
	(c)[0] = (a)[0] + _mathlib_temp_float1 * (b)[0];	\
	(c)[1] = (a)[1] + _mathlib_temp_float1 * (b)[1];	\
	(c)[2] = (a)[2] + _mathlib_temp_float1 * (b)[2];	\
} while(0);

#define VectorScale(in, _scale, out)		\
do {										\
	float scale = (_scale);					\
	(out)[0] = (in)[0] * (scale); (out)[1] = (in)[1] * (scale); (out)[2] = (in)[2] * (scale);	\
} while (0);

#define anglemod(a)	((360.0 / 65536) * ((int) ((a) * (65536 / 360.0)) & 65535))

#define VectorNormalizeFast(_v)		\
do {								\
	_mathlib_temp_float1 = DotProduct((_v), (_v));						\
	if (_mathlib_temp_float1) {											\
		_mathlib_temp_float2 = 0.5f * _mathlib_temp_float1;				\
		_mathlib_temp_int1 = *((int *) &_mathlib_temp_float1);			\
		_mathlib_temp_int1 = 0x5f375a86 - (_mathlib_temp_int1 >> 1);	\
		_mathlib_temp_float1 = *((float *) &_mathlib_temp_int1);		\
		_mathlib_temp_float1 = _mathlib_temp_float1 * (1.5f - _mathlib_temp_float2 * _mathlib_temp_float1 * _mathlib_temp_float1);	\
		VectorScale((_v), _mathlib_temp_float1, (_v))					\
	}																	\
} while (0);

#define BOX_ON_PLANE_SIDE(emins, emaxs, p)		\
	(((p)->type < 3) ?							\
	(											\
		((p)->dist <= (emins)[(p)->type]) ?		\
			1									\
		:										\
		(										\
			((p)->dist >= (emaxs)[(p)->type]) ?	\
				2								\
			:									\
				3								\
		)										\
	)											\
	:											\
		BoxOnPlaneSide((emins), (emaxs), (p)))

#define VectorInterpolate(v1, _frac, v2, v)							\
do {																\
	_mathlib_temp_float1 = _frac;									\
																	\
	(v)[0] = (v1)[0] + _mathlib_temp_float1 * ((v2)[0] - (v1)[0]);	\
	(v)[1] = (v1)[1] + _mathlib_temp_float1 * ((v2)[1] - (v1)[1]);	\
	(v)[2] = (v1)[2] + _mathlib_temp_float1 * ((v2)[2] - (v1)[2]);	\
} while (0);

#define AngleInterpolate(v1, _frac, v2, v)									\
do {																		\
	_mathlib_temp_float1 = _frac;											\
	VectorSubtract((v2), (v1), _mathlib_temp_vec1);							\
																			\
	if (_mathlib_temp_vec1[0] > 180) _mathlib_temp_vec1[0] -= 360;			\
	else if (_mathlib_temp_vec1[0] < -180) _mathlib_temp_vec1[0] += 360;	\
	if (_mathlib_temp_vec1[1] > 180) _mathlib_temp_vec1[1] -= 360;			\
	else if (_mathlib_temp_vec1[1] < -180) _mathlib_temp_vec1[1] += 360;	\
	if (_mathlib_temp_vec1[2] > 180) _mathlib_temp_vec1[2] -= 360;			\
	else if (_mathlib_temp_vec1[2] < -180) _mathlib_temp_vec1[2] += 360;	\
																			\
	(v)[0] = (v1)[0] + _mathlib_temp_float1 * _mathlib_temp_vec1[0];		\
	(v)[1] = (v1)[1] + _mathlib_temp_float1 * _mathlib_temp_vec1[1];		\
	(v)[2] = (v1)[2] + _mathlib_temp_float1 * _mathlib_temp_vec1[2];		\
} while (0);

#define FloatInterpolate(f1, _frac, f2)			\
	(_mathlib_temp_float1 = _frac,				\
	(f1) + _mathlib_temp_float1 * ((f2) - (f1)))

#define PlaneDist(point, plane) (														\
	(plane)->type < 3 ? (point)[(plane)->type] : DotProduct((point), (plane)->normal)	\
)

#define PlaneDiff(point, plane) (																			\
	(((plane)->type < 3) ? (point)[(plane)->type] - (plane)->dist: DotProduct((point), (plane)->normal) - (plane)->dist) 	\
)

void VectorVectors(vec3_t forward, vec3_t right, vec3_t up);
void MakeNormalVectors (vec3_t forward, vec3_t right, vec3_t up);
vec_t VectorLength (vec3_t v);
float VectorNormalize (vec3_t v);		// returns vector length

void R_ConcatRotations (float in1[3][3], float in2[3][3], float out[3][3]);
void R_ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4]);

void FloorDivMod (double numer, double denom, int *quotient, int *rem);
fixed16_t Invert24To16(fixed16_t val);
int GreatestCommonDivisor (int i1, int i2);

void AngleVectors (vec3_t angles, vec3_t forward, vec3_t right, vec3_t up);
//VULT COLLISION
void AngleVectorsFLU (const vec3_t angles, vec3_t forward, vec3_t left, vec3_t up);
int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct mplane_s *plane);

void ProjectPointOnPlane(vec3_t dst, const vec3_t p, const vec3_t normal);
void PerpendicularVector(vec3_t dst, const vec3_t src);
void RotatePointAroundVector(vec3_t dst, const vec3_t dir, const vec3_t point, float degrees);

int GetPolyCentroid(vec3_t *v, int n, float *xCentroid, float *yCentroid, float *area);

extern vec3_t vec3_origin;
extern int _mathlib_temp_int1, _mathlib_temp_int2, _mathlib_temp_int3;
extern float _mathlib_temp_float1, _mathlib_temp_float2, _mathlib_temp_float3;
extern vec3_t _mathlib_temp_vec1, _mathlib_temp_vec2, _mathlib_temp_vec3;

#define Q_ROUND_POWER2(in, out) {						\
	_mathlib_temp_int1 = in;							\
	for (out = 1; out < _mathlib_temp_int1; out <<= 1)	\
	;												\
}


#define clamp(a,b,c) (a = min(max(a, b), c))
#define sgn(x) ((x < 0) ? -1 : ((x > 0) ? 1 : 0))

#define MinI(a,b) min(a,b)
#define MinD(a,b) min(a,b)
#define MaxI(a,b) max(a,b)
#define MaxD(a,b) max(a,b)

// Minimal matrix math for rotating point around vector.
// We have RotatePointAroundVector(), but matrix math allow me rotate few points faster than this function.

/*
Init rotation matrix 'out', 'angle' in radians, 'v' should be normilized vector.
*/
void Matrix3x3_CreateRotate(matrix3x3_t out, float angle, const vec3_t v);

/*
Multiply matrix 'in' by vector 'v', note what 'out' is vector.
*/
void Matrix3x3_MultiplyByVector(vec3_t out, const matrix3x3_t in, const vec3_t v);

float VectorDistance(const vec3_t x, const vec3_t y);
float VectorDistanceQuick(const vec3_t x, const vec3_t y);

#endif /* !__MATHLIB_H__ */


================================================
FILE: src/md4.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	

*/
/* GLOBAL.H - RSAREF types and constants */

#include <string.h>

/* POINTER defines a generic pointer type */
typedef unsigned char *POINTER;

/* UINT2 defines a two byte word */
typedef unsigned short int UINT2;

/* UINT4 defines a four byte word */
#if defined(__alpha__) || defined(_LP64) || defined(__x86_64)
typedef unsigned int UINT4;
#else
typedef unsigned long int UINT4;
#endif


/* MD4.H - header file for MD4C.C */

/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991.

All rights reserved.

License to copy and use this software is granted provided that it is identified as the 'RSA Data Security, Inc. MD4 Message-Digest Algorithm' in all material mentioning or referencing this software or this function.
License is also granted to make and use derivative works provided that such works are identified as 'derived from the RSA Data Security, Inc. MD4 Message-Digest Algorithm' in all material mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided 'as is' without express or implied warranty of any kind.

These notices must be retained in any copies of any part of this documentation and/or software. */

/* MD4 context. */
typedef struct {
    UINT4 state[4];             /* state (ABCD) */
    UINT4 count[2];             /* number of bits, modulo 2^64 (lsb first) */
    unsigned char buffer[64];           /* input buffer */
} MD4_CTX;

void MD4Init (MD4_CTX *);
void MD4Update (MD4_CTX *, unsigned char *, unsigned int);
void MD4Final (unsigned char [16], MD4_CTX *);



/* MD4C.C - RSA Data Security, Inc., MD4 message-digest algorithm */
/* Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved.

License to copy and use this software is granted provided that it is identified as the
RSA Data Security, Inc. MD4 Message-Digest Algorithm
 in all material mentioning or referencing this software or this function.
License is also granted to make and use derivative works provided that such works are identified as
derived from the RSA Data Security, Inc. MD4 Message-Digest Algorithm
in all material mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided
as is without express or implied warranty of any kind.

These notices must be retained in any copies of any part of this documentation and/or software. */

/* Constants for MD4Transform routine.  */
#define S11 3
#define S12 7
#define S13 11
#define S14 19
#define S21 3
#define S22 5
#define S23 9
#define S24 13
#define S31 3
#define S32 9
#define S33 11
#define S34 15

static void MD4Transform (UINT4 [4], unsigned char [64]);
static void Encode (unsigned char *, UINT4 *, unsigned int);
static void Decode (UINT4 *, unsigned char *, unsigned int);

static unsigned char PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

/* F, G and H are basic MD4 functions. */
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))

/* ROTATE_LEFT rotates x left n bits. */
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
/* Rotation is separate from addition to prevent recomputation */
#define FF(a, b, c, d, x, s) {(a) += F ((b), (c), (d)) + (x); (a) = ROTATE_LEFT ((a), (s));}

#define GG(a, b, c, d, x, s) {(a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; (a) = ROTATE_LEFT ((a), (s));}

#define HH(a, b, c, d, x, s) {(a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; (a) = ROTATE_LEFT ((a), (s));}


/* MD4 initialization. Begins an MD4 operation, writing a new context. */
void MD4Init (MD4_CTX *context)
{
    context->count[0] = context->count[1] = 0;

/* Load magic initialization constants.*/
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}

/* MD4 block update operation. Continues an MD4 message-digest operation, processing another message block, and updating the context. */
void MD4Update (MD4_CTX *context, unsigned char *input, unsigned int inputLen)
{
    unsigned int i, index, partLen;

    /* Compute number of bytes mod 64 */
    index = (unsigned int)((context->count[0] >> 3) & 0x3F);

    /* Update number of bits */
    if ((context->count[0] += ((UINT4)inputLen << 3))< ((UINT4)inputLen << 3))
        context->count[1]++;

    context->count[1] += ((UINT4)inputLen >> 29);

    partLen = 64 - index;

    /* Transform as many times as possible.*/
    if (inputLen >= partLen)
    {
        memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
        MD4Transform (context->state, context->buffer);

        for (i = partLen; i + 63 < inputLen; i += 64)
            MD4Transform (context->state, &input[i]);

        index = 0;
    }
    else
        i = 0;

    /* Buffer remaining input */
    memcpy ((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i);
}


/* MD4 finalization. Ends an MD4 message-digest operation, writing the the message digest and zeroizing the context. */
void MD4Final (unsigned char digest[16], MD4_CTX *context)
{
    unsigned char bits[8];
    unsigned int index, padLen;

    /* Save number of bits */
    Encode (bits, context->count, 8);

    /* Pad out to 56 mod 64.*/
    index = (unsigned int)((context->count[0] >> 3) & 0x3f);
    padLen = (index < 56) ? (56 - index) : (120 - index);
    MD4Update (context, PADDING, padLen);

    /* Append length (before padding) */
    MD4Update (context, bits, 8);

    /* Store state in digest */
    Encode (digest, context->state, 16);

    /* Zeroize sensitive information.*/
    memset ((POINTER)context, 0, sizeof (*context));
}


/* MD4 basic transformation. Transforms state based on block. */
static void MD4Transform (UINT4 state[4], unsigned char block[64])
{
    UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];

    Decode (x, block, 64);

/* Round 1 */
FF (a, b, c, d, x[ 0], S11);                /* 1 */
FF (d, a, b, c, x[ 1], S12);                /* 2 */
FF (c, d, a, b, x[ 2], S13);                /* 3 */
FF (b, c, d, a, x[ 3], S14);                /* 4 */
FF (a, b, c, d, x[ 4], S11);                /* 5 */
FF (d, a, b, c, x[ 5], S12);                /* 6 */
FF (c, d, a, b, x[ 6], S13);                /* 7 */
FF (b, c, d, a, x[ 7], S14);                /* 8 */
FF (a, b, c, d, x[ 8], S11);                /* 9 */
FF (d, a, b, c, x[ 9], S12);                /* 10 */
FF (c, d, a, b, x[10], S13);            /* 11 */
FF (b, c, d, a, x[11], S14);            /* 12 */
FF (a, b, c, d, x[12], S11);            /* 13 */
FF (d, a, b, c, x[13], S12);            /* 14 */
FF (c, d, a, b, x[14], S13);            /* 15 */
FF (b, c, d, a, x[15], S14);            /* 16 */

/* Round 2 */
GG (a, b, c, d, x[ 0], S21);            /* 17 */
GG (d, a, b, c, x[ 4], S22);            /* 18 */
GG (c, d, a, b, x[ 8], S23);            /* 19 */
GG (b, c, d, a, x[12], S24);            /* 20 */
GG (a, b, c, d, x[ 1], S21);            /* 21 */
GG (d, a, b, c, x[ 5], S22);            /* 22 */
GG (c, d, a, b, x[ 9], S23);            /* 23 */
GG (b, c, d, a, x[13], S24);            /* 24 */
GG (a, b, c, d, x[ 2], S21);            /* 25 */
GG (d, a, b, c, x[ 6], S22);            /* 26 */
GG (c, d, a, b, x[10], S23);            /* 27 */
GG (b, c, d, a, x[14], S24);            /* 28 */
GG (a, b, c, d, x[ 3], S21);            /* 29 */
GG (d, a, b, c, x[ 7], S22);            /* 30 */
GG (c, d, a, b, x[11], S23);            /* 31 */
GG (b, c, d, a, x[15], S24);            /* 32 */

/* Round 3 */
HH (a, b, c, d, x[ 0], S31);                /* 33 */
HH (d, a, b, c, x[ 8], S32);            /* 34 */
HH (c, d, a, b, x[ 4], S33);            /* 35 */
HH (b, c, d, a, x[12], S34);            /* 36 */
HH (a, b, c, d, x[ 2], S31);            /* 37 */
HH (d, a, b, c, x[10], S32);            /* 38 */
HH (c, d, a, b, x[ 6], S33);            /* 39 */
HH (b, c, d, a, x[14], S34);            /* 40 */
HH (a, b, c, d, x[ 1], S31);            /* 41 */
HH (d, a, b, c, x[ 9], S32);            /* 42 */
HH (c, d, a, b, x[ 5], S33);            /* 43 */
HH (b, c, d, a, x[13], S34);            /* 44 */
HH (a, b, c, d, x[ 3], S31);            /* 45 */
HH (d, a, b, c, x[11], S32);            /* 46 */
HH (c, d, a, b, x[ 7], S33);            /* 47 */
HH (b, c, d, a, x[15], S34);            /* 48 */

state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;

    /* Zeroize sensitive information.*/
    memset ((POINTER)x, 0, sizeof (x));
}


/* Encodes input (UINT4) into output (unsigned char). Assumes len is a multiple of 4. */
static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
{
    unsigned int i, j;

    for (i = 0, j = 0; j < len; i++, j += 4) {
        output[j] = (unsigned char)(input[i] & 0xff);
        output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
        output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
        output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
    }
}


/* Decodes input (unsigned char) into output (UINT4). Assumes len is a multiple of 4. */
static void Decode (UINT4 *output, unsigned char *input, unsigned int len)
{
unsigned int i, j;

for (i = 0, j = 0; j < len; i++, j += 4)
    output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) | (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
}

//===================================================================

unsigned Com_BlockChecksum (void *buffer, int length)
{
    int         digest[4];
    unsigned    val;
    MD4_CTX     ctx;

    MD4Init (&ctx);
    MD4Update (&ctx, (unsigned char *)buffer, length);
    MD4Final ( (unsigned char *)digest, &ctx);

    val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];

    return val;
}

void Com_BlockFullChecksum (void *buffer, int len, unsigned char *outbuf)
{
    MD4_CTX     ctx;

    MD4Init (&ctx);
    MD4Update (&ctx, (unsigned char *)buffer, len);
    MD4Final ( outbuf, &ctx);
}


================================================
FILE: src/menu.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef _WIN32
#include <dirent.h>
#include <sys/stat.h>
#endif
#include "quakedef.h"
#include "gl_model.h"
#ifndef CLIENTONLY
#include "server.h"
#endif
#include "menu.h"
#include "EX_browser.h"
#include "Ctrl_Tab.h"
#include "menu_demo.h"
#include "menu_proxy.h"
#include "menu_options.h"
#include "menu_ingame.h"
#include "menu_multiplayer.h"
#include "EX_FileList.h"
#include "help.h"
#include "utils.h"
#include "qsound.h"
#include "keys.h"
#include "common_draw.h"
#include "r_matrix.h"

qbool vid_windowedmouse = true;
void (*vid_menudrawfn)(void);
void (*vid_menukeyfn)(int key);
void CL_Disconnect_f(void);

extern cvar_t con_shift, scr_menualpha;

void M_Menu_Main_f (void);
	void M_Menu_SinglePlayer_f (void);
		void M_Menu_Load_f (void);
		void M_Menu_Save_f (void);
	void M_Menu_Browser_f (void);
	void M_Menu_MultiPlayer_f (void);
			void M_Menu_SEdit_f (void);
		void M_Menu_Demos_f (void);
		void M_Menu_GameOptions_f (void);
	void M_Menu_Options_f (void);
	void M_Menu_Quit_f (void);

void M_Main_Draw (void);
	void M_SinglePlayer_Draw (void);
		void M_Load_Draw (void);
		void M_Save_Draw (void);
	void M_MultiPlayer_Draw (void);
		void M_ServerList_Draw (void);
			void M_SEdit_Draw (void);
		void M_Demo_Draw (void);
		void M_GameOptions_Draw (void);
		void M_Proxy_Draw (void);
	void M_Options_Draw (void);
	void M_Help_Draw (void);
	void M_Quit_Draw (void);

void M_Main_Key (int key);
	void M_SinglePlayer_Key (int key);
		void M_Load_Key (int key);
		void M_Save_Key (int key);
	void M_MultiPlayerSub_Key (int key);
		void M_ServerList_Key (int key);
			void M_SEdit_Key (int key);
		void M_Demo_Key (int key);
		qbool M_GameOptions_Key (int key);
		void M_Proxy_Key (int key);
	void M_Options_Key (int key, wchar unichar);
	void M_Help_Key (int key);
	void M_Quit_Key (int key);

void M_Menu_Help_f (void);

m_state_t m_state;

qbool    m_entersound;          // play after drawing a frame, so caching
                                // won't disrupt the sound
int            m_topmenu;       // set if a submenu was entered via a
                                // menu_* command
#define    SLIDER_RANGE    10

typedef struct menu_window_s {
	int x;
	int y;
	int w;
	int h;
} menu_window_t;

//=============================================================================
/* Support Routines */

cvar_t     scr_scaleMenu = {"scr_scaleMenu","2"};
int        menuwidth = 320;
int        menuheight = 240;

cvar_t     scr_centerMenu = {"scr_centerMenu","1"};
cvar_t     menu_ingame = {"menu_ingame", "1"};
cvar_t     menu_botmatch_gamedir = { "menu_botmatch_gamedir", "fbca" };
cvar_t     menu_botmatch_mod_old = { "menu_botmatch_mod_old", "1" };
int        m_yofs = 0;

void M_DrawCharacter (int cx, int line, int num) {
	Draw_Character (cx + ((menuwidth - 320)>>1), line + m_yofs, num);
}

void M_Print_GetPoint(int cx, int cy, int *rx, int *ry, const char *str, qbool red) {
	cx += ((menuwidth - 320)>>1);
	cy += m_yofs;
	*rx = cx;
	*ry = cy;
	if (red) {
		Draw_Alt_String(cx, cy, str, 1, false);
	}
	else {
		Draw_String(cx, cy, str);
	}
}

void M_Print (int cx, int cy, char *str) {
	int rx, ry;
	M_Print_GetPoint(cx, cy, &rx, &ry, str, true);
}

void M_PrintWhite (int cx, int cy, char *str) {
	Draw_String (cx + ((menuwidth - 320)>>1), cy + m_yofs, str);
}

// replacement of M_DrawTransPic - sometimes we need the real coordinate of the pic
static void M_DrawTransPic_GetPoint (int x, int y, int *rx, int *ry, mpic_t *pic)
{
	*rx = x + ((menuwidth - 320)>>1);
	*ry = y + m_yofs;
	Draw_TransPic (x + ((menuwidth - 320)>>1), y + m_yofs, pic);
}

void M_DrawTransPic (int x, int y, mpic_t *pic) {
	int tx, ty;
	M_DrawTransPic_GetPoint(x, y, &tx, &ty, pic);
}

void M_DrawPic (int x, int y, mpic_t *pic) {
	Draw_Pic (x + ((menuwidth - 320)>>1), y + m_yofs, pic);
}

void M_DrawTextBox (int x, int y, int width, int lines) {
	Draw_TextBox (x + ((menuwidth - 320) >> 1), y + m_yofs, width, lines);
}

void M_DrawSlider (int x, int y, float range) {
	int    i;

	range = bound(0, range, 1);
	M_DrawCharacter (x-8, y, 128);
	for (i=0 ; i<SLIDER_RANGE ; i++)
		M_DrawCharacter (x + i*8, y, 129);
	M_DrawCharacter (x+i*8, y, 130);
	M_DrawCharacter (x + (SLIDER_RANGE-1)*8 * range, y, 131);
}

qbool Key_IsLeftRightSameBind(int b);

void M_FindKeysForCommand (const char *command, int *twokeys) {
	int count, j, l;
	char *b;

	twokeys[0] = twokeys[1] = -1;
	l = strlen(command) + 1;
	count = 0;

	for (j = 0 ; j < (sizeof(keybindings) / sizeof(*keybindings)); j++) {
		b = keybindings[j];
		if (!b)
			continue;
		if (!strncmp (b, command, l)) {
			if (count) {
				if (j == twokeys[0] + 1 && (twokeys[0] == K_LCTRL || twokeys[0] == K_LSHIFT || twokeys[0] == K_LALT)) {

					twokeys[0]--;
					continue;
				}
			}
			twokeys[count] = j;
			count++;
			if (count == 2) {

				if (Key_IsLeftRightSameBind(twokeys[1]))
					twokeys[1]++;
				break;
			}
		}
	}
}

void M_Unscale_Menu(void)
{
	// do not scale this menu
	if (scr_scaleMenu.value) 
	{
		menuwidth = vid.width;
		menuheight = vid.height;
		R_OrthographicProjection(0, menuwidth, menuheight, 0, -99999, 99999);
	}
}

// will apply menu scaling effect for given window region
// scr_scaleMenu 1 uses glOrtho function and we use the same algorithm in here
static void M_Window_Adjust(const menu_window_t *original, menu_window_t *scaled)
{
	double sc_x, sc_y; // scale factors

	if (scr_scaleMenu.value)
	{
		sc_x = (double) vid.width / (double) menuwidth;
		sc_y = (double) vid.height / (double) menuheight;
		scaled->x = original->x * sc_x;
		scaled->y = original->y * sc_y;
		scaled->w = original->w * sc_x;
		scaled->h = original->h * sc_y;
	}
	else
	{
		memcpy(scaled, original, sizeof(menu_window_t));
	}
}

// this function will look at window borders and current mouse cursor position
// and will change which item in the window should be selected
// we presume that all entries have same height and occupy the whole window
// 1st par: input, window position & size
// 2nd par: input, mouse position
// 3rd par: input, how many entries does the window have
// 4th par: output, newly selected entry, first entry is 0, second 1, ...
// return value: does the cursor belong to this window? yes/no
static qbool M_Mouse_Select(const menu_window_t *uw, const mouse_state_t *m, int entries, int *newentry)
{
	double entryheight;
	double nentry;
	menu_window_t rw;
	menu_window_t *w = &rw; // just a language "shortcut"
	
	M_Window_Adjust(uw, w);

	// window is invisible
	if (!(w->h > 0) || !(w->w > 0)) return false;

	// check if the pointer is inside of the window
	if (m->x < w->x || m->y < w->y || m->x > w->x + w->w || m->y > w->y + w->h)
		return false; // no, it's not

	entryheight = w->h / entries;
	nentry = (int) (m->y - w->y) / (int) entryheight;
	
	*newentry = bound(0, nentry, entries-1);

	return true;
}

//=============================================================================

void M_EnterMenu (int state) {
	if (key_dest != key_menu) {
		m_topmenu = state;
		if (state != m_proxy) {
			Con_ClearNotify ();
			// hide the console
			scr_conlines = 0;
			scr_con_current = 0;
		}
	} else {
		m_topmenu = m_none;
	}

	key_dest = key_menu;
	m_state = state;
	m_entersound = true;
}

static void M_ToggleHeadMenus(int type)
{
	m_entersound = true;

	// do not ever use ingame menu, if user doesn't wish so
	if (!menu_ingame.integer) {
		type = m_main;
	}

	if (key_dest == key_menu) {
		if (m_state != type) {
			M_EnterMenu(type);
			return;
		}
		key_dest = key_game;
		m_state = m_none;
	} else {
		M_EnterMenu(type);
	}
}

void M_ToggleMenu_f (void) {
	if (cls.state == ca_active) {
		M_ToggleHeadMenus(m_ingame);
	}
	else M_ToggleHeadMenus(m_main);
}

void M_EnterProxyMenu (void) {
	M_EnterMenu(m_proxy);
}

void M_LeaveMenu (int parent) {
	if (m_topmenu == m_state) {
		m_state = m_none;
		key_dest = key_game;
	} else {
		m_state = parent;
		m_entersound = true;
	}
}

// dunno how to call this function
// must leave all menus instead of calling few functions in row
void M_LeaveMenus (void) {
//	m_entersound = true; // fixme: which value we must set ???

	m_topmenu = m_none;
	m_state   = m_none;
	key_dest  = key_game;
}

void M_ToggleProxyMenu_f (void) {
	// this is what user has bound to a key - that means 
	// when in proxy menu -> turn it off; and vice versa
	m_entersound = true;

	if ((key_dest == key_menu) && (m_state == m_proxy)) {
		M_LeaveMenus();
		Menu_Proxy_Toggle();
	} else {
		M_EnterMenu (m_proxy);
		Menu_Proxy_Toggle();
	}
}

//=============================================================================
/* MAIN MENU */

int    m_main_cursor;
static qbool	newmainmenu = false;
menu_window_t m_main_window;

void M_Menu_Main_f (void) {
	M_EnterMenu (m_main);
}

#define BIGLETTER_WIDTH	64
#define BIGLETTER_HEIGHT	64
#define BIGMENU_LEFT				72
#define BIGMENU_TOP					32
#define BIGMENU_ITEMS_SCALE			0.3
#define	BIGMENU_LETTER_SPACING		-2
#define BIGMENU_VERTICAL_PADDING	2

typedef struct bigmenu_items_s {
	const char *label;
	void (* enter_handler) (void);
} bigmenu_items_t;

#define BIGMENU_ITEMS_COUNT(x) (sizeof(x) / sizeof(bigmenu_items_t))

bigmenu_items_t mainmenu_items[] = {
	{"Single Player", M_Menu_SinglePlayer_f},
	{"Multiplayer", M_Menu_MultiPlayer_f},
	{"Options", M_Menu_Options_f},
	{"Demos", M_Menu_Demos_f},
	{"Help", M_Menu_Help_f},
	{"Quit", M_Menu_Quit_f}
};

#define    MAIN_ITEMS    (newmainmenu ? BIGMENU_ITEMS_COUNT(mainmenu_items) : 5)

// mcharset must be supported in this point
static void M_BigMenu_DrawItems(bigmenu_items_t *menuitems, const unsigned int items, int left_corner, int top_corner, int *width, int *height)
{
	int i;
	int mheight = 0;
	int mwidth = 0;
	int x = left_corner;
	int y = top_corner;

	for (i = 0; i < items; i++) {
		int thiswidth = strlen(menuitems[i].label)*BIGMENU_ITEMS_SCALE*BIGLETTER_WIDTH;
		mheight += BIGMENU_ITEMS_SCALE*BIGLETTER_HEIGHT + BIGMENU_VERTICAL_PADDING;
		mwidth = max(mwidth, thiswidth);
		Draw_BigString(x, y, menuitems[i].label, NULL, 0, 
			BIGMENU_ITEMS_SCALE, 1, BIGMENU_LETTER_SPACING);
		y += BIGMENU_ITEMS_SCALE*BIGLETTER_HEIGHT + BIGMENU_VERTICAL_PADDING;
	}

	*width = mwidth;
	*height = mheight;
}

void M_Main_Draw (void) {
	int f = (int) (curtime * 10) % 6;
	mpic_t *p;
	int itemheight;

	M_DrawTransPic (16, BIGMENU_TOP, Draw_CachePic (CACHEPIC_QPLAQUE) );

	// the Main Manu heading
	p = Draw_CachePic (CACHEPIC_TTL_MAIN);
	M_DrawPic ( (320-p->width)/2, 4, p);

	// Main Menu items
	if (Draw_BigFontAvailable()) {
		newmainmenu = true;
		m_main_window.x = BIGMENU_LEFT + (menuwidth - 320)/2;
		m_main_window.y = BIGMENU_TOP + m_yofs;
		M_BigMenu_DrawItems(mainmenu_items, BIGMENU_ITEMS_COUNT(mainmenu_items), m_main_window.x, m_main_window.y,
						 &m_main_window.w, &m_main_window.h);
		itemheight = m_main_window.h / BIGMENU_ITEMS_COUNT(mainmenu_items);
	}
	else {
		newmainmenu = false;
		p = Draw_CachePic (CACHEPIC_MAINMENU);
		m_main_window.w = p->width;
		m_main_window.h = p->height;
		M_DrawTransPic_GetPoint (72, 32, &m_main_window.x, &m_main_window.y, p);
		
		// main menu specific correction, mainmenu.lmp|png have some useless extra space at the bottom
		// that makes the mouse pointer position calculation imperfect
		m_main_window.h *= 0.9;

		itemheight = 20;
	}	

	M_DrawTransPic (54, BIGMENU_TOP + m_main_cursor * itemheight,
		Draw_CachePic(CACHEPIC_MENUDOT1 + f)
	);
}

static void M_Main_Enter(const unsigned int entry)
{
	if (newmainmenu) {
		mainmenu_items[entry].enter_handler();
	}
	else {
		switch (entry) {
		case 0: M_Menu_SinglePlayer_f (); break;
		case 1:	M_Menu_MultiPlayer_f (); break;
		case 2: M_Menu_Options_f (); break;
		case 4: M_Menu_Quit_f (); break;
		}
	}
}

void M_Main_Key (int key) {
	switch (key) {
	case K_ESCAPE:
	case K_MOUSE2:
		if (cls.state < ca_active)
			key_dest = key_console;
		else 
			key_dest = key_game;
		m_state = m_none;
		break;

	case '`':
	case '~':
		key_dest = key_console;
		m_state = m_none;
		break;

	case K_UPARROW:
	case K_MWHEELUP:
		S_LocalSound ("misc/menu1.wav");
		if (--m_main_cursor < 0)
			m_main_cursor = MAIN_ITEMS - 1;
		break;

	case K_DOWNARROW:
	case K_MWHEELDOWN:
		S_LocalSound ("misc/menu1.wav");
		if (++m_main_cursor >= MAIN_ITEMS)
			m_main_cursor = 0;
		break;

	case K_HOME:
	case K_PGUP:
		S_LocalSound ("misc/menu1.wav");
		m_main_cursor = 0;
		break;

	case K_END:
	case K_PGDN:
		S_LocalSound ("misc/menu1.wav");
		m_main_cursor = MAIN_ITEMS - 1;
		break;

	case K_ENTER:
	case K_MOUSE1:
		m_entersound = true;
		M_Main_Enter((unsigned) m_main_cursor);
	}
}

static qbool M_Main_Mouse_Event(const mouse_state_t* ms)
{
	M_Mouse_Select(&m_main_window, ms, MAIN_ITEMS, &m_main_cursor);
    
    if (ms->button_up == 1) M_Main_Key(K_MOUSE1);
    if (ms->button_up == 2) M_Main_Key(K_MOUSE2);

    return true;
}

//=============================================================================
/* OPTIONS MENU */

void M_Menu_Options_f (void) {
	M_EnterMenu (m_options);
}

void M_Options_Key (int key, wchar unichar) {
	Menu_Options_Key(key, unichar); // menu_options module
}

void M_Options_Draw (void) {
	Menu_Options_Draw();	// menu_options module
}

//=============================================================================
/* PROXY MENU */

// key press in demos menu
void M_Proxy_Key (int key) {
	int togglekeys[2];

	// the menu_proxy module doesn't know which key user has bound to toggleproxymenu action
	M_FindKeysForCommand("toggleproxymenu", togglekeys);
	if ((key == togglekeys[0]) || (key == togglekeys[1])) {
		Menu_Proxy_Toggle(); 
		M_LeaveMenus();
		return;
	}

	// ppl are used to access console even when in qizmo menu
	M_FindKeysForCommand("toggleconsole", togglekeys);
	if ((key == togglekeys[0]) || (key == togglekeys[1])) {
		Con_ToggleConsole_f();
		return;
	}

	Menu_Proxy_Key(key); // menu_proxy module
}


//=============================================================================
/* HELP MENU */

int        help_page;
#define    NUM_HELP_PAGES    6

void M_Menu_Help_f (void) {
	M_EnterMenu (m_help);
}

void M_Help_Draw (void) {
	int x, y, w, h;

	M_Unscale_Menu();

    // this will add top, left and bottom padding
    // right padding is not added because it causes annoying scrollbar behaviour
    // when mouse gets off the scrollbar to the right side of it
	w = vid.width - OPTPADDING; // here used to be a limit to 512x... size
	h = vid.height - OPTPADDING*2;
	x = OPTPADDING;
	y = OPTPADDING;

	Menu_Help_Draw (x, y, w, h);
}

//=============================================================================
/* QUIT MENU */

int        msgNumber;
int        m_quit_prevstate;
qbool    wasInMenus;

void M_Menu_Quit_f (void) {
	extern cvar_t cl_confirmquit;

	if (!cl_confirmquit.integer) Host_Quit();

	if (m_state == m_quit)
		return;
	wasInMenus = (key_dest == key_menu);
	m_quit_prevstate = m_state;
	msgNumber = rand()&7;
	M_EnterMenu (m_quit);
}

void M_Quit_Key (int key) {
	switch (key) {
		case K_MOUSE2:
		case K_ESCAPE:
		case 'n':
		case 'N':
			if (wasInMenus) {
				m_state = m_quit_prevstate;
				m_entersound = true;
			} else {
				key_dest = key_game;
				m_state = m_none;
			}
			break;

		case '`':
		case '~':
			key_dest = key_console;
			m_state = m_none;
			break;

		case K_MOUSE1:
		case K_ENTER:
		case 'Y':
		case 'y':
			key_dest = key_console;
			Host_Quit ();
			break;

		default:
			break;
	}
}

void M_Quit_Draw (void) { // Quit screen text.
	M_DrawTextBox (0, 0, 38, 26);
	M_PrintWhite (16, 12,  "  Quake version 1.09 by id Software\n\n");
	M_PrintWhite (16, 28,  "Programming        Art \n");
	M_Print (16, 36,  " John Carmack       Adrian Carmack\n");
	M_Print (16, 44,  " Michael Abrash     Kevin Cloud\n");
	M_Print (16, 52,  " John Cash          Paul Steed\n");
	M_Print (16, 60,  " Dave 'Zoid' Kirsch\n");
	M_PrintWhite (16, 68,  "Design             Biz\n");
	M_Print (16, 76,  " John Romero        Jay Wilbur\n");
	M_Print (16, 84,  " Sandy Petersen     Mike Wilson\n");
	M_Print (16, 92,  " American McGee     Donna Jackson\n");
	M_Print (16, 100,  " Tim Willits        Todd Hollenshead\n");
	M_PrintWhite (16, 108, "Support            Projects\n");
	M_Print (16, 116, " Barrett Alexander  Shawn Green\n");
	M_PrintWhite (16, 124, "Sound Effects\n");
	M_Print (16, 132, " Trent Reznor and Nine Inch Nails\n\n");
	M_PrintWhite (16, 148, "Quake is a trademark of Id Software,\n");
	M_PrintWhite (16, 156, "inc., (c)1996 Id Software, inc. All\n");
	M_PrintWhite (16, 164, "rights reserved. NIN logo is a\n");
	M_PrintWhite (16, 172, "registered trademark licensed to\n");
	M_PrintWhite (16, 180, "Nothing Interactive, Inc. All rights\n");
	M_PrintWhite (16, 188, "reserved.\n\n");
	M_Print (16, 204, "          Press y to exit\n");
}

//=============================================================================
/* SINGLE PLAYER MENU */

#ifndef CLIENTONLY

#define    SINGLEPLAYER_ITEMS    3
int    m_singleplayer_cursor;
qbool m_singleplayer_confirm;
qbool m_singleplayer_notavail;
menu_window_t m_singleplayer_window;
static qbool m_singleplayer_big = false;
static bigmenu_items_t m_singleplayer_items[] = {
	{"New Game", NULL},
	{"Load", NULL}, 
	{"Save", NULL}
};

extern    cvar_t    maxclients;

void M_Menu_SinglePlayer_f (void) {
	M_EnterMenu (m_singleplayer);
	m_singleplayer_confirm = false;
	m_singleplayer_notavail = false;
}

void M_SinglePlayer_Draw (void) {
	int f = (int)(curtime * 10)%6;
	mpic_t *p;
	int itemheight;

#ifndef WITH_NQPROGS
	if (m_singleplayer_notavail) {
		p = Draw_CachePic ("gfx/ttl_sgl.lmp");
		M_DrawPic ( (320-p->width)/2, 4, p);
		M_DrawTextBox (60, 10*8, 24, 4);
		M_PrintWhite (80, 12*8, " Cannot start a game");
		M_PrintWhite (80, 13*8, "spprogs.dat not found");
		return;
	}
#endif

	if (m_singleplayer_confirm) {
		M_PrintWhite (64, 11*8, "Are you sure you want to");
		M_PrintWhite (64, 12*8, "    start a new game?");
		return;
	}

	M_DrawTransPic (16, BIGMENU_TOP, Draw_CachePic (CACHEPIC_QPLAQUE) );
	p = Draw_CachePic (CACHEPIC_TTL_SGL);
	M_DrawPic ( (320-p->width)/2, 4, p);

	if (Draw_BigFontAvailable()) {
		m_singleplayer_big = true;
		m_singleplayer_window.x = BIGMENU_LEFT + ((menuwidth - 320)>>1);
		m_singleplayer_window.y = BIGMENU_TOP + m_yofs;
		M_BigMenu_DrawItems(m_singleplayer_items, BIGMENU_ITEMS_COUNT(m_singleplayer_items),
			m_singleplayer_window.x, m_singleplayer_window.y, &m_singleplayer_window.w,
			&m_singleplayer_window.h);
		itemheight = m_singleplayer_window.h / BIGMENU_ITEMS_COUNT(m_singleplayer_items);
	}
	else {
		m_singleplayer_big = false;
		p = Draw_CachePic (CACHEPIC_SP_MENU);
		m_singleplayer_window.w = p->width;
		m_singleplayer_window.h = p->height;
		M_DrawTransPic_GetPoint(72, 32, &m_singleplayer_window.x, &m_singleplayer_window.y, p);
		itemheight = 20;
	}

	M_DrawTransPic (54, BIGMENU_TOP + m_singleplayer_cursor * itemheight,
		Draw_CachePic(CACHEPIC_MENUDOT1 + f)
	);
}

#ifndef WITH_NQPROGS
static void CheckSPGame (void) {
	vfsfile_t *v;
	if ((v = FS_OpenVFS("spprogs.dat", "rb", FS_ANY))) {
		VFS_CLOSE(v);
		m_singleplayer_notavail = false;
	} else {
		m_singleplayer_notavail = true;
	}
}
#endif	// !WITH_NQPROGS

static void StartNewGame(void)
{
	extern cvar_t sv_progtype;

	key_dest = key_game;
	m_state = m_none;
	Cvar_Set(&maxclients, "1");
	Cvar_Set(&teamplay, "0");
	Cvar_Set(&deathmatch, "0");
	Cvar_Set(&coop, "0");

	Cvar_Set(&sv_progsname, "spprogs"); // force progsname
#ifdef USE_PR2
	Cvar_Set(&sv_progtype, "0"); // force .dat
#endif

	if (com_serveractive) {
		Cbuf_AddText("disconnect\n");
	}

	Cbuf_AddText("map start\n");
}

void M_SinglePlayer_Key (int key) {
#ifndef WITH_NQPROGS
	if (m_singleplayer_notavail) {
		switch (key) {
			case K_BACKSPACE:
			case K_ESCAPE:
			case K_ENTER:
				m_singleplayer_notavail = false;
				break;
		}
		return;
	}
#endif

	if (m_singleplayer_confirm) {
		if (key == K_ESCAPE || key == 'n' || key == K_MOUSE2) {
			m_singleplayer_confirm = false;
			m_entersound = true;
		} else if (key == 'y' || key == K_ENTER || key == K_MOUSE1) {
			StartNewGame ();
		}
		return;
	}

	switch (key) {
		case K_BACKSPACE:
			m_topmenu = m_none;    // intentional fallthrough
		case K_MOUSE2:
		case K_ESCAPE:
			M_LeaveMenu (m_main);
			break;

		case '`':
		case '~':
			key_dest = key_console;
			m_state = m_none;
			break;

		case K_DOWNARROW:
		case K_MWHEELDOWN:
			S_LocalSound ("misc/menu1.wav");
			if (++m_singleplayer_cursor >= SINGLEPLAYER_ITEMS)
				m_singleplayer_cursor = 0;
			break;

		case K_UPARROW:
		case K_MWHEELUP:
			S_LocalSound ("misc/menu1.wav");
			if (--m_singleplayer_cursor < 0)
				m_singleplayer_cursor = SINGLEPLAYER_ITEMS - 1;
			break;

		case K_HOME:
		case K_PGUP:
			S_LocalSound ("misc/menu1.wav");
			m_singleplayer_cursor = 0;
			break;

		case K_END:
		case K_PGDN:
			S_LocalSound ("misc/menu1.wav");
			m_singleplayer_cursor = SINGLEPLAYER_ITEMS - 1;
			break;

		case K_ENTER:
		case K_MOUSE1:
			switch (m_singleplayer_cursor) {
				case 0:
#ifndef WITH_NQPROGS
					CheckSPGame ();
					if (m_singleplayer_notavail) {
						m_entersound = true;
						return;
					}
#endif
					if (com_serveractive) {
						// bring up confirmation dialog
						m_singleplayer_confirm = true;
						m_entersound = true;
					} else {
						StartNewGame ();
					}
					break;

				case 1:
					M_Menu_Load_f ();
					break;

				case 2:
					M_Menu_Save_f ();
					break;
			}
	}
}

qbool M_SinglePlayer_Mouse_Event(const mouse_state_t* ms)
{
	M_Mouse_Select(&m_singleplayer_window, ms, SINGLEPLAYER_ITEMS, &m_singleplayer_cursor);

    if (ms->button_up == 1) M_SinglePlayer_Key(K_MOUSE1);
    if (ms->button_up == 2) M_SinglePlayer_Key(K_MOUSE2);

    return true;
}

#else    // !CLIENTONLY

void M_Menu_SinglePlayer_f (void) {
	M_EnterMenu (m_singleplayer);
}

void M_SinglePlayer_Draw (void) {
	mpic_t *p;

	M_DrawTransPic (16, 4, Draw_CachePic (CACHEPIC_QPLAQUE) );
	p = Draw_CachePic (CACHEPIC_TTL_SGL);
	M_DrawPic ( (320-p->width)/2, 4, p);
	//    M_DrawTransPic (72, 32, Draw_CachePic (CACHEPIC_SP_MENU) );

	M_DrawTextBox (60, 10*8, 23, 4);
	M_PrintWhite (88, 12*8, "This client is for");
	M_PrintWhite (88, 13*8, "Internet play only");
}

void M_SinglePlayer_Key (int key) {
	switch (key) {
		case K_BACKSPACE:
			m_topmenu = m_none;    // intentional fallthrough
		case K_ESCAPE:
		case K_ENTER:
			M_LeaveMenu (m_main);
			break;

		case '`':
		case '~':
			key_dest = key_console;
			m_state = m_none;
			break;
	}
}
#endif    // CLIENTONLY


//=============================================================================
/* LOAD/SAVE MENU */

#ifndef CLIENTONLY

#define    MAX_SAVEGAMES        12

const char* save_filenames[] = {
	"s0.sav", "s1.sav", "s2.sav", "s3.sav", "s4.sav", "s5.sav", "s6.sav", "s7.sav", "s8.sav", "s9.sav", "s10.sav", "s11.sav"
};
#ifdef C_ASSERT
C_ASSERT(sizeof(save_filenames) / sizeof(save_filenames[0]) == MAX_SAVEGAMES);
#endif

int        load_cursor;        // 0 < load_cursor < MAX_SAVEGAMES
char    m_filenames[MAX_SAVEGAMES][SAVEGAME_COMMENT_LENGTH + 1];
int        loadable[MAX_SAVEGAMES];
menu_window_t load_window, save_window;

void M_ScanSaves(char* sp_gamedir)
{
	int i, j;
	char name[MAX_OSPATH];
	vfsfile_t* f;

	for (i = 0; i < MAX_SAVEGAMES; i++) {
		loadable[i] = false;
		strlcpy(m_filenames[i], "--- UNUSED SLOT ---", SAVEGAME_COMMENT_LENGTH + 1);

		FS_SaveGameDirectory(name, sizeof(name));
		strlcat(name, save_filenames[i], sizeof(name));
		if (!(f = FS_OpenVFS(name, "rb", FS_NONE_OS))) {
			continue;
		}
		VFS_GETS(f, name, sizeof(name));
		VFS_GETS(f, name, sizeof(name));
		strlcpy(m_filenames[i], name, sizeof(m_filenames[i]));

		// change _ back to space
		for (j = 0; j < SAVEGAME_COMMENT_LENGTH; j++) {
			if (m_filenames[i][j] == '_') {
				m_filenames[i][j] = ' ';
			}
		}
		loadable[i] = true;
		VFS_CLOSE(f);
	}
}

void M_Menu_Load_f (void) {
	vfsfile_t *f;

	if (!(f = FS_OpenVFS("spprogs.dat", "rb", FS_ANY)))
		return;

	M_EnterMenu (m_load);
	// VFS-FIXME: file_from_gamedir is not set in FS_OpenVFS
	M_ScanSaves (!file_from_gamedir ? "qw" : com_gamedir);
}

void M_Menu_Save_f (void) {
	if (sv.state != ss_active)
		return;
	if (cl.intermission)
		return;

	M_EnterMenu (m_save);
	M_ScanSaves (com_gamedir);
}

void M_Load_Draw (void) {
	int i;
	mpic_t *p;
	int lx = 0, ly = 0;	// lower bounds of the window

	p = Draw_CachePic (CACHEPIC_P_LOAD);
	M_DrawPic ( (320 - p->width) >> 1, 4, p);

	for (i = 0; i < MAX_SAVEGAMES; i++)
	{
		if (i == 0)
			M_Print_GetPoint (16, 32 + 8*i, &load_window.x, &load_window.y, m_filenames[i], load_cursor == 0);
		else 
			M_Print_GetPoint (16, 32 + 8*i, &lx, &ly, m_filenames[i], load_cursor == i);
	}

	load_window.w = SAVEGAME_COMMENT_LENGTH*8; // presume 8 pixels for each letter
	load_window.h = ly - load_window.y + 8;

	// line cursor
	M_DrawCharacter (8, 32 + load_cursor * 8, FLASHINGARROW());
}

void M_Save_Draw (void) {
	int i;
	mpic_t *p;
	int lx = 0, ly = 0;	// lower bounds of the window

	p = Draw_CachePic (CACHEPIC_P_SAVE);
	M_DrawPic ( (320 - p->width) >> 1, 4, p);

	for (i = 0; i < MAX_SAVEGAMES; i++)
	{
		if (i == 0)
			M_Print_GetPoint (16, 32 + 8 * i, &save_window.x, &save_window.y, m_filenames[i], load_cursor == 0);
		else
			M_Print_GetPoint (16, 32 + 8 * i, &lx, &ly, m_filenames[i], load_cursor == i);
	}

	save_window.w = SAVEGAME_COMMENT_LENGTH*8; // presume 8 pixels for each letter
	save_window.h = ly - save_window.y + 8;

	// line cursor
	M_DrawCharacter (8, 32 + load_cursor * 8, FLASHINGARROW());
}

void M_Load_Key (int key) {
	switch (key) {
		case K_BACKSPACE:
			m_topmenu = m_none;    // intentional fallthrough
		case K_MOUSE2:
		case K_ESCAPE:
			M_LeaveMenu (m_singleplayer);
			break;

		case '`':
		case '~':
			key_dest = key_console;
			m_state = m_none;
			break;

		case K_ENTER:
		case K_MOUSE1:
			S_LocalSound ("misc/menu2.wav");
			if (!loadable[load_cursor])
				return;
			m_state = m_none;
			key_dest = key_game;

			// issue the load command
			Cbuf_AddText(va("load s%i\n", load_cursor));
			return;

		case K_UPARROW:
		case K_MWHEELUP:
		case K_LEFTARROW:
			S_LocalSound ("misc/menu1.wav");
			load_cursor--;
			if (load_cursor < 0)
				load_cursor = MAX_SAVEGAMES - 1;
			break;

		case K_DOWNARROW:
		case K_MWHEELDOWN:
		case K_RIGHTARROW:
			S_LocalSound ("misc/menu1.wav");
			load_cursor++;
			if (load_cursor >= MAX_SAVEGAMES)
				load_cursor = 0;
			break;
	}
}

void M_Save_Key (int key) {
	switch (key) {
		case K_BACKSPACE:
			m_topmenu = m_none;    // intentional fallthrough
		case K_MOUSE2:
		case K_ESCAPE:
			M_LeaveMenu (m_singleplayer);
			break;

		case '`':
		case '~':
			key_dest = key_console;
			m_state = m_none;
			break;

		case K_ENTER:
		case K_MOUSE1:
			m_state = m_none;
			key_dest = key_game;
			Cbuf_AddText (va("save s%i\n", load_cursor));
			return;

		case K_UPARROW:
		case K_MWHEELUP:
		case K_LEFTARROW:
			S_LocalSound ("misc/menu1.wav");
			load_cursor--;
			if (load_cursor < 0)
				load_cursor = MAX_SAVEGAMES-1;
			break;

		case K_DOWNARROW:
		case K_MWHEELDOWN:
		case K_RIGHTARROW:
			S_LocalSound ("misc/menu1.wav");
			load_cursor++;
			if (load_cursor >= MAX_SAVEGAMES)
				load_cursor = 0;
			break;
	}
}

qbool M_Save_Mouse_Event(const mouse_state_t *ms)
{
	M_Mouse_Select(&save_window, ms, MAX_SAVEGAMES, &load_cursor);

    if (ms->button_up == 1) M_Save_Key(K_MOUSE1);
    if (ms->button_up == 2) M_Save_Key(K_MOUSE2);

	return true;
}

qbool M_Load_Mouse_Event(const mouse_state_t *ms)
{
	M_Mouse_Select(&load_window, ms, MAX_SAVEGAMES, &load_cursor);

    if (ms->button_up == 1) M_Load_Key(K_MOUSE1);
    if (ms->button_up == 2) M_Load_Key(K_MOUSE2);

    return true;
}

#endif


// ================================
// Multiplayer submenu
// used only if mcharset is not available making demo player menu inaccesible from mainmenu

int    m_multiplayer_cursor;
#define    MULTIPLAYER_ITEMS    2
menu_window_t m_multiplayer_window;

void M_MultiPlayerSub_Draw (void) {
	mpic_t    *p;
	int lx, ly;

	M_DrawTransPic (16, 4, Draw_CachePic (CACHEPIC_QPLAQUE) );
	p = Draw_CachePic (CACHEPIC_P_MULTI);
	M_DrawPic ( (320-p->width)/2, 4, p);
	M_Print_GetPoint (80, 40, &m_multiplayer_window.x, &m_multiplayer_window.y, "Join Game", m_multiplayer_cursor == 0);
	m_multiplayer_window.h = 8;
	M_Print_GetPoint (80, 48, &lx, &ly, "Demos", m_multiplayer_cursor == MULTIPLAYER_ITEMS - 1);
	m_multiplayer_window.h += 8;
	m_multiplayer_window.w = 20 * 8; // presume 20 letters long word and 8 pixels for a letter
	
	// cursor
	M_DrawCharacter (64, 40 + m_multiplayer_cursor * 8, FLASHINGARROW());
}

void M_MultiPlayerSub_Key (int key) {
	switch (key) {
		case K_BACKSPACE:
			m_topmenu = m_none;    // intentional fallthrough
		case K_MOUSE2:
		case K_ESCAPE:
			M_LeaveMenu (m_main);
			break;

		case '`':
		case '~':
			key_dest = key_console;
			m_state = m_none;
			break;

		case K_DOWNARROW:
		case K_MWHEELDOWN:
			S_LocalSound ("misc/menu1.wav");
			if (++m_multiplayer_cursor >= MULTIPLAYER_ITEMS)
				m_multiplayer_cursor = 0;
			break;

		case K_UPARROW:
		case K_MWHEELUP:
			S_LocalSound ("misc/menu1.wav");
			if (--m_multiplayer_cursor < 0)
				m_multiplayer_cursor = MULTIPLAYER_ITEMS - 1;
			break;

		case K_HOME:
		case K_PGUP:
			S_LocalSound ("misc/menu1.wav");
			m_multiplayer_cursor = 0;
			break;

		case K_END:
		case K_PGDN:
			S_LocalSound ("misc/menu1.wav");
			m_multiplayer_cursor = MULTIPLAYER_ITEMS - 1;
			break;

		case K_ENTER:
		case K_MOUSE1:
			m_entersound = true;
			switch (m_multiplayer_cursor) {
				case 0:
					M_EnterMenu(m_multiplayer);
					break;
				case 1:
					M_Menu_Demos_f ();
					break;
			}
	}
}

qbool M_MultiPlayerSub_Mouse_Event(const mouse_state_t *ms)
{
	M_Mouse_Select(&m_multiplayer_window, ms, MULTIPLAYER_ITEMS, &m_multiplayer_cursor);

    if (ms->button_up == 1) M_MultiPlayerSub_Key(K_MOUSE1);
    if (ms->button_up == 2) M_MultiPlayerSub_Key(K_MOUSE2);
    
    return true;
}

void M_Menu_Browser_f (void) {
	M_EnterMenu(m_multiplayer);
}

void M_Menu_MultiPlayer_f (void)
{
	if (Draw_BigFontAvailable()) {
		M_EnterMenu(m_multiplayer);
	}
	else {
		// demos entry is not accessible with old main menu
		// so we need to create a submenu in the multiplayer menu
		M_EnterMenu(m_multiplayer_submenu);
	}
}

void M_Menu_Demos_f (void)
{
	M_EnterMenu(m_demos); // switches client state
}

//=============================================================================
/* Menu Subsystem */

void M_Init (void) {
	extern cvar_t menu_marked_bgcolor;
	extern cvar_t menu_marked_fade;

	Cvar_SetCurrentGroup(CVAR_GROUP_MENU);
	Cvar_Register(&scr_centerMenu);
	Cvar_Register(&menu_ingame);
	Cvar_Register(&scr_scaleMenu);
	Cvar_Register(&menu_marked_fade);
	Cvar_Register(&menu_botmatch_gamedir);
	Cvar_Register(&menu_botmatch_mod_old);

	Cvar_Register(&menu_marked_bgcolor);
	Browser_Init();
	Cvar_ResetCurrentGroup();
	Menu_Help_Init();	// help_files module
	Menu_Demo_Init();	// menu_demo module
	Menu_Options_Init(); // menu_options module
	Menu_Ingame_Init();
	Menu_MultiPlayer_Init(); // menu_multiplayer.h

	Cmd_AddCommand ("togglemenu", M_ToggleMenu_f);
	Cmd_AddCommand ("toggleproxymenu", M_ToggleProxyMenu_f);

	Cmd_AddCommand ("menu_main", M_Menu_Main_f);
#ifndef CLIENTONLY
	Cmd_AddCommand ("menu_singleplayer", M_Menu_SinglePlayer_f);
	Cmd_AddCommand ("menu_load", M_Menu_Load_f);
	Cmd_AddCommand ("menu_save", M_Menu_Save_f);
#endif
	Cmd_AddCommand ("menu_multiplayer", M_Menu_MultiPlayer_f);
	Cmd_AddCommand ("menu_slist", M_Menu_Browser_f);
	Cmd_AddCommand ("menu_demos", M_Menu_Demos_f);
	Cmd_AddCommand ("menu_options", M_Menu_Options_f);
	Cmd_AddCommand ("help", M_Menu_Help_f);
	Cmd_AddCommand ("menu_help", M_Menu_Help_f);
	Cmd_AddCommand ("menu_quit", M_Menu_Quit_f);
}

void M_Shutdown(void)
{
	Menu_Help_Shutdown();
	Menu_Demo_Shutdown();
	Menu_Options_Shutdown();
	Menu_Ingame_Shutdown();
	Menu_MultiPlayer_Shutdown();
}

void M_Draw(void)
{
	if (m_state == m_none || key_dest != key_menu || m_state == m_proxy) {
		return;
	}

	scr_copyeverything = 1;

	if (SCR_NEED_CONSOLE_BACKGROUND) {
		Draw_ConsoleBackground(scr_con_current);
	}
	else {
		// if you don't like fade in ingame menu, uncomment this
		// if (m_state != m_ingame && m_state != m_democtrl)
		Draw_FadeScreen(scr_menualpha.value);
	}

	scr_fullupdate = 0;

	if (scr_scaleMenu.value) {
		if (vid.aspect > 1.0) {
			menuheight = bound(240, (int)((vid.height / scr_scaleMenu.value) + 0.5f), 960);
			menuwidth = (int)((menuheight * vid.aspect) + 0.5f);
		}
		else {
			menuwidth = bound(320, (int)((vid.width / scr_scaleMenu.value) + 0.5f), 960);
			menuheight = (int)((menuwidth / vid.aspect) + 0.5f);
		}

		R_OrthographicProjection(0, menuwidth, menuheight, 0, -99999, 99999);
	}
	else {
		menuwidth = vid.width;
		menuheight = vid.height;
	}

	if (scr_centerMenu.value) {
		m_yofs = (menuheight - 200) / 2;
	}
	else {
		m_yofs = 0;
	}

	switch (m_state) {
		case m_none: break;
		case m_main:			M_Main_Draw(); break;
		case m_singleplayer:	M_SinglePlayer_Draw(); break;
#ifndef CLIENTONLY
		case m_load:			M_Load_Draw(); break;
		case m_save:			M_Save_Draw(); break;
#else
			// keeps gcc happy
		case m_load:
		case m_save:
			break;
#endif
		case m_multiplayer:		Menu_MultiPlayer_Draw(); break;
		case m_multiplayer_submenu: M_MultiPlayerSub_Draw(); break;
		case m_options:			M_Options_Draw(); break;
		case m_proxy:			Menu_Proxy_Draw(); break;
		case m_ingame:			M_Ingame_Draw(); break;
		case m_help:			M_Help_Draw(); break;
		case m_quit:			M_Quit_Draw(); break;
		case m_demos:			Menu_Demo_Draw(); break;
	}

	if (scr_scaleMenu.value) {
		R_OrthographicProjection(0, vid.width, vid.height, 0, -99999, 99999);
	}

	if (m_entersound) {
		S_LocalSound("misc/menu2.wav");
		m_entersound = false;
	}
}

// Return true if the system should execute the key, false if we want it to pass to M_Keydown
qbool Menu_ExecuteKey (int key) {
	// This always turns into /togglemenu anyway
	if (key == K_ESCAPE) {
		return true;
	}

	// Capture all keypresses when binding
	if (Menu_Options_IsBindingKey ()) {
		return false;
	}

	// Capture F1 in menus that have help boxes
	if (key == K_F1 && m_state != m_ingame) {
		return false;
	}

	// Other function keys should execute
	if (key >= K_F1 && key <= K_F12)
		return true;

	// Capture everything else
	return false;
}

void M_Keydown (int key, wchar unichar) {
	switch (m_state) {
		case m_none: return;
		case m_main:			M_Main_Key(key); return;
		case m_singleplayer:	M_SinglePlayer_Key(key); return;
#ifndef CLIENTONLY
		case m_load:			M_Load_Key(key); return;
		case m_save:			M_Save_Key(key); return;
#else
		case m_load:
		case m_save:
			break;
#endif
		case m_multiplayer:		Menu_MultiPlayer_Key(key, unichar); return;
		case m_multiplayer_submenu: M_MultiPlayerSub_Key(key); return;
		case m_options: 		M_Options_Key(key, unichar); return;
		case m_proxy:			M_Proxy_Key(key); return;
		case m_ingame:			M_Ingame_Key(key); return;
		case m_help:			Menu_Help_Key(key, unichar); return;
		case m_quit:			M_Quit_Key(key); return;
		case m_demos:			Menu_Demo_Key(key, unichar); break;
	}
}

qbool Menu_Mouse_Event(const mouse_state_t* ms)
{
	if (ms->button_down == K_MWHEELDOWN || ms->button_up == K_MWHEELDOWN ||
		ms->button_down == K_MWHEELUP   || ms->button_up == K_MWHEELUP)
	{
		// menus do not handle this type of mouse wheel event, they accept it as a key event	
		return false;
	}

	// send the mouse state to appropriate modules here
    // functions should report if they handled the event or not
    switch (m_state) {
	case m_main:			return M_Main_Mouse_Event(ms);
#ifndef CLIENTONLY
	case m_singleplayer:	return M_SinglePlayer_Mouse_Event(ms);
#endif
	case m_multiplayer:		return Menu_MultiPlayer_Mouse_Event(ms);
	case m_multiplayer_submenu: return M_MultiPlayerSub_Mouse_Event(ms);
#ifndef CLIENTONLY
	case m_load:			return M_Load_Mouse_Event(ms);
	case m_save:			return M_Save_Mouse_Event(ms);
#endif
	case m_options:			return Menu_Options_Mouse_Event(ms);
	case m_demos:			return Menu_Demo_Mouse_Event(ms);
	case m_ingame:			return Menu_Ingame_Mouse_Event(ms);
	case m_help:			return Menu_Help_Mouse_Event(ms);
	case m_none: default:	return false;
	}
}


================================================
FILE: src/menu.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: menu.h,v 1.22 2007-10-17 17:08:26 dkure Exp $

*/

#ifndef __MENU_H__
#define __MENU_H__

#include "keys.h"

#define OPTPADDING 4

//
// menus
//
void M_Init (void);
void M_Keydown (int key, wchar unichar);
void M_Draw (void);
void M_ToggleMenu_f (void);
void M_LeaveMenus (void);
void M_LeaveMenu (int parent);
void M_EnterMenu (int state);
void M_Menu_Main_f (void);
void M_EnterProxyMenu (void);
void M_DrawTextBox (int x, int y, int width, int lines);
void M_Menu_Quit_f (void);
void M_Demos_Playlist_stop_f (void);
void M_Menu_ServerList_f (void);
void M_DrawTransPic (int x, int y, mpic_t *pic);
void M_DrawPic (int x, int y, mpic_t *pic);
void M_PrintWhite (int cx, int cy, char *str);
void M_Print (int cx, int cy, char *str);
void M_DrawCharacter (int cx, int line, int num);
void M_DrawSlider (int x, int y, float range);
void M_FindKeysForCommand (const char *command, int *twokeys);
void M_BuildTranslationTable(int top, int bottom);
void M_Unscale_Menu(void);
qbool Menu_Mouse_Event(const mouse_state_t* ms);
qbool Menu_ExecuteKey(int key);

extern int m_yofs;

#define FLASHINGARROW() (12+((int)(curtime*4)&1))
#define FLASHINGCURSOR() (10+((int)(curtime*4)&1))

typedef enum {
    m_none, m_main, m_proxy, m_singleplayer, m_load, m_save,
	m_multiplayer, m_demos, m_multiplayer_submenu,
    m_options,
	m_help,
	m_quit, m_ingame, 
} m_state_t;

extern m_state_t m_state;

void M_Shutdown(void);

#endif // __MENU_H_


================================================
FILE: src/menu_demo.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
	Demo Menu module

	Stands between menu.c and Ctrl_Tab.c

	Naming convention:
	function mask | usage    | purpose
	--------------|----------|-----------------------------
	Menu_Demo_*   | external | interface for menu.c
	CT_Demo_*     | external | interface for Ctrl_Tab.c
	CL_Demo_*_f   | external | interface for cl_demo.c
	M_Demo_*_f    | external | commands issued by the user
	Demo_         | internal | internal (static) functions

	made by:
		johnnycz, Dec 2006
*/

#include "quakedef.h"
#include "gl_model.h"
#include "settings.h"
#include "settings_page.h"
#include "EX_FileList.h"
#include "Ctrl.h"
#include "Ctrl_Tab.h"
#include "menu.h"
#include "keys.h"

#include "hash.h"
#include "fs.h"
#include "vfs.h"

#ifdef _WIN32
#define DEMO_TIME                 FILETIME
#else
#define DEMO_TIME                 time_t
#endif

//unused
//#define MAX_DEMO_NAME           MAX_OSPATH
//#define MAX_DEMO_FILES          2048
#define DEMO_MAXLINES             17

#define DEMO_PLAYLIST_NAME_MAX    16
#define DEMO_PLAYLIST_OPTIONS_MAX 5
#define	DEMO_PLAYLIST_MAX         256
#define DEMO_PLAYLIST_TAB_MAIN    0

#define DEMO_OPTIONS_MAX          2

#define DEMO_TAB_MAIN             0
#define DEMO_TAB_PLAYLIST         1
#define DEMO_TAB_OPTIONS          2
#define DEMO_TAB_MAX              2

extern int mvd_demo_track_run;

typedef enum
{
    DEMOPG_BROWSER,		// Browse page
	DEMOPG_PLAYLIST,	// Playlist page
	DEMOPG_ENTRY,		// Entry page
	DEMOPG_OPTIONS		// Options page
}	demo_tab_t;

typedef struct demo_playlist_s
{
	char name[MAX_PATH];
	char path[MAX_PATH];
	char trackname[DEMO_PLAYLIST_NAME_MAX];
} demo_playlist_t;

extern cvar_t     scr_scaleMenu;
extern int        menuwidth;
extern int        menuheight;

// Demo browser container
filelist_t demo_filelist;

// Demo menu container
CTab_t demo_tab;

// Playlist structures
demo_playlist_t demo_playlist[DEMO_PLAYLIST_MAX]; // TODO: A play list probably shouldn't be tied to a GUI, put this in cl_demo.c instead and allow adding demos from the console also.

char track_name[DEMO_PLAYLIST_NAME_MAX];
char default_track[DEMO_PLAYLIST_NAME_MAX];
qbool demo_playlist_started = false;

cvar_t    demo_playlist_loop = {"demo_playlist_loop","0"};
cvar_t    demo_playlist_track_name = {"demo_playlist_track_name",""};

// demo playlist options
settings_page demoplsett;
setting demoplsett_arr[] = {
	ADDSET_SEPARATOR("Playlist options"),
	ADDSET_BOOL("looping", demo_playlist_loop),
	ADDSET_STRING("default track", demo_playlist_track_name)
};

static int demo_playlist_base = 0;
static int demo_playlist_current_played = 0;
static int demo_playlist_cursor = 0;
static int demo_playlist_num = 0;
static int demo_playlist_opt_cursor = 0;
static int demo_playlist_started_test = 0;

char demo_track[DEMO_PLAYLIST_NAME_MAX];

// Demo Playlist Functions
static void M_Demo_Playlist_stop_f (void)
{
	if (!demo_playlist_started_test)
	{
		demo_playlist_started = false;
		demo_playlist_started_test = 0;
	}
}

static void Demo_Playlist_Start (int i)
{
	key_dest = key_game;
	m_state = m_none;
	demo_playlist_current_played = i;
	demo_playlist_started_test = 0 ;

	if (cls.demoplayback)
	{
		CL_Disconnect_f();
	}

	demo_playlist_started_test = 0 ;
	demo_playlist_started = true;
	strlcpy(track_name, demo_playlist[demo_playlist_current_played].trackname, sizeof(track_name));
	Cbuf_AddText (va("playdemo \"%s\"\n", demo_playlist[demo_playlist_current_played].path));
}

void CL_Demo_Playlist_f (void)
{
	demo_playlist_current_played++;

	strlcpy (track_name, demo_playlist[demo_playlist_current_played].trackname, sizeof(track_name));

	if (demo_playlist_current_played == demo_playlist_num  && demo_playlist_loop.value )
	{
		demo_playlist_current_played = 0;
		Cbuf_AddText (va("playdemo \"%s\"\n", demo_playlist[demo_playlist_current_played].path));
	}
	else if (demo_playlist_current_played == demo_playlist_num )
	{
		Com_Printf("End of demo playlist.\n");
		demo_playlist_started = false;
		demo_playlist_current_played = 0;
	}
	else
	{
		Cbuf_AddText (va("playdemo \"%s\"\n", demo_playlist[demo_playlist_current_played].path));
	}
}

void M_Demo_Playlist_Next_f (void)
{
	int tmp;

	if (!demo_playlist_started)
	{
		return;
	}

	tmp = demo_playlist_current_played + 1 ;

	if (tmp > demo_playlist_num - 1)
	{
		tmp = 0 ;
	}

	Demo_Playlist_Start(tmp);
}

void M_Demo_Playlist_Prev_f (void)
{
	int tmp;
	if (!demo_playlist_started)
	{
		return;
	}

	tmp = demo_playlist_current_played - 1 ;

	if (tmp < 0)
	{
		tmp = demo_playlist_num - 1 ;
	}

	Com_Printf("Prev %i\n", tmp);
	Demo_Playlist_Start(tmp);
}

void M_Demo_Playlist_Clear_f (void)
{
	if (demo_playlist_num == 0)
	{
		return;
	}

	memset (&demo_playlist, 0, sizeof(demo_playlist_t) * demo_playlist_num);

	demo_playlist_num = 0;
	demo_playlist_started = false;
}

void M_Demo_Playlist_Stop_f (void)
{
	M_Demo_Playlist_stop_f();
	Cbuf_AddText("disconnect\n");
}

static void Demo_Playlist_Setup_f (void)
{
	strlcpy (demo_track, demo_playlist[demo_playlist_cursor + demo_playlist_base].trackname, sizeof(demo_track));
	strlcpy (default_track, demo_playlist_track_name.string, min(16, sizeof(default_track)));
}

//
// Delete the current entry from the playlist.
//
static void Demo_Playlist_Del(int i)
{
	int y;

	if (i >= DEMO_PLAYLIST_MAX) {
		Com_Printf("Error: demo playlist item %d out of range (%d)\n", i, DEMO_PLAYLIST_MAX);
		return;
	}

	// Remove the playlist item.
	memset (&demo_playlist[i], 0, sizeof(demo_playlist[i]));

	for (y = i; y < (DEMO_PLAYLIST_MAX - 1) && demo_playlist[y+1].name[0] != '\0'; y++ )
	{
		memmove (&demo_playlist[y], &demo_playlist[y+1], sizeof(demo_playlist[y]));
		memset (&demo_playlist[y+1], 0, sizeof(demo_playlist[y+1]));
	}

	demo_playlist_num--;
	demo_playlist_num = max(0, demo_playlist_num);

	demo_playlist_cursor = bound(0, demo_playlist_cursor, demo_playlist_num - 1);
}

//
// Move the selected entry up a step in the playlist.
//
static void Demo_Playlist_Move_Up (int i)
{
	demo_playlist_t tmp;

	if (i == 0)
	{
		return;
	}

	memcpy (&tmp, &demo_playlist[i-1], sizeof(tmp));
	memcpy (&demo_playlist[i-1], &demo_playlist[i], sizeof(demo_playlist[i-1]));
	memcpy (&demo_playlist[i], &tmp, sizeof(demo_playlist[i]));
}

//
// Move the selected entry down a step in the playlist.
//
static void Demo_Playlist_Move_Down (int i)
{
	demo_playlist_t tmp;

	if(i + 1 == demo_playlist_num)
	{
		return;
	}

	memcpy (&tmp, &demo_playlist[i+1], sizeof(tmp));
	memcpy (&demo_playlist[i+1], &demo_playlist[i], sizeof(demo_playlist[i+1]));
	memcpy (&demo_playlist[i], &tmp, sizeof(demo_playlist[i]));
}

//
// Select the previous entry in the playlist.
//
static void Demo_Playlist_SelectPrev(void)
{
	demo_playlist_cursor -= DEMO_MAXLINES - 1;
	if (demo_playlist_cursor < 0)
	{
		demo_playlist_base += demo_playlist_cursor;
		demo_playlist_base = max (0, demo_playlist_base);
		demo_playlist_cursor = 0;
	}

	Demo_Playlist_Setup_f();
}

static void Demo_Playlist_SelectNext(void)
{
	demo_playlist_cursor += DEMO_MAXLINES - 1;

	if (demo_playlist_base + demo_playlist_cursor >= demo_playlist_num)
	{
		demo_playlist_cursor = demo_playlist_num - demo_playlist_base - 1;
	}

	if (demo_playlist_cursor >= DEMO_MAXLINES)
	{
		demo_playlist_base += demo_playlist_cursor - (DEMO_MAXLINES - 1);
		demo_playlist_cursor = DEMO_MAXLINES - 1;

		if (demo_playlist_base + demo_playlist_cursor >= demo_playlist_num)
		{
			demo_playlist_base = demo_playlist_num - demo_playlist_cursor - 1;
		}
	}

	Demo_Playlist_Setup_f();
}

/*
static void Demo_FormatSize (char *t) {
	char *s;

	for (s = t; *s; s++) {
		if (*s >= '0' && *s <= '9')
			*s = *s - '0' + 18;
		else
			*s |= 128;
	}
}
*/

// ============
// <draw pages>

void CT_Demo_Browser_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
    FL_Draw(&demo_filelist, x, y, w, h);
}


void CT_Demo_Playlist_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	int i, y2;

	if(demo_playlist_num == 0)
	{
		UI_Print_Center(x, y + 16, w, "Playlist is empty", false);
		UI_Print_Center(x, y + 32, w, "Use [Insert] or [Ctrl]+[Enter]", true);
		UI_Print_Center(x, y + 40, w, "in the demo browser to add a demo", true);
		// UI_Print_Center(x, y + 40, w, "to add demo to the playlist", true);
	}
	else
	{
		y = y - 48;
		for (i = 0; i <= demo_playlist_num - demo_playlist_base && i < DEMO_MAXLINES; i++)
		{
			y2 = 32 + i * 8 ;

			if (demo_playlist_cursor == i)
				M_Print (24, y + y2, demo_playlist[demo_playlist_base + i].name);
			else
				M_PrintWhite (24, y + y2, demo_playlist[demo_playlist_base + i].name);
		}

		M_DrawCharacter (8, y + 32 + demo_playlist_cursor * 8, FLASHINGARROW());
	}
}

void CT_Demo_Entry_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	int z;
	y = y - 32;

	if (demo_playlist_started && cls.demoplayback)
	{
		M_Print (24, y + 32, "Currently playing:");
		M_PrintWhite (24, y + 40, demo_playlist[demo_playlist_current_played].name);
	}
	else
	{
		M_Print (24, y + 32, "Not playing anything");
	}

	M_Print (24, y + 56, "Next     demo");
	M_Print (24, y + 64, "Previous demo");
	M_Print (24, y + 72, "Stop  playlist");
	M_Print (24, y + 80, "Clear playlist");

	if (demo_playlist_num > 0)
	{
		M_Print (24, y + 96, "Currently selected:");
		M_Print (24, y + 104, demo_playlist[demo_playlist_cursor].name);
	}
	else
	{
		M_Print (24, y + 96, "No demo in playlist");
	}

	if (strcasecmp(demo_playlist[demo_playlist_cursor].name + strlen(demo_playlist[demo_playlist_cursor].name) - 4, ".mvd"))
	{
		M_Print (24, y + 120, "Tracking only available with mvds");
	}
	else
	{
		M_Print (24, y + 120, "Track");
		M_DrawTextBox (160, y + 112, 16, 1);
		M_PrintWhite (168, y + 120, demo_track);
		if (demo_playlist_opt_cursor == 4 && demo_playlist_num > 0)
			M_DrawCharacter (168 + 8*strlen(demo_track), 120 + y, FLASHINGCURSOR());
	}

	z = demo_playlist_opt_cursor + (demo_playlist_opt_cursor >= 4 ? 4 : 0);
	z = y + 56 + z * 8;
	M_DrawCharacter (8, z, FLASHINGARROW());
}

void CT_Demo_Options_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	Settings_Draw(x, y, w, h, &demoplsett); 
}

#define DEMOPAGEPADDING 4

// in the end leads calls one of the four functions above
void Menu_Demo_Draw (void)
{
	extern void Demo_Draw(int, int, int, int);

	int x, y, w, h;

	M_Unscale_Menu();

    // don't add padding on the right side so the scrolling is friendly
	w = vid.width - DEMOPAGEPADDING; // here used to be a limit to 512x... size, we've considered it useless
	h = vid.height - DEMOPAGEPADDING*2;
	x = DEMOPAGEPADDING;
	y = DEMOPAGEPADDING;

	CTab_Draw(&demo_tab, x, y, w, h);
}
// </draw pages>
// =============

static void Demo_AddDemoToPlaylist(const char* display_name, const char* path)
{
	if (demo_playlist_num >= DEMO_PLAYLIST_MAX) {
		Com_Printf("Playlist is full, cannot add \"%s\" to it. Max allowed demos in playlist is %d\n", display_name, DEMO_PLAYLIST_MAX);
		return;
	}

	snprintf(demo_playlist[demo_playlist_num].name, sizeof((*demo_playlist).name), "%s", display_name);
	snprintf(demo_playlist[demo_playlist_num].path, sizeof((*demo_playlist).path), "%s", path);
	demo_playlist_num++;
}

void Demo_AddDirToPlaylist (char *dir_path)
{
	extern void FL_ReadDir(filelist_t *fl);
	int i;
	filelist_t dir_filelist;

	if (!dir_path) {
		return;
	}

	// Bit of a hack, but we need values for cvars and what not for the FL_ functions to work
	// so borrow them from demo_filelist.
	memcpy (&dir_filelist, &demo_filelist, sizeof(dir_filelist));

	FL_SetCurrentDir (&dir_filelist, dir_path);
	FL_ReadDir (&dir_filelist);

	// Find the demos and add them to the playlist.
	for (i = 0; i < dir_filelist.num_entries; i++)
	{
		filedesc_t *f = &dir_filelist.entries[i];

		// Don't bother with zips and directories.
		if (f->is_directory
#ifdef WITH_ZIP
			|| f->is_archive
#endif
			)
		{
			// TODO: Make this recursive for dirs?
			continue;
		}

		Demo_AddDemoToPlaylist (f->display, f->name);
	}
}

#ifdef WITH_ZIP
void Demo_AddZipToPlaylist(const char *zip_path)
{
	unz_global_info global_info;
	unzFile         zip_file;
	char            filename[MAX_PATH_LENGTH];
	unz_file_info   file_info;
	char            full_queued_path[MAX_PATH_LENGTH];

	// Unpack the files to a temp path.
	zip_file = FS_ZipUnpackOpenFile(zip_path);

	// Get the number of files in the zip archive.
	if (unzGetGlobalInfo(zip_file, &global_info) == UNZ_OK) {
		int i;

		for (i = 0; i < global_info.number_entry; ++i) {
			if (i && unzGoToNextFile(zip_file) != UNZ_OK) {
				break;
			}

			if (unzGetCurrentFileInfo(zip_file, &file_info, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK) {
				break;
			}

			if (!CL_DemoExtensionMatch(filename)) {
				continue;
			}

			strlcpy(full_queued_path, zip_path, sizeof(full_queued_path));
			strlcat(full_queued_path, "/", sizeof(full_queued_path));
			strlcat(full_queued_path, filename, sizeof(full_queued_path));
			Demo_AddDemoToPlaylist(COM_SkipPath(filename), filename);
		}
	}
}
#endif // WITH_ZIP

// ==============================
// <key processing for each page>

int CT_Demo_Browser_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	extern void M_ToggleMenu_f (void);
	extern void M_LeaveMenu (int);
    qbool processed = false;

	// Special case for adding zips/dirs to playlist.
	if (key == K_INS || (key == K_ENTER && keydown[K_CTRL]))
	{
		#ifdef WITH_ZIP
		if (FS_IsArchive (FL_GetCurrentPath(&demo_filelist)))
		{
			// Zip.
			Demo_AddZipToPlaylist (FL_GetCurrentPath(&demo_filelist));
			return true;
		}
		else
		#endif // WITH_ZIP
		{
			if (FL_IsCurrentDir (&demo_filelist))
			{
				// Dir.
				Demo_AddDirToPlaylist (FL_GetCurrentPath(&demo_filelist));
				return true;
			}
		}
	}

	// See if the main filebrowser functions wants to
	// do something first, like enter a dir/zip.
    processed = FL_Key(&demo_filelist, key);

    if (!processed)
    {
		if (key == K_INS)
		{
			// Add the selected demo to the playlist.
			Demo_AddDemoToPlaylist (FL_GetCurrentDisplay (&demo_filelist), FL_GetCurrentPath (&demo_filelist));
		}
        else if (key == K_ENTER || key == K_MOUSE1)
        {
			if (keydown[K_CTRL])
			{
				// Add the selected demo to the playlist.
				Demo_AddDemoToPlaylist (FL_GetCurrentDisplay (&demo_filelist), FL_GetCurrentPath (&demo_filelist));
			}
			else if (keydown[K_SHIFT])
			{
				M_LeaveMenus();
				Cbuf_AddText (va("timedemo \"%s\"\n", FL_GetCurrentPath(&demo_filelist)));
			}
			else
			{
				M_LeaveMenus();
				Cbuf_AddText(va("playdemo \"%s\"\n", FL_GetCurrentPath(&demo_filelist)));
				processed = true;
			}
        }
    }

    return processed;
}

int CT_Demo_Playlist_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	switch (key)
	{
		case K_UPARROW:
		case K_MWHEELUP:
		{
			if (keydown[K_CTRL] && demo_playlist_cursor + demo_playlist_base > 0)
				Demo_Playlist_Move_Up(demo_playlist_cursor + demo_playlist_base);

			if (demo_playlist_cursor > 0)
			{
				demo_playlist_cursor--;
			}
			else if (demo_playlist_base > 0)
			{
				demo_playlist_base--;
			}

			Demo_Playlist_Setup_f();
			break;
		}
		case K_DOWNARROW:
		case K_MWHEELDOWN:
		{
			if (keydown[K_CTRL] && demo_playlist_cursor + demo_playlist_base < demo_playlist_num)
				Demo_Playlist_Move_Down(demo_playlist_cursor + demo_playlist_base);

			if (demo_playlist_cursor + demo_playlist_base < demo_playlist_num - 1)
			{
				if (demo_playlist_cursor < DEMO_MAXLINES - 1)
					demo_playlist_cursor++;
				else
					demo_playlist_base++;
			}
			Demo_Playlist_Setup_f();
			break;
		}
		case K_HOME:
		{
			demo_playlist_cursor = 0;
			demo_playlist_base = 0;
			Demo_Playlist_Setup_f();
			break;
		}
		case K_END:
		{
			if (demo_playlist_num > DEMO_PLAYLIST_OPTIONS_MAX)
			{
				demo_playlist_cursor = DEMO_PLAYLIST_OPTIONS_MAX - 1;
				demo_playlist_base = demo_playlist_num - demo_playlist_cursor - 1;
			}
			else
			{
				demo_playlist_base = 0;
				demo_playlist_cursor = demo_playlist_num - 1;
			}
			Demo_Playlist_Setup_f();
			break;
		}
		case K_PGUP:
		{
			Demo_Playlist_SelectPrev();
			break;
		}
		case K_PGDN:
		{
			Demo_Playlist_SelectNext();
			break;
		}
		case K_ENTER:
		{
			Demo_Playlist_Start(demo_playlist_cursor + demo_playlist_base);
			break;
		}
		case K_DEL:
		{
			Demo_Playlist_Del(demo_playlist_cursor + demo_playlist_base);
			break;
		}
		default:
			return false;
	}

	return true;
}

int CT_Demo_Entry_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	int l;

	switch (key)
	{
		case K_LEFTARROW: return false;
		case K_RIGHTARROW: return false;
		case K_UPARROW:
		case K_MWHEELUP:
		{
			demo_playlist_opt_cursor = demo_playlist_opt_cursor ? demo_playlist_opt_cursor - 1 : DEMO_PLAYLIST_OPTIONS_MAX - 1;
			break;
		}
		case K_DOWNARROW:
		case K_MWHEELDOWN:
		{
			demo_playlist_opt_cursor++;
			demo_playlist_opt_cursor = demo_playlist_opt_cursor % DEMO_PLAYLIST_OPTIONS_MAX;
			break;
		}
		case K_PGUP:
		{
			Demo_Playlist_SelectPrev();
			break;
		}
		case K_PGDN:
		{
			Demo_Playlist_SelectNext();
			break;
		}
		case K_ENTER:
		{
			if (demo_playlist_opt_cursor == 0)
				M_Demo_Playlist_Next_f();
			else if (demo_playlist_opt_cursor == 1)
				M_Demo_Playlist_Prev_f();
			else if (demo_playlist_opt_cursor == 2)
				M_Demo_Playlist_Stop_f();
			else if (demo_playlist_opt_cursor == 3)
				M_Demo_Playlist_Clear_f();
			break;
		}
		case K_BACKSPACE:
		{
			if (demo_playlist_opt_cursor == 4)
			{
				if (strlen(demo_track))
					demo_track[strlen(demo_track)-1] = 0;
				strlcpy(demo_playlist[demo_playlist_cursor + demo_playlist_base].trackname,demo_track,sizeof(demo_playlist->trackname));
			}
			break;
		}
		default:
		{
			if (key < 32 || key > 127)
				return false;

			if (demo_playlist_opt_cursor == 4)
			{
				l = strlen(demo_track);
				if (l < 15)
				{
					demo_track[l+1] = 0;
					demo_track[l] = key;
					strlcpy(demo_playlist[demo_playlist_cursor + demo_playlist_base].trackname,demo_track,sizeof(demo_playlist->trackname));
				}
				return true;
			}
			else
			{
				return false;
			}
		}
	}

	return true;
}

int CT_Demo_Options_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	return Settings_Key(&demoplsett, key, unichar);
}

qbool CT_Demo_Browser_Mouse_Event(const mouse_state_t *ms)
{
    if (FL_Mouse_Event(&demo_filelist, ms)) {
        return true;
    } else if (ms->button_up >= 1 && ms->button_up <= 2) {
        CT_Demo_Browser_Key(K_MOUSE1 - 1 + ms->button_up, 0, &demo_tab, demo_tab.pages + DEMOPG_BROWSER);
        return true;
    }

    // this specially "eats" button_up event, there is no reason to process other events anyway
	return true;
}

qbool CT_Demo_Options_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&demoplsett, ms);
}

// will lead to call of one of the 4 functions above
void Menu_Demo_Key(int key, wchar unichar)
{
	extern void M_Menu_Main_f (void);

    int handled = CTab_Key(&demo_tab, key, unichar);

    if (!handled)
    {
		if (key == K_ESCAPE || key == K_MOUSE2)
        {
            M_Menu_Main_f();
        }
    }
}
// </key processing for each page>

qbool Menu_Demo_Mouse_Event(const mouse_state_t *ms)
{
	mouse_state_t nms = *ms;

    if (ms->button_up == 2) {
        Menu_Demo_Key(K_MOUSE2, 0);
        return true;
    }

	nms.x -= DEMOPAGEPADDING;
	nms.y -= DEMOPAGEPADDING;
	nms.x_old -= DEMOPAGEPADDING;
	nms.y_old -= DEMOPAGEPADDING;
	return CTab_Mouse_Event(&demo_tab, &nms);
}

CTabPage_Handlers_t demo_browser_handlers = {
	CT_Demo_Browser_Draw,
	CT_Demo_Browser_Key,
	NULL,
	CT_Demo_Browser_Mouse_Event
};

CTabPage_Handlers_t demo_playlist_handlers = {
	CT_Demo_Playlist_Draw,
	CT_Demo_Playlist_Key
};

CTabPage_Handlers_t demo_entry_handlers = {
	CT_Demo_Entry_Draw,
	CT_Demo_Entry_Key
};

CTabPage_Handlers_t demo_options_handlers = {   
	CT_Demo_Options_Draw,
	CT_Demo_Options_Key,
	NULL,
	CT_Demo_Options_Mouse_Event
};

// set new initial dir
void Menu_Demo_NewHome(const char *homedir)
{
	FL_SetCurrentDir(&demo_filelist, homedir);
}

void Menu_Demo_Init(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	Cvar_Register (&demo_playlist_loop);
	Cvar_Register (&demo_playlist_track_name);
	Cvar_ResetCurrentGroup();

	Cmd_AddCommand ("demo_playlist_stop", M_Demo_Playlist_Stop_f);
	Cmd_AddCommand ("demo_playlist_next", M_Demo_Playlist_Next_f);
	Cmd_AddCommand ("demo_playlist_prev", M_Demo_Playlist_Prev_f);
	Cmd_AddCommand ("demo_playlist_clear", M_Demo_Playlist_Clear_f);

	FL_Init(&demo_filelist, "./qw");
    FL_AddFileType(&demo_filelist, 0, ".qwd");
	FL_AddFileType(&demo_filelist, 1, ".qwz");
	FL_AddFileType(&demo_filelist, 2, ".mvd");
	FL_AddFileType(&demo_filelist, 3, ".dem");
	#ifdef WITH_ZLIB
	FL_AddFileType(&demo_filelist, 4, ".gz");
	#endif // WITH_ZLIB
	#ifdef WITH_ZIP
	FL_AddFileType(&demo_filelist, 4, ".zip");
	FL_AddFileType(&demo_filelist, 4, ".pk3");
	#endif // WITH_ZIP

	Settings_Page_Init(demoplsett, demoplsett_arr);

	// initialize tab control
    CTab_Init(&demo_tab);
	CTab_AddPage(&demo_tab, "Browser", DEMOPG_BROWSER, &demo_browser_handlers);
	CTab_AddPage(&demo_tab, "Playlist", DEMOPG_PLAYLIST, &demo_playlist_handlers);
	CTab_AddPage(&demo_tab, "Entry", DEMOPG_ENTRY, &demo_entry_handlers);
	CTab_AddPage(&demo_tab, "Options", DEMOPG_OPTIONS, &demo_options_handlers);
	CTab_SetCurrentId(&demo_tab, DEMOPG_BROWSER);
}

void Menu_Demo_Shutdown(void)
{
	FL_Shutdown(&demo_filelist);
	Settings_Shutdown(&demoplsett);
}

void CL_Demo_NextInPlaylist(void)
{
	if (demo_playlist_started) {
		CL_Demo_Playlist_f();
		mvd_demo_track_run = 0;
	}
}

void CL_Demo_Disconnected(void)
{
	demo_playlist_started = false;
	mvd_demo_track_run = 0;
}


================================================
FILE: src/menu_demo.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
	Demo Menu module
	$Id: menu_demo.h,v 1.8 2007-03-19 13:23:20 johnnycz Exp $
*/

#include "keys.h"

// <interface for menu.c>
// initializes the "Demo" menu on client startup
void Menu_Demo_Init(void);

// process key press that belongs to demo menu
void Menu_Demo_Key(int key, wchar unichar);

// process request to draw the demo menu
void Menu_Demo_Draw (void);

// process mouse move event
qbool Menu_Demo_Mouse_Event(const mouse_state_t *);

// sets new starting dir
void Menu_Demo_NewHome(const char *);
// </interface>


// <interface for cl_demo.c>
void CL_Demo_Playlist_f(void);
void CL_Demo_NextInPlaylist(void);
void CL_Demo_Disconnected(void);
// </interface>


================================================
FILE: src/menu_ingame.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
	\file

	\brief
	In-game menu

	\author
	johnnycz
**/

#include "quakedef.h"
#include "keys.h"
#include "menu.h"
#include "Ctrl.h"
#include "settings.h"
#include "settings_page.h"
#include "server.h"
#include "version.h"

#define TOPMARGIN (6*LETTERWIDTH)

settings_page single_menu;
settings_page ingame_menu;
settings_page democtrl_menu;
settings_page botmatch_menu;
settings_page qtv_menu;

#define MENU_ALIAS(func,command,leavem) static void func(void) { Cbuf_AddText(command "\n"); if (leavem) M_LeaveMenus(); }

void MIng_MainMenu(void)		{ M_Menu_Main_f(); }
void MIng_Back(void)			{ M_LeaveMenus(); }

MENU_ALIAS(MIng_ServerBrowser,"menu_slist",false);
MENU_ALIAS(MIng_Options,"menu_options",false);
MENU_ALIAS(MIng_Join,"join",true);
MENU_ALIAS(MIng_Observe,"observe",true);
MENU_ALIAS(MIng_Disconnect,"disconnect",true);
MENU_ALIAS(MIng_Ready, "ready",true);
MENU_ALIAS(MIng_Break, "break",true);
MENU_ALIAS(MIng_SkillUp, "skillup",false);
MENU_ALIAS(MIng_SkillDown, "skilldown",false);
MENU_ALIAS(MIng_AddBot, "addbot",false);
MENU_ALIAS(MIng_RemoveBot, "removebot",false);
MENU_ALIAS(MIng_TeamBlue, "team blue;color 13",true);
MENU_ALIAS(MIng_TeamRed, "team red;color 4",true);
MENU_ALIAS(MDemoCtrl_DemoBrowser,"menu_demos",false);
MENU_ALIAS(MDemoCtrl_DemoControls, "demo_controls",true);
MENU_ALIAS(MSP_Load, "menu_load", false);
MENU_ALIAS(MSP_Save, "menu_save", false);
MENU_ALIAS(MQTV_Autotrack, "autotrack", true);
MENU_ALIAS(MQTV_Lastscores, "lastscores", true);
MENU_ALIAS(MQTV_Observers, "qtvusers", true);
MENU_ALIAS(MQTV_Reconnect, "qtvreconnect", true);

setting single_menu_entries[] = {
	ADDSET_SEPARATOR("In-game Menu"),
	ADDSET_ACTION("Load Game", MSP_Load, ""),
	ADDSET_ACTION("Save Game", MSP_Save, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Options", MIng_Options, ""),
	ADDSET_ACTION("Main Menu", MIng_MainMenu, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Return To Game", MIng_Back, ""),
};

setting ingame_menu_entries[] = {
	ADDSET_SEPARATOR("In-game Menu"),
	ADDSET_ACTION("Ready", MIng_Ready, ""),
	ADDSET_ACTION("Break", MIng_Break, ""),
	ADDSET_ACTION("Join", MIng_Join, ""),
	ADDSET_ACTION("Observe", MIng_Observe, ""),
	ADDSET_ACTION("Disconnect", MIng_Disconnect, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Server Browser", MIng_ServerBrowser, ""),
	ADDSET_ACTION("Options", MIng_Options, ""),
	ADDSET_ACTION("Main Menu", MIng_MainMenu, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Return To Game", MIng_Back, ""),
};

setting democtrl_menu_entries[] = {
	ADDSET_SEPARATOR("Demo Control Menu"),
	ADDSET_ACTION("Toggle autotrack", MQTV_Autotrack, ""),
	ADDSET_ACTION("Demo controls", MDemoCtrl_DemoControls, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Disconnect", MIng_Disconnect, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Demo Browser", MDemoCtrl_DemoBrowser, ""),
	ADDSET_ACTION("Options", MIng_Options, ""),
	ADDSET_ACTION("Main Menu", MIng_MainMenu, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Return To Demo", MIng_Back, ""),
};

setting qtv_menu_entries[] = {
	ADDSET_SEPARATOR("QuakeTV Menu"),
	ADDSET_ACTION("Toggle autotrack", MQTV_Autotrack, ""),
	ADDSET_ACTION("Last scores", MQTV_Lastscores, ""),
	ADDSET_ACTION("List observers", MQTV_Observers, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Reconnect", MQTV_Reconnect, ""),
	ADDSET_ACTION("Disconnect", MIng_Disconnect, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Options", MIng_Options, ""),
	ADDSET_ACTION("Main Menu", MIng_MainMenu, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Return To Game", MIng_Back, ""),
};

setting botmatch_menu_entries[] = {
	ADDSET_SEPARATOR("Botmatch Menu"),
	ADDSET_ACTION("Ready", MIng_Ready, ""),
	ADDSET_ACTION("Break", MIng_Break, ""),
	ADDSET_ACTION("Team Blue", MIng_TeamBlue, ""),
	ADDSET_ACTION("Team Red", MIng_TeamRed, ""),
	ADDSET_ACTION("Add Bot", MIng_AddBot, ""),
	ADDSET_ACTION("Remove Bot", MIng_RemoveBot, ""),
	ADDSET_ACTION("Increase Bot Skill", MIng_SkillUp, ""),
	ADDSET_ACTION("Decrease Bot Skill", MIng_SkillDown, ""),
	ADDSET_ACTION("Disconnect", MIng_Disconnect, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Options", MIng_Options, ""),
	ADDSET_ACTION("Main Menu", MIng_MainMenu, ""),
	ADDSET_BLANK(),
	ADDSET_ACTION("Return To Game", MIng_Back, ""),
};

#define DEMOPLAYBACK() (cls.demoplayback && cls.mvdplayback != QTV_PLAYBACK)
#define BOTMATCH() (!strcmp(cls.gamedirfile, "fbca"))
#ifndef CLIENTONLY
#define SINGLEPLAYER() (com_serveractive && cls.state == ca_active && !cl.deathmatch && maxclients.value == 1)
#endif
#define QTVPLAYBACK() (cls.mvdplayback == QTV_PLAYBACK)

static settings_page *M_Ingame_Current(void) {
	if (DEMOPLAYBACK()) {
		return &democtrl_menu;
	}
	else if (BOTMATCH()) {
		return &botmatch_menu;
	}
#ifndef CLIENTONLY
	else if (SINGLEPLAYER()) {
		return &single_menu;
	}
#endif
	else if (QTVPLAYBACK()) {
		return &qtv_menu;
	}
	else {
		return &ingame_menu;
	}
}

void M_Ingame_Draw(void) {
	char version[VERSION_MAX_LEN] = { 0 };
	qbool outdated;

	M_Unscale_Menu();
	Settings_Draw(0, TOPMARGIN, vid.width, vid.height - TOPMARGIN, M_Ingame_Current());

	outdated = VersionCheck_GetLatest(version);
	if (outdated)
	{
		char message[4096] = { 0 };
		snprintf(message, sizeof(message), "Outdated client %s, latest version is %s", VERSION_NUMBER, version);
		UI_Print_Center(0, 32, vid.width, message, 0);
	}
}

void M_Ingame_Key(int key) {
	if (Settings_Key(M_Ingame_Current(), key, 0)) return;

	switch (key) {
	case K_MOUSE2:
	case K_ESCAPE: M_LeaveMenus(); break;
	}
}

qbool Menu_Ingame_Mouse_Event(const mouse_state_t *ms) {
	mouse_state_t m = *ms;
	m.y -= TOPMARGIN;
	return Settings_Mouse_Event(M_Ingame_Current(), &m);
}

void Menu_Ingame_Init(void)
{
	Settings_Page_Init(single_menu, single_menu_entries);
	Settings_Page_SetMinit(single_menu);
	Settings_Page_Init(ingame_menu, ingame_menu_entries);
	Settings_Page_SetMinit(ingame_menu);
	Settings_Page_Init(democtrl_menu, democtrl_menu_entries);
	Settings_Page_SetMinit(democtrl_menu);
	Settings_Page_Init(botmatch_menu, botmatch_menu_entries);
	Settings_Page_SetMinit(botmatch_menu);
	Settings_Page_Init(qtv_menu, qtv_menu_entries);
	Settings_Page_SetMinit(qtv_menu);
}

void Menu_Ingame_Shutdown(void)
{
	Settings_Shutdown(&single_menu);
	Settings_Shutdown(&ingame_menu);
	Settings_Shutdown(&democtrl_menu);
	Settings_Shutdown(&botmatch_menu);
	Settings_Shutdown(&qtv_menu);
}


================================================
FILE: src/menu_ingame.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**

	In-game menu

	made by johnnycz, June 2007
	last edit:
	$Id: menu_ingame.h,v 1.2 2007-07-15 09:50:44 disconn3ct Exp $

*/

#ifndef __MENU_INGAME_H__
#define __MENU_INGAME_H__

extern void M_Ingame_Draw(void);
extern void M_Democtrl_Draw(void);

extern void M_Ingame_Key(int);
extern void M_Democtrl_Key(int);

extern qbool Menu_Ingame_Mouse_Event(const mouse_state_t *ms);
extern qbool Menu_Democtrl_Mouse_Event(const mouse_state_t *ms);

extern void Menu_Ingame_Init(void);

#endif // __MENU_INGAME_H__


================================================
FILE: src/menu_multiplayer.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "keys.h"
#include "EX_browser.h"
#include "settings.h"
#include "settings_page.h"
#include "Ctrl.h"
#include "Ctrl_Tab.h"
#include "menu.h"
#include "gl_model.h"
#include "menu_multiplayer.h"

#define BROWSERPADDING 4

CTab_t sb_tab;

extern cvar_t scr_scaleMenu;
extern int menuwidth;
extern int menuheight;

const char* sb_showproxies_labels[] = { "hide", "show", "exclusively" };

static settings_page sbsettings;
static setting sbsettings_arr[] = {
	ADDSET_SEPARATOR("Server Filters"),
	ADDSET_BOOL		("Hide Empty", sb_hideempty),
	ADDSET_BOOL		("Hide Full", sb_hidefull),
	ADDSET_BOOL		("Hide Not Empty", sb_hidenotempty),
	ADDSET_BOOL		("Hide Dead", sb_hidedead),
	ADDSET_BOOL     ("Hide High Ping", sb_hidehighping),
	ADDSET_NAMED    ("Show Proxies", sb_showproxies, sb_showproxies_labels),

	ADDSET_SEPARATOR("Display Columns"),
	ADDSET_BOOL		("Show Ping", sb_showping),
	ADDSET_BOOL		("Show Map", sb_showmap),
	ADDSET_BOOL		("Show Gamedir", sb_showgamedir),
	ADDSET_BOOL		("Show Players", sb_showplayers),
	ADDSET_BOOL		("Show Timelimit", sb_showtimelimit),
	ADDSET_BOOL		("Show Fraglimit", sb_showfraglimit),
	ADDSET_BOOL		("Show Server Address", sb_showaddress),

	ADDSET_SEPARATOR("Display"),
	ADDSET_BOOL		("Server Status", sb_status),

	ADDSET_SEPARATOR("Network Filters"),
	ADDSET_NUMBER	("Ping Timeout", sb_pingtimeout, 50, 1000, 50),
	ADDSET_NUMBER	("Pings Per Server", sb_pings, 1, 5, 1),
	ADDSET_NUMBER	("Pings Per Second", sb_pingspersec, 10, 300, 10),
	ADDSET_NUMBER	("Master Timeout", sb_mastertimeout, 50, 1000, 50),
	ADDSET_NUMBER	("Master Retries", sb_masterretries, 1, 5, 1),
	ADDSET_NUMBER	("Info Timeout", sb_infotimeout, 50, 1000, 50),
	ADDSET_NUMBER	("Info Retries", sb_inforetries, 0, 4, 1),
	ADDSET_NUMBER	("Infos Per Second", sb_infospersec, 10, 1000, 10),
	ADDSET_BOOL     ("Find best routes", sb_findroutes)
};

/* generates a toggle function for custom enum in ADDSET_CUSTOM setting type */
#define GENERATE_ENUM_TOGGLE_PROC(basename,var,upperbound)	\
	static void M_CG_##basename##_t(qbool back) {		\
		(var) += back ? -1 : 1;			\
		if ((var) >= upperbound) {		\
			(var) = 0;					\
		} else if ((var) < 0) {			\
			(var) = upperbound - 1;		\
		}								\
	}

/* generates a reading function for custom enum in ADDSET_CUSTOM setting type */
#define GENERATE_ENUM_READ_PROC(basename,var,ubound,descarray)	\
	static const char* M_CG_##basename##_r(void) {	\
		if (((var) > 0) && ((var) < ubound)) {			\
			return descarray[var];						\
		} else {										\
			return descarray[0];						\
		}												\
	}

// spawns a variable of given enum type and it's reading and writing menu function
#define GENERATE_ENUM_MENU_FUNC(menu_enum) \
	static menu_enum ## _t menu_enum ## _var; \
	GENERATE_ENUM_READ_PROC(menu_enum, menu_enum ## _var, menu_enum ## _max, menu_enum ## _desc) \
	GENERATE_ENUM_TOGGLE_PROC(menu_enum, menu_enum ## _var, menu_enum ## _max)

typedef struct {
	char    *name;
	char    *description;
} level_t;

level_t        levels[] = {
	{"start", "Entrance"},    // 0

	{"e1m1", "Slipgate Complex"},                // 1
	{"e1m2", "Castle of the Damned"},
	{"e1m3", "The Necropolis"},
	{"e1m4", "The Grisly Grotto"},
	{"e1m5", "Gloom Keep"},
	{"e1m6", "The Door To Chthon"},
	{"e1m7", "The House of Chthon"},
	{"e1m8", "Ziggurat Vertigo"},

	{"e2m1", "The Installation"},                // 9
	{"e2m2", "Ogre Citadel"},
	{"e2m3", "Crypt of Decay"},
	{"e2m4", "The Ebon Fortress"},
	{"e2m5", "The Wizard's Manse"},
	{"e2m6", "The Dismal Oubliette"},
	{"e2m7", "Underearth"},

	{"e3m1", "Termination Central"},            // 16
	{"e3m2", "The Vaults of Zin"},
	{"e3m3", "The Tomb of Terror"},
	{"e3m4", "Satan's Dark Delight"},
	{"e3m5", "Wind Tunnels"},
	{"e3m6", "Chambers of Torment"},
	{"e3m7", "The Haunted Halls"},

	{"e4m1", "The Sewage System"},                // 23
	{"e4m2", "The Tower of Despair"},
	{"e4m3", "The Elder God Shrine"},
	{"e4m4", "The Palace of Hate"},
	{"e4m5", "Hell's Atrium"},
	{"e4m6", "The Pain Maze"},
	{"e4m7", "Azure Agony"},
	{"e4m8", "The Nameless City"},

	{"end", "Shub-Niggurath's Pit"},            // 31

	{"dm1", "Place of Two Deaths"},                // 32
	{"dm2", "Claustrophobopolis"},
	{"dm3", "The Abandoned Base"},
	{"dm4", "The Bad Place"},
	{"dm5", "The Cistern"},
	{"dm6", "The Dark Zone"}
};

typedef struct {
	char    *description;
	int        firstLevel;
	int        levels;
} episode_t;

episode_t    episodes[] = {
	{"Welcome to Quake", 0, 1},
	{"Doomed Dimension", 1, 8},
	{"Realm of Black Magic", 9, 7},
	{"Netherworld", 16, 7},
	{"The Elder World", 23, 8},
	{"Final Level", 31, 1},
	{"Deathmatch Arena", 32, 6}
};

/* bot match type */
	typedef enum bm_type_e {
		bmt_arena, bmt_clarena, bmt_duel, bmt_ffa, bmt_team, bm_type_max
	} bm_type_t;
	static const char *bm_type_desc[bm_type_max] = {
		"Arena", "Clan Arena", "Duel", "Free For All", "Teamplay"
	};
	GENERATE_ENUM_MENU_FUNC(bm_type);

/* bot match map */
	typedef enum bm_map_e {
		bmm_dm3, bmm_dm4, bmm_dm6, bmm_ztndm3, bmm_e1m2, bmm_aerowalk, bmm_spinev2,
		bmm_pkeg1, bmm_ultrav, bmm_frobodm2, bmm_amphi2, bmm_povdmm4, bmm_dranzdm8,
		bm_map_max
	} bm_map_t;
	static const char *bm_map_desc[bm_map_max] = {
		"dm3", "dm4", "dm6", "ztndm3", "e1m2", "aerowalk", "spinev2", "pkeg1",
		"ultrav", "frobodm2", "amphi2", "povdmm4", "dranzdm8"
	};
	GENERATE_ENUM_MENU_FUNC(bm_map);

/* bot match starter */
	static void M_CG_BotMatch_Start(void) {
		const char *cfg;
		const char *map = bm_map_desc[bm_map_var];
		extern cvar_t menu_botmatch_gamedir, menu_botmatch_mod_old;

		switch (bm_type_var) {
			case bmt_arena:		cfg = "arena"; break;
			case bmt_clarena:	cfg = "clarena"; break;
			case bmt_duel:		cfg = "duel"; break;
			case bmt_ffa:		cfg = "ffa"; break;
			case bmt_team:		cfg = "team"; break;
			default:			cfg = "ffa"; break;
		}

		Cbuf_AddText("disconnect;sv_progsname qwprogs;");
		if (menu_botmatch_gamedir.string[0]) {
			Cbuf_AddText(va("gamedir \"%s\";", menu_botmatch_gamedir.string));
		}
		if (menu_botmatch_mod_old.integer) {
			Cbuf_AddText("cl_sv_packetsync 0\n");
			Cbuf_AddText("cl_pext_floatcoords 0\n");
			Cbuf_AddText("sv_bigcoords 0\n");
		}
		Cbuf_AddText(va("exec configs/%s.cfg;map %s\n",cfg,map));
		M_LeaveMenus();
	}


/* coop game difficulty */
	typedef enum game_skill_e {
		GSKILL_EASY = 0,
		GSKILL_NORMAL,
		GSKILL_HARD,
		GSKILL_NIGHTMARE,
		game_skill_max
	} game_skill_t;
	static const char* game_skill_desc[game_skill_max] = {
		"Easy", "Normal", "Hard", "Nightmare"
	};
	GENERATE_ENUM_MENU_FUNC(game_skill);

/* coop game team damage */
	typedef enum cg_teamdamage_e {
		TD_OFF, TD_ON, cg_teamdamage_max
	} cg_teamdamage_t;
	static const char* cg_teamdamage_desc[cg_teamdamage_max] = {
		"off", "on"
	};
	GENERATE_ENUM_MENU_FUNC(cg_teamdamage);

/* deathmatch map */
	typedef enum game_map_group_e {
		GMG_EPISODE1,	
		GMG_EPISODE2,
		GMG_EPISODE3,
		GMG_EPISODE4,
		GMG_CUSTOM,
		game_map_group_max
	} game_map_group_t;
	static const char* game_map_group_desc[game_map_group_max] = {
		"Doomed Dimension", "Realm of Black Magic", "Netherworld", "The Elder World", "Custom"
	};
	GENERATE_ENUM_MENU_FUNC(game_map_group);

/* deathmatch game mode */
	typedef enum DM_game_mode_e {
		DMGM_ffa, DMGM_duel, DMGM_tp, DMGM_arena, DM_game_mode_max
	} DM_game_mode_t;
	static const char* DM_game_mode_desc[DM_game_mode_max] = {
		"Free For All", "Duel", "Teamplay", "Arena"
	};
	GENERATE_ENUM_MENU_FUNC(DM_game_mode);

static int coopmaxplayers = 2;

static int dm_maxplayers = 2;
static int dm_maxspectators = 8;
static int dm_timelimit = 10;
static int dm_fraglimit = 0;

void Menu_CG_DM_StartGame(void)
{
	int dm;
	int tp;

	Cbuf_AddText("disconnect; gamedir qw; coop 0; sv_progsname qwprogs;\n");
	switch (DM_game_mode_var) {
		case DMGM_ffa: tp = 0; dm = 3; break;
		case DMGM_duel: tp = 0; dm = 3; break;
		case DMGM_tp: tp = 2; dm = 1; break;
		case DMGM_arena: tp = 0; dm = 4; break;
		default: tp = 0; dm = 3; break;
	}
	Cbuf_AddText(va("deathmatch %d;teamplay %d\n",dm,tp));
	Cbuf_AddText(va("maxclients %d;maxspectators %d\n",dm_maxplayers,dm_maxspectators));
	Cbuf_AddText(va("timelimit %d;fraglimit %d\n",dm_timelimit,dm_fraglimit));
	// todo: finish map choosing
	Cbuf_AddText("map dm4\n");
	M_LeaveMenus();
}

void Menu_CG_Coop_StartGame(void)
{
	int tp = (cg_teamdamage_var == TD_OFF) ? 1 : 2;
	int skill = game_skill_var;

	Cbuf_AddText("disconnect; sv_progsname spprogs; gamedir qw; coop 1; deathmatch 0\n");
	Cbuf_AddText(va("teamplay %d; skill %d;maxclients %d;map start",
					tp,skill,coopmaxplayers));
	M_LeaveMenus();
}

static settings_page create_game_options;
static setting create_game_options_arr[] = {
	ADDSET_SEPARATOR("Bot Match"),
	ADDSET_CUSTOM	("Game Mode", M_CG_bm_type_r, M_CG_bm_type_t,
					 "Choose one of the three available game types"),
	ADDSET_CUSTOM	("Map", M_CG_bm_map_r, M_CG_bm_map_t, "Bots support only limit set of maps"),
	ADDSET_ACTION	("Start Bot Match", M_CG_BotMatch_Start, "Start the bot match"),

	ADDSET_SEPARATOR("Deathmatch"),
	ADDSET_INTNUMBER("Player slots", dm_maxplayers, 1, 32, 1),
	ADDSET_INTNUMBER("Spectator slots", dm_maxspectators, 0, 16, 1),
	ADDSET_CUSTOM	("Game Mode", M_CG_DM_game_mode_r, M_CG_DM_game_mode_t, "Game Mode"),
	ADDSET_INTNUMBER("Timelimit", dm_timelimit, 0, 60, 5),
	ADDSET_INTNUMBER("Fraglimit", dm_fraglimit, 0, 100, 10),
	ADDSET_CUSTOM	("Map Group", M_CG_game_map_group_r, M_CG_game_map_group_t, ""),
	/* ADDSET_CUSTOM	("Map", Menu_CG_map_r, Menu_CG_map_t, ""), */
	ADDSET_ACTION	("Start Deathmatch", Menu_CG_DM_StartGame,
					 "Start game with given parameters"),

	ADDSET_SEPARATOR("Cooperative"),
	ADDSET_CUSTOM	("Difficulty", M_CG_game_skill_r, M_CG_game_skill_t, 
					 "Monsters skill level"),
	ADDSET_CUSTOM	("Teamplay Damage", M_CG_cg_teamdamage_r, M_CG_cg_teamdamage_t,
					 "Whether Give damage to teammates if you shoot them"),
	ADDSET_INTNUMBER("Player Slots", coopmaxplayers, 1, 32, 1),
	ADDSET_ACTION	("Start Coop Game", Menu_CG_Coop_StartGame,
					 "Start game with given parameters"),
};

static void Servers_Draw (int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	SB_Servers_Draw(x,y,w,h);
}

static int Servers_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	return SB_Servers_Key(key);
}

static void Servers_OnShow(void)
{
	SB_Servers_OnShow();
}

static qbool Servers_Mouse_Event(const mouse_state_t *ms)
{
	return SB_Servers_Mouse_Event(ms);
}

static void Sources_Draw (int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	SB_Sources_Draw(x,y,w,h);
}

static int Sources_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	return SB_Sources_Key(key);
}

static qbool Sources_Mouse_Event(const mouse_state_t *ms)
{
	return SB_Sources_Mouse_Event(ms);
}

static void Players_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	SB_Players_Draw(x, y, w, h);
}

static int Players_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	return SB_Players_Key(key);
}
static qbool Players_Mouse_Event(const mouse_state_t *ms)
{
	return SB_Players_Mouse_Event(ms);
}

static qbool Options_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&sbsettings, ms);
}

static int Options_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	return Settings_Key(&sbsettings, key, unichar);
}

static void Options_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	Settings_Draw(x, y, w, h, &sbsettings);
}

void Menu_MultiPlayer_Draw (void)
{
	int x, y, w, h;

	M_Unscale_Menu();

	w = min(640, vid.width) - BROWSERPADDING*2;
	h = min(480, vid.height) - BROWSERPADDING*2;
	x = (vid.width - w) / 2;
	y = (vid.height - h) / 2;

	Browser_window.x = x;
	Browser_window.y = y;
	Browser_window.w = w;
	Browser_window.h = h;

	CTab_Draw(&sb_tab, x, y, w, h);

	SB_Specials_Draw();
}

void Menu_MultiPlayer_Key(int key, wchar unichar)
{
	if (SB_Specials_Key(key, unichar)) return;
	
	CTab_Key(&sb_tab, key, unichar);
}

qbool Menu_MultiPlayer_Mouse_Event(const mouse_state_t *ms)
{
	mouse_state_t nms = *ms;

    if (ms->button_up == 2) {
        Menu_MultiPlayer_Key(K_MOUSE2, 0);
        return true;
    }

	nms.x -= Browser_window.x;
	nms.y -= Browser_window.y;
	nms.x_old -= Browser_window.x;
	nms.y_old -= Browser_window.y;

	return CTab_Mouse_Event(&sb_tab, &nms);
}

static qbool CreateGame_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&create_game_options, ms);
}

static int CreateGame_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	return Settings_Key(&create_game_options, key, unichar);
}

static void CreateGame_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	Settings_Draw(x,y,w,h,&create_game_options);
}

CTabPage_Handlers_t sb_servers_handlers = {
	Servers_Draw,
	Servers_Key,
	Servers_OnShow,
	Servers_Mouse_Event
};

CTabPage_Handlers_t sb_sources_handlers = {
	Sources_Draw,
	Sources_Key,
	NULL,
	Sources_Mouse_Event
};

CTabPage_Handlers_t sb_players_handlers = {
	Players_Draw,
	Players_Key,
	NULL,
	Players_Mouse_Event
};

CTabPage_Handlers_t sb_options_handlers = {
	Options_Draw,
	Options_Key,
	NULL,
	Options_Mouse_Event
};

CTabPage_Handlers_t sb_creategame_handlers = {
	CreateGame_Draw,
	CreateGame_Key,
	NULL,
	CreateGame_Mouse_Event
};

void Menu_MultiPlayer_Init(void)
{
	Settings_Page_Init(sbsettings, sbsettings_arr);
	Settings_Page_Init(create_game_options, create_game_options_arr);

	CTab_Init(&sb_tab);
	CTab_AddPage(&sb_tab, "Servers", SBPG_SERVERS, &sb_servers_handlers);
	CTab_AddPage(&sb_tab, "Sources", SBPG_SOURCES, &sb_sources_handlers);
	CTab_AddPage(&sb_tab, "Players", SBPG_PLAYERS, &sb_players_handlers);
	CTab_AddPage(&sb_tab, "Options", SBPG_OPTIONS, &sb_options_handlers);
	CTab_AddPage(&sb_tab, "Create", SBPG_CREATEGAME, &sb_creategame_handlers);
	CTab_SetCurrentId(&sb_tab, SBPG_SERVERS);
}

void Menu_MultiPlayer_Shutdown(void)
{
	Settings_Shutdown(&sbsettings);
	Settings_Shutdown(&create_game_options);
}

void Menu_MultiPlayer_SwitchToServersTab(void)
{
	M_EnterMenu(m_multiplayer);
	CTab_SetCurrentId(&sb_tab, SBPG_SERVERS);
}


================================================
FILE: src/menu_multiplayer.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// initialize the multiplayer menu
void Menu_MultiPlayer_Init(void);

void Menu_MultiPlayer_Draw (void);

void Menu_MultiPlayer_Key(int key, wchar unichar);

qbool Menu_MultiPlayer_Mouse_Event(const mouse_state_t *ms);

void Menu_MultiPlayer_SwitchToServersTab(void);

typedef enum
{
	SBPG_SERVERS,	// Servers page
	SBPG_SOURCES,	// Sources page
	SBPG_PLAYERS,	// Players page
	SBPG_OPTIONS,	// Options page
	SBPG_CREATEGAME   // Host Game page
} sb_tab_t;
extern CTab_t sb_tab;



================================================
FILE: src/menu_options.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*

	Options Menu module

	Uses Ctrl_Tab and Settings modules

	Naming convention:
	function mask | usage    | purpose
	--------------|----------|-----------------------------
	Menu_Opt_*    | external | interface for menu.c
	CT_Opt_*      | external | interface for Ctrl_Tab.c

	made by:
		johnnycz, Jan 2006

*/

#include "quakedef.h"
#include "settings.h"
#include "settings_page.h"
#include "Ctrl_EditBox.h"
#include "vx_stuff.h"
#include "vx_tracker.h"
#include "gl_model.h"
#include "tr_types.h"
#include "teamplay.h"
#include "EX_FileList.h"
#include "Ctrl.h"
#include "Ctrl_Tab.h"
#include "input.h"
#include "qsound.h"
#include "menu.h"
#include "keys.h"
#include "hud.h"
#include "hud_common.h"
#include "r_local.h"

extern cvar_t r_farclip, gl_max_size, gl_miptexLevel;
extern cvar_t r_bloom;
extern cvar_t gl_flashblend, r_dynamic, gl_lightmode, gl_modulate;

extern cvar_t vid_framebuffer, vid_framebuffer_hdr, vid_framebuffer_hdr_tonemap, vid_framebuffer_scale, vid_framebuffer_multisample, vid_framebuffer_fxaa;

extern cvar_t vid_software_palette;

#ifdef EZ_MULTIPLE_RENDERERS
extern cvar_t vid_renderer;
#endif

typedef enum {
	OPTPG_MISC,
	OPTPG_PLAYER,
	OPTPG_FPS,
	OPTPG_HUD,
	OPTPG_DEMO_SPEC,
	OPTPG_BINDS,
	OPTPG_SYSTEM,
	OPTPG_CONFIG,
}	options_tab_t;

CTab_t options_tab;
int options_unichar;	// variable local to this module

extern cvar_t     scr_scaleMenu;
extern int        menuwidth;
extern int        menuheight;

extern qbool    m_entersound; // todo - put into menu.h
void M_Menu_Help_f (void);	// todo - put into menu.h
extern cvar_t scr_scaleMenu;
qbool OnMenuAdvancedChange(cvar_t*, char*);
cvar_t menu_advanced = {"menu_advanced", "0"};

//=============================================================================
// <SETTINGS>

enum {mode_fastest, mode_faithful, mode_higheyecandy, mode_eyecandy, mode_undef} fps_mode = mode_undef;

extern cvar_t scr_fov, scr_newHud, cl_staticsounds, r_fullbrightSkins, cl_deadbodyfilter, cl_muzzleflash, r_fullbright;
extern cvar_t scr_sshot_format;
void ResetConfigs_f(void);

static qbool AlwaysRun(void) { return cl_forwardspeed.value > 200; }
const char* AlwaysRunRead(void) { return AlwaysRun() ? "on" : "off"; }
void AlwaysRunToggle(qbool back) {
	if (AlwaysRun()) {
		Cvar_SetValue (&cl_forwardspeed, 200);
		Cvar_SetValue (&cl_backspeed, 200);
		Cvar_SetValue (&cl_sidespeed, 200);
	} else {
		Cvar_SetValue (&cl_forwardspeed, 400);
		Cvar_SetValue (&cl_backspeed, 400);
		Cvar_SetValue (&cl_sidespeed, 400);
	}
}

static qbool InvertMouse(void) { return m_pitch.value < 0; }
const char* InvertMouseRead(void) { return InvertMouse() ? "on" : "off"; }
void InvertMouseToggle(qbool back) { Cvar_SetValue(&m_pitch, -m_pitch.value); }

static qbool AutoSW(void) { return (w_switch.value > 2) || (!w_switch.value) || (b_switch.value > 2) || (!b_switch.value); }
const char* AutoSWRead(void) { return AutoSW() ? "on" : "off"; }
void AutoSWToggle(qbool back) {
	if (AutoSW()) {
		Cvar_SetValue (&w_switch, 1);
		Cvar_SetValue (&b_switch, 1);
	} else {
		Cvar_SetValue (&w_switch, 8);
		Cvar_SetValue (&b_switch, 8);
	}
}

static int GFXPreset(void) {
	if (fps_mode == mode_undef) {
		switch ((int) cl_deadbodyfilter.value) {
		case 0: fps_mode = mode_eyecandy; break;
		case 1: fps_mode = cl_muzzleflash.value ? mode_faithful : mode_eyecandy; break;
		default: fps_mode = mode_fastest; break;
		}
	}
	return fps_mode;
}
const char* GFXPresetRead(void) {
	switch (GFXPreset()) {
	case mode_fastest: return "fastest";
	case mode_higheyecandy: return "high eyecandy";
	case mode_faithful: return "faithful";
	default: return "eyecandy";
	}
}
void GFXPresetToggle(qbool back) {
	if (back) {
		if (fps_mode <= 0) {
			fps_mode = mode_undef;
		}
		--fps_mode;
	}
	else {
		++fps_mode;
		if (fps_mode >= mode_undef) {
			fps_mode = 0;
		}
	}

	switch (GFXPreset()) {
	case mode_fastest: Cbuf_AddText ("exec cfg/gfx_gl_fast.cfg\n"); return;
	case mode_higheyecandy: Cbuf_AddText ("exec cfg/gfx_gl_higheyecandy.cfg\n"); return;
	case mode_faithful: Cbuf_AddText ("exec cfg/gfx_gl_faithful.cfg\n"); return;
	case mode_eyecandy: Cbuf_AddText ("exec cfg/gfx_gl_eyecandy.cfg\n"); return;
	}
}

const char* amf_tracker_frags_enum[] = {"off", "related", "all" };

const char* mvdautohud_enum[] = { "off", "simple", "customizable" };
const char* mvdautotrack_enum[] = { "off", "auto", "custom", "multitrack", "simple" };
const char* funcharsmode_enum[] = { "ctrl+key", "ctrl+y" };
const char* ignoreopponents_enum[] = { "off", "always", "on match" };
const char* msgfilter_enum[] = { "off", "say+spec", "team", "say+team+spec" };
const char* allowscripts_enum[] = { "off", "simple", "all" };
const char* scrautoid_enum[] = { "off", "nick", "health+armor", "health+armor+type", "all (rl)", "all (best gun)" };
const char* coloredtext_enum[] = { "off", "simple", "frag messages" };
const char* autorecord_enum[] = { "off", "don't save", "auto save" };
const char* hud_enum[] = { "classic", "new", "combined" };
const char* ignorespec_enum[] = { "off", "on (as player)", "on (always)" };
const char* gender_enum[] = { "Male", "m", "Female", "f", "Neutral", "n", "Not specified", "" };
const char* lighting_enum[] = { "Off", "0", "On (CPU)", "1", "On (GPU - GLSL only)", "2" };

const char* scr_sshot_format_enum[] = {
	"JPG", "jpg", "PNG", "png", "TGA", "tga" };

extern cvar_t mvd_autotrack, mvd_moreinfo, mvd_status, cl_weaponpreselect, cl_weaponhide, con_funchars_mode, con_notifytime, scr_consize, ignore_opponents, _con_notifylines,
	ignore_qizmo_spec, ignore_spec, msg_filter, crosshair, crosshairsize, cl_smartjump, scr_coloredText,
	cl_rollangle, cl_rollspeed, v_gunkick, v_kickpitch, v_kickroll, v_kicktime, v_viewheight, match_auto_sshot, match_auto_record, match_auto_logconsole,
	r_fastturb, r_grenadetrail, cl_drawgun, r_viewmodelsize, r_viewmodeloffset, gl_outline, scr_clock, scr_gameclock, show_fps, rate, cl_c2sImpulseBackup,
	name, team, skin, topcolor, bottomcolor, cl_teamtopcolor, cl_teambottomcolor, cl_teamquadskin, cl_teampentskin, cl_teambothskin, /*cl_enemytopcolor, cl_enemybottomcolor, */
	cl_enemyquadskin, cl_enemypentskin, cl_enemybothskin, demo_dir, qizmo_dir, qwdtools_dir, cl_fakename, cl_fakename_suffix,
	cl_chatsound, con_sound_mm1_volume, con_sound_mm2_volume, con_sound_spec_volume, con_sound_other_volume, s_khz, s_desiredsamples,
	ruleset, scr_sshot_dir, log_dir, cl_nolerp, cl_confirmquit, log_readable, ignore_flood, ignore_flood_duration, con_timestamps, scr_consize, scr_conspeed, cl_chatmode, cl_chasecam,
	enemyforceskins, teamforceskins, vid_vsync_lag_fix, cl_sayfilter_coloredtext, cl_sayfilter_sendboth,
	mvd_autotrack_lockteam, qtv_adjustbuffer, cl_earlypackets, cl_useimagesinfraglog, con_completion_format, menu_ingame, sys_inactivesound
;

#ifdef _WIN32
extern cvar_t demo_format, sys_highpriority, cl_window_caption, vid_flashonactivity;
void Sys_RegisterQWURLProtocol_f(void);
#endif
extern cvar_t scr_autoid, crosshairalpha, amf_hidenails, amf_hiderockets, gl_anisotropy, gl_lumatextures, gl_textureless, gl_colorlights, scr_conalpha, scr_conback, gl_clear, gl_powerupshells,
	scr_teaminfo
;

void CL_Autotrack_f(void);

const char* bandwidth_enum[] = { 
	"Modem (33k)", "3800", "Modem (56k)", "5670", 
	"ISDN (112k)", "9856", "Cable (128k)", "14336",
	"ADSL (> 256k)", "30000" };

const char* cl_c2sImpulseBackup_enum[] = {
	"Perfect", "0", "Low", "2", "Medium", "4",
	"High", "6" };
	

const char* ignore_flood_enum[] = {
	"Off", "0", "say/spec", "1", "say/say_team/spec", "2" };

#ifdef _WIN32
const char* demoformat_enum[] = { "QuakeWorld Demo", "qwd", "Qizmo compressed QWD", "qwz", "MultiViewDemo", "mvd" };
#endif

const char* cl_chatmode_enum[] = {
	"All Commands", "All Chat", "First Word" };

const char* con_completion_format_enum[] = {
	"Old", "New:Current+Default", "New:Current", "New:Default", "New:Current+Default,if changed", "New:Without values"
};
	
const char* scr_conback_enum[] = {
	"Off", "On Load", "Always", };

const char* s_khz_enum[] = {
	"11 kHz", "11", "22 kHz", "22", "44 kHz", "44"
//FIXME probably works on all supported platforms by now?
#if defined(__linux__) || defined(__FreeBSD__) || defined(_WIN32)
	,"48 kHz", "48"
#endif
};
const char* s_desired_samples_enum[] = {
	"(default)", "0", "128", "128", "256", "256", "512", "512", "1024", "1024"
};

const char* cl_nolerp_enum[] = {"on", "off"};
const char* ruleset_enum[] = { "ezQuake default", "default", "Smackdown", "smackdown", "Thunderdome", "thunderdome", "Moscow TF League", "mtfl", "QuakeCon", "qcon", "Smackdrive", "smackdrive" };
const char *mediaroot_enum[] = { "relative to exe", "relative to home", "full path" };
const char *teamforceskins_enum[] = { "off", "use player's name", "use player's userid", "set t1, t2, t3, ..." };
const char *enemyforceskins_enum[] = { "off", "use player's name", "use player's userid", "set e1, e2, e3, ..." };

#ifdef _WIN32
const char *priority_enum[] = { "low", "-1", "normal", "0", "high", "1" };
#endif


void DefaultConfig(void) { Cbuf_AddText("cfg_reset full\n"); }

settings_page settmisc;

void CT_Opt_Settings_Draw (int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page) {
	Settings_Draw(x, y, w, h, &settmisc);
}

int CT_Opt_Settings_Key (int k, wchar unichar, CTab_t *tab, CTabPage_t *page) {
	return Settings_Key(&settmisc, k, unichar);
}

void OnShow_SettMain(void) { Settings_OnShow(&settmisc); }

qbool CT_Opt_Settings_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&settmisc, ms);
}

// </SETTINGS>
//=============================================================================

settings_page settview;

void CT_Opt_View_Draw (int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page) {
	Settings_Draw(x, y, w, h, &settview);
}

int CT_Opt_View_Key (int k, wchar unichar, CTab_t *tab, CTabPage_t *page) {
	return Settings_Key(&settview, k, unichar);
}

void OnShow_SettView(void) { Settings_OnShow(&settview); }

qbool CT_Opt_View_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&settview, ms);
}
settings_page settplayer;
void CT_Opt_Player_Draw (int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page) {
	Settings_Draw(x, y, w, h, &settplayer);
}

int CT_Opt_Player_Key (int k, wchar unichar, CTab_t *tab, CTabPage_t *page) {
	return Settings_Key(&settplayer, k, unichar);
}

void OnShow_SettPlayer(void) { Settings_OnShow(&settplayer); }

qbool CT_Opt_Player_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&settplayer, ms);
}


//=============================================================================
// <BINDS>

extern cvar_t in_raw, in_m_smooth, m_rate, in_m_os_parameters;
const char* in_raw_enum[] = { "off", "on" };
const char* in_m_os_parameters_enum[] = { "off", "Keep accel settings", "Keep speed settings", "Keep all settings" };

void Menu_Input_Restart(void) { Cbuf_AddText("in_restart\n"); }

settings_page settbinds;

void CT_Opt_Binds_Draw (int x2, int y2, int w, int h, CTab_t *tab, CTabPage_t *page) {
	Settings_Draw(x2, y2, w, h, &settbinds);
}

int CT_Opt_Binds_Key (int k, wchar unichar, CTab_t *tab, CTabPage_t *page) {
	return Settings_Key(&settbinds, k, unichar);
}

void OnShow_SettBinds(void) { Settings_OnShow(&settbinds); }

qbool CT_Opt_Binds_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&settbinds, ms);
}

// </BINDS>
//=============================================================================



//=============================================================================
// <FPS>
extern cvar_t v_bonusflash;
extern cvar_t cl_rocket2grenade;
extern cvar_t v_damagecshift;
extern cvar_t r_fastsky;
extern cvar_t r_drawflame;
extern cvar_t gl_simpleitems;
extern cvar_t gl_simpleitems_orientation;
extern cvar_t gl_part_inferno;
extern cvar_t amf_lightning;
extern cvar_t r_drawflat;

const char* explosiontype_enum[] =
{ "fire + sparks", "fire only", "teleport", "blood", "big blood", "dbl gunshot", "blob effect", "big explosion", "plasma", "sparks", "off" };

const char* muzzleflashes_enum[] =
{ "off", "on", "own off" };

const char* outline_enum[] =
{ "off", "models", "world", "models+world" };

const char* simpleitemsorientation_enum[] =
{"Parallel upright", "Facing upright", "Parallel", "Oriented"};

const char* deadbodyfilter_enum[] =
{ "off", "fast", "instant", "DM off, TF on" };

const char* rocketmodel_enum[] =
{ "rocket", "grenade" };

const char* rockettrail_enum[] =
{ "off", "normal", "grenade", "alt normal", "slight blood", "big blood", "tracer 1", "tracer 2", "plasma", "lavaball", "fuel rod", "plasma 2", "alt normal 2" };

const char* powerupglow_enum[] =
{ "off", "on", "own off" };

const char* grenadetrail_enum[] =
{ "off", "normal", "grenade", "alt normal", "slight blood", "big blood", "tracer 1", "tracer 2", "plasma", "lavaball", "fuel rod", "plasma 2", "alt normal 2" };

extern cvar_t cl_maxfps;
const char* FpslimitRead(void) {
	switch ((int) cl_maxfps.value) {
	case 0: return "no limit";
	case 72: return "72 (old std)";
	case 77: return "77 (standard)";
	default: return "custom";
	}
}
void FpslimitToggle(qbool back) {
	if (back) {
		switch ((int) cl_maxfps.value) {
		case 0: Cvar_SetValue(&cl_maxfps, 77); return;
		case 72: Cvar_SetValue(&cl_maxfps, 0); return;
		case 77: Cvar_SetValue(&cl_maxfps, 72); return;
		}
	} else {
		switch ((int) cl_maxfps.value) {
		case 0: Cvar_SetValue(&cl_maxfps, 72); return;
		case 72: Cvar_SetValue(&cl_maxfps, 77); return;
		case 77: Cvar_SetValue(&cl_maxfps, 0); return;
		}
	}
}

const char* gl_max_size_enum[] = {
	"low", "1", "medium", "8", "high", "256", "max", "2048"
};

extern cvar_t gl_texturemode;
const char* gl_texturemode_enum[] = {
	"very low", "GL_NEAREST_MIPMAP_NEAREST",
	"low", "GL_LINEAR",
	"medium", "GL_LINEAR_MIPMAP_NEAREST",
	"high", "GL_LINEAR_MIPMAP_LINEAR",
	"very high", "GL_NEAREST"
};

const char* vid_software_palette_enum[] = {
	"hardware", "0",
	"shader", "1"
};

#ifdef EZ_MULTIPLE_RENDERERS
const char* vid_renderer_enum[] = {
	"classic", "0",
	"modern", "1"
};
#endif

const char* vid_framebuffer_enum[] = {
	"disabled", "0",
	"enabled", "1",
	"enabled (separate scene & hud)", "2"
};

settings_page settfps;

void CT_Opt_FPS_Draw (int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	Settings_Draw(x, y, w, h, &settfps);
}

int CT_Opt_FPS_Key (int k, wchar unichar, CTab_t *tab, CTabPage_t *page) {
	return Settings_Key(&settfps, k, unichar);
}

void OnShow_SettFPS(void) { Settings_OnShow(&settfps); }

qbool CT_Opt_FPS_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&settfps, ms);
}


// </FPS>
//=============================================================================


//=============================================================================
// <SYSTEM>

// these variables serve as a temporary storage for user selected settings
// they get initialized with current settings when the page is showed
typedef struct menu_video_settings_s {
	int res;
	int bpp;
	qbool usedesktopres;
	qbool fullscreen;
} menu_system_settings_t;
qbool mss_askmode = false;

// here we store the configuration that user selected in menu
menu_system_settings_t mss_selected;

// here we store the current video config in case the new video settings weren't successfull
menu_system_settings_t mss_previous;

// will apply given video settings
static void ApplyVideoSettings(const menu_system_settings_t *s)
{
	const SDL_DisplayMode *current;

	current = VID_GetDisplayMode(s->res);
	if (current == NULL) {
		return;
	}

	Cvar_SetValue(&vid_width, current->w);
	Cvar_SetValue(&vid_height, current->h);
	Cvar_SetValue(&r_displayRefresh,current->refresh_rate);
	Cvar_SetValue(&r_colorbits, s->bpp);
	Cvar_SetValue(&r_fullscreen, s->fullscreen);
	Cbuf_AddText("vid_restart\n");
	Com_DPrintf("askmode: %s\n", mss_askmode ? "on" : "off");
}

// will store current video settings into the given structure
static void StoreCurrentVideoSettings(menu_system_settings_t *out)
{
	out->usedesktopres = vid_usedesktopres.integer ? true : false;
	out->res = VID_GetCurrentModeIndex();
	out->bpp = (int) r_colorbits.value;
	out->fullscreen = (int) r_fullscreen.value;
}

// performed when user hits the "apply" button
void VideoApplySettings (void)
{
	StoreCurrentVideoSettings(&mss_previous);

	ApplyVideoSettings(&mss_selected);

	mss_askmode = true;
}

// performed when user hits the "apply" button
void RendererRestart (void)
{
	Cbuf_AddText("vid_restart\n");
}

// two possible results of the "keep these video settings?" dialogue
static void KeepNewVideoSettings (void) { mss_askmode = false; }
static void CancelNewVideoSettings (void) {
	mss_askmode = false;
	ApplyVideoSettings(&mss_previous);
}


const char* BitDepthRead(void)
{
	return mss_selected.bpp == 32 ? "32 bit" : mss_selected.bpp == 16 ? "16 bit" : "use desktop settings";
}

const char* ResolutionRead(void)
{
	static char buf[64];
	const SDL_DisplayMode *mode;

	mode = VID_GetDisplayMode(mss_selected.res);
	if (mode == NULL) {
		return "";
	}

	snprintf(buf, sizeof(buf), "%dx%d@%dHz", mode->w, mode->h, mode->refresh_rate);
		
	return buf;
}

const char* FullScreenRead(void)
{
	return mss_selected.fullscreen ? "on" : "off";
}

void ResolutionToggle(qbool back)
{
	int count = VID_GetModeIndexCount();
	if (back) {
		mss_selected.res--;
	} else {
		 mss_selected.res++;
	}

	mss_selected.res = (mss_selected.res + count) % count;
}

void BitDepthToggle(qbool back) {
	if (back) {
		switch (mss_selected.bpp) {
		case 0: mss_selected.bpp = 32; return;
		case 16: mss_selected.bpp = 0; return;
		default: mss_selected.bpp = 16; return;
		}
	} else {
		switch (mss_selected.bpp) {
		case 0: mss_selected.bpp = 16; return;
		case 16: mss_selected.bpp = 32; return;
		case 32: mss_selected.bpp = 0; return;
		}
	}
}
void FullScreenToggle(qbool back) { mss_selected.fullscreen = mss_selected.fullscreen ? 0 : 1; }

settings_page settsystem;

void CT_Opt_System_Draw (int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	#define ASKBOXWIDTH 300
	if(mss_askmode)
	{
		UI_DrawBox((w-ASKBOXWIDTH)/2, h/2 - 16, ASKBOXWIDTH, 32);
		UI_Print_Center((w-ASKBOXWIDTH)/2, h/2 - 8, ASKBOXWIDTH, "Do you wish to keep these settings?", false);
		UI_Print_Center((w-ASKBOXWIDTH)/2, h/2, ASKBOXWIDTH, "(y/n)", true);
	}
	else
	{
		Settings_Draw(x,y,w,h, &settsystem);
	}
}

int CT_Opt_System_Key (int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	if (mss_askmode)
	{

		if (key == 'y' || key == K_ENTER)
		{
			KeepNewVideoSettings();
		}
		else if(key == 'n' || key == K_ESCAPE)
		{
			CancelNewVideoSettings();
		}
		return true;
	}
	else
	{
		return Settings_Key(&settsystem, key, unichar);
	}
}

void OnShow_SettSystem(void)
{
	StoreCurrentVideoSettings(&mss_selected);
	Settings_OnShow(&settsystem);
}

qbool CT_Opt_System_Mouse_Event(const mouse_state_t *ms)
{
	return Settings_Mouse_Event(&settsystem, ms);
}

// </SYSTEM>

// *********
// <CONFIG>

// Menu Options Config Page Mode

filelist_t configs_filelist;
CEditBox filenameeb;

enum { MOCPM_SETTINGS, MOCPM_CHOOSECONFIG, MOCPM_CHOOSESCRIPT, MOCPM_ENTERFILENAME } MOpt_configpage_mode = MOCPM_SETTINGS;

extern cvar_t cfg_backup, cfg_save_aliases, cfg_save_binds, cfg_save_cmdline,
	cfg_save_cmds, cfg_save_cvars, cfg_save_unchanged, cfg_save_userinfo, cfg_use_home, cfg_save_onquit, cfg_use_gamedir, cfg_legacy_exec;

void MOpt_ImportConfig(void) {
	MOpt_configpage_mode = MOCPM_CHOOSECONFIG;
	
	// hope few doubled trinary operator won't hurt your brains
	if (cfg_use_home.integer)
		FL_SetCurrentDir(&configs_filelist, (cfg_use_gamedir.integer) ? va("%s/%s", com_homedir, (strcmp(com_gamedirfile, "qw") == 0) ? "" : com_gamedirfile) : com_homedir);
    else
		FL_SetCurrentDir(&configs_filelist, (cfg_use_gamedir.integer) ? va("%s/%s/configs", com_basedir, (strcmp(com_gamedirfile, "qw") == 0) ? "ezquake" : com_gamedirfile) : va("%s/ezquake/configs", com_basedir));
}
void MOpt_ExportConfig(void) {
	MOpt_configpage_mode = MOCPM_ENTERFILENAME;
	filenameeb.text[0] = 0;
	filenameeb.pos = 0;
}

void MOpt_LoadScript(void) {
	MOpt_configpage_mode = MOCPM_CHOOSESCRIPT;
	FL_SetCurrentDir(&configs_filelist, "./ezquake/cfg");
}

void MOpt_CfgSaveAllOn(void) {
	S_LocalSound("misc/basekey.wav");
	Cvar_SetValue(&cfg_backup, 1);
	Cvar_SetValue(&cfg_legacy_exec, 1);
	Cvar_SetValue(&cfg_save_aliases, 1);
	Cvar_SetValue(&cfg_save_binds, 1);
	Cvar_SetValue(&cfg_save_cmdline, 1);
	Cvar_SetValue(&cfg_save_cmds, 1);
	Cvar_SetValue(&cfg_save_cvars, 1);
	Cvar_SetValue(&cfg_save_unchanged, 1);
	Cvar_SetValue(&cfg_save_userinfo, 2);
}

const char* MOpt_legacywrite_enum[] = { "off", "non-qw dir frontend.cfg", "also config.cfg", "non-qw config.cfg" };
const char* MOpt_userinfo_enum[] = { "off", "all but player", "all" };

void MOpt_LoadCfg(void) {
	S_LocalSound("misc/basekey.wav");
	Cbuf_AddText("cfg_load\n");
}
void MOpt_SaveCfg(void) { 
	S_LocalSound("doors/runeuse.wav");
	Cbuf_AddText("cfg_save\n");
}

settings_page settconfig;

#define INPUTBOXWIDTH 300
#define INPUTBOXHEIGHT 48

void MOpt_FilenameInputBoxDraw(int x, int y, int w, int h)
{
	UI_DrawBox(x + (w-INPUTBOXWIDTH) / 2, y + (h-INPUTBOXHEIGHT) / 2, INPUTBOXWIDTH, INPUTBOXHEIGHT);
	UI_Print_Center(x, y + h/2 - 8, w, "Enter the config file name", false);
	CEditBox_Draw(&filenameeb, x + (w-INPUTBOXWIDTH)/2 + 16, y + h/2 + 8, true);
}

qbool MOpt_FileNameInputBoxKey(int key)
{
	CEditBox_Key(&filenameeb, key, key);
	return true;
}

char *MOpt_FileNameInputBoxGetText(void)
{
	return filenameeb.text;
}

void CT_Opt_Config_Draw(int x, int y, int w, int h, CTab_t *tab, CTabPage_t *page)
{
	switch (MOpt_configpage_mode) {
	case MOCPM_SETTINGS:
		Settings_Draw(x,y,w,h,&settconfig);
		break;

	case MOCPM_CHOOSESCRIPT:
	case MOCPM_CHOOSECONFIG:
		FL_Draw(&configs_filelist, x,y,w,h);
		break;

	case MOCPM_ENTERFILENAME:
		MOpt_FilenameInputBoxDraw(x,y,w,h);
		break;
	}
}

int CT_Opt_Config_Key(int key, wchar unichar, CTab_t *tab, CTabPage_t *page)
{
	switch (MOpt_configpage_mode) {
	case MOCPM_SETTINGS:
		return Settings_Key(&settconfig, key, unichar);
		break;

	case MOCPM_CHOOSECONFIG:
		if (key == K_ENTER || key == K_MOUSE1) {
			Cbuf_AddText(va("cfg_load \"%s\"\n", COM_SkipPath(FL_GetCurrentEntry(&configs_filelist)->name)));
			MOpt_configpage_mode = MOCPM_SETTINGS;
			return true;
		} else if (key == K_ESCAPE || key == K_MOUSE2) {
			MOpt_configpage_mode = MOCPM_SETTINGS;
			return true;
		} else return FL_Key(&configs_filelist, key);

	case MOCPM_CHOOSESCRIPT:
		if (key == K_ENTER || key == K_MOUSE1) {
			Cbuf_AddText(va("exec \"cfg/%s\"\n", COM_SkipPath(FL_GetCurrentEntry(&configs_filelist)->name)));
			MOpt_configpage_mode = MOCPM_SETTINGS;
			return true;
		} else if (key == K_ESCAPE || key == K_MOUSE2) {
			MOpt_configpage_mode = MOCPM_SETTINGS;
			return true;
		} else return FL_Key(&configs_filelist, key);

	case MOCPM_ENTERFILENAME:
		if (key == K_ENTER || key == K_MOUSE1) {
			Cbuf_AddText(va("cfg_save \"%s\"\n", MOpt_FileNameInputBoxGetText()));
			MOpt_configpage_mode = MOCPM_SETTINGS;
			return true;
        } else if (key == K_ESCAPE || key == K_MOUSE2) {
			MOpt_configpage_mode = MOCPM_SETTINGS;
			return true;
		} else return MOpt_FileNameInputBoxKey(key);
	}

	return false;
}

void OnShow_SettConfig(void) { Settings_OnShow(&settconfig); }

qbool CT_Opt_Config_Mouse_Event(const mouse_state_t *ms)
{
    if (MOpt_configpage_mode == MOCPM_CHOOSECONFIG || MOpt_configpage_mode == MOCPM_CHOOSESCRIPT) {
        if (FL_Mouse_Event(&configs_filelist, ms))
            return true;
        else if (ms->button_up == 1 || ms->button_up == 2)
            return CT_Opt_Config_Key(K_MOUSE1 - 1 + ms->button_up, 0, &options_tab, options_tab.pages + OPTPG_CONFIG);

        return true;
    }
    else
    {
        return Settings_Mouse_Event(&settconfig, ms);
    }
}


// </CONFIG>
// *********

CTabPage_Handlers_t options_misc_handlers = {
	CT_Opt_Settings_Draw,
	CT_Opt_Settings_Key,
	OnShow_SettMain,
	CT_Opt_Settings_Mouse_Event
};

CTabPage_Handlers_t options_player_handlers = {
	CT_Opt_Player_Draw,
	CT_Opt_Player_Key,
	OnShow_SettPlayer,
	CT_Opt_Player_Mouse_Event
};

CTabPage_Handlers_t options_graphics_handlers = {
	CT_Opt_FPS_Draw,
	CT_Opt_FPS_Key,
	OnShow_SettFPS,
	CT_Opt_FPS_Mouse_Event
};

CTabPage_Handlers_t options_view_handlers = {
	CT_Opt_View_Draw,
	CT_Opt_View_Key,
	OnShow_SettView,
	CT_Opt_View_Mouse_Event
};

CTabPage_Handlers_t options_controls_handlers = {
	CT_Opt_Binds_Draw,
	CT_Opt_Binds_Key,
	OnShow_SettBinds,
	CT_Opt_Binds_Mouse_Event
};

CTabPage_Handlers_t options_system_handlers = {
	CT_Opt_System_Draw,
	CT_Opt_System_Key,
	OnShow_SettSystem,
	CT_Opt_System_Mouse_Event
};

CTabPage_Handlers_t options_config_handlers = {
	CT_Opt_Config_Draw,
	CT_Opt_Config_Key,
	OnShow_SettConfig,
	CT_Opt_Config_Mouse_Event
};

void Menu_Options_Key(int key, wchar unichar) {
    int handled = CTab_Key(&options_tab, key, unichar);
	options_unichar = unichar;

	if (!handled && (key == K_ESCAPE || key == K_MOUSE2))
		M_Menu_Main_f();
}

void Menu_Options_Draw(void) {
	int x, y, w, h;

	M_Unscale_Menu();

    // this will add top, left and bottom padding
    // right padding is not added because it causes annoying scrollbar behaviour
    // when mouse gets off the scrollbar to the right side of it
	w = vid.width - OPTPADDING; // here used to be a limit to 512x... size
	h = vid.height - OPTPADDING*2;
	x = OPTPADDING;
	y = OPTPADDING;

	CTab_Draw(&options_tab, x, y, w, h);
}


// PLAYER TAB
setting settplayer_arr[] = {
	ADDSET_BOOL		("Advanced Options", menu_advanced),
	ADDSET_SEPARATOR("Player Settings"),
	ADDSET_STRING	("Name", name),
	ADDSET_STRING	("Teamchat Name", cl_fakename),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_STRING	("Teamchat Name Suffix", cl_fakename_suffix),
	ADDSET_BASIC_SECTION(),
	ADDSET_ENUM     ("Gender", gender, gender_enum),
	ADDSET_STRING	("Team", team),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_SKIN		("Skin", skin),
	ADDSET_BASIC_SECTION(),
	ADDSET_COLOR	("Shirt Color", topcolor),
	ADDSET_COLOR	("Pants Color", bottomcolor),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NUMBER	("Fullbright Skins", r_fullbrightSkins, 0, 1, 0.05),
	ADDSET_ENUM    	("Ruleset", ruleset, ruleset_enum),
	ADDSET_BASIC_SECTION(),
	
	ADDSET_SEPARATOR("Weapon Handling"),
	ADDSET_CUSTOM	("Gun Autoswitch", AutoSWRead, AutoSWToggle, "Switches to the weapon picked up if it is more powerful than what you're currently holding."),
	ADDSET_BOOL		("Gun Preselect", cl_weaponpreselect),
	ADDSET_BOOL		("Gun Auto Hide", cl_weaponhide),
	
    ADDSET_SEPARATOR("Movement"),
	ADDSET_CUSTOM	("Always Run", AlwaysRunRead, AlwaysRunToggle, "Maximum forward speed at all times."),
	ADDSET_ADVANCED_SECTION(),
    ADDSET_BOOL		("Smart Jump", cl_smartjump),
	ADDSET_NAMED	("Movement Scripts", allow_scripts, allowscripts_enum),
	ADDSET_BASIC_SECTION(),
	
	ADDSET_SEPARATOR("Team Skin & Colors"),
	ADDSET_COLOR	("Shirt Color", cl_teamtopcolor),
	ADDSET_COLOR	("Pants Color", cl_teambottomcolor),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_SKIN		("Skin", cl_teamskin),
	ADDSET_NAMED	("Force Skins", teamforceskins, teamforceskins_enum),
	ADDSET_SKIN		("Quad Skin", cl_teamquadskin),
	ADDSET_SKIN		("Pent Skin", cl_teampentskin),
	ADDSET_SKIN		("Quad+Pent Skin", cl_teambothskin),
	ADDSET_BASIC_SECTION(),
	
	ADDSET_SEPARATOR("Enemy Skin & Colors"),
	ADDSET_COLOR	("Shirt Color", cl_enemytopcolor),
	ADDSET_COLOR	("Pants Color", cl_enemybottomcolor),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_SKIN		("Skin", cl_enemyskin),
	ADDSET_NAMED	("Force Skins", enemyforceskins, enemyforceskins_enum),
	ADDSET_SKIN		("Quad Skin", cl_enemyquadskin),
	ADDSET_SKIN		("Pent Skin", cl_enemypentskin),
	ADDSET_SKIN		("Quad+Pent Skin", cl_enemybothskin),
	ADDSET_BASIC_SECTION(),
};

// GRAPHICS TAB
setting settfps_arr[] = {
	ADDSET_BOOL		("Advanced Options", menu_advanced),
	
	ADDSET_SEPARATOR("Presets"),
	ADDSET_CUSTOM	("GFX Preset", GFXPresetRead, GFXPresetToggle, "Select different graphic presets."),

	ADDSET_SEPARATOR("Field Of View"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NUMBER("Draw Distance", r_farclip, 4096, 8192, 4096),
	ADDSET_BASIC_SECTION(),
	ADDSET_NUMBER	("View Size (fov)", scr_fov, 40, 140, 2),
	ADDSET_NUMBER	("Screen Size", scr_viewsize, 30, 120, 5),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NUMBER	("Rollangle", cl_rollangle, 0, 10, 1),
	ADDSET_NUMBER	("Rollspeed", cl_rollspeed, 0, 30, 2),
	ADDSET_BOOL		("Gun Kick", v_gunkick),
	ADDSET_NUMBER	("Kick Pitch", v_kickpitch, 0, 10, 0.5),
	ADDSET_NUMBER	("Kick Roll", v_kickroll, 0, 10, 0.5),
	ADDSET_NUMBER	("Kick Time", v_kicktime, 0, 10, 0.5),
	ADDSET_NUMBER	("View Height", v_viewheight, -7, 4, 0.5),
	ADDSET_BASIC_SECTION(),

	ADDSET_ADVANCED_SECTION(),	
	ADDSET_SEPARATOR("Textures"),
	ADDSET_BOOL		("Luma", gl_lumatextures),
	ADDSET_ENUM 	("Detail", gl_max_size, gl_max_size_enum),
	ADDSET_NUMBER	("Miptex", gl_miptexLevel, 0, 3, 1),
	ADDSET_BOOL		("No Textures", gl_textureless),
	ADDSET_BASIC_SECTION(),
	
	ADDSET_SEPARATOR("Player & Weapon Model"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Powerup Luma", gl_powerupshells),
	ADDSET_NUMBER	("Weapon Opacity", cl_drawgun, 0, 1, 0.05),
	ADDSET_BASIC_SECTION(),
	ADDSET_NUMBER	("Weapon Size", r_viewmodelsize, 0.1, 1, 0.05),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NUMBER	("Weapon Shift", r_viewmodeloffset, -10, 10, 1),
	ADDSET_NAMED	("Weapon Muzzleflashes", cl_muzzleflash, muzzleflashes_enum),
	ADDSET_NAMED	("Outline", gl_outline, outline_enum),
	ADDSET_BASIC_SECTION(),
	
	ADDSET_SEPARATOR("Environment"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Fullbright World", r_fullbright),
	ADDSET_BOOL		("Simple Sky", r_fastsky),
	ADDSET_BOOL		("Simple Walls", r_drawflat),
	ADDSET_BOOL		("Simple Turbs", r_fastturb),
	ADDSET_BOOL		("Simple Items", gl_simpleitems),
	ADDSET_NAMED	("Simple Items Orientation", gl_simpleitems_orientation, simpleitemsorientation_enum),
	ADDSET_BOOL		("Draw Flame", r_drawflame),
	ADDSET_BOOL		("Backpack Filter", cl_backpackfilter),
	ADDSET_BASIC_SECTION(),
	ADDSET_BOOL		("Gib Filter", cl_gibfilter),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NAMED	("Dead Body Filter", cl_deadbodyfilter, deadbodyfilter_enum),
	ADDSET_BASIC_SECTION(),
	
	ADDSET_SEPARATOR("Projectiles"),
	ADDSET_NAMED	("Explosion Type", r_explosiontype, explosiontype_enum),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NAMED	("Rocket Model", cl_rocket2grenade, rocketmodel_enum),
	ADDSET_BASIC_SECTION(),
	ADDSET_NAMED	("Rocket Trail", r_rockettrail, rockettrail_enum),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NUMBER	("Rocket Light", r_rocketlight, 0, 1, 0.05),
	ADDSET_NAMED	("Grenade Trail", r_grenadetrail, grenadetrail_enum),
	ADDSET_BASIC_SECTION(),
	ADDSET_NUMBER	("Fakeshaft", cl_fakeshaft, 0, 1, 0.05),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Hide Nails", amf_hidenails),
	ADDSET_BOOL		("Hide Rockets", amf_hiderockets),
	ADDSET_BASIC_SECTION(),

	ADDSET_SEPARATOR("Lighting"),
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	ADDSET_BOOL		("GL Bloom", r_bloom),
#endif
	ADDSET_NAMED	("Powerup Glow", r_powerupglow, powerupglow_enum),
	ADDSET_NUMBER	("Damage Flash", v_damagecshift, 0, 1, 0.1),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Pickup Flash", v_bonusflash),
	ADDSET_BASIC_SECTION(),
	ADDSET_BOOL		("Colored Lights", gl_colorlights),
	ADDSET_BOOL		("Fast Lights", gl_flashblend),
	ADDSET_ENUM     ("Dynamic Lights", r_dynamic, lighting_enum),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Darken Map", gl_lightmode),
	ADDSET_BOOL		("Particle Shaft", amf_lightning),
	ADDSET_BASIC_SECTION(),
};

// VIEW TAB
setting settview_arr[] = {
	ADDSET_BOOL		("Advanced Options", menu_advanced),
	ADDSET_SEPARATOR("Head Up Display"),
	ADDSET_NAMED	("HUD Type", scr_newHud, hud_enum),
	ADDSET_NUMBER	("Crosshair", crosshair, 0, 7, 1),
	ADDSET_NUMBER	("Crosshair Size", crosshairsize, 0.2, 3, 0.2),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NUMBER	("Crosshair Alpha", crosshairalpha, 0.1, 1, 0.1),
	ADDSET_NAMED	("Overhead Name", scr_autoid, scrautoid_enum),
	ADDSET_BASIC_SECTION(),

	ADDSET_SEPARATOR("New HUD"),
	ADDSET_BOOLLATE	("Gameclock", hud_gameclock_show),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOLLATE ("Big Gameclock", hud_gameclock_big),
	ADDSET_BASIC_SECTION(),
	ADDSET_BOOL		("Teaminfo Table", scr_teaminfo),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOLLATE ("Own Frags Announcer", hud_ownfrags_show),
	ADDSET_BOOLLATE ("Teamholdbar", hud_teamholdbar_show),
	ADDSET_BOOLLATE ("Teamholdinfo", hud_teamholdinfo_show),
	ADDSET_BOOLLATE ("Clock", hud_clock_show),
	ADDSET_BASIC_SECTION(),
	ADDSET_BOOLLATE ("FPS", hud_fps_show),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOLLATE ("Radar", hud_radar_show),
	ADDSET_BASIC_SECTION(),

	ADDSET_SEPARATOR("Quake Classic HUD"),
	ADDSET_BOOL		("Status Bar", cl_sbar),
	ADDSET_BOOL		("HUD Left", cl_hudswap),
	ADDSET_BOOL		("Show FPS", show_fps),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Show Clock", scr_clock),
	ADDSET_BASIC_SECTION(),
	ADDSET_BOOL		("Show Gameclock", scr_gameclock),

	ADDSET_SEPARATOR("Tracker Messages"),
	ADDSET_NUMBER	("Messages", amf_tracker_messages, 0, 10, 1),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Flags", amf_tracker_flags),
	ADDSET_NAMED	("Frags", amf_tracker_frags, amf_tracker_frags_enum),
	ADDSET_BOOL		("Streaks", amf_tracker_streaks),
	ADDSET_NUMBER	("Time", amf_tracker_time, 0.5, 6, 0.5),
	ADDSET_NUMBER	("Scale", amf_tracker_scale, 0.1, 2, 0.1),
	ADDSET_BOOL		("Use Images", cl_useimagesinfraglog),
	ADDSET_BOOL		("Align Right", amf_tracker_align_right),
	ADDSET_BASIC_SECTION(),

	ADDSET_ADVANCED_SECTION(),
	ADDSET_SEPARATOR("Message Filtering"),
	ADDSET_NAMED	("Ignore Opponents", ignore_opponents, ignoreopponents_enum),
	ADDSET_NAMED	("Ignore Spectators", ignore_spec, ignorespec_enum),
	ADDSET_BOOL		("Ignore Qizmo Observers", ignore_qizmo_spec),
	ADDSET_ENUM 	("Ignore Flood", ignore_flood, ignore_flood_enum),
	ADDSET_NUMBER 	("Ignore Flood Duration", ignore_flood_duration, 0, 10, 1),
	ADDSET_NAMED	("Message Filtering", msg_filter, msgfilter_enum),

	ADDSET_SEPARATOR("Outgoing Filtering"),
	ADDSET_BOOL		("Filter Colored Text", cl_sayfilter_coloredtext),
	ADDSET_BOOL		("Send #u/#c Versions", cl_sayfilter_sendboth),

	ADDSET_SEPARATOR("Console Options"),
	ADDSET_BOOL		("Timestamps", con_timestamps),
	ADDSET_NAMED	("Chat Mode", cl_chatmode, cl_chatmode_enum),
	ADDSET_NAMED	("Completion Format", con_completion_format, con_completion_format_enum),
	ADDSET_NUMBER	("Size", scr_consize, 0, 1, 0.1),
	ADDSET_NUMBER	("Speed", scr_conspeed, 1000, 9999, 1000),
	ADDSET_NUMBER	("Alpha", scr_conalpha, 0, 1, 0.1),
	ADDSET_NAMED	("Map Preview", scr_conback, scr_conback_enum),
	ADDSET_NAMED	("Fun Chars Mode", con_funchars_mode, funcharsmode_enum),
	ADDSET_NAMED	("Colored Text", scr_coloredText, coloredtext_enum),
	ADDSET_NUMBER	("Notify Time", con_notifytime, 0.5, 16, 0.5),
	ADDSET_NUMBER	("Notify Lines", _con_notifylines, 0, 16, 1),
	ADDSET_BOOL		("Confirm Quit", cl_confirmquit),

	ADDSET_SEPARATOR("Demo & Observing"),
	ADDSET_BOOL		("Chasecam", cl_chasecam),

	ADDSET_BASIC_SECTION(),
	ADDSET_SEPARATOR("Demo Playback"),
	ADDSET_NUMBER	("Multiview", cl_multiview, 0, 4, 1),
	ADDSET_BOOL		("Display HUD", cl_mvdisplayhud),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("HUD Flip", cl_mvhudflip),
	ADDSET_BOOL		("HUD Vertical", cl_mvhudvertical),
	ADDSET_BOOL		("Inset View", cl_mvinset),
	ADDSET_BOOL		("Inset HUD", cl_mvinsethud),
	ADDSET_BOOL		("Inset Cross", cl_mvinsetcrosshair),
	ADDSET_BASIC_SECTION(),
	
	ADDSET_SEPARATOR("Multiview Demos"),
	ADDSET_ACTION	("Toggle Autotrack", CL_Autotrack_f, "Toggle auto-tracking of the best player"),
	ADDSET_NAMED	("Autohud", mvd_autohud, mvdautohud_enum),
	ADDSET_NAMED	("Autotrack Type", mvd_autotrack, mvdautotrack_enum),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Autotrack Lock Team", mvd_autotrack_lockteam),
	ADDSET_BASIC_SECTION(),
	ADDSET_BOOL		("Moreinfo", mvd_moreinfo),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL     ("Status", mvd_status),
	ADDSET_BASIC_SECTION(),
};

// CONTROLS TAB
// please try to put mostly binds in here
setting settbinds_arr[] = {
	ADDSET_BOOL		("Advanced Options", menu_advanced),
	
	ADDSET_SEPARATOR("Mouse Settings"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Freelook", freelook),
	ADDSET_BASIC_SECTION(),
	ADDSET_NUMBER	("Sensitivity", sensitivity, 1, 20, 0.25), // My sens is 16, so maybe some people have it up to 20?
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NUMBER	("Menu Mouse Sensitivity", cursor_sensitivity, 0.10 , 3, 0.10),
	ADDSET_NUMBER	("Acceleration", m_accel, 0, 1, 0.1),
	ADDSET_BASIC_SECTION(),
	ADDSET_CUSTOM	("Invert Mouse", InvertMouseRead, InvertMouseToggle, "Inverts the Y axis."),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_STRING   ("X-axis Sensitivity", m_yaw),
	ADDSET_STRING   ("Y-axis Sensitivity", m_pitch),
	ADDSET_NAMED    ("Raw Mouse Input", in_raw, in_raw_enum),
	ADDSET_BASIC_SECTION(),

	ADDSET_SEPARATOR("Movement"),
	ADDSET_BIND("Attack", "+attack"),
	ADDSET_BIND("Jump/Swim up", "+jump"),
	ADDSET_BIND("Move Forward", "+forward"),
	ADDSET_BIND("Move Backward", "+back"),
	ADDSET_BIND("Strafe Left", "+moveleft"),
	ADDSET_BIND("Strafe Right", "+moveright"),
	ADDSET_BIND("Turn Left", "+left"),
	ADDSET_BIND("Turn Right", "+right"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BIND("Swim Up", "+moveup"),
	ADDSET_BIND("Swim Down", "+movedown"),
	ADDSET_BIND("Zoom In/Out", "+zoom"),
	ADDSET_BASIC_SECTION(),

	ADDSET_SEPARATOR("Weapons"),
	ADDSET_BIND("Previous Weapon", "weapon 12"),
	ADDSET_BIND("Next Weapon", "weapon 10"),
	ADDSET_BIND("Axe", "weapon 1"),
	ADDSET_BIND("Shotgun", "weapon 2"),
	ADDSET_BIND("Super Shotgun", "weapon 3"),
	ADDSET_BIND("Nailgun", "weapon 4"),
	ADDSET_BIND("Super Nailgun", "weapon 5"),
	ADDSET_BIND("Grenade Launcher", "weapon 6"),
	ADDSET_BIND("Rocket Launcher", "weapon 7"),
	ADDSET_BIND("Thunderbolt", "weapon 8"),

	ADDSET_SEPARATOR("Chat settings"),
	ADDSET_BIND	("Chat", "messagemode"),
	ADDSET_BIND	("Teamchat", "messagemode2"),

	ADDSET_SEPARATOR("Miscellaneous"),
	ADDSET_BIND("Show Scores", "+showscores"),
	ADDSET_BIND("Screenshot", "screenshot"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BIND("Pause", "pause"),
	ADDSET_BIND("Quit", "quit"),
	ADDSET_BIND("Proxy Menu", "toggleproxymenu"),
	ADDSET_BASIC_SECTION(),

	ADDSET_SEPARATOR("Demo & Spec"),
	ADDSET_BIND("Demo Controls", "demo_controls"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BIND("Autotrack", "autotrack"),
	ADDSET_BIND("Play", "cl_demospeed 1;echo Playing demo."),
	ADDSET_BIND("Stop", "disconnect"),
	ADDSET_BIND("Pause", "cl_demospeed 0;echo Demo paused."),
	ADDSET_BIND("Fast Forward", "cl_demospeed 5;echo Demo paused."),
	ADDSET_BASIC_SECTION(),

	ADDSET_SEPARATOR("Teamplay"),
	ADDSET_BIND("Report Status", "tp_msgreport"),
	ADDSET_BIND("Lost Location", "tp_msglost"),
	ADDSET_BIND("Location Safe", "tp_msgsafe"),
	ADDSET_BIND("Point At Item", "tp_msgpoint"),
	ADDSET_BIND("Took Item", "tp_msgtook"),
	ADDSET_BIND("Need Items", "tp_msgneed"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BIND("Yes/Ok", "tp_msgyesok"),
	ADDSET_BIND("Coming From Location", "tp_msgcoming"),
	ADDSET_BASIC_SECTION(),
	ADDSET_BIND("Help Location", "tp_msghelp"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BIND("Get Quad", "tp_msggetquad"),
	ADDSET_BIND("Get Pent", "tp_msggetpent"),
	ADDSET_BIND("Enemy Quad Dead", "tp_msgquaddead"),
	ADDSET_BIND("Enemy Has Powerup", "tp_msgenemypwr"),
	ADDSET_BIND("Trick At Location", "tp_msgtrick"),
	ADDSET_BIND("Replace At Location", "tp_msgreplace"),
	ADDSET_BIND("You Take Item", "tp_msgutake"),
	ADDSET_BIND("Waiting", "tp_msgwaiting"),
	ADDSET_BIND("Enemy Slipped", "tp_msgslipped"),
	ADDSET_BASIC_SECTION(),
};

// MISC TAB
setting settmisc_arr[] = {
	ADDSET_BOOL		("Advanced Options", menu_advanced),

	//Match Tools
	ADDSET_SEPARATOR("Match Tools"),
	ADDSET_BOOL		("Auto Screenshot", match_auto_sshot),
	ADDSET_ENUM 	("Screenshot Format", scr_sshot_format, scr_sshot_format_enum),
	ADDSET_NAMED	("Auto Record Demo", match_auto_record, autorecord_enum),
#ifdef _WIN32
	ADDSET_ENUM     ("Demo Format", demo_format, demoformat_enum),
#endif
	ADDSET_NAMED	("Auto Log Match", match_auto_logconsole, autorecord_enum),
	ADDSET_BOOL		("Log Readable", log_readable),

	//Paths
	ADDSET_SEPARATOR("Paths"),
	ADDSET_NAMED    ("Media Paths Type", cl_mediaroot, mediaroot_enum),
	ADDSET_STRING   ("Screenshots Path", scr_sshot_dir),
	ADDSET_STRING	("Demos Path", demo_dir),
	ADDSET_STRING   ("Logs Path", log_dir),
	ADDSET_STRING	("Qizmo Path", qizmo_dir),
	ADDSET_STRING	("QWDTools Path", qwdtools_dir),
#ifdef _WIN32
	ADDSET_ACTION	("Set qw:// assoc.", Sys_RegisterQWURLProtocol_f,
		"Sets this application as the handler of qw:// URLs, so by double-clicking such links in your operating system, this client will open and connect to given address"),
#endif

	ADDSET_ADVANCED_SECTION(),
	ADDSET_SEPARATOR	("Miscellaneous"),
	ADDSET_NAMED		("Linear Interpolation", cl_nolerp, cl_nolerp_enum),
	ADDSET_BOOL			("In-Game Menu", menu_ingame),
	ADDSET_BASIC_SECTION(),
};

// SYSTEM TAB
setting settsystem_arr[] = {
	ADDSET_BOOL		("Advanced Options", menu_advanced),

	//Video
	ADDSET_SEPARATOR("Video"),
	ADDSET_NUMBER	("Gamma", v_gamma, 0.3, 3.0, 0.1),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_ENUM		("Gamma control", vid_software_palette, vid_software_palette_enum),
	ADDSET_BASIC_SECTION(),
	ADDSET_NUMBER	("Contrast", v_contrast, 1, 5, 0.1),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_NUMBER	("Lightmap Intensity", gl_modulate, 0.5, 3.0, 0.1),
	ADDSET_BOOL		("Clear Video Buffer", gl_clear),
	ADDSET_NUMBER	("Anisotropy Filter", gl_anisotropy, 0, 16, 1),
	ADDSET_ENUM		("Quality Mode", gl_texturemode, gl_texturemode_enum),
	ADDSET_BASIC_SECTION(),

	ADDSET_SEPARATOR("Screen Settings"),
	ADDSET_BOOL("Use desktop resolution", vid_usedesktopres),
	ADDSET_CUSTOM("Resolution", ResolutionRead, ResolutionToggle, "Change your screen resolution."),
	ADDSET_BOOL("Vertical Sync", r_swapInterval),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL("Vsync Lag Fix", vid_vsync_lag_fix),
	ADDSET_BASIC_SECTION(),
	ADDSET_CUSTOM("Bit Depth", BitDepthRead, BitDepthToggle, "Choose 16bit or 32bit color mode for your screen."),
	ADDSET_CUSTOM("Fullscreen", FullScreenRead, FullScreenToggle, "Toggle between fullscreen and windowed mode."),
	ADDSET_ACTION("Apply Changes", VideoApplySettings, "Restarts the renderer and applies the selected resolution."),

#ifdef EZ_MULTIPLE_RENDERERS
	ADDSET_SEPARATOR("Renderer"),
	ADDSET_ENUM("Mode", vid_renderer, vid_renderer_enum),
	ADDSET_ACTION("Apply Changes", RendererRestart, "Restarts the renderer."),
#endif

	ADDSET_ADVANCED_SECTION(),
	ADDSET_SEPARATOR("Framebuffer"),
	ADDSET_ENUM("Mode", vid_framebuffer, vid_framebuffer_enum),
	ADDSET_BOOL("HDR", vid_framebuffer_hdr),
	ADDSET_BOOL("HDR Tonemap", vid_framebuffer_hdr_tonemap),
	ADDSET_NUMBER("Scale", vid_framebuffer_scale, 0.25, 2.0, 0.25),
	ADDSET_NUMBER("Multisample", vid_framebuffer_multisample, 0, 16, 1),
	ADDSET_NUMBER("FXAA", vid_framebuffer_fxaa, 0, 17, 1),
	ADDSET_ACTION("Apply Changes", RendererRestart, "Restarts the renderer."),
	ADDSET_BASIC_SECTION(),

	//Font
	ADDSET_ADVANCED_SECTION(),
	ADDSET_SEPARATOR("Font"),
	ADDSET_NUMBER("Width", r_conwidth, 320, 2048, 8),
	ADDSET_NUMBER("Height", r_conheight, 240, 1538, 4),
	ADDSET_BASIC_SECTION(),

	//Sound & Volume
	ADDSET_SEPARATOR("Sound & Volume"),
	ADDSET_NUMBER	("Primary Volume", s_volume, 0, 1, 0.05),
	ADDSET_BIND("Mute/Unmute", "mutesound"),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Self Volume Levels", cl_chatsound),
	ADDSET_NUMBER	("Chat Volume", con_sound_mm1_volume, 0, 1, 0.1),
	ADDSET_NUMBER	("Team Chat Volume", con_sound_mm2_volume, 0, 1, 0.1),
	ADDSET_NUMBER	("Spectator Volume", con_sound_spec_volume, 0, 1, 0.1),
	ADDSET_NUMBER	("Other Volume", con_sound_other_volume, 0, 1, 0.1),
	ADDSET_BOOL		("Static Sounds", cl_staticsounds),
	ADDSET_BOOL		("Sounds When Minimized", sys_inactivesound),
	ADDSET_BASIC_SECTION(),
	ADDSET_ENUM 	("Quality", s_khz, s_khz_enum),
	ADDSET_ENUM 	("Buffer size", s_desiredsamples, s_desired_samples_enum),

	//Connection
	ADDSET_SEPARATOR("Connection"),
	ADDSET_ENUM 	("Bandwidth Limit", rate, bandwidth_enum),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL		("Early Packets", cl_earlypackets),
	ADDSET_ENUM		("Packetloss", cl_c2sImpulseBackup, cl_c2sImpulseBackup_enum),
	ADDSET_BOOL		("QTV Buffer Adjusting", qtv_adjustbuffer),
	ADDSET_BASIC_SECTION(),

	ADDSET_ADVANCED_SECTION(),
	ADDSET_SEPARATOR("Miscellaneous"),
	ADDSET_CUSTOM	("FPS Limit", FpslimitRead, FpslimitToggle, "Limits the amount of frames rendered per second. May help with lag; best to consult forums about the best value for your setup."),
#ifdef _WIN32
	ADDSET_ENUM		("Process Priority", sys_highpriority, priority_enum),
	ADDSET_BOOL		("Taskbar Flash", vid_flashonactivity),
	ADDSET_BOOL		("Taskbar Name", cl_window_caption),
#endif
	ADDSET_BASIC_SECTION(),
};

// CONFIG TAB
setting settconfig_arr[] = {
	ADDSET_BOOL		("Advanced Options", menu_advanced),
	ADDSET_ACTION	("Go To Console", Con_ToggleConsole_f, "Opens the console."),

    ADDSET_SEPARATOR("Load & Save"),
    ADDSET_ACTION("Reload Settings", MOpt_LoadCfg, "Reset the settings to last saved configuration."),
    ADDSET_ACTION("Save Settings", MOpt_SaveCfg, "Save the settings"),
	ADDSET_ADVANCED_SECTION(),
    ADDSET_BOOL("Save To Profile Dir", cfg_use_home),
	ADDSET_BOOL("Save To Mod Directory", cfg_use_gamedir),
    ADDSET_BASIC_SECTION(),
	ADDSET_ACTION("Reset To Defaults", DefaultConfig, "Reset all settings to defaults"),

    
	ADDSET_SEPARATOR("Export & Import"),
	ADDSET_ACTION("Load Script", MOpt_LoadScript, "Find and load scripts here."),
	ADDSET_ACTION("Import config ...", MOpt_ImportConfig, "You can load a configuration file from here."),
	ADDSET_ACTION("Export config ...", MOpt_ExportConfig, "Will export your current configuration to a file."),
	
	ADDSET_SEPARATOR("Config Saving Options"),
    ADDSET_ACTION("Reset Saving Options", MOpt_CfgSaveAllOn, "Configuration saving settings will be reset to defaults."),
    ADDSET_BOOL("Auto Save On Quit", cfg_save_onquit),
	ADDSET_BOOL("Save Unchanged Opt.", cfg_save_unchanged),
	ADDSET_ADVANCED_SECTION(),
	ADDSET_BOOL("Backup Old File", cfg_backup),
	ADDSET_NAMED("Load Legacy", cfg_legacy_exec, MOpt_legacywrite_enum),
	ADDSET_BOOL("Aliases", cfg_save_aliases),
	ADDSET_BOOL("Binds", cfg_save_binds),
	ADDSET_BOOL("Cmdline", cfg_save_cmdline),
	ADDSET_BOOL("Init Commands", cfg_save_cmds),
	ADDSET_BOOL("Variables", cfg_save_cvars),
	ADDSET_NAMED("Userinfo", cfg_save_userinfo, MOpt_userinfo_enum)
};

qbool Menu_Options_Mouse_Event(const mouse_state_t *ms)
{
	mouse_state_t nms = *ms;

    if (ms->button_up == 2) {
        Menu_Options_Key(K_MOUSE2, 0);
        return true;
    }

	// we are sending relative coordinates
	nms.x -= OPTPADDING;
	nms.y -= OPTPADDING;
	nms.x_old -= OPTPADDING;
	nms.y_old -= OPTPADDING;

	if (nms.x < 0 || nms.y < 0) return false;

	return CTab_Mouse_Event(&options_tab, &nms);
}
void Menu_Options_Init(void) {
	Settings_MainInit();

	Settings_Page_Init(settmisc, settmisc_arr);
	Settings_Page_Init(settfps, settfps_arr);
	Settings_Page_Init(settview, settview_arr);
	Settings_Page_Init(settplayer, settplayer_arr);
	Settings_Page_Init(settbinds, settbinds_arr);
	Settings_Page_Init(settsystem, settsystem_arr);
	Settings_Page_Init(settconfig, settconfig_arr);

	Cvar_SetCurrentGroup(CVAR_GROUP_MENU);
	Cvar_Register(&menu_advanced);
	Cvar_ResetCurrentGroup();

	FL_Init(&configs_filelist, "./ezquake/configs");
	FL_SetDirUpOption(&configs_filelist, false);
	FL_SetDirsOption(&configs_filelist, false);
	FL_AddFileType(&configs_filelist, 0, ".cfg");
	FL_AddFileType(&configs_filelist, 1, ".txt");

	CEditBox_Init(&filenameeb, 32, 64);

	CTab_Init(&options_tab);
	CTab_AddPage(&options_tab, "Player", OPTPG_PLAYER, &options_player_handlers);
	CTab_AddPage(&options_tab, "Graphics", OPTPG_FPS, &options_graphics_handlers);
	CTab_AddPage(&options_tab, "View", OPTPG_HUD, &options_view_handlers);
	CTab_AddPage(&options_tab, "Controls", OPTPG_BINDS, &options_controls_handlers);
	CTab_AddPage(&options_tab, "Misc", OPTPG_MISC, &options_misc_handlers);
	CTab_AddPage(&options_tab, "System", OPTPG_SYSTEM, &options_system_handlers);
	CTab_AddPage(&options_tab, "Config", OPTPG_CONFIG, &options_config_handlers);
	CTab_SetCurrentId(&options_tab, OPTPG_PLAYER);
}

void Menu_Options_Shutdown(void)
{
	FL_Shutdown(&configs_filelist);
	Settings_Shutdown(&settmisc);
	Settings_Shutdown(&settfps);
	Settings_Shutdown(&settview);
	Settings_Shutdown(&settplayer);
	Settings_Shutdown(&settbinds);
	Settings_Shutdown(&settsystem);
	Settings_Shutdown(&settconfig);
	Settings_MainShutdown();
}

qbool Menu_Options_IsBindingKey (void)
{
	// Options/Binds, and waiting for a keypress
	return m_state == m_options && (
		(CTab_GetCurrentId (&options_tab) == OPTPG_BINDS && settbinds.mode == SPM_BINDING) ||
		(CTab_GetCurrentId (&options_tab) == OPTPG_SYSTEM && settsystem.mode == SPM_BINDING)
	);
}


================================================
FILE: src/menu_options.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
	Options Menu module
	$Id: menu_options.h,v 1.4 2007-03-19 13:23:20 johnnycz Exp $
*/

// <interface for menu.c>
// initializes the "Demo" menu on client startup
void Menu_Options_Init(void);

// process key press that belongs to demo menu
void Menu_Options_Key(int key, wchar unichar);

// process request to draw the demo menu
void Menu_Options_Draw (void);

qbool Menu_Options_IsBindingKey (void);

// process mouse move
qbool Menu_Options_Mouse_Event(const mouse_state_t *);
// </interface>


================================================
FILE: src/menu_proxy.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*

	Proxy Menu module

	This stands rather apart from the Main Menu hierarchy,
	but we still use the menu structures.

	made by:
		johnnycz, Jan 2007
	last edit:
		$Id: menu_proxy.c,v 1.2 2007-03-11 06:01:41 disconn3ct Exp $

*/

#include "quakedef.h"
#include "menu.h"
#include "keys.h"


#define PROXYACCESS "say proxy:menu"
#define ProxyMenuToggle() Cbuf_AddText(PROXYACCESS "\n");
#define ProxyMenuCmd(x) Cbuf_AddText(PROXYACCESS " " x "\n")

// disconnection from proxy should make us leave menus
qbool CheckProxyConnection(void) {
	if (!CL_ConnectedToProxy()) {
		Com_Printf("You are not connected to a proxy.\n");
		M_LeaveMenus();
		return false;
	}

	return true;
}

void Menu_Proxy_Toggle(void)
{
	if (!CheckProxyConnection())
		return;

	ProxyMenuToggle();
}

void Menu_Proxy_Key(int key)
{
	if (!CheckProxyConnection())
		return;

	switch (key) {
	case K_ESCAPE: 
		ProxyMenuToggle(); 
		M_LeaveMenus();
		break;
	case K_MOUSE1: case K_ENTER:
		ProxyMenuCmd("select"); break;
	case K_BACKSPACE: ProxyMenuCmd("back"); break;

	case K_UPARROW: ProxyMenuCmd("up"); break;
	case K_DOWNARROW: ProxyMenuCmd("down"); break;
	case K_LEFTARROW: ProxyMenuCmd("left"); break;
	case K_RIGHTARROW: ProxyMenuCmd("right"); break;

	case K_PGDN: ProxyMenuCmd("pgdn"); break;
	case K_PGUP: ProxyMenuCmd("pgup"); break;
	case K_HOME: ProxyMenuCmd("home"); break;
	case K_END: ProxyMenuCmd("end"); break;
	case K_DEL: ProxyMenuCmd("delete"); break;
	case K_INS: ProxyMenuCmd("help"); break;
	}
}

void Menu_Proxy_Draw(void) { 
// proxy menu is usually drawn by centerprint messages
// but ofc this can be changed later .. don't forget to hack SCR_CheckDrawCenterString() then again
} 


================================================
FILE: src/menu_proxy.h
================================================
/*
Proxy Menu module

Copyright (C) 2011 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// catches key presses sent to proxy
void Menu_Proxy_Key(int key);

// main proxy menu drawing function
void Menu_Proxy_Draw(void);

// send signal to the proxy to toggle the menu
void Menu_Proxy_Toggle(void);


================================================
FILE: src/modelgen.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
//
// modelgen.h: header file for model generation program
//

// *********************************************************
// * This file must be identical in the modelgen directory *
// * and in the Quake directory, because it's used to      *
// * pass data from one to the other via model files.      *
// *********************************************************

#ifdef INCLUDELIBS

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>

#include "cmdlib.h"
#include "scriplib.h"
#include "trilib.h"
#include "lbmlib.h"
#include "mathlib.h"

#endif

#define ALIAS_VERSION	6

#define ALIAS_ONSEAM				0x0020

// must match definition in spritegn.h
#ifndef SYNCTYPE_T
#define SYNCTYPE_T
typedef enum {ST_SYNC=0, ST_RAND } synctype_t;
#endif

typedef enum { ALIAS_SINGLE=0, ALIAS_GROUP } aliasframetype_t;

typedef enum { ALIAS_SKIN_SINGLE=0, ALIAS_SKIN_GROUP } aliasskintype_t;

typedef struct {
	int			ident;
	int			version;
	vec3_t		scale;
	vec3_t		scale_origin;
	float		boundingradius;
	vec3_t		eyeposition;
	int			numskins;
	int			skinwidth;
	int			skinheight;
	int			numverts;
	int			numtris;
	int			numframes;
	synctype_t	synctype;
	int			flags;
	float		size;
} mdl_t;

// TODO: could be shorts

typedef struct {
	int		onseam;
	int		s;
	int		t;
} stvert_t;

typedef struct dtriangle_s {
	int					facesfront;
	int					vertindex[3];
} dtriangle_t;

#define DT_FACES_FRONT				0x0010

// This mirrors trivert_t in trilib.h, is present so Quake knows how to
// load this data

typedef struct {
	byte	v[3];
	byte	lightnormalindex;
} trivertx_t;

typedef struct {
	vec3_t  v;
	vec3_t  normal;
	byte	lightnormalindex;
} ez_trivertx_t;

typedef struct {
	trivertx_t	bboxmin;	// lightnormal isn't used
	trivertx_t	bboxmax;	// lightnormal isn't used
	char		name[16];	// frame name from grabbing
} daliasframe_t;

typedef struct {
	int			numframes;
	trivertx_t	bboxmin;	// lightnormal isn't used
	trivertx_t	bboxmax;	// lightnormal isn't used
} daliasgroup_t;

typedef struct {
	int			numskins;
} daliasskingroup_t;

typedef struct {
	float	interval;
} daliasinterval_t;

typedef struct {
	float	interval;
} daliasskininterval_t;

typedef struct {
	aliasframetype_t	type;
} daliasframetype_t;

typedef struct {
	aliasskintype_t	type;
} daliasskintype_t;

#define IDPOLYHEADER	(('O'<<24)+('P'<<16)+('D'<<8)+'I')
														// little-endian "IDPO"



================================================
FILE: src/movie.c
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: movie.c,v 1.26 2007-10-11 06:46:12 borisu Exp $
*/

#include "quakedef.h"
#include "utils.h"
#include "qsound.h"
#include "image.h"
#ifdef _WIN32
#include "movie_avi.h"	//joe: capturing to avi
#include <windows.h>
#else
	#include <time.h>
#endif

static void OnChange_movie_dir(cvar_t *var, char *string, qbool *cancel);
static void WAVCaptureStop (void);
static void WAVCaptureStart (void);
void SCR_Movieshot (char *);	//joe: capturing to avi

//joe: capturing audio
// Variables for buffering audio
static short capture_audio_samples[44100];	// big enough buffer for 1fps at 44100Hz
static int captured_audio_samples;
static qbool frame_has_sound = false;

#ifdef _WIN32
void OnChange_movie_codec(cvar_t *var, char *string, qbool *cancel);
LONG Movie_CurrentLength(void);

static char movie_avi_filename[MAX_OSPATH]; // Stores the user's requested filename
static void Movie_Start_AVI_Capture(void);
static int avi_number = 0;

//joe: capturing to avi
static qbool movie_is_avi = false;
qbool movie_avi_loaded = false, movie_acm_loaded = false;
static char avipath[256];
static FILE *avifile = NULL;
cvar_t   movie_codec      = {"demo_capture_codec", "0", 0, OnChange_movie_codec };	// Capturing to avi
cvar_t   movie_mp3        = {"demo_capture_mp3", "0"};
cvar_t   movie_mp3_kbps   = {"demo_capture_mp3_kbps", "128"};
cvar_t   movie_vid_maxlen = {"demo_capture_vid_maxlen", "0"};
#endif

cvar_t          movie_fps                = {"demo_capture_fps", "30.0"};
static cvar_t   movie_dir                = {"demo_capture_dir",  "capture", 0, OnChange_movie_dir};
cvar_t          movie_steadycam          = {"demo_capture_steadycam", "0"};
static cvar_t   movie_background_threads = {"demo_capture_background_threads", "0"};

extern cvar_t scr_sshot_type;

static unsigned char aviSoundBuffer[4096]; // Static buffer for mixing

static double movie_real_start_time;
static volatile qbool movie_is_capturing = false;
static double movie_start_time;
static double movie_len;
static int movie_frame_count;
static char image_ext[4];
static qbool capturing_apng;
static int apng_expected_frames;


#ifdef _WIN32
	static SYSTEMTIME movie_start_date;
#else
	struct tm movie_start_date;
#endif

qbool Movie_IsCapturing(void)
{
	return cls.demoplayback && !cls.timedemo && movie_is_capturing;
}

double Movie_Frametime(void)
{
	double time = (double)(movie_fps.value > 0 ? 1.0 / movie_fps.value : 1 / 30.0);

	return bound(1.0 / 1000, time, 1.0);;
}

double Movie_InputFrametime(void)
{
	if (movie_steadycam.value) {
		return movie_fps.value > 0 ? 1.0 / movie_fps.value : 1 / 30.0;
	}

	return cls.trueframetime;
}

static void Movie_Start(double _time) 
{
	extern cvar_t scr_sshot_format;

	#ifndef _WIN32
	time_t t;
	t = time(NULL);
	localtime_r(&t, &movie_start_date);
	#else
	GetLocalTime(&movie_start_date);
	#endif
	#ifdef _WIN32
	movie_is_avi = !!avifile; //joe: capturing to avi
	#endif
	movie_len = _time;
	movie_start_time = cls.realtime;

	movie_frame_count = 0;

	#ifdef _WIN32
	if (movie_is_avi)	//joe: capturing to avi
	{
		movie_is_capturing = Capture_Open (avipath);
	}
	else
	#endif
	{
		// DEFAULT_SSHOT_FORMAT
		if (!strcmp(scr_sshot_format.string, "tga")
		 || !strcmp(scr_sshot_format.string, "jpeg")
		 || !strcmp(scr_sshot_format.string, "jpg")
		 || !strcmp(scr_sshot_format.string, "png"))
		{
			strlcpy(image_ext, scr_sshot_format.string, sizeof(image_ext));		
		}
		else if (!strcmp(scr_sshot_format.string, "apng")) {
			strlcpy(image_ext, "png", sizeof(image_ext));
		}
		else
		{
			strlcpy (image_ext, "tga", sizeof (image_ext));
		}
		movie_is_capturing = true;
		WAVCaptureStart ();
	}
	movie_real_start_time = Sys_DoubleTime ();
}

void Movie_Stop(qbool restarting)
{
	if (Movie_AnimatedPNG()) {
		Image_CloseAPNG();
	}
#ifdef _WIN32
	if (movie_is_avi) { //joe: capturing to avi
		Capture_Close ();
		fclose (avifile);
		avifile = NULL;
	}
	if (!restarting) {
		S_StopAllSounds();
		Movie_BackgroundShutdown();

		Com_Printf("Captured %d frames (%.2fs).\n", movie_frame_count, (float) (cls.realtime - movie_start_time));
		Com_Printf("  Time: %5.1f seconds\n", Sys_DoubleTime() - movie_real_start_time);
	}
#endif
	WAVCaptureStop ();
	movie_is_capturing = restarting;
}

void Movie_Demo_Capture_f(void)
{
	int argc;
	double duration;
	char *error;
	extern cvar_t scr_sshot_format;

#ifdef _WIN32
	error = va("Usage: %s (\"start\" time [avifile]) | \"stop\"\n", Cmd_Argv(0));
	if ((argc = Cmd_Argc()) != 2 && argc != 3 && argc != 4) {
#else
	error = va("Usage: %s (\"start\" time) | \"stop\"\n", Cmd_Argv(0));
	if ((argc = Cmd_Argc()) != 2 && argc != 3) {
#endif
		Com_Printf(error);
		return;
	}
	if (argc == 2) {
		if (strncasecmp("stop", Cmd_Argv(1), 4))
			Com_Printf(error);
		else if (Movie_IsCapturing()) 
			Movie_Stop(false);
		else
			Com_Printf("%s : Not capturing\n", Cmd_Argv(0));
		return;
	}
	if (strncasecmp("start", Cmd_Argv(1), 5)) {
		Com_Printf(error);
		return;
	} else if (Movie_IsCapturing()) {
		Com_Printf("%s : Already capturing\n", Cmd_Argv(0));
		return;
	}
	if (!cls.demoplayback || cls.timedemo) {
		Com_Printf("%s : Must be playing a demo to capture\n", Cmd_Argv(0));
		return;
	}
	if ((duration = Q_atof(Cmd_Argv(2))) <= 0) {
		Com_Printf("%s : Time argument must be positive\n", Cmd_Argv(0));
		return;
	}
	capturing_apng = false;
#ifdef _WIN32
	//joe: capturing to avi
	if (argc == 4) {
		avi_number = 0;

		strlcpy(movie_avi_filename, Cmd_Argv(3), sizeof(movie_avi_filename)-10);		// Store user's requested filename
		if (!movie_avi_loaded) {
			Com_Printf_State (PRINT_FAIL, "Avi capturing not initialized\n");
			return;
		}

		Movie_Start_AVI_Capture();
	}
	else
#endif
	if (!strcasecmp(scr_sshot_format.string, "apng")) {
		char fname[MAX_OSPATH];
		extern cvar_t image_png_compression_level;
		extern int glwidth, glheight;
#ifndef _WIN32
		time_t t;
		t = time(NULL);
		localtime_r(&t, &movie_start_date);

		snprintf(fname, sizeof(fname), "%s/capture_%02d-%02d-%04d_%02d-%02d-%02d/capture.png",
			movie_dir.string, movie_start_date.tm_mday, movie_start_date.tm_mon, movie_start_date.tm_year,
			movie_start_date.tm_hour, movie_start_date.tm_min, movie_start_date.tm_sec);
#else
		GetLocalTime(&movie_start_date);

		snprintf(fname, sizeof(fname), "%s/capture_%02d-%02d-%04d_%02d-%02d-%02d/capture.png",
			movie_dir.string, movie_start_date.wDay, movie_start_date.wMonth, movie_start_date.wYear,
			movie_start_date.wHour, movie_start_date.wMinute, movie_start_date.wSecond);
#endif

		apng_expected_frames = duration * movie_fps.integer;
		capturing_apng = Image_OpenAPNG(fname, image_png_compression_level.integer, glwidth, glheight, apng_expected_frames);

		if (!capturing_apng) {
			Movie_BackgroundInitialise();
		}
	}
	else {
		Movie_BackgroundInitialise();
	}
	Movie_Start(duration);
}

#ifdef _WIN32
static void Movie_Start_AVI_Capture(void)
{
	++avi_number;

	// If we're going to break up the movie, append number
	char aviname[MAX_OSPATH];
	if (avi_number > 1) {
		snprintf (aviname, sizeof (aviname), "%s-%03d", movie_avi_filename, avi_number);
	}
	else {
		strlcpy (aviname, movie_avi_filename, sizeof (aviname));
	}

	if (!(Util_Is_Valid_Filename(aviname))) {
		Com_Printf(Util_Invalid_Filename_Msg(aviname));
		return;
	}
	COM_ForceExtensionEx (aviname, ".avi", sizeof (aviname));
	snprintf (avipath, sizeof(avipath), "%s/%s/%s", com_basedir, movie_dir.string, aviname);
	if (!(avifile = fopen(avipath, "wb"))) {
		FS_CreatePath (avipath);
		if (!(avifile = fopen(avipath, "wb"))) {
			Com_Printf("Error: Couldn't open %s\n", aviname);
			return;
		}
	}
}
#endif

void Movie_Init(void) {
	Cvar_SetCurrentGroup(CVAR_GROUP_DEMO);
	Cvar_Register(&movie_fps);
	Cvar_Register(&movie_dir);
	Cvar_Register(&movie_background_threads);
	Cvar_Register(&movie_steadycam);

	Cvar_ResetCurrentGroup();

	Cmd_AddCommand("demo_capture", Movie_Demo_Capture_f);

#ifdef _WIN32
	Capture_InitAVI ();		//joe: capturing to avi
	if (!movie_avi_loaded)
		return;

	captured_audio_samples = 0;
	Cvar_SetCurrentGroup(CVAR_GROUP_DEMO);
	Cvar_Register(&movie_codec);
	Cvar_Register(&movie_vid_maxlen);

	Cvar_ResetCurrentGroup();

	Capture_InitACM ();
	if (!movie_acm_loaded)
		return;

	Cvar_SetCurrentGroup(CVAR_GROUP_DEMO);
	Cvar_Register(&movie_mp3);
	Cvar_Register(&movie_mp3_kbps);

	Cvar_ResetCurrentGroup();
#endif
}

void Movie_StartFrame(void) 
{
	if (Cmd_FindAlias("f_captureframe")) {
		Cbuf_AddTextEx (&cbuf_main, "f_captureframe\n");
	}
}

void Movie_FinishFrame(void) 
{
	char fname[128];
	if (!Movie_IsCapturing())
		return;

	#ifdef _WIN32
	if (!movie_is_avi) 
	{
		snprintf(fname, sizeof(fname), "%s/capture_%02d-%02d-%04d_%02d-%02d-%02d/shot-%06d.%s",
			movie_dir.string, movie_start_date.wDay, movie_start_date.wMonth, movie_start_date.wYear,
			movie_start_date.wHour,	movie_start_date.wMinute, movie_start_date.wSecond, movie_frame_count, image_ext);

		con_suppress = true;
	}
	else 
	{
		fname[0] = '\0';
		// Split up if we're over the time limit for each segment
		if (movie_vid_maxlen.integer && Movie_CurrentLength() >= movie_vid_maxlen.value * 1024 * 1024) 
		{
			double original_start_time = movie_start_time;

			// Close existing, and start again
			Movie_Stop(true);
			Movie_Start_AVI_Capture();
			Movie_Start(movie_len);

			// keep track of original start time so we know when to stop for good
			movie_start_time = original_start_time;
		}
	}
	#else
	snprintf(fname, sizeof(fname), "%s/capture_%02d-%02d-%04d_%02d-%02d-%02d/shot-%06d.%s",
		movie_dir.string, movie_start_date.tm_mday, 1 + movie_start_date.tm_mon, 1900 + movie_start_date.tm_year,
		movie_start_date.tm_hour, movie_start_date.tm_min, movie_start_date.tm_sec, movie_frame_count, image_ext);

	con_suppress = true;
	#endif // _WIN32

	SCR_Movieshot (fname);
	movie_frame_count++;

#ifdef _WIN32
	if (!movie_is_avi)
#endif
	{
		con_suppress = false;
	}

	if (Movie_AnimatedPNG()) {
		if (movie_frame_count >= apng_expected_frames) {
			Movie_Stop(false);
		}
	}
	else if (cls.realtime >= movie_start_time + movie_len) {
		Movie_Stop (false);
	}
}

qbool Movie_IsCapturingAVI(void) {
#ifdef _WIN32
	return movie_is_avi && Movie_IsCapturing();
#else
	return false;
#endif
}

static vfsfile_t *wav_output = NULL;
static int wav_sample_count = 0;

static void WAVCaptureStart (void)
{
	// WAV file format details taken from http://soundfile.sapp.org/doc/WaveFormat/
	char fname[MAX_PATH];

	int chunkSize = 0;  // We write 0 to start with, need to replace once we know number of samples
	int fmtBlockSize = LittleLong (16);
	short fmtFormat = LittleShort (1); // PCM, uncompressed
	short fmtNumberChannels = LittleShort (shw->numchannels);
	int fmtSampleRate = LittleLong (shw->khz);
	int fmtBitsPerSample = 16;
	int fmtByteRate = shw->khz * fmtNumberChannels * (fmtBitsPerSample / 8);  // 16 = 16 bit sound
	int fmtBlockAlign = (fmtBitsPerSample / 8) * shw->numchannels; // 16 bit sound

#ifdef _WIN32
	snprintf (fname, sizeof (fname), "%s/capture_%02d-%02d-%04d_%02d-%02d-%02d/audio.wav",
		movie_dir.string, movie_start_date.wDay, movie_start_date.wMonth, movie_start_date.wYear,
		movie_start_date.wHour, movie_start_date.wMinute, movie_start_date.wSecond);
#else
	snprintf (fname, sizeof (fname), "%s/capture_%02d-%02d-%04d_%02d-%02d-%02d/audio.wav",
		movie_dir.string, movie_start_date.tm_mday, 1 + movie_start_date.tm_mon, 1900 + movie_start_date.tm_year,
		movie_start_date.tm_hour, movie_start_date.tm_min, movie_start_date.tm_sec);
#endif
	if (!(wav_output = FS_OpenVFS (fname, "wb", FS_NONE_OS))) {
		FS_CreatePath (fname);
		if (!(wav_output = FS_OpenVFS (fname, "wb", FS_NONE_OS)))
			return;
	}

	// RIFF header
	VFS_WRITE (wav_output, "RIFF", 4);
	VFS_WRITE (wav_output, &chunkSize, 4);
	VFS_WRITE (wav_output, "WAVE", 4);

	// "fmt " chunk (24 bytes total)
	VFS_WRITE (wav_output, "fmt ", 4);
	VFS_WRITE (wav_output, &fmtBlockSize, 4);
	VFS_WRITE (wav_output, &fmtFormat, 2);
	VFS_WRITE (wav_output, &fmtNumberChannels, 2);
	VFS_WRITE (wav_output, &fmtSampleRate, 4);
	VFS_WRITE (wav_output, &fmtByteRate, 4);
	VFS_WRITE (wav_output, &fmtBlockAlign, 2);
	VFS_WRITE (wav_output, &fmtBitsPerSample, 2);

	// "data" chunk
	VFS_WRITE (wav_output, "data", 4);
	VFS_WRITE (wav_output, &chunkSize, 4);

	// actual data will be written as audio mixed each frame
	wav_sample_count = 0;
}

static void WAVCaptureFrame (int samples, byte *sample_buffer)
{
	int i;

	if (wav_output) {
		for (i = 0; i < samples; ++i) {
			unsigned long original = LittleLong (*(unsigned long*)sample_buffer);

			VFS_WRITE (wav_output, &original, 4);
			sample_buffer += 4;
		}

		wav_sample_count += samples;
	}
}

static void WAVCaptureStop (void)
{
	if (wav_output) {
		// Now we know how many samples, so can fill in the blocks in the file
		int dataSize = wav_sample_count * 2 * shw->numchannels; // 16 bit sound, stereo
		int riffChunkSize = 36 + dataSize; // 36 = 4[format field] + (8 + chunk1size)[fmt block] + 8 [subchunk2Id + size fields]

		VFS_SEEK (wav_output, 4, SEEK_SET);
		VFS_WRITE (wav_output, &riffChunkSize, 4);
		VFS_SEEK (wav_output, 40, SEEK_SET);   // RIFF header = 12, fmt chunk 24, "data" 4
		VFS_WRITE (wav_output, &dataSize, 4);
		VFS_CLOSE (wav_output);

		wav_output = 0;
		wav_sample_count = 0;
	}
}

void Movie_MixFrameSound (void (*mixFunction)(void))
{
	int samples_required = (int)(0.5 + Movie_Frametime() * shw->khz) * shw->numchannels - (captured_audio_samples << 1);

	memset(aviSoundBuffer, 0, sizeof(aviSoundBuffer));
	shw->buffer = (unsigned char*)aviSoundBuffer;
	shw->samples = min(samples_required, sizeof(aviSoundBuffer) / 2);
	frame_has_sound = false;

	do {
		mixFunction();
	} while (! frame_has_sound);
}

void Movie_TransferSound(void* data, int snd_linear_count)
{
	int samples_per_frame = (int)(0.5 + Movie_Frametime() * shw->khz);

	// Write some sound
	memcpy(capture_audio_samples + (captured_audio_samples << 1), data, snd_linear_count * shw->numchannels);
	captured_audio_samples += (snd_linear_count >> 1);
	shw->snd_sent += snd_linear_count * shw->numchannels;

	if (captured_audio_samples >= samples_per_frame) {
		// We have enough audio samples to match one frame of video
#ifdef _WIN32
		if (movie_is_avi) {
			Capture_WriteAudio (samples_per_frame, (byte *)capture_audio_samples);
		}
		else {
			WAVCaptureFrame (samples_per_frame, (byte *)capture_audio_samples);
		}
#else
		WAVCaptureFrame (samples_per_frame, (byte *)capture_audio_samples);
#endif
		memcpy (capture_audio_samples, capture_audio_samples + (samples_per_frame << 1), (captured_audio_samples - samples_per_frame) * 2 * shw->numchannels);
		captured_audio_samples -= samples_per_frame;

		frame_has_sound = true;
	}
}

static void OnChange_movie_dir(cvar_t *var, char *string, qbool *cancel) {
	if (Movie_IsCapturing()) {
		Com_Printf("Cannot change demo_capture_dir whilst capturing.  Use 'demo_capture stop' to cease capturing first.\n");
		*cancel = true;
		return;
	} else if (strlen(string) > 31) {
		Com_Printf("demo_capture_dir can only contain a maximum of 31 characters\n");
		*cancel = true;
		return;
	}
	Util_Process_Filename(string);
	if (!(Util_Is_Valid_Filename(string))) {
		Com_Printf(Util_Invalid_Filename_Msg("demo_capture_dir"));
		*cancel = true;
		return;
	}
}

typedef struct background_thread_s {
	SDL_Thread* thread;            // thread handle
	SDL_mutex* mutex;              // mutex
	SDL_sem* finished;             // signals that the background thread should terminate (set by main)
	SDL_sem* signal;               // queue length
	scr_sshot_target_t* data;      // queue data
	byte* buffer;                  // screenshot data
} background_thread_t;

#define MAX_SCREENSHOT_THREADS           8

static background_thread_t threads[MAX_SCREENSHOT_THREADS] = { { 0 } };
static byte* tempBuffer = 0;
static int background_threads = 0;
static int next_thread = 0;
static size_t movie_width = 0;
static size_t movie_height = 0;

static int Movie_BackgroundThread(void* thread_data)
{
	background_thread_t* thread = (background_thread_t*) thread_data;
	while (true) {
		// Wait to be woken up
		SDL_SemWait(thread->signal);

		SDL_LockMutex(thread->mutex);
		if (SDL_SemTryWait(thread->finished) == SDL_MUTEX_TIMEDOUT) {
			SCR_ScreenshotWrite(thread->data);
			SDL_UnlockMutex(thread->mutex);
		}
		else {
			SDL_UnlockMutex(thread->mutex);
			break;
		}
	}

	return 0;
}

qbool Movie_BackgroundInitialise(void)
{
	extern int glwidth, glheight;
	int i;

	background_threads = (int) bound(0, movie_background_threads.integer, MAX_SCREENSHOT_THREADS);
	if (background_threads) {
		memset(&threads, 0, sizeof(threads));
		next_thread = 0;

		// Create background threads in background
		for (i = 0; i < background_threads; ++i) {
			threads[i].mutex = SDL_CreateMutex();
			threads[i].signal = SDL_CreateSemaphore(0);
			threads[i].finished = SDL_CreateSemaphore(0);
			threads[i].buffer = Q_malloc(glwidth * glheight * 3);
			threads[i].thread = SDL_CreateThread(Movie_BackgroundThread, NULL, (void*)&threads[i]);
		}
	}

	movie_height = glheight;
	movie_width = glwidth;
	tempBuffer = Q_malloc(movie_width * movie_height * 3);

	return true;
}

void Movie_BackgroundShutdown(void)
{
	int i;

	for (i = 0; i < background_threads; ++i) {
		SDL_SemPost(threads[i].finished);
		SDL_SemPost(threads[i].signal);
	}

	for (i = 0; i < background_threads; ++i) {
		SDL_WaitThread(threads[i].thread, NULL);
		SDL_DestroySemaphore(threads[i].finished);
		SDL_DestroySemaphore(threads[i].signal);
		SDL_DestroyMutex(threads[i].mutex);

		Q_free(threads[i].buffer);
	}

	Q_free(tempBuffer);

}

byte* Movie_TempBuffer(size_t width, size_t height)
{
	if (width != movie_width || height != movie_height) {
		return NULL;
	}

	return tempBuffer;
}

qbool Movie_BackgroundCapture(scr_sshot_target_t* params)
{
	if (params->buffer != tempBuffer) {
		return false;
	}

	if (Movie_IsCapturing() && ! Movie_IsCapturingAVI() && background_threads) {
		background_thread_t* thread = &threads[next_thread];

		SDL_LockMutex(thread->mutex);
		memcpy(thread->buffer, params->buffer, params->width * params->height * 3);
		params->buffer = thread->buffer;
		thread->data = params;
		SDL_UnlockMutex(thread->mutex);
		SDL_SemPost(thread->signal);

		next_thread = (next_thread + 1) % background_threads;
		return true;
	}

	return false;
}

qbool Movie_AnimatedPNG(void)
{
	return Movie_IsCapturing() && capturing_apng;
}


================================================
FILE: src/movie.h
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef __MOVIE_H_

#define __MOVIE_H_

void Movie_Init(void);
void Movie_StartFrame(void);
void Movie_FinishFrame(void);
qbool Movie_IsCapturing(void);
qbool Movie_IsCapturingAVI(void);
void Movie_Stop(qbool restarting);
double Movie_Frametime(void);
double Movie_InputFrametime(void);
qbool Movie_TransferSound(void* data, int snd_linear_count);
void Movie_MixFrameSound(void (*mixFunction)(void));

#endif


================================================
FILE: src/movie_avi.c
================================================
/*
Copyright (C) 2001 Quake done Quick

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// movie_avi.c

#include "quakedef.h"
#include <windows.h>
#include <vfw.h>
#include <msacm.h>
#include <mmreg.h>
#include <mmsystem.h>
#include "movie_avi.h"
#include "qsound.h"
#include "gl_model.h"

#ifndef ACMAPI // mingw hax
#define ACMAPI WINAPI
#endif

static void (CALLBACK *qAVIFileInit)(void);
static HRESULT (CALLBACK *qAVIFileOpen)(PAVIFILE *, LPCTSTR, UINT, LPCLSID);
static HRESULT (CALLBACK *qAVIFileCreateStream)(PAVIFILE, PAVISTREAM *, AVISTREAMINFO *);
static HRESULT (CALLBACK *qAVIMakeCompressedStream)(PAVISTREAM *, PAVISTREAM, AVICOMPRESSOPTIONS *, CLSID *);
static HRESULT (CALLBACK *qAVIStreamSetFormat)(PAVISTREAM, LONG, LPVOID, LONG);
static HRESULT (CALLBACK *qAVIStreamWrite)(PAVISTREAM, LONG, LONG, LPVOID, LONG, DWORD, LONG *, LONG *);
static ULONG (CALLBACK *qAVIStreamRelease)(PAVISTREAM);
static ULONG (CALLBACK *qAVIFileRelease)(PAVIFILE);
static void (CALLBACK *qAVIFileExit)(void);

static MMRESULT (ACMAPI *qacmDriverOpen)(LPHACMDRIVER, HACMDRIVERID, DWORD);
static MMRESULT (ACMAPI *qacmDriverDetails)(HACMDRIVERID, LPACMDRIVERDETAILS, DWORD);
static MMRESULT (ACMAPI *qacmDriverEnum)(ACMDRIVERENUMCB, DWORD, DWORD);
static MMRESULT (ACMAPI *qacmFormatTagDetails)(HACMDRIVER, LPACMFORMATTAGDETAILS, DWORD);
static MMRESULT (ACMAPI *qacmStreamOpen)(LPHACMSTREAM, HACMDRIVER, LPWAVEFORMATEX, LPWAVEFORMATEX, LPWAVEFILTER, DWORD, DWORD, DWORD);
static MMRESULT (ACMAPI *qacmStreamSize)(HACMSTREAM, DWORD, LPDWORD, DWORD);
static MMRESULT (ACMAPI *qacmStreamPrepareHeader)(HACMSTREAM, LPACMSTREAMHEADER, DWORD);
static MMRESULT (ACMAPI *qacmStreamUnprepareHeader)(HACMSTREAM, LPACMSTREAMHEADER, DWORD);
static MMRESULT (ACMAPI *qacmStreamConvert)(HACMSTREAM, LPACMSTREAMHEADER, DWORD);
static MMRESULT (ACMAPI *qacmStreamClose)(HACMSTREAM, DWORD);
static MMRESULT (ACMAPI *qacmDriverClose)(HACMDRIVER, DWORD);

static HINSTANCE handle_avi = NULL, handle_acm = NULL;

PAVIFILE	m_file;
PAVISTREAM	m_uncompressed_video_stream;
PAVISTREAM	m_compressed_video_stream;
PAVISTREAM	m_audio_stream;

unsigned long	m_codec_fourcc;
int		m_video_frame_counter;
int		m_video_frame_size;

qbool	m_audio_is_mp3;
int		m_audio_frame_counter;
WAVEFORMATEX	m_wave_format;
MPEGLAYER3WAVEFORMAT mp3_format;
qbool	mp3_driver;
HACMDRIVER	had;
HACMSTREAM	hstr;
ACMSTREAMHEADER	strhdr;
LONG bytesWritten;


extern qbool movie_avi_loaded, movie_acm_loaded;
extern	cvar_t	movie_codec, movie_fps, movie_mp3, movie_mp3_kbps;

#define AVI_GETFUNC(f) (qAVI##f = (void *)GetProcAddress(handle_avi, "AVI" #f))
#define ACM_GETFUNC(f) (qacm##f = (void *)GetProcAddress(handle_acm, "acm" #f))

void Capture_InitAVI (void)
{
	movie_avi_loaded = false;

	if (!(handle_avi = LoadLibrary("avifil32.dll")))
	{
		Com_Printf ("\x02" "Avi capturing module not found\n");
		goto fail;
	}

	AVI_GETFUNC(FileInit);
	AVI_GETFUNC(FileOpen);
	AVI_GETFUNC(FileCreateStream);
	AVI_GETFUNC(MakeCompressedStream);
	AVI_GETFUNC(StreamSetFormat);
	AVI_GETFUNC(StreamWrite);
	AVI_GETFUNC(StreamRelease);
	AVI_GETFUNC(FileRelease);
	AVI_GETFUNC(FileExit);

	movie_avi_loaded = qAVIFileInit && qAVIFileOpen && qAVIFileCreateStream && 
			qAVIMakeCompressedStream && qAVIStreamSetFormat && qAVIStreamWrite && 
			qAVIStreamRelease && qAVIFileRelease && qAVIFileExit;

	if (!movie_avi_loaded)
	{
		Com_Printf_State (PRINT_FAIL, "Avi capturing module not initialized\n");
		goto fail;
	}

	Com_Printf_State (PRINT_OK, "Avi capturing module initialized\n");
	return;

fail:
	if (handle_avi)
	{
		FreeLibrary (handle_avi);
		handle_avi = NULL;
	}
}

void Capture_InitACM (void)
{
	movie_acm_loaded = false;

	if (!(handle_acm = LoadLibrary("msacm32.dll")))
	{
		Com_Printf ("\x02" "ACM module not found\n");
		goto fail;
	}

	ACM_GETFUNC(DriverOpen);
	ACM_GETFUNC(DriverEnum);
	ACM_GETFUNC(StreamOpen);
	ACM_GETFUNC(StreamSize);
	ACM_GETFUNC(StreamPrepareHeader);
	ACM_GETFUNC(StreamUnprepareHeader);
	ACM_GETFUNC(StreamConvert);
	ACM_GETFUNC(StreamClose);
	ACM_GETFUNC(DriverClose);
	qacmDriverDetails = (void *)GetProcAddress (handle_acm, "acmDriverDetailsA");
	qacmFormatTagDetails = (void *)GetProcAddress (handle_acm, "acmFormatTagDetailsA");

	movie_acm_loaded = qacmDriverOpen && qacmDriverDetails && qacmDriverEnum && 
			qacmFormatTagDetails && qacmStreamOpen && qacmStreamSize && 
			qacmStreamPrepareHeader && qacmStreamUnprepareHeader && 
			qacmStreamConvert && qacmStreamClose && qacmDriverClose;

	if (!movie_acm_loaded)
	{
		Com_Printf_State (PRINT_FAIL, "ACM module not initialized\n");
		goto fail;
	}

	Com_Printf_State (PRINT_OK, "ACM module initialized\n");
	return;

fail:
	if (handle_acm)
	{
		FreeLibrary (handle_acm);
		handle_acm = NULL;
	}
}

PAVISTREAM Capture_VideoStream (void)
{
	return m_codec_fourcc ? m_compressed_video_stream : m_uncompressed_video_stream;
}

#ifndef ACMDRIVERDETAILS_SUPPORTF_CODEC
#define ACMDRIVERDETAILS_SUPPORTF_CODEC 0x00000001L
#endif
#ifndef ACM_FORMATTAGDETAILSF_INDEX
#define ACM_FORMATTAGDETAILSF_INDEX         0x00000000L
#endif
#ifndef MPEGLAYER3_WFX_EXTRA_BYTES
#define MPEGLAYER3_WFX_EXTRA_BYTES   12
#define MPEGLAYER3_ID_UNKNOWN            0
#define MPEGLAYER3_ID_MPEG               1
#define MPEGLAYER3_ID_CONSTANTFRAMESIZE  2

#define MPEGLAYER3_FLAG_PADDING_ISO      0x00000000
#define MPEGLAYER3_FLAG_PADDING_ON       0x00000001
#define MPEGLAYER3_FLAG_PADDING_OFF      0x00000002
#endif
#ifndef ACMERR_BASE
#define ACMERR_BASE         (512)
#define ACMERR_NOTPOSSIBLE  (ACMERR_BASE + 0)
#define ACMERR_BUSY         (ACMERR_BASE + 1)
#define ACMERR_UNPREPARED   (ACMERR_BASE + 2)
#define ACMERR_CANCELED     (ACMERR_BASE + 3)
#endif

BOOL CALLBACK acmDriverEnumCallback (HACMDRIVERID hadid, DWORD_PTR dwInstance, DWORD fdwSupport)
{
	if (fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CODEC)
	{
		int	i;
		ACMDRIVERDETAILS details;

		details.cbStruct = sizeof(details);
		qacmDriverDetails (hadid, &details, 0);
		qacmDriverOpen (&had, hadid, 0);

		for (i = 0 ; i < details.cFormatTags ; i++)
		{
			ACMFORMATTAGDETAILS	fmtDetails;

			memset (&fmtDetails, 0, sizeof(fmtDetails));
			fmtDetails.cbStruct = sizeof(fmtDetails);
			fmtDetails.dwFormatTagIndex = i;
			qacmFormatTagDetails (had, &fmtDetails, ACM_FORMATTAGDETAILSF_INDEX);
			if (fmtDetails.dwFormatTag == WAVE_FORMAT_MPEGLAYER3)
			{
				Com_DPrintf ("MP3-capable ACM codec found: %s\n", details.szLongName);
				mp3_driver = true;

				return false;
			}
		}

		qacmDriverClose (had, 0);
	}

	return true;
}

qbool Capture_Open (char *filename)
{
	HRESULT				hr;
	BITMAPINFOHEADER	bitmap_info_header;
	AVISTREAMINFO		stream_header;
	char				*fourcc;

	bytesWritten = 0;
	m_video_frame_counter = m_audio_frame_counter = 0;
	m_file = NULL;
	m_codec_fourcc = 0;
	m_compressed_video_stream = m_uncompressed_video_stream = m_audio_stream = NULL;
	m_audio_is_mp3 = (qbool)movie_mp3.value;

	if (*(fourcc = movie_codec.string) != '0')	// codec fourcc supplied
	{
		m_codec_fourcc = mmioFOURCC (fourcc[0], fourcc[1], fourcc[2], fourcc[3]);
	}

	qAVIFileInit ();
	hr = qAVIFileOpen (&m_file, filename, OF_WRITE | OF_CREATE, NULL);
	if (FAILED(hr))
	{
		Com_Printf ("ERROR: Couldn't open AVI file\n");
		Capture_Close ();
		return false;
	}

	// initialize video data
	m_video_frame_size = glwidth * glheight * 3;

	memset (&bitmap_info_header, 0, sizeof(bitmap_info_header));
	bitmap_info_header.biSize = sizeof(BITMAPINFOHEADER);
	bitmap_info_header.biWidth = glwidth;
	bitmap_info_header.biHeight = glheight;
	bitmap_info_header.biPlanes = 1;
	bitmap_info_header.biBitCount = 24;
	bitmap_info_header.biCompression = BI_RGB;
	bitmap_info_header.biSizeImage = m_video_frame_size;

	memset (&stream_header, 0, sizeof(stream_header));
	stream_header.fccType = streamtypeVIDEO;
	stream_header.fccHandler = m_codec_fourcc;
	stream_header.dwScale = 1;
	stream_header.dwRate = (unsigned long)(0.5 + movie_fps.value);
	stream_header.dwSuggestedBufferSize = bitmap_info_header.biSizeImage;
	SetRect (&stream_header.rcFrame, 0, 0, bitmap_info_header.biWidth, bitmap_info_header.biHeight);

	hr = qAVIFileCreateStream (m_file, &m_uncompressed_video_stream, &stream_header);
	if (FAILED(hr))
	{
		Com_Printf ("ERROR: Couldn't create video stream\n");
		Capture_Close ();
		return false;
	}

	if (m_codec_fourcc)
	{
		AVICOMPRESSOPTIONS	opts;

		memset (&opts, 0, sizeof(opts));
		opts.fccType = stream_header.fccType;
		opts.fccHandler = m_codec_fourcc;

		// Make the stream according to compression
		hr = qAVIMakeCompressedStream (&m_compressed_video_stream, m_uncompressed_video_stream, &opts, NULL);
		if (FAILED(hr))
		{
			Com_Printf ("ERROR: Couldn't make compressed video stream\n");
			Capture_Close ();
			return false;
		}
	}

	hr = qAVIStreamSetFormat (Capture_VideoStream(), 0, &bitmap_info_header, bitmap_info_header.biSize);
	if (FAILED(hr))
	{
		Com_Printf ("ERROR: Couldn't set video stream format\n");
		Capture_Close ();
		return false;
	}

	// initialize audio data
	memset (&m_wave_format, 0, sizeof(m_wave_format));
	m_wave_format.wFormatTag = WAVE_FORMAT_PCM;
	m_wave_format.nChannels = 2; // always stereo in Quake sound engine
	m_wave_format.nSamplesPerSec = shw ? shw->khz : 0;
	m_wave_format.wBitsPerSample = 16; // always 16bit in Quake sound engine
	m_wave_format.nBlockAlign = m_wave_format.wBitsPerSample/8 * m_wave_format.nChannels;
	m_wave_format.nAvgBytesPerSec = m_wave_format.nSamplesPerSec * m_wave_format.nBlockAlign;

	memset (&stream_header, 0, sizeof(stream_header));
	stream_header.fccType = streamtypeAUDIO;
	stream_header.dwScale = m_wave_format.nBlockAlign;
	stream_header.dwRate = stream_header.dwScale * (unsigned long)m_wave_format.nSamplesPerSec;
	stream_header.dwSampleSize = m_wave_format.nBlockAlign;

	hr = qAVIFileCreateStream (m_file, &m_audio_stream, &stream_header);
	if (FAILED(hr))
	{
		Com_Printf ("ERROR: Couldn't create audio stream\n");
		Capture_Close ();
		return false;
	}

	if (m_audio_is_mp3)
	{
		MMRESULT	mmr;

		// try to find an MP3 codec
		had = NULL;
		mp3_driver = false;
		qacmDriverEnum (acmDriverEnumCallback, 0, 0);
		if (!mp3_driver)
		{
			Com_Printf ("ERROR: Couldn't find any MP3 decoder\n");
			Capture_Close ();
			return false;
		}

		memset (&mp3_format, 0, sizeof(mp3_format));
		mp3_format.wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3;
		mp3_format.wfx.nChannels = 2;
		mp3_format.wfx.nSamplesPerSec = shw->khz;
		mp3_format.wfx.wBitsPerSample = 0;
		mp3_format.wfx.nBlockAlign = 1;
		mp3_format.wfx.nAvgBytesPerSec = movie_mp3_kbps.value * 125;
		mp3_format.wfx.cbSize = MPEGLAYER3_WFX_EXTRA_BYTES;
		mp3_format.wID = MPEGLAYER3_ID_MPEG;
		mp3_format.fdwFlags = MPEGLAYER3_FLAG_PADDING_OFF;
		mp3_format.nBlockSize = mp3_format.wfx.nAvgBytesPerSec / movie_fps.value;
		mp3_format.nFramesPerBlock = 1;
		mp3_format.nCodecDelay = 1393;

		hstr = NULL;
		if ((mmr = qacmStreamOpen(&hstr, had, &m_wave_format, &mp3_format.wfx, NULL, 0, 0, 0)))
		{
			switch (mmr)
			{
			case MMSYSERR_INVALPARAM:
				Com_Printf ("ERROR: Invalid parameters passed to acmStreamOpen\n");
				Capture_Close ();
				return false;

			case ACMERR_NOTPOSSIBLE:
				Com_Printf ("ERROR: No ACM filter found capable of decoding MP3\n");
				Capture_Close ();
				return false;

			default:
				Com_Printf ("ERROR: Couldn't open ACM decoding stream\n");
				Capture_Close ();
				return false;
			}
		}

		hr = qAVIStreamSetFormat (m_audio_stream, 0, &mp3_format, sizeof(MPEGLAYER3WAVEFORMAT));
		if (FAILED(hr))
		{
			Com_Printf ("ERROR: Couldn't set audio stream format\n");
			Capture_Close ();
			return false;
		}
	}
	else
	{
		hr = qAVIStreamSetFormat (m_audio_stream, 0, &m_wave_format, sizeof(WAVEFORMATEX));
		if (FAILED(hr))
		{
			Com_Printf ("ERROR: Couldn't set audio stream format\n");
			Capture_Close ();
			return false;
		}
	}

	return true;
}

void Capture_Close (void)
{
	if (m_uncompressed_video_stream) {
		qAVIStreamRelease (m_uncompressed_video_stream);
		m_uncompressed_video_stream = 0;
	}
	if (m_compressed_video_stream) {
		qAVIStreamRelease (m_compressed_video_stream);
		m_compressed_video_stream = 0;
	}
	if (m_audio_stream) {
		qAVIStreamRelease (m_audio_stream);
		m_audio_stream = 0;
	}
	if (m_audio_is_mp3) {
		qacmStreamClose (hstr, 0);
		qacmDriverClose (had, 0);
		hstr = 0;
		had = 0;
	}
	if (m_file) {
		qAVIFileRelease (m_file);
		m_file = 0;
	}

	bytesWritten = 0;
	qAVIFileExit ();
}

void Capture_WriteVideo (byte *pixel_buffer, int size)
{
	HRESULT	hr;
	LONG frameBytesWritten;

	// Check frame size (TODO: other things too?) hasn't changed
	if (m_video_frame_size != size)
	{
		Com_Printf ("ERROR: Frame size changed\n");
		return;
	}

	if (!Capture_VideoStream())
	{
		Com_Printf ("ERROR: Video stream is NULL\n");
		return;
	}

	// Write the pixel buffer to to the AVIFile, one sample/frame at the time
	// set each frame to be a keyframe (it doesn't depend on previous frames).
	hr = qAVIStreamWrite (Capture_VideoStream(), m_video_frame_counter++, 1, pixel_buffer, m_video_frame_size, AVIIF_KEYFRAME, NULL, &frameBytesWritten);
	if (FAILED(hr))
	{
		Com_Printf ("ERROR: Couldn't write to AVI file\n");
		return;
	}

	bytesWritten += frameBytesWritten;
}

#ifndef ACM_STREAMSIZEF_SOURCE
#define ACM_STREAMSIZEF_SOURCE          0x00000000L
#endif
#ifndef ACM_STREAMCONVERTF_BLOCKALIGN
#define ACM_STREAMCONVERTF_BLOCKALIGN   0x00000004
#define ACM_STREAMCONVERTF_START        0x00000010
#define ACM_STREAMCONVERTF_END          0x00000020
#endif

void Capture_WriteAudio (int samples, byte *sample_buffer)
{
	HRESULT        hr = E_UNEXPECTED;
	LONG           frameBytesWritten;
	unsigned long  sample_bufsize;

	if (!m_audio_stream) {
		Com_Printf ("ERROR: Audio stream is NULL\n");
		return;
	}

	sample_bufsize = samples * m_wave_format.nBlockAlign;
	if (m_audio_is_mp3) {
		MMRESULT	mmr;
		byte		*mp3_buffer;
		unsigned long	mp3_bufsize;

		if ((mmr = qacmStreamSize (hstr, sample_bufsize, &mp3_bufsize, ACM_STREAMSIZEF_SOURCE))) {
			Com_Printf ("ERROR: Couldn't get mp3bufsize\n");
			return;
		}
		if (!mp3_bufsize) {
			Com_Printf ("ERROR: mp3bufsize is zero\n");
			return;
		}
		mp3_buffer = (byte *)Q_calloc (mp3_bufsize, 1);

		memset (&strhdr, 0, sizeof (strhdr));
		strhdr.cbStruct = sizeof (strhdr);
		strhdr.pbSrc = sample_buffer;
		strhdr.cbSrcLength = sample_bufsize;
		strhdr.pbDst = mp3_buffer;
		strhdr.cbDstLength = mp3_bufsize;

		if ((mmr = qacmStreamPrepareHeader (hstr, &strhdr, 0))) {
			Com_Printf ("ERROR: Couldn't prepare header\n");
			Q_free (mp3_buffer);
			return;
		}

		if ((mmr = qacmStreamConvert (hstr, &strhdr, ACM_STREAMCONVERTF_BLOCKALIGN))) {
			Com_Printf ("ERROR: Couldn't convert audio stream\n");
			goto clean;
		}

		hr = qAVIStreamWrite (m_audio_stream, m_audio_frame_counter++, 1, mp3_buffer, strhdr.cbDstLengthUsed, AVIIF_KEYFRAME, NULL, &frameBytesWritten);
		bytesWritten += frameBytesWritten;

	clean:
		if ((mmr = qacmStreamUnprepareHeader (hstr, &strhdr, 0))) {
			Com_Printf ("ERROR: Couldn't unprepare header\n");
			Q_free (mp3_buffer);
			return;
		}

		Q_free (mp3_buffer);
	}
	else {
		// The audio is not in MP3 format, just write the WAV data to the avi.
		hr = qAVIStreamWrite (m_audio_stream, m_audio_frame_counter++, 1, sample_buffer, samples * m_wave_format.nBlockAlign, AVIIF_KEYFRAME, NULL, &frameBytesWritten);
		bytesWritten += frameBytesWritten;
	}

	if (FAILED (hr)) {
		Com_Printf ("ERROR: Couldn't write to AVI file\n");
		return;
	}
}

LONG Movie_CurrentLength (void)
{
	return bytesWritten;
}

qbool ValidateMovieCodec (char* name)
{
	HKEY registryKey;
	int valueIndex;
	char valueName[64];
	DWORD valueLength = sizeof (valueName);
	DWORD lookupLength;

	// Uncompressed stream
	if (name[0] == 0 || !strcmp (name, "0")) {
		return true;
	}

	// Open / Create the key.
	if (RegCreateKeyEx (HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32",
		0, NULL, REG_OPTION_NON_VOLATILE, KEY_QUERY_VALUE, NULL, &registryKey, NULL)) {
		Com_Printf_State (PRINT_WARNING, "Could not read list of valid codecs\n");
		return true; // assume ok, will find out later
	}

	strlcpy (valueName, "vidc.", sizeof (valueName));
	strlcat (valueName, name, sizeof (valueName));
	if (RegQueryValueEx(registryKey, valueName, NULL, NULL, NULL, &lookupLength) == ERROR_SUCCESS) {
		RegCloseKey (registryKey);
		return true;
	}

	Con_Printf ("Warning: '%s' not found in list of valid codecs.\n", name);
	Con_Printf ("The following codecs are installed:\n", name);
	for (valueIndex = 0; RegEnumValue (registryKey, valueIndex, valueName, &valueLength, NULL, NULL, NULL, NULL) == ERROR_SUCCESS; valueIndex++, valueLength = sizeof (valueName)) {
		if (! strncmp (valueName, "vidc.", 5)) {
			Con_Printf ("  %s\n", valueName + 5);
		}
	}

	RegCloseKey (registryKey);
	return false;
}

void OnChange_movie_codec (cvar_t *var, char *string, qbool *cancel)
{
	// Print warning if codec specified isn't installed
	ValidateMovieCodec (string);
}


================================================
FILE: src/movie_avi.h
================================================
/*
Copyright (C) 2002 Quake done Quick

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef __MOVIE_AVI_H_

#define __MOVIE_AVI_H_

void Capture_InitAVI (void);
void Capture_InitACM (void);
qbool Capture_Open (char *filename);
void Capture_WriteVideo (byte *pixel_buffer, int size);
void Capture_WriteAudio (int samples, byte *sample_buffer);
void Capture_Close (void);

#endif


================================================
FILE: src/mvd_autotrack.c
================================================
/*
Copyright (C) 2001-2002 jogihoogi

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: mvd_autotrack.c,v 1.6 2007-09-27 23:18:03 johnnycz Exp $
*/

// MultiView Demo Autotrack system
// when observing a demo or QTV playback, will switch to best players automatically

#include "quakedef.h"
#include "parser.h"
#include "localtime.h"
#include "mvd_utils_common.h"

// mvd_autotrack cvars
cvar_t mvd_autotrack = {"mvd_autotrack", "0"};
cvar_t mvd_autotrack_instant = {"mvd_autotrack_instant", "0"};
cvar_t mvd_autotrack_1on1 = {"mvd_autotrack_1on1", "%a * %A + 50 * %W + %p + %f"};
cvar_t mvd_autotrack_1on1_values = {"mvd_autotrack_1on1_values", "1 2 3 2 3 5 8 8 1 2 3 0 0 0"};
cvar_t mvd_autotrack_2on2 = {"mvd_autotrack_2on2", "%a * %A + 50 * %W + %p + %f"};
cvar_t mvd_autotrack_2on2_values = {"mvd_autotrack_2on2_values", "1 2 3 2 3 5 8 8 1 2 3 500 900 1000"};
cvar_t mvd_autotrack_4on4 = {"mvd_autotrack_4on4", "%a * %A + 50 * %W + %p + %f"};
cvar_t mvd_autotrack_4on4_values = {"mvd_autotrack_4on4_values", "1 2 4 2 4 6 10 10 1 2 3 500 900 1000"};
cvar_t mvd_autotrack_custom = {"mvd_autotrack_custom", "%a * %A + 50 * %W + %p + %f"};
cvar_t mvd_autotrack_custom_values = {"mvd_autotrack_custom_values", "1 2 3 2 3 4 6 6 1 2 3 500 900 1000"};
cvar_t mvd_autotrack_lockteam = {"mvd_autotrack_lockteam", "0"};

cvar_t mvd_multitrack_1 = {"mvd_multitrack_1", "%f"};
cvar_t mvd_multitrack_1_values = {"mvd_multitrack_1_values", "1 2 3 2 3 5 8 8 1 2 3 0 0 0"};
cvar_t mvd_multitrack_2 = {"mvd_multitrack_2", "%W"};
cvar_t mvd_multitrack_2_values = {"mvd_multitrack_2_values", "1 2 3 2 3 5 8 8 1 2 3 0 0 0"};
cvar_t mvd_multitrack_3 = {"mvd_multitrack_3", "%h"};
cvar_t mvd_multitrack_3_values = {"mvd_multitrack_3_values", "1 2 3 2 3 5 8 8 1 2 3 0 0 0"};
cvar_t mvd_multitrack_4 = {"mvd_multitrack_4", "%A"};
cvar_t mvd_multitrack_4_values = {"mvd_multitrack_4_values", "1 2 3 2 3 5 8 8 1 2 3 0 0 0"};

#define PL_VALUES_COUNT 14
static float pl_values[PL_VALUES_COUNT];
#define axe_val     (pl_values[0])
#define sg_val      (pl_values[1])
#define ssg_val     (pl_values[2])
#define ng_val      (pl_values[3])
#define sng_val     (pl_values[4])
#define gl_val      (pl_values[5])
#define rl_val      (pl_values[6])
#define lg_val      (pl_values[7])
#define ga_val      (pl_values[8])
#define ya_val      (pl_values[9])
#define ra_val      (pl_values[10])
#define ring_val    (pl_values[11])
#define quad_val    (pl_values[12])
#define pent_val    (pl_values[13])

int multitrack_id_1 = 0;
int multitrack_id_2 = 0;
int multitrack_id_3 = 0;
int multitrack_id_4 = 0;

char *multitrack_val ;
char *multitrack_str ;
int last_track = 0;

static int currentplayer_num;

static int MVD_AutoTrackBW(int i){
	extern cvar_t tp_weapon_order;
	int j;
	char *t[] = {tp_weapon_order.string, "78654321", NULL}, **s;

	for (s = t; *s; s++) {
		for (j = 0 ; j < strlen(*s) ; j++) {
			switch ((*s)[j]) {
				case '1': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_AXE) return axe_val; break;
				case '2': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_SHOTGUN) return sg_val; break;
				case '3': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_SUPER_SHOTGUN) return ssg_val; break;
				case '4': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_NAILGUN) return ng_val; break;
				case '5': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_SUPER_NAILGUN) return sng_val; break;
				case '6': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER) return gl_val; break;
				case '7': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER) return rl_val; break;
				case '8': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_LIGHTNING) return lg_val; break;
			}
		}
	}
	return 0;
}

static expr_val MVD_Var_Vals(const char *n)
{
	int i = currentplayer_num;
    int stats = mvd_new_info[i].p_info->stats[STAT_ITEMS];
	double bp_at, bp_pw;

	// get armortype
	if      (stats & IT_ARMOR1) bp_at = ga_val;
	else if (stats & IT_ARMOR2) bp_at = ya_val;
	else if (stats & IT_ARMOR3)	bp_at = ra_val;
	else                        bp_at = 0;

	// get powerup type
	bp_pw=0;
	if (stats & IT_QUAD)            bp_pw += quad_val;
	if (stats & IT_INVULNERABILITY)	bp_pw += pent_val;
	if (stats & IT_INVISIBILITY)    bp_pw += ring_val;

	// not implemented yet:
	// D - average quad run time
	// e - average quad run frags
	// E - average quad run teamfrags
	// u - average pent run frags
	// U - average pent run teamfrags
	// q - Axe kills
	// Q - Shotgun kills
	// r - Supershotgun kills
	// R - Nailgun kills
	// s - Supernailgun kills
	// S - Grenadelauncher kills
	// t - Rocketlauncher kills
	// T - Lightninggun kills

	switch (*n) {
		/// armor ammount
		case 'a': return Get_Expr_Double(mvd_new_info[i].p_info->stats[STAT_ARMOR]);
			  /// armor type
		case 'A': return Get_Expr_Double(bp_at);
			  /// current run time
		case 'c': return Get_Expr_Double(mvd_new_info[i].mvdinfo.runs[mvd_new_info[i].mvdinfo.run].time);
			  /// current run frags
		case 'C': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.runs[mvd_new_info[i].mvdinfo.run].frags);
			  /// current run teamfrags
		case 'd': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.runs[mvd_new_info[i].mvdinfo.run].teamfrags);

			  /// frags
		case 'f': return Get_Expr_Integer(mvd_new_info[i].p_info->frags);

			  /// teamfrags
		case 'F': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.teamfrags);

			  /// deaths
		case 'g': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.das.deathcount);
			  /// health
		case 'h': return Get_Expr_Integer(mvd_new_info[i].p_info->stats[STAT_HEALTH]);

			  /// taken super-shotguns
		case 'I': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[SSG_INFO].count);
			  /// taken nailguns
		case 'j': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[NG_INFO].count);
			  /// taken super-nailguns
		case 'J': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[SNG_INFO].count);
			  /// taken grenade launchers
		case 'k': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[GL_INFO].count);
			  /// # of lost grenade launchers
		case 'K': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[GL_INFO].lost);
			  /// # of taken rocket launchers
		case 'l': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[RL_INFO].count);
			  /// # of lost rocket launchers
		case 'L': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[RL_INFO].lost);
		case 'm': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[LG_INFO].count);
		case 'M': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[LG_INFO].lost);
		case 'n': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[MH_INFO].count);
		case 'N': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[GA_INFO].count);
		case 'o': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[YA_INFO].count);
		case 'O': return Get_Expr_Integer(mvd_new_info[i].mvdinfo.itemstats[RA_INFO].count);
		case 'p': return Get_Expr_Double(bp_pw);

			  // id, so that player are always distinguishable by something
		case 'u': return Get_Expr_Integer(i);
			  // v - average run time
		case 'v': return Get_Expr_Double(mvd_new_info[i].mvdinfo.run_stats.all.avg_time);
			  // V - average run frags
		case 'V': return Get_Expr_Double(mvd_new_info[i].mvdinfo.run_stats.all.avg_frags);
			  // w - average run teamfrags
		case 'w': return Get_Expr_Double(mvd_new_info[i].mvdinfo.run_stats.all.avg_teamfrags);

		case 'W': return Get_Expr_Integer(MVD_AutoTrackBW(i));
		case 'x': return Get_Expr_Double(mvd_new_info[i].mvdinfo.itemstats[RING_INFO].count);
		case 'X': return Get_Expr_Double(mvd_new_info[i].mvdinfo.itemstats[RING_INFO].lost);
		case 'y': return Get_Expr_Double(mvd_new_info[i].mvdinfo.itemstats[QUAD_INFO].count);
		case 'Y': return Get_Expr_Double(mvd_new_info[i].mvdinfo.itemstats[QUAD_INFO].lost);
		case 'z': return Get_Expr_Double(mvd_new_info[i].mvdinfo.itemstats[PENT_INFO].count);
	}
	return Get_Expr_Integer(0);
}

static const parser_extra mvd_pars_extra = { MVD_Var_Vals, NULL };

static void MVD_GetValuesAndEquation(const char** v, const char** e) {
#define RET(x) { *v = mvd_autotrack_##x##_values.string; *e = mvd_autotrack_##x.string; }
	if (mvd_autotrack.integer == 1) {
		if      (mvd_cg_info.gametype == 0) RET(1on1)
		else if (mvd_cg_info.gametype == 1) RET(2on2)
		else if (mvd_cg_info.gametype == 3) RET(4on4)
		else								RET(4on4)
	}
	else if (mvd_autotrack.integer == 2)	RET(custom)
	else if (mvd_autotrack.integer == 3 && cl_multiview.value) {
		*v = multitrack_val; *e = multitrack_str; 
	} else									RET(4on4)
#undef RET
}

static void MVD_UpdatePlayerValues(void)
{
	int eval_error, i;
    const char* eq;
	const char* vals;
    double value;

	MVD_GetValuesAndEquation(&vals, &eq);

    // will extract user string "1 5 8 100.4 ..." into pl_values array which is
    // later accessed via macros like ra_val, quad_val, rl_val, ...
    if (COM_GetFloatTokens(vals, pl_values, PL_VALUES_COUNT) != PL_VALUES_COUNT)
    {
	    Com_Printf("mvd_autotrack aborting due to wrong use of mvd_autotrack_*_value\n");
		Cvar_SetValue(&mvd_autotrack,0);
		return;
    }

	for ( i=0; i<mvd_cg_info.pcount ; i++ )
    {
		// store global variable which is used in MVD_Var_Vals
		currentplayer_num = i;
		eval_error = Expr_Eval_Double(eq, &mvd_pars_extra, &value);

		if (eval_error != EXPR_EVAL_SUCCESS) {
			Com_Printf("Expression evaluation error: %s\n", Parser_Error_Description(eval_error));
			Cvar_SetValue(&mvd_autotrack,0);
			return;
		}

		mvd_new_info[i].value = value;
	}
}

static qbool MVD_LockTeamIgnore(player_info_t* plr)
{
	int tracked;

	if (!mvd_autotrack_lockteam.integer || !cl.teamplay) {
		return false;
	}

	tracked = CL_MultiviewAutotrackSlot();

	return plr == NULL || (tracked >= 0 && tracked < 31 && strcmp(plr->team, cl.players[tracked].team));
}

static int MVD_FindId_By_TrackId(int track_id)
{
	int i;
	for (i = 0; i < mvd_cg_info.pcount; i++) {
		if (mvd_new_info[i].id == track_id) {
			return i;
		}
	}

	return 0;
}

static int MVD_GetBestPlayer(void)
{
	int initial_track, initial_id, i, bp_id;
	float bp_val = -1000;
	qbool candidate_found = false;

	initial_track = 0;
	if (last_track >= 0 && last_track < mvd_cg_info.pcount && mvd_new_info[last_track].p_info) {
		initial_track = last_track;
	}

	initial_id = MVD_FindId_By_TrackId(initial_track);

	if (!MVD_LockTeamIgnore(mvd_new_info[initial_track].p_info)) {
		bp_val = mvd_new_info[initial_id].value;
		candidate_found = true;
	}
	bp_id = mvd_new_info[initial_id].id;
	for (i = 0; i < mvd_cg_info.pcount; i++) {
		if (MVD_LockTeamIgnore(mvd_new_info[i].p_info)) {
			continue;
		}

		if (!candidate_found || bp_val < mvd_new_info[i].value) {
			bp_val = mvd_new_info[i].value;
			bp_id = mvd_new_info[i].id;
			candidate_found = true;
		}
	}
	return bp_id;
}

static int MVD_FindBestPlayer(void)
{
	MVD_UpdatePlayerValues();
	return MVD_GetBestPlayer();
}

#define HASRL(x) (x & IT_ROCKET_LAUNCHER)
#define HASPENT(x) (x & IT_INVULNERABILITY)
#define HASQUAD(x) (x & IT_QUAD)
#define HASWEAPON(x) ((x & IT_ROCKET_LAUNCHER ) || (x & IT_LIGHTNING))
int MVD_GetBetterPlayerSimple(int a, int b)
{
	int sa = cl.players[a].stats[STAT_ITEMS];
	int sb = cl.players[b].stats[STAT_ITEMS];

	if (HASPENT(sa) && HASRL(sa)) return a;
	if (HASPENT(sb) && HASRL(sb)) return b;
	if (HASQUAD(sa) && HASWEAPON(sa)) return a;
	if (HASQUAD(sb) && HASWEAPON(sb)) return b;
	if (HASPENT(sa)) return a;
	if (HASPENT(sb)) return b;
	if (HASQUAD(sa)) return a;
	if (HASQUAD(sb)) return b;
	if (HASWEAPON(sa)) return a;
	if (HASWEAPON(sb)) return b;

	return a;
}

static int MVD_FindBestPlayerSimple(void)
{
	int i, b;
	int tracked = CL_MultiviewAutotrackSlot();

	b = tracked;
	for (i = 0; i < mvd_cg_info.pcount; i++) {
		if (MVD_LockTeamIgnore(mvd_new_info[i].p_info)) {
			continue;
		}
		b = MVD_GetBetterPlayerSimple(b, mvd_new_info[i].id);
	}

	return b;
}

static qbool MVD_TrackedHasNoWeapon(int pov) {
	int stat = cl.players[pov].stats[STAT_ITEMS];
	if ((stat & IT_ROCKET_LAUNCHER) || (stat & IT_LIGHTNING)) {
		return false;
	}
	else {
		return true;
	}
}

static qbool MVD_SomeoneHasWeapon(void) {
	int i, stats;
	for (i = 0; i < mvd_cg_info.pcount; i++) {
		if (MVD_LockTeamIgnore(mvd_new_info[i].p_info)) {
			continue;
		}
		stats = mvd_new_info[i].p_info->stats[STAT_ITEMS];
		if ((stats & IT_ROCKET_LAUNCHER) || (stats & IT_LIGHTNING)) {
			return true;
		}
	}
	return false;
}

static qbool MVD_TrackedHasNoPowerup(int pov) {
	int stats = cl.players[pov].stats[STAT_ITEMS];
	if ((stats & IT_QUAD) || (stats & IT_INVULNERABILITY)) {
		return false;
	}
	else {
		return true;
	}
}

static qbool MVD_SomeoneHasPowerup(void) {
	int i, stats;
	for (i = 0; i < mvd_cg_info.pcount; i++) {
		if (MVD_LockTeamIgnore(mvd_new_info[i].p_info)) {
			continue;
		}
		stats = mvd_new_info[i].p_info->stats[STAT_ITEMS];
		if ((stats & IT_QUAD) || (stats & IT_INVULNERABILITY)) {
			return true;
		}
	}
	return false;
}

static qbool MVD_SomeoneHasPentWithRL(void) {
	int i, stats;

	for (i = 0; i < mvd_cg_info.pcount; i++) {
		if (MVD_LockTeamIgnore(mvd_new_info[i].p_info)) {
			continue;
		}
		stats = mvd_new_info[i].p_info->stats[STAT_ITEMS];
		if ((stats & IT_ROCKET_LAUNCHER) && (stats & IT_INVULNERABILITY)) {
			return true;
		}
	}
	return false;
}

static qbool MVD_SwitchMoment(void) {
	int pov = CL_MultiviewAutotrackSlot ();

	if (MVD_TrackedHasNoWeapon(pov) && MVD_SomeoneHasWeapon()) {
		return true;
	}
	else if (MVD_TrackedHasNoPowerup(pov) && MVD_SomeoneHasPowerup()) {
		return true;
	}
	else if (MVD_SomeoneHasPentWithRL()) {
		return true;
	}
	else {
		return false;
	}
}

void MVD_AutoTrack(void) {
	char arg[64];
	int id;
	static double lastupdate = 0;

	#ifdef DEBUG
	printf("MVD_AutoTrack Started\n");
	#endif

	if (!mvd_autotrack.value)
		return;

	if (cl.standby || cl.countdown)
		return;

	// no need to recalculate the values in every frame
	if (cls.realtime - lastupdate < 0.5)
		return;

	lastupdate = cls.realtime;

	if (mvd_autotrack.value == 3 && cl_multiview.value > 0){
		if (cl_multiview.value >= 1 ){
			multitrack_str = mvd_multitrack_1.string;
			multitrack_val = mvd_multitrack_1_values.string;
			id = MVD_FindBestPlayer();
			if (id != multitrack_id_1){
				snprintf(arg, sizeof (arg), "track1 %i \n",id);
				Cbuf_AddText(arg);
				multitrack_id_1 = id;
			}
		}
		if (cl_multiview.value >= 2 ){
			multitrack_str = mvd_multitrack_2.string;
			multitrack_val = mvd_multitrack_2_values.string;
			id = MVD_FindBestPlayer();
			if (id != multitrack_id_2){
				snprintf(arg, sizeof (arg), "track2 %i \n",id);
				Cbuf_AddText(arg);
				multitrack_id_2 = id;
			}
		}
		if (cl_multiview.value >= 3 ){
			multitrack_str = mvd_multitrack_3.string;
			multitrack_val = mvd_multitrack_3_values.string;
			id = MVD_FindBestPlayer();
			if (id != multitrack_id_3){
				snprintf(arg, sizeof (arg), "track3 %i \n",id);
				Cbuf_AddText(arg);
				multitrack_id_3 = id;
			}
		}
		if (cl_multiview.value >= 4 ){
			multitrack_str = mvd_multitrack_4.string;
	 		multitrack_val = mvd_multitrack_4_values.string;
			id = MVD_FindBestPlayer();
			if (id != multitrack_id_4){
				snprintf(arg, sizeof (arg), "track4 %i \n",id);
				Cbuf_AddText(arg);
				multitrack_id_4 = id;
			}
		}
	}
	else if (mvd_autotrack_instant.integer || MVD_SwitchMoment())// mvd_autotrack is 1 or 2 or 3
	{
		if (mvd_autotrack.integer == 4) {
			id = MVD_FindBestPlayerSimple();
		}
		else {
			id = MVD_FindBestPlayer();
		}

		if (id != last_track || CL_MultiviewAutotrackSlot() != id) {
			snprintf(arg, sizeof (arg), "track \"%s\"\n", cl.players[id].name);
			Cbuf_AddText(arg);
			last_track = id;
		}
	}
	#ifdef DEBUG
	printf("MVD_AutoTrack Stopped\n");
	#endif
}

void MVD_AutoTrack_Init(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_MVD);
	Cvar_Register (&mvd_autotrack);
	Cvar_Register (&mvd_autotrack_instant);
	Cvar_Register (&mvd_autotrack_1on1);
	Cvar_Register (&mvd_autotrack_1on1_values);
	Cvar_Register (&mvd_autotrack_2on2);
	Cvar_Register (&mvd_autotrack_2on2_values);
	Cvar_Register (&mvd_autotrack_4on4);
	Cvar_Register (&mvd_autotrack_4on4_values);
	Cvar_Register (&mvd_autotrack_custom);
	Cvar_Register (&mvd_autotrack_custom_values);
	Cvar_Register (&mvd_autotrack_lockteam);

	Cvar_Register (&mvd_multitrack_1);
	Cvar_Register (&mvd_multitrack_1_values);
	Cvar_Register (&mvd_multitrack_2);
	Cvar_Register (&mvd_multitrack_2_values);
	Cvar_Register (&mvd_multitrack_3);
	Cvar_Register (&mvd_multitrack_3_values);
	Cvar_Register (&mvd_multitrack_4);
	Cvar_Register (&mvd_multitrack_4_values);
	Cvar_ResetCurrentGroup();
}


================================================
FILE: src/mvd_utils.c
================================================
/*
Copyright (C) 2001-2002 jogihoogi

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: mvd_utils.c,v 1.57 2007-10-11 17:56:47 johnnycz Exp $
*/

// core module of the group of MVD tools: mvd_utils, mvd_xmlstats, mvd_autotrack

#include "quakedef.h"
#include <math.h>
#include "parser.h"
#include "localtime.h"
#include "gl_model.h"
#include "teamplay.h"
#include "utils.h"
#include "mvd_utils_common.h"
#include "Ctrl.h"
#include "sbar.h"
#include "vx_tracker.h"

#define MENTION_PICKED_UP_ITEM  1
#define MENTION_PICKED_UP_PACK  2
#define MENTION_DIED_WITH_ITEM -1
#define MENTION_ITEM_RAN_OUT   -2
#define MENTION_DROPPED_ITEM   -3

#define MAX_ANNOUNCER_LINES 16
#define MAX_ANNOUNCER_LINE_TIME 10
#define MAX_ANNOUNCER_LINE_TIME_FADE 8
static char announcer_line_strings[MAX_ANNOUNCER_LINES][256];
static double announcer_line_times[MAX_ANNOUNCER_LINES];
static int announcer_lines;

static const char* MVD_AnnouncerTeamPlayerName(player_info_t* info);

// Can contain 'pack'
#define MVD_ANNOUNCER_ITEM_LENGTH 9

extern cvar_t tp_name_quad, tp_name_pent, tp_name_ring, tp_name_separator, tp_name_backpack, tp_name_suit;
extern cvar_t tp_name_axe, tp_name_sg, tp_name_ssg, tp_name_ng, tp_name_sng, tp_name_gl, tp_name_rl, tp_name_lg, tp_name_ga, tp_name_ya, tp_name_ra, tp_name_mh;

mvd_gt_info_t mvd_gt_info[mvd_gt_types] = {
	{gt_1on1,"duel"},
	{gt_2on2,"2on2"},
	{gt_3on3,"3on3"},
	{gt_4on4,"4on4"},
	{gt_unknown,"unknown"},
};

mvd_cg_info_s mvd_cg_info;

mvd_wp_info_t mvd_wp_info[mvd_info_types] = {
	{AXE_INFO,  "axe",  IT_AXE,              "axe",         0,                  0, 0xDA, 0xDA, 0xDA, NULL,          "&cf0f", "axe",             MVD_ADDCLOCK_NEVER, false },
	{SG_INFO,   "sg",   IT_SHOTGUN,          "sg",          0,                  0, 0xDA, 0xDA, 0xDA, NULL,          "&cf0f", "sg",              MVD_ADDCLOCK_NEVER, false },
	{SSG_INFO,  "ssg",  IT_SUPER_SHOTGUN,    "&cf0fssg&r",  0,                  0, 0xDA, 0xDA, 0xDA, &tp_name_ssg,  "&cf0f", "&cf0fssg pack&r", MVD_ADDCLOCK_NEVER, false },
	{NG_INFO,   "ng",   IT_NAILGUN,          "&cf0fng&r",   0,                  0, 0xDA, 0xDA, 0xDA, &tp_name_ng,   "&cf0f", "&cf0fng pack&r",  MVD_ADDCLOCK_NEVER, false },
	{SNG_INFO,  "sng",  IT_SUPER_NAILGUN,    "&cf0fsng&r",  0,                  0, 0xDA, 0xDA, 0xDA, &tp_name_sng,  "&cf0f", "&cf0fsng pack&r", MVD_ADDCLOCK_NEVER, false },
	{GL_INFO,   "gl",   IT_GRENADE_LAUNCHER, "&cf0fgl&r",   0,                  0, 0xDA, 0xDA, 0xDA, &tp_name_gl,   "&cf0f", "&cf0fgl pack&r",  MVD_ADDCLOCK_NEVER, false },
	{RL_INFO,   "rl",   IT_ROCKET_LAUNCHER,  "&cf0frl&r",   MOD_ROCKETLAUNCHER, 0, 0xDA, 0xDA, 0xDA, &tp_name_rl,   "&cf0f", "&cf0frl pack&r",  MVD_ADDCLOCK_DMM1,  false },
	{LG_INFO,   "lg",   IT_LIGHTNING,        "&cf0flg&r",   MOD_LIGHTNINGGUN,   0, 0xDA, 0xDA, 0xDA, &tp_name_lg,   "&cf0f", "&cf0flg pack&r",  MVD_ADDCLOCK_DMM1,  false },
	{RING_INFO, "rg",   IT_INVISIBILITY,     "&cff0ring&r", MOD_RING,           0, 0xA6, 0xA6, 0x00, &tp_name_ring, "&cff0", "",                MVD_ADDCLOCK_ALWAYS,  true  },
	{QUAD_INFO, "qd",   IT_QUAD,             "&c00fquad&r", MOD_QUAD,           0, 0x4D, 0x45, 0xC9, &tp_name_quad, "&c00f", "",                MVD_ADDCLOCK_ALWAYS,  true  },
	{PENT_INFO, "pt",   IT_INVULNERABILITY,  "&cf00pent&r", MOD_PENT,           0, 0x91, 0x01, 0x01, &tp_name_pent, "&cf00", "",                MVD_ADDCLOCK_ALWAYS,  true  },
	{GA_INFO,   "ga",   IT_ARMOR1,           "&c0f0ga&r",   MOD_ARMOR,          0, 0x00, 0x72, 0x36, &tp_name_ga,   "&c0f0", "",                MVD_ADDCLOCK_ALWAYS,  false },
	{YA_INFO,   "ya",   IT_ARMOR2,           "&cff0ya&r",   MOD_ARMOR,          1, 0xA6, 0xA6, 0x00, &tp_name_ya,   "&cff0", "",                MVD_ADDCLOCK_ALWAYS,  false },
	{RA_INFO,   "ra",   IT_ARMOR3,           "&cf00ra&r",   MOD_ARMOR,          2, 0x91, 0x01, 0x01, &tp_name_ra,   "&cf00", "",                MVD_ADDCLOCK_ALWAYS,  false },
	{MH_INFO,   "mh",   IT_SUPERHEALTH,      "&c00fmh&r",   MOD_MEGAHEALTH,     0, 0xAD, 0x54, 0x2A, &tp_name_mh,   "&c00f", "",                MVD_ADDCLOCK_ALWAYS,  false },
};
static int item_counts[mvd_info_types];

#define MVDCLOCK_PERSISTENT        1
#define MVDCLOCK_BACKPACK          2
#define MVDCLOCK_BACKPACK_REMOVED  4
#define MVDCLOCK_NEVERSPAWNED      8    // we add baseline ents, so might include quad in duel... use this to hide
#define MVDCLOCK_HIDDEN           16    // don't show in itemslist

#define ITEMSCLOCK_TAKEN_PAUSE     4    // in seconds

typedef struct mvd_clock_t {
	int itemtype;                       // RA, Quad, RL, ...
	double clockval;                    // time when the clock expires
	char location[MAX_MACRO_STRING];    // Player location when the object was picked up
	int flags;                          // flags
	int entity;                         // entity number
	int last_taken_by;                  // player entity item was last taken by (0 for unknown)
	int dropped_by;                     // player entity who dropped it (0 for unknown)
	double last_taken;                  // time when item was last taken
	double old_clockval;                // used to briefly keep items in same order as they're taken
	float hold_clockval;                // time when the player's hold-time will expire
	int order;                          // for static ordering

	struct mvd_clock_t* next;           // next item in the linked list
	struct mvd_clock_t* prev;           // prev item in the linked list
} mvd_clock_t;

// points to the first (earliest) item of the clock list
static mvd_clock_t* mvd_clocklist = NULL;

typedef struct quad_cams_s {
	vec3_t	org;
	vec3_t	angles;
} quad_cams_t;

// Warning: this is a bitmask, pent & quad values are subtracted
typedef enum {
	powerup_cam_inactive = 0,
	powerup_cam_quad_active = 1,
	powerup_cam_pent_active = 2,
	powerup_cam_quadpent_active = 3
} powerup_cam_status_id;

typedef struct cam_id_s {
	quad_cams_t cam;
	char* tag;
	powerup_cam_status_id filter;
} cam_id_t;

quad_cams_t quad_cams[3];
quad_cams_t pent_cams[3];

cam_id_t cam_id[7];

// NEW VERSION

typedef struct runs_s {
	double starttime;
	double endtime;
} runs_t;

typedef struct kill_s {
	int		type;	//0 - kill, 1 - selfkill
	double	time;
	vec3_t	location;
	int		lwf;
} kill_t;

typedef struct death_s {
	double time;
	vec3_t location;
	int id;
} death_t;

typedef struct spawn_s {
	double time;
	vec3_t location;
} spawn_t;

typedef struct mvd_new_info_cg_s {
	double game_starttime;
} mvd_new_info_cg_t; // mvd_new_info_cg;

typedef struct mvd_player_s {
	player_state_t* p_state;
	player_info_t* p_info;
} mvd_player_t;

typedef struct mvd_gameinfo_s {
	double starttime;
	char mapname[1024];
	char team1[1024];
	char team2[1024];
	char hostname[1024];
	int gametype;
	int timelimit;
	int pcount;
	int deathmatch;
} mvd_gameinfo_t;

extern	centity_t		cl_entities[CL_MAX_EDICTS];
extern	entity_t		cl_static_entities[MAX_STATIC_ENTITIES];
double lasttime1, lasttime2;
double lasttime = 0;
double gamestart_time;

double quad_time = 0;
double pent_time = 0;
qbool quad_is_active = false;
qbool pent_is_active = false;
powerup_cam_status_id powerup_cam_status = powerup_cam_inactive;
qbool powerup_cam_active[4];

static qbool was_standby = true;
static int fixed_ordering = 0;


extern cvar_t tp_name_none, tp_weapon_order;
char mvd_info_best_weapon[20];

extern qbool TP_LoadLocFile(char* path, qbool quiet);
extern char* TP_LocationName(vec3_t location);

//matchinfo_t *MT_GetMatchInfo(void);

//char Mention_Win_Buf[80][1024];

mvd_new_info_t mvd_new_info[MAX_CLIENTS];

int mvd_demo_track_run = 0;

// mvd_info cvars
cvar_t			mvd_info = { "mvd_info", "0" };
cvar_t			mvd_info_show_header = { "mvd_info_show_header", "0" };
cvar_t			mvd_info_setup = { "mvd_info_setup", "%p%n \x10%l\x11 %h/%a %w" }; // FIXME: non-ascii chars
cvar_t			mvd_info_x = { "mvd_info_x", "0" };
cvar_t			mvd_info_y = { "mvd_info_y", "0" };

// mvd_stats cvars
cvar_t			mvd_status = { "mvd_status","0" };
cvar_t			mvd_status_x = { "mvd_status_x","0" };
cvar_t			mvd_status_y = { "mvd_status_y","0" };

// Powerup cams
static cvar_t mvd_powerup_cam = { "mvd_powerup_cam", "0" };

static cvar_t mvd_pc_quad_1 = { "mvd_pc_quad_1", "" };
static cvar_t mvd_pc_quad_2 = { "mvd_pc_quad_2", "" };
static cvar_t mvd_pc_quad_3 = { "mvd_pc_quad_3", "" };

static cvar_t mvd_pc_pent_1 = { "mvd_pc_pent_1", "" };
static cvar_t mvd_pc_pent_2 = { "mvd_pc_pent_2", "" };
static cvar_t mvd_pc_pent_3 = { "mvd_pc_pent_3", "" };

static cvar_t powerup_cam_cvars[4] = {
	{ "mvd_pc_view_1", "" }, 
	{ "mvd_pc_view_2", "" },
	{ "mvd_pc_view_3", "" },
	{ "mvd_pc_view_4", "" }
};

cvar_t mvd_moreinfo = { "mvd_moreinfo","0" };
cvar_t mvd_autoadd_items = { "mvd_autoadd_items", "0" };
cvar_t mvd_sortitems = { "mvd_sortitems", "1" };

typedef struct bp_var_s {
	int id;
	int val;
} bp_var_t;

bp_var_t bp_var[MAX_CLIENTS];

char* Make_Red(char* s, int i) {
	static char buf[1024];
	char* p, * ret;
	buf[0] = 0;
	ret = buf;
	for (p = s; *p; p++) {
		if (!strspn(p, "1234567890.") || !(i))
			*ret++ = *p | 128;
		else
			*ret++ = *p;
	}
	*ret = 0;
	return buf;
}

void MVD_Init_Info(int player_slot)
{
	int i;
	int z;

	for (z = 0, i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator == 1)
			continue;
		mvd_new_info[z].id = i;
		if (player_slot == i || player_slot == MAX_CLIENTS) {
			mvd_new_info[z].mvdinfo.initialized = false;
		}
		// memset(mvd_new_info[z].item_info, 0, sizeof(mvd_new_info[z].item_info));
		mvd_new_info[z++].p_info = &cl.players[i];
	}

	strlcpy(mvd_cg_info.mapname, TP_MapName(), sizeof(mvd_cg_info.mapname));
	mvd_cg_info.timelimit = cl.timelimit;

	strlcpy(mvd_cg_info.team1, (z ? mvd_new_info[0].p_info->team : ""), sizeof(mvd_cg_info.team1));
	for (i = 0; i < z; i++) {
		if (strcmp(mvd_new_info[i].p_info->team, mvd_cg_info.team1)) {
			strlcpy(mvd_cg_info.team2, mvd_new_info[i].p_info->team, sizeof(mvd_cg_info.team2));
			break;
		}
	}

	if (z == 2)
		mvd_cg_info.gametype = 0;
	else if (z == 4)
		mvd_cg_info.gametype = 1;
	else if (z == 6)
		mvd_cg_info.gametype = 2;
	else if (z == 8)
		mvd_cg_info.gametype = 3;
	else
		mvd_cg_info.gametype = 4;

	strlcpy(mvd_cg_info.hostname, Info_ValueForKey(cl.serverinfo, "hostname"), sizeof(mvd_cg_info.hostname));
	mvd_cg_info.deathmatch = cl.deathmatch;

	mvd_cg_info.pcount = z;

	for (i = 0; i < mvd_cg_info.pcount; i++) {
		mvd_new_info[i].p_state = &cl.frames[cl.parsecount & UPDATE_MASK].playerstate[mvd_new_info[i].id];
	}

	memset(item_counts, 0, sizeof(item_counts));
	for (i = 0; i < sizeof(item_counts) / sizeof(item_counts[0]); ++i) {
		int item_model_hint = mvd_wp_info[i].model_hint;
		int item_skin_number = mvd_wp_info[i].skin_number;

		if (item_model_hint) {
			int j;

			for (j = 0; j < CL_MAX_EDICTS; j++) {
				int modindex = cl_entities[j].baseline.modelindex;
				int skin = cl_entities[j].baseline.skinnum;

				if (modindex >= 0 && modindex < sizeof(cl.model_precache) / sizeof(cl.model_precache[0]) && cl.model_precache[modindex]) {
					if (cl.model_precache[modindex]->modhint == item_model_hint && skin == item_skin_number) {
						++item_counts[i];
					}
				}
			}
		}
	}

	if (player_slot == MAX_CLIENTS) {
		memset(announcer_line_strings, 0, sizeof(announcer_line_strings));
		memset(announcer_line_times, 0, sizeof(announcer_line_times));
		announcer_lines = 0;
	}
}

double MVD_RespawnTimeGet(int itemtype)
{
	switch (itemtype) {
	case RA_INFO:
	case YA_INFO:
	case GA_INFO:
	case MH_INFO:
		return 20.0;

	case SSG_INFO:
	case NG_INFO:
	case SNG_INFO:
	case GL_INFO:
	case RL_INFO:
	case LG_INFO:
		return 30.0;

	case QUAD_INFO:
		return 60.0;

	case RING_INFO:
	case PENT_INFO:
		return 300.0;

	default:
		Com_DPrintf("Warning in MVD_RespawnTimeGet(): unknown item type %d\n", itemtype);
		return 0.0;
	}
}

void MVD_ClockList_Insert(mvd_clock_t* newclock)
{
	Com_DPrintf("MVD_ClockList_Insert type=%d\n", newclock->itemtype);
	if (mvd_clocklist == NULL) {
		mvd_clocklist = newclock;
		newclock->next = NULL;
		newclock->prev = NULL;
	}
	else {
		mvd_clock_t* current = mvd_clocklist;
		mvd_clock_t* last = NULL;
		while (current && current->clockval < newclock->clockval) {
			last = current;
			current = current->next;
		}
		if (current) {
			newclock->next = current;
			newclock->prev = current->prev;
			if (current->prev) {
				current->prev->next = newclock;
			}
			current->prev = newclock;
			if (last == NULL) {
				mvd_clocklist = newclock;
			}
		}
		else {
			if (last) {
				last->next = newclock;
				newclock->prev = last;
				newclock->next = NULL;
			}
			else {
				newclock->prev = NULL;
				newclock->next = mvd_clocklist;
				mvd_clocklist = newclock;
			}
		}
	}
}

mvd_clock_t* MVD_ClockList_Remove(mvd_clock_t* item)
{
	mvd_clock_t* ret = NULL;

	if (item == mvd_clocklist) {
		mvd_clocklist = item->next;
		if (mvd_clocklist) {
			mvd_clocklist->prev = NULL;
		}
		Q_free(item);
		return mvd_clocklist;
	}

	ret = item->next;
	// item->prev is not null
	if (item->next) {
		item->next->prev = item->prev;
		item->prev->next = item->next;
	}
	else {
		item->prev->next = NULL;
	}
	Q_free(item);
	return ret;
}

static void MVD_ClockStart(int itemtype, vec3_t origin)
{
	mvd_clock_t* newclock = (mvd_clock_t*)Q_malloc(sizeof(mvd_clock_t));
	newclock->clockval = cls.demopackettime + MVD_RespawnTimeGet(itemtype);
	newclock->itemtype = itemtype;
	if (origin) {
		strlcpy(newclock->location, TP_LocationName(origin), sizeof(newclock->location));
	}
	newclock->order = 0;
	MVD_ClockList_Insert(newclock);
}

static mvd_clock_t* MVD_ClockStartEntity(int entity, int itemtype, int flags)
{
	mvd_clock_t* newclock = (mvd_clock_t*)Q_malloc(sizeof(mvd_clock_t));
	newclock->clockval = 0;
	newclock->itemtype = itemtype;
	strlcpy(newclock->location, TP_LocationName(cl_entities[entity].baseline.origin), sizeof(newclock->location));
	newclock->flags = flags;
	newclock->entity = entity;
	newclock->order = ++fixed_ordering;
	MVD_ClockList_Insert(newclock);
	return newclock;
}

static mvd_clock_t* MVD_ClockFindEntity(int entity)
{
	mvd_clock_t* current;

	for (current = mvd_clocklist; current; current = current->next) {
		if (current->entity == entity) {
			return current;
		}
	}

	return NULL;
}

void MVD_ClockList_RemoveExpired(void)
{
	mvd_clock_t* current;

	for (current = mvd_clocklist; current; ) {
		// We don't remove persistent counters
		if (!(current->flags & MVDCLOCK_PERSISTENT)) {
			// Expired
			if (current->clockval + 1 < cls.demopackettime) {
				current = MVD_ClockList_Remove(current);
				continue;
			}

			//
			if (current->entity && !(current->flags & MVDCLOCK_BACKPACK_REMOVED)) {
				int mod = cl_entities[current->entity].current.modelindex;
				if (mod <= 0 || mod >= sizeof(cl.model_precache) / sizeof(cl.model_precache[0])) {
					if (current->last_taken) {
						// Backpack has been picked up, disconnect from entity
						current->flags &= ~(MVDCLOCK_BACKPACK);
						current->flags |= MVDCLOCK_BACKPACK_REMOVED;
						current->entity = 0;
					}
					else {
						current = MVD_ClockList_Remove(current);
					}
					continue;
				}

				if (cl_entities[current->entity].sequence < cl.validsequence) {
					// Backpack has been picked up or disappeared, disconnect from entity and let expire
					current->flags &= ~(MVDCLOCK_BACKPACK);
					current->flags |= MVDCLOCK_BACKPACK_REMOVED;
					current->entity = 0;
				}
				else if (cl.model_precache[mod] == NULL || cl.model_precache[mod]->modhint != MOD_BACKPACK) {
					// No longer a backpack, remove
					current = MVD_ClockList_Remove(current);
					continue;
				}
			}
		}

		current = current->next;
	}
}

int MVD_ClockList_GetLongestName(void)
{
	int i, current, longest = 0;
	int items[] = {
		IT_AXE, IT_SHOTGUN, IT_SUPER_SHOTGUN, IT_NAILGUN, IT_SUPER_NAILGUN,
		IT_GRENADE_LAUNCHER, IT_ROCKET_LAUNCHER, IT_LIGHTNING, IT_INVISIBILITY,
		IT_QUAD, IT_INVULNERABILITY, IT_ARMOR1, IT_ARMOR2, IT_ARMOR3, IT_SUPERHEALTH
	};

	for (i = 0; i < (sizeof(items) / sizeof(*items)); i++) {
		current = strlen_color(TP_ItemName(items[i]));
		if (longest < current)
			longest = current;
	}
	return longest;
}

static double MVD_ClockList_SortTime(mvd_clock_t* c)
{
	double t = c->clockval;

	if (c->last_taken && cls.demopackettime - c->last_taken < ITEMSCLOCK_TAKEN_PAUSE) {
		// item has just been taken, keep to the start of the list
		t = -1 - c->old_clockval;
	}
	else if (c->last_taken && t == -1) {
		// megahealth still held by player, put to end of list
		t = cls.demopackettime + c->last_taken + 1000;
	}

	return t;
}

// Moves persistent
static int MVD_ClockList_Compare(mvd_clock_t* c, mvd_clock_t* n)
{
	double c_time = MVD_ClockList_SortTime(c);
	double n_time = MVD_ClockList_SortTime(n);
	qbool c_persistent = c->flags & MVDCLOCK_PERSISTENT;
	qbool n_persistent = n->flags & MVDCLOCK_PERSISTENT;

	if (c_persistent && !n_persistent) {
		return 1;
	}
	if (!c_persistent && n_persistent) {
		return -1;
	}

	if (mvd_sortitems.integer) {
		return c_time - n_time;
	}
	else {
		return c->order - n->order;
	}
}

static void MVD_ClockList_Sort(void)
{
	qbool any_change = true;

	while (any_change) {
		mvd_clock_t* c = mvd_clocklist;

		any_change = false;
		while (c) {
			mvd_clock_t* n = c->next;
			int comparison;

			if (!n) {
				break;
			}

			comparison = MVD_ClockList_Compare(c, n);
			if (comparison > 0) {
				c->next = n->next;
				n->prev = c->prev;
				c->prev = n;
				n->next = c;

				if (n->prev) {
					n->prev->next = n;
				}
				if (c->next) {
					c->next->prev = c;
				}

				if (c == mvd_clocklist) {
					mvd_clocklist = n;
				}

				any_change = true;
			}
			else {
				c = n;
			}
		}
	}
}

// MEAG: Deliberately not taking 'proportional' argument into account here, don't think we should measure by item type either...
void MVD_ClockList_TopItems_DimensionsGet(double time_limit, int style, int* width, int* height, float scale, qbool backpacks, qbool proportional)
{
	int lines = 0;
	mvd_clock_t* current = mvd_clocklist;
	int persistent = 0, temporary = 0;

	if (style == 5) {
		MVD_ClockList_Sort();

		current = mvd_clocklist;
	}

	while (current) {
		int time = (int)((current->clockval - cls.demopackettime) + 1);

		// Skip if it's a backpack and the config turns these off
		if (!backpacks && (current->flags & (MVDCLOCK_BACKPACK | MVDCLOCK_BACKPACK_REMOVED))) {
			current = current->next;
			continue;
		}

		if (current->flags & MVDCLOCK_PERSISTENT) {
			// Skip if player has manually removed
			if (current->flags & MVDCLOCK_HIDDEN) {
				current = current->next;
				continue;
			}

			if (current->flags & MVDCLOCK_NEVERSPAWNED) {
				// Skip auto-added items that haven't spawned and have never spawned
				if (cl_entities[current->entity].current.modelindex == 0 && time <= 0) {
					current = current->next;
					continue;
				}

				current->flags &= ~(MVDCLOCK_NEVERSPAWNED);
			}

		}

		if (current->entity || current->clockval - cls.demopackettime < time_limit) {
			int time = (int)((current->clockval - cls.demopackettime) + 1);

			if (current->flags & MVDCLOCK_PERSISTENT) {
				if (cl_entities[current->entity].current.modelindex != 0 || time >= 0) {
					++persistent;
				}
			}
			else {
				++temporary;
			}
			lines++;
		}
		current = current->next;
	}

	// the longest possible string
	if (style == 1) {
		*width = LETTERWIDTH * (MVD_ClockList_GetLongestName() + sizeof(" spawn") - 1) * scale;
	}
	else if (style == 3) {
		*width = LETTERWIDTH * (2 + sizeof(" spawn") - 1) * scale;
	}
	else if (style == 4) {
		*width = LETTERWIDTH * (2 + sizeof(" spawn") - 1) * scale;
	}
	else {
		*width = LETTERWIDTH * (sizeof("QUAD spawn") - 1) * scale;
	}

	if (persistent && temporary) {
		lines++;
	}

	*height = LETTERHEIGHT * lines * scale * (style == 3 ? 2 : 1);
}

static qbool MVD_ClockIsHeld(mvd_clock_t* current, qbool test_held, float* alpha)
{
	double time_since;

	if (alpha) {
		*alpha = 1.0f;
	}

	if (!current->entity || (test_held && current->hold_clockval <= cls.demopackettime)) {
		return false;
	}

	if (current->last_taken_by <= 0 || current->last_taken_by > MAX_CLIENTS || !cl.players[current->last_taken_by - 1].name[0]) {
		return false;
	}

	if (test_held && (cl.players[current->last_taken_by - 1].stats[STAT_ITEMS] & mvd_wp_info[current->itemtype].it)) {
		return true;
	}

	if (!current->last_taken || current->last_taken > cls.demopackettime) {
		return false;
	}

	time_since = (cls.demopackettime - current->last_taken);
	if (alpha) {
		if (time_since > ITEMSCLOCK_TAKEN_PAUSE - 1 && time_since < ITEMSCLOCK_TAKEN_PAUSE) {
			*alpha = (ITEMSCLOCK_TAKEN_PAUSE - time_since);
		}
		else if (time_since >= ITEMSCLOCK_TAKEN_PAUSE && time_since < ITEMSCLOCK_TAKEN_PAUSE + 1) {
			*alpha = (time_since - ITEMSCLOCK_TAKEN_PAUSE);
		}
	}
	return time_since < ITEMSCLOCK_TAKEN_PAUSE;
}

void MVD_ClockList_TopItems_Draw(double time_limit, int style, int x, int y, float scale, int filter, qbool backpacks, qbool proportional)
{
	mvd_clock_t* current = mvd_clocklist;
	char clockitem[128];
	char temp[128];
	int base_x = x;
	qbool was_persistent = true;
	int barWidth;

	while (current) {
		float alpha = 1.0f;
		x = base_x;

		// Skip backpacks
		if (!backpacks && (current->flags & (MVDCLOCK_BACKPACK | MVDCLOCK_BACKPACK_REMOVED))) {
			current = current->next;
			continue;
		}

		// Skip auto-added items that have never spawned or manually removed
		if (current->flags & (MVDCLOCK_NEVERSPAWNED | MVDCLOCK_HIDDEN)) {
			current = current->next;
			continue;
		}

		if (current->entity || current->clockval - cls.demopackettime < time_limit) {
			int time = (int)((current->clockval - cls.demopackettime) + 1);
			mpic_t* texture = Mod_SimpleTextureForHint(mvd_wp_info[current->itemtype].model_hint, mvd_wp_info[current->itemtype].skin_number);

			if (filter & mvd_wp_info[current->itemtype].it) {
				current = current->next;
				continue;
			}

			if ((current->flags & MVDCLOCK_PERSISTENT) && !was_persistent) {
				y += LETTERHEIGHT * scale;
			}
			was_persistent = (current->flags & MVDCLOCK_PERSISTENT);

			if (style == 1) {
				// tp_name_*
				strlcpy(clockitem, TP_ItemName(mvd_wp_info[current->itemtype].it), sizeof(clockitem));
			}
			else if (style == 2) {
				// brown + white
				strlcpy(clockitem, mvd_wp_info[current->itemtype].name, sizeof(clockitem));
				CharsToBrown(clockitem, clockitem + strlen(clockitem));
			}
			else if (style == 3 && texture && R_TextureReferenceIsValid(texture->texnum)) {
				// simpleitem
				Draw_FitPic(x, y, 2 * LETTERWIDTH * scale, 2 * LETTERHEIGHT * scale, texture);
				x += 2 * LETTERWIDTH * scale;
				clockitem[0] = '\0';
				y += LETTERHEIGHT * scale / 2;
			}
			else if (style == 4) {
				char item_name[MAX_MACRO_STRING];

				if (mvd_wp_info[current->itemtype].name_cvar && mvd_wp_info[current->itemtype].name_cvar->string[0]) {
					Util_SkipChars(mvd_wp_info[current->itemtype].name_cvar->string, "{}", item_name, sizeof(item_name));
				}
				else {
					strlcpy(item_name, mvd_wp_info[current->itemtype].colored_name, sizeof(item_name));
				}

				snprintf(clockitem, sizeof(clockitem), "%*s", MVD_ANNOUNCER_ITEM_LENGTH + ((int)strlen(item_name) - strlen_color(item_name)), item_name);

				strlcat(clockitem, " \034", sizeof(clockitem));
			}
			else if (style == 5) {
				char item_name[MAX_MACRO_STRING];

				if (current->flags & (MVDCLOCK_BACKPACK | MVDCLOCK_BACKPACK_REMOVED)) {
					const char* name = mvd_wp_info[current->itemtype].colored_packname;

					snprintf(item_name, sizeof(item_name) - 1, "%*s", MVD_ANNOUNCER_ITEM_LENGTH + ((int)strlen(name) - strlen_color(name)), name);
				}
				else {
					const char* color = mvd_wp_info[current->itemtype].color_string;

					snprintf(item_name, sizeof(item_name) - 1, "%s%*s&r", color ? color : "", MVD_ANNOUNCER_ITEM_LENGTH + ((int)strlen(current->location) - strlen_color(current->location)), current->location);
				}

				strlcpy(clockitem, item_name, sizeof(clockitem));
				strlcat(clockitem, " \034", sizeof(clockitem));
				Draw_SString(x, y, clockitem, scale, proportional);

				x += strlen_color(clockitem) * 8 * scale;
				clockitem[0] = '\0';
			}
			else if (style == 6) {
				// progress bar countdown
				strlcpy(clockitem, mvd_wp_info[current->itemtype].name, sizeof(clockitem));

				barWidth = (round(67 * scale) / time_limit) * (time_limit - time + 1);
				if (time == 0) {
					barWidth = (round(67 * scale) / time_limit) * time_limit;
				}

				Draw_AlphaFillRGB(x - 1, y, barWidth, 10 * scale,
					RGBA_TO_COLOR(mvd_wp_info[current->itemtype].Rcolor,
						mvd_wp_info[current->itemtype].Gcolor,
						mvd_wp_info[current->itemtype].Bcolor, 128));
			}
			else if (style == 7) {
				// progress bar countdown, but itemname not in bar
				strlcpy(clockitem, mvd_wp_info[current->itemtype].name, sizeof(clockitem));

				barWidth = (round(44 * scale) / time_limit) * (time_limit - time + 1);
				if (time == 0) {
					barWidth = (round(44 * scale) / time_limit) * time_limit;
				}

				Draw_AlphaFillRGB(x + (22 * scale), y, barWidth, 10 * scale,
					RGBA_TO_COLOR(mvd_wp_info[current->itemtype].Rcolor,
						mvd_wp_info[current->itemtype].Gcolor,
						mvd_wp_info[current->itemtype].Bcolor, 128));
			}
			else {
				// built-in color(GL) or simple white (software)
				if (mvd_wp_info[current->itemtype].name_cvar) {
					strlcpy(clockitem, mvd_wp_info[current->itemtype].colored_name, sizeof(clockitem));
				}
				else {
					strlcpy(clockitem, mvd_wp_info[current->itemtype].colored_name, sizeof(clockitem));
				}
			}

			if (current->flags & MVDCLOCK_BACKPACK_REMOVED) {
				if (current->location[0]) {
					strlcat(clockitem, " ", sizeof(clockitem));
					strlcat(clockitem, current->location, sizeof(clockitem));
				}

				if (current->dropped_by && current->last_taken_by) {
					strlcat(clockitem, " (", sizeof(clockitem));
					strlcat(clockitem, MVD_AnnouncerTeamPlayerName(&cl.players[current->dropped_by - 1]), sizeof(clockitem));
					strlcat(clockitem, " \015 ", sizeof(clockitem));
					strlcat(clockitem, MVD_AnnouncerTeamPlayerName(&cl.players[current->last_taken_by - 1]), sizeof(clockitem));
					strlcat(clockitem, ")", sizeof(clockitem));
				}
				else {
					current = MVD_ClockList_Remove(current);
					continue;
				}
			}
			else if (time > 0) {
				if (current->flags & MVDCLOCK_BACKPACK) {
					strlcpy(current->location, TP_LocationName(cl_entities[current->entity].current.origin), sizeof(current->location));

					snprintf(temp, sizeof(temp), " %s", current->location);

					if (current->dropped_by) {
						strlcat(temp, " (", sizeof(temp));
						strlcat(temp, MVD_AnnouncerTeamPlayerName(&cl.players[current->dropped_by - 1]), sizeof(temp));
						strlcat(temp, ")", sizeof(temp));
					}
				}
				else if (MVD_ClockIsHeld(current, mvd_wp_info[current->itemtype].show_held, &alpha)) {
					snprintf(temp, sizeof(temp), " %s", MVD_AnnouncerTeamPlayerName(&cl.players[current->last_taken_by - 1]));
				}
				else if (style == 5) {
					if (time >= 60) {
						snprintf(temp, sizeof(temp), " %d:%02d", time / 60, time % 60);
					}
					else {
						snprintf(temp, sizeof(temp), " %d", time);
					}
				}
				else {
					snprintf(temp, sizeof(temp), " %*d", time_limit >= 10 ? 2 : 1, time);
				}
				strlcat(clockitem, temp, sizeof(clockitem));
			}
			else if (current->flags & MVDCLOCK_PERSISTENT) {
				strlcpy(temp, " up", sizeof(temp));

				// If a player is holding the item, use their name instead
				if (MVD_ClockIsHeld(current, true, NULL)) {
					snprintf(temp, sizeof(temp), " %s", MVD_AnnouncerTeamPlayerName(&cl.players[current->last_taken_by - 1]));
				}

				strlcat(clockitem, temp, sizeof(clockitem));
			}
			else {
				strlcat(clockitem, " spawn", sizeof(clockitem));
			}

			if (style == 4 && item_counts[current->itemtype] != 1 && current->location[0]) {
				strlcat(clockitem, " \020", sizeof(clockitem));
				strlcat(clockitem, current->location, sizeof(clockitem));
				strlcat(clockitem, "\021", sizeof(clockitem));
			}

			Draw_SStringAlpha(x, y, clockitem, scale, alpha, proportional);

			y += LETTERHEIGHT * scale;
			if (style == 3) {
				y += LETTERHEIGHT * scale / 2;
			}
			else if ((style == 6) || (style == 7)) {
				y += round(4 * scale);
			}
		}
		current = current->next;
	}
}

static void MVD_Took(int player, int item, qbool addclock)
{
	if (mvd_new_info[player].mvdinfo.initialized && !cl.mvd_ktx_markers) {
		if (addclock) {
			MVD_ClockStart(item, mvd_new_info[player].p_state ? mvd_new_info[player].p_state->origin : NULL);
		}
		mvd_new_info[player].mvdinfo.itemstats[item].mention = addclock ? MENTION_PICKED_UP_ITEM : MENTION_PICKED_UP_PACK;
	}
}

// this steps in action if the user has created a demo playlist and has specified
// which player should be prefered in the demos (so that he doesn't have to switch
// to that player at the start of each demo manually)
void MVD_Demo_Track(void) {
	extern char track_name[16];
	extern cvar_t demo_playlist_track_name;
	char track_player[128] = { 0 };

#ifdef DEBUG
	printf("MVD_Demo_Track Started\n");
#endif

	track_name[15] = '\0';
	if (strlen(track_name))
	{
		if (FindBestNick(track_name, FBN_IGNORE_SPECS | FBN_IGNORE_QTVSPECS, track_player, sizeof(track_player)))
			Cbuf_AddText(va("track \"%s\"\n", track_player));
	}
	else if (strlen(demo_playlist_track_name.string))
	{
		if (FindBestNick(demo_playlist_track_name.string, FBN_IGNORE_SPECS | FBN_IGNORE_QTVSPECS, track_player, sizeof(track_player)))
			Cbuf_AddText(va("track \"%s\"\n", track_player));
	}

	mvd_demo_track_run = 1;
#ifdef DEBUG
	printf("MVD_Demo_Track Stopped\n");
#endif
}


int MVD_BestWeapon(int i) {
	int x;
	char* t[] = { tp_weapon_order.string, "78654321", NULL }, ** s;
	for (s = t; *s; s++) {
		for (x = 0; x < strlen(*s); x++) {
			switch ((*s)[x]) {
			case '1': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_AXE) return IT_AXE; break;
			case '2': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_SHOTGUN) return IT_SHOTGUN; break;
			case '3': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_SUPER_SHOTGUN) return IT_SUPER_SHOTGUN; break;
			case '4': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_NAILGUN) return IT_NAILGUN; break;
			case '5': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_SUPER_NAILGUN) return IT_SUPER_NAILGUN; break;
			case '6': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER) return IT_GRENADE_LAUNCHER; break;
			case '7': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER) return IT_ROCKET_LAUNCHER; break;
			case '8': if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_LIGHTNING) return IT_LIGHTNING; break;
			}
		}
	}
	return 0;
}

char* MVD_BestWeapon_strings(int i) {
	return TP_ItemName(MVD_BestWeapon(i));
}

int MVD_Weapon_LWF(int i) {
	switch (i) {
	case IT_AXE: return 0;
	case IT_SHOTGUN: return 1;
	case IT_SUPER_SHOTGUN: return 2;
	case IT_NAILGUN: return 3;
	case IT_SUPER_NAILGUN: return 4;
	case IT_GRENADE_LAUNCHER: return 5;
	case IT_ROCKET_LAUNCHER: return 6;
	case IT_LIGHTNING: return 7;
	default: return 666;
	}
}

char* MVD_BestAmmo(int i) {

	switch (MVD_BestWeapon(i)) {
	case IT_SHOTGUN: case IT_SUPER_SHOTGUN:
		return va("%i", mvd_new_info[i].p_info->stats[STAT_SHELLS]);

	case IT_NAILGUN: case IT_SUPER_NAILGUN:
		return va("%i", mvd_new_info[i].p_info->stats[STAT_NAILS]);

	case IT_GRENADE_LAUNCHER: case IT_ROCKET_LAUNCHER:
		return va("%i", mvd_new_info[i].p_info->stats[STAT_ROCKETS]);

	case IT_LIGHTNING:
		return va("%i", mvd_new_info[i].p_info->stats[STAT_CELLS]);

	default: return "0";
	}
}

void MVD_Info(void) {
	char str[1024];
	char mvd_info_final_string[1024], mvd_info_powerups[20], mvd_info_header_string[1024];
	int x, y, z, i;



#ifdef DEBUG
	printf("MVD_Info Started\n");
#endif

	z = 1;

	if (!mvd_info.value)
		return;

	if (!cls.mvdplayback)
		return;

	if (mvd_info_show_header.value) {
		strlcpy(mvd_info_header_string, mvd_info_setup.string, sizeof(mvd_info_header_string));
		Replace_In_String(mvd_info_header_string, sizeof(mvd_info_header_string), '%', \
			10, \
			"a", "Armor", \
			"f", "Frags", \
			"h", "Health", \
			"l", "Location", \
			"n", "Nick", \
			"P", "Ping", \
			"p", "Powerup", \
			"v", "Value", \
			"w", "Cur.Weap.", \
			"W", "Best Weap.");
		strlcpy(mvd_info_header_string, Make_Red(mvd_info_header_string, 0), sizeof(mvd_info_header_string));
		strlcpy(str, mvd_info_final_string, sizeof(str));
		x = ELEMENT_X_COORD(mvd_info);
		y = ELEMENT_Y_COORD(mvd_info);
		Draw_String(x, y + ((z++) * 8), mvd_info_header_string);
	}

	for (i = 0; i < mvd_cg_info.pcount; i++) {

		mvd_info_powerups[0] = 0;
		if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_QUAD)
			//strlcpy(mvd_info_powerups, tp_name_quad.string, sizeof(mvd_info_powerups));

			if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_INVULNERABILITY) {
				//if (mvd_info_powerups[0])
				//	strlcat(mvd_info_powerups, tp_name_separator.string, sizeof(mvd_info_powerups));
				//strlcat(mvd_info_powerups, tp_name_pent.string, sizeof(mvd_info_powerups));
			}

		if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_INVISIBILITY) {
			//if (mvd_info_powerups[0])
			//	strlcat(mvd_info_powerups, tp_name_separator.string, sizeof(mvd_info_powerups));
			//strlcat(mvd_info_powerups, tp_name_ring.string, sizeof(mvd_info_powerups));
		}

		strlcpy(mvd_info_final_string, mvd_info_setup.string, sizeof(mvd_info_final_string));
		Replace_In_String(mvd_info_final_string, sizeof(mvd_info_final_string), '%', \
			10, \
			"w", va("%s:%i", TP_ItemName(mvd_new_info[i].p_info->stats[STAT_ACTIVEWEAPON]), mvd_new_info[i].p_info->stats[STAT_AMMO]), \
			"W", va("%s:%s", MVD_BestWeapon_strings(i), MVD_BestAmmo(i)), \
			"a", va("%i", mvd_new_info[i].p_info->stats[STAT_ARMOR]), \
			"f", va("%i", mvd_new_info[i].p_info->frags), \
			"h", va("%i", mvd_new_info[i].p_info->stats[STAT_HEALTH]), \
			"l", TP_LocationName(mvd_new_info[i].p_state->origin), \
			"n", mvd_new_info[i].p_info->name, \
			"P", va("%i", mvd_new_info[i].p_info->ping), \
			"p", mvd_info_powerups, \
			"v", va("%f", mvd_new_info[i].value));
		strlcpy(str, mvd_info_final_string, sizeof(str));
		x = ELEMENT_X_COORD(mvd_info);
		y = ELEMENT_Y_COORD(mvd_info);
		Draw_String(x, y + ((z++) * 8), str);

#ifdef DEBUG
		printf("MVD_Info Stopped\n");
#endif
	}
}

static void MVD_AddString(const char* line)
{
	VX_TrackerPickupText(line);

	if (announcer_lines == MAX_ANNOUNCER_LINES) {
		memmove(&announcer_line_strings[0], &announcer_line_strings[1], sizeof(announcer_line_strings[0]) * (MAX_ANNOUNCER_LINES - 1));
		memmove(&announcer_line_times[0], &announcer_line_times[1], sizeof(announcer_line_times[0]) * (MAX_ANNOUNCER_LINES - 1));
		announcer_lines = MAX_ANNOUNCER_LINES - 1;
	}
	strlcpy(announcer_line_strings[announcer_lines], line, sizeof(announcer_line_strings[announcer_lines]));
	announcer_line_times[announcer_lines] = cl.time;
	++announcer_lines;
}

const char* MVD_AnnouncerString(int line, int total, float* alpha)
{
	int index = announcer_lines - total + line;
	if (index >= 0 && index < announcer_lines && announcer_line_times[index] > cl.time - MAX_ANNOUNCER_LINE_TIME) {
		if (cl.time - announcer_line_times[index] < MAX_ANNOUNCER_LINE_TIME_FADE) {
			*alpha = 1;
		}
		else {
			*alpha = (1 - (cl.time - announcer_line_times[index] - MAX_ANNOUNCER_LINE_TIME_FADE) / (MAX_ANNOUNCER_LINE_TIME - MAX_ANNOUNCER_LINE_TIME_FADE));
		}
		return announcer_line_strings[index];
	}
	else {
		*alpha = 0;
		return "";
	}
}

static const char* MVD_AnnouncerTeamPlayerName(player_info_t* info)
{
	if (cl.teamplay) {
		int player_color = Sbar_BottomColor(info);

		byte red = host_basepal[player_color * 3];
		byte green = host_basepal[player_color * 3 + 1];
		byte blue = host_basepal[player_color * 3 + 2];
		char* buf;

		if (info->bottomcolor == 3) {
			red = 99;
			green = 255;
			blue = 120;
		}
		else if (info->bottomcolor == 12) {
			red = green = 255;
			blue = 0;
		}

		buf = va("&c%x%x%x%s&r", (unsigned int)(red / 16), (unsigned int)(green / 16), (unsigned int)(blue / 16), info->name);
		CharsToWhite(buf, buf + strlen(buf));
		return buf;
	}
	else {
		return info->name;
	}
}

static const char* MVD_AnnouncerPlayerName(int i)
{
	return MVD_AnnouncerTeamPlayerName(mvd_new_info[i].p_info);
}

void MVD_Status_Announcer(int i, int z) {
	//char *pn = mvd_new_info[i].p_info->name;
	vec3_t* pl = &mvd_new_info[i].p_state->origin;

	if (cl.mvd_ktx_markers) {
		return;
	}

	if (mvd_new_info[i].mvdinfo.itemstats[z].mention > 0) {
		int mention = mvd_new_info[i].mvdinfo.itemstats[z].mention;

		mvd_new_info[i].mvdinfo.itemstats[z].mention = 0;

		if (!mvd_moreinfo.integer) {
			return;
		}

		if (z >= 2 && z < sizeof(mvd_wp_info) / sizeof(mvd_wp_info[0]) && z != GA_INFO && z != GL_INFO) {
			char location_name[MAX_MACRO_STRING];
			char item_name[MAX_MACRO_STRING];
			char simple_item_name[MAX_MACRO_STRING];

			if (mvd_wp_info[z].name_cvar && mvd_wp_info[z].name_cvar->string && mvd_wp_info[z].name_cvar->string[0]) {
				Util_SkipChars(mvd_wp_info[z].name_cvar->string, "{}", item_name, sizeof(item_name));
			}
			else {
				strlcpy(item_name, mvd_wp_info[z].colored_name, sizeof(item_name));
			}
			Util_SkipEZColors(simple_item_name, item_name, sizeof(simple_item_name));
			strlcpy(location_name, TP_ParseFunChars(TP_LocationName(*pl), false), sizeof(location_name));
			if (mention == MENTION_PICKED_UP_ITEM) {
				qbool names_match = !strcmp(location_name, simple_item_name);

				if (item_counts[z] == 1 || names_match) {
					MVD_AddString(va("%*s \015 %s\n", MVD_ANNOUNCER_ITEM_LENGTH + (strlen(item_name) - strlen_color(item_name)), item_name, MVD_AnnouncerPlayerName(i)));
				}
				else {
					MVD_AddString(va("%*s \015 %s \020%s\021\n", MVD_ANNOUNCER_ITEM_LENGTH + (strlen(item_name) - strlen_color(item_name)), item_name, MVD_AnnouncerPlayerName(i), location_name));
				}
			}
			else if (mention == MENTION_PICKED_UP_PACK) {
				if (tp_name_backpack.string[0]) {
					char pack_name[MAX_MACRO_STRING];

					Util_SkipChars(tp_name_backpack.string, "{}", pack_name, sizeof(pack_name));

					strlcat(item_name, " ", sizeof(item_name));
					strlcat(item_name, pack_name, sizeof(item_name));
				}
				else {
					strlcat(item_name, " pack", sizeof(item_name));
				}

				MVD_AddString(va("%*s \015 %s \020%s\021\n", MVD_ANNOUNCER_ITEM_LENGTH + (strlen(item_name) - strlen_color(item_name)), item_name, MVD_AnnouncerPlayerName(i), location_name));
			}
		}
	}
	else if (mvd_new_info[i].mvdinfo.itemstats[z].mention < 0) {
		int mention = mvd_new_info[i].mvdinfo.itemstats[z].mention;

		mvd_new_info[i].mvdinfo.itemstats[z].mention = 0;

		if (!mvd_moreinfo.integer) {
			return;
		}

		if (z >= 5 && z < sizeof(mvd_wp_info) / sizeof(mvd_wp_info[0])) {
			char location_name[MAX_MACRO_STRING];
			char item_name[MAX_MACRO_STRING];
			const char* pn = MVD_AnnouncerPlayerName(i);

			if (mvd_wp_info[z].name_cvar && mvd_wp_info[z].name_cvar->string && mvd_wp_info[z].name_cvar->string[0]) {
				Util_SkipChars(mvd_wp_info[z].name_cvar->string, "{}", item_name, sizeof(item_name));
			}
			else {
				strlcpy(item_name, mvd_wp_info[z].colored_name, sizeof(item_name));
			}
			strlcpy(location_name, TP_ParseFunChars(TP_LocationName(*pl), false), sizeof(location_name));
			if (mention == MENTION_DIED_WITH_ITEM) {
				// Weapon tracking should probably be added back in
				if (cl.deathmatch == 1 && (z == RING_INFO || z == QUAD_INFO)) {
					strlcat(item_name, " &cf00dead&r", sizeof(item_name));

					MVD_AddString(va("%*s   (%s)\n", MVD_ANNOUNCER_ITEM_LENGTH + (strlen(item_name) - strlen_color(item_name)), item_name, pn));
				}
			}
			else if (mention == MENTION_ITEM_RAN_OUT) {
				strlcat(item_name, " over", sizeof(item_name));

				MVD_AddString(va("%*s   (%s)\n", MVD_ANNOUNCER_ITEM_LENGTH + (strlen(item_name) - strlen_color(item_name)), item_name, pn));
			}
			else if (mention == MENTION_DROPPED_ITEM) {
				if (cl.deathmatch == 1) {
					strlcat(item_name, " &cf00drop&r", sizeof(item_name));

					MVD_AddString(va("%*s \015 %s \020%s\021\n", MVD_ANNOUNCER_ITEM_LENGTH + (strlen(item_name) - strlen_color(item_name)), item_name, MVD_AnnouncerPlayerName(i), location_name));
				}
			}
		}
	}
}

void MVD_Status_WP(int i, int* taken) {
	int j, k;
	for (k = j = SSG_INFO; j <= LG_INFO; j++, k = k * 2) {
		if (!mvd_new_info[i].mvdinfo.itemstats[j].has && mvd_new_info[i].p_info->stats[STAT_ITEMS] & k) {
			if (j >= GL_INFO && cl.deathmatch == 1) {
				*taken |= (1 << j);
			}
			mvd_new_info[i].mvdinfo.itemstats[j].has = 1;
			mvd_new_info[i].mvdinfo.itemstats[j].count++;
		}
	}

}

void MVD_Stats_Cleanup(void)
{
	quad_is_active = false;
	pent_is_active = false;
	powerup_cam_status = powerup_cam_inactive;
	memset(powerup_cam_active, 0, sizeof(powerup_cam_active));
	pent_time = quad_time = 0;
	was_standby = true;
	while (mvd_clocklist) {
		MVD_ClockList_Remove(mvd_clocklist);
	}

	memset(mvd_new_info, 0, sizeof(mvd_new_info));
	memset(&mvd_cg_info, 0, sizeof(mvd_cg_info));
	fixed_ordering = 0;
}

void MVD_Set_Armor_Stats(int z, int i) {
	switch (z) {
	case GA_INFO:
		mvd_new_info[i].mvdinfo.itemstats[YA_INFO].has = 0;
		mvd_new_info[i].mvdinfo.itemstats[RA_INFO].has = 0;
		break;
	case YA_INFO:
		mvd_new_info[i].mvdinfo.itemstats[GA_INFO].has = 0;
		mvd_new_info[i].mvdinfo.itemstats[RA_INFO].has = 0;
		break;
	case RA_INFO:
		mvd_new_info[i].mvdinfo.itemstats[GA_INFO].has = 0;
		mvd_new_info[i].mvdinfo.itemstats[YA_INFO].has = 0;
		break;

	}
}

// calculates the average values of run statistics
void MVD_Stats_CalcAvgRuns(void)
{
	int i;
	static double lastupdate = 0;

	// no need to recalculate the values in every frame
	if (cls.demopackettime - lastupdate < 0.5) {
		return;
	}
	else {
		lastupdate = cls.demopackettime;
	}

	for (i = 0; i < MAX_CLIENTS; i++) {
		mvd_info_t* pi = &mvd_new_info[i].mvdinfo;
		//		int r = mvd_new_info[i].mvdinfo.run;
		int tf, ttf, tt;
		int j;
		tf = ttf = tt = 0;

		for (j = 0; j < pi->run; j++) {
			tf += pi->runs[j].frags;
			ttf += pi->runs[j].teamfrags;
			tt += pi->runs[j].time;
		}

		if (pi->run) {
			pi->run_stats.all.avg_frags = tf / (double)pi->run;
			pi->run_stats.all.avg_teamfrags = ttf / (double)pi->run;
			pi->run_stats.all.avg_time = tt / (double)pi->run;
		}
	}
}

static qbool MVD_Weapon_From_Backpack(int weapon, int taken, int* ammotaken)
{
	// Things that signalize backpack took:
	// a) some taken ammo, different than weapon pickup gives, or
	// b) more than one weapon was taken

	// From the info we have the process is undeterministic.
	// The current semantics is "paranoid":
	// When not sure, expect it was a backpack pickup.
	// Howver, it is still impossible to distinguish some backpack pickups.

	// Why?
	// For example when player has sg and 199 shells and his status
	// changes to ssg + 200 shells, it's impossible to tell whether
	// he picked up ssg from pack or regular ssg spawn.
	// Or when he has 0 rockets and then picks rl pack with 5 rockets,
	// it looks like he picked regular rl.
	// Also there's the thing which is dependent on deathmatch setting when you
	// get extra rockets that even weren't in the rl pack originally
	// but you get them anyway if you have no rox.

	// Also worth mentioning this does not reflect custom mods
	// like tf, ctf and others...

	// Possible approach would be to check player coordinates
	// and check whether on given bsp some of the spawnpoints
	// of given item is close enough to the player.

	// Another possible approach would be to extend the protocol with
	// proper pickup info delivery.

	int i;

	if (weapon == SSG_INFO) {
		if (ammotaken[0] != 5 || ammotaken[1] > 0 || ammotaken[2] > 0 || ammotaken[3] > 0) {
			return true;
		}
	}
	if (weapon == NG_INFO) {
		if (ammotaken[0] > 0 || ammotaken[1] != 30 || ammotaken[2] > 0 || ammotaken[3] > 0) {
			return true;
		}
	}
	if (weapon == SNG_INFO) {
		if (ammotaken[0] > 0 || ammotaken[1] != 30 || ammotaken[2] > 0 || ammotaken[3] > 0) {
			return true;
		}
	}
	if (weapon == GL_INFO) {
		if (ammotaken[0] > 0 || ammotaken[1] > 0 || ammotaken[2] != 5 || ammotaken[3] > 0) {
			return true;
		}
	}
	if (weapon == RL_INFO) {
		if (ammotaken[0] > 0 || ammotaken[1] > 0 || ammotaken[2] != 5 || ammotaken[3] > 0) {
			return true;
		}
	}
	if (weapon == LG_INFO) {
		if (ammotaken[0] > 0 || ammotaken[1] > 0 || ammotaken[2] > 0 || ammotaken[3] != 15) {
			return true;
		}
	}

	for (i = SSG_INFO; i <= LG_INFO; i++) {
		if ((taken & (1 << i)) && i != weapon) {
			return true;
		}
	}

	return false;
}

static void MVD_Stats_Gather_AlivePlayer(int player_index)
{
	int x; // item index
	int z; // item index
	int i = player_index;
	int killdiff;
	int taken = 0;
	int ammotaken[AMMO_TYPES] = { 0, 0, 0, 0 };
	qbool had_mega;
	qbool has_mega;

	for (x = GA_INFO; x <= RA_INFO && mvd_cg_info.deathmatch != 4; x++) {
		if (mvd_new_info[i].p_info->stats[STAT_ITEMS] & mvd_wp_info[x].it) {

			if (!mvd_new_info[i].mvdinfo.itemstats[x].has) {
				taken |= (1 << x);
				MVD_Set_Armor_Stats(x, i);
				mvd_new_info[i].mvdinfo.itemstats[x].count++;
				mvd_new_info[i].mvdinfo.itemstats[x].lost = mvd_new_info[i].p_info->stats[STAT_ARMOR];
				mvd_new_info[i].mvdinfo.itemstats[x].has = 1;
				mvd_new_info[i].mvdinfo.itemstats[x].starttime = cls.demopackettime;
			}

			if (mvd_new_info[i].mvdinfo.itemstats[x].lost < mvd_new_info[i].p_info->stats[STAT_ARMOR]) {
				taken |= (1 << x);
				mvd_new_info[i].mvdinfo.itemstats[x].count++;
				mvd_new_info[i].mvdinfo.itemstats[x].starttime = cls.demopackettime;
			}
			mvd_new_info[i].mvdinfo.itemstats[x].lost = mvd_new_info[i].p_info->stats[STAT_ARMOR];
		}
	}

	for (x = RING_INFO; x <= PENT_INFO && mvd_cg_info.deathmatch != 4; x++) {
		mvd_pw_t* item = &mvd_new_info[i].mvdinfo.itemstats[x];

		if (!item->has && (mvd_new_info[i].p_info->stats[STAT_ITEMS] & mvd_wp_info[x].it)) {
			taken |= (1 << x);
			item->has = 1;

			if (x == PENT_INFO && (powerup_cam_status == powerup_cam_quadpent_active || powerup_cam_status == powerup_cam_pent_active)) {
				pent_is_active = true;
				powerup_cam_status -= powerup_cam_pent_active;
				pent_time = cls.demopackettime;
			}
			if (x == QUAD_INFO && (powerup_cam_status == powerup_cam_quadpent_active || powerup_cam_status == powerup_cam_quad_active)) {
				quad_is_active = true;
				powerup_cam_status -= powerup_cam_quad_active;
				quad_time = cls.demopackettime;
			}
			mvd_new_info[i].mvdinfo.itemstats[x].starttime = cls.demopackettime;
			mvd_new_info[i].mvdinfo.itemstats[x].count++;
		}
		if (mvd_new_info[i].mvdinfo.itemstats[x].has && !(mvd_new_info[i].p_info->stats[STAT_ITEMS] & mvd_wp_info[x].it)) {
			mvd_new_info[i].mvdinfo.itemstats[x].has = 0;
			if (x == QUAD_INFO && quad_is_active) {
				quad_is_active = false;
			}
			if (x == PENT_INFO && pent_is_active) {
				pent_is_active = false;
			}
			mvd_new_info[i].mvdinfo.itemstats[x].runs[mvd_new_info[i].mvdinfo.itemstats[x].run].starttime = mvd_new_info[i].mvdinfo.itemstats[x].starttime;
			mvd_new_info[i].mvdinfo.itemstats[x].runs[mvd_new_info[i].mvdinfo.itemstats[x].run].time = cls.demopackettime - mvd_new_info[i].mvdinfo.itemstats[x].starttime;
			mvd_new_info[i].mvdinfo.itemstats[x].run++;
		}
	}

	had_mega = mvd_new_info[i].mvdinfo.itemstats[MH_INFO].has > 0;
	has_mega = mvd_new_info[i].p_info->stats[STAT_ITEMS] & IT_SUPERHEALTH;
	if (!had_mega && has_mega) {
		// Picked up mega
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].mention = MENTION_PICKED_UP_ITEM;
		VectorCopy(mvd_new_info[i].p_state->origin, mvd_new_info[i].mega_locations[0]);
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].has = 1;
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].count++;
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].starttime = cls.demopackettime;
		MVD_Status_Announcer(i, MH_INFO);
	}
	else if (has_mega && mvd_new_info[i].mvdinfo.itemstats[MH_INFO].lost < mvd_new_info[i].p_info->stats[STAT_HEALTH] && mvd_new_info[i].p_info->stats[STAT_HEALTH] > 100) {
		// They already had mega health but health increased - must have been another mega
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].mention = MENTION_PICKED_UP_ITEM;
		if (mvd_new_info[i].mvdinfo.itemstats[MH_INFO].has < MAX_MEGAS_PER_PLAYER) {
			VectorCopy(mvd_new_info[i].p_state->origin, mvd_new_info[i].mega_locations[mvd_new_info[i].mvdinfo.itemstats[MH_INFO].has]);
		}
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].has++;
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].count++;
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].starttime = cls.demopackettime;
		MVD_Status_Announcer(i, MH_INFO);
	}
	mvd_new_info[i].mvdinfo.itemstats[MH_INFO].lost = mvd_new_info[i].p_info->stats[STAT_HEALTH];

	if (had_mega && !has_mega) {
		// Might have had two megas ticking down, create as many clocks as necessary
		int megas = mvd_new_info[i].mvdinfo.itemstats[MH_INFO].has;
		while (megas > 0) {
			--megas;
			if (!cl.mvd_ktx_markers) {
				MVD_ClockStart(MH_INFO, megas < MAX_MEGAS_PER_PLAYER ? mvd_new_info[i].mega_locations[megas] : NULL);
			}
		}
		mvd_new_info[i].mvdinfo.itemstats[MH_INFO].has = 0;
	}

	for (z = RING_INFO; z <= PENT_INFO; z++) {
		if (mvd_new_info[i].mvdinfo.itemstats[z].has == 1) {
			mvd_new_info[i].mvdinfo.itemstats[z].runs[mvd_new_info[i].mvdinfo.itemstats[z].run].starttime = mvd_new_info[i].mvdinfo.itemstats[z].starttime;
			mvd_new_info[i].mvdinfo.itemstats[z].runs[mvd_new_info[i].mvdinfo.itemstats[z].run].time = cls.demopackettime - mvd_new_info[i].mvdinfo.itemstats[z].starttime;
		}
	}

	if (mvd_new_info[i].mvdinfo.lastfrags != mvd_new_info[i].p_info->frags) {
		if (mvd_new_info[i].mvdinfo.lastfrags < mvd_new_info[i].p_info->frags) {
			killdiff = mvd_new_info[i].p_info->frags - mvd_new_info[i].mvdinfo.lastfrags;
			for (z = 0; z < 8; z++) {
				if (z == MVD_Weapon_LWF(mvd_new_info[i].mvdinfo.lfw))
					mvd_new_info[i].mvdinfo.killstats.normal[z].kills += killdiff;
			}
			if (mvd_new_info[i].mvdinfo.lfw == -1)
				mvd_new_info[i].mvdinfo.spawntelefrags += killdiff;
			for (z = 8; z < 11; z++) {
				if (mvd_new_info[i].mvdinfo.itemstats[z].has)
					mvd_new_info[i].mvdinfo.itemstats[z].runs[mvd_new_info[i].mvdinfo.itemstats[z].run].frags += killdiff;
			}
			mvd_new_info[i].mvdinfo.runs[mvd_new_info[i].mvdinfo.run].frags++;
		}
		else if (mvd_new_info[i].mvdinfo.lastfrags > mvd_new_info[i].p_info->frags) {
			killdiff = mvd_new_info[i].mvdinfo.lastfrags - mvd_new_info[i].p_info->frags;
			for (z = AXE_INFO; z <= LG_INFO; z++) {
				if (z == MVD_Weapon_LWF(mvd_new_info[i].mvdinfo.lfw))
					mvd_new_info[i].mvdinfo.killstats.normal[z].teamkills += killdiff;
			}
			if (mvd_new_info[i].mvdinfo.lfw == -1) {
				mvd_new_info[i].mvdinfo.teamspawntelefrags += killdiff;

			}
			for (z = 8; z < 11; z++) {
				if (mvd_new_info[i].mvdinfo.itemstats[z].has)
					mvd_new_info[i].mvdinfo.itemstats[z].runs[mvd_new_info[i].mvdinfo.itemstats[z].run].teamfrags += killdiff;
			}
			mvd_new_info[i].mvdinfo.runs[mvd_new_info[i].mvdinfo.run].teamfrags++;
		}


		mvd_new_info[i].mvdinfo.lastfrags = mvd_new_info[i].p_info->frags;
	}

	mvd_new_info[i].mvdinfo.runs[mvd_new_info[i].mvdinfo.run].time = cls.demopackettime - mvd_new_info[i].mvdinfo.das.alivetimestart;

	if (mvd_new_info[i].mvdinfo.lfw == -1) {
		if (mvd_new_info[i].mvdinfo.lastfrags > mvd_new_info[i].p_info->frags) {
			mvd_new_info[i].mvdinfo.teamspawntelefrags += mvd_new_info[i].p_info->frags - mvd_new_info[i].mvdinfo.lastfrags;
		}
		else if (mvd_new_info[i].mvdinfo.lastfrags < mvd_new_info[i].p_info->frags) {
			mvd_new_info[i].mvdinfo.spawntelefrags += mvd_new_info[i].p_info->frags - mvd_new_info[i].mvdinfo.lastfrags;
		}
		mvd_new_info[i].mvdinfo.lastfrags = mvd_new_info[i].p_info->frags;
	}

	if (mvd_new_info[i].p_state->weaponframe > 0)
		mvd_new_info[i].mvdinfo.lfw = mvd_new_info[i].p_info->stats[STAT_ACTIVEWEAPON];
	if (mvd_cg_info.deathmatch != 4) {
		MVD_Status_WP(i, &taken);
		for (z = SSG_INFO; z <= RA_INFO; z++) {
			MVD_Status_Announcer(i, z);
		}
	}

	for (x = 0; x < AMMO_TYPES; x++) {
		int ammo_new = mvd_new_info[i].p_info->stats[STAT_SHELLS + x];
		int ammo_old = mvd_new_info[i].mvdinfo.ammostats[x];
		if (mvd_new_info[i].mvdinfo.initialized && ammo_new > ammo_old) {
			int diff = ammo_new - ammo_old;
			ammotaken[x] = diff;
		}
		mvd_new_info[i].mvdinfo.ammostats[x] =
			mvd_new_info[i].p_info->stats[STAT_SHELLS + x];
	}

	for (x = 0; x < mvd_info_types; x++) {
		if (taken & (1 << x)) {
			qbool weapon_from_backpack =
				IS_WEAPON(x) && MVD_Weapon_From_Backpack(x, taken, ammotaken);
			// don't start clock if item was from backpack
			qbool add_clock = !weapon_from_backpack;
			Com_DPrintf("player %i took %i, weapon from backpack: %s\n",
				i, x, weapon_from_backpack ? "yes" : "no");

			MVD_Took(i, x, add_clock);
		}
	}
}

int MVD_Stats_Gather(void)
{
	int death_stats = 0;
	int x, i;

	if (cl.countdown || cl.standby) {
		return 0;
	}

	for (i = 0; i < mvd_cg_info.pcount; i++) {
		mvd_new_info[i].p_state = &cl.frames[cl.parsecount & UPDATE_MASK].playerstate[mvd_new_info[i].id];
	}

	for (i = 0; i < mvd_cg_info.pcount; i++) {
		if (pent_time == 0 && quad_time == 0 && !mvd_new_info[i].mvdinfo.firstrun) {
			powerup_cam_status = powerup_cam_quadpent_active;
			quad_time = pent_time = cls.demopackettime;
		}

		if (mvd_new_info[i].mvdinfo.firstrun == 0) {
			mvd_new_info[i].mvdinfo.das.alivetimestart = cls.demopackettime;
			gamestart_time = cls.demopackettime;
			mvd_new_info[i].mvdinfo.firstrun = 1;
			mvd_new_info[i].mvdinfo.lfw = -1;
		}

		// death alive stats
		if (mvd_new_info[i].p_info->stats[STAT_HEALTH] > 0 && mvd_new_info[i].mvdinfo.das.isdead == 1) {
			mvd_new_info[i].mvdinfo.das.isdead = 0;
			mvd_new_info[i].mvdinfo.das.alivetimestart = cls.demopackettime;
			mvd_new_info[i].mvdinfo.lfw = -1;
		}

		mvd_new_info[i].mvdinfo.das.alivetime = cls.demopackettime - mvd_new_info[i].mvdinfo.das.alivetimestart;
		if (mvd_new_info[i].p_info->stats[STAT_HEALTH] <= 0 && mvd_new_info[i].mvdinfo.das.isdead != 1) {
			mvd_new_info[i].mvdinfo.das.isdead = 1;
			mvd_new_info[i].mvdinfo.das.deathcount++;
			death_stats = 1;
		}

		if (death_stats) {
			death_stats = 0;
			mvd_new_info[i].mvdinfo.run++;

			for (x = 0; x < mvd_info_types; x++) {
				if (mvd_new_info[i].p_info && mvd_new_info[i].p_info->stats[STAT_ACTIVEWEAPON] == mvd_wp_info[x].it) {
					if (mvd_wp_info[x].it == IT_ROCKET_LAUNCHER || mvd_wp_info[x].it == IT_LIGHTNING) {
						mvd_new_info[i].mvdinfo.itemstats[x].mention = MENTION_DROPPED_ITEM;
					}
					mvd_new_info[i].mvdinfo.itemstats[x].lost++;
				}
				else if (mvd_new_info[i].p_info && (mvd_new_info[i].p_info->stats[STAT_ITEMS] & mvd_wp_info[x].it)) {
					if (mvd_wp_info[x].it == IT_ROCKET_LAUNCHER || mvd_wp_info[x].it == IT_LIGHTNING || mvd_wp_info[x].it == IT_QUAD || mvd_wp_info[x].it == IT_INVISIBILITY) {
						mvd_new_info[i].mvdinfo.itemstats[x].mention = MENTION_DIED_WITH_ITEM;
					}
				}
				/*if (x == MVD_Weapon_LWF(mvd_new_info[i].mvdinfo.lfw)) {
					mvd_new_info[i].mvdinfo.itemstats[x].mention = MENTION_DIED_WITH_ITEM;
					mvd_new_info[i].mvdinfo.itemstats[x].lost++;
				}*/

				if (x == QUAD_INFO && mvd_new_info[i].mvdinfo.itemstats[QUAD_INFO].has) {
					if (mvd_new_info[i].mvdinfo.itemstats[x].starttime - cls.demopackettime < 30) {
						quad_is_active = false;
					}
					mvd_new_info[i].mvdinfo.itemstats[x].run++;
					mvd_new_info[i].mvdinfo.itemstats[x].lost++;
				}
				mvd_new_info[i].mvdinfo.itemstats[x].has = 0;
			}
			mvd_new_info[i].mvdinfo.lfw = -1;
		}

		if (!mvd_new_info[i].mvdinfo.das.isdead) {
			MVD_Stats_Gather_AlivePlayer(i);
		}
		else {
			// Report dropped items immediately
			int z;
			for (z = SSG_INFO; z <= RA_INFO; z++) {
				MVD_Status_Announcer(i, z);
			}
		}

		if ((((pent_time + 300) - cls.demopackettime) < 5) && !pent_is_active) {
			powerup_cam_status |= powerup_cam_pent_active;
		}
		if ((((quad_time + 60) - cls.demopackettime) < 5) && !quad_is_active) {
			powerup_cam_status |= powerup_cam_quad_active;
		}
		mvd_new_info[i].mvdinfo.initialized = true;
	}

	return 1;
}

void MVD_Status(void)
{
	int x, y, p;
	char str[1024];
	int i;
	int id = 0;
	int z = 0;
	double av_f = 0;
	double av_t = 0;
	double av_tk = 0;

	if (!mvd_status.value)
		return;

	if (!cls.mvdplayback)
		return;

	for (i = 0; i < mvd_cg_info.pcount; i++) {
		if (mvd_new_info[i].id == cl.spec_track) {
			id = i;
		}
	}

	x = ELEMENT_X_COORD(mvd_status);
	y = ELEMENT_Y_COORD(mvd_status);
	if (mvd_new_info[id].p_info) {
		strlcpy(str, mvd_new_info[id].p_info->name, sizeof(str));
	}
	else {
		str[0] = '\0';
	}
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);
	strlcpy(str, "&cf40Took", sizeof(str));

	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, va("RL: %i LG: %i GL: %i RA: %i YA: %i GA:%i", \
		mvd_new_info[id].mvdinfo.itemstats[RL_INFO].count, \
		mvd_new_info[id].mvdinfo.itemstats[LG_INFO].count, \
		mvd_new_info[id].mvdinfo.itemstats[GL_INFO].count, \
		mvd_new_info[id].mvdinfo.itemstats[RA_INFO].count, \
		mvd_new_info[id].mvdinfo.itemstats[YA_INFO].count, \
		mvd_new_info[id].mvdinfo.itemstats[GA_INFO].count), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);
	strlcpy(str, va("Ring: %i Quad: %i Pent: %i MH: %i", \
		mvd_new_info[id].mvdinfo.itemstats[RING_INFO].count, \
		mvd_new_info[id].mvdinfo.itemstats[QUAD_INFO].count, \
		mvd_new_info[id].mvdinfo.itemstats[PENT_INFO].count, \
		mvd_new_info[id].mvdinfo.itemstats[MH_INFO].count), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	//	Com_Printf("%f %f %f \n",lasttime,mvd_new_info[id].mvdinfo.das.alivetimestart, mvd_new_info[id].mvdinfo.das.alivetime);
	if (cls.demopackettime >= lasttime + .1) {
		lasttime = cls.demopackettime;
		lasttime1 = mvd_new_info[id].mvdinfo.das.alivetime;
	}

	strlcpy(str, va("Deaths: %i", mvd_new_info[id].mvdinfo.das.deathcount), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, "Average Run:", sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, "Time      Frags TKS", sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	for (p = 0; p <= mvd_new_info[id].mvdinfo.run; p++) {
		av_t += mvd_new_info[id].mvdinfo.runs[p].time;
		av_f += mvd_new_info[id].mvdinfo.runs[p].frags;
		av_tk += mvd_new_info[id].mvdinfo.runs[p].teamfrags;
	}
	if (av_t > 0) {
		av_t = av_t / (mvd_new_info[id].mvdinfo.run + 1);
		av_f = av_f / (mvd_new_info[id].mvdinfo.run + 1);
		av_tk = av_tk / (mvd_new_info[id].mvdinfo.run + 1);
	}

	strlcpy(str, va("%9.3f %3.3f %3.3f", av_t, av_f, av_tk), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);


	strlcpy(str, "Last 3 Runs:", sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, "No. Time      Frags TKS", sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	p = mvd_new_info[id].mvdinfo.run - 3;
	if (p < 0)
		p = 0;
	//&& mvd_new_info[id].mvdinfo.runs[p].time
	for (; p <= mvd_new_info[id].mvdinfo.run; p++) {
		strlcpy(str, va("%3i %9.3f %5i %3i", p + 1, mvd_new_info[id].mvdinfo.runs[p].time, mvd_new_info[id].mvdinfo.runs[p].frags, mvd_new_info[id].mvdinfo.runs[p].teamfrags), sizeof(str));
		Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);
	}
	strlcpy(str, va("Last Fired Weapon: %s", TP_ItemName(mvd_new_info[id].mvdinfo.lfw)), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, "&cf40Lost", sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, va("RL: %i LG: %i GL: %i QUAD: %i", \
		mvd_new_info[id].mvdinfo.itemstats[RL_INFO].lost, \
		mvd_new_info[id].mvdinfo.itemstats[LG_INFO].lost, \
		mvd_new_info[id].mvdinfo.itemstats[GL_INFO].lost, \
		mvd_new_info[id].mvdinfo.itemstats[QUAD_INFO].lost), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, "&cf40Kills", sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, va("RL: %i LG: %i GL: %i SNG: %i NG: %i SSG: %i SG: %i AXE: %i", \
		mvd_new_info[id].mvdinfo.killstats.normal[RL_INFO].kills, \
		mvd_new_info[id].mvdinfo.killstats.normal[LG_INFO].kills, \
		mvd_new_info[id].mvdinfo.killstats.normal[GL_INFO].kills, \
		mvd_new_info[id].mvdinfo.killstats.normal[SNG_INFO].kills, \
		mvd_new_info[id].mvdinfo.killstats.normal[NG_INFO].kills, \
		mvd_new_info[id].mvdinfo.killstats.normal[SSG_INFO].kills, \
		mvd_new_info[id].mvdinfo.killstats.normal[SG_INFO].kills, \
		mvd_new_info[id].mvdinfo.killstats.normal[AXE_INFO].kills), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, va("SPAWN: %i", \
		mvd_new_info[id].mvdinfo.spawntelefrags), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, "&cf40Teamkills", sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, va("RL: %i LG: %i GL: %i SNG: %i NG: %i SSG: %i SG: %i AXE: %i", \
		mvd_new_info[id].mvdinfo.killstats.normal[RL_INFO].teamkills, \
		mvd_new_info[id].mvdinfo.killstats.normal[LG_INFO].teamkills, \
		mvd_new_info[id].mvdinfo.killstats.normal[GL_INFO].teamkills, \
		mvd_new_info[id].mvdinfo.killstats.normal[SNG_INFO].teamkills, \
		mvd_new_info[id].mvdinfo.killstats.normal[NG_INFO].teamkills, \
		mvd_new_info[id].mvdinfo.killstats.normal[SSG_INFO].teamkills, \
		mvd_new_info[id].mvdinfo.killstats.normal[SG_INFO].teamkills, \
		mvd_new_info[id].mvdinfo.killstats.normal[AXE_INFO].teamkills), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);
	strlcpy(str, va("SPAWN: %i", \
		mvd_new_info[id].mvdinfo.teamspawntelefrags), sizeof(str));
	strlcpy(str, Make_Red(str, 1), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, "Last 3 Quad Runs:", sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	strlcpy(str, "No. Time      Frags TKS", sizeof(str));
	strlcpy(str, Make_Red(str, 0), sizeof(str));
	Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);

	p = mvd_new_info[id].mvdinfo.itemstats[QUAD_INFO].run - 3;
	if (p < 0)
		p = 0;
	for (; p <= mvd_new_info[id].mvdinfo.itemstats[QUAD_INFO].run && mvd_new_info[id].mvdinfo.itemstats[QUAD_INFO].runs[p].time; p++) {
		strlcpy(str, va("%3i %9.3f %5i %3i", p + 1, mvd_new_info[id].mvdinfo.itemstats[QUAD_INFO].runs[p].time, mvd_new_info[id].mvdinfo.itemstats[QUAD_INFO].runs[p].frags, mvd_new_info[id].mvdinfo.itemstats[QUAD_INFO].runs[p].teamfrags), sizeof(str));
		Draw_ColoredString(x, y + ((z++) * 8), str, 1, false);
	}
}

qbool MVD_MatchStarted(void) {
	if (was_standby && !cl.standby) {
		was_standby = false;
		return true;
	}
	was_standby = cl.standby;
	return false;
}

void MVD_Mainhook(void) {
	if (MVD_MatchStarted()) {
		MVD_Init_Info(MAX_CLIENTS);
	}

	MVD_Stats_Gather();
	MVD_Stats_CalcAvgRuns();
	MVD_AutoTrack();
	MVD_ClockList_RemoveExpired();
	if (cls.mvdplayback && mvd_demo_track_run == 0) {
		MVD_Demo_Track();
	}
}

static void MVD_PowerupCam_GetCoords(void)
{
	char val[1024];

	strlcpy(val, mvd_pc_quad_1.string, sizeof(val));
	cam_id[0].cam.org[0] = (float)atof(strtok(val, " "));
	cam_id[0].cam.org[1] = (float)atof(strtok(NULL, " "));
	cam_id[0].cam.org[2] = (float)atof(strtok(NULL, " "));
	cam_id[0].cam.angles[0] = (float)atof(strtok(NULL, " "));
	cam_id[0].cam.angles[1] = (float)atof(strtok(NULL, " "));
	cam_id[0].tag = "q1";
	cam_id[0].filter = powerup_cam_quad_active;

	strlcpy(val, mvd_pc_quad_2.string, sizeof(val));
	cam_id[1].cam.org[0] = (float)atof(strtok(val, " "));
	cam_id[1].cam.org[1] = (float)atof(strtok(NULL, " "));
	cam_id[1].cam.org[2] = (float)atof(strtok(NULL, " "));
	cam_id[1].cam.angles[0] = (float)atof(strtok(NULL, " "));
	cam_id[1].cam.angles[1] = (float)atof(strtok(NULL, " "));
	cam_id[1].tag = "q2";
	cam_id[1].filter = powerup_cam_quad_active;

	strlcpy(val, mvd_pc_quad_3.string, sizeof(val));
	cam_id[2].cam.org[0] = (float)atof(strtok(val, " "));
	cam_id[2].cam.org[1] = (float)atof(strtok(NULL, " "));
	cam_id[2].cam.org[2] = (float)atof(strtok(NULL, " "));
	cam_id[2].cam.angles[0] = (float)atof(strtok(NULL, " "));
	cam_id[2].cam.angles[1] = (float)atof(strtok(NULL, " "));
	cam_id[2].tag = "q3";
	cam_id[2].filter = powerup_cam_quad_active;

	strlcpy(val, mvd_pc_pent_1.string, sizeof(val));
	cam_id[3].cam.org[0] = (float)atof(strtok(val, " "));
	cam_id[3].cam.org[1] = (float)atof(strtok(NULL, " "));
	cam_id[3].cam.org[2] = (float)atof(strtok(NULL, " "));
	cam_id[3].cam.angles[0] = (float)atof(strtok(NULL, " "));
	cam_id[3].cam.angles[1] = (float)atof(strtok(NULL, " "));
	cam_id[3].tag = "p1";
	cam_id[3].filter = powerup_cam_pent_active;

	strlcpy(val, mvd_pc_pent_2.string, sizeof(val));
	cam_id[4].cam.org[0] = (float)atof(strtok(val, " "));
	cam_id[4].cam.org[1] = (float)atof(strtok(NULL, " "));
	cam_id[4].cam.org[2] = (float)atof(strtok(NULL, " "));
	cam_id[4].cam.angles[0] = (float)atof(strtok(NULL, " "));
	cam_id[4].cam.angles[1] = (float)atof(strtok(NULL, " "));
	cam_id[4].tag = "p2";
	cam_id[4].filter = powerup_cam_pent_active;

	strlcpy(val, mvd_pc_pent_3.string, sizeof(val));
	cam_id[5].cam.org[0] = (float)atof(strtok(val, " "));
	cam_id[5].cam.org[1] = (float)atof(strtok(NULL, " "));
	cam_id[5].cam.org[2] = (float)atof(strtok(NULL, " "));
	cam_id[5].cam.angles[0] = (float)atof(strtok(NULL, " "));
	cam_id[5].cam.angles[1] = (float)atof(strtok(NULL, " "));
	cam_id[5].tag = "p3";
	cam_id[5].filter = powerup_cam_pent_active;
}

static qbool MVD_PowerupCam_Process(cvar_t* cvar)
{
	qbool active = false;

	if (strlen(cvar->string)) {
		int i;
		qbool found = false;

		for (i = 0; i < 6; i++) {
			if (!strcmp(cvar->string, cam_id[i].tag)) {
				found = true;

				if (cam_id[i].filter & powerup_cam_status) {
					VectorCopy(cam_id[i].cam.angles, r_refdef.viewangles);
					VectorCopy(cam_id[i].cam.org, r_refdef.vieworg);
					active = true;
				}
				break;
			}
		}
		if (!found) {
			Cvar_Set(cvar, "");
			Com_Printf("wrong tag for %s\n", cvar->name);
		}
	}

	return active;
}

// If powerup cam configured but not currently enabled
qbool MVD_PowerupCam_Hidden(void)
{
	int view_number = CL_MultiviewCurrentView();

	if (view_number < 1 || view_number > sizeof(powerup_cam_active) / sizeof(powerup_cam_active[0])) {
		return false;
	}

	--view_number;
	return powerup_cam_cvars[view_number].string && powerup_cam_cvars[view_number].string[0] && !(powerup_cam_status && powerup_cam_active[view_number]);
}

int MVD_PowerupCams_Enabled(void)
{
	int i, count = 0;

	for (i = 0; i < sizeof(powerup_cam_active) / sizeof(powerup_cam_active[0]) && i < cl_multiview.integer; ++i) {
		if (powerup_cam_active[i]) {
			++count;
		}
	}

	return count;
}

qbool MVD_PowerupCam_Enabled(void)
{
	int view_number = CL_MultiviewCurrentView();

	if (view_number < 1 || view_number > sizeof(powerup_cam_active) / sizeof(powerup_cam_active[0])) {
		return false;
	}

	--view_number;
	return powerup_cam_cvars[view_number].string && powerup_cam_cvars[view_number].string[0] && powerup_cam_status && powerup_cam_active[view_number];
}

void MVD_PowerupCam_Frame(void)
{
	int view_number = CL_MultiviewCurrentView();

	if (view_number < 1 || view_number > sizeof(powerup_cam_active) / sizeof(powerup_cam_active[0])) {
		return;
	}

	--view_number;
	if (!mvd_powerup_cam.integer || powerup_cam_status == powerup_cam_inactive) {
		memset(powerup_cam_active, 0, sizeof(powerup_cam_active));
		return;
	}

	MVD_PowerupCam_GetCoords();
	powerup_cam_active[view_number] = MVD_PowerupCam_Process(&powerup_cam_cvars[view_number]);
}

static void MVDAnnouncer_HelpListItems(void)
{
	int i;

	Con_Printf("Valid types: ");
	for (i = 0; i < sizeof(mvd_wp_info) / sizeof(mvd_wp_info[0]); ++i) {
		if (i) {
			Con_Printf(",");
		}
		Con_Printf("%s", mvd_wp_info[i].name);
	}
	Con_Printf("\n");
}

static int MVDAnnouncer_FindEntity(const vec3_t pos, int type)
{
	int j;

	for (j = 0; j < CL_MAX_EDICTS; j++) {
		int modindex = cl_entities[j].baseline.modelindex;
		int skin = cl_entities[j].baseline.skinnum;

		if (modindex >= 0 && modindex < sizeof(cl.model_precache) / sizeof(cl.model_precache[0]) && cl.model_precache[modindex]) {
			if (cl.model_precache[modindex]->modhint == mvd_wp_info[type].model_hint && skin == mvd_wp_info[type].skin_number) {
				vec3_t distance;
				VectorSubtract(cl_entities[j].baseline.origin, pos, distance);
				if (VectorLength(distance) < 50) {
					return j;
				}
			}
		}
	}

	return 0;
}

static void MVDAnnouncer_RemoveItem(void)
{
	vec3_t pos;
	const char* type;
	int i;
	mvd_clock_t* clock_entry;

	if (Cmd_Argc() < 5) {
		Con_Printf("Removes a persistent item clock for item at given position\n");
		Con_Printf("Usage: %s <x> <y> <z> <type>\n", Cmd_Argv(0));
		MVDAnnouncer_HelpListItems();
		return;
	}

	pos[0] = atof(Cmd_Argv(1));
	pos[1] = atof(Cmd_Argv(2));
	pos[2] = atof(Cmd_Argv(3));

	type = Cmd_Argv(4);

	for (i = 0; i < sizeof(mvd_wp_info) / sizeof(mvd_wp_info[0]); ++i) {
		if (!strcmp(type, mvd_wp_info[i].name)) {
			int ent = MVDAnnouncer_FindEntity(pos, i);

			if (ent) {
				for (clock_entry = mvd_clocklist; clock_entry; clock_entry = clock_entry->next) {
					if ((clock_entry->flags & MVDCLOCK_PERSISTENT) && clock_entry->entity == ent) {
						clock_entry->flags |= MVDCLOCK_HIDDEN;
						return;
					}
				}

				// Create it and mark it as hidden to stop it re-appearing
				MVD_ClockStartEntity(ent, mvd_wp_info[i].id, MVDCLOCK_PERSISTENT | MVDCLOCK_HIDDEN | MVDCLOCK_NEVERSPAWNED);
				return;
			}

			Con_Printf("No item found at specified location\n");
			return;
		}
	}

	Con_Printf("Invalid type specified\n");
	MVDAnnouncer_HelpListItems();
}

static void MVDAnnouncer_ListItems(void)
{
	mvd_clock_t* clock_entry;

	for (clock_entry = mvd_clocklist; clock_entry; clock_entry = clock_entry->next) {
		if ((clock_entry->flags & MVDCLOCK_PERSISTENT) && clock_entry->entity) {
			Con_Printf("mvd_name_item %d %d %d %s \"%s\" // entity %d\n",
				(int)cl_entities[clock_entry->entity].baseline.origin[0],
				(int)cl_entities[clock_entry->entity].baseline.origin[1],
				(int)cl_entities[clock_entry->entity].baseline.origin[2],
				mvd_wp_info[clock_entry->itemtype].name,
				clock_entry->location,
				clock_entry->entity
			);
		}
	}
}

static void MVDAnnouncer_NameItem(void)
{
	vec3_t pos;
	const char* type;
	const char* label;
	int i;

	if (Cmd_Argc() < 6) {
		Con_Printf("Creates a persistent item clock for item at given position\n");
		Con_Printf("Usage: %s <x> <y> <z> <type> <label>\n", Cmd_Argv(0));
		MVDAnnouncer_HelpListItems();
		return;
	}

	pos[0] = atof(Cmd_Argv(1));
	pos[1] = atof(Cmd_Argv(2));
	pos[2] = atof(Cmd_Argv(3));

	type = Cmd_Argv(4);
	label = Cmd_Argv(5);

	for (i = 0; i < sizeof(mvd_wp_info) / sizeof(mvd_wp_info[0]); ++i) {
		if (!strcmp(type, mvd_wp_info[i].name)) {
			int ent = MVDAnnouncer_FindEntity(pos, i);
			if (ent) {
				mvd_clock_t* existing = MVD_ClockFindEntity(ent);
				if (existing) {
					strlcpy(existing->location, label, sizeof(existing->location));
					// We move to bottom of the list to allow the user to list every item and dictate order
					existing->order = ++fixed_ordering;
					existing->flags &= ~(MVDCLOCK_HIDDEN);
				}
				else {
					MVD_ClockStartEntity(ent, mvd_wp_info[i].id, MVDCLOCK_PERSISTENT | MVDCLOCK_NEVERSPAWNED);
				}
				return;
			}

			Con_Printf("No entity of type %s found near %d %d %d\n", type, (int)pos[0], (int)pos[1], (int)pos[2]);
			return;
		}
	}

	Con_Printf("Invalid type specified '%s'\n", type);
	MVDAnnouncer_HelpListItems();
}

void MVD_Utils_Init(void)
{
	int i;

	MVD_AutoTrack_Init();
	MVD_XMLStats_Init();

	Cvar_SetCurrentGroup(CVAR_GROUP_MVD);
	Cvar_Register(&mvd_info);
	Cvar_Register(&mvd_info_show_header);
	Cvar_Register(&mvd_info_setup);
	Cvar_Register(&mvd_info_x);
	Cvar_Register(&mvd_info_y);

	Cvar_Register(&mvd_status);
	Cvar_Register(&mvd_status_x);
	Cvar_Register(&mvd_status_y);

	Cvar_Register(&mvd_powerup_cam);

	Cvar_Register(&mvd_pc_quad_1);
	Cvar_Register(&mvd_pc_quad_2);
	Cvar_Register(&mvd_pc_quad_3);

	Cvar_Register(&mvd_pc_pent_1);
	Cvar_Register(&mvd_pc_pent_2);
	Cvar_Register(&mvd_pc_pent_3);

	for (i = 0; i < sizeof(powerup_cam_cvars) / sizeof(powerup_cam_cvars[0]); ++i) {
		Cvar_Register(&powerup_cam_cvars[i]);
	}

	Cvar_Register(&mvd_moreinfo);
	Cvar_Register(&mvd_autoadd_items);
	Cvar_Register(&mvd_sortitems);
	Cmd_AddCommand("mvd_name_item", MVDAnnouncer_NameItem);
	Cmd_AddCommand("mvd_remove_item", MVDAnnouncer_RemoveItem);
	Cmd_AddCommand("mvd_list_items", MVDAnnouncer_ListItems);

	Cvar_ResetCurrentGroup();
}

void MVD_Screen(void) {
	MVD_Info();
	MVD_Status();
}

void MVD_FlushUserCommands(void)
{
	int i;
	float targettime = cls.demopackettime + cl.mvd_time_offset;

	for (i = 1; i < sizeof(cl.mvd_user_cmd) / sizeof(cl.mvd_user_cmd[0]); ++i) {
		if (cl.mvd_user_cmd_time[i] && cl.mvd_user_cmd_time[i] <= targettime) {
			cl.mvd_user_cmd_time[0] = cl.mvd_user_cmd_time[i];
			cl.mvd_user_cmd[0] = cl.mvd_user_cmd[i];
			cl.mvd_user_cmd_time[i] = 0;
			cl.mvd_user_cmd[i] = 0;
		}
	}
}

void MVD_ParseUserCommand(const char* s)
{
	float time;
	int command;
	int i;
	int plr;

	if (Cam_TrackNum() == -1) {
		return;
	}

	Cmd_TokenizeString((char*)s);

	if (Cmd_Argc() < 2) {
		return;
	}

	time = atof(Cmd_Argv(0));
	command = atoi(Cmd_Argv(1));
	plr = Cmd_Argc() >= 3 ? atoi(Cmd_Argv(2)) : 0;

	if (plr != 0 && cl.spec_track != plr - 1) {
		return;
	}

	if (!cl.mvd_time_offset) {
		cl.mvd_time_offset = time - cls.demopackettime;
	}

	MVD_FlushUserCommands();
	for (i = 0; i < sizeof(cl.mvd_user_cmd) / sizeof(cl.mvd_user_cmd[0]); ++i) {
		if (cl.mvd_user_cmd_time[i] == 0) {
			cl.mvd_user_cmd_time[i] = time;
			cl.mvd_user_cmd[i] = command;
			break;
		}
	}
}

mvd_new_info_t* MVD_StatsForPlayer(player_info_t* info)
{
	int i;
	for (i = 0; i < MAX_CLIENTS; ++i) {
		if (mvd_new_info[i].p_info == info) {
			return &mvd_new_info[i];
		}
	}
	return NULL;
}

void MVD_Initialise(void)
{
	memset(mvd_new_info, 0, sizeof(mvd_new_info));
	memset(&mvd_cg_info, 0, sizeof(mvd_cg_info));
	cl.mvd_ktx_markers = false;
}

void MVD_GameStart(void)
{
	int i;

	if (!cl.mvd_ktx_markers) {
		MVD_Initialise();
	}

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator == 1) {
			continue;
		}

		MVD_Init_Info(i);
	}
}

int MVD_ItemTypeForEntity(int ent)
{
	int modindex = cl_entities[ent].baseline.modelindex;
	int skin = cl_entities[ent].baseline.skinnum;

	if (modindex >= 0 && modindex < sizeof(cl.model_precache) / sizeof(cl.model_precache[0]) && cl.model_precache[modindex]) {
		int j;

		for (j = 0; j < sizeof(mvd_wp_info) / sizeof(mvd_wp_info[0]); ++j) {
			if (mvd_wp_info[j].add_clock == MVD_ADDCLOCK_ALWAYS || (mvd_wp_info[j].add_clock == MVD_ADDCLOCK_DMM1 && cl.deathmatch == 1)) {
				if (cl.model_precache[modindex]->modhint == mvd_wp_info[j].model_hint && skin == mvd_wp_info[j].skin_number) {
					return mvd_wp_info[j].id;
				}
			}
		}
	}
	return 0;
}

// ktx matchstart (no args)
void MVDAnnouncer_MatchStart(void)
{
	int i;
	int j;

	MVD_Stats_Cleanup();
	MVD_Init_Info(MAX_CLIENTS);
	MVD_GameStart();
	cl.mvd_ktx_markers = true;

	// Clocklist should start as persistent timers from entity baselines
	if (mvd_autoadd_items.integer) {
		for (i = 0; i < CL_MAX_EDICTS; i++) {
			int modindex = cl_entities[i].baseline.modelindex;
			int skin = cl_entities[i].baseline.skinnum;

			if (modindex >= 0 && modindex < sizeof(cl.model_precache) / sizeof(cl.model_precache[0]) && cl.model_precache[modindex]) {
				for (j = 0; j < sizeof(mvd_wp_info) / sizeof(mvd_wp_info[0]); ++j) {
					if (mvd_wp_info[j].add_clock == MVD_ADDCLOCK_ALWAYS || (mvd_wp_info[j].add_clock == MVD_ADDCLOCK_DMM1 && cl.deathmatch == 1)) {
						if (cl.model_precache[modindex]->modhint == mvd_wp_info[j].model_hint && skin == mvd_wp_info[j].skin_number) {
							MVD_ClockStartEntity(i, mvd_wp_info[j].id, MVDCLOCK_PERSISTENT | MVDCLOCK_NEVERSPAWNED);
						}
					}
				}
			}
		}
	}
	TP_ExecTrigger("f_demomatchstart");

	was_standby = false;
}

// Signifies an item has been taken
// ktx took <entity-num> <respawn-period> <plr-entnum>
void MVDAnnouncer_ItemTaken(const char* s)
{
	int entity, respawn, player_ent;
	mvd_clock_t* clock_entry;

	Cmd_TokenizeString((char*)s);

	if (Cmd_Argc() < 5) {
		Com_DPrintf("//ktx took: expected 5 args, found %d\n", Cmd_Argc());
		return;
	}

	cl.mvd_ktx_markers = true;

	entity = atoi(Cmd_Argv(2));
	respawn = atoi(Cmd_Argv(3));
	player_ent = atoi(Cmd_Argv(4));

	clock_entry = MVD_ClockFindEntity(entity);
	if (clock_entry) {
		clock_entry->last_taken = cls.demopackettime;
		clock_entry->old_clockval = clock_entry->clockval;
		if (respawn > 0) {
			clock_entry->clockval = cls.demopackettime + respawn;
			if (clock_entry->itemtype == QUAD_INFO || clock_entry->itemtype == PENT_INFO || clock_entry->itemtype == RING_INFO) {
				clock_entry->hold_clockval = cls.demopackettime + 30;
			}
			else {
				clock_entry->hold_clockval = 0;
			}
		}
		else {
			// Hold indefinitely
			clock_entry->clockval = -1;
			clock_entry->hold_clockval = HUGE_VAL;
		}

		if (player_ent >= 1 && player_ent <= MAX_CLIENTS) {
			clock_entry->last_taken_by = player_ent;
		}
	}
	else if (respawn) {
		int item = MVD_ItemTypeForEntity(entity);

		if (item) {
			MVD_ClockStart(item, cl_entities[entity].baseline.origin);
			mvd_new_info[player_ent - 1].mvdinfo.itemstats[item].mention = MENTION_PICKED_UP_ITEM;
		}
	}
}

// Used to manually start a countdown if it was indefinitely held in the past (e.g. mega-health worn off)
// ktx timer <entity-num> <respawn-period>
void MVDAnnouncer_StartTimer(const char* s)
{
	int entity, respawn;
	mvd_clock_t* clock_entry;

	Cmd_TokenizeString((char*)s);

	if (Cmd_Argc() < 4) {
		Com_DPrintf("//ktx timer: expected 4 args, found %d\n", Cmd_Argc());
		return;
	}

	cl.mvd_ktx_markers = true;
	entity = atoi(Cmd_Argv(2));
	respawn = atoi(Cmd_Argv(3));

	clock_entry = MVD_ClockFindEntity(entity);
	if (clock_entry) {
		clock_entry->old_clockval = clock_entry->clockval;
		clock_entry->clockval = cls.demopackettime + respawn;
		clock_entry->last_taken_by = 0;
		clock_entry->last_taken = 0;
	}
	else {
		int item = MVD_ItemTypeForEntity(entity);

		if (item) {
			MVD_ClockStart(item, cl_entities[entity].baseline.origin);
		}
	}
}

// ktx drop <entity-num> <weapon-it> <plr-entnum>
void MVDAnnouncer_PackDropped(const char* s)
{
	int entity, weapon, player_ent, i;
	mvd_clock_t* clock_entry;

	Cmd_TokenizeString((char*)s);

	if (Cmd_Argc() < 5) {
		Com_DPrintf("//ktx drop: expected 5 args, found %d\n", Cmd_Argc());
		return;
	}

	cl.mvd_ktx_markers = true;
	entity = atoi(Cmd_Argv(2));
	weapon = atoi(Cmd_Argv(3));
	player_ent = atoi(Cmd_Argv(4));

	if (entity >= 0 && entity < sizeof(cl_entities) / sizeof(cl_entities[0])) {
		cl_entities[entity].contents = weapon;

		clock_entry = MVD_ClockFindEntity(entity);
		if (clock_entry) {
			MVD_ClockList_Remove(clock_entry);
		}

		for (i = 0; i < sizeof(mvd_wp_info) / sizeof(mvd_wp_info[0]); ++i) {
			if (mvd_wp_info[i].it == weapon) {
				clock_entry = MVD_ClockStartEntity(entity, i, MVDCLOCK_BACKPACK);
				clock_entry->clockval = cls.demopackettime + 120;
				clock_entry->dropped_by = player_ent;
			}
		}
	}
}

// ktx expire <entity-num>
void MVDAnnouncer_Expired(const char* s)
{
	int entity;
	mvd_clock_t* clock_entry;

	Cmd_TokenizeString((char*)s);

	if (Cmd_Argc() < 3) {
		Com_DPrintf("//ktx expire: expected 3 args, found %d\n", Cmd_Argc());
		return;
	}

	cl.mvd_ktx_markers = true;
	entity = atoi(Cmd_Argv(2));
	if (entity >= 0 && entity < sizeof(cl_entities) / sizeof(cl_entities[0])) {
		cl_entities[entity].contents = 0;

		clock_entry = MVD_ClockFindEntity(entity);
		if (clock_entry) {
			MVD_ClockList_Remove(clock_entry);
		}
	}
}

// ktx bp <entnum> <plr-entnum>
void MVDAnnouncer_BackpackPickup(const char* s)
{
	int entity, player_ent;
	mvd_clock_t* clock_entry;

	Cmd_TokenizeString((char*)s);
	if (Cmd_Argc() < 4) {
		Com_DPrintf("//ktx bp: expected 4 args, found %d\n", Cmd_Argc());
		return;
	}

	cl.mvd_ktx_markers = true;
	entity = atoi(Cmd_Argv(2));
	player_ent = atoi(Cmd_Argv(3));

	clock_entry = MVD_ClockFindEntity(entity);
	if (clock_entry) {
		clock_entry->last_taken_by = player_ent;
		clock_entry->clockval = cls.demopackettime + ITEMSCLOCK_TAKEN_PAUSE;
		clock_entry->last_taken = cls.demopackettime;
	}

	if (entity >= 0 && entity < sizeof(cl_entities) / sizeof(cl_entities[0])) {
		cl_entities[entity].contents = 0;
	}
}


================================================
FILE: src/mvd_utils.h
================================================
/*
Copyright (C) 2001-2002 jogihoogi

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: mvd_utils.h,v 1.5 2007-09-24 21:41:17 johnnycz Exp $
*/

#ifndef MVDUTILS_HEADER
#define MVDUTILS_HEADER

// main header for a group of MVD tools: mvd_utils, mvd_xmlstats, mvd_autotrack
void MVD_Screen (void);

// initialize the module, add variables and commands
void MVD_Utils_Init(void); 
void MVD_Mainhook(void);
void MVD_Stats_Cleanup(void);
void MVD_ClockList_TopItems_Draw(double time_limit, int style, int x, int y, float scale, int filter, qbool backpacks, qbool proportional);
void MVD_ClockList_TopItems_DimensionsGet(double time_limit, int style, int *width, int *height, float scale, qbool backpacks, qbool proportional);

// update match info structures
void MVD_Init_Info(int player_slot);
void MVD_GameStart(void);
void MVD_Initialise(void);

// //ktx event notifications
void MVDAnnouncer_MatchStart(void);
void MVDAnnouncer_ItemTaken(const char* s);
void MVDAnnouncer_StartTimer(const char* s);
void MVDAnnouncer_PackDropped(const char* s);
void MVDAnnouncer_Expired(const char* s);
void MVDAnnouncer_BackpackPickup(const char* s);
void CL_ReadKtxDamageIndicatorString(const char* s);

// Powerup cams
qbool MVD_PowerupCam_Enabled(void);
int MVD_PowerupCams_Enabled(void);
void MVD_PowerupCam_Frame(void);

// JSON stats embedded in mvd
typedef struct {
	int frags;
	int deaths;
	int teamkills;
	int spawnfrags;
	int kills;
	int suicides;
} mvd_player_basic_stats;

typedef struct {
	int taken;
	int given;
	int team;
	int self;
	int team_weapons;
	int enemy_weapons;
	int taken_to_die;
} mvd_player_dmg_stats;

typedef struct {
	int max;
	int quad;
} mvd_player_spree_stats;

typedef struct {
	qbool present;
	float max;
	float avg;
} mvd_player_speed_stats;

typedef struct {
	int attacks;
	int hits;
	int real;
	int virtual;
} mvd_player_weapon_accuracy_stats;

typedef struct {
	int total;
	int team;
	int enemy;
	int self;
} mvd_player_weapon_kill_stats;

typedef struct {
	int enemy;
	int team;
} mvd_player_weapon_dmg_stats;

typedef struct {
	char name[16];
	mvd_player_weapon_accuracy_stats accuracy;
	mvd_player_weapon_kill_stats kills;
	int deaths;
	int pickups;
	int dropped;
	int taken;
	int total_taken;
	int spawn_taken;
	int spawn_total_taken;
	mvd_player_weapon_dmg_stats damage;
} mvd_player_weapon_stats;

typedef struct {
	char name[64];
	int taken;
	int time;
} mvd_player_item_stats;

typedef struct {
	qbool present;
	int points;
	int flag_caps;
	int defends;
	int carrier_defends;
	int carrier_frags;
	int pickups;
	int returns;
	int runes[4];
} mvd_player_ctf_stats;

typedef struct {
	int coilgun;
	int axe;
	int stomp;
	int multi;
	int air;
	int best_multi;
} mvd_player_instagib_gib_stats;

typedef struct {
	qbool present;
	int avg_height;
	int max_height;
	int rings;
	mvd_player_instagib_gib_stats gibs;
} mvd_player_instagib_stats;

typedef struct {
	int bronze;
	int silver;
	int gold;
	int platinum;
} mvd_player_midair_type_stats;

typedef struct {
	float total;
	float max;
	float avg;
} mvd_player_midair_height_stats;

typedef struct {
	qbool present;
	int stomps;
	mvd_player_midair_type_stats midairs;
	int total;
	int bonus;
	mvd_player_midair_height_stats heights;
} mvd_player_midair_stats;

typedef struct {
	qbool present;
	int wins;
	int losses;
} mvd_player_rocket_arena_stats;

#define HOONYMODE_MAXROUNDS 64

typedef struct {
	qbool present;
	int classic_roundcount;
	char classic_rounds[HOONYMODE_MAXROUNDS];
	int blitz_roundcount;
	int blitz_roundfrags[HOONYMODE_MAXROUNDS];
} mvd_player_hoonymode_stats;

#define LGCMODE_DISTANCE_BUCKETS 32

typedef struct {
	qbool present;
	int under;
	int over;
	int hit_buckets;
	int hits[LGCMODE_DISTANCE_BUCKETS];
	int misses[LGCMODE_DISTANCE_BUCKETS];
} mvd_player_lgc_stats;

typedef struct {
	qbool present;
	int skill;
	qbool customised;
} mvd_player_bot_stats;

typedef struct {
	int topcolor;
	int bottomcolor;
	int ping;
	char login[64];
	char team[64];
	mvd_player_basic_stats stats;
	mvd_player_dmg_stats dmg;
	int transferred_packs;
	mvd_player_spree_stats spree;
	float control;
	mvd_player_speed_stats speed;
	int handicap;
	mvd_player_weapon_stats weapons[16];
	mvd_player_item_stats items[32];
	mvd_player_ctf_stats ctf;
	mvd_player_instagib_stats instagib;
	mvd_player_midair_stats midair;
	mvd_player_rocket_arena_stats rocket_arena;
	mvd_player_hoonymode_stats hoonymode;
	mvd_player_lgc_stats lgc;
	mvd_player_bot_stats bot;
} mvd_player_stats;

typedef struct {
	int version;
	time_t date;
	char map[32];
	char hostname[32];
	char ip[64];
	int port;
	char matchtag[64];
	char mode[16];
	int timelimit;
	int fraglimit;
	int dmm;
	int teamplay;
	int duration;
	char demoname[128];

	mvd_player_stats players;
} mvd_game_stats;

#endif // MVDUTILS_HEADER


================================================
FILE: src/mvd_utils_common.h
================================================
/*
Copyright (C) 2001-2002 jogihoogi

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: mvd_utils_common.h,v 1.2 2007-09-24 21:34:51 johnnycz Exp $
*/

// Shared declarations for the whole mvd group of tools
// declarations from mvd_utils.c and mvd_autotrack.c

#define MH_INFO		14
#define RA_INFO		13
#define YA_INFO		12
#define GA_INFO		11
#define PENT_INFO	10
#define QUAD_INFO	9
#define RING_INFO	8
#define LG_INFO		7
#define RL_INFO		6
#define GL_INFO		5
#define SNG_INFO	4
#define NG_INFO		3
#define SSG_INFO	2
#define SG_INFO		1
#define AXE_INFO	0
#define mvd_info_types 15

#define IS_WEAPON(x) ((x) >= SSG_INFO && (x) <= LG_INFO)
#define MAX_MEGAS_PER_PLAYER 4

#define AMMO_TYPES 4

// killstats structures
typedef struct mvd_ks_w_s {
	int kills;
	int teamkills;
	int lastkills;
} mvd_ks_w_t;

typedef struct mvd_ks_s {
	mvd_ks_w_t normal[8];	// weapon kills axe - lg
	mvd_ks_w_t q[7];
	mvd_ks_w_t p[7];
	mvd_ks_w_t r[7];
	mvd_ks_w_t qp[7];
	mvd_ks_w_t qr[7];
	mvd_ks_w_t pr[7];
	mvd_ks_w_t qpr[7];
} mvd_ks_t;

typedef struct  mvd_ds_s {
	int isdead;
	int deathcount;
	double alivetimestart;
	double alivetime;

} mvd_ds_t ;

// keeps runstats from spawn to death
typedef struct mvd_runs_s {
	double time;
	int frags;
	int teamfrags;
	double starttime;

} mvd_runs_t ;

// average run statistics
typedef struct mvd_avgruns_s {
	double avg_time;
	double avg_frags;
	double avg_teamfrags;
} mvd_avgruns_t;

// average run statistics
typedef struct mvd_avgruns_all_s {
	mvd_avgruns_t all;
	// following 3 are not implemented yet
	mvd_avgruns_t quad;
	mvd_avgruns_t pent;
	mvd_avgruns_t ring;
} mvd_avgruns_all_t;

// item stuff
typedef struct mvd_pw_s {
	int has;
	double starttime;
	double ctime;
	int count ;
	int lost ;
	int mention;
	mvd_runs_t runs[512];
	int run;
} mvd_pw_t;

typedef struct mvd_info_s {
    float value;
    int lfw;				//last fired weapon
	mvd_ds_t das;			//dead alive stats
	mvd_pw_t itemstats[mvd_info_types];		//item stats
	unsigned short ammostats[AMMO_TYPES];
	mvd_runs_t runs[512];	//
	mvd_avgruns_all_t run_stats;	// calculated from other items
	mvd_ks_t killstats;		// killstats
	int spawntelefrags;
	int teamspawntelefrags;
	int teamfrags;			// frags are in cl.players structure
	int lastfrags;
	int run;
	int firstrun;
	qbool initialized;
} mvd_info_t;

typedef struct items_s {
	int took;
	int lost;
} items_t;

typedef struct mvd_event_s {
	int			type;			// what happened ?	0-spawn,1-death,2-kill,3-teamkill,4-took,5-powerup_end
	double		time;		// when did it happen ?
	vec3_t		loc;		// where did it happen ?
	int			info;		// for item on tooks
							// lfw on deaths
							// lfw on kills 0-7 axe-lg,-1 spawn
							//
	int			k_id;		// userid of the guy we killed
} mvd_event_t;

typedef struct mvd_new_info_s {
	int id;							//id cl.players[id]
	float value;						//mvd_info/mvd_autotrack value

	mvd_event_t		*event;
	player_state_t	*p_state ;
	player_info_t	*p_info;
	int lwf;						// last weapon fired
	mvd_info_t mvdinfo;
	vec3_t mega_locations[MAX_MEGAS_PER_PLAYER];
} mvd_new_info_t;// mvd_new_info;

extern mvd_new_info_t mvd_new_info[MAX_CLIENTS];

typedef struct mvd_cg_info_s {
	char mapname[1024];
	char team1[1024];
	char team2[1024];
	char hostname[1024];
	int gametype;
	int timelimit;
	int pcount;
	int deathmatch;
} mvd_cg_info_s;

extern mvd_cg_info_s mvd_cg_info;

typedef struct mvd_gt_info_s {
	int id;
	char *name;
} mvd_gt_info_t;

#define gt_unknown	3
#define gt_4on4	3
#define gt_3on3	2
#define gt_2on2	1
#define gt_1on1	0
#define mvd_gt_types 5

extern mvd_gt_info_t mvd_gt_info[mvd_gt_types];

#define MVD_ADDCLOCK_NEVER  0
#define MVD_ADDCLOCK_ALWAYS 1
#define MVD_ADDCLOCK_DMM1   2

typedef struct mvd_wp_info_s {
	int           id;
	char*         name;
	int           it;
	const char*   colored_name;
	int           model_hint;
	int           skin_number;
	byte          Rcolor;
	byte          Gcolor;
	byte          Bcolor;
	const cvar_t* name_cvar;
	const char*   color_string;
	const char*   colored_packname;
	int           add_clock;
	qbool         show_held;
} mvd_wp_info_t;

extern mvd_wp_info_t mvd_wp_info[mvd_info_types];

// mvd_autotrack:
void MVD_AutoTrack(void);
void MVD_AutoTrack_Init(void);

// mvd_xmlstats:
void MVD_XMLStats_Init(void);

mvd_new_info_t* MVD_StatsForPlayer(player_info_t* info);


================================================
FILE: src/mvd_xmlstats.c
================================================
/*
Copyright (C) 2001-2002 jogihoogi

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: mvd_xmlstats.c,v 1.1 2007-09-24 21:34:52 johnnycz Exp $
*/

// MultiView Demo Stats Export System
// after a match is over, user can export stats in xml format to a file

#include "quakedef.h"
#include "mvd_utils_common.h"

static char *mvd_name_to_xml(char *s){
	static char buf[1024];
	char *p;
	int i;
	buf[0]=0;
	for(p=s;*p;p++){
		i=(int)*p;
		if(i<0)
			i+=256;
		if (strlen(buf)>0 ){
			snprintf(buf, sizeof (buf), "%s",va("%s			<char>%i</char>\n",buf,i));
		}else
			snprintf(buf, sizeof (buf), "%s",va("\n			<char>%i</char>\n",i));
	}
	return buf;

}

static void mvd_s_h (FILE *f){
	fprintf(f,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
	fprintf(f,"<?xml-stylesheet type=\"text/xsl\" href=\"mvdstats.xsl\"?>\n");
	fprintf(f,"<mvdstats>\n");
	fprintf(f,"\n");
	fprintf(f,"\n");
	fprintf(f,"<demoinfos>\n");
	fprintf(f,"		<map>%s</map>\n",mvd_cg_info.mapname);
	fprintf(f,"		<gametype>%s</gametype>\n",mvd_gt_info[mvd_cg_info.gametype].name);
	fprintf(f,"		<hostname>%s</hostname>\n",mvd_cg_info.hostname);
	if (mvd_cg_info.gametype != 0 && mvd_cg_info.gametype != 4){
		fprintf(f,"		<team1>%s</team1>\n",mvd_name_to_xml(mvd_cg_info.team1));
		fprintf(f,"		<team2>%s</team2>\n",mvd_name_to_xml(mvd_cg_info.team2));
	}
	fprintf(f,"		<timelimit>%i</timelimit>\n",mvd_cg_info.timelimit);
	fprintf(f,"</demoinfos>\n");
}

static void mvd_s_e (FILE *f){
	fprintf(f,"</mvdstats>\n");

}

static void mvd_s_p (FILE *f,int i,int k){
	int x,y,z;

		fprintf(f,"	<player id=\"%i\">\n",k);
		fprintf(f,"		<nick>%s		</nick>\n",mvd_name_to_xml(mvd_new_info[i].p_info->name));
		if (mvd_cg_info.gametype != 0 && mvd_cg_info.gametype != 4)
			fprintf(f,"		<team>%s</team>\n",mvd_name_to_xml(mvd_new_info[i].p_info->team));
		fprintf(f,"		<kills>\n");
		for (z=0,x=AXE_INFO;x<=LG_INFO;x++){
			fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[x].name,mvd_new_info[i].mvdinfo.killstats.normal[x].kills,mvd_wp_info[x].name);
			z+=mvd_new_info[i].mvdinfo.killstats.normal[x].kills;
		}
		fprintf(f,"			<spawn>%i</spawn>\n",mvd_new_info[i].mvdinfo.spawntelefrags);
		z+=mvd_new_info[i].mvdinfo.spawntelefrags;
			fprintf(f,"			<all>%i</all>\n",z);
		fprintf(f,"		</kills>\n");
		fprintf(f,"		<teamkills>\n");
		for (z=0,x=AXE_INFO;x<=LG_INFO;x++){
			fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[x].name,mvd_new_info[i].mvdinfo.killstats.normal[x].teamkills,mvd_wp_info[x].name);
			z+=mvd_new_info[i].mvdinfo.killstats.normal[x].teamkills;
		}
		fprintf(f,"			<spawn>%i</spawn>\n",mvd_new_info[i].mvdinfo.teamspawntelefrags);
		z+=mvd_new_info[i].mvdinfo.teamspawntelefrags;
			fprintf(f,"			<all>%i</all>\n",z);

		fprintf(f,"		</teamkills>\n");
		fprintf(f,"		<deaths>%i</deaths>\n",mvd_new_info[i].mvdinfo.das.deathcount);
		fprintf(f,"		<took>\n");
		for (x=SSG_INFO;x<=MH_INFO;x++){
			fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[x].name,mvd_new_info[i].mvdinfo.itemstats[x].count,mvd_wp_info[x].name);
		}
		fprintf(f,"		</took>\n");
		fprintf(f,"		<lost>\n");
		for (x=SSG_INFO;x<=MH_INFO;x++){
			fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[x].name,mvd_new_info[i].mvdinfo.itemstats[x].lost,mvd_wp_info[x].name);
		}
		fprintf(f,"		</lost>\n");

		fprintf(f,"	<runs>\n");
		for(x=0;x<mvd_new_info[i].mvdinfo.run;x++){
			fprintf(f,"		<run id=\"%i\">\n",x);
			fprintf(f,"			<time>%9.3f</time>\n",mvd_new_info[i].mvdinfo.runs[x].time);
			fprintf(f,"			<frags>%i</frags>\n",mvd_new_info[i].mvdinfo.runs[x].frags);
			fprintf(f,"			<teamfrags>%i</teamfrags>\n",mvd_new_info[i].mvdinfo.runs[x].teamfrags);
			fprintf(f,"		</run>\n");
		}
		fprintf(f,"	</runs>\n");

		for(y=RING_INFO;y<=PENT_INFO ;y++){
			if (mvd_new_info[i].mvdinfo.itemstats[y].run == 0)
				continue;
			fprintf(f,"	<%s_runs>\n",mvd_wp_info[y].name);

			for(x=0;x<mvd_new_info[i].mvdinfo.itemstats[y].run;x++){
			fprintf(f,"		<run id=\"%i\">\n",x);
			fprintf(f,"			<time>%9.3f</time>\n",mvd_new_info[i].mvdinfo.itemstats[y].runs[x].time);
			fprintf(f,"			<frags>%i</frags>\n",mvd_new_info[i].mvdinfo.itemstats[y].runs[x].frags);
			fprintf(f,"			<teamfrags>%i</teamfrags>\n",mvd_new_info[i].mvdinfo.itemstats[y].runs[x].teamfrags);;
			fprintf(f,"		</run>\n");
			}
			fprintf(f,"	</%s_runs>\n",mvd_wp_info[y].name);
		}

		fprintf(f,"	</player>\n\n");
}

static void mvd_s_t (FILE *f){
	int i,z;
	int static count;

	if (mvd_cg_info.gametype == 0 || mvd_cg_info.gametype == 4)
		return;
	fprintf(f,"<Teamstats>\n");

	fprintf(f,"		<team1>\n");
	fprintf(f,"			<name>%s</name>\n",mvd_name_to_xml(mvd_cg_info.team1));
	fprintf(f,"			<players>\n");
	for (i = 0,z=0; i < mvd_cg_info.pcount; i++) {
		if (strcmp(mvd_new_info[i].p_info->team,mvd_cg_info.team1))
			continue;
		mvd_s_p(f,i,z);
		z++;
	}

	fprintf(f,"			</players>\n");

	fprintf(f,"		<took>\n");
	for(z=SSG_INFO;z<=MH_INFO;z++,count=0){
		for (i = 0; i < mvd_cg_info.gametype; i++) {
			if (strcmp(mvd_new_info[i].p_info->team,mvd_cg_info.team1))
				continue;
			count+=mvd_new_info[i].mvdinfo.itemstats[z].count;

		}
		fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[z].name,count,mvd_wp_info[z].name);
	}
	fprintf(f,"		</took>\n");

	fprintf(f,"		<lost>\n");
	for(z=SSG_INFO;z<=QUAD_INFO;z++,count=0){
		for (i = 0; i < mvd_cg_info.pcount; i++) {
			if (!strcmp(mvd_new_info[i].p_info->team,mvd_cg_info.team1))
				continue;
			count+=mvd_new_info[i].mvdinfo.itemstats[z].lost;

		}
		fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[z].name,count,mvd_wp_info[z].name);
	}

	fprintf(f,"		</lost>\n");

	fprintf(f,"		<kills>\n");
	for(z=AXE_INFO;z<=LG_INFO;z++,count=0){
		for (i = 0; i < mvd_cg_info.pcount; i++) {
			if (strcmp(mvd_new_info[i].p_info->team,mvd_cg_info.team1))
				continue;
			count+=mvd_new_info[i].mvdinfo.killstats.normal[z].kills;

		}
		fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[z].name,count,mvd_wp_info[z].name);
		count=0;
	}

	fprintf(f,"		</kills>\n");

	fprintf(f,"		</team1>\n");

	fprintf(f,"		<team2>\n");
		fprintf(f,"			<name>%s</name>\n",mvd_name_to_xml(mvd_cg_info.team2));
		fprintf(f,"			<players>\n");
		for (i = 0,z=0; i < mvd_cg_info.pcount; i++) {
			if (strcmp(mvd_new_info[i].p_info->team,mvd_cg_info.team2))
				continue;
			mvd_s_p(f,i,z);
			z++;
		}
		fprintf(f,"			</players>\n");

		fprintf(f,"		<took>\n");
		for(z=SSG_INFO;z<=MH_INFO;z++,count=0){
			for (i = 0; i < mvd_cg_info.gametype; i++) {
				if (strcmp(mvd_new_info[i].p_info->team,mvd_cg_info.team2))
					continue;
				count+=mvd_new_info[i].mvdinfo.itemstats[z].count;

			}
			fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[z].name,count,mvd_wp_info[z].name);

		}
		fprintf(f,"		</took>\n");

		fprintf(f,"		<lost>\n");
		for(z=SSG_INFO;z<=QUAD_INFO;z++,count=0){
			for (i = 0; i < mvd_cg_info.pcount; i++) {
				if (strcmp(mvd_new_info[i].p_info->team,mvd_cg_info.team2))
					continue;
				count+=mvd_new_info[i].mvdinfo.itemstats[z].lost;

			}
			fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[z].name,count,mvd_wp_info[z].name);
		}

		fprintf(f,"		</lost>\n");

		fprintf(f,"		<kills>\n");
		for(z=AXE_INFO;z<=LG_INFO;z++,count=0){
			for (i = 0; i < mvd_cg_info.pcount; i++) {
				if (strcmp(mvd_new_info[i].p_info->team,mvd_cg_info.team2))
					continue;
				count+=mvd_new_info[i].mvdinfo.killstats.normal[z].kills;

			}
			fprintf(f,"			<%s>%i</%s>\n",mvd_wp_info[z].name,count,mvd_wp_info[z].name);

		}

		fprintf(f,"		</kills>\n");

		fprintf(f,"		</team2>\n");

	fprintf(f,"</Teamstats>\n");
}

static void MVD_Status_Xml (void){
	FILE *f;
	int i;
	char* filename;

	// todo: add match name from match tools

	filename = "stats.xml";

	f=fopen(filename,"wb");
	if (!f) {
		Com_Printf("Can't open %s\n", filename);
		return;
	}
	Com_Printf("Dumping XML stats to %s\n",filename);

	mvd_s_h(f);
	if (mvd_cg_info.gametype!=0 && mvd_cg_info.gametype!=4 ){
		mvd_s_t(f);
	} else {
		for (i=0;i<mvd_cg_info.pcount;i++)
			mvd_s_p(f,i,i);
	}
	mvd_s_e(f);
	fclose(f);
}

void MVD_XMLStats_Init(void)
{
	Cmd_AddCommand ("mvd_dumpstats",MVD_Status_Xml);
}


================================================
FILE: src/net.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


*/
// net.c

#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "quakedef.h"
#include "server.h"
#include "utils.h"
#define MAX_STRINGS 16 // well, this used not only for va, anyway, static buffers is evil...
#endif

#ifdef _WIN32
WSADATA winsockdata;
#define EZ_TCP_WOULDBLOCK (WSAEWOULDBLOCK)
#else
#define EZ_TCP_WOULDBLOCK (EINPROGRESS)
#endif


#ifndef SERVERONLY
netadr_t	net_local_cl_ipadr;

void NET_CloseClient (void);

static void cl_net_clientport_changed(cvar_t* var, char* value, qbool* cancel);
static cvar_t cl_net_clientport = { "cl_net_clientport", "27001", CVAR_AUTO, cl_net_clientport_changed };  // Was PORT_CLIENT in protocol.h

typedef struct {
	int port;
	double rtt;
} portpingprobe_t;

typedef struct {
	int thread_id;
	int num_ports;
	struct sockaddr_in *addr;
	portpingprobe_t *results;
} portpingprobe_worker_args_t;

typedef struct {
	char *target_addr;
	char *original_addr;
} portpingprobe_orchestrator_args_t;

static SDL_atomic_t portpingprobe_status;
static SDL_atomic_t portpingprobe_progress;

static void cl_portpingprobe_probes_changed(cvar_t *var, char *val, qbool *cancel);
static void cl_portpingprobe_port_probes_changed(cvar_t *var, char *val, qbool *cancel);
static cvar_t cl_portpingprobe_probes      = {"cl_portpingprobe_probes", "500", 0, cl_portpingprobe_probes_changed};
static cvar_t cl_portpingprobe_port_probes = {"cl_portpingprobe_port_probes", "1", 0, cl_portpingprobe_port_probes_changed};
static cvar_t cl_portpingprobe_enable      = {"cl_portpingprobe_enable", "0"};
static cvar_t cl_portpingprobe_delay       = {"cl_portpingprobe_delay",  "0"};

static double NET_PortPing(const struct sockaddr_in *srv_adr, const int probe_port);
static int NET_PortPingProbeWorker(void *data);
static SDL_Thread **NET_PortPingProbeInitWorkers(struct sockaddr_in *addr, int num_threads, portpingprobe_t *results);
static int NET_PortPingProbeOrchestrator(void *data);

#define MIN_TCP_TIMEOUT  500
#define MAX_TCP_TIMEOUT 5000

static cvar_t net_tcp_timeout = { "net_tcp_timeout", "2000" };
#endif

#ifndef CLIENTONLY
netadr_t	net_local_sv_ipadr;
netadr_t	net_local_sv_tcpipadr;

cvar_t		sv_local_addr = {"sv_local_addr", "", CVAR_ROM};
#endif

netadr_t	net_from;
sizebuf_t	net_message;

static byte net_message_buffer[MSG_BUF_SIZE];

// forward definition.
qbool NET_GetPacketEx (netsrc_t netsrc, qbool delay);
void NET_SendPacketEx (netsrc_t netsrc, int length, void *data, netadr_t to, qbool delay);

#ifdef SERVERONLY
#define TCP_LISTEN_BACKLOG 2
#else
#define TCP_LISTEN_BACKLOG 1
#ifndef _WIN32
extern qbool stdin_ready;
extern int do_stdin;
#endif
#endif

//=============================================================================
//
// LOOPBACK defs.
//

#define MAX_LOOPBACK 4 // must be a power of two

typedef struct {
	byte	data[MAX_UDP_PACKET];
	int		datalen;
} loopmsg_t;

typedef struct {
	loopmsg_t	msgs[MAX_LOOPBACK];
	unsigned int	get, send;
} loopback_t;

loopback_t	loopbacks[2];

//=============================================================================
//
// Delayed packets, CLIENT ONLY.
//

#ifndef SERVERONLY

typedef struct packet_queue_s {
	cl_delayed_packet_t packets[CL_MAX_DELAYED_PACKETS];
	int head;
	int tail;
	qbool outgoing;
} packet_queue_t;

static packet_queue_t delay_queue_get;
static packet_queue_t delay_queue_send;

static inline void NET_PacketQueueSetNextIndex(int* index)
{
	*index = (*index + 1) % CL_MAX_DELAYED_PACKETS;
}

static qbool NET_PacketQueueRemove(packet_queue_t* queue, sizebuf_t* buffer, netadr_t* from_address)
{
	cl_delayed_packet_t* next = &queue->packets[queue->head];
	double time;

	// Empty queue
	if (!next->time) {
		return false;
	}

	// Not time yet
	time = Sys_DoubleTime();
	if (next->time > time) {
		return false;
	}

	SZ_Clear(buffer);
	SZ_Write(buffer, next->data, next->length);
	*from_address = next->addr;
	next->time = 0;

	NET_PacketQueueSetNextIndex(&queue->head);
	return true;
}

static qbool NET_PacketQueueAdd(packet_queue_t* queue, byte* data, int size, netadr_t addr)
{
	cl_delayed_packet_t* next = &queue->packets[queue->tail];
	float deviation = 0;
	float ms_delay;

	if (cl_delay_packet_dev.integer) {
		deviation = f_rnd(-bound(0, cl_delay_packet_dev.integer, CL_MAX_PACKET_DELAY_DEVIATION), bound(0, cl_delay_packet_dev.integer, CL_MAX_PACKET_DELAY_DEVIATION));
	}

	// If buffer is full, can't prevent packet loss - drop this packet
	if (next->time && queue->head == queue->tail) {
		return false;
	}

	// calculate delay based on settings
	if (cls.state != ca_active) {
		// not yet connected, go as fast as possible
		ms_delay = 0;
	}
	else if (cl_delay_packet_target.integer && *(int*)data != -1) {
		if (!queue->outgoing) {
			// dynamically change delay to target a particular latency
			int sequence_ack;
			int sequencemod;
			double expected_latency;

			MSG_BeginReading();
			MSG_ReadLong(); // sequence =
			sequence_ack = MSG_ReadLong();
			sequence_ack &= ~(1 << 31);

			sequencemod = sequence_ack & UPDATE_MASK;
			expected_latency = (cls.realtime - cl.frames[sequencemod].senttime) * 1000.0;

			ms_delay = max(0, cl_delay_packet_target.value - expected_latency + deviation);
		}
		else {
			// push some of the delay onto outgoing
			ms_delay = cls.latency / 2;
		}
	}
	else {
		// delay by constant amount
		ms_delay = bound(0, 0.5 * cl_delay_packet.integer + deviation, CL_MAX_PACKET_DELAY);
	}

	memmove(next->data, data, size);
	next->length = size;
	next->addr = addr;
	next->time = Sys_DoubleTime() + 0.001 * ms_delay;

	NET_PacketQueueSetNextIndex(&queue->tail);
	return true;
}

static cl_delayed_packet_t* NET_PacketQueuePeek(packet_queue_t* queue)
{
	cl_delayed_packet_t* next = &queue->packets[queue->head];

	// Empty queue
	if (!next->time)
		return NULL;

	return next;
}

static void NET_PacketQueueAdvance(packet_queue_t* queue)
{
	cl_delayed_packet_t* head = NET_PacketQueuePeek(queue);

	if (head != NULL)
	{
		head->time = 0;

		NET_PacketQueueSetNextIndex(&queue->head);
	}
}

#endif

//=============================================================================
//
// Geters.
//
#ifndef CLIENTONLY
int NET_UDPSVPort (void)
{
	return ntohs(net_local_sv_ipadr.port);
}
#endif

int NET_GetSocket(netsrc_t netsrc, qbool tcp)
{
	if (netsrc == NS_SERVER)
	{
#ifdef CLIENTONLY
		Sys_Error("NET_GetPacket: Bad netsrc");
		return INVALID_SOCKET;
#else
		return tcp ? svs.sockettcp : svs.socketip;
#endif
	}
	else
	{
#ifdef SERVERONLY
		Sys_Error("NET_GetPacket: Bad netsrc");
		return INVALID_SOCKET;
#else
		return tcp ? cls.sockettcp : cls.socketip;
#endif
	}
}

//=============================================================================
//
// Converters.
//

void NetadrToSockadr (const netadr_t *a, struct sockaddr_storage *s)
{
	memset (s, 0, sizeof(struct sockaddr_in));
	((struct sockaddr_in*)s)->sin_family = AF_INET;

	((struct sockaddr_in*)s)->sin_addr.s_addr = *(int *)&a->ip;
	((struct sockaddr_in*)s)->sin_port = a->port;
}

void SockadrToNetadr (const struct sockaddr_storage *s, netadr_t *a)
{
	a->type = NA_IP;
	*(int *)&a->ip = ((struct sockaddr_in *)s)->sin_addr.s_addr;
	a->port = ((struct sockaddr_in *)s)->sin_port;
	return;
}

//=============================================================================
//
// Comparators.
//

qbool NET_CompareBaseAdr (const netadr_t a, const netadr_t b)
{
#ifndef SERVERONLY
	if (a.type == NA_LOOPBACK && b.type == NA_LOOPBACK)
		return true;
#endif

	// FIXME: Should we check a.type == b.type here ???

	if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3])
		return true;
	return false;
}

qbool NET_CompareAdr (const netadr_t a, const netadr_t b)
{
#ifndef SERVERONLY
	if (a.type == NA_LOOPBACK && b.type == NA_LOOPBACK)
		return true;
#endif

	// FIXME: Should we check a.type == b.type here ???

	if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3] && a.port == b.port)
		return true;
	return false;
}

//=============================================================================
//
// Printors.
//

char *NET_AdrToString (const netadr_t a)
{
	static char s[MAX_STRINGS][32]; // 22 should be OK too
	static int idx = 0;

	idx %= MAX_STRINGS;

#ifndef SERVERONLY
	if (a.type == NA_LOOPBACK) {
		return "loopback";
	}
#endif

	snprintf (s[idx], sizeof(s[0]), "%i.%i.%i.%i:%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3], ntohs(a.port));
	return s[idx++];
}

char *NET_BaseAdrToString (const netadr_t a)
{
	static char s[MAX_STRINGS][32]; // 22 should be OK too
	static int idx = 0;

	idx %= MAX_STRINGS;

#ifndef SERVERONLY
	if (a.type == NA_LOOPBACK) {
		return "loopback";
	}
#endif

	snprintf (s[idx], sizeof(s[0]), "%i.%i.%i.%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3]);
	return s[idx++];
}

static qbool NET_StringToSockaddr (const char *s, struct sockaddr_storage *sadr)
{
	struct hostent	*h;
	char	*colon;
	char	copy[128];

	if (!(*s))
		return false;

	memset (sadr, 0, sizeof(*sadr));

	((struct sockaddr_in *)sadr)->sin_family = AF_INET;
	((struct sockaddr_in *)sadr)->sin_port = 0;

	// can't resolve IP by hostname if hostname was truncated
	if (strlcpy (copy, s, sizeof(copy)) >= sizeof(copy))
		return false;

	// strip off a trailing :port if present
	for (colon = copy ; *colon ; colon++)
	{
		if (*colon == ':') {
			*colon = 0;
			((struct sockaddr_in *)sadr)->sin_port = htons((short)atoi(colon+1));
		}
	}

	//this is the wrong way to test. a server name may start with a number.
	if (copy[0] >= '0' && copy[0] <= '9')
	{
		//this is the wrong way to test. a server name may start with a number.
		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(copy);
	}
	else {
		if (!(h = gethostbyname(copy))) {
			return false;
		}

		if (h->h_addrtype != AF_INET) {
			return false;
		}

		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0];
	}

	return true;
}

qbool NET_StringToAdr (const char *s, netadr_t *a)
{
	struct sockaddr_storage sadr;

#ifndef SERVERONLY
	if (!strcmp(s, "local")) {
		memset(a, 0, sizeof(*a));
		a->type = NA_LOOPBACK;
		return true;
	}
#endif

	if (!NET_StringToSockaddr (s, &sadr))
		return false;

	SockadrToNetadr (&sadr, a);

	return true;
}

/*
=============================================================================
LOOPBACK BUFFERS FOR LOCAL PLAYER
=============================================================================
*/

qbool NET_GetLoopPacket (netsrc_t netsrc, netadr_t *from, sizebuf_t *message)
{
	int i;
	loopback_t *loop;

	loop = &loopbacks[netsrc];

	if (loop->send - loop->get > MAX_LOOPBACK)
		loop->get = loop->send - MAX_LOOPBACK;

	if (loop->get >= loop->send)
		return false;

	i = loop->get & (MAX_LOOPBACK-1);
	loop->get++;

	if (message->maxsize < loop->msgs[i].datalen)
		Sys_Error("NET_SendLoopPacket: Loopback buffer was too big");

	memcpy (message->data, loop->msgs[i].data, loop->msgs[i].datalen);
	message->cursize = loop->msgs[i].datalen;
	memset (from, 0, sizeof(*from));
	from->type = NA_LOOPBACK;
	return true;
}

void NET_SendLoopPacket (netsrc_t netsrc, int length, void *data, netadr_t to)
{
	int i;
	loopback_t *loop;

	loop = &loopbacks[netsrc ^ 1];

	i = loop->send & (MAX_LOOPBACK - 1);
	loop->send++;

	if (length > (int) sizeof(loop->msgs[i].data))
		Sys_Error ("NET_SendLoopPacket: length > %d", (int) sizeof(loop->msgs[i].data));

	memcpy (loop->msgs[i].data, data, length);
	loop->msgs[i].datalen = length;
}

void NET_ClearLoopback (void)
{
	loopbacks[0].send = loopbacks[0].get = 0;
	loopbacks[1].send = loopbacks[1].get = 0;
}

#ifndef CLIENTONLY
//=============================================================================
//
// SV TCP connection.
//

// allocate, may link it in, if requested
svtcpstream_t *sv_tcp_connection_new(int sock, netadr_t from, char *buf, int buf_len, qbool link)
{
	svtcpstream_t *st = NULL;

	st = Q_malloc(sizeof(svtcpstream_t));
	st->waitingforprotocolconfirmation = true;
	st->socketnum = sock;
	st->remoteaddr = from;
	if (buf_len > 0 && buf_len < sizeof(st->inbuffer))
	{
		memmove(st->inbuffer, buf, buf_len);
		st->inlen = buf_len;
	}
	else
		st->drop = true; // yeah, funny

	// link it in if requested
	if (link)
	{
		st->next = svs.tcpstreams;
		svs.tcpstreams = st;
	}

	return st;
}

// free data, may unlink it out if requested
static void sv_tcp_connection_free(svtcpstream_t *drop, qbool unlink)
{
	if (!drop)
		return; // someone kidding us

	// unlink if requested
	if (unlink)
	{
		if (svs.tcpstreams == drop)
		{
			svs.tcpstreams = svs.tcpstreams->next;
		}
		else
		{
			svtcpstream_t *st = NULL;

			for (st = svs.tcpstreams; st; st = st->next)
			{
				if (st->next == drop)
				{
					st->next = st->next->next;
					break;
				}
			}
		}
	}

	// well, think socket may be zero, but most of the time zero is stdin fd, so better not close it
	if (drop->socketnum && drop->socketnum != INVALID_SOCKET)
		closesocket(drop->socketnum);

	Q_free(drop);
}

int sv_tcp_connection_count(void)
{
	svtcpstream_t *st = NULL;
	int cnt = 0;

	for (st = svs.tcpstreams; st; st = st->next)
		cnt++;

	return cnt;
}
#endif

//=============================================================================

qbool NET_GetUDPPacket (netsrc_t netsrc, netadr_t *from_adr, sizebuf_t *message)
{
	int ret, err;
	struct sockaddr_storage from = {0};
	socklen_t fromlen;
	int socket = NET_GetSocket(netsrc, false);

	if (socket == INVALID_SOCKET)
		return false;

	fromlen = sizeof(from);
	ret = recvfrom (socket, (char *)message->data, message->maxsize, 0, (struct sockaddr *)&from, &fromlen);
	SockadrToNetadr (&from, from_adr);

	if (ret == -1)
	{
		err = qerrno;

		if (err == EWOULDBLOCK)
			return false; // common error, does not spam in logs.

		if (err == EMSGSIZE)
		{
			Con_DPrintf ("Warning: Oversize packet from %s\n", NET_AdrToString (*from_adr));
			return false;
		}

		if (err == ECONNABORTED || err == ECONNRESET)
		{
			Con_DPrintf ("Connection lost or aborted\n");
			return false;
		}

		Con_Printf ("NET_GetPacket: recvfrom: (%i): %s\n", err, strerror(err));
		return false;
	}

	if (ret >= message->maxsize)
	{
		Con_Printf ("Oversize packet from %s\n", NET_AdrToString (*from_adr));
		return false;
	}

	message->cursize = ret;

	return ret;
}

#ifndef SERVERONLY
qbool NET_GetTCPPacket_CL (netsrc_t netsrc, netadr_t *from, sizebuf_t *message)
{
	int ret, err;

	if (netsrc != NS_CLIENT || cls.sockettcp == INVALID_SOCKET)
		return false;

	ret = recv(cls.sockettcp, (char *) cls.tcpinbuffer + cls.tcpinlen, sizeof(cls.tcpinbuffer) - cls.tcpinlen, 0);

	// FIXME: should we check for ret == 0  for disconnect ???

	if (ret == -1)
	{
		err = qerrno;

		if (err == EWOULDBLOCK)
		{
			ret = 0; // hint for code below that it was not cricial error.
		}
		else if (err == ECONNABORTED || err == ECONNRESET)
		{
			Con_Printf ("Connection lost or aborted\n"); //server died/connection lost.
		}
		else
		{
			Con_Printf ("NET_GetPacket: Error (%i): %s\n", err, strerror(err));
		}

		if (ret)
		{
			// error detected, close socket then.
			closesocket(cls.sockettcp);
			cls.sockettcp = INVALID_SOCKET;
			return false;
		}
	}

	cls.tcpinlen += ret;

	if (cls.tcpinlen < 2)
		return false;

	message->cursize = BigShort(*(short*)cls.tcpinbuffer);
	if (message->cursize >= message->maxsize)
	{
		closesocket(cls.sockettcp);
		cls.sockettcp = INVALID_SOCKET;
		Con_Printf ("Warning: Oversize packet from %s\n", NET_AdrToString (cls.sockettcpdest));
		return false;
	}

	if (message->cursize + 2 > cls.tcpinlen)
	{
		//not enough buffered to read a packet out of it.
		return false;
	}

	memcpy(message->data, cls.tcpinbuffer + 2, message->cursize);
	memmove(cls.tcpinbuffer, cls.tcpinbuffer + message->cursize + 2, cls.tcpinlen - (message->cursize + 2));
	cls.tcpinlen -= message->cursize + 2;

	*from = cls.sockettcpdest;

	return true;
}
#endif

#ifndef CLIENTONLY
qbool NET_GetTCPPacket_SV (netsrc_t netsrc, netadr_t *from, sizebuf_t *message)
{
	int ret;
	float timeval = Sys_DoubleTime();
	svtcpstream_t *st = NULL, *next = NULL;

	if (netsrc != NS_SERVER)
		return false;

	for (st = svs.tcpstreams; st; st = next)
	{
		next = st->next;

		*from = st->remoteaddr;

		if (st->socketnum == INVALID_SOCKET || st->drop)
		{
			sv_tcp_connection_free(st, true); // free and unlink
			continue;
		}

		//due to the above checks about invalid sockets, the socket is always open for st below.

		// check for client timeout
		if (st->timeouttime < timeval)
		{
			st->drop = true;
			continue;
		}

		ret = recv(st->socketnum, st->inbuffer+st->inlen, sizeof(st->inbuffer)-st->inlen, 0);
		if (ret == 0)
		{
			// connection closed
			st->drop = true;
			continue;
		}
		else if (ret == -1)
		{
			int err = qerrno;

			if (err == EWOULDBLOCK)
			{
				ret = 0; // it's OK
			}
			else
			{
				if (err == ECONNABORTED || err == ECONNRESET)
				{
					Con_DPrintf ("Connection lost or aborted\n"); //server died/connection lost.
				}
				else
				{
					Con_DPrintf ("NET_GetPacket: Error (%i): %s\n", err, strerror(err));
				}

				st->drop = true;
				continue;
			}
		}
		else
		{
			// update timeout
			st->timeouttime = Sys_DoubleTime() + 10;
		}

		st->inlen += ret;

		if (st->waitingforprotocolconfirmation)
		{
			// not enough data
			if (st->inlen < 6)
				continue;

			if (strncmp(st->inbuffer, "qizmo\n", 6))
			{
				Con_Printf ("Unknown TCP client\n");
				st->drop = true;
				continue;
			}

			// remove leading 6 bytes
			memmove(st->inbuffer, st->inbuffer+6, st->inlen - (6));
			st->inlen -= 6;
			// confirmed
			st->waitingforprotocolconfirmation = false;
		}

		// need two bytes for packet len
		if (st->inlen < 2)
			continue;

		message->cursize = BigShort(*(short*)st->inbuffer);
		if (message->cursize < 0)
		{
			message->cursize = 0;
			Con_Printf ("Warning: malformed message from %s\n", NET_AdrToString (*from));
			st->drop = true;
			continue;
		}

		if (message->cursize >= message->maxsize)
		{
			Con_Printf ("Warning: Oversize packet from %s\n", NET_AdrToString (*from));
			st->drop = true;
			continue;
		}

		if (message->cursize + 2 > st->inlen)
		{
			//not enough buffered to read a packet out of it.
			continue;
		}

		memcpy(message->data, st->inbuffer + 2, message->cursize);
		memmove(st->inbuffer, st->inbuffer + message->cursize + 2, st->inlen - (message->cursize + 2));
		st->inlen -= message->cursize + 2;

		return true; // we got packet!
	}

	return false; // no packet received.
}
#endif

qbool NET_GetPacketEx (netsrc_t netsrc, qbool delay)
{
#ifndef SERVERONLY
	if (delay)
		return NET_PacketQueueRemove(&delay_queue_get, &net_message, &net_from);
#endif

#ifndef SERVERONLY
	if (NET_GetLoopPacket(netsrc, &net_from, &net_message))
		return true;
#endif

	if (NET_GetUDPPacket(netsrc, &net_from, &net_message))
		return true;

// TCPCONNECT -->
#ifndef SERVERONLY
	if (netsrc == NS_CLIENT && cls.sockettcp != INVALID_SOCKET && NET_GetTCPPacket_CL(netsrc, &net_from, &net_message))
		return true;
#endif

#ifndef CLIENTONLY
	if (netsrc == NS_SERVER && svs.tcpstreams && NET_GetTCPPacket_SV(netsrc, &net_from, &net_message))
		return true;
#endif
// <--TCPCONNECT

	return false;
}

qbool NET_GetPacket (netsrc_t netsrc)
{
#ifdef SERVERONLY
	qbool delay = false;
#else
	qbool delay = (netsrc == NS_CLIENT && (cl_delay_packet.integer || cl_delay_packet_target.integer));
#endif

	return NET_GetPacketEx (netsrc, delay);
}

//=============================================================================

#ifndef SERVERONLY
qbool NET_SendTCPPacket_CL (netsrc_t netsrc, int length, void *data, netadr_t to)
{
	unsigned short slen;

	if (netsrc != NS_CLIENT || cls.sockettcp == INVALID_SOCKET)
		return false;

	if (!NET_CompareAdr(to, cls.sockettcpdest))
		return false;

	// this goes to the server so send it via TCP.
	slen = BigShort((unsigned short)length);
	// FIXME: CHECK send() result, we use NON BLOCKIN MODE, FFS!
	send(cls.sockettcp, (char*)&slen, sizeof(slen), 0);
	send(cls.sockettcp, data, length, 0);

	return true;
}
#endif

#ifndef CLIENTONLY
qbool NET_SendTCPPacket_SV (netsrc_t netsrc, int length, void *data, netadr_t to)
{
	svtcpstream_t *st;

	if (netsrc != NS_SERVER)
		return false;

	for (st = svs.tcpstreams; st; st = st->next)
	{
		if (st->socketnum == INVALID_SOCKET)
			continue;

		if (NET_CompareAdr(to, st->remoteaddr))
		{
			int sent;
			unsigned short slen = BigShort((unsigned short)length);

			if (st->outlen + length + sizeof(slen) >= sizeof(st->outbuffer))
			{
				// not enough space, we overflowed
				break; // well, quake should resist to some packet lost.. so we just drop that packet.
			}

			// put data in buffer
			memmove(st->outbuffer + st->outlen, (char*)&slen, sizeof(slen));
			st->outlen += sizeof(slen);
			memmove(st->outbuffer + st->outlen, data, length);
			st->outlen += length;

			sent = send(st->socketnum, st->outbuffer, st->outlen, 0);

			if (sent == 0)
			{
				// think it's OK
			}
			else if (sent > 0) //we put some data through
			{ //move up the buffer
				st->outlen -= sent;
				memmove(st->outbuffer, st->outbuffer + sent, st->outlen);
			}
			else
			{ //error of some kind. would block or something
				if (qerrno != EWOULDBLOCK && qerrno != EAGAIN)
				{
					st->drop = true; // something cricial, drop than
				}
			}

			break;
		}
	}

	// 'st' will be not zero, if we found 'to' in 'svs.tcpstreams'.
	// That does not mean we actualy send packet, since there case of overflow, but who cares,
	// all is matter that we found such 'to' and tried to send packet.
	return !!st;
}
#endif

qbool NET_SendUDPPacket (netsrc_t netsrc, int length, void *data, netadr_t to)
{
	struct sockaddr_storage addr;
	int ret;
	int socket = NET_GetSocket(netsrc, false);

	if (socket == INVALID_SOCKET)
		return false;

	NetadrToSockadr (&to, &addr);

	ret = sendto (socket, data, length, 0, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
	if (ret == -1)
	{
		int err = qerrno;

		if (err == EWOULDBLOCK || err == ECONNREFUSED || err == EADDRNOTAVAIL)
			; // nothing
		else
			Con_Printf ("NET_SendPacket: sendto: (%i): %s %i\n", err, strerror(err), socket);
	}

	return true;
}

void NET_SendPacketEx (netsrc_t netsrc, int length, void *data, netadr_t to, qbool delay)
{
#ifndef SERVERONLY
	if (delay)
	{
		NET_PacketQueueAdd (&delay_queue_send, data, length, to);
		return;
	}
#endif

#ifndef SERVERONLY
	if (to.type == NA_LOOPBACK)
	{
		NET_SendLoopPacket (netsrc, length, data, to);
		return;
	}
#endif

// TCPCONNECT -->
#ifndef SERVERONLY
	if (netsrc == NS_CLIENT && cls.sockettcp != INVALID_SOCKET && NET_SendTCPPacket_CL(netsrc, length, data, to))
		return;
#endif

#ifndef CLIENTONLY
	if (netsrc == NS_SERVER && svs.tcpstreams && NET_SendTCPPacket_SV(netsrc, length, data, to))
		return;
#endif
// <--TCPCONNECT

	NET_SendUDPPacket(netsrc, length, data, to);
}

void NET_SendPacket (netsrc_t netsrc, int length, void *data, netadr_t to)
{
#ifdef SERVERONLY
	qbool delay = false;
#else
	qbool delay = (netsrc == NS_CLIENT && cl_delay_packet.integer);
#endif

	NET_SendPacketEx (netsrc, length, data, to, delay);
}

#ifndef SERVERONLY
qbool CL_UnqueOutputPacket(qbool sendall)
{
	double time = 0;
	cl_delayed_packet_t* packet = NULL;
	qbool released = false;

	while ((packet = NET_PacketQueuePeek(&delay_queue_send)))
	{
		if (!time) {
			time = Sys_DoubleTime();
		}

		// Not yet ready to send
		if (packet->time > time && !sendall)
			break;

		// ok, send it
		NET_SendPacketEx(NS_CLIENT, packet->length, packet->data, packet->addr, false);

		// mark as unused slot
		NET_PacketQueueAdvance(&delay_queue_send);

		released = true;
	}

	return released;
}
#endif

//=============================================================================

qbool TCP_Set_KEEPALIVE(int sock)
{
	int		iOptVal = 1;

	if (sock == INVALID_SOCKET) {
		Con_Printf("TCP_Set_KEEPALIVE: invalid socket\n");
		return false;
	}

	if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void*)&iOptVal, sizeof(iOptVal)) == SOCKET_ERROR) {
		Con_Printf ("TCP_Set_KEEPALIVE: setsockopt: (%i): %s\n", qerrno, strerror (qerrno));
		return false;
	}

#if defined(__linux__)

//	The time (in seconds) the connection needs to remain idle before TCP starts sending keepalive probes, 
//  if the socket option SO_KEEPALIVE has been set on this socket.

	iOptVal = 60;

	if (setsockopt(sock, SOL_TCP, TCP_KEEPIDLE, (void*)&iOptVal, sizeof(iOptVal)) == -1) {
		Con_Printf ("TCP_Set_KEEPALIVE: setsockopt TCP_KEEPIDLE: (%i): %s\n", qerrno, strerror(qerrno));
		return false;
	}

//  The time (in seconds) between individual keepalive probes.
	iOptVal = 30;

	if (setsockopt(sock, SOL_TCP, TCP_KEEPINTVL, (void*)&iOptVal, sizeof(iOptVal)) == -1) {
		Con_Printf ("TCP_Set_KEEPALIVE: setsockopt TCP_KEEPINTVL: (%i): %s\n", qerrno, strerror(qerrno));
		return false;
	}

//  The maximum number of keepalive probes TCP should send before dropping the connection. 
	iOptVal = 6;

	if (setsockopt(sock, SOL_TCP, TCP_KEEPCNT, (void*)&iOptVal, sizeof(iOptVal)) == -1) {
		Con_Printf ("TCP_Set_KEEPALIVE: setsockopt TCP_KEEPCNT: (%i): %s\n", qerrno, strerror(qerrno));
		return false;
	}
#else
	// FIXME: windows, bsd etc...
#endif

	return true;
}

int TCP_OpenStream(netadr_t remoteaddr)
{
	unsigned long _true = true;
	int newsocket;
	int temp;
	struct sockaddr_storage qs;

	NetadrToSockadr(&remoteaddr, &qs);
	temp = sizeof(struct sockaddr_in);

	if ((newsocket = socket(((struct sockaddr_in*)&qs)->sin_family, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {
		Con_Printf("TCP_OpenStream: socket: (%i): %s\n", qerrno, strerror(qerrno));
		return INVALID_SOCKET;
	}

	// Set socket to non-blocking
#if !defined(_WIN32)
	if ((fcntl(newsocket, F_SETFL, O_NONBLOCK)) == -1) { // O'Rly?! @@@
		Con_Printf("TCP_OpenStream: fcntl: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}
#endif

	if (ioctlsocket(newsocket, FIONBIO, &_true) == -1) { // make asynchronous
		Con_Printf("TCP_OpenStream: ioctl: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}

	if (connect (newsocket, (struct sockaddr *)&qs, temp) == INVALID_SOCKET) {
		// Socket is non-blocking, so check if the error is just because it would block
		if (qerrno == EZ_TCP_WOULDBLOCK) {
			struct timeval t;
			fd_set socket_set;

			t.tv_sec = bound(MIN_TCP_TIMEOUT, net_tcp_timeout.integer, MAX_TCP_TIMEOUT) / 1000;
			t.tv_usec = (bound(MIN_TCP_TIMEOUT, net_tcp_timeout.integer, MAX_TCP_TIMEOUT) % 1000) * 1000;

			FD_ZERO(&socket_set);
			FD_SET(newsocket, &socket_set);

			if (select(newsocket + 1, NULL, &socket_set, NULL, &t) <= 0) {
				Con_Printf("TCP_OpenStream: connection timeout\n");
				closesocket(newsocket);
				return INVALID_SOCKET;
			}
			else {
				int error = SOCKET_ERROR;
#ifdef _WIN32
				int len = sizeof(error);
#else
				socklen_t len = sizeof(error);
#endif

				getsockopt(newsocket, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
				if (error != 0) {
					Con_Printf("TCP_OpenStream: connect: (%i): %s\n", error, strerror(error));
					closesocket(newsocket);
					return INVALID_SOCKET;
				}
			}
		}
		else {
			Con_Printf("TCP_OpenStream: connect: (%i): %s\n", qerrno, strerror(qerrno));
			closesocket(newsocket);
			return INVALID_SOCKET;
		}
	}

	return newsocket;
}

int TCP_OpenListenSocket (unsigned short int port)
{
	int newsocket;
	struct sockaddr_in address = { 0 };
	unsigned long nonblocking = true;
	int i;

	if ((newsocket = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {
		Con_Printf ("TCP_OpenListenSocket: socket: (%i): %s\n", qerrno, strerror(qerrno));
		return INVALID_SOCKET;
	}

#ifndef _WIN32
	if ((fcntl (newsocket, F_SETFL, O_NONBLOCK)) == -1) { // O'Rly?! @@@
		Con_Printf ("TCP_OpenListenSocket: fcntl: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}
#endif

	if (ioctlsocket (newsocket, FIONBIO, &nonblocking) == -1) { // make asynchronous
		Con_Printf ("TCP_OpenListenSocket: ioctl: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}

#ifdef __APPLE__
	address.sin_len = sizeof(address); // apple are special...
#endif
	address.sin_family = AF_INET;

	// check for interface binding option
	if ((i = COM_CheckParm(cmdline_param_net_ipaddress)) != 0 && i < COM_Argc()) {
		address.sin_addr.s_addr = inet_addr(COM_Argv(i+1));
		Con_DPrintf ("Binding to IP Interface Address of %s\n", inet_ntoa(address.sin_addr));
	}
	else {
		address.sin_addr.s_addr = INADDR_ANY;
	}
	
	if (port == PORT_ANY) {
		address.sin_port = 0;
	}
	else {
		address.sin_port = htons(port);
	}

	if (bind (newsocket, (void *)&address, sizeof(address)) == -1) {
		Con_Printf ("TCP_OpenListenSocket: bind: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}

	if (listen (newsocket, TCP_LISTEN_BACKLOG) == INVALID_SOCKET) {
		Con_Printf ("TCP_OpenListenSocket: listen: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}

	if (!TCP_Set_KEEPALIVE(newsocket)) {
		Con_Printf ("TCP_OpenListenSocket: TCP_Set_KEEPALIVE: failed\n");
		closesocket(newsocket);
		return INVALID_SOCKET;
	}

	return newsocket;
}

int UDP_OpenSocket (unsigned short int port)
{
	int newsocket;
	struct sockaddr_in address;
	unsigned long _true = true;
	int i;

	if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {
		Con_Printf ("UDP_OpenSocket: socket: (%i): %s\n", qerrno, strerror(qerrno));
		return INVALID_SOCKET;
	}

#ifndef _WIN32
	if ((fcntl (newsocket, F_SETFL, O_NONBLOCK)) == -1) { // O'Rly?! @@@
		Con_Printf ("UDP_OpenSocket: fcntl: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}
#endif

	if (ioctlsocket (newsocket, FIONBIO, &_true) == -1) { // make asynchronous
		Con_Printf ("UDP_OpenSocket: ioctl: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}

	address.sin_family = AF_INET;

	// check for interface binding option
	if ((i = COM_CheckParm(cmdline_param_net_ipaddress)) != 0 && i < COM_Argc()) {
		address.sin_addr.s_addr = inet_addr(COM_Argv(i+1));
		Con_DPrintf ("Binding to IP Interface Address of %s\n", inet_ntoa(address.sin_addr));
	}
	else {
		address.sin_addr.s_addr = INADDR_ANY;
	}

	if (port == PORT_ANY) {
		address.sin_port = 0;
	}
	else {
		address.sin_port = htons(port);
	}

	if (bind (newsocket, (void *)&address, sizeof(address)) == -1) {
		Con_Printf ("UDP_OpenSocket: bind: (%i): %s\n", qerrno, strerror(qerrno));
		closesocket(newsocket);
		return INVALID_SOCKET;
	}

	return newsocket;
}

qbool NET_Sleep(int msec, qbool stdinissocket)
{
	struct timeval	timeout;
	fd_set			fdset;
	qbool			stdin_ready = false;
	int				maxfd = 0;

	FD_ZERO (&fdset);

	if (stdinissocket) {
		FD_SET (0, &fdset); // stdin is processed too (tends to be socket 0)
		maxfd = max(0, maxfd);
	}

#ifndef CLIENTONLY
	if (svs.socketip != INVALID_SOCKET) {
		FD_SET(svs.socketip, &fdset); // network socket
		maxfd = max(svs.socketip, maxfd);
	}
#endif

	timeout.tv_sec = msec/1000;
	timeout.tv_usec = (msec%1000)*1000;
	switch (select(maxfd + 1, &fdset, NULL, NULL, &timeout))
	{
		case -1:
		case  0:
			break;
		default:
			if (stdinissocket) {
				stdin_ready = FD_ISSET(0, &fdset);
			}
			break;
	}

	return stdin_ready;
}

void NET_GetLocalAddress (int socket, netadr_t *out)
{
	char buff[512];
	struct sockaddr_storage address;
	size_t namelen;
	netadr_t adr = {0};
	qbool notvalid = false;

	strlcpy (buff, "localhost", sizeof (buff));
	gethostname (buff, sizeof (buff));
	buff[sizeof(buff) - 1] = 0;

	if (!NET_StringToAdr (buff, &adr))	//urm
		NET_StringToAdr ("127.0.0.1", &adr);

	namelen = sizeof(address);
	if (getsockname (socket, (struct sockaddr *)&address, (socklen_t *)&namelen) == -1) {
		notvalid = true;
		NET_StringToSockaddr("0.0.0.0", (struct sockaddr_storage *)&address);
//		Sys_Error ("NET_Init: getsockname:", strerror(qerrno));
	}

	SockadrToNetadr(&address, out);
	if (!*(int*)out->ip)	//socket was set to auto
		*(int *)out->ip = *(int *)adr.ip;	//change it to what the machine says it is, rather than the socket.

#ifndef SERVERONLY
	if (notvalid)
		Com_Printf_State (PRINT_FAIL, "Couldn't detect local ip\n");
	else
		Com_Printf_State (PRINT_OK, "IP address %s\n", NET_AdrToString (*out));
#endif
}

void NET_Init (void)
{
#ifdef _WIN32
	WORD wVersionRequested;
	int r;

	wVersionRequested = MAKEWORD(1, 1);
	r = WSAStartup (wVersionRequested, &winsockdata);
	if (r)
		Sys_Error ("Winsock initialization failed.");
#endif

	// init the message buffer
	SZ_Init (&net_message, net_message_buffer, sizeof(net_message_buffer));

	Con_DPrintf("UDP Initialized\n");

#ifndef SERVERONLY
	cls.socketip = INVALID_SOCKET;
// TCPCONNECT -->
	cls.sockettcp = INVALID_SOCKET;
// <--TCPCONNECT

	Cvar_Register(&cl_net_clientport);
	Cvar_Register(&net_tcp_timeout);

	Cvar_Register(&cl_portpingprobe_delay);
	Cvar_Register(&cl_portpingprobe_enable);
	Cvar_Register(&cl_portpingprobe_probes);
	Cvar_Register(&cl_portpingprobe_port_probes);
	NET_SetPortPingProbeStatus(PORTPINGPROBE_READY);

	delay_queue_send.outgoing = true;
#endif

#ifndef CLIENTONLY
	Cvar_Register (&sv_local_addr);

	svs.socketip = INVALID_SOCKET;
// TCPCONNECT -->
	svs.sockettcp = INVALID_SOCKET;
// <--TCPCONNECT
#endif

#ifdef SERVERONLY
	// As client+server we init it in SV_SpawnServer().
	// As serveronly we do it here.
	NET_InitServer();
#endif
}

void NET_Shutdown (void)
{
#ifndef CLIENTONLY
	NET_CloseServer();
#endif

#ifndef SERVERONLY
	NET_CloseClient();
#endif

#ifdef _WIN32
	WSACleanup ();
#endif
}

#ifndef SERVERONLY
static void cl_net_clientport_changed(cvar_t* var, char* value, qbool* cancel)
{
	int new_socket = INVALID_SOCKET;
	int new_port = atoi(value);
	qbool set_auto = false;

	// No change
	if (new_port == var->integer) {
		*cancel = true;
		return;
	}

#ifndef CLIENTONLY
	// FIXME: Technically this could be changed on the command line or dynamically allocated
	//        no damage done if they do this when disconnected 
	if (new_port == PORT_SERVER) {
		*cancel = true;
		Con_Printf("Port %i is reserved for the internal server.\n", new_port);
		return;
	}
#endif

	// In theory you could be connected to mvd...
	if (cls.state != ca_disconnected) {
		Con_Printf("You must be disconnected to change %s.\n", var->name);
		*cancel = true;
		return;
	}

	if (new_port > 0) {
		new_socket = UDP_OpenSocket(new_port);

		if (new_socket == INVALID_SOCKET) {
			Con_Printf("Unable to open new socket on port %d\n", new_port);
			*cancel = true;
			return;
		}
	}
	if (new_socket == INVALID_SOCKET) {
		new_socket = UDP_OpenSocket(PORT_ANY);
		set_auto = true;
	}
	
	if (new_socket == INVALID_SOCKET) {
		Con_Printf("Unable to open new socket\n");
		*cancel = true;
		return;
	}

	if (cls.socketip != INVALID_SOCKET) {
		closesocket(cls.socketip);
	}

	cls.socketip = new_socket;
	NET_GetLocalAddress(cls.socketip, &net_local_cl_ipadr);
	if (set_auto) {
		Com_Printf("Client port allocated: %i\n", ntohs(net_local_cl_ipadr.port));
		Cvar_AutoSetInt(var, ntohs(net_local_cl_ipadr.port));
	}
	else {
		Cvar_AutoReset(var);
	}
}

// This is called after config loaded
void NET_InitClient(void)
{
	int port = cl_net_clientport.integer;
	qbool set_auto = false;
	qbool set = (cls.socketip == INVALID_SOCKET);
	int p;

	// Allow user to override the config file
	p = COM_CheckParm(cmdline_param_net_clientport);
	if (p && p < COM_Argc()) {
		port = atoi(COM_Argv(p + 1));
		set_auto = true;
	}

	if (cls.socketip == INVALID_SOCKET && port > 0)
		cls.socketip = UDP_OpenSocket(port);

	if (cls.socketip == INVALID_SOCKET) {
		cls.socketip = UDP_OpenSocket(PORT_ANY); // any dynamic port
		set_auto = true;
	}

	if (cls.socketip == INVALID_SOCKET) {
		Sys_Error("Couldn't allocate client socket");
		return;
	}

	// init the message buffer
	SZ_Init(&net_message, net_message_buffer, sizeof(net_message_buffer));

	// determine my name & address
	NET_GetLocalAddress(cls.socketip, &net_local_cl_ipadr);
	if (set) {
		if (set_auto) {
			Cvar_AutoSetInt(&cl_net_clientport, ntohs(net_local_cl_ipadr.port));
		}
		else {
			Cvar_AutoReset(&cl_net_clientport);
		}
	}

	Com_Printf_State(PRINT_OK, "Client port initialized: %i\n", ntohs(net_local_cl_ipadr.port));
}

void NET_CloseClient (void)
{
	if (cls.socketip != INVALID_SOCKET) {
		closesocket(cls.socketip);
		cls.socketip = INVALID_SOCKET;
	}

// TCPCONNECT -->
	// FIXME: is it OK? Probably we should send disconnect?
	if (cls.sockettcp != INVALID_SOCKET) {
		closesocket(cls.sockettcp);
		cls.sockettcp = INVALID_SOCKET;
	}
// <--TCPCONNECT
}

qbool CL_QueInputPacket(void)
{
	if (!NET_GetPacketEx(NS_CLIENT, false))
		return false;

	return NET_PacketQueueAdd(&delay_queue_get, net_message.data, net_message.cursize, net_from);
}

void CL_ClearQueuedPackets(void)
{
	memset(&delay_queue_get, 0, sizeof(delay_queue_get));
	memset(&delay_queue_send, 0, sizeof(delay_queue_send));
	delay_queue_send.outgoing = true;
}
#endif

#ifndef CLIENTONLY
//
// Open server TCP port.
// NOTE: Zero port will actually close already opened port.
//
void NET_InitServer_TCP(unsigned short int port)
{
	// close socket first.
	if (svs.sockettcp != INVALID_SOCKET)
	{
		Con_Printf("Server TCP port closed\n");
		closesocket(svs.sockettcp);
		svs.sockettcp = INVALID_SOCKET;
		net_local_sv_tcpipadr.type = NA_INVALID;
	}

	if (port)
	{
		svs.sockettcp = TCP_OpenListenSocket (port);

		if (svs.sockettcp != INVALID_SOCKET)
		{
			// get local address.
			NET_GetLocalAddress (svs.sockettcp, &net_local_sv_tcpipadr);
			Con_Printf("Opening server TCP port %u\n", (unsigned int)port);
		}
		else
		{
			Con_Printf("Failed to open server TCP port %u\n", (unsigned int)port);
		}
	}
}

void NET_InitServer (void)
{
	int port = PORT_SERVER;
	int p;

	p = COM_CheckParm (cmdline_param_net_serverport);
	if (p && p < COM_Argc()) {
		port = atoi(COM_Argv(p+1));
	}

	if (svs.socketip == INVALID_SOCKET) {
		svs.socketip = UDP_OpenSocket (port);
	}

	if (svs.socketip != INVALID_SOCKET) {
		NET_GetLocalAddress (svs.socketip, &net_local_sv_ipadr);
		Cvar_SetROM (&sv_local_addr, NET_AdrToString (net_local_sv_ipadr));
	}
	else {
		// FIXME: is it right???
		Cvar_SetROM (&sv_local_addr, "");
	}

	if (svs.socketip == INVALID_SOCKET) {
#ifdef SERVERONLY
		Sys_Error
#else
		Con_Printf
#endif
			("WARNING: Couldn't allocate server socket\n");
	}

#ifndef SERVERONLY
	// init the message buffer
	SZ_Init (&net_message, net_message_buffer, sizeof(net_message_buffer));
#endif
}

void NET_CloseServer (void)
{
	if (svs.socketip != INVALID_SOCKET) {
		closesocket(svs.socketip);
		svs.socketip = INVALID_SOCKET;
	}

	net_local_sv_ipadr.type = NA_LOOPBACK; // FIXME: why not NA_INVALID?

// TCPCONNECT -->
	NET_InitServer_TCP(0);
// <--TCPCONNECT
}
#endif

static void cl_portpingprobe_probes_changed(cvar_t *var, char *val, qbool *cancel)
{
	int probes = Q_atoi(val);

	if (probes < 1 || probes > 1000)
	{
		Com_Printf("The number of probes needs to be between 1 and 1000.\n");
		*cancel = true;
	}
}

static void cl_portpingprobe_port_probes_changed(cvar_t *var, char *val, qbool *cancel)
{
	int probes = Q_atoi(val);

	if (probes < 1 || probes > 5)
	{
		Com_Printf("The number of port probes needs to be between 1 and 5.\n");
		*cancel = true;
	}
}

static double NET_PortPing(const struct sockaddr_in *srv_adr, const int probe_port) {
	static char payload[] = {0xff, 0xff, 0xff, 0xff, 'p', 'i', 'n', 'g'};
	static struct timeval timeout = {1, 0};
	struct sockaddr_in cli_addr;
	double start;
	char buf;
	int sock, ret = -1;
#ifdef _WIN32
	static int timeout_ms = -1;

	if (timeout_ms == -1)
	{
		timeout_ms = timeout.tv_sec * 1000 + timeout.tv_usec / 1000;
	}
#endif

	if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
	{
		Com_Printf("NET_PortPing: Unable to initialize socket\n");
		return -1;
	}

#ifdef _WIN32
	if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout_ms, sizeof(timeout_ms)) < 0)
#else
	if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0)
#endif
	{
		Com_Printf("NET_PortPing: Unable to set timeout on socket\n");
		goto cleanup;
	}

	memset(&cli_addr, 0, sizeof(cli_addr));
	cli_addr.sin_family = AF_INET;
	cli_addr.sin_addr.s_addr = INADDR_ANY;
	cli_addr.sin_port = htons(probe_port);

	if (bind(sock, (struct sockaddr *)&cli_addr, sizeof(cli_addr)) < 0)
	{
		Com_DPrintf("NET_PortPing: Port is already in use: %d\n", probe_port);
		goto cleanup;
	}

	start = Sys_DoubleTime();

	if ((ret = sendto(sock, payload, sizeof(payload), 0, (struct sockaddr *)srv_adr, sizeof(*srv_adr))) < 0)
	{
		Com_Printf("NET_PortPing: Unable to send data to the server from port %d\n", probe_port);
		goto cleanup;
	}

	// If this fails, it is an indication that we are being rate-limited by
	// a router along the way, so we'll pause for a while before proceeding.
	if ((ret = recvfrom(sock, &buf, sizeof(buf), 0, NULL, NULL)) <= 0)
	{
		Com_DPrintf("NET_PortPing: No data received from the server\n");
		Sys_MSleep(100);
		ret = -1;
	}

cleanup:
	closesocket(sock);

	return ret == -1 ? ret : Sys_DoubleTime() - start;
}

static int NET_PortPingProbeWorker(void *data)
{
	portpingprobe_worker_args_t *args = (portpingprobe_worker_args_t *)data;
	double rtt;
	int i, port;
	int *ports = Q_malloc(args->num_ports * sizeof(int));
	int num_probes = args->num_ports * cl_portpingprobe_port_probes.integer;

	Com_DPrintf("[%d]: Generating %d random ports\n", args->thread_id, args->num_ports);
	for (i = 0; i < args->num_ports; i++)
	{
		ports[i] = rand() % (65536 - 1024) + 1024;
	}

	Com_DPrintf("[%d]: Launching %d probes\n", args->thread_id, num_probes);
	for (i = 0; i < num_probes; i++)
	{
		port = ports[i % args->num_ports];
		rtt = NET_PortPing(args->addr, port);
		args->results[i].port = port;
		args->results[i].rtt = rtt;

		// If the client issues a new connection while a probe is in
		// progress or disconnects, we'll abort and exit gracefully.
		if (NET_GetPortPingProbeStatus() == PORTPINGPROBE_ABORT)
		{
			goto cleanup;
		}

		// If set, we'll sleep for delay number of ms before moving on
		// to the next iteration.
		if (cl_portpingprobe_delay.integer > 0)
		{
			Sys_MSleep(cl_portpingprobe_delay.integer);
		}

		Com_DPrintf("[%d]: Probing port %d: RTT = %f ms\n", args->thread_id, port, rtt*1000.0);

		// Increment the progress counter.
		SDL_AtomicIncRef(&portpingprobe_progress);
	}

cleanup:
	free(args);
	free(ports);

	return 0;
}

static SDL_Thread **NET_PortPingProbeInitWorkers(struct sockaddr_in *addr, int num_threads, portpingprobe_t *results)
{
	SDL_Thread **workers = Q_malloc(sizeof(SDL_Thread *) * num_threads);
	portpingprobe_worker_args_t *args;
	int i, j, num_probes, remaining_probes;

	// Calculate the number of probes each thread should perform.
	num_probes = num_threads == 1
		? cl_portpingprobe_probes.integer
		: cl_portpingprobe_probes.integer / num_threads;
	remaining_probes = num_threads == 1 ? 0 : cl_portpingprobe_probes.integer % num_threads;

	for (i = 0; i < num_threads; i++)
	{
		// The arguments we allocate here will be freed by the
		// NET_PortPingProbeWorker when it is finished. If we can't
		// create the thread, we'll free the current arguments here and
		// let the cleanup handle the previously created workers.
		args = Q_malloc(sizeof(portpingprobe_worker_args_t));
		args->addr = addr;
		args->thread_id = i;
		args->results = &results[i * num_probes * cl_portpingprobe_port_probes.integer];
		args->num_ports = num_probes + (i == num_threads - 1 ? remaining_probes : 0);

		workers[i] = Sys_CreateThread(NET_PortPingProbeWorker, args);
		if (!workers[i])
		{
			Com_Printf("NET_PortPingProbeInitWorkers: Failed to create worker thread %d\n", i);
			Q_free(args);
			goto cleanup;
		}
	}

	return workers;

cleanup:
	// If we've started some threads, we'll need to push the ABORT signal so
	// they are exited before we proceed with further cleanup.
	if (i > 0)
	{
		NET_SetPortPingProbeStatus(PORTPINGPROBE_ABORT);

		for (j = 0; j < i; j++)
		{
			SDL_WaitThread(workers[j], NULL);
		}
	}

	Q_free(workers);

	return NULL;
}

static int NET_PortPingProbeOrchestrator(void *data)
{
	portpingprobe_orchestrator_args_t *args = (portpingprobe_orchestrator_args_t *)data;
	portpingprobe_status_t status = PORTPINGPROBE_READY;
	portpingprobe_t *results = NULL;
	SDL_Thread **workers = NULL;
	struct sockaddr_in addr;
	netadr_t net_addr;
	double best_rtt = 100000;
	int best_port = cl_net_clientport.integer;
	int num_cores = SDL_GetCPUCount();
	int num_threads = num_cores - 4;
	int i;

	if (num_threads < 1)
	{
		num_threads = 1;
	}

	// Ensure that the target address is valid before we proceed.
	if (!NET_StringToAdr(args->target_addr, &net_addr))
	{
		Com_Printf("NET_PortPingProbeOrchestrator: Invalid address %s\n", args->target_addr);
		goto cleanup;
	}
	memset(&addr, 0, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_port = net_addr.port == 0 ? htons(27500) : net_addr.port;
	memcpy(&addr.sin_addr.s_addr, net_addr.ip, 4);

	// Allocate memory for the probe results.
	results = Q_malloc(sizeof(portpingprobe_t) * cl_portpingprobe_probes.integer * cl_portpingprobe_port_probes.integer);

	// Initialize the worker threads.
	workers = NET_PortPingProbeInitWorkers(&addr, num_threads, results);
	if (workers == NULL)
	{
		goto cleanup;
	}

	// Reset the progress counter. The worker threads will increment the
	// counter during the probing, and the results will be rendered using
	// the progress bar from console.c
	SDL_AtomicSet(&portpingprobe_progress, 0);

	Com_Printf("Probing %s to find the best source port (%d probes, %d threads, %d %s per port)\n",
		args->target_addr, cl_portpingprobe_probes.integer, num_threads,
		cl_portpingprobe_port_probes.integer,
		cl_portpingprobe_port_probes.integer == 1 ? "probe" : "probes");

	// Wait for the worker threads to finish; they will either finish when
	// all probes have been completed or if they are aborted by the user.
	for (i = 0; i < num_threads; i++)
	{
		SDL_WaitThread(workers[i], NULL);
	}

	// The probe was aborted. Let's clean up immediately and end the
	// orchestrator.
	if (NET_GetPortPingProbeStatus() == PORTPINGPROBE_ABORT)
	{
		Com_Printf("Port ping probe aborted\n");
		goto cleanup;
	}

	// Iterate over the results and select the port with the lowest latency.
	for (i = 0; i < cl_portpingprobe_probes.integer * cl_portpingprobe_port_probes.integer; i++)
	{
		Com_DPrintf("Results: index: %d, port: %d RTT: %f\n",
			i, results[i].port, results[i].rtt);

		if (results[i].rtt != -1 && results[i].rtt < best_rtt)
		{
			best_port = results[i].port;
			best_rtt = results[i].rtt;
		}
	}

	Com_Printf("Connecting to %s using source port %d (%.2f ms)\n",
		args->target_addr, best_port, best_rtt*1000.0);
	Cvar_SetValue(&cl_net_clientport, best_port);
	Cbuf_AddText(va("connect %s\n", args->original_addr));

	status = PORTPINGPROBE_COMPLETED;

cleanup:
	Q_free(workers);
	Q_free(results);
	Q_free(args->target_addr);
	Q_free(args->original_addr);
	Q_free(args);

	NET_SetPortPingProbeStatus(status);

	return 0;
}

qbool IsPortPingProbeEnabled(void)
{
	return cl_portpingprobe_enable.integer;
}

void NET_PortPingProbe(const char *target_addr, const char *original_addr)
{
	portpingprobe_orchestrator_args_t *args;

	// Ensure we are ready to start a new probe before we proceed.
	if (NET_GetPortPingProbeStatus() != PORTPINGPROBE_READY)
	{
		return;
	}

	// Set status to PROBING to ensure we aren't launching any more probes
	// when we're already working on one.
	NET_SetPortPingProbeStatus(PORTPINGPROBE_PROBING);

	// We need to allocate and copy the target and original addresses since
	// they will go out of scope as soon as the connect function ends. We'll
	// free the allocations once the worker function completes.
	args = Q_malloc(sizeof(portpingprobe_orchestrator_args_t));
	args->target_addr = Q_strdup(target_addr);
	args->original_addr = Q_strdup(original_addr);

	if (Sys_CreateDetachedThread(NET_PortPingProbeOrchestrator, (void *)args) < 0)
	{
		Com_Printf("NET_PortPingProbe: Unable to launch orchestrator thread\n");
	}
}

void NET_SetPortPingProbeStatus(const portpingprobe_status_t status)
{
	SDL_AtomicSet(&portpingprobe_status, (int)status);
}

portpingprobe_status_t NET_GetPortPingProbeStatus(void)
{
	return (portpingprobe_status_t)SDL_AtomicGet(&portpingprobe_status);
}

int NET_GetPortPingProbeProgress(void)
{
	return ((float)SDL_AtomicGet(&portpingprobe_progress) / (cl_portpingprobe_probes.integer * cl_portpingprobe_port_probes.integer)) * 100;
}


================================================
FILE: src/net.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


*/

// net.h -- quake's interface to the networking layer

#ifndef __NET_H__
#define __NET_H__

#include <errno.h>

#define MAX_DUPLICATE_PACKETS (3)

#ifdef _WIN32

//
// OS specific includes.
//

#include <winsock2.h>
#include <ws2tcpip.h>

//
// OS specific types definition.
//

typedef int socklen_t;
typedef SOCKET socket_t;

//
// OS specific definitions.
//

#ifdef EWOULDBLOCK
#undef EWOULDBLOCK
#endif
#ifdef EMSGSIZE
#undef EMSGSIZE
#endif
#ifdef ECONNRESET
#undef ECONNRESET
#endif
#ifdef ECONNABORTED
#undef ECONNABORTED
#endif
#ifdef ECONNREFUSED
#undef ECONNREFUSED
#endif
#ifdef EADDRNOTAVAIL
#undef EADDRNOTAVAIL
#endif
#ifdef EAFNOSUPPORT
#undef EAFNOSUPPORT
#endif

#define EWOULDBLOCK     WSAEWOULDBLOCK
#define EMSGSIZE        WSAEMSGSIZE
#define ECONNRESET      WSAECONNRESET
#define ECONNABORTED    WSAECONNABORTED
#define ECONNREFUSED    WSAECONNREFUSED
#define EADDRNOTAVAIL   WSAEADDRNOTAVAIL
#define EAFNOSUPPORT    WSAEAFNOSUPPORT
#define qerrno          WSAGetLastError()
#else //_WIN32

//
// OS specific includes.
//

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netdb.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>

#ifdef __sun__
#include <sys/filio.h>
#endif //__sun__

#ifdef NeXT
#include <libc.h>
#endif //NeXT

//
// OS specific types definition.
//

typedef int socket_t;

//
// OS specific definitions.
//

#define qerrno 			errno

#define closesocket close
#define ioctlsocket ioctl

#endif //_WIN32

//
// common definitions.
//

// winsock2.h defines INVALID_SOCKET as (SOCKET)(~0)
// SOCKET is 64 bits on x86_64 while int may still be 32 bit wide
#if defined _WIN32 && defined INVALID_SOCKET
#undef INVALID_SOCKET
#endif

#ifndef INVALID_SOCKET
#define INVALID_SOCKET  -1
#endif

#ifndef SOCKET_ERROR
#define SOCKET_ERROR    -1
#endif

#define PORT_ANY ((unsigned short int)0xFFFF)

typedef enum {NA_INVALID, NA_LOOPBACK, NA_IP} netadrtype_t;

typedef enum {NS_CLIENT, NS_SERVER} netsrc_t;

typedef struct {
	netadrtype_t    type;

	byte            ip[4];

	unsigned short  port;
} netadr_t;

extern	netadr_t	net_local_sv_ipadr;
extern	netadr_t	net_local_sv_tcpipadr;
extern	netadr_t	net_local_cl_ipadr;

extern	netadr_t	net_from; // address of who sent the packet
extern	sizebuf_t	net_message;

#define MAX_UDP_PACKET (MAX_MSGLEN*2) // one more than msg + header

// convert netadrt_t to sockaddr_storage.
void	NetadrToSockadr (const netadr_t *a, struct sockaddr_storage *s);
// convert sockaddr_storage to netadrt_t.
void	SockadrToNetadr (const struct sockaddr_storage *s, netadr_t *a);

// compare netart_t.
qbool	NET_CompareAdr (const netadr_t a, const netadr_t b);
// compare netart_t, ignore port.
qbool	NET_CompareBaseAdr (const netadr_t a, const netadr_t b);
// print netadr_t as string, xxx.xxx.xxx.xxx:xxxxx notation.
char	*NET_AdrToString (const netadr_t a);
// print netadr_t as string, port skipped, xxx.xxx.xxx.xxx notation.
char	*NET_BaseAdrToString (const netadr_t a);
// convert/resolve IP/DNS to netadr_t.
qbool	NET_StringToAdr (const char *s, netadr_t *a);

void	NET_Init (void);
void	NET_Shutdown (void);
void	NET_InitClient (void);
void	NET_InitServer (void);
void	NET_CloseServer (void);
qbool	NET_GetPacket (netsrc_t sock);
void	NET_SendPacket (netsrc_t sock, int length, void *data, netadr_t to);

void	NET_GetLocalAddress (int socket, netadr_t *out);

void	NET_ClearLoopback (void);
qbool	NET_Sleep(int msec, qbool stdinissocket);

// GETER: return port of UDP server socket.
int		NET_UDPSVPort (void);

// GETER: return client/server UDP/TCP socket.
int		NET_GetSocket(netsrc_t netsrc, qbool tcp);

// open server TCP socket.
void	NET_InitServer_TCP(unsigned short int port);

// UTILITY: set KEEPALIVE option on TCP socket (useful for faster timeout detection).
qbool 	TCP_Set_KEEPALIVE(int sock);
// UTILITY: open TCP socket for remove address (useful for client connection).
int		TCP_OpenStream (netadr_t remoteaddr);
// UTILITY: open TCP listen socket (useful for server).
int		TCP_OpenListenSocket (unsigned short int port);
// UTILITY: open UDP listen socket (useful for server).
int		UDP_OpenSocket (unsigned short int port);
//============================================================================

//
// netchan related.
//

#define	OLD_AVG		0.99		// total = oldtotal*OLD_AVG + new*(1-OLD_AVG)

#define	MAX_LATENT	32

typedef struct {
	netsrc_t	sock;

	qbool		fatal_error;

	int			dropped;			// between last packet and previous

	float		last_received;		// for timeouts

	// the statistics are cleared at each client begin, because
	// the server connecting process gives a bogus picture of the data
	float		frame_latency;		// rolling average
	float		frame_rate;

	int			drop_count;			// dropped packets, cleared each level
	int			good_count;			// cleared each level

	netadr_t	remote_address;
	int			qport;

	// bandwidth estimator
	double		cleartime;			// if curtime > nc->cleartime, free to go
	double		rate;				// seconds / byte

	int         dupe;               // duplicate packets to send (0 = no duplicates, as normal)

	// sequencing variables
	int			incoming_sequence;
	int			incoming_acknowledged;
	int			incoming_reliable_acknowledged; // single bit

	int			incoming_reliable_sequence; // single bit, maintained local

	int			outgoing_sequence;
	int			reliable_sequence;	// single bit
	int			last_reliable_sequence; // sequence number of last send

	// reliable staging and holding areas
	sizebuf_t	message;			// writing buffer to send to server
	byte		message_buf[MAX_MSGLEN];

	int			reliable_length;
	byte		reliable_buf[MAX_MSGLEN]; // unacked reliable message

	// time and size data to calculate bandwidth
	int			outgoing_size[MAX_LATENT];
	double		outgoing_time[MAX_LATENT];
} netchan_t;

void Netchan_Init (void);
void Netchan_Transmit (netchan_t *chan, int length, byte *data);
void Netchan_OutOfBand (netsrc_t sock, netadr_t adr, int length, byte *data);
void Netchan_OutOfBandPrint (netsrc_t sock, netadr_t adr, char *format, ...);
qbool Netchan_Process (netchan_t *chan);
void Netchan_Setup (netsrc_t sock, netchan_t *chan, netadr_t adr, int qport, int mtu);

qbool Netchan_CanPacket (netchan_t *chan);
qbool Netchan_CanReliable (netchan_t *chan);

typedef enum {
	PORTPINGPROBE_READY,
	PORTPINGPROBE_PROBING,
	PORTPINGPROBE_COMPLETED,
	PORTPINGPROBE_ABORT
} portpingprobe_status_t;

qbool IsPortPingProbeEnabled(void);
void NET_PortPingProbe(const char *target_addr, const char *original_addr);
void NET_SetPortPingProbeStatus(const portpingprobe_status_t status);
portpingprobe_status_t NET_GetPortPingProbeStatus(void);
int NET_GetPortPingProbeProgress(void);

#endif /* !__NET_H__ */


================================================
FILE: src/net_chan.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


*/

#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include <time.h>
#include "quakedef.h"
#include "server.h"
#endif

#define	PACKET_HEADER 8

/*

packet header
-------------
31	sequence
1	does this message contain a reliable payload
31	acknowledge sequence
1	acknowledge receipt of even/odd message
16  qport

The remote connection never knows if it missed a reliable message, the
local side detects that it has been dropped by seeing a sequence acknowledge
higher than the last reliable sequence, but without the correct even/odd
bit for the reliable set.

If the sender notices that a reliable message has been dropped, it will be
retransmitted.  It will not be retransmitted again until a message after
the retransmit has been acknowledged and the reliable still failed to get there.

If the sequence number is -1, the packet should be handled without a netcon.

The reliable message can be added to at any time by doing
MSG_Write* (&netchan->message, <data>).

If the message buffer is overflowed, either by a single message, or by
multiple frames worth piling up while the last reliable transmit goes
unacknowledged, the netchan signals a fatal error.

Reliable messages are always placed first in a packet, then the unreliable
message is included if there is sufficient room.

To the receiver, there is no distinction between the reliable and unreliable
parts of the message, they are just processed out as a single larger message.

Illogical packet sequence numbers cause the packet to be dropped, but do
not kill the connection.  This, combined with the tight window of valid
reliable acknowledgement numbers provides protection against malicious
address spoofing.

The qport field is a workaround for bad address translating routers that
sometimes remap the client's source port on a packet during gameplay.

If the base part of the net address matches and the qport matches, then the
channel matches even if the IP port differs.  The IP port should be updated
to the new value before sending out any replies.

*/

cvar_t  showpackets    = {"showpackets", "0"};
cvar_t  showdrop       = {"showdrop", "0"};
#ifndef SERVERONLY
cvar_t  qport          = {"qport", "0"};
#ifndef CLIENTONLY
cvar_t  sv_showpackets = {"sv_showpackets", "0"};
cvar_t  sv_showdrop    = {"sv_showdrop", "0"};
#endif
#endif

#ifdef SERVERONLY
#define CHAN_IDENTIFIER(sockType) " [s]"
#define ShowPacket(src,packet_type) (showpackets.integer == 1 || showpackets.integer == packet_type)
#define ShowDrop(src) (showdrop.integer)
#elif CLIENTONLY
#define CHAN_IDENTIFIER(sockType) " [c]"
#define ShowPacket(src,packet_type) (showpackets.integer == 1 || showpackets.integer == packet_type)
#define ShowDrop(src) (showdrop.integer)
#else
#define CHAN_IDENTIFIER(sockType) (sockType == NS_SERVER ? " [s]" : " [c]")

// Use the sv_ options for internal server
static qbool ShowPacket(netsrc_t src, int packet_type)
{
	if (src == NS_SERVER) {
		return sv_showpackets.integer == 1 || sv_showpackets.integer == packet_type;
	}
	else {
		return showpackets.integer == 1 || showpackets.integer == packet_type;
	}
}

static qbool ShowDrop(netsrc_t src)
{
	if (src == NS_SERVER) {
		return sv_showdrop.integer;
	}
	else {
		return showdrop.integer;
	}
}
#endif

#define PACKET_SENDING 2
#define PACKET_RECEIVING 3

/*
===============
Netchan_Init

===============
*/
void Netchan_Init(void)
{
#ifndef SERVERONLY
	int		port = 0xffff;

	srand((unsigned)time(NULL));
	port &= rand();
#endif // SERVERONLY

	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);

	Cvar_Register(&showpackets);
	Cvar_Register(&showdrop);

#ifndef SERVERONLY
	Cvar_SetCurrentGroup(CVAR_GROUP_NO_GROUP);
	Cvar_Register(&qport);
	Cvar_SetValue(&qport, port);

#ifndef CLIENTONLY
	Cvar_Register(&sv_showpackets);
	Cvar_Register(&sv_showdrop);
#endif
#endif

	Cvar_ResetCurrentGroup();
}

/*
===============
Netchan_OutOfBand

Sends an out-of-band datagram
================
*/
void Netchan_OutOfBand (netsrc_t sock, netadr_t adr, int length, byte *data)
{
	sizebuf_t send;
	byte send_buf[MAX_MSGLEN + PACKET_HEADER];

	// write the packet header
	SZ_Init (&send, send_buf, sizeof(send_buf));

	MSG_WriteLong (&send, -1);	// -1 sequence means out of band
	SZ_Write (&send, data, length);

	// send the datagram
#ifndef SERVERONLY
	//zoid, no input in demo playback mode
	if (!cls.demoplayback)
#endif
		NET_SendPacket (sock, send.cursize, send.data, adr);
}

/*
===============
Netchan_OutOfBandPrint

Sends a text message in an out-of-band datagram
================
*/
void Netchan_OutOfBandPrint (netsrc_t sock, netadr_t adr, char *format, ...)
{
	va_list argptr;
	char string[8192];

	va_start (argptr, format);
	vsnprintf (string, sizeof(string), format, argptr);
	va_end (argptr);

	Netchan_OutOfBand (sock, adr, strlen(string), (byte *)string);
}

/*
==============
Netchan_Setup

called to open a channel to a remote system
==============
*/
void Netchan_Setup (netsrc_t sock, netchan_t *chan, netadr_t adr, int qport, int mtu)
{
	if (mtu < 1) {
		mtu = (int)sizeof(chan->message_buf); // OLD way, backward compatibility.
	}
	else {
		mtu -= PACKET_HEADER; // new way.
	}

	memset (chan, 0, sizeof (*chan));

	chan->sock = sock;
	chan->remote_address = adr;
	chan->qport = qport;

	chan->last_received = curtime;
	chan->rate = 1.0/2500;

	SZ_InitEx (&chan->message, chan->message_buf, bound(min(MIN_MTU, (int)sizeof(chan->message_buf)), mtu, (int)sizeof(chan->message_buf)), true);
}

/*
===============
Netchan_CanPacket

Returns true if the bandwidth choke isn't active
================
*/
#ifndef SERVERONLY
#define MAX_BACKUP  200
#else
#define	MAX_BACKUP	400
#endif
qbool Netchan_CanPacket (netchan_t *chan)
{
#ifndef SERVERONLY
	if (chan->remote_address.type == NA_LOOPBACK)
		return true; // unlimited bandwidth for local client
#endif

	return (chan->cleartime < curtime + MAX_BACKUP * chan->rate) ? true : false;
}

/*
===============
Netchan_CanReliable

Returns true if the bandwidth choke isn't 
================
*/
qbool Netchan_CanReliable (netchan_t *chan)
{
	if (chan->reliable_length)
		return false; // waiting for ack
	return Netchan_CanPacket (chan);
}

/*
===============
Netchan_Transmit

tries to send an unreliable message to a connection, and handles the
transmition / retransmition of the reliable messages.

A 0 length will still generate a packet and deal with the reliable messages.
================
*/
void Netchan_Transmit (netchan_t *chan, int length, byte *data)
{
	sizebuf_t send;
	byte send_buf[MAX_MSGLEN + PACKET_HEADER];
	qbool send_reliable;
	unsigned w1, w2;
	int i;
	static double last_error_time = 0;

	// check for message overflow
	if (chan->message.overflowed) {
		chan->fatal_error = true; //FIXME: THIS DOES NOTHING
		if (last_error_time - curtime > 5 || developer.value) {
			Con_Printf ("%s:Outgoing message overflow\n", NET_AdrToString (chan->remote_address));
			last_error_time = curtime;
		}
		return;
	}

	// if the remote side dropped the last reliable message, resend it
	send_reliable = false;

	if (chan->incoming_acknowledged > chan->last_reliable_sequence && chan->incoming_reliable_acknowledged != chan->reliable_sequence)
		send_reliable = true;

	// if the reliable transmit buffer is empty, copy the current message out
	if (!chan->reliable_length && chan->message.cursize) {
		memcpy (chan->reliable_buf, chan->message_buf, chan->message.cursize);
		chan->reliable_length = chan->message.cursize;
		chan->message.cursize = 0;
		chan->reliable_sequence ^= 1;
		send_reliable = true;
	}

	// write the packet header
	SZ_Init (&send, send_buf, min(chan->message.maxsize + PACKET_HEADER, (int)sizeof(send_buf)));

	w1 = chan->outgoing_sequence | (send_reliable<<31);
	w2 = chan->incoming_sequence | (chan->incoming_reliable_sequence<<31);

	chan->outgoing_sequence++;

	MSG_WriteLong (&send, w1);
	MSG_WriteLong (&send, w2);

#ifndef SERVERONLY
	// send the qport if we are a client
	if (chan->sock == NS_CLIENT)
		MSG_WriteShort (&send, chan->qport);
#endif

	// copy the reliable message to the packet first
	if (send_reliable) {
		SZ_Write (&send, chan->reliable_buf, chan->reliable_length);
		chan->last_reliable_sequence = chan->outgoing_sequence;
	}

	// add the unreliable part if space is available
	if (send.maxsize - send.cursize >= length) {
		SZ_Write(&send, data, length);
	}

	// send the datagram
	i = chan->outgoing_sequence & (MAX_LATENT-1);
	chan->outgoing_size[i] = send.cursize;
	chan->outgoing_time[i] = curtime;

#ifndef SERVERONLY
	//zoid, no input in demo playback mode
	if (!cls.demoplayback)
#endif
	{
		for (i = 0; i <= chan->dupe; ++i) {
			NET_SendPacket(chan->sock, send.cursize, send.data, chan->remote_address);
		}
	}

	if (chan->cleartime < curtime) {
		chan->cleartime = curtime + send.cursize * i * chan->rate;
	}
	else {
		chan->cleartime += send.cursize * i * chan->rate;
	}

#ifndef CLIENTONLY
	if (chan->sock == NS_SERVER && sv.paused)
		chan->cleartime = curtime;
#endif

	if (ShowPacket(chan->sock, PACKET_SENDING)) {
#ifndef SERVERONLY
		Print_flags[Print_current] |= PR_TR_SKIP;
#endif
		Con_Printf ("%.1f --> s=%i(%i) a=%i(%i) %i%s\n"
		            , cls.demopackettime * 1000, chan->outgoing_sequence
		            , send_reliable
		            , chan->incoming_sequence
		            , chan->incoming_reliable_sequence
		            , send.cursize, CHAN_IDENTIFIER(chan->sock)
		);
	}

}

/*
=================
Netchan_Process

called when the current net_message is from remote_address
modifies net_message so that it points to the packet payload
=================
*/
qbool Netchan_Process (netchan_t *chan)
{
	unsigned sequence, sequence_ack;
	unsigned reliable_ack, reliable_message;

#ifdef SERVERONLY
	if (!NET_CompareAdr (net_from, chan->remote_address))
		return false;
#endif

	// get sequence numbers
	MSG_BeginReading ();
	sequence = MSG_ReadLong ();
	sequence_ack = MSG_ReadLong ();

	// read the qport if we are a server
	if (chan->sock == NS_SERVER)
		MSG_ReadShort ();

	reliable_message = sequence >> 31;
	reliable_ack = sequence_ack >> 31;

	sequence &= ~(1 << 31);
	sequence_ack &= ~(1 << 31);

	if (ShowPacket(chan->sock, PACKET_RECEIVING)) {
#ifndef SERVERONLY
		Print_flags[Print_current] |= PR_TR_SKIP;
#endif
		Con_Printf ("%.1f <-- s=%i(%i) a=%i(%i) %i%s\n"
		            , cls.demopackettime * 1000, sequence
		            , reliable_message
		            , sequence_ack
		            , reliable_ack
		            , net_message.cursize, CHAN_IDENTIFIER(chan->sock)
		);
	}

	// discard stale or duplicated packets
	if (sequence <= (unsigned)chan->incoming_sequence) {
		if (ShowDrop(chan->sock)) {
#ifndef SERVERONLY
			Print_flags[Print_current] |= PR_TR_SKIP;
#endif
			Con_Printf ("%s:Out of order packet %i at %i\n"
			            , NET_AdrToString (chan->remote_address)
			            , sequence
			            , chan->incoming_sequence);
		}
		return false;
	}

	// dropped packets don't keep the message from being used
	chan->dropped = sequence - (chan->incoming_sequence+1);
	if (chan->dropped > 0) {
		chan->drop_count += 1;

		if (ShowDrop(chan->sock)) {
#ifndef SERVERONLY
			Print_flags[Print_current] |= PR_TR_SKIP;
#endif
			Con_Printf ("%s:Dropped %i packets at %i\n"
			            , NET_AdrToString (chan->remote_address)
			            , chan->dropped
			            , sequence);
		}
	}

	// if the current outgoing reliable message has been acknowledged
	// clear the buffer to make way for the next
	if (reliable_ack == (unsigned)chan->reliable_sequence) {
		chan->reliable_length = 0;	// it has been received
	}

	// if this message contains a reliable message, bump incoming_reliable_sequence
	chan->incoming_sequence = sequence;
	chan->incoming_acknowledged = sequence_ack;
	chan->incoming_reliable_acknowledged = reliable_ack;
	if (reliable_message) {
		chan->incoming_reliable_sequence ^= 1;
	}

	// the message can now be read from the current message pointer
	// update statistics counters
	chan->frame_latency = chan->frame_latency * OLD_AVG +
		(chan->outgoing_sequence - sequence_ack) * (1.0 - OLD_AVG);
	chan->frame_rate = chan->frame_rate * OLD_AVG +
		(curtime - chan->last_received) * (1.0 - OLD_AVG);
	chan->good_count += 1;

	chan->last_received = curtime;

	return true;
}


================================================
FILE: src/parser.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
	\file

	\brief
	Arithmetic expression evaluator
    
	\author johnnycz
**/

// fixme: most probably there are some memory leaks when working with strings

#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <string.h>
#include <wctype.h>
#include "quakedef.h"
#include "q_shared.h"
#include "utils.h"
#include "pcre2.h"
#include "parser.h"

#undef Q_malloc
#undef Q_free
#undef Q_strdup
#define Q_malloc malloc
#define Q_free free
#define Q_strdup strdup

#define GLOBAL /* */
#define LOCAL static

#define REAL_COMPARE_EPSILON	0.00000001
#define MAX_NUMBER_LENGTH		32
#define BOOL_TRUE	1
#define BOOL_FALSE	0

#define ERR_INVALID_TOKEN   1
#define ERR_UNEXPECTED_CHAR 2
#define ERR_TYPE_MISMATCH	3
#define ERR_ZERO_DIV		4
#define ERR_NOTIMPL			5
#define ERR_MALFORMED_NUM   6
#define ERR_OUT_OF_MEM		7
#define ERR_INTERNAL        8
#define ERR_REGEXP			9
#define ERR_INVALID_ARG     10

//
// Tokens
//
#define TK_EOF      0
#define TK_INVALID  1
// double, integer
#define TK_DOUBLE   100
#define TK_INTEGER	101
// +, -
#define TK_PLUS     200
#define TK_MINUS    201
// *, /, mod
#define TK_ASTERISK 250
#define TK_SLASH    251
#define TK_MOD		252
#define TK_XOR      253
#define TK_DIV      254
// parentheses
#define TK_BR_O     300
#define TK_BR_C     301
// variable
#define TK_VAR      500
#define TK_STR      501
// comparisions
#define TK_LT		600
#define TK_LE		601
#define TK_EQ       602
#define TK_EQ2		603
#define TK_GE       604
#define TK_GT       605
#define TK_NE       606
#define TK_ISIN     607
#define TK_NISIN    608
#define TK_REEQ     609
#define TK_RENE     610
// logic
#define TK_AND      700
#define TK_OR       701
// string
#define TK_STRLEN   800
#define TK_INT      801
#define TK_SUBSTR   802
#define TK_POS      804
#define TK_TOBROWN  805
#define TK_TOWHITE  806
// misc
#define TK_COMMA    900

typedef struct {
    const char *string;			// input string
    int pos;					// current reading position in the input string
    int lookahead;				// next token in the string
    int error;					// first error
	int warning;				// last warning
	variable_val_fnc varfnc;	// pointer to a function returning variable values
	subpatterns_report_fnc re_patfnc;
								// a function where we report regexp-found subpatterns
} expr_parser_t, *EParser;

#define CURCHAR(p) (p->string[p->pos])

LOCAL void SetError(EParser p, int error)
{
	if (p->error == EXPR_EVAL_SUCCESS)
	{
		p->error = error;
	} // else keep the previous error
}

LOCAL void FreeIfStr(const expr_val *e)
{
	if (e->type == ET_STR) {
		Q_free(e->s_val);
	}
}

LOCAL double Get_Double(const expr_val e)
{
	switch (e.type) {
	case ET_INT: return e.i_val;
	case ET_DBL: return e.d_val;
	case ET_BOOL: return e.b_val;
	case ET_STR: default: return 0;
	}
}

LOCAL int Get_Integer(const expr_val e)
{
	switch (e.type) {
	case ET_INT: return e.i_val;
	case ET_DBL: return (int) e.d_val;
	case ET_BOOL:return e.b_val;
	case ET_STR: default: return 0;
	}
}

LOCAL int Get_Bool(const expr_val e)
{
	switch (e.type) {
	case ET_INT: return e.i_val;
	case ET_DBL: return (int) e.d_val;
	case ET_BOOL:return e.b_val;
	case ET_STR: {
		int retval = (*e.s_val) ? BOOL_TRUE : BOOL_FALSE;
		Q_free(e.s_val);
		return retval;
		}
	default: assert(false); return 0;
	}
}

GLOBAL expr_val Get_Expr_Double(double v)
{
	expr_val t = {0};
	t.type = ET_DBL;
	t.d_val = v;
	return t;
}

GLOBAL expr_val Get_Expr_String(const char *v)
{
	expr_val t = {0};
	t.type = ET_STR;
	t.s_val = Q_strdup(v);
	return t;
}

GLOBAL expr_val Get_Expr_Integer(int v)
{
	expr_val t = {0};
	t.type = ET_INT;
	t.i_val = v;
	return t;
}

GLOBAL expr_val Get_Expr_Bool(int v)
{
	expr_val t = {0};
	t.type = ET_BOOL;
	t.b_val = v ? BOOL_TRUE : BOOL_FALSE;
	return t;
}

GLOBAL expr_val Get_Expr_Dummy(void)
{
	expr_val t = {0};
	t.type = ET_INT;
	t.i_val = 0;
	return t;
}

LOCAL int Compare_Double(double a, double b)
{
	double diff = fabs(a-b);
	if (diff < REAL_COMPARE_EPSILON)
		return 0; // a == b
	else if (a > b)
		return 1;
	else
		return -1;
}

LOCAL expr_val ToString(EParser p, const expr_val e)
{
	expr_val r = {0};
	switch (e.type) {
	case ET_STR: r = e; break;
	case ET_INT:
		r.s_val = (char *) malloc(MAX_NUMBER_LENGTH);
		if (!r.s_val) { SetError(p, ERR_OUT_OF_MEM); return Get_Expr_Dummy(); }
		snprintf(r.s_val, MAX_NUMBER_LENGTH, "%i", e.i_val);
		break;

	case ET_DBL:
		r.s_val = (char *) malloc(MAX_NUMBER_LENGTH);
		if (!r.s_val) { SetError(p, ERR_OUT_OF_MEM); return Get_Expr_Dummy(); }
		snprintf(r.s_val, MAX_NUMBER_LENGTH, "%f", e.d_val);
		break;

	case ET_BOOL:
		r.s_val = (char *) malloc(6);
		if (!r.s_val) { SetError(p, ERR_OUT_OF_MEM); return Get_Expr_Dummy(); }
		snprintf(r.s_val, 6, "%s", e.b_val ? "true" : "false");
		break;
	}

	return r;
}

LOCAL expr_val Concat(EParser p, const expr_val e1, const expr_val e2)
{
	size_t len;
	expr_val ret = {0};
	if (e1.type != ET_STR || e2.type != ET_STR) {
		SetError(p, ERR_INTERNAL);
		return Get_Expr_Dummy();
	}

	len = strlen(e1.s_val) + strlen(e2.s_val) + 1;
	ret.type = ET_STR;
	ret.s_val = malloc(len);
	if (!ret.s_val) {
		SetError(p, ERR_OUT_OF_MEM);
		FreeIfStr(&e1);
		FreeIfStr(&e2);
		return Get_Expr_Dummy();
	}
	strlcpy(ret.s_val, e1.s_val, len);
	strlcat(ret.s_val, e2.s_val, len);
	Q_free(e1.s_val);
	Q_free(e2.s_val);

	return ret;
}

LOCAL expr_val operator_plus(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret = {0};

	switch (e1.type) {
	case ET_INT: switch (e2.type) {
		case ET_INT:	ret.type = ET_INT; ret.i_val = e1.i_val + e2.i_val; break;
		case ET_DBL:	ret.type = ET_DBL; ret.d_val = e1.i_val + e2.d_val; break;
		case ET_BOOL:	ret.type = ET_INT; ret.i_val = e1.i_val + e2.b_val; break;
		case ET_STR:	SetError(p, ERR_TYPE_MISMATCH); break;
		} break;

	case ET_DBL: switch (e2.type) {
		case ET_INT:	ret.type = ET_DBL; ret.d_val = e1.d_val + e2.i_val; break;
		case ET_DBL:	ret.type = ET_DBL; ret.d_val = e1.d_val + e2.d_val; break;
		case ET_BOOL:	ret.type = ET_DBL; ret.d_val = e1.d_val + e2.b_val; break;
		case ET_STR:	SetError(p, ERR_TYPE_MISMATCH); break;
		} break;

	case ET_BOOL: switch (e2.type) {
		case ET_INT:	ret.type = ET_INT; ret.i_val = e1.b_val + e2.i_val; break;
		case ET_DBL:	ret.type = ET_DBL; ret.d_val = e1.b_val + e2.d_val; break;
		case ET_BOOL:	ret.type = ET_BOOL;ret.b_val = e1.b_val + e2.b_val; break;
		case ET_STR:	SetError(p, ERR_TYPE_MISMATCH); break;
        } break;

	case ET_STR: switch (e2.type) {
		case ET_STR:	ret = Concat(p, e1, e2); break;
		default:		SetError(p, ERR_TYPE_MISMATCH); break;
		} break;
	}

	return ret;
}

LOCAL expr_val operator_minus (EParser p, const expr_val e1)
{
	expr_val ret = {0};

	switch (e1.type) {
	case ET_INT: ret.type = ET_INT; ret.i_val = -e1.i_val; break;
	case ET_DBL: ret.type = ET_DBL; ret.d_val = -e1.d_val; break;
	case ET_BOOL: ret.type = ET_BOOL; ret.b_val = -e1.b_val; break;
	case ET_STR: SetError(p, ERR_TYPE_MISMATCH); break;
	}

	return ret;
}

LOCAL expr_val operator_multiply(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret = {0};

	switch (e1.type) {
	case ET_INT: switch (e2.type) {
		case ET_INT: ret.type = ET_INT; ret.i_val = e1.i_val * e2.i_val; break;
		case ET_DBL: ret.type = ET_DBL; ret.d_val = e1.i_val * e2.d_val; break;
		case ET_BOOL:ret.type = ET_BOOL;ret.b_val = e1.i_val * e2.b_val; break;
		case ET_STR: SetError(p, ERR_TYPE_MISMATCH); break;
		} break;

	case ET_DBL: switch (e2.type) {
		case ET_INT: ret.type = ET_DBL; ret.d_val = e1.d_val * e2.i_val; break;
		case ET_DBL: ret.type = ET_DBL; ret.d_val = e1.d_val * e2.d_val; break;
		case ET_BOOL:ret.type = ET_DBL; ret.d_val = e1.d_val * e2.b_val; break;
		case ET_STR: SetError(p, ERR_TYPE_MISMATCH); break;
		} break;

	case ET_BOOL: switch (e2.type) {
		case ET_INT: ret.type = ET_INT; ret.i_val = e1.b_val * e2.i_val; break;
		case ET_DBL: ret.type = ET_DBL; ret.d_val = e1.b_val * e2.d_val; break;
		case ET_BOOL:ret.type = ET_BOOL;ret.b_val = e1.b_val * e2.b_val; break;
		case ET_STR: SetError(p, ERR_TYPE_MISMATCH); break;
		} break;

	case ET_STR: default: SetError(p, ERR_TYPE_MISMATCH); break;
	}

	return ret;
}

LOCAL expr_val operator_modulo(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret;

	if (e1.type == ET_INT && e2.type == ET_INT) {
		ret.type = ET_INT;
		ret.i_val = e1.i_val % e2.i_val;
	}
	else {
		SetError(p, ERR_TYPE_MISMATCH);
		ret = Get_Expr_Dummy();
	}

	return ret;
}

LOCAL expr_val operator_xor(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret;

	if (e1.type == ET_INT && e2.type == ET_INT) {
		ret.type = ET_INT;
		ret.i_val = e1.i_val ^ e2.i_val;
	}
	else if (e1.type == ET_BOOL && e2.type == ET_BOOL) {
		ret.type = ET_BOOL;
		ret.b_val = ((e1.b_val ? 1 : 0) ^ (e2.b_val ? 1 : 0)) ? BOOL_TRUE : BOOL_FALSE;
	}
	else {
		SetError(p, ERR_TYPE_MISMATCH);
		ret = Get_Expr_Dummy();
	}

	return ret;
}

LOCAL expr_val operator_divint(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret;

	if (e1.type == ET_INT && e2.type == ET_INT) {
		ret.type = ET_INT;
		ret.i_val = e1.i_val / e2.i_val;
	}
	else {
		SetError(p, ERR_TYPE_MISMATCH);
		ret = Get_Expr_Dummy();
	}

	return ret;
}

LOCAL expr_val operator_divide(EParser p, const expr_val e1)
{
	double d;
	expr_val ret;

	switch (e1.type) {
	case ET_INT:	d = e1.i_val; break;
	case ET_DBL:	d = e1.d_val; break;
	case ET_BOOL:	d = e1.b_val; break;
	case ET_STR: 
	default:
		SetError(p, ERR_TYPE_MISMATCH); 
		return e1;
	}

	if (d) {
		ret.type = ET_DBL;
		ret.d_val = 1/d;
	} else 	{
		SetError(p, ERR_ZERO_DIV);
		ret = Get_Expr_Dummy();
	}

	return ret;
}

LOCAL expr_val operator_strlen(EParser p, const expr_val arg1)
{
	expr_val ret;
	ret.type = ET_INT;
	
	if (arg1.type == ET_STR) {
		ret.i_val = strlen(arg1.s_val);
		Q_free(arg1.s_val);
	}
	else {
		SetError(p, ERR_TYPE_MISMATCH);
	}

	return ret;
}

LOCAL expr_val operator_substr(EParser p, const expr_val arg1, const expr_val arg2,
                               const expr_val arg3)
{
	expr_val ret;
	
	if (arg1.type == ET_STR && arg2.type == ET_INT && arg3.type == ET_INT) {
		const char *str = arg1.s_val;
		size_t arglen = strlen(str);
		size_t pos = arg2.i_val;
		size_t len = arg3.i_val;

		if (pos >= 0 && len >= 0) {
			if (len == 0 || pos >= arglen) {
				ret.type = ET_STR;
				ret.s_val = Q_strdup("");
			}
			else { // len > 0 && pos < arglen
				char *buf;

				if (pos + len > arglen) {
					len = arglen - pos;
				}

				buf = (char *) malloc(len + 1);

				if (buf) {
					strlcpy(buf, str + pos, len + 1);
					ret.type = ET_STR;
					ret.s_val = buf;
				}
				else { // malloc fail
					SetError(p, ERR_OUT_OF_MEM);
					ret = Get_Expr_Dummy();
				}
			}
		}
		else { // pos < 0 || len < 0
			SetError(p, ERR_INVALID_ARG);
			ret = Get_Expr_Dummy();
		}
	}
	else { // args are not string, int, int
		SetError(p, ERR_TYPE_MISMATCH);
		ret = Get_Expr_Dummy();
	}

	FreeIfStr(&arg1);
	FreeIfStr(&arg2);
	FreeIfStr(&arg3);

	return ret;
}

LOCAL expr_val operator_pos(EParser p, const expr_val arg1, const expr_val arg2)
{
	expr_val ret;
	
	if (arg1.type == ET_STR && arg2.type == ET_STR) {
		char *haystack = arg1.s_val;
		char *needle = arg2.s_val;
		
		char *find = strstr(haystack, needle);

		ret.type = ET_INT;
		if (find) {
			ret.i_val = (int) (find - arg1.s_val);
		}
		else {
			ret.i_val = -1;
		}

		Q_free(arg1.s_val);
		Q_free(arg2.s_val);
	}
	else {
		SetError(p, ERR_TYPE_MISMATCH);
		FreeIfStr(&arg1);
		FreeIfStr(&arg2);
		ret = Get_Expr_Dummy();
	}

	return ret;
}

LOCAL expr_val operator_int(EParser p, const expr_val arg1)
{
	expr_val ret;
	ret.type = ET_INT;

	switch (arg1.type) {
		case ET_INT:
			ret.i_val = arg1.i_val;
			break;
		case ET_DBL:
			ret.i_val = (int) arg1.d_val;
			break;
		case ET_STR:
			ret.i_val = atoi(arg1.s_val);
			Q_free(arg1.s_val);
			break;
		case ET_BOOL:
			ret.i_val = arg1.b_val ? 1 : 0;
			break;
	}

	return ret;
}

LOCAL expr_val operator_tobrown(EParser p, const expr_val arg1)
{
	expr_val ret;

	if (arg1.type == ET_STR) {
		ret.s_val = Q_strdup(arg1.s_val);
		ret.type = ET_STR;
		CharsToBrown(ret.s_val, ret.s_val + strlen(ret.s_val));
	}
	else {
		SetError(p, ERR_TYPE_MISMATCH);
		ret = Get_Expr_Dummy();
	}

	FreeIfStr(&arg1);
	return ret;
}

LOCAL expr_val operator_towhite(EParser p, const expr_val arg1)
{
	expr_val ret;

	if (arg1.type == ET_STR) {
		ret.s_val = Q_strdup(arg1.s_val);
		ret.type = ET_STR;
		CharsToWhite(ret.s_val, ret.s_val + strlen(ret.s_val));
	}
	else {
		SetError(p, ERR_TYPE_MISMATCH);
		ret = Get_Expr_Dummy();
	}

	FreeIfStr(&arg1);

	return ret;
}


typedef enum {
	CMPRESULT_lt,
	CMPRESULT_le,
	CMPRESULT_eq,
	CMPRESULT_ne,
	CMPRESULT_ge,
	CMPRESULT_gt
} cmp_type;

// this will be called if one of the expressions is string
// and we want to do a comparision on them
LOCAL expr_val string_check_cmp(EParser p, const expr_val e1, const expr_val e2, cmp_type ctype)
{
	expr_val r = {0};
	r.type = ET_BOOL;
	r.b_val = BOOL_FALSE;

	if (e1.type != ET_STR && e2.type != ET_STR)	{
		SetError(p, ERR_INTERNAL);
	} else if (e1.type != ET_STR) {
		Q_free(e2.s_val);
		SetError(p, ERR_TYPE_MISMATCH);
	} else if (e2.type != ET_STR) {
		Q_free(e1.s_val);
		SetError(p, ERR_TYPE_MISMATCH);
	} else {	// both STR
		int a = strcmp(e1.s_val, e2.s_val);
		switch(ctype) {
		case CMPRESULT_lt: r.b_val = a <  0; break;
		case CMPRESULT_le: r.b_val = a <= 0; break;
		case CMPRESULT_eq: r.b_val = a == 0; break;
		case CMPRESULT_ne: r.b_val = a != 0; break;
		case CMPRESULT_ge: r.b_val = a >= 0; break;
		case CMPRESULT_gt: r.b_val = a >  0; break;
		}
		Q_free(e1.s_val);
		Q_free(e2.s_val);
	}
	return r;
}

// test: "1==1.0", "2==2.0", "5/2==2.5"
LOCAL expr_val operator_eq(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret = {0};
	ret.type = ET_BOOL;

	if (e1.type == ET_STR || e2.type == ET_STR)
		return string_check_cmp(p, e1, e2, CMPRESULT_eq);

	switch(e1.type) {
	case ET_INT: switch (e2.type) {
		case ET_INT: ret.b_val = e1.i_val == e2.i_val; break;
		case ET_DBL: ret.b_val = !Compare_Double(e1.i_val, e2.d_val); break;
		case ET_BOOL: ret.b_val = e2.b_val ? e1.i_val == 1 : e1.i_val == 0; break;
		// handled above, avoid gcc warning
		case ET_STR: break;
		} break;
	case ET_DBL: switch (e2.type) {
		case ET_INT: ret.b_val = !Compare_Double(e1.d_val, e2.i_val); break;
		case ET_DBL: ret.b_val = !Compare_Double(e1.d_val, e2.d_val); break;
		case ET_BOOL: SetError(p, ERR_TYPE_MISMATCH); break;
		// handled above, avoid gcc warning
		case ET_STR: break;
		} break;
	case ET_BOOL: switch (e2.type) {
		case ET_INT: ret.b_val = e1.b_val ? e2.i_val == 1 : e2.i_val == 0; break;
		case ET_DBL: SetError(p, ERR_TYPE_MISMATCH); break;
		case ET_BOOL: ret.b_val = e1.b_val == e2.b_val; break;
		// handled above, avoid gcc warning
		case ET_STR: break;
	    } break;
	// handled above, avoid gcc warning
	case ET_STR: break;
	}

	return ret;
}

// test: "1<1.0", ...
LOCAL expr_val operator_lt(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret = {0};
	ret.type = ET_BOOL;

	if (e1.type == ET_STR || e2.type == ET_STR)
		return string_check_cmp(p, e1, e2, CMPRESULT_lt);

	switch(e1.type) {
	case ET_INT: switch (e2.type) {
		case ET_INT: ret.b_val = e1.i_val < e2.i_val; break;
		case ET_DBL: ret.b_val = Compare_Double(e1.i_val, e2.d_val) == -1; break;
		case ET_BOOL: SetError(p, ERR_TYPE_MISMATCH); break;
		// handled above, avoid gcc warning
		case ET_STR: break;
		} break;
	case ET_DBL: switch (e2.type) {
		case ET_INT: ret.b_val = Compare_Double(e1.d_val, e2.i_val) == -1; break;
		case ET_DBL: ret.b_val = Compare_Double(e1.d_val, e2.d_val) == -1; break;
		case ET_BOOL: SetError(p, ERR_TYPE_MISMATCH); break;
		// handled above, avoid gcc warning
		case ET_STR: break;
		} break;
	case ET_BOOL: switch (e2.type) {
		case ET_BOOL: ret.b_val = !e1.b_val && e2.b_val; break;
		default: SetError(p, ERR_TYPE_MISMATCH); break;
	    } break;
	// handled above, avoid gcc warning
	case ET_STR: break;
	}

	return ret;
}

// this obscurity here just defines operators "<=", ">", "!=" and ">="
// by using operators "<" and "=="
#define LT_VAL() (operator_lt(p,e1,e2).b_val)
#define EQ_VAL() (operator_eq(p,e1,e2).b_val)
#define ADDOP(name,cond)										\
LOCAL expr_val operator_##name (EParser p, const expr_val e1, const expr_val e2) {	\
	expr_val ret = {0}; ret.type = ET_BOOL;												\
	if (e1.type == ET_STR || e2.type == ET_STR)										\
		return string_check_cmp(p, e1, e2, CMPRESULT_##name);						\
	else ret.b_val = (cond); return ret;											\
}

ADDOP(le, LT_VAL() || EQ_VAL());
ADDOP(gt, !LT_VAL() && !EQ_VAL());
ADDOP(ne, !EQ_VAL());
ADDOP(ge, !LT_VAL());

#undef ADDOP
#undef LT_VAL
#undef EQ_VAL

LOCAL expr_val operator_isin(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val s1 = ToString(p, e1);
	expr_val s2 = ToString(p, e2);
	expr_val r = {0}; r.type = ET_BOOL;

	if (!(*s1.s_val)) {
		r.b_val = BOOL_FALSE;
	} else {
		r.b_val = strstr(s2.s_val, s1.s_val) ? BOOL_TRUE : BOOL_FALSE;
	}

	Q_free(s1.s_val);
	Q_free(s2.s_val);
	return r;
}

LOCAL expr_val operator_nisin(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val r = operator_isin(p, e1, e2);
	r.b_val = !r.b_val;
	return r;
}

LOCAL expr_val operator_reeq(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val r = {0};
	expr_val strr = ToString(p, e1);
	expr_val mask = ToString(p, e2);
	// this makes sense for "111 =~ 1.1", however we are doing str->double->str conversion
	// and it can happen that the result string won't be the same as the source
	pcre2_code       *regexp;
	int              error;
	PCRE2_SIZE       error_offset;
	pcre2_match_data *match_data = NULL;
	PCRE2_SIZE       *offsets;
	int              rc;

	r.type = ET_BOOL;

	regexp = pcre2_compile ((PCRE2_SPTR)mask.s_val, PCRE2_ZERO_TERMINATED, 0, &error, &error_offset, NULL);
	if (!regexp) {
		SetError(p, ERR_REGEXP);
		return Get_Expr_Dummy();
	}
	match_data = pcre2_match_data_create_from_pattern(regexp, NULL);
	rc = pcre2_match (regexp, (PCRE2_SPTR)strr.s_val, strlen(strr.s_val),
	                0, 0, match_data, NULL);
	if (rc >= 0) {
		offsets = pcre2_get_ovector_pointer(match_data);
		if (p->re_patfnc)
			p->re_patfnc(strr.s_val, offsets, rc > 99 ? 99 : rc);
		r.b_val = BOOL_TRUE;
	} else
		r.b_val = BOOL_FALSE;

	Q_free(e1.s_val);
	Q_free(e2.s_val);

	pcre2_match_data_free (match_data);
	pcre2_code_free (regexp);
	return r;
}

LOCAL expr_val operator_rene(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val r = operator_reeq(p, e1, e2);
	r.b_val = !r.b_val;
	return r;
}

LOCAL expr_val operator_and(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret = {0};
	ret.type = ET_BOOL;

	switch (e1.type) {
	case ET_INT: switch (e2.type) {
		case ET_INT: ret.b_val = e1.i_val && e2.i_val; break;
		case ET_DBL: ret.b_val = e1.i_val && e2.d_val; break;
		case ET_BOOL: ret.b_val = e1.i_val && e2.b_val; break;
		case ET_STR: ret.i_val = e1.i_val && *e2.s_val; break;
	    } break;
	case ET_DBL: switch (e2.type) {
	    case ET_INT: ret.b_val = e1.d_val && e2.i_val; break;
		case ET_DBL: ret.b_val = e1.d_val && e2.d_val; break;
		case ET_BOOL: ret.b_val = e1.d_val && e2.b_val; break;
		case ET_STR: ret.b_val = e1.d_val && *e2.s_val; break;
		} break;
	case ET_BOOL: switch (e2.type) {
		case ET_INT: ret.b_val = e1.b_val && e2.i_val; break;
		case ET_DBL: ret.b_val = e1.b_val && e2.d_val; break;
		case ET_BOOL: ret.b_val = e1.b_val && e2.b_val; break;
		case ET_STR: ret.b_val = e1.b_val && *e2.s_val; break;
		} break;
	case ET_STR: switch (e2.type) {
		case ET_INT: ret.b_val = *e1.s_val && e2.i_val; break;
		case ET_DBL: ret.b_val = *e1.s_val && e2.d_val; break;
		case ET_BOOL: ret.b_val = *e1.s_val && e2.b_val; break;
		case ET_STR: ret.b_val = *e1.s_val && *e2.s_val; break;
		} break;
	}

	FreeIfStr(&e1);
	FreeIfStr(&e2);

	return ret;
}

// a copy-paste of operator_and, I couldn't think of better way, limited C :(
LOCAL expr_val operator_or(EParser p, const expr_val e1, const expr_val e2)
{
	expr_val ret = {0};
	ret.type = ET_BOOL;

	switch (e1.type) {
	case ET_INT: switch (e2.type) {
		case ET_INT: ret.b_val = e1.i_val || e2.i_val; break;
		case ET_DBL: ret.b_val = e1.i_val || e2.d_val; break;
		case ET_BOOL: ret.b_val = e1.i_val || e2.b_val; break;
		case ET_STR: ret.i_val = e1.i_val || *e2.s_val; break;
	    } break;
	case ET_DBL: switch (e2.type) {
	    case ET_INT: ret.b_val = e1.d_val || e2.i_val; break;
		case ET_DBL: ret.b_val = e1.d_val || e2.d_val; break;
		case ET_BOOL: ret.b_val = e1.d_val || e2.b_val; break;
		case ET_STR: ret.b_val = e1.d_val || *e2.s_val; break;
		} break;
	case ET_BOOL: switch (e2.type) {
		case ET_INT: ret.b_val = e1.b_val || e2.i_val; break;
		case ET_DBL: ret.b_val = e1.b_val || e2.d_val; break;
		case ET_BOOL: ret.b_val = e1.b_val || e2.b_val; break;
		case ET_STR: ret.b_val = e1.b_val || *e2.s_val; break;
		} break;
	case ET_STR: switch (e2.type) {
		case ET_INT: ret.b_val = *e1.s_val || e2.i_val; break;
		case ET_DBL: ret.b_val = *e1.s_val || e2.d_val; break;
		case ET_BOOL: ret.b_val = *e1.s_val || e2.b_val; break;
		case ET_STR: ret.b_val = *e1.s_val || *e2.s_val; break;
		} break;
	}

	FreeIfStr(&e1);
	FreeIfStr(&e2);

	return ret;
}


// does the input string contain str as the very first string?
LOCAL int Follows(EParser p, const char *str)
{
	const char* c1 = p->string + p->pos;
	const char* c2 = str;

	while (*c1 && *c2 && *c1 == *c2) { c1++; c2++; }

	if (!*c2) return 1;
	else      return 0;
}

// update the lookahead based on what we see next in the input string
LOCAL void Next_Token(EParser p)
{
    char c;

    while(c = CURCHAR(p), c && c == ' ') p->pos++;

    if (!c)                     { p->lookahead = TK_EOF; }
	else if (Follows(p, "isin")) { p->lookahead = TK_ISIN; }
	else if (Follows(p, "!isin")) { p->lookahead = TK_NISIN; }
	else if (Follows(p, "mod")) { p->lookahead = TK_MOD; }
	else if (Follows(p, "xor")) { p->lookahead = TK_XOR; }
	else if (Follows(p, "div")) { p->lookahead = TK_DIV; }
	else if (Follows(p, "and") || Follows(p, "AND") || Follows(p, "&&"))
	{ p->lookahead = TK_AND; }
	else if (Follows(p, "or") || Follows(p, "OR") || Follows(p, "||"))
	{ p->lookahead = TK_OR; }
	else if (Follows(p, "strlen"))    { p->lookahead = TK_STRLEN; }
	else if (Follows(p, "int"))       { p->lookahead = TK_INT; }
	else if (Follows(p, "substr"))    { p->lookahead = TK_SUBSTR; }
	else if (Follows(p, "pos"))       { p->lookahead = TK_POS; }
	else if (Follows(p, "tobrown"))   { p->lookahead = TK_TOBROWN; }
	else if (Follows(p, "towhite"))   { p->lookahead = TK_TOWHITE; }
	else if (Follows(p, "<="))  { p->lookahead = TK_LE; }
	else if (Follows(p, "=="))  { p->lookahead = TK_EQ2; }
	else if (Follows(p, "!="))  { p->lookahead = TK_NE; }
	else if (Follows(p, ">="))  { p->lookahead = TK_GE; }
	else if (Follows(p, "=~"))  { p->lookahead = TK_REEQ; }
	else if (Follows(p, "!~"))  { p->lookahead = TK_RENE; }
	else if (c == '=')          { p->lookahead = TK_EQ; }
	else if (c == '<')          { p->lookahead = TK_LT; }
	else if (c == '>')          { p->lookahead = TK_GT; }
    else if (c == '+')          { p->lookahead = TK_PLUS; }
    else if (c == '*')          { p->lookahead = TK_ASTERISK; }
    else if (c == '-')          { p->lookahead = TK_MINUS; }
	else if (c == '/')			{ p->lookahead = TK_SLASH; }
    else if (c == '(')          { p->lookahead = TK_BR_O; }
    else if (c == ')')          { p->lookahead = TK_BR_C; }
	else if (c == ',')          { p->lookahead = TK_COMMA; }
    else if ((c >= '0' && c <= '9') || c == '.') {  // isdigit screamed with debug warnings here in some occasions
		int dbl = 0;
		const char *cp = p->string + p->pos;
		while (isdigit(*cp) || *cp == '.') {
			if (*cp++ == '.') dbl++;
		}

		if (dbl == 0)		{ p->lookahead = TK_INTEGER; }
		else if (dbl == 1)	{ p->lookahead = TK_DOUBLE; }
		else				{ SetError(p, ERR_MALFORMED_NUM); }
	}
    else if (c == '%') { p->lookahead = TK_VAR; }
	else p->lookahead = TK_STR;
}

LOCAL expr_val Match_Var(EParser p)
{
	char varname[MAX_VAR_NAME];
	char *wp = varname;
	size_t vnlen = 0;

	// var name can start with % sign
	if (p->string[p->pos] == '%' || p->string[p->pos] == '$') p->pos++;

	while (p->string[p->pos] && (isalpha(p->string[p->pos]) ||  p->string[p->pos] == '_') && vnlen < sizeof(varname))
	{
		*wp++ = *(p->string + p->pos++);
		vnlen++;
	}
	*wp = '\0';

    Next_Token(p);

	return p->varfnc ? p->varfnc(varname) : Get_Expr_Dummy();
}

LOCAL expr_val Match_String(EParser p)
{
	expr_val ret = {0};
	size_t len = 0;
	int startpos = p->pos;
	char firstc = p->string[startpos];

	if (firstc == '\'') {
		p->pos++; startpos++;
		while (p->string[p->pos] && p->string[p->pos] != '\'') {
			len++; p->pos++;
		}
		p->pos++;	// skip the '
	} else if (firstc == '\"') {
		p->pos++; startpos++;
		while (p->string[p->pos] && p->string[p->pos] != '\"') {
			len++; p->pos++;
		}
		p->pos++;	// skip the "
	} else {
		/*
		 * FIXME is iswspace behaves same on Windows, Linux, MacOSX and FreeBSD?
		 */
		while (p->string[p->pos] && !iswspace(p->string[p->pos])) {
			len++; p->pos++;
		}
	}

	ret.type = ET_STR;
	ret.s_val = (char *) malloc(len+1);
	if (!ret.s_val) {
		SetError(p, ERR_OUT_OF_MEM);
		return Get_Expr_Dummy();
	}
	strlcpy(ret.s_val, p->string + startpos, len+1);

	Next_Token(p);

	return ret;
}

// check if we are reading string we expected, return it's value (if any)
// and move the reading position
LOCAL expr_val Match(EParser p, int token)
{
#define UNEXP_CHAR(p) { \
    SetError(p, ERR_UNEXPECTED_CHAR); \
    return ret; \
}
    char c;
    expr_val ret = Get_Expr_Dummy();

    switch (token)
    {
    case TK_DOUBLE:
        // add error check here
		ret.type = ET_DBL;
		ret.d_val = atof(p->string + p->pos);
        while (c = CURCHAR(p), c && (isdigit(c) || c == '.')) p->pos++;
        Next_Token(p);
        break;

	case TK_INTEGER:
		ret.type = ET_INT;
		ret.i_val = atoi(p->string + p->pos);
		while (c = CURCHAR(p), c && isdigit(c)) p->pos++;
		Next_Token(p);
		break;

    case TK_VAR:
        // add error check here
        return Match_Var(p);

	case TK_STR:
		return Match_String(p);

	case TK_AND:
		if		(Follows(p, "and")) { p->pos += 3; Next_Token(p); }
		else if (Follows(p, "AND")) { p->pos += 3; Next_Token(p); }
		else if (Follows(p, "&&"))  { p->pos += 2; Next_Token(p); }
		else UNEXP_CHAR(p);
		break;

	case TK_OR:
		if		(Follows(p, "or")) { p->pos += 2; Next_Token(p); }
		else if (Follows(p, "OR")) { p->pos += 2; Next_Token(p); }
		else if (Follows(p, "||"))  { p->pos += 2; Next_Token(p); }
		else UNEXP_CHAR(p);
		break;

    case TK_BR_O:
        if (!Follows(p, "(")) UNEXP_CHAR(p);
        p->pos++;
        Next_Token(p);
        break;

    case TK_BR_C:
        if (!Follows(p, ")")) UNEXP_CHAR(p);
        p->pos++;
        Next_Token(p);
        break;

    case TK_PLUS:
        if (!Follows(p, "+")) UNEXP_CHAR(p);
        p->pos++;
        Next_Token(p);
        break;

    case TK_ASTERISK:
        if (!Follows(p, "*")) UNEXP_CHAR(p);
        p->pos++;
        Next_Token(p);
        break;

	case TK_SLASH:
		if (!Follows(p, "/")) UNEXP_CHAR(p);
		p->pos++;
		Next_Token(p);
		break;

    case TK_MINUS:
        if (!Follows(p, "-")) UNEXP_CHAR(p);
        p->pos++;
        Next_Token(p);
        break;

	case TK_LT:
		if (!Follows(p, "<")) UNEXP_CHAR(p);
		p->pos++; Next_Token(p);
		break;

	case TK_LE:
		if (!Follows(p, "<=")) UNEXP_CHAR(p);
		p->pos += 2; Next_Token(p);
		break;

	case TK_EQ:
		if (!Follows(p, "=")) UNEXP_CHAR(p);
		p->pos++; Next_Token(p);
		break;

	case TK_EQ2:
		if (!Follows(p, "==")) UNEXP_CHAR(p);
		p->pos += 2; Next_Token(p);
		break;

	case TK_NE:
		if (!Follows(p, "!=") && !Follows(p, "<>")) UNEXP_CHAR(p);
		p->pos += 2; Next_Token(p);
		break;

	case TK_GE:
		if (!Follows(p, ">=")) UNEXP_CHAR(p);
		p->pos += 2; Next_Token(p);
		break;

	case TK_GT:
		if (!Follows(p, ">")) UNEXP_CHAR(p);
		p->pos++; Next_Token(p);
		break;

	case TK_ISIN:
		if (!Follows(p, "isin")) UNEXP_CHAR(p);
		p->pos += 4; Next_Token(p);
		break;

	case TK_NISIN:
		if (!Follows(p, "!isin")) UNEXP_CHAR(p);
		p->pos += 5; Next_Token(p);
		break;

	case TK_REEQ:
		if (!Follows(p, "=~")) UNEXP_CHAR(p);
		p->pos += 2; Next_Token(p);
		break;

	case TK_RENE:
		if (!Follows(p, "!~")) UNEXP_CHAR(p);
		p->pos += 2; Next_Token(p);
		break;

	case TK_MOD:
		if (!Follows(p, "mod")) UNEXP_CHAR(p);
		p->pos += 3; Next_Token(p);
		break;

	case TK_XOR:
		if (!Follows(p, "xor")) UNEXP_CHAR(p);
		p->pos += 3; Next_Token(p);
		break;

	case TK_DIV:
		if (!Follows(p, "div")) UNEXP_CHAR(p);
		p->pos += 3; Next_Token(p);
		break;

	case TK_STRLEN:
		if (!Follows(p, "strlen")) UNEXP_CHAR(p);
		p->pos += 6; Next_Token(p);
		break;

	case TK_INT:
		if (!Follows(p, "int")) UNEXP_CHAR(p);
		p->pos += 3; Next_Token(p);
		break;

	case TK_SUBSTR:
		if (!Follows(p, "substr")) UNEXP_CHAR(p);
		p->pos += 6; Next_Token(p);
		break;

	case TK_POS:
		if (!Follows(p, "pos")) UNEXP_CHAR(p);
		p->pos += 3; Next_Token(p);
		break;

	case TK_TOBROWN:
		if (!Follows(p, "tobrown")) UNEXP_CHAR(p);
		p->pos += 7; Next_Token(p);
		break;

	case TK_TOWHITE:
		if (!Follows(p, "towhite")) UNEXP_CHAR(p);
		p->pos += 7; Next_Token(p);
		break;

	case TK_COMMA:
		if (!Follows(p, ",")) UNEXP_CHAR(p);
		p->pos += 1; Next_Token(p);
		break;
    }

    return ret;
}


/*

Following code represents this grammar

 S -> C
 C -> BC'
 C'-> orBC'
 C'-> lambda
 B -> EB'
 B'-> <EB'
 B'-> lambda
 E -> TE'
 E'-> +TE'
 E'-> lambda
 T -> FT'
 T'-> *FT'
 T'-> lambda
 F -> (C)
 F -> var
 F -> number
 F -> fnc(C)

 which came from following grammar after eliminating left recursion
 C -> C or B
 C -> B
 B -> B < E
 B -> E
 E -> E + T
 E -> T
 T -> T * F
 T -> F
 F -> (C)
 F -> var
 F -> number
 F -> fnc(C)

*/

LOCAL expr_val C(EParser p);

LOCAL expr_val F(EParser p)
{
	switch (p->lookahead)
    {
	case TK_BR_O: {
		expr_val m;
        Match(p, TK_BR_O); m = C(p); Match(p, TK_BR_C);
        return m;
		}
	case TK_VAR:
		return Match(p, TK_VAR);
	case TK_STR:
		return Match(p, TK_STR);
    case TK_DOUBLE:
		return Match(p, TK_DOUBLE);
	case TK_INTEGER:
		return Match(p, TK_INTEGER);
    case TK_MINUS:
		Match(p, TK_MINUS);
		return operator_minus(p, F(p));
	case TK_STRLEN:
		Match(p, TK_STRLEN);
		return operator_strlen(p, F(p));
	case TK_SUBSTR: {
		expr_val arg1, arg2, arg3;
		Match(p, TK_SUBSTR);
		Match(p, TK_BR_O);
		arg1 = F(p);
		Match(p, TK_COMMA);
		arg2 = F(p);
		Match(p, TK_COMMA);
		arg3 = F(p);
		Match(p, TK_BR_C);
		return operator_substr(p, arg1, arg2, arg3);
		}
	case TK_POS: {
		expr_val arg1, arg2;
		Match(p, TK_POS);
		Match(p, TK_BR_O);
		arg1 = F(p);
		Match(p, TK_COMMA);
		arg2 = F(p);
		Match(p, TK_BR_C);
		return operator_pos(p, arg1, arg2);
		}
	case TK_INT:
		Match(p, TK_INT);
		return operator_int(p, F(p));
	case TK_TOBROWN:
		Match(p, TK_TOBROWN);
		return operator_tobrown(p, F(p));
	case TK_TOWHITE:
		Match(p, TK_TOWHITE);
		return operator_towhite(p, F(p));
	default:
		SetError(p, ERR_INVALID_TOKEN);
		return Get_Expr_Dummy();
    }
}

LOCAL expr_val Tap(EParser p, expr_val v)
{
	switch (p->lookahead) {
	case TK_ASTERISK: Match(p, TK_ASTERISK);
        return operator_multiply(p, v, Tap(p, F(p)));
	case TK_SLASH: Match(p, TK_SLASH);
		return operator_multiply(p, v, Tap(p, operator_divide(p, F(p))));
	case TK_MOD: Match(p, TK_MOD);
		return operator_modulo(p, v, Tap(p, F(p)));
	case TK_XOR: Match(p, TK_XOR);
		return operator_xor(p, v, Tap(p, F(p)));
	case TK_DIV: Match(p, TK_DIV);
		return operator_divint(p, v, Tap(p, F(p)));
	default: return v;
	}
}

LOCAL expr_val T(EParser p) { return Tap(p, F(p)); }

LOCAL expr_val Eap(EParser p, expr_val v)
{
	switch (p->lookahead) {
	case TK_PLUS: Match(p, TK_PLUS);
		return operator_plus(p, v, Eap(p,T(p)));
	case TK_MINUS: Match(p, TK_MINUS);
		return operator_plus(p, v, Eap(p, operator_minus(p, T(p))));
	default: return v;
	}
}

LOCAL expr_val E(EParser p) { return Eap(p, T(p)); }

LOCAL expr_val Bap(EParser p, expr_val v)
{
	switch (p->lookahead) {
	case TK_LT: Match(p, TK_LT); return operator_lt(p, v, Bap(p, E(p)));
	case TK_LE: Match(p, TK_LE); return operator_le(p, v, Bap(p, E(p)));
	case TK_EQ: Match(p, TK_EQ); return operator_eq(p, v, Bap(p, E(p)));
	case TK_EQ2: Match(p, TK_EQ2); return operator_eq(p, v, Bap(p, E(p)));
	case TK_NE: Match(p, TK_NE); return operator_ne(p, v, Bap(p, E(p)));
	case TK_GE: Match(p, TK_GE); return operator_ge(p, v, Bap(p, E(p)));
	case TK_GT: Match(p, TK_GT); return operator_gt(p, v, Bap(p, E(p)));
	case TK_ISIN: Match(p, TK_ISIN); return operator_isin(p, v, Bap(p, E(p)));
	case TK_NISIN: Match(p, TK_NISIN); return operator_nisin(p, v, Bap(p, E(p)));
	case TK_REEQ: Match(p, TK_REEQ); return operator_reeq(p, v, Bap(p, E(p)));
	case TK_RENE: Match(p, TK_RENE); return operator_rene(p, v, Bap(p, E(p)));
	default: return v;
	}
}

LOCAL expr_val B(EParser p) { return Bap(p, E(p)); }

LOCAL expr_val Cap(EParser p, expr_val v)
{
	switch (p->lookahead) {
	case TK_AND: Match(p, TK_AND);
		return operator_and(p, v, Cap(p, B(p)));
	case TK_OR: Match(p, TK_OR);
		return operator_or(p, v, Cap(p, B(p)));
	default: return v;
	}
}

LOCAL expr_val C(EParser p) { return Cap(p, B(p)); }

LOCAL expr_val S(EParser p) { return C(p); }

// -- grammar end --

GLOBAL const char* Parser_Error_Description(int error)
{
	switch (error) {
	case EXPR_EVAL_SUCCESS:		return "Evaluation succeeded";
	case ERR_INVALID_TOKEN:		return "Invalid token found";
	case ERR_UNEXPECTED_CHAR:	return "Unexpected character";
	case ERR_TYPE_MISMATCH:		return "Type mismatch";
	case ERR_ZERO_DIV:			return "Division by zero";
	case ERR_NOTIMPL:			return "Operation not implemented";
	case ERR_MALFORMED_NUM:		return "Malformed number found";
	case ERR_OUT_OF_MEM:		return "Out of memory";
	case ERR_INTERNAL:			return "Internal error";
	case ERR_REGEXP:			return "Regexp error";
	case ERR_INVALID_ARG:       return "Invalid argument";
	default:					return "Unknown error";
	}
}

LOCAL void Init_Parser(EParser p, const parser_extra* f, const char *str)
{
    p->pos = 0;
    p->error = EXPR_EVAL_SUCCESS;
    p->string = str;
	p->varfnc = f ? f->var2val_fnc : 0;
	p->re_patfnc = f ? f->subpatt_fnc : 0;
    Next_Token(p);
}

/// Evaluates an expression represented by a string
///
/// \param[in]	str		expression to be evaluated
/// \param[in]	f		extra parser options
/// \param[out]	error	error level
/// \return Returns the result of the evaluation of the expression, it's type and value
GLOBAL expr_val Expr_Eval(const char *str, const parser_extra* f, int *error)
{
    expr_parser_t p;
	expr_val e;
    Init_Parser(&p, f, str);
	e = S(&p);
	*error = p.error;
	return e;
}

GLOBAL int Expr_Eval_Int(const char *str, const parser_extra* f, int *result)
{
	int err;
	expr_val e;

	e = Expr_Eval(str, f, &err);
	if (err == EXPR_EVAL_SUCCESS) *result = Get_Integer(e);

	return err;
}

GLOBAL int Expr_Eval_Double(const char *str, const parser_extra* f, double *result)
{
	int err;
	expr_val e;

	e = Expr_Eval(str, f, &err);
	if (err == EXPR_EVAL_SUCCESS) *result = Get_Double(e);

    return err;
}

GLOBAL int Expr_Eval_Bool(const char* str, const parser_extra* f, int *result)
{
	int err;
	expr_val e;

	e = Expr_Eval(str, f, &err);
	if (err == EXPR_EVAL_SUCCESS) *result = Get_Bool(e);

    return err;
}

LOCAL int Expr_Run_Test_Core(const char *str, const expr_val expected_result, int expected_error)
{
	int real_error;
	expr_val real_result = Expr_Eval(str, NULL, &real_error);
	if (expected_error == real_error) {
		if (expected_error == EXPR_EVAL_SUCCESS) {
			if (expected_result.type == real_result.type) {
				switch (expected_result.type) {
					case ET_INT: return (expected_result.i_val == real_result.i_val) ? 0 : -1;
					case ET_DBL: return ((fabs(expected_result.d_val - real_result.d_val) < 0.000001) ? 0 : -1);
					case ET_BOOL: return (expected_result.b_val == real_result.b_val) ? 0 : -1;
					case ET_STR: {
						int equal = (strcmp(expected_result.s_val, real_result.s_val) == 0);
						Q_free(real_result.s_val);

						return (equal ? 0 : -1);
					}
					default: return -4;
				}
			}
			else {
				return -2;
			}
		}
		else { // expected error happened
			return 0;
		}
	}
	else {
		return -3;
	}
}

LOCAL int Expr_Run_Test(const char *str, const expr_val expected_result, int expected_error)
{
	void Com_Printf (char *fmt, ...);
	int res = Expr_Run_Test_Core(str, expected_result, expected_error);
	if (res != 0) {
		Com_Printf("Test '%s' failed with error %d\n", str, res);
		res = 1;
	}
	return res;
}

LOCAL int Expr_Run_Test_Int(const char *str, int val)
{
	return Expr_Run_Test(str, Get_Expr_Integer(val), EXPR_EVAL_SUCCESS);
}

LOCAL int Expr_Run_Test_Bool(const char *str, int val)
{
	return Expr_Run_Test(str, Get_Expr_Bool(val), EXPR_EVAL_SUCCESS);
}

LOCAL int Expr_Run_Test_Double(const char *str, double val)
{
	return Expr_Run_Test(str, Get_Expr_Double(val), EXPR_EVAL_SUCCESS);
}

LOCAL int Expr_Run_Test_Error(const char *str, int error)
{
	return Expr_Run_Test(str, Get_Expr_Dummy(), error);
}

LOCAL int Expr_Run_Test_Str(const char *str, const char *val)
{
	expr_val eval = Get_Expr_String(val);
	int res = Expr_Run_Test(str, eval, EXPR_EVAL_SUCCESS);
	Q_free(eval.s_val);
	return res;
}

GLOBAL int Expr_Run_Unit_Tests(void)
{
	int errors = 0;

	errors += Expr_Run_Test_Int("0", 0);
	errors += Expr_Run_Test_Int("-1", -1);
	errors += Expr_Run_Test_Int("   100 ", 100);
	errors += Expr_Run_Test_Int("1+2+3+4+5+6", 1+2+3+4+5+6);
	errors += Expr_Run_Test_Double("4+2/6+9.1-4*(4*7+2.5-4/2*(42/9+2.075)-8-3-12)-9+21*4",
		112.366667);
	
	errors += Expr_Run_Test_Error("2+4/(3-1-0.5-0.5-0.25-0.75)", ERR_ZERO_DIV);

	errors += Expr_Run_Test_Double("3.33333", 3.33333);
	errors += Expr_Run_Test_Double("-0.0001", -0.0001);
	errors += Expr_Run_Test_Double("10.0/3.0", 10.0/3.0);

	errors += Expr_Run_Test_Bool("0+1 > 1+0", 0);
	errors += Expr_Run_Test_Bool("0+1 >= 1+0", 1);
	errors += Expr_Run_Test_Bool("0+1 < 1+0", 0);
	errors += Expr_Run_Test_Bool("0+1+2 <= 2+1+0", 1);
	errors += Expr_Run_Test_Bool("123==123", 1);
	errors += Expr_Run_Test_Bool("1051=1052", 0);
	errors += Expr_Run_Test_Bool("1051!=1052", 1);

	errors += Expr_Run_Test_Bool("\"x\" isin \"x\"", 1);
	errors += Expr_Run_Test_Bool("\"x\" isin \"xaaa\"", 1);
	errors += Expr_Run_Test_Bool("\"x\" isin \"aaax\"", 1);
	errors += Expr_Run_Test_Bool("\"x\" isin \"aaa\"", 0);
	errors += Expr_Run_Test_Bool("\"x\" !isin \"aaa\"", 1);

	errors += Expr_Run_Test_Int("10 mod 3", 10 % 3);
	errors += Expr_Run_Test_Int("12643 xor 18061", 12643 ^ 18061);
	errors += Expr_Run_Test_Int("123 div 11", 123/11);

	errors += Expr_Run_Test_Int("strlen \"1234\"", 4);
	errors += Expr_Run_Test_Int("int 4.4", 4);
	errors += Expr_Run_Test_Int("int 4.6", 4);
	errors += Expr_Run_Test_Str("substr(\"abcd\", 3, 30)", "d");
	errors += Expr_Run_Test_Str("substr(\"abcdef\", 0, 2)", "ab");
	errors += Expr_Run_Test_Str("substr(\"abcdef\", 2, 1)", "c");

	errors += Expr_Run_Test_Bool("(1 and 0) or (0 and 2) or (0 xor 0)", 0);
	errors += Expr_Run_Test_Bool("(1 and 0) or (0 and 2) or (0 xor 1)", 1);
	errors += Expr_Run_Test_Bool("0 or 0 or 0 or 0 or 1 or 0 or 0 or 0", 1);
	errors += Expr_Run_Test_Bool("1 and 1 and 1 and 1 and 0 and 1 and 1", 0);
	errors += Expr_Run_Test_Bool("1 and 1 and 1 and 1 and 2 and 1 and 1", 1);
	errors += Expr_Run_Test_Bool("1<2 && 3<4 && 5<=5 && 6<=7 && 8>=8 && 10>9", 1);

	errors += Expr_Run_Test_Bool("(abc isin dabcd or (x !isin xxxx and 3 < 5)) and 'a'+'bc' isin 'dab'+'cd'", 1);

	// todo: tobrown, towhite

	return errors;
}



================================================
FILE: src/parser.h
================================================
/*
Copyright (C) 2011 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
	\file

	\brief
	This module allows you to evaluate string representation
	of an arithmetic expression into a number

	Supports:
	- parentheses (, )
	- binary operators:
          - +, -, *, / (arithmetic, also + for string concatenation)
		  - <, <=, =, ==, >=, >, =~, !~, isin, !isin
		  - and, AND, &&, or, OR, ||
	- unary operators: -
	- types: double, integer, bool,
	    string (wrapped in quotes or apostrophes or surrounded by white-space chars)
	- variables: optionally preceded with '%'

	\author	johnnycz
**/

#ifndef __PARSER_H__
#define __PARSER_H__

#define MAX_VAR_NAME		32

#define EXPR_EVAL_SUCCESS	0

/// type of an expression
typedef enum { 
	ET_INT,		///< integer
	ET_DBL,		///< double
	ET_BOOL,	///< boolean
	ET_STR		///< string
} expr_type;

/// expression value and type
typedef struct expr_val {
	expr_type type;	///< type of an expression
	int i_val;		///< integer value
	double d_val;	///< double value
	int b_val;		///< boolean value
	char *s_val;	///< string value
} expr_val;

/// \brief Gets value of an user variable found in an expression during the evaluation
///
/// \param[in] varname name of the user variable
/// \return Value of the user variable
typedef expr_val (* variable_val_fnc) (const char* varname);

/// \brief Regexp match handler
///
/// Gets called when the expression parser does a regexp match
///
/// \param[in] str		source string
/// \param[in] offsets	array of offset pairs (start1,end1,start2,end2,...)
/// \param[in] matches	number of captured groups
typedef void (* subpatterns_report_fnc) (const char* str, size_t* offsets, int matches);

/// expression parser's extra options
typedef struct {
	/// pointer to the function that returns values of the user variables
	variable_val_fnc		var2val_fnc;

	/// pointer to the function that handles regexp matches
	subpatterns_report_fnc	subpatt_fnc;
} parser_extra;

// conversion functions
extern expr_val Get_Expr_Double(double v);
extern expr_val Get_Expr_Integer(int v);
extern expr_val Get_Expr_Dummy(void);

// given the number of the error, you'll get brief description of that error
extern const char* Parser_Error_Description(int error);

// evaluate str, write the result and return error level
extern expr_val Expr_Eval(const char* str, const parser_extra*, int* error);
extern int Expr_Eval_Int(const char *str, const parser_extra*, int *result);
extern int Expr_Eval_Double(const char *str, const parser_extra*, double *result);
extern int Expr_Eval_Bool(const char* std, const parser_extra*, int *result);

// run unit tests, return number of errors
int Expr_Run_Unit_Tests(void);

#endif // __PARSER_H__


================================================
FILE: src/particles_classic.h
================================================

#ifndef PARTICLES_CLASSIC_HEADER
#define PARTICLES_CLASSIC_HEADER

typedef enum {
	pt_static, pt_grav, pt_slowgrav, pt_fire, pt_explode, pt_explode2, pt_blob, pt_blob2, pt_rail
} ptype_t;

typedef struct qparticle_s {
	vec3_t      org;
	float       color;
	vec3_t      vel;
	float       ramp;
	float       die;
	ptype_t     type;
	//struct particle_s *next;
} qparticle_t;

//#define DEFAULT_NUM_PARTICLES	2048
#define ABSOLUTE_MIN_PARTICLES	512
#define ABSOLUTE_MAX_PARTICLES	8192

#endif // PARTICLES_CLASSIC_HEADER


================================================
FILE: src/pmove.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "quakedef.h"
#include "pmove.h"
#endif

movevars_t      movevars;
playermove_t    pmove;

static float	pm_frametime;

static vec3_t	pm_forward, pm_right;

static vec3_t   groundnormal;

vec3_t	player_mins = {-16, -16, -24};
vec3_t	player_maxs = {16, 16, 32};

#define STEPSIZE        18

#define pm_flyfriction	4

#define BLOCKED_FLOOR	1
#define BLOCKED_STEP	2
#define BLOCKED_OTHER	4
#define BLOCKED_ANY		7

#define MAX_JUMPFIX_DOTPRODUCT -0.1

// Add an entity to touch list, discarding duplicates
static void PM_AddTouchedEnt (int num)
{
	int i;

	if (pmove.numtouch == sizeof(pmove.touchindex)/sizeof(pmove.touchindex[0]))
		return;

	for (i = 0; i < pmove.numtouch; i++)
		if (pmove.touchindex[i] == num)
			return; // already added

	pmove.touchindex[pmove.numtouch] = num;
	pmove.numtouch++;
}

//Slide off of the impacting object
//returns the blocked flags (1 = floor, 2 = step / wall)
#define STOP_EPSILON 0.1
static void PM_ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
{
	float backoff, change;
	int i;

	backoff = DotProduct (in, normal) * overbounce;

	for (i = 0; i < 3; i++) {
		change = normal[i] * backoff;
		out[i] = in[i] - change;
		if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
			out[i] = 0;
	}
}

//The basic solid body movement clip that slides along multiple planes
#define	MAX_CLIP_PLANES 5
static int PM_SlideMove (void)
{
	vec3_t dir, planes[MAX_CLIP_PLANES], primal_velocity, original_velocity, end;
	int bumpcount, numbumps, i, j, blocked, numplanes;
	float d, time_left;
	trace_t trace;

	numbumps = 4;
	blocked = 0;
	VectorCopy (pmove.velocity, original_velocity);
	VectorCopy (pmove.velocity, primal_velocity);
	numplanes = 0;

	time_left = pm_frametime;

	for (bumpcount = 0; bumpcount < numbumps; bumpcount++) {
		VectorMA(pmove.origin, time_left, pmove.velocity, end);
		trace = PM_PlayerTrace (pmove.origin, end);

		if (trace.startsolid || trace.allsolid) {
			// entity is trapped in another solid
			VectorClear (pmove.velocity);
			return 3;
		}

		if (trace.fraction > 0) {
			// actually covered some distance
			VectorCopy (trace.endpos, pmove.origin);
			numplanes = 0;
		}

		if (trace.fraction == 1) {
			break; // moved the entire distance
		}

		// save entity for contact
		PM_AddTouchedEnt (trace.e.entnum);

		if (trace.plane.normal[2] >= MIN_STEP_NORMAL)
			blocked |= BLOCKED_FLOOR;
		else if (!trace.plane.normal[2])
			blocked |= BLOCKED_STEP;
		else
			blocked |= BLOCKED_OTHER;

		time_left -= time_left * trace.fraction;

		// cliped to another plane
		if (numplanes >= MAX_CLIP_PLANES) {
			// this shouldn't really happen
			VectorClear (pmove.velocity);
			break;
		}

		VectorCopy (trace.plane.normal, planes[numplanes]);
		numplanes++;

		// modify original_velocity so it parallels all of the clip planes
		for (i = 0; i < numplanes; i++) {
			PM_ClipVelocity (original_velocity, planes[i], pmove.velocity, 1);
			for (j = 0; j < numplanes; j++) {
				if (j != i) {
					if (DotProduct(pmove.velocity, planes[j]) < 0) {
						break; // not ok
					}
				}
			}
			if (j == numplanes) {
				break;
			}
		}

		if (i != numplanes) {
			// go along this plane
		}
		else {
			// go along the crease
			if (numplanes != 2) {
				VectorClear (pmove.velocity);
				break;
			}
			CrossProduct (planes[0], planes[1], dir);
			d = DotProduct (dir, pmove.velocity);
			VectorScale (dir, d, pmove.velocity);
		}

		// if velocity is against the original velocity, stop dead
		// to avoid tiny occilations in sloping corners
		if (DotProduct (pmove.velocity, primal_velocity) <= 0) {
			VectorClear (pmove.velocity);
			break;
		}
	}

	if (pmove.waterjumptime) {
		VectorCopy(primal_velocity, pmove.velocity);
	}

	return blocked;
}

//Each intersection will try to step over the obstruction instead of sliding along it.
static int PM_StepSlideMove (qbool in_air)
{
	vec3_t original, originalvel, down, up, downvel, dest;
	float downdist, updist, stepsize;
	trace_t trace;
	int blocked;

	// try sliding forward both on ground and up 16 pixels
	// take the move that goes farthest
	VectorCopy (pmove.origin, original);
	VectorCopy (pmove.velocity, originalvel);

	blocked = PM_SlideMove ();

	if (!blocked) {
		return blocked; // moved the entire distance
	}

	if (in_air) {
		// don't let us step up unless it's indeed a step we bumped in
		// (that is, there's solid ground below)
		float *org;

		if (!(blocked & BLOCKED_STEP)) {
			return blocked;
		}

		org = (originalvel[2] < 0) ? pmove.origin : original;
		VectorCopy (org, dest);
		dest[2] -= STEPSIZE;
		trace = PM_PlayerTrace (org, dest);
		if (trace.fraction == 1 || trace.plane.normal[2] < MIN_STEP_NORMAL) {
			return blocked;
		}

		// adjust stepsize, otherwise it would be possible to walk up a
		// a step higher than STEPSIZE
		stepsize = STEPSIZE - (org[2] - trace.endpos[2]);
	}
	else {
		stepsize = STEPSIZE;
	}

	VectorCopy (pmove.origin, down);
	VectorCopy (pmove.velocity, downvel);

	VectorCopy (original, pmove.origin);
	VectorCopy (originalvel, pmove.velocity);

	// move up a stair height
	VectorCopy (pmove.origin, dest);
	dest[2] += stepsize;
	trace = PM_PlayerTrace (pmove.origin, dest);
	if (!trace.startsolid && !trace.allsolid) {
		VectorCopy(trace.endpos, pmove.origin);
	}

	if (in_air && originalvel[2] < 0) {
		pmove.velocity[2] = 0;
	}

	PM_SlideMove ();

	// press down the stepheight
	VectorCopy (pmove.origin, dest);
	dest[2] -= stepsize;
	trace = PM_PlayerTrace (pmove.origin, dest);
	if (trace.fraction != 1 && trace.plane.normal[2] < MIN_STEP_NORMAL) {
		goto usedown;
	}
	if (!trace.startsolid && !trace.allsolid) {
		VectorCopy(trace.endpos, pmove.origin);
	}

	if (pmove.origin[2] < original[2]) {
		goto usedown;
	}

	VectorCopy (pmove.origin, up);

	// decide which one went farther
	downdist = (down[0] - original[0]) * (down[0] - original[0])
		+ (down[1] - original[1]) * (down[1] - original[1]);
	updist = (up[0] - original[0]) * (up[0] - original[0])
		+ (up[1] - original[1]) * (up[1] - original[1]);

	if (downdist >= updist) {
usedown:
		VectorCopy (down, pmove.origin);
		VectorCopy (downvel, pmove.velocity);
		return blocked;
	}

	// copy z value from slide move
	pmove.velocity[2] = downvel[2];

	if (!pmove.onground && pmove.waterlevel < 2 && (blocked & BLOCKED_STEP)) {
		float scale;
		// in pm_airstep mode, walking up a 16 unit high step
		// will kill 16% of horizontal velocity
		scale = 1 - 0.01*(pmove.origin[2] - original[2]);
		pmove.velocity[0] *= scale;
		pmove.velocity[1] *= scale;
	}

	return blocked;
}

//Handles both ground friction and water friction
static void PM_Friction(void)
{
	float speed, newspeed, control, friction, drop;
	vec3_t start, stop;
	trace_t trace;

	if (pmove.waterjumptime)
		return;

	speed = VectorLength(pmove.velocity);
	if (speed < 1) {
		pmove.velocity[0] = pmove.velocity[1] = 0;
		if (pmove.pm_type == PM_FLY) {
			pmove.velocity[2] = 0;
		}
		return;
	}

	if (pmove.waterlevel >= 2) {
		// apply water friction, even if in fly mode
		drop = speed * movevars.waterfriction * pmove.waterlevel * pm_frametime;
	}
	else if (pmove.pm_type == PM_FLY) {
		// apply flymode friction
		drop = speed * pm_flyfriction * pm_frametime;
	}
	else if (pmove.onground) {
		// apply ground friction
		friction = movevars.friction;

		// if the leading edge is over a dropoff, increase friction
		start[0] = stop[0] = pmove.origin[0] + pmove.velocity[0] / speed * 16;
		start[1] = stop[1] = pmove.origin[1] + pmove.velocity[1] / speed * 16;
		start[2] = pmove.origin[2] + player_mins[2];
		stop[2] = start[2] - 34;
		trace = PM_PlayerTrace(start, stop);
		if (trace.fraction == 1) {
			friction *= 2;
		}

		control = speed < movevars.stopspeed ? movevars.stopspeed : speed;
		drop = control * friction * pm_frametime;
	}
	else {
		return; // in air, no friction
	}

	// scale the velocity
	newspeed = speed - drop;
	newspeed = max(newspeed, 0);
	newspeed /= speed;

	VectorScale(pmove.velocity, newspeed, pmove.velocity);
}

static void PM_Accelerate(vec3_t wishdir, float wishspeed, float accel)
{
	float addspeed, accelspeed, currentspeed;

	if (pmove.pm_type == PM_DEAD)
		return;
	if (pmove.waterjumptime)
		return;

	currentspeed = DotProduct(pmove.velocity, wishdir);
	addspeed = wishspeed - currentspeed;
	if (addspeed <= 0)
		return;
	accelspeed = accel * pm_frametime * wishspeed;
	if (accelspeed > addspeed)
		accelspeed = addspeed;

	VectorMA(pmove.velocity, accelspeed, wishdir, pmove.velocity);
}

#ifndef SERVERONLY
#ifdef EXPERIMENTAL_SHOW_ACCELERATION
qbool player_in_air = false;
float cosinus_val = 0.f;
qbool flag_player_pmove;
#endif
#endif

static void PM_AirAccelerate(vec3_t wishdir, float wishspeed, float accel)
{
	float addspeed, accelspeed, currentspeed, wishspd = wishspeed;
	float originalspeed = 0.0, newspeed = 0.0, speedcap = 0.0;

	if (pmove.pm_type == PM_DEAD)
		return;
	if (pmove.waterjumptime)
		return;

	if (movevars.bunnyspeedcap > 0)
		originalspeed = sqrt(pmove.velocity[0] * pmove.velocity[0] + pmove.velocity[1] * pmove.velocity[1]);

	wishspd = min(wishspd, 30);
	currentspeed = DotProduct(pmove.velocity, wishdir);
	addspeed = wishspd - currentspeed;

#ifdef EXPERIMENTAL_SHOW_ACCELERATION
	if (flag_player_pmove) {
		cosinus_val = 0.f;
		originalspeed = sqrt(pmove.velocity[0] * pmove.velocity[0] + pmove.velocity[1] * pmove.velocity[1]);
		if (originalspeed > 1.f) {
			cosinus_val = currentspeed / originalspeed;
		}

		player_in_air = true;
	}
#endif

	if (addspeed <= 0)
		return;
	accelspeed = accel * wishspeed * pm_frametime;
	accelspeed = min(accelspeed, addspeed);

	VectorMA(pmove.velocity, accelspeed, wishdir, pmove.velocity);

	if (movevars.bunnyspeedcap > 0) {
		newspeed = sqrt(pmove.velocity[0] * pmove.velocity[0] + pmove.velocity[1] * pmove.velocity[1]);
		if (newspeed > originalspeed) {
			speedcap = movevars.maxspeed * movevars.bunnyspeedcap;
			if (newspeed > speedcap) {
				if (originalspeed < speedcap)
					originalspeed = speedcap;
				pmove.velocity[0] *= originalspeed / newspeed;
				pmove.velocity[1] *= originalspeed / newspeed;
			}
		}
	}
}

static int PM_WaterMove(void)
{
	vec3_t wishvel, wishdir;
	float wishspeed;
	int i;

	// user intentions
	for (i = 0; i < 3; i++)
		wishvel[i] = pm_forward[i] * pmove.cmd.forwardmove + pm_right[i] * pmove.cmd.sidemove;

	if (pmove.pm_type != PM_FLY && !pmove.cmd.forwardmove && !pmove.cmd.sidemove && !pmove.cmd.upmove)
		wishvel[2] -= 60; // drift towards bottom
	else
		wishvel[2] += pmove.cmd.upmove;

	VectorCopy(wishvel, wishdir);
	wishspeed = VectorNormalize(wishdir);

	if (wishspeed > movevars.maxspeed) {
		VectorScale(wishvel, movevars.maxspeed / wishspeed, wishvel);
		wishspeed = movevars.maxspeed;
	}
	wishspeed *= 0.7;

	// water acceleration
	PM_Accelerate(wishdir, wishspeed, movevars.wateraccelerate);

	return PM_StepSlideMove(false);
}

static int PM_FlyMove(void)
{
	vec3_t wishvel, wishdir;
	float wishspeed;
	int i;

	for (i = 0; i < 3; i++)
		wishvel[i] = pm_forward[i] * pmove.cmd.forwardmove + pm_right[i] * pmove.cmd.sidemove;

	wishvel[2] += pmove.cmd.upmove;

	VectorCopy(wishvel, wishdir);
	wishspeed = VectorNormalize(wishdir);

	if (wishspeed > movevars.maxspeed) {
		VectorScale(wishvel, movevars.maxspeed / wishspeed, wishvel);
		wishspeed = movevars.maxspeed;
	}

	PM_Accelerate(wishdir, wishspeed, movevars.accelerate);
	return PM_StepSlideMove(false);
}

static int PM_AirMove(void)
{
	float fmove, smove, wishspeed;
	vec3_t wishvel, wishdir;
	int i;

	fmove = pmove.cmd.forwardmove;
	smove = pmove.cmd.sidemove;

	pm_forward[2] = 0;
	pm_right[2] = 0;
	VectorNormalize(pm_forward);
	VectorNormalize(pm_right);

	for (i = 0; i < 2; i++)
		wishvel[i] = pm_forward[i] * fmove + pm_right[i] * smove;
	wishvel[2] = 0;

	VectorCopy(wishvel, wishdir);
	wishspeed = VectorNormalize(wishdir);

	// clamp to server defined max speed
	if (wishspeed > movevars.maxspeed) {
		VectorScale(wishvel, movevars.maxspeed / wishspeed, wishvel);
		wishspeed = movevars.maxspeed;
	}

	if (pmove.onground) {
		if (movevars.slidefix) {
			pmove.velocity[2] = min(pmove.velocity[2], 0); // bound above by 0
			PM_Accelerate(wishdir, wishspeed, movevars.accelerate);
			// add gravity
			pmove.velocity[2] -= movevars.entgravity * movevars.gravity * pm_frametime;
		}
		else {
			pmove.velocity[2] = 0;
			PM_Accelerate(wishdir, wishspeed, movevars.accelerate);
		}

		if (!pmove.velocity[0] && !pmove.velocity[1]) {
			pmove.velocity[2] = 0;
			return 0;
		}

		return PM_StepSlideMove(false);
	}
	else {
		int blocked;
		// not on ground, so little effect on velocity
		PM_AirAccelerate(wishdir, wishspeed, movevars.accelerate);

		// add gravity
		pmove.velocity[2] -= movevars.entgravity * movevars.gravity * pm_frametime;

		if (movevars.airstep)
			blocked = PM_StepSlideMove(true);
		else
			blocked = PM_SlideMove();

		if (movevars.pground) {
			if (blocked & BLOCKED_FLOOR) {
				pmove.onground = true;
			}
		}

		return blocked;
	}
}

#define MAXGROUNDSPEED_DEFAULT 180
#define MAXGROUNDSPEED_MAXIMUM 240

static void PM_RampEdgeAdjustNormal(vec3_t normal, int flags)
{
	int i;

	for (i = 0; i < 3; ++i) {
		if (flags & (PHYSICSNORMAL_FLIPX << i)) {
			if (pmove.velocity[i] < 0) {
				normal[i] = -normal[i];
			}
			else if (pmove.velocity[0] == 0) {
				normal[i] = 0;
			}
		}
	}
}

#define PM_FarFromGround(trace) (((trace).fraction == 1 || (trace).plane.normal[2] < MIN_STEP_NORMAL))

static trace_t PM_CategorizePositionRunTrace(vec3_t point)
{
	trace_t trace = { 0 };

	trace = PM_PlayerTrace(pmove.origin, point);
	if (!PM_FarFromGround(trace)) {
		VectorCopy(trace.plane.normal, groundnormal);
	}

	return trace;
}

void PM_CategorizePosition(void)
{
	trace_t trace = { 0 };
	vec3_t point;
	int cont;
	mphysicsnormal_t ground;

	pmove.maxgroundspeed = MAXGROUNDSPEED_DEFAULT;

	// if the player hull point one unit down is solid, the player is on ground
	// see if standing on something solid
	point[0] = pmove.origin[0];
	point[1] = pmove.origin[1];
	point[2] = pmove.origin[2] - 1;

	if (movevars.rampjump) {
		// Increase speed limit for player as steepness of the floor increases
		trace = PM_CategorizePositionRunTrace(point);
		ground = CM_PhysicsNormal(trace.physicsnormal);

		if (ground.flags & PHYSICSNORMAL_SET) {
			VectorCopy(ground.normal, groundnormal);
			PM_RampEdgeAdjustNormal(groundnormal, ground.flags);
			VectorNormalize(groundnormal);

			if (movevars.rampjump && !PM_FarFromGround(trace) && trace.e.entnum == 0 && groundnormal[2] > MIN_STEP_NORMAL && groundnormal[2] < 1 && DotProduct(groundnormal, pmove.velocity) < MAX_JUMPFIX_DOTPRODUCT) {
				// They are moving up a ramp, increase maxspeed to check if we keep them on it
				float range = 1.0 - asin(groundnormal[2]) * 2 / M_PI; // asin() returns 0...PI/2, so range is [1...0]

				// Max out at 45 degree ramps...
				range = min(range, 0.5f) * 2;

				pmove.maxgroundspeed += (MAXGROUNDSPEED_MAXIMUM - MAXGROUNDSPEED_DEFAULT) * range;
			}
		}
	}

	if (pmove.velocity[2] > pmove.maxgroundspeed) {
		pmove.onground = false;
	}
	else if (!movevars.pground || pmove.onground) {
		if (!movevars.rampjump) {
			trace = PM_CategorizePositionRunTrace(point);
		}
		if (PM_FarFromGround(trace)) {
			pmove.onground = false;
		}
		else {
			pmove.onground = true;
			pmove.groundent = trace.e.entnum;
			pmove.waterjumptime = 0;
		}

		// standing on an entity other than the world
		if (trace.e.entnum > 0) {
			PM_AddTouchedEnt(trace.e.entnum);
		}
	}

	// get waterlevel
	pmove.waterlevel = 0;
	pmove.watertype = CONTENTS_EMPTY;

	point[2] = pmove.origin[2] + player_mins[2] + 1;
	cont = PM_PointContents (point);
	if (cont <= CONTENTS_WATER) {
		pmove.watertype = cont;
		pmove.waterlevel = 1;
		point[2] = pmove.origin[2] + (player_mins[2] + player_maxs[2]) * 0.5;
		cont = PM_PointContents (point);
		if (cont <= CONTENTS_WATER) {
			pmove.waterlevel = 2;
			point[2] = pmove.origin[2] + 22;
			cont = PM_PointContents (point);
			if (cont <= CONTENTS_WATER) {
				pmove.waterlevel = 3;
			}
		}
	}

	if (!movevars.pground) {
		if (pmove.onground && pmove.pm_type != PM_FLY && pmove.waterlevel < 2) {
			// snap to ground so that we can't jump higher than we're supposed to
			if (!trace.startsolid && !trace.allsolid) {
				VectorCopy(trace.endpos, pmove.origin);
			}
		}
	}
}

static void PM_CheckJump (void)
{
	if (pmove.pm_type == PM_FLY)
		return;

	if (pmove.pm_type == PM_DEAD) {
		pmove.jump_held = true; // don't jump on respawn
		return;
	}

	if (!(pmove.cmd.buttons & BUTTON_JUMP)) {
		pmove.jump_held = false;
		return;
	}

	if (pmove.waterjumptime) {
		return;
	}

	if (pmove.waterlevel >= 2) {
		// swimming, not jumping
		pmove.onground = false;

		if (pmove.watertype == CONTENTS_WATER)
			pmove.velocity[2] = 100;
		else if (pmove.watertype == CONTENTS_SLIME)
			pmove.velocity[2] = 80;
		else
			pmove.velocity[2] = 50;
		return;
	}

	if (!pmove.onground)
		return; // in air, so no effect

	if (pmove.jump_held && !pmove.jump_msec)
		return; // don't pogo stick

	if (!movevars.pground) {
		// check for jump bug
		// groundplane normal was set in the call to PM_CategorizePosition
		if ((movevars.rampjump || pmove.velocity[2] < 0) && DotProduct(pmove.velocity, groundnormal) < MAX_JUMPFIX_DOTPRODUCT) {
			// pmove.velocity is pointing into the ground, clip it
			PM_ClipVelocity(pmove.velocity, groundnormal, pmove.velocity, 1);
		}
	}

	pmove.onground = false;
	if (pmove.maxgroundspeed > MAXGROUNDSPEED_DEFAULT && pmove.velocity[2] > MAXGROUNDSPEED_DEFAULT) {
		// we adjusted maxspeed to keep them on ground, need to reduce velocity here so they can't jump too high
		pmove.velocity[2] = MAXGROUNDSPEED_DEFAULT;
	}
	pmove.velocity[2] += 270;

	if (movevars.ktjump > 0) {
		// meag: pmove.velocity[2] = max(pmove.velocity[2], 270); (?)
		if (movevars.ktjump > 1)
			movevars.ktjump = 1;
		if (pmove.velocity[2] < 270)
			pmove.velocity[2] = pmove.velocity[2] * (1 - movevars.ktjump) + 270 * movevars.ktjump;
	}

	pmove.jump_held = true; // don't jump again until released
	pmove.jump_msec = pmove.cmd.msec;
}

static void PM_CheckWaterJump (void)
{
	vec3_t flatforward;
	vec3_t spot;
	int cont;

	if (pmove.waterjumptime)
		return;

	// don't hop out if we just jumped in
	if (pmove.velocity[2] < -180)
		return;

	// see if near an edge
	flatforward[0] = pm_forward[0];
	flatforward[1] = pm_forward[1];
	flatforward[2] = 0;
	VectorNormalize (flatforward);

	VectorMA (pmove.origin, 24, flatforward, spot);
	spot[2] += 8;
	cont = PM_PointContents_AllBSPs (spot);
	if (cont != CONTENTS_SOLID)
		return;
	spot[2] += 24;
	cont = PM_PointContents_AllBSPs (spot);
	if (cont != CONTENTS_EMPTY)
		return;
	// jump out of water
	VectorScale (flatforward, 50, pmove.velocity);
	pmove.velocity[2] = 310;
	pmove.waterjumptime = 2; // safety net
	pmove.jump_held = true; // don't jump again until released
}

//If pmove.origin is in a solid position,
//try nudging slightly on all axis to
//allow for the cut precision of the net coordinates
static void PM_NudgePosition (void)
{
	static int sign[3] = {0, -1, 1};
	int x, y, z, i;
	vec3_t base;

	VectorCopy (pmove.origin, base);

	for (i = 0; i < 3; i++)
		pmove.origin[i] = ((int) (pmove.origin[i] * 8)) * 0.125;

	for (z = 0; z <= 2; z++) {
		for (y = 0; y <= 2; y++) {
			for (x = 0; x <= 2; x++) {
				pmove.origin[0] = base[0] + (sign[x] * 0.125);
				pmove.origin[1] = base[1] + (sign[y] * 0.125);
				pmove.origin[2] = base[2] + (sign[z] * 0.125);
				if (PM_TestPlayerPosition (pmove.origin))
					return;
			}
		}
	}

	// some maps spawn the player several units into the ground
	for (z = 1; z <= 18; z++) {
		pmove.origin[0] = base[0];
		pmove.origin[1] = base[1];
		pmove.origin[2] = base[2] + z;
		if (PM_TestPlayerPosition(pmove.origin))
			return;
	}

	VectorCopy (base, pmove.origin);
}

static void PM_SpectatorMove(void)
{
	float newspeed, currentspeed, addspeed, accelspeed, wishspeed;
	float speed, drop, friction, control, fmove, smove;
	vec3_t wishvel, wishdir;
	int i;

	// friction
	speed = VectorLength(pmove.velocity);
	if (speed < 1) {
		VectorClear(pmove.velocity);
	}
	else {
		friction = movevars.friction * 1.5; // extra friction
		control = speed < movevars.stopspeed ? movevars.stopspeed : speed;
		drop = control * friction * pm_frametime;

		// scale the velocity
		newspeed = speed - drop;
		if (newspeed < 0) {
			newspeed = 0;
		}
		newspeed /= speed;

		VectorScale(pmove.velocity, newspeed, pmove.velocity);
	}

	// accelerate
	fmove = pmove.cmd.forwardmove;
	smove = pmove.cmd.sidemove;

	VectorNormalize(pm_forward);
	VectorNormalize(pm_right);

	for (i = 0; i < 3; i++) {
		wishvel[i] = pm_forward[i] * fmove + pm_right[i] * smove;
	}
	wishvel[2] += pmove.cmd.upmove;

	VectorCopy(wishvel, wishdir);
	wishspeed = VectorNormalize(wishdir);

	// clamp to server defined max speed
	if (wishspeed > movevars.spectatormaxspeed) {
		VectorScale(wishvel, movevars.spectatormaxspeed / wishspeed, wishvel);
		wishspeed = movevars.spectatormaxspeed;
	}

	currentspeed = DotProduct(pmove.velocity, wishdir);
	addspeed = wishspeed - currentspeed;

	// Buggy QW spectator mode, kept for compatibility
	if (pmove.pm_type == PM_OLD_SPECTATOR) {
		if (addspeed <= 0) {
			return;
		}
	}

	if (addspeed > 0) {
		accelspeed = movevars.accelerate * pm_frametime * wishspeed;
		accelspeed = min(accelspeed, addspeed);
		VectorMA(pmove.velocity, accelspeed, wishdir, pmove.velocity);
	}

	// move
	VectorMA(pmove.origin, pm_frametime, pmove.velocity, pmove.origin);
}

//Returns with origin, angles, and velocity modified in place.
//Numtouch and touchindex[] will be set if any of the physents were contacted during the move.
int PM_PlayerMove(void)
{
	int blocked = 0;

#ifndef SERVERONLY
#ifdef EXPERIMENTAL_SHOW_ACCELERATION
	if (flag_player_pmove) player_in_air = false;
#endif
#endif

	pm_frametime = pmove.cmd.msec * 0.001;
	pmove.numtouch = 0;

	if (pmove.pm_type == PM_NONE || pmove.pm_type == PM_LOCK) {
		PM_CategorizePosition();
		return 0;
	}

	// take angles directly from command
	VectorCopy(pmove.cmd.angles, pmove.angles);
	AngleVectors(pmove.angles, pm_forward, pm_right, NULL);

	if (pmove.pm_type == PM_SPECTATOR || pmove.pm_type == PM_OLD_SPECTATOR) {
		PM_SpectatorMove();
		pmove.onground = false;
		return 0;
	}

	PM_NudgePosition();

	// set onground, watertype, and waterlevel
	PM_CategorizePosition();

	if (pmove.waterlevel == 2 && pmove.pm_type != PM_FLY)
		PM_CheckWaterJump();

	if (pmove.velocity[2] < 0 || pmove.pm_type == PM_DEAD)
		pmove.waterjumptime = 0;

	if (pmove.waterjumptime) {
		pmove.waterjumptime -= pm_frametime;
		if (pmove.waterjumptime < 0)
			pmove.waterjumptime = 0;
	}

	if (pmove.jump_msec) {
		pmove.jump_msec += pmove.cmd.msec;
		if (pmove.jump_msec > 50)
			pmove.jump_msec = 0;
	}

	PM_CheckJump();

	PM_Friction();

	if (pmove.waterlevel >= 2)
		blocked = PM_WaterMove();
	else if (pmove.pm_type == PM_FLY)
		blocked = PM_FlyMove();
	else
		blocked = PM_AirMove();

	// set onground, watertype, and waterlevel for final spot
	PM_CategorizePosition();

	if (!movevars.pground) {
		// this is to make sure landing sound is not played twice
		// and falling damage is calculated correctly
		if (pmove.onground && pmove.velocity[2] < -300) {
			if (DotProduct(pmove.velocity, groundnormal) < MAX_JUMPFIX_DOTPRODUCT) {
				PM_ClipVelocity(pmove.velocity, groundnormal, pmove.velocity, 1);
			}
		}
	}

	return blocked;
}


================================================
FILE: src/pmove.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

#ifndef __PMOVE_H__
#define __PMOVE_H__

#define	MAX_PHYSENTS 64 

typedef struct {
	vec3_t		origin;
	cmodel_t	*model;		// only for bsp models
	vec3_t		mins, maxs;	// only for non-bsp models
	int			info;		// for client or server to identify
#if defined(FTE_PEXT_TRANS)
	qbool		is_transparent;
#endif
} physent_t;

typedef enum {
	PM_NORMAL,              // normal ground movement
	PM_OLD_SPECTATOR,       // fly, no clip to world (QW bug)
	PM_SPECTATOR,           // fly, no clip to world
	PM_DEAD,                // no acceleration
	PM_FLY,                 // fly, bump into walls
	PM_NONE,                // can't move
	PM_LOCK                 // server controls origin and view angles
} pmtype_t;

typedef struct {
	// player state
	vec3_t		origin;
	vec3_t		angles;
	vec3_t		velocity;
	qbool		jump_held;
	int			jump_msec; // msec since last jump
	float		waterjumptime;
	int			pm_type;

	// world state
	int			numphysent;
	physent_t	physents[MAX_PHYSENTS]; // 0 should be the world

	// input
	usercmd_t	cmd;

	// results
	int			numtouch;
	int			touchindex[MAX_PHYSENTS];
	qbool		onground;
	int			groundent; // index in physents array, only valid when onground is true
	int			waterlevel;
	int			watertype;

	int         maxgroundspeed;
} playermove_t;

typedef struct {
	float	gravity;
	float	stopspeed;
	float	maxspeed;
	float	spectatormaxspeed;
	float	accelerate;
	float	airaccelerate;
	float	wateraccelerate;
	float	friction;
	float	waterfriction;
	float	entgravity;
	float	bunnyspeedcap;
	float	ktjump;
	qbool	slidefix; // NQ-style movement down ramps
	qbool	airstep;
	qbool	pground; // NQ-style "onground" flag handling.
	int     rampjump; // if set, all vertical velocity clipped by groundplane during jump frame.  If 0, only when falling (standard jumpfix)
	int     safestrafe; // sv_safestrafe value from server
} movevars_t;

extern movevars_t movevars;
extern playermove_t pmove;

int PM_PlayerMove (void);

int PM_PointContents (vec3_t point);
int PM_PointContents_AllBSPs (vec3_t p);
void PM_CategorizePosition (void);
qbool PM_TestPlayerPosition (vec3_t point);
trace_t PM_PlayerTrace (vec3_t start, vec3_t end);
trace_t PM_TraceLine (vec3_t start, vec3_t end);

#define MIN_STEP_NORMAL 0.7 // roughly 45 degrees

#endif /* !__PMOVE_H__ */


================================================
FILE: src/pmovetst.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "quakedef.h"
#include "pmove.h"
#endif

extern	vec3_t player_mins;
extern	vec3_t player_maxs;


static void PM_TraceBounds (vec3_t start, vec3_t end, vec3_t boxmins, vec3_t boxmaxs)
{
	int i;

	for (i = 0; i < 3; i++) {
		if (end[i] > start[i]) {
			boxmins[i] = start[i] - 1;
			boxmaxs[i] = end[i] + 1;
		} else {
			boxmins[i] = end[i] - 1;
			boxmaxs[i] = start[i] + 1;
		}
	}
}

static qbool PM_CullTraceBox(vec3_t mins, vec3_t maxs, vec3_t offset, vec3_t emins, vec3_t emaxs, vec3_t hullmins, vec3_t hullmaxs) {
	return
		(	mins[0] + hullmins[0] > offset[0] + emaxs[0] || maxs[0] + hullmaxs[0] < offset[0] + emins[0] ||
			mins[1] + hullmins[1] > offset[1] + emaxs[1] || maxs[1] + hullmaxs[1] < offset[1] + emins[1] ||
			mins[2] + hullmins[2] > offset[2] + emaxs[2] || maxs[2] + hullmaxs[2] < offset[2] + emins[2]
		);
}

/*
==================
PM_PointContents
==================
*/
int PM_PointContents (vec3_t p)
{
	hull_t *hull;
	
	// Safety check for NULL model in case entity updates arrive out of order
	if (!pmove.physents[0].model)
		return CONTENTS_EMPTY;
	
	hull = &pmove.physents[0].model->hulls[0];
	return CM_HullPointContents (hull, hull->firstclipnode, p);
}

/*
==================
PM_PointContents_AllBSPs

Checks world and bsp entities, but not bboxes (like traceline with nomonsters set)
For waterjump test
==================
*/
int PM_PointContents_AllBSPs (vec3_t p)
{
	int         i;
	physent_t   *pe;
	hull_t      *hull;
	vec3_t      test;
	int         result, final;

	final = CONTENTS_EMPTY;
	for (i = 0; i < pmove.numphysent; i++)
	{
		pe = &pmove.physents[i];
		if (!pe->model)
			continue;	// ignore non-bsp
		hull = &pmove.physents[i].model->hulls[0];
		VectorSubtract (p, pe->origin, test);
		result = CM_HullPointContents (hull, hull->firstclipnode, test);
		if (result == CONTENTS_SOLID)
			return CONTENTS_SOLID;
		if (final == CONTENTS_EMPTY)
			final = result;
	}

	return final;
}

/*
================
PM_TestPlayerPosition

Returns false if the given player position is not valid (in solid)
================
*/
qbool PM_TestPlayerPosition (vec3_t pos)
{
	int       i;
	physent_t *pe;
	vec3_t    mins, maxs, offset, test;
	hull_t    *hull;

	for (i = 0; i < pmove.numphysent; i++) {
		pe = &pmove.physents[i];
		// get the clipping hull
		if (pe->model) {
			hull = &pmove.physents[i].model->hulls[1];
			VectorSubtract(hull->clip_mins, player_mins, offset);
			VectorAdd(offset, pe->origin, offset);
		}
		else {
			VectorSubtract(pe->mins, player_maxs, mins);
			VectorSubtract(pe->maxs, player_mins, maxs);
			hull = CM_HullForBox(mins, maxs);
			VectorCopy(pe->origin, offset);
		}

		VectorSubtract(pos, offset, test);

		if (CM_HullPointContents(hull, hull->firstclipnode, test) == CONTENTS_SOLID) {
			return false;
		}
	}

	return true;
}

/*
================
PM_PlayerTrace
================
*/
trace_t PM_PlayerTrace (vec3_t start, vec3_t end)
{
	trace_t   trace, total;
	vec3_t    offset;
	vec3_t    start_l, end_l;
	hull_t    *hull;
	int       i;
	physent_t *pe;
	vec3_t    mins, maxs, tracemins, tracemaxs;

	// fill in a default trace
	memset (&total, 0, sizeof(trace_t));
	total.fraction = 1;
	total.e.entnum = -1;
	VectorCopy (end, total.endpos);

	PM_TraceBounds(start, end, tracemins, tracemaxs);

	for (i = 0; i < pmove.numphysent; i++) {
		pe = &pmove.physents[i];

		// get the clipping hull
		if (pe->model) {
			hull = &pmove.physents[i].model->hulls[1];

			if (i > 0 && PM_CullTraceBox(tracemins, tracemaxs, pe->origin, pe->model->mins, pe->model->maxs, hull->clip_mins, hull->clip_maxs)) {
				continue;
			}

			VectorSubtract(hull->clip_mins, player_mins, offset);
			VectorAdd(offset, pe->origin, offset);
		}
		else {
			VectorSubtract(pe->mins, player_maxs, mins);
			VectorSubtract(pe->maxs, player_mins, maxs);

			if (PM_CullTraceBox(tracemins, tracemaxs, pe->origin, mins, maxs, vec3_origin, vec3_origin)) {
				continue;
			}

			hull = CM_HullForBox(mins, maxs);
			VectorCopy(pe->origin, offset);
		}

		VectorSubtract(start, offset, start_l);
		VectorSubtract(end, offset, end_l);

		// trace a line through the appropriate clipping hull
		trace = CM_HullTrace(hull, start_l, end_l);

		// fix trace up by the offset
		VectorAdd(trace.endpos, offset, trace.endpos);

		if (trace.allsolid) {
			trace.startsolid = true;
		}
		if (trace.startsolid) {
			trace.fraction = 0;
		}

		// did we clip the move?
		if (trace.fraction < total.fraction) {
			total = trace;
			total.e.entnum = i;
		}
	}

	return total;
}

/*
================
PM_TraceLine
================
*/
trace_t PM_TraceLine (vec3_t start, vec3_t end)
{
	int i;
	hull_t *hull;
	physent_t *pe;
	vec3_t offset, start_l, end_l;
	trace_t trace, total;

	// fill in a default trace
	memset (&total, 0, sizeof(trace_t));
	total.fraction = 1;
	total.e.entnum = -1;
	VectorCopy (end, total.endpos);

	for (i = 0; i < pmove.numphysent; i++) {
		pe = &pmove.physents[i];

#if defined(FTE_PEXT_TRANS)
		if (cls.fteprotocolextensions & FTE_PEXT_TRANS && pe->is_transparent) {
			continue;
		}
#endif

		// get the clipping hull
		hull = (pe->model) ? (&pmove.physents[i].model->hulls[0]) : (CM_HullForBox(pe->mins, pe->maxs));

		// PM_HullForEntity (ent, mins, maxs, offset);
		VectorCopy(pe->origin, offset);

		VectorSubtract(start, offset, start_l);
		VectorSubtract(end, offset, end_l);

		// trace a line through the appropriate clipping hull
		trace = CM_HullTrace(hull, start_l, end_l);

		// fix trace up by the offset
		VectorAdd(trace.endpos, offset, trace.endpos);

		if (trace.allsolid) {
			trace.startsolid = true;
		}
		if (trace.startsolid) {
			trace.fraction = 0;
		}

		// did we clip the move?
		if (trace.fraction < total.fraction) {
			total = trace;
			total.e.entnum = i;
		}
	}

	return total;
}


================================================
FILE: src/pr2.h
================================================
/*
 *  QW262
 *  Copyright (C) 2004  [sd] angel
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 */

#ifndef __PR2_H__
#define __PR2_H__


intptr_t PR2_GameSystemCalls( intptr_t *args );
extern cvar_t sv_progtype;
extern vm_t* sv_vm;


void		PR2_Init(void);
#define PR_Init PR2_Init
void		PR2_UnLoadProgs(void);
#define PR_UnLoadProgs PR2_UnLoadProgs
void		PR2_LoadProgs(void);
#define PR_LoadProgs PR2_LoadProgs
void		PR2_GameStartFrame(qbool isBotFrame);
#define PR_GameStartFrame PR2_GameStartFrame
void		PR2_LoadEnts(char *data);
#define PR_LoadEnts PR2_LoadEnts
void		PR2_GameClientConnect(int spec);
#define PR_GameClientConnect PR2_GameClientConnect
void		PR2_GamePutClientInServer(int spec);
#define PR_GamePutClientInServer PR2_GamePutClientInServer
void		PR2_GameClientDisconnect(int spec);
#define PR_GameClientDisconnect PR2_GameClientDisconnect
void		PR2_GameClientPreThink(int spec);
#define PR_GameClientPreThink PR2_GameClientPreThink
void		PR2_GameClientPostThink(int spec);
#define PR_GameClientPostThink PR2_GameClientPostThink
qbool		PR2_ClientCmd(void);
#define PR_ClientCmd PR2_ClientCmd
void		PR2_ClientKill(void);
#define PR_ClientKill PR2_ClientKill
qbool		PR2_ClientSay(int isTeamSay, char *message);
#define PR_ClientSay PR2_ClientSay
void		PR2_GameSetNewParms(void);
#define PR_GameSetNewParms PR2_GameSetNewParms
void		PR2_GameSetChangeParms(void);
#define PR_GameSetChangeParms PR2_GameSetChangeParms
void		PR2_EdictTouch(func_t f);
#define PR_EdictTouch PR2_EdictTouch
void		PR2_EdictThink(func_t f);
#define PR_EdictThink PR2_EdictThink
void		PR2_EdictBlocked(func_t f);
#define PR_EdictBlocked PR2_EdictBlocked
qbool 		PR2_UserInfoChanged(int after);
#define PR_UserInfoChanged PR2_UserInfoChanged
void 		PR2_GameShutDown(void);
#define PR_GameShutDown PR2_GameShutDown
void 		PR2_GameConsoleCommand(void);
void		PR2_PausedTic(float duration);
#define PR_PausedTic PR2_PausedTic

char*		PR2_GetString(intptr_t reference);
//#define		PR_GetString PR2_GetString
char*       PR2_GetEntityString(string_t reference);
#define     PR_GetEntityString PR2_GetEntityString
void        PR2_SetEntityString(edict_t* ed, string_t* target, char* value);
void        PR2_SetGlobalString(string_t* target, char* value);
#define     PR_SetEntityString(entity, address, value) PR2_SetEntityString(entity, &address, value)
#define     PR_SetGlobalString(address, value) PR2_SetGlobalString(&address, value)
void		PR2_RunError(char *error, ...);
eval_t*		PR2_GetEdictFieldValue(edict_t *ed, char *field);
#define PR_GetEdictFieldValue PR2_GetEdictFieldValue
int			ED2_FindFieldOffset(char *field);
#define ED_FindFieldOffset ED2_FindFieldOffset
void 		PR2_InitProg(void);
#define PR_InitProg PR2_InitProg
void        PR2_ClearEdict(edict_t* e);
#define PR_ClearEdict PR2_ClearEdict

#endif /* !__PR2_H__ */


================================================
FILE: src/pr2_cmds.c
================================================
/*
 *  QW262
 *  Copyright (C) 2004  [sd] angel
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 *  
 */

#ifndef CLIENTONLY
#ifdef USE_PR2

#include "qwsvdef.h"
#include "vm.h"
#include "vm_local.h"

#define SETUSERINFO_STAR          (1<<0) // allow set star keys

#ifdef SERVERONLY
#define Cbuf_AddTextEx(x, y) Cbuf_AddText(y)
#define Cbuf_ExecuteEx(x) Cbuf_Execute()
#endif

const char *pr2_ent_data_ptr;
vm_t *sv_vm = NULL;
extern gameData_t gamedata;

static int PASSFLOAT(float f)
{
	floatint_t fi;
	fi.f = f;
	return fi.i;
}

#if 0 // Provided for completness.
static float GETFLOAT(int i)
{
	floatint_t fi;
	fi.i = i;
	return fi.f;
}
#endif

typedef intptr_t (*ext_syscall_t)(intptr_t *arg);
static intptr_t EXT_MapExtFieldPtr(intptr_t *args);
static intptr_t EXT_SetExtFieldPtr(intptr_t *args);
static intptr_t EXT_GetExtFieldPtr(intptr_t *args);
struct
{
	char *extname;
	ext_syscall_t fun;
} ext_syscalls[] =
{
	{"MapExtFieldPtr",	EXT_MapExtFieldPtr},
	{"SetExtFieldPtr",	EXT_SetExtFieldPtr},
	{"GetExtFieldPtr",	EXT_GetExtFieldPtr},
};
ext_syscall_t ext_syscall_tbl[256];

int NUM_FOR_GAME_EDICT(byte *e)
{
	int b;

	b = (byte *)e - (byte *)sv.game_edicts;
	b /= pr_edict_size;

	if (b < 0 || b >= sv.num_edicts)
		SV_Error("NUM_FOR_GAME_EDICT: bad pointer");

	return b;
}

intptr_t PR2_EntityStringLocation(string_t offset, int max_size);
void static PR2_SetEntityString_model(edict_t *ed, string_t *target, char *s) {
	if (!sv_vm) {
		PR1_SetString(target, s);
		return;
	}

	switch (sv_vm->type) {
	case VMI_NONE:
		PR1_SetString(target, s);
		return;

	case VMI_NATIVE:
		if (sv_vm->pr2_references) {
			char **location =
					(char **)PR2_EntityStringLocation(*target, sizeof(char *));
			if (location) {
				*location = s;
			}
		}
#ifndef idx64
		else if (target) {
			*target = (string_t)s;
		}
#endif
		return;
	case VMI_BYTECODE:
	case VMI_COMPILED: {
		int off = VM_ExplicitPtr2VM(sv_vm, (byte *)s);

		if (sv_vm->pr2_references) {
			string_t *location =
					(string_t *)PR2_EntityStringLocation(*target, sizeof(string_t));

			if (location) {
				*location = off;
			}
		} else {
			*target = off;
		}
	}
		return;
	}

	*target = 0;
}

/*
============
PR2_RunError
 
Aborts the currently executing function
============
*/
void PR2_RunError(char *error, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start(argptr, error);
	vsnprintf(string, sizeof(string), error, argptr);
	va_end(argptr);

	sv_error = true;

	Con_Printf("%s\n", string);

	SV_Error("Program error: %s", string);
}

void PR2_CheckEmptyString(char *s)
{
	if (!s || s[0] <= ' ')
		PR2_RunError("Bad string");
}

void PF2_precache_sound(char *s)
{
	int i;

	if (sv.state != ss_loading)
		PR2_RunError("PF_Precache_*: Precache can only be done in spawn "
		             "functions");
	PR2_CheckEmptyString(s);

	for (i = 0; i < MAX_SOUNDS; i++)
	{
		if (!sv.sound_precache[i])
		{
			sv.sound_precache[i] = s;
			return;
		}
		if (!strcmp(sv.sound_precache[i], s))
			return;
	}

	PR2_RunError ("PF_precache_sound: overflow");
}

void PF2_precache_model(char *s)
{
	int 	i;

	if (sv.state != ss_loading)
		PR2_RunError("PF_Precache_*: Precache can only be done in spawn "
		             "functions");

	PR2_CheckEmptyString(s);

	for (i = 0; i < MAX_MODELS; i++)
	{
		if (!sv.model_precache[i])
		{
			sv.model_precache[i] = s;
			return;
		}
		if (!strcmp(sv.model_precache[i], s))
			return;
	}

	PR2_RunError ("PF_precache_model: overflow");
}

intptr_t PF2_precache_vwep_model(char *s)
{
	int 	i;

	if (sv.state != ss_loading)
		PR2_RunError("PF_Precache_*: Precache can only be done in spawn "
		             "functions");

	PR2_CheckEmptyString(s);

	// the strings are transferred via the stufftext mechanism, hence the stringency
	if (strchr(s, '"') || strchr(s, ';') || strchr(s, '\n'  ) || strchr(s, '\t') || strchr(s, ' '))
		PR2_RunError ("Bad string\n");

	for (i = 0; i < MAX_VWEP_MODELS; i++)
	{
		if (!sv.vw_model_name[i]) {
			sv.vw_model_name[i] = s;
			return i;
		}
	}
	PR2_RunError ("PF_precache_vwep_model: overflow");
	return 0;
}

/*
=================
PF2_setorigin
 
This is the only valid way to move an object without using the physics of the world (setting velocity and waiting).  Directly changing origin will not set internal links correctly, so clipping would be messed up.  This should be called when an object is spawned, and then only if it is teleported.
 
setorigin (entity, origin)
=================
*/

void PF2_setorigin(edict_t *e, float x, float y, float z)
{
	vec3_t origin;

	origin[0] = x;
	origin[1] = y;
	origin[2] = z;

	VectorCopy(origin, e->v->origin);
	SV_AntilagReset(e);
	SV_LinkEdict(e, false);
}

/*
=================
PF2_setsize
 
the size box is rotated by the current angle
 
setsize (entity, minvector, maxvector)
=================
*/
void PF2_setsize(edict_t *e, float x1, float y1, float z1, float x2, float y2, float z2)
{
	// vec3_t min, max;
	e->v->mins[0] = x1;
	e->v->mins[1] = y1;
	e->v->mins[2] = z1;

	e->v->maxs[0] = x2;
	e->v->maxs[1] = y2;
	e->v->maxs[2] = z2;

	VectorSubtract(e->v->maxs, e->v->mins, e->v->size);

	SV_LinkEdict(e, false);
}

/*
=================
PF2_setmodel
 
setmodel(entity, model)
Also sets size, mins, and maxs for inline bmodels
=================
*/
void PF2_setmodel(edict_t *e, char *m)
{
	char		**check;
	int		i;
	cmodel_t	*mod;

	if (!m)
		m = "";
	// check to see if model was properly precached
	for (i = 0, check = sv.model_precache; *check; i++, check++)
		if (!strcmp(*check, m))
			break;

	if (!*check)
		PR2_RunError("no precache: %s\n", m);

	PR2_SetEntityString_model(e, &e->v->model, m);
	e->v->modelindex = i;

	// if it is an inline model, get the size information for it
	if (m[0] == '*')
	{
		mod = CM_InlineModel (m);
		VectorCopy(mod->mins, e->v->mins);
		VectorCopy(mod->maxs, e->v->maxs);
		VectorSubtract(mod->maxs, mod->mins, e->v->size);
		SV_LinkEdict(e, false);
	}

}

/*
=================
PF2_sprint
 
single print to a specific client
 
sprint(clientent, value)
=================
*/

// trap_SPrint() flags
#define SPRINT_IGNOREINDEMO   (   1<<0) // do not put such message in mvd demo

void PF2_sprint(int entnum, int level, char *s, int flags)
{
	client_t *client, *cl;
	int i;

	if (gamedata.APIversion < 15)
		flags = 0;
	if (entnum < 1 || entnum > MAX_CLIENTS)
	{
		Con_Printf("tried to sprint to a non-client %d (%s)\n", entnum, s);
		return;
	}

	client = &svs.clients[entnum - 1];

	// do not print to client in such state
	if (client->state < cs_connected)
		return;

	if (flags & SPRINT_IGNOREINDEMO)
		SV_ClientPrintf2 (client, level, "%s", s); // this does't go to mvd demo
	else
		SV_ClientPrintf  (client, level, "%s", s); // this will be in mvd demo too

	//bliP: spectator print ->
	if ((int)sv_specprint.value & SPECPRINT_SPRINT)
	{
		for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
		{
			if (!cl->state || !cl->spectator)
				continue;

			if ((cl->spec_track == entnum) && (cl->spec_print & SPECPRINT_SPRINT))
			{
				if (flags & SPRINT_IGNOREINDEMO)
					SV_ClientPrintf2 (cl, level, "%s", s); // this does't go to mvd demo
				else
					SV_ClientPrintf  (cl, level, "%s", s); // this will be in mvd demo too
			}
		}
	}
	//<-
}

/*
=================
PF2_centerprint

single print to a specific client

centerprint(clientent, value)
=================
*/
void PF2_centerprint(int entnum, char *s)
{
	client_t *cl, *spec;
	int i;

	if (entnum < 1 || entnum > MAX_CLIENTS)
	{
		Con_Printf("tried to centerprint to a non-client %d \n", entnum);
		return;
	}

	cl = &svs.clients[entnum - 1];

	ClientReliableWrite_Begin(cl, svc_centerprint, 2 + strlen(s));
	ClientReliableWrite_String(cl, s);

	if (sv.mvdrecording)
	{
		if (MVDWrite_Begin(dem_single, entnum - 1, 2 + strlen(s)))
		{
			MVD_MSG_WriteByte(svc_centerprint);
			MVD_MSG_WriteString(s);
		}
	}

	//bliP: spectator print ->
	if ((int)sv_specprint.value & SPECPRINT_CENTERPRINT)
	{
		for (i = 0, spec = svs.clients; i < MAX_CLIENTS; i++, spec++)
		{
			if (!cl->state || !spec->spectator)
				continue;

			if ((spec->spec_track == entnum) && (cl->spec_print & SPECPRINT_CENTERPRINT))
			{
				ClientReliableWrite_Begin (spec, svc_centerprint, 2 + strlen(s));
				ClientReliableWrite_String (spec, s);
			}
		}
	}
	//<-

}

/*
=================
PF2_ambientsound
 
=================
*/
void PF2_ambientsound(float x, float y, float z, char *samp, float vol,	float attenuation)
{
	char	**check;
	int		i, soundnum;
	vec3_t 	pos;

	pos[0] = x;
	pos[1] = y;
	pos[2] = z;

	if( !samp )
		samp = "";

	// check to see if samp was properly precached
	for (soundnum = 0, check = sv.sound_precache; *check; check++, soundnum++)
		if (!strcmp(*check, samp))
			break;

	if (!*check)
	{
		Con_Printf("no precache: %s\n", samp);
		return;
	}

	// add an svc_spawnambient command to the level signon packet
	MSG_WriteByte(&sv.signon, svc_spawnstaticsound);
	for (i = 0; i < 3; i++)
		MSG_WriteCoord(&sv.signon, pos[i]);

	MSG_WriteByte(&sv.signon, soundnum);

	MSG_WriteByte(&sv.signon, vol * 255);
	MSG_WriteByte(&sv.signon, attenuation * 64);

}

/*
=================
PF2_traceline
 
Used for use tracing and shot targeting
Traces are blocked by bbox and exact bsp entityes, and also slide box entities
if the tryents flag is set.
 
traceline (vector1, vector2, tryents)
=================
*/
void PF2_traceline(float v1_x, float v1_y, float v1_z,
					float v2_x, float v2_y, float v2_z,
					int nomonsters, int entnum)
{
	trace_t	trace;
	edict_t	*ent;
	vec3_t v1, v2;

	ent = EDICT_NUM(entnum);
	v1[0] = v1_x;
	v1[1] = v1_y;
	v1[2] = v1_z;

	v2[0] = v2_x;
	v2[1] = v2_y;
	v2[2] = v2_z;

	if (sv_antilag.value == 2)
	{
		if (!(entnum >= 1 && entnum <= MAX_CLIENTS && svs.clients[entnum - 1].isBot)) {
			nomonsters |= MOVE_LAGGED;
		}
	}

	trace = SV_Trace(v1, vec3_origin, vec3_origin, v2, nomonsters, ent);

	pr_global_struct->trace_allsolid = trace.allsolid;
	pr_global_struct->trace_startsolid = trace.startsolid;
	pr_global_struct->trace_fraction = trace.fraction;
	pr_global_struct->trace_inwater = trace.inwater;
	pr_global_struct->trace_inopen = trace.inopen;
	VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
	VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
	pr_global_struct->trace_plane_dist = trace.plane.dist;

	if (trace.e.ent)
		pr_global_struct->trace_ent = EDICT_TO_PROG(trace.e.ent);
	else
		pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
}

/*
=================
PF2_TraceCapsule
 
Used for use tracing and shot targeting
Traces are blocked by bbox and exact bsp entityes, and also slide box entities
if the tryents flag is set.
=================
*/
void PF2_TraceCapsule(float v1_x, float v1_y, float v1_z,
					float v2_x,	float v2_y, float v2_z,
					int nomonsters, edict_t *ent,
					float min_x, float min_y, float min_z,
					float max_x, float max_y, float max_z)
{
	trace_t	trace;
	vec3_t v1, v2, v3, v4;

	v1[0] = v1_x;
	v1[1] = v1_y;
	v1[2] = v1_z;

	v2[0] = v2_x;
	v2[1] = v2_y;
	v2[2] = v2_z;

	v3[0] = min_x;
	v3[1] = min_y;
	v3[2] = min_z;

	v4[0] = max_x;
	v4[1] = max_y;
	v4[2] = max_z;

	trace = SV_Trace(v1, v3, v4, v2, nomonsters, ent);

	pr_global_struct->trace_allsolid = trace.allsolid;
	pr_global_struct->trace_startsolid = trace.startsolid;
	pr_global_struct->trace_fraction = trace.fraction;
	pr_global_struct->trace_inwater = trace.inwater;
	pr_global_struct->trace_inopen = trace.inopen;
	VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
	VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
	pr_global_struct->trace_plane_dist = trace.plane.dist;

	if (trace.e.ent)
		pr_global_struct->trace_ent = EDICT_TO_PROG(trace.e.ent);
	else
		pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
}

/*
=================
PF2_checkclient
 
Returns a client (or object that has a client enemy) that would be a
valid target.
 
If there are more than one valid options, they are cycled each frame
 
If (self.origin + self.viewofs) is not in the PVS of the current target,
it is not returned at all.
 
name checkclient ()
=================
*/

static byte	*checkpvs;

int PF2_newcheckclient(int check)
{
	int		i;
	edict_t	*ent;
	vec3_t	org;

	// cycle to the next one
	if (check < 1)
		check = 1;
	if (check > MAX_CLIENTS)
		check = MAX_CLIENTS;

	if (check == MAX_CLIENTS)
		i = 1;
	else
		i = check + 1;

	for ( ; ; i++)
	{
		if (i == MAX_CLIENTS + 1)
			i = 1;

		ent = EDICT_NUM(i);

		if (i == check)
			break;	// didn't find anything else

		if (ent->e.free)
			continue;
		if (ent->v->health <= 0)
			continue;
		if ((int) ent->v->flags & FL_NOTARGET)
			continue;

		// anything that is a client, or has a client as an enemy
		break;
	}

	// get the PVS for the entity
	VectorAdd (ent->v->origin, ent->v->view_ofs, org);
	checkpvs = CM_LeafPVS (CM_PointInLeaf(org));

	return i;
}

#define	MAX_CHECK	16

intptr_t PF2_checkclient(void)
{
	edict_t	*ent, *self;
	int		l;
	vec3_t	view;

	// find a new check if on a new frame
	if (sv.time - sv.lastchecktime >= 0.1)
	{
		sv.lastcheck = PF2_newcheckclient(sv.lastcheck);
		sv.lastchecktime = sv.time;
	}

	// return check if it might be visible
	ent = EDICT_NUM(sv.lastcheck);
	if (ent->e.free || ent->v->health <= 0)
	{
		// RETURN_EDICT(sv.edicts);
		return NUM_FOR_EDICT(sv.edicts);
	}

	// if current entity can't possibly see the check entity, return 0
	self = PROG_TO_EDICT(pr_global_struct->self);
	VectorAdd(self->v->origin, self->v->view_ofs, view);
	l = CM_Leafnum(CM_PointInLeaf(view)) - 1;
	if ((l < 0) || !(checkpvs[l >> 3] & (1 << (l & 7))))
	{
		return NUM_FOR_EDICT(sv.edicts);
	}

	return NUM_FOR_EDICT(ent);
}

//============================================================================
// modified by Tonik
/*
=================
PF2_stuffcmd

Sends text over to the client's execution buffer

stuffcmd (clientent, value)
=================
*/

// trap_stuffcmd() flags
#define STUFFCMD_IGNOREINDEMO   (   1<<0) // do not put in mvd demo
#define STUFFCMD_DEMOONLY       (   1<<1) // put in mvd demo only

void PF2_stuffcmd(int entnum, char *str, int flags)
{
	char *buf = NULL;
	client_t *cl, *spec;
	int j;

	if (gamedata.APIversion < 15)
		flags = 0;
	if( !str )
		PR2_RunError("PF2_stuffcmd: NULL pointer");

	// put in mvd demo only
	if (flags & STUFFCMD_DEMOONLY)
	{
		if (strchr( str, '\n' )) // we have \n trail
		{
			if (sv.mvdrecording)
			{
				if (MVDWrite_Begin(dem_all, 0, 2 + strlen(str)))
				{
					MVD_MSG_WriteByte(svc_stufftext);
					MVD_MSG_WriteString(str);
				}
			}
		}

		return; // do not send to client in any case
	}

	if (entnum < 1 || entnum > MAX_CLIENTS)
		PR2_RunError("Parm 0 not a client");


	cl = &svs.clients[entnum - 1];
	if (!strncmp(str, "disconnect\n", MAX_STUFFTEXT))
	{
		// so long and thanks for all the fish
		cl->drop = true;
		return;
	}
	
	buf = cl->stufftext_buf;
	if (strlen(buf) + strlen(str) >= MAX_STUFFTEXT)
		PR2_RunError("stufftext buffer overflow");
	strlcat (buf, str, MAX_STUFFTEXT);

	if( strchr( buf, '\n' ) )
	{
		ClientReliableWrite_Begin(cl, svc_stufftext, 2 + strlen(buf));
		ClientReliableWrite_String(cl, buf);

		if (!(flags & STUFFCMD_IGNOREINDEMO)) // STUFFCMD_IGNOREINDEMO flag is NOT set
		{
			if (sv.mvdrecording)
			{
				if (MVDWrite_Begin(dem_single, cl - svs.clients, 2 + strlen(buf)))
				{
					MVD_MSG_WriteByte(svc_stufftext);
					MVD_MSG_WriteString(buf);
				}
			}
		}

		//bliP: spectator print ->
		if ((int)sv_specprint.value & SPECPRINT_STUFFCMD)
		{
			for (j = 0, spec = svs.clients; j < MAX_CLIENTS; j++, spec++)
			{
				if (!cl->state || !spec->spectator)
					continue;

				if ((spec->spec_track == entnum) && (cl->spec_print & SPECPRINT_STUFFCMD))
				{
					ClientReliableWrite_Begin (spec, svc_stufftext, 2+strlen(buf));
					ClientReliableWrite_String (spec, buf);
				}
			}
		}
		buf[0] = 0;
	}

}

/*
=================
PF2_executecmd
=================
*/
void PF2_executecmd(void)
{
	int old_other, old_self; // mod_consolecmd will be executed, so we need to store this

	old_self = pr_global_struct->self;
	old_other = pr_global_struct->other;

	Cbuf_ExecuteEx(&cbuf_server);

	pr_global_struct->self = old_self;
	pr_global_struct->other = old_other;
}

/*
=================
PF2_readcmd
 
void readmcmd (string str,string buff, int sizeofbuff)
=================
*/

void PF2_readcmd(char *str, char *buf, int sizebuff)
{
	extern char outputbuf[];
	extern 	redirect_t sv_redirected;
	redirect_t old;

	Cbuf_ExecuteEx(&cbuf_server);
	Cbuf_AddTextEx(&cbuf_server, str);

	old = sv_redirected;

	if (old != RD_NONE)
		SV_EndRedirect();

	SV_BeginRedirect(RD_MOD);
	Cbuf_ExecuteEx(&cbuf_server);

	strlcpy(buf, outputbuf, sizebuff);

	SV_EndRedirect();

	if (old != RD_NONE)
		SV_BeginRedirect(old);

}

/*
=================
PF2_redirectcmd
 
void redirectcmd (entity to, string str)
=================
*/

void PF2_redirectcmd(int entnum, char *str)
{

	extern redirect_t sv_redirected;

	if (sv_redirected) {
		Cbuf_AddTextEx(&cbuf_server, str);
		Cbuf_ExecuteEx(&cbuf_server);
		return;
	}

	if (entnum < 1 || entnum > MAX_CLIENTS) {
		PR2_RunError("Parm 0 not a client");
	}

	SV_BeginRedirect((redirect_t)(RD_MOD + entnum));
	Cbuf_AddTextEx(&cbuf_server, str);
	Cbuf_ExecuteEx(&cbuf_server);
	SV_EndRedirect();
}

/*
=================
PF2_FindRadius

Returns a chain of entities that have origins within a spherical area
gedict_t *findradius( gedict_t * start, vec3_t org, float rad );
=================
*/

intptr_t PF2_FindRadius(int e, float *org, float rad)
{
	int j;

	edict_t *ed;
	vec3_t	eorg;

	for ( e++; e < sv.num_edicts; e++ )
	{
		ed = EDICT_NUM( e );

		if (ed->e.free)
			continue;
		if (ed->v->solid == SOLID_NOT)
			continue;
		for (j=0 ; j<3 ; j++)
			eorg[j] = org[j] - (ed->v->origin[j] + (ed->v->mins[j] + ed->v->maxs[j])*0.5);
		if (VectorLength(eorg) > rad)
			continue;
		return VM_Ptr2VM((byte *)ed->v);
	}
	return 0;
}

/*
===============
PF2_walkmove
 
float(float yaw, float dist) walkmove
===============
*/
int PF2_walkmove(edict_t *ent, float yaw, float dist)
{
	vec3_t		move;
	int			oldself;
	int			ret;

	if (!((int) ent->v->flags & (FL_ONGROUND | FL_FLY | FL_SWIM)))
	{
		return 0;
	}

	yaw = yaw * M_PI * 2 / 360;

	move[0] = cos(yaw) * dist;
	move[1] = sin(yaw) * dist;
	move[2] = 0;

	// save program state, because SV_movestep may call other progs
	//	oldf = pr_xfunction;
	oldself = pr_global_struct->self;

	ret = SV_movestep(ent, move, true);

	// restore program state
	//	pr_xfunction = oldf;
	pr_global_struct->self = oldself;
	return ret;
}

/*
===============
PF2_MoveToGoal
 
float(float dist) PF2_MoveToGoal
===============
*/

void PF2_MoveToGoal(float dist)
{
	edict_t		*ent, *goal;

	//	dfunction_t	*oldf;
	int			oldself;

	ent  = PROG_TO_EDICT(pr_global_struct->self);
	goal = PROG_TO_EDICT(ent->v->goalentity);

	if ( !( (int)ent->v->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
	{
		return;
	}

	// if the next step hits the enemy, return immediately
	if ( PROG_TO_EDICT(ent->v->enemy) != sv.edicts && SV_CloseEnough (ent, goal, dist) )
		return;

	// save program state, because SV_movestep may call other progs
	//	oldf = pr_xfunction;
	oldself = pr_global_struct->self;

	// bump around...
	if ( (rand()&3)==1 || !SV_StepDirection (ent, ent->v->ideal_yaw, dist))
	{
		SV_NewChaseDir (ent, goal, dist);
	}

	// restore program state
	//	pr_xfunction = oldf;
	pr_global_struct->self = oldself;
}

/*
===============
PF2_droptofloor
 
void(entnum) droptofloor
===============
*/
int PF2_droptofloor(edict_t *ent)
{
	vec3_t		end;
	trace_t		trace;

	VectorCopy(ent->v->origin, end);
	end[2] -= 256;

	trace = SV_Trace(ent->v->origin, ent->v->mins, ent->v->maxs, end, false, ent);

	if (trace.fraction == 1 || trace.allsolid)
	{
		return 0;
	}
	else
	{
		VectorCopy(trace.endpos, ent->v->origin);
		SV_LinkEdict(ent, false);
		ent->v->flags = (int) ent->v->flags | FL_ONGROUND;
		ent->v->groundentity = EDICT_TO_PROG(trace.e.ent);
		return 1;
	}
}

/*
===============
PF2_lightstyle
 
void(int style, string value) lightstyle
===============
*/
void PF2_lightstyle(int style, char *val)
{
	client_t	*client;
	int			j;

	// change the string in sv
	sv.lightstyles[style] = val;

	// send message to all clients on this server
	if (sv.state != ss_active)
		return;

	for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
		if (client->state == cs_spawned)
		{
			ClientReliableWrite_Begin(client, svc_lightstyle, strlen(val) + 3);
			ClientReliableWrite_Char(client, style);
			ClientReliableWrite_String(client, val);
		}

	if (sv.mvdrecording)
	{
		if (MVDWrite_Begin(dem_all, 0, strlen(val) + 3))
		{
			MVD_MSG_WriteByte(svc_lightstyle);
			MVD_MSG_WriteChar(style);
			MVD_MSG_WriteString(val);
		}
	}
}

/*
=============
PF2_pointcontents
=============
*/
int PF2_pointcontents(float x, float y, float z)
{
	vec3_t origin;

	origin[0] = x;
	origin[1] = y;
	origin[2] = z;

	return SV_PointContents(origin);
}

/*
=============
PF2_nextent

entity nextent(entity)
=============
*/
intptr_t PF2_nextent(int i)
{
	edict_t	*ent;

	while (1)
	{
		i++;
		if (i >= sv.num_edicts)
		{
			return 0;
		}
		ent = EDICT_NUM(i);
		if (!ent->e.free)
		{
			return i;
		}
	}
}

/*
=============
PF2_nextclient

fast walk over spawned clients
 
entity nextclient(entity)
=============
*/
intptr_t PF2_nextclient(int i)
{
	edict_t	*ent;

	while (1)
	{
		i++;
		if (i < 1 || i > MAX_CLIENTS)
		{
			return 0;
		}
		ent = EDICT_NUM(i);
		if (!ent->e.free) // actually that always true for clients edicts
		{
			if (svs.clients[i - 1].state == cs_spawned) // client in game
			{
				return VM_Ptr2VM((byte *)ent->v);
			}
		}
	}
}

/*
=============
PF2_find

entity find(start,fieldoff,str)
=============
*/
intptr_t PF2_Find(int e, int fofs, char *str)
{
	char *t;
	edict_t	*ed;

	if(!str)
		PR2_RunError ("PF2_Find: bad search string");

	for (e++ ; e < sv.num_edicts ; e++)
	{
		ed = EDICT_NUM(e);
		if (ed->e.free)
			continue;

		if (!(intptr_t *)((byte *)ed->v + fofs))
			continue;

		t = VM_ArgPtr(*(intptr_t *)((char *)ed->v + fofs));

		if (!t)
			continue;

		if (!strcmp(t,str))
		{
			return VM_Ptr2VM((byte *)ed->v);
		}
	}
	return 0;
}

/*
=============
PF2_aim ??????
 
Pick a vector for the player to shoot along
vector aim(entity, missilespeed)
=============
*/
/*
==============
PF2_changeyaw ???
 
This was a major timewaster in progs, so it was converted to C
==============
*/

/*
===============================================================================
 
MESSAGE WRITING
 
===============================================================================
*/


#define	MSG_BROADCAST	0		// unreliable to all
#define	MSG_ONE			1		// reliable to one (msg_entity)
#define	MSG_ALL			2		// reliable to all
#define	MSG_INIT		3		// write to the init string
#define	MSG_MULTICAST	4		// for multicast()


sizebuf_t *WriteDest2(int dest)
{
	//	int		entnum;
	//	int		dest;
	//	edict_t	*ent;

	//dest = G_FLOAT(OFS_PARM0);
	switch (dest)
	{
	case MSG_BROADCAST:
		return &sv.datagram;

	case MSG_ONE:
		SV_Error("Shouldn't be at MSG_ONE");
#if 0
		ent = PROG_TO_EDICT(pr_global_struct->msg_entity);
		entnum = NUM_FOR_EDICT(ent);
		if (entnum < 1 || entnum > MAX_CLIENTS)
			PR2_RunError("WriteDest: not a client");
		return &svs.clients[entnum - 1].netchan.message;
#endif

	case MSG_ALL:
		return &sv.reliable_datagram;

	case MSG_INIT:
		if (sv.state != ss_loading)
			PR2_RunError("PF_Write_*: MSG_INIT can only be written in spawn "
			             "functions");
		return &sv.signon;

	case MSG_MULTICAST:
		return &sv.multicast;

	default:
		PR2_RunError ("WriteDest: bad destination");
		break;
	}

	return NULL;
}

static client_t *Write_GetClient(void)
{
	int		entnum;
	edict_t	*ent;

	ent = PROG_TO_EDICT(pr_global_struct->msg_entity);
	entnum = NUM_FOR_EDICT(ent);
	if (entnum < 1 || entnum > MAX_CLIENTS)
		PR2_RunError("WriteDest: not a client");
	return &svs.clients[entnum - 1];
}

void PF2_WriteByte(int to, int data)
{
	if (to == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 1);
		ClientReliableWrite_Byte(cl, data);
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 1))
			{
				MVD_MSG_WriteByte(data);
			}
		}
	}
	else
		MSG_WriteByte(WriteDest2(to), data);
}

void PF2_WriteChar(int to, int data)
{
	if (to == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 1);
		ClientReliableWrite_Char(cl, data);
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 1))
			{
				MVD_MSG_WriteByte(data);
			}
		}
	}
	else
		MSG_WriteChar(WriteDest2(to), data);
}

void PF2_WriteShort(int to, int data)
{
	if (to == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 2);
		ClientReliableWrite_Short(cl, data);
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 2))
			{
				MVD_MSG_WriteShort(data);
			}
		}
	}
	else
		MSG_WriteShort(WriteDest2(to), data);
}

void PF2_WriteLong(int to, int data)
{
	if (to == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 4);
		ClientReliableWrite_Long(cl, data);
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 4))
			{
				MVD_MSG_WriteLong(data);
			}
		}
	}
	else
		MSG_WriteLong(WriteDest2(to), data);
}

void PF2_WriteAngle(int to, float data)
{
	if (to == MSG_ONE)
	{
#ifdef FTE_PEXT_FLOATCOORDS
		int size = msg_anglesize;
#else
		int size = 1;
#endif
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, size);
		ClientReliableWrite_Angle(cl, data);
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, size))
			{
				MVD_MSG_WriteAngle(data);
			}
		}
	}
	else
		MSG_WriteAngle(WriteDest2(to), data);
}

void PF2_WriteCoord(int to, float data)
{
	if (to == MSG_ONE)
	{
#ifdef FTE_PEXT_FLOATCOORDS
		int size = msg_coordsize;
#else
		int size = 2;
#endif
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, size);
		ClientReliableWrite_Coord(cl, data);
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, size))
			{
				MVD_MSG_WriteCoord(data);
			}
		}
	}
	else
		MSG_WriteCoord(WriteDest2(to), data);
}

void PF2_WriteString(int to, char *data)
{
	if (to == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 1 + strlen(data));
		ClientReliableWrite_String(cl, data);
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 1 + strlen(data)))
			{
				MVD_MSG_WriteString(data);
			}
		}
	}
	else
		MSG_WriteString(WriteDest2(to), data);
}

void PF2_WriteEntity(int to, int data)
{
	if (to == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 2);
		ClientReliableWrite_Short(cl,data );//G_EDICTNUM(OFS_PARM1)
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 2))
			{
				MVD_MSG_WriteShort(data);
			}
		}
	}
	else
		MSG_WriteShort(WriteDest2(to), data);
}

//=============================================================================

int SV_ModelIndex(char *name);

/*
==================
PF2_makestatic 
 
==================
*/
void PF2_makestatic(edict_t *ent)
{
	entity_state_t *s;

	if (sv.static_entity_count >= sizeof(sv.static_entities) / sizeof(sv.static_entities[0])) {
		ED_Free (ent);
		return;
	}

	s = &sv.static_entities[sv.static_entity_count];
	memset(s, 0, sizeof(sv.static_entities[0]));
	s->number = sv.static_entity_count + 1;
	s->modelindex = SV_ModelIndex(PR_GetEntityString(ent->v->model));
	if (!s->modelindex) {
		ED_Free (ent);
		return;
	}
	s->frame = ent->v->frame;
	s->colormap = ent->v->colormap;
	s->skinnum = ent->v->skin;
	VectorCopy(ent->v->origin, s->origin);
	VectorCopy(ent->v->angles, s->angles);
#ifdef FTE_PEXT_TRANS
	s->trans = ent->xv.alpha >= 1.0f ? 0 : bound(0, (byte)(ent->xv.alpha * 254.0), 254);
#endif
#ifdef FTE_PEXT_COLOURMOD
	if (ent->xv.colourmod[0] != 1.0f && ent->xv.colourmod[1] != 1.0f && ent->xv.colourmod[2] != 1.0f)
	{
		s->colourmod[0] = bound(0, ent->xv.colourmod[0] * (256.0f / 8.0f), 255);
		s->colourmod[1] = bound(0, ent->xv.colourmod[1] * (256.0f / 8.0f), 255);
		s->colourmod[2] = bound(0, ent->xv.colourmod[2] * (256.0f / 8.0f), 255);
	}
#endif
	++sv.static_entity_count;

	// throw the entity away now
	ED_Free(ent);
}

//=============================================================================

/*
==============
PF2_setspawnparms
==============
*/
void PF2_setspawnparms(int entnum)
{
	int			i;
	client_t	*client;

	if (entnum < 1 || entnum > MAX_CLIENTS)
		PR2_RunError("Entity is not a client");

	// copy spawn parms out of the client_t
	client = svs.clients + (entnum - 1);

	for (i = 0; i < NUM_SPAWN_PARMS; i++)
		(&pr_global_struct->parm1)[i] = client->spawn_parms[i];
}

/*
==============
PF2_changelevel
==============
*/
void PF2_changelevel(char *s, char *entfile)
{
	static int last_spawncount;
	char expanded[MAX_QPATH];

	if (gamedata.APIversion < 15)
		entfile = "";
	// check to make sure the level exists.
	// this is work around for bellow check about two changelevels,
	// which lock server in one map if we trying switch to map which does't exist
	snprintf(expanded, MAX_QPATH, "maps/%s.bsp", s);
	if (!FS_FLocateFile(expanded, FSLFRT_IFFOUND, NULL))
	{
		Sys_Printf ("Can't find %s\n", expanded);
		return;
	}

	// make sure we don't issue two changelevels
	// this check is evil and cause lock on one map, if /map command fail for some reason
	if (svs.spawncount == last_spawncount)
		return;
	last_spawncount = svs.spawncount;

	if (entfile && *entfile) {
		Cbuf_AddTextEx(&cbuf_server, va("map %s %s\n", s, entfile));
	}
	else {
		Cbuf_AddTextEx(&cbuf_server, va("map %s\n", s));
	}
}

/*
==============
PF2_logfrag
 
logfrag (killer, killee)
==============
*/
void PF2_logfrag(int e1, int e2)
{
	char *s;
	// -> scream
	time_t		t;
	struct tm	*tblock;

	if (e1 < 1 || e1 > MAX_CLIENTS || e2 < 1 || e2 > MAX_CLIENTS)
		return;

	// -> scream
	t = time (NULL);
	tblock = localtime (&t);

	//bliP: date check ->
	if (!tblock)
		s = va("%s\n", "#bad date#");
	else
		if ((int)frag_log_type.value) // need for old-style frag log file
			s = va("\\frag\\%s\\%s\\%s\\%s\\%d-%d-%d %d:%d:%d\\\n",
			       svs.clients[e1-1].name, svs.clients[e2-1].name,
			       svs.clients[e1-1].team, svs.clients[e2-1].team,
			       tblock->tm_year + 1900, tblock->tm_mon + 1, tblock->tm_mday,
			       tblock->tm_hour, tblock->tm_min, tblock->tm_sec);
		else
			s = va("\\%s\\%s\\\n",svs.clients[e1-1].name, svs.clients[e2-1].name);
	// <-

	SZ_Print(&svs.log[svs.logsequence & 1], s);
	SV_Write_Log(FRAG_LOG, 1, s);
}
/*
==============
PF2_getinfokey
 
string(entity e, string key) infokey
==============
*/
void PF2_infokey(int e1, char *key, char *valbuff, int sizebuff)
//(int e1, char *key, char *valbuff, int sizebuff)
{
	static char ov[256];
	char		*value;

	value = ov;

	if (e1 == 0)
	{
		if (key && key[0] == '\\') { // so we can check is server support such "hacks" via infokey(world, "\\realip") f.e.
			key++;

			value = "no";

			if (   !strcmp(key, "date_str")
				|| !strcmp(key, "ip") || !strncmp(key, "realip", 7) || !strncmp(key, "download", 9)
				|| !strcmp(key, "ping") || !strcmp(key, "*userid") || !strncmp(key, "login", 6)
				|| !strcmp(key, "*VIP") || !strcmp(key, "*state")
				|| !strcmp(key, "netname")
				|| !strcmp(key, "mapname") || !strcmp(key, "modelname")
				|| !strcmp(key, "version") || !strcmp(key, "servername")
			   )
				value = "yes";
		}
		else if (!strcmp(key, "date_str")) { // qqshka - qvm does't have any time builtin support, so add this
			date_t date;

			SV_TimeOfDay(&date, "%a %b %d, %H:%M:%S %Y");
			snprintf(ov, sizeof(ov), "%s", date.str);
		}
		else if (!strcmp(key, "mapname")) {
			value = sv.mapname;
		}
		else if (!strcmp(key, "modelname")) {
			value = sv.modelname;
		}
		else if (!strcmp(key, "version")) {
			value = VersionStringFull();
		}
		else if (!strcmp(key, "servername")) {
			value = SERVER_NAME;
		}
		else if ((value = Info_ValueForKey(svs.info, key)) == NULL || !*value)
			value = Info_Get(&_localinfo_, key);
	}
	else if (e1 > 0 && e1 <= MAX_CLIENTS)
	{
		client_t *cl = &svs.clients[e1-1];

		if (!strcmp(key, "ip"))
			strlcpy(ov, NET_BaseAdrToString(cl->netchan.remote_address), sizeof(ov));
		else if (!strncmp(key, "realip", 7))
			strlcpy(ov, NET_BaseAdrToString (cl->realip), sizeof(ov));
		else if (!strncmp(key, "download", 9))
			snprintf(ov, sizeof(ov), "%d", cl->file_percent ? cl->file_percent : -1); //bliP: file percent
		else if (!strcmp(key, "ping"))
			snprintf(ov, sizeof(ov), "%d", (int)SV_CalcPing(cl));
		else if (!strcmp(key, "*userid"))
			snprintf(ov, sizeof(ov), "%d", cl->userid);
		else if (!strncmp(key, "login", 6))
			value = cl->login;
		else if (!strcmp(key, "*VIP")) // qqshka: also located in userinfo, but this is more safe/secure way, imo
			snprintf(ov, sizeof(ov), "%d", cl->vip);
		else if (!strcmp(key, "netname"))
			value = cl->name;
		else if (!strcmp(key, "*state"))
		{
			switch (cl->state)
			{
				case cs_free:         value = "free"; break;
				case cs_zombie:       value = "zombie"; break;
				case cs_preconnected: value = "preconnected"; break;
				case cs_connected:    value = "connected"; break;
				case cs_spawned:      value = "spawned"; break;

				default: value = "unknown"; break;
			}
		}
		else
			value = Info_Get(&cl->_userinfo_ctx_, key);
	}
	else
		value = "";

	if ((int) strlen(value) > sizebuff)
		Con_DPrintf("PR2_infokey: buffer size too small\n");

	strlcpy(valbuff, value, sizebuff);
	//	RETURN_STRING(value);
}

/*
==============
PF2_multicast
 
void(vector where, float set) multicast
==============
*/
void PF2_multicast(float x, float y, float z, int to)
//(vec3_t o, int to)
{
	vec3_t o;

	o[0] = x;
	o[1] = y;
	o[2] = z;
	SV_Multicast(o, to);
}

/*
==============
PF2_disable_updates
 
void(entiny whom, float time) disable_updates
==============
*/
void PF2_disable_updates(int entnum, float time1)
//(int entnum, float time)
{
	client_t *client;

	//	entnum = G_EDICTNUM(OFS_PARM0);
	//	time1 = G_FLOAT(OFS_PARM1);

	if (entnum < 1 || entnum > MAX_CLIENTS)
	{
		Con_Printf("tried to disable_updates to a non-client\n");
		return;
	}

	client = &svs.clients[entnum - 1];

	client->disable_updates_stop = realtime + time1;
}

#define MAX_PR2_FILES 8

typedef struct
{
	char name[256];
	vfsfile_t  *handle;
	fsMode_t accessmode;
}
pr2_fopen_files_t;

pr2_fopen_files_t pr2_fopen_files[MAX_PR2_FILES];
int pr2_num_open_files = 0;

char* cmodes[]={"rb","r","wb","w","ab","a"};
// FIXME: read from paks
int PF2_FS_OpenFile(char *name, fileHandle_t *handle, fsMode_t fmode)
{
	int i, ret = -1;

	if(pr2_num_open_files >= MAX_PR2_FILES)
	{
		return -1;
	}

	*handle = 0;
	for (i = 0; i < MAX_PR2_FILES; i++)
		if (!pr2_fopen_files[i].handle)
			break;
	if (i == MAX_PR2_FILES)	//too many already open
	{
		return -1;
	}

	if (FS_UnsafeFilename(name)) {
		// someone tried to be clever.
		return -1;
	}
	strlcpy(pr2_fopen_files[i].name, name, sizeof(pr2_fopen_files[i].name));
	pr2_fopen_files[i].accessmode = fmode;
	switch(fmode)
	{
	case FS_READ_BIN:
	case FS_READ_TXT:
#ifndef SERVERONLY
		pr2_fopen_files[i].handle = FS_OpenVFS(name, cmodes[fmode], FS_ANY);
#else
		pr2_fopen_files[i].handle = FS_OpenVFS(name, cmodes[fmode], FS_GAME);
#endif

		if(!pr2_fopen_files[i].handle)
		{
			return -1;
		}

		Con_DPrintf( "PF2_FS_OpenFile %s\n", name );

		ret = VFS_GETLEN(pr2_fopen_files[i].handle);

		break;
	case FS_WRITE_BIN:
	case FS_WRITE_TXT:
	case FS_APPEND_BIN:
	case FS_APPEND_TXT:
		// well, perhaps we we should create path...
		//		FS_CreatePathRelative(name, FS_GAME_OS);
		pr2_fopen_files[i].handle = FS_OpenVFS(name, cmodes[fmode], FS_GAME_OS);
		if ( !pr2_fopen_files[i].handle )
		{
			return -1;
		}
		Con_DPrintf( "PF2_FS_OpenFile %s\n", name );
		ret = VFS_TELL(pr2_fopen_files[i].handle);

		break;
	default:
		return -1;
	}

	*handle = i+1;
	pr2_num_open_files++;
	return ret;
}

void PF2_FS_CloseFile(fileHandle_t fnum)
{
	fnum--;
	if (fnum < 0 || fnum >= MAX_PR2_FILES)
		return;	//out of range
	if(!pr2_num_open_files)
		return;
	if(!(pr2_fopen_files[fnum].handle))
		return;

	VFS_CLOSE(pr2_fopen_files[fnum].handle);

	pr2_fopen_files[fnum].handle = NULL;
	pr2_num_open_files--;
}

int seek_origin[]={SEEK_CUR,SEEK_END,SEEK_SET};

intptr_t PF2_FS_SeekFile(fileHandle_t fnum, intptr_t offset, fsOrigin_t type)
{
	fnum--;

	if (fnum < 0 || fnum >= MAX_PR2_FILES)
		return 0;//out of range

	if(!pr2_num_open_files)
		return 0;

	if(!(pr2_fopen_files[fnum].handle))
		return 0;
	if(type < 0 || type >= sizeof(seek_origin) / sizeof(seek_origin[0]))
		return 0;

	return VFS_SEEK(pr2_fopen_files[fnum].handle, offset, seek_origin[type]);
}

intptr_t PF2_FS_TellFile(fileHandle_t fnum)
{
	fnum--;

	if (fnum < 0 || fnum >= MAX_PR2_FILES)
		return 0;//out of range

	if(!pr2_num_open_files)
		return 0;

	if(!(pr2_fopen_files[fnum].handle))
		return 0;

	return VFS_TELL(pr2_fopen_files[fnum].handle);
}

intptr_t PF2_FS_WriteFile(char *dest, intptr_t quantity, fileHandle_t fnum)
{
	fnum--;
	if (fnum < 0 || fnum >= MAX_PR2_FILES)
		return 0;//out of range

	if(!pr2_num_open_files)
		return 0;

	if(!(pr2_fopen_files[fnum].handle))
		return 0;

	return VFS_WRITE(pr2_fopen_files[fnum].handle, dest, quantity);
}

intptr_t PF2_FS_ReadFile(char *dest, intptr_t quantity, fileHandle_t fnum)
{
	fnum--;
	if (fnum < 0 || fnum >= MAX_PR2_FILES)
		return 0;//out of range

	if(!pr2_num_open_files)
		return 0;

	if(!(pr2_fopen_files[fnum].handle))
		return 0;

	return VFS_READ(pr2_fopen_files[fnum].handle, dest, quantity, NULL);
}

void PR2_FS_Restart(void)
{
	int i;

	if(pr2_num_open_files)
	{
		for (i = 0; i < MAX_PR2_FILES; i++)
		{
			if(pr2_fopen_files[i].handle)
			{
				VFS_CLOSE(pr2_fopen_files[i].handle);
				pr2_num_open_files--;
				pr2_fopen_files[i].handle = NULL;
			}
		}
	}
	if(pr2_num_open_files)
		Sys_Error("PR2_fcloseall: pr2_num_open_files != 0");
	pr2_num_open_files = 0;
	memset(pr2_fopen_files,0,sizeof(pr2_fopen_files));
}

static int GetFileList_Compare (const void *p1, const void *p2)
{
	return strcmp (*((char**)p1), *((char**)p2));
}

#define FILELIST_GAMEDIR_ONLY	(1<<0) // if set then search in gamedir only
#define FILELIST_WITH_PATH		(1<<1) // include path to file
#define FILELIST_WITH_EXT		(1<<2) // include extension of file

intptr_t PF2_FS_GetFileList(char *path, char *ext,
			char *listbuff, intptr_t buffsize, intptr_t flags)
{
//	extern	searchpath_t *com_searchpaths; // evil, because this must be used in fs.c only...
	char	*gpath = NULL;

	char 	*list[MAX_DIRFILES];
	const 	int	list_cnt = sizeof(list) / sizeof(list[0]);

	dir_t	dir;

//	searchpath_t *search;
	char	netpath[MAX_OSPATH], *fullname;

	char	*dirptr;

	int numfiles = 0;
	int i, j;

	if (gamedata.APIversion < 15)
		flags = 0;

	memset(list, 0, sizeof(list));

	dirptr   = listbuff;
	*dirptr  = 0;

	if (strstr( path, ".." ) || strstr( path, "::" ))
		return 0; // do not allow relative paths

	// search through the path, one element at a time
	for (i = 0, gpath = NULL; i < list_cnt && ( gpath = FS_NextPath( gpath ) ); )
	{
		// if FILELIST_GAMEDIR_ONLY set then search in gamedir only
		if ((flags & FILELIST_GAMEDIR_ONLY) && strcmp(gpath, fs_gamedir))
			continue;

		snprintf (netpath, sizeof (netpath), "%s/%s", gpath, path);

		// reg exp search...
		dir = Sys_listdir(netpath, ext, SORT_NO);

		for (j = 0; i < list_cnt && dir.files[j].name[0]; j++, i++)
		{
			if (flags & FILELIST_WITH_PATH)
			{
				// with path
				snprintf (netpath, sizeof (netpath), "%s/%s", gpath, dir.files[j].name);
				fullname = netpath;

				// skip "./" prefix
				if (!strncmp(fullname, "./", sizeof("./") - 1))
					fullname += 2;
			}
			else
			{
				// just name
				fullname = dir.files[j].name;
			}

			// skip file extension
			if (!(flags & FILELIST_WITH_EXT)) {
#ifndef SERVERONLY
				COM_StripExtension(fullname, fullname, sizeof(fullname));
#else
				COM_StripExtension(fullname);
#endif
			}

			list[i] = Q_strdup(fullname); // a bit below we will free it
		}
	}

	// sort it, this will help exclude duplicates a bit below
	qsort (list, i, sizeof(list[0]), GetFileList_Compare);

	// copy
	for (i = 0; i < list_cnt && list[i]; i++)
	{
		size_t namelen = strlen(list[i]) + 1;

		if(dirptr + namelen > listbuff + buffsize)
			break;

		if (!*list[i])
			continue; // hrm, empty

		// simple way to exclude duplicates, since we sorted it above!
		if (i && !strcmp(list[i-1], list[i]))
			continue;

//		Con_Printf("%4d %s\n", i, list[i]);

		strlcpy(dirptr, list[i], namelen);
		dirptr += namelen;

		numfiles++;
	}

	// free allocated mem
	for (i = 0; i < list_cnt; i++)
		Q_free(list[i]);
	return numfiles;
}

// To prevent mods from hardcoding field offsets which would cause engine incompatibilities.
static uint32_t GetExtFieldCookie(void)
{
	static uint32_t cookie = 0;
	while (cookie == 0)
	{
		cookie = ((uint32_t)(rand() & 0xFFFF)) << 16;
	}
	return cookie;
}

static qbool ValidateExtFieldToken(uint32_t token, uint32_t *offset)
{
	uint32_t cookie = GetExtFieldCookie();
	*offset = token & ~cookie;
	return (token & cookie) == cookie;
}

static intptr_t EXT_SetExtFieldPtr(intptr_t *args)
{
	uint32_t field_ref;
	edict_t *e;
	size_t size;

	if (!ValidateExtFieldToken(args[2], &field_ref))
	{
		Con_Printf("SetExtFieldPtr: Corrupt field reference!\n");
		return 0;
	}

	size = args[4];

	if ((field_ref + size) > sizeof(ext_entvars_t))
	{
		Con_Printf("SetExtFieldPtr: Field reference out of bounds!\n");
		return 0;
	}

	e = &sv.edicts[NUM_FOR_GAME_EDICT(VM_ArgPtr(args[1]))];
	memcpy((byte*)&e->xv + field_ref, VM_ArgPtr(args[3]), size);

	return 1;
}

static intptr_t EXT_GetExtFieldPtr(intptr_t *args)
{
	uint32_t field_ref;
	edict_t *e;
	size_t size;

	if (!ValidateExtFieldToken(args[2], &field_ref))
	{
		Con_Printf("GetExtFieldPtr: Corrupt field reference!\n");
		return 0;
	}

	size = args[4];

	if ((field_ref + size) > sizeof(ext_entvars_t))
	{
		Con_Printf("GetExtFieldPtr: Field reference out of bounds!\n");
		return 0;
	}

	e = &sv.edicts[NUM_FOR_GAME_EDICT(VM_ArgPtr(args[1]))];
	memcpy(VM_ArgPtr(args[3]), (byte*)&e->xv + field_ref, size);

	return 1;
}

static intptr_t EXT_MapExtFieldPtr(intptr_t *args)
{
	char *key = VM_ArgPtr(args[1]);
	if (key)
	{
		if (!strcmp(key, "alpha"))
		{
			return offsetof(ext_entvars_t, alpha) | GetExtFieldCookie();
		}
		if (!strcmp(key, "colormod"))
		{
			return offsetof(ext_entvars_t, colourmod) | GetExtFieldCookie();
		}
	}

	return 0;
}

/*
  int trap_Map_Extension( const char* ext_name, int mapto)
  return:
    0 	success maping
   -1	not found
   -2	cannot map
*/
intptr_t PF2_Map_Extension(char *name, int mapto)
{
	int i;

	if ((mapto - G_EXTENSIONS_FIRST) >= ARRAY_LEN(ext_syscall_tbl))
	{
		return -2;
	}

	if (!name)
	{
		if (mapto < _G__LASTAPI)
		{
			return -2;
		}
		return -1;
	}
	for (i = 0; i < ARRAY_LEN(ext_syscalls); i++)
	{
		if (!strcmp(ext_syscalls[i].extname, name))
		{
			ext_syscall_tbl[mapto - G_EXTENSIONS_FIRST] = ext_syscalls[i].fun;
			return mapto;
		}
	}

	return -1;
}
/////////Bot Functions
extern cvar_t maxclients, maxspectators;
int PF2_Add_Bot(char *name, int bottomcolor, int topcolor, char *skin)
{
	client_t *cl, *newcl = NULL;
	int     edictnum;
	int     clients, i;
	extern char *shortinfotbl[];
	char   *s;
	edict_t *ent;
	eval_t *val;
	int old_self;
	char info[MAX_EXT_INFO_STRING];

	// count up the clients and spectators
	clients = 0;
	for ( i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++ )
	{
		if ( cl->state == cs_free )
			continue;
		if ( !cl->spectator )
			clients++;
	}

	// if at server limits, refuse connection
	if ((int)maxclients.value > MAX_CLIENTS )
		Cvar_SetValue( &maxclients, MAX_CLIENTS );
	if ((int)maxspectators.value > MAX_CLIENTS )
		Cvar_SetValue( &maxspectators, MAX_CLIENTS );
	if ((int)maxspectators.value + maxclients.value > MAX_CLIENTS )
		Cvar_SetValue( &maxspectators, MAX_CLIENTS - (int)maxclients.value );

	if ( clients >= ( int ) maxclients.value )
	{
		return 0;
	}
	for ( i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++ )
	{
		if ( cl->state == cs_free )
		{
			newcl = cl;
			break;
		}
	}
	if ( !newcl )
	{
		return 0;
	}

	memset(newcl, 0, sizeof(*newcl));
	edictnum = (newcl - svs.clients) + 1;
	ent = EDICT_NUM(edictnum);
	ED_ClearEdict(ent);

	memset(&newcl->_userinfo_ctx_, 0, sizeof(newcl->_userinfo_ctx_));
	memset(&newcl->_userinfoshort_ctx_, 0, sizeof(newcl->_userinfoshort_ctx_));

	snprintf( info, sizeof( info ),
	          "\\name\\%s\\topcolor\\%d\\bottomcolor\\%d\\emodel\\6967\\pmodel\\13845\\skin\\%s\\*bot\\1",
	          name, topcolor, bottomcolor, skin );

	newcl->_userinfo_ctx_.max      = MAX_CLIENT_INFOS;
	newcl->_userinfoshort_ctx_.max = MAX_CLIENT_INFOS;
	Info_Convert(&newcl->_userinfo_ctx_, info);

	newcl->state = cs_spawned;
	newcl->userid = SV_GenerateUserID();
	newcl->datagram.allowoverflow = true;
	newcl->datagram.data = newcl->datagram_buf;
	newcl->datagram.maxsize = sizeof( newcl->datagram_buf );
	newcl->spectator = 0;
	newcl->isBot = 1;
	SV_SetClientConnectionTime(newcl);
	strlcpy(newcl->name, name, sizeof(newcl->name));

	newcl->entgravity = 1.0;
	val = PR2_GetEdictFieldValue( ent, "gravity" ); // FIXME: do it similar to maxspeed
	if ( val )
		val->_float = 1.0;
	sv_client->maxspeed = sv_maxspeed.value;

	if (fofs_maxspeed)
		EdictFieldFloat(ent, fofs_maxspeed) = sv_maxspeed.value;

	newcl->edict = ent;
	ent->v->colormap = edictnum;
	val = PR2_GetEdictFieldValue(ent, "isBot"); // FIXME: do it similar to maxspeed
	if( val )
		val->_int = 1;

	// restore client name.
	PR_SetEntityString(ent, ent->v->netname, newcl->name);

	memset( newcl->stats, 0, sizeof( newcl->stats ) );
	SZ_InitEx (&newcl->netchan.message, newcl->netchan.message_buf, (int)sizeof(newcl->netchan.message_buf), true);
	SZ_Clear( &newcl->netchan.message );
	newcl->netchan.drop_count = 0;
	newcl->netchan.incoming_sequence = 1;

	// copy the most important userinfo into userinfoshort
	// {
	SV_ExtractFromUserinfo( newcl, true );

	for ( i = 0; shortinfotbl[i] != NULL; i++ )
	{
		s = Info_Get( &newcl->_userinfo_ctx_, shortinfotbl[i] );
		Info_SetStar( &newcl->_userinfoshort_ctx_, shortinfotbl[i], s );
	}

	// move star keys to infoshort
	Info_CopyStar( &newcl->_userinfo_ctx_, &newcl->_userinfoshort_ctx_ );

	// }

	newcl->disable_updates_stop = -1.0;	// Vladis

	SV_FullClientUpdate( newcl, &sv.reliable_datagram );

	old_self = pr_global_struct->self;
	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(newcl->edict);

	PR2_GameClientConnect(0);
	PR2_GamePutClientInServer(0);

	pr_global_struct->self = old_self;
	return edictnum;
}

void RemoveBot(client_t *cl)
{

	if( !cl->isBot )
		return;

	pr_global_struct->self = EDICT_TO_PROG(cl->edict);
	if ( sv_vm )
		PR2_GameClientDisconnect(0);

	cl->old_frags = 0;
	cl->edict->v->frags = 0.0;
	cl->name[0] = 0;
	cl->state = cs_free;

	Info_RemoveAll(&cl->_userinfo_ctx_);
	Info_RemoveAll(&cl->_userinfoshort_ctx_);

	SV_FullClientUpdate( cl, &sv.reliable_datagram );
	cl->isBot = 0;
}

void PF2_Remove_Bot(int entnum)
{
	client_t *cl;
	int old_self;

	if ( entnum < 1 || entnum > MAX_CLIENTS )
	{
		Con_Printf( "tried to remove a non-botclient %d \n", entnum );
		return;
	}
	cl = &svs.clients[entnum - 1];
	if ( !cl->isBot )
	{
		Con_Printf( "tried to remove a non-botclient %d \n", entnum );
		return;
	}
	old_self = pr_global_struct->self; //save self

	pr_global_struct->self = entnum;
	RemoveBot(cl);
	pr_global_struct->self = old_self;

}

// FIXME: Why PR2_UserInfoChanged is not called here? Like for normal players.
//        Why we need this special handling in the first place?
void PF2_SetBotUserInfo(int entnum, char *key, char *value, int flags)
{
	client_t *cl;
	int     i;
	extern char *shortinfotbl[];

	if (gamedata.APIversion < 15)
		flags = 0;
	if (strstr(key, "&c") || strstr(key, "&r") || strstr(value, "&c") || strstr(value, "&r"))
		return;

	if ( entnum < 1 || entnum > MAX_CLIENTS )
	{
		Con_Printf( "tried to change userinfo a non-botclient %d \n", entnum );
		return;
	}
	cl = &svs.clients[entnum - 1];
	if ( !cl->isBot )
	{
		Con_Printf( "tried to change userinfo a non-botclient %d \n", entnum );
		return;
	}

	if ( flags & SETUSERINFO_STAR )
		Info_SetStar( &cl->_userinfo_ctx_, key, value );
	else
		Info_Set( &cl->_userinfo_ctx_, key, value );
	SV_ExtractFromUserinfo( cl, !strcmp( key, "name" ) );

	for ( i = 0; shortinfotbl[i] != NULL; i++ )
	{
		if ( key[0] == '_' || !strcmp( key, shortinfotbl[i] ) )
		{
			char *nuw = Info_Get( &cl->_userinfo_ctx_, key );

			Info_Set( &cl->_userinfoshort_ctx_, key, nuw );

			i = cl - svs.clients;
			MSG_WriteByte( &sv.reliable_datagram, svc_setinfo );
			MSG_WriteByte( &sv.reliable_datagram, i );
			MSG_WriteString( &sv.reliable_datagram, key );
			MSG_WriteString( &sv.reliable_datagram, nuw );
			break;
		}
	}
}

void PF2_SetBotCMD(int entnum, int msec, float a1, float a2, float a3,
				int forwardmove, int sidemove, int upmove, int buttons, int impulse)
{
	client_t *cl;

	if ( entnum < 1 || entnum > MAX_CLIENTS )
	{
		Con_Printf( "tried to set cmd a non-botclient %d \n", entnum );
		return;
	}
	cl = &svs.clients[entnum - 1];
	if ( !cl->isBot )
	{
		Con_Printf( "tried to set cmd a non-botclient %d \n", entnum );
		return;
	}
	cl->botcmd.msec = msec;
	cl->botcmd.angles[0] = a1;
	cl->botcmd.angles[1] = a2;
	cl->botcmd.angles[2] = a3;
	cl->botcmd.forwardmove = forwardmove;
	cl->botcmd.sidemove = sidemove;
	cl->botcmd.upmove = upmove;
	cl->botcmd.buttons = buttons;
	cl->botcmd.impulse = impulse;

	if (cl->edict->v->fixangle)
	{
		VectorCopy(cl->edict->v->angles, cl->botcmd.angles);
		cl->botcmd.angles[PITCH] *= -3;
		cl->edict->v->fixangle = 0;
	}
}

//=========================================
// some time support in QVM
//=========================================

/*
==============
PF2_QVMstrftime
==============
*/
int PF2_QVMstrftime(char *valbuff, int sizebuff, char *fmt, int offset)
{
	struct tm *newtime;
	time_t long_time;
	int ret;

	if (sizebuff <= 0 || !valbuff) {
		Con_DPrintf("PF2_QVMstrftime: wrong buffer\n");
		return 0;
	}

	time(&long_time);
	long_time += offset;
	newtime = localtime(&long_time);

	if (!newtime)
	{
		valbuff[0] = 0; // or may be better set to "#bad date#" ?
		return 0;
	}

	ret = strftime(valbuff, sizebuff-1, fmt, newtime);

	if (!ret) {
		valbuff[0] = 0; // or may be better set to "#bad date#" ?
		Con_DPrintf("PF2_QVMstrftime: buffer size too small\n");
		return 0;
	}
	return ret;
}

// a la the ZQ_PAUSE QC extension
void PF2_setpause(int pause)
{
	if (pause != (sv.paused & 1))
		SV_TogglePause (NULL, 1);
}

void PF2_SetUserInfo(int entnum, char *k, char *v, int flags)
{
	client_t *cl;
	char   key[MAX_KEY_STRING];
	char   value[MAX_KEY_STRING];
	char   s[MAX_KEY_STRING * 4];
	int     i;
	extern char *shortinfotbl[];

	if (strstr(k, "&c") || strstr(k, "&r") || strstr(v, "&c") || strstr(v, "&r"))
		return;

	if ( entnum < 1 || entnum > MAX_CLIENTS )
	{
		Con_Printf( "tried to change userinfo a non-client %d \n", entnum );
		return;
	}

	cl = &svs.clients[entnum - 1];

	// well, our API is weird
	if ( cl->isBot )
	{
		PF2_SetBotUserInfo(entnum, k, v, flags);
		return;
	}

	// tokenize

	snprintf( s, sizeof(s), "PF2_SetUserInfo \"%-.*s\" \"%-.*s\"", (int)sizeof(key), k, (int)sizeof(value), v );

	Cmd_TokenizeString( s );

	// well, PR2_UserInfoChanged() may call PF2_SetUserInfo() again, so we better save thouse
	strlcpy( key, Cmd_Argv(1), sizeof(key) );
	strlcpy( value, Cmd_Argv(2), sizeof(value) );

	if( sv_vm )
	{
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(cl->edict);

		if (PR2_UserInfoChanged(0))
			return;
	}

	if ( flags & SETUSERINFO_STAR )
		Info_SetStar( &cl->_userinfo_ctx_, key, value );
	else
		Info_Set( &cl->_userinfo_ctx_, key, value );

	SV_ExtractFromUserinfo( cl, !strcmp( key, "name" ) );
	PR2_UserInfoChanged(1);

	for ( i = 0; shortinfotbl[i] != NULL; i++ )
	{
		if ( !strcmp( key, shortinfotbl[i] ) )
		{
			char *nuw = Info_Get( &cl->_userinfo_ctx_, key );

			// well, here we do not have if ( flags & SETUSERINFO_STAR ) because shortinfotbl[] does't have any star key

			Info_Set( &cl->_userinfoshort_ctx_, key, nuw );

			i = cl - svs.clients;
			MSG_WriteByte( &sv.reliable_datagram, svc_setinfo );
			MSG_WriteByte( &sv.reliable_datagram, i );
			MSG_WriteString( &sv.reliable_datagram, key );
			MSG_WriteString( &sv.reliable_datagram, nuw );
			break;
		}
	}
}

void PF2_VisibleTo(int viewer, int first, int len, byte *visible)
{
	int e, last = first + len;
	edict_t *ent;
	edict_t *viewer_ent = EDICT_NUM(viewer);
	vec3_t org;
	byte *pvs;

	if (last > sv.num_edicts)
		last = sv.num_edicts;

	VectorAdd(viewer_ent->v->origin, viewer_ent->v->view_ofs, org);
	pvs = CM_FatPVS(org);

	for (e = first, ent = EDICT_NUM(e); e < last; e++, ent = NEXT_EDICT(ent))
	{
		int i;
		if (ent->e.num_leafs < 0 || ent->e.free
			|| (e >= 1 && e <= MAX_CLIENTS && svs.clients[e - 1].state != cs_spawned)) {
			continue; // Ignore free edicts or not active client.
		}
		for (i = 0; i < ent->e.num_leafs; i++) {
			if (pvs[ent->e.leafnums[i] >> 3] & (1 << (ent->e.leafnums[i]&7))) {
				visible[e - first] = true; // seems to be visible
				break;
			}
		}
	}
}

//===========================================================================
// SysCalls
//===========================================================================

#define VMV(x) _vmf(args[x]), _vmf(args[(x) + 1]), _vmf(args[(x) + 2])
#define VME(x) EDICT_NUM(args[x])
intptr_t PR2_GameSystemCalls(intptr_t *args) {
	switch (args[0]) {
	case G_GETAPIVERSION:
		return GAME_API_VERSION;
	case G_DPRINT:
		Con_DPrintf("%s", (const char *)VMA(1));
		return 0;
	case G_ERROR:
		PR2_RunError(VMA(1));
		return 0;
	case G_GetEntityToken:
		VM_CheckBounds(sv_vm, args[1], args[2]);
		pr2_ent_data_ptr = COM_Parse(pr2_ent_data_ptr);
		strlcpy(VMA(1), com_token, args[2]);
		return pr2_ent_data_ptr != NULL;
	case G_SPAWN_ENT:
		return NUM_FOR_EDICT(ED_Alloc());
	case G_REMOVE_ENT:
		ED_Free(VME(1));
		return 0;
	case G_PRECACHE_SOUND:
		PF2_precache_sound(VMA(1));
		return 0;
	case G_PRECACHE_MODEL:
		PF2_precache_model(VMA(1));
		return 0;
	case G_LIGHTSTYLE:
		PF2_lightstyle(args[1], VMA(2));
		return 0;
	case G_SETORIGIN:
		PF2_setorigin(VME(1), VMV(2));
		return 0;
	case G_SETSIZE:
		PF2_setsize(VME(1), VMV(2), VMV(5));
		return 0;
	case G_SETMODEL:
		PF2_setmodel(VME(1), VMA(2));
		return 0;
	case G_BPRINT: {
		int flags = args[3];
		if (gamedata.APIversion < 15)
			flags = 0;
		SV_BroadcastPrintfEx(args[1], flags, "%s", VMA(2));
	}
		return 0;
	case G_SPRINT:
		PF2_sprint(args[1], args[2], VMA(3), args[4]);
		return 0;
	case G_CENTERPRINT:
		PF2_centerprint(args[1], VMA(2));
		return 0;
	case G_AMBIENTSOUND:
		PF2_ambientsound(VMV(1), VMA(4), VMF(5), VMF(6));
		return 0;
	case G_SOUND:
		/*
		=================
		PF2_sound

		Each entity can have eight independant sound sources, like voice,
		weapon, feet, etc.

		Channel 0 is an auto-allocate channel, the others override anything
		already running on that entity/channel pair.

		An attenuation of 0 will play full volume everywhere in the level.
		Larger attenuations will drop off.
		void sound( gedict_t * ed, int channel, char *samp, float vol, float att )
		=================
		*/
		SV_StartSound(VME(1), args[2], VMA(3), VMF(4) * 255, VMF(5));
		return 0;
	case G_TRACELINE:
		PF2_traceline(VMV(1), VMV(4), args[7], args[8]);
		return 0;
	case G_CHECKCLIENT:
		return PF2_checkclient();
	case G_STUFFCMD:
		PF2_stuffcmd(args[1], VMA(2), args[3]);
		return 0;
	case G_LOCALCMD:
		/* =================
		Sends text over to the server's execution buffer

		localcmd (string)
		================= */
		Cbuf_AddTextEx(&cbuf_server, VMA(1));
		return 0;
	case G_CVAR:
		return PASSFLOAT(Cvar_Value(VMA(1)));
	case G_CVAR_SET:
		Cvar_SetByName(VMA(1), VMA(2));
		return 0;
	case G_FINDRADIUS:
		return PF2_FindRadius(NUM_FOR_GAME_EDICT(VMA(1)), (float *)VMA(2), VMF(3));
	case G_WALKMOVE:
		return PF2_walkmove(VME(1), VMF(2), VMF(3));
	case G_DROPTOFLOOR:
		return PF2_droptofloor(VME(1));
	case G_CHECKBOTTOM:
		return SV_CheckBottom(VME(1));
	case G_POINTCONTENTS:
		return PF2_pointcontents(VMV(1));
	case G_NEXTENT:
		return PF2_nextent(args[1]);
	case G_AIM:
		return 0;
	case G_MAKESTATIC:
		PF2_makestatic(VME(1));
		return 0;
	case G_SETSPAWNPARAMS:
		PF2_setspawnparms(args[1]);
		return 0;
	case G_CHANGELEVEL:
		PF2_changelevel(VMA(1), VMA(2));
		return 0;
	case G_LOGFRAG:
		PF2_logfrag(args[1], args[2]);
		return 0;
	case G_GETINFOKEY:
		VM_CheckBounds(sv_vm, args[3], args[4]);
		PF2_infokey(args[1], VMA(2), VMA(3), args[4]);
		return 0;
	case G_MULTICAST:
		PF2_multicast(VMV(1), args[4]);
		return 0;
	case G_DISABLEUPDATES:
		PF2_disable_updates(args[1], VMF(2));
		return 0;
	case G_WRITEBYTE:
		PF2_WriteByte(args[1], args[2]);
		return 0;
	case G_WRITECHAR:
		PF2_WriteChar(args[1], args[2]);
		return 0;
	case G_WRITESHORT:
		PF2_WriteShort(args[1], args[2]);
		return 0;
	case G_WRITELONG:
		PF2_WriteLong(args[1], args[2]);
		return 0;
	case G_WRITEANGLE:
		PF2_WriteAngle(args[1], VMF(2));
		return 0;
	case G_WRITECOORD:
		PF2_WriteCoord(args[1], VMF(2));
		return 0;
	case G_WRITESTRING:
		PF2_WriteString(args[1], VMA(2));
		return 0;
	case G_WRITEENTITY:
		PF2_WriteEntity(args[1], args[2]);
		return 0;
	case G_FLUSHSIGNON:
		SV_FlushSignon();
		return 0;
	case g_memset:
		VM_CheckBounds(sv_vm, args[1], args[3]);
		memset(VMA(1), args[2], args[3]);
		return args[1];
	case g_memcpy:
		VM_CheckBounds2(sv_vm, args[1], args[2], args[3]);
		memcpy(VMA(1), VMA(2), args[3]);
		return args[1];
	case g_strncpy:
		VM_CheckBounds2(sv_vm, args[1], args[2], args[3]);
		strncpy(VMA(1), VMA(2), args[3]);
		return args[1];
	case g_sin:
		return PASSFLOAT(sin(VMF(1)));
	case g_cos:
		return PASSFLOAT(cos(VMF(1)));
	case g_atan2:
		return PASSFLOAT(atan2(VMF(1), VMF(2)));
	case g_sqrt:
		return PASSFLOAT(sqrt(VMF(1)));
	case g_floor:
		return PASSFLOAT(floor(VMF(1)));
	case g_ceil:
		return PASSFLOAT(ceil(VMF(1)));
	case g_acos:
		return PASSFLOAT(acos(VMF(1)));
	case G_CMD_ARGC:
		return Cmd_Argc();
	case G_CMD_ARGV:
		VM_CheckBounds(sv_vm, args[2], args[3]);
		strlcpy(VMA(2), Cmd_Argv(args[1]), args[3]);
		return 0;
	case G_TraceCapsule:
		PF2_TraceCapsule(VMV(1), VMV(4), args[7], VME(8), VMV(9), VMV(12));
		return 0;
	case G_FSOpenFile:
		return PF2_FS_OpenFile(VMA(1), (fileHandle_t *)VMA(2), (fsMode_t)args[3]);
	case G_FSCloseFile:
		PF2_FS_CloseFile((fileHandle_t)args[1]);
		return 0;
	case G_FSReadFile:
		VM_CheckBounds(sv_vm, args[1], args[2]);
		return PF2_FS_ReadFile(VMA(1), args[2], (fileHandle_t)args[3]);
	case G_FSWriteFile:
		VM_CheckBounds(sv_vm, args[1], args[2]);
		return PF2_FS_WriteFile(VMA(1), args[2], (fileHandle_t)args[3]);
	case G_FSSeekFile:
		return PF2_FS_SeekFile((fileHandle_t)args[1], args[2], (fsOrigin_t)args[3]);
	case G_FSTellFile:
		return PF2_FS_TellFile((fileHandle_t)args[1]);
	case G_FSGetFileList:
		VM_CheckBounds(sv_vm, args[3], args[4]);
		return PF2_FS_GetFileList(VMA(1), VMA(2), VMA(3), args[4], args[5]);
	case G_CVAR_SET_FLOAT:
		Cvar_SetValueByName(VMA(1), VMF(2));
		return 0;
	case G_CVAR_STRING:
		VM_CheckBounds(sv_vm, args[2], args[3]);
		strlcpy(VMA(2), Cvar_String(VMA(1)), args[3]);
		return 0;
	case G_Map_Extension:
		return PF2_Map_Extension(VMA(1), args[2]);
	case G_strcmp:
		return strcmp(VMA(1), VMA(2));
	case G_strncmp:
		return strncmp(VMA(1), VMA(2), args[3]);
	case G_stricmp:
		return strcasecmp(VMA(1), VMA(2));
	case G_strnicmp:
		return strncasecmp(VMA(1), VMA(2), args[3]);
	case G_Find:
		return PF2_Find(NUM_FOR_GAME_EDICT(VMA(1)), args[2], VMA(3));
	case G_executecmd:
		PF2_executecmd();
		return 0;
	case G_conprint:
		Sys_Printf("%s", VMA(1));
		return 0;
	case G_readcmd:
		VM_CheckBounds(sv_vm, args[2], args[3]);
		PF2_readcmd(VMA(1), VMA(2), args[3]);
		return 0;
	case G_redirectcmd:
		PF2_redirectcmd(NUM_FOR_GAME_EDICT(VMA(1)), VMA(2));
		return 0;
	case G_Add_Bot:
		return PF2_Add_Bot(VMA(1), args[2], args[3], VMA(4));
	case G_Remove_Bot:
		PF2_Remove_Bot(args[1]);
		return 0;
	case G_SetBotUserInfo:
		PF2_SetBotUserInfo(args[1], VMA(2), VMA(3), args[4]);
		return 0;
	case G_SetBotCMD:
		PF2_SetBotCMD(args[1], args[2], VMV(3), args[6], args[7], args[8], args[9], args[10]);
		return 0;
	case G_QVMstrftime:
		VM_CheckBounds(sv_vm, args[1], args[2]);
		return PF2_QVMstrftime(VMA(1), args[2], VMA(3), args[4]);
	case G_CMD_ARGS:
		VM_CheckBounds(sv_vm, args[1], args[2]);
		strlcpy(VMA(1), Cmd_Args(), args[2]);
		return 0;
	case G_CMD_TOKENIZE:
		Cmd_TokenizeString(VMA(1));
		return 0;
	case g_strlcpy:
		VM_CheckBounds(sv_vm, args[1], args[3]);
		return strlcpy(VMA(1), VMA(2), args[3]);
	case g_strlcat:
		VM_CheckBounds(sv_vm, args[1], args[3]);
		return strlcat(VMA(1), VMA(2), args[3]);
	case G_MAKEVECTORS:
		AngleVectors(VMA(1), pr_global_struct->v_forward, pr_global_struct->v_right,
								 pr_global_struct->v_up);
		return 0;
	case G_NEXTCLIENT:
		return PF2_nextclient(NUM_FOR_GAME_EDICT(VMA(1)));
	case G_PRECACHE_VWEP_MODEL:
		return PF2_precache_vwep_model(VMA(1));
	case G_SETPAUSE:
		PF2_setpause(args[1]);
		return 0;
	case G_SETUSERINFO:
		PF2_SetUserInfo(args[1], VMA(2), VMA(3), args[4]);
		return 0;
	case G_MOVETOGOAL:
		PF2_MoveToGoal(VMF(1));
		return 0;
	case G_VISIBLETO:
		VM_CheckBounds(sv_vm, args[4], args[3]);
		memset(VMA(4), 0, args[3]); // Ensure same memory state on each run.
		PF2_VisibleTo(args[1], args[2], args[3], VMA(4));
		return 0;
	default:
		if (args[0] >= _G__LASTAPI && ext_syscall_tbl[args[0] - G_EXTENSIONS_FIRST])
		{
			return ext_syscall_tbl[args[0] - G_EXTENSIONS_FIRST](args);
		}
		else
		{
			SV_Error("Bad game system trap: %ld", (long int)args[0]);
		}
	}
	return 0;
}

#endif /* USE_PR2 */

#endif // !CLIENTONLY


================================================
FILE: src/pr2_edict.c
================================================
/*
 *  QW262
 *  Copyright (C) 2004  [sd] angel
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 *  
 */

#ifndef CLIENTONLY
#ifdef USE_PR2

#include "qwsvdef.h"

field_t *fields;

eval_t *PR2_GetEdictFieldValue(edict_t *ed, char *field)
{
	char *s;
	field_t	*f;

	if (!sv_vm)
		return PR1_GetEdictFieldValue(ed, field);

	for (f = fields; (s = PR2_GetString(f->name)) && *s; f++)
		if (!strcasecmp(PR2_GetString(f->name), field))
			return (eval_t *)((char *)ed->v + f->ofs);

	return NULL;
}

int ED2_FindFieldOffset (char *field)
{
	char *s;
	field_t	*f;

	if (!sv_vm)
		return ED1_FindFieldOffset(field);

	for (f = fields; (s = PR2_GetString(f->name)) && *s; f++)
		if (!strcasecmp(PR2_GetString(f->name), field))
			return f->ofs;

	return 0;
}

/*
=============
ED2_PrintEdict_f
 
For debugging, prints a single edicy
=============
*/
void ED2_PrintEdict_f (void)
{
	extern void ED_PrintEdict_f (void);

	if(!sv_vm)
		ED_PrintEdict_f();
}

/*
=============
ED2_PrintEdicts
 
For debugging, prints all the entities in the current server
=============
*/
void ED2_PrintEdicts (void)
{
	extern void ED_PrintEdicts (void);

	if(!sv_vm)
		ED_PrintEdicts();
}

#endif /* USE_PR2 */

#endif // !CLIENTONLY


================================================
FILE: src/pr2_exec.c
================================================
/*
 *  QW262
 *  Copyright (C) 2004  [sd] angel
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 *  
 */

#ifndef CLIENTONLY
#ifdef USE_PR2

#include "qwsvdef.h"
#include "vm_local.h"

gameData_t gamedata;
extern field_t *fields;

// 0 = pr1 (qwprogs.dat etc), 1 = native (.so/.dll), 2 = q3vm (.qvm), 3 = q3vm (.qvm) with JIT
cvar_t sv_progtype = { "sv_progtype","0" };

// 0 = standard, 1 = pr2 mods set string_t fields as byte offsets to location of actual strings
cvar_t sv_pr2references = {"sv_pr2references", "0"};

void ED2_PrintEdicts (void);
void PR2_Profile_f (void);
void ED2_PrintEdict_f (void);
void ED_Count (void);
void VM_VmInfo_f( void );

void PR2_Init(void)
{
	int p;
	int usedll;
	Cvar_Register(&sv_progtype);
	Cvar_Register(&sv_progsname);
	Cvar_Register(&sv_pr2references);
	Cvar_Register(&vm_rtChecks);
#ifdef WITH_NQPROGS
	Cvar_Register(&sv_forcenqprogs);
#endif

	p = SV_CommandLineProgTypeArgument();

	if (p && p < COM_Argc())
	{
		usedll = Q_atoi(COM_Argv(p + 1));

		if (usedll > VMI_COMPILED || usedll < VMI_NONE)
			usedll = VMI_NONE;
		Cvar_SetValue(&sv_progtype,usedll);
	}

	Cmd_AddCommand ("edict", ED2_PrintEdict_f);
	Cmd_AddCommand ("edicts", ED2_PrintEdicts);
	Cmd_AddCommand ("edictcount", ED_Count);
	Cmd_AddCommand ("profile", PR2_Profile_f);
	Cmd_AddCommand ("mod", PR2_GameConsoleCommand);

	Cmd_AddCommand ("vminfo", VM_VmInfo_f);
	memset(pr_newstrtbl, 0, sizeof(pr_newstrtbl));
}

void PR2_Profile_f(void)
{
	if(!sv_vm)
	{
		PR_Profile_f();
		return;
	}
}

//===========================================================================
// PR2_GetString: only called to get direct addresses now
//===========================================================================
char *PR2_GetString(intptr_t num)
{
	if(!sv_vm)
		return PR1_GetString(num);

	switch (sv_vm->type)
	{
	case VMI_NONE:
		return PR1_GetString(num);

	case VMI_NATIVE:
		if (num) {
			return (char *)num;
		}
		else {
			return "";
		}

	case VMI_BYTECODE:
	case VMI_COMPILED:
		if (num <= 0)
			return "";
		return VM_ExplicitArgPtr(sv_vm, num);
	}

	return NULL;
}

intptr_t PR2_EntityStringLocation(string_t offset, int max_size)
{
	if (offset > 0 && offset < pr_edict_size * sv.max_edicts - max_size) {
		return ((intptr_t)sv.game_edicts + offset);
	}

	return 0;
}

intptr_t PR2_GlobalStringLocation(string_t offset)
{
	// FIXME: the mod has allocated this memory, don't have max size
	if (offset > 0) {
		return ((intptr_t)pr_global_struct + offset);
	}

	return 0;
}

char *PR2_GetEntityString(string_t num)
{

	if(!sv_vm)
		return PR1_GetString(num);

	switch (sv_vm->type)
	{
	case VMI_NONE:
		return PR1_GetString(num);

	case VMI_NATIVE:
		if (num) {
			if (sv_vm->pr2_references) {
				char** location = (char**)PR2_EntityStringLocation(num, sizeof(char*));
				if (location && *location) {
					return *location;
				}
			}
#ifndef idx64
			else {
				return (char *) (num);
			}
#endif
		}
		return "";

	case VMI_BYTECODE:
	case VMI_COMPILED:
		if (num <= 0)
			return "";
		if (sv_vm->pr2_references) {
			num = *(string_t*)PR2_EntityStringLocation(num, sizeof(string_t));
		}
		return VM_ExplicitArgPtr(sv_vm, num);
	}

	return NULL;
}

//===========================================================================
// PR2_SetString
// !!!!IMPOTANT!!!!
// Server change string pointers in mod memory only in trapcall(strings passed from mod, and placed in mod memory).
// Never pass pointers outside of the mod memory to mod, this does not work in QVM in 64 bit server.
//===========================================================================
void PR2_SetEntityString(edict_t* ed, string_t* target, char* s)
{
	if (!sv_vm) {
		PR1_SetString(target, s);
		return;
	}
}
void PR2_SetGlobalString(string_t* target, char* s)
{
	if (!sv_vm) {
		PR1_SetString(target, s);
		return;
	}
}

/*
=================
PR2_LoadEnts
=================
*/
extern const char *pr2_ent_data_ptr;

void PR2_LoadEnts(char *data)
{
	if (sv_vm)
	{
		pr2_ent_data_ptr = data;

		//Init parse
		VM_Call(sv_vm, 0, GAME_LOADENTS, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	}
	else
	{
		PR1_LoadEnts(data);
	}
}

//===========================================================================
// GameStartFrame
//===========================================================================
void PR2_GameStartFrame(qbool isBotFrame)
{
	if (isBotFrame && (!sv_vm || sv_vm->type == VMI_NONE || gamedata.APIversion < 15)) {
		return;
	}

	if (sv_vm)
		VM_Call(sv_vm, 2, GAME_START_FRAME, (int) (sv.time * 1000), (int)isBotFrame, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_GameStartFrame();
}

//===========================================================================
// GameClientConnect
//===========================================================================
void PR2_GameClientConnect(int spec)
{
	if (sv_vm)
		VM_Call(sv_vm, 1, GAME_CLIENT_CONNECT, spec, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_GameClientConnect(spec);
}

//===========================================================================
// GamePutClientInServer
//===========================================================================
void PR2_GamePutClientInServer(int spec)
{
	if (sv_vm)
		VM_Call(sv_vm, 1, GAME_PUT_CLIENT_IN_SERVER, spec, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_GamePutClientInServer(spec);
}

//===========================================================================
// GameClientDisconnect
//===========================================================================
void PR2_GameClientDisconnect(int spec)
{
	if (sv_vm)
		VM_Call(sv_vm, 1, GAME_CLIENT_DISCONNECT, spec, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_GameClientDisconnect(spec);
}

//===========================================================================
// GameClientPreThink
//===========================================================================
void PR2_GameClientPreThink(int spec)
{
	if (sv_vm)
		VM_Call(sv_vm, 1, GAME_CLIENT_PRETHINK, spec, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_GameClientPreThink(spec);
}

//===========================================================================
// GameClientPostThink
//===========================================================================
void PR2_GameClientPostThink(int spec)
{
	if (sv_vm)
		VM_Call(sv_vm, 1, GAME_CLIENT_POSTTHINK, spec, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_GameClientPostThink(spec);
}

//===========================================================================
// ClientCmd return false on unknown command
//===========================================================================
qbool PR2_ClientCmd(void)
{
	if (sv_vm)
		return VM_Call(sv_vm, 0, GAME_CLIENT_COMMAND, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		return PR1_ClientCmd();
}

//===========================================================================
// ClientKill
//===========================================================================
void PR2_ClientKill(void)
{
	if (sv_vm)
		PR2_ClientCmd(); // PR2 have some universal way for command execution unlike QC based mods.
	else
		PR1_ClientKill();
}

//===========================================================================
// ClientSay return false if say unhandled by mod
//===========================================================================
qbool PR2_ClientSay(int isTeamSay, char *message)
{
	//
	// message - used for QC based mods only.
	// PR2 mods get it from Cmd_Args() and such.
	//

	if (sv_vm)
		return VM_Call(sv_vm, 1, GAME_CLIENT_SAY, isTeamSay, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		return PR1_ClientSay(isTeamSay, message);
}

//===========================================================================
// GameSetNewParms
//===========================================================================
void PR2_GameSetNewParms(void)
{
	if (sv_vm)
		VM_Call(sv_vm, 0, GAME_SETNEWPARMS, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_GameSetNewParms();
}

//===========================================================================
// GameSetNewParms
//===========================================================================
void PR2_GameSetChangeParms(void)
{
	if (sv_vm)
		VM_Call(sv_vm, 0, GAME_SETCHANGEPARMS, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
	{
		PR1_GameSetChangeParms();
	}
}

//===========================================================================
// EdictTouch
//===========================================================================
void PR2_EdictTouch(func_t f)
{
	if (sv_vm)
		VM_Call(sv_vm, 0, GAME_EDICT_TOUCH, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_EdictTouch(f);
}

//===========================================================================
// EdictThink
//===========================================================================
void PR2_EdictThink(func_t f)
{
	if (sv_vm)
		VM_Call(sv_vm, 0, GAME_EDICT_THINK, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_EdictThink(f);
}

//===========================================================================
// EdictBlocked
//===========================================================================
void PR2_EdictBlocked(func_t f)
{
	if (sv_vm)
		VM_Call(sv_vm, 0, GAME_EDICT_BLOCKED, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_EdictBlocked(f);
}

//===========================================================================
// UserInfoChanged
//===========================================================================
qbool PR2_UserInfoChanged(int after)
{
	if (sv_vm)
		return VM_Call(sv_vm, 1, GAME_CLIENT_USERINFO_CHANGED, after, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		return PR1_UserInfoChanged(after);
}

//===========================================================================
// GameShutDown
//===========================================================================
void PR2_GameShutDown(void)
{
	if (sv_vm)
		VM_Call(sv_vm, 0, GAME_SHUTDOWN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_GameShutDown();
}

//===========================================================================
// UnLoadProgs
//===========================================================================
void PR2_UnLoadProgs(void)
{
	if (sv_vm)
	{
		VM_Free( sv_vm );
		sv_vm = NULL;
	}
	else
	{
		PR1_UnLoadProgs();
	}
}

//===========================================================================
// LoadProgs
//===========================================================================
void PR2_LoadProgs(void)
{
	sv_vm = VM_Create(VM_GAME, sv_progsname.string, PR2_GameSystemCalls, sv_progtype.value );

	if ( sv_vm )
	{
		; // nothing.
	}
	else
	{
		PR1_LoadProgs ();
	}
}

//===========================================================================
// GameConsoleCommand
//===========================================================================
void PR2_GameConsoleCommand(void)
{
	int     old_other, old_self;
	client_t	*cl;
	int			i;

	if( sv_vm )
	{
		old_self = pr_global_struct->self;
		old_other = pr_global_struct->other;
		pr_global_struct->other = 0; //sv_cmd = SV_CMD_CONSOLE;
		pr_global_struct->self = 0;

		for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
		{
			if (!cl->state)
				continue;
			if ( cl->isBot )
				continue;

			if (NET_CompareAdr(cl->netchan.remote_address, net_from))
			{
				pr_global_struct->self = EDICT_TO_PROG(cl->edict);
				break;
			}
		}
		VM_Call(sv_vm, 0, GAME_CONSOLE_COMMAND, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
		pr_global_struct->self = old_self;
		pr_global_struct->other = old_other;
	}
}

//===========================================================================
// PausedTic
//===========================================================================
void PR2_PausedTic(float duration)
{
	if (sv_vm)
		VM_Call(sv_vm, 1, GAME_PAUSED_TIC, (int)(duration*1000), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	else
		PR1_PausedTic(duration);
}

void PR2_ClearEdict(edict_t* e)
{
	if (sv_vm && sv_vm->pr2_references && (sv_vm->type == VMI_NATIVE || sv_vm->type == VMI_BYTECODE || sv_vm->type == VMI_COMPILED)) {
		int old_self = pr_global_struct->self;
		pr_global_struct->self = EDICT_TO_PROG(e);
		VM_Call(sv_vm, 0, GAME_CLEAR_EDICT, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
		pr_global_struct->self = old_self;
	}
}

//===========================================================================
// InitProgs
//===========================================================================

#define GAME_API_VERSION_MIN 16

void LoadGameData(intptr_t gamedata_ptr)
{
#ifdef idx64
	gameData_vm_t* gamedata_vm;

	if (sv_vm->type == VMI_BYTECODE || sv_vm->type == VMI_COMPILED)
	{
		gamedata_vm = (gameData_vm_t *)PR2_GetString(gamedata_ptr);
		gamedata.ents = (intptr_t)gamedata_vm->ents_p;
		gamedata.global = (intptr_t)gamedata_vm->global_p;
		gamedata.fields = (intptr_t)gamedata_vm->fields_p;
		gamedata.APIversion = gamedata_vm->APIversion;
		gamedata.sizeofent = gamedata_vm->sizeofent;
		gamedata.maxentities = gamedata_vm->maxentities;
		return;
	}
#endif
	gamedata = *(gameData_t *)PR2_GetString(gamedata_ptr);
}

void LoadFields(void)
{
#ifdef idx64
	if (sv_vm->type == VMI_BYTECODE || sv_vm->type == VMI_COMPILED)
	{
		field_vm_t *fieldvm_p;
		field_t	*f;
		int num = 0;
		fieldvm_p = (field_vm_t*)PR2_GetString((intptr_t)gamedata.fields);
		while (fieldvm_p[num].name) {
			num++;
		}
		f = fields = (field_t *)Hunk_AllocName(sizeof(field_t) * (num + 1), "edfields");
		while (fieldvm_p->name){
			f->name = (stringptr_t)fieldvm_p->name;
			f->ofs =  fieldvm_p->ofs;
			f->type = (fieldtype_t)fieldvm_p->type;
			f++;
			fieldvm_p++;
		}
		f->name = 0;
		return;
	}
#endif
	fields = (field_t*)PR2_GetString((intptr_t)gamedata.fields);
}

extern void PR2_FS_Restart(void);

void PR2_InitProg(void)
{
	extern cvar_t sv_pr2references;

	intptr_t gamedata_ptr;

	Cvar_SetValue(&sv_pr2references, 0.0f);

	if (!sv_vm) {
		PR1_InitProg();
		return;
	}

	PR2_FS_Restart();

	gamedata.APIversion = 0;
	gamedata_ptr = (intptr_t) VM_Call(sv_vm, 2, GAME_INIT, (int)(sv.time * 1000), (int)(Sys_DoubleTime() * 100000), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	if (!gamedata_ptr) {
		SV_Error("PR2_InitProg: gamedata == NULL");
	}

	LoadGameData(gamedata_ptr);
	if (gamedata.APIversion < GAME_API_VERSION_MIN || gamedata.APIversion > GAME_API_VERSION) {
		if (GAME_API_VERSION_MIN == GAME_API_VERSION) {
			SV_Error("PR2_InitProg: Incorrect API version (%i should be %i)", gamedata.APIversion, GAME_API_VERSION);
		}
		else {
			SV_Error("PR2_InitProg: Incorrect API version (%i should be between %i and %i)", gamedata.APIversion, GAME_API_VERSION_MIN, GAME_API_VERSION);
		}
	}

	sv_vm->pr2_references = gamedata.APIversion >= 15 && (int)sv_pr2references.value;
#ifdef idx64
	if (sv_vm->type == VMI_NATIVE && (!sv_vm->pr2_references || gamedata.APIversion < 15))
		SV_Error("PR2_InitProg: Native prog must support sv_pr2references for 64bit mode (mod API version (%i should be 15+))", gamedata.APIversion);
#endif
	pr_edict_size = gamedata.sizeofent;
	Con_DPrintf("edict size %d\n", pr_edict_size);
	sv.game_edicts = (entvars_t *)(PR2_GetString((intptr_t)gamedata.ents));
	pr_global_struct = (globalvars_t*)PR2_GetString((intptr_t)gamedata.global);
	pr_globals = (float *)pr_global_struct;
	LoadFields();

	sv.max_edicts = MAX_EDICTS;
	if (gamedata.APIversion >= 14) {
		sv.max_edicts = min(sv.max_edicts, gamedata.maxentities);
	}
	else {
		sv.max_edicts = min(sv.max_edicts, 512);
	}
}

#endif /* USE_PR2 */

#endif // !CLIENTONLY


================================================
FILE: src/pr_cmds.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

#ifndef CLIENTONLY
#include "qwsvdef.h"

static tokenizecontext_t pr1_tokencontext;

#define	RETURN_EDICT(e) (((int *)pr_globals)[OFS_RETURN] = EDICT_TO_PROG(e))
#define	RETURN_STRING(s) (PR1_SetString(&((int *)pr_globals)[OFS_RETURN], s))

/*
===============================================================================
 
						BUILT-IN FUNCTIONS
 
===============================================================================
*/

char *PF_VarString (int	first)
{
	int		i;
	static char out[2048];

	out[0] = 0;
	for (i=first ; i<pr_argc ; i++)
	{
		strlcat (out, G_STRING((OFS_PARM0+i*3)), sizeof(out));
	}
	return out;
}


/*
=================
PF_errror
 
This is a TERMINAL error, which will kill off the entire server.
Dumps self.
 
error(value)
=================
*/
void PF_error (void)
{
	char	*s;
	edict_t	*ed;

	s = PF_VarString(0);
	Con_Printf ("======SERVER ERROR in %s:\n%s\n", PR1_GetString(pr_xfunction->s_name) ,s);
	ed = PROG_TO_EDICT(pr_global_struct->self);
	ED_Print (ed);

	SV_Error ("Program error (PF_error)");
}

/*
=================
PF_objerror
 
Dumps out self, then an error message.  The program is aborted and self is
removed, but the level can continue.
 
objerror(value)
=================
*/
void PF_objerror (void)
{
	char	*s;
	edict_t	*ed;

	s = PF_VarString(0);
	Con_Printf ("======OBJECT ERROR in %s:\n%s\n", PR1_GetString(pr_xfunction->s_name),s);
	ed = PROG_TO_EDICT(pr_global_struct->self);
	ED_Print (ed);
	ED_Free (ed);

	SV_Error ("Program error (PF_objerror)");
}



/*
==============
PF_makevectors
 
Writes new values for v_forward, v_up, and v_right based on angles
makevectors(vector)
==============
*/
void PF_makevectors (void)
{
	AngleVectors (G_VECTOR(OFS_PARM0), PR_GLOBAL(v_forward), PR_GLOBAL(v_right), PR_GLOBAL(v_up));
}

/*
=================
PF_setorigin
 
This is the only valid way to move an object without using the physics of the world (setting velocity and waiting).  Directly changing origin will not set internal links correctly, so clipping would be messed up.  This should be called when an object is spawned, and then only if it is teleported.
 
setorigin (entity, origin)
=================
*/
void PF_setorigin (void)
{
	edict_t	*e;
	float	*org;

	e = G_EDICT(OFS_PARM0);
	org = G_VECTOR(OFS_PARM1);
	VectorCopy (org, e->v->origin);
	SV_AntilagReset (e);
	SV_LinkEdict (e, false);
}


/*
=================
PF_setsize
 
the size box is rotated by the current angle
 
setsize (entity, minvector, maxvector)
=================
*/
void PF_setsize (void)
{
	edict_t	*e;
	float	*min, *max;

	e = G_EDICT(OFS_PARM0);
	min = G_VECTOR(OFS_PARM1);
	max = G_VECTOR(OFS_PARM2);
	VectorCopy (min, e->v->mins);
	VectorCopy (max, e->v->maxs);
	VectorSubtract (max, min, e->v->size);
	SV_LinkEdict (e, false);
}


/*
=================
PF_setmodel
 
setmodel(entity, model)
Also sets size, mins, and maxs for inline bmodels
=================
*/
static void PF_setmodel (void)
{
	int			i;
	edict_t		*e;
	char		*m, **check;
	cmodel_t	*mod;

	e = G_EDICT(OFS_PARM0);
	m = G_STRING(OFS_PARM1);

// check to see if model was properly precached
	for (i = 0, check = sv.model_precache; i < MAX_MODELS && *check ; i++, check++)
		if (!strcmp(*check, m))
			goto ok;
	PR_RunError ("PF_setmodel: no precache: %s\n", m);
ok:

	e->v->model = G_INT(OFS_PARM1);
	e->v->modelindex = i;

// if it is an inline model, get the size information for it
	if (m[0] == '*')
	{
		mod = CM_InlineModel (m);
		VectorCopy (mod->mins, e->v->mins);
		VectorCopy (mod->maxs, e->v->maxs);
		VectorSubtract (mod->maxs, mod->mins, e->v->size);
		SV_LinkEdict (e, false);
	}
	else if (pr_nqprogs)
	{
		// hacks to make NQ progs happy
		if (!strcmp(PR1_GetString(e->v->model), "maps/b_explob.bsp"))
		{
			VectorClear (e->v->mins);
			VectorSet (e->v->maxs, 32, 32, 64);
		}
		else
		{
			// FTE does this, so we do, too; I'm not sure if it makes a difference
			VectorSet (e->v->mins, -16, -16, -16);
			VectorSet (e->v->maxs, 16, 16, 16);
		}
		VectorSubtract (e->v->maxs, e->v->mins, e->v->size);
		SV_LinkEdict (e, false);
	}
}

/*
=================
PF_bprint
 
broadcast print to everyone on server
 
bprint(value)
=================
*/
void PF_bprint (void)
{
	char		*s;
	int			level;

	if (pr_nqprogs)
	{
		level = PRINT_HIGH;
		s = PF_VarString(0);
	}
	else
	{
		level = G_FLOAT(OFS_PARM0);
		s = PF_VarString(1);
	}

	SV_BroadcastPrintf (level, "%s", s);
}

#define SPECPRINT_CENTERPRINT	0x1
#define SPECPRINT_SPRINT	0x2
#define SPECPRINT_STUFFCMD	0x4
/*
=================
PF_sprint
 
single print to a specific client
 
sprint(clientent, value)
=================
*/
void PF_sprint (void)
{
	char		*s;
	client_t	*client, *cl;
	int			entnum;
	int			level;
	int			i;

	entnum = G_EDICTNUM(OFS_PARM0);
	if (pr_nqprogs)
	{
		level = PRINT_HIGH;
		s = PF_VarString(1);
	}
	else
	{
		level = G_FLOAT(OFS_PARM1);
		s = PF_VarString(2);
	}

	if (entnum < 1 || entnum > MAX_CLIENTS)
	{
		Con_Printf ("tried to sprint to a non-client\n");
		return;
	}

	client = &svs.clients[entnum-1];

	SV_ClientPrintf (client, level, "%s", s);

	//bliP: spectator print ->
	if ((int)sv_specprint.value & SPECPRINT_SPRINT)
	{
		for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
		{
			if (!cl->state || !cl->spectator)
				continue;

			if ((cl->spec_track == entnum) && (cl->spec_print & SPECPRINT_SPRINT))
				SV_ClientPrintf (cl, level, "%s", s);
		}
	}
	//<-
}



/*
=================
PF_centerprint
 
single print to a specific client
 
centerprint(clientent, value)
=================
*/
void PF_centerprint (void)
{
	char		*s;
	int			entnum;
	client_t	*cl, *spec;
	int			i;

	entnum = G_EDICTNUM(OFS_PARM0);
	s = PF_VarString(1);

	if (entnum < 1 || entnum > MAX_CLIENTS)
	{
		Con_Printf ("tried to sprint to a non-client\n");
		return;
	}

	cl = &svs.clients[entnum-1];

	ClientReliableWrite_Begin (cl, svc_centerprint, 2 + strlen(s));
	ClientReliableWrite_String (cl, s);

	if (sv.mvdrecording)
	{
		if (MVDWrite_Begin (dem_single, entnum - 1, 2 + strlen(s)))
		{
			MVD_MSG_WriteByte (svc_centerprint);
			MVD_MSG_WriteString (s);
		}
	}

	//bliP: spectator print ->
	if ((int)sv_specprint.value & SPECPRINT_CENTERPRINT)
	{
		for (i = 0, spec = svs.clients; i < MAX_CLIENTS; i++, spec++)
		{
			if (!cl->state || !spec->spectator)
				continue;

			if ((spec->spec_track == entnum) && (cl->spec_print & SPECPRINT_CENTERPRINT))
			{
				ClientReliableWrite_Begin (spec, svc_centerprint, 2 + strlen(s));
				ClientReliableWrite_String (spec, s);
			}
		}
	}
	//<-
}


/*
=================
PF_normalize
 
vector normalize(vector)
=================
*/
void PF_normalize (void)
{
	float	*value1;
	vec3_t	newvalue;
	float	nuw;

	value1 = G_VECTOR(OFS_PARM0);

	nuw = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
	nuw = sqrt(nuw);

	if (nuw == 0)
		newvalue[0] = newvalue[1] = newvalue[2] = 0;
	else
	{
		nuw = 1/nuw;
		newvalue[0] = value1[0] * nuw;
		newvalue[1] = value1[1] * nuw;
		newvalue[2] = value1[2] * nuw;
	}

	VectorCopy (newvalue, G_VECTOR(OFS_RETURN));
}

/*
=================
PF_vlen
 
scalar vlen(vector)
=================
*/
void PF_vlen (void)
{
	float	*value1;
	float	nuw;

	value1 = G_VECTOR(OFS_PARM0);

	nuw = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
	nuw = sqrt(nuw);

	G_FLOAT(OFS_RETURN) = nuw;
}

/*
=================
PF_vectoyaw
 
float vectoyaw(vector)
=================
*/
void PF_vectoyaw (void)
{
	float	*value1;
	float	yaw;

	value1 = G_VECTOR(OFS_PARM0);

	if (value1[1] == 0 && value1[0] == 0)
		yaw = 0;
	else
	{
		yaw = /*(int)*/ (atan2(value1[1], value1[0]) * 180 / M_PI);
		if (yaw < 0)
			yaw += 360;
	}

	G_FLOAT(OFS_RETURN) = yaw;
}


/*
=================
PF_vectoangles
 
vector vectoangles(vector)
=================
*/
void PF_vectoangles (void)
{
	float	*value1;
	float	forward;
	float	yaw, pitch;

	value1 = G_VECTOR(OFS_PARM0);

	if (value1[1] == 0 && value1[0] == 0)
	{
		yaw = 0;
		if (value1[2] > 0)
			pitch = 90;
		else
			pitch = 270;
	}
	else
	{
		yaw = /*(int)*/ (atan2(value1[1], value1[0]) * 180 / M_PI);
		if (yaw < 0)
			yaw += 360;

		forward = sqrt (value1[0]*value1[0] + value1[1]*value1[1]);
		pitch = /*(int)*/ (atan2(value1[2], forward) * 180 / M_PI);
		if (pitch < 0)
			pitch += 360;
	}

	G_FLOAT(OFS_RETURN+0) = pitch;
	G_FLOAT(OFS_RETURN+1) = yaw;
	G_FLOAT(OFS_RETURN+2) = 0;
}

/*
=================
PF_Random
 
Returns a number from 0<= num < 1
 
random()
=================
*/
void PF_random (void)
{
	float		num;

	num = (rand ()&0x7fff) / ((float)0x7fff);

	G_FLOAT(OFS_RETURN) = num;
}


/*
=================
PF_particle

particle(origin, dir, color, count [,replacement_te [,replacement_count]]) = #48
For NQ progs (or as a QW extension)
=================
*/
static void PF_particle (void)
{
	float	*org, *dir;
	float	color, count;
	int		replacement_te;
	int		replacement_count = 0 /* suppress compiler warning */;
			
	org = G_VECTOR(OFS_PARM0);
	dir = G_VECTOR(OFS_PARM1);
	color = G_FLOAT(OFS_PARM2);
	count = G_FLOAT(OFS_PARM3);

	// Progs should provide a tempentity code and particle count for the case
	// when a client doesn't support svc_particle
	if (pr_argc >= 5)
	{
		replacement_te = G_FLOAT(OFS_PARM4);
		replacement_count = (pr_argc >= 6) ? G_FLOAT(OFS_PARM5) : 1;
	}
	else
	{
		// To aid porting of NQ mods, if the extra arguments are not provided, try
		// to figure out what progs want by inspecting color and count
		if (count == 255)
		{
			replacement_te = TE_EXPLOSION;		// count is not used
		}
		else if (color == 73)
		{
			replacement_te = TE_BLOOD;
			replacement_count = 1;	// FIXME: use count / <some value>?
		}
		else if (color == 225)
		{
			replacement_te = TE_LIGHTNINGBLOOD;	// count is not used
		}
		else
		{
			replacement_te = 0;		// don't send anything
		}
	}

	SV_StartParticle (org, dir, color, count, replacement_te, replacement_count);
}

/*
=================
PF_ambientsound
 
=================
*/
void PF_ambientsound (void)
{
	char		**check;
	char		*samp;
	float		*pos;
	float 		vol, attenuation;
	int			i, soundnum;

	pos = G_VECTOR (OFS_PARM0);
	samp = G_STRING(OFS_PARM1);
	vol = G_FLOAT(OFS_PARM2);
	attenuation = G_FLOAT(OFS_PARM3);

	// check to see if samp was properly precached
	for (soundnum=0, check = sv.sound_precache ; *check ; check++, soundnum++)
		if (!strcmp(*check,samp))
			break;

	if (!*check)
	{
		Con_Printf ("no precache: %s\n", samp);
		return;
	}

	// add an svc_spawnambient command to the level signon packet

	MSG_WriteByte (&sv.signon,svc_spawnstaticsound);
	for (i=0 ; i<3 ; i++)
		MSG_WriteCoord(&sv.signon, pos[i]);

	MSG_WriteByte (&sv.signon, soundnum);

	MSG_WriteByte (&sv.signon, vol*255);
	MSG_WriteByte (&sv.signon, attenuation*64);

}

/*
=================
PF_sound
 
Each entity can have eight independant sound sources, like voice,
weapon, feet, etc.
 
Channel 0 is an auto-allocate channel, the others override anything
already running on that entity/channel pair.
 
An attenuation of 0 will play full volume everywhere in the level.
Larger attenuations will drop off.
 
=================
*/
void PF_sound (void)
{
	char		*sample;
	int			channel;
	edict_t		*entity;
	int 		volume;
	float attenuation;

	entity = G_EDICT(OFS_PARM0);
	channel = G_FLOAT(OFS_PARM1);
	sample = G_STRING(OFS_PARM2);
	volume = G_FLOAT(OFS_PARM3) * 255;
	attenuation = G_FLOAT(OFS_PARM4);

	SV_StartSound (entity, channel, sample, volume, attenuation);
}

/*
=================
PF_break
 
break()
=================
*/
void PF_break (void)
{
	Con_Printf ("break statement\n");
	*(int *)-4 = 0;	// dump to debugger
	//	PR_RunError ("break statement");
}

/*
=================
PF_traceline
 
Used for use tracing and shot targeting
Traces are blocked by bbox and exact bsp entityes, and also slide box entities
if the tryents flag is set.
 
traceline (vector1, vector2, tryents)
=================
*/
void PF_traceline (void)
{
	float	*v1, *v2;
	trace_t	trace;
	int		nomonsters;
	edict_t	*ent;

	v1 = G_VECTOR(OFS_PARM0);
	v2 = G_VECTOR(OFS_PARM1);
	nomonsters = G_FLOAT(OFS_PARM2);
	ent = G_EDICT(OFS_PARM3);

	if (sv_antilag.value == 2)
		nomonsters |= MOVE_LAGGED;

	trace = SV_Trace (v1, vec3_origin, vec3_origin, v2, nomonsters, ent);

	PR_GLOBAL(trace_allsolid) = trace.allsolid;
	PR_GLOBAL(trace_startsolid) = trace.startsolid;
	PR_GLOBAL(trace_fraction) = trace.fraction;
	PR_GLOBAL(trace_inwater) = trace.inwater;
	PR_GLOBAL(trace_inopen) = trace.inopen;
	VectorCopy (trace.endpos, PR_GLOBAL(trace_endpos));
	VectorCopy (trace.plane.normal, PR_GLOBAL(trace_plane_normal));
	PR_GLOBAL(trace_plane_dist) =  trace.plane.dist;	
	if (trace.e.ent)
		PR_GLOBAL(trace_ent) = EDICT_TO_PROG(trace.e.ent);
	else
		PR_GLOBAL(trace_ent) = EDICT_TO_PROG(sv.edicts);
}

/*
=================
PF_checkpos
 
Returns true if the given entity can move to the given position from it's
current position by walking or rolling.
FIXME: make work...
scalar checkpos (entity, vector)
=================
*/
void PF_checkpos (void)
{}

//============================================================================

// Unlike Quake's Mod_LeafPVS, CM_LeafPVS returns a pointer to static data
// uncompressed at load time, so it's safe to store for future use
static byte	*checkpvs;

int PF_newcheckclient (int check)
{
	int		i;
	edict_t	*ent;
	vec3_t	org;

// cycle to the next one

	if (check < 1)
		check = 1;
	if (check > MAX_CLIENTS)
		check = MAX_CLIENTS;

	if (check == MAX_CLIENTS)
		i = 1;
	else
		i = check + 1;

	for ( ;  ; i++)
	{
		if (i == MAX_CLIENTS+1)
			i = 1;

		ent = EDICT_NUM(i);

		if (i == check)
			break;	// didn't find anything else

		if (ent->e.free)
			continue;
		if (ent->v->health <= 0)
			continue;
		if ((int)ent->v->flags & FL_NOTARGET)
			continue;

	// anything that is a client, or has a client as an enemy
		break;
	}

// get the PVS for the entity
	VectorAdd (ent->v->origin, ent->v->view_ofs, org);
	checkpvs = CM_LeafPVS (CM_PointInLeaf(org));

	return i;
}


/*
=================
PF_checkclient

Returns a client (or object that has a client enemy) that would be a
valid target.

If there are more than one valid options, they are cycled each frame

If (self.origin + self.viewofs) is not in the PVS of the current target,
it is not returned at all.

entity checkclient() = #17
=================
*/
#define	MAX_CHECK	16
static void PF_checkclient (void)
{
	edict_t	*ent, *self;
	int		l;
	vec3_t	vieworg;
	
// find a new check if on a new frame
	if (sv.time - sv.lastchecktime >= 0.1)
	{
		sv.lastcheck = PF_newcheckclient (sv.lastcheck);
		sv.lastchecktime = sv.time;
	}

// return check if it might be visible	
	ent = EDICT_NUM(sv.lastcheck);
	if (ent->e.free || ent->v->health <= 0)
	{
		RETURN_EDICT(sv.edicts);
		return;
	}

// if current entity can't possibly see the check entity, return 0
	self = PROG_TO_EDICT(pr_global_struct->self);
	VectorAdd (self->v->origin, self->v->view_ofs, vieworg);
	l = CM_Leafnum(CM_PointInLeaf(vieworg)) - 1;
	if ( (l<0) || !(checkpvs[l>>3] & (1<<(l&7)) ) )
	{
		RETURN_EDICT(sv.edicts);
		return;
	}

// might be able to see it
	RETURN_EDICT(ent);
}

//============================================================================


/*
=================
PF_stuffcmd
 
Sends text over to the client's execution buffer
 
stuffcmd (clientent, value)
=================
*/
void PF_stuffcmd (void)
{
	int		entnum;
	char	*str;
	client_t	*cl, *spec;
	char	*buf;
	int j;

	entnum = G_EDICTNUM(OFS_PARM0);
	if (entnum < 1 || entnum > MAX_CLIENTS)
		PR_RunError ("Parm 0 not a client");
	str = G_STRING(OFS_PARM1);

	cl = &svs.clients[entnum-1];

	if (!strncmp(str, "disconnect\n", MAX_STUFFTEXT))
	{
		// so long and thanks for all the fish
		cl->drop = true;
		return;
	}

	buf = cl->stufftext_buf;
	if (strlen(buf) + strlen(str) >= MAX_STUFFTEXT)
		PR_RunError ("stufftext buffer overflow");
	strlcat (buf, str, MAX_STUFFTEXT);

	if( strchr( buf, '\n' ) )
	{
		ClientReliableWrite_Begin (cl, svc_stufftext, 2+strlen(buf));
		ClientReliableWrite_String (cl, buf);
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin ( dem_single, cl - svs.clients, 2+strlen(buf)))
			{
				MVD_MSG_WriteByte (svc_stufftext);
				MVD_MSG_WriteString (buf);
			}
		}

		//bliP: spectator print ->
		if ((int)sv_specprint.value & SPECPRINT_STUFFCMD)
		{
			for (j = 0, spec = svs.clients; j < MAX_CLIENTS; j++, spec++)
			{
				if (!cl->state || !spec->spectator)
					continue;

				if ((spec->spec_track == entnum) && (cl->spec_print & SPECPRINT_STUFFCMD))
				{
					ClientReliableWrite_Begin (spec, svc_stufftext, 2+strlen(buf));
					ClientReliableWrite_String (spec, buf);
				}
			}
		}
		//<-
	
		buf[0] = 0;
	}
}

/*
=================
PF_localcmd
 
Sends text over to the client's execution buffer
 
localcmd (string)
=================
*/
void PF_localcmd (void)
{
	char	*str;

	str = G_STRING(OFS_PARM0);

	if (pr_nqprogs && !strcmp(str, "restart\n"))
	{
		Cbuf_AddText (va("map %s\n", sv.mapname));
		return;
	}

	Cbuf_AddText (str);
}

#define MAX_PR_STRING_SIZE	2048
#define MAX_PR_STRINGS		64

int		pr_string_index = 0;
char	pr_string_buf[MAX_PR_STRINGS][MAX_PR_STRING_SIZE];
char	*pr_string_temp = pr_string_buf[0];

void PF_SetTempString(void)
{
	pr_string_temp = pr_string_buf[(++pr_string_index) & (MAX_PR_STRINGS - 1)];
}


/*
=================
PF_tokenize
 
float tokenize(string)
=================
*/

void PF_tokenize (void)
{
	const char *str;

	str = G_STRING(OFS_PARM0);
	Cmd_TokenizeStringEx(&pr1_tokencontext, str);
	G_FLOAT(OFS_RETURN) = Cmd_ArgcEx(&pr1_tokencontext);
}

/*
=================
PF_argc
 
returns number of tokens (must be executed after PF_Tokanize!)
 
float argc(void)
=================
*/

void PF_argc (void)
{
	G_FLOAT(OFS_RETURN) = (float) Cmd_ArgcEx(&pr1_tokencontext);
}

/*
=================
PF_argv
 
returns token requested by user (must be executed after PF_Tokanize!)
 
string argc(float)
=================
*/

void PF_argv (void)
{
	int num;

	num = (int) G_FLOAT(OFS_PARM0);

//	if (num < 0 ) num = 0;
//	if (num > Cmd_Argc()-1) num = Cmd_Argc()-1;

	if (num < 0 || num >= Cmd_ArgcEx(&pr1_tokencontext)) {
		RETURN_STRING("");
	}
	else {
		snprintf(pr_string_temp, MAX_PR_STRING_SIZE, "%s", Cmd_ArgvEx(&pr1_tokencontext, num));
		RETURN_STRING(pr_string_temp);
		PF_SetTempString();
	}
}

/*
=================
PF_substr
 
string substr(string str, float start, float len)
=================
*/

void PF_substr (void)
{
	char *s;
	int start, len, l;

	s = G_STRING(OFS_PARM0);
	start = (int) G_FLOAT(OFS_PARM1);
	len = (int) G_FLOAT(OFS_PARM2);
	l = strlen(s);

	if (start >= l || !len || !*s)
	{
		PR_SetTmpString(&G_INT(OFS_RETURN), "");
		return;
	}

	s += start;
	l -= start;

	if (len > l + 1)
		len = l + 1;

	strlcpy(pr_string_temp, s, len + 1);

	PR1_SetString(&G_INT(OFS_RETURN), pr_string_temp);

	PF_SetTempString();
}

/*
=================
PF_strcat
 
string strcat(string str1, string str2)
=================
*/

void PF_strcat (void)
{
	strlcpy(pr_string_temp, PF_VarString(0), MAX_PR_STRING_SIZE);
	PR1_SetString(&G_INT(OFS_RETURN), pr_string_temp);

	PF_SetTempString();
}

/*
=================
PF_strlen
 
float strlen(string str)
=================
*/

void PF_strlen (void)
{
	G_FLOAT(OFS_RETURN) = (float) strlen(G_STRING(OFS_PARM0));
}

/*
=================
PF_strzone

ZQ_QC_STRINGS
string newstr (string str [, float size])

The 'size' parameter is not QSG but an MVDSV extension
=================
*/

void PF_strzone (void)
{
	char *s;
	int i, size;

	s = G_STRING(OFS_PARM0);

	for (i = 0; i < MAX_PRSTR; i++)
	{
		if (!pr_newstrtbl[i] || pr_newstrtbl[i] == pr_strings)
			break;
	}

	if (i == MAX_PRSTR)
		PR_RunError("strzone: out of string memory");

	size = strlen(s) + 1;
	if (pr_argc == 2 && (int) G_FLOAT(OFS_PARM1) > size)
		size = (int) G_FLOAT(OFS_PARM1);

	pr_newstrtbl[i] = (char *) Q_malloc(size);
	strlcpy(pr_newstrtbl[i], s, size);

	G_INT(OFS_RETURN) = -(i+MAX_PRSTR);
}

/*
=================
PF_strunzone

ZQ_QC_STRINGS
void strunzone (string str)
=================
*/

void PF_strunzone (void)
{
	int num;

	num = G_INT(OFS_PARM0);
	if (num > - MAX_PRSTR)
		PR_RunError("strunzone: not a dynamic string");

	if (num <= -(MAX_PRSTR * 2))
		PR_RunError ("strunzone: bad string");

	num = - (num + MAX_PRSTR);

	if (pr_newstrtbl[num] == pr_strings)
		return;	// allow multiple strunzone on the same string (like free in C)

	Q_free(pr_newstrtbl[num]);
	pr_newstrtbl[num] = pr_strings;
}

void PF_clear_strtbl(void)
{
	int i;

	for (i = 0; i < MAX_PRSTR; i++)
	{
		if (pr_newstrtbl[i] && pr_newstrtbl[i] != pr_strings)
		{
			Q_free(pr_newstrtbl[i]);
			pr_newstrtbl[i] = NULL;
		}
	}
}

//FTE_CALLTIMEOFDAY
void PF_calltimeofday (void)
{
	extern func_t ED_FindFunctionOffset (char *name);
	func_t f;

	if ((f = ED_FindFunctionOffset ("timeofday")))
	{
		date_t date;

		SV_TimeOfDay(&date, "%a %b %d, %H:%M:%S %Y");

		G_FLOAT(OFS_PARM0) = (float)date.sec;
		G_FLOAT(OFS_PARM1) = (float)date.min;
		G_FLOAT(OFS_PARM2) = (float)date.hour;
		G_FLOAT(OFS_PARM3) = (float)date.day;
		G_FLOAT(OFS_PARM4) = (float)date.mon;
		G_FLOAT(OFS_PARM5) = (float)date.year;
		PR_SetTmpString(&G_INT(OFS_PARM6), date.str);

		PR_ExecuteProgram(f);
	}
}

/*
=================
PF_cvar

float cvar (string)
=================
*/
void PF_cvar (void)
{
	char	*str;

	str = G_STRING(OFS_PARM0);

	if (!strcasecmp(str, "pr_checkextension")) {
		// we do support PF_checkextension
		G_FLOAT(OFS_RETURN) = 1.0;
		return;
	}

	if (pr_nqprogs && !pr_globals[35]/* deathmatch */
		&& (!strcmp(str, "timelimit") || !strcmp(str, "samelevel"))
	)
	{
		// workaround for NQ progs bug: timelimit and samelevel are checked in SP/coop
		G_FLOAT(OFS_RETURN) = 0.0;
		return;
	}

	G_FLOAT(OFS_RETURN) = Cvar_Value (str);
}

/*
=================
PF_cvar_set
 
float cvar (string)
=================
*/
void PF_cvar_set (void)
{
	char	*var_name, *val;
	cvar_t	*var;

	var_name = G_STRING(OFS_PARM0);
	val = G_STRING(OFS_PARM1);

	var = Cvar_Find(var_name);
	if (!var)
	{
		Con_Printf ("PF_cvar_set: variable %s not found\n", var_name);
		return;
	}

	Cvar_Set (var, val);
}

/*
=================
PF_findradius
 
Returns a chain of entities that have origins within a spherical area
 
findradius (origin, radius)
=================
*/
static void PF_findradius (void)
{
	int			i, j, numtouch;
	edict_t		*touchlist[MAX_EDICTS], *ent, *chain;
	float		rad, rad_2, *org;
	vec3_t		mins, maxs, eorg;

	org = G_VECTOR(OFS_PARM0);
	rad = G_FLOAT(OFS_PARM1);
	rad_2 = rad * rad;

	for (i = 0; i < 3; i++)
	{
		mins[i] = org[i] - rad - 1;		// enlarge the bbox a bit
		maxs[i] = org[i] + rad + 1;
	}

	numtouch = SV_AreaEdicts (mins, maxs, touchlist, sv.max_edicts, AREA_SOLID);
	numtouch += SV_AreaEdicts (mins, maxs, &touchlist[numtouch], sv.max_edicts - numtouch, AREA_TRIGGERS);

	chain = (edict_t *)sv.edicts;

// touch linked edicts
	for (i = 0; i < numtouch; i++)
	{
		ent = touchlist[i];
		if (ent->v->solid == SOLID_NOT)
			continue;	// FIXME?

		for (j = 0; j < 3; j++)
			eorg[j] = org[j] - (ent->v->origin[j] + (ent->v->mins[j] + ent->v->maxs[j]) * 0.5);
		if (DotProduct(eorg, eorg) > rad_2)
			continue;

		ent->v->chain = EDICT_TO_PROG(chain);
		chain = ent;
	}

	RETURN_EDICT(chain);
}


/*
=========
PF_dprint
=========
*/
void PF_dprint (void)
{
	Con_Printf ("%s",PF_VarString(0));
}

void PF_ftos (void)
{
	float	v;
	v = G_FLOAT(OFS_PARM0);

	if (v == (int)v)
		snprintf (pr_string_temp, MAX_PR_STRING_SIZE, "%d",(int)v);
	else
		snprintf (pr_string_temp, MAX_PR_STRING_SIZE, "%5.1f",v);
	PR1_SetString(&G_INT(OFS_RETURN), pr_string_temp);
	PF_SetTempString();
}

void PF_fabs (void)
{
	float	v;
	v = G_FLOAT(OFS_PARM0);
	G_FLOAT(OFS_RETURN) = fabs(v);
}

void PF_vtos (void)
{
	snprintf (pr_string_temp, MAX_PR_STRING_SIZE, "'%5.1f %5.1f %5.1f'", G_VECTOR(OFS_PARM0)[0], G_VECTOR(OFS_PARM0)[1], G_VECTOR(OFS_PARM0)[2]);
	PR1_SetString(&G_INT(OFS_RETURN), pr_string_temp);

	PF_SetTempString();
}

void PF_Spawn (void)
{
	edict_t	*ed;
	ed = ED_Alloc();
	RETURN_EDICT(ed);
}

void PF_Remove (void)
{
	edict_t	*ed;

	ed = G_EDICT(OFS_PARM0);
	ED_Free (ed);
}


// entity (entity start, .string field, string match) find = #5;
void PF_Find (void)
{
	int		e;
	int		f;
	char	*s, *t;
	edict_t	*ed;

	e = G_EDICTNUM(OFS_PARM0);
	f = G_INT(OFS_PARM1);
	s = G_STRING(OFS_PARM2);
	if (!s)
		PR_RunError ("PF_Find: bad search string");

	for (e++ ; e < sv.num_edicts ; e++)
	{
		ed = EDICT_NUM(e);
		if (ed->e.free)
			continue;
		t = E_STRING(ed,f);
		if (!t)
			continue;
		if (!strcmp(t,s))
		{
			RETURN_EDICT(ed);
			return;
		}
	}

	RETURN_EDICT(sv.edicts);
}

void PR_CheckEmptyString (char *s)
{
	if (s[0] <= ' ')
		PR_RunError ("Bad string");
}

void PF_precache_file (void)
{	// precache_file is only used to copy files with qcc, it does nothing
	G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
}

void PF_precache_sound (void)
{
	char	*s;
	int		i;

	if (sv.state != ss_loading)
		PR_RunError ("PF_Precache_*: Precache can only be done in spawn functions");

	s = G_STRING(OFS_PARM0);
	G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
	PR_CheckEmptyString (s);

	for (i=0 ; i<MAX_SOUNDS ; i++)
	{
		if (!sv.sound_precache[i])
		{
			sv.sound_precache[i] = s;
			return;
		}
		if (!strcmp(sv.sound_precache[i], s))
			return;
	}
	PR_RunError ("PF_precache_sound: overflow");
}

void PF_precache_model (void)
{
	char	*s;
	int		i;

	if (sv.state != ss_loading)
		PR_RunError ("PF_Precache_*: Precache can only be done in spawn functions");

	s = G_STRING(OFS_PARM0);
	G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
	PR_CheckEmptyString (s);

	for (i=0 ; i<MAX_MODELS ; i++)
	{
		if (!sv.model_precache[i])
		{
			sv.model_precache[i] = s;
			return;
		}
		if (!strcmp(sv.model_precache[i], s))
			return;
	}
	PR_RunError ("PF_precache_model: overflow");
}

static void PF_precache_vwep_model (void)
{
	char	*s;
	int		i;
	
	if (sv.state != ss_loading)
		PR_RunError ("PF_Precache_*: Precache can only be done in spawn functions");
		
	s = G_STRING(OFS_PARM0);
	PR_CheckEmptyString (s);

	// the strings are transferred via the stufftext mechanism, hence the stringency
	if (strchr(s, '"') || strchr(s, ';') || strchr(s, '\n'  ) || strchr(s, '\t') || strchr(s, ' '))
		PR_RunError ("Bad string\n");

	for (i = 0; i < MAX_VWEP_MODELS; i++)
	{
		if (!sv.vw_model_name[i]) {
			sv.vw_model_name[i] = s;
			G_INT(OFS_RETURN) = i;
			return;
		}
	}
	PR_RunError ("PF_precache_vwep_model: overflow");
}


void PF_coredump (void)
{
	ED_PrintEdicts ();
}

void PF_traceon (void)
{
	pr_trace = true;
}

void PF_traceoff (void)
{
	pr_trace = false;
}

void PF_eprint (void)
{
	ED_PrintNum (G_EDICTNUM(OFS_PARM0));
}

/*
===============
PF_walkmove
 
float(float yaw, float dist) walkmove
===============
*/
void PF_walkmove (void)
{
	edict_t	*ent;
	float	yaw, dist;
	vec3_t	move;
	dfunction_t	*oldf;
	int 	oldself;

	ent = PROG_TO_EDICT(pr_global_struct->self);
	yaw = G_FLOAT(OFS_PARM0);
	dist = G_FLOAT(OFS_PARM1);

	if ( !( (int)ent->v->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
	{
		G_FLOAT(OFS_RETURN) = 0;
		return;
	}

	yaw = yaw*M_PI*2 / 360;

	move[0] = cos(yaw)*dist;
	move[1] = sin(yaw)*dist;
	move[2] = 0;

	// save program state, because SV_movestep may call other progs
	oldf = pr_xfunction;
	oldself = pr_global_struct->self;

	G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true);


	// restore program state
	pr_xfunction = oldf;
	pr_global_struct->self = oldself;
}

/*
===============
PF_droptofloor
 
void() droptofloor
===============
*/
void PF_droptofloor (void)
{
	edict_t		*ent;
	vec3_t		end;
	trace_t		trace;

	ent = PROG_TO_EDICT(pr_global_struct->self);

	VectorCopy (ent->v->origin, end);
	end[2] -= 256;

	trace = SV_Trace (ent->v->origin, ent->v->mins, ent->v->maxs, end, false, ent);

	if (trace.fraction == 1 || trace.allsolid)
		G_FLOAT(OFS_RETURN) = 0;
	else
	{
		VectorCopy (trace.endpos, ent->v->origin);
		SV_LinkEdict (ent, false);
		ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
		ent->v->groundentity = EDICT_TO_PROG(trace.e.ent);
		G_FLOAT(OFS_RETURN) = 1;
	}
}

/*
===============
PF_lightstyle
 
void(float style, string value) lightstyle
===============
*/
void PF_lightstyle (void)
{
	int		style;
	char	*val;
	client_t	*client;
	int			j;

	style = G_FLOAT(OFS_PARM0);
	val = G_STRING(OFS_PARM1);

	// change the string in sv
	sv.lightstyles[style] = val;

	// send message to all clients on this server
	if (sv.state != ss_active)
		return;

	for (j=0, client = svs.clients ; j<MAX_CLIENTS ; j++, client++)
		if ( client->state == cs_spawned )
		{
			ClientReliableWrite_Begin (client, svc_lightstyle, strlen(val)+3);
			ClientReliableWrite_Char (client, style);
			ClientReliableWrite_String (client, val);
		}
	if (sv.mvdrecording)
	{
		if (MVDWrite_Begin( dem_all, 0, strlen(val)+3))
		{
			MVD_MSG_WriteByte(svc_lightstyle);
			MVD_MSG_WriteChar(style);
			MVD_MSG_WriteString(val);
		}
	}
}

void PF_rint (void)
{
	float	f;
	f = G_FLOAT(OFS_PARM0);
	if (f > 0)
		G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
	else
		G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
}
void PF_floor (void)
{
	G_FLOAT(OFS_RETURN) = floor(G_FLOAT(OFS_PARM0));
}
void PF_ceil (void)
{
	G_FLOAT(OFS_RETURN) = ceil(G_FLOAT(OFS_PARM0));
}


/*
=============
PF_checkbottom
=============
*/
void PF_checkbottom (void)
{
	edict_t	*ent;

	ent = G_EDICT(OFS_PARM0);

	G_FLOAT(OFS_RETURN) = SV_CheckBottom (ent);
}

/*
=============
PF_pointcontents
=============
*/
void PF_pointcontents (void)
{
	float	*v;

	v = G_VECTOR(OFS_PARM0);

	G_FLOAT(OFS_RETURN) = SV_PointContents (v);
}

/*
=============
PF_nextent
 
entity nextent(entity)
=============
*/
void PF_nextent (void)
{
	int		i;
	edict_t	*ent;

	i = G_EDICTNUM(OFS_PARM0);
	while (1)
	{
		i++;
		if (i == sv.num_edicts)
		{
			RETURN_EDICT(sv.edicts);
			return;
		}
		ent = EDICT_NUM(i);
		if (!ent->e.free)
		{
			RETURN_EDICT(ent);
			return;
		}
	}
}

/*
=============
PF_aim
 
Pick a vector for the player to shoot along
vector aim(entity, missilespeed)
=============
*/
void PF_aim (void)
{
	VectorCopy (PR_GLOBAL(v_forward), G_VECTOR(OFS_RETURN));
}

/*
==============
PF_changeyaw
 
This was a major timewaster in progs, so it was converted to C
==============
*/
void PF_changeyaw (void)
{
	edict_t		*ent;
	float		ideal, current, move, speed;

	ent = PROG_TO_EDICT(pr_global_struct->self);
	current = anglemod( ent->v->angles[1] );
	ideal = ent->v->ideal_yaw;
	speed = ent->v->yaw_speed;

	if (current == ideal)
		return;
	move = ideal - current;
	if (ideal > current)
	{
		if (move >= 180)
			move = move - 360;
	}
	else
	{
		if (move <= -180)
			move = move + 360;
	}
	if (move > 0)
	{
		if (move > speed)
			move = speed;
	}
	else
	{
		if (move < -speed)
			move = -speed;
	}

	ent->v->angles[1] = anglemod (current + move);
}

/*
===============================================================================
 
MESSAGE WRITING
 
===============================================================================
*/

#define	MSG_BROADCAST	0		// unreliable to all
#define	MSG_ONE			1		// reliable to one (msg_entity)
#define	MSG_ALL			2		// reliable to all
#define	MSG_INIT		3		// write to the init string
#define	MSG_MULTICAST	4		// for multicast()

sizebuf_t *WriteDest (void)
{
	int		dest;
	//	int		entnum;
	//	edict_t	*ent;

	dest = G_FLOAT(OFS_PARM0);
	switch (dest)
	{
	case MSG_BROADCAST:
		return &sv.datagram;

	case MSG_ONE:
		SV_Error("Shouldn't be at MSG_ONE");
#if 0
		ent = PROG_TO_EDICT(PR_GLOBAL(msg_entity));
		entnum = NUM_FOR_EDICT(ent);
		if (entnum < 1 || entnum > MAX_CLIENTS)
			PR_RunError ("WriteDest: not a client");
		return &svs.clients[entnum-1].netchan.message;
#endif

	case MSG_ALL:
		return &sv.reliable_datagram;

	case MSG_INIT:
		if (sv.state != ss_loading)
			PR_RunError ("PF_Write_*: MSG_INIT can only be written in spawn functions");
		return &sv.signon;

	case MSG_MULTICAST:
		return &sv.multicast;

	default:
		PR_RunError ("WriteDest: bad destination");
		break;
	}

	return NULL;
}

static client_t *Write_GetClient(void)
{
	int		entnum;
	edict_t	*ent;

	ent = PROG_TO_EDICT(PR_GLOBAL(msg_entity));
	entnum = NUM_FOR_EDICT(ent);
	if (entnum < 1 || entnum > MAX_CLIENTS)
		PR_RunError ("WriteDest: not a client");
	return &svs.clients[entnum-1];
}


#ifdef WITH_NQPROGS
static byte nqp_buf_data[1024] /* must be large enough for svc_finale text */;
static sizebuf_t nqp_buf;
static qbool nqp_ignore_this_frame;
static int nqp_expect;

void NQP_Reset (void)
{
	nqp_ignore_this_frame = false;
	nqp_expect = 0;
	SZ_Init (&nqp_buf, nqp_buf_data, sizeof(nqp_buf_data));
}

static void NQP_Flush (int count)
{
// FIXME, we make no distinction reliable or not
	assert (count <= nqp_buf.cursize);
	SZ_Write (&sv.reliable_datagram, nqp_buf_data, count);
	memmove (nqp_buf_data, nqp_buf_data + count, nqp_buf.cursize - count);
	nqp_buf.cursize -= count;
}

static void NQP_Skip (int count)
{
	assert (count <= nqp_buf.cursize);
	memmove (nqp_buf_data, nqp_buf_data + count, nqp_buf.cursize - count);
	nqp_buf.cursize -= count;
}

static void NQP_Process (void)
{
	int cmd;

	if (nqp_ignore_this_frame) {
		SZ_Clear (&nqp_buf);
		return;
	}

	while (1) {
		if (nqp_expect) {
			if (nqp_buf.cursize >= nqp_expect) {
				NQP_Flush (nqp_expect);
				nqp_expect = 0;
			}
			else
				break;
		}

		if (!nqp_buf.cursize)
			break;

		nqp_expect = 0;

		cmd = nqp_buf_data[0];
		if (cmd == svc_killedmonster || cmd == svc_foundsecret || cmd == svc_sellscreen)
			nqp_expect = 1;
		else if (cmd == svc_updatestat) {
			NQP_Skip (1);
			MSG_WriteByte (&sv.reliable_datagram, svc_updatestatlong);
			nqp_expect = 5;
		}
		else if (cmd == svc_print) {
			byte *p = (byte *)memchr (nqp_buf_data + 1, 0, nqp_buf.cursize - 1);
			if (!p)
				goto waitformore;
			MSG_WriteByte(&sv.reliable_datagram, svc_print);
			MSG_WriteByte(&sv.reliable_datagram, PRINT_HIGH);
			MSG_WriteString(&sv.reliable_datagram, (char *)(nqp_buf_data + 1));
			NQP_Skip(p - nqp_buf_data + 1);
		}
		else if (cmd == nq_svc_setview) {
			if (nqp_buf.cursize < 3)
				goto waitformore;
			NQP_Skip (3);		// TODO: make an extension for this
		}
		else if (cmd == svc_updatefrags)
			nqp_expect = 4;
		else if (cmd == nq_svc_updatecolors) {
			if (nqp_buf.cursize < 3)
				goto waitformore;
			MSG_WriteByte (&sv.reliable_datagram, svc_setinfo);
			MSG_WriteByte (&sv.reliable_datagram, nqp_buf_data[1]);
			MSG_WriteString (&sv.reliable_datagram, "topcolor");
			MSG_WriteString (&sv.reliable_datagram, va("%i", min(nqp_buf_data[2] & 15, 13)));
			MSG_WriteByte (&sv.reliable_datagram, svc_setinfo);
			MSG_WriteByte (&sv.reliable_datagram, nqp_buf_data[1]);
			MSG_WriteString (&sv.reliable_datagram, "bottomcolor");
			MSG_WriteString (&sv.reliable_datagram, va("%i", min((nqp_buf_data[2] >> 4)& 15, 13)));
			NQP_Skip (3);
		}
		else if (cmd == nq_svc_updatename) {
			int slot;
			byte *p;
			if (nqp_buf.cursize < 3)
				goto waitformore;
			slot = nqp_buf_data[1];
			p = (byte *)memchr (nqp_buf_data + 2, 0, nqp_buf.cursize - 2);
			if (!p)
				goto waitformore;
			MSG_WriteByte (&sv.reliable_datagram, svc_setinfo);
			MSG_WriteByte (&sv.reliable_datagram, slot);
			MSG_WriteString (&sv.reliable_datagram, "name");
			MSG_WriteString (&sv.reliable_datagram, (char *)nqp_buf_data + 2);
			MSG_WriteByte (&sv.reliable_datagram, svc_updateping);
			MSG_WriteByte (&sv.reliable_datagram, slot);
			MSG_WriteShort (&sv.reliable_datagram, 0);
			// We expect bots to set their name when they enter the game and never change it
			MSG_WriteByte (&sv.reliable_datagram, svc_updateentertime);
			MSG_WriteByte (&sv.reliable_datagram, slot);
			MSG_WriteFloat (&sv.reliable_datagram, 0);
			NQP_Skip ((p - nqp_buf_data) + 1);
		}
		else if (cmd == svc_cdtrack) {
			if (nqp_buf.cursize < 3)
				goto waitformore;
			NQP_Flush (2);
			NQP_Skip (1);
		}
		else if (cmd == svc_finale) {
			byte *p = (byte *)memchr (nqp_buf_data + 1, 0, nqp_buf.cursize - 1);
			if (!p)
				goto waitformore;
			nqp_expect = (p - nqp_buf_data) + 1;
		}
		else if (cmd == svc_intermission) {
			int i;
			NQP_Flush (1);
			for (i = 0; i < 3; i++)
				MSG_WriteCoord (&sv.reliable_datagram, svs.clients[0].edict->v->origin[i]);
			for (i = 0; i < 3; i++)
				MSG_WriteAngle (&sv.reliable_datagram, svs.clients[0].edict->v->angles[i]);
		}
		else if (cmd == nq_svc_cutscene) {
			byte *p = (byte *)memchr (nqp_buf_data + 1, 0, nqp_buf.cursize - 1);
			if (!p)
				goto waitformore;
			MSG_WriteByte (&sv.reliable_datagram, svc_stufftext);
			MSG_WriteString (&sv.reliable_datagram, "//cutscene\n"); // ZQ extension
			NQP_Skip (p - nqp_buf_data + 1);
		}
		else if (nqp_buf_data[0] == svc_temp_entity) {
			if (nqp_buf.cursize < 2)
				break;

switch (nqp_buf_data[1]) {
  case TE_SPIKE:
  case TE_SUPERSPIKE:
  case TE_EXPLOSION:
  case TE_TAREXPLOSION:
  case TE_WIZSPIKE:
  case TE_KNIGHTSPIKE:
  case TE_LAVASPLASH:
  case TE_TELEPORT:
		nqp_expect = 8;
		break;
  case TE_GUNSHOT:
		if (nqp_buf.cursize < 8)
			goto waitformore;
		NQP_Flush (2);
		MSG_WriteByte (&sv.reliable_datagram, 1);
		NQP_Flush (6);
		break;

  case TE_LIGHTNING1:
  case TE_LIGHTNING2:
  case TE_LIGHTNING3:
		nqp_expect = 16;
	  break;
  case NQ_TE_BEAM:
  {		int entnum;
		if (nqp_buf.cursize < 16)
			goto waitformore;
		MSG_WriteByte (&sv.reliable_datagram, svc_temp_entity);
		MSG_WriteByte (&sv.reliable_datagram, TE_LIGHTNING1);
		entnum = nqp_buf_data[2] + nqp_buf_data[3]*256;
		if ((unsigned int)entnum > 1023)
			entnum = 0;
		MSG_WriteShort (&sv.reliable_datagram, (short)(entnum - 1288));
		NQP_Skip (4);
		nqp_expect = 12;
		break;
  }

  case NQ_TE_EXPLOSION2:
		nqp_expect = 10;
		break;
  default:
		Con_Printf ("WARNING: progs.dat sent an unsupported svc_temp_entity: %i\n", nqp_buf_data[1]);
	    goto ignore;
}

		}
		else {
			Con_Printf ("WARNING: progs.dat sent an unsupported svc: %i\n", cmd);
ignore:
			nqp_ignore_this_frame = true;
			break;
		}
	}
waitformore:;
}

#else // !WITH_NQPROGS
#define NQP_Process()
sizebuf_t nqp_buf;	// dummy
#endif


void PF_WriteByte (void)
{
	if (pr_nqprogs)
	{
		if (G_FLOAT(OFS_PARM0) == MSG_ONE || G_FLOAT(OFS_PARM0) == MSG_INIT)
			return;	// we don't support this
		MSG_WriteByte (&nqp_buf, G_FLOAT(OFS_PARM1));
		NQP_Process ();
		return;
	}

	if (G_FLOAT(OFS_PARM0) == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 1);
		ClientReliableWrite_Byte(cl, G_FLOAT(OFS_PARM1));
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 1))
			{
				MVD_MSG_WriteByte(G_FLOAT(OFS_PARM1));
			}
		}
	}
	else
		MSG_WriteByte (WriteDest(), G_FLOAT(OFS_PARM1));
}

void PF_WriteChar (void)
{
	if (pr_nqprogs)
	{
		if (G_FLOAT(OFS_PARM0) == MSG_ONE || G_FLOAT(OFS_PARM0) == MSG_INIT)
			return;	// we don't support this
		MSG_WriteByte (&nqp_buf, G_FLOAT(OFS_PARM1));
		NQP_Process ();
		return;
	}

	if (G_FLOAT(OFS_PARM0) == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 1);
		ClientReliableWrite_Char(cl, G_FLOAT(OFS_PARM1));
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 1))
			{
				MVD_MSG_WriteByte(G_FLOAT(OFS_PARM1));
			}
		}
	}
	else
		MSG_WriteChar (WriteDest(), G_FLOAT(OFS_PARM1));
}

void PF_WriteShort (void)
{
	if (pr_nqprogs)
	{
		if (G_FLOAT(OFS_PARM0) == MSG_ONE || G_FLOAT(OFS_PARM0) == MSG_INIT)
			return;	// we don't support this
		MSG_WriteShort (&nqp_buf, G_FLOAT(OFS_PARM1));
		NQP_Process ();
		return;
	}

	if (G_FLOAT(OFS_PARM0) == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 2);
		ClientReliableWrite_Short(cl, G_FLOAT(OFS_PARM1));
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 2))
			{
				MVD_MSG_WriteShort(G_FLOAT(OFS_PARM1));
			}
		}
	}
	else
		MSG_WriteShort (WriteDest(), G_FLOAT(OFS_PARM1));
}

void PF_WriteLong (void)
{
	if (pr_nqprogs)
	{
		if (G_FLOAT(OFS_PARM0) == MSG_ONE || G_FLOAT(OFS_PARM0) == MSG_INIT)
			return;	// we don't support this
		MSG_WriteLong (&nqp_buf, G_FLOAT(OFS_PARM1));
		NQP_Process ();
		return;
	}

	if (G_FLOAT(OFS_PARM0) == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 4);
		ClientReliableWrite_Long(cl, G_FLOAT(OFS_PARM1));
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 4))
			{
				MVD_MSG_WriteLong(G_FLOAT(OFS_PARM1));
			}
		}
	}
	else
		MSG_WriteLong (WriteDest(), G_FLOAT(OFS_PARM1));
}

void PF_WriteAngle (void)
{
	if (pr_nqprogs)
	{
		if (G_FLOAT(OFS_PARM0) == MSG_ONE || G_FLOAT(OFS_PARM0) == MSG_INIT)
			return;	// we don't support this
		MSG_WriteAngle (&nqp_buf, G_FLOAT(OFS_PARM1));
		NQP_Process ();
		return;
	}

	if (G_FLOAT(OFS_PARM0) == MSG_ONE)
	{
#ifdef FTE_PEXT_FLOATCOORDS
		int size = msg_anglesize;
#else
		int size = 1;
#endif
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, size);
		ClientReliableWrite_Angle(cl, G_FLOAT(OFS_PARM1));
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, size))
			{
				MVD_MSG_WriteAngle(G_FLOAT(OFS_PARM1));
			}
		}
	}
	else
		MSG_WriteAngle (WriteDest(), G_FLOAT(OFS_PARM1));
}

void PF_WriteCoord (void)
{
	if (pr_nqprogs)
	{
		if (G_FLOAT(OFS_PARM0) == MSG_ONE || G_FLOAT(OFS_PARM0) == MSG_INIT)
			return;	// we don't support this
		MSG_WriteCoord (&nqp_buf, G_FLOAT(OFS_PARM1));
		NQP_Process ();
		return;
	}

	if (G_FLOAT(OFS_PARM0) == MSG_ONE)
	{
#ifdef FTE_PEXT_FLOATCOORDS
		int size = msg_coordsize;
#else
		int size = 2;
#endif
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, size);
		ClientReliableWrite_Coord(cl, G_FLOAT(OFS_PARM1));
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, size))
			{
				MVD_MSG_WriteCoord(G_FLOAT(OFS_PARM1));
			}
		}
	}
	else
		MSG_WriteCoord (WriteDest(), G_FLOAT(OFS_PARM1));
}

void PF_WriteString (void)
{
	if (pr_nqprogs)
	{
		if (G_FLOAT(OFS_PARM0) == MSG_ONE || G_FLOAT(OFS_PARM0) == MSG_INIT)
			return;	// we don't support this
		MSG_WriteString (&nqp_buf, G_STRING(OFS_PARM1));
		NQP_Process ();
		return;
	}

	if (G_FLOAT(OFS_PARM0) == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 1+strlen(G_STRING(OFS_PARM1)));
		ClientReliableWrite_String(cl, G_STRING(OFS_PARM1));
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 1 + strlen(G_STRING(OFS_PARM1))))
			{
				MVD_MSG_WriteString(G_STRING(OFS_PARM1));
			}
		}
	}
	else
		MSG_WriteString (WriteDest(), G_STRING(OFS_PARM1));
}


void PF_WriteEntity (void)
{
	if (pr_nqprogs)
	{
		if (G_FLOAT(OFS_PARM0) == MSG_ONE || G_FLOAT(OFS_PARM0) == MSG_INIT)
			return;	// we don't support this
		MSG_WriteShort (&nqp_buf, G_EDICTNUM(OFS_PARM1));
		NQP_Process ();
		return;
	}

	if (G_FLOAT(OFS_PARM0) == MSG_ONE)
	{
		client_t *cl = Write_GetClient();
		ClientReliableCheckBlock(cl, 2);
		ClientReliableWrite_Short(cl, G_EDICTNUM(OFS_PARM1));
		if (sv.mvdrecording)
		{
			if (MVDWrite_Begin(dem_single, cl - svs.clients, 2))
			{
				MVD_MSG_WriteShort(G_EDICTNUM(OFS_PARM1));
			}
		}
	}
	else
		MSG_WriteShort (WriteDest(), G_EDICTNUM(OFS_PARM1));
}

//=============================================================================

int SV_ModelIndex (char *name);

void PF_makestatic (void)
{
	entity_state_t* s;
	edict_t	*ent;

	ent = G_EDICT(OFS_PARM0);
	if (sv.static_entity_count >= sizeof(sv.static_entities) / sizeof(sv.static_entities[0])) {
		ED_Free (ent);
		return;
	}

	s = &sv.static_entities[sv.static_entity_count];
	memset(s, 0, sizeof(sv.static_entities[0]));
	s->number = sv.static_entity_count + 1;
	s->modelindex = SV_ModelIndex(PR_GetEntityString(ent->v->model));
	if (!s->modelindex) {
		ED_Free (ent);
		return;
	}
	s->frame = ent->v->frame;
	s->colormap = ent->v->colormap;
	s->skinnum = ent->v->skin;
	VectorCopy(ent->v->origin, s->origin);
	VectorCopy(ent->v->angles, s->angles);
#ifdef FTE_PEXT_TRANS
	s->trans = ent->xv.alpha >= 1.0f ? 0 : bound(0, (byte)(ent->xv.alpha * 254.0), 254);
#endif
#ifdef FTE_PEXT_COLOURMOD
	if (ent->xv.colourmod[0] != 1.0f && ent->xv.colourmod[1] != 1.0f && ent->xv.colourmod[2] != 1.0f)
	{
		s->colourmod[0] = bound(0, ent->xv.colourmod[0] * (256.0f / 8.0f), 255);
		s->colourmod[1] = bound(0, ent->xv.colourmod[1] * (256.0f / 8.0f), 255);
		s->colourmod[2] = bound(0, ent->xv.colourmod[2] * (256.0f / 8.0f), 255);
	}
#endif
	++sv.static_entity_count;

	// throw the entity away now
	ED_Free (ent);
}

//=============================================================================

/*
==============
PF_setspawnparms
==============
*/
void PF_setspawnparms (void)
{
	edict_t	*ent;
	int		i;
	client_t	*client;

	ent = G_EDICT(OFS_PARM0);
	i = NUM_FOR_EDICT(ent);
	if (i < 1 || i > MAX_CLIENTS)
		PR_RunError ("Entity is not a client");

	// copy spawn parms out of the client_t
	client = svs.clients + (i-1);

	for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
		(&PR_GLOBAL(parm1))[i] = client->spawn_parms[i];
}

/*
==============
PF_changelevel
==============
*/
void PF_changelevel (void)
{
	char	*s;
	static	int	last_spawncount;

	// make sure we don't issue two changelevels
	if (svs.spawncount == last_spawncount)
		return;
	last_spawncount = svs.spawncount;

	s = G_STRING(OFS_PARM0);
	Cbuf_AddText (va("map %s\n",s));
}


/*
==============
PF_logfrag
 
logfrag (killer, killee)
==============
*/
void PF_logfrag (void)
{
	edict_t	*ent1, *ent2;
	int		e1, e2;
	char	*s;
	// -> scream
	time_t		t;
	struct tm	*tblock;
	// <-

	ent1 = G_EDICT(OFS_PARM0);
	ent2 = G_EDICT(OFS_PARM1);

	e1 = NUM_FOR_EDICT(ent1);
	e2 = NUM_FOR_EDICT(ent2);

	if (e1 < 1 || e1 > MAX_CLIENTS || e2 < 1 || e2 > MAX_CLIENTS)
		return;
	// -> scream
	t = time (NULL);
	tblock = localtime (&t);

	//bliP: date check ->
	if (!tblock)
		s = va("%s\n", "#bad date#");
	else
		if ((int)frag_log_type.value) // need for old-style frag log file
			s = va("\\frag\\%s\\%s\\%s\\%s\\%d-%d-%d %d:%d:%d\\\n",
			       svs.clients[e1-1].name, svs.clients[e2-1].name,
			       svs.clients[e1-1].team, svs.clients[e2-1].team,
			       tblock->tm_year + 1900, tblock->tm_mon + 1, tblock->tm_mday,
			       tblock->tm_hour, tblock->tm_min, tblock->tm_sec);
		else
			s = va("\\%s\\%s\\\n",svs.clients[e1-1].name, svs.clients[e2-1].name);
	// <-
	SZ_Print (&svs.log[svs.logsequence&1], s);
	SV_Write_Log(FRAG_LOG, 1, s);
	//	SV_Write_Log(MOD_FRAG_LOG, 1, "\n==== PF_logfrag ===={\n");
	//	SV_Write_Log(MOD_FRAG_LOG, 1, va("%d\n", time(NULL)));
	//	SV_Write_Log(MOD_FRAG_LOG, 1, s);
	//	SV_Write_Log(MOD_FRAG_LOG, 1, "}====================\n");
}

/*
==============
PF_infokey

string(entity e, string key) infokey
==============
*/
void PF_infokey (void)
{
	edict_t	*e;
	int		e1;
	char	*value;
	char	*key;
	static	char ov[256];
	client_t *cl;

	e = G_EDICT(OFS_PARM0);
	e1 = NUM_FOR_EDICT(e);
	key = G_STRING(OFS_PARM1);
	cl = &svs.clients[e1-1];

	if (e1 == 0)
	{
		if ((value = Info_ValueForKey (svs.info, key)) == NULL || !*value)
			value = Info_Get(&_localinfo_, key);
	}
	else if (e1 <= MAX_CLIENTS)
	{
		value = ov;
		if (!strncmp(key, "ip", 3))
			strlcpy(ov, NET_BaseAdrToString (cl->netchan.remote_address), sizeof(ov));
		else if (!strncmp(key, "realip", 7))
			strlcpy(ov, NET_BaseAdrToString (cl->realip), sizeof(ov));
		else if (!strncmp(key, "download", 9))
			//snprintf(ov, sizeof(ov), "%d", cl->download != NULL ? (int)(100*cl->downloadcount/cl->downloadsize) : -1);
			snprintf(ov, sizeof(ov), "%d", cl->file_percent ? cl->file_percent : -1); //bliP: file percent
		else if (!strncmp(key, "ping", 5))
			snprintf(ov, sizeof(ov), "%d", SV_CalcPing (cl));
		else if (!strncmp(key, "*userid", 8))
			snprintf(ov, sizeof(ov), "%d", svs.clients[e1 - 1].userid);
		else if (!strncmp(key, "login", 6))
			value = cl->login;
		else
			value = Info_Get (&cl->_userinfo_ctx_, key);
	}
	else
		value = "";

	strlcpy(pr_string_temp, value, MAX_PR_STRING_SIZE);
	RETURN_STRING(pr_string_temp);
	PF_SetTempString();
}

/*
==============
PF_stof
 
float(string s) stof
==============
*/
void PF_stof (void)
{
	char	*s;

	s = G_STRING(OFS_PARM0);

	G_FLOAT(OFS_RETURN) = Q_atof(s);
}


/*
==============
PF_multicast
 
void(vector where, float set) multicast
==============
*/
void PF_multicast (void)
{
	float	*o;
	int		to;

	o = G_VECTOR(OFS_PARM0);
	to = G_FLOAT(OFS_PARM1);

	SV_Multicast (o, to);
}

//DP_QC_SINCOSSQRTPOW
//float sin(float x) = #60
void PF_sin (void)
{
	G_FLOAT(OFS_RETURN) = sin(G_FLOAT(OFS_PARM0));
}

//DP_QC_SINCOSSQRTPOW
//float cos(float x) = #61
void PF_cos (void)
{
	G_FLOAT(OFS_RETURN) = cos(G_FLOAT(OFS_PARM0));
}

//DP_QC_SINCOSSQRTPOW
//float sqrt(float x) = #62
void PF_sqrt (void)
{
	G_FLOAT(OFS_RETURN) = sqrt(G_FLOAT(OFS_PARM0));
}

//DP_QC_SINCOSSQRTPOW
//float pow(float x, float y) = #97;
static void PF_pow (void)
{
	G_FLOAT(OFS_RETURN) = pow(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
}

//DP_QC_MINMAXBOUND
//float min(float a, float b, ...) = #94
void PF_min (void)
{
	// LordHavoc: 3+ argument enhancement suggested by FrikaC
	if (pr_argc == 2)
		G_FLOAT(OFS_RETURN) = min(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
	else if (pr_argc >= 3)
	{
		int i;
		float f = G_FLOAT(OFS_PARM0);
		for (i = 1;i < pr_argc;i++)
			if (G_FLOAT((OFS_PARM0+i*3)) < f)
				f = G_FLOAT((OFS_PARM0+i*3));
		G_FLOAT(OFS_RETURN) = f;
	}
	else
		Sys_Error("min: must supply at least 2 floats");
}

//DP_QC_MINMAXBOUND
//float max(float a, float b, ...) = #95
void PF_max (void)
{
	// LordHavoc: 3+ argument enhancement suggested by FrikaC
	if (pr_argc == 2)
		G_FLOAT(OFS_RETURN) = max(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
	else if (pr_argc >= 3)
	{
		int i;
		float f = G_FLOAT(OFS_PARM0);
		for (i = 1;i < pr_argc;i++)
			if (G_FLOAT((OFS_PARM0+i*3)) > f)
				f = G_FLOAT((OFS_PARM0+i*3));
		G_FLOAT(OFS_RETURN) = f;
	}
	else
		Sys_Error("max: must supply at least 2 floats");
}

//DP_QC_MINMAXBOUND
//float bound(float min, float value, float max) = #96
void PF_bound (void)
{
	G_FLOAT(OFS_RETURN) = bound(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1), G_FLOAT(OFS_PARM2));
}

/*
=================
PF_tracebox

Like traceline but traces a box of the size specified
(NOTE: currently the hull size can only be one of the sizes used in the map
for bmodel collisions, entity collisions will pay attention to the exact size
specified however, this is a collision code limitation in quake itself,
and will be fixed eventually).

DP_QC_TRACEBOX

void(vector v1, vector mins, vector maxs, vector v2, float nomonsters, entity ignore) tracebox = #90;
=================
*/
static void PF_tracebox (void)
{
        float       *v1, *v2, *mins, *maxs;
        edict_t     *ent;
        int          nomonsters;
        trace_t      trace;

        v1 = G_VECTOR(OFS_PARM0);
        mins = G_VECTOR(OFS_PARM1);
        maxs = G_VECTOR(OFS_PARM2);
        v2 = G_VECTOR(OFS_PARM3);
        nomonsters = G_FLOAT(OFS_PARM4);
        ent = G_EDICT(OFS_PARM5);

        trace = SV_Trace (v1, mins, maxs, v2, nomonsters, ent);

        PR_GLOBAL(trace_allsolid) = trace.allsolid;
        PR_GLOBAL(trace_startsolid) = trace.startsolid;
        PR_GLOBAL(trace_fraction) = trace.fraction;
        PR_GLOBAL(trace_inwater) = trace.inwater;
        PR_GLOBAL(trace_inopen) = trace.inopen;
        VectorCopy (trace.endpos, PR_GLOBAL(trace_endpos));
        VectorCopy (trace.plane.normal, PR_GLOBAL(trace_plane_normal));
        PR_GLOBAL(trace_plane_dist) =  trace.plane.dist;
        if (trace.e.ent)
                PR_GLOBAL(trace_ent) = EDICT_TO_PROG(trace.e.ent);
        else
                PR_GLOBAL(trace_ent) = EDICT_TO_PROG(sv.edicts);
}

/*
=================
PF_randomvec

DP_QC_RANDOMVEC
vector randomvec() = #91
=================
*/
static void PF_randomvec (void)
{
	vec3_t temp;

	do {
		temp[0] = (rand() & 0x7fff) * (2.0 / 0x7fff) - 1.0;
		temp[1] = (rand() & 0x7fff) * (2.0 / 0x7fff) - 1.0;
		temp[2] = (rand() & 0x7fff) * (2.0 / 0x7fff) - 1.0;
	} while (DotProduct(temp, temp) >= 1);

	VectorCopy (temp, G_VECTOR(OFS_RETURN));
}

/*
=================
PF_cvar_string

QSG_CVARSTRING DP_QC_CVAR_STRING
string cvar_string(string varname) = #103;
=================
*/
static void PF_cvar_string (void)
{
	char	*str;
	cvar_t	*var;

	str = G_STRING(OFS_PARM0);
	var = Cvar_Find(str);
	if (!var) {
		G_INT(OFS_RETURN) = 0;
		return;
	}

	strlcpy (pr_string_temp, var->string, MAX_PR_STRING_SIZE);
	RETURN_STRING(pr_string_temp);
	PF_SetTempString();
}

// DP_REGISTERCVAR
// float(string name, string value) registercvar = #93;
// DarkPlaces implementation has an undocumented feature where you can add cvar flags
// as a third parameter;  I don't see how that can be useful so it's not implemented
void PF_registercvar (void)
{
	char *name, *value;

	name = G_STRING(OFS_PARM0);
	value = G_STRING(OFS_PARM0);

	if (Cvar_Find(name)) {
		G_INT(OFS_RETURN) = 0;
		return;
	}

	Cvar_Create (name, value, 0);
	G_INT(OFS_RETURN) = 1;
}

// ZQ_PAUSE
// void(float pause) setpause = #531;
void PF_setpause (void)
{
	int pause;

	pause = G_FLOAT(OFS_PARM0) ? 1 : 0;

	if (pause != (sv.paused & 1))
		SV_TogglePause (NULL, 1);
}


/*
==============
PF_checkextension

float checkextension(string extension) = #99;
==============
*/
static void PF_checkextension (void)
{
	static char *supported_extensions[] = {
		"DP_CON_SET",               // http://wiki.quakesrc.org/index.php/DP_CON_SET
		"DP_QC_CVAR_STRING",		// http://wiki.quakesrc.org/index.php/DP_QC_CVAR_STRING
		"DP_QC_MINMAXBOUND",        // http://wiki.quakesrc.org/index.php/DP_QC_MINMAXBOUND
		"DP_QC_RANDOMVEC",			// http://wiki.quakesrc.org/index.php/DP_QC_RANDOMVEC
		"DP_QC_SINCOSSQRTPOW",      // http://wiki.quakesrc.org/index.php/DP_QC_SINCOSSQRTPOW
		"DP_QC_TRACEBOX",			// http://wiki.quakesrc.org/index.php/DP_QC_TRACEBOX
		"DP_REGISTERCVAR",			// http://wiki.quakesrc.org/index.php/DP_REGISTERCVAR
		"FTE_CALLTIMEOFDAY",        // http://wiki.quakesrc.org/index.php/FTE_CALLTIMEOFDAY
		"QSG_CVARSTRING",			// http://wiki.quakesrc.org/index.php/QSG_CVARSTRING
		"ZQ_CLIENTCOMMAND",			// http://wiki.quakesrc.org/index.php/ZQ_CLIENTCOMMAND
		"ZQ_ITEMS2",                // http://wiki.quakesrc.org/index.php/ZQ_ITEMS2
		"ZQ_MOVETYPE_NOCLIP",       // http://wiki.quakesrc.org/index.php/ZQ_MOVETYPE_NOCLIP
		"ZQ_MOVETYPE_FLY",          // http://wiki.quakesrc.org/index.php/ZQ_MOVETYPE_FLY
		"ZQ_MOVETYPE_NONE",         // http://wiki.quakesrc.org/index.php/ZQ_MOVETYPE_NONE
		"ZQ_PAUSE",					// http://wiki.quakesrc.org/index.php/ZQ_PAUSE
		"ZQ_QC_STRINGS",			// http://wiki.quakesrc.org/index.php/ZQ_QC_STRINGS
		"ZQ_QC_TOKENIZE",           // http://wiki.quakesrc.org/index.php/ZQ_QC_TOKENIZE
		"ZQ_VWEP",
		NULL
	};
	char **pstr, *extension;
	extension = G_STRING(OFS_PARM0);

	for (pstr = supported_extensions; *pstr; pstr++) {
		if (!strcasecmp(*pstr, extension)) {
			G_FLOAT(OFS_RETURN) = 1.0;	// supported
			return;
		}
	}

	G_FLOAT(OFS_RETURN) = 0.0;	// not supported
}



void PF_Fixme (void)
{
	PR_RunError ("unimplemented bulitin");
}



static builtin_t std_builtins[] =
{
PF_Fixme,		//#0
PF_makevectors,	// void(entity e)	makevectors 		= #1;
PF_setorigin,	// void(entity e, vector o) setorigin	= #2;
PF_setmodel,	// void(entity e, string m) setmodel	= #3;
PF_setsize,	// void(entity e, vector min, vector max) setsize = #4;
PF_Fixme,	// void(entity e, vector min, vector max) setabssize = #5;
PF_break,	// void() break						= #6;
PF_random,	// float() random						= #7;
PF_sound,	// void(entity e, float chan, string samp) sound = #8;
PF_normalize,	// vector(vector v) normalize			= #9;
PF_error,	// void(string e) error				= #10;
PF_objerror,	// void(string e) objerror				= #11;
PF_vlen,	// float(vector v) vlen				= #12;
PF_vectoyaw,	// float(vector v) vectoyaw		= #13;
PF_Spawn,	// entity() spawn						= #14;
PF_Remove,	// void(entity e) remove				= #15;
PF_traceline,	// float(vector v1, vector v2, float tryents) traceline = #16;
PF_checkclient,	// entity() clientlist					= #17;
PF_Find,	// entity(entity start, .string fld, string match) find = #18;
PF_precache_sound,	// void(string s) precache_sound		= #19;
PF_precache_model,	// void(string s) precache_model		= #20;
PF_stuffcmd,	// void(entity client, string s)stuffcmd = #21;
PF_findradius,	// entity(vector org, float rad) findradius = #22;
PF_bprint,	// void(string s) bprint				= #23;
PF_sprint,	// void(entity client, string s) sprint = #24;
PF_dprint,	// void(string s) dprint				= #25;
PF_ftos,	// void(string s) ftos				= #26;
PF_vtos,	// void(string s) vtos				= #27;
PF_coredump,
PF_traceon,
PF_traceoff,		//#30
PF_eprint,	// void(entity e) debug print an entire entity
PF_walkmove, // float(float yaw, float dist) walkmove
PF_Fixme, // float(float yaw, float dist) walkmove
PF_droptofloor,
PF_lightstyle,
PF_rint,
PF_floor,
PF_ceil,
PF_Fixme,
PF_checkbottom,		//#40
PF_pointcontents,
PF_Fixme,
PF_fabs,
PF_aim,
PF_cvar,
PF_localcmd,
PF_nextent,
PF_particle,
PF_changeyaw,
PF_Fixme,		//#50
PF_vectoangles,

PF_WriteByte,
PF_WriteChar,
PF_WriteShort,
PF_WriteLong,
PF_WriteCoord,
PF_WriteAngle,
PF_WriteString,
PF_WriteEntity,		//#59

PF_Fixme,
PF_Fixme,
PF_Fixme,
PF_Fixme,
PF_Fixme,
PF_Fixme,
PF_Fixme,

SV_MoveToGoal,
PF_precache_file,
PF_makestatic,

PF_changelevel,		//#70
PF_Fixme,

PF_cvar_set,
PF_centerprint,

PF_ambientsound,

PF_precache_model,
PF_precache_sound,		// precache_sound2 is different only for qcc
PF_precache_file,

PF_setspawnparms,

PF_logfrag,

PF_infokey,		//#80
PF_stof,
PF_multicast,
};

#define num_std_builtins (sizeof(std_builtins)/sizeof(std_builtins[0]))

static struct { int num; builtin_t func; } ext_builtins[] =
{
{60, PF_sin},			//float(float f) sin = #60;
{61, PF_cos},			//float(float f) cos = #61;
{62, PF_sqrt},			//float(float f) sqrt = #62;

{84, PF_tokenize},		// float(string s) tokenize
{85, PF_argc},			// float() argc
{86, PF_argv},			// string(float n) argv

{90, PF_tracebox},		// void (vector v1, vector mins, vector maxs, vector v2, float nomonsters, entity ignore) tracebox
{91, PF_randomvec},		// vector() randomvec
////
{93, PF_registercvar},	// float(string name, string value) registercvar
{94, PF_min},			// float(float a, float b, ...) min
{95, PF_max},			// float(float a, float b, ...) max
{96, PF_bound},			// float(float min, float value, float max) bound
{97, PF_pow},			// float(float x, float y) pow
////
{99, PF_checkextension},// float(string name) checkextension
////
{103, PF_cvar_string},	// string(string varname) cvar_string
////
{114, PF_strlen},		// float(string s) strlen
{115, PF_strcat},		// string(string s1, string s2, ...) strcat
{116, PF_substr},		// string(string s, float start, float count) substr
//{117, PF_stov},			// vector(string s) stov
{118, PF_strzone},		// string(string s) strzone
{119, PF_strunzone},	// void(string s) strunzone
{231, PF_calltimeofday},// void() calltimeofday
{448, PF_cvar_string},	// string(string varname) cvar_string
{531, PF_setpause},		//void(float pause) setpause
{532, PF_precache_vwep_model},	// float(string model) precache_vwep_model = #532;
};

#define num_ext_builtins (sizeof(ext_builtins)/sizeof(ext_builtins[0]))

builtin_t *pr_builtins = NULL;
int pr_numbuiltins = 0;

void PR_InitBuiltins (void)
{
	int i;

	if (pr_builtins)
		return; // We don't need reinit it.

	// Free old array.
	Q_free (pr_builtins);
	// We have at least iD builtins.
	pr_numbuiltins = num_std_builtins;
	// Find highest builtin number to see how much space we actually need.
	for (i = 0; i < num_ext_builtins; i++)
		pr_numbuiltins = max(ext_builtins[i].num + 1, pr_numbuiltins);
	// Allocate builtins array.
	pr_builtins = (builtin_t *) Q_malloc(pr_numbuiltins * sizeof(builtin_t));
	// Init new array to PF_Fixme().
	for (i = 0; i < pr_numbuiltins; i++)
		pr_builtins[i] = PF_Fixme;
	// Copy iD builtins in new array.
	memcpy (pr_builtins, std_builtins, num_std_builtins * sizeof(builtin_t));
	// Add QSG builtins or, probably, overwrite iD ones.
	for (i = 0; i < num_ext_builtins; i++)
	{
		assert (ext_builtins[i].num >= 0);
		pr_builtins[ext_builtins[i].num] = ext_builtins[i].func;
	}
}

#endif // CLIENTONLY

================================================
FILE: src/pr_comp.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef __PR_COMP_H__
#define __PR_COMP_H__

// this file is shared by quake and qcc

typedef int func_t;
typedef int string_t;
typedef intptr_t stringptr_t;

typedef enum {ev_void, ev_string, ev_float, ev_vector, ev_entity, ev_field, ev_function, ev_pointer} etype_t;


#define	OFS_NULL		0
#define	OFS_RETURN		1
#define	OFS_PARM0		4		// leave 3 ofs for each parm to hold vectors
#define	OFS_PARM1		7
#define	OFS_PARM2		10
#define	OFS_PARM3		13
#define	OFS_PARM4		16
#define	OFS_PARM5		19
#define	OFS_PARM6		22
#define	OFS_PARM7		25
#define	RESERVED_OFS	28


enum {
	OP_DONE,
	OP_MUL_F,
	OP_MUL_V,
	OP_MUL_FV,
	OP_MUL_VF,
	OP_DIV_F,
	OP_ADD_F,
	OP_ADD_V,
	OP_SUB_F,
	OP_SUB_V,
	
	OP_EQ_F,
	OP_EQ_V,
	OP_EQ_S,
	OP_EQ_E,
	OP_EQ_FNC,
	
	OP_NE_F,
	OP_NE_V,
	OP_NE_S,
	OP_NE_E,
	OP_NE_FNC,
	
	OP_LE,
	OP_GE,
	OP_LT,
	OP_GT,

	OP_LOAD_F,
	OP_LOAD_V,
	OP_LOAD_S,
	OP_LOAD_ENT,
	OP_LOAD_FLD,
	OP_LOAD_FNC,

	OP_ADDRESS,

	OP_STORE_F,
	OP_STORE_V,
	OP_STORE_S,
	OP_STORE_ENT,
	OP_STORE_FLD,
	OP_STORE_FNC,

	OP_STOREP_F,
	OP_STOREP_V,
	OP_STOREP_S,
	OP_STOREP_ENT,
	OP_STOREP_FLD,
	OP_STOREP_FNC,

	OP_RETURN,
	OP_NOT_F,
	OP_NOT_V,
	OP_NOT_S,
	OP_NOT_ENT,
	OP_NOT_FNC,
	OP_IF,
	OP_IFNOT,
	OP_CALL0,
	OP_CALL1,
	OP_CALL2,
	OP_CALL3,
	OP_CALL4,
	OP_CALL5,
	OP_CALL6,
	OP_CALL7,
	OP_CALL8,
	OP_STATE,
	OP_GOTO,
	OP_AND,
	OP_OR,
	
	OP_BITAND,
	OP_BITOR
};


typedef struct statement_s
{
	unsigned short	op;
	short	a,b,c;
} dstatement_t;

typedef struct
{
	unsigned short	type;		// if DEF_SAVEGLOBGAL bit is set
								// the variable needs to be saved in savegames
	unsigned short	ofs;
	int			s_name;
} ddef_t;
#define	DEF_SAVEGLOBAL	(1<<15)

#define	MAX_PARMS	8

typedef struct
{
	int		first_statement;	// negative numbers are builtins
	int		parm_start;
	int		locals;				// total ints of parms + locals
	
	int		profile;		// runtime
	
	int		s_name;
	int		s_file;			// source file defined in
	
	int		numparms;
	byte	parm_size[MAX_PARMS];
} dfunction_t;


#define	PROG_VERSION	6
typedef struct
{
	int		version;
	int		crc;			// check of header file
	
	int		ofs_statements;
	int		numstatements;	// statement 0 is an error

	int		ofs_globaldefs;
	int		numglobaldefs;
	
	int		ofs_fielddefs;
	int		numfielddefs;
	
	int		ofs_functions;
	int		numfunctions;	// function 0 is an empty
	
	int		ofs_strings;
	int		numstrings;		// first string is a null string

	int		ofs_globals;
	int		numglobals;
	
	int		entityfields;
} dprograms_t;

#endif /* !__PR_COMP_H__ */


================================================
FILE: src/pr_edict.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/
// sv_edict.c -- entity dictionary

#ifndef CLIENTONLY
#include "qwsvdef.h"

dprograms_t		*progs;
dfunction_t		*pr_functions;
char			*pr_strings;
ddef_t			*pr_fielddefs;
ddef_t			*pr_globaldefs;
dstatement_t	*pr_statements;
globalvars_t	*pr_global_struct;
float			*pr_globals;			// same as pr_global_struct
int				pr_edict_size;	// in bytes

#define NQ_PROGHEADER_CRC 5927

#ifdef WITH_NQPROGS
qbool pr_nqprogs;
int pr_fieldoffsetpatch[106];
int pr_globaloffsetpatch[62];
static int pr_globaloffsetpatch_nq[62] = {0,0,0,0,0,666,-4,-4,8,8,
8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8, 
8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8, 8,8};
#endif

static int type_size[8] =
{
	1,                  // void
	1,                  // string_t
	1,                  // float
	3,                  // vector
	1,                  // entity
	1,                  // field
	1,                  // func_t
	1                   // pointer (its an int index)
};

ddef_t *ED_FieldAtOfs (int ofs);
qbool ED_ParseEpair (void *base, ddef_t *key, char *s);

#define	MAX_FIELD_LEN	64
#define GEFV_CACHESIZE	2

typedef struct
{
	ddef_t	*pcache;
	char	field[MAX_FIELD_LEN];
}
gefv_cache;

static gefv_cache	gefvCache[GEFV_CACHESIZE] = {{NULL, ""}, {NULL, ""}};

func_t mod_SpectatorConnect, mod_SpectatorThink, mod_SpectatorDisconnect;
func_t GE_ClientCommand, GE_PausedTic, GE_ShouldPause;

func_t mod_ConsoleCmd, mod_UserCmd;
func_t mod_UserInfo_Changed, mod_localinfoChanged;
func_t mod_ChatMessage;

cvar_t	sv_progsname = {"sv_progsname", "qwprogs"};
#ifdef WITH_NQPROGS
cvar_t  sv_forcenqprogs = {"sv_forcenqprogs", "0"};
#endif

/*
=================
ED_ClearEdict
 
Sets everything to NULL
=================
*/
void ED_ClearEdict (edict_t *e)
{
	memset(e->v, 0, pr_edict_size);
	memset(&e->xv, 0, sizeof(ext_entvars_t));
	e->e.lastruntime = 0;
	e->e.free = false;
	PR_ClearEdict(e);
}

/*
=================
ED_Alloc
 
Either finds a free edict, or allocates a new one.
Try to avoid reusing an entity that was recently freed, because it
can cause the client to think the entity morphed into something else
instead of being removed and recreated, which can cause interpolated
angles and bad trails.
=================
*/
edict_t *ED_Alloc (void)
{
	int			i;
	edict_t		*e;

	for (i = MAX_CLIENTS + 1; i < sv.num_edicts; i++)
	{
		e = EDICT_NUM(i);
		// the first couple seconds of server time can involve a lot of
		// freeing and allocating, so relax the replacement policy
		if (e->e.free && (e->e.freetime < 2 || sv.time - e->e.freetime > 0.5))
		{
			ED_ClearEdict(e);
			return e;
		}
	}

	if (i == sv.max_edicts)
	{
		Con_Printf ("WARNING: ED_Alloc: no free edicts [%d]\n", sv.max_edicts);
		i--;	// step on whatever is the last edict
		e = EDICT_NUM(i);
		SV_UnlinkEdict(e);
	}
	else
	{
		sv.num_edicts++;
		e = EDICT_NUM(i);
	}

	ED_ClearEdict(e);

	return e;
}

/*
=================
ED_Free
 
Marks the edict as free
FIXME: walk all entities and NULL out references to this entity
=================
*/
void ED_Free (edict_t *ed)
{
	SV_UnlinkEdict (ed);		// unlink from world bsp
	memset(&ed->xv, 0, sizeof(ext_entvars_t));
	ed->e.free = true;
	ed->v->model = 0;
	ed->v->takedamage = 0;
	ed->v->modelindex = 0;
	ed->v->colormap = 0;
	ed->v->skin = 0;
	ed->v->frame = 0;
	ed->v->health = 0;
	ed->v->classname = 0;
	VectorClear (ed->v->origin);
	VectorClear (ed->v->angles);
	ed->v->nextthink = -1;
	ed->v->solid = 0;

	ed->e.freetime = sv.time;
}

//===========================================================================

/*
============
ED_GlobalAtOfs
============
*/
ddef_t *ED_GlobalAtOfs (int ofs)
{
	ddef_t		*def;
	int			i;

	for (i=0 ; i<progs->numglobaldefs ; i++)
	{
		def = &pr_globaldefs[i];
		if (def->ofs == ofs)
			return def;
	}
	return NULL;
}

/*
============
ED_FieldAtOfs
============
*/
ddef_t *ED_FieldAtOfs (int ofs)
{
	ddef_t		*def;
	int			i;

	for (i=0 ; i<progs->numfielddefs ; i++)
	{
		def = &pr_fielddefs[i];
		if (def->ofs == ofs)
			return def;
	}
	return NULL;
}

/*
============
ED_FindField
============
*/
ddef_t *ED_FindField (char *name)
{
	ddef_t		*def;
	int			i;

	for (i=0 ; i<progs->numfielddefs ; i++)
	{
		def = &pr_fielddefs[i];
		if (!strcmp(PR1_GetString(def->s_name),name) )
			return def;
	}
	return NULL;
}


/*
============
ED_FindGlobal
============
*/
ddef_t *ED_FindGlobal (char *name)
{
	ddef_t		*def;
	int			i;

	for (i=0 ; i<progs->numglobaldefs ; i++)
	{
		def = &pr_globaldefs[i];
		if (!strcmp(PR1_GetString(def->s_name),name) )
			return def;
	}
	return NULL;
}

/*
============
ED1_FindFieldOffset
============
*/
int ED1_FindFieldOffset (char *field)
{
	ddef_t *d;
	d = ED_FindField(field);
	if (!d)
		return 0;
	return d->ofs*4;
}

/*
============
ED_FindFunction
============
*/
dfunction_t *ED_FindFunction (char *name)
{
	register dfunction_t		*func;
	register int				i;

	if (!progs)
		return NULL;

	for (i=0 ; i<progs->numfunctions ; i++)
	{
		func = &pr_functions[i];
		if (!strcmp(PR1_GetString(func->s_name), name))
			return func;
	}
	return NULL;
}

func_t ED_FindFunctionOffset (char *name)
{
	dfunction_t *func;

	func = ED_FindFunction (name);
	return func ? (func_t)(func - pr_functions) : 0;
}

eval_t *PR1_GetEdictFieldValue(edict_t *ed, char *field)
{
	ddef_t			*def = NULL;
	int				i;
	static int		rep = 0;

	for (i=0 ; i<GEFV_CACHESIZE ; i++)
	{
		if (!strcmp(field, gefvCache[i].field))
		{
			def = gefvCache[i].pcache;
			goto Done;
		}
	}

	def = ED_FindField (field);

	if (strlen(field) < MAX_FIELD_LEN)
	{
		gefvCache[rep].pcache = def;
		strlcpy (gefvCache[rep].field, field, MAX_FIELD_LEN);
		rep ^= 1;
	}

Done:
	if (!def)
		return NULL;

	return (eval_t *)((char *)ed->v + def->ofs*4);
}

/*
============
PR_ValueString
 
Returns a string describing *data in a type specific manner
=============
*/
char *PR_ValueString (etype_t type, eval_t *val)
{
	static char	line[256];
	ddef_t		*def;
	dfunction_t	*f;

	type = (etype_t) (type & ~DEF_SAVEGLOBAL);

	switch (type)
	{
	case ev_string:
		snprintf (line, sizeof(line), "%s", PR1_GetString(val->string));
		break;
	case ev_entity:
		snprintf (line, sizeof(line), "entity %i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)) );
		break;
	case ev_function:
		f = pr_functions + val->function;
		snprintf (line, sizeof(line), "%s()", PR1_GetString(f->s_name));
		break;
	case ev_field:
		def = ED_FieldAtOfs ( val->_int );
		snprintf (line, sizeof(line), ".%s", PR1_GetString(def->s_name));
		break;
	case ev_void:
		snprintf (line, sizeof(line), "void");
		break;
	case ev_float:
		snprintf (line, sizeof(line), "%5.1f", val->_float);
		break;
	case ev_vector:
		snprintf (line, sizeof(line), "'%5.1f %5.1f %5.1f'", val->vector[0], val->vector[1], val->vector[2]);
		break;
	case ev_pointer:
		snprintf (line, sizeof(line), "pointer");
		break;
	default:
		snprintf (line, sizeof(line), "bad type %i", type);
		break;
	}

	return line;
}

/*
============
PR_UglyValueString
 
Returns a string describing *data in a type specific manner
Easier to parse than PR_ValueString
=============
*/
char *PR_UglyValueString (etype_t type, eval_t *val)
{
	static char	line[256];
	ddef_t		*def;
	dfunction_t	*f;

	type = (etype_t) (type & ~DEF_SAVEGLOBAL);

	switch (type)
	{
	case ev_string:
		snprintf (line, sizeof(line), "%s", PR1_GetString(val->string));
		break;
	case ev_entity:
		snprintf (line, sizeof(line), "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)));
		break;
	case ev_function:
		f = pr_functions + val->function;
		snprintf (line, sizeof(line), "%s", PR1_GetString(f->s_name));
		break;
	case ev_field:
		def = ED_FieldAtOfs ( val->_int );
		snprintf (line, sizeof(line), "%s", PR1_GetString(def->s_name));
		break;
	case ev_void:
		snprintf (line, sizeof(line), "void");
		break;
	case ev_float:
		snprintf (line, sizeof(line), "%f", val->_float);
		break;
	case ev_vector:
		snprintf (line, sizeof(line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
		break;
	default:
		snprintf (line, sizeof(line), "bad type %i", type);
		break;
	}

	return line;
}

/*
============
PR_GlobalString
 
Returns a string with a description and the contents of a global,
padded to 20 field width
============
*/
char *PR_GlobalString (int ofs)
{
	char	*s;
	int		i;
	ddef_t	*def;
	void	*val;
	static char	line[128];

	val = (void *)&pr_globals[ofs];
	def = ED_GlobalAtOfs(ofs);
	if (!def)
	{
		snprintf (line, sizeof(line), "%i(?""?""?)", ofs); // separate the ?'s to shut up gcc
	}
	else
	{
		s = PR_ValueString ((etype_t)def->type, (eval_t *) val);
		snprintf (line, sizeof(line), "%i(%s)%s", ofs, PR1_GetString(def->s_name), s);
	}

	i = strlen(line);
	for ( ; i<20 ; i++)
		strlcat (line, " ", sizeof(line));
	strlcat (line, " ", sizeof(line));

	return line;
}

char *PR_GlobalStringNoContents (int ofs)
{
	int		i;
	ddef_t	*def;
	static char	line[128];

	def = ED_GlobalAtOfs(ofs);
	if (!def)
		snprintf (line, sizeof(line), "%i(?""?""?)", ofs); // separate the ?'s to shut up gcc
	else
		snprintf (line, sizeof(line), "%i(%s)", ofs, PR1_GetString(def->s_name));

	i = strlen(line);
	for ( ; i<20 ; i++)
		strlcat (line, " ", sizeof(line));
	strlcat (line, " ", sizeof(line));

	return line;
}


/*
=============
ED_Print
 
For debugging
=============
*/
void ED_Print (edict_t *ed)
{
	int		l;
	ddef_t	*d;
	int		*v;
	int		i, j;
	char	*name;
	int		type;

	if (ed->e.free)
	{
		Con_Printf ("FREE\n");
		return;
	}

	for (i=1 ; i<progs->numfielddefs ; i++)
	{
		d = &pr_fielddefs[i];
		name = PR1_GetString(d->s_name);
		if (name[strlen(name)-2] == '_')
			continue;	// skip _x, _y, _z vars

		v = (int *)((char *)ed->v + d->ofs*4);

		// if the value is still all 0, skip the field
		type = d->type & ~DEF_SAVEGLOBAL;

		for (j = 0; j < type_size[type]; j++) {
			if (v[j]) {
				break;
			}
		}
		if (j == type_size[type]) {
			continue;
		}

		Con_Printf ("%s",name);
		l = strlen (name);
		while (l++ < 15) {
			Con_Printf(" ");
		}

		Con_Printf ("%s\n", PR_ValueString((etype_t)d->type, (eval_t *)v));
	}
}

/*
=============
ED_Write
 
For savegames
=============
*/
void ED_Write (FILE *f, edict_t *ed)
{
	ddef_t	*d;
	int		*v;
	int		i, j;
	char	*name;
	int		type;

	fprintf (f, "{\n");

	if (ed->e.free)
	{
		fprintf (f, "}\n");
		return;
	}

	for (i=1 ; i<progs->numfielddefs ; i++)
	{
		d = &pr_fielddefs[i];
		name = PR1_GetString(d->s_name);
		if (name[strlen(name)-2] == '_')
			continue;	// skip _x, _y, _z vars

		v = (int *)((char *)ed->v + d->ofs*4);

		// if the value is still all 0, skip the field
		type = d->type & ~DEF_SAVEGLOBAL;
		for (j=0 ; j<type_size[type] ; j++)
			if (v[j])
				break;
		if (j == type_size[type])
			continue;

		fprintf (f,"\"%s\" ",name);
		fprintf (f,"\"%s\"\n", PR_UglyValueString((etype_t)d->type, (eval_t *)v));
	}

	fprintf (f, "}\n");
}

void ED_PrintNum (int ent)
{
	ED_Print (EDICT_NUM(ent));
}

/*
=============
ED_PrintEdicts
 
For debugging, prints all the entities in the current server
=============
*/
void ED_PrintEdicts (void)
{
	int		i;

	Con_Printf ("%i entities\n", sv.num_edicts);
	for (i=0 ; i<sv.num_edicts ; i++)
	{
		Con_Printf ("\nEDICT %i:\n",i);
		ED_PrintNum (i);
	}
}

/*
=============
ED_PrintEdict_f
 
For debugging, prints a single edicy
=============
*/
void ED_PrintEdict_f (void)
{
	int		i;

	if (Cmd_Argc () != 2)
	{
		Con_Printf ("\nUsage:\nedict [num]\n");
		return;
	}

	i = Q_atoi (Cmd_Argv(1));
	if(i < 0 || i >= sv.num_edicts)
	{
		Con_Printf ("\nNo such edict: %i\n", i);
		return;
	}
	
	Con_Printf ("\n EDICT %i:\n",i);
	ED_PrintNum (i);
}

/*
=============
ED_Count
 
For debugging
=============
*/
void ED_Count (void)
{
	int		i;
	edict_t	*ent;
	int		active, models, solid, step;

	active = models = solid = step = 0;
	for (i=0 ; i<sv.num_edicts ; i++)
	{
		ent = EDICT_NUM(i);
		if (ent->e.free)
			continue;
		active++;
		if (ent->v->solid)
			solid++;
		if (ent->v->model)
			models++;
		if (ent->v->movetype == MOVETYPE_STEP)
			step++;
	}

	Con_Printf ("num_edicts:%3i\n", sv.num_edicts);
	Con_Printf ("active    :%3i\n", active);
	Con_Printf ("view      :%3i\n", models);
	Con_Printf ("touch     :%3i\n", solid);
	Con_Printf ("step      :%3i\n", step);

}

/*
==============================================================================
 
					ARCHIVING GLOBALS
 
FIXME: need to tag constants, doesn't really work
==============================================================================
*/

/*
=============
ED_WriteGlobals
=============
*/
void ED_WriteGlobals (FILE *f)
{
	ddef_t		*def;
	int			i;
	char		*name;
	int			type;

	fprintf (f,"{\n");
	for (i=0 ; i<progs->numglobaldefs ; i++)
	{
		def = &pr_globaldefs[i];
		type = def->type;
		if ( !(def->type & DEF_SAVEGLOBAL) )
			continue;
		type &= ~DEF_SAVEGLOBAL;

		if (type != ev_string
		        && type != ev_float
		        && type != ev_entity)
			continue;

		name = PR1_GetString(def->s_name);
		fprintf (f,"\"%s\" ", name);
		fprintf (f,"\"%s\"\n", PR_UglyValueString((etype_t)type, (eval_t *)&pr_globals[def->ofs]));
	}
	fprintf (f,"}\n");
}

/*
=============
ED_ParseGlobals
=============
*/
void ED_ParseGlobals (const char *data)
{
	char	keyname[64];
	ddef_t	*key;

	while (1)
	{
		// parse key
		data = COM_Parse (data);
		if (com_token[0] == '}')
			break;
		if (!data)
			SV_Error ("ED_ParseEntity: EOF without closing brace");

		strlcpy (keyname, com_token, sizeof(keyname));

		// parse value
		data = COM_Parse (data);
		if (!data)
			SV_Error ("ED_ParseEntity: EOF without closing brace");

		if (com_token[0] == '}')
			SV_Error ("ED_ParseEntity: closing brace without data");

		key = ED_FindGlobal (keyname);
		if (!key)
		{
			Con_Printf ("%s is not a global\n", keyname);
			continue;
		}

		if (!ED_ParseEpair ((void *)pr_globals, key, com_token))
			SV_Error ("ED_ParseGlobals: parse error");
	}
}

//============================================================================


/*
=============
ED_NewString
=============
*/
char *ED_NewString (char *string)
{
	char	*nuw, *new_p;
	int		i,l;

	l = strlen(string) + 1;
	nuw = (char *) Hunk_AllocName (l, "edstring");
	new_p = nuw;

	for (i=0 ; i< l ; i++)
	{
		if (string[i] == '\\' && i < l-1)
		{
			i++;
			if (string[i] == 'n')
				*new_p++ = '\n';
			else
				*new_p++ = '\\';
		}
		else
			*new_p++ = string[i];
	}

	return nuw;
}


/*
=============
ED_ParseEval
 
Can parse either fields or globals
returns false if error
=============
*/
qbool ED_ParseEpair (void *base, ddef_t *key, char *s)
{
	int		i;
	char	string[128];
	ddef_t	*def;
	char	*v, *w;
	void	*d;
	dfunction_t	*func;

	d = (void *)((int *)base + key->ofs);

	switch (key->type & ~DEF_SAVEGLOBAL)
	{
	case ev_string:
		PR1_SetString((string_t *)d, ED_NewString (s));
		break;

	case ev_float:
		*(float *)d = Q_atof (s);
		break;

	case ev_vector:
		strlcpy (string, s, sizeof(string));
		v = string;
		w = string;
		for (i=0 ; i<3 ; i++)
		{
			while (*v && *v != ' ')
				v++;
			*v = 0;
			((float *)d)[i] = Q_atof (w);
			w = v = v+1;
		}
		break;

	case ev_entity:
		*(int *)d = EDICT_TO_PROG(EDICT_NUM(Q_atoi (s)));
		break;

	case ev_field:
		def = ED_FindField (s);
		if (!def)
		{
			Con_Printf ("Can't find field %s\n", s);
			return false;
		}
		*(int *)d = G_INT(def->ofs);
		break;

	case ev_function:
		func = ED_FindFunction (s);
		if (!func)
		{
			Con_Printf ("Can't find function %s\n", s);
			return false;
		}
		*(func_t *)d = func - pr_functions;
		break;

	default:
		break;
	}
	return true;
}

/*
====================
ED_ParseEdict
 
Parses an edict out of the given string, returning the new position
ed should be a properly initialized empty edict.
Used for initial level load and for savegames.
====================
*/
const char *ED_ParseEdict (const char *data, edict_t *ent)
{
	ddef_t		*key;
	qbool		anglehack;
	qbool		init;
	char		keyname[256];

	init = false;

	// go through all the dictionary pairs
	while (1)
	{
		// parse key
		data = COM_Parse (data);
		if (com_token[0] == '}')
			break;
		if (!data)
			SV_Error ("ED_ParseEntity: EOF without closing brace");

		// anglehack is to allow QuakeEd to write single scalar angles
		// and allow them to be turned into vectors. (FIXME...)
		if (!strcmp(com_token, "angle"))
		{
			strlcpy (com_token, "angles", MAX_COM_TOKEN);
			anglehack = true;
		}
		else
			anglehack = false;

		// FIXME: change light to _light to get rid of this hack
		if (!strcmp(com_token, "light"))
			strlcpy (com_token, "light_lev", MAX_COM_TOKEN);	// hack for single light def

		strlcpy (keyname, com_token, sizeof(keyname));

		// parse value
		data = COM_Parse (data);
		if (!data)
			SV_Error ("ED_ParseEntity: EOF without closing brace");

		if (com_token[0] == '}')
			SV_Error ("ED_ParseEntity: closing brace without data");

		init = true;

		// keynames with a leading underscore are used for utility comments,
		// and are immediately discarded by quake
		if (keyname[0] == '_')
			continue;

		if (!strcmp (keyname, "alpha"))
		{
			ent->xv.alpha = bound(0.0f, atof (com_token), 1.0f);
			continue;
		}
		if (!strcmp(keyname, "colormod"))
		{
			float v[3];
			int ret = sscanf(com_token, "%f %f %f", &v[0], &v[1], &v[2]);
			if (ret == 3 && v[0] > 0.0f && v[1] > 0.0f && v[2] > 0.0f)
			{
				ent->xv.colourmod[0] = max(0.0f, v[0]);
				ent->xv.colourmod[1] = max(0.0f, v[1]);
				ent->xv.colourmod[2] = max(0.0f, v[2]);
			}
			continue;
		}

		key = ED_FindField (keyname);
		if (!key)
		{
			Con_Printf ("%s is not a field\n", keyname);
			continue;
		}

		if (anglehack)
		{
			char	temp[32];
			strlcpy (temp, com_token, sizeof(temp));
			snprintf (com_token, MAX_COM_TOKEN, "0 %s 0", temp);
		}

		if (!ED_ParseEpair ((void *)ent->v, key, com_token))
			SV_Error ("ED_ParseEdict: parse error");
	}

	if (!init)
		ent->e.free = true;

	return data;
}


/*
================
ED_LoadFromFile
 
The entities are directly placed in the array, rather than allocated with
ED_Alloc, because otherwise an error loading the map would have entity
number references out of order.
 
Creates a server's entity / program execution context by
parsing textual entity definitions out of an ent file.
 
Used for both fresh maps and savegame loads.  A fresh map would also need
to call ED_CallSpawnFunctions () to let the objects initialize themselves.
================
*/
void ED_LoadFromFile (const char *data)
{
	edict_t		*ent;
	int			inhibit;
	dfunction_t	*func;

	ent = NULL;
	inhibit = 0;
	pr_global_struct->time = sv.time;

	// parse ents
	while (1)
	{
		// parse the opening brace
		data = COM_Parse (data);
		if (!data)
			break;
		if (com_token[0] != '{')
			SV_Error ("ED_LoadFromFile: found %s when expecting {",com_token);

		if (!ent)
			ent = EDICT_NUM(0);
		else
			ent = ED_Alloc ();
		data = ED_ParseEdict (data, ent);

		// remove things from different skill levels or deathmatch
		if ((int)deathmatch.value)
		{
			if (((int)ent->v->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
			{
				ED_Free (ent);
				inhibit++;
				continue;
			}
		}
		else if ((current_skill == 0 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_EASY))
		         || (current_skill == 1 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_MEDIUM))
		         || (current_skill >= 2 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_HARD)) )
		{
			ED_Free (ent);
			inhibit++;
			continue;
		}

		//
		// immediately call spawn function
		//
		if (!ent->v->classname)
		{
			Con_Printf ("No classname for:\n");
			ED_Print (ent);
			ED_Free (ent);
			continue;
		}

		// look for the spawn function
		func = ED_FindFunction ( PR1_GetString(ent->v->classname) );

		if (!func)
		{
			Con_Printf ("No spawn function for:\n");
			ED_Print (ent);
			ED_Free (ent);
			continue;
		}

		pr_global_struct->self = EDICT_TO_PROG(ent);
		PR_ExecuteProgram (func - pr_functions);
		SV_FlushSignon();
	}

	Con_DPrintf ("%i entities inhibited\n", inhibit);
}
extern redirect_t	sv_redirected;
qbool PR_ConsoleCmd(void)
{
	if (mod_ConsoleCmd)
	{
		if (sv_redirected != RD_MOD)
		{
			pr_global_struct->time = sv.time;
			pr_global_struct->self = 0;
		}
		PR_ExecuteProgram (mod_ConsoleCmd);
		return (int) G_FLOAT(OFS_RETURN);
	}

	return false;
}

qbool PR1_ClientCmd(void)
{
	// ZQ_CLIENTCOMMAND extension
	if (GE_ClientCommand)
	{
		static char cmd_copy[128], args_copy[1024] /* Ouch! */;
		strlcpy (cmd_copy, Cmd_Argv(0), sizeof(cmd_copy));
		strlcpy (args_copy, Cmd_Args(), sizeof(args_copy));
		PR1_SetString (&((int *)pr_globals)[OFS_PARM0], cmd_copy);
		PR1_SetString (&((int *)pr_globals)[OFS_PARM1], args_copy);
		PR_ExecuteProgram (GE_ClientCommand);
		return G_FLOAT(OFS_RETURN) ? true : false;
	}

	if (mod_UserCmd)
	{
		static char cmd_copy[128];
		strlcpy (cmd_copy, Cmd_Argv(0), sizeof(cmd_copy));
		PR1_SetString (&((int *)pr_globals)[OFS_PARM0], cmd_copy);

		PR_ExecuteProgram (mod_UserCmd);
		return G_FLOAT(OFS_RETURN) ? true : false;
	}

	return false;
}


/*
===============
PR1_LoadProgs
===============
*/
void PF_clear_strtbl(void);

#ifdef WITH_NQPROGS
void PR_InitPatchTables (void)
{
	int i;

	if (pr_nqprogs)
	{
		memcpy (pr_globaloffsetpatch, pr_globaloffsetpatch_nq, sizeof(pr_globaloffsetpatch));
		for (i = 0; i < 106; i++)
		{
			pr_fieldoffsetpatch[i] = (i < 8) ? i : (i < 25) ? i + 1 :
				(i < 28) ? i + (102 - 25) : (i < 73) ? i - 2 :
				(i < 74) ? i + (105 - 73) : (i < 105) ? i - 3 : /* (i == 105) */ 8;
		}

		for (i=0 ; i<progs->numfielddefs ; i++)
			pr_fielddefs[i].ofs = PR_FIELDOFS(pr_fielddefs[i].ofs);
	}
	else
	{
		memset (pr_globaloffsetpatch, 0, sizeof(pr_globaloffsetpatch));

		for (i = 0; i < 106; i++)
			pr_fieldoffsetpatch[i] = i;
	}
}
#endif

void PR1_LoadProgs (void)
{
	int	i;
	char num[32];
	int filesize;

	// flush the non-C variable lookup cache
	for (i = 0; i < GEFV_CACHESIZE; i++)
		gefvCache[i].field[0] = 0;

	// clear pr_newstrtbl
	PF_clear_strtbl();

	progs = NULL;
#ifdef WITH_NQPROGS
	pr_nqprogs = false;

	// forced load of NQ progs.
	if (!progs && Cvar_Value("sv_forcenqprogs") && (progs = (dprograms_t *)FS_LoadHunkFile ("progs.dat", &filesize)))
		pr_nqprogs = true;
#endif

	if (!progs)
	{
		char name[MAX_OSPATH];
		snprintf(name, sizeof(name), "%s.dat", sv_progsname.string);
		progs = (dprograms_t *)FS_LoadHunkFile (name, &filesize);
	}
	if (!progs)
		progs = (dprograms_t *)FS_LoadHunkFile ("qwprogs.dat", &filesize);
	if (!progs)
		progs = (dprograms_t *)FS_LoadHunkFile ("spprogs.dat", &filesize);
#ifdef WITH_NQPROGS
	// low priority load of NQ progs.
	if (!progs && (progs = (dprograms_t *)FS_LoadHunkFile ("progs.dat", &filesize)))
		pr_nqprogs = true;
#endif

	if (!progs)
		SV_Error ("PR1_LoadProgs: couldn't load progs.dat");
	Con_DPrintf ("Programs occupy %iK.\n", filesize/1024);

#ifdef WITH_NQPROGS
	if (pr_nqprogs)
		Con_DPrintf ("NQ progs.\n");
#endif

	// add prog crc to the serverinfo
	snprintf (num, sizeof(num), "%i", CRC_Block ((byte *)progs, filesize));
	Info_SetValueForStarKey (svs.info, "*progs", num, MAX_SERVERINFO_STRING);

	// byte swap the header
	for (i = 0; i < (int) sizeof(*progs) / 4 ; i++)
		((int *)progs)[i] = LittleLong ( ((int *)progs)[i] );

	if (progs->version != PROG_VERSION)
		SV_Error ("qwprogs.dat has wrong version number (%i should be %i)", progs->version, PROG_VERSION);
	if (progs->crc != (pr_nqprogs ? NQ_PROGHEADER_CRC : PROGHEADER_CRC))
		SV_Error ("You must have the qwprogs.dat from QuakeWorld installed");

	pr_functions = (dfunction_t *)((byte *)progs + progs->ofs_functions);
	pr_strings = (char *)progs + progs->ofs_strings;
	pr_globaldefs = (ddef_t *)((byte *)progs + progs->ofs_globaldefs);
	pr_fielddefs = (ddef_t *)((byte *)progs + progs->ofs_fielddefs);
	pr_statements = (dstatement_t *)((byte *)progs + progs->ofs_statements);

	num_prstr = 0;

	pr_global_struct = (globalvars_t *)((byte *)progs + progs->ofs_globals);
	pr_globals = (float *)pr_global_struct;

	pr_edict_size = progs->entityfields * 4;

	// byte swap the lumps
	for (i = 0; i < progs->numstatements; i++)
	{
		pr_statements[i].op = LittleShort(pr_statements[i].op);
		pr_statements[i].a = LittleShort(pr_statements[i].a);
		pr_statements[i].b = LittleShort(pr_statements[i].b);
		pr_statements[i].c = LittleShort(pr_statements[i].c);
	}

	for (i = 0; i < progs->numfunctions; i++)
	{
		pr_functions[i].first_statement = LittleLong (pr_functions[i].first_statement);
		pr_functions[i].parm_start = LittleLong (pr_functions[i].parm_start);
		pr_functions[i].s_name = LittleLong (pr_functions[i].s_name);
		pr_functions[i].s_file = LittleLong (pr_functions[i].s_file);
		pr_functions[i].numparms = LittleLong (pr_functions[i].numparms);
		pr_functions[i].locals = LittleLong (pr_functions[i].locals);
	}

	for (i = 0; i < progs->numglobaldefs; i++)
	{
		pr_globaldefs[i].type = LittleShort (pr_globaldefs[i].type);
		pr_globaldefs[i].ofs = LittleShort (pr_globaldefs[i].ofs);
		pr_globaldefs[i].s_name = LittleLong (pr_globaldefs[i].s_name);
	}

	for (i = 0; i < progs->numfielddefs; i++)
	{
		pr_fielddefs[i].type = LittleShort (pr_fielddefs[i].type);
		if (pr_fielddefs[i].type & DEF_SAVEGLOBAL)
			SV_Error ("PR1_LoadProgs: pr_fielddefs[i].type & DEF_SAVEGLOBAL");
		pr_fielddefs[i].ofs = LittleShort (pr_fielddefs[i].ofs);
		pr_fielddefs[i].s_name = LittleLong (pr_fielddefs[i].s_name);
	}

	for (i = 0; i < progs->numglobals; i++)
		((int *)pr_globals)[i] = LittleLong (((int *)pr_globals)[i]);

	PR_InitBuiltins();
}

void PR1_InitProg(void)
{
	sv.game_edicts = (entvars_t*) Hunk_AllocName (MAX_EDICTS * pr_edict_size, "edicts");
	sv.max_edicts = MAX_EDICTS;
}

/*
===============
PR1_Init
===============
*/
void PR1_Init (void)
{
	Cvar_Register(&sv_progsname);
#ifdef WITH_NQPROGS
	Cvar_Register(&sv_forcenqprogs);
#endif

	Cmd_AddCommand ("edict", ED_PrintEdict_f);
	Cmd_AddCommand ("edicts", ED_PrintEdicts);
	Cmd_AddCommand ("edictcount", ED_Count);
	Cmd_AddCommand ("profile", PR_Profile_f);

	memset(pr_newstrtbl, 0, sizeof(pr_newstrtbl));
}

edict_t *EDICT_NUM(int n)
{
	if (n < 0 || n >= sv.max_edicts)
		SV_Error ("EDICT_NUM: bad number %i", n);
	return &sv.edicts[n];
}

int NUM_FOR_EDICT(edict_t *e)
{
	int		b;

	b = e->e.entnum;

	if (b < 0 || b >= sv.num_edicts)
		SV_Error ("NUM_FOR_EDICT: bad pointer");

	return b;
}

#endif // !CLIENTONLY


================================================
FILE: src/pr_exec.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

   
*/

#ifndef CLIENTONLY
#include "qwsvdef.h"
#include <limits.h>

typedef struct prstack_s
{
	int s;
	dfunction_t *f;
} prstack_t;

#define	MAX_STACK_DEPTH 32
prstack_t	pr_stack[MAX_STACK_DEPTH];
int			pr_depth;

#define	LOCALSTACK_SIZE 2048
int			localstack[LOCALSTACK_SIZE];
int			localstack_used;


qbool		pr_trace;
dfunction_t	*pr_xfunction;
int			pr_xstatement;


int			pr_argc;

char *pr_opnames[] =
    {
        "DONE",

        "MUL_F",
        "MUL_V",
        "MUL_FV",
        "MUL_VF",

        "DIV",

        "ADD_F",
        "ADD_V",

        "SUB_F",
        "SUB_V",

        "EQ_F",
        "EQ_V",
        "EQ_S",
        "EQ_E",
        "EQ_FNC",

        "NE_F",
        "NE_V",
        "NE_S",
        "NE_E",
        "NE_FNC",

        "LE",
        "GE",
        "LT",
        "GT",

        "INDIRECT",
        "INDIRECT",
        "INDIRECT",
        "INDIRECT",
        "INDIRECT",
        "INDIRECT",

        "ADDRESS",

        "STORE_F",
        "STORE_V",
        "STORE_S",
        "STORE_ENT",
        "STORE_FLD",
        "STORE_FNC",

        "STOREP_F",
        "STOREP_V",
        "STOREP_S",
        "STOREP_ENT",
        "STOREP_FLD",
        "STOREP_FNC",

        "RETURN",

        "NOT_F",
        "NOT_V",
        "NOT_S",
        "NOT_ENT",
        "NOT_FNC",

        "IF",
        "IFNOT",

        "CALL0",
        "CALL1",
        "CALL2",
        "CALL3",
        "CALL4",
        "CALL5",
        "CALL6",
        "CALL7",
        "CALL8",

        "STATE",

        "GOTO",

        "AND",
        "OR",

        "BITAND",
        "BITOR"
    };

char *PR_GlobalString (int ofs);
char *PR_GlobalStringNoContents (int ofs);


//=============================================================================

/*
=================
PR_PrintStatement
=================
*/
void PR_PrintStatement (dstatement_t *s)
{
	int i;

	if ( (unsigned)s->op < sizeof(pr_opnames)/sizeof(pr_opnames[0]))
	{

		Con_Printf ("%s ",  pr_opnames[s->op]);

		i = strlen(pr_opnames[s->op]);
		for ( ; i<10 ; i++)
			Con_Printf (" ");
	}

	if (s->op == OP_IF || s->op == OP_IFNOT)
		Con_Printf ("%sbranch %i",PR_GlobalString(s->a),s->b);
	else if (s->op == OP_GOTO)
	{
		Con_Printf ("branch %i",s->a);
	}
	else if ( (unsigned)(s->op - OP_STORE_F) < 6)
	{
		Con_Printf ("%s",PR_GlobalString(s->a));
		Con_Printf ("%s", PR_GlobalStringNoContents(s->b));
	}
	else
	{
		if (s->a)
			Con_Printf ("%s",PR_GlobalString(s->a));
		if (s->b)
			Con_Printf ("%s",PR_GlobalString(s->b));
		if (s->c)
			Con_Printf ("%s", PR_GlobalStringNoContents(s->c));
	}
	Con_Printf ("\n");
}

/*
============
PR_StackTrace
============
*/
void PR_StackTrace (void)
{
	dfunction_t *f;
	int i;

	if (pr_depth == 0)
	{
		Con_Printf ("<NO STACK>\n");
		return;
	}

	pr_stack[pr_depth].f = pr_xfunction;
	for (i=pr_depth ; i>0 ; i--)
	{
		f = pr_stack[i].f;

		if (!f)
			Con_Printf ("<NO FUNCTION>\n");
		else
			Con_Printf ("%12s : %s\n", PR1_GetString(f->s_file), PR1_GetString(f->s_name));
	}
}


/*
============
PR_Profile_f

============
*/
void PR_Profile_f (void)
{
	dfunction_t	*f, *best;
	int max;
	int num;
	int i;

	if (sv.state != ss_active)
		return;	

	num = 0;
	do
	{
		max = 0;
		best = NULL;
		for (i=0 ; i<progs->numfunctions ; i++)
		{
			f = &pr_functions[i];
			if (f->profile > max)
			{
				max = f->profile;
				best = f;
			}
		}
		if (best)
		{
			if (num < 10)
				Con_Printf ("%7i %s\n", best->profile, PR1_GetString(best->s_name));
			num++;
			best->profile = 0;
		}
	}
	while (best);
}


/*
============
PR_RunError

Aborts the currently executing function
============
*/
void PR_RunError (char *error, ...)
{
	va_list argptr;
	char string[1024];

	va_start (argptr,error);
	vsnprintf (string, sizeof(string), error, argptr);
	va_end (argptr);


	sv_error = true;

	PR_PrintStatement (pr_statements + pr_xstatement);
	PR_StackTrace ();
	Con_Printf ("%s\n", string);

	pr_depth = 0; // dump the stack so SV_Error can shutdown functions

	SV_Error ("Program error (PR_RunError)");
}

/*
====================
PR_EnterFunction

Returns the new program statement counter
====================
*/
int PR_EnterFunction (dfunction_t *f)
{
	int i, j, c, o;

	pr_stack[pr_depth].s = pr_xstatement;
	pr_stack[pr_depth].f = pr_xfunction;
	pr_depth++;
	if (pr_depth >= MAX_STACK_DEPTH)
		PR_RunError ("stack overflow");

	// save off any locals that the new function steps on
	c = f->locals;
	if (localstack_used + c > LOCALSTACK_SIZE)
		PR_RunError ("PR_ExecuteProgram: locals stack overflow\n");

	for (i=0 ; i < c ; i++)
		localstack[localstack_used+i] = ((int *)pr_globals)[f->parm_start + i];
	localstack_used += c;

	// copy parameters
	o = f->parm_start;
	for (i=0 ; i<f->numparms ; i++)
	{
		for (j=0 ; j<f->parm_size[i] ; j++)
		{
			((int *)pr_globals)[o] = ((int *)pr_globals)[OFS_PARM0+i*3+j];
			o++;
		}
	}

	pr_xfunction = f;
	return f->first_statement - 1; // offset the s++
}

/*
====================
PR_LeaveFunction
====================
*/
int PR_LeaveFunction (void)
{
	int i, c;

	if (pr_depth <= 0)
		SV_Error ("prog stack underflow");

	// restore locals from the stack
	c = pr_xfunction->locals;
	localstack_used -= c;
	if (localstack_used < 0)
		PR_RunError ("PR_ExecuteProgram: locals stack underflow\n");

	for (i=0 ; i < c ; i++)
		((int *)pr_globals)[pr_xfunction->parm_start + i] = localstack[localstack_used+i];

	// up stack
	pr_depth--;
	pr_xfunction = pr_stack[pr_depth].f;
	return pr_stack[pr_depth].s;
}

/*
============================================================================
PR_ExecuteProgram

The interpretation main loop
============================================================================
*/
void PR_ExecuteProgram (func_t fnum)
{
	eval_t *a = NULL, *b = NULL, *c = NULL;
	int s;
	dstatement_t *st = NULL;
	dfunction_t *f, *newf;
	int runaway;
	int i;
	edict_t *ed;
	int exitdepth;
	eval_t *ptr;

	if (!fnum || fnum >= progs->numfunctions)
	{
		if (pr_global_struct->self)
			ED_Print (PROG_TO_EDICT(pr_global_struct->self));
		SV_Error ("PR_ExecuteProgram: NULL function");
	}

	f = &pr_functions[fnum];

	runaway = 100000;
	pr_trace = false;

	// make a stack frame
	exitdepth = pr_depth;

	s = PR_EnterFunction (f);

	while (1)
	{
		s++; // next statement

		st = &pr_statements[s];
		a = (eval_t *)&pr_globals[st->a];
		b = (eval_t *)&pr_globals[st->b];
		c = (eval_t *)&pr_globals[st->c];

		if (--runaway == 0)
			PR_RunError ("runaway loop error");

		pr_xfunction->profile++;
		pr_xstatement = s;

		if (pr_trace)
			PR_PrintStatement (st);

		switch (st->op)
		{
		case OP_ADD_F:
			c->_float = a->_float + b->_float;
			break;
		case OP_ADD_V:
			c->vector[0] = a->vector[0] + b->vector[0];
			c->vector[1] = a->vector[1] + b->vector[1];
			c->vector[2] = a->vector[2] + b->vector[2];
			break;

		case OP_SUB_F:
			c->_float = a->_float - b->_float;
			break;
		case OP_SUB_V:
			c->vector[0] = a->vector[0] - b->vector[0];
			c->vector[1] = a->vector[1] - b->vector[1];
			c->vector[2] = a->vector[2] - b->vector[2];
			break;

		case OP_MUL_F:
			c->_float = a->_float * b->_float;
			break;
		case OP_MUL_V:
			c->_float = a->vector[0]*b->vector[0]
			            + a->vector[1]*b->vector[1]
			            + a->vector[2]*b->vector[2];
			break;
		case OP_MUL_FV:
			c->vector[0] = a->_float * b->vector[0];
			c->vector[1] = a->_float * b->vector[1];
			c->vector[2] = a->_float * b->vector[2];
			break;
		case OP_MUL_VF:
			c->vector[0] = b->_float * a->vector[0];
			c->vector[1] = b->_float * a->vector[1];
			c->vector[2] = b->_float * a->vector[2];
			break;

		case OP_DIV_F:
			c->_float = a->_float / b->_float;
			break;

		case OP_BITAND:
			c->_float = (int)a->_float & (int)b->_float;
			break;

		case OP_BITOR:
			c->_float = (int)a->_float | (int)b->_float;
			break;


		case OP_GE:
			c->_float = a->_float >= b->_float;
			break;
		case OP_LE:
			c->_float = a->_float <= b->_float;
			break;
		case OP_GT:
			c->_float = a->_float > b->_float;
			break;
		case OP_LT:
			c->_float = a->_float < b->_float;
			break;
		case OP_AND:
			c->_float = a->_float && b->_float;
			break;
		case OP_OR:
			c->_float = a->_float || b->_float;
			break;

		case OP_NOT_F:
			c->_float = !a->_float;
			break;
		case OP_NOT_V:
			c->_float = !a->vector[0] && !a->vector[1] && !a->vector[2];
			break;
		case OP_NOT_S:
			c->_float = !a->string || !*PR1_GetString(a->string);
			break;
		case OP_NOT_FNC:
			c->_float = !a->function;
			break;
		case OP_NOT_ENT:
			c->_float = (PROG_TO_EDICT(a->edict) == sv.edicts);
			break;

		case OP_EQ_F:
			c->_float = a->_float == b->_float;
			break;
		case OP_EQ_V:
			c->_float = (a->vector[0] == b->vector[0]) &&
			            (a->vector[1] == b->vector[1]) &&
			            (a->vector[2] == b->vector[2]);
			break;
		case OP_EQ_S:
			c->_float = !strcmp(PR1_GetString(a->string), PR1_GetString(b->string));
			break;
		case OP_EQ_E:
			c->_float = a->_int == b->_int;
			break;
		case OP_EQ_FNC:
			c->_float = a->function == b->function;
			break;


		case OP_NE_F:
			c->_float = a->_float != b->_float;
			break;
		case OP_NE_V:
			c->_float = (a->vector[0] != b->vector[0]) ||
			            (a->vector[1] != b->vector[1]) ||
			            (a->vector[2] != b->vector[2]);
			break;
		case OP_NE_S:
			c->_float = strcmp(PR1_GetString(a->string), PR1_GetString(b->string));
			break;
		case OP_NE_E:
			c->_float = a->_int != b->_int;
			break;
		case OP_NE_FNC:
			c->_float = a->function != b->function;
			break;

			//==================
		case OP_STORE_F:
		case OP_STORE_ENT:
		case OP_STORE_FLD:		// integers
		case OP_STORE_S:
		case OP_STORE_FNC:		// pointers
			b->_int = a->_int;
			break;
		case OP_STORE_V:
			b->vector[0] = a->vector[0];
			b->vector[1] = a->vector[1];
			b->vector[2] = a->vector[2];
			break;

		case OP_STOREP_F:
		case OP_STOREP_ENT:
		case OP_STOREP_FLD:		// integers
		case OP_STOREP_S:
		case OP_STOREP_FNC:		// pointers
			ptr = (eval_t *)((byte *)sv.game_edicts + b->_int);
			ptr->_int = a->_int;
			break;
		case OP_STOREP_V:
			ptr = (eval_t *)((byte *)sv.game_edicts + b->_int);
			ptr->vector[0] = a->vector[0];
			ptr->vector[1] = a->vector[1];
			ptr->vector[2] = a->vector[2];
			break;

		case OP_ADDRESS:
			ed = PROG_TO_EDICT(a->edict);
#ifdef PARANOID
			NUM_FOR_EDICT(ed);		// make sure it's in range
#endif
			if (ed == (edict_t *)sv.edicts && sv.state == ss_active)
				PR_RunError ("assignment to world entity");
			c->_int = (byte *)((int *)ed->v + PR_FIELDOFS(b->_int)) - (byte *)sv.game_edicts;
			break;

		case OP_LOAD_F:
		case OP_LOAD_FLD:
		case OP_LOAD_ENT:
		case OP_LOAD_S:
		case OP_LOAD_FNC:
			ed = PROG_TO_EDICT(a->edict);
#ifdef PARANOID
			NUM_FOR_EDICT(ed);		// make sure it's in range
#endif
			//need for checking 'cmd mmode player N', if N >= 0x10000000 =(signed)=> negative
			if (b->_int >= 0)
			{
				a = (eval_t *)((int *)ed->v + PR_FIELDOFS(b->_int));
				c->_int = a->_int;
			}
			else
				c->_int = 0;
			break;

		case OP_LOAD_V:
			ed = PROG_TO_EDICT(a->edict);
#ifdef PARANOID
			NUM_FOR_EDICT(ed);		// make sure it's in range
#endif
			a = (eval_t *)((int *)ed->v + PR_FIELDOFS(b->_int));
			c->vector[0] = a->vector[0];
			c->vector[1] = a->vector[1];
			c->vector[2] = a->vector[2];
			break;

			//==================

		case OP_IFNOT:
			if (!a->_int)
				s += st->b - 1;	// offset the s++
			break;

		case OP_IF:
			if (a->_int)
				s += st->b - 1;	// offset the s++
			break;

		case OP_GOTO:
			s += st->a - 1;	// offset the s++
			break;

		case OP_CALL0:
		case OP_CALL1:
		case OP_CALL2:
		case OP_CALL3:
		case OP_CALL4:
		case OP_CALL5:
		case OP_CALL6:
		case OP_CALL7:
		case OP_CALL8:
			pr_argc = st->op - OP_CALL0;
			if (!a->function)
				PR_RunError ("NULL function");

			newf = &pr_functions[a->function];

			if (newf->first_statement < 0)
			{	// negative statements are built in functions
				i = -newf->first_statement;
				if (i >= pr_numbuiltins)
					PR_RunError ("Bad builtin call number");
				pr_builtins[i] ();
				break;
			}

			s = PR_EnterFunction (newf);

			break;

		case OP_DONE:
		case OP_RETURN:
			pr_globals[OFS_RETURN] = pr_globals[st->a];
			pr_globals[OFS_RETURN+1] = pr_globals[st->a+1];
			pr_globals[OFS_RETURN+2] = pr_globals[st->a+2];

			s = PR_LeaveFunction ();
			if (pr_depth == exitdepth)
				return;		// all done
			break;

		case OP_STATE:
			ed = PROG_TO_EDICT(pr_global_struct->self);
			ed->v->nextthink = pr_global_struct->time + 0.1;
			if (a->_float != ed->v->frame)
			{
				ed->v->frame = a->_float;
			}
			ed->v->think = b->function;
			break;

		default:
			PR_RunError ("Bad opcode %i", st->op);
		}
	}

}

//=============================================================================

char *pr_newstrtbl[MAX_PRSTR];
char *pr_strtbl[MAX_PRSTR];
int num_prstr;

char *PR1_GetString(int num)
{
	if (num < 0)
	{
		//Con_DPrintf("GET:%d == %s\n", num, pr_strtbl[-num]);
		num = -num;
		if (num >= 2 * MAX_PRSTR)
		{
			Con_Printf("PR1_GetString: num = %d\n", num);// May be will be better to generate PR_RunError?
			return NULL;
		}
		if (num >= MAX_PRSTR)
			return pr_newstrtbl[num - MAX_PRSTR];

		return pr_strtbl[num];
	}
	return pr_strings + num;
}

void PR1_SetString(string_t* address, char* s)
{
	int i;

	if (!address) {
		return;
	}

	if (!s || !s[0]) {
		*address = 0;
		return;
	}

	if (s - pr_strings < 0 || s - pr_strings > INT_MAX) {
		for (i = 0; i < num_prstr; i++) {
			if (pr_strtbl[i] == s) {
				*address = -i;
				return;
			}
		}

		if (num_prstr + 1 >= MAX_PRSTR) {
			Sys_Error("MAX_PRSTR");
		}

		pr_strtbl[++num_prstr] = s;
		//Con_DPrintf("SET:%d == %s\n", -num_prstr, s);
		*address = -num_prstr;
	}
	else {
		*address = (int)(s - pr_strings);
	}
}

/*
==============
PR_SetTmpString

temp strings are used for qc function parameters
many calls to function could cause strtbl overflow
==============
*/

void PR_SetTmpString(string_t* target, const char *s)
{
	static int index1;
	static char tmp[8][2048];

	index1 = (index1 + 1) & 7;

	strlcpy(tmp[index1], s, sizeof(tmp[index1]));
	PR1_SetString(target, tmp[index1]);
}

//=============================================================================

void PR1_GameClientDisconnect(int spec)
{
	if (spec)
	{
		if (mod_SpectatorDisconnect)
			PR_ExecuteProgram(mod_SpectatorDisconnect);
	}
	else
	{
		PR_ExecuteProgram(PR_GLOBAL(ClientDisconnect));
	}
}

//=============================================================================

void PR1_GameClientConnect(int spec)
{
	if (spec)
	{
		if (mod_SpectatorConnect)
			PR_ExecuteProgram(mod_SpectatorConnect);
	}
	else
	{
		PR_ExecuteProgram(PR_GLOBAL(ClientConnect));
	}
}

//=============================================================================

void PR1_GamePutClientInServer(int spec)
{
	if (spec)
	{
		// none...
	}
	else
	{
		PR_ExecuteProgram(PR_GLOBAL(PutClientInServer));
	}
}

//=============================================================================

void PR1_GameClientPreThink(int spec)
{
	if (spec)
	{
		// none...
	}
	else
	{
		PR_ExecuteProgram(PR_GLOBAL(PlayerPreThink));
	}
}

//=============================================================================

void PR1_GameClientPostThink(int spec)
{
	if (spec)
	{
		if (mod_SpectatorThink)
			PR_ExecuteProgram(mod_SpectatorThink);
	}
	else
	{
		PR_ExecuteProgram(PR_GLOBAL(PlayerPostThink));
	}
}

//=============================================================================

qbool PR1_ClientSay(int isTeamSay, char *message)
{
	qbool ret = false;

	if (mod_ChatMessage)
	{
		int j;

		// remove surrounding " if any.
		if (message[0] == '"' && (j = (int)strlen(message)) > 2 && message[j-1] == '"')
		{
			message++;  // skip opening ".
			message[max(0,(int)strlen(message)-1)] = 0;   // truncate closing ".
		}

		PR_SetTmpString(&G_INT(OFS_PARM0), message);
		G_FLOAT(OFS_PARM1) = (float)isTeamSay;

		PR_ExecuteProgram(mod_ChatMessage);

		ret = !!G_FLOAT(OFS_RETURN);
	}

	return ret;
}

//=============================================================================

void PR1_PausedTic(float duration)
{
	if (GE_PausedTic)
	{
		G_FLOAT(OFS_PARM0) = duration;
		PR_ExecuteProgram (GE_PausedTic);
	}
}

//=============================================================================

void PR1_UnLoadProgs(void)
{
	if (progs)
	{
		// FIXME: There should be done alot of variables reseting...

#ifdef WITH_NQPROGS
		pr_nqprogs = false;
#endif
		progs = NULL;
	}
}

#endif // !CLIENTONLY


================================================
FILE: src/progdefs.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef __PROGDEFS_H__
#define __PROGDEFS_H__

/* file generated by qcc, do not modify */

typedef struct
{	int	pad[28];
	int	self;
	int	other;
	int	world;
	float	time;
	float	frametime;
	int	newmis;
	float	force_retouch;
	string_t	mapname;
	float	serverflags;
	float	total_secrets;
	float	total_monsters;
	float	found_secrets;
	float	killed_monsters;
	float	parm1;
	float	parm2;
	float	parm3;
	float	parm4;
	float	parm5;
	float	parm6;
	float	parm7;
	float	parm8;
	float	parm9;
	float	parm10;
	float	parm11;
	float	parm12;
	float	parm13;
	float	parm14;
	float	parm15;
	float	parm16;
	vec3_t	v_forward;
	vec3_t	v_up;
	vec3_t	v_right;
	float	trace_allsolid;
	float	trace_startsolid;
	float	trace_fraction;
	vec3_t	trace_endpos;
	vec3_t	trace_plane_normal;
	float	trace_plane_dist;
	int	trace_ent;
	float	trace_inopen;
	float	trace_inwater;
	int	msg_entity;
	func_t	main;
	func_t	StartFrame;
	func_t	PlayerPreThink;
	func_t	PlayerPostThink;
	func_t	ClientKill;
	func_t	ClientConnect;
	func_t	PutClientInServer;
	func_t	ClientDisconnect;
	func_t	SetNewParms;
	func_t	SetChangeParms;
} globalvars_t;

typedef struct
{
	float	modelindex;
	vec3_t	absmin;
	vec3_t	absmax;
	float	ltime;
	float	lastruntime;
	float	movetype;
	float	solid;
	vec3_t	origin;
	vec3_t	oldorigin;
	vec3_t	velocity;
	vec3_t	angles;
	vec3_t	avelocity;
	string_t	classname;
	string_t	model;
	float	frame;
	float	skin;
	float	effects;
	vec3_t	mins;
	vec3_t	maxs;
	vec3_t	size;
	func_t	touch;
	func_t	use;
	func_t	think;
	func_t	blocked;
	float	nextthink;
	int	groundentity;
	float	health;
	float	frags;
	float	weapon;
	string_t	weaponmodel;
	float	weaponframe;
	float	currentammo;
	float	ammo_shells;
	float	ammo_nails;
	float	ammo_rockets;
	float	ammo_cells;
	float	items;
	float	takedamage;
	int	chain;
	float	deadflag;
	vec3_t	view_ofs;
	float	button0;
	float	button1;
	float	button2;
	float	impulse;
	float	fixangle;
	vec3_t	v_angle;
	string_t	netname;
	int	enemy;
	float	flags;
	float	colormap;
	float	team;
	float	max_health;
	float	teleport_time;
	float	armortype;
	float	armorvalue;
	float	waterlevel;
	float	watertype;
	float	ideal_yaw;
	float	yaw_speed;
	int	aiment;
	int	goalentity;
	float	spawnflags;
	string_t	target;
	string_t	targetname;
	float	dmg_take;
	float	dmg_save;
	int	dmg_inflictor;
	int	owner;
	vec3_t	movedir;
	string_t	message;
	float	sounds;
	string_t	noise;
	string_t	noise1;
	string_t	noise2;
	string_t	noise3;
} entvars_t;

#define PROGHEADER_CRC 54730

#endif /* !__PROGDEFS_H__ */


================================================
FILE: src/progs.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef __PROGS_H__
#define __PROGS_H__

#include "pr_comp.h" // defs shared with qcc
#include "progdefs.h" // generated by program cdefs

typedef union eval_s
{
	string_t	string;
	float		_float;
	float		vector[3];
	func_t		function;
	int		_int;
	int		edict;
} eval_t;

struct edict_s; // forward referecnce for link_t

typedef struct link_s
{
	struct edict_s *ed;

	struct link_s	*prev, *next;
} link_t;

#define	EDICT_FROM_AREA(l)	((l)->ed)

#define	MAX_ENT_LEAFS	16

typedef struct sv_edict_s
{
	qbool		free;
	link_t		area;			// linked to a division node or leaf

	int         entnum;

	int			num_leafs;
	short		leafnums[MAX_ENT_LEAFS];

	entity_state_t	baseline;

	float		freetime;		// sv.time when the object was freed
	double		lastruntime;	// sv.time when SV_RunEntity was last called for this edict (Tonik)
} sv_edict_t;

typedef struct
{
	float	alpha;			// 0 = opaque, 1 = opaque, 0 < x < 1 translucent
	float	colourmod[3];	// r,g,b [0.0 .. 1.0], > 1 overbright
} ext_entvars_t;

typedef struct edict_s
{
	sv_edict_t	e;			// server side part of the edict_t
	ext_entvars_t	xv;
	entvars_t	*v;			// C exported fields from progs
} edict_t;

//============================================================================

extern	dprograms_t	*progs;
extern	dfunction_t	*pr_functions;
extern	char		*pr_strings;
extern	ddef_t		*pr_globaldefs;
extern	ddef_t		*pr_fielddefs;
extern	dstatement_t	*pr_statements;
extern	globalvars_t	*pr_global_struct;
extern	float		*pr_globals;	// same as pr_global_struct

extern	int         pr_edict_size;	// in bytes
extern	cvar_t      sv_progsname; 
#ifdef WITH_NQPROGS
extern	cvar_t      sv_forcenqprogs;
#endif

//============================================================================

#ifdef WITH_NQPROGS

extern	qbool			pr_nqprogs;

extern	int pr_fieldoffsetpatch[106];
extern	int pr_globaloffsetpatch[62];

#define PR_FIELDOFS(i) ((unsigned int)(i) > 105 ? (i) : pr_fieldoffsetpatch[i])
#define PR_GLOBAL(field) (((globalvars_t *)((byte *)pr_global_struct + \
	pr_globaloffsetpatch[((int *)&((globalvars_t *)0)->field - (int *)0) - 28]))->field)

void NQP_Reset (void);

#else	// !WITH_NQPROGS

#define pr_nqprogs 0
#define PR_FIELDOFS(i) (i)
#define PR_GLOBAL(field) pr_global_struct->field
#define NQP_Reset()

#endif

//============================================================================

void PR_Init (void);

void PR_ExecuteProgram (func_t fnum);
void PR_InitPatchTables (void);	// NQ progs support

void PR_Profile_f (void);

void ED_ClearEdict (edict_t *e);
edict_t *ED_Alloc (void);
void ED_Free (edict_t *ed);

char *ED_NewString (char *string);
// returns a copy of the string allocated from the server's string heap

void ED_Print (edict_t *ed);
void ED_Write (FILE *f, edict_t *ed);
const char *ED_ParseEdict (const char *data, edict_t *ent);

void ED_WriteGlobals (FILE *f);
void ED_ParseGlobals (const char *data);

void ED_LoadFromFile (const char *data);

edict_t *EDICT_NUM(int n);
int NUM_FOR_EDICT(edict_t *e);

#define	NEXT_EDICT(e) ((edict_t *)((byte *)(e) + sizeof(edict_t)))

#define	EDICT_TO_PROG(e) ((byte *)(e)->v - (byte *)sv.game_edicts)
#define PROG_TO_EDICT(e) (&sv.edicts[(e)/pr_edict_size])

//============================================================================

#define	G_FLOAT(o) (pr_globals[o])
#define	G_INT(o) (*(int *)&pr_globals[o])
#define	G_EDICT(o) (&sv.edicts[(*(int *)&pr_globals[o])/pr_edict_size])
#define G_EDICTNUM(o) NUM_FOR_EDICT(G_EDICT(o))
#define	G_VECTOR(o) (&pr_globals[o])
#define	G_STRING(o) (PR1_GetString(*(string_t *)&pr_globals[o]))
#define	G_FUNCTION(o) (*(func_t *)&pr_globals[o])

#define	E_FLOAT(e,o) (((float*)e->v)[o])
#define	E_INT(e,o) (*(int *)&((float*)e->v)[o])
#define	E_VECTOR(e,o) (&((float*)e->v)[o])
#define	E_STRING(e,o) (PR1_GetString(*(string_t *)&((float*)e->v)[PR_FIELDOFS(o)]))

typedef void		(*builtin_t) (void);
extern	builtin_t	*pr_builtins;
extern	int		pr_numbuiltins;

extern	int		pr_argc;

extern	qbool	pr_trace;
extern	dfunction_t	*pr_xfunction;
extern	int		pr_xstatement;

extern func_t mod_ConsoleCmd, mod_UserCmd;
extern func_t mod_UserInfo_Changed, mod_localinfoChanged;
extern func_t mod_ChatMessage;
extern func_t mod_SpectatorConnect, mod_SpectatorDisconnect, mod_SpectatorThink;
extern func_t GE_ClientCommand, GE_PausedTic, GE_ShouldPause;

extern int fofs_items2; // ZQ_ITEMS2 extension
extern int fofs_vw_index;	// ZQ_VWEP
extern int fofs_movement;
extern int fofs_gravity, fofs_maxspeed;
extern int fofs_hideentity;
extern int fofs_trackent;
extern int fofs_visibility;
extern int fofs_hide_players;
extern int fofs_teleported;

#define EdictFieldFloat(ed, fieldoffset) ((eval_t *)((byte *)(ed)->v + (fieldoffset)))->_float
#define EdictFieldVector(ed, fieldoffset) ((eval_t *)((byte *)(ed)->v + (fieldoffset)))->vector

void PR_RunError (char *error, ...);

void ED_PrintEdicts (void);
void ED_PrintNum (int ent);

eval_t *PR1_GetEdictFieldValue(edict_t *ed, char *field);

int ED1_FindFieldOffset (char *field);

//
// PR Strings stuff
//
#define MAX_PRSTR 1024

extern char *pr_strtbl[MAX_PRSTR];
extern char *pr_newstrtbl[MAX_PRSTR];
extern int num_prstr;

char *PR1_GetString(int num);
void PR1_SetString(string_t* address, char* s);
void PR_SetTmpString(string_t* address, const char *s);

void PR1_LoadProgs (void);
void PR1_InitProg(void);
void PR1_Init(void);

#define PR1_GameShutDown()	// PR1 does not really have it.
void PR1_UnLoadProgs(void);

void PR1_GameClientDisconnect(int spec);
void PR1_GameClientConnect(int spec);
void PR1_GamePutClientInServer(int spec);
void PR1_GameClientPreThink(int spec);
void PR1_GameClientPostThink(int spec);
qbool PR1_ClientSay(int isTeamSay, char *message);
void PR1_PausedTic(float duration);
qbool PR1_ClientCmd(void);

#define PR1_GameSetChangeParms() PR_ExecuteProgram(PR_GLOBAL(SetChangeParms))
#define PR1_GameSetNewParms() PR_ExecuteProgram(PR_GLOBAL(SetNewParms))
#define PR1_GameStartFrame() PR_ExecuteProgram (PR_GLOBAL(StartFrame))
#define PR1_ClientKill() PR_ExecuteProgram (PR_GLOBAL(ClientKill))
#define PR1_UserInfoChanged(after) (0) // PR1 does not really have it,
                                  // we have mod_UserInfo_Changed but it is slightly different.
#define PR1_LoadEnts ED_LoadFromFile
#define PR1_EdictThink PR_ExecuteProgram
#define PR1_EdictTouch PR_ExecuteProgram
#define PR1_EdictBlocked PR_ExecuteProgram

#ifndef USE_PR2
	#define PR_LoadProgs PR1_LoadProgs
	#define PR_InitProg PR1_InitProg
	#define PR_GameShutDown PR1_GameShutDown
	#define PR_UnLoadProgs PR1_UnLoadProgs

	#define PR_Init PR1_Init
	//#define PR_GetString PR1_GetString
	//#define PR_SetString PR1_SetString
	#define PR_GetEntityString PR1_GetString
	#define PR_SetEntityString(ent, target, value) PR1_SetString(&target, value)
	#define PR_SetGlobalString(target, value) PR1_SetString(&target, value)
	#define ED_FindFieldOffset ED1_FindFieldOffset
	#define PR_GetEdictFieldValue PR1_GetEdictFieldValue

	#define PR_GameClientDisconnect PR1_GameClientDisconnect
	#define PR_GameClientConnect PR1_GameClientConnect
	#define PR_GamePutClientInServer PR1_GamePutClientInServer
	#define PR_GameClientPreThink PR1_GameClientPreThink
	#define PR_GameClientPostThink PR1_GameClientPostThink
	#define PR_ClientSay PR1_ClientSay
	#define PR_PausedTic PR1_PausedTic
	#define PR_ClientCmd PR1_ClientCmd

	#define PR_GameSetChangeParms PR1_GameSetChangeParms
	#define PR_GameSetNewParms PR1_GameSetNewParms
	#define PR_GameStartFrame(isBotFrame) { if (!isBotFrame) { PR1_GameStartFrame(); } }
	#define PR_ClientKill PR1_ClientKill
	#define PR_UserInfoChanged PR1_UserInfoChanged
	#define PR_LoadEnts PR1_LoadEnts
	#define PR_EdictThink PR1_EdictThink
	#define PR_EdictTouch PR1_EdictTouch
	#define PR_EdictBlocked PR1_EdictBlocked

	#define PR_ClearEdict(ent)
#endif

// pr_cmds.c
void PR_InitBuiltins (void);

#endif /* !__PROGS_H__ */


================================================
FILE: src/q_platform.h
================================================
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#ifndef __Q_PLATFORM_H
#define __Q_PLATFORM_H

// this is for determining if we have an asm version of a C function
#define idx64 0

#ifdef Q3_VM

#define idx386 0
#define idppc 0
#define idppc_altivec 0
#define idsparc 0

#else

#if (defined _M_IX86 || defined __i386__) && !defined(C_ONLY)
#define idx386 1
#else
#define idx386 0
#endif

#if (defined(powerc) || defined(powerpc) || defined(ppc) || \
	defined(__ppc) || defined(__ppc__)) && !defined(C_ONLY)
#define idppc 1
#if defined(__VEC__)
#define idppc_altivec 1
#ifdef MACOS_X  // Apple's GCC does this differently than the FSF.
#define VECCONST_UINT8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
	(vector unsigned char) (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
#else
#define VECCONST_UINT8(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
	(vector unsigned char) {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p}
#endif
#else
#define idppc_altivec 0
#endif
#else
#define idppc 0
#define idppc_altivec 0
#endif

#if defined(__sparc__) && !defined(C_ONLY)
#define idsparc 1
#else
#define idsparc 0
#endif

#endif

#ifndef __ASM_I386__ // don't include the C bits if included from qasm.h

// for windows fastcall option
#define QDECL

//================================================================= WIN64/32 ===

#if defined(_WIN64) || defined(__WIN64__)

#undef idx64
#define idx64 1

#undef QDECL
#define QDECL __cdecl

#if defined( _MSC_VER )
#define OS_STRING "win_msvc64"
#elif defined __MINGW64__
#define OS_STRING "win_mingw64"
#else
#define OS_STRING "win64"
#endif

#define ID_INLINE static __inline
#define PATH_SEPARATOR "\\"

#if defined( __WIN64__ ) 
#define ARCH_STRING "x86_64"
#elif defined _M_ALPHA
#define ARCH_STRING "AXP"
#endif

#define Q3_LITTLE_ENDIAN

#define DLEXT "dll"

#elif defined(_WIN32) || defined(__WIN32__)

#undef QDECL
#define QDECL __cdecl

#if defined( _MSC_VER )
#define OS_STRING "win_msvc"
#elif defined __MINGW32__
#define OS_STRING "win_mingw"
#endif

#define ID_INLINE static __inline
#define PATH_SEPARATOR "\\"

#if defined( _M_IX86 ) || defined( __i386__ )
#define ARCH_STRING "x86"
#elif defined _M_ALPHA
#define ARCH_STRING "AXP"
#endif

#define Q3_LITTLE_ENDIAN

#define DLEXT "dll"

#endif

//============================================================== MAC OS X ===

#if defined(MACOS_X) || defined(__APPLE_CC__)

// make sure this is defined, just for sanity's sake...
#ifndef MACOS_X
#define MACOS_X
#endif

#define OS_STRING "macosx"
#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#ifdef __ppc__
#define ARCH_STRING "ppc"
#define Q3_BIG_ENDIAN
#elif defined __i386__
#define ARCH_STRING "i386"
#define Q3_LITTLE_ENDIAN
#elif defined __x86_64__
#undef idx64
#define idx64 1
#define ARCH_STRING "x86_64"
#define Q3_LITTLE_ENDIAN
#endif

#define DLEXT "dylib"

#endif

//================================================================= LINUX ===

#if defined(__linux__) || defined(__FreeBSD_kernel__) || defined(ANDROID) || defined(__ANDROID__)

#include <endian.h>

#if defined(ANDROID) || defined(__ANDROID__)
#define OS_STRING "android"
#elif defined(__linux__)
#define OS_STRING "linux"
#else
#define OS_STRING "kFreeBSD"
#endif

#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#if defined __i386__
#define ARCH_STRING "i386"
#elif defined __x86_64__
#undef idx64
#define idx64 1
#define ARCH_STRING "x86_64"
#elif defined __powerpc64__
#define ARCH_STRING "ppc64"
#elif defined __powerpc__
#define ARCH_STRING "ppc"
#elif defined __s390__
#define ARCH_STRING "s390"
#elif defined __s390x__
#define ARCH_STRING "s390x"
#elif defined __ia64__
#define ARCH_STRING "ia64"
#elif defined __alpha__
#define ARCH_STRING "alpha"
#elif defined __sparc__
#define ARCH_STRING "sparc"
#elif defined __arm__
#define ARCH_STRING "arm"
#elif defined __cris__
#define ARCH_STRING "cris"
#elif defined __hppa__
#define ARCH_STRING "hppa"
#elif defined __mips__
#define ARCH_STRING "mips"
#elif defined __sh__
#define ARCH_STRING "sh"
#endif

#if __FLOAT_WORD_ORDER == __BIG_ENDIAN
#define Q3_BIG_ENDIAN
#else
#define Q3_LITTLE_ENDIAN
#endif

#define DLEXT "so"

#endif

//=================================================================== BSD ===

#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)

#include <sys/types.h>
#include <machine/endian.h>

#ifndef __BSD__
  #define __BSD__
#endif

#if defined(__FreeBSD__)
#define OS_STRING "freebsd"
#elif defined(__OpenBSD__)
#define OS_STRING "openbsd"
#elif defined(__NetBSD__)
#define OS_STRING "netbsd"
#endif

#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#ifdef __i386__
#define ARCH_STRING "i386"
#elif defined __amd64__
#undef idx64
#define idx64 1
#define ARCH_STRING "amd64"
#elif defined __axp__
#define ARCH_STRING "alpha"
#endif

#if BYTE_ORDER == BIG_ENDIAN
#define Q3_BIG_ENDIAN
#else
#define Q3_LITTLE_ENDIAN
#endif

#define DLEXT "so"

#endif

//================================================================= SUNOS ===

#ifdef __sun

#include <stdint.h>
#include <sys/byteorder.h>

#define OS_STRING "solaris"
#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#ifdef __i386__
#define ARCH_STRING "i386"
#elif defined __sparc
#define ARCH_STRING "sparc"
#endif

#if defined( _BIG_ENDIAN )
#define Q3_BIG_ENDIAN
#elif defined( _LITTLE_ENDIAN )
#define Q3_LITTLE_ENDIAN
#endif

#define DLEXT "so"

#endif

//================================================================== IRIX ===

#ifdef __sgi

#define OS_STRING "irix"
#define ID_INLINE static __inline
#define PATH_SEPARATOR "/"

#define ARCH_STRING "mips"

#define Q3_BIG_ENDIAN // SGI's MIPS are always big endian

#define DLEXT "so"

#endif

//=============================================================== MORPHOS ===

#ifdef __MORPHOS__

#define OS_STRING "morphos"
#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#define ARCH_STRING "ppc"

#define Q3_BIG_ENDIAN

#define DLEXT "so"

#endif

#ifdef __CYGWIN__
#define OS_STRING "cygwin"
#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#define ARCH_STRING "x86"

#define Q3_LITTLE_ENDIAN

#define DLEXT "dll"

#endif

#ifdef __DJGPP__
#define OS_STRING "msdos"
#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#define ARCH_STRING "dos"

#define Q3_LITTLE_ENDIAN

#define DLEXT "dll"
#endif


#ifdef FTE_TARGET_WEB
#define OS_STRING "emscripten"
#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#define ARCH_STRING "web"

#define Q3_LITTLE_ENDIAN

#define DLEXT "so"
#endif

#ifdef NACL
#define OS_STRING "nacl"
#define ID_INLINE static inline
#define PATH_SEPARATOR "/"

#define ARCH_STRING "web"

#define Q3_LITTLE_ENDIAN

#define DLEXT "so"
#endif

//================================================================== Q3VM ===

#ifdef Q3_VM

#define OS_STRING "q3vm"
#define ID_INLINE static
#define PATH_SEPARATOR "/"

#define ARCH_STRING "bytecode"

#define DLEXT "qvm"

#endif

//===========================================================================

//catch missing defines in above blocks
#if !defined( OS_STRING )
#define ARCH_STRING "unknown"
//#error "Operating system not supported"
#endif

#if !defined( ARCH_STRING )
#define ARCH_STRING "unk"
//#error "Architecture not supported"
#endif

#ifndef ID_INLINE
#define ID_INLINE static
//#error "ID_INLINE not defined"
#endif

#ifndef PATH_SEPARATOR
#define PATH_SEPARATOR "/"
//#error "PATH_SEPARATOR not defined"
#endif

#ifndef DLEXT
#define DLEXT "so"
//#error "DLEXT not defined"
#endif

/*
//endianness
short ShortSwap (short l);
int LongSwap (int l);
float FloatSwap (const float *f);

#if defined( Q3_BIG_ENDIAN ) && defined( Q3_LITTLE_ENDIAN )
#error "Endianness defined as both big and little"
#elif defined( Q3_BIG_ENDIAN )

#define LittleShort(x) ShortSwap(x)
#define LittleLong(x) LongSwap(x)
#define LittleFloat(x) FloatSwap(&x)
#define BigShort
#define BigLong
#define BigFloat

#elif defined( Q3_LITTLE_ENDIAN )

#define LittleShort
#define LittleLong
#define LittleFloat
#define BigShort(x) ShortSwap(x)
#define BigLong(x) LongSwap(x)
#define BigFloat(x) FloatSwap(&x)

#elif defined( Q3_VM )

#define LittleShort
#define LittleLong
#define LittleFloat
#define BigShort
#define BigLong
#define BigFloat

#else
#error "Endianness not defined"
#endif
*/


//platform string
#ifdef NDEBUG
#define PLATFORM_STRING OS_STRING "-" ARCH_STRING
#else
#define PLATFORM_STRING OS_STRING "-" ARCH_STRING "-debug"
#endif

#endif

#endif


================================================
FILE: src/q_shared.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: q_shared.c,v 1.27 2007-09-15 21:00:32 disconn3ct Exp $

*/
// q_shared.c -- functions shared by all subsystems

#include "quakedef.h"
#include "q_shared.h"
#include "r_framestats.h"

/*
============================================================================
                        LIBRARY REPLACEMENT FUNCTIONS
============================================================================
*/

int Q_atoi (const char *str)
{
	int val, sign, c;

	if (!str) return 0;

	for (; *str && *str <= ' '; str++);

	if (*str == '-') {
		sign = -1;
		str++;
	} else {
		if (*str == '+')
			str++;

		sign = 1;
	}

	val = 0;

	// check for hex
	if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') ) {
		str += 2;
		while (1) {
			c = *str++;
			if (c >= '0' && c <= '9')
				val = (val << 4) + c - '0';
			else if (c >= 'a' && c <= 'f')
				val = (val << 4) + c - 'a' + 10;
			else if (c >= 'A' && c <= 'F')
				val = (val << 4) + c - 'A' + 10;
			else
				return val*sign;
		}
	}

	// check for character
	if (str[0] == '\'')
		return sign * str[1];

	// assume decimal
	while (1) {
		c = *str++;
		if (c <'0' || c > '9')
			return val*sign;
		val = val * 10 + c - '0';
	}

	return 0;
}

float Q_atof (const char *str)
{
	double val;
	int sign, c, decimal, total;

	if (!str) return 0;

	for (; *str && *str <= ' '; str++); // VVD: from MVDSV :-)
/*
	//R00k - qbism// 1999-12-27 ATOF problems with leading spaces fix by Maddes
	while ((*str) && (*str<=' '))
	{
		str++;
	}
	//R00k - qbism// 1999-12-27 ATOF problems with leading spaces fix by Maddes
*/
	if (*str == '-') {
		sign = -1;
		str++;
	} else {
		if (*str == '+')
			str++;

		sign = 1;
	}

	val = 0;

	// check for hex
	if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') ) {
		str += 2;
		while (1) {
			c = *str++;
			if (c >= '0' && c <= '9')
				val = (val * 16) + c - '0';
			else if (c >= 'a' && c <= 'f')
				val = (val * 16) + c - 'a' + 10;
			else if (c >= 'A' && c <= 'F')
				val = (val * 16) + c - 'A' + 10;
			else
				return val*sign;
		}
	}

	// check for character
	if (str[0] == '\'')
		return sign * str[1];

	// assume decimal
	decimal = -1;
	total = 0;
	while (1) {
		c = *str++;
		if (c == '.') {
			decimal = total;
			continue;
		}
		if (c <'0' || c > '9')
			break;
		val = val*10 + c - '0';
		total++;
	}

	if (decimal == -1)
		return val * sign;
	while (total > decimal) {
		val /= 10;
		total--;
	}

	return val * sign;
}

// removes trailing zeros
char *Q_ftos (float value)
{
	static char str[128];
	int	i;

	snprintf (str, sizeof(str), "%f", value);

	for (i=strlen(str)-1 ; i>0 && str[i]=='0' ; i--)
		str[i] = 0;
	if (str[i] == '.')
		str[i] = 0;

	return str;
}

// like strcpy, but allow overlapping strings
char *Q_strcpy( char *to, char *from )
{
	int i;

	if (to < from) {
		for (i = 0; from[i] != 0; i++) {
			to[i] = from[i];
		}
		to[i] = from[i];
	} else {
		for (i = strlen(from); i >= 0; i--) {
			to[i] = from[i];
		}
	}

	return to;
}

char* Q_strlwr(char* s1) {
	char* s;

	s = s1;
	while (*s) {
		*s = tolower(*s);
		s++;
	}
	return s1;
}

char* Q_strupr(char* s1) {
	char* s;

	s = s1;
	while (*s) {
		*s = toupper(*s);
		s++;
	}
	return s1;
}

// Added by VVD {
#ifdef _WIN32
int qsnprintf(char *buffer, size_t count, char const *format, ...)
{
	int ret;
	va_list argptr;
	if (!count) return 0;
	va_start(argptr, format);
	ret = _vsnprintf(buffer, count, format, argptr);
	buffer[count - 1] = 0;
	va_end(argptr);
	return ret;
}
int qvsnprintf(char *buffer, size_t count, const char *format, va_list argptr)
{
	int ret;
	if (!count) return 0;
	ret = _vsnprintf(buffer, count, format, argptr);
	buffer[count - 1] = 0;
	return ret;
}
#endif

#if defined(__linux__) || defined(_WIN32)

size_t strlcpy(char *dst, const char *src, size_t siz)
{
	register char *d = dst;
	register const char *s = src;
	register size_t n = siz;

	/* Copy as many bytes as will fit */
	if (n != 0 && --n != 0) {
		do {
			if ((*d++ = *s++) == 0)
				break;
		} while (--n != 0);
	}

	/* Not enough room in dst, add NUL and traverse rest of src */
	if (n == 0) {
		if (siz != 0)
			*d = '\0'; /* NUL-terminate dst */
		while (*s++)
			;
	}

	return(s - src - 1);	/* count does not include NUL */
}

size_t strlcat(char *dst, const char *src, size_t siz)
{
	register char *d = dst;
	register const char *s = src;
	register size_t n = siz;
	size_t dlen;

	/* Find the end of dst and adjust bytes left but don't go past end */
	while (n-- != 0 && *d != '\0')
		d++;
	dlen = d - dst;
	n = siz - dlen;

	if (n == 0)
		return(dlen + strlen(s));
	while (*s != '\0') {
		if (n != 1) {
			*d++ = *s;
			n--;
		}
		s++;
	}
	*d = '\0';

	return(dlen + (s - src));       /* count does not include NUL */
}

char *strnstr(const char *s, const char *find, size_t slen)
{
	char c, sc;
	size_t len;

	if ((c = *find++) != '\0') 
	{
		len = strlen(find);

		do 
		{
			do 
			{
				if ((sc = *s++) == '\0' || slen-- < 1)
					return (NULL);
			} 
			while (sc != c);
			
			if (len > slen)
				return (NULL);

		} while (strncmp(s, find, len) != 0);
		s--;
	}
	return ((char *)s);
}
#endif
// A Case-insensitive strstr.
char *strstri(const char *text, const char *find)
{
	char *s = (char *)text;
	int findlen = strlen(find);

	// Empty substring, return input (like strstr).
	if (findlen == 0)
	{
		return s;
	}

	while (*s)
	{
		// Check if we can find the substring.
		if (!strncasecmp(s, find, findlen))
		{
			return s;
		}

		s++;
	}

	return NULL;
}

// Added by VVD }

//
// Finds the first occurance of a char in a string starting from the end.
// 
char *strchrrev(char *str, char chr)
{
	char *firstchar = str;
	for (str = str + strlen(str)-1; str >= firstchar; str--)
		if (*str == chr)
			return str;

	return NULL;
}

// D-Kure: added for fte vfs
int wildcmp(char *wild, char *string)
{
	char *cp=NULL, *mp=NULL;

	while ((*string) && (*wild != '*'))
	{
		if ((*wild != *string) && (*wild != '?'))
		{
			return 0;
		}
		wild++;
		string++;
	}

	while (*string)
	{
		if (*wild == '*')
		{
			if (!*++wild)   //a * at the end of the wild string matches anything the checked string has
			{
				return 1;
			}
			mp = wild;
			cp = string+1;
		}
		else if ((*wild == *string) || (*wild == '?'))
		{
			wild++;
			string++;
		}
		else
		{
			wild = mp;
			string = cp++;
		}
	}

	while (*wild == '*')
	{
		wild++;
	}
	return !*wild;
}

wchar char2wc (char c)
{
	return (wchar)(unsigned char)c;
}

char wc2char (wchar wc)
{
	return (wc <= 255) ? (char)wc : '?';
}

wchar *str2wcs (const char *s)
{
	static wchar buf[65536]; //ouch! ouch!
	size_t i;

	for (i = 0; i < (sizeof(buf)/sizeof(buf[0])) - 1; i++) {
		if (s[i] == 0)
			break;
		buf[i] = (short)(unsigned char)s[i];
	}
	buf[i] = 0;
	return buf;
}

char *wcs2str (const wchar *ws)
{
	static char buf[65536];	//ouch! ouch!
	size_t i;

	for (i = 0; i < sizeof(buf) - 1; i++) {
		if (ws[i] == 0)
			break;
		buf[i] = ws[i] <= 255 ? (char)ws[i] : '?';
	}
	buf[i] = 0;
	return buf;
}

#ifndef _WIN32
// disconnect: We assume both str and strSearch are NULL-terminated
wchar *qwcsstr (const wchar *str, const wchar *strSearch)
{
	size_t i, j, search;
	size_t str_len;
	size_t strSearch_len;

	str_len = qwcslen (str);
	strSearch_len = qwcslen (strSearch);
	search = 0;

	if (str_len && strSearch_len) { // paranoid check
		for (i = 0; i < str_len - 1; i++) { // -1 because last wchar is NULL
			for (j = 0; j <  strSearch_len - 1; j++) { // -1 because last wchar is NULL
				if (str [j + i] != strSearch[j]) {
					search = 0;
					break;
				} else {
					search = i;
				}
			}

			if (search)
				break;
		}
	}

	return (wchar *)(str + search);
}

size_t qwcslen (const wchar *ws)
{
	size_t i = 0;
	while (*ws++)
		i++;
	return i;
}

wchar *qwcscpy (wchar *dest, const wchar *src)
{
	while (*src)
		*dest++ = *src++;
	*dest = 0;
	return dest;
}
#endif

// NOTE: size is not the number of bytes to copy, but the number of characters. sizeof(dest) / sizeof(wchar) should be used.
size_t qwcslcpy (wchar *dst, const wchar *src, size_t size)
{
	size_t len = qwcslen (src);

	if (len < size) {
		// it'll fit
		memmove(dst, src, (len + 1) * sizeof(wchar));
		return len;
	}

	if (size == 0)
		return len;

	assert (size >= 0);	// if a negative size was passed, then we're fucked

	memcpy (dst, src, (size - 1) * sizeof(wchar));
	dst[size - 1] = 0;

	return len;
}

size_t qwcslcat (wchar *dst, const wchar *src, size_t size)
{
	size_t dstlen = qwcslen (dst);
	size_t srclen = qwcslen (src);
	size_t len = dstlen + srclen;

	if (len < size) {
		// it'll fit
		memcpy (dst + dstlen, src, (srclen + 1) * sizeof(wchar));
		return len;
	}

	if (dstlen >= size - 1)
		return srclen + size;

	if (size == 0)
		return srclen;

	assert (size >= 0);	// if a negative size was passed, then we're fucked

	memcpy (dst + dstlen, src, (size - 1 - dstlen)*sizeof(wchar));
	dst[size - 1] = 0;

	return len;
}

#ifndef qwcschr
wchar *qwcschr (const wchar *ws, wchar wc)
{
	while (*ws) {
		if (*ws == wc)
			return (wchar *)ws;
		ws++;
	}
	return NULL;
}
#endif

#ifndef qwcschr
wchar *qwcsrchr (const wchar *ws, wchar wc)
{
	wchar *p = NULL;
	while (*ws) {
		if (*ws == wc)
			p = (wchar *)ws;
		ws++;
	}
	return p;
}
#endif

wchar *Q_wcsdup (const wchar *src)
{
	wchar *out;
	size_t size = (qwcslen(src) + 1) * sizeof(wchar);
	out = Q_malloc (size);
	memcpy (out, src, size);
	return out;
}


static qbool Q_glob_match_after_star (const char *pattern, const char *text)
{
	char c, c1;
	const char *p = pattern, *t = text;

	while ((c = *p++) == '?' || c == '*') {
		if (c == '?' && *t++ == '\0')
			return false;
	}

	if (c == '\0')
		return true;

	for (c1 = ((c == '\\') ? *p : c); ; ) {
		if (tolower(*t) == c1 && Q_glob_match (p - 1, t))
			return true;
		if (*t++ == '\0')
			return false;
	}
}

/*
Match a pattern against a string.
Based on Vic's Q_WildCmp, which is based on Linux glob_match.
Works like glob_match, except that sets ([]) are not supported.

A match means the entire string TEXT is used up in matching.

In the pattern string, `*' matches any sequence of characters,
`?' matches any character. Any other character in the pattern
must be matched exactly.

To suppress the special syntactic significance of any of `*?\'
and match the character exactly, precede it with a `\'.
*/
qbool Q_glob_match (const char *pattern, const char *text)
{
	char c;

	while ((c = *pattern++) != '\0') {
		switch (c) {
			case '?':
				if (*text++ == '\0')
					return false;
				break;
			case '\\':
				if (tolower(*pattern++) != tolower(*text++))
					return false;
				break;
			case '*':
				return Q_glob_match_after_star(pattern, text);
			default:
				if (tolower(c) != tolower(*text++))
					return false;
		}
	}

	return (*text == '\0');
}

extern void Com_Printf (char *fmt, ...);
unsigned int Com_HashKey (const char *str) {
	unsigned int hash = 0;
	int c;

	if (!str) {
		Com_Printf("warning: Com_HashKey called with NULL argument\n");
		return 0;
	}

	// the (c&~32) makes it case-insensitive
	// hash function known as sdbm, used in gawk
	while ((c = *str++))
        hash = (c &~ 32) + (hash << 6) + (hash << 16) - hash;

    return hash;
}


/*
============================================================================
                         BYTE ORDER FUNCTIONS
============================================================================
*/

/*short ShortSwap (short l) {
	byte b1, b2;

	b1 = l & 255;
	b2 = (l >> 8) & 255;

	return (b1 << 8) + b2;
}

int LongSwap (int l) {
	byte b1, b2, b3, b4;

	b1 = l & 255;
	b2 = (l >> 8) & 255;
	b3 = (l >> 16) & 255;
	b4 = (l >> 24) & 255;

	return ((int) b1 << 24) + ((int) b2 << 16) + ((int) b3 << 8) + b4;
}

float FloatSwap (float f) {
	union {
		float	f;
		byte	b[4];
	} dat1, dat2;

	dat1.f = f;
	dat2.b[0] = dat1.b[3];
	dat2.b[1] = dat1.b[2];
	dat2.b[2] = dat1.b[1];
	dat2.b[3] = dat1.b[0];
	return dat2.f;
}*/

#ifndef ShortSwap
short ShortSwap (short s)
{
	union
	{
		short	s;
		byte	b[2];
	} dat1, dat2;
	dat1.s = s;
	dat2.b[0] = dat1.b[1];
	dat2.b[1] = dat1.b[0];
	return dat2.s;
}
#endif

#ifndef LongSwap
int LongSwap (int l)
{
	union
	{
		int		l;
		byte	b[4];
	} dat1, dat2;
	dat1.l = l;
	dat2.b[0] = dat1.b[3];
	dat2.b[1] = dat1.b[2];
	dat2.b[2] = dat1.b[1];
	dat2.b[3] = dat1.b[0];
	return dat2.l;
}
#endif

float FloatSwap (float f)
{
	union
	{
		float	f;
		byte	b[4];
	} dat1, dat2;
	dat1.f = f;
	dat2.b[0] = dat1.b[3];
	dat2.b[1] = dat1.b[2];
	dat2.b[2] = dat1.b[1];
	dat2.b[3] = dat1.b[0];
	return dat2.f;
}

#ifdef __PDP_ENDIAN
int LongSwapPDP2Big (int l)
{
	union
	{
		int		l;
		byte	b[4];
	} dat1, dat2;
	dat1.l = l;
	dat2.b[0] = dat1.b[1];
	dat2.b[1] = dat1.b[0];
	dat2.b[2] = dat1.b[3];
	dat2.b[3] = dat1.b[2];
	return dat2.l;
}

int LongSwapPDP2Lit (int l)
{
	union
	{
		int		l;
		short	s[2];
	} dat1, dat2;
	dat1.l = l;
	dat2.s[0] = dat1.s[1];
	dat2.s[1] = dat1.s[0];
	return dat2.l;
}

float FloatSwapPDP2Big (float f)
{
	union
	{
		float	f;
		byte	b[4];
	} dat1, dat2;
	dat1.f = f;
	dat2.b[0] = dat1.b[1];
	dat2.b[1] = dat1.b[0];
	dat2.b[2] = dat1.b[3];
	dat2.b[3] = dat1.b[2];
	return dat2.f;
}

float FloatSwapPDP2Lit (float f)
{
	union
	{
		float	f;
		short	s[2];
	} dat1, dat2;
	dat1.f = f;
	dat2.s[0] = dat1.s[1];
	dat2.s[1] = dat1.s[0];
	return dat2.f;
}
#endif

// Extract integers from buffers
unsigned int BuffBigLong (const unsigned char *buffer)
{
	return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
}

unsigned short BuffBigShort (const unsigned char *buffer)
{
	return (buffer[0] << 8) | buffer[1];
}

unsigned int BuffLittleLong (const unsigned char *buffer)
{
	return (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];
}

unsigned short BuffLittleShort (const unsigned char *buffer)
{
	return (buffer[1] << 8) | buffer[0];
}

//===========================================================================

void SZ_InitEx2(sizebuf_t* buf, byte* data, int length, qbool allowoverflow, sizebuf_overflow_handler_func_t overflow_handler)
{
	memset(buf, 0, sizeof(*buf));
	buf->data = data;
	buf->maxsize = length;
	buf->allowoverflow = allowoverflow;
	buf->overflow_handler = overflow_handler;
}

void SZ_InitEx (sizebuf_t *buf, byte *data, int length, qbool allowoverflow)
{
	SZ_InitEx2(buf, data, length, allowoverflow, NULL);
}

void SZ_Init (sizebuf_t *buf, byte *data, int length)
{
	SZ_InitEx (buf, data, length, false);
}

void SZ_Clear (sizebuf_t *buf) {
	buf->cursize = 0;
	buf->overflowed = false;
}

void *SZ_GetSpace(sizebuf_t *buf, int length)
{
	void *data;

	if (buf->cursize + length > buf->maxsize && buf->overflow_handler) {
		buf->overflow_handler(buf, length);
	}

	if (buf->cursize + length > buf->maxsize) {
		if (!buf->allowoverflow)
			Sys_Error ("SZ_GetSpace: overflow without allowoverflow set (%i/%i/%i)", buf->cursize, length, buf->maxsize);

		if (length > buf->maxsize)
			Sys_Error ("SZ_GetSpace: %i/%i is > full buffer size", length, buf->maxsize);

		Sys_Printf ("SZ_GetSpace: overflow\n");	// because Com_Printf may be redirected
		SZ_Clear (buf);
		buf->overflowed = true;
	}

	data = buf->data + buf->cursize;
	buf->cursize += length;

	return data;
}

void SZ_Write(sizebuf_t *buf, const void *data, int length)
{
	byte* dest = SZ_GetSpace(buf, length);

	memcpy(dest, data, length);
}

void SZ_Print(sizebuf_t *buf, char *data)
{
	int len = strlen(data) + 1;

	// Remove trailing '\0'
	if (buf->cursize && !buf->data[buf->cursize - 1]) {
		--buf->cursize;
	}

	SZ_Write(buf, data, len);
}

//============================================================================

#ifdef DEBUG_MEMORY_ALLOCATIONS
static unsigned int allocation_number = 0;

typedef struct ezquake_memory_block_s {
	char filename[MAX_OSPATH];
	char label[64];
	int line_number;
	size_t size;
	unsigned int allocation_number;
} ezquake_memory_block_t;

#define MEMORY_BLOCK_FOR_PTR(ptr) ((ezquake_memory_block_t*) (((intptr_t)ptr) - sizeof(ezquake_memory_block_t)));
#define PTR_FOR_MEMORY_BLOCK(block) (void*)(((intptr_t)block) + sizeof(ezquake_memory_block_t))

static void Q_malloc_register(const char* file, int line)
{
	if (frameStats.hotloop) {
		++frameStats.hotloop_mallocs;
		if (developer.integer) {
			frameStats.hotloop = false;
			Com_Printf("HotMalloc: %s[%d]\n", file, line);
			frameStats.hotloop = true;
		}
	}
	++frameStats.mallocs;
}

#endif

/*
** Q_malloc
**
** Use it instead of malloc so that if memory allocation fails,
** the program exits with a message saying there's not enough memory
** instead of crashing after trying to use a NULL pointer
*/
#ifdef DEBUG_MEMORY_ALLOCATIONS
void* Q_malloc_debug(size_t size, const char* file, int line, const char* label)
#else
void* Q_malloc(size_t size)
#endif
{
#ifdef DEBUG_MEMORY_ALLOCATIONS
	void *p;
	ezquake_memory_block_t* block = malloc(sizeof(ezquake_memory_block_t) + size);

	Sys_Printf("\nmemory,alloc,%u,%s,%d,%u,%s\n", allocation_number, file, line, size, label ? label : "");

	if (!block) {
		Sys_Error("Q_malloc: Not enough memory free; check disk space\n");
		return NULL;
	}

	strlcpy(block->filename, file, sizeof(block->filename));
	if (label) {
		strlcpy(block->label, label, sizeof(block->label));
	}
	block->line_number = line;
	block->size = size;
	block->allocation_number = allocation_number++;

	Q_malloc_register(file, line);

	p = PTR_FOR_MEMORY_BLOCK(block);
#else
	void *p = malloc(size);

	if (!p) {
		Sys_Error("Q_malloc: Not enough memory free; check disk space\n");
	}
#endif

//#ifndef _DEBUG
	memset(p, 0, size);
//#endif

	return p;
}

#ifdef DEBUG_MEMORY_ALLOCATIONS
void *Q_calloc_debug(size_t n, size_t size, const char* file, int line, const char* label)
#else
void *Q_calloc(size_t n, size_t size)
#endif
{
#ifdef DEBUG_MEMORY_ALLOCATIONS
	void *p = Q_malloc_debug(n * size, file, line, label);
#else
	void *p = calloc(n, size);

	if (!p) {
		Sys_Error("Q_calloc: Not enough memory free; check disk space\n");
	}
#endif

	return p;
}

#ifdef DEBUG_MEMORY_ALLOCATIONS
#define EZQUAKE_SAFE_REALLOC
void* Q_realloc_debug(void* p, size_t newsize, const char* file, int line, const char* label)
{
	ezquake_memory_block_t* block = NULL;
	size_t old_size = 0;

#ifdef EZQUAKE_SAFE_REALLOC
	if (p && old_size)
	{
		void* new_buffer;

		// To be sure we're not assuming the memory block is extended, allocate and re-allocate (can catch some bugs)
		block = MEMORY_BLOCK_FOR_PTR(p);
		new_buffer = Q_malloc_debug(newsize + sizeof(ezquake_memory_block_t), file, line, label);
		if (!new_buffer) {
			return NULL;
		}
		memcpy(new_buffer, p, block->size);
		Q_free_debug(p, file, line);
		return new_buffer;
	}
#endif

	if (p) {
		block = MEMORY_BLOCK_FOR_PTR(p);
		Sys_Printf("\nmemory,free(realloc),%u,%s,%d,%u,%s,%d\n", block->allocation_number, block->filename, block->line_number, block->size, file, line);
	}
	Sys_Printf("\nmemory,alloc(realloc),%u,%s,%d,%u,%s\n", allocation_number, file, line, newsize, label ? label : "");

	block = p = realloc(block, newsize + sizeof(ezquake_memory_block_t));

	strlcpy(block->filename, file, sizeof(block->filename));
	block->line_number = line;
	block->size = newsize;
	block->allocation_number = allocation_number++;
	if (label) {
		strlcpy(block->label, label, sizeof(block->label));
	}
	Q_malloc_register(file, line);

	return (void*)(((intptr_t)p) + sizeof(ezquake_memory_block_t));
}
#else
void *Q_realloc(void *p, size_t newsize)
{
	if (!(p = realloc(p, newsize))) {
		Sys_Error("Q_realloc: Not enough memory free; check disk space\n");
	}

	return p;
}
#endif // !DEBUG_MEMORY_ALLOCATIONS

#ifdef DEBUG_MEMORY_ALLOCATIONS
void Q_free_debug(void* ptr, const char* file, int line)
{
	if (ptr) {
		ezquake_memory_block_t* block = MEMORY_BLOCK_FOR_PTR(ptr);

		Sys_Printf("\nmemory,free,%u,%s,%d,%u,%s,%d\n", block->allocation_number, block->filename, block->line_number, block->size, file, line);

		free(block);
	}
}

char *Q_strdup_debug(const char *src, const char* file, int line, const char* label)
{
	if (src) {
		size_t size = strlen(src) + 1;
		char *p = Q_malloc_debug(size, file, line, label);

		if (!p) {
			Sys_Error("Q_strdup: Not enough memory free; check disk space\n");
		}

		strlcpy(p, src, size);

		return p;
	}
	return NULL;
}

#else
char *Q_strdup(const char *src)
{
	if (src) {
		char *p = strdup(src);

		if (!p) {
			Sys_Error("Q_strdup: Not enough memory free; check disk space\n");
		}
		return p;
	}
	return NULL;
}
#endif

// PLZ free returned string after it no longer need!!!
#ifdef DEBUG_MEMORY_ALLOCATIONS
char *Q_wcs2str_malloc_debug(const wchar *ws, const char* file, int line)
#else
char *Q_wcs2str_malloc(const wchar *ws)
#endif
{
	size_t i;
	size_t len = qwcslen(ws);
#ifdef DEBUG_MEMORY_ALLOCATIONS
	char *buf = (char *)Q_malloc_debug(len + 1, file, line, NULL);
	Q_malloc_register(file, line);
#else
	char *buf = (char *)Q_malloc(len + 1);
#endif

	for (i = 0; i < len; i++) {
		if (ws[i] == 0)
			break;
		buf[i] = ws[i] <= 255 ? (char)ws[i] : '?';
	}
	buf[i] = 0;
	return buf;
}

#ifdef _WIN64
#undef strlen
int Q_strlen(const char* s)
{
	return (int)strlen(s);
}
#endif

// case insensitive and red-insensitive compare
int Q_strcmp2(const char * s1, const char * s2)
{
	if (s1 == NULL && s2 == NULL)
		return 0;

	if (s1 == NULL)
		return -1;

	if (s2 == NULL)
		return 1;

	while (*s1 || *s2) {
		if (tolower(*s1 & 0x7f) != tolower(*s2 & 0x7f)) {
			return tolower(*s1 & 0x7f) - tolower(*s2 & 0x7f);
		}
		s1++;
		s2++;
	}

	return 0;
}


================================================
FILE: src/q_shared.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: q_shared.h,v 1.36 2007-10-03 14:00:04 dkure Exp $

*/
// q_shared.h -- functions shared by all subsystems

#ifndef __Q_SHARED_H__
#define __Q_SHARED_H__

#include <math.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>

#define wchar unsigned short	// 16-bit Unicode char

#undef true
#undef false
typedef enum {false, true} qbool;

#include "mathlib.h"
#include "sys.h"

#if defined(_MSC_VER) | defined (__INTEL_COMPILER)
#define unlink _unlink
#define strdup _strdup
#endif

#ifdef _MSC_VER
#pragma warning( disable : 4244 4127 4201 4214 4514 4305 4115 4018 4996)
#endif

#ifdef __INTEL_COMPILER
#pragma warning( disable : 188)
#endif

typedef unsigned char byte;

#ifndef NULL
#define NULL ((void *) 0)
#endif


#ifdef _WIN32
#define IS_SLASH(c) ((c) == '/' || (c) == '\\')
#else
#define IS_SLASH(c) ((c) == '/')
#endif

#ifndef min
#define min(a,b) ((a) < (b) ? (a) : (b))
#endif
#ifndef max
#define max(a,b) ((a) > (b) ? (a) : (b))
#endif

//#define bound(a,b,c) (max((a), min((b), (c))))
#define bound(a,b,c) ((a) >= (c) ? (a) : \
					(b) < (a) ? (a) : (b) > (c) ? (c) : (b))

#define isspace2(c) ((c) == 0x09 || (c) == 0x0D || (c) == 0x0A || (c) == 0x20)

//============================================================================

#define	MINIMUM_MEMORY		0x550000

#define	MAX_QPATH			64		// max length of a quake game pathname
#define	MAX_OSPATH			260		// max length of a filesystem pathname

#define	ON_EPSILON			0.1		// point on plane side epsilon

//============================================================================

struct sizebuf_s;

typedef void (*sizebuf_overflow_handler_func_t)(struct sizebuf_s*, int);

typedef struct sizebuf_s {
	qbool	allowoverflow;	// if false, do a Sys_Error
	qbool	overflowed;		// set to true if the buffer size failed
	byte	*data;
	int		maxsize;
	int		cursize;
	sizebuf_overflow_handler_func_t overflow_handler;
} sizebuf_t;

#define MSG_HasOverflowHandler(m) ((m)->overflow_handler != NULL)

extern char *com_args_original;

void SZ_Init(sizebuf_t *buf, byte *data, int length);
void SZ_InitEx(sizebuf_t *buf, byte *data, int length, qbool allowoverflow);
void SZ_InitEx2(sizebuf_t* buf, byte* data, int length, qbool allowoverflow, sizebuf_overflow_handler_func_t overflow_handler);
void SZ_Clear(sizebuf_t *buf);
void *SZ_GetSpace(sizebuf_t *buf, int length);
void SZ_Write(sizebuf_t *buf, const void *data, int length);
void SZ_Print(sizebuf_t *buf, char *data);	// strcats onto the sizebuf

//============================================================================

short	ShortSwap (short l);
int		LongSwap (int l);
float	FloatSwap (float f);
int		LongSwapPDP2Big (int l);
int		LongSwapPDP2Lit (int l);
float	FloatSwapPDP2Big (float f);
float	FloatSwapPDP2Lit (float f);

#if defined(_MSC_VER) && _MSC_VER >= 1400
// vc++ 2005 and up has intrinsics for the BSWAP instruction.
#define ShortSwap _byteswap_ushort
#define LongSwap _byteswap_ulong
#endif

//======================= ENDIAN DECTECTION ==================================
//======================= WIN32 DEFINES ======================================
#ifdef _WIN32
#define __LITTLE_ENDIAN__
#endif

//======================= LINUX DEFINES ======================================
#ifdef __linux__

#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) && !defined(__PDP_ENDIAN__)

#if __FLOAT_WORD_ORDER == __BIG_ENDIAN
#define __BIG_ENDIAN__
#elif __BYTE_ORDER == __ORDER_BIG_ENDIAN
#define __BIG_ENDIAN__
#elif __FLOAT_WORD_ORDER == __LITTLE_ENDIAN
#define __LITTLE_ENDIAN__
#elif __BYTE_ORDER == __ORDER_LITTLE_ENDIAN
#define __LITTLE_ENDIAN__
#elif __FLOAT_WORD_ORDER == __PDP_ENDIAN
#define __PDP_ENDIAN__
#endif

#endif

#endif

//======================= FreeBSD/OpenBSD/NetBSD DEFINES ====================================
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)

#include <machine/endian.h>
#if BYTE_ORDER == BIG_ENDIAN
#ifndef __BIG_ENDIAN__
#define __BIG_ENDIAN__
#endif
#elif BYTE_ORDER == LITTLE_ENDIAN
#ifndef __LITTLE_ENDIAN__
#define __LITTLE_ENDIAN__
#endif
#elif BYTE_ORDER == PDP_ENDIAN
#ifndef __PDP_ENDIAN__
#define __PDP_ENDIAN__
#endif
#endif

#endif

//======================= BYTE SWAPS =========================================
#if defined __BIG_ENDIAN__
#define BigShort(x)		(x)
#define BigLong(x)		(x)
#define BigFloat(x)		(x)
#define LittleShort(x)	ShortSwap(x)
#define LittleLong(x)	LongSwap(x)
#define LittleFloat(x)	FloatSwap(x)

#elif defined __LITTLE_ENDIAN__
#define BigShort(x)		ShortSwap(x)
#define BigLong(x)		LongSwap(x)
#define BigFloat(x)		FloatSwap(x)
#define LittleShort(x)	(x)
#define LittleLong(x)	(x)
#define LittleFloat(x)	(x)

#elif defined __PDP_ENDIAN__
#define BigShort(x)		ShortSwap(x)
#define BigLong(x)		LongSwapPDP2Big(x)
#define BigFloat(x)		FloatSwapPDP2Big(x)
#define LittleShort(x)	(x)
#define LittleLong(x)	LongSwapPDP2Lit(x)
#define LittleFloat(x)	FloatSwapPDP2Lit(x)

#else
#error Unknown byte order type!
#endif

unsigned int BuffBigLong (const unsigned char *buffer);
unsigned short BuffBigShort (const unsigned char *buffer);
unsigned int BuffLittleLong (const unsigned char *buffer);
unsigned short BuffLittleShort (const unsigned char *buffer);
/* johnnycz: VVD's change broke e.g. TGA loading (crosshairimage, tom)
VVD: fixed by changing from "int" to "short" in 2nd string - stupid copy&paste bug :-(
#define	BuffLittleLong(buffer)	LittleLong(*(int*)buffer)
#define	BuffLittleShort(buffer)	LittleShort(*(short*)buffer)
*/

//============================================================================

int Q_atoi (const char *str);
float Q_atof (const char *str);
char *Q_ftos (float value); // removes trailing zero chars

char* Q_strcpy(char *to, char *from);
char* Q_strupr(char* s1);
char* Q_strlwr(char *s1);
int Q_strcmp2(const char * s1, const char * s2);

// Added by VVD {
#ifdef _MSC_VER
#define strcasecmp(s1, s2)	_stricmp  ((s1),   (s2))
#define strncasecmp(s1, s2, n)	_strnicmp ((s1),   (s2),   (n))
// vc++ snprintf and vsnprintf are non-standard and not compatible with C99.
int qsnprintf(char *str, size_t n, char const *fmt, ...);
int qvsnprintf(char *buffer, size_t count, const char *format, va_list argptr);
#if _MSC_VER < 1900
#define snprintf qsnprintf
#define vsnprintf qvsnprintf
#endif // _MSC_VER < 1900 // Visual Studio 15
#endif

char *strstri(const char *text, const char *find); // Case insensitive strstr.

#if defined(__linux__) || defined(_WIN32)
size_t strlcpy (char *dst, const char *src, size_t siz);
size_t strlcat (char *dst, const char *src, size_t siz);
char  *strnstr (const char *s, const char *find, size_t slen);
#endif
// Added by VVD }

char *strchrrev(char *str, char chr);
int wildcmp(char *wild, char *string);

wchar char2wc (char c);
char wc2char (wchar wc);
wchar *str2wcs (const char *str);
char *wcs2str (const wchar *ws);

#ifdef _WIN32
#ifdef _WIN64
#define qwcscpy wcscpy
#define qwcschr wcschr
#define qwcsrchr wcsrchr
#define qwcslen (int)wcslen
#define qwcsstr wcsstr
#else
#define qwcscpy wcscpy
#define qwcschr wcschr
#define qwcsrchr wcsrchr
#define qwcslen wcslen
#define qwcsstr wcsstr
#endif
#else
wchar *qwcscpy (wchar *dest, const wchar *src);
wchar *qwcschr (const wchar *ws, wchar wc);
wchar *qwcsrchr (const wchar *ws, wchar wc);
size_t qwcslen (const wchar *s);
wchar *qwcsstr (const wchar *str, const wchar *strSearch);
#endif

// NOTE: size is not the number of bytes to copy, but the number of characters. sizeof(dest) / sizeof(wchar) should be used.
size_t qwcslcpy (wchar *dst, const wchar *src, size_t size);
size_t qwcslcat (wchar *dst, const wchar *src, size_t size);
wchar *Q_wcsdup(const wchar *src);

qbool Q_glob_match (const char *pattern, const char *text);

unsigned int Com_HashKey (const char *name);

//============================================================================

// memory management
#ifdef DEBUG_MEMORY_ALLOCATIONS
void *Q_malloc_debug(size_t size, const char* file, int line, const char* label);
void *Q_calloc_debug(size_t n, size_t size, const char* file, int line, const char* label);
void *Q_realloc_debug(void *p, size_t newsize, const char* file, int line, const char* label);
char *Q_strdup_debug(const char *src, const char* file, int line, const char* label);
void Q_free_debug(void* ptr, const char* file, int line);
char *Q_wcs2str_malloc_debug(const wchar *ws, const char* file, int line); // you must freed returned string after it no longer need!!!
#define Q_malloc_named(size, name) (Q_malloc_debug((size), __FILE__, __LINE__, name))
#define Q_malloc(size) (Q_malloc_debug((size), __FILE__, __LINE__, NULL))
#define Q_calloc(n, size) (Q_calloc_debug((n), (size), __FILE__, __LINE__, NULL))
#define Q_calloc_named(n, size, name) (Q_calloc_debug((n), (size), __FILE__, __LINE__, name))
#define Q_realloc(p, newsize) (Q_realloc_debug((p), (newsize), __FILE__, __LINE__, NULL))
#define Q_realloc_named(p, newsize, name) (Q_realloc_debug((p), (newsize), __FILE__, __LINE__, name))
#define Q_strdup(src) (Q_strdup_debug((src), __FILE__, __LINE__, NULL))
#define Q_strdup_named(src, name) (Q_strdup_debug((src), __FILE__, __LINE__, (name)))
#define Q_free(ptr) { Q_free_debug(ptr, __FILE__, __LINE__); ptr = NULL; }
#define Q_wcs2str_malloc(ws) (Q_wcs2str_malloc_debug(ws, __FILE__, __LINE__))
#else
#define Q_malloc_named(size, name) (Q_malloc(size))
#define Q_calloc_named(n, size, name) (Q_calloc(n, size))
#define Q_realloc_named(p, newsize, name) (Q_realloc(p, newsize))
#define Q_strdup_named(size, name) (Q_strdup(size))
void *Q_malloc(size_t size);
void *Q_calloc(size_t n, size_t size);
void *Q_realloc(void *p, size_t newsize);
#define Q_free(ptr) if(ptr) { free(ptr); ptr = NULL; }
char *Q_strdup(const char *src);
char *Q_wcs2str_malloc(const wchar *ws); // you must freed returned string after it no longer need!!!
#endif
#define Q_calloc_untracked(n, size) (calloc(n, size))
#define Q_free_untracked(ptr) if(ptr) { free(ptr); ptr = NULL; }

//============================================================================
// chat icons flags 
// used now by client code only, but may be used in future by server code too, so put here
#define CIF_CHAT  (1<<0) /* set this flag if user in console, mm1, mm2 etc but not in game */
#define CIF_AFK   (1<<1) /* set this flag if app lose focus, ie alt+tab */

//============================================================================

#define	MAX_MSGLEN			1450		// max length of a reliable message
#define	MAX_DATAGRAM		1450		// max length of unreliable message
#define	MSG_BUF_SIZE		8192		// max length of msg buf; MVD demo need it
#define	FILE_TRANSFER_BUF_SIZE	(MAX_MSGLEN - 100)
#define MIN_MTU             1350        // since user can specifie MTU it is a good idea to limit it at some "sane" value.

// qqshka: Its all messy.
// For example ezquake (and FTE?) expect maximum message is MSG_BUF_SIZE == 8192 with mvd header which have not fixed size,
// however fuhquake uses less msg size as I recall.
// mvd header max size is 10 bytes.
// 
// MAX_MVD_SIZE - max size of single mvd message _WITHOUT_ header
#define	MAX_MVD_SIZE			(MSG_BUF_SIZE - 100)

#endif /* __Q_SHARED_H__ */


================================================
FILE: src/qmb_particles.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_QMB_PARTICLES_HEADER
#define EZQUAKE_QMB_PARTICLES_HEADER

//====================================================
void QMB_InitParticles(void);
void QMB_ClearParticles(void);
void QMB_CalculateParticles(void);
void QMB_DrawParticles(void);
void QMB_ShutdownParticles(void);

void QMB_RunParticleEffect(vec3_t org, vec3_t dir, int color, int count);
void QMB_ParticleTrail(vec3_t start, vec3_t end, trail_type_t type);
void QMB_EntityParticleTrail(centity_t* cent, trail_type_t type);
void QMB_ParticleRailTrail(vec3_t start, vec3_t end, int color_num);
void QMB_BlobExplosion(vec3_t org);
void QMB_ParticleExplosion(vec3_t org);
void QMB_LavaSplash(vec3_t org);
void QMB_TeleportSplash(vec3_t org);

void QMB_DetpackExplosion(vec3_t org);

void QMB_InfernoFlame(vec3_t org);
void QMB_StaticBubble(entity_t *ent);

extern qbool qmb_initialized;
extern float particle_time;

#define MIN_ENTITY_PARTICLE_FRAMETIME (0.1)
#define ONE_FRAME_ONLY	(0.0001)

#define	INIT_NEW_PARTICLE(_pt, _p, _color, _size, _time) \
{ \
	_p = free_particles;								\
	free_particles = _p->next;							\
	_p->next = _pt->start;								\
	_pt->start = _p;									\
	_p->size = _size;									\
	_p->hit = 0;										\
	_p->start = r_refdef2.time;							\
	_p->die = _p->start + _time;						\
	_p->growth = 0;										\
	_p->rotspeed = 0;									\
	_p->texindex = (rand() % particle_textures[_pt->texture].components);	\
	_p->bounces = 0;									\
	_p->initial_alpha = _pt->startalpha;                \
	memcpy(_p->color, _color, sizeof(_p->color));		\
	_p->cached_contents = 0;                            \
	_p->cached_distance = 0;                            \
	VectorClear(_p->cached_movement);                   \
	_p->entity_ref = 0;                                 \
	_p->entity_trailnumber = 0;                         \
	ParticleStats(1); \
}

#endif


================================================
FILE: src/qsound.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
// qsound.h -- client sound i/o functions

#ifndef __QSOUND_H__
#define __QSOUND_H__

#include "q_shared.h"
#include "zone.h"
#include "cvar.h"

typedef struct sfx_s {
	char  name[MAX_QPATH];
	void *buf;
} sfx_t;

// FIXME: REMOVE ME PLZ
typedef struct snd_format_s {
	unsigned int speed;
	unsigned int width;
	unsigned int channels;
} snd_format_t;

typedef struct sfxcache_s {
	snd_format_t	format;
	unsigned int 	total_length;
	int 		loopstart;
	unsigned char	data[1];
} sfxcache_t;

typedef struct soundhw_s {
	unsigned int  numchannels;
	unsigned int  samples;
	unsigned int  samplepos;
	unsigned int  samplebits;
	unsigned int  khz;
	unsigned long snd_sent;
	unsigned char *buffer;
	/* qw related */
	int paintedtime;
	int oldsamplepos;
	int numwraps;
	int queuelen;
} soundhw_t;

extern soundhw_t *shw;

typedef struct channel_s {
	sfx_t		*sfx;			// sfx number
	int		leftvol;		// 0-255 volume
	int		rightvol;		// 0-255 volume
	int		end;			// end time in global paintsamples
	int 		pos;			// sample position in sfx
	int		looping;		// where to loop, -1 = no looping
	int		entnum;			// to allow overriding a specific sound
	int		entchannel;		//
	vec3_t		origin;			// origin of sound effect
	vec_t		dist_mult;		// distance multiplier (attenuation/clipK)
	int		master_vol;		// 0-255 master volume
	int		flags;
} channel_t;

#define CHANNEL_FLAG_VOICE (1 << 0)

typedef struct wavinfo_s {
	int		rate;
	int		width;
	int		channels;
	int		loopstart;
	int		samples;
	int		dataofs;		// chunk starts this many bytes from file start
} wavinfo_t;

void S_Init (void);
void S_Shutdown (void);
void S_StartSound (int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float fvol,  float attenuation);
void S_StaticSound (sfx_t *sfx, vec3_t origin, float vol, float attenuation);
void S_StopSound (int entnum, int entchannel);
void S_StopAllSounds(void);
void S_Update (vec3_t origin, vec3_t v_forward, vec3_t v_right, vec3_t v_up);

sfx_t *S_PrecacheSound (char *sample);
void S_PaintChannels(int endtime);

void S_LocalSound (char *s);
void S_LocalSoundWithVol(char *sound, float volume);
sfxcache_t *S_LoadSound (sfx_t *s);
#define RAW_SOURCE_QIZMO_VOICE MAX_CLIENTS
void S_RawAudio(int sourceid, byte *data, unsigned int speed, unsigned int samples, unsigned int channelsnum, unsigned int width);
void S_QizmoVoice_PlayFrame(int sequence, int voice_id, const byte *data, int bytes);

void SND_InitScaletable (void);
int SND_Rate(int rate);

void SND_ResampleStream(void *in, int inrate, int inwidth, int inchannels, int insamps,
						void *out, int outrate, int outwidth, int outchannels, int resampstyle);

// ====================================================================
// User-setable variables
// ====================================================================

#define MAX_CHANNELS 512
#define MAX_DYNAMIC_CHANNELS 32


extern channel_t	channels[MAX_CHANNELS];
// 0 to MAX_DYNAMIC_CHANNELS - 1 = normal entity sounds
// MAX_DYNAMIC_CHANNELS to MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS - 1 = water, etc
// MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS to total_channels = static sounds

extern unsigned int	total_channels;

extern qbool		snd_initialized;
extern qbool		snd_started;

extern int		soundtime;

extern cvar_t		s_loadas8bit;
extern cvar_t		s_khz;
extern cvar_t		s_volume;
extern cvar_t		s_raw_volume;
extern cvar_t		s_swapstereo;
extern cvar_t		bgmvolume;

#endif


================================================
FILE: src/qtv.c
================================================
/*
Copyright (C) 2011 qqshka

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
	Support for FTE QuakeTV

	$Id: qtv.c,v 1.20 2007-10-28 02:45:19 qqshka Exp $
*/

#include "quakedef.h"
#include "qtv.h"
#include "input.h"
#include "teamplay.h"
#include "fs.h"
#include "utils.h"

cvar_t  qtv_buffertime       = { "qtv_buffertime",       "0.5" };
cvar_t  qtv_prebuffertime    = { "qtv_prebuffertime",    "0" };
cvar_t  qtv_chatprefix       = { "qtv_chatprefix",       "$[{QTV}$] " };
cvar_t  qtv_gamechatprefix   = { "qtv_gamechatprefix",   "$[{QTV>game}$] " };
cvar_t  qtv_skipchained      = { "qtv_skipchained",      "1" };
cvar_t  qtv_adjustbuffer     = { "qtv_adjustbuffer",     "1" };
cvar_t  qtv_adjustminspeed   = { "qtv_adjustminspeed",   "0" };
cvar_t  qtv_adjustmaxspeed   = { "qtv_adjustmaxspeed",   "999" };
cvar_t  qtv_adjustlowstart   = { "qtv_adjustlowstart",   "0.3" };
cvar_t  qtv_adjusthighstart  = { "qtv_adjusthighstart",  "1" };
cvar_t  qtv_say_team         = { "qtv_say_team",         "0" };
cvar_t  qtv_allow_pause      = { "qtv_allow_pause",      "0" }; // ignore cl_demospeed during QTV playback by default

cvar_t  qtv_event_join       = { "qtv_event_join",        " &c2F2joined&r"};
cvar_t  qtv_event_leave      = { "qtv_event_leave",       " &cF22left&r"};
cvar_t  qtv_event_changename = { "qtv_event_changename",  " &cFF0changed name to&r "};
cvar_t  qtv_event_msglevel   = { "qtv_event_msglevel",    "2" };

extern qbool qtv_playback_paused;

void Qtvusers_f (void);
void QtvStartDelay_f(void);
void QtvEndDelay_f(void);

void QTV_Init(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_QTV);

	Cvar_Register(&qtv_buffertime);
	Cvar_Register(&qtv_prebuffertime);
	Cvar_Register(&qtv_chatprefix);
	Cvar_Register(&qtv_gamechatprefix);
	Cvar_Register(&qtv_skipchained);
	Cvar_Register(&qtv_adjustbuffer);
	Cvar_Register(&qtv_adjustminspeed);
	Cvar_Register(&qtv_adjustmaxspeed);
	Cvar_Register(&qtv_adjustlowstart);
	Cvar_Register(&qtv_adjusthighstart);
	Cvar_Register(&qtv_say_team);
	Cvar_Register(&qtv_allow_pause);

	Cvar_Register(&qtv_event_join);
	Cvar_Register(&qtv_event_leave);
	Cvar_Register(&qtv_event_changename);
	Cvar_Register(&qtv_event_msglevel);

	Cvar_ResetCurrentGroup();

	Cmd_AddCommand("qtvusers", Qtvusers_f);
	Cmd_AddCommand("+qtv_delay", QtvStartDelay_f);
	Cmd_AddCommand("-qtv_delay", QtvEndDelay_f);
}

//=================================================

char *QTV_CL_HEADER(float qtv_ver, int qtv_ezquake_ext)
{
	static char header[1024];

	snprintf(header, sizeof(header), "QTV\n" "VERSION: %g\n" QTV_EZQUAKE_EXT ": %d\n", qtv_ver, qtv_ezquake_ext);

	return header;
}

//=================================================

// ripped from FTEQTV, original name is SV_ConsistantMVDData
// return non zero if we have at least one message
// ms - will contain ms
int ConsistantMVDDataEx(unsigned char *buffer, int remaining, int *ms, int max_messages)
{
	qbool warn = true;
	int lengthofs;
	int length;
	int available = 0;

	if (ms) {
		ms[0] = 0;
	}

	while ( 1 ) {
		if (remaining < 2) {
			return available;
		}

		//buffer[0] is time

		switch (buffer[1]&dem_mask)
		{
		case dem_set:
			length = 10;
			goto gottotallength;
		case dem_multiple:
			lengthofs = 6;
			break;
		default:
			lengthofs = 2;
			break;
		}

		if (lengthofs+4 > remaining) {
			return available;
		}

		length = (buffer[lengthofs]<<0) + (buffer[lengthofs+1]<<8) + (buffer[lengthofs+2]<<16) + (buffer[lengthofs+3]<<24);

		if (length > MAX_MVD_SIZE && warn) {
			Com_Printf("Corrupt mvd, length: %d\n", length);
			warn = false;
		}

		length += lengthofs+4;

gottotallength:
		if (remaining < length) {
			return available;
		}

		if (ms) {
			ms[0] += buffer[0];
		}
			
		remaining -= length;
		available += length;
		buffer    += length;

		if (max_messages && available >= max_messages) {
			return available;
		}
	}
}

int ConsistantMVDData(unsigned char *buffer, int remaining, int max_packets)
{
	return ConsistantMVDDataEx(buffer, remaining, NULL, max_packets);
}

//=================================================

extern vfsfile_t *playbackfile;

void QTV_ForwardToServerEx (qbool skip_if_no_params, qbool use_first_argument)
{
	char data[1024 + 100] = {0}, text[1024], *s;
	sizebuf_t buf;

	if (    cls.mvdplayback != QTV_PLAYBACK
		|| !playbackfile /* || cls.qtv_ezquake_ext & QTV_EZQUAKE_EXT_CLC_STRINGCMD ???*/
	   )
		return;

	if (skip_if_no_params)
		if (Cmd_Argc() < 2)
			return;

	// lowercase command
	for (s = Cmd_Argv(0); *s; s++)
		*s = (char) tolower(*s);

	if (cls.state == ca_disconnected) {
		Com_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
		return;
	}

	if (strcmp(Cmd_Argv(0), "say_team") == 0 && !qtv_say_team.integer) {
		Com_Printf("Cannot send team messages. Use qtv_say_team 1 to override.\n");
		return;
	}

	SZ_Init(&buf, (byte*) data, sizeof(data));

	s = TP_ParseMacroString (Cmd_Args());
	s = TP_ParseFunChars (s, true);

	text[0] = 0; // *cat is dangerous, ensure we empty buffer before use it

	if (use_first_argument)
		strlcat(text, Cmd_Argv(0), sizeof(text));

	if (s[0])
	{
		strlcat(text, " ", sizeof(text));
		strlcat(text, s,   sizeof(text));
	}

	MSG_WriteShort  (&buf, 2 + 1 + strlen(text) + 1); // short + byte + null terminated string
	MSG_WriteByte   (&buf, qtv_clc_stringcmd);
	MSG_WriteString (&buf, text);

	VFS_WRITE(playbackfile, buf.data, buf.cursize);
}

#if defined(_MSC_VER) && !defined(__clang__)
#pragma optimize( "", off )
#endif
void QTV_Say_f (void)
{
	tokenizecontext_t tmpcontext;

	// save context, so we can later restore it
	Cmd_SaveContext(&tmpcontext);

	// in our last tests, this check was not necessary
	// and even lead to issues
	// so we are disabling it temporarily to see if everything works ok without it
#if 0
	// get rid of quotes, if any
	char *s = Cmd_Args();
	if (0 && s[0] == '\"' && s[(len = strlen(s))-1] == '\"' && len > 2)
	{
		int len;
		char text[1024] = {0};
		snprintf(text, sizeof(text), "%s %s", Cmd_Argv(0), s + 1);
		if ((len = strlen(text)))
			text[len - 1] = 0;
		Cmd_TokenizeString(text);
	}
#endif

	QTV_ForwardToServerEx (true, true);

	// restore
	Cmd_RestoreContext(&tmpcontext);
}
#if defined(_MSC_VER) && !defined(__clang__)
#pragma optimize( "", on )
#endif

void QTV_Cmd_ForwardToServer (void)
{
	QTV_ForwardToServerEx (false, true);
}

// don't forward the first argument
void QTV_Cl_ForwardToServer_f (void)
{
	QTV_ForwardToServerEx (false, false);
}

void QTV_Cmd_Printf(int qtv_ext, char *fmt, ...)
{
	va_list argptr;
	char msg[1024] = {0};
	tokenizecontext_t tmpcontext;

	if (cls.mvdplayback != QTV_PLAYBACK || (qtv_ext & cls.qtv_ezquake_ext) != qtv_ext)
		return; // no point for this, since it not qtv playback or qtv server do not support it

	va_start (argptr, fmt);
	vsnprintf (msg, sizeof(msg), fmt, argptr);
	va_end (argptr);

	// save context, so we can later restore it
	Cmd_SaveContext(&tmpcontext);

	Cmd_TokenizeString(msg);
	QTV_Cmd_ForwardToServer ();

	// restore
	Cmd_RestoreContext(&tmpcontext);
}

//=================================================

qtvuser_t *qtvuserlist = NULL;

static qtvuser_t *QTV_UserById(int id)
{
	qtvuser_t *current;

	for (current = qtvuserlist; current; current = current->next)
		if (current->id == id)
			return current;

	return NULL;
}

static void QTV_SetUser(qtvuser_t *to, qtvuser_t *from)
{
	*to = *from;
}

// allocate data and set fields, perform linkage to qtvuserlist
// Well, instead of QTV_NewUser(int id, char *name, ...) I pass params with single qtvuser_t *user struct, well its OK for current struct.
static qtvuser_t *QTV_NewUser(qtvuser_t *user)
{
	// check, may be user alredy exist, so reuse it
	qtvuser_t *newuser = QTV_UserById(user->id);

	if (!newuser)
	{
		// user does't exist, alloc data
		newuser = Q_malloc(sizeof(*newuser));

		QTV_SetUser(newuser, user);

		// perform linkage
		newuser->next = qtvuserlist;
		qtvuserlist = newuser;
	}
	else
	{
		// we do not need linkage, just save current
		qtvuser_t *oldnext = newuser->next; // we need save this before assign all fields

		QTV_SetUser(newuser, user);

		newuser->next = oldnext;
	}

	return newuser;
}

// free data, perform unlink if requested
static void QTV_FreeUser(qtvuser_t *user, qbool unlink)
{
	if (!user)
		return;

	if (unlink)
	{
		qtvuser_t *next, *prev, *current;

		prev = NULL;
		current = qtvuserlist;

		for ( ; current; )
		{
			next = current->next;

			if (user == current)
			{
				if (prev)
					prev->next = next;
				else
					qtvuserlist = next;

				break;
			}

			prev = current;
			current = next;
		}
	}

	Q_free(user);
}

// free whole qtvuserlist
void QTV_FreeUserList(void)
{
	qtvuser_t *next, *current;

	current = qtvuserlist;

	for ( ; current; current = next)
	{
		next = current->next;
		QTV_FreeUser(current, false);
	}

	qtvuserlist = NULL;
}

#define QTV_EVENT_PREFIX "QTV: "

// user join qtv
void QTV_JoinEvent(qtvuser_t *user, qtvuserlist_t event)
{
	// make it optional message, or if QUL_INIT, just return since we don't
	// need to spam which users are already on the QTV.
	if (!qtv_event_join.string[0] || qtv_event_msglevel.integer == 0 || event == QUL_INIT)
		return;

	// do not show "user joined" at moment of connection to QTV, it mostly QTV just spammed userlist to us.
	if (cls.state <= ca_demostart)
		return;

	if (QTV_UserById(user->id))
	{
		// we alredy have this user, do not double trigger
		return;
	}

	if (qtv_event_msglevel.integer == 1 ||
		(qtv_event_msglevel.integer == 2 && cls.state == ca_active && (cls.demoplayback || cl.standby)))

	{
		Com_Printf("%s%s%s\n", QTV_EVENT_PREFIX, user->name, qtv_event_join.string);
	}
}

// user leaved/left qtv
void QTV_LeaveEvent(qtvuser_t *user)
{
	qtvuser_t *olduser;

	// make it optional message
	if (!qtv_event_leave.string[0] || qtv_event_msglevel.integer == 0)
		return;

	if (!(olduser = QTV_UserById(user->id)))
	{
		// we do not have this user
		return;
	}

	if (qtv_event_msglevel.integer == 1 ||
		(qtv_event_msglevel.integer == 2 && cls.state == ca_active && (cls.demoplayback || cl.standby)))
	{
		Com_Printf("%s%s%s\n", QTV_EVENT_PREFIX, olduser->name, qtv_event_leave.string);
	}
}

// user changed name on qtv
void QTV_ChangeEvent(qtvuser_t *user)
{
	qtvuser_t *olduser;

	// well, too spammy, make it as option
	if (!qtv_event_changename.string[0] || qtv_event_msglevel.integer == 0)
		return;

	if (!(olduser = QTV_UserById(user->id)))
	{
		// we do not have this user yet
		Com_DPrintf("qtv: change event without olduser\n");
		return;
	}

	if (qtv_event_msglevel.integer == 1 ||
		(qtv_event_msglevel.integer == 2 && cls.state == ca_active && (cls.demoplayback || cl.standby)))
	{
		Com_Printf("%s%s%s%s\n", QTV_EVENT_PREFIX, olduser->name, qtv_event_changename.string, user->name);
	}
}

void Parse_QtvUserList(char *s)
{
	qtvuser_t		tmpuser;
	qtvuserlist_t	action;
	int				cnt = 1;
	
	memset(&tmpuser, 0, sizeof(tmpuser));

	// action id [\"name\"]

	Cmd_TokenizeString( s );

	action 		= atoi( Cmd_Argv( cnt++ ) );
	tmpuser.id	= atoi( Cmd_Argv( cnt++ ) );
	strlcpy(tmpuser.name, Cmd_Argv( cnt++ ), sizeof(tmpuser.name)); // name is optional in some cases

	switch ( action )
	{
		case QUL_ADD:
		case QUL_INIT:
			QTV_JoinEvent(&tmpuser, action);
			QTV_NewUser(&tmpuser);

		break;
		
		case QUL_CHANGE:
			QTV_ChangeEvent(&tmpuser);
			QTV_NewUser(&tmpuser);

		break;

		case QUL_DEL:
			QTV_LeaveEvent(&tmpuser);
			QTV_FreeUser(QTV_UserById(tmpuser.id), true);

		break;

		default:
			Com_Printf("Parse_QtvUserList: unknown action %d\n", action);

		return;
	}
}

// FIXME: make sexy GUI instead!
void Qtvusers_f (void)
{
	qtvuser_t *current;
	int c;

	if (cls.state == ca_disconnected)
	{
		Com_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
		return;
	}

	if (cls.mvdplayback != QTV_PLAYBACK)
	{
		CL_SendClientCommand(true, "%s %s", Cmd_Argv(0), Cmd_Args());
		return;
	}

	c = 0;
	Com_Printf ("userid name\n");
	Com_Printf ("------ ----\n");

	for (current = qtvuserlist; current; current = current->next)
	{
		Com_Printf ("%6i %s\n", current->id, current->name);
		c++;
	}

	Com_Printf ("%i total users\n", c);
}

qbool QTV_FindBestNick (const char *nick, char *result, size_t result_len)
{
	int best = 999999;
	char name[128], *match;

	qtvuser_t *current = NULL, *bestplayer = NULL;

	result[0] = 0;

	for (current = qtvuserlist; current; current = current->next)
	{
		if (!current->name[0])
			continue;

		strlcpy(name, current->name, sizeof(name));
		RemoveColors(name, sizeof (name));
		for (match = name; match[0]; match++)
			match[0] = tolower(match[0]);

		if (!name[0])
			continue;

		if ((match = strstr(name, nick)) && match - name < best)
		{
			best = match - name;
			bestplayer = current;
		}
	}

	if (bestplayer)
	{
		strlcpy(result, bestplayer->name, result_len);
		return true;
	}

	return false;
}

void QtvStartDelay_f(void)
{
	if (cls.mvdplayback != QTV_PLAYBACK) {
		Con_Printf("Can only be used during QTV playback.\n");
		return;
	}

	qtv_playback_paused = true;
}

void QtvEndDelay_f(void)
{
	int ms;

	if (Demo_BufferSize(&ms)) {
		Cvar_SetValue(&qtv_buffertime, ms / 1000.0f);
		Con_Printf("QTV delay set to %3.1fs.\n", qtv_buffertime.value);
	}
	else {
		Con_Printf("No QTV data in buffer: no delay set.\n");
	}

	qtv_playback_paused = false;
}



================================================
FILE: src/qtv.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// qtv.h - qtv related stuff

#ifndef __QTV_H__
#define __QTV_H__

//======================================

#define QTVPREBUFFERTIME (qtv_prebuffertime.value > 0 ? qtv_prebuffertime.value : bound(0.1, qtv_buffertime.value, 10))
#define QTVBUFFERTIME bound(0.1, qtv_buffertime.value, 30)

//======================================

#define QTV_VERSION			1.0f		// we are support up to this QTV version

// { QTV_EZQUAKE_EXT

#define QTV_EZQUAKE_EXT		"QTV_EZQUAKE_EXT"

#define QTV_EZQUAKE_EXT_DOWNLOAD	(1<<0)		// well, this is not just download, but also different connection process
#define QTV_EZQUAKE_EXT_SETINFO		(1<<1)		// does't qtv server/client support setinfo
#define QTV_EZQUAKE_EXT_QTVUSERLIST	(1<<2)		// does't qtv server/client support qtvuserlist command

#define QTV_EZQUAKE_EXT_NUM ( QTV_EZQUAKE_EXT_DOWNLOAD | QTV_EZQUAKE_EXT_SETINFO | QTV_EZQUAKE_EXT_QTVUSERLIST )

// }

// this just can't be done as macro, so I wrote function
char *QTV_CL_HEADER(float qtv_ver, int qtv_ezquake_ext);

// qqshka: It's all messy.
// For example ezquake (and FTE?) expect maximum message is MSG_BUF_SIZE == 8192 with mvd header which have not fixed size,
// however fuhquake uses less msg size as I recall.
// mvd header max size is 10 bytes.
// 
// MAX_MVD_SIZE - max size of single mvd message _WITHOUT_ header
#define	MAX_MVD_SIZE			(MSG_BUF_SIZE - 100)
//======================================

typedef enum {
	QUL_NONE = 0,	//
	QUL_ADD,		// user joined
	QUL_CHANGE,		// user changed something like name or something
	QUL_DEL,		// user dropped
	QUL_INIT		// user init
} qtvuserlist_t;

typedef struct qtvuser_s {
	int					id;								// unique user id
	char				name[MAX_INFO_KEY];				// client name, well must be unique too

	struct qtvuser_s	*next;							// next qtvuser_s struct in our list
} qtvuser_t;

void		QTV_FreeUserList(void);
void		Parse_QtvUserList(char *s);

qbool		QTV_FindBestNick (const char *nick, char *result, size_t result_len);

//======================================

extern cvar_t qtv_buffertime;
extern cvar_t qtv_prebuffertime;
extern cvar_t qtv_chatprefix;
extern cvar_t qtv_gamechatprefix;
extern cvar_t qtv_skipchained;
extern cvar_t qtv_adjustbuffer;
extern cvar_t qtv_adjustminspeed;
extern cvar_t qtv_adjustmaxspeed;
extern cvar_t qtv_adjustlowstart;
extern cvar_t qtv_adjusthighstart;
extern cvar_t qtv_allow_pause;

extern cvar_t qtv_event_join;
extern cvar_t qtv_event_leave;
extern cvar_t qtv_event_changename;

void QTV_Init(void);

//======================================

#define		dem_mask	(7)

int			ConsistantMVDDataEx(unsigned char *buffer, int remaining, int *ms, int max_packets);
int			ConsistantMVDData(unsigned char *buffer, int remaining, int max_packets);

//======================================
// qtv clc list
//

#define qtv_clc_stringcmd    1

//======================================

void		QTV_ForwardToServerEx (qbool skip_if_no_params, qbool use_first_argument);
void		QTV_Say_f (void);
void		QTV_Cmd_ForwardToServer (void);
void		QTV_Cl_ForwardToServer_f (void);
void		QTV_Cmd_Printf(int qtv_ext, char *fmt, ...);

#endif // __QTV_H__



================================================
FILE: src/quakedef.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// quakedef.h -- primary header for client


//define PARANOID // speed sapping error checking

#ifndef  __QUAKEDEF_H__
#define  __QUAKEDEF_H__

#include "common.h"

#include "vid.h"
#include "screen.h"
#include "render.h"
#include "draw.h"
#include "console.h"
#include "cl_view.h"
#include "fs.h"

#include "client.h"

// particles
typedef enum trail_type_s {
	ROCKET_TRAIL, GRENADE_TRAIL, ALT_ROCKET_TRAIL, BLOOD_TRAIL, BIG_BLOOD_TRAIL,
	TRACER1_TRAIL, TRACER2_TRAIL, VOOR_TRAIL,
	//VULT PARTICLES
	RAIL_TRAIL,
	RAIL_TRAIL2,
	LAVA_TRAIL,
	AMF_ROCKET_TRAIL,
	BLEEDING_TRAIL,
	BLEEDING_TRAIL2,
} trail_type_t;

void R_InitParticles(void);
void R_ClearParticles(void);
void R_DrawParticles(void);
void R_ParticleFrame(void);
void R_ParticleEndFrame(void);
void R_ReadPointFile_f(void);
void R_RunParticleEffect(vec3_t, vec3_t, int, int);
void R_ParticleTrail(vec3_t start, vec3_t end, trail_type_t type);
void R_EntityParticleTrail(centity_t* cent, trail_type_t type);
void R_BlobExplosion(vec3_t);
void R_ParticleExplosion(vec3_t);
void R_LavaSplash(vec3_t);
void R_TeleportSplash(vec3_t);
void Classic_InitParticles(void);
void Classic_ClearParticles(void);
void Classic_RunParticleEffect(vec3_t org, vec3_t dir, int color, int count);
void Classic_ParticleTrail(vec3_t start, vec3_t end, vec3_t *, trail_type_t type);
void Classic_ParticleRailTrail(vec3_t start, vec3_t end, int color);
void Classic_BlobExplosion(vec3_t org);
void Classic_ParticleExplosion(vec3_t org);
void Classic_LavaSplash(vec3_t org);
void Classic_TeleportSplash(vec3_t org);

typedef enum {
	texture_type_2d,
	texture_type_2d_array,
	texture_type_cubemap,
	texture_type_2d_multisampled,
	texture_type_count
} r_texture_type_id;

typedef enum {
	texture_minification_nearest,
	texture_minification_linear,
	texture_minification_nearest_mipmap_nearest,
	texture_minification_linear_mipmap_nearest,
	texture_minification_nearest_mipmap_linear,
	texture_minification_linear_mipmap_linear,

	texture_minification_count
} texture_minification_id;

typedef enum {
	texture_magnification_nearest,
	texture_magnification_linear,

	texture_magnification_count
} texture_magnification_id;

#if defined(_WIN32) && defined(_DEBUG)
#define DebugOutput(text) \
	if (IsDebuggerPresent()) { \
		OutputDebugString(text); \
	}
#else
#define DebugOutput(text)
#endif

#endif /* !__QUAKEDEF_H__ */


================================================
FILE: src/qwsvdef.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// qwsvdef.h -- primary header for server


//define	PARANOID			// speed sapping error checking

#include <time.h>
#include "common.h"
#include "fs.h"
#include "gl_model.h"
#include "server.h"

#include "net.h"
#include "crc.h"
#include "sha1.h"
#include "sha3.h"
#include "pmove.h"
#include "version.h"
#include "sv_log.h"
#include "sv_world.h"
#include "vfs.h"


================================================
FILE: src/r_aliasmodel.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// Alias model (.mdl) processing
// Most code taken from gl_rmain.c

#include "quakedef.h"
#include "gl_model.h"
#include "vx_stuff.h"
#include "vx_vertexlights.h"
#include "utils.h"
#include "qsound.h"
#include "hud.h"
#include "hud_common.h"
#include "rulesets.h"
#include "teamplay.h"
#include "r_aliasmodel.h"
#include "crc.h"
#include "qmb_particles.h"
#include "r_matrix.h"
#include "r_local.h"
#include "r_framestats.h"
#include "r_trace.h"
#include "r_lighting.h"
#include "r_renderer.h"

texture_ref shelltexture;
model_t* cl_custommodels[custom_model_count];

// precalculated dot products for quantized angles
byte      r_avertexnormal_dots[SHADEDOT_QUANT][NUMVERTEXNORMALS] =
#include "anorm_dots.h"
;
float     r_avertexnormals[NUMVERTEXNORMALS][3] = {
#include "anorms.h"
};
byte      *shadedots = r_avertexnormal_dots[0];

/*
==============================================================================
ALIAS MODELS
==============================================================================
*/

aliashdr_t	*pheader;

stvert_t	stverts[MAXALIASVERTS];
mtriangle_t	triangles[MAXALIASTRIS];

// a pose is a single set of vertexes.  a frame may be
// an animating sequence of poses
trivertx_t	*poseverts[MAXALIASFRAMES];
int			posenum;

static void* Mod_LoadAliasFrame(void* pin, maliasframedesc_t *frame, int* posenum);
static void* Mod_LoadAliasGroup(void* pin, maliasframedesc_t *frame, int* posenum);
void* Mod_LoadAllSkins(model_t* loadmodel, int numskins, daliasskintype_t *pskintype);

static cvar_t    gl_shaftlight = { "gl_shaftlight", "1" };
cvar_t    r_lerpmuzzlehack = { "r_lerpmuzzlehack", "1" };
cvar_t    gl_powerupshells_effect1level = { "gl_powerupshells_effect1level", "0.75" };
cvar_t    gl_powerupshells_base1level = { "gl_powerupshells_base1level", "0.05" };
cvar_t    gl_powerupshells_effect2level = { "gl_powerupshells_effect2level", "0.4" };
cvar_t    gl_powerupshells_base2level = { "gl_powerupshells_base2level", "0.1" };
cvar_t    gl_custom_grenade_tf = { "gl_custom_grenade_tf", "1" };

float     r_framelerp;

extern float     bubblecolor[NUM_DLIGHTTYPES][4];

extern cvar_t    r_lerpframes;
extern cvar_t    gl_outline;

static custom_model_color_t custom_model_colors[] = {
	// LG beam
	{
		{ "gl_custom_lg_color", "", CVAR_COLOR },
		{ "gl_custom_lg_fullbright", "1" },
		&amf_lightning,
		MOD_THUNDERBOLT,
		0,
		true
	},
	// Rockets
	{
		{ "gl_custom_rocket_color", "", CVAR_COLOR },
		{ "gl_custom_rocket_fullbright", "1" },
		NULL,
		MOD_ROCKET,
		0,
		true
	},
	// Grenades
	{
		{ "gl_custom_grenade_color", "", CVAR_COLOR },
		{ "gl_custom_grenade_fullbright", "1" },
		NULL,
		MOD_GRENADE,
		0,
		true
	},
	// Spikes
	{
		{ "gl_custom_spike_color", "", CVAR_COLOR },
		{ "gl_custom_spike_fullbright", "1" },
		&amf_part_spikes,
		MOD_SPIKE,
		0,
		true
	},
	// Backpacks with RL inside
	{
		{ "gl_custom_rlpack_color", "255 64 64", CVAR_COLOR },
		{ "", "0" },
		NULL,
		MOD_BACKPACK,
		RF_ROCKETPACK,
		false
	},
	// Backpacks with LG inside
	{
		{ "gl_custom_lgpack_color", "64 64 255", CVAR_COLOR },
		{ "", "0" },
		NULL,
		MOD_BACKPACK,
		RF_LGPACK,
		false
	}
};

static qbool IsFlameModel(model_t* model)
{
	return model->modhint == MOD_FLAME || model->modhint == MOD_FLAME0 || model->modhint == MOD_FLAME3;
}

static void R_RenderAliasModelEntity(
	entity_t* ent, aliashdr_t *paliashdr, byte *color32bit,
	texture_ref texture, texture_ref fb_texture, maliasframedesc_t* oldframe, maliasframedesc_t* frame,
	qbool outline, int effects
)
{
	int i;
	model_t* model = ent->model;

	if (!(ent->renderfx & RF_FORCECOLOURMOD))
		ent->r_modelcolor[0] = -1;  // by default no solid fill color for model, using texture
	if (color32bit) {
		// force some color for such model
		for (i = 0; i < 3; i++) {
			ent->r_modelcolor[i] = color32bit[i] / 255.0;
			ent->r_modelcolor[i] = bound(0, ent->r_modelcolor[i], 1);
		}

		fb_texture = null_texture_reference;
	}

	R_SetupAliasFrame(ent, model, oldframe, frame, outline, texture, fb_texture, effects, ent->renderfx);
}

qbool R_CullAliasModel(entity_t* ent, maliasframedesc_t* oldframe, maliasframedesc_t* frame)
{
	vec3_t mins, maxs;

	//culling
	if (!(ent->renderfx & RF_WEAPONMODEL)) {
		if (ent->angles[0] || ent->angles[1] || ent->angles[2]) {
			if (R_CullSphere(ent->origin, max(oldframe->radius, frame->radius))) {
				return true;
			}
		}
		else {
			if (r_framelerp == 1) {
				VectorAdd(ent->origin, frame->bboxmin, mins);
				VectorAdd(ent->origin, frame->bboxmax, maxs);
			}
			else {
				int i;
				for (i = 0; i < 3; i++) {
					mins[i] = ent->origin[i] + min(oldframe->bboxmin[i], frame->bboxmin[i]);
					maxs[i] = ent->origin[i] + max(oldframe->bboxmax[i], frame->bboxmax[i]);
				}
			}
			if (R_CullBox(mins, maxs)) {
				return true;
			}
		}
	}

	return false;
}

// FIXME: Move filtering options to cl_ents.c
qbool R_FilterEntity(entity_t* ent)
{
	// VULT NAILTRAIL - Hidenails
	if (amf_hidenails.value && ent->model->modhint == MOD_SPIKE) {
		return true;
	}

	// VULT ROCKETTRAILS - Hide rockets
	if (amf_hiderockets.value && (ent->model->flags & EF_ROCKET)) {
		return true;;
	}

	// VULT CAMERAS - Show/Hide playermodel
	if (ent->alpha == -1) {
		if (cameratype == C_NORMAL) {
			return true;
		}
		ent->alpha = 1;
		return false;
	}
	else if (ent->alpha < 0) {
		// VULT MOTION TRAILS
		return true;
	}

	// Handle flame/flame0 model changes
	if (qmb_initialized) {
		if (!amf_part_fire.integer && ent->model->modhint == MOD_FLAME0) {
			ent->model = cl.model_precache[cl_modelindices[mi_flame]];
		}
		else if (amf_part_fire.integer) {
			if (ent->model->modhint == MOD_FLAME0) {
				if (!ISPAUSED) {
					ParticleTorchFire(ent);
				}
			}
			else if (ent->model->modhint == MOD_FLAME && cl_custommodels[custom_model_flame0]) {
				// do we have progs/flame0.mdl?
				if (!ISPAUSED) {
					ParticleTorchFire(ent);
				}
				ent->model = cl_custommodels[custom_model_flame0];
			}
			else if (ent->model->modhint == MOD_FLAME2 || ent->model->modhint == MOD_FLAME3) {
				if (!ISPAUSED) {
					ParticleTorchFire(ent);
				}
				return true;
			}
		}
	}

	return false;
}

void R_OverrideModelTextures(entity_t* ent, texture_ref* texture, texture_ref* fb_texture, byte** color32bit)
{
	int playernum = -1;

	if (ent->scoreboard && (ent->renderfx & RF_VWEPMODEL) == 0) {
		playernum = ent->scoreboard - cl.players;
	}

	if (playernum >= 0 && playernum < MAX_CLIENTS) {
		R_SetSkinForPlayerEntity(ent, texture, fb_texture, color32bit);
	}
	// TODO: Can we move the custom_model logic to here?  If fullbright, nullify textures and set color?

	if (ent->full_light || !gl_fb_models.integer) {
		*fb_texture = null_texture_reference;
	}
}

static qbool R_CanDrawModelShadow(entity_t* ent)
{
	return (r_shadows.integer && !ent->full_light && !(ent->renderfx & RF_NOSHADOW)) && !ent->alpha;
}

void R_DrawAliasModel(entity_t *ent, qbool outline)
{
	int anim, skinnum;
	texture_ref texture, fb_texture;
	aliashdr_t* paliashdr;
	maliasframedesc_t *oldframe, *frame;
	byte *color32bit = NULL;
	float oldMatrix[16];

	if (R_FilterEntity(ent)) {
		return;
	}

	// Meag: Do not move this above R_FilterEntity(), it might change the model... :(
	paliashdr = (aliashdr_t *)Mod_Extradata(ent->model); // locate the proper data

	//VULT CORONAS
	if (amf_coronas.integer) {
		if (IsFlameModel(ent->model)) {
			//FIXME: This is slow and pathetic as hell, really we should just check the entity
			//alternatively add some kind of permanent client side TE for the torch
			NewStaticLightCorona(C_FIRE, ent->origin, ent->entity_id);
		}
		else if (ent->model->modhint == MOD_TELEPORTDESTINATION) {
			NewStaticLightCorona(C_LIGHTNING, ent->origin, ent->entity_id);
		}
	}

	ent->frame = bound(0, ent->frame, paliashdr->numframes - 1);
	ent->oldframe = bound(0, ent->oldframe, paliashdr->numframes - 1);

	frame = &paliashdr->frames[ent->frame];
	oldframe = &paliashdr->frames[ent->oldframe];

	r_framelerp = 1.0;
	if (r_lerpframes.integer && ent->framelerp >= 0 && ent->oldframe != ent->frame) {
		r_framelerp = min(ent->framelerp, 1);
	}

	if (R_CullAliasModel(ent, oldframe, frame)) {
		return;
	}

	frameStats.classic.polycount[polyTypeAliasModel] += paliashdr->numtris;

	R_TraceEnterRegion(va("%s(%s)", __func__, ent->model->name), true);
	R_PushModelviewMatrix(oldMatrix);
	R_StateBeginDrawAliasModel(ent, paliashdr);

	//get lighting information
	R_AliasSetupLighting(ent);
	shadedots = r_avertexnormal_dots[((int)(ent->angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1)];
	ent->r_modelalpha = (ent->alpha ? ent->alpha : 1);

	if (ent->r_modelalpha != 1 && outline) {
		// todo
		R_PopModelviewMatrix(oldMatrix);
		R_TraceLeaveRegion(true);
		return;
	}

	anim = (int)(r_refdef2.time * 10) & 3;
	skinnum = ent->skinnum;
	if (skinnum >= paliashdr->numskins || skinnum < 0) {
		Com_DPrintf("R_DrawAliasModel: no such skin # %d\n", skinnum);
		skinnum = 0;
	}

	texture = paliashdr->gl_texturenum[skinnum][anim];
	fb_texture = paliashdr->glc_fb_texturenum[skinnum][anim];

	R_OverrideModelTextures(ent, &texture, &fb_texture, &color32bit);
	R_RenderAliasModelEntity(ent, paliashdr, color32bit, texture, fb_texture, oldframe, frame, outline, ent->effects);
	R_PopModelviewMatrix(oldMatrix);

	if (R_CanDrawModelShadow(ent)) {
		renderer.DrawAliasModelShadow(ent);
	}

	R_TraceLeaveRegion(true);

	return;
}

int R_AliasFramePose(const maliasframedesc_t* frame)
{
	int pose, numposes;
	float interval;

	pose = frame->firstpose;
	numposes = frame->numposes;
	if (numposes > 1) {
		interval = frame->interval;
		pose += (int)(r_refdef2.time / interval) % numposes;
	}

	return pose;
}

void R_SetupAliasFrame(
	entity_t* ent,
	model_t* model,
	maliasframedesc_t *oldframe, maliasframedesc_t *frame,
	qbool outline,
	texture_ref texture, texture_ref fb_texture,
	int effects, int render_effects
)
{
	extern cvar_t gl_lumatextures;
	int oldpose, pose;
	float lerp;

	R_AliasModelDeterminePoses(oldframe, frame, &oldpose, &pose, &lerp);

	if (!gl_lumatextures.integer) {
		R_TextureReferenceInvalidate(fb_texture);
	}

	renderer.DrawAliasFrame(ent, model, oldpose, pose, texture, fb_texture, outline, effects, render_effects, lerp);
}

void R_AliasModelDeterminePoses(const maliasframedesc_t* oldframe, const maliasframedesc_t* frame, int* prevpose, int* nextpose, float* lerpfrac)
{
	int oldpose = R_AliasFramePose(oldframe);
	int pose = R_AliasFramePose(frame);
	float lerp = 0;

	if (oldframe->nextpose == pose) {
		lerp = r_framelerp;
	}
	else if (frame->nextpose == oldpose) {
		int temp = pose;

		pose = oldpose;
		oldpose = temp;
		lerp = (1 - r_framelerp);
	}
	else {
		lerp = 1;
	}

	if (lerp == 1) {
		oldpose = pose;
		lerp = 0;
	}
	else if (lerp == 0) {
		pose = oldpose;
	}

	*prevpose = oldpose;
	*nextpose = pose;
	*lerpfrac = lerp;
}

static void R_AliasModelScaleLight(entity_t* ent)
{
	float max_component;

	max_component = max(ent->lightcolor[0], ent->lightcolor[1]);
	max_component = max(max_component, ent->lightcolor[2]);

	if (max_component >= 256) {
		VectorScale(ent->lightcolor, 255 / max_component, ent->lightcolor);
	}
	else if (max_component < cl.minlight) {
		ent->lightcolor[0] += cl.minlight;
		ent->lightcolor[1] += cl.minlight;
		ent->lightcolor[2] += cl.minlight;
	}
}

static void R_AliasModelColoredLighting(entity_t* ent)
{
	int i, j, k, lnum;
	vec3_t dist;
	float add, added = 0;

	/* FIXME: dimman... cache opt from fod */
	//VULT COLOURED MODEL LIGHTS
	ent->bestlight = -1;
	for (i = 0; i < MAX_DLIGHTS / 32; i++) {
		if (!cl_dlight_active[i]) {
			continue;
		}

		for (j = 0; j < 32; j++) {
			if ((cl_dlight_active[i] & (1 << j)) && i * 32 + j < MAX_DLIGHTS) {
				lnum = i * 32 + j;

				VectorSubtract(ent->origin, cl_dlights[lnum].origin, dist);
				add = cl_dlights[lnum].radius - VectorLength(dist);

				if (add > 0) {
					vec3_t dlight_color;

					if (amf_lighting_vertex.integer && (ent->bestlight < 0 || cl_dlights[lnum].radius > cl_dlights[ent->bestlight].radius)) {
						ent->bestlight = lnum;
					}
					added += add;

					if (cl_dlights[lnum].type == lt_custom) {
						VectorCopy(cl_dlights[lnum].color, dlight_color);
						VectorScale(dlight_color, (1.0 / 255), dlight_color); // convert color from byte to float
					}
					else {
						VectorCopy(bubblecolor[cl_dlights[lnum].type], dlight_color);
					}

					for (k = 0; k < 3; k++) {
						ent->lightcolor[k] += (dlight_color[k] * add) * 2;
					}
				}
			}
		}
	}

	ent->ambientlight += added;
	R_AliasModelScaleLight(ent);
}

static void R_AliasModelStandardLighting(entity_t* ent)
{
	int i, j, lnum;
	vec3_t dist;
	float add, added = 0;

	/* FIXME: dimman... cache opt from fod */
	ent->bestlight = -1;
	for (i = 0; i < MAX_DLIGHTS / 32; i++) {
		if (cl_dlight_active[i]) {
			for (j = 0; j < 32; j++) {
				if ((cl_dlight_active[i] & (1 << j)) && i * 32 + j < MAX_DLIGHTS) {
					lnum = i * 32 + j;

					VectorSubtract(ent->origin, cl_dlights[lnum].origin, dist);
					add = cl_dlights[lnum].radius - VectorLength(dist);

					if (add > 0) {
						if (amf_lighting_vertex.integer && (ent->bestlight < 0 || cl_dlights[lnum].radius > cl_dlights[ent->bestlight].radius)) {
							ent->bestlight = lnum;
						}
						added += add;
					}
				}
			}
		}
	}

	ent->ambientlight += added;
	ent->lightcolor[0] += added;
	ent->lightcolor[1] += added;
	ent->lightcolor[2] += added;
}

void R_AliasSetupLighting(entity_t *ent)
{
	float fbskins = 0;
	unsigned int i;
	model_t* clmodel = ent->model;
	qbool player_model = (clmodel->modhint == MOD_PLAYER || ent->renderfx & RF_PLAYERMODEL);
	qbool calculate_lighting = true;

	//VULT COLOURED MODEL LIGHTING
	ent->custom_model = NULL;
	ent->ambientlight = ent->shadelight = 0;
	for (i = 0; i < sizeof(custom_model_colors) / sizeof(custom_model_colors[0]); ++i) {
		custom_model_color_t* test = &custom_model_colors[i];
		if (test->model_hint && test->model_hint == clmodel->modhint && (test->renderfx == 0 || test->renderfx == ent->renderfx)) {
			if (test->color_cvar.string[0] && (test->amf_cvar == NULL || test->amf_cvar->integer == 0)) {
				ent->custom_model = &custom_model_colors[i];
			}
			break;
		}
	}

	if (clmodel->modhint == MOD_GRENADE && !gl_custom_grenade_tf.integer && cl.teamfortress) {
		ent->custom_model = NULL;
	}

	if (ent->custom_model && ent->custom_model->fullbright_cvar.integer) {
		ent->ambientlight = 4096;
		ent->shadelight = 0;
		ent->full_light = true;
		return;
	}

	// make thunderbolt and torches full light
	if (clmodel->modhint == MOD_THUNDERBOLT) {
		ent->ambientlight = 60 + 150 * bound(0, gl_shaftlight.value, 1);
		ent->shadelight = 0;
		ent->full_light = true;
		return;
	}
	else if (clmodel->modhint == MOD_FLAME || clmodel->modhint == MOD_FLAME2) {
		ent->ambientlight = 255;
		ent->shadelight = 0;
		ent->full_light = true;
		return;
	}

	//normal lighting
	ent->full_light = false;
	if (player_model) {
		fbskins = bound(0, r_fullbrightSkins.value, r_refdef2.max_fbskins);
		if (fbskins >= 1 && gl_fb_models.integer == 1) {
			ent->ambientlight = ent->shadelight = 4096;
			ent->full_light = true;
			calculate_lighting = false;
		}
		else {
			ent->full_light = fbskins > 0;
			calculate_lighting = true;
		}
	}
	else if (Rulesets_FullbrightModel(clmodel)) {
		ent->ambientlight = ent->shadelight = 4096;
		calculate_lighting = (r_shadows.integer);
	}

	if (calculate_lighting) {
		R_LightEntity(ent);

		if (amf_lighting_colour.integer) {
			R_AliasModelColoredLighting(ent);
		}
		else {
			R_AliasModelStandardLighting(ent);
		}

		if (player_model) {
			ent->ambientlight = max(ent->ambientlight, 8 + fbskins * 120);
			ent->shadelight = max(ent->shadelight, 8 + fbskins * 120);
		}
		else {
			// clamp lighting so it doesn't overbright as much
			ent->ambientlight = min(ent->ambientlight, 128);
			if (ent->ambientlight + ent->shadelight > 192) {
				ent->shadelight = 192 - ent->ambientlight;
			}
		}
	}

	// always give the gun some light
	if ((ent->renderfx & RF_WEAPONMODEL) && ent->ambientlight < 24) {
		ent->ambientlight = ent->shadelight = 24;
	}

	// never allow players to go totally black
	if (player_model && ent->ambientlight < 8) {
		ent->ambientlight = ent->shadelight = 8;
	}

	if (ent->ambientlight < cl.minlight) {
		ent->ambientlight = ent->shadelight = cl.minlight;
	}
}

void R_DrawViewModel(void)
{
	extern cvar_t cl_drawgun;
	centity_t *cent = CL_WeaponModelForView();
	static entity_t gun;

	//VULT CAMERA - Don't draw gun in external camera
	if (cameratype != C_NORMAL) {
		return;
	}

	if (!r_drawentities.value || !cent->current.modelindex || cl_drawgun.value <= 0) {
		return;
	}

	memset(&gun, 0, sizeof(gun));

	if (!(gun.model = cl.model_precache[cent->current.modelindex])) {
		Host_Error("R_DrawViewModel: bad modelindex");
	}

	VectorCopy(cent->current.origin, gun.origin);
	VectorCopy(cent->current.angles, gun.angles);
	gun.colormap = vid.colormap;
	gun.renderfx = RF_WEAPONMODEL | RF_NOSHADOW | gun.model->renderfx;

	gun.effects |= (cl.stats[STAT_ITEMS] & IT_QUAD) ? EF_BLUE : 0;
	gun.effects |= (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) ? EF_RED : 0;
	gun.effects |= (cl.stats[STAT_ITEMS] & IT_SUIT) ? EF_GREEN : 0;

	gun.frame = cent->current.frame;
	if (cent->frametime >= 0 && cent->frametime <= r_refdef2.time) {
		gun.oldframe = cent->oldframe;
		gun.framelerp = (r_refdef2.time - cent->frametime) * 10;
	}
	else {
		gun.oldframe = gun.frame;
		gun.framelerp = -1;
	}
	//Con_Printf("Lerping %d=>%d\n", gun.oldframe, gun.frame);

	gun.alpha = bound(0, cl_drawgun.value, 1);

	if (R_UseImmediateOpenGL() && !gl_mtexable) {
		gun.alpha = 0;
	}

	switch (gun.model->type) {
		case mod_alias:
			// don't support outlining weaponmodel just yet
			R_DrawAliasModel(&gun, false);
			if (gun.effects) {
				renderer.DrawAliasModelPowerupShell(&gun);
			}
			break;
		case mod_alias3:
			renderer.DrawAlias3Model(&gun, false, false);
			if (gun.effects) {
				renderer.DrawAlias3ModelPowerupShell(&gun);
			}
			renderer.DrawAlias3Model(&gun, false, true);
			break;
		default:
			Com_Printf("Not drawing view model of type %i\n", gun.model->type);
			break;
	}
}

void R_InitAliasModelCvars(void)
{
	int i;

	for (i = 0; i < sizeof(custom_model_colors) / sizeof(custom_model_colors[0]); ++i) {
		Cvar_Register(&custom_model_colors[i].color_cvar);
		Cvar_Register(&custom_model_colors[i].fullbright_cvar);
	}

	Cvar_Register(&r_lerpmuzzlehack);
	Cvar_Register(&gl_shaftlight);

	Cvar_Register(&gl_powerupshells_base1level);
	Cvar_Register(&gl_powerupshells_effect1level);
	Cvar_Register(&gl_powerupshells_base2level);
	Cvar_Register(&gl_powerupshells_effect2level);
	Cvar_Register(&gl_custom_grenade_tf);
}

void Mod_LoadAliasModel(model_t *mod, void *buffer, int filesize, const char* loadname)
{
	int i, j, version, numframes, size, start, end, total;
	mdl_t *pinmodel;
	stvert_t *pinstverts;
	dtriangle_t *pintriangles;
	daliasframetype_t *pframetype;
	daliasskintype_t *pskintype;
	aliasframetype_t frametype;
	int posenum;

	//VULT MODELS
	Mod_AddModelFlags(mod);

	if (mod->modhint == MOD_PLAYER || mod->modhint == MOD_EYES) {
		mod->crc = CRC_Block(buffer, filesize);
	}

	start = Hunk_LowMark();

	pinmodel = (mdl_t *)buffer;

	version = LittleLong(pinmodel->version);

	if (version != ALIAS_VERSION) {
		Hunk_FreeToLowMark(start);
		Host_Error("Mod_LoadAliasModel: %s has wrong version number (%i should be %i)\n", mod->name, version, ALIAS_VERSION);
		return;
	}

	// allocate space for a working header, plus all the data except the frames, skin and group info
	size = sizeof(aliashdr_t) + (LittleLong(pinmodel->numframes) - 1) * sizeof(pheader->frames[0]);
	pheader = (aliashdr_t *)Hunk_AllocName(size, loadname);

	mod->flags = LittleLong(pinmodel->flags);

	// endian-adjust and copy the data, starting with the alias model header
	pheader->boundingradius = LittleFloat(pinmodel->boundingradius);
	pheader->numskins = LittleLong(pinmodel->numskins);
	pheader->skinwidth = LittleLong(pinmodel->skinwidth);
	pheader->skinheight = LittleLong(pinmodel->skinheight);

	if (pheader->skinheight > MAX_LBM_HEIGHT) {
		Host_Error("Mod_LoadAliasModel: model %s has a skin taller than %d", mod->name, MAX_LBM_HEIGHT);
	}

	pheader->numverts = LittleLong(pinmodel->numverts);

	if (pheader->numverts <= 0) {
		Host_Error("Mod_LoadAliasModel: model %s has no vertices", mod->name);
	}

	if (pheader->numverts > MAXALIASVERTS) {
		Host_Error("Mod_LoadAliasModel: model %s has too many vertices", mod->name);
	}

	pheader->numtris = LittleLong(pinmodel->numtris);

	if (pheader->numtris <= 0) {
		Host_Error("Mod_LoadAliasModel: model %s has no triangles", mod->name);
	}

	pheader->numframes = LittleLong(pinmodel->numframes);
	numframes = pheader->numframes;
	if (numframes < 1) {
		Host_Error("Mod_LoadAliasModel: model %s has invalid # of frames: %d\n", mod->name, numframes);
	}

	pheader->size = LittleFloat(pinmodel->size) * ALIAS_BASE_SIZE_RATIO;
	mod->synctype = LittleLong(pinmodel->synctype);
	mod->numframes = pheader->numframes;

	for (i = 0; i < 3; i++) {
		pheader->scale[i] = LittleFloat(pinmodel->scale[i]);
		pheader->scale_origin[i] = LittleFloat(pinmodel->scale_origin[i]);
		pheader->eyeposition[i] = LittleFloat(pinmodel->eyeposition[i]);
	}

	// load the skins
	pskintype = (daliasskintype_t *)&pinmodel[1];
	pskintype = Mod_LoadAllSkins(mod, pheader->numskins, pskintype);

	// load base s and t vertices
	pinstverts = (stvert_t *)pskintype;

	for (i = 0; i < pheader->numverts; i++) {
		stverts[i].onseam = LittleLong(pinstverts[i].onseam);
		stverts[i].s = LittleLong(pinstverts[i].s);
		stverts[i].t = LittleLong(pinstverts[i].t);
	}

	// load triangle lists
	pintriangles = (dtriangle_t *)&pinstverts[pheader->numverts];

	for (i = 0; i < pheader->numtris; i++) {
		triangles[i].facesfront = LittleLong(pintriangles[i].facesfront);

		for (j = 0; j < 3; j++) {
			int index = triangles[i].vertindex[j] = LittleLong(pintriangles[i].vertindex[j]);
			if (index < 0 || index >= pheader->numverts) {
				Host_Error("Mod_LoadAliasModel: model %s has invalid vertex ref (%d/%d)\n", mod->name, index, pheader->numverts);
			}
		}
	}

	// load the frames
	posenum = 0;
	pframetype = (daliasframetype_t *)&pintriangles[pheader->numtris];

	mod->mins[0] = mod->mins[1] = mod->mins[2] = 255;
	mod->maxs[0] = mod->maxs[1] = mod->maxs[2] = 0;

	for (i = 0; i < numframes; i++) {
		frametype = LittleLong(pframetype->type);

		if (frametype == ALIAS_SINGLE) {
			pframetype = (daliasframetype_t *)Mod_LoadAliasFrame(pframetype + 1, &pheader->frames[i], &posenum);
		}
		else {
			pframetype = (daliasframetype_t *)Mod_LoadAliasGroup(pframetype + 1, &pheader->frames[i], &posenum);
		}

		for (j = 0; j < 3; j++) {
			mod->mins[j] = min(mod->mins[j], pheader->frames[i].bboxmin[j]);
			mod->maxs[j] = max(mod->maxs[j], pheader->frames[i].bboxmax[j]);
		}
	}

	mod->radius = RadiusFromBounds(mod->mins, mod->maxs);

	pheader->numposes = posenum;

	mod->type = mod_alias;

	// build the draw lists
	renderer.PrepareAliasModel(mod, pheader);

	// move the complete, relocatable alias model to the cache
	end = Hunk_LowMark();
	total = end - start;

	mod->cached_data = Q_malloc(total);
	memcpy(mod->cached_data, pheader, total);

	// try load simple textures
	memset(mod->simpletexture, 0, sizeof(mod->simpletexture));
	for (i = 0; i < MAX_SIMPLE_TEXTURES && i < pheader->numskins; i++) {
		mod->simpletexture[i] = Mod_LoadSimpleTexture(mod, i);
	}

	Hunk_FreeToLowMark(start);
}

static void* Mod_LoadAliasFrame(void * pin, maliasframedesc_t *frame, int* posenum)
{
	trivertx_t *pinframe;
	int i, len;
	daliasframe_t *pdaliasframe;

	pdaliasframe = (daliasframe_t *)pin;

	strlcpy(frame->name, pdaliasframe->name, sizeof(frame->name));
	strlcpy(frame->groupname, frame->name, sizeof(frame->groupname));
	frame->firstpose = *posenum;
	frame->numposes = 1;
	frame->groupnumber = 0;

	for (len = strlen(frame->groupname); len > 0 && isdigit(frame->groupname[len - 1]); --len) {
		frame->groupnumber *= 10;
		frame->groupnumber += (frame->groupname[len - 1] - '0');

		frame->groupname[len - 1] = '\0';
	}

	for (i = 0; i < 3; i++) {
		// these are byte values, so we don't have to worry about endianness
		frame->bboxmin[i] = pdaliasframe->bboxmin.v[i] * pheader->scale[i] + pheader->scale_origin[i];
		frame->bboxmax[i] = pdaliasframe->bboxmax.v[i] * pheader->scale[i] + pheader->scale_origin[i];
	}
	frame->radius = RadiusFromBounds(frame->bboxmin, frame->bboxmax);

	pinframe = (trivertx_t *)(pdaliasframe + 1);

	poseverts[*posenum] = pinframe;
	(*posenum)++;

	pinframe += pheader->numverts;

	return (void *)pinframe;
}

static void* Mod_LoadAliasGroup(void * pin, maliasframedesc_t *frame, int* posenum)
{
	daliasgroup_t *pingroup;
	int i, numframes;
	daliasinterval_t *pin_intervals;
	void *ptemp;

	pingroup = (daliasgroup_t *)pin;

	numframes = LittleLong(pingroup->numframes);

	frame->firstpose = *posenum;
	frame->numposes = numframes;

	for (i = 0; i < 3; i++) {
		// these are byte values, so we don't have to worry about endianness
		frame->bboxmin[i] = pingroup->bboxmin.v[i] * pheader->scale[i] + pheader->scale_origin[i];
		frame->bboxmax[i] = pingroup->bboxmax.v[i] * pheader->scale[i] + pheader->scale_origin[i];
	}
	frame->radius = RadiusFromBounds(frame->bboxmin, frame->bboxmax);

	pin_intervals = (daliasinterval_t *)(pingroup + 1);
	frame->interval = LittleFloat(pin_intervals->interval);
	pin_intervals += numframes;

	ptemp = (void *)pin_intervals;
	for (i = 0; i < numframes; i++) {
		poseverts[*posenum] = (trivertx_t *)((daliasframe_t *)ptemp + 1);
		(*posenum)++;

		ptemp = (trivertx_t *)((daliasframe_t *)ptemp + 1) + pheader->numverts;
	}

	return ptemp;
}

maliasframedesc_t* R_AliasModelFindFrame(aliashdr_t* hdr, const char* framename, int framenumber)
{
	int f;

	for (f = 0; f < hdr->numframes; ++f) {
		maliasframedesc_t* frame = &hdr->frames[f];

		if (frame->groupnumber == framenumber && !strcmp(frame->groupname, framename)) {
			return frame;
		}
	}

	return NULL;
}

void R_AliasModelColor(const entity_t* ent, float* color, qbool* invalidate_texture)
{
	*invalidate_texture = false;

	if (ent->custom_model == NULL) {
		if (ent->r_modelcolor[0] < 0) {
			// normal color
			VectorSet(color, 1, 1, 1);
		}
		else {
			VectorCopy(ent->r_modelcolor, color);
		}
	}
	else {
		VectorScale(ent->custom_model->color_cvar.color, 1.0f / 255, color);

		*invalidate_texture = (ent->custom_model->fullbright_cvar.integer || ent->custom_model->disable_texturing);
	}
	VectorScale(color, ent->r_modelalpha, color);
	color[3] = ent->r_modelalpha;
}

void R_AliasModelPrepare(entity_t* ent, int framecount, int* frame1_, int* frame2_, float* lerpfrac, qbool* outline)
{
	extern cvar_t r_viewmodelsize, cl_drawgun;
	int frame1 = bound(0, ent->oldframe, framecount - 1);
	int frame2 = bound(0, ent->frame, framecount - 1);
	int expected1 = Mod_ExpectedNextFrame(ent->model, frame1, framecount);
	int expected2 = Mod_ExpectedNextFrame(ent->model, frame2, framecount);

	R_RotateForEntity(ent);
	if ((ent->renderfx & RF_WEAPONMODEL) && r_viewmodelsize.value < 1) {
		// perform scalling for r_viewmodelsize
		R_ScaleModelview(0.5 + bound(0, r_viewmodelsize.value, 1) / 2, 1, 1);
	}

	//
	ent->r_modelalpha = ((ent->renderfx & RF_WEAPONMODEL) && gl_mtexable) ? bound(0, cl_drawgun.value, 1) : 1;
	ent->r_modelalpha = (ent->alpha ? ent->alpha : ent->r_modelalpha);
	if (!(ent->renderfx & RF_FORCECOLOURMOD))
		ent->r_modelcolor[0] = -1;  // by default no solid fill color for model, using texture

	R_AliasSetupLighting(ent);

	if (!r_lerpframes.value || ent->framelerp < 0 || frame1 == frame2 || (frame2 != expected1 && frame1 != expected2)) {
		*lerpfrac = 1.0f;
	}
	else {
		*lerpfrac = min(ent->framelerp, 1.0f);
	}

	if (frame2 != expected1 && frame1 == expected2) {
		int temp = frame1;
		frame1 = frame2;
		frame2 = temp;
		*lerpfrac = 1.0f - *lerpfrac;
	}

	if (*lerpfrac == 1) {
		*lerpfrac = 0;
		frame1 = frame2;
	}

	*frame1_ = frame1;
	*frame2_ = frame2;

	// We don't support outline for transparent models,
	*outline &= ent->r_modelalpha == 1;
}


================================================
FILE: src/r_aliasmodel.h
================================================

#ifndef EZQUAKE_R_ALIASMODEL_HEADER
#define EZQUAKE_R_ALIASMODEL_HEADER

#include "r_buffers.h"

extern byte      *shadedots;

void R_AliasSetupLighting(entity_t *ent);

void GLM_DrawAliasModelFrame(
	entity_t* ent, model_t* model, int poseVertIndex, int poseVertIndex2, int vertsPerPose,
	texture_ref texture, qbool outline, int effects, int render_effects, float lerp_fraction
);

void* Mod_LoadAllSkins(model_t* loadmodel, int numskins, daliasskintype_t* pskintype);

extern cvar_t gl_powerupshells_base1level, gl_powerupshells_base2level;
extern cvar_t gl_powerupshells_effect1level, gl_powerupshells_effect2level;
extern cvar_t gl_fb_models, r_shadows, r_fullbrightSkins, r_drawentities;

void R_SetupAliasFrame(
	entity_t* ent,
	model_t* model,
	maliasframedesc_t *oldframe, maliasframedesc_t *frame,
	qbool outline, texture_ref texture, texture_ref fb_texture,
	int effects, int render_effects
);

#define ALIAS_BASE_SIZE_RATIO		(1.0 / 11.0)
// normalizing factor so player model works out to about
//  1 pixel per triangle
#define	MAX_LBM_HEIGHT		480

// FIXME: Get rid
extern qbool gl_mtexable;

extern texture_ref shelltexture;

void GLC_StateBeginMD3Draw(float alpha, qbool textured, qbool weapon, qbool additive_pass);
void R_StateBeginDrawAliasModel(const entity_t* e, aliashdr_t* paliashdr);

// gl_mesh.c
void R_AliasModelPopulateVBO(model_t* mod, vbo_model_vert_t* aliasModelBuffer, int position);
void R_CreateAliasModelVBO(void);

void GLC_StateBeginAliasPowerupShell(qbool weapon);
void GLC_AllocateAliasPoseBuffer(void);

void GLC_BeginCausticsTextureMatrix(void);
void GLC_EndCausticsTextureMatrix(void);

void R_DrawAliasModel(entity_t *ent, qbool outline);

qbool R_FilterEntity(entity_t* ent);
qbool R_CullAliasModel(entity_t* ent, maliasframedesc_t* oldframe, maliasframedesc_t* frame);

void R_AliasModelPrepare(entity_t* ent, int framecount, int* frame1, int* frame2, float* lerpfrac, qbool* outline);
int R_AliasFramePose(const maliasframedesc_t* frame);
maliasframedesc_t* R_AliasModelFindFrame(aliashdr_t* hdr, const char* framename, int framenumber);
void R_AliasModelColor(const entity_t* ent, float* color, qbool* invalidate_texture);

// Previous constant was 135, pre-scaling... this is in world coordinates now,
//   so picked a new constant that stopped the nailgun moving 
#define ALIASMODEL_MAX_LERP_DISTANCE (6.3)

void R_SetSkinForPlayerEntity(entity_t* ent, texture_ref* texture, texture_ref* fb_texture, byte** color32bit);
void R_AliasModelDeterminePoses(const maliasframedesc_t* oldframe, const maliasframedesc_t* frame, int* prevpose, int* nextpose, float* lerpfrac);

// FIXME: not really GL_, probably Vulkan too?
void GL_PrepareAliasModel(model_t* m, aliashdr_t* hdr);

#endif // EZQUAKE_R


================================================
FILE: src/r_aliasmodel_md3.c
================================================
/*
Copyright (C) 2011 fuh and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// Code to load MD3 files

#include "quakedef.h"
#include "gl_model.h"
#include "r_aliasmodel_md3.h"
#include "vx_vertexlights.h" 
#include "r_texture.h"
#include "r_buffers.h"
#include "r_local.h"

void GLM_MakeAlias3DisplayLists(model_t* model);

typedef float m3by3_t[3][3];

static int Mod_ReadFlagsFromMD1(char *name, int md3version)
{
	mdl_t* pinmodel;
	char fname[MAX_QPATH];
	COM_StripExtension(name, fname, sizeof(fname));
	COM_DefaultExtension(fname, ".md3", sizeof(fname));

	if (!strcmp(name, fname)) {
		//md3 renamed as mdl
		COM_StripExtension(name, fname, sizeof(fname));	//seeing as the md3 is named over the mdl,
		COM_DefaultExtension(fname, ".md1", sizeof(fname));//read from a file with md1 (one, not an ell)
	}
	else {
		COM_StripExtension(name, fname, sizeof(fname));
		COM_DefaultExtension(fname, ".mdl", sizeof(fname));
	}

	pinmodel = (mdl_t *)FS_LoadTempFile(fname, NULL);

	if (!pinmodel) {
		//not found
		return 0;
	}

	if (pinmodel->ident != IDPOLYHEADER) {
		return 0;
	}
	if (pinmodel->version != ALIAS_VERSION) {
		return 0;
	}
	return pinmodel->flags;
}

typedef struct md3_skin_list_entry_s {
	surfinf_t surface_info;
	int surface_number;
	int skin_number;

	struct md3_skin_list_entry_s* next;
} md3_skin_list_entry_t;

static void Mod_MD3LoadSkins(model_t* mod, md3Header_t* header, md3model_t* model)
{
	const char* alternative_names[] = { "default", "blue", "red", "green", "yellow" };
	char skinfileskinname[128];
	char strippedmodelname[128];
	int found_skins = 0;
	int surface = 0;
	md3Surface_t* surf;
	md3_skin_list_entry_t* skin_list = NULL;

	strlcpy(strippedmodelname, mod->name, sizeof(strippedmodelname));
	COM_StripExtension(strippedmodelname, strippedmodelname, sizeof(strippedmodelname));

	*skinfileskinname = '\0';

	// Load as many external skins as we can find
	while (true) {
		char *sfile, *sfilestart, *nl;
		char skinfile[128] = { 0 };
		int skinfile_length;

		snprintf(skinfile, sizeof(skinfile), "%s_%d.skin", strippedmodelname, found_skins);
		sfile = sfilestart = (char *)FS_LoadHeapFile(skinfile, &skinfile_length);

		if (!sfile) {
			// Try alternate name if we have one
			if (found_skins < sizeof(alternative_names) / sizeof(alternative_names[0])) {
				snprintf(skinfile, sizeof(skinfile), "%s_%s.skin", strippedmodelname, alternative_names[found_skins]);
				sfile = sfilestart = (char *)FS_LoadHeapFile(skinfile, &skinfile_length);
			}
			
			if (!sfile) {
				break;
			}
		}

		// Scan the file for the textures to use for each surface
		MD3_ForEachSurface(header, surf, surface) {
			int name_length = strlen(surf->name);
			md3_skin_list_entry_t* new_skin = Q_malloc(sizeof(md3_skin_list_entry_t));

			new_skin->next = skin_list;
			skin_list = new_skin;
			new_skin->surface_number = surface;
			new_skin->skin_number = found_skins;

			strlcpy(new_skin->surface_info.name, "textures/", sizeof(new_skin->surface_info.name));
			strlcat(new_skin->surface_info.name, surf->name, sizeof(new_skin->surface_info.name));

			// Search through the .skin file for the mapping from surface => texture
			for (sfile = sfilestart; sfile < sfilestart + skinfile_length && sfile[0]; sfile = nl + 1) {
				nl = strchr(sfile, '\n');
				if (!nl) {
					nl = sfile + skinfile_length;
				}
				if (sfile[name_length] == ',' && !strncasecmp(surf->name, sfile, name_length)) {
					strlcpy(new_skin->surface_info.name, sfile + name_length + 1, sizeof(new_skin->surface_info.name));
					new_skin->surface_info.name[min(sizeof(new_skin->surface_info.name) - 1, nl - (sfile + name_length + 1))] = '\0';
					nl = strchr(new_skin->surface_info.name, '\r');
					if (nl) {
						*nl = '\0';
					}
					break;
				}
				sfile = nl + 1;
			}
		}
		Q_free(sfilestart);

		++found_skins;
	}

	// End: make sure we allocate at least as many skins as defined in the model
	while (found_skins < max(header->numSkins, 1)) {
		MD3_ForEachSurface(header, surf, surface) {
			md3_skin_list_entry_t* new_skin = Q_malloc(sizeof(md3_skin_list_entry_t));
			new_skin->next = skin_list;
			skin_list = new_skin;
			strlcpy(new_skin->surface_info.name, "textures/", sizeof(new_skin->surface_info.name));
			strlcat(new_skin->surface_info.name, COM_SkipPath(surf->name), sizeof(new_skin->surface_info.name));
			++found_skins;
		}
	}

	header->numSkins = found_skins;

	// Convert linked list to array so it's moveable & easier to access
	surfinf_t* surface_info = Hunk_AllocName(sizeof(surfinf_t) * header->numSkins * header->numSurfaces, "md3surfinfo");
	model->surfinf = (int)((intptr_t)surface_info - (intptr_t)model);
	while (skin_list) {
		md3_skin_list_entry_t* next = skin_list->next;
		int surf_info_index = skin_list->skin_number * header->numSurfaces + skin_list->surface_number;

		surface_info[surf_info_index] = skin_list->surface_info;

		Q_free(skin_list);
		skin_list = next;
	}
}

void Mod_LoadAlias3Model(model_t *mod, void *buffer, int filesize)
{
	int start, end, total;
	int numsurfs;
	int surfn;

	md3model_t *pheader;
	md3Header_t *mem;
	surfinf_t *sinf;
	md3Surface_t *surf;
	md3Shader_t *sshad;
	md3Frame_t *mFrame;
	int fr, i, j;
	md3St_t *st;
	ezMd3XyzNormal_t* output_vert;

	start = Hunk_LowMark();

	mod->type = mod_alias3;
	Mod_AddModelFlags(mod);

	numsurfs = LittleLong(((md3Header_t *)buffer)->numSurfaces);

	pheader = (md3model_t *)Hunk_AllocName(sizeof(md3model_t), "md3model");
	mem = (md3Header_t *)Hunk_AllocName(filesize, "md3header");
	pheader->md3model = (char *)mem - (char *)pheader;
	memcpy(mem, buffer, filesize);	//casually load the entire thing. As you do.

	mem->ident = LittleLong(mem->ident);
	mem->version = LittleLong(mem->version);

	mem->flags = LittleLong(mem->flags);	//Does anyone know what these are?

	mem->numFrames = LittleLong(mem->numFrames);
	mem->numTags = LittleLong(mem->numTags);
	mem->numSurfaces = LittleLong(mem->numSurfaces);

	mem->numSkins = LittleLong(mem->numSkins);

	mem->ofsFrames = LittleLong(mem->ofsFrames);
	mem->ofsTags = LittleLong(mem->ofsTags);
	mem->ofsSurfaces = LittleLong(mem->ofsSurfaces);
	mem->ofsEnd = LittleLong(mem->ofsEnd);

	pheader->numframes = mem->numFrames;
	pheader->numtags = mem->numTags;
	pheader->ofstags = pheader->md3model + mem->ofsTags;
	for (fr = 0; fr < mem->numFrames; fr++) {
		mFrame = ((md3Frame_t *)((char *)mem + mem->ofsFrames)) + fr;
		for (j = 0; j < 3; j++) {
			mFrame->bounds[0][j] = LittleFloat(mFrame->bounds[0][j]);
			mFrame->bounds[1][j] = LittleFloat(mFrame->bounds[1][j]);
			mFrame->localOrigin[j] = LittleFloat(mFrame->localOrigin[j]);
		}
		mFrame->radius = LittleLong(mFrame->radius);
	}

	Mod_MD3LoadSkins(mod, mem, pheader);
	{
		sinf = (surfinf_t*)((char *)pheader + pheader->surfinf);
		surf = (md3Surface_t *)((char *)mem + mem->ofsSurfaces);
		for (surfn = 0; surfn < numsurfs; surfn++) {
			md3Triangle_t	*tris;
			md3XyzNormal_t	*vert;

			surf->ident = LittleLong(surf->ident);

			surf->flags = LittleLong(surf->flags);
			surf->numFrames = LittleLong(surf->numFrames);

			surf->numShaders = LittleLong(surf->numShaders);
			surf->numVerts = LittleLong(surf->numVerts);

			surf->numTriangles = LittleLong(surf->numTriangles);
			surf->ofsTriangles = LittleLong(surf->ofsTriangles);

			surf->ofsShaders = LittleLong(surf->ofsShaders);
			surf->ofsSt = LittleLong(surf->ofsSt);
			surf->ofsXyzNormals = LittleLong(surf->ofsXyzNormals);

			surf->ofsEnd = LittleLong(surf->ofsEnd);

			st = (md3St_t *)((char *)surf + surf->ofsSt);	//skin texture coords.
			for (i = 0; i < surf->numVerts; i++) {
				st[i].s = LittleFloat(st[i].s);
				st[i].t = LittleFloat(st[i].t);
			}

			// swap all the triangles
			tris = (md3Triangle_t *)((char *)surf + surf->ofsTriangles);
			for (j = 0; j < surf->numTriangles; j++) {
				tris[j].indexes[0] = LittleLong(tris[j].indexes[0]);
				tris[j].indexes[1] = LittleLong(tris[j].indexes[1]);
				tris[j].indexes[2] = LittleLong(tris[j].indexes[2]);
			}

			// swap all the vertices, convert to our format
			vert = (md3XyzNormal_t *)((char *)surf + surf->ofsXyzNormals);
			output_vert = (ezMd3XyzNormal_t*)Hunk_AllocName(surf->numVerts * surf->numFrames * sizeof(ezMd3XyzNormal_t), "md3normal");
			for (j = 0; j < surf->numVerts * surf->numFrames; j++) {
				vert[j].xyz[0] = LittleShort(vert[j].xyz[0]);
				vert[j].xyz[1] = LittleShort(vert[j].xyz[1]);
				vert[j].xyz[2] = LittleShort(vert[j].xyz[2]);
				vert[j].normal = LittleShort(vert[j].normal);

				VectorScale(vert[j].xyz, MD3_XYZ_SCALE, output_vert[j].xyz);
				{
					output_vert[j].normal_lat = ((vert[j].normal >> 8) & 255) * (2.0 * M_PI) / 255.0;
					output_vert[j].normal_lng = (vert[j].normal & 255) * (2.0 * M_PI) / 255.0;

					output_vert[j].normal[0] = cos(output_vert[j].normal_lat) * sin(output_vert[j].normal_lng);
					output_vert[j].normal[1] = sin(output_vert[j].normal_lat) * sin(output_vert[j].normal_lng);
					output_vert[j].normal[2] = cos(output_vert[j].normal_lng);
				}
			}
			surf->ofsXyzNormals = (char*)output_vert - (char*)surf;

			sshad = (md3Shader_t *)((char *)surf + surf->ofsShaders);
			sshad->shaderIndex = LittleLong(sshad->shaderIndex);

			for (i = 0; i < mem->numSkins; ++i) {
				char specifiedskinnameinfolder[128] = { 0 };
				char tenebraeskinname[128] = { 0 };

				// MEAG: Changed the load order here, tenebraeskinname can be over-written by the .skin file
				const char* potential_textures[] = {
					sinf->name,
					sshad->name,
					specifiedskinnameinfolder,
					tenebraeskinname
				};

				strlcpy(specifiedskinnameinfolder, "textures/", sizeof(specifiedskinnameinfolder));
				strlcat(specifiedskinnameinfolder, sshad->name, sizeof(specifiedskinnameinfolder));

				if (sshad->name[0]) {
					strlcpy(tenebraeskinname, mod->name, sizeof(tenebraeskinname)); //backup
					COM_SkipPathWritable(tenebraeskinname)[0] = '\0';
					strlcat(tenebraeskinname, sshad->name, sizeof(tenebraeskinname));
				}

				// Try and load
				for (j = 0; j < sizeof(potential_textures) / sizeof(potential_textures[0]); ++j) {
					if (potential_textures[j][0] && R_TextureReferenceIsValid(sinf->texnum = R_LoadTextureImage(potential_textures[j], potential_textures[j], 0, 0, 0))) {
						if (potential_textures[j] != sinf->name) {
							strlcpy(sinf->name, potential_textures[j], sizeof(sinf->name));
						}
						break;
					}
				}
				if (!R_TextureReferenceIsValid(sinf->texnum)) {
					sinf->texnum = R_LoadTextureImage("dummy", "dummy", 0, 0, 0);
					strlcpy(sinf->name, "dummy", sizeof(sinf->name));
				}
				++sinf;
			}

			surf = (md3Surface_t *)((char *)surf + surf->ofsEnd);
		}
	}

	end = Hunk_LowMark();
	total = end - start;

	mod->cached_data = Q_malloc(total);
	if (!mod->cached_data) {
		return;
	}
	memcpy(mod->cached_data, pheader, total);

	// try load simple textures
	memset(mod->simpletexture, 0, sizeof(mod->simpletexture));
	for (i = 0; i < sizeof(mod->simpletexture) / sizeof(mod->simpletexture[0]); ++i) {
		mod->simpletexture[i] = Mod_LoadSimpleTexture(mod, i);
		if (!R_TextureReferenceIsValid(mod->simpletexture[i])) {
			break;
		}
	}

	Hunk_FreeToLowMark(start);

	mod->flags = Mod_ReadFlagsFromMD1(mod->name, mem->flags);

	if (buffers.supported) {
		GLM_MakeAlias3DisplayLists(mod);
	}
}

/*
// Commented out for the moment, isn't used...
// if anyone is interested that is...
int GetTag(model_t *mod, char *tagname, int frame, float **org, m3by3_t **ang)
{
	md3model_t *mhead;
	md3tag_t *tag;
	int tnum;
	float bad[3] = { 0 };
	m3by3_t badm = { {0} };

	*org = bad;
	*ang = &badm;

	if (mod->type != mod_alias3) {
		return false;
	}

	mhead = (md3model_t *)Mod_Extradata(mod);
	if (frame > mhead->numframes) {
		frame = 0;
	}

	tag = (md3tag_t *)((char *)mhead + mhead->ofstags);
	tag += frame*mhead->numtags;

	for (tnum = 0;tnum < mhead->numtags; tnum++) {
		if (!strcasecmp(tag->name, tagname)) {
			*org = tag->org;
			*ang = &tag->ang;
			return true;
		}
		tag++;
	}

	return false;
}*/

// Helper functions to simplify logic
md3Surface_t* MD3_NextSurface(md3Surface_t* surf)
{
	return (md3Surface_t *)((uintptr_t)surf + surf->ofsEnd);
}

md3Surface_t* MD3_FirstSurface(md3Header_t* header)
{
	return (md3Surface_t *)((uintptr_t)header + header->ofsSurfaces);
}

md3St_t* MD3_SurfaceTextureCoords(md3Surface_t* surface)
{
	return (md3St_t *)((uintptr_t)surface + surface->ofsSt);
}

ezMd3XyzNormal_t* MD3_SurfaceVertices(md3Surface_t* surface)
{
	return (ezMd3XyzNormal_t *)((uintptr_t)surface + surface->ofsXyzNormals);
}

md3Triangle_t* MD3_SurfaceTriangles(md3Surface_t* surface)
{
	return (md3Triangle_t*)((uintptr_t)surface + surface->ofsTriangles);
}

surfinf_t* MD3_ExtraSurfaceInfoForModel(md3model_t* model)
{
	return (surfinf_t *)((uintptr_t)model + model->surfinf);
}

md3Header_t* MD3_HeaderForModel(md3model_t* model)
{
	return (md3Header_t *)((uintptr_t)model + model->md3model);
}


================================================
FILE: src/r_aliasmodel_md3.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef _GL_MD3_H_
#define _GL_MD3_H_

#define MD3_IDENT		(('3'<<24)+('P'<<16)+('D'<<8)+'I')

#define	MD3_XYZ_SCALE	(1.0 / 64)

void Mod_LoadAlias3Model (model_t *mod, void *buffer, int filesize);
struct entity_s;	//whoops

//structures from Tenebrae
typedef struct {
	int			ident;
	int			version;

	char		name[MAX_QPATH];

	int			flags;	//Does anyone know what these are?

	int			numFrames;
	int			numTags;			
	int			numSurfaces;

	int			numSkins;

	int			ofsFrames;
	int			ofsTags;
	int			ofsSurfaces;
	int			ofsEnd;
} md3Header_t;

//then has header->numFrames of these at header->ofs_Frames
typedef struct md3Frame_s {
	vec3_t		bounds[2];
	vec3_t		localOrigin;
	float		radius;
	char		name[16];
} md3Frame_t;

//there are header->numSurfaces of these at header->ofsSurfaces, following from ofsEnd
typedef struct {
	int		ident;				// 

	char	name[MAX_QPATH];	// polyset name

	int		flags;
	int		numFrames;			// all surfaces in a model should have the same

	int		numShaders;			// all surfaces in a model should have the same
	int		numVerts;

	int		numTriangles;
	int		ofsTriangles;

	int		ofsShaders;			// offset from start of md3Surface_t
	int		ofsSt;				// texture coords are common for all frames
	int		ofsXyzNormals;		// numVerts * numFrames (after loading this now points to ezMd3NormalXyz_t)

	int		ofsEnd;				// next surface follows
} md3Surface_t;

//at surf+surf->ofsXyzNormals (on initial load only, then that points to ezMd3NormalXyz_t)
typedef struct {
	short		xyz[3];
	unsigned short normal;
} md3XyzNormal_t;

typedef struct {
	vec3_t      xyz;
	vec3_t      normal;
	float       normal_lat;
	float       normal_lng;
} ezMd3XyzNormal_t;

//surf->numTriangles at surf+surf->ofsTriangles
typedef struct {
	int			indexes[3];
} md3Triangle_t;

//surf->numVerts at surf+surf->ofsSt
typedef struct {
	float		s;
	float		t;
} md3St_t;

typedef struct {
	char			name[MAX_QPATH];
	int				shaderIndex;
} md3Shader_t;
//End of Tenebrae 'assistance'

typedef struct {
	char name[MAX_QPATH];
	vec3_t org;
	float ang[3][3];
} md3tag_t;

//extra surfinfo
typedef struct {
	char name[MAX_QPATH];	//FIXME: pointer to shader. Requires model recaching when shader info is wiped though.
	texture_ref texnum;
} surfinf_t;

typedef struct {
	int surfinf;		//ofs, surfs*skins
	int md3model;	//ofs md3Header_t

	int ofstags;
	int numtags;
	int numframes;
} md3model_t;

md3Surface_t* MD3_NextSurface(md3Surface_t* surf);
md3Surface_t* MD3_FirstSurface(md3Header_t* header);
md3St_t* MD3_SurfaceTextureCoords(md3Surface_t* surface);
ezMd3XyzNormal_t* MD3_SurfaceVertices(md3Surface_t* surface);
md3Triangle_t* MD3_SurfaceTriangles(md3Surface_t* surface);
surfinf_t* MD3_ExtraSurfaceInfoForModel(md3model_t* model);
md3Header_t* MD3_HeaderForModel(md3model_t* model);

#define MD3_ForEachSurface(header, surface, surfnum) \
	for ((surfnum) = 0, (surface) = MD3_FirstSurface(header); (surfnum) < (header)->numSurfaces; ++(surfnum), (surface) = MD3_NextSurface(surface))

#endif


================================================
FILE: src/r_aliasmodel_mesh.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// gl_mesh.c: triangle model functions

#include "quakedef.h"
#include "gl_model.h"
#include "r_local.h"
#include "r_aliasmodel.h"
#include "glsl/constants.glsl"

#ifdef RENDERER_OPTION_MODERN_OPENGL
void GLM_CreateAliasModelVAO(void);
#endif

// Also used by .md3
void GL_AliasModelSetVertexDirection(int num_triangles, vbo_model_vert_t* vbo_buffer, int v1, int v2, qbool limit_lerp, int key_pose)
{
	int j, k;

	for (j = 0; j < num_triangles; ++j) {
		for (k = 0; k < 3; ++k, ++v1, ++v2) {
			VectorSubtract(vbo_buffer[v2].position, vbo_buffer[v1].position, vbo_buffer[v1].direction);

			vbo_buffer[v1].flags = 0;
			if (limit_lerp) {
				if ((vbo_buffer[v1].position[0] > 0) != (vbo_buffer[v2].position[0] > 0)) {
					vbo_buffer[v1].flags |= AM_VERTEX_NOLERP;
				}
			}
		}
	}
}

// Also used by .md3
void GL_AliasModelFixNormals(vbo_model_vert_t* vbo_buffer, int v, int vertsPerPose)
{
	int j, k;
	vec3_t new_normal;  // 2020...
	int matches;

	for (j = 0; j < vertsPerPose; ++j) {
		if (vbo_buffer[v + j].flags & AM_VERTEX_NORMALFIXED) {
			continue;
		}

		VectorCopy(vbo_buffer[v + j].normal, new_normal);
		matches = 1;

		for (k = j + 1; k < vertsPerPose; ++k) {
			if (VectorCompare(vbo_buffer[v + j].position, vbo_buffer[v + k].position)) {
				VectorAdd(new_normal, vbo_buffer[v + k].normal, new_normal);
				++matches;
			}
		}

		if (matches > 1) {
			VectorScale(new_normal, 1.0f / matches, new_normal);

			VectorCopy(new_normal, vbo_buffer[v + j].normal);
			for (k = j + 1; k < vertsPerPose; ++k) {
				if (VectorCompare(vbo_buffer[v + j].position, vbo_buffer[v + k].position)) {
					VectorCopy(new_normal, vbo_buffer[v + k].normal);
					vbo_buffer[v + k].flags |= AM_VERTEX_NORMALFIXED;
				}
			}
		}
	}
}

void GL_PrepareAliasModel(model_t* m, aliashdr_t* hdr)
{
	// 
	extern float r_avertexnormals[NUMVERTEXNORMALS][3];
	vbo_model_vert_t* vbo_buffer;
	int pose, j, k, v;
	int f;

	v = 0;
	hdr->poseverts = hdr->vertsPerPose = 3 * hdr->numtris;
	m->vertsInVBO = hdr->vertsPerPose * hdr->numposes;
	m->temp_vbo_buffer = vbo_buffer = Q_malloc_named(m->vertsInVBO * sizeof(vbo_model_vert_t), m->name);

	// 
	for (pose = 0; pose < hdr->numposes; ++pose) {
		v = pose * hdr->vertsPerPose;
		for (j = 0; j < hdr->numtris; ++j) {
			for (k = 0; k < 3; ++k, ++v) {
				trivertx_t* src;
				float x, y, z, s, t;
				int l;
				int vert = triangles[j].vertindex[k];

				src = &poseverts[pose][vert];

				l = src->lightnormalindex;
				x = src->v[0] * hdr->scale[0] + hdr->scale_origin[0];
				y = src->v[1] * hdr->scale[1] + hdr->scale_origin[1];
				z = src->v[2] * hdr->scale[2] + hdr->scale_origin[2];
				if (m->modhint == MOD_EYES) {
					x *= 2;
					y *= 2;
					z *= 2;
					z -= 30;
				}
				s = stverts[vert].s;
				t = stverts[vert].t;

				if (!triangles[j].facesfront && stverts[vert].onseam) {
					s += pheader->skinwidth / 2;	// on back side
				}
				s = (s + 0.5) / pheader->skinwidth;
				t = (t + 0.5) / pheader->skinheight;

				memset(&vbo_buffer[v], 0, sizeof(vbo_buffer[v]));
				VectorSet(vbo_buffer[v].position, x, y, z);
				vbo_buffer[v].texture_coords[0] = s;
				vbo_buffer[v].texture_coords[1] = t;
				VectorCopy(r_avertexnormals[l], vbo_buffer[v].normal);
				vbo_buffer[v].flags = 0;
				vbo_buffer[v].lightnormalindex = l;
			}
		}

		GL_AliasModelFixNormals(vbo_buffer, pose * hdr->vertsPerPose, hdr->vertsPerPose);
	}

	// Go back through and set directions
	for (f = 0; f < hdr->numframes; ++f) {
		maliasframedesc_t* frame = &hdr->frames[f];

		if (frame->numposes > 1) {
			// This frame has animated poses, so link them all together
			for (pose = 0; pose < frame->numposes - 1; ++pose) {
				GL_AliasModelSetVertexDirection(hdr->numtris, vbo_buffer, hdr->vertsPerPose * (frame->firstpose + pose), hdr->vertsPerPose * (frame->firstpose + pose + 1), m->renderfx & RF_LIMITLERP, 0);
			}
		}
		else {
			// Find next frame's pose
			maliasframedesc_t* frame2 = R_AliasModelFindFrame(hdr, frame->groupname, frame->groupnumber + 1);
			if (!frame2) {
				frame2 = R_AliasModelFindFrame(hdr, frame->groupname, 1 + Mod_ExpectedNextFrame(m, frame->groupnumber, hdr->numframes));
			}

			if (frame2) {
				GL_AliasModelSetVertexDirection(hdr->numtris, vbo_buffer, hdr->vertsPerPose * frame->firstpose, hdr->vertsPerPose * frame2->firstpose, m->renderfx & RF_LIMITLERP, 0);
				frame->nextpose = frame2->firstpose;
			}
		}
	}
}

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
extern cvar_t gl_program_aliasmodels;
#define R_GLSLAliasModelRendering() ((!R_UseImmediateOpenGL()) || gl_program_aliasmodels.integer)
#else
#define R_GLSLAliasModelRendering() (1)
#endif

void R_AliasModelPopulateVBO(model_t* mod, vbo_model_vert_t* aliasModelBuffer, int position)
{
	// Don't delete if using immediate mode as we loop over them ourselves
	if (mod->temp_vbo_buffer && R_GLSLAliasModelRendering()) {
		memcpy(aliasModelBuffer + position, mod->temp_vbo_buffer, mod->vertsInVBO * sizeof(vbo_model_vert_t));

		mod->vbo_start = position;
		Q_free(mod->temp_vbo_buffer);
	}
}

static void R_ImportSpriteCoordsToVBO(vbo_model_vert_t* verts, int* position)
{
	verts = &verts[*position];

	memset(verts, 0, sizeof(vbo_model_vert_t) * 4);

	VectorSet(verts[0].position, 0, -1, -1);
	verts[0].texture_coords[0] = 1;
	verts[0].texture_coords[1] = 1;
	verts[0].flags = 0;

	VectorSet(verts[1].position, 0, -1, 1);
	verts[1].texture_coords[0] = 1;
	verts[1].texture_coords[1] = 0;
	verts[1].flags = 1;

	VectorSet(verts[2].position, 0, 1, 1);
	verts[2].texture_coords[0] = 0;
	verts[2].texture_coords[1] = 0;
	verts[2].flags = 2;

	VectorSet(verts[3].position, 0, 1, -1);
	verts[3].texture_coords[0] = 0;
	verts[3].texture_coords[1] = 1;
	verts[3].flags = 3;

	*position += 4;
}

static void R_ImportModelToVBO(model_t* mod, vbo_model_vert_t* aliasmodel_data, int* new_vbo_position)
{
	if (mod->type == mod_alias || mod->type == mod_alias3) {
		R_AliasModelPopulateVBO(mod, aliasmodel_data, *new_vbo_position);
		*new_vbo_position += mod->vertsInVBO;
	}
	else if (mod->type == mod_sprite) {
		mod->vbo_start = 0;
	}
	else if (mod->type == mod_brush) {
		mod->vbo_start = 0;
	}
}

void R_CreateAliasModelVBO(void)
{
	vbo_model_vert_t* aliasModelData;
	int new_vbo_position = 0;
	int required_vbo_length = 4;
	int i;

	for (i = 1; i < MAX_MODELS; ++i) {
		model_t* mod = cl.model_precache[i];

		if (mod && (mod->type == mod_alias || mod->type == mod_alias3)) {
			required_vbo_length += mod->vertsInVBO;
		}
	}

	for (i = 0; i < MAX_VWEP_MODELS; i++) {
		model_t* mod = cl.vw_model_precache[i];

		if (mod && (mod->type == mod_alias || mod->type == mod_alias3)) {
			required_vbo_length += mod->vertsInVBO;
		}
	}

	// custom models are explicitly loaded by client, not notified by server
	for (i = 0; i < custom_model_count; ++i) {
		model_t* mod = Mod_CustomModel(i, false);

		if (mod && (mod->type == mod_alias || mod->type == mod_alias3)) {
			required_vbo_length += mod->vertsInVBO;
		}
	}

	// Go back through all models, populating VBO content
	aliasModelData = Q_malloc(required_vbo_length * sizeof(vbo_model_vert_t));

	// VBO starts with simple-model/sprite vertices
	R_ImportSpriteCoordsToVBO(aliasModelData, &new_vbo_position);

	for (i = 1; i < MAX_MODELS; ++i) {
		model_t* mod = cl.model_precache[i];

		if (mod) {
			R_ImportModelToVBO(mod, aliasModelData, &new_vbo_position);
		}
	}

	for (i = 0; i < MAX_VWEP_MODELS; i++) {
		model_t* mod = cl.vw_model_precache[i];

		if (mod) {
			R_ImportModelToVBO(mod, aliasModelData, &new_vbo_position);
		}
	}

	for (i = 0; i < custom_model_count; ++i) {
		model_t* mod = Mod_CustomModel(i, false);

		if (mod) {
			R_ImportModelToVBO(mod, aliasModelData, &new_vbo_position);
		}
	}

	buffers.Create(r_buffer_aliasmodel_vertex_data, buffertype_vertex, "aliasmodel-vertex-data", required_vbo_length * sizeof(vbo_model_vert_t), aliasModelData, bufferusage_reuse_many_frames);
#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		GLM_CreateAliasModelVAO();
#ifdef EZQ_GL_BINDINGPOINT_ALIASMODEL_SSBO
		aliasModel_ssbo = buffers.Create(buffertype_storage, "aliasmodel-vertex-ssbo", required_vbo_length * sizeof(vbo_model_vert_t), aliasModelData, bufferusage_constant_data);
		buffers.BindBase(aliasModel_ssbo, EZQ_GL_BINDINGPOINT_ALIASMODEL_SSBO);
#endif
	}
#endif
	Q_free(aliasModelData);

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_AllocateAliasPoseBuffer();
	}
#endif
}


================================================
FILE: src/r_aliasmodel_skins.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// Alias model (.mdl) skin processing
// Most code taken from gl_rmain.c

#include "quakedef.h"
#include "gl_model.h"
#include "rulesets.h"
#include "r_texture.h"
#include "r_local.h"
#include "image.h"

static void Mod_FloodFillSkin(byte *skin, int skinwidth, int skinheight);

//byte player_8bit_texels[320 * 200];
byte player_8bit_texels[256*256]; // Workaround for new player model, isn't proper for "real" quake skins

void R_CompressFullbrightTexture(byte* skin_pixels, int skin_width, int skin_height, byte* fb_pixels, int fb_width, int fb_height)
{
	int x, y;

	// adjust fb-texture to add alpha (this is from (TEX_FULLBRIGHT | TEX_LUMA) processing)
	for (x = 0; x < skin_width; ++x) {
		for (y = 0; y < skin_height; ++y) {
			int base = (x + y * skin_width) * 4;
			extern cvar_t gl_wicked_luma_level;

			// For luma textures that don't have alpha component (or are just incorrect)
			if (fb_pixels[base] < gl_wicked_luma_level.integer && fb_pixels[base + 1] < gl_wicked_luma_level.integer && fb_pixels[base + 2] < gl_wicked_luma_level.integer) {
				fb_pixels[base] = fb_pixels[base + 1] = fb_pixels[base + 2] = fb_pixels[base + 3] = 0;
			}
		}
	}

	// re-scale fb texture to match underlying skin
	R_TextureRescaleOverlay(&fb_pixels, &fb_width, &fb_height, skin_width, skin_height);

	// Merge the fb texture with the original
	for (x = 0; x < skin_width; ++x) {
		for (y = 0; y < skin_height; ++y) {
			int base = (x + y * skin_width) * 4;

			skin_pixels[base + 3] = 255;
			if (fb_pixels[base + 3]) {
				float a = fb_pixels[base + 3] / 255.0f;
				int orig = skin_pixels[base];

				skin_pixels[base] = (byte)bound(0, (int)orig * (1 - a) + (int)fb_pixels[base] * a, 255);
				skin_pixels[base + 1] = (byte)bound(0, (int)orig * (1 - a) + (int)fb_pixels[base + 1] * a, 255);
				skin_pixels[base + 2] = (byte)bound(0, (int)orig * (1 - a) + (int)fb_pixels[base + 2] * a, 255);
				skin_pixels[base + 3] = (1 - a) * 255;
			}
		}
	}

	Q_free(fb_pixels);
}

static texture_ref Mod_LoadExternalSkin(model_t* loadmodel, char *identifier, texture_ref *fb_texnum)
{
	char loadpath[MAX_OSPATH] = {0};
	int texmode = 0, luma_texmode;
	texture_ref texnum;
	qbool luma_allowed = Ruleset_IsLumaAllowed(loadmodel);
	int skin_width = 0, skin_height = 0;
	int luma_width = 0, luma_height = 0;
	byte* skin_pixels = NULL;
	byte* luma_pixels = NULL;

	R_TextureReferenceInvalidate(texnum);
	R_TextureReferenceInvalidate(*fb_texnum);

	if (gl_no24bit.integer || RuleSets_DisallowExternalTexture(loadmodel)) {
		return texnum;
	}

	texmode |= TEX_MIPMAP;
	texmode |= (loadmodel->modhint == MOD_VMODEL ? TEX_VIEWMODEL : 0);
	texmode |= (!gl_scaleModelTextures.value ? TEX_NOSCALE : 0);
	luma_texmode = texmode | TEX_FULLBRIGHT | TEX_ALPHA | TEX_LUMA;

	// try "textures/models/..." path
	strlcpy(loadpath, "textures/models/", sizeof(loadpath));
	strlcat(loadpath, identifier, sizeof(loadpath));
	skin_pixels = R_LoadImagePixels(loadpath, 0, 0, texmode, &skin_width, &skin_height);

	if (!skin_pixels) {
		// try "textures/..." path
		strlcpy(loadpath, "textures/", sizeof(loadpath));
		strlcat(loadpath, identifier, sizeof(loadpath));

		skin_pixels = R_LoadImagePixels(loadpath, 0, 0, texmode, &skin_width, &skin_height);
	}

	if (skin_pixels && luma_allowed) {
		// not a luma actually, but which suffix use then? _fb or what?
		strlcat(loadpath, "_luma", sizeof(loadpath));

		luma_pixels = R_LoadImagePixels(loadpath, 0, 0, luma_texmode, &luma_width, &luma_height);
	}

	if (R_CompressFullbrightTextures() && skin_pixels && luma_pixels) {
		R_CompressFullbrightTexture(skin_pixels, skin_width, skin_height, luma_pixels, luma_width, luma_height);

		texmode |= (TEX_ALPHA | TEX_MERGED_LUMA);
		luma_pixels = NULL;
	}

	if (skin_pixels) {
		texnum = R_LoadTexturePixels(skin_pixels, identifier, skin_width, skin_height, texmode);
		if (luma_pixels) {
			*fb_texnum = R_LoadTexturePixels(luma_pixels, va("@fb_%s", identifier), luma_width, luma_height, luma_texmode);
			Q_free(luma_pixels);
		}

		Q_free(skin_pixels);
	}

	return texnum;
}

void* Mod_LoadAllSkins(model_t* loadmodel, int numskins, daliasskintype_t* pskintype)
{
	int i, j, k, s, groupskins, texmode = 0;
	texture_ref gl_texnum, fb_texnum;
	char basename[64], identifier[64];
	byte *skin;
	daliasskingroup_t *pinskingroup;
	daliasskininterval_t *pinskinintervals;

	skin = (byte *)(pskintype + 1);

	if (numskins < 1 || numskins > MAX_SKINS) {
		Host_Error("Mod_LoadAllSkins: Invalid # of skins: %d (model %s)\n", numskins, loadmodel->name);
	}

	s = pheader->skinwidth * pheader->skinheight;

	COM_StripExtension(COM_SkipPath(loadmodel->name), basename, sizeof(basename));

	texmode |= TEX_MIPMAP;
	texmode |= (loadmodel->modhint == MOD_VMODEL ? TEX_VIEWMODEL : 0);
	texmode |= (!gl_scaleModelTextures.value && !loadmodel->isworldmodel) ? TEX_NOSCALE : 0;

	for (i = 0; i < numskins; i++) {
		if (pskintype->type == ALIAS_SKIN_SINGLE) {
			Mod_FloodFillSkin(skin, pheader->skinwidth, pheader->skinheight);

			// save 8 bit texels for the player model to remap
			if (loadmodel->modhint == MOD_PLAYER) {
				if (s > sizeof(player_8bit_texels)) {
					Host_Error("Mod_LoadAllSkins: Player skin too large (model %s)", loadmodel->name);
					return NULL;
				}
				memcpy(player_8bit_texels, (byte *)(pskintype + 1), s);
			}

			snprintf(identifier, sizeof(identifier), "%s_%i", basename, i);

			R_TextureReferenceInvalidate(gl_texnum);
			R_TextureReferenceInvalidate(fb_texnum);

			gl_texnum = Mod_LoadExternalSkin(loadmodel, identifier, &fb_texnum);
			if (!R_TextureReferenceIsValid(gl_texnum)) {
				gl_texnum = R_LoadTexture(identifier, pheader->skinwidth, pheader->skinheight, (byte *)(pskintype + 1), texmode, 1);

				if (Img_HasFullbrights((byte *)(pskintype + 1), pheader->skinwidth * pheader->skinheight)) {
					fb_texnum = R_LoadTexture(va("@fb_%s", identifier), pheader->skinwidth, pheader->skinheight, (byte *)(pskintype + 1), texmode | TEX_FULLBRIGHT, 1);
				}
			}

			pheader->gl_texturenum[i][0] = pheader->gl_texturenum[i][1] = pheader->gl_texturenum[i][2] = pheader->gl_texturenum[i][3] = gl_texnum;
			pheader->glc_fb_texturenum[i][0] = pheader->glc_fb_texturenum[i][1] = pheader->glc_fb_texturenum[i][2] = pheader->glc_fb_texturenum[i][3] = fb_texnum;

			pskintype = (daliasskintype_t *)((byte *)(pskintype + 1) + s);
		}
		else {
			// animating skin group.  yuck.
			pskintype++;
			pinskingroup = (daliasskingroup_t *)pskintype;
			groupskins = LittleLong(pinskingroup->numskins);
			pinskinintervals = (daliasskininterval_t *)(pinskingroup + 1);

			pskintype = (void *)(pinskinintervals + groupskins);

			for (j = 0; j < groupskins; j++) {
				Mod_FloodFillSkin(skin, pheader->skinwidth, pheader->skinheight);

				snprintf(identifier, sizeof(identifier), "%s_%i_%i", basename, i, j);

				R_TextureReferenceInvalidate(gl_texnum);
				R_TextureReferenceInvalidate(fb_texnum);

				gl_texnum = Mod_LoadExternalSkin(loadmodel, identifier, &fb_texnum);
				if (!R_TextureReferenceIsValid(gl_texnum)) {
					gl_texnum = R_LoadTexture(identifier, pheader->skinwidth, pheader->skinheight, (byte *)(pskintype), texmode, 1);

					if (Img_HasFullbrights((byte *)(pskintype), pheader->skinwidth*pheader->skinheight)) {
						fb_texnum = R_LoadTexture(va("@fb_%s", identifier), pheader->skinwidth, pheader->skinheight, (byte *)(pskintype), texmode | TEX_FULLBRIGHT, 1);
					}
				}

				pheader->gl_texturenum[i][j & 3] = gl_texnum;
				pheader->glc_fb_texturenum[i][j & 3] = fb_texnum;

				pskintype = (daliasskintype_t *)((byte *)(pskintype)+s);
			}

			for (k = j; j < 4; j++) {
				pheader->gl_texturenum[i][j & 3] = pheader->gl_texturenum[i][j - k];
				pheader->glc_fb_texturenum[i][j & 3] = pheader->glc_fb_texturenum[i][j - k];
			}
		}
	}
	return pskintype;
}

typedef struct {
	short x, y;
} floodfill_t;

extern unsigned d_8to24table[];

// must be a power of 2
#define FLOODFILL_FIFO_SIZE 0x1000
#define FLOODFILL_FIFO_MASK (FLOODFILL_FIFO_SIZE - 1)

#define FLOODFILL_STEP( off, dx, dy ) \
{ \
	if (pos[off] == fillcolor) \
	{ \
		pos[off] = 255; \
		fifo[inpt].x = x + (dx), fifo[inpt].y = y + (dy); \
		inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; \
	} \
	else if (pos[off] != 255) fdc = pos[off]; \
}

//Fill background pixels so mipmapping doesn't have haloes - Ed
static void Mod_FloodFillSkin(byte *skin, int skinwidth, int skinheight)
{
	byte fillcolor = *skin; // assume this is the pixel to fill
	floodfill_t fifo[FLOODFILL_FIFO_SIZE];
	int inpt = 0, outpt = 0, filledcolor = -1, i;

	if (filledcolor == -1) {
		filledcolor = 0;
		// attempt to find opaque black
		for (i = 0; i < 256; ++i) {
			if (d_8to24table[i] == (255 << 0)) { // alpha 1.0
				filledcolor = i;
				break;
			}
		}
	}

	// can't fill to filled color or to transparent color (used as visited marker)
	if ((fillcolor == filledcolor) || (fillcolor == 255)) {
		//printf( "not filling skin from %d to %d\n", fillcolor, filledcolor );
		return;
	}

	fifo[inpt].x = 0, fifo[inpt].y = 0;
	inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;

	while (outpt != inpt) {
		int x = fifo[outpt].x, y = fifo[outpt].y, fdc = filledcolor;
		byte *pos = &skin[x + skinwidth * y];

		outpt = (outpt + 1) & FLOODFILL_FIFO_MASK;

		if (x > 0)				FLOODFILL_STEP(-1, -1, 0);
		if (x < skinwidth - 1)	FLOODFILL_STEP(1, 1, 0);
		if (y > 0)				FLOODFILL_STEP(-skinwidth, 0, -1);
		if (y < skinheight - 1)	FLOODFILL_STEP(skinwidth, 0, 1);
		skin[x + skinwidth * y] = fdc;
	}
}


================================================
FILE: src/r_atlas.c
================================================
/*
Module for creating 2d atlas for UI elements

Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "gl_model.h"
#include "tr_types.h"
#include "r_texture.h"
#include "r_local.h"
#include "r_trace.h"
#include "r_renderer.h"

#define MAXIMUM_ATLAS_TEXTURE_WIDTH  4096
#define MAXIMUM_ATLAS_TEXTURE_HEIGHT 4096

typedef struct deleteable_texture_s {
	texture_ref original;
	qbool moved_to_atlas;
} deleteable_texture_t;

static byte* atlas_texels;
static byte* buffer;
static byte* prev_atlas_texels;
static deleteable_texture_t atlas_deletable_textures[WADPIC_PIC_COUNT + NUMCROSSHAIRS + 2 + MAX_CHARSETS];
static int atlas_allocated[MAXIMUM_ATLAS_TEXTURE_WIDTH];
static int atlas_delete_count = 0;
static int atlas_texture_width = 0;
static int atlas_texture_height = 0;
static int atlas_block_width = 0;
static int atlas_block_height = 0;
static int atlas_chunk_size = 64;
static qbool atlas_dirty;
#define ATLAS_SIZE_IN_BYTES (atlas_texture_width * atlas_texture_height * 4)

static cachepic_node_t wadpics[WADPIC_PIC_COUNT];
static cachepic_node_t charsetpics[MAX_CHARSETS * 256];
static cachepic_node_t crosshairpics[NUMCROSSHAIRS + 2];
#ifdef EZ_FREETYPE_SUPPORT
static cachepic_node_t fontpics[MAX_CHARSETS * 256];
#endif

static float solid_s;
static float solid_t;
static texture_ref atlas_texnum;
static texture_ref solid_texnum;
static qbool atlas_refresh = false;

static void AddTextureToDeleteList(texture_ref tex)
{
	if (R_TextureReferenceIsValid(tex) && atlas_delete_count < sizeof(atlas_deletable_textures) / sizeof(atlas_deletable_textures[0])) {
		atlas_deletable_textures[atlas_delete_count].original = tex;
		atlas_deletable_textures[atlas_delete_count].moved_to_atlas = false;
		R_TraceAPI("[atlas] adding texture to delete list: %d [%s], pos %d", tex.index, R_TextureIdentifier(tex), atlas_delete_count);
		atlas_delete_count++;
	}
	else if (R_TextureReferenceIsValid(tex)) {
		R_TraceAPI("[atlas] !! attempted to add invalid texture reference to delete list");
	}
	else {
		R_TraceAPI("[atlas] !! failed to add texture to delete list (overflow) %d [%s]", tex.index, R_TextureIdentifier(tex));
	}
}

static void AddToDeleteList(mpic_t* src)
{
	if (!R_TextureReferenceEqual(atlas_texnum, src->texnum) && src->sl == 0 && src->tl == 0 && src->th == 1 && src->sh == 1) {
		AddTextureToDeleteList(src->texnum);
	}
	else if (!R_TextureReferenceEqual(atlas_texnum, src->texnum)) {
		R_TraceAPI("[atlas] !! not adding %d [%s] to delete list (incomplete texture): %.2f %.2f %.2f %.2f", src->texnum.index, R_TextureIdentifier(src->texnum), src->sl, src->sh, src->tl, src->th);
	}
}

static void ConfirmDeleteTexture(texture_ref tex)
{
	int i;
	for (i = 0; i < atlas_delete_count; ++i) {
		if (R_TextureReferenceEqual(atlas_deletable_textures[i].original, tex)) {
			atlas_deletable_textures[i].moved_to_atlas = true;
			R_TraceAPI("[atlas] marking deletable %d (%d/%s) as moved to atlas", i, atlas_deletable_textures[i].original.index, R_TextureIdentifier(atlas_deletable_textures[i].original));
		}
	}
}

static void DeleteOldTextures(void)
{
	int i;

	R_TraceEnterFunctionRegion;
	for (i = 0; i < atlas_delete_count; ++i) {
		if (atlas_deletable_textures[i].moved_to_atlas) {
			R_TraceAPI("[atlas] deleting %d (%d/%s)", i, atlas_deletable_textures[i].original.index, R_TextureIdentifier(atlas_deletable_textures[i].original));
			R_DeleteTexture(&atlas_deletable_textures[i].original);
		}
	}
	R_TraceLeaveFunctionRegion;
}

void Atlas_SolidTextureCoordinates(texture_ref* ref, float* s, float* t)
{
	if (ref) {
		*ref = solid_texnum;
	}
	*s = solid_s;
	*t = solid_t;
}

// Returns false if allocation failed.
static qbool Atlas_AllocBlock(int w, int h, int *x, int *y)
{
	int i, j, best, best2;

	w = (w + (atlas_chunk_size - 1)) / atlas_chunk_size;
	h = (h + (atlas_chunk_size - 1)) / atlas_chunk_size;
	best = atlas_block_height;

	for (i = 0; i < atlas_block_width - w; i++) {
		best2 = 0;

		for (j = 0; j < w; j++) {
			if (atlas_allocated[i + j] >= best) {
				break;
			}
			if (atlas_allocated[i + j] > best2) {
				best2 = atlas_allocated[i + j];
			}
		}

		if (j == w) {
			// This is a valid spot.
			*x = i;
			*y = best = best2;
		}
	}

	if (best + h > atlas_block_height) {
		*x = *y = 0;
		return false;
	}

	for (i = 0; i < w; i++) {
		atlas_allocated[*x + i] = best + h;
	}

	atlas_dirty = true;
	*x *= atlas_chunk_size;
	*y *= atlas_chunk_size;

	return true;
}

static void CachePics_AllocateSolidTexture(void)
{
	int x_pos, y_pos, y;

	if (!Atlas_AllocBlock(atlas_chunk_size, atlas_chunk_size, &x_pos, &y_pos)) {
		solid_texnum = solidwhite_texture;
		solid_s = 0.5;
		solid_t = 0.5;
		return;
	}

	for (y = 0; y < atlas_chunk_size; ++y) {
		memset(atlas_texels + (x_pos + (y_pos + y) * atlas_texture_width) * 4, 0xFF, atlas_chunk_size * 4);
	}

	solid_s = (x_pos + atlas_chunk_size / 2) * 1.0f / atlas_texture_width;
	solid_t = (y_pos + atlas_chunk_size / 2) * 1.0f / atlas_texture_height;
	solid_texnum = atlas_texnum;
}

static void CachePics_CopyToBuffer(mpic_t* pic, int x_pos, int y_pos, int new_texture_width, const byte* input, byte* output)
{
	int texWidth = R_TextureWidth(pic->texnum);
	int texHeight = R_TextureHeight(pic->texnum);
	int height = (pic->th - pic->tl) * texHeight;
	int width = (pic->sh - pic->sl) * texWidth;
	int yOffset;

	for (yOffset = 0; yOffset < height; ++yOffset) {
		int y = y_pos + yOffset;
		int base = (x_pos + y * new_texture_width) * 4;
		int srcBase = (pic->sl * texWidth + (yOffset + pic->tl * texHeight) * texWidth) * 4;

		memcpy(output + base, input + srcBase, 4 * width);
	}
}

static int CachePics_AddToAtlas(mpic_t* pic)
{
	int width = pic->width, height = pic->height;
	int texWidth = 0, texHeight = 0;
	int x_pos, y_pos;
	int padding = 1;

	// Find size of the source
	texWidth = R_TextureWidth(pic->texnum);
	texHeight = R_TextureHeight(pic->texnum);

	width = (pic->sh - pic->sl) * texWidth;
	height = (pic->th - pic->tl) * texHeight;

	if (width > atlas_texture_width || height > atlas_texture_height) {
		return -1;
	}

	// Allocate space in an atlas texture
	if (Atlas_AllocBlock(width + (width == atlas_texture_width ? 0 : padding), height + (height == atlas_texture_height ? 0 : padding), &x_pos, &y_pos)) {
		byte* input_image = NULL;

		// Copy texture image
		if (R_TextureReferenceEqual(pic->texnum, atlas_texnum)) {
			input_image = prev_atlas_texels;
		}
		else {
			renderer.TextureGet(pic->texnum, ATLAS_SIZE_IN_BYTES, buffer, 4);

			input_image = buffer;
		}

		CachePics_CopyToBuffer(pic, x_pos, y_pos, atlas_texture_width, input_image, atlas_texels);

		R_TraceAPI("  moved to atlas: %d,%d => %d,%d", x_pos, y_pos, x_pos + width, y_pos + height);
		pic->sl = (x_pos) / (float)atlas_texture_width;
		pic->sh = (x_pos + width) / (float)atlas_texture_width;
		pic->tl = (y_pos) / (float)atlas_texture_height;
		pic->th = (y_pos + height) / (float)atlas_texture_height;
		pic->texnum = atlas_texnum;

		return 0;
	}
	else if (R_TextureReferenceEqual(atlas_texnum, pic->texnum)) {
		// Was on texture but no longer fits - need to create new texture
		CachePics_CopyToBuffer(pic, 0, 0, width, prev_atlas_texels, buffer);
		R_TraceAPI("  !moved from atlas: %d,%d => %d,%d", x_pos, y_pos, x_pos + width, y_pos + height);

		pic->tl = pic->sl = 0;
		pic->th = pic->sh = 1;
		pic->texnum = R_LoadTexturePixels(buffer, "", width, height, TEX_ALPHA);
	}
	else {
		R_TraceAPI("  !unable to move to atlas");
	}

	return -1;
}

void CachePics_AtlasFrame(void)
{
	// cls.state != active should be safe, vid_restart builds atlas directly via GFX_Init()
	if (atlas_refresh && cls.state != ca_active) {
		CachePics_CreateAtlas();
	}
}

void CachePics_AtlasUpload(void)
{
	if (atlas_dirty) {
		R_TraceEnterFunctionRegion;
		atlas_texnum = R_LoadTexture("cachepics:atlas", atlas_texture_width, atlas_texture_height, atlas_texels, TEX_ALPHA | TEX_NOSCALE, 4);
		renderer.TextureSetFiltering(atlas_texnum, texture_minification_linear, texture_magnification_linear);
		renderer.TextureWrapModeClamp(atlas_texnum);
		R_TraceLeaveFunctionRegion;
	}
	atlas_dirty = false;
}

void CachePics_Init(void)
{
	atlas_dirty = true;
	atlas_texture_width = atlas_texture_height = min(glConfig.gl_max_size_default, MAXIMUM_ATLAS_TEXTURE_WIDTH);

	CachePics_AtlasUpload();
}

static void CachePics_InsertBySize(cachepic_node_t** sized_list, cachepic_node_t* node)
{
	int size_node;
	cachepic_node_t* current = *sized_list;
	int size_this;

	node->width = R_TextureWidth(node->data.pic->texnum);
	node->height = R_TextureHeight(node->data.pic->texnum);

	node->width *= (node->data.pic->sh - node->data.pic->sl);
	node->height *= (node->data.pic->th - node->data.pic->tl);

	size_node = node->width * node->height;

	while (current) {
		size_this = current->width * current->height;
		if (size_this > size_node) {
			sized_list = &current->size_order;
			current = *sized_list;
			continue;
		}

		break;
	}

	node->size_order = current;
	*sized_list = node;
}

void CachePics_LoadAmmoPics(mpic_t* ibar)
{
	extern mpic_t sb_ib_ammo[4];
	mpic_t* targPic;
	int i;
	int texWidth, texHeight;
	float sRatio = (ibar->sh - ibar->sl) / (float)ibar->width;
	float tRatio = (ibar->th - ibar->tl) / (float)ibar->height;
	byte* source;
	byte* target;
	int realwidth, realheight;
	float newsh, newsl;
	float newth, newtl;

	// Find size of the source
	texWidth = R_TextureWidth(ibar->texnum);
	texHeight = R_TextureHeight(ibar->texnum);

	source = Q_malloc(texWidth * texHeight * 4);
	target = Q_malloc(texWidth * texHeight * 4);

	renderer.TextureGet(ibar->texnum, texWidth * texHeight * 4, source, 4);
	for (i = WADPIC_SB_IBAR_AMMO1; i <= WADPIC_SB_IBAR_AMMO4; ++i) {
		int num = i - WADPIC_SB_IBAR_AMMO1;
		int y;
		int x_src, y_src;
		char name[16];
		int xcoord = (3 + num * 48);
		int xwidth = 42;
		int ycoord = 0;
		int yheight = 11;

		newsl = ibar->sl + xcoord * sRatio;
		newsh = newsl + xwidth * sRatio;
		newtl = ibar->tl + ycoord * tRatio;
		newth = newtl + yheight * tRatio;

		x_src = texWidth * newsl;
		y_src = texHeight * newtl;

		realwidth = (newsh - newsl) * texWidth;
		realheight = (newth - newtl) * texHeight;

		// Cope with 1x1 transparent png files...(#571)
		realwidth = max(realwidth, 1);
		realheight = max(realheight, 1);
		x_src = min(x_src, texWidth - 1);
		y_src = min(y_src, texHeight - 1);

		snprintf(name, sizeof(name), "hud_ammo_%d", i - WADPIC_SB_IBAR_AMMO1);

		for (y = 0; y < realheight; ++y) {
			memcpy(target + (y * realwidth) * 4, &source[(x_src + (y_src + y) * texWidth) * 4], realwidth * 4);
		}

		targPic = wad_pictures[i].pic = &sb_ib_ammo[num];
		targPic->texnum = R_LoadTexture(name, realwidth, realheight, target, TEX_NOCOMPRESS | TEX_ALPHA | TEX_NOSCALE | TEX_NO_TEXTUREMODE, 4);
		targPic->sl = 0;
		targPic->sh = 1;
		targPic->tl = 0;
		targPic->th = 1;
		targPic->width = 42;
		targPic->height = 11;
	}

	Q_free(target);
	Q_free(source);

	AddToDeleteList(ibar);
}

static void DeleteCharsetTextures(void)
{
	int i;

	R_TraceEnterFunctionRegion;
	for (i = 0; i < MAX_CHARSETS; ++i) {
		charset_t* charset = &char_textures[i];
		int j;
		qbool all_on_atlas = true;

		if (!R_TextureReferenceIsValid(charset->master)) {
			continue;
		}

		R_TraceAPI("Checking normal charset %03d is on atlas...", i);
		for (j = 0; j < 256 && all_on_atlas; ++j) {
			texture_ref glyph_tex = charset->glyphs[j].texnum;

			all_on_atlas &= (!R_TextureReferenceIsValid(glyph_tex) || R_TextureReferenceEqual(glyph_tex, atlas_texnum));
		}
		if (all_on_atlas && R_TextureReferenceIsValid(charset->master)) {
			R_TraceAPI("- all on atlas, deleting...", i);
			R_DeleteTexture(&charset->master);
			R_TextureReferenceInvalidate(charset->master);
		}
		else {
			R_TraceAPI("- some glyphs not on atlas", i);
		}
	}

#ifdef EZ_FREETYPE_SUPPORT
	for (i = 0; i < MAX_CHARSETS; ++i) {
		extern charset_t proportional_fonts[MAX_CHARSETS];
		charset_t* charset = &proportional_fonts[i];
		int j;
		qbool all_on_atlas = true;

		if (!R_TextureReferenceIsValid(charset->master)) {
			continue;
		}

		R_TraceAPI("Checking proportional charset %03d is on atlas...", i);
		for (j = 0; j < 256 && all_on_atlas; ++j) {
			all_on_atlas &= R_TextureReferenceEqual(charset->glyphs[j].texnum, atlas_texnum);
		}
		if (all_on_atlas && R_TextureReferenceIsValid(charset->master)) {
			R_TraceAPI("- all on atlas, deleting...", i);
			R_DeleteTexture(&charset->master);
		}
		else {
			R_TraceAPI("- some glyphs not on atlas", i);
		}
	}
#endif
	R_TraceLeaveFunctionRegion;
}

void CachePics_CreateAtlas(void)
{
	cachepic_node_t* sized_list = NULL;
	cachepic_node_t* cur;
	cachepic_node_t simple_items[MOD_NUMBER_HINTS * MAX_SIMPLE_TEXTURES];
	int i, j;
	double start_time = Sys_DoubleTime();

	if (COM_CheckParm(cmdline_param_client_noatlas)) {
		atlas_refresh = false;
		return;
	}

	R_TraceEnterFunctionRegion;

	// Delete old atlas textures
	atlas_texels = Q_malloc(ATLAS_SIZE_IN_BYTES);
	prev_atlas_texels = Q_malloc(ATLAS_SIZE_IN_BYTES);
	if (R_TextureReferenceIsValid(atlas_texnum)) {
		renderer.TextureGet(atlas_texnum, ATLAS_SIZE_IN_BYTES, prev_atlas_texels, 4);
	}
	memset(atlas_allocated, 0, sizeof(atlas_allocated));
	memset(wadpics, 0, sizeof(wadpics));
	atlas_delete_count = 0;

	atlas_chunk_size = atlas_texture_width >= 4096 ? 64 : atlas_texture_width >= 2048 ? 32 : 16;
	atlas_block_width = atlas_texture_width / atlas_chunk_size;
	atlas_block_height = atlas_texture_height / atlas_chunk_size;

	// Copy wadpic data over
	for (i = 0; i < WADPIC_PIC_COUNT; ++i) {
		extern wadpic_t wad_pictures[WADPIC_PIC_COUNT];
		mpic_t* src = wad_pictures[i].pic;

		// This tiles, so don't include in atlas
		if (i == WADPIC_BACKTILE) {
			continue;
		}

		if (src) {
			wadpics[i].data.pic = src;

			if (i != WADPIC_SB_IBAR) {
				CachePics_InsertBySize(&sized_list, &wadpics[i]);

				AddToDeleteList(src);
			}
		}
	}

	for (i = 0; i < MAX_CHARSETS; ++i) {
		charset_t* charset = &char_textures[i];

		for (j = 0; j < 256; ++j) {
			if (R_TextureReferenceIsValid(charset->glyphs[j].texnum)) {
				charsetpics[i * 256 + j].data.pic = &charset->glyphs[j];

				CachePics_InsertBySize(&sized_list, &charsetpics[i * 256 + j]);
			}
		}
	}

#ifdef EZ_FREETYPE_SUPPORT
	for (i = 0; i < MAX_CHARSETS; ++i) {
		extern charset_t proportional_fonts[MAX_CHARSETS];
		charset_t* charset = &proportional_fonts[i];

		for (j = 0; j < 256; ++j) {
			if (R_TextureReferenceIsValid(charset->glyphs[j].texnum)) {
				fontpics[i * 256 + j].data.pic = &charset->glyphs[j];

				CachePics_InsertBySize(&sized_list, &fontpics[i * 256 + j]);
			}
		}
	}
#endif

	// Copy crosshairs
	{
		extern mpic_t crosshairtexture_txt;
		extern mpic_t crosshairpic;
		extern mpic_t crosshairs_builtin[NUMCROSSHAIRS];

		if (R_TextureReferenceIsValid(crosshairtexture_txt.texnum)) {
			crosshairpics[0].data.pic = &crosshairtexture_txt;
			CachePics_InsertBySize(&sized_list, &crosshairpics[0]);

			AddToDeleteList(&crosshairtexture_txt);
		}

		if (R_TextureReferenceIsValid(crosshairpic.texnum)) {
			crosshairpics[1].data.pic = &crosshairpic;
			CachePics_InsertBySize(&sized_list, &crosshairpics[1]);

			AddToDeleteList(&crosshairpic);
		}

		for (i = 0; i < NUMCROSSHAIRS; ++i) {
			if (R_TextureReferenceIsValid(crosshairs_builtin[i].texnum)) {
				crosshairpics[i + 2].data.pic = &crosshairs_builtin[i];
				CachePics_InsertBySize(&sized_list, &crosshairpics[i + 2]);

				AddToDeleteList(&crosshairs_builtin[i]);
			}
		}
	}

	// Add simple item textures (meag: these should be very low priority)
	for (i = 0; i < MOD_NUMBER_HINTS; ++i) {
		for (j = 0; j < MAX_SIMPLE_TEXTURES; ++j) {
			mpic_t* pic = Mod_SimpleTextureForHint(i, j);
			cachepic_node_t* node = &simple_items[i * MAX_SIMPLE_TEXTURES + j];

			node->data.pic = pic;

			if (pic && R_TextureReferenceIsValid(pic->texnum)) {
				CachePics_InsertBySize(&sized_list, node);

				// Don't delete these, used for 3d sprites
			}
		}
	}

	// Add cached picture images
	for (i = 0; i < CACHED_PICS_HDSIZE; ++i) {
		extern cachepic_node_t *cachepics[CACHED_PICS_HDSIZE];
		cachepic_node_t *cur;

		for (cur = cachepics[i]; cur; cur = cur->next) {
			if (!Draw_IsConsoleBackground(cur->data.pic) && !Draw_KeepOffAtlas(cur->data.name)) {
				CachePics_InsertBySize(&sized_list, cur);

				AddToDeleteList(cur->data.pic);
			}
		}
	}

	// Actually copy to the atlas texture
	buffer = Q_malloc(ATLAS_SIZE_IN_BYTES);
	for (cur = sized_list; cur; cur = cur->size_order) {
		texture_ref original = cur->data.pic->texnum;
		R_TraceAPI("[atlas] attempting to add %d/%s to atlas", original.index, R_TextureIdentifier(original));
		if (CachePics_AddToAtlas(cur->data.pic) >= 0) {
			ConfirmDeleteTexture(original);
		}
	}
	CachePics_AllocateSolidTexture();

	// Upload atlas texture
	CachePics_AtlasUpload();

	DeleteOldTextures();
	DeleteCharsetTextures();

	Q_free(atlas_texels);
	Q_free(prev_atlas_texels);
	Q_free(buffer);
	Con_DPrintf("Atlas build time: %f\n", Sys_DoubleTime() - start_time);

	// Make sure we don't reference any old textures
	R_EmptyImageQueue();

	R_TraceLeaveFunctionRegion;

	atlas_refresh = false;
}

void CachePics_MarkAtlasDirty(void)
{
	atlas_refresh = true;
}


================================================
FILE: src/r_bloom.c
================================================
/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "r_local.h"

void GLC_BloomBlend(void);
void GLC_InitBloomTextures(void);

void R_BloomBlend(void)
{
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_BloomBlend();
	}
#endif
}

void R_InitBloomTextures(void)
{
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_InitBloomTextures();
	}
#endif
}


================================================
FILE: src/r_brushmodel.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "r_vao.h"
#include "r_renderer.h"
#include "r_state.h"
#include "tr_types.h"
#include "rulesets.h"
#include "r_trace.h"
#include "r_matrix.h"
#include "r_brushmodel.h"
#include "r_lightmaps.h"
#include "r_lighting.h"
#include "glc_state.h"

unsigned int* modelIndexes;
unsigned int modelIndexMaximum;

static int R_BrushModelMeasureVBOSize(model_t* m);
static int R_BrushModelPopulateVBO(model_t* m, void* vbo_buffer, int vbo_pos);
void R_BrushModelClearTextureChains(model_t *clmodel);

static int R_BrushModelMeasureIndexSize(model_t* m)
{
	int j, total_surf_verts = 0, total_surfaces = 0;

	for (j = 0; j < m->nummodelsurfaces; ++j) {
		msurface_t* surf = m->surfaces + m->firstmodelsurface + j;
		glpoly_t* poly;

		for (poly = surf->polys; poly; poly = poly->next) {
			total_surf_verts += poly->numverts;
			++total_surfaces;
		}
	}

	if (total_surf_verts <= 0 || total_surfaces < 1) {
		return 0;
	}

	// Every vert in every surface, + surface terminator
	return (total_surf_verts)+(total_surfaces - 1);
}

void R_BrushModelCreateVBO(void)
{
	int i;
	int size = 0;
	int position = 0;
	int indexes = 0;
	int max_entity_indexes = 0;
	void* buffer = NULL;
	unsigned int buffer_size;

	for (i = 1; i < MAX_MODELS; ++i) {
		model_t* mod = cl.model_precache[i];
		if (mod && mod->type == mod_brush) {
			int index_count = R_BrushModelMeasureIndexSize(mod);

			size += R_BrushModelMeasureVBOSize(mod);
			if (mod->isworldmodel) {
				indexes += index_count;
			}
			else {
				max_entity_indexes = max(max_entity_indexes, index_count);
			}
		}
	}

	for (i = 0; i < MAX_VWEP_MODELS; i++) {
		model_t* mod = cl.vw_model_precache[i];
		if (mod && mod->type == mod_brush) {
			int index_count = R_BrushModelMeasureIndexSize(mod);

			size += R_BrushModelMeasureVBOSize(mod);
			if (mod->isworldmodel) {
				indexes += index_count;
			}
			else {
				max_entity_indexes = max(max_entity_indexes, index_count);
			}
		}
	}

	indexes += max_entity_indexes * MAX_STANDARD_ENTITIES;
	if (!R_BufferReferenceIsValid(r_buffer_brushmodel_index_data) || indexes > buffers.Size(r_buffer_brushmodel_index_data) / sizeof(modelIndexes[0])) {
		Q_free(modelIndexes);
		modelIndexMaximum = indexes;
		modelIndexes = Q_malloc(sizeof(*modelIndexes) * modelIndexMaximum);

		R_BindVertexArray(vao_none);
		if (R_BufferReferenceIsValid(r_buffer_brushmodel_index_data)) {
			buffers.Resize(r_buffer_brushmodel_index_data, modelIndexMaximum * sizeof(modelIndexes[0]), NULL);
		}
		else {
			buffers.Create(r_buffer_brushmodel_index_data, buffertype_index, "brushmodel-elements", modelIndexMaximum * sizeof(modelIndexes[0]), NULL, bufferusage_once_per_frame);
		}
	}

	// Create vbo buffer
	buffer_size = size * (R_UseModernOpenGL() ? sizeof(vbo_world_vert_t) : sizeof(glc_vbo_world_vert_t));
	buffer = Q_malloc(buffer_size);

	// Copy data into buffer
	for (i = 1; i < MAX_MODELS; ++i) {
		model_t* mod = cl.model_precache[i];
		if (mod && mod->type == mod_brush) {
			position = R_BrushModelPopulateVBO(mod, buffer, position);
		}
	}

	for (i = 0; i < MAX_VWEP_MODELS; i++) {
		model_t* mod = cl.vw_model_precache[i];
		if (mod && mod->type == mod_brush) {
			position = R_BrushModelPopulateVBO(mod, buffer, position);
		}
	}

	// Copy VBO buffer across
	buffers.Create(r_buffer_brushmodel_vertex_data, buffertype_vertex, "brushmodel-vbo", buffer_size, buffer, bufferusage_reuse_many_frames);

	Q_free(buffer);
}

static int R_BrushModelMeasureVBOSize(model_t* m)
{
	int j, total_surf_verts = 0, total_surfaces = 0;

	for (j = 0; j < m->nummodelsurfaces; ++j) {
		msurface_t* surf = m->surfaces + m->firstmodelsurface + j;
		glpoly_t* poly;

		if (!(surf->flags & (SURF_DRAWTURB | SURF_DRAWSKY))) {
			if (surf->texinfo->flags & TEX_SPECIAL) {
				continue;
			}
		}
		if (!m->textures[surf->texinfo->miptex]) {
			continue;
		}

		for (poly = surf->polys; poly; poly = poly->next) {
			total_surf_verts += poly->numverts;
			++total_surfaces;
		}
	}

	if (total_surf_verts <= 0 || total_surfaces < 1) {
		return 0;
	}

	return (total_surf_verts);// +2 * (total_surfaces - 1));
}

// Create VBO, ordering by texture array
static int R_BrushModelPopulateVBO(model_t* m, void* vbo_buffer, int vbo_pos)
{
	int i, j;

	// Order vertices in the VBO by texture & lightmap
	for (i = 0; i < m->numtextures; ++i) {
		qbool has_fb = false, has_luma = false;

		if (!m->textures[i]) {
			continue;
		}

		has_fb = R_TextureReferenceIsValid(m->textures[i]->fb_texturenum);
		has_luma = has_fb & m->textures[i]->isLumaTexture;
		for (j = 0; j < m->nummodelsurfaces; ++j) {
			msurface_t* surf = m->surfaces + m->firstmodelsurface + j;
			qbool isTurbOrSky = surf->flags & (SURF_DRAWTURB | SURF_DRAWSKY);
			qbool isLitTurb = surf->texinfo->texture->isLitTurb;
			int lightmap = isTurbOrSky && !isLitTurb ? -1 : surf->lightmaptexturenum;
			glpoly_t* poly;

			if (surf->texinfo->miptex != i) {
				continue;
			}

			// copy verts into buffer (alternate to turn fan into triangle strip)
			for (poly = surf->polys; poly; poly = poly->next) {
				int k = 0;
				int material = i;
				float scaleS = m->textures[i]->gl_texture_scaleS;
				float scaleT = m->textures[i]->gl_texture_scaleT;

				if (!poly->numverts) {
					continue;
				}

				// Store position for drawing individual polys
				poly->vbo_start = vbo_pos;
				for (k = 0; k < poly->numverts; ++k) {
					vbo_pos = renderer.BrushModelCopyVertToBuffer(m, vbo_buffer, vbo_pos, poly->verts[k], lightmap, material, scaleS, scaleT, surf, has_fb, has_luma);
				}

			}
		}
	}

	return vbo_pos;
}

void R_BrushModelFreeMemory(void)
{
	modelIndexMaximum = 0;
	Q_free(modelIndexes);
}

void R_BrushModelDrawEntity(entity_t *e)
{
	int k;
	unsigned int li;
	unsigned int lj;
	vec3_t mins, maxs;
	model_t *clmodel;
	qbool rotated;
	float oldMatrix[16];
	extern cvar_t gl_brush_polygonoffset;
	qbool caustics = false;
	extern cvar_t gl_flashblend;
	extern msurface_t* skychain;

	// Get rid of Z-fighting for textures by offsetting the
	// drawing of entity models compared to normal polygons.
	// dimman: disabled for qcon
	qbool polygonOffset = gl_brush_polygonoffset.value > 0 && Ruleset_AllowPolygonOffset(e);

	clmodel = e->model;
	if (!clmodel->nummodelsurfaces) {
		return;
	}

	if (e->angles[0] || e->angles[1] || e->angles[2]) {
		rotated = true;
		if (R_CullSphere(e->origin, clmodel->radius)) {
			return;
		}
	}
	else {
		rotated = false;
		VectorAdd(e->origin, clmodel->mins, mins);
		VectorAdd(e->origin, clmodel->maxs, maxs);

		if (R_CullBox(mins, maxs)) {
			return;
		}
	}

	R_TraceEnterRegion(va("%s(%s)", __func__, e->model->name), true);

	VectorSubtract(r_refdef.vieworg, e->origin, modelorg);
	if (rotated) {
		vec3_t	temp;
		vec3_t	forward, right, up;

		VectorCopy(modelorg, temp);
		AngleVectors(e->angles, forward, right, up);
		modelorg[0] = DotProduct(temp, forward);
		modelorg[1] = -DotProduct(temp, right);
		modelorg[2] = DotProduct(temp, up);
	}

	// calculate dynamic lighting for bmodel if it's not an instanced model
	if (clmodel->firstmodelsurface) {
		for (li = 0; li < MAX_DLIGHTS / 32; li++) {
			if (cl_dlight_active[li]) {
				for (lj = 0; lj < 32; lj++) {
					if ((cl_dlight_active[li] & (1 << lj)) && li * 32 + lj < MAX_DLIGHTS) {
						k = li * 32 + lj;

						if (!gl_flashblend.integer || (cl_dlights[k].bubble && gl_flashblend.integer != 2)) {
							R_MarkLights(&cl_dlights[k], 1 << k, clmodel->nodes + clmodel->firstnode);
						}
					}
				}
			}
		}
	}

	R_BrushModelClearTextureChains(clmodel);
	renderer.ChainBrushModelSurfaces(clmodel, e);

	if (clmodel->last_texture_chained >= 0 || clmodel->drawflat_todo || skychain) {
		R_PushModelviewMatrix(oldMatrix);
		R_RotateForEntity(e);

		// START shaman FIX for no simple textures on world brush models {
		//draw the textures chains for the model
		if (clmodel->last_texture_chained >= 0 || clmodel->drawflat_todo) {
			if (clmodel->firstmodelsurface) {
				R_RenderAllDynamicLightmaps(clmodel);
			}

			//R00k added contents point for underwater bmodels
			if (r_refdef2.drawCaustics) {
				if (clmodel->isworldmodel) {
					vec3_t midpoint;

					VectorAdd(clmodel->mins, clmodel->maxs, midpoint);
					VectorScale(midpoint, 0.5f, midpoint);
					VectorAdd(midpoint, e->origin, midpoint);

					caustics = R_PointIsUnderwater(midpoint);
				}
				else {
					caustics = R_PointIsUnderwater(e->origin);
				}
			}
		}

		renderer.DrawBrushModel(e, polygonOffset, caustics);
		// } END shaman FIX for no simple textures on world brush models

		R_PopModelviewMatrix(oldMatrix);
	}

	R_TraceLeaveRegion(true);
}

// Convert ordering of verts for convex polygons to triangle strip
void R_BrushModelPolygonToTriangleStrip(glpoly_t* poly)
{
	float tempVert[VERTEXSIZE];
	int i;

	// Apart from first vertex, replace odd verts with vert at end of list
	for (i = 2; i < poly->numverts - 1; i += 2) {
		memcpy(tempVert, poly->verts[poly->numverts - 1], sizeof(tempVert));
		memmove(poly->verts[i + 1], poly->verts[i], sizeof(tempVert) * (poly->numverts - i - 1));
		memcpy(poly->verts[i], tempVert, sizeof(tempVert));
	}
}


================================================
FILE: src/r_brushmodel.h
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef R_BRUSHMODEL_HEADER
#define R_BRUSHMODEL_HEADER

#include "r_buffers.h"
#include "r_framestats.h"

qbool R_PointIsUnderwater(vec3_t point);

void GLC_StateBeginWaterSurfaces(void);
void GLC_StateBeginAlphaChain(void);
void GLC_StateBeginAlphaChainSurface(msurface_t* s);

// gl_rsurf.c
void GLC_EmitDetailPolys_GLSL(void);
void GLC_EmitDetailPolys(qbool use_vbo);
void R_BrushModelDrawEntity(entity_t *e);
void R_DrawWorld(void);
void GLC_DrawAlphaChain(msurface_t* alphachain, frameStatsPolyType polyType);

// gl_warp.c
void R_TurbSurfacesSubdivide(msurface_t *fa);
void R_SkySurfacesBuildPolys(msurface_t *fa);
void R_InitSky(texture_t *mt);	// called at level load
void R_DrawSky(void);
qbool R_DrawWorldOutlines(void);

// internal
#define CHAIN_SURF_B2F(surf, chain) 			\
	{											\
		(surf)->texturechain = (chain);			\
		(chain) = (surf);						\
	}
void chain_surfaces_simple(msurface_t** chain_head, msurface_t* surf);
void chain_surfaces_simple_drawflat(msurface_t** chain_head, msurface_t* surf);
void chain_surfaces_by_lightmap(msurface_t** chain_head, msurface_t* surf);
extern unsigned int* modelIndexes;
extern unsigned int modelIndexMaximum;
void R_BrushModelCreateVBO(void);

#define BRUSHMODEL_MAX_SURFACE_EXTENTS +999999999
#define BRUSHMODEL_MIN_SURFACE_EXTENTS -999999999

#endif // R_BRUSHMODEL_HEADER


================================================
FILE: src/r_brushmodel_bspx.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

//============================================================
// BSPX loading

// This code has been moved to cmodel.c, as there are physics lumps (rampjump)
//   as well as rendering-only (colored lighting)
// Move code to do with rendering lumps here?


================================================
FILE: src/r_brushmodel_load.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: gl_model.c,v 1.41 2007-10-07 08:06:33 tonik Exp $
*/
// gl_brushmodel.c  -- model loading and caching of brush models

#include "quakedef.h"
#include <limits.h>
#include "gl_model.h"
#include "teamplay.h"
#include "rulesets.h"
#include "wad.h"
#include "crc.h"
#include "fmod.h"
#include "utils.h"
#include "glsl/constants.glsl"
#include "r_brushmodel_sky.h"
#include "r_local.h"
#include "r_texture.h"
#include "r_matrix.h"
#include "r_lighting.h"
#include "r_lightmaps.h"
#include "r_framestats.h"
#include "r_brushmodel.h"
#include "r_trace.h"
#include "r_renderer.h"
#include "r_state.h"
#include "tr_types.h"

vec3_t modelorg;

extern msurface_t* skychain;
extern msurface_t* alphachain;
char* TranslateTextureName(texture_t *tx);
qbool Mod_LoadExternalTexture(model_t* loadmodel, texture_t *tx, int mode, int brighten_flag);

model_t* Mod_FindName(const char *name);

static void SetTextureFlags(model_t* mod, msurface_t* out, int surfnum)
{
	out->texinfo->surfaces++;

	// set the drawing flags flag
	// sky, turb and alpha should be mutually exclusive
	if (Mod_IsSkyTextureName(mod, out->texinfo->texture->name)) {	// sky
		out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED);
		R_SkySurfacesBuildPolys(out);	// build gl polys
		out->texinfo->skippable = false;
		return;
	}

	if (Mod_IsTurbTextureName(mod, out->texinfo->texture->name)) {	// turbulent
		out->flags |= SURF_DRAWTURB;
		out->texinfo->skippable = false;

		// check if texture should receive no lighting.
		if (out->texinfo->flags & TEX_SPECIAL) {
			out->flags |= SURF_DRAWTILED;
		} else {
			out->texinfo->texture->isLitTurb = true;
		}
		R_TurbSurfacesSubdivide(out);	// cut up polygon for warps
		return;
	}

	if (Mod_IsAlphaTextureName(mod, out->texinfo->texture->name)) {
		out->flags |= SURF_DRAWALPHA;
		out->texinfo->skippable = false;
		out->texinfo->texture->isAlphaTested = true;
	}
}

static byte* LoadColoredLighting(char *name, char **litfilename, int *filesize)
{
	qbool system;
	byte *data;
	char *groupname, *mapname;
	extern cvar_t gl_loadlitfiles;

	if (!(gl_loadlitfiles.integer == 1 || gl_loadlitfiles.integer == 2)) {
		return NULL;
	}

	mapname = TP_MapName();
	groupname = TP_GetMapGroupName(mapname, &system);

	if (strcmp(name, va("maps/%s.bsp", mapname))) {
		return NULL;
	}

	*litfilename = va("maps/lits/%s.lit", mapname);
	data = FS_LoadHunkFile (*litfilename, filesize);

	if (!data) {
		*litfilename = va("maps/%s.lit", mapname);
		data = FS_LoadHunkFile (*litfilename, filesize);
	}

	if (!data) {
		*litfilename = va("lits/%s.lit", mapname);
		data = FS_LoadHunkFile (*litfilename, filesize);
	}

	if (!data && groupname && !system) {
		*litfilename = va("maps/%s.lit", groupname);
		data = FS_LoadHunkFile (*litfilename, filesize);
	}

	if (!data && groupname && !system) {
		*litfilename = va("lits/%s.lit", groupname);
		data = FS_LoadHunkFile (*litfilename, filesize);
	}

	return data;
}

static void SetSurfaceLighting(model_t* loadmodel, msurface_t* out, byte* styles, int lightofs)
{
	int i;
	for (i = 0; i < MAXLIGHTMAPS; i++) {
		out->styles[i] = styles[i];
	}
	i = LittleLong(lightofs);
	if (i == -1 || loadmodel->lightdata == NULL) {
		out->samples = NULL;
	}
	else {
		out->samples = loadmodel->lightdata + (loadmodel->bspversion == HL_BSPVERSION ? i : i * loadmodel->lightdatasamplesize);
	}
}

//Fills in s->texturemins[] and s->extents[]
static void CalcSurfaceExtents(model_t* loadmodel, msurface_t *s) {
	float mins[2], maxs[2], val;
	int i,j, e, bmins[2], bmaxs[2];
	mvertex_t *v;
	mtexinfo_t *tex;

	mins[0] = mins[1] = BRUSHMODEL_MAX_SURFACE_EXTENTS;
	maxs[0] = maxs[1] = BRUSHMODEL_MIN_SURFACE_EXTENTS;

	tex = s->texinfo;

	for (i = 0; i < s->numedges; i++) {
		e = loadmodel->surfedges[s->firstedge+i];
		if (e >= 0) {
			v = &loadmodel->vertexes[loadmodel->edges[e].v[0]];
		}
		else {
			v = &loadmodel->vertexes[loadmodel->edges[-e].v[1]];
		}

		for (j = 0; j < 2; j++) {
			// The following calculation is sensitive to floating-point
			// precision. It needs to produce the same result that the
			// light compiler does, because R_BuildLightMap uses surf->
			// extents to know the width/height of a surface's lightmap,
			// and incorrect rounding here manifests itself as patches
			// of "corrupted" looking lightmaps.
			// Most light compilers are win32 executables, so they use
			// x87 floating point. This means the multiplies and adds
			// are done at 80-bit precision, and the result is rounded
			// down to 32-bits and stored in val.
			// Adding the casts to double seems to be good enough to fix
			// lighting glitches when Quakespasm is compiled as x86_64
			// and using SSE2 floating-point. A potential trouble spot
			// is the hallway at the beginning of mfxsp17. -- ericw
			val = (double) v->position[0] * (double) tex->vecs[j][0] +
				  (double) v->position[1] * (double) tex->vecs[j][1] +
				  (double) v->position[2] * (double) tex->vecs[j][2] +
				  (double) tex->vecs[j][3];
			if (i == 0 || val < mins[j]) {
				mins[j] = val;
			}
			if (i == 0 || val > maxs[j]) {
				maxs[j] = val;
			}
		}
	}

	for (i = 0; i < 2; i++) {
		bmins[i] = floor(mins[i]/16);
		bmaxs[i] = ceil(maxs[i]/16);

		s->texturemins[i] = bmins[i] * 16;
		s->extents[i] = (bmaxs[i] - bmins[i]) * 16;
		if (!(tex->flags & TEX_SPECIAL) && s->extents[i] > 512 /* 256 */) {
			Host_Error("CalcSurfaceExtents: Bad surface extents");
		}
	}
}

static void Mod_SetParent(mnode_t *node, mnode_t *parent)
{
	node->parent = parent;
	if (node->contents < 0) {
		return;
	}
	Mod_SetParent(node->children[0], node);
	Mod_SetParent(node->children[1], node);
}

static void Mod_LoadLighting(model_t* loadmodel, lump_t* l, byte* mod_base, bspx_header_t* bspx_header)
{
	int i, lit_ver, mark;
	byte *in, *out, *data;
	char *litfilename;
	int filesize;
	extern cvar_t gl_loadlitfiles;
	qbool load_inline;


	loadmodel->lightdata = NULL;

	if (loadmodel->bspversion == HL_BSPVERSION && l->filelen > 0) {
		loadmodel->lightdata = (byte *) Hunk_AllocName(l->filelen, loadmodel->name);
		memcpy (loadmodel->lightdata, mod_base + l->fileofs, l->filelen);
		return;
	}

	load_inline = gl_loadlitfiles.integer == 1 || gl_loadlitfiles.integer == 3;
	if (!load_inline && (l->filelen <= 0 && !R_FullBrightAllowed())) {
		Con_Printf("No vanilla lighting, using inline to satisfy ruleset.\n");
		load_inline = true;
	}

	if (load_inline) {
		int threshold = (lightmode == 1 ? 255 : lightmode == 2 ? 170 : 128);
		int lumpsize;
		byte *rgb;

		rgb = Mod_BSPX_FindLump(bspx_header, "LIGHTING_E5BGR9", &lumpsize, mod_base);
		if (rgb && lumpsize % 4 == 0 && (lumpsize == l->filelen * 4 || l->filelen <= 0)) {
			loadmodel->lightdata = (byte *) Hunk_AllocName (lumpsize, loadmodel->name);
			loadmodel->lightdatasamplesize = 4;
			memcpy(loadmodel->lightdata, rgb, lumpsize);
			loadmodel->flags |= MOD_HDRLIGHTING;
			for (i = 0; i < lumpsize / 4; i++) { //native endian...
				((int*)loadmodel->lightdata)[i] = LittleLong(((int*)loadmodel->lightdata)[i]);
			}
		} else {
			rgb = Mod_BSPX_FindLump(bspx_header, "RGBLIGHTING", &lumpsize, mod_base);
			// Sanity-check size if vanilla lit exists
			if (rgb && lumpsize % 3 == 0 && (lumpsize == l->filelen * 3 || l->filelen <= 0)) {
				loadmodel->lightdata = (byte *) Hunk_AllocName(lumpsize, loadmodel->name);
				loadmodel->lightdatasamplesize = 3;
				memcpy(loadmodel->lightdata, rgb, lumpsize);
				// we trust the inline RGB data to be bug free so we don't check it against the mono lightmap
				// what we do though is prevent color wash-out in brightly lit areas
				// (one day we may do it in R_BuildLightMap instead)
				out = loadmodel->lightdata;
				for (i = 0; i < lumpsize / 3; i++, out += 3) {
					int m = max(out[0], max(out[1], out[2]));
					if (m > threshold) {
						out[0] = out[0] * threshold / m;
						out[1] = out[1] * threshold / m;
						out[2] = out[2] * threshold / m;
					}
				}
				// all done, but we let them override it with a .lit
			}
		}
	}

	// Missing or corrupt vanilla lighting needed for .lit files, bail.
	if (l->filelen <= 0 || l->filelen >= INT_MAX / 3) {
		return;
	}

	//check for a .lit file
	mark = Hunk_LowMark();
	data = LoadColoredLighting(loadmodel->name, &litfilename, &filesize);
	if (data) {
		if (filesize < 8 || strncmp((char *)data, "QLIT", 4)) {
			Com_Printf("Corrupt .lit file (%s)...ignoring\n", COM_SkipPath(litfilename));
		} else if (l->filelen * 3 + 8 != filesize) {
			Com_Printf("Warning: .lit file (%s) has incorrect size\n", COM_SkipPath(litfilename));
		} else if ((lit_ver = LittleLong(((int *)data)[1])) != 1) {
			Com_Printf("Unknown .lit file version (v%d)\n", lit_ver);
		} else {
			extern cvar_t gl_oldlitscaling;
			if (developer.integer || cl_warncmd.integer) {
				Com_Printf("Static coloured lighting loaded\n");
			}
			loadmodel->lightdata = data + 8;
			loadmodel->lightdatasamplesize = 3;

			in = mod_base + l->fileofs;
			out = loadmodel->lightdata;
			if (gl_oldlitscaling.integer) {
				// old way (makes colored areas too dark)
				for (i = 0; i < l->filelen; i++, in++, out+=3) {
					float m, s;

					m = max(out[0], max(out[1], out[2]));
					if (!m) {
						out[0] = out[1] = out[2] = *in;
					} else {
						s = *in / m;
						out[0] = (int) (s * out[0]);
						out[1] = (int) (s * out[1]);
						out[2] = (int) (s * out[2]);
					}
				}
			}
			else {
				// new way
				float threshold = (lightmode == 1 ? 255 : lightmode == 2 ? 170 : 128);
				for (i = 0; i < l->filelen; i++, in++, out+=3) {
					float r, g, b, m, p, s;
					if (!out[0] && !out[1] && !out[2]) {
						out[0] = out[1] = out[2] = *in;
						continue;
					}

					// calculate perceived brightness of the color sample
					// kudos to Darel Rex Finley for his HSP color model
					p = sqrt(out[0]*out[0]*0.241 + out[1]*out[1]*0.691 + out[2]*out[2]*0.068);
					// scale to match perceived brightness of monochrome sample
					s = *in / p;
					r = s * out[0];
					g = s * out[1];
					b = s * out[2];
					m = max(r, max(g, b));
					if (m > threshold) {
						// scale down to avoid color washout
						r *= threshold/m;
						g *= threshold/m;
						b *= threshold/m;
					}
					out[0] = (int) (r + 0.5);
					out[1] = (int) (g + 0.5);
					out[2] = (int) (b + 0.5);
				}
			}
			return;
		}
		Hunk_FreeToLowMark (mark);
	}

	if (loadmodel->lightdata) {
		return;		// we have loaded inline RGB data
	}

	//no .lit found, expand the white lighting data to color
	loadmodel->lightdata = (byte *) Hunk_AllocName (l->filelen * 3, va("%s_@lightdata", loadmodel->name));
	loadmodel->lightdatasamplesize = 3;
	in = mod_base + l->fileofs;
	out = loadmodel->lightdata;
	for (i = 0; i < l->filelen; i++, out += 3) {
		out[0] = out[1] = out[2] = *in++;
	}
}

static qbool Mod_LoadExternalSkyTexture(texture_t *tx)
{
	char *altname, *mapname;
	char solidname[MAX_QPATH], alphaname[MAX_QPATH];
	char altsolidname[MAX_QPATH], altalphaname[MAX_QPATH];
	byte alphapixel = 255;
	int flags = TEX_MIPMAP | (!gl_scaleskytextures.integer ? TEX_NOSCALE : 0);

	if (!R_ExternalTexturesEnabled(true)) {
		return false;
	}

	altname = TranslateTextureName (tx);
	mapname = Cvar_String("mapname");
	snprintf (solidname, sizeof(solidname), "%s_solid", tx->name);
	snprintf (alphaname, sizeof(alphaname), "%s_alpha", tx->name);

	solidskytexture = R_LoadTextureImage (va("textures/%s/%s", mapname, solidname), solidname, 0, 0, flags);
	if (!R_TextureReferenceIsValid(solidskytexture) && altname) {
		snprintf(altsolidname, sizeof(altsolidname), "%s_solid", altname);
		solidskytexture = R_LoadTextureImage (va("textures/%s", altsolidname), altsolidname, 0, 0, flags);
	}
	if (!R_TextureReferenceIsValid(solidskytexture)) {
		solidskytexture = R_LoadTextureImage(va("textures/%s", solidname), solidname, 0, 0, flags);
	}
	if (!R_TextureReferenceIsValid(solidskytexture)) {
		return false;
	}

	alphaskytexture = R_LoadTextureImage (va("textures/%s/%s", mapname, alphaname), alphaname, 0, 0, TEX_ALPHA | TEX_PREMUL_ALPHA | flags);
	if (!R_TextureReferenceIsValid(alphaskytexture) && altname) {
		snprintf (altalphaname, sizeof(altalphaname), "%s_alpha", altname);
		alphaskytexture = R_LoadTextureImage (va("textures/%s", altalphaname), altalphaname, 0, 0, TEX_ALPHA | TEX_PREMUL_ALPHA | flags);
	}
	if (!R_TextureReferenceIsValid(alphaskytexture)) {
		alphaskytexture = R_LoadTextureImage(va("textures/%s", alphaname), alphaname, 0, 0, TEX_ALPHA | TEX_PREMUL_ALPHA | flags);
	}
	if (!R_TextureReferenceIsValid(alphaskytexture)) {
		// Load a texture consisting of a single transparent pixel
		alphaskytexture = R_LoadTexture(alphaname, 1, 1, &alphapixel, TEX_ALPHA | TEX_PREMUL_ALPHA | flags, 1);
	}
	return true;
}

static void Mod_LoadVisibility(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	if (l->filelen <= 0) {
		loadmodel->visdata = NULL;
		return;
	}
	loadmodel->visdata = (byte*)Hunk_AllocName(l->filelen, loadmodel->name);
	loadmodel->visdata_length = l->filelen;
	memcpy(loadmodel->visdata, mod_base + l->fileofs, l->filelen);
}

static void Mod_LoadSubmodels(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	dmodel_t *in, *out;
	int i, j, count;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadSubmodels: funny lump size in %s", loadmodel->name);
		return;
	}
	count = l->filelen / sizeof(*in);
	if (count > MAX_MODELS) {
		Host_Error("Mod_LoadSubmodels : count > MAX_MODELS");
		return;
	}
	if (count > INT_MAX / sizeof(*out)) {
		Host_Error("Mod_LoadSubmodels : count > %d", INT_MAX);
		return;
	}
	out = (dmodel_t *) Hunk_AllocName ( count*sizeof(*out), loadmodel->name);

	loadmodel->submodels = out;
	loadmodel->numsubmodels = count;

	for (i = 0; i < count; i++, in++, out++)	{
		for (j = 0; j < 3; j++) {	// spread the mins / maxs by a pixel
			out->mins[j] = LittleFloat (in->mins[j]) - 1;
			out->maxs[j] = LittleFloat (in->maxs[j]) + 1;
			out->origin[j] = LittleFloat (in->origin[j]);
		}
		for (j = 0; j < MAX_MAP_HULLS; j++) {
			out->headnode[j] = LittleLong(in->headnode[j]);
		}
		out->visleafs = LittleLong (in->visleafs);
		out->firstface = LittleLong (in->firstface);
		out->numfaces = LittleLong (in->numfaces);
	}
}

static void Mod_LoadTextures(model_t* mod, lump_t *l, byte* mod_base)
{
	int i, j, num, max, altmax, pixels;
	miptex_t *mt;
	texture_t *tx, *tx2, *anims[10], *altanims[10];
	dmiptexlump_t *m;

	if (l->filelen <= 0) {
		mod->textures = NULL;
		return;
	}

	m = (dmiptexlump_t *) (mod_base + l->fileofs);
	m->nummiptex = LittleLong (m->nummiptex);
	if (m->nummiptex < 0 || m->nummiptex > INT_MAX / sizeof(*mod->textures)) {
		Host_Error("Mod_LoadTextures: nummiptex %d (0-%d)", m->nummiptex, INT_MAX / sizeof(*mod->textures));
		return;
	}
	mod->numtextures = m->nummiptex;
	mod->textures = (texture_t **) Hunk_AllocName(m->nummiptex * sizeof(*mod->textures), mod->name);

	for (i = 0; i < m->nummiptex; i++) {
		m->dataofs[i] = LittleLong(m->dataofs[i]);
		if (m->dataofs[i] == -1) {
			continue;
		}

		if (m->dataofs[i] < 0 || m->dataofs[i] > l->fileofs + l->filelen - sizeof(miptex_t)) {
			Host_Error("Miptex %d has data offset %d (-1 to %d)", i, m->dataofs[i], l->fileofs + l->filelen - sizeof(miptex_t));
		}

		mt = (miptex_t *)((byte *)m + m->dataofs[i]);
		if ((uintptr_t)mt > (uintptr_t)mod_base + l->fileofs + l->filelen - sizeof(miptex_t)) {
			Host_Error("Texture %s data offset > lump (%d + %d vs %d)", mt->name, mod_base, l->fileofs, l->filelen);
		}
		mt->width  = LittleLong(mt->width);
		mt->height = LittleLong(mt->height);
		for (j = 0; j < MIPLEVELS; j++) {
			mt->offsets[j] = LittleLong(mt->offsets[j]);
		}

		if ((mt->width & 15) || (mt->height & 15)) {
			Host_Error("Texture %s is not 16 aligned", mt->name);
		}

		pixels = mt->width * mt->height / 64 * 85;// some magic numbers?
		if (mod->bspversion == HL_BSPVERSION) {
			pixels += 2 + 256 * 3;	/* palette and unknown two bytes */
		}
		// Some sanity checking (improve!)
		if (pixels < 0 || m->dataofs[i] > (l->fileofs + l->filelen - pixels) || pixels > INT_MAX - sizeof(texture_t)) {
			Host_Error("Texture %s: offset %d pixelsize %d, lumpsize %d", mt->name, m->dataofs[i], pixels, l->filelen);
		}
		tx = (texture_t *)Hunk_AllocName(sizeof(texture_t) + pixels, mod->name);
		mod->textures[i] = tx;

		memcpy(tx->name, mt->name, sizeof(tx->name));
		if (!tx->name[0]) {
			snprintf(tx->name, sizeof(tx->name), "unnamed%d", i);
			Com_DPrintf("Warning: unnamed texture in %s, renaming to %s\n", mod->name, tx->name);
		}

		tx->width  = mt->width;
		tx->height = mt->height;
		tx->index = i;
		tx->loaded = false; // so texture will be reloaded

		if (tx->width < 0 || tx->height < 0) {
			Host_Error("Texture %s negative dimensions: %dx%d", tx->name, tx->width, tx->height);
		}
		if (tx->width == 0 || tx->height == 0) {
			Con_Printf("Warning: Skipping zero size texture %s in %s\n", tx->name, mod->name);
			continue;
		}
		if (tx->width > INT_MAX / tx->height / 3) {
			Host_Error("Texture %s excessive size: %dx%d", tx->name, tx->width, tx->height);
		}

		if (mod->bspversion == HL_BSPVERSION) {
			if (!mt->offsets[0]) {
				continue;
			}

			// the pixels immediately follow the structures
			memcpy(tx + 1, mt + 1, pixels);
			for (j = 0; j < MIPLEVELS; j++) {
				tx->offsets[j] = mt->offsets[j] + sizeof(texture_t) - sizeof(miptex_t);
			}
			continue;
		}

		if (mt->offsets[0]) {
			// the pixels immediately follow the structures
			memcpy(tx+1, mt+1, pixels);

			for (j = 0; j < MIPLEVELS; j++) {
				tx->offsets[j] = mt->offsets[j] + sizeof(texture_t) - sizeof(miptex_t);
			}

			// HACK HACK HACK
			if (!strcmp(mt->name, "shot1sid") && mt->width==32 && mt->height==32
				&& CRC_Block((byte*)(mt+1), mt->width*mt->height) == 65393)
			{	// This texture in b_shell1.bsp has some of the first 32 pixels painted white.
				// They are invisible in software, but look really ugly in GL. So we just copy
				// 32 pixels from the bottom to make it look nice.
				memcpy (tx+1, (byte *)(tx+1) + 32*31, 32);
			}

			// just for r_fastturb's sake
			{
				byte *data = (byte *) &d_8to24table[*((byte *) mt + mt->offsets[0] + ((mt->height * mt->width) >> 1))];
				tx->flatcolor3ub = (255 << 24) + (data[0] << 0) + (data[1] << 8) + (data[2] << 16);

				if (strstr(tx->name, "water") || strstr(tx->name, "mwat")) {
					tx->turbType = TEXTURE_TURB_WATER;
				}
				else if (strstr(tx->name, "slime")) {
					tx->turbType = TEXTURE_TURB_SLIME;
				}
				else if (strstr(tx->name, "lava")) {
					tx->turbType = TEXTURE_TURB_LAVA;
				}
				else if (strstr(tx->name, "tele")) {
					tx->turbType = TEXTURE_TURB_TELE;
				}
			}
		}
	}

	R_LoadBrushModelTextures(mod);

	// sequence the animations
	for (i = 0; i < m->nummiptex; i++) {
		tx = mod->textures[i];
		if (!tx || tx->name[0] != '+') {
			continue;
		}
		if (tx->anim_next) {
			continue; // already sequenced
		}

		// find the number of frames in the animation
		memset (anims, 0, sizeof(anims));
		memset (altanims, 0, sizeof(altanims));

		max = tx->name[1];
		altmax = 0;
		if (max >= 'a' && max <= 'z') {
			max -= 'a' - 'A';
		}
		if (max >= '0' && max <= '9') {
			max -= '0';
			altmax = 0;
			anims[max] = tx;
			max++;
		}
		else if (max >= 'A' && max <= 'J') {
			altmax = max - 'A';
			max = 0;
			altanims[altmax] = tx;
			altmax++;
		}
		else {
			Host_Error ("Mod_LoadTextures: Bad animating texture %s", tx->name);
		}

		for (j = i + 1; j < m->nummiptex; j++) {
			tx2 = mod->textures[j];
			if (!tx2 || tx2->name[0] != '+') {
				continue;
			}
			if (strcmp(tx2->name + 2, tx->name + 2)) {
				continue;
			}

			num = tx2->name[1];
			if (num >= 'a' && num <= 'z') {
				num -= 'a' - 'A';
			}
			if (num >= '0' && num <= '9') {
				num -= '0';
				anims[num] = tx2;
				if (num + 1 > max) {
					max = num + 1;
				}
			}
			else if (num >= 'A' && num <= 'J') {
				num = num - 'A';
				altanims[num] = tx2;
				if (num + 1 > altmax) {
					altmax = num + 1;
				}
			}
			else {
				Host_Error ("Mod_LoadTextures: Bad animating texture %s", tx->name);
			}
		}

#define	ANIM_CYCLE	2
		// link them all together
		for (j = 0; j < max && j < sizeof(anims) / sizeof(anims[0]); j++) {
			tx2 = anims[j];
			if (!tx2) {
				Host_Error("Mod_LoadTextures: Missing frame %i of %s", j, tx->name);
				return;
			}
			tx2->anim_total = max * ANIM_CYCLE;
			tx2->anim_min = j * ANIM_CYCLE;
			tx2->anim_max = (j + 1) * ANIM_CYCLE;
			tx2->anim_next = anims[(j + 1) % max];
			if (altmax) {
				tx2->alternate_anims = altanims[0];
			}
		}
		for (j = 0; j < altmax && j < sizeof(altanims) / sizeof(altanims[0]); j++) {
			tx2 = altanims[j];
			if (!tx2) {
				Host_Error("Mod_LoadTextures: Missing frame %i of %s", j, tx->name);
				return;
			}
			tx2->anim_total = altmax * ANIM_CYCLE;
			tx2->anim_min = j * ANIM_CYCLE;
			tx2->anim_max = (j + 1) * ANIM_CYCLE;
			tx2->anim_next = altanims[ (j + 1) % altmax ];
			if (max) {
				tx2->alternate_anims = anims[0];
			}
		}
	}
}

static void Mod_LoadVertexes(model_t* mod, lump_t *l, byte* mod_base)
{
	dvertex_t *in;
	mvertex_t *out;
	int i, count;
	int max_vertices = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen <= 0) {
		Host_Error("Mod_LoadVertexes: lump size <= 0 in %s", mod->name);
		return;
	}
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadVertexes: funny lump size in %s", mod->name);
		return;
	}
	count = l->filelen / sizeof(*in);
	if (count > max_vertices) {
		Host_Error("Mod_LoadVertexes: invalid vertex count (%d vs 0-%d)", count, max_vertices);
		return;
	}
	out = (mvertex_t *)Hunk_AllocName(count * sizeof(*out), mod->name);

	mod->vertexes = out;
	mod->numvertexes = count;

	for (i = 0; i < count; i++, in++, out++) {
		out->position[0] = LittleFloat(in->point[0]);
		out->position[1] = LittleFloat(in->point[1]);
		out->position[2] = LittleFloat(in->point[2]);
	}
}

static void Mod_LoadEdges(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	dedge_t *in;
	medge_t *out;
	int i, count;
	int max_edges = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadEdges: funny lump size in %s", loadmodel->name);
		return;
	}
	count = l->filelen / sizeof(*in);
	if (count < 0 || count + 1 >= max_edges) {
		Host_Error("Mod_LoadEdges: invalid edge count (%d vs 0-%d)", count, max_edges);
		return;
	}
	out = (medge_t *) Hunk_AllocName ( (count + 1) * sizeof(*out), loadmodel->name);

	loadmodel->edges = out;
	loadmodel->numedges = count;

	for (i = 0; i < count; i++, in++, out++) {
		out->v[0] = (unsigned short) LittleShort(in->v[0]);
		out->v[1] = (unsigned short) LittleShort(in->v[1]);
	}
}

static void Mod_LoadEdgesBSP2(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	dedge29a_t *in;
	medge_t *out;
	int i, count;
	int max_edges = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
		Host_Error ("Mod_LoadEdges: funny lump size in %s", loadmodel->name);
	count = l->filelen / sizeof(*in);
	if (count < 0 || count + 1 >= max_edges) {
		Host_Error("Mod_LoadEdges: invalid edge count (%d vs 0-%d)", count, max_edges);
		return;
	}
	out = (medge_t *) Hunk_AllocName ( (count + 1) * sizeof(*out), loadmodel->name);

	loadmodel->edges = out;
	loadmodel->numedges = count;

	for (i = 0; i < count; i++, in++, out++) {
		out->v[0] = LittleLong(in->v[0]);
		out->v[1] = LittleLong(in->v[1]);
	}
}

static void Mod_LoadSurfedges(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	int i, count, *in, *out;
	int max_edges = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
		Host_Error ("Mod_LoadSurfedges: funny lump size in %s", loadmodel->name);
	count = l->filelen / sizeof(*in);
	if (count < 0 || count + 1 >= max_edges) {
		Host_Error("Mod_LoadSurfEdges: invalid edge count (%d vs 0-%d)", count, max_edges);
		return;
	}
	out = (int *) Hunk_AllocName ( count*sizeof(*out), loadmodel->name);

	loadmodel->surfedges = out;
	loadmodel->numsurfedges = count;

	for (i = 0; i < count; i++) {
		out[i] = LittleLong(in[i]);
	}
}

static void Mod_LoadPlanes(model_t* model, lump_t* l, byte* mod_base)
{
	int i, j, count, bits;
	mplane_t *out;
	dplane_t *in;
	int max_planes = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadPlanes: funny lump size in %s", model->name);
	}
	count = l->filelen / sizeof(*in);
	if (count < 0 || count >= max_planes) {
		Host_Error("Mod_LoadPlanes: invalid plane count (%d vs 0-%d)", count, max_planes);
		return;
	}
	out = (mplane_t *) Hunk_AllocName ( count*sizeof(*out), model->name);

	model->planes = out;
	model->numplanes = count;

	for (i = 0; i < count; i++, in++, out++) {
		bits = 0;
		for (j = 0; j < 3 ; j++) {
			out->normal[j] = LittleFloat (in->normal[j]);
			if (out->normal[j] < 0) {
				bits |= 1 << j;
			}
		}

		out->dist = LittleFloat (in->dist);
		out->type = LittleLong (in->type);
		out->signbits = bits;
	}
}

static void Mod_LoadMarksurfacesBSP2(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	int i, count;
	unsigned int j;
	int *in;
	msurface_t **out;
	int max_surfaces = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadMarksurfaces: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count < 0 || count >= max_surfaces) {
		Host_Error("Mod_LoadMarksurfaces: invalid marksurface count (%d vs 0-%d)", count, max_surfaces);
		return;
	}
	out = (msurface_t **)Hunk_AllocName(count * sizeof(*out), loadmodel->name);

	loadmodel->marksurfaces = out;
	loadmodel->nummarksurfaces = count;

	for (i = 0; i < count; i++) {
		// Surface indices are unsigned
		j = (unsigned int) LittleLong(in[i]);
		if (j >= loadmodel->numsurfaces) {
			Host_Error("Mod_LoadMarksurfaces: bad surface number");
		}
		out[i] = loadmodel->surfaces + j;
	}
}

static void Mod_LoadMarksurfaces(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	int i, count;
	unsigned short j;
	short *in;
	msurface_t **out;
	int max_surfaces = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadMarksurfaces: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count < 0 || count >= max_surfaces) {
		Host_Error("Mod_LoadMarksurfaces: invalid marksurface count (%d vs 0-%d)", count, max_surfaces);
		return;
	}
	out = (msurface_t **) Hunk_AllocName ( count*sizeof(*out), loadmodel->name);

	loadmodel->marksurfaces = out;
	loadmodel->nummarksurfaces = count;

	for (i = 0; i < count; i++) {
		// Surface indices are unsigned
		j = (unsigned short) LittleShort(in[i]);
		if (j >= loadmodel->numsurfaces) {
			Host_Error("Mod_LoadMarksurfaces: bad surface number");
		}
		out[i] = loadmodel->surfaces + j;
	}
}

static void Mod_ParseWadsFromEntityLump(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	const char *data;
	char *s, key[1024], value[1024];
	int i, j, k;

	if (l->filelen <= 0) {
		return;
	}

	data = (char *)(mod_base + l->fileofs);
	data = COM_Parse(data);
	if (!data) {
		return;
	}

	if (com_token[0] != '{') {
		return; // error
	}

	while (1) {
		if (!(data = COM_Parse(data))) {
			return; // error
		}

		if (com_token[0] == '}') {
			break; // end of worldspawn
		}

		strlcpy(key, (com_token[0] == '_') ? com_token + 1 : com_token, sizeof(key));
		for (s = key + strlen(key) - 1; s >= key && *s == ' '; s--) {
			// remove trailing spaces
			*s = 0;
		}

		if (!(data = COM_Parse(data))) {
			return; // error
		}

		strlcpy(value, com_token, sizeof(value));
		if (!strcmp("sky", key) || !strcmp("skyname", key)) {
			Cvar_Set(&r_skyname, value);
		}

		if (!strcmp("wad", key)) {
			j = 0;
			for (i = 0; i < strlen(value); i++) {
				if (value[i] != ';' && value[i] != '\\' && value[i] != '/' && value[i] != ':') {
					break;
				}
			}
			if (!value[i]) {
				continue;
			}
			for ( ; i < sizeof(value); i++) {
				// ignore path - the \\ check is for HalfLife
				if (value[i] == '\\' || value[i] == '/' || value[i] == ':') {
					j = i + 1;
				}
				else if (value[i] == ';' || value[i] == 0) {
					k = value[i];
					value[i] = 0;
					if (value[j]) {
						WAD3_LoadWadFile(value + j);
					}
					j = i + 1;
					if (!k) {
						break;
					}
				}
			}
		}
	}
}

static void Mod_LoadTexinfo(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	texinfo_t *in;
	mtexinfo_t *out;
	int i, j, k, count;
	int max_texinfo = (INT_MAX / sizeof(*out));

	in = (void *) (mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadTexinfo: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count > max_texinfo) {
		Host_Error("Mod_LoadTexinfo: invalid texinfo count (%d vs 0-%d)", count, max_texinfo);
		return;
	}
	out = (mtexinfo_t *) Hunk_AllocName (count*sizeof(*out), loadmodel->name);

	loadmodel->texinfo = out;
	loadmodel->numtexinfo = count;

	for (i = 0; i < count; i++, in++, out++) {
		for (j = 0; j < 2; j++) {
			for (k = 0; k < 4; k++) {
				out->vecs[j][k] = LittleFloat(in->vecs[j][k]);
			}
		}

		out->miptex = LittleLong (in->miptex);
		out->flags = LittleLong (in->flags);

		// Skip texture unless surface flags say otherwise
		out->skippable = out->flags & TEX_SPECIAL;

		if (!loadmodel->textures) {
			out->texture = r_notexture_mip;	// checkerboard texture
			out->flags = 0;
		}
		else {
			if (out->miptex >= loadmodel->numtextures) {
				Host_Error("Mod_LoadTexinfo: %d miptex %d >= loadmodel->numtextures", i, out->miptex);
			}
			if (out->miptex < 0) {
				Host_Error("Mod_LoadTexinfo: %d miptex %d < 0", i, out->miptex);
			}
			out->texture = loadmodel->textures[out->miptex];
			if (!out->texture) {
				out->texture = r_notexture_mip; // texture not found
				out->flags = 0;
			}
		}
	}
}

// Extension to support lightmaps that aren't tied to texture scale.
static int Mod_LoadDecoupledLM(dlminfo_t* lminfos, int surfnum, msurface_t *out)
{
	dlminfo_t *lminfo;
	unsigned short lmwidth, lmheight;
	int i, j;

	if (lminfos == NULL) {
		return -1;
	}

	lminfo = lminfos + surfnum;

	lmwidth = LittleShort(lminfo->lmwidth);
	lmheight = LittleShort(lminfo->lmheight);

	if (lmwidth <= 0 || lmheight <= 0) {
		return -1;
	}

	for (i = 0; i < 2; i++) {
		for (j = 0; j < 4; j++) {
			out->lmvecs[i][j] = LittleFloat(lminfo->vecs[i][j]);
		}
	}

	out->extents[0] = (short)(lmwidth - 1);
	out->extents[1] = (short)(lmheight - 1);
	out->lmshift = 0;
	out->texturemins[0] = 0;
	out->texturemins[1] = 0;

	float v0 = VectorLength(out->lmvecs[0]);
	out->lmvlen[0] = v0 > 0.0f ? 1.0f / v0 : 0.0f;

	float v1 = VectorLength(out->lmvecs[1]);
	out->lmvlen[1] = v1 > 0.0f ? 1.0f / v1 : 0.0f;

	return LittleLong(lminfo->lightofs);
}

static void Mod_LoadFaces(model_t* loadmodel, lump_t* l, byte* mod_base, bspx_header_t *bspx_header)
{
	dlminfo_t *lminfos;
	dface_t *in;
	msurface_t *out;
	int count, surfnum, planenum, side, lminfosize, lightofs;
	int max_faces = INT_MAX / sizeof(*out);
	int texinfo;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
		Host_Error ("Mod_LoadFaces: funny lump size in %s", loadmodel->name);
	count = l->filelen / sizeof(*in);
	if (count <= 0 || count > max_faces) {
		Host_Error("Mod_LoadFaces: invalid surface count (%d vs 0-%d)", count, max_faces);
		return;
	}
	out = (msurface_t *) Hunk_AllocName ( count*sizeof(*out), loadmodel->name);

	loadmodel->surfaces = out;
	loadmodel->numsurfaces = count;

	lminfos = Mod_BSPX_FindLump(bspx_header, "DECOUPLED_LM", &lminfosize, mod_base);
	if (lminfos != NULL && lminfosize / sizeof(dlminfo_t) != loadmodel->numsurfaces) {
		Com_Printf("[%s] decoupled_lm size %d does not match surface count %d\n", loadmodel->name, lminfosize / sizeof(dlminfo_t), loadmodel->numsurfaces);
		lminfos = NULL;
	}

	for (surfnum = 0; surfnum < count; surfnum++, in++, out++) {
		out->firstedge = LittleLong(in->firstedge);
		out->numedges = LittleShort(in->numedges);
		out->flags = 0;

		texinfo = LittleShort(in->texinfo);

		if (out->firstedge < 0 || out->firstedge >= loadmodel->numsurfedges || out->numedges > loadmodel->numsurfedges - out->firstedge) {
			Host_Error("[%s] surface %d references invalid edge range [%d length %d, vs %d]", loadmodel->name, surfnum, out->firstedge, out->numedges, loadmodel->numsurfedges);
		}

		planenum = LittleShort(in->planenum);
		if (planenum < 0 || planenum >= loadmodel->numplanes) {
			Host_Error("[%s] surface %d references invalid plane %d/%d", loadmodel->name, surfnum, planenum, loadmodel->numplanes);
		}

		side = LittleShort(in->side);
		if (side) {
			out->flags |= SURF_PLANEBACK;
		}

		if (texinfo < 0 || texinfo >= loadmodel->numtexinfo) {
			Host_Error("[%s] surface %d references invalid texinfo %d/%d", loadmodel->name, surfnum, texinfo, loadmodel->numtexinfo);
		}
		out->plane = loadmodel->planes + planenum;
		out->texinfo = loadmodel->texinfo + texinfo;

		lightofs = Mod_LoadDecoupledLM(lminfos, surfnum, out);
		if (lightofs < 0) {
			memcpy(out->lmvecs, out->texinfo->vecs, sizeof(out->lmvecs));
			out->lmshift = DEFAULT_LMSHIFT;
			out->lmvlen[0] = 1.0f;
			out->lmvlen[1] = 1.0f;

			CalcSurfaceExtents(loadmodel, out);

			lightofs = in->lightofs;
		}

		// lighting info
		SetSurfaceLighting(loadmodel, out, in->styles, lightofs);

		SetTextureFlags(loadmodel, out, surfnum);
	}
}

static void Mod_LoadFacesBSP2(model_t* loadmodel, lump_t* l, byte* mod_base, bspx_header_t *bspx_header)
{
	dlminfo_t *lminfos;
	dface29a_t *in;
	msurface_t *out;
	int count, surfnum, planenum, side, lminfosize, lightofs;
	int max_faces = INT_MAX / sizeof(*out);

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadFaces: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count <= 0 || count > max_faces) {
		Host_Error("Mod_LoadFaces: invalid surface count (%d vs 0-%d)", count, max_faces);
		return;
	}
	out = (msurface_t *) Hunk_AllocName ( count*sizeof(*out), loadmodel->name);

	loadmodel->surfaces = out;
	loadmodel->numsurfaces = count;

	lminfos = Mod_BSPX_FindLump(bspx_header, "DECOUPLED_LM", &lminfosize, mod_base);
	if (lminfos != NULL && lminfosize / sizeof(dlminfo_t) != loadmodel->numsurfaces) {
		Com_Printf("[%s] decoupled_lm size %d does not match surface count %d\n", loadmodel->name, lminfosize / sizeof(dlminfo_t), loadmodel->numsurfaces);
		lminfos = NULL;
	}

	for (surfnum = 0; surfnum < count; surfnum++, in++, out++) {
		out->firstedge = LittleLong(in->firstedge);
		out->numedges = LittleLong(in->numedges);
		out->flags = 0;

		planenum = LittleLong(in->planenum);
		side = LittleLong(in->side);
		if (side) {
			out->flags |= SURF_PLANEBACK;
		}

		out->plane = loadmodel->planes + planenum;
		out->texinfo = loadmodel->texinfo + LittleLong(in->texinfo);

		lightofs = Mod_LoadDecoupledLM(lminfos, surfnum, out);
		if (lightofs < 0) {
			memcpy(out->lmvecs, out->texinfo->vecs, sizeof(out->lmvecs));
			out->lmshift = DEFAULT_LMSHIFT;
			out->lmvlen[0] = 1.0f;
			out->lmvlen[1] = 1.0f;

			CalcSurfaceExtents(loadmodel, out);

			lightofs = in->lightofs;
		}

		// lighting info
		SetSurfaceLighting(loadmodel, out, in->styles, lightofs);

		SetTextureFlags(loadmodel, out, surfnum);
	}
}

static void Mod_LoadNodes(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	int i, j, count, p;
	dnode_t *in;
	mnode_t *out;
	int max_nodes = (INT_MAX / sizeof(*out));

	in = (void *) (mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadNodes: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count <= 0 || count > max_nodes) {
		Host_Error("Mod_LoadNodes: invalid node count (%d vs 0-%d)", count, max_nodes);
		return;
	}
	out = (mnode_t *) Hunk_AllocName (count * sizeof(*out), loadmodel->name);

	loadmodel->nodes = out;
	loadmodel->numnodes = count;

	for (i = 0; i < count; i++, in++, out++) {
		for (j = 0; j < 3; j++) {
			out->minmaxs[j] = LittleShort (in->mins[j]);
			out->minmaxs[3 + j] = LittleShort (in->maxs[j]);
		}

		p = LittleLong(in->planenum);
		out->plane = loadmodel->planes + p;

		out->firstsurface = LittleShort (in->firstface);
		out->numsurfaces = LittleShort (in->numfaces);

		for (j = 0; j < 2; j++) {
			p = LittleShort (in->children[j]);
			if (p >= 0) {
				out->children[j] = loadmodel->nodes + p;
			}
			else {
				out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
			}
		}
	}

	Mod_SetParent (loadmodel->nodes, NULL);	// sets nodes and leafs
}

static void Mod_LoadNodes29a(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	int i, j, count, p;
	dnode29a_t *in;
	mnode_t *out;
	int max_nodes = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadNodes: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count <= 0 || count > max_nodes) {
		Host_Error("Mod_LoadNodes: invalid node count (%d vs 0-%d)", count, max_nodes);
		return;
	}
	out = (mnode_t *) Hunk_AllocName (count * sizeof(*out), loadmodel->name);

	loadmodel->nodes = out;
	loadmodel->numnodes = count;

	for (i = 0; i < count; i++, in++, out++) {
		for (j = 0; j < 3; j++) {
			out->minmaxs[j] = LittleShort (in->mins[j]);
			out->minmaxs[3 + j] = LittleShort (in->maxs[j]);
		}

		p = LittleLong(in->planenum);
		out->plane = loadmodel->planes + p;

		out->firstsurface = LittleLong (in->firstface);
		out->numsurfaces = LittleLong (in->numfaces);

		for (j = 0; j < 2; j++) {
			p = LittleLong (in->children[j]);
			if (p >= 0) {
				out->children[j] = loadmodel->nodes + p;
			}
			else {
				out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
			}
		}
	}

	Mod_SetParent (loadmodel->nodes, NULL);	// sets nodes and leafs
}

static void Mod_LoadNodesBSP2(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	int i, j, count, p;
	dnode_bsp2_t *in;
	mnode_t *out;
	int max_nodes = (INT_MAX / sizeof(*out));

	in = (void *) (mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadNodes: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count <= 0 || count > max_nodes) {
		Host_Error("Mod_LoadNodes: invalid node count (%d vs 0-%d)", count, max_nodes);
		return;
	}
	out = (mnode_t *) Hunk_AllocName (count * sizeof(*out), loadmodel->name);

	loadmodel->nodes = out;
	loadmodel->numnodes = count;

	for (i = 0; i < count; i++, in++, out++) {
		for (j = 0; j < 3; j++) {
			out->minmaxs[j] = LittleFloat (in->mins[j]);
			out->minmaxs[3 + j] = LittleFloat (in->maxs[j]);
		}

		p = LittleLong(in->planenum);
		out->plane = loadmodel->planes + p;

		out->firstsurface = LittleLong (in->firstface);
		out->numsurfaces = LittleLong (in->numfaces);

		for (j = 0; j < 2; j++) {
			p = LittleLong (in->children[j]);
			if (p >= 0) {
				out->children[j] = loadmodel->nodes + p;
			}
			else {
				out->children[j] = (mnode_t*)(loadmodel->leafs + (-1 - p));
			}
		}
	}

	Mod_SetParent (loadmodel->nodes, NULL);	// sets nodes and leafs
}

static qbool ContentsIsLiquid(int contents)
{
	switch (contents) {
	case CONTENTS_WATER:
	case CONTENTS_SLIME:
	case CONTENTS_LAVA:
		return true;
	default:
		return false;
	}
}

static void Mod_LoadLeafs(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	dleaf_t *in;
	mleaf_t *out;
	int i, j, count, p;
	int max_leafs = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
		Host_Error ("Mod_LoadLeafs: funny lump size in %s", loadmodel->name);
	count = l->filelen / sizeof(*in);
	if (count <= 0 || count > max_leafs) {
		Host_Error("Mod_LoadNodes: invalid node count (%d vs 0-%d)", count, max_leafs);
		return;
	}
	out = (mleaf_t *) Hunk_AllocName ( count*sizeof(*out), loadmodel->name);

	loadmodel->leafs = out;
	loadmodel->numleafs = count;
	for (i = 0; i < count; i++, in++, out++) {
		int first_marksurface, num_marksurfaces;

		for (j = 0; j < 3; j++) {
			out->minmaxs[j] = LittleShort (in->mins[j]);
			out->minmaxs[3 + j] = LittleShort (in->maxs[j]);
		}

		p = LittleLong(in->contents);
		out->contents = p;

		first_marksurface = LittleShort(in->firstmarksurface);
		num_marksurfaces = LittleShort(in->nummarksurfaces);

		if (first_marksurface < 0 || first_marksurface > loadmodel->nummarksurfaces) {
			Host_Error("Mod_LoadLeafs: first mark surface invalid (%d vs 0-%d)", first_marksurface, loadmodel->nummarksurfaces);
		}
		if (num_marksurfaces < 0 || num_marksurfaces > loadmodel->nummarksurfaces - first_marksurface) {
			Host_Error("Mod_LoadLeafs: num_marksurfaces invalid (%d + %d vs 0-%d)", first_marksurface, num_marksurfaces, loadmodel->nummarksurfaces);
		}

		out->firstmarksurface = loadmodel->marksurfaces + first_marksurface;
		out->nummarksurfaces = num_marksurfaces;

		p = LittleLong(in->visofs);
		out->compressed_vis = (p == -1 || loadmodel->visdata == NULL || p >= loadmodel->visdata_length) ? NULL : loadmodel->visdata + p;
		out->efrags = NULL;

		if (ContentsIsLiquid(out->contents)) {
			for (j = 0; j < out->nummarksurfaces; j++)
				out->firstmarksurface[j]->flags |= SURF_UNDERWATER;
		}
	}
}

static void Mod_LoadLeafs29a(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	dleaf29a_t *in;
	mleaf_t *out;
	int i, j, count, p;
	int max_leafs = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadLeafs: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count <= 0 || count > max_leafs) {
		Host_Error("Mod_LoadNodes: invalid node count (%d vs 0-%d)", count, max_leafs);
		return;
	}
	out = (mleaf_t *) Hunk_AllocName (count*sizeof(*out), loadmodel->name);

	loadmodel->leafs = out;
	loadmodel->numleafs = count;
	for (i = 0; i < count; i++, in++, out++)	{
		for (j = 0; j < 3; j++) {
			out->minmaxs[j] = LittleShort (in->mins[j]);
			out->minmaxs[3 + j] = LittleShort (in->maxs[j]);
		}

		p = LittleLong(in->contents);
		out->contents = p;

		out->firstmarksurface = loadmodel->marksurfaces +
			LittleLong(in->firstmarksurface);
		out->nummarksurfaces = LittleLong(in->nummarksurfaces);

		p = LittleLong(in->visofs);
		out->compressed_vis = (p == -1 || loadmodel->visdata == NULL || p >= loadmodel->visdata_length) ? NULL : loadmodel->visdata + p;
		out->efrags = NULL;

		if (ContentsIsLiquid(out->contents)) {
			for (j = 0; j < out->nummarksurfaces; j++)
				out->firstmarksurface[j]->flags |= SURF_UNDERWATER;
		}
	}
}

static void Mod_LoadLeafsBSP2(model_t* loadmodel, lump_t* l, byte* mod_base)
{
	dleaf_bsp2_t *in;
	mleaf_t *out;
	int i, j, count, p;
	int max_leafs = (INT_MAX / sizeof(*out));

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in)) {
		Host_Error("Mod_LoadLeafs: funny lump size in %s", loadmodel->name);
	}
	count = l->filelen / sizeof(*in);
	if (count <= 0 || count > max_leafs) {
		Host_Error("Mod_LoadNodes: invalid node count (%d vs 0-%d)", count, max_leafs);
		return;
	}
	out = (mleaf_t *) Hunk_AllocName ( count*sizeof(*out), loadmodel->name);

	loadmodel->leafs = out;
	loadmodel->numleafs = count;

	for (i = 0; i < count; i++, in++, out++)	{
		for (j = 0; j < 3; j++) {
			out->minmaxs[j] = LittleFloat (in->mins[j]);
			out->minmaxs[3 + j] = LittleFloat (in->maxs[j]);
		}

		p = LittleLong(in->contents);
		out->contents = p;

		out->firstmarksurface = loadmodel->marksurfaces +
			LittleLong(in->firstmarksurface);
		out->nummarksurfaces = LittleLong(in->nummarksurfaces);

		p = LittleLong(in->visofs);
		out->compressed_vis = (p == -1 || loadmodel->visdata == NULL || p >= loadmodel->visdata_length) ? NULL : loadmodel->visdata + p;
		out->efrags = NULL;

		if (ContentsIsLiquid(out->contents)) {
			for (j = 0; j < out->nummarksurfaces; j++) {
				out->firstmarksurface[j]->flags |= SURF_UNDERWATER;
			}
		}
	}
}

// Called from Mod_LoadModel()
void Mod_LoadBrushModel(model_t *mod, void *buffer, int filesize)
{
	int i;
	dheader_t *header;
	dmodel_t *bm;
	vec3_t normal;
	bspx_header_t* bspx_header;

	mod->type = mod_brush;

	header = (dheader_t *)buffer;

	mod->bspversion = LittleLong(header->version);

	if (mod->bspversion != Q1_BSPVERSION && mod->bspversion != HL_BSPVERSION && mod->bspversion != Q1_BSPVERSION2 && mod->bspversion != Q1_BSPVERSION29a) {
		Host_Error("Mod_LoadBrushModel: %s has wrong version number (%i should be %i (Quake), %i (HalfLife), %i (BSP2) or %i (2PSB))", mod->name, mod->bspversion, Q1_BSPVERSION, HL_BSPVERSION, Q1_BSPVERSION2, Q1_BSPVERSION29a);
	}
	mod->isworldmodel = !strcmp(mod->name, va("maps/%s.bsp", host_mapname.string));

	// swap all the lumps
	for (i = 0; i < sizeof(dheader_t) / 4; i++) {
		((int *)header)[i] = LittleLong(((int *)header)[i]);
	}

	// Check lump sizes
	for (i = 0; i < sizeof(header->lumps) / sizeof(header->lumps[0]); ++i) {
		if (header->lumps[i].fileofs > filesize) {
			Host_Error("Mod_LoadBrushModel(%s): lump %d has offset beyond file (%d vs %d)", mod->name, i, header->lumps[i].fileofs, filesize);
			return;
		}
		if (header->lumps[i].filelen < 0) {
			Host_Error("Mod_LoadBrushModel(%s): lump %d has negative lump length (%d)", mod->name, i, header->lumps[i].filelen);
			return;
		}
		if (header->lumps[i].filelen > filesize - header->lumps[i].fileofs) {
			Host_Error("Mod_LoadBrushModel(%s): lump %d has length beyond file (%d + %d vs %d)", mod->name, i, header->lumps[i].fileofs, header->lumps[i].filelen, filesize);
			return;
		}
	}

	// check for BSPX extensions
	bspx_header = Mod_LoadBSPX(filesize, (byte*)header);

	// load into heap
	Mod_LoadVertexes(mod, &header->lumps[LUMP_VERTEXES], (byte*)header);
	if (mod->bspversion == Q1_BSPVERSION2 || mod->bspversion == Q1_BSPVERSION29a) {
		Mod_LoadEdgesBSP2(mod, &header->lumps[LUMP_EDGES], (byte*)header);
	}
	else {
		Mod_LoadEdges(mod, &header->lumps[LUMP_EDGES], (byte*)header);
	}
	Mod_LoadSurfedges(mod, &header->lumps[LUMP_SURFEDGES], (byte*)header);
	if (mod->bspversion == HL_BSPVERSION) {
		Mod_ParseWadsFromEntityLump(mod, &header->lumps[LUMP_ENTITIES], (byte*)header);
	}
	Mod_LoadTextures(mod, &header->lumps[LUMP_TEXTURES], (byte*)header);
	Mod_LoadLighting(mod, &header->lumps[LUMP_LIGHTING], (byte*)header, bspx_header);
	Mod_LoadPlanes(mod, &header->lumps[LUMP_PLANES], (byte*)header);
	Mod_LoadTexinfo(mod, &header->lumps[LUMP_TEXINFO], (byte*)header);
	if (mod->bspversion == Q1_BSPVERSION2 || mod->bspversion == Q1_BSPVERSION29a) {
		Mod_LoadFacesBSP2(mod, &header->lumps[LUMP_FACES], (byte*)header, bspx_header);
		Mod_LoadMarksurfacesBSP2(mod, &header->lumps[LUMP_MARKSURFACES], (byte*)header);
	}
	else {
		Mod_LoadFaces(mod, &header->lumps[LUMP_FACES], (byte*)header, bspx_header);
		Mod_LoadMarksurfaces(mod, &header->lumps[LUMP_MARKSURFACES], (byte*)header);
	}
	Mod_LoadVisibility(mod, &header->lumps[LUMP_VISIBILITY], (byte*)header);
	if (mod->bspversion == Q1_BSPVERSION29a) {
		Mod_LoadLeafs29a(mod, &header->lumps[LUMP_LEAFS], (byte*)header);
		Mod_LoadNodes29a(mod, &header->lumps[LUMP_NODES], (byte*)header);
	}
	else if (mod->bspversion == Q1_BSPVERSION2) {
		Mod_LoadLeafsBSP2(mod, &header->lumps[LUMP_LEAFS], (byte*)header);
		Mod_LoadNodesBSP2(mod, &header->lumps[LUMP_NODES], (byte*)header);
	}
	else {
		Mod_LoadLeafs(mod, &header->lumps[LUMP_LEAFS], (byte*)header);
		Mod_LoadNodes(mod, &header->lumps[LUMP_NODES], (byte*)header);
	}
	Mod_LoadSubmodels(mod, &header->lumps[LUMP_MODELS], (byte*)header);

	// regular and alternate animation
	mod->numframes = 2;

	// set up the submodels (FIXME: this is confusing)
	for (i = 0; i < mod->numsubmodels; i++) {
		bm = &mod->submodels[i];

		mod->firstmodelsurface = bm->firstface;
		mod->nummodelsurfaces = bm->numfaces;

		mod->firstnode = bm->headnode[0];
		if ((unsigned)mod->firstnode > mod->numnodes) {
			Host_Error("Inline model %i has bad firstnode", i);
		}

		VectorCopy(bm->maxs, mod->maxs);
		VectorCopy(bm->mins, mod->mins);

		mod->radius = RadiusFromBounds(mod->mins, mod->maxs);

		mod->numleafs = bm->visleafs;

		if (i < mod->numsubmodels - 1) {
			// duplicate the basic information
			char name[16];
			model_t* submodel;

			snprintf(name, sizeof(name), "*%i", i + 1);
			submodel = Mod_FindName(name);
			*submodel = *mod;
			strlcpy(submodel->name, name, sizeof(submodel->name));
			mod = submodel;
		}
	}

	// set wall/ceiling drawflat
	for (i = 0; i < mod->numsurfaces; ++i) {
		msurface_t* s = &mod->surfaces[i];

		VectorCopy(s->plane->normal, normal);
		VectorNormalize(normal);

		if (normal[2] < -0.5 || normal[2] > 0.5) {
			// floor or ceiling
			s->flags |= SURF_DRAWFLAT_FLOOR;
		}
	}
}

// this is initial load, or callback from VID after a vid_restart
void R_LoadBrushModelTextures(model_t *m)
{
	char		*texname;
	texture_t	*tx;
	int			i, texmode, noscale_flag, alpha_flag, brighten_flag, mipTexLevel;
	byte		*data;
	int			width, height;

	// try load simple textures
	Mod_AddModelFlags(m);
	memset(m->simpletexture, 0, sizeof(m->simpletexture));
	m->simpletexture[0] = Mod_LoadSimpleTexture(m, 0);

	if (!m->textures) {
		return;
	}

	//	Com_Printf("lm %d %s\n", lightmode, loadmodel->name);

	for (i = 0; i < m->numtextures; i++)
	{
		tx = m->textures[i];
		if (!tx) {
			continue;
		}

		if (tx->loaded) {
			continue; // seems already loaded
		}

		R_TextureReferenceInvalidate(tx->gl_texturenum);
		R_TextureReferenceInvalidate(tx->fb_texturenum);

		if (m->isworldmodel && m->bspversion != HL_BSPVERSION && Mod_IsSkyTextureName(m, tx->name)) {
			if (!Mod_LoadExternalSkyTexture(tx)) {
				R_InitSky(tx);
			}
			tx->loaded = true;
			continue; // mark as loaded
		}

		noscale_flag = 0;
		noscale_flag = (!gl_scaleModelTextures.value && !m->isworldmodel) ? TEX_NOSCALE : noscale_flag;
		noscale_flag = (!gl_scaleTurbTextures.value  && Mod_IsTurbTextureName(m, tx->name)) ? TEX_NOSCALE : noscale_flag;
		noscale_flag = (!gl_scaleAlphaTextures.value  && Mod_IsAlphaTextureName(m, tx->name)) ? TEX_NOSCALE : noscale_flag;

		mipTexLevel  = noscale_flag ? 0 : gl_miptexLevel.value;

		texmode = TEX_MIPMAP | noscale_flag;
		brighten_flag = (!Mod_IsTurbTextureName(m, tx->name) && (lightmode == 2)) ? TEX_BRIGHTEN : 0;
		alpha_flag = Mod_IsAlphaTextureName(m, tx->name) ? TEX_ALPHA : 0;

		if (Mod_LoadExternalTexture(m, tx, texmode | alpha_flag, brighten_flag)) {
			tx->loaded = true; // mark as loaded
			continue;
		}

		if (m->bspversion == HL_BSPVERSION) {
			if ((data = WAD3_LoadTexture(tx))) {
				fs_netpath[0] = 0;
				tx->gl_texturenum = R_LoadTexturePixels(data, tx->name, tx->width, tx->height, texmode | alpha_flag);
				Q_free(data);
				tx->loaded = true; // mark as loaded
				continue;
			}

			tx->offsets[0] = 0; // this mean use r_notexture_mip, any better solution?
		}

		if (tx->offsets[0]) {
			texname = tx->name;
			width   = tx->width  >> mipTexLevel;
			height  = tx->height >> mipTexLevel;
			data    = (byte *) tx + tx->offsets[mipTexLevel];
		}
		else {
			texname = r_notexture_mip->name;
			width   = r_notexture_mip->width  >> mipTexLevel;
			height  = r_notexture_mip->height >> mipTexLevel;
			data     = (byte *) r_notexture_mip + r_notexture_mip->offsets[mipTexLevel];
		}

		tx->gl_texturenum = R_LoadTexture(texname, width, height, data, texmode | brighten_flag | alpha_flag, 1);
		if (!Mod_IsTurbTextureName(m, tx->name) && Img_HasFullbrights(data, width * height)) {
			tx->fb_texturenum = R_LoadTexture(va("@fb_%s", texname), width, height, data, texmode | TEX_FULLBRIGHT | alpha_flag, 1);
		}
		tx->loaded = true; // mark as loaded
	}
}


================================================
FILE: src/r_brushmodel_sky.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// gl_sky.c -- sky polygons (was previously in gl_warp.c)

#include "quakedef.h"
#include "gl_model.h"
#include "teamplay.h"
#include "r_brushmodel_sky.h"
#include "r_texture.h"
#include "r_local.h"
#include "r_trace.h"
#include "r_renderer.h"
#include "tr_types.h"

static qbool Sky_LoadSkyboxTextures(const char* skyname);

texture_ref solidskytexture, alphaskytexture;
texture_ref skyboxtextures[MAX_SKYBOXTEXTURES];
texture_ref skybox_cubeMap;

qbool r_skyboxloaded;

extern cvar_t r_skywind;

static float skywind_dist;
static float skywind_yaw;
static float skywind_pitch;
static float skywind_period;

static char active_skyname[MAX_QPATH];

#define SKYWIND_CFG			"_wind.cfg"

static void Skywind_Load_f(void);
static void Skywind_Clear(void);

//A sky texture is 256 * 128, with the right side being a masked overlay
void R_InitSky (texture_t *mt) {
	int i, j, p, r, g, b;
	byte *src;
	unsigned trans[128 * 128], transpix, *rgba;
	int flags = TEX_MIPMAP | (gl_scaleskytextures.integer ? 0 : TEX_NOSCALE);

	src = (byte *) mt + mt->offsets[0];

	// make an average value for the back to avoid a fringe on the top level
	r = g = b = 0;
	for (i = 0; i < 128; i++) {
		for (j = 0; j < 128; j++) {
			p = src[i * 256 + j + 128];
			rgba = &d_8to24table[p];
			trans[(i * 128) + j] = *rgba;
			r += ((byte *) rgba)[0];
			g += ((byte *) rgba)[1];
			b += ((byte *) rgba)[2];
		}
	}

	((byte *) &transpix)[0] = r / (128 * 128);
	((byte *) &transpix)[1] = g / (128 * 128);
	((byte *) &transpix)[2] = b / (128 * 128);
	((byte *) &transpix)[3] = 0;

	solidskytexture = R_LoadTexture ("***solidskytexture***", 128, 128, (byte *)trans, flags, 4);

	for (i = 0; i < 128; i++) {
		for (j = 0; j < 128; j++) {
			p = src[i * 256 + j];
			trans[(i * 128) + j] = p ? d_8to24table[p] : transpix;
		}
	}

	alphaskytexture = R_LoadTexture ("***alphaskytexture***", 128, 128, (byte *)trans, TEX_ALPHA | flags, 4);
}

int R_SetSky(char *skyname)
{
	char *groupname;

	memset(active_skyname, 0, sizeof(active_skyname));
	r_skyboxloaded = false;
	Skywind_Clear();

	// set skyname to groupname if any
	skyname	= (groupname = TP_GetSkyGroupName(TP_MapName(), NULL)) ? groupname : skyname;

	if (!skyname || !skyname[0] || strchr(skyname, '.'))
	{
		// Empty name or contain dot(dot causing troubles with skipping part of the name as file extenson),
		// so do nothing.
		return 1;
	}

	if (!Sky_LoadSkyboxTextures(skyname)) {
		return 1;
	}

	// everything was OK
	r_skyboxloaded = true;

	strlcpy(active_skyname, skyname, sizeof(active_skyname));

	if (r_skywind.integer) {
		Skywind_Load_f();
	}

	return 0;
}

void OnChange_r_skyname (cvar_t *v, char *skyname, qbool* cancel)
{
	if (!skyname[0]) {
		memset(active_skyname, 0, sizeof(active_skyname));
		r_skyboxloaded = false;
		return;
	}

	*cancel = R_SetSky(skyname);
}

static void R_LoadSky_f(void)
{
	switch (Cmd_Argc()) {
	case 1:
		if (r_skyboxloaded) {
			Com_Printf("Current skybox is \"%s\"\n", r_skyname.string);
		}
		else {
			Com_Printf("No skybox has been set\n");
		}
		break;
	case 2:
		if (!strcasecmp(Cmd_Argv(1), "none")) {
			Cvar_Set(&r_skyname, "");
		}
		else {
			Cvar_Set(&r_skyname, Cmd_Argv(1));
		}
		break;
	default:
		Com_Printf("Usage: %s <skybox>\n", Cmd_Argv(0));
		break;
	}
}

/*
==============
R_DrawSky

Draw either the classic cloudy quake sky or a skybox
==============
*/
void R_DrawSky (void)
{
	if (!skychain) {
		return;
	}

	R_TraceEnterNamedRegion("R_DrawSky");
	renderer.DrawSky();
	R_TraceLeaveNamedRegion();

	skychain = NULL;
	skychain_tail = &skychain;
}

static qbool R_LoadSkyTexturePixels(r_cubemap_direction_id dir, const char* skyname, byte** data, int* width, int* height)
{
	static const char *skybox_ext[r_cubemap_direction_count] = { "rt", "bk", "lf", "ft", "up", "dn" };
	static const char* search_paths[][2] = { { "env/", "" }, { "gfx/env/", "" }, { "env/", "_" }, { "gfx/env/", "_" } };
	int j, flags = TEX_NOCOMPRESS | TEX_MIPMAP | (gl_scaleskytextures.integer ? 0 : TEX_NOSCALE);

	if (dir < 0 || dir >= r_cubemap_direction_count) {
		return false;
	}

	for (j = 0; j < sizeof(search_paths) / sizeof(search_paths[0]); ++j) {
		char path[MAX_PATH];

		strlcpy(path, search_paths[j][0], sizeof(path));
		strlcat(path, skyname, sizeof(path));
		strlcat(path, search_paths[j][1], sizeof(path));
		strlcat(path, skybox_ext[dir], sizeof(path));

		*data = R_LoadImagePixels(path, 0, 0, flags, width, height);
		if (*data) {
			return *data != NULL;
		}
	}

	return false;
}

static qbool Sky_LoadSkyboxTextures(const char* skyname)
{
	static int skydirection[] = { 4, 1, 5, 0, 2, 3 };

	r_cubemap_direction_id i;
	byte* data;
	int fixed_size = 0;
	int width, height;

	R_DeleteTexture(&skybox_cubeMap);
	for (i = 0; i < MAX_SKYBOXTEXTURES; i++) {
		R_DeleteTexture(&skyboxtextures[i]);
	}

	for (i = 0; i < MAX_SKYBOXTEXTURES; i++) {
		if (R_LoadSkyTexturePixels(i, skyname, &data, &width, &height)) {
			if (R_UseCubeMapForSkyBox()) {
				int size = (i != 0 ? fixed_size : min(width, height));

				R_TextureRescaleOverlay(&data, &width, &height, size, size);

				fixed_size = size;

				if (i == 0) {
					skybox_cubeMap = R_CreateCubeMap("***skybox***", size, size, TEX_NOCOMPRESS | TEX_MIPMAP | TEX_NOSCALE | TEX_ALPHA);
					if (!R_TextureReferenceIsValid(skybox_cubeMap)) {
						Q_free(data);
						Com_Printf("Couldn't load skybox \"%s\"\n", skyname);
						return false;
					}
				}

				renderer.TextureLoadCubemapFace(skybox_cubeMap, skydirection[i], data, size, size);
			}
			else {
				char id[16];

				snprintf(id, sizeof(id) - 1, "***skybox%d***", i);

				skyboxtextures[i] = R_LoadTexture(id, width, height, data, TEX_NOCOMPRESS | TEX_MIPMAP | TEX_NOSCALE, 4);
			}

			// we should free data from R_LoadImagePixels()
			Q_free(data);
		}
		else {
			int j;

			Com_Printf("Couldn't load skybox \"%s\"\n", skyname);
			if (R_UseCubeMapForSkyBox()) {
				R_DeleteCubeMap(&skybox_cubeMap);
			}
			else {
				for (j = 0; j < i; ++j) {
					R_DeleteTexture(&skyboxtextures[j]);
				}
			}

			return false;
		}
	}

	if (R_TextureReferenceIsValid(skybox_cubeMap)) {
		renderer.TextureMipmapGenerate(skybox_cubeMap);
	}

	return true;
}

void R_ClearSkyTextures(void)
{
	R_TextureReferenceInvalidate(solidskytexture);
	R_TextureReferenceInvalidate(alphaskytexture);
}

static void Skywind_Clear(void)
{
	if (!r_skyboxloaded)
		return;
	skywind_dist = 0.f;
	skywind_yaw = 45.f;
	skywind_pitch = 0.f;
	skywind_period = 30.f;
}

static void Skywind_Load_f(void)
{
	char relname[MAX_QPATH];
	char *buf;
	const char *data;

	if (!r_skyboxloaded)
	{
		Con_Printf ("No skybox loaded\n");
		return;
	}

	snprintf(relname, sizeof(relname), "gfx/env/%s" SKYWIND_CFG, active_skyname);
	buf = (char *)FS_LoadTempFile(relname, NULL);
	if (!buf)
	{
		Con_DPrintf ("Sky wind config not found '%s'.\n", relname);
		return;
	}

	data = COM_Parse(buf);
	if (!data)
	{
		return;
	}

	if (strcmp(com_token, "skywind") != 0)
	{
		Con_Printf("Skywind_Load_f: first token must be 'skywind'.\n");
		return;
	}

	Skywind_Clear();

	if ((data = COM_Parse(data)) != NULL)
	{
		skywind_dist = bound(-2.0f, atof(com_token), 2.0f);
	}

	if ((data = COM_Parse(data)) != NULL)
	{
		skywind_yaw = fmodf(atof(com_token), 360.0f);
	}

	if ((data = COM_Parse(data)) != NULL)
	{
		skywind_period = atof(com_token);
	}

	if ((data = COM_Parse(data)) != NULL)
	{
		skywind_pitch = fmodf(atof(com_token) + 90.0f, 180.0f) - 90.0f;
	}
}

static void Skywind_Save_f (void)
{
	char relname[MAX_QPATH];
	char path[MAX_OSPATH];
	FILE *f;

	if (!r_skyboxloaded)
	{
		Con_Printf("No skybox loaded\n");
		return;
	}

	snprintf(relname, sizeof(relname), "gfx/env/%s" SKYWIND_CFG, active_skyname);
	snprintf(path, sizeof(path), "%s/%s", com_gamedir, relname);
	f = fopen(path, "wt");
	if (!f)
	{
		Con_Printf("Couldn't write '%s'.\n", relname);
		return;
	}

	fprintf(f,
			"// distance yaw period pitch\n"
			"skywind %g %g %g %g\n",
			skywind_dist,
			skywind_yaw,
			skywind_period,
			skywind_pitch
	);

	fclose(f);

	Con_Printf("Wrote %s\n", relname);
}

static void Skywind_LookDir_f (void)
{
	if (cls.state != ca_active)
	{
		return;
	}

	if (!r_skyboxloaded)
	{
		Con_Printf("No skybox loaded\n");
		return;
	}

	// invert view direction so that clouds move towards the player, not away from them
	skywind_yaw = fmodf(cl.viewangles[YAW] + 180.0f, 360.0f);
	skywind_pitch = -cl.viewangles[PITCH];

	// first argument, if present, overrides the loop duration (default: 30 seconds)
	if (Cmd_Argc() >= 2)
	{
		skywind_period = atof(Cmd_Argv(1));
	}
	else if (!skywind_period)
	{
		skywind_period = 30.f;
	}

	// second argument, if present, overrides the amplitude of the movement (default: 1.0)
	if (Cmd_Argc() >= 3)
	{
		skywind_dist = bound(-2.0f, atof(Cmd_Argv(2)), 2.0f);
	}
	else if (!skywind_dist)
	{
		skywind_dist = 1.0f;
	}
}

static void Skywind_Rotate_f(void)
{
	if (cls.state != ca_active)
	{
		return;
	}

	if (!r_skyboxloaded)
	{
		Con_Printf("No skybox loaded\n");
		return;
	}

	if (Cmd_Argc() < 2)
	{
		Con_Printf(
				"usage:\n"
				"   %s <yawdelta> [pitchdelta]\n",
				Cmd_Argv (0)
		);
		return;
	}

	skywind_yaw = fmodf(skywind_yaw + atof(Cmd_Argv(1)), 360.0f);
	if (Cmd_Argc() >= 3)
	{
		skywind_pitch = fmodf(skywind_pitch + atof(Cmd_Argv(2)) + 90.0f, 180.0f) - 90.0f;
	}
}

static void Skywind_f (void)
{
	if (cls.state != ca_active)
	{
		return;
	}

	if (!r_skyboxloaded)
	{
		Con_Printf("No skybox loaded\n");
		return;
	}

	if (Cmd_Argc() < 2)
	{
		Con_Printf (
				"usage:\n"
				"   %s [distance] [yaw] [period] [pitch]\n"
				"current values:\n"
				"   \"distance\" is \"%g\"\n"
				"   \"yaw\"      is \"%g\"\n"
				"   \"period\"   is \"%g\"\n"
				"   \"pitch\"    is \"%g\"\n",
				Cmd_Argv(0),
				skywind_dist,
				skywind_yaw,
				skywind_period,
				skywind_pitch
		);
		return;
	}

	skywind_dist = bound(-2.0f, atof(Cmd_Argv (1)), 2.0f);
	if (Cmd_Argc () >= 3)
	{
		skywind_yaw = fmodf(atof(Cmd_Argv(2)), 360.0f);
	}
	if (Cmd_Argc () >= 4)
	{
		skywind_period = atof(Cmd_Argv(3));
	}
	if (Cmd_Argc () >= 5)
	{
		skywind_pitch = fmodf(atof(Cmd_Argv(4)) + 90.0f, 180.0f) - 90.0f;
	}
}

qbool Skywind_Active(void)
{
	return r_skyboxloaded && skywind_dist > 0.0f;
}

qbool Skywind_GetDirectionAndPhase(float wind_dir[3], float *wind_phase)
{
	float yaw, pitch, sy, sp, cy, cp, dist, period;
	double phase;

	if (!Skywind_Active())
	{
		return false;
	}

	yaw = DEG2RAD(skywind_yaw);
	pitch = DEG2RAD(skywind_pitch);
	sy = sinf(yaw);
	sp = sinf(pitch);
	cy = cosf(yaw);
	cp = cosf(pitch);
	dist = bound(-2.f, skywind_dist, 2.f);
	period = skywind_period / r_skywind.value;
	phase = period ? cl.time * 0.5 / period : 0.5;

	phase -= floor(phase) + 0.5; // [-0.5, 0.5)
	wind_dir[0] = dist * cp * sy;
	wind_dir[1] = dist * sp;
	wind_dir[2] = -dist * cp * cy;
	*wind_phase = (float) phase;

	return true;
}

void R_SkyRegisterCvars(void)
{
	Cmd_AddCommand("loadsky", R_LoadSky_f);
	Cmd_AddCommand("skywind",Skywind_f);
	Cmd_AddCommand("skywind_save",Skywind_Save_f);
	Cmd_AddCommand("skywind_load",Skywind_Load_f);
	Cmd_AddCommand("skywind_lookdir",Skywind_LookDir_f);
	Cmd_AddCommand("skywind_rotate",Skywind_Rotate_f);
}

================================================
FILE: src/r_brushmodel_sky.h
================================================

#ifndef EZQUAKE_R_BRUSHMODEL_SKY_HEADER
#define EZQUAKE_R_BRUSHMODEL_SKY_HEADER

void GLC_SkyDrawChainedSurfaces(void);

extern msurface_t *skychain;
extern msurface_t **skychain_tail;
extern texture_ref solidskytexture, alphaskytexture;
extern cvar_t r_skyname;

#define MAX_SKYBOXTEXTURES 6
extern texture_ref skyboxtextures[MAX_SKYBOXTEXTURES];

void R_ClearSkyTextures(void);
void R_SkyRegisterCvars(void);
extern qbool r_skyboxloaded;

qbool Skywind_Active(void);
qbool Skywind_GetDirectionAndPhase(float wind_dir[3], float *wind_phase);

#endif // EZQUAKE_R_BRUSHMODEL_SKY_HEADER


================================================
FILE: src/r_brushmodel_surfaces.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// r_surf.c: surface-related refresh code

#include "quakedef.h"
#include "gl_model.h"
#include "rulesets.h"
#include "utils.h"
#include "r_performance.h"
#include "r_local.h"
#include "r_texture.h"
#include "r_lighting.h"
#include "r_brushmodel.h"
#include "r_brushmodel_sky.h"
#include "r_lightmaps.h"
#include "r_trace.h"
#include "r_renderer.h"

// Move to API
void GLC_ClearTextureChains(void);

// gl_refrag.c
void R_StoreEfrags(efrag_t **ppefrag);

static void R_TurbSurfacesEmitParticleEffects(msurface_t* s);

msurface_t	*skychain = NULL;
msurface_t	**skychain_tail = &skychain;

msurface_t	*waterchain = NULL;

msurface_t	*alphachain = NULL;
msurface_t	**alphachain_tail = &alphachain;

typedef void(*chain_surf_func)(msurface_t** chain_head, msurface_t* surf);

void chain_surfaces_simple(msurface_t** chain_head, msurface_t* surf)
{
	surf->texturechain = *chain_head;
	*chain_head = surf;
}

void chain_surfaces_simple_drawflat(msurface_t** chain_head, msurface_t* surf)
{
	surf->drawflatchain = *chain_head;
	*chain_head = surf;
}

void chain_surfaces_by_lightmap(msurface_t** chain_head, msurface_t* surf)
{
	msurface_t* current = *chain_head;
	qbool alphaSurface = surf->flags & SURF_DRAWALPHA;

	while (current) {
		if ((alphaSurface && !(current->flags & SURF_DRAWALPHA)) || (!alphaSurface && surf->lightmaptexturenum > current->lightmaptexturenum)) {
			chain_head = &(current->texturechain);
			current = *chain_head;
			continue;
		}

		break;
	}

	surf->texturechain = current;
	*chain_head = surf;
}

#define CHAIN_SURF_F2B(surf, chain_tail)		\
	{											\
		*(chain_tail) = (surf);					\
		(chain_tail) = &(surf)->texturechain;	\
		(surf)->texturechain = NULL;			\
	}

#define CHAIN_SURF_B2F(surf, chain) 			\
	{											\
		(surf)->texturechain = (chain);			\
		(chain) = (surf);						\
	}

#define CHAIN_RESET(chain)			\
{								\
	chain = NULL;				\
	chain##_tail = &chain;		\
}

//Returns the proper texture for a given time and base texture
texture_t *R_TextureAnimation(entity_t* ent, texture_t *base)
{
	int relative, count;

	if (ent && ent->frame && base->alternate_anims) {
		base = base->alternate_anims;
	}

	if (!base->anim_total) {
		return base;
	}

	relative = (int) (r_refdef2.time * 10) % base->anim_total;

	count = 0;
	while (base->anim_min > relative || base->anim_max <= relative) {
		base = base->anim_next;
		if (!base) {
			Host_Error("R_TextureAnimation: broken cycle");
		}
		if (++count > 100) {
			Host_Error("R_TextureAnimation: infinite cycle");
		}
	}

	return base;
}

void R_BrushModelClearTextureChains(model_t *clmodel)
{
	int i;
	texture_t *texture;

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_ClearTextureChains();
	}
#endif

	clmodel->texturechains_have_lumas = false;
	for (i = 0; i < clmodel->numtextures; i++) {
		if ((texture = clmodel->textures[i])) {
			texture->texturechain = NULL;
			texture->texturechain_tail = &texture->texturechain;
		}
	}
	clmodel->drawflat_chain = NULL;
	clmodel->drawflat_todo = false;
	clmodel->alphapass_todo = false;
	clmodel->first_texture_chained = clmodel->numtextures;
	clmodel->last_texture_chained = -1;

	r_notexture_mip->texturechain = NULL;
	r_notexture_mip->texturechain_tail = &r_notexture_mip->texturechain;

	CHAIN_RESET(skychain);
	if (clmodel == cl.worldmodel) {
		waterchain = NULL;
	}
	CHAIN_RESET(alphachain);
}

void OnChange_r_drawflat (cvar_t *var, char *value, qbool *cancel) {
	char *p;
	qbool progress = false;


	p = Info_ValueForKey (cl.serverinfo, "status");
	progress = (strstr (p, "left")) ? true : false;

	if (cls.state >= ca_connected && progress && !r_refdef2.allow_cheats && !cl.spectator) {
		Com_Printf ("%s changes are not allowed during the match.\n", var->name);
		*cancel = true;
		return;
	}
}

void R_RecursiveWorldNode(mnode_t *node, int clipflags)
{
	extern cvar_t r_fastturb, r_fastsky;
	model_t* clmodel = cl.worldmodel;

	int c, side, clipped;
	mplane_t *plane, *clipplane;
	msurface_t *surf, **mark;
	mleaf_t *pleaf;
	float dot;

	if (node->contents == CONTENTS_SOLID || node->visframe != r_visframecount) {
		return;
	}
	for (c = 0, clipplane = frustum; c < 4; c++, clipplane++) {
		if (!(clipflags & (1 << c))) {
			continue;	// don't need to clip against it
		}

		clipped = BOX_ON_PLANE_SIDE(node->minmaxs, node->minmaxs + 3, clipplane);
		if (clipped == 2) {
			return;
		}
		else if (clipped == 1) {
			clipflags &= ~(1 << c);	// node is entirely on screen
		}
	}

	// if a leaf node, draw stuff
	if (node->contents < 0) {
		pleaf = (mleaf_t *)node;

		mark = pleaf->firstmarksurface;
		c = pleaf->nummarksurfaces;

		if (c) {
			do {
				(*mark)->visframe = r_framecount;
				mark++;
			} while (--c);
		}

		// deal with model fragments in this leaf
		if (pleaf->efrags) {
			R_StoreEfrags(&pleaf->efrags);
		}

		return;
	}

	// node is just a decision point, so go down the apropriate sides

	// find which side of the node we are on
	plane = node->plane;

	dot = PlaneDiff(modelorg, plane);
	side = (dot >= 0) ? 0 : 1;

	// recurse down the children, front side first
	R_RecursiveWorldNode(node->children[side], clipflags);

	// draw stuff
	c = node->numsurfaces;

	if (c) {
		qbool turbSurface;
		qbool alphaSurface;

		surf = cl.worldmodel->surfaces + node->firstsurface;

		if (dot < -BACKFACE_EPSILON) {
			side = SURF_PLANEBACK;
		}
		else if (dot > BACKFACE_EPSILON) {
			side = 0;
		}

		for (; c; c--, surf++) {
			if (surf->visframe != r_framecount) {
				continue;
			}

			if ((dot < 0) ^ !!(surf->flags & SURF_PLANEBACK)) {
				continue;		// wrong side
			}

			// add surf to the right chain
			cl.worldmodel->first_texture_chained = min(cl.worldmodel->first_texture_chained, surf->texinfo->miptex);
			cl.worldmodel->last_texture_chained = max(cl.worldmodel->last_texture_chained, surf->texinfo->miptex);

			turbSurface = (surf->flags & SURF_DRAWTURB);
			alphaSurface = (surf->flags & SURF_DRAWALPHA);
			if (surf->flags & SURF_DRAWSKY) {
				if (r_fastsky.integer || R_UseModernOpenGL()) {
					chain_surfaces_simple_drawflat(&cl.worldmodel->drawflat_chain, surf);
					cl.worldmodel->drawflat_todo = true;
				}
				else if (!r_fastsky.integer) {
					chain_surfaces_simple(&skychain, surf);
				}
			}
			else if (turbSurface) {
				if (r_fastturb.integer && r_refdef2.wateralpha == 1) {
					chain_surfaces_simple_drawflat(&cl.worldmodel->drawflat_chain, surf);
					cl.worldmodel->drawflat_todo = true;
				}
				else if (r_refdef2.solidTexTurb && R_UseModernOpenGL()) {
					chain_surfaces_simple(&surf->texinfo->texture->texturechain, surf);
				}
				else {
					chain_surfaces_simple(&waterchain, surf);
				}
				R_TurbSurfacesEmitParticleEffects(surf);
			}
			else {
				if (!alphaSurface && r_refdef2.drawFlatFloors && (surf->flags & SURF_DRAWFLAT_FLOOR)) {
					if (R_UseImmediateOpenGL()) {
						R_AddDrawflatChainSurface(surf, true);
					}
					else {
						chain_surfaces_simple_drawflat(&cl.worldmodel->drawflat_chain, surf);
					}
					cl.worldmodel->drawflat_todo = true;
				}
				else if (!alphaSurface && r_refdef2.drawFlatWalls && !(surf->flags & SURF_DRAWFLAT_FLOOR)) {
					if (R_UseImmediateOpenGL()) {
						R_AddDrawflatChainSurface(surf, false);
					}
					else {
						chain_surfaces_simple_drawflat(&cl.worldmodel->drawflat_chain, surf);
					}
					cl.worldmodel->drawflat_todo = true;
				}
				else {
					clmodel->texturechains_have_lumas |= R_TextureAnimation(NULL, surf->texinfo->texture)->isLumaTexture;
					clmodel->alphapass_todo |= alphaSurface;

					if (R_UseImmediateOpenGL()) {
						if (alphaSurface) {
							CHAIN_SURF_B2F(surf, surf->texinfo->texture->texturechain);
						}
						else {
							chain_surfaces_by_lightmap(&surf->texinfo->texture->texturechain, surf);
						}
					}
					else {
						chain_surfaces_simple(&surf->texinfo->texture->texturechain, surf);
					}
				}
			}
		}
	}
	// recurse down the back side
	R_RecursiveWorldNode(node->children[!side], clipflags);
}

void R_CreateWorldTextureChains(void)
{
	extern cvar_t r_drawworld;

	if (cl.worldmodel && (!cls.timedemo || r_drawworld.integer)) {
		R_BrushModelClearTextureChains(cl.worldmodel);

		VectorCopy(r_refdef.vieworg, modelorg);

		//set up texture chains for the world
		R_RecursiveWorldNode(cl.worldmodel->nodes, 15);

		// these are rendered later now, so we can process earlier
		R_RenderDlights();

		R_RenderAllDynamicLightmaps(cl.worldmodel);
	}
}

void R_DrawWorld(void)
{
	R_TraceEnterNamedRegion("R_DrawWorld");
	VectorCopy(r_refdef.vieworg, modelorg);

	//draw the world sky
	R_DrawSky();

	renderer.DrawWorld();

	if (r_refdef2.wateralpha == 1) {
		renderer.DrawWaterSurfaces();
	}
	R_TraceLeaveNamedRegion();
}

void R_MarkLeaves(void)
{
	byte *vis;
	mnode_t *node;
	int i;
	byte solid[MAX_MAP_LEAFS / 8];
	extern cvar_t r_novis;

	if (!r_novis.value && r_oldviewleaf == r_viewleaf && r_oldviewleaf2 == r_viewleaf2) {
		// watervis hack
		return;
	}

	r_visframecount++;
	r_oldviewleaf = r_viewleaf;

	if (r_novis.value) {
		vis = solid;
		memset(solid, 0xff, (cl.worldmodel->numleafs + 7) >> 3);
	}
	else {
		vis = Mod_LeafPVS(r_viewleaf, cl.worldmodel);

		if (r_viewleaf2) {
			int			i, count;
			unsigned	*src, *dest;

			// merge visibility data for two leafs
			count = (cl.worldmodel->numleafs + 7) >> 3;
			memcpy(solid, vis, count);
			src = (unsigned *)Mod_LeafPVS(r_viewleaf2, cl.worldmodel);
			dest = (unsigned *)solid;
			count = (count + 3) >> 2;
			for (i = 0; i < count; i++)
				*dest++ |= *src++;
			vis = solid;
		}
	}

	for (i = 0; i < cl.worldmodel->numleafs; i++) {
		if (vis[i >> 3] & (1 << (i & 7))) {
			node = (mnode_t *)&cl.worldmodel->leafs[i + 1];
			do {
				if (node->visframe == r_visframecount)
					break;
				node->visframe = r_visframecount;
				node = node->parent;
			} while (node);
		}
	}
}

static void R_TurbSurfacesEmitParticleEffects(msurface_t* s)
{
#define ESHADER(eshadername)  extern void eshadername (vec3_t org)
	extern void EmitParticleEffect(msurface_t *fa, void (*fun)(vec3_t nv));
	extern cvar_t tei_lavafire, tei_slime;

	ESHADER(FuelRodExplosion);//green mushroom explosion
	ESHADER(ParticleFire);//torch fire
	ESHADER(ParticleFirePool);//lavapool alike fire
	ESHADER(VX_DeathEffect);//big white spark explosion
	ESHADER(VX_GibEffect);//huge red blood cloud
	ESHADER(VX_DetpackExplosion);//cool huge explosion
	ESHADER(VX_Implosion);//TODO
	ESHADER(VX_TeslaCharge);
	ESHADER(ParticleSlime);
	ESHADER(ParticleSlimeHarcore);
	ESHADER(ParticleBloodPool);
	ESHADER(ParticleSlimeBubbles); //HyperNewbie particles init
	ESHADER(ParticleSlimeGlow);
	ESHADER(ParticleSmallerFirePool);
	ESHADER(ParticleLavaSmokePool);

	if (!tei_lavafire.integer && !tei_slime.integer) {
		return;
	}

	//Tei "eshaders".
	if (s->texinfo && s->texinfo->texture && s->texinfo->texture->name[0]) {
		switch (s->texinfo->texture->name[1]) {
			//Lava
		case 'l':
		case 'L':
		{
			switch (tei_lavafire.integer) {
			case 1:
				//Tei lavafire, normal
				EmitParticleEffect(s, ParticleFire);
				break;
			case 2:
				//Tei lavafire HARDCORE
				EmitParticleEffect(s, ParticleFirePool);
				//Tei redblood smoke
				EmitParticleEffect(s, ParticleBloodPool);
				break;
			case 3:
				//HyperNewbie's smokefire
				EmitParticleEffect(s, ParticleSmallerFirePool);
				EmitParticleEffect(s, ParticleLavaSmokePool);
				break;
			case 4:
				EmitParticleEffect(s, ParticleSmallerFirePool);
				EmitParticleEffect(s, ParticleLavaSmokePool);
				EmitParticleEffect(s, ParticleLavaSmokePool);
				EmitParticleEffect(s, ParticleLavaSmokePool);
				break;
			}
			break;
		}
		case 't':
			//Teleport
			//TODO: a cool implosion subtel fx
			//		EmitParticleEffect(s,VX_Implosion);
			break;
		case 's':
		{
			switch (tei_slime.integer) {
			case 1:
				EmitParticleEffect(s, ParticleSlime);
				break;
			case 2:
				EmitParticleEffect(s, ParticleSlimeHarcore);
				break;
			case 3:
				if (!(rand() % 40)) {
					EmitParticleEffect(s, ParticleSlimeGlow);
				}
				if (!(rand() % 40)) {
					EmitParticleEffect(s, ParticleSlimeBubbles);
				}
				break;
			case 4:
				if (!(rand() % 10)) {
					EmitParticleEffect(s, ParticleSlimeGlow);
				}
				if (!(rand() % 10)) {
					EmitParticleEffect(s, ParticleSlimeBubbles);
				}
				break;
			}
			break;
		}
		case 'w':
			//	EmitParticleEffect(s,VX_TeslaCharge);
			break;
		default:
			break;
		}
	}
}

qbool R_DrawWorldOutlines(void)
{
	extern cvar_t gl_outline;

	return (gl_outline.integer & 2) && !RuleSets_DisallowModelOutline(NULL);
}


================================================
FILE: src/r_brushmodel_textures.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// gl_brushmodel_textures.c  -- external texture loading for brush models

#include "quakedef.h"
#include "gl_model.h"
#include "teamplay.h"
#include "r_texture.h"
#include "r_brushmodel.h"
#include "image.h"
#include "r_renderer.h"

/* Some id maps have textures with identical names but different looks.
We hardcode a list of names, checksums and alternative names to provide a way
for external texture packs to differentiate them. */
static struct {
	int md4;
	char *origname, *newname;
} translate_names[] = {
	//	{ 0x8a010dc0, "sky4", "sky4" },
	{ 0xde688b77, "sky4", "sky1" },
	{ 0x45d110ec, "metal5_2", "metal5_2_arc" },
	{ 0x0d275f87, "metal5_2", "metal5_2_x" },
	{ 0xf8e27da8, "metal5_4", "metal5_4_arc" },
	{ 0xa301c52e, "metal5_4", "metal5_4_double" },
	{ 0xfaa8bf77, "metal5_8", "metal5_8_back" },
	{ 0x88792923, "metal5_8", "metal5_8_rune" },
	{ 0xfe4f9f5a, "plat_top1", "plat_top1_bolt" },
	{ 0x9ac3fccf, "plat_top1", "plat_top1_cable" },
	{ 0, NULL, NULL },
};

char *TranslateTextureName(texture_t *tx)
{
	int i;
	int checksum = 0;
	qbool checksum_done = false;

	for (i = 0; translate_names[i].origname; i++) {
		if (strcmp(tx->name, translate_names[i].origname)) {
			continue;
		}
		if (!checksum_done) {
			checksum = Com_BlockChecksum(tx+1, tx->width*tx->height);
			checksum_done = true;
			//Com_DPrintf ("checksum(\"%s\") = 0x%x\n", tx->name, checksum);
		}
		if (translate_names[i].md4 == checksum) {
			//Com_DPrintf ("Translating %s --> %s\n", tx->name, translate_names[i].newname);
			assert (strlen(translate_names[i].newname) < sizeof(tx->name));
			return translate_names[i].newname;
		}
	}

	return NULL;
}

qbool Mod_LoadExternalTexture(model_t* loadmodel, texture_t *tx, int mode, int brighten_flag)
{
	char *name, *altname, *mapname, *groupname;
	int luma_mode = TEX_LUMA;
	int material_width = 0;
	int material_height = 0;
	int luma_width = 0;
	int luma_height = 0;
	byte* material_pixels = NULL;
	byte* luma_pixels = NULL;
	char texture_path[MAX_OSPATH];

	if (!R_ExternalTexturesEnabled(loadmodel->isworldmodel)) {
		return false;
	}

	name = tx->name;
	altname = TranslateTextureName(tx);
	mapname = TP_MapName();
	groupname = TP_GetMapGroupName(mapname, NULL);
	texture_path[0] = '\0';

	if (loadmodel->isworldmodel) {
		strlcpy(texture_path, "textures/", sizeof(texture_path));
		strlcat(texture_path, mapname, sizeof(texture_path));
		strlcat(texture_path, "/", sizeof(texture_path));
		strlcat(texture_path, name, sizeof(texture_path));

		material_pixels = R_LoadImagePixels(texture_path, 0, 0, mode | brighten_flag, &material_width, &material_height);
		if (!material_pixels && groupname) {
			strlcpy(texture_path, "textures/", sizeof(texture_path));
			strlcat(texture_path, groupname, sizeof(texture_path));
			strlcat(texture_path, "/", sizeof(texture_path));
			strlcat(texture_path, name, sizeof(texture_path));

			material_pixels = R_LoadImagePixels(texture_path, 0, 0, mode | brighten_flag, &material_width, &material_height);
		}
	}
	else {
		strlcpy(texture_path, "textures/bmodels/", sizeof(texture_path));
		strlcat(texture_path, name, sizeof(texture_path));

		material_pixels = R_LoadImagePixels(texture_path, 0, 0, mode | brighten_flag, &material_width, &material_height);
	}

	if (!material_pixels && altname) {
		strlcpy(texture_path, "textures/", sizeof(texture_path));
		strlcat(texture_path, altname, sizeof(texture_path));

		material_pixels = R_LoadImagePixels(texture_path, 0, 0, mode | brighten_flag, &material_width, &material_height);
	}

	if (!material_pixels) {
		strlcpy(texture_path, "textures/", sizeof(texture_path));
		strlcat(texture_path, name, sizeof(texture_path));

		material_pixels = R_LoadImagePixels(texture_path, 0, 0, mode | brighten_flag, &material_width, &material_height);
	}

	// Try and load the corresponding luma
	if (material_pixels && !Mod_IsTurbTextureName(loadmodel, name)) {
		strlcat(texture_path, "_luma", sizeof(texture_path));

		luma_pixels = R_LoadImagePixels(texture_path, 0, 0, mode | luma_mode, &luma_width, &luma_height);
	}

	// resize luma if dimensions don't match material
	if (R_LumaTexturesMustMatchDimensions() && material_pixels && luma_pixels) {
		// make sure sizes match (so they fit in array): the shader still has to read from both alpha-material & luma
		R_TextureRescaleOverlay(&luma_pixels, &luma_width, &luma_height, material_width, material_height);
	}

	// Load into renderer
	if (material_pixels) {
		tx->gl_texturenum = R_LoadTexturePixels(material_pixels, name, material_width, material_height, mode);
		if (luma_pixels) {
			tx->fb_texturenum = R_LoadTexturePixels(luma_pixels, va("@fb_%s", name), luma_width, luma_height, mode | luma_mode);
			Q_free(luma_pixels);
		}

		Q_free(material_pixels);
	}

	tx->isLumaTexture = R_TextureReferenceIsValid(tx->fb_texturenum);

	return R_TextureReferenceIsValid(tx->gl_texturenum);
}

qbool Mod_IsTurbTextureName(model_t* model, const char* name)
{
	if (model->bspversion != HL_BSPVERSION && name[0] == '*') {
		return true;
	}

	return (model->bspversion == HL_BSPVERSION && name[0] == '!');
}

qbool Mod_IsSkyTextureName(model_t* model, const char* name)
{
	return (tolower(name[0]) == 's' && tolower(name[1]) == 'k' && tolower(name[2]) == 'y');
}

qbool Mod_IsAlphaTextureName(model_t* model, const char* name)
{
	return (name[0] == '{');
}


================================================
FILE: src/r_brushmodel_warpsurfaces.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// gl_warp.c -- water polygons

#include "quakedef.h"
#include "vx_stuff.h"
#include "gl_model.h"
#include "glsl/constants.glsl"
#include "r_local.h"
#include "r_brushmodel.h"
#include "utils.h"

extern model_t *loadmodel;
static msurface_t *warpface;

static void R_WarpSurfaceBoundPoly(int numverts, float *verts, vec3_t mins, vec3_t maxs)
{
	int i, j;
	float *v;

	mins[0] = mins[1] = mins[2] = BRUSHMODEL_MAX_SURFACE_EXTENTS;
	maxs[0] = maxs[1] = maxs[2] = BRUSHMODEL_MIN_SURFACE_EXTENTS;
	v = verts;
	for (i = 0; i < numverts; i++) {
		for (j = 0; j < 3; j++, v++) {
			if (i == 0 || *v < mins[j]) {
				mins[j] = *v;
			}
			if (i == 0 || *v > maxs[j]) {
				maxs[j] = *v;
			}
		}
	}
}

static void R_WarpSurfaceSubdividePolygon(int numverts, float *verts)
{
	int i, j, k, f, b;
	vec3_t mins, maxs, front[64], back[64];
	float m, *v, dist[64], frac, s, t;
	glpoly_t *poly;
	float subdivide_size;
	extern cvar_t gl_subdivide_size;

	if (numverts > 60) {
		Sys_Error("numverts = %i", numverts);
	}

	subdivide_size = max(1, gl_subdivide_size.value);
	R_WarpSurfaceBoundPoly(numverts, verts, mins, maxs);

	for (i = 0; i < 3; i++) {
		m = (mins[i] + maxs[i]) * 0.5;
		m = subdivide_size * floor(m / subdivide_size + 0.5);
		if (maxs[i] - m < 8) {
			continue;
		}
		if (m - mins[i] < 8) {
			continue;
		}

		// cut it
		v = verts + i;
		for (j = 0; j < numverts; j++, v += 3) {
			dist[j] = *v - m;
		}

		// wrap cases
		dist[j] = dist[0];
		v -= i;
		VectorCopy(verts, v);

		f = b = 0;
		v = verts;
		for (j = 0; j < numverts; j++, v += 3) {
			if (dist[j] >= 0) {
				VectorCopy(v, front[f]);
				f++;
			}
			if (dist[j] <= 0) {
				VectorCopy(v, back[b]);
				b++;
			}
			if (dist[j] == 0 || dist[j + 1] == 0) {
				continue;
			}
			if ((dist[j] > 0) != (dist[j + 1] > 0)) {
				// clip point
				frac = dist[j] / (dist[j] - dist[j + 1]);
				for (k = 0; k < 3; k++) {
					front[f][k] = back[b][k] = v[k] + frac * (v[3 + k] - v[k]);
				}
				f++;
				b++;
			}
		}
		R_WarpSurfaceSubdividePolygon(f, front[0]);
		R_WarpSurfaceSubdividePolygon(b, back[0]);
		return;
	}

	poly = (glpoly_t *)Hunk_AllocName(sizeof(glpoly_t) + (numverts - 4) * VERTEXSIZE * sizeof(float), "subdivpoly");
	poly->next = warpface->subdivided;
	warpface->subdivided = poly;
	poly->numverts = numverts;
	for (i = 0; i < numverts; i++, verts += 3) {
		VectorCopy(verts, poly->verts[i]);
		s = DotProduct(verts, warpface->texinfo->vecs[0]);
		t = DotProduct(verts, warpface->texinfo->vecs[1]);
		poly->verts[i][3] = s / 64.0f;
		poly->verts[i][4] = t / 64.0f;
		poly->verts[i][5] = 8 * sin(2 * t) / 64.0f;
		poly->verts[i][6] = 8 * sin(2 * s) / 64.0f;
		poly->verts[i][7] = 8 * cos(2 * t) / 64.0f;
		poly->verts[i][8] = 8 * cos(2 * s) / 64.0f;
	}
	R_BrushModelPolygonToTriangleStrip(poly);
}

// Breaks a polygon up along axial 64 unit boundaries so that turbulent and sky warps can be done reasonably.
void R_TurbSurfacesSubdivide(msurface_t *fa)
{
	vec3_t verts[64];
	int numverts, i, lindex;
	float *vec;

	warpface = fa;

	// convert edges back to a normal polygon
	numverts = 0;
	for (i = 0; i < fa->numedges && numverts < 64; i++) {
		lindex = loadmodel->surfedges[fa->firstedge + i];

		if (lindex > 0) {
			vec = loadmodel->vertexes[loadmodel->edges[lindex].v[0]].position;
		}
		else {
			vec = loadmodel->vertexes[loadmodel->edges[-lindex].v[1]].position;
		}
		VectorCopy(vec, verts[numverts]);
		numverts++;
	}

	R_WarpSurfaceSubdividePolygon(numverts, verts[0]);
}

// Just build the gl polys, don't subdivide
void R_SkySurfacesBuildPolys(msurface_t *fa)
{
	vec3_t		verts[64];
	int			numverts;
	int			i;
	int			lindex;
	float		*vec;
	glpoly_t	*poly;
	float		*vert;

	//
	// convert edges back to a normal polygon
	//
	numverts = 0;
	for (i = 0; i < fa->numedges; i++) {
		lindex = loadmodel->surfedges[fa->firstedge + i];

		if (lindex > 0) {
			vec = loadmodel->vertexes[loadmodel->edges[lindex].v[0]].position;
		}
		else {
			vec = loadmodel->vertexes[loadmodel->edges[-lindex].v[1]].position;
		}
		VectorCopy(vec, verts[numverts]);
		numverts++;
	}

	poly = Hunk_AllocName(sizeof(glpoly_t) + (numverts - 4) * VERTEXSIZE * sizeof(float), "subdivpoly");
	poly->next = NULL;
	fa->polys = poly;
	poly->numverts = numverts;
	vert = verts[0];
	for (i = 0; i < numverts; i++, vert += 3) {
		VectorCopy(vert, poly->verts[i]);
	}
	R_BrushModelPolygonToTriangleStrip(poly);
}

byte* SurfaceFlatTurbColor(texture_t* texture)
{
	extern cvar_t r_telecolor, r_watercolor, r_slimecolor, r_lavacolor, r_skycolor;

	switch (texture->turbType)
	{
	case TEXTURE_TURB_WATER:
		return r_watercolor.color;
	case TEXTURE_TURB_SLIME:
		return r_slimecolor.color;
	case TEXTURE_TURB_LAVA:
		return r_lavacolor.color;
	case TEXTURE_TURB_TELE:
		return r_telecolor.color;
	case TEXTURE_TURB_SKY:
		return r_skycolor.color;
	}

	return (byte *)&texture->flatcolor3ub;
}

//Tei, add fire to lava
void EmitParticleEffect(msurface_t *fa, void(*fun)(vec3_t nv))
{
	glpoly_t *p;
	float *v;
	int i;
	vec3_t nv;

	for (p = fa->subdivided; p; p = p->next) {
		float min_x, min_y, max_x, max_y;
		for (i = 0, v = p->verts[0]; i < p->numverts; i++, v += VERTEXSIZE) {
			min_x = i == 0 ? v[0] : min(min_x, v[0]);
			min_y = i == 0 ? v[1] : min(min_y, v[1]);
			max_x = i == 0 ? v[0] : max(max_x, v[0]);
			max_y = i == 0 ? v[1] : max(max_y, v[1]);
		}

		for (i = 0, v = p->verts[0]; i < p->numverts; i++, v += VERTEXSIZE) {
			if (rand() % 100 <= (cls.frametime / 0.00416) * 4) {
				VectorCopy(v, nv);

				nv[0] += f_rnd(min_x - v[0], max_x - v[0]);
				nv[1] += f_rnd(min_y - v[1], max_y - v[1]);

				fun(nv);
			}
		}
	}
}


================================================
FILE: src/r_brushmodel_warpsurfaces_sin.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
0.000000, 0.098172, 0.196330, 0.294458, 0.392541, 0.490566, 0.588517, 0.686378, 
0.784137, 0.881778, 0.979285, 1.076646, 1.173844, 1.270865, 1.367695, 1.464319, 
1.560723, 1.656891, 1.752810, 1.848465, 1.943841, 2.038925, 2.133702, 2.228158, 
2.322277, 2.416048, 2.509454, 2.602482, 2.695119, 2.787349, 2.879160, 2.970538, 
3.061467, 3.151936, 3.241931, 3.331436, 3.420441, 3.508930, 3.596891, 3.684310, 
3.771174, 3.857470, 3.943186, 4.028307, 4.112822, 4.196717, 4.279981, 4.362600, 
4.444562, 4.525854, 4.606466, 4.686383, 4.765594, 4.844088, 4.921853, 4.998876, 
5.075146, 5.150652, 5.225383, 5.299326, 5.372472, 5.444808, 5.516324, 5.587010, 
5.656854, 5.725847, 5.793977, 5.861234, 5.927609, 5.993091, 6.057671, 6.121338, 
6.184084, 6.245898, 6.306771, 6.366695, 6.425660, 6.483658, 6.540679, 6.596714, 
6.651757, 6.705798, 6.758829, 6.810842, 6.861829, 6.911783, 6.960696, 7.008561, 
7.055370, 7.101117, 7.145794, 7.189396, 7.231914, 7.273344, 7.313678, 7.352911, 
7.391036, 7.428049, 7.463942, 7.498712, 7.532353, 7.564859, 7.596225, 7.626448, 
7.655523, 7.683444, 7.710209, 7.735812, 7.760250, 7.783520, 7.805617, 7.826539, 
7.846282, 7.864844, 7.882221, 7.898411, 7.913412, 7.927221, 7.939836, 7.951256, 
7.961478, 7.970501, 7.978324, 7.984945, 7.990364, 7.994579, 7.997591, 7.999398, 
8.000000, 7.999398, 7.997591, 7.994579, 7.990364, 7.984945, 7.978324, 7.970501, 
7.961478, 7.951256, 7.939836, 7.927221, 7.913412, 7.898411, 7.882221, 7.864844, 
7.846282, 7.826539, 7.805617, 7.783520, 7.760250, 7.735812, 7.710209, 7.683444, 
7.655523, 7.626448, 7.596225, 7.564859, 7.532353, 7.498712, 7.463942, 7.428049, 
7.391036, 7.352911, 7.313678, 7.273344, 7.231914, 7.189396, 7.145794, 7.101117, 
7.055370, 7.008561, 6.960696, 6.911783, 6.861829, 6.810842, 6.758829, 6.705798, 
6.651757, 6.596714, 6.540679, 6.483658, 6.425660, 6.366695, 6.306771, 6.245898, 
6.184084, 6.121338, 6.057671, 5.993091, 5.927609, 5.861234, 5.793977, 5.725847, 
5.656854, 5.587010, 5.516324, 5.444808, 5.372472, 5.299326, 5.225383, 5.150652, 
5.075146, 4.998876, 4.921853, 4.844088, 4.765594, 4.686383, 4.606466, 4.525854, 
4.444562, 4.362600, 4.279981, 4.196717, 4.112822, 4.028307, 3.943186, 3.857470, 
3.771174, 3.684310, 3.596891, 3.508930, 3.420441, 3.331436, 3.241931, 3.151936, 
3.061467, 2.970538, 2.879160, 2.787349, 2.695119, 2.602482, 2.509454, 2.416048, 
2.322277, 2.228158, 2.133702, 2.038925, 1.943841, 1.848465, 1.752810, 1.656891, 
1.560723, 1.464319, 1.367695, 1.270865, 1.173844, 1.076646, 0.979285, 0.881778, 
0.784137, 0.686378, 0.588517, 0.490566, 0.392541, 0.294458, 0.196330, 0.098172, 
0.000000, -0.098172, -0.196330, -0.294458, -0.392541, -0.490566, -0.588517, -0.686378, 
-0.784137, -0.881778, -0.979285, -1.076646, -1.173844, -1.270865, -1.367695, -1.464319, 
-1.560723, -1.656891, -1.752810, -1.848465, -1.943841, -2.038925, -2.133702, -2.228158, 
-2.322277, -2.416048, -2.509454, -2.602482, -2.695119, -2.787349, -2.879160, -2.970538, 
-3.061467, -3.151936, -3.241931, -3.331436, -3.420441, -3.508930, -3.596891, -3.684310, 
-3.771174, -3.857470, -3.943186, -4.028307, -4.112822, -4.196717, -4.279981, -4.362600, 
-4.444562, -4.525854, -4.606466, -4.686383, -4.765594, -4.844088, -4.921853, -4.998876, 
-5.075146, -5.150652, -5.225383, -5.299326, -5.372472, -5.444808, -5.516324, -5.587010, 
-5.656854, -5.725847, -5.793977, -5.861234, -5.927609, -5.993091, -6.057671, -6.121338, 
-6.184084, -6.245898, -6.306771, -6.366695, -6.425660, -6.483658, -6.540679, -6.596714, 
-6.651757, -6.705798, -6.758829, -6.810842, -6.861829, -6.911783, -6.960696, -7.008561, 
-7.055370, -7.101117, -7.145794, -7.189396, -7.231914, -7.273344, -7.313678, -7.352911, 
-7.391036, -7.428049, -7.463942, -7.498712, -7.532353, -7.564859, -7.596225, -7.626448, 
-7.655523, -7.683444, -7.710209, -7.735812, -7.760250, -7.783520, -7.805617, -7.826539, 
-7.846282, -7.864844, -7.882221, -7.898411, -7.913412, -7.927221, -7.939836, -7.951256, 
-7.961478, -7.970501, -7.978324, -7.984945, -7.990364, -7.994579, -7.997591, -7.999398, 
-8.000000, -7.999398, -7.997591, -7.994579, -7.990364, -7.984945, -7.978324, -7.970501, 
-7.961478, -7.951256, -7.939836, -7.927221, -7.913412, -7.898411, -7.882221, -7.864844, 
-7.846282, -7.826539, -7.805617, -7.783520, -7.760250, -7.735812, -7.710209, -7.683444, 
-7.655523, -7.626448, -7.596225, -7.564859, -7.532353, -7.498712, -7.463942, -7.428049, 
-7.391036, -7.352911, -7.313678, -7.273344, -7.231914, -7.189396, -7.145794, -7.101117, 
-7.055370, -7.008561, -6.960696, -6.911783, -6.861829, -6.810842, -6.758829, -6.705798, 
-6.651757, -6.596714, -6.540679, -6.483658, -6.425660, -6.366695, -6.306771, -6.245898, 
-6.184084, -6.121338, -6.057671, -5.993091, -5.927609, -5.861234, -5.793977, -5.725847, 
-5.656854, -5.587010, -5.516324, -5.444808, -5.372472, -5.299326, -5.225383, -5.150652, 
-5.075146, -4.998876, -4.921853, -4.844088, -4.765594, -4.686383, -4.606466, -4.525854, 
-4.444562, -4.362600, -4.279981, -4.196717, -4.112822, -4.028307, -3.943186, -3.857470, 
-3.771174, -3.684310, -3.596891, -3.508930, -3.420441, -3.331436, -3.241931, -3.151936, 
-3.061467, -2.970538, -2.879160, -2.787349, -2.695119, -2.602482, -2.509454, -2.416048, 
-2.322277, -2.228158, -2.133702, -2.038925, -1.943841, -1.848465, -1.752810, -1.656891, 
-1.560723, -1.464319, -1.367695, -1.270865, -1.173844, -1.076646, -0.979285, -0.881778, 
-0.784137, -0.686378, -0.588517, -0.490566, -0.392541, -0.294458, -0.196330, -0.098172, 

================================================
FILE: src/r_buffers.c
================================================

#include "quakedef.h"
#include "r_local.h"
#include "r_buffers.h"

api_buffers_t buffers;

void R_CreateInstanceVBO(void)
{
	unsigned int values[MAX_STANDARD_ENTITIES];
	int i;

	for (i = 0; i < MAX_STANDARD_ENTITIES; ++i) {
		values[i] = i;
	}

	buffers.Create(r_buffer_instance_number, buffertype_vertex, "instance#", sizeof(values), values, bufferusage_reuse_many_frames);
}


================================================
FILE: src/r_buffers.h
================================================

#ifndef EZQUAKE_R_BUFFERS_HEADER
#define EZQUAKE_R_BUFFERS_HEADER

typedef enum {
	r_buffer_none,
	r_buffer_aliasmodel_vertex_data,
	r_buffer_aliasmodel_vertex_ssbo,
	r_buffer_aliasmodel_glc_pose_data,
	r_buffer_aliasmodel_drawcall_indirect,
	r_buffer_aliasmodel_model_data,
	r_buffer_brushmodel_vertex_data,
	r_buffer_brushmodel_index_data,
	r_buffer_brushmodel_surface_data,
	r_buffer_brushmodel_lightstyles_ssbo,
	r_buffer_brushmodel_surfacestolight_ssbo,
	r_buffer_brushmodel_worldsamplers_ssbo,
	r_buffer_brushmodel_drawcall_indirect,
	r_buffer_brushmodel_drawcall_data,
	r_buffer_sprite_vertex_data,
	r_buffer_sprite_index_data,
	r_buffer_instance_number,
	r_buffer_hud_image_vertex_data,
	r_buffer_hud_image_index_data,
	r_buffer_hud_circle_vertex_data,
	r_buffer_postprocess_vertex_data,
	r_buffer_frame_constants,

	r_buffer_count
} r_buffer_id;

#define R_BufferReferenceIsValid(x) (buffers.IsValid(x))
#define R_BufferReferencesEqual(x,y) ((x) == (y))

// Buffers
typedef enum {
	bufferusage_unknown,
	bufferusage_once_per_frame,     // filled & used once per frame
	bufferusage_reuse_per_frame,    // filled & used many times per frame
	bufferusage_reuse_many_frames,  // filled once, expect to use many times over subsequent frames
	bufferusage_constant_data,       // filled once, never updated again

	bufferusage_count
} bufferusage_t;

typedef enum {
	buffertype_unknown,
	buffertype_vertex,
	buffertype_index,
	buffertype_storage,
	buffertype_uniform,
	buffertype_indirect,

	buffertype_count
} buffertype_t;

typedef struct api_buffers_t {
	void (*InitialiseState)(void);

	void (*StartFrame)(void);
	void (*EndFrame)(void);
	qbool (*FrameReady)(void);

	size_t (*Size)(r_buffer_id id);
	qbool (*Create)(r_buffer_id id, buffertype_t type, const char* name, int size, void* data, bufferusage_t usage);
	uintptr_t (*BufferOffset)(r_buffer_id id);

	void (*Bind)(r_buffer_id id);
	void (*BindBase)(r_buffer_id id, unsigned int index);
	void (*BindRange)(r_buffer_id id, unsigned int index, ptrdiff_t offset, int size);
	void (*UnBind)(buffertype_t type);
	void (*Update)(r_buffer_id id, int size, void* data);
	void (*UpdateSection)(r_buffer_id id, ptrdiff_t offset, int size, const void* data);
	void (*Resize)(r_buffer_id id, int size, void* data);
	void (*EnsureSize)(r_buffer_id id, int size);

	qbool (*IsValid)(r_buffer_id id);
	void (*SetElementArray)(r_buffer_id id);
	void (*Shutdown)(void);

#ifdef WITH_RENDERING_TRACE
	void (*PrintState)(FILE* debug_frame_out, int debug_frame_depth);
#endif

	qbool supported;
} api_buffers_t;

extern api_buffers_t buffers;

void R_CreateInstanceVBO(void);

#endif // EZQUAKE_R_BUFFERS_HEADER


================================================
FILE: src/r_chaticons.c
================================================
/*
Copyright (C) 1996-2003 Id Software, Inc., A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "glm_texture_arrays.h"
#include "r_sprite3d.h"
#include "r_texture.h"
#include "r_chaticons.h"
#include "r_state.h"
#include "r_matrix.h"

// Chat icons
typedef byte col_t[4]; // FIXME: why 4?

typedef struct ci_player_s {
	vec3_t		org;
	col_t		color;
	float		rotangle;
	float		size;
	byte		texindex;
	int			flags;
	float       distance;

	player_info_t *player;
} ci_player_t;

typedef enum {
	citex_chat,
	citex_afk,
	citex_chat_afk,
	num_citextures,
} ci_tex_t;

#define	MAX_CITEX_COMPONENTS		8
typedef struct ci_texture_s {
	texture_ref  texnum;
	texture_ref  tex_array;
	int          tex_index;
	int          components;
	float        coords[MAX_CITEX_COMPONENTS][4];
	float        originalCoords[MAX_CITEX_COMPONENTS][4];
} ci_texture_t;

#define TEXTURE_DETAILS(x) (R_UseModernOpenGL() ? x.tex_array : x.texnum),(x.tex_index)

extern cvar_t r_chaticons_alpha;

/**************************************** chat icon *****************************/
// qqshka: code is a mixture of autoid and particle engine

static ci_player_t ci_clients[MAX_CLIENTS];
static int ci_count;
static ci_texture_t ci_textures[num_citextures];
static qbool ci_initialized = false;

#define FONT_SIZE (256.0)

#define ADD_CICON_TEXTURE(_ptex, _texnum, _texindex, _components, _s1, _t1, _s2, _t2)	\
	do {																					\
		ci_textures[_ptex].texnum = _texnum;												\
		ci_textures[_ptex].components = _components;										\
		ci_textures[_ptex].coords[_texindex][0] = (_s1 + 1) / FONT_SIZE;					\
		ci_textures[_ptex].coords[_texindex][1] = (_t1 + 1) / FONT_SIZE;					\
		ci_textures[_ptex].coords[_texindex][2] = (_s2 - 1) / FONT_SIZE;					\
		ci_textures[_ptex].coords[_texindex][3] = (_t2 - 1) / FONT_SIZE;					\
		memcpy(ci_textures[_ptex].originalCoords, ci_textures[_ptex].coords, sizeof(ci_textures[_ptex].originalCoords)); \
	} while(0);

// FIXME: Almost duplicate of QMB_LoadTextureSubImage, extracting sprites from an atlas
//        This version works on different enumeration, and doesn't double-up for pre-multiplied alpha
static void R_LoadChatIconTextureSubImage(ci_tex_t tex, const char* id, const byte* pixels, byte* temp_buffer, int full_width, int full_height, int texIndex, int components, int sub_x, int sub_y, int sub_x2, int sub_y2)
{
	const int mode = TEX_ALPHA | TEX_COMPLAIN | TEX_NOSCALE;// | TEX_MIPMAP;
	texture_ref tex_ref;
	int y, x;
	int width = sub_x2 - sub_x;
	int height = sub_y2 - sub_y;

	for (y = 0; y < height; ++y) {
		const byte* source = pixels + ((sub_y + y) * full_width + sub_x) * 4;
		byte* target = temp_buffer + y * width * 4;

		for (x = 0; x < width; ++x, source += 4, target += 4) {
			target[0] = (byte)(((int)source[0] * (int)source[3]) / 255.0);
			target[1] = (byte)(((int)source[1] * (int)source[3]) / 255.0);
			target[2] = (byte)(((int)source[2] * (int)source[3]) / 255.0);
		}
	}

	tex_ref = R_LoadTexture(id, width, height, temp_buffer, mode, 4);

	ADD_CICON_TEXTURE(tex, tex_ref, 0, 1, 0, 0, FONT_SIZE, FONT_SIZE);
}

static void R_DrawChatIconBillboard(sprite3d_batch_id batch, ci_texture_t* _ptex, ci_player_t* _p, vec3_t _coord[4])
{
	float coordinates[4][4];
	r_sprite3d_vert_t* vert;
	int i;

	for (i = 0; i < 4; ++i) {
		VectorScale(_coord[i], _p->size, coordinates[i]);
		if (_p->rotangle) {
			R_RotateVector(coordinates[i], _p->rotangle, vpn[0], vpn[1], vpn[2]);
		}
		VectorAdd(coordinates[i], _p->org, coordinates[i]);
	}

	vert = R_Sprite3DAddEntry(batch, 4);
	if (vert) {
		R_Sprite3DSetVert(vert++, coordinates[0][0], coordinates[0][1], coordinates[0][2], _ptex->coords[_p->texindex][0], _ptex->coords[_p->texindex][3], _p->color, _ptex->tex_index);
		R_Sprite3DSetVert(vert++, coordinates[1][0], coordinates[1][1], coordinates[1][2], _ptex->coords[_p->texindex][0], _ptex->coords[_p->texindex][1], _p->color, _ptex->tex_index);
		R_Sprite3DSetVert(vert++, coordinates[3][0], coordinates[3][1], coordinates[3][2], _ptex->coords[_p->texindex][2], _ptex->coords[_p->texindex][3], _p->color, _ptex->tex_index);
		R_Sprite3DSetVert(vert++, coordinates[2][0], coordinates[2][1], coordinates[2][2], _ptex->coords[_p->texindex][2], _ptex->coords[_p->texindex][1], _p->color, _ptex->tex_index);
	}
}

static int CmpCI_Order(const void *p1, const void *p2)
{
	const ci_player_t	*a1 = (ci_player_t *)p1;
	const ci_player_t	*a2 = (ci_player_t *)p2;
	int l1 = a1->distance;
	int l2 = a2->distance;

	if (l1 > l2)
		return -1;
	if (l1 < l2)
		return  1;

	return 0;
}

void R_SetupChatIcons(void)
{
	int j, tracknum = -1;
	player_state_t *state;
	player_info_t *info;
	ci_player_t *id;
	centity_t *cent;

	ci_count = 0;

	if (!bound(0, r_chaticons_alpha.value, 1)) {
		return;
	}

	if (cls.state != ca_active || !cl.validsequence || cl.intermission) {
		return;
	}

	if (cl.spectator) {
		tracknum = Cam_TrackNum();
	}

	state = cl.frames[cl.parsecount & UPDATE_MASK].playerstate;
	info = cl.players;
	cent = &cl_entities[1];

	for (j = 0; j < MAX_CLIENTS; j++, info++, state++, cent++) {
		vec3_t diff;
		float fade = 1;

		if (state->messagenum != cl.parsecount || j == cl.playernum || j == tracknum || info->spectator) {
			continue;
		}

		if (!info->chatflag) {
			continue; // user not chatting, so ignore
		}

		id = &ci_clients[ci_count];
		id->texindex = 0;
		id->player = info;

		id->org[0] = cent->lerp_origin[0];
		id->org[1] = cent->lerp_origin[1];
		id->org[2] = cent->lerp_origin[2] + 33; // move balloon up a bit
		VectorSubtract(id->org, r_refdef.vieworg, diff);
		id->distance = VectorLength(diff);

		if ((!cls.mvdplayback || Cam_TrackNum() >= 0) && cl.racing) {
			if (id->distance < KTX_RACING_PLAYER_MIN_DISTANCE) {
				continue; // too close, hide indicators
			}
			fade = min(id->distance, KTX_RACING_PLAYER_MAX_DISTANCE) / KTX_RACING_PLAYER_ALPHA_SCALE;
		}

		id->size = 8; // scale baloon
		id->rotangle = 5 * sin(2 * r_refdef2.time); // may be set to 0, if u dislike rolling
		id->color[0] = id->color[1] = id->color[2] = id->color[3] = 255 * bound(0, r_chaticons_alpha.value, 1) * fade; // pre-multiplied alpha

		id->flags = info->chatflag & (CIF_CHAT | CIF_AFK); // get known flags
		id->flags = (id->flags ? id->flags : CIF_CHAT); // use chat as default if we got some unknown "chat" value

		ci_count++;
	}

	if (ci_count) {
		// sort icons so we draw most far to you first
		qsort((void *)ci_clients, ci_count, sizeof(ci_clients[0]), CmpCI_Order);
	}
}

void R_InitChatIcons(void)
{
	int texmode = TEX_ALPHA | TEX_COMPLAIN | TEX_NOSCALE | TEX_MIPMAP;

	ci_initialized = false;

	{
		int real_width, real_height;
		byte* original;
		byte* temp_buffer;

		original = R_LoadImagePixels("textures/chaticons", 0, 0, texmode, &real_width, &real_height);
		if (!original) {
			return;
		}

		temp_buffer = Q_malloc(real_width * real_height * 4);
		R_LoadChatIconTextureSubImage(citex_chat, "ci:chat", original, temp_buffer, real_width, real_height, 0, 1, 0, 0, real_width / 4, real_height / 4);
		R_LoadChatIconTextureSubImage(citex_afk, "ci:afk", original, temp_buffer, real_width, real_height, 0, 1, real_width / 4, 0, real_width / 2, real_height / 4);
		R_LoadChatIconTextureSubImage(citex_chat_afk, "ci:chat-afk", original, temp_buffer, real_width, real_height, 0, 1, 0, 0, real_width / 2, real_height / 4);
		Q_free(temp_buffer);
		Q_free(original);
	}

	ci_initialized = true;
}

void R_DrawChatIcons(void)
{
	int	i, flags;
	vec3_t billboard[4], billboard2[4], vright_tmp;
	ci_player_t *p;

	if (!ci_initialized) {
		return;
	}

	if (!bound(0, r_chaticons_alpha.value, 1) || ci_count < 1) {
		return;
	}

	VectorAdd(vup, vright, billboard[2]);
	VectorSubtract(vright, vup, billboard[3]);
	VectorNegate(billboard[2], billboard[0]);
	VectorNegate(billboard[3], billboard[1]);

	VectorScale(vright, 2, vright_tmp);
	VectorAdd(vup, vright_tmp, billboard2[2]);
	VectorSubtract(vright_tmp, vup, billboard2[3]);
	VectorNegate(billboard2[2], billboard2[0]);
	VectorNegate(billboard2[3], billboard2[1]);

	R_Sprite3DInitialiseBatch(SPRITE3D_CHATICON_AFK_CHAT, r_state_chaticon, TEXTURE_DETAILS(ci_textures[citex_chat_afk]), r_primitive_triangle_strip);
	R_Sprite3DInitialiseBatch(SPRITE3D_CHATICON_AFK, r_state_chaticon, TEXTURE_DETAILS(ci_textures[citex_afk]), r_primitive_triangle_strip);
	R_Sprite3DInitialiseBatch(SPRITE3D_CHATICON_CHAT, r_state_chaticon, TEXTURE_DETAILS(ci_textures[citex_chat]), r_primitive_triangle_strip);

	for (i = 0; i < ci_count; i++) {
		p = &ci_clients[i];
		flags = p->flags;

		if ((flags & CIF_CHAT) && (flags & CIF_AFK)) {
			R_DrawChatIconBillboard(SPRITE3D_CHATICON_AFK_CHAT, &ci_textures[citex_chat_afk], p, billboard2);
		}
		else if (flags & CIF_CHAT) {
			R_DrawChatIconBillboard(SPRITE3D_CHATICON_CHAT, &ci_textures[citex_chat], p, billboard);
		}
		else if (flags & CIF_AFK) {
			R_DrawChatIconBillboard(SPRITE3D_CHATICON_AFK, &ci_textures[citex_afk], p, billboard);
		}
	}
}

void R_ImportChatIconTextureArrayReferences(texture_flag_t* texture_flags)
{
	ci_tex_t tex;
	int i;

	for (tex = 0; tex < num_citextures; ++tex) {
		if (R_TextureReferenceIsValid(ci_textures[tex].texnum)) {
			texture_array_ref_t* array_ref = &texture_flags[ci_textures[tex].texnum.index].array_ref[TEXTURETYPES_SPRITES];

			ci_textures[tex].tex_array = array_ref->ref;
			ci_textures[tex].tex_index = array_ref->index;
			for (i = 0; i < ci_textures[tex].components; ++i) {
				ci_textures[tex].coords[i][0] *= array_ref->scale_s;
				ci_textures[tex].coords[i][2] *= array_ref->scale_s;
				ci_textures[tex].coords[i][1] *= array_ref->scale_t;
				ci_textures[tex].coords[i][3] *= array_ref->scale_t;
			}
		}
	}
}

void R_FlagChatIconTexturesForArray(texture_flag_t* texture_flags)
{
	ci_tex_t tex;

	for (tex = 0; tex < num_citextures; ++tex) {
		if (R_TextureReferenceIsValid(ci_textures[tex].texnum)) {
			texture_flags[ci_textures[tex].texnum.index].flags |= (1 << TEXTURETYPES_SPRITES);
			memcpy(ci_textures[tex].coords, ci_textures[tex].originalCoords, sizeof(ci_textures[tex].coords));
		}
	}
}


================================================
FILE: src/r_chaticons.h
================================================
/*
Copyright (C) 1996-2003 Id Software, Inc., A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef EZQUAKE_R_CHATICONS_HEADER
#define EZQUAKE_R_CHATICONS_HEADER

void R_InitChatIcons(void);
void R_SetupChatIcons(void);
void R_DrawChatIcons(void);

#endif // EZQUAKE_R_CHATICONS_HEADER


================================================
FILE: src/r_draw.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: gl_draw.c,v 1.104 2007-10-18 05:28:23 dkure Exp $
*/

#include "quakedef.h"
#include "gl_model.h"
#include "wad.h"
#include "stats_grid.h"
#include "utils.h"
#include "sbar.h"
#include "common_draw.h"
#include "tr_types.h"
#include "gl_framebuffer.h"
#include "r_texture.h"
#include "r_matrix.h"
#include "r_local.h"
#include "r_draw.h"
#include "r_state.h"
#include "r_trace.h"
#include "r_renderer.h"

void CachePics_Init(void);
void Draw_InitCharset(void);
void CachePics_LoadAmmoPics(mpic_t* ibar);
void Draw_SetCrosshairTextMode(qbool enabled);

void GLC_DrawDisc(void);

extern cvar_t crosshair, cl_crossx, cl_crossy, crosshaircolor, crosshairsize;
extern cvar_t con_shift, hud_faderankings;

cvar_t	scr_conalpha		= {"scr_conalpha", "0.8"};
cvar_t	scr_conback			= {"scr_conback", "1"};
void OnChange_scr_conpicture(cvar_t *, char *, qbool *);
cvar_t  scr_conpicture      = {"scr_conpicture", "conback", 0, OnChange_scr_conpicture};
cvar_t	scr_menualpha		= {"scr_menualpha", "0.7"};
cvar_t	scr_menudrawhud		= {"scr_menudrawhud", "0"};

cvar_t  r_smoothtext        = { "r_smoothtext",      "1" };
cvar_t  r_smoothcrosshair   = { "r_smoothcrosshair", "1" };
cvar_t  r_smoothimages      = { "r_smoothimages",    "1" };
cvar_t  r_smoothalphahack   = { "r_smoothalphahack", "0" };

void OnChange_crosshairimage(cvar_t *, char *, qbool *);
static cvar_t crosshairimage          = {"crosshairimage", "", 0, OnChange_crosshairimage};

cvar_t crosshairalpha                 = {"crosshairalpha", "1"};

static cvar_t crosshairscalemethod         = {"crosshairscalemethod", "0"};
static cvar_t crosshairscale               = {"crosshairscale", "0"};
static int    current_crosshair_pixel_size = 0;

mpic_t			*draw_disc;
static mpic_t	*draw_backtile;

static mpic_t	conback;

mpic_t      crosshairtexture_txt;
mpic_t      crosshairpic;
mpic_t      crosshairs_builtin[NUMCROSSHAIRS];

static byte customcrosshairdata[64];

#define CROSSHAIR_NONE	0
#define CROSSHAIR_TXT	1
#define CROSSHAIR_IMAGE	2
static int customcrosshair_loaded = CROSSHAIR_NONE;

#define CH_POINT(x,y,size) ((x) + (y) * size)

static void CreateBuiltinCrosshair(byte* data, int size, int format)
{
	int i = 0;
	int middle = (size / 2) - 1;

	memset(data, 0xff, size * size);

	switch (format) {
	case 2:
		// simple cross, alternating stipple effect
		for (i = 0; i < size; i += 2) {
			// vertical
			data[CH_POINT(middle, i, size)] = 0xfe;

			// horizontal
			data[CH_POINT(i, middle, size)] = 0xfe;
		}
		break;
	case 3:
		// small cross in center
		{
			int length = max(0, size / 8);

			data[CH_POINT(middle, middle, size)] = 0xfe;
			for (i = 1; i <= length; ++i) {
				int p1 = CH_POINT(middle - i, middle, size);
				int p2 = CH_POINT(middle + i, middle, size);
				int p3 = CH_POINT(middle, middle - i, size);
				int p4 = CH_POINT(middle, middle + i, size);

				data[p1] = 0xfe;
				data[p2] = 0xfe;
				data[p3] = 0xfe;
				data[p4] = 0xfe;
			}
		}
		break;
	case 4:
		// just a dot (scale to make square then circle?)
		data[CH_POINT(middle, middle, size)] = 0xfe;
		break;
	case 5:
		// diagonals (middle missing)
		for (i = 0; i < size; ++i) {
			if (i >= middle - 1 && i <= middle + 1) {
				continue;
			}
			data[CH_POINT(i, i, size)] = 0xfe;
			data[CH_POINT(size - 1 - i, i, size)] = 0xfe;
		}
		break;
	case 6:
		// Supposed to be a smiley face, not converting that...
	case 7:
		// Square with dot in centre
		data[CH_POINT(middle, middle, size)] = 0xfe;
		for (i = 2; i <= size - 4; ++i) {
			data[CH_POINT(i, 0, size)] = 0xfe;
			data[CH_POINT(0, i, size)] = 0xfe;
			data[CH_POINT(i, size - 2, size)] = 0xfe;
			data[CH_POINT(size - 2, i, size)] = 0xfe;
		}
		break;
	}
}

/*
* Draw_CopyMPICKeepSize
* Copy data from src to dst but keep unchanged dst->width and dst->height
*/
static void Draw_CopyMPICKeepSize(mpic_t *dst, mpic_t *src)
{
	byte width[sizeof(dst->width)];
	byte height[sizeof(dst->height)];

	// remember particular fields
	memcpy(width, (byte*)&dst->width, sizeof(width));
	memcpy(height, (byte*)&dst->height, sizeof(height));

	// bit by bit copy
	*dst = *src;

	// restore fields
	memcpy((byte*)&dst->width, width, sizeof(width));
	memcpy((byte*)&dst->height, height, sizeof(height));
}

void OnChange_scr_conpicture(cvar_t *v, char *s, qbool *cancel)
{
	mpic_t *pic_24bit;

	if (!s[0])
		return;

	if (!(pic_24bit = R_LoadPicImage(va("gfx/%s", s), "conback", 0, 0, 0)))
	{
		Com_Printf("Couldn't load image gfx/%s\n", s);
		return;
	}

	Draw_CopyMPICKeepSize(&conback, pic_24bit);
	Draw_AdjustConback();
}

void OnChange_crosshairimage(cvar_t *v, char *s, qbool *cancel)
{
	mpic_t *pic;

	customcrosshair_loaded &= ~CROSSHAIR_IMAGE;

	if (!s[0])
		return;

	if (!(pic = Draw_CachePicSafe(va("crosshairs/%s", s), false, true)))
	{
		Com_Printf("Couldn't load image %s\n", s);
		return;
	}

	crosshairpic = *pic;
	customcrosshair_loaded |= CROSSHAIR_IMAGE;
	CachePics_MarkAtlasDirty();
}

void customCrosshair_Init(void)
{
	char ch;
	vfsfile_t *f;
	vfserrno_t err;
	int i = 0, c;

	customcrosshair_loaded = CROSSHAIR_NONE;
	R_TextureReferenceInvalidate(crosshairtexture_txt.texnum);

	if (!(f = FS_OpenVFS("crosshairs/crosshair.txt", "rb", FS_ANY))) {
		return;
	}

	while (i < 64) {
		VFS_READ(f, &ch, sizeof(char), &err);
		if (err == VFSERR_EOF) {
			Com_Printf("Invalid format in crosshair.txt (Need 64 X's and O's)\n");
			VFS_CLOSE(f);
			return;
		}
		c = ch;

		if (isspace(c))
			continue;

		if (tolower(c) != 'x' && tolower(c) != 'o') {
			Com_Printf("Invalid format in crosshair.txt (Only X's and O's and whitespace permitted)\n");
			VFS_CLOSE(f);
			return;
		}
		customcrosshairdata[i++] = (c == 'x' || c == 'X') ? 0xfe : 0xff;
	}

	VFS_CLOSE(f);
	crosshairtexture_txt.texnum = R_LoadTexture("cross:custom", 8, 8, customcrosshairdata, TEX_ALPHA, 1);
	crosshairtexture_txt.sl = crosshairtexture_txt.tl = 0;
	crosshairtexture_txt.sh = crosshairtexture_txt.th = 1;
	customcrosshair_loaded |= CROSSHAIR_TXT;
	CachePics_MarkAtlasDirty();
}

static int CrosshairPixelSize(void)
{
	// 0 = 8, 1 = 16 etc
	return pow(2, 3 + (int)bound(0, crosshairscale.integer, 5));
}

static void BuildBuiltinCrosshairs(void)
{
	int i;
	char str[256] = {0};
	int crosshair_size = CrosshairPixelSize();
	byte* crosshair_buffer = (byte*)Q_malloc(crosshair_size * crosshair_size);

	if (!(customcrosshair_loaded & CROSSHAIR_IMAGE)) {
		memset(&crosshairpic, 0, sizeof(crosshairpic));
	}
	for (i = 0; i < NUMCROSSHAIRS; i++) {
		snprintf(str, sizeof(str), "cross:hardcoded%d", i);
		CreateBuiltinCrosshair(crosshair_buffer, crosshair_size, i + 2);
		crosshairs_builtin[i].texnum = R_LoadTexture (str, crosshair_size, crosshair_size, crosshair_buffer, TEX_ALPHA, 1);
		crosshairs_builtin[i].sl = crosshairs_builtin[i].tl = 0;
		crosshairs_builtin[i].sh = crosshairs_builtin[i].th = 1;
		crosshairs_builtin[i].height = crosshairs_builtin[i].width = 16;

		renderer.TextureWrapModeClamp(crosshairs_builtin[i].texnum);
	}
	Q_free(crosshair_buffer);
	current_crosshair_pixel_size = crosshair_size;
	CachePics_MarkAtlasDirty();
}

void Draw_InitCrosshairs(void)
{
	char str[256] = {0};

	BuildBuiltinCrosshairs();
	customCrosshair_Init(); // safe re-init

	snprintf(str, sizeof(str), "%s", crosshairimage.string);
	Cvar_Set(&crosshairimage, str);
}

float overall_alpha = 1.0;

void Draw_SetOverallAlpha(float alpha)
{
	clamp(alpha, 0.0, 1.0);
	overall_alpha = alpha;
}

float Draw_MultiplyOverallAlpha(float alpha)
{
	float old = overall_alpha;

	overall_alpha *= alpha;

	return old;
}

void Draw_EnableScissorRectangle(float x, float y, float width, float height)
{
	float resdif_w = (glwidth / (float)vid.conwidth);
	float resdif_h = (glheight / (float)vid.conheight);

	R_EnableScissorTest(
		Q_rint(x * resdif_w),
		Q_rint((vid.conheight - (y + height)) * resdif_h),
		Q_rint(width * resdif_w),
		Q_rint(height * resdif_h)
	);
}

void Draw_EnableScissor(float left, float right, float top, float bottom)
{
	Draw_EnableScissorRectangle(left, top, (right - left), (bottom - top));
}

void Draw_DisableScissor(void)
{
	R_DisableScissorTest();
}

//=============================================================================
// Support Routines
wadpic_t wad_pictures[WADPIC_PIC_COUNT];

mpic_t *Draw_CacheWadPic(char *name, int code)
{
	qpic_t *p;
	mpic_t *pic, *pic_24bit;
	wadpic_t* wadpic = NULL;

	if (code >= 0 && code < WADPIC_PIC_COUNT) {
		wadpic = &wad_pictures[code];
	}

	p = W_GetLumpName (name);
	pic = (mpic_t *)p;
	if (wadpic) {
		strlcpy(wadpic->name, name, sizeof(wadpic->name));
		wadpic->pic = pic;
	}

	if ((pic_24bit = R_LoadPicImage(va("textures/wad/%s", name), name, 0, 0, TEX_ALPHA)) ||
		(pic_24bit = R_LoadPicImage(va("gfx/%s", name), name, 0, 0, TEX_ALPHA)))
	{
		// Only keep the size info from the lump. The other stuff is copied from the 24 bit image.
		pic->sh		= pic_24bit->sh;
		pic->sl		= pic_24bit->sl;
		pic->texnum = pic_24bit->texnum;
		pic->th		= pic_24bit->th;
		pic->tl		= pic_24bit->tl;

		if (code == WADPIC_SB_IBAR) {
			CachePics_LoadAmmoPics(pic);
		}

		return pic;
	}

	R_LoadPicTexture(name, pic, p->data);

	if (code == WADPIC_SB_IBAR) {
		CachePics_LoadAmmoPics(pic);
	}

	return pic;
}

//
// Loads an image into the cache.
// Variables:
//		crash - Crash the client if loading fails.
//		only24bit - Don't fall back to loading the normal 8-bit texture if
//					loading the 24-bit version fails.
//
mpic_t *Draw_CachePicSafe(const char *path, qbool crash, qbool only24bit)
{
	char stripped_path[MAX_PATH];
	char lmp_path[MAX_PATH];
	mpic_t *fpic;
	mpic_t *pic_24bit;
	qbool lmp_found = false;
	qpic_t *dat = NULL;
	vfsfile_t *v = NULL;

	// Check if the picture was already cached, if so inc refcount.
	if ((fpic = CachePic_Find(path, true))) {
		return fpic;
	}

	// Get the filename without extension.
	COM_StripExtension(path, stripped_path, sizeof(stripped_path));
	snprintf(lmp_path, MAX_PATH, "%s.lmp", stripped_path);

	// Try loading the pic from disk.

	// Only load the 24-bit version of the picture.
	if (only24bit) {
		if (!(pic_24bit = R_LoadPicImage(path, NULL, 0, 0, TEX_ALPHA))) {
			if(crash) {
				Sys_Error ("Draw_CachePicSafe: failed to load %s", path);
			}
			return NULL;
		}

		/* This will make a copy of the pic struct */
		return CachePic_Add(path, pic_24bit);
	}

	// Load the ".lmp" file.
	if ((v = FS_OpenVFS(lmp_path, "rb", FS_ANY))) {
		VFS_CLOSE(v);

		if (!(dat = (qpic_t *)FS_LoadTempFile(lmp_path, NULL))) {
			if(crash) {
				Sys_Error ("Draw_CachePicSafe: failed to load %s", lmp_path);
			}
			return NULL;
		}
		lmp_found = true;

		// Make sure the width and height are correct.
		SwapPic (dat);
	}

	// Try loading the 24-bit picture.
	// If that fails load the data for the lmp instead.
	if ((pic_24bit = R_LoadPicImage(path, NULL, 0, 0, TEX_ALPHA))) {
		// Only use the lmp-data if there was one.
		if (lmp_found) {
			pic_24bit->width = dat->width;
			pic_24bit->height = dat->height;
		}
		return CachePic_Add(path, pic_24bit);
	}
	else if (dat) {
		mpic_t tmp = {0};
		tmp.width = dat->width;
		tmp.height = dat->height;
		R_LoadPicTexture(path, &tmp, dat->data);
		return CachePic_Add(path, &tmp);
	}
	else {
		if(crash) {
			Sys_Error ("Draw_CachePicSafe: failed to load %s", path);
		}
		return NULL;
	}
}

static const char* cache_pic_paths[] = {
	"gfx/pause.lmp",
	"gfx/loading.lmp",
	"gfx/box_tl.lmp",
	"gfx/box_ml.lmp",
	"gfx/box_bl.lmp",
	"gfx/box_tm.lmp",
	"gfx/box_mm.lmp",
	"gfx/box_mm2.lmp",
	"gfx/box_bm.lmp",
	"gfx/box_tr.lmp",
	"gfx/box_mr.lmp",
	"gfx/box_br.lmp",
	"gfx/ttl_main.lmp",
	"gfx/mainmenu.lmp",
	"gfx/menudot1.lmp",
	"gfx/menudot2.lmp",
	"gfx/menudot3.lmp",
	"gfx/menudot4.lmp",
	"gfx/menudot5.lmp",
	"gfx/menudot6.lmp",
	"gfx/ttl_sgl.lmp",
	"gfx/qplaque.lmp",
	"gfx/sp_menu.lmp",
	"gfx/p_load.lmp",
	"gfx/p_save.lmp",
	"gfx/p_multi.lmp",
	"gfx/ranking.lmp",
	"gfx/complete.lmp",
	"gfx/inter.lmp",
	"gfx/finale.lmp"
};

qbool Draw_KeepOffAtlas(const char* path)
{
	int i;
	qbool result = false;

	// Tiled backgrounds: atlas not suitable for tiling, so keep off atlas
	for (i = CACHEPIC_BOX_TL; i <= CACHEPIC_BOX_BR && !result; ++i) {
		result |= !strcmp(path, cache_pic_paths[i]);
	}

	// Single-player & main menu items - take up too much space for no high-performance path
	for (i = CACHEPIC_TTL_MAIN; i <= CACHEPIC_P_MULTI && !result; ++i) {
		result |= !strcmp(path, cache_pic_paths[i]);
	}

	// Single-player intermission titles
	for (i = CACHEPIC_COMPLETE; i <= CACHEPIC_FINALE && !result; ++i) {
		result |= !strcmp(path, cache_pic_paths[i]);
	}

	R_TraceAPI("Draw_KeepOffAtlas(%s) = %s\n", path, result ? "true" : "false");
	return result;
}

mpic_t *Draw_CachePic(cache_pic_id_t id)
{
	if (id < 0 || id >= CACHEPIC_NUM_OF_PICS) {
		Sys_Error("Draw_CachePic(%d) - out of range", id);
	}

	return Draw_CachePicSafe(cache_pic_paths[id], true, false);
}

static void Draw_Precache(void)
{
	int i;
	for (i = 0; i < CACHEPIC_NUM_OF_PICS; ++i) {
		Draw_CachePic(i);
	}
}

void Draw_InitConback (void);

void Draw_Shutdown(void)
{
	W_FreeWadFile();
}

void Draw_Init (void)
{
	extern void HUD_Common_Reset_Group_Pics(void);
	extern void Draw_Charset_Init(void);

	Draw_Charset_Init();

	if (!host_initialized) {
		Cvar_SetCurrentGroup(CVAR_GROUP_CONSOLE);
		Cvar_Register(&scr_conalpha);
		Cvar_Register(&scr_conback);
		Cvar_Register(&scr_conpicture);
		Cvar_Register(&r_smoothtext);

		Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
		Cvar_Register(&scr_menualpha);
		Cvar_Register(&scr_menudrawhud);
		Cvar_Register(&r_smoothimages);
		Cvar_Register(&r_smoothalphahack);

		Cvar_SetCurrentGroup(CVAR_GROUP_CROSSHAIR);
		Cvar_Register(&crosshairimage);
		Cvar_Register(&crosshairalpha);
		Cvar_Register(&crosshairscale);
		Cvar_Register(&crosshairscalemethod);
		Cvar_Register(&r_smoothcrosshair);

		Cvar_ResetCurrentGroup();
	}

	draw_disc = draw_backtile = NULL;

	W_LoadWadFile("gfx.wad"); // Safe re-init.
	CachePics_Shutdown();
	HUD_Common_Reset_Group_Pics();

	R_Texture_Init();  // Probably safe to re-init now.

	// Clear the scrap, should be called ASAP after textures initialization
	CachePics_Init();

	// Load the console background and the charset by hand, because we need to write the version
	// string into the background before turning it into a texture.
	Draw_InitCharset(); // Safe re-init.
	Draw_InitConback(); // Safe re-init.

	// Load the crosshair pics
	Draw_InitCrosshairs();

	// Get the other pics we need.
	draw_disc     = Draw_CacheWadPic("disc", WADPIC_DISC);
	draw_backtile = Draw_CacheWadPic("backtile", WADPIC_BACKTILE);

	Draw_Precache();
}

qbool CL_MultiviewGetCrosshairCoordinates(qbool use_screen_coords, float* cross_x, float* cross_y, qbool* half_size);

void Draw_Crosshair (void)
{
	float x = 0.0, y = 0.0, ofs1, ofs2, sh, th, sl, tl;
	byte col[4];
	extern vrect_t scr_vrect;
	float crosshair_scale = (crosshairscalemethod.integer ? 1 : ((float)glwidth / 320));
	int crosshair_pixel_size = CrosshairPixelSize();
	qbool half_size = false;

	if (current_crosshair_pixel_size != crosshair_pixel_size) {
		BuildBuiltinCrosshairs();
	}

	if ((crosshair.value >= 2 && crosshair.value <= NUMCROSSHAIRS + 1) ||
		((customcrosshair_loaded & CROSSHAIR_TXT) && crosshair.value == 1) ||
		(customcrosshair_loaded & CROSSHAIR_IMAGE)) {
		texture_ref texnum;
		int width2d = VID_RenderWidth2D();
		int height2d = VID_RenderHeight2D();

		if (!crosshairalpha.value) {
			return;
		}

		if (!CL_MultiviewGetCrosshairCoordinates(true, &x, &y, &half_size)) {
			return;
		}

		R_OrthographicProjection(0, width2d, height2d, 0, -99999, 99999);

		x += (crosshairscalemethod.integer ? 1 : (float)width2d / vid.width) * cl_crossx.value;
		y += (crosshairscalemethod.integer ? 1 : (float)height2d / vid.height) * cl_crossy.value;

		col[0] = crosshaircolor.color[0];
		col[1] = crosshaircolor.color[1];
		col[2] = crosshaircolor.color[2];
		col[3] = bound(0, crosshairalpha.value, 1) * 255;

		if (customcrosshair_loaded & CROSSHAIR_IMAGE) {
			texnum = crosshairpic.texnum;
			ofs1 = (crosshairpic.width * 0.5f - 0.5f) * bound(0, crosshairsize.value, 20);
			ofs2 = (crosshairpic.height * 0.5f + 0.5f) * bound(0, crosshairsize.value, 20);

			sh = crosshairpic.sh;
			sl = crosshairpic.sl;
			th = crosshairpic.th;
			tl = crosshairpic.tl;
		}
		else {
			mpic_t* pic = ((crosshair.value >= 2) ? &crosshairs_builtin[(int)crosshair.value - 2] : &crosshairtexture_txt);

			texnum = pic->texnum;
			ofs1 = (crosshair_pixel_size * 0.5f - 0.5f) * crosshair_scale * bound(0, crosshairsize.value, 20);
			ofs2 = (crosshair_pixel_size * 0.5f + 0.5f) * crosshair_scale * bound(0, crosshairsize.value, 20);

			sh = pic->sh;
			sl = pic->sl;
			th = pic->th;
			tl = pic->tl;
		}

		if (half_size) {
			ofs1 *= 0.5f;
			ofs2 *= 0.5f;
		}

		R_DrawImage(x - ofs1, y - ofs1, ofs1 + ofs2, ofs1 + ofs2, sl, tl, sh - sl, th - tl, col, false, texnum, false, true);

		R_OrthographicProjection(0, vid.width, vid.height, 0, -99999, 99999);
	}
	else if (crosshair.value) {
		// Multiview
		Draw_SetCrosshairTextMode(true);
		if (CL_MultiviewInsetEnabled()) {
			if (CL_MultiviewInsetView()) {
				int width2d = VID_RenderWidth2D();
				int height2d = VID_RenderHeight2D();

				if (!CL_MultiviewGetCrosshairCoordinates(true, &x, &y, &half_size)) {
					return;
				}

				// convert from 3d to 2d
				x = (x * vid.width) / width2d;
				y = (y * vid.height) / height2d;

				// x = vid.width - (vid.width / 3) / 2 - 4
				// y = (vid.height / 3) / 2 - 2,
				Draw_Character(x - 4, y - 4, '+');
			}
			else {
				Draw_Character(scr_vrect.x + scr_vrect.width / 2 - 4 + cl_crossx.value, scr_vrect.y + scr_vrect.height / 2 - 4 + cl_crossy.value, '+');
			}
		}
		else if (CL_MultiviewActiveViews() == 2) {
			Draw_Character(vid.width / 2 - 4, vid.height * 3 / 4 - 2, '+');
			Draw_Character(vid.width / 2 - 4, vid.height / 4 - 2, '+');
		}
		else if (CL_MultiviewActiveViews() == 3) {
			Draw_Character(vid.width / 2 - 4, vid.height / 4 - 2, '+');
			Draw_Character(vid.width / 4 - 4, vid.height / 2 + vid.height / 4 - 2, '+');
			Draw_Character(vid.width / 2 + vid.width / 4 - 4, vid.height / 2 + vid.height / 4 - 2, '+');
		}
		else if (CL_MultiviewActiveViews() == 4) {
			Draw_Character(vid.width / 4 - 4, vid.height / 4 - 2, '+');
			Draw_Character(vid.width / 2 + vid.width / 4 - 4, vid.height / 4 - 2, '+');
			Draw_Character(vid.width / 4 - 4, vid.height / 2 + vid.height / 4 - 2, '+');
			Draw_Character(vid.width / 2 + vid.width / 4 - 4, vid.height / 2 + vid.height / 4 - 2, '+');
		}
		else {
			Draw_Character(scr_vrect.x + scr_vrect.width / 2 - 4 + cl_crossx.value, scr_vrect.y + scr_vrect.height / 2 - 4 + cl_crossy.value, '+');
		}
		Draw_SetCrosshairTextMode(false);
	}
}

void Draw_TextBox(float x, float y, int width, int lines)
{
	mpic_t *p;
	int cx, cy, n;

	// draw left side
	cx = x;
	cy = y;
	p = Draw_CachePic (CACHEPIC_BOX_TL);
	Draw_TransPic (cx, cy, p);
	p = Draw_CachePic (CACHEPIC_BOX_ML);
	for (n = 0; n < lines; n++)
	{
		cy += 8;
		Draw_TransPic (cx, cy, p);
	}

	p = Draw_CachePic (CACHEPIC_BOX_BL);
	Draw_TransPic (cx, cy+8, p);

	// Draw middle.
	cx += 8;
	while (width > 0)
	{
		cy = y;
		p = Draw_CachePic (CACHEPIC_BOX_TM);
		Draw_TransPic (cx, cy, p);
		p = Draw_CachePic (CACHEPIC_BOX_MM);

		for (n = 0; n < lines; n++)
		{
			cy += 8;
			if (n == 1)
				p = Draw_CachePic (CACHEPIC_BOX_MM2);
			Draw_TransPic (cx, cy, p);
		}

		p = Draw_CachePic (CACHEPIC_BOX_BM);
		Draw_TransPic (cx, cy+8, p);
		width -= 2;
		cx += 16;
	}

	// Draw right side.
	cy = y;
	p = Draw_CachePic (CACHEPIC_BOX_TR);
	Draw_TransPic (cx, cy, p);
	p = Draw_CachePic (CACHEPIC_BOX_MR);

	for (n = 0; n < lines; n++)
	{
		cy += 8;
		Draw_TransPic (cx, cy, p);
	}

	p = Draw_CachePic (CACHEPIC_BOX_BR);
	Draw_TransPic (cx, cy+8, p);
}

// This repeats a 64 * 64 tile graphic to fill the screen around a sized down refresh window.
void Draw_TileClear(int x, int y, int w, int h)
{
	byte white[4] = { 255, 255, 255, 255 };

	R_DrawImage(x, y, w, h, x / 64.0, y / 64.0, w / 64.0, h / 64.0, white, false, draw_backtile->texnum, false, false);
}

void Draw_AlphaRectangleRGB(float x, float y, float w, float h, float thickness, qbool fill, color_t color)
{
	byte bytecolor[4];

	// Is alpha 0?
	if ((byte)(color >> 24 & 0xFF) == 0) {
		return;
	}

	COLOR_TO_RGBA(color, bytecolor);
	thickness = max(0, thickness);

	R_DrawAlphaRectangleRGB(x, y, w, h, thickness, fill, bytecolor);
}

void Draw_AlphaRectangle (int x, int y, int w, int h, byte c, float thickness, qbool fill, float alpha)
{
	Draw_AlphaRectangleRGB(x, y, w, h, thickness, fill,
		RGBA_TO_COLOR(host_basepal[c * 3], host_basepal[c * 3 + 1], host_basepal[c * 3 + 2], (byte)(alpha * 255)));
}

void Draw_AlphaFillRGB(float x, float y, float w, float h, color_t color)
{
	Draw_AlphaRectangleRGB(x, y, w, h, 1, true, color);
}

void Draw_AlphaFill(float x, float y, float w, float h, byte c, float alpha)
{
	Draw_AlphaRectangle(x, y, w, h, c, 1, true, alpha);
}

void Draw_Fill (int x, int y, int w, int h, byte c)
{
	Draw_AlphaFill(x, y, w, h, c, 1);
}

void Draw_AlphaLineRGB (float x_start, float y_start, float x_end, float y_end, float thickness, color_t color)
{
	byte bytecolor[4];

	COLOR_TO_RGBA_PREMULT(color, bytecolor);

	R_Draw_LineRGB(thickness, bytecolor, x_start, y_start, x_end, y_end);
}

void Draw_AlphaLine (float x_start, float y_start, float x_end, float y_end, float thickness, byte c, float alpha)
{
	Draw_AlphaLineRGB (x_start, y_start, x_end, y_end, thickness,
		RGBA_TO_COLOR(host_basepal[c * 3], host_basepal[c * 3 + 1], host_basepal[c * 3 + 2], 255));
}

void Draw_Polygon(int x, int y, vec3_t *vertices, int num_vertices, color_t color)
{
	R_Draw_Polygon(x, y, vertices, num_vertices, color);
}

static void Draw_AlphaPieSliceRGB (int x, int y, float radius, float startangle, float endangle, float thickness, qbool fill, color_t color)
{
	R_Draw_AlphaPieSliceRGB(x, y, radius, startangle, endangle, thickness, fill, color);
}

void Draw_AlphaPieSlice (int x, int y, float radius, float startangle, float endangle, float thickness, qbool fill, byte c, float alpha)
{
	Draw_AlphaPieSliceRGB (x, y, radius, startangle, endangle, thickness, fill,
		RGBA_TO_COLOR(host_basepal[c * 3], host_basepal[c * 3 + 1], host_basepal[c * 3 + 2], (byte)Q_rint(255 * alpha)));
}

void Draw_AlphaCircleRGB(float x, float y, float radius, float thickness, qbool fill, color_t color)
{
	Draw_AlphaPieSliceRGB (x, y, radius, 0, 2 * M_PI, thickness, fill, color);
}

void Draw_AlphaCircle(float x, float y, float radius, float thickness, qbool fill, byte c, float alpha)
{
	Draw_AlphaPieSlice (x, y, radius, 0, 2 * M_PI, thickness, fill, c, alpha);
}

void Draw_AlphaCircleOutlineRGB(float x, float y, float radius, float thickness, color_t color)
{
	Draw_AlphaCircleRGB(x, y, radius, thickness, false, color);
}

void Draw_AlphaCircleOutline(float x, float y, float radius, float thickness, byte color, float alpha)
{
	Draw_AlphaCircle(x, y, radius, thickness, false, color, alpha);
}

void Draw_AlphaCircleFillRGB(float x, float y, float radius, color_t color)
{
	Draw_AlphaCircleRGB(x, y, radius, 1.0, true, color);
}

void Draw_AlphaCircleFill(float x, float y, float radius, byte color, float alpha)
{
	Draw_AlphaCircle(x, y, radius, 1.0, true, color, alpha);
}

//
// SCALE versions of some functions
//

//=============================================================================
// Draw picture functions
//=============================================================================
void Draw_SAlphaSubPic2(float x, float y, mpic_t *pic, int src_x, int src_y, int src_width, int src_height, float scale_x, float scale_y, float alpha)
{
	float newsl, newtl, newsh, newth;
    float oldglwidth, oldglheight;

    oldglwidth = pic->sh - pic->sl;
    oldglheight = pic->th - pic->tl;

    newsl = pic->sl + (src_x * oldglwidth) / (float)pic->width;
    newsh = newsl + (src_width * oldglwidth) / (float)pic->width;

    newtl = pic->tl + (src_y * oldglheight) / (float)pic->height;
    newth = newtl + (src_height * oldglheight) / (float)pic->height;

	alpha *= overall_alpha;

	R_Draw_SAlphaSubPic2(x, y, pic, src_width, src_height, newsl, newtl, newsh, newth, scale_x, scale_y, alpha);
}

void Draw_SAlphaSubPic(float x, float y, mpic_t *pic, int src_x, int src_y, int src_width, int src_height, float scale, float alpha)
{
	Draw_SAlphaSubPic2(x, y, pic, src_x, src_y, src_width, src_height, scale, scale, alpha);
}

void Draw_SSubPic(float x, float y, mpic_t *gl, int srcx, int srcy, int width, int height, float scale)
{
	Draw_SAlphaSubPic(x, y, gl, srcx, srcy, width, height, scale, 1);
}

void Draw_AlphaSubPic(float x, float y, mpic_t *pic, int srcx, int srcy, int width, int height, float alpha)
{
	Draw_SAlphaSubPic(x, y, pic, srcx, srcy, width, height, 1, alpha);
}

void Draw_SubPic(float x, float y, mpic_t *pic, int srcx, int srcy, int width, int height)
{
	Draw_SAlphaSubPic(x, y, pic, srcx, srcy, width, height, 1, 1);
}

void Draw_AlphaPic(float x, float y, mpic_t *pic, float alpha)
{
	Draw_SAlphaSubPic(x , y, pic, 0, 0, pic->width, pic->height, 1, alpha);
}

void Draw_SAlphaPic(float x, float y, mpic_t *gl, float alpha, float scale)
{
	Draw_SAlphaSubPic(x ,y , gl, 0, 0, gl->width, gl->height, scale, alpha);
}

void Draw_SPic(float x, float y, mpic_t *gl, float scale)
{
	Draw_SAlphaSubPic (x, y, gl, 0, 0, gl->width, gl->height, scale, 1.0);
}

void Draw_FitPic(float x, float y, int fit_width, int fit_height, mpic_t *gl)
{
    float sw, sh;
    sw = (float) fit_width / (float) gl->width;
    sh = (float) fit_height / (float) gl->height;
    Draw_SPic(x, y, gl, min(sw, sh));
}

void Draw_FitPicAlpha(float x, float y, int fit_width, int fit_height, mpic_t *gl, float alpha)
{
	float sw, sh;
	sw = (float) fit_width / (float) gl->width;
	sh = (float) fit_height / (float) gl->height;
	Draw_SAlphaPic(x, y, gl, alpha, min(sw, sh));
}

void Draw_FitPicAlphaCenter(float x, float y, int fit_width, int fit_height, mpic_t* gl, float alpha)
{
	float sw, sh, scale;
	sw = (float)fit_width / (float)gl->width;
	sh = (float)fit_height / (float)gl->height;
	scale = min(sw, sh);
	Draw_SAlphaPic(x + (fit_width - scale * gl->width) / 2.0f, y + (fit_height - scale * gl->height) / 2.0f, gl, alpha, scale);
}

void Draw_STransPic(float x, float y, mpic_t *pic, float scale)
{
    Draw_SPic(x, y, pic, scale);
}

void Draw_Pic(float x, float y, mpic_t *pic)
{
	Draw_SAlphaSubPic(x, y, pic, 0, 0, pic->width, pic->height, 1, 1);
}

void Draw_TransPic(float x, float y, mpic_t *pic)
{
	Draw_Pic(x, y, pic);
}

static char last_mapname[MAX_QPATH] = {0};
static mpic_t *last_lvlshot = NULL;

// If conwidth or conheight changes, adjust conback sizes too.
void Draw_AdjustConback(void)
{
	conback.width  = vid.conwidth;
	conback.height = vid.conheight;

	if (last_lvlshot) {
		// Resize.
		last_lvlshot->width = conback.width;
		last_lvlshot->height = conback.height;
	}
}

static void Draw_DeleteOldLevelshot(mpic_t* pic)
{
	if (pic && R_TextureReferenceIsValid(pic->texnum)) {
		R_DeleteTexture(&pic->texnum);
		if (!CachePic_RemoveByPic(pic)) {
			R_TextureReferenceInvalidate(pic->texnum);
		}
	}
}

void Draw_ClearConback(void)
{
	last_lvlshot = NULL;
	last_mapname[0] = 0;
}

void Draw_InitConback(void)
{
	qpic_t *cb;
	mpic_t *pic_24bit;

	// Level shots init. It's cache based so don't free!
	// Expect the cache to be wiped thus render the old data invalid
	Draw_DeleteOldLevelshot(last_lvlshot);
	Draw_ClearConback();

	if (!glConfig.initialized) {
		return;
	}

	if (!(cb = (qpic_t *)FS_LoadHeapFile("gfx/conback.lmp", NULL))) {
		Sys_Error("Couldn't load gfx/conback.lmp");
		return;
	}
	SwapPic (cb);

	if (cb->width != 320 || cb->height != 200) {
		Sys_Error("Draw_InitConback: conback.lmp size is not 320x200");
	}

	if ((pic_24bit = R_LoadPicImage(va("gfx/%s", scr_conpicture.string), "conback", 0, 0, TEX_ALPHA))) {
		Draw_CopyMPICKeepSize(&conback, pic_24bit);
	}
	else {
		conback.width = cb->width;
		conback.height = cb->height;
		R_LoadPicTexture("conback", &conback, cb->data);
	}

	Draw_AdjustConback();

	// Free loaded console.
	Q_free(cb);
}

void Draw_ConsoleBackground(int lines)
{
	mpic_t *lvlshot = NULL;
	float alpha = (SCR_NEED_CONSOLE_BACKGROUND ? 1 : bound(0, scr_conalpha.value, 1)) * overall_alpha;

	if (host_mapname.string[0]											// We have mapname.
		 && (    scr_conback.value == 2									// Always per level conback.
			 || (scr_conback.value == 1 && SCR_NEED_CONSOLE_BACKGROUND) // Only at load time.
			))
	{
		// Here we limit call Draw_CachePicSafe() once per level,
		// because if image not found Draw_CachePicSafe() will try open image again each frame, that cause HDD lag.
		if (strncmp(host_mapname.string, last_mapname, sizeof(last_mapname))) {
			char name[MAX_QPATH];
			mpic_t* old_levelshot = last_lvlshot;

			snprintf(name, sizeof(name), "textures/levelshots/%s.xxx", host_mapname.string);
			if ((last_lvlshot = Draw_CachePicSafe(name, false, true))) {
				// Resize.
				last_lvlshot->width  = conback.width;
				last_lvlshot->height = conback.height;
			}
			if (last_lvlshot != old_levelshot) {
				Draw_DeleteOldLevelshot(old_levelshot);
			}

			strlcpy(last_mapname, host_mapname.string, sizeof(last_mapname)); // Save.
		}

		lvlshot = last_lvlshot;
	}

	if (alpha) {
		int con_shift_value = cls.state == ca_active ? con_shift.value : 0;

		Draw_AlphaPic(0, (lines - vid.height) + con_shift_value, lvlshot ? lvlshot : &conback, alpha);
	}
}

void Draw_FadeScreen(float alpha)
{
	alpha = bound(0, alpha, 1) * overall_alpha;
	if (!alpha) {
		return;
	}

	R_Draw_FadeScreen(alpha);

	Sbar_Changed();
}

//=============================================================================
// Draws the little blue disc in the corner of the screen.
// Call before beginning any disc IO.
void Draw_BeginDisc (void)
{
	extern cvar_t r_drawdisc;

	if (!draw_disc || !r_drawdisc.integer) {
		return;
	}

	// Intel cards, most notably Intel 915GM/910GML has problems with
	// writing directly to the front buffer and then flipping the back buffer,
	// so don't draw the I/O disc on those cards, it will cause the console
	// to flicker.
	//
	// From Intels dev network:
	// "Using two dimensional data within a 3D scene is sometimes used to render
	// objects like scoreboards and road signs. When that blit request is sent 
	// to or from a buffer, the data contained within must be updated, causing 
	// a pipeline flush and disabling Zone Rendering. One easy way to generate 
	// the same effect is to use a quad or a billboard that is aligned to the 
	// view frustrum. Similarly, a flip operation while rendering to a back buffer 
	// will cause serialization. Be sure you are done altering the back buffer
	// before you flip.
#ifndef __APPLE__
	if (glConfig.hardwareType == GLHW_INTEL) {
		return;
	}
#endif

	renderer.DrawDisc();
}

// Erases the disc icon.
// Call after completing any disc IO
void Draw_EndDisc(void)
{
}

//
// Changes the projection to orthogonal (2D drawing).
//
void R_Set2D(void)
{
	renderer.Begin2DRendering();
	R_IdentityModelView();
	R_OrthographicProjection(0, vid.width, vid.height, 0, -99999, 99999);
	R_TraceResetRegion(false);
}

void Draw_2dAlphaTexture(float x, float y, float width, float height, texture_ref texture_num, float alpha)
{
	mpic_t pic;

	pic.height = height;
	pic.width = width;
	pic.th = 1;
	pic.tl = 0;
	pic.sh = 1;
	pic.sl = 0;
	pic.texnum = texture_num;

	Draw_AlphaPic(x, y, &pic, alpha);
}

qbool Draw_IsConsoleBackground(mpic_t* pic)
{
	return pic == &conback || pic == last_lvlshot;
}


================================================
FILE: src/r_draw.h
================================================

#ifndef EZQUAKE_R_DRAW_HEADER
#define EZQUAKE_R_DRAW_HEADER

void R_Draw_SAlphaSubPic2(float x, float y, mpic_t *pic, int src_width, int src_height, float newsl, float newtl, float newsh, float newth, float scale_x, float scale_y, float alpha);
void R_Draw_AlphaPieSliceRGB(float x, float y, float radius, float startangle, float endangle, float thickness, qbool fill, color_t color);
void R_Draw_LineRGB(float thickness, byte* color, float x_start, float y_start, float x_end, float y_end);
void R_DrawImage(float x, float y, float width, float height, float tex_s, float tex_t, float tex_width, float tex_height, byte* color, qbool alpha_test, texture_ref texnum, qbool isText, qbool isCrosshair);
void R_DrawAlphaRectangleRGB(int x, int y, int w, int h, float thickness, qbool fill, byte* bytecolor);
void R_Draw_FadeScreen(float alpha);
float R_Draw_CharacterBase(float x, float y, wchar num, float scale, qbool apply_overall_alpha, qbool bigchar, qbool gl_statechange, qbool proportional);
void R_Draw_ResetCharGLState(void);
void R_Draw_SetColor(byte* rgba);
void R_Draw_StringBase_StartString(float x, float y, float scale);
void R_Cache2DMatrix(void);
void R_UndoLastCharacter(void);
void R_Draw_Polygon(float x, float y, vec3_t *vertices, int num_vertices, color_t color);

#endif // EZQUAKE_R_DRAW_HEADER


================================================
FILE: src/r_draw_charset.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: gl_draw.c,v 1.104 2007-10-18 05:28:23 dkure Exp $
*/

#include "quakedef.h"
#include "gl_model.h"
#include "wad.h"
#include "stats_grid.h"
#include "utils.h"
#include "sbar.h"
#include "common_draw.h"
#include "fonts.h"
#include "r_texture.h"
#include "r_draw.h"
#include "r_trace.h"

static void OnChange_gl_consolefont(cvar_t *, char *, qbool *);
void Draw_InitFont(void);

cvar_t gl_alphafont    = { "gl_alphafont", "1" };
cvar_t gl_consolefont  = { "gl_consolefont", "povo5", CVAR_AUTO, OnChange_gl_consolefont };
cvar_t scr_coloredText = { "scr_coloredText", "1" };
cvar_t gl_charsets_min = { "gl_charsets_min", "1" };

static byte *draw_chars; // 8*8 graphic characters

charset_t char_textures[MAX_CHARSETS];
int char_mapping[256]; // need to expand in future...

static byte cache_currentColor[4];
static qbool nextCharacterIsCrosshair = false;

static const byte color_white[4] = { 255, 255, 255, 255 };

/*
* Load_LMP_Charset
*/
static qbool Load_LMP_Charset(char *name, int flags, charset_t* charset)
{
	int i;
	byte	buf[256 * 256];
	byte	*data;
	byte	*src, *dest;
	int filesize;
	texture_ref tex;

	// We expect an .lmp to be in QPIC format, but it's ok if it's just raw data.
	if (!strcasecmp(name, "charset")) {
		// work around for original charset
		data = draw_chars;
		filesize = 128 * 128;
	}
	else {
		data = FS_LoadTempFile(va("gfx/%s.lmp", name), &filesize);
	}

	if (!data)
		return 0;

	if (filesize == 128 * 128) {
		// Raw data.
	}
	else if (filesize == 128 * 128 + 8) {
		qpic_t *p = (qpic_t *)data;
		SwapPic(p);
		if (p->width != 128 || p->height != 128)
			return 0;
		data += 8;
	}
	else {
		return 0;
	}

	for (i = 0; i < (256 * 64); i++) {
		if (data[i] == 0) {
			data[i] = 255;	// Proper transparent color.
		}
	}

	// Convert the 128*128 conchars texture to 256*256 leaving
	// empty space between rows so that chars don't stumble on
	// each other because of texture smoothing.
	memset(buf, 255, sizeof(buf));
	src = data;
	dest = buf;

	for (i = 0; i < 128; i++) {
		int j;

		if (i % 8 == 0 && i) {
			dest += 256 * 8;
		}
		for (j = 0; j < 16; ++j) {
			memcpy(dest, src, 8);
			src += 8;
			dest += 8 * 2;
		}
	}

	tex = R_LoadTexture(va("pic:%s", name), 256, 256, buf, flags, 1);
	if (R_TextureReferenceIsValid(tex)) {
		for (i = 0; i < 256; ++i) {
			charset->glyphs[i].texnum = tex;
			charset->glyphs[i].width = 128 / 16;
			charset->glyphs[i].height = 128 / 16;
			charset->glyphs[i].sl = 2 * (i & 0x0F) * (1.0f / 32);
			charset->glyphs[i].sh = charset->glyphs[i].sl + 8.0f / 256;
			charset->glyphs[i].tl = 2 * (i / 0x10) * (1.0f / 32);
			charset->glyphs[i].th = charset->glyphs[i].tl + 8.0f / 256;
		}

		charset->master = tex;
		charset->custom_scale_x = charset->custom_scale_y = 1;

		return true;
	}
	return false;
}

/*
* Load_Locale_Charset
*/
static qbool Load_Locale_Charset(const char *name, const char *locale, unsigned int num, int flags)
{
	char texture[1024], id[256], lmp[256], basename[MAX_QPATH];

	if (num >= MAX_CHARSETS) {
		return 0;
	}

	R_TraceEnterFunctionRegion;
	memset(&char_textures[num], 0, sizeof(char_textures[num]));

	COM_StripExtension(name, basename, sizeof(basename));
	snprintf(texture, sizeof(texture), "textures/charsets/%s-%s", basename, locale);
	snprintf(id, sizeof(id), "pic:charset-%s", locale);
	snprintf(lmp, sizeof(lmp), "conchars-%s", locale);

	// try first 24 bit, then 8 bit
	char_mapping[num] = 0;
	if (R_LoadCharsetImage(texture, id, flags, &char_textures[num])) {
		char_mapping[num] = num;
	}
	else if (Load_LMP_Charset(lmp, flags, &char_textures[num])) {
		char_mapping[num] = num;
	}
	R_TraceLeaveFunctionRegion;

	return char_mapping[num];
}

static int Draw_LoadCharset(const char *name)
{
	int flags = TEX_ALPHA | TEX_NOCOMPRESS | TEX_NOSCALE | TEX_NO_TEXTUREMODE;
	int i = 0;
	qbool loaded = false;

	//
	// NOTE: we trying to not change char_textures[0] if we can't load charset.
	//		This way user still have some charset and can fix issue.
	//
	if (!strcasecmp(name, "original")) {
		loaded = Load_LMP_Charset("charset", flags, &char_textures[0]);
	}
	else {
		loaded = R_LoadCharsetImage(va("textures/charsets/%s", name), "pic:charset", flags, &char_textures[0]);
	}

	if (!loaded) {
		Com_Printf("Couldn't load charset \"%s\"\n", name);
		return 1;
	}

	// Load alternate charsets if available
	if (gl_charsets_min.integer) {
		Load_Locale_Charset(name, "cyr", 4, flags);
	}
	else {
		for (i = 1; i < MAX_USER_CHARSETS; ++i) {
			char charsetName[10];

			snprintf(charsetName, sizeof(charsetName), "%03d", i);

			loaded = Load_Locale_Charset(name, charsetName, i, flags);

			// 2.2 only supported -cyr suffix
			if (i == 4 && !loaded) {
				Load_Locale_Charset(name, "cyr", 4, flags);
			}
		}
	}

	CachePics_MarkAtlasDirty();

	return 0;
}

static void OnChange_gl_consolefont(cvar_t *var, char *string, qbool *cancel)
{
	*cancel = Draw_LoadCharset(string);
}

static void Draw_LoadCharset_f(void)
{
	switch (Cmd_Argc()) {
	case 1:
		Com_Printf("Current charset is \"%s\"\n", gl_consolefont.string);
		break;
	case 2:
		Cvar_Set(&gl_consolefont, Cmd_Argv(1));
		break;
	default:
		Com_Printf("Usage: %s <charset>\n", Cmd_Argv(0));
	}
}

// Called when textencoding, if we can't display a font it can replace with alternative
qbool R_CharAvailable(wchar num)
{
	if (num == (num & 0xff)) {
		return true;
	}

	return (char_mapping[(num >> 8) & 0xff]);
}

// x, y					= Pixel position of char.
// num					= The character to draw.
// scale				= The scale of the character.
// apply_overall_alpha	= Should the overall alpha for all drawing apply to this char?
// color				= Color!
// bigchar				= Draw this char using the big character charset.
// gl_statechange		= Change the gl state before drawing?
static float Draw_CharacterBaseW(float x, float y, wchar num, float scale, qbool apply_overall_alpha, qbool bigchar, qbool gl_statechange, qbool proportional)
{
	int original_x = x;

	if (FontAlterCharCoordsWide(&x, &y, num, bigchar, scale, proportional)) {
		return R_Draw_CharacterBase(x, y, num, scale, apply_overall_alpha, bigchar, gl_statechange, proportional);
	}
	return x - original_x;
}

static void Draw_ResetCharGLState(void)
{
	R_Draw_ResetCharGLState();
}

void Draw_SCharacter(float x, float y, int num, float scale)
{
	Draw_CharacterBaseW(x, y, char2wc(num), scale, true, false, true, false);
	Draw_ResetCharGLState();
}

float Draw_SCharacterP(float x, float y, int num, float scale, qbool proportional)
{
	float new_x = Draw_CharacterBaseW(x, y, char2wc(num), scale, true, false, true, proportional);
	Draw_ResetCharGLState();
	return new_x;
}

float Draw_CharacterWSP(float x, float y, wchar num, float scale, qbool proportional)
{
	float new_x = Draw_CharacterBaseW(x, y, num, scale, true, false, true, proportional);
	Draw_ResetCharGLState();
	return new_x;
}

void Draw_CharacterW(float x, float y, wchar num)
{
	Draw_CharacterBaseW(x, y, num, 1, true, false, true, false);
	Draw_ResetCharGLState();
}

void Draw_Character(float x, float y, int num)
{
	Draw_CharacterBaseW(x, y, char2wc(num), 1, true, false, true, false);
	Draw_ResetCharGLState();
}

void Draw_SetColor(byte *rgba)
{
	R_Draw_SetColor(rgba);
}

static float Draw_StringBase(float x, float y, const char *text, clrinfo_t *color, int color_count, int red, float scale, float alpha, qbool bigchar, int char_gap, qbool proportional, float max_x)
{
	byte rgba[4];
	qbool color_is_white = true;
	int i, r, g, b;
	int curr_char;
	int color_index = 0;
	color_t last_color = COLOR_WHITE;
	float original_x = x;
	float char_width = 0;

	// Nothing to draw.
	if (!*text) {
		return 0;
	}

	// Make sure we set the color from scratch so that the 
	// overall opacity is applied properly.
	rgba[0] = rgba[1] = rgba[2] = rgba[3] = 255;
	if (scr_coloredText.integer && color_count > 0) {
		COLOR_TO_RGBA(color[0].c, rgba);
	}

	// Draw the string.
	R_Draw_StringBase_StartString(x, y, scale);
	for (i = 0; text[i]; i++) {
		// If we didn't get a color array, check for color codes in the text instead.
		if (!color) {
			if (text[i] == '&') {
				if (text[i + 1] == 'c' && text[i + 2] && text[i + 3] && text[i + 4]) {
					r = HexToInt(text[i + 2]);
					g = HexToInt(text[i + 3]);
					b = HexToInt(text[i + 4]);

					if (r >= 0 && g >= 0 && b >= 0) {
						if (scr_coloredText.value) {
							rgba[0] = (r * 16);
							rgba[1] = (g * 16);
							rgba[2] = (b * 16);
							rgba[3] = 255;
							color_is_white = false;
						}

						color_count++; // Keep track on how many colors we're using.

						rgba[3] = 255 * alpha;
						Draw_SetColor(rgba);

						i += 4;
						continue;
					}
				}
				else if (text[i + 1] == 'r') {
					if (!color_is_white) {
						rgba[0] = rgba[1] = rgba[2] = 255;
						rgba[3] = 255 * alpha;
						color_is_white = true;
						Draw_SetColor(rgba);
					}

					i++;
					continue;
				}
			}
		}
		else if (scr_coloredText.value && (color_index < color_count) && (i == color[color_index].i)) {
			// Change color if the color array tells us this index should have a new color.

			// Set the new color if it's not the same as the last.
			if (color[color_index].c != last_color) {
				last_color = color[color_index].c;
				COLOR_TO_RGBA(color[color_index].c, rgba);
				rgba[3] = 255 * alpha;
				Draw_SetColor(rgba);
			}

			color_index++; // Goto next color.
		}
		curr_char = (unsigned char)text[i];

		// Do not convert the character to red if we're applying color to the text.
		if (red && color_count <= 0) {
			curr_char |= 128;
		}

		// Draw the character but don't apply overall opacity, we've already done that
		// And don't update the glstate, we've done that also!
		char_width = Draw_CharacterBaseW(x, y, curr_char, scale, false, bigchar, false, proportional);

		if (max_x && x + char_width > max_x) {
			R_UndoLastCharacter();
			break;
		}

		x += char_width;
	}
	Draw_ResetCharGLState();
	return ceil(x - original_x);
}

void Draw_BigString(float x, float y, const char *text, clrinfo_t *color, int color_count, float scale, float alpha, int char_gap)
{
	Draw_StringBase(x, y, text, color, color_count, false, scale, alpha, true, char_gap, false, 0);
}

float Draw_SColoredAlphaString(float x, float y, const char *text, clrinfo_t *color, int color_count, int red, float scale, float alpha, qbool proportional)
{
	return Draw_StringBase(x, y, text, color, color_count, red, scale, alpha, false, 0, proportional, 0);
}

void Draw_SColoredStringAligned(int x, int y, const char *text, clrinfo_t* color, int color_count, float scale, float alpha, qbool proportional, text_alignment_t align, float max_x)
{
	int initial_position, final_position;
	float width;

	initial_position = Draw_ImagePosition();
	width = Draw_StringBase(x, y, text, color, color_count, false, scale, alpha, false, 0, proportional, max_x);
	final_position = Draw_ImagePosition();

	if (align == text_align_center) {
		Draw_AdjustImages(initial_position, final_position, (max_x - x - width) / 2);
	}
	else if (align == text_align_right) {
		Draw_AdjustImages(initial_position, final_position, max_x - x - width);
	}
}

void Draw_SStringAligned(int x, int y, const char *text, float scale, float alpha, qbool proportional, text_alignment_t align, float max_x)
{
	int initial_position, final_position;
	float width;

	initial_position = Draw_ImagePosition();
	width = Draw_StringBase(x, y, text, NULL, 0, false, scale, alpha, false, 0, proportional, max_x);
	final_position = Draw_ImagePosition();

	if (align == text_align_center) {
		Draw_AdjustImages(initial_position, final_position, (max_x - x - width) / 2);
	}
	else if (align == text_align_right) {
		Draw_AdjustImages(initial_position, final_position, max_x - x - width);
	}
}

float Draw_SString(float x, float y, const char *text, float scale, qbool proportional)
{
	return Draw_StringBase(x, y, text, NULL, 0, false, scale, 1, false, 0, proportional, 0);
}

float Draw_SStringAlpha(int x, int y, const char* text, float scale, float alpha, qbool proportional)
{
	return Draw_StringBase(x, y, text, NULL, 0, false, scale, alpha, false, 0, proportional, 0);
}

void Draw_SAlt_String(float x, float y, const char *text, float scale, qbool proportional)
{
	Draw_StringBase(x, y, text, NULL, 0, true, scale, 1, false, 0, proportional, 0);
}

int Draw_ConsoleString(float x, float y, const wchar *text, clrinfo_t *color, int text_length, int red, float scale, qbool proportional)
{
	const qbool bigchar = false;
	byte rgba[4];
	qbool color_is_white = true;
	int i, r, g, b;
	int curr_char;
	int color_index = 0;
	color_t last_color = COLOR_WHITE;
	int color_count = color ? text_length : 0;

	// Nothing to draw.
	if (!*text) {
		return 0;
	}

	// Make sure we set the color from scratch so that the 
	// overall opacity is applied properly.
	rgba[0] = rgba[1] = rgba[2] = rgba[3] = 255;
	if (scr_coloredText.integer && color_count > 0) {
		COLOR_TO_RGBA(color[color_index].c, rgba);
	}

	// Draw the string.
	R_Draw_StringBase_StartString(x, y, scale);
	for (i = 0; text[i] != 0 && (text_length <= 0 || i < text_length); i++) {
		// If we didn't get a color array, check for color codes in the text instead.
		if (!color) {
			if (text[i] == '&') {
				if ((text_length == 0 || i + 4 < text_length) && text[i + 1] == 'c' && text[i + 2] && text[i + 3] && text[i + 4]) {
					r = HexToInt(text[i + 2]);
					g = HexToInt(text[i + 3]);
					b = HexToInt(text[i + 4]);

					if (r >= 0 && g >= 0 && b >= 0) {
						if (scr_coloredText.value) {
							rgba[0] = (r * 16);
							rgba[1] = (g * 16);
							rgba[2] = (b * 16);
							rgba[3] = 255;
							color_is_white = false;
						}

						color_count++; // Keep track on how many colors we're using.

						rgba[3] = 255;
						Draw_SetColor(rgba);

						i += 4;
						continue;
					}
				}
				else if ((text_length == 0 || i + 1 < text_length) && text[i + 1] == 'r') {
					if (!color_is_white) {
						rgba[0] = rgba[1] = rgba[2] = 255;
						rgba[3] = 255;
						color_is_white = true;
						Draw_SetColor(rgba);
					}

					i++;
					continue;
				}
			}
		}
		else if (scr_coloredText.value) {
			// Change color if the color array tells us this index should have a new color.

			// Set the new color if it's not the same as the last.
			if (color[color_index].c != last_color) {
				last_color = color[color_index].c;
				COLOR_TO_RGBA(color[color_index].c, rgba);
				rgba[3] = 255;
				Draw_SetColor(rgba);
			}

			color_index++; // Goto next color.
		}
		curr_char = text[i];

		// Do not convert the character to red if we're applying color to the text.
		if (red && color_count <= 0) {
			curr_char |= 128;
		}

		// Draw the character but don't apply overall opacity, we've already done that
		// And don't update the glstate, we've done that also!
		x += Draw_CharacterBaseW(x, y, curr_char, scale, false, bigchar, false, proportional);
	}
	Draw_ResetCharGLState();

	return i;
}

void Draw_ColoredString3(float x, float y, const char *text, clrinfo_t *color, int color_count, int red)
{
	Draw_StringBase(x, y, text, color, color_count, red, 1, 1, false, 0, false, 0);
}

void Draw_ColoredString(float x, float y, const char *text, int red, qbool proportional)
{
	Draw_StringBase(x, y, text, NULL, 0, red, 1, 1, false, 0, proportional, 0);
}

void Draw_SColoredStringBasic(float x, float y, const char *text, int red, float scale, qbool proportional)
{
	Draw_StringBase(x, y, text, NULL, 0, red, scale, 1, false, 0, proportional, 0);
}

// FIXME: Replace with Draw_ColoredString()
void Draw_Alt_String(float x, float y, const char *text, float scale, qbool proportional)
{
	Draw_StringBase(x, y, text, NULL, 0, true, scale, 1, false, 0, proportional, 0);
}

// TODO: proportional
void Draw_AlphaString(float x, float y, const char *text, float alpha)
{
	Draw_StringBase(x, y, text, NULL, 0, false, 1, alpha, false, 0, false, 0);
}

void Draw_String(float x, float y, const char *text)
{
	Draw_StringBase(x, y, text, NULL, 0, false, 1, 1, false, 0, false, 0);
}

float Draw_StringLengthW(const wchar *text, int length, float scale, qbool proportional)
{
	int i;
	float x = 0;

	for (i = 0; text[i] && (length == -1 || i < length); i++) {
		x += FontCharacterWidthWide(text[i], scale, proportional);
	}

	return x;
}

float Draw_StringLength(const char *text, int length, float scale, qbool proportional)
{
	if (!proportional) {
		if (length < 0) {
			length = strlen(text);
		}
		return length * scale * 8;
	}
	else {
		int i;
		float x = 0;

		for (i = 0; text[i] && (length == -1 || i < length); i++) {
			x += FontCharacterWidth(text[i], scale, proportional);
		}

		return x;
	}
}

float Draw_StringLengthColors(const char *text, int length, float scale, qbool proportional)
{
	return Draw_StringLengthColorsByTerminator(text, length, scale, proportional, 0);
}

float Draw_StringLengthColorsByTerminator(const char *text, int length, float scale, qbool proportional, char terminator)
{
	if (!proportional) {
		if (length < 0) {
			length = strlen_color_by_terminator(text, terminator);
		}
		return length * scale * 8;
	}
	else {
		int i;
		float x = 0;

		for (i = 0; text[i] && text[i] != terminator && (length == -1 || i < length); i++) {
			if (text[i] == '&') {
				if (text[i + 1] == 'c' && HexToInt(text[i + 2]) >= 0 && HexToInt(text[i + 3]) >= 0 && HexToInt(text[i + 4]) >= 0) {
					i += 4; // skip "&cRGB"
					continue;
				}
				else if (text[i + 1] == 'r') {
					i += 1; // skip "&r"
					continue;
				}
			}

			x += FontCharacterWidthWide(text[i], scale, proportional);
		}

		return x;
	}
}

int Draw_CharacterFit(const char* text, float width, float scale, qbool proportional)
{
	int fit = 0;

	if (!proportional) {
		return width / (8 * scale);
	}

	while (*text) {
		float next_char_width = FontCharacterWidthWide(*text, scale, proportional);
		if (next_char_width > width) {
			break;
		}

		width -= next_char_width;
		++fit;
		++text;
	}

	return fit;
}

// Called during initialisation, before R_Texture_Init
void Draw_Charset_Init(void)
{
	if (!host_initialized) {
		Cmd_AddCommand("loadcharset", Draw_LoadCharset_f);
#ifdef EZ_FREETYPE_SUPPORT
		FontInitialise();
#endif

		Cvar_SetCurrentGroup(CVAR_GROUP_CONSOLE);
		Cvar_Register(&gl_consolefont);
		Cvar_Register(&gl_alphafont);
		Cvar_Register(&gl_charsets_min);
		Cvar_Register(&scr_coloredText);
		Cvar_ResetCurrentGroup();
	}

	draw_chars = NULL;
}

// Called during initialisation, _after_ R_Texture_Init, wad file loaded etc
void Draw_InitCharset(void)
{
	int i;

	memset(char_textures, 0, sizeof(char_textures));
	memset(char_mapping, 0, sizeof(char_mapping));

	draw_chars = W_GetLumpName("conchars");
	for (i = 0; i < 256 * 64; i++) {
		if (draw_chars[i] == 0) {
			draw_chars[i] = 255;
		}
	}

	Cvar_AutoReset(&gl_consolefont);
	Draw_LoadCharset(gl_consolefont.string);

	if (!R_TextureReferenceIsValid(char_textures[0].glyphs[0].texnum)) {
		if (Draw_LoadCharset("original") == 0) {
			Cvar_AutoSet(&gl_consolefont, "original");
		}
	}

	if (!R_TextureReferenceIsValid(char_textures[0].glyphs[0].texnum)) {
		Sys_Error("Draw_InitCharset: Couldn't load charset");
	}

	Draw_InitFont();
}

void Draw_SetCrosshairTextMode(qbool enabled)
{
	nextCharacterIsCrosshair = enabled;
}

static void Draw_TextCacheInit(float x, float y, float scale)
{
	memcpy(cache_currentColor, color_white, sizeof(cache_currentColor));
}

static void Draw_TextCacheSetColor(const byte* color)
{
	memcpy(cache_currentColor, color, sizeof(cache_currentColor));
}

static float Draw_TextCacheAddCharacter(float x, float y, wchar ch, float scale, qbool proportional)
{
	int new_charset = (ch >> 8) & 0xFF;
	charset_t* texture = &char_textures[0];
	mpic_t* pic;

#ifdef EZ_FREETYPE_SUPPORT
	if (proportional) {
		extern charset_t proportional_fonts[MAX_CHARSETS];

		proportional &= R_TextureReferenceIsValid(proportional_fonts[new_charset].glyphs[ch & 0xFF].texnum);
		if (proportional) {
			texture = &proportional_fonts[new_charset];
		}
	}
#else
	proportional = false;
#endif

	if (!proportional) {
		int slot = new_charset;

		if (slot) {
			if (slot < 0xE0 && !char_mapping[slot]) {
				slot = 0;
				ch = '?';
			}
		}

		texture = &char_textures[slot];
	}

	pic = &texture->glyphs[ch & 0xFF];
	if (!R_TextureReferenceIsValid(pic->texnum)) {
		texture = &char_textures[0];
		pic = &texture->glyphs['*'];
	}
	R_TraceAPI("R_DrawChar(%d %c = %d[%d], pic[%d/%s] %0.3f %0.3f, %0.3f", ch, (ch < 256 ? ch : '?'), new_charset, ch & 0xFF, pic->texnum.index, R_TextureIdentifier(pic->texnum), texture->custom_scale_x, texture->custom_scale_y, scale);
	R_TraceAPI(
		"-> %f,%f %f,%f [%d,%d %d,%d]",
		pic->sl, pic->tl, pic->sh - pic->sl, pic->th - pic->tl,
		(int)(pic->sl * R_TextureWidth(pic->texnum)),
		(int)(pic->tl * R_TextureHeight(pic->texnum)),
		(int)((pic->sh - pic->sl) * R_TextureWidth(pic->texnum)),
		(int)((pic->th - pic->tl) * R_TextureHeight(pic->texnum))
	);
	R_DrawImage(x, y, texture->custom_scale_x * scale * 8, texture->custom_scale_y * scale * 8, pic->sl, pic->tl, pic->sh - pic->sl, pic->th - pic->tl, cache_currentColor, false, pic->texnum, true, nextCharacterIsCrosshair);
	return FontCharacterWidthWide(ch, scale, proportional);
}

// x, y					= Pixel position of char.
// num					= The character to draw.
// scale				= The scale of the character.
// apply_overall_alpha	= Should the overall alpha for all drawing apply to this char?
// bigchar				= Draw this char using the big character charset.
// gl_statechange		= Change the gl state before drawing?
float R_Draw_CharacterBase(float x, float y, wchar num, float scale, qbool apply_overall_alpha, qbool bigchar, qbool gl_statechange, qbool proportional)
{
	int char_size = (bigchar ? 64 : 8);

	if (bigchar) {
		mpic_t *p = Draw_CachePicSafe(MCHARSET_PATH, false, true);

		if (p) {
			int sx = 0;
			int sy = 0;
			int char_width = (p->width / 8);
			int char_height = (p->height / 8);
			char c = (char)(num & 0xFF);

			Draw_GetBigfontSourceCoords(c, char_width, char_height, &sx, &sy);

			if (sx >= 0) {
				// Don't apply alpha here, since we already applied it above.
				Draw_SAlphaSubPic(x, y, p, sx, sy, char_width, char_height, (((float)char_size / char_width) * scale), 1);
			}

			return 64 * scale;
		}

		// TODO : Force players to have mcharset.png or fallback to overscaling normal font? :s
	}

	return Draw_TextCacheAddCharacter(x, y, num, scale, proportional);
}

void R_Draw_ResetCharGLState(void)
{
	Draw_TextCacheSetColor(color_white);
}

void R_Draw_SetColor(byte* rgba)
{
	extern cvar_t scr_coloredText;

	if (scr_coloredText.integer) {
		Draw_TextCacheSetColor(rgba);
	}
}

void R_Draw_StringBase_StartString(float x, float y, float scale)
{
	Draw_TextCacheInit(x, y, scale);
}


================================================
FILE: src/r_draw_circle.c
================================================
/*
Copyright (C) 2017-2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "utils.h"
#include "common_draw.h"
#include "glm_draw.h"
#include "glm_vao.h"
#include "r_state.h"
#include "r_matrix.h"
#include "r_buffers.h"
#include "r_renderer.h"

glm_circle_framedata_t circleData;

extern float overall_alpha;

static void SetCirclePoint(float* points, float x, float y)
{
	float v[4] = { x, y, 0, 1 };
	extern float cachedMatrix[16];

	R_MultiplyVector(cachedMatrix, v, v);

	points[0] = v[0];
	points[1] = v[1];
}

void R_Draw_AlphaPieSliceRGB(float x, float y, float radius, float startangle, float endangle, float thickness, qbool fill, color_t color)
{
	float* pointData;
	double angle;
	byte color_bytes[4];
	int i;
	int start;
	int end;
	int points;

	if (circleData.circleCount >= CIRCLES_PER_FRAME) {
		return;
	}
	if (!R_LogCustomImageType(imagetype_circle, circleData.circleCount)) {
		return;
	}

	// Get the vertex index where to start and stop drawing.
	start = Q_rint((startangle * CIRCLE_LINE_COUNT) / (2 * M_PI));
	end = Q_rint((endangle * CIRCLE_LINE_COUNT) / (2 * M_PI));

	// If the end is less than the start, increase the index so that
	// we start on a "new" circle.
	if (end < start) {
		end = end + CIRCLE_LINE_COUNT;
	}

	points = 0;
	pointData = circleData.drawCirclePointData + (FLOATS_PER_CIRCLE * circleData.circleCount);
	COLOR_TO_RGBA(color, color_bytes);
	circleData.drawCircleColors[circleData.circleCount][0] = (color_bytes[0] / 255.0f) * overall_alpha;
	circleData.drawCircleColors[circleData.circleCount][1] = (color_bytes[1] / 255.0f) * overall_alpha;
	circleData.drawCircleColors[circleData.circleCount][2] = (color_bytes[2] / 255.0f) * overall_alpha;
	circleData.drawCircleColors[circleData.circleCount][3] = (color_bytes[3] / 255.0f) * overall_alpha;
	circleData.drawCircleFill[circleData.circleCount] = fill;
	circleData.drawCircleThickness[circleData.circleCount] = thickness;
	++circleData.circleCount;

	// Create a vertex at the exact position specified by the start angle.
	SetCirclePoint(&pointData[points * 2], x + radius * cos(startangle), y - radius * sin(startangle));
	++points;

	// TODO: Use lookup table for sin/cos?
	for (i = start; i < end; i++) {
		angle = (i * 2 * M_PI) / CIRCLE_LINE_COUNT;
		SetCirclePoint(&pointData[points * 2], x + radius * cos(angle), y - radius * sin(angle));
		++points;

		// When filling we're drawing triangles so we need to
		// create a vertex in the middle of the circle to fill
		// the entire pie slice/circle.
		if (fill) {
			SetCirclePoint(&pointData[points * 2], x, y);
			++points;
		}
	}

	SetCirclePoint(&pointData[points * 2], x + radius * cos(endangle), y - radius * sin(endangle));
	++points;

	// Create a vertex for the middle point if we're not drawing a complete circle.
	if (endangle - startangle < 2 * M_PI) {
		SetCirclePoint(&pointData[points * 2], x, y);
		++points;
	}

	circleData.drawCirclePoints[circleData.circleCount - 1] = points;
}


================================================
FILE: src/r_draw_image.c
================================================
/*
Copyright (C) 2017-2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "glm_draw.h"
#include "tr_types.h"
#include "glsl/constants.glsl"
#include "r_matrix.h"
#include "glm_vao.h"
#include "r_state.h"
#include "glc_vao.h"
#include "r_buffers.h"
#include "r_renderer.h"

extern cvar_t r_smoothtext, r_smoothcrosshair, r_smoothimages;
float cachedMatrix[16];

glm_image_framedata_t imageData;

int Draw_ImagePosition(void)
{
	return imageData.imageCount;
}

void Draw_AdjustImages(int first, int last, float x_offset)
{
	float v1[4] = { x_offset, 0, 0, 1 };
	float v2[4] = { 0, 0, 0, 1 };

	R_MultiplyVector(cachedMatrix, v1, v1);
	R_MultiplyVector(cachedMatrix, v2, v2);

	x_offset = v1[0] - v2[0];

	renderer.AdjustImages(first, last, x_offset);
}

void R_DrawImage(float x, float y, float width, float height, float tex_s, float tex_t, float tex_width, float tex_height, byte* color, qbool alpha_test, texture_ref texnum, qbool isText, qbool isCrosshair)
{
	int flags = IMAGEPROG_FLAGS_TEXTURE;

	if (imageData.imageCount >= MAX_MULTI_IMAGE_BATCH) {
		return;
	}
	if (!R_LogCustomImageTypeWithTexture(imagetype_image, imageData.imageCount, texnum)) {
		return;
	}

	flags |= (alpha_test ? IMAGEPROG_FLAGS_ALPHATEST : 0);
	if (isCrosshair) {
		if (!r_smoothcrosshair.integer) {
			flags |= IMAGEPROG_FLAGS_NEAREST;
		}
	}
	else if (isText) {
		flags |= IMAGEPROG_FLAGS_TEXT;
		if (!r_smoothtext.integer) {
			flags |= IMAGEPROG_FLAGS_NEAREST;
		}
	}
	else {
		if (!r_smoothimages.integer) {
			flags |= IMAGEPROG_FLAGS_NEAREST;
		}
	}

	renderer.DrawImage(x, y, width, height, tex_s, tex_t, tex_width, tex_height, color, flags);
}

void R_DrawRectangle(float x, float y, float width, float height, byte* color)
{
	renderer.DrawRectangle(x, y, width, height, color);
}

void R_Cache2DMatrix(void)
{
	R_MultiplyMatrix(R_ProjectionMatrix(), R_ModelviewMatrix(), cachedMatrix);
}

void R_UndoLastCharacter(void)
{
	if (imageData.imageCount) {
		--imageData.imageCount;
		R_HudUndoLastElement();
	}
}


================================================
FILE: src/r_draw_line.c
================================================
/*
Copyright (C) 2017-2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "glm_draw.h"
#include "glm_vao.h"
#include "r_state.h"
#include "r_matrix.h"
#include "r_buffers.h"

glm_line_framedata_t lineData;

void GLM_Draw_Line3D(byte* color, vec3_t start, vec3_t end)
{
	if (lineData.lineCount >= MAX_LINES_PER_FRAME) {
		return;
	}
}

void R_Draw_LineRGB(float thickness, byte* color, float x_start, float y_start, float x_end, float y_end)
{
	extern float cachedMatrix[16];
	float v1[4] = { x_start, y_start, 0, 1 };
	float v2[4] = { x_end, y_end, 0, 1 };
	float texCoords[2];
	texture_ref texture;
	glm_image_t* img;

	if (lineData.lineCount >= MAX_LINES_PER_FRAME) {
		return;
	}
	if (imageData.imageCount + 2 >= MAX_MULTI_IMAGE_BATCH) {
		return;
	}

	Atlas_SolidTextureCoordinates(&texture, &texCoords[0], &texCoords[1]);

	if (!R_LogCustomImageTypeWithTexture(imagetype_line, lineData.lineCount, texture)) {
		return;
	}

	R_MultiplyVector(cachedMatrix, v1, v1);
	R_MultiplyVector(cachedMatrix, v2, v2);

	img = &imageData.images[imageData.imageCount * 4];
	img[0].pos[0] = v1[0];
	img[0].pos[1] = v1[1];
	memcpy(img[0].colour, color, sizeof(img[0].colour));
	img[1].pos[0] = v2[0];
	img[1].pos[1] = v2[1];
	memcpy(img[1].colour, color, sizeof(img[1].colour));
	img[0].tex[0] = img[1].tex[0] = texCoords[0];
	img[0].tex[1] = img[1].tex[1] = texCoords[1];
	img[0].tex[2] = img[1].tex[2] = 0;
	img[0].tex[3] = img[1].tex[3] = 1;
	lineData.line_thickness[lineData.lineCount] = thickness;
	lineData.imageIndex[lineData.lineCount] = imageData.imageCount * 4;
	++imageData.imageCount;
	++lineData.lineCount;
}


================================================
FILE: src/r_draw_polygon.c
================================================
/*
Copyright (C) 2017-2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "common_draw.h"
#include "glm_draw.h"
#include "glm_vao.h"
#include "r_state.h"
#include "r_matrix.h"
#include "r_buffers.h"

glm_polygon_framedata_t polygonData;

void R_Draw_Polygon(float x, float y, vec3_t *vertices, int num_vertices, color_t color)
{
	int i;
	texture_ref texture;
	float texCoords[2];

	if (polygonData.polygonCount >= MAX_POLYGONS_PER_FRAME) {
		return;
	}
	if (num_vertices <= 2 || num_vertices >= 4 * (MAX_MULTI_IMAGE_BATCH - imageData.imageCount)) {
		return;
	}

	Atlas_SolidTextureCoordinates(&texture, &texCoords[0], &texCoords[1]);

	if (!R_LogCustomImageTypeWithTexture(imagetype_polygon, polygonData.polygonCount, texture)) {
		return;
	}

	polygonData.polygonVerts[polygonData.polygonCount] = num_vertices;
	polygonData.polygonImageIndexes[polygonData.polygonCount] = imageData.imageCount * 4;

	for (i = 0; i < num_vertices; ++i) {
		extern float cachedMatrix[16];
		float v1[4] = { vertices[i][0], vertices[i][1], vertices[i][2], 1 };
		glm_image_t* img = &imageData.images[imageData.imageCount * 4 + i];

		R_MultiplyVector(cachedMatrix, v1, v1);

		COLOR_TO_RGBA_PREMULT(color, img->colour);
		img->tex[0] = texCoords[0];
		img->tex[1] = texCoords[1];
		img->pos[0] = v1[0];
		img->pos[1] = v1[1];
	}
	imageData.imageCount += (num_vertices + 3) / 4;
	++polygonData.polygonCount;
}


================================================
FILE: src/r_framestats.h
================================================

#ifndef EZQUAKE_R_FRAMESTATS_HEADER
#define EZQUAKE_R_FRAMESTATS_HEADER

typedef enum {
	polyTypeWorldModel,
	polyTypeAliasModel,
	polyTypeBrushModel,

	polyTypeMaximum
} frameStatsPolyType;

typedef struct r_frame_stats_classic_s {
	int polycount[polyTypeMaximum];
} r_frame_stats_classic_t;

typedef struct r_frame_stats_modern_s {
	int world_batches;
	int buffer_uploads;
	int multidraw_calls;
} r_frame_stats_modern_t;

typedef struct r_frame_stats_s {
	r_frame_stats_classic_t classic;
	r_frame_stats_modern_t modern;

	qbool hotloop;
	int hotloop_mallocs;
	int mallocs;
	int hotloop_stringops;
	int stringops;

	int texture_binds;
	unsigned int lightmap_min_changed;
	unsigned int lightmap_max_changed;
	int lightmap_updates;
	int draw_calls;
	int subdraw_calls;
	int particle_count;

	double start_time;
	double end_time;
} r_frame_stats_t;

extern r_frame_stats_t frameStats, prevFrameStats;
extern cvar_t r_speeds;

#endif // EZQUAKE_R_FRAMESTATS_HEADER


================================================
FILE: src/r_hud.c
================================================
/*
Copyright (C) 2017-2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "glm_draw.h"
#include "r_draw.h"
#include "r_local.h"
#include "tr_types.h"
#include "r_matrix.h"

#define MAX_2D_ELEMENTS 4096

typedef struct draw_hud_element_s {
	r_image_type_t type;
	texture_ref texture;
	int index;
} draw_hud_element_t;

typedef struct hud_api_s {
	struct {
		void(*Prepare)(void);
		void(*Draw)(texture_ref texture, int start, int end);
	} types[imagetype_count];
	void(*OnComplete)(void);
	//void(*DrawAccelBar)(int x, int y, int length, int charsize, int pos);

	draw_hud_element_t elements[MAX_2D_ELEMENTS];
	int count;
} hud_api_t;

static hud_api_t hud;

#define HudSetFunctionPointers(prefix) \
{ \
	extern void prefix ## _HudDrawCircles(texture_ref texture, int start, int end); \
	extern void prefix ## _HudDrawLines(texture_ref texture, int start, int end); \
	extern void prefix ## _HudDrawPolygons(texture_ref texture, int start, int end); \
	extern void prefix ## _HudDrawImages(texture_ref texture, int start, int length); \
	extern void prefix ## _HudPrepareCircles(void); \
	extern void prefix ## _HudPrepareImages(void); \
	extern void prefix ## _HudDrawComplete(void); \
\
	hud.types[imagetype_image].Draw = prefix ## _HudDrawImages; \
	hud.types[imagetype_image].Prepare = prefix ## _HudPrepareImages; \
	hud.types[imagetype_circle].Draw = prefix ## _HudDrawCircles; \
	hud.types[imagetype_circle].Prepare = prefix ## _HudPrepareCircles; \
	hud.types[imagetype_line].Draw = prefix ## _HudDrawLines; \
	hud.types[imagetype_line].Prepare = NULL; \
	hud.types[imagetype_polygon].Draw = prefix ## _HudDrawPolygons; \
	hud.types[imagetype_polygon].Prepare = NULL; \
	hud.OnComplete = prefix ## _HudDrawComplete; \
}

void R_Hud_Initialise(void)
{
#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		HudSetFunctionPointers(GLM);
	}
#endif
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		HudSetFunctionPointers(GLC);
	}
#endif
#ifdef RENDERER_OPTION_VULKAN
	if (R_UseVulkan()) {
		HudSetFunctionPointers(VK);
	}
#endif
}

static void R_PrepareImageDraw(void)
{
	hud.types[imagetype_image].Prepare();
	hud.types[imagetype_circle].Prepare();

	R_IdentityModelView();
	R_IdentityProjectionView();
}

void R_DrawRectangle(float x, float y, float width, float height, byte* color);

void R_DrawAlphaRectangleRGB(int x, int y, int w, int h, float thickness, qbool fill, byte* bytecolor)
{
	if (fill) {
		R_DrawRectangle(x, y, w, h, bytecolor);
	}
	else {
		R_DrawRectangle(x, y, w, thickness, bytecolor);
		R_DrawRectangle(x, y + thickness, thickness, h - thickness, bytecolor);
		R_DrawRectangle(x + w - thickness, y + thickness, thickness, h - thickness, bytecolor);
		R_DrawRectangle(x, y + h - thickness, w, thickness, bytecolor);
	}
}

void R_Draw_SAlphaSubPic2(float x, float y, mpic_t *pic, int src_width, int src_height, float newsl, float newtl, float newsh, float newth, float scale_x, float scale_y, float alpha)
{
	byte color[] = { 255, 255, 255, alpha * 255 };

	R_DrawImage(x, y, scale_x * src_width, scale_y * src_height, newsl, newtl, newsh - newsl, newth - newtl, color, false, pic->texnum, false, false);
}

void R_Draw_FadeScreen(float alpha)
{
	Draw_AlphaRectangleRGB(0, 0, vid.width, vid.height, 0.0f, true, RGBA_TO_COLOR(0, 0, 0, (alpha < 1 ? alpha * 255 : 255)));
}

void R_EmptyImageQueue(void)
{
	hud.count = imageData.imageCount = circleData.circleCount = lineData.lineCount = polygonData.polygonCount = 0;
}

void R_FlushImageDraw(void)
{
	R_PrepareImageDraw();

	if (hud.count > 0 && glConfig.initialized) {
		texture_ref currentTexture = null_texture_reference;
		r_image_type_t type = imagetype_image;
		int start = 0;
		int i;

		for (i = 0; i < hud.count; ++i) {
			qbool texture_changed = (R_TextureReferenceIsValid(currentTexture) && R_TextureReferenceIsValid(hud.elements[i].texture) && !R_TextureReferenceEqual(currentTexture, hud.elements[i].texture));

			if (i && (hud.elements[i].type != type || texture_changed)) {
				hud.types[type].Draw(currentTexture, hud.elements[start].index, hud.elements[i - 1].index);

				start = i;
			}

			if (R_TextureReferenceIsValid(hud.elements[i].texture)) {
				currentTexture = hud.elements[i].texture;
			}
			type = hud.elements[i].type;
		}

		hud.types[type].Draw(currentTexture, hud.elements[start].index, hud.elements[hud.count - 1].index);
	}

	R_EmptyImageQueue();

	hud.OnComplete();
}

qbool R_LogCustomImageType(r_image_type_t type, int index)
{
	if (hud.count >= MAX_2D_ELEMENTS) {
		return false;
	}

	hud.elements[hud.count].type = type;
	hud.elements[hud.count].index = index;
	hud.elements[hud.count].texture = null_texture_reference;
	hud.count++;
	return true;
}

qbool R_LogCustomImageTypeWithTexture(r_image_type_t type, int index, texture_ref texture)
{
	if (hud.count >= MAX_2D_ELEMENTS) {
		return false;
	}

	hud.elements[hud.count].type = type;
	hud.elements[hud.count].index = index;
	hud.elements[hud.count].texture = texture;
	hud.count++;
	return true;
}

void R_HudUndoLastElement(void)
{
	if (hud.count) {
		--hud.count;
	}
}


================================================
FILE: src/r_lighting.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_R_LIGHTING_HEADER
#define EZQUAKE_R_LIGHTING_HEADER

extern cvar_t       gl_lightmode;
extern cvar_t       gl_modulate;
extern int          lightmode;              // set to gl_lightmode on mapchange

extern cvar_t       gl_flashblend;
extern cvar_t       gl_rl_globe;

// gl_rlight.c
void R_MarkLights(dlight_t *light, int bit, mnode_t *node);
void R_AnimateLight(void);
void R_RenderDlights(void);
void R_LightEntity(entity_t* ent);

extern unsigned int d_lightstylevalue[256];	// 8.8 fraction of base light value
static const float rgb9e5tab[32] = {
	//multipliers for the 9-bit mantissa, according to the biased mantissa
	//aka: pow(2, biasedexponent - bias-bits) where bias is 15 and bits is 9
	1.0/(1<<24), 1.0/(1<<23), 1.0/(1<<22), 1.0/(1<<21), 1.0/(1<<20), 1.0/(1<<19), 1.0/(1<<18), 1.0/(1<<17),
	1.0/(1<<16), 1.0/(1<<15), 1.0/(1<<14), 1.0/(1<<13), 1.0/(1<<12), 1.0/(1<<11), 1.0/(1<<10), 1.0/(1<<9),
	1.0/(1<<8),  1.0/(1<<7),  1.0/(1<<6),  1.0/(1<<5),  1.0/(1<<4),  1.0/(1<<3),  1.0/(1<<2),  1.0/(1<<1),
	1.0,         1.0*(1<<1),  1.0*(1<<2),  1.0*(1<<3),  1.0*(1<<4),  1.0*(1<<5),  1.0*(1<<6),  1.0*(1<<7),
};

extern cvar_t r_dynamic;
#define R_NoLighting()       (r_dynamic.integer == 0)
#define R_HardwareLighting() (r_dynamic.integer == 2 && R_UseModernOpenGL())
#define R_SoftwareLighting() (r_dynamic.integer && !R_HardwareLighting())

#endif // EZQUAKE_R_LOCAL_HEADER


================================================
FILE: src/r_lightmaps.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// gl_lightmaps.c: lightmap-related code

#include "quakedef.h"
#include "gl_model.h"
#include "rulesets.h"
#include "utils.h"
#include "r_local.h"
#include "r_texture.h"
#include "r_lightmaps.h"
#include "r_lighting.h"
#include "r_buffers.h"
#include "r_framestats.h"
#include "r_lightmaps_internal.h"
#include "r_trace.h"
#include "r_renderer.h"
#include "tr_types.h"

typedef struct dlightinfo_s {
	int local[2];
	int rad;
	int minlight;	// rad - minlight
	int lnum; // reference to cl_dlights[]
	int color[3];
} dlightinfo_t;

static unsigned int blocklights[MAX_LIGHTMAP_SIZE * 3];

lightmap_data_t* lightmaps;
static unsigned int last_lightmap_updated;
unsigned int lightmap_array_size;

static qbool gl_invlightmaps = true;

static dlightinfo_t dlightlist[MAX_DLIGHTS];
static int numdlights;

// funny, but this colors differ from bubblecolor[NUM_DLIGHTTYPES][4]
int dlightcolor[NUM_DLIGHTTYPES][3] = {
	{ 100,  90,  80 },	// dimlight or brightlight
	{ 100,  50,  10 },	// muzzleflash
	{ 100,  50,  10 },	// explosion
	{  90,  60,   7 },	// rocket
	{ 128,   0,   0 },	// red
	{   0,   0, 128 },	// blue
	{ 128,   0, 128 },	// red + blue
	{   0, 128,   0 },	// green
	{ 128, 128,   0 }, 	// red + green
	{   0, 128, 128 }, 	// blue + green
	{ 128, 128, 128 },	// white
	{ 128, 128, 128 },	// custom
};

static void R_BuildDlightList (msurface_t *surf)
{
	float dist;
	vec3_t impact;
	int lnum, i, smax, tmax, irad, iminlight, local[2], tdmin, sdmin, distmin;
	unsigned int dlightbits;
	dlightinfo_t *light;

	numdlights = 0;

	smax = (surf->extents[0] >> surf->lmshift) + 1;
	tmax = (surf->extents[1] >> surf->lmshift) + 1;
	dlightbits = surf->dlightbits;

	for (lnum = 0; lnum < MAX_DLIGHTS && dlightbits; lnum++) {
		if (!(surf->dlightbits & (1 << lnum))) {
			continue;		// not lit by this light
		}

		dlightbits &= ~(1<<lnum);

		dist = PlaneDiff(cl_dlights[lnum].origin, surf->plane);
		irad = (cl_dlights[lnum].radius - fabs(dist)) * 256;
		iminlight = cl_dlights[lnum].minlight * 256;
		if (irad < iminlight) {
			continue;
		}

		iminlight = irad - iminlight;

		for (i = 0; i < 3; i++) {
			impact[i] = cl_dlights[lnum].origin[i] - surf->plane->normal[i] * dist;
		}

		local[0] = DotProduct (impact, surf->lmvecs[0]) + surf->lmvecs[0][3] - surf->texturemins[0];
		local[1] = DotProduct (impact, surf->lmvecs[1]) + surf->lmvecs[1][3] - surf->texturemins[1];

		// check if this dlight will touch the surface
		if (local[1] > 0) {
			tdmin = local[1] - (tmax << surf->lmshift);
			if (tdmin < 0) {
				tdmin = 0;
			}
		}
		else {
			tdmin = -local[1];
		}

		if (local[0] > 0) {
			sdmin = local[0] - (smax << surf->lmshift);
			if (sdmin < 0)
				sdmin = 0;
		} else {
			sdmin = -local[0];
		}

		if (sdmin > tdmin)
			distmin = (sdmin << 8) + (tdmin << 7);
		else
			distmin = (tdmin << 8) + (sdmin << 7);

		if (distmin < iminlight) {
			extern cvar_t gl_colorlights;

			// save dlight info
			light = &dlightlist[numdlights];
			light->minlight = iminlight >> 7;
			light->rad = irad >> 7;
			light->local[0] = local[0];
			light->local[1] = local[1];
			light->lnum = lnum;

			if (gl_colorlights.integer) {
				if (cl_dlights[light->lnum].type == lt_custom) {
					VectorCopy(cl_dlights[light->lnum].color, light->color);
				}
				else {
					VectorCopy(dlightcolor[cl_dlights[light->lnum].type], light->color);
				}
			}
			else {
				VectorSet(light->color, 128, 128, 128);
			}
			numdlights++;
		}
	}
}

//R_BuildDlightList must be called first!
static void R_AddDynamicLights(msurface_t *surf)
{
	int i, smax, tmax, s, t, sd, td, _sd, _td, irad, idist, iminlight, tmp;
	dlightinfo_t *light;
	unsigned *dest;

	smax = (surf->extents[0] >> surf->lmshift) + 1;
	tmax = (surf->extents[1] >> surf->lmshift) + 1;

	for (i = 0, light = dlightlist; i < numdlights; i++, light++) {
		irad = light->rad;
		iminlight = light->minlight;

		for (t = 0, _td = light->local[1]; t < tmax; t++, _td -= (1 << surf->lmshift)) {
			td = _td < 0 ? -_td : _td;
			td *= surf->lmvlen[1];

			if (td < irad) {
				dest = blocklights + t * smax * 3;
				for (s = 0, _sd = light->local[0]; s < smax; s++, _sd -= (1 << surf->lmshift), dest += 3) {
					sd = _sd < 0 ? -_sd : _sd;
					sd *= surf->lmvlen[0];

					if (sd + td < iminlight) {
						idist = sd + td;
						if (sd > td) {
							idist += sd;
						}
						else {
							idist += td;
						}

						if (idist < iminlight) {
							tmp = irad - idist;
							dest[0] += tmp * light->color[0];
							dest[1] += tmp * light->color[1];
							dest[2] += tmp * light->color[2];
						}
					}
					else if (_sd < 0) {
						s = smax;
					}
				}
			}
			else if (_td < 0) {
				t = tmax;
			}
		}
	}
}

//Combine and scale multiple lightmaps into the 8.8 format in blocklights
static void R_BuildLightMap(msurface_t *surf, byte *dest, int stride, uint32_t flags)
{
	int smax, tmax, i, j, size, blocksize, maps;
	unsigned scale, *bl;
	qbool fullbright = false;

	R_TraceEnterRegion(va("R_BuildLightMap(%d)", surf->surfacenum), true);

	surf->cached_dlight = !!numdlights;

	smax = (surf->extents[0] >> surf->lmshift) + 1;
	tmax = (surf->extents[1] >> surf->lmshift) + 1;
	size = smax * tmax;
	blocksize = size * 3;

	// check for full bright or no light data
	fullbright = (R_FullBrightAllowed() || !cl.worldmodel || !cl.worldmodel->lightdata);

	if (fullbright) {	// set to full bright
		for (i = 0; i < blocksize; i++) {
			blocklights[i] = 255 << 8;
		}
	}
	else {
		// clear to no light
		memset(blocklights, 0, blocksize * sizeof(int));
	}

	// add all the lightmaps
	if (flags & MOD_HDRLIGHTING) {
		uint32_t *lightmap = (uint32_t *)surf->samples;
		for (maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++) {
			scale = d_lightstylevalue[surf->styles[maps]];
			surf->cached_light[maps] = scale;	// 8.8 fraction
			// it sucks that blocklights is an int array. we can still massively
			// overbright though, just not underbright quite as accurately
			// (still quite a bit more than rgb8 precision there).
			bl = blocklights;
			for (i=0 ; i<size ; i++) {
				uint32_t e5bgr9 = *lightmap++;
				//we're converting to a scale that holds overbrights, so 1->128, its 2->255ish
				float e = rgb9e5tab[e5bgr9>>27] * (1<<7) * scale;
				*bl++ += e*((e5bgr9>> 0)&0x1ff); //red
				*bl++ += e*((e5bgr9>> 9)&0x1ff); //green
				*bl++ += e*((e5bgr9>>18)&0x1ff); //blue
			}
		}
	} else {
		byte *lightmap = surf->samples;
		for (maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++) {
			scale = d_lightstylevalue[surf->styles[maps]];
			surf->cached_light[maps] = scale;	// 8.8 fraction

			if (!fullbright && lightmap) {
				bl = blocklights;
				for (i = 0; i < blocksize; i++) {
					*bl++ += lightmap[i] * scale;
				}
				lightmap += blocksize;		// skip to next lightmap
			}
		}
	}

	// add all the dynamic lights
	if (!fullbright && numdlights) {
		R_AddDynamicLights(surf);
	}

	// bound, invert, and shift
	bl = blocklights;
	stride -= smax * 4;

	scale = (lightmode == 2) ? (int)(256 * 1.5) : 256 * 2;
	scale *= bound(0.5, gl_modulate.value, 3);
	for (i = 0; i < tmax; i++, dest += stride) {
		for (j = smax; j; j--) {
			unsigned r, g, b, m;
			r = bl[0] * scale;
			g = bl[1] * scale;
			b = bl[2] * scale;
			m = max(r, g);
			m = max(m, b);
			if (m > ((255 << 16) + (1 << 15))) {
				unsigned s = (((255 << 16) + (1 << 15)) << 8) / m;
				r = (r >> 8) * s;
				g = (g >> 8) * s;
				b = (b >> 8) * s;
			}
			if (gl_invlightmaps) {
				if (GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS)) {
					dest[2] = 255 - (r >> 16);
					dest[1] = 255 - (g >> 16);
					dest[0] = 255 - (b >> 16);
				}
				else {
					dest[0] = 255 - (r >> 16);
					dest[1] = 255 - (g >> 16);
					dest[2] = 255 - (b >> 16);
				}
			}
			else {
				if (GL_Supported(R_SUPPORT_BGRA_LIGHTMAPS)) {
					dest[2] = r >> 16;
					dest[1] = g >> 16;
					dest[0] = b >> 16;
				}
				else {
					dest[0] = r >> 16;
					dest[1] = g >> 16;
					dest[2] = b >> 16;
				}
			}
			dest[3] = 255;
			bl += 3;
			dest += 4;
		}
	}

	R_TraceLeaveFunctionRegion;
}

void R_UploadLightMap(int textureUnit, int lightmapnum)
{
	lightmap_data_t* lm = &lightmaps[lightmapnum];

	if (lm->modified) {
		R_TraceEnterFunctionRegion;
		lm->modified = false;
		renderer.UploadLightmap(textureUnit, lightmapnum);
		lm->change_area.l = LIGHTMAP_WIDTH;
		lm->change_area.t = LIGHTMAP_HEIGHT;
		lm->change_area.h = 0;
		lm->change_area.w = 0;
		++frameStats.lightmap_updates;
		R_TraceLeaveFunctionRegion;
	}
}

void R_RenderDynamicLightmaps(msurface_t *fa, qbool world)
{
	byte *base;
	int maps, smax, tmax;
	glRect_t *theRect;
	qbool lightstyle_modified = false;
	lightmap_data_t* lm;

	if (!R_SoftwareLighting() && !fa->cached_dlight) {
		return;
	}
	if (fa->lightmaptexturenum < 0) {
		return;
	}

	// check for lightmap modification
	for (maps = 0; maps < MAXLIGHTMAPS && fa->styles[maps] != 255; maps++) {
		if (d_lightstylevalue[fa->styles[maps]] != fa->cached_light[maps]) {
			lightstyle_modified = true;
			break;
		}
	}

	if (R_SoftwareLighting()) {
		if (fa->dlightframe == r_framecount) {
			R_BuildDlightList(fa);
		}
		else {
			numdlights = 0;
		}

		if (numdlights == 0 && !fa->cached_dlight && !lightstyle_modified) {
			return;
		}
	}
	else {
		numdlights = 0;
	}

	lm = &lightmaps[fa->lightmaptexturenum];
	lm->modified = true;
	theRect = &lm->change_area;
	if (fa->light_t < theRect->t) {
		if (theRect->h) {
			theRect->h += theRect->t - fa->light_t;
		}
		theRect->t = fa->light_t;
	}
	if (fa->light_s < theRect->l) {
		if (theRect->w) {
			theRect->w += theRect->l - fa->light_s;
		}
		theRect->l = fa->light_s;
	}
	smax = (fa->extents[0] >> fa->lmshift) + 1;
	tmax = (fa->extents[1] >> fa->lmshift) + 1;
	if (theRect->w + theRect->l < fa->light_s + smax) {
		theRect->w = fa->light_s - theRect->l + smax;
	}
	if (theRect->h + theRect->t < fa->light_t + tmax) {
		theRect->h = fa->light_t - theRect->t + tmax;
	}
	base = lm->rawdata + (fa->light_t * LIGHTMAP_WIDTH + fa->light_s) * 4;
	R_BuildLightMap (fa, base, LIGHTMAP_WIDTH * 4, world ? cl.worldmodel->flags : 0);
}

void R_LightmapFrameInit(void)
{
	frameStats.lightmap_min_changed = lightmap_array_size;
	frameStats.lightmap_max_changed = 0;

	renderer.LightmapFrameInit();
}

static void R_RenderAllDynamicLightmapsForChain(msurface_t* surface, qbool world)
{
	int k;
	msurface_t* s;
	frameStatsPolyType polyType;

	if (!surface) {
		return;
	}

	R_TraceEnterFunctionRegion;

	polyType = world ? polyTypeWorldModel : polyTypeBrushModel;
	for (s = surface; s; s = s->texturechain) {
		k = s->lightmaptexturenum;

		++frameStats.classic.polycount[polyType];

		if (k >= 0 && !(s->flags & (SURF_DRAWTURB | SURF_DRAWSKY))) {
			renderer.RenderDynamicLightmaps(s, world);

			if (lightmaps[k].modified) {
				frameStats.lightmap_min_changed = min(k, frameStats.lightmap_min_changed);
				frameStats.lightmap_max_changed = max(k, frameStats.lightmap_max_changed);
			}
		}
	}

	for (s = surface->drawflatchain; s; s = s->drawflatchain) {
		k = s->lightmaptexturenum;

		++frameStats.classic.polycount[polyType];

		if (k >= 0 && !(s->flags & (SURF_DRAWTURB | SURF_DRAWSKY))) {
			renderer.RenderDynamicLightmaps(s, world);

			if (lightmaps[k].modified) {
				frameStats.lightmap_min_changed = min(k, frameStats.lightmap_min_changed);
				frameStats.lightmap_max_changed = max(k, frameStats.lightmap_max_changed);
			}
		}
	}

	R_TraceLeaveFunctionRegion;
}

void R_UploadChangedLightmaps(void)
{
	if (r_lightmap_lateupload.integer == 1) {
		return;
	}

	R_TraceEnterNamedRegion(__func__);
	if (R_HardwareLighting()) {
		if (R_FullBrightAllowed() || !cl.worldmodel || !cl.worldmodel->lightdata) {
			int i;

			for (i = frameStats.lightmap_min_changed; i <= frameStats.lightmap_max_changed; ++i) {
				if (lightmaps[i].modified) {
					memset(lightmaps[i].rawdata, 255, sizeof(lightmaps[i].rawdata));
					R_UploadLightMap(0, i);
				}
			}

			frameStats.lightmap_min_changed = lightmap_array_size;
			frameStats.lightmap_max_changed = 0;
		}
#ifdef RENDERER_OPTION_MODERN_OPENGL
		else if (R_UseModernOpenGL()) {
			GLM_ComputeLightmaps();
		}
#endif
	}
	else if (frameStats.lightmap_min_changed < lightmap_array_size) {
		unsigned int i;

		for (i = frameStats.lightmap_min_changed; i <= frameStats.lightmap_max_changed; ++i) {
			if (lightmaps[i].modified) {
				R_UploadLightMap(0, i);
			}
		}

		frameStats.lightmap_min_changed = lightmap_array_size;
		frameStats.lightmap_max_changed = 0;
	}
	R_TraceLeaveNamedRegion();
}

void R_RenderAllDynamicLightmaps(model_t *model)
{
	unsigned int i;

	R_TraceEnterFunctionRegion;

	for (i = 0; i < model->numtextures; i++) {
		if (!model->textures[i]) {
			continue;
		}

		R_TraceEnterRegion(model->textures[i]->name, true);
		R_RenderAllDynamicLightmapsForChain(model->textures[i]->texturechain, model->isworldmodel);
		R_TraceLeaveRegion(true);
	}

	R_TraceEnterRegion("drawflat_chain", true);
	R_RenderAllDynamicLightmapsForChain(model->drawflat_chain, model->isworldmodel);
	R_TraceLeaveRegion(true);

	for (i = 0; i < R_LightmapCount(); ++i) {
		msurface_t* surf = R_DrawflatLightmapChain(i);

		if (surf) {
			R_TraceEnterRegion(va("lightmapChain[%d]", i), true);
			R_RenderAllDynamicLightmapsForChain(surf, model->isworldmodel);
			R_TraceLeaveRegion(true);
		}
	}

	if (R_UseImmediateOpenGL()) {
		R_UploadChangedLightmaps();
	}

	R_TraceLeaveFunctionRegion;
}

// returns a lightmap number and the position inside it
static int LightmapAllocBlock(int w, int h, int *x, int *y)
{
	int i, j, best, best2;
	int texnum;

	if (w < 1 || w > LIGHTMAP_WIDTH || h < 1 || h > LIGHTMAP_HEIGHT) {
		Sys_Error("AllocBlock: Bad dimensions (w: %d, h: %d)", w, h);
	}

	for (texnum = last_lightmap_updated; texnum < lightmap_array_size; texnum++, last_lightmap_updated++) {
		best = LIGHTMAP_HEIGHT + 1;

		for (i = 0; i < LIGHTMAP_WIDTH - w; i++) {
			best2 = 0;

			for (j = i; j < i + w; j++) {
				if (lightmaps[texnum].allocated[j] >= best) {
					i = j;
					break;
				}
				if (lightmaps[texnum].allocated[j] > best2) {
					best2 = lightmaps[texnum].allocated[j];
				}
			}
			if (j == i + w) {
				// this is a valid spot
				*x = i;
				*y = best = best2;
			}
		}

		if (best + h > LIGHTMAP_HEIGHT) {
			continue;
		}

		for (i = 0; i < w; i++) {
			lightmaps[texnum].allocated[*x + i] = best + h;
		}

		return texnum;
	}

	// Dynamically increase array
	{
		unsigned int new_size = lightmap_array_size + LIGHTMAP_ARRAY_GROWTH;
		lightmaps = Q_realloc(lightmaps, sizeof(lightmaps[0]) * new_size);
		if (!lightmaps) {
			Sys_Error("AllocBlock: full");
			return 0;
		}
		memset(lightmaps + lightmap_array_size, 0, sizeof(lightmaps[0]) * LIGHTMAP_ARRAY_GROWTH);
		lightmap_array_size = new_size;

		// Memory pointers might now be invalid afer realloc()
		for (i = 0; i < new_size; ++i) {
			lightmaps[i].drawflat_chain_tail = &lightmaps[i].drawflat_chain;
		}
	}
	return LightmapAllocBlock(w, h, x, y);
}

#define EPSILON 1e-6

// Check if triangle has a ~zero area
// https://en.wikipedia.org/wiki/Collinearity
static qbool R_ArePointsColinear(const vec3_t v1, const vec3_t v2, const vec3_t v3)
{
	vec3_t d0, d1, cross;

	VectorSubtract(v2, v1, d0);
	VectorSubtract(v3, v2, d1);

	CrossProduct(d0, d1, cross);

	return DotProduct(cross, cross) < EPSILON;
}

static void R_RemoveColinearVertices(glpoly_t *poly, float new_verts[][VERTEXSIZE])
{
	int i, v1_index, v2_index, v3_index, new_numverts = 0;
	int numverts = poly->numverts;

	v1_index = numverts - 1;
	v2_index = 0;
	v3_index = 1;

	for (i = 0; i < numverts; i++) {
		float *v1 = poly->verts[v1_index];
		float *v2 = poly->verts[v2_index];
		float *v3 = poly->verts[v3_index];

		if (!R_ArePointsColinear(v1, v2, v3)) {
			memcpy(new_verts[new_numverts], v2, sizeof(float) * VERTEXSIZE);
			new_numverts++;
		}

		v1_index = v2_index;
		v2_index = v3_index;
		v3_index = (v3_index + 1) % numverts;
	}

	if (new_numverts > 0) {
		memcpy(poly->verts, new_verts, new_numverts * sizeof(float) * VERTEXSIZE);
		poly->numverts = new_numverts;
	}
}

// 
static void R_BuildSurfaceDisplayList(model_t* currentmodel, msurface_t *fa)
{
	extern cvar_t r_remove_collinear_vertices;
	int i, lindex, lnumverts;
	medge_t *pedges, *r_pedge;
	float *vec, s, t;
	glpoly_t *poly;
	qbool isTurb = (fa->flags & SURF_DRAWTURB);

	// reconstruct the polygon
	pedges = currentmodel->edges;
	lnumverts = fa->numedges;

	// draw texture
	if (!fa->polys) { // seems map loaded first time, so light maps loaded first time too
		poly = (glpoly_t *)Hunk_AllocName(sizeof(glpoly_t) + (lnumverts - 4) * VERTEXSIZE * sizeof(float), "lmpoly");
		poly->next = fa->polys;
		fa->polys = poly;
		poly->numverts = lnumverts;
	}
	else { // seems vid_restart issued, so do not allocate memory, we alredy done it, I hope
		poly = fa->polys;
	}

	for (i = 0; i < lnumverts; i++) {
		lindex = currentmodel->surfedges[fa->firstedge + i];

		if (lindex > 0) {
			r_pedge = &pedges[lindex];
			vec = currentmodel->vertexes[r_pedge->v[0]].position;
		}
		else {
			r_pedge = &pedges[-lindex];
			vec = currentmodel->vertexes[r_pedge->v[1]].position;
		}

		s = DotProduct(vec, fa->texinfo->vecs[0]);
		if (!isTurb) {
			s += fa->texinfo->vecs[0][3];
			s /= fa->texinfo->texture->width;
		}
		else {
			s /= 64;
		}

		t = DotProduct(vec, fa->texinfo->vecs[1]);
		if (!isTurb) {
			t += fa->texinfo->vecs[1][3];
			t /= fa->texinfo->texture->height;
		}
		else {
			t /= 64;
		}

		VectorCopy(vec, poly->verts[i]);

		// material
		poly->verts[i][3] = s;
		poly->verts[i][4] = t;

		// lightmap texture coordinates
		if (isTurb && !fa->texinfo->texture->isLitTurb) {
			poly->verts[i][5] = poly->verts[i][6] = 0;
			poly->verts[i][7] = poly->verts[i][8] = 0;
		}
		else {
			s = DotProduct(vec, fa->lmvecs[0]) + fa->lmvecs[0][3];
			s -= fa->texturemins[0];
			s += fa->light_s * (1 << fa->lmshift);
			s += (1 << fa->lmshift) * 0.5;
			s /= LIGHTMAP_WIDTH * (1 << fa->lmshift);

			t = DotProduct(vec, fa->lmvecs[1]) + fa->lmvecs[1][3];
			t -= fa->texturemins[1];
			t += fa->light_t * (1 << fa->lmshift);
			t += (1 << fa->lmshift) * 0.5;
			t /= LIGHTMAP_HEIGHT * (1 << fa->lmshift);

			poly->verts[i][5] = s;
			poly->verts[i][6] = t;

			s = DotProduct(vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
			s /= 128;

			t = DotProduct(vec, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3];
			t /= 128;

			// Detail textures
			poly->verts[i][7] = 18 * s;
			poly->verts[i][8] = 18 * t;
		}
	}
	poly->numverts = lnumverts;

	// Some GPUs misbehave if fed triangles of empty size.
	if (r_remove_collinear_vertices.value) {
		if (poly->numverts > 4) {
			float (*new_verts)[VERTEXSIZE] = Q_malloc(poly->numverts * sizeof(float[VERTEXSIZE]));
			R_RemoveColinearVertices(poly, new_verts);
			Q_free(new_verts);
		} else {
			float new_verts[4][VERTEXSIZE];
			R_RemoveColinearVertices(poly, new_verts);
		}
	}

	R_BrushModelPolygonToTriangleStrip(poly);
}

static void R_BuildLightmapData(msurface_t* surf, int surfnum)
{
	lightmap_data_t* lm = &lightmaps[surf->lightmaptexturenum];
	unsigned int smax = (surf->extents[0] >> surf->lmshift) + 1;
	unsigned int tmax = (surf->extents[1] >> surf->lmshift) + 1;
	unsigned int lightmap_flags;
	int s, t, maps;

	lightmap_flags = 0xFFFFFFFF;
	for (maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++) {
		lightmap_flags &= ~(0xFF << (8 * maps));
		lightmap_flags |= surf->styles[maps] << (8 * maps);
	}

	for (t = 0; t < tmax; ++t) {
		size_t offset = ((surf->light_t + t) * LIGHTMAP_WIDTH + surf->light_s) * 4;
		int* data = &lm->computeData[offset];
		unsigned int* source = &lm->sourcedata[offset];

		for (s = 0; s < smax; ++s, data += 4, source += 4) {
			data[0] = surfnum;
			data[1] = (s * (1 << surf->lmshift) + surf->texturemins[0] - surf->lmvecs[0][3]);
			data[2] = (t * (1 << surf->lmshift) + surf->texturemins[1] - surf->lmvecs[1][3]);
			data[3] = 0;

			source[0] = source[1] = source[2] = 0;
			source[3] = lightmap_flags;

			if (surf->samples) {
				if (surfnum != -1 && cl.worldmodel->flags & MOD_HDRLIGHTING) {
					uint32_t* lightmap = (uint32_t *)surf->samples;
					for (maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++) {
						size_t lightmap_index = (maps * smax * tmax + t * smax + s);
						uint32_t e5bgr9 = lightmap[lightmap_index];
						//we're converting to a scale that holds overbrights, so 1->128, its 2->255ish
						float e = rgb9e5tab[e5bgr9>>27] * (1<<7);
						// should not clamp here, but changing the light compute shader can be done later
						source[0] += (unsigned int)bound(0, e*((e5bgr9>> 0)&0x1ff), 0xff) << (8 * maps);
						source[1] += (unsigned int)bound(0, e*((e5bgr9>> 9)&0x1ff), 0xff) << (8 * maps);
						source[2] += (unsigned int)bound(0, e*((e5bgr9>>18)&0x1ff), 0xff) << (8 * maps);
					}
				} else {
					byte* lightmap = surf->samples;
					for (maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++) {
						size_t lightmap_index = (maps * smax * tmax + t * smax + s) * 3;

						source[0] |= ((unsigned int)lightmap[lightmap_index + 0]) << (8 * maps);
						source[1] |= ((unsigned int)lightmap[lightmap_index + 1]) << (8 * maps);
						source[2] |= ((unsigned int)lightmap[lightmap_index + 2]) << (8 * maps);
					}
				}
			}
		}
	}
}

static void R_LightmapCreateForSurface(msurface_t *surf, int surfnum, uint32_t flags)
{
	int smax, tmax;
	byte *base;

	smax = (surf->extents[0] >> surf->lmshift) + 1;
	tmax = (surf->extents[1] >> surf->lmshift) + 1;

	if (smax > LIGHTMAP_WIDTH) {
		Host_Error("%s: smax = %d > BLOCK_WIDTH", __func__, smax);
	}
	if (tmax > LIGHTMAP_HEIGHT) {
		Host_Error("%s: tmax = %d > BLOCK_HEIGHT", __func__, tmax);
	}
	if (smax * tmax > MAX_LIGHTMAP_SIZE) {
		Host_Error("%s: smax * tmax = %d > MAX_LIGHTMAP_SIZE", __func__, smax * tmax);
	}

	surf->lightmaptexturenum = LightmapAllocBlock(smax, tmax, &surf->light_s, &surf->light_t);

	base = lightmaps[surf->lightmaptexturenum].rawdata + (surf->light_t * LIGHTMAP_WIDTH + surf->light_s) * 4;
	numdlights = 0;
	R_BuildLightmapData(surf, surfnum);
	R_BuildLightMap(surf, base, LIGHTMAP_WIDTH * 4, flags);
}

static int R_LightmapSurfaceSortFunction(const void* lhs_, const void* rhs_)
{
	const msurface_t* lhs = *(const msurface_t**)lhs_;
	const msurface_t* rhs = *(const msurface_t**)rhs_;

	if (r_lightmap_packbytexture.integer == 1) {
		int lhs_size = ((lhs->extents[0] >> lhs->lmshift) + 1) * ((lhs->extents[1] >> lhs->lmshift) + 1);
		int rhs_size = ((rhs->extents[0] >> rhs->lmshift) + 1) * ((rhs->extents[1] >> rhs->lmshift) + 1);

		return rhs_size - lhs_size;
	}
	else if (r_lightmap_packbytexture.integer == 2) {
		int lhs_width = ((lhs->extents[0] >> lhs->lmshift) + 1);
		int lhs_height = ((lhs->extents[1] >> lhs->lmshift) + 1);
		int rhs_width = ((rhs->extents[0] >> rhs->lmshift) + 1);
		int rhs_height = ((rhs->extents[1] >> rhs->lmshift) + 1);

		int height_diff = rhs_height - lhs_height;
		int width_diff = rhs_width - lhs_width;

		if (height_diff) {
			return height_diff;
		}
		return width_diff;
	}
	else {
		return 0;
	}
}

//Builds the lightmap texture with all the surfaces from all brush models
//Only called when map is initially loaded
void R_BuildLightmaps(void)
{
	int i, j, t;
	model_t	*m;

	if (lightmaps) {
		for (i = 0; i < lightmap_array_size; ++i) {
			lightmaps[i].drawflat_chain = NULL;
			lightmaps[i].drawflat_chain_tail = &lightmaps[i].drawflat_chain;
			memset(lightmaps[i].allocated, 0, sizeof(lightmaps[i].allocated));
		}
	}
	else {
		lightmaps = Q_malloc(sizeof(*lightmaps) * LIGHTMAP_ARRAY_GROWTH);
		lightmap_array_size = LIGHTMAP_ARRAY_GROWTH;
		for (i = 0; i < lightmap_array_size; ++i) {
			lightmaps[i].drawflat_chain_tail = &lightmaps[i].drawflat_chain;
		}
	}
	last_lightmap_updated = 0;

	gl_invlightmaps = R_UseImmediateOpenGL();

	r_framecount = 1;		// no dlightcache
	for (j = 1; j < MAX_MODELS; j++) {
		if (!(m = cl.model_precache[j])) {
			break;
		}
		if (m->name[0] == '*') {
			continue;
		}

		// mark all surfaces as needing lightmap
		for (i = 0; i < m->numsurfaces; i++) {
			m->surfaces[i].surfacenum = i;
			m->surfaces[i].lightmaptexturenum = -1;
		}

		// assign in order based on texture and then by size
		if (r_lightmap_packbytexture.integer) {
			msurface_t** surfaces = Q_malloc(m->numsurfaces * sizeof(msurface_t*));

			for (t = 0; t < m->numtextures; ++t) {
				int surface_count = 0;

				// create list of surfaces that need processed for this texture
				for (i = 0; i < m->numsurfaces; i++) {
					qbool isTurb = (m->surfaces[i].flags & SURF_DRAWTURB);
					qbool isSky = (m->surfaces[i].flags & SURF_DRAWSKY);

					if (m->surfaces[i].texinfo->miptex != t) {
						continue;
					}
					if (isSky || m->surfaces[i].lightmaptexturenum >= 0) {
						continue;
					}
					if (!isTurb && (m->surfaces[i].texinfo->flags & TEX_SPECIAL)) {
						continue;
					}

					surfaces[surface_count++] = &m->surfaces[i];
				}

				// sort, biggest first
				qsort(surfaces, surface_count, sizeof(surfaces[0]), R_LightmapSurfaceSortFunction);

				//
				for (i = 0; i < surface_count; ++i) {
					qbool isTurb = (surfaces[i]->flags & SURF_DRAWTURB);

					if (!isTurb) {
						R_LightmapCreateForSurface(surfaces[i], m->isworldmodel ? surfaces[i]->surfacenum : -1, m->flags);
					}
					R_BuildSurfaceDisplayList(m, surfaces[i]);
				}
			}

			Q_free(surfaces);
		}

		// Double-check: go through all textures again
		for (i = 0; i < m->numsurfaces; i++) {
			qbool isTurb = (m->surfaces[i].flags & SURF_DRAWTURB);
			qbool isSky = (m->surfaces[i].flags & SURF_DRAWSKY);

			if (isSky || m->surfaces[i].lightmaptexturenum >= 0) {
				continue;
			}
			if (!isTurb && (m->surfaces[i].texinfo->flags & TEX_SPECIAL)) {
				continue;
			}

			if (!isTurb || !(m->surfaces[i].texinfo->flags & TEX_SPECIAL)) {
				R_LightmapCreateForSurface(m->surfaces + i, m->isworldmodel ? m->surfaces[i].surfacenum : -1, m->flags);
			}
			R_BuildSurfaceDisplayList(m, m->surfaces + i);
		}
	}

	// upload all lightmaps that were filled
	renderer.CreateLightmapTextures();

	for (i = 0; i < lightmap_array_size; i++) {
		if (!lightmaps[i].allocated[0]) {
			break;		// not used anymore
		}
		lightmaps[i].modified = false;
		lightmaps[i].change_area.l = LIGHTMAP_WIDTH;
		lightmaps[i].change_area.t = LIGHTMAP_HEIGHT;
		lightmaps[i].change_area.w = 0;
		lightmaps[i].change_area.h = 0;
		renderer.BuildLightmap(i);
	}
}

void R_InvalidateLightmapTextures(void)
{
	int i;

	if (renderer.InvalidateLightmapTextures) {
		renderer.InvalidateLightmapTextures();
	}

	for (i = 0; i < lightmap_array_size; ++i) {
		R_TextureReferenceInvalidate(lightmaps[i].gl_texref);
	}

	Q_free(lightmaps);
	lightmap_array_size = 0;
	last_lightmap_updated = 0;
}

void R_LightmapShutdown(void)
{
	Q_free(lightmaps);
	lightmap_array_size = 0;

	if (renderer.LightmapShutdown) {
		renderer.LightmapShutdown();
	}
}

// mark all surfaces so ALL light maps will reload in R_RenderDynamicLightmaps()
void R_ForceReloadLightMaps(void)
{
	model_t	*m;
	int i, j;

	Com_DPrintf("forcing of reloading all light maps!\n");

	for (j = 1; j < MAX_MODELS; j++) {
		if (!(m = cl.model_precache[j])) {
			break;
		}

		if (m->name[0] == '*') {
			continue;
		}

		for (i = 0; i < m->numsurfaces; i++) {
			m->surfaces[i].cached_dlight = true; // kinda hack, so we force reload light map
		}
	}
}

qbool R_FullBrightAllowed(void)
{
	extern cvar_t r_fullbright;

	return r_fullbright.value && r_refdef2.allow_cheats;
}

void R_CheckReloadLightmaps(void)
{
	static qbool allowed;
	static qbool hardware_lighting;
	static float modulate;

	// not changed, nothing to do
	if (allowed == R_FullBrightAllowed() && hardware_lighting == R_HardwareLighting() && modulate == gl_modulate.value) {
		return;
	}

	// ok, it changed, lets update all our light maps...
	allowed = R_FullBrightAllowed();
	hardware_lighting = R_HardwareLighting();
	modulate = gl_modulate.value;

	R_ForceReloadLightMaps();
}

unsigned int R_LightmapCount(void)
{
	return lightmap_array_size;
}

struct msurface_s* R_DrawflatLightmapChain(int i)
{
	return lightmaps[i].drawflat_chain;
}

void R_ClearDrawflatLightmapChain(int i)
{
	lightmaps[i].drawflat_chain = NULL;
	lightmaps[i].drawflat_chain_tail = &lightmaps[i].drawflat_chain;
}

void R_AddDrawflatChainSurface(struct msurface_s* surf, qbool floor)
{
	lightmap_data_t* lm = &lightmaps[surf->lightmaptexturenum];

	if (!lm->drawflat_chain_tail) {
		lm->drawflat_chain_tail = &lm->drawflat_chain;
	}

	if (floor) {
		*lm->drawflat_chain_tail = surf;
		lm->drawflat_chain_tail = &surf->drawflatchain;
		surf->drawflatchain = NULL;
	}
	else {
		surf->drawflatchain = lm->drawflat_chain;
		if (lm->drawflat_chain_tail == &lm->drawflat_chain) {
			lm->drawflat_chain_tail = &surf->drawflatchain;
		}
		lm->drawflat_chain = surf;
	}
}


================================================
FILE: src/r_lightmaps.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_R_LIGHTMAPS_HEADER
#define EZQUAKE_R_LIGHTMAPS_HEADER

void R_BuildLightmaps(void);
qbool R_FullBrightAllowed(void);
void R_CheckReloadLightmaps(void);
void R_RenderAllDynamicLightmaps(struct model_s* model);
void R_LightmapFrameInit(void);
void R_ForceReloadLightMaps(void);
unsigned int R_LightmapCount(void);
struct msurface_s* R_DrawflatLightmapChain(int i);
void R_ClearDrawflatLightmapChain(int i);
void R_AddDrawflatChainSurface(struct msurface_s* surf, qbool floor);

#endif // EZQUAKE_R_LIGHTMAPS_HEADER


================================================
FILE: src/r_lightmaps_internal.h
================================================

#ifndef EZQUAKE_R_LIGHTMAPS_INTERNAL_HEADER
#define EZQUAKE_R_LIGHTMAPS_INTERNAL_HEADER

// Lightmap size
#define	LIGHTMAP_WIDTH  128
#define	LIGHTMAP_HEIGHT 128

#define MAX_LIGHTMAP_SIZE (64 * 64)
#define LIGHTMAP_ARRAY_GROWTH 4

typedef struct glRect_s {
	unsigned int l, t, w, h;
} glRect_t;

typedef struct lightmap_data_s {
	byte rawdata[4 * LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT];
	int computeData[4 * LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT];
	unsigned int sourcedata[4 * LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT];
	int allocated[LIGHTMAP_WIDTH];

	texture_ref gl_texref;
	glpoly_t* poly_chain;
	msurface_t* drawflat_chain;
	msurface_t** drawflat_chain_tail;
	glRect_t change_area;
	qbool modified;
} lightmap_data_t;

extern lightmap_data_t* lightmaps;
extern unsigned int lightmap_array_size;

void GLM_LightmapFrameInit(void);
void GLM_RenderDynamicLightmaps(msurface_t* surface, qbool world);
void GLM_ComputeLightmaps(void);

#endif // EZQUAKE_R_LIGHTMAPS_INTERNAL_HEADER


================================================
FILE: src/r_local.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_R_LOCAL_HEADER
#define EZQUAKE_R_LOCAL_HEADER

#include "r_buffers.h"

extern int glx, gly, glwidth, glheight;

void R_BeginRendering(int *x, int *y, int *width, int *height);
void R_EndRendering(void);
void R_Set2D(void);
void R_PolyBlend(void);
void R_OnDisconnect(void);
void R_StateDefault3D(void);

// 2d rendering
void R_FlushImageDraw(void);
void R_EmptyImageQueue(void);

// culling
qbool R_CullBox(vec3_t mins, vec3_t maxs);
qbool R_CullSphere(vec3_t centre, float radius);

// vis
extern refdef_t	r_refdef;
extern struct mleaf_s* r_viewleaf;
extern struct mleaf_s* r_oldviewleaf;
extern struct mleaf_s* r_viewleaf2;
extern struct mleaf_s* r_oldviewleaf2;	// 2 is for watervis hack

// Using multiple renderers?
#ifdef EZ_MULTIPLE_RENDERERS
#undef EZ_MULTIPLE_RENDERERS
#endif

#if defined(RENDERER_OPTION_CLASSIC_OPENGL) && defined(RENDERER_OPTION_MODERN_OPENGL)
#define EZ_MULTIPLE_RENDERERS

extern cvar_t vid_renderer;
#define R_UseImmediateOpenGL()    (vid_renderer.integer == 0)
#define R_UseModernOpenGL()       (vid_renderer.integer == 1)
#define R_UseVulkan()             (vid_renderer.integer == 2)

void R_SelectRenderer(void);
#endif

#ifndef EZ_MULTIPLE_RENDERERS
#define R_SelectRenderer()
#if defined(RENDERER_OPTION_CLASSIC_OPENGL)
#define R_UseImmediateOpenGL()    (1)
#define R_UseModernOpenGL()       (0)
#define R_UseVulkan()             (0)
#elif defined(RENDERER_OPTION_MODERN_OPENGL)
#define R_UseImmediateOpenGL()    (0)
#define R_UseModernOpenGL()       (1)
#define R_UseVulkan()             (0)
#else
#error No renderer options defined
#endif
#endif

// Debug profile may or may not do anything, but if it does anything it's slower, so only enable in dev mode
#define R_DebugProfileContext()  ((IsDeveloperMode() && COM_CheckParm(cmdline_param_client_video_r_debug)) || COM_CheckParm(cmdline_param_client_video_r_trace))
#define R_CompressFullbrightTextures() (!R_UseImmediateOpenGL())
#define R_LumaTexturesMustMatchDimensions() (!R_UseImmediateOpenGL())
#define R_UseCubeMapForSkyBox() (!R_UseImmediateOpenGL() || GL_Supported(R_SUPPORT_SEAMLESS_CUBEMAPS))

// bloom.c
void R_InitBloomTextures(void);
void R_BloomBlend(void);

// r_draw.c (here for atlas)
#define NUMCROSSHAIRS 6

// r_main.c
typedef enum {
	r_shutdown_full = 0,       // shutting down program
	r_shutdown_restart = 1,    // restarting gfx system (window destroyed & recreated)
	r_shutdown_reload = 2      // soft restart (reload textures only)
} r_shutdown_mode_t;

void R_NewMapPrepare(qbool vid_restart);
void R_Shutdown(r_shutdown_mode_t mode);
void VID_GfxInfo_f(void);
int VID_DisplayNumber(qbool fullscreen);

// Shorthand
#define ISUNDERWATER(contents) (contents == CONTENTS_WATER || contents == CONTENTS_SLIME || contents == CONTENTS_LAVA)
//#define TruePointContents(p) CM_HullPointContents(&cl.worldmodel->hulls[0], 0, p)
#define TruePointContents(p) CM_HullPointContents(&cl.clipmodels[1]->hulls[0], 0, p) // ?TONIK?

extern int r_framecount;

// palette
void Check_Gamma(unsigned char *pal);
void VID_SetPalette(unsigned char *palette);
qbool R_OldGammaBehaviour(void);

void R_Initialise(void);
float R_WaterAlpha(void);

// 3d rendering limits
#define R_MINIMUM_NEARCLIP (2.0f)
#define R_MAXIMUM_NEARCLIP (4.0f)
#define R_MINIMUM_FARCLIP (4096.0f)
#define R_MAXIMUM_FARCLIP (16384.0f)
float R_FarPlaneZ(void);
float R_NearPlaneZ(void);

#endif // EZQUAKE_R_LOCAL_HEADER


================================================
FILE: src/r_main.c
================================================

#include "quakedef.h"
#include "common_draw.h"
#include "r_local.h"
#include "r_vao.h"
#include "r_lightmaps.h"
#include "gl_local.h"
#include "glc_local.h"
#include "glm_local.h"
#include "r_texture.h"
#include "r_renderer.h"

void GLM_Initialise(void);
void GLC_Initialise(void);

void CachePics_Shutdown(void);
void R_LightmapShutdown(void);
void R_Hud_Initialise(void);
void R_BrushModelFreeMemory(void);

renderer_api_t renderer;

void R_NewMapPrepare(qbool vid_restart)
{
	if (cl.worldmodel) {
		R_BuildLightmaps();
	}
	renderer.PrepareModelRendering(vid_restart);
}

void VID_GfxInfo_f(void)
{
	renderer.PrintGfxInfo();
}

void R_Shutdown(r_shutdown_mode_t mode)
{
	if (renderer.Shutdown) {
		renderer.Shutdown(mode);
	}

	CachePics_Shutdown();
	R_LightmapShutdown();

	// Not texture related so leave alone (FIXME: move to renderer.Shutdown)
	if (mode != r_shutdown_reload) {
		R_BrushModelFreeMemory();
		if (renderer.DeleteVAOs) {
			renderer.DeleteVAOs();
		}
		if (buffers.Shutdown) {
			buffers.Shutdown();
		}
	}
	R_DeleteTextures();
	R_TexturesInvalidateAllReferences();
}

#ifdef EZ_MULTIPLE_RENDERERS
void R_SelectRenderer(void)
{
	int i;
	const int renderer_options[] = { 
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
		0,
#endif
#ifdef RENDERER_OPTION_MODERN_OPENGL
		1,
#endif
#ifdef RENDERER_OPTION_VULKAN
		2
#endif
	};

	for (i = 0; i < sizeof(renderer_options) / sizeof(renderer_options[0]); ++i) {
		if (renderer_options[i] == vid_renderer.integer) {
			// Selected renderer is valid
			return;
		}
	}

	// Fall back to first on list
	Cvar_LatchedSetValue(&vid_renderer, renderer_options[0]);
	return;
}
#endif // EZ_MULTIPLE_RENDERERS

void R_Initialise(void)
{
	R_SelectRenderer();

#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		GLM_Initialise();
	}
#endif
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_Initialise();
	}
#endif
#ifdef RENDERER_OPTION_VULKAN
	if (R_UseVulkan()) {
		VK_Initialise();
		VK_PopulateConfig();
		VK_InitialiseVAOHandling();
		VK_InitialiseBufferHandling(&buffers);
		VK_InitialiseState();
	}
#endif
	R_Hud_Initialise();
}

// Called during disconnect
void R_OnDisconnect(void)
{
	R_ClearModelTextureData();
}


================================================
FILE: src/r_matrix.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "r_local.h"
#include "glc_matrix.h"
#include "r_draw.h"
#include "tr_types.h"

static float projectionMatrix[16];
static float modelMatrix[16];
static float identityMatrix[16] = {
	1, 0, 0, 0,
	0, 1, 0, 0,
	0, 0, 1, 0,
	0, 0, 0, 1
};

static void R_SetMatrix(float* target, const float* source)
{
	memcpy(target, source, sizeof(float) * 16);
}

void R_SetIdentityMatrix(float* matrix)
{
	R_SetMatrix(matrix, identityMatrix);
}

// 
static const float* R_OrthoMatrix(float left, float right, float top, float bottom, float zNear, float zFar)
{
	static float matrix[16];

	memset(matrix, 0, sizeof(matrix));
	matrix[0] = 2 / (right - left);
	matrix[5] = 2 / (top - bottom);
	matrix[10] = -2 / (zFar - zNear);
	matrix[12] = -(right + left) / (right - left);
	matrix[13] = -(top + bottom) / (top - bottom);
	matrix[14] = -(zFar + zNear) / (zFar - zNear);
	matrix[15] = 1;

	return matrix;
}

float* R_ModelviewMatrix(void)
{
	return modelMatrix;
}

float* R_ProjectionMatrix(void)
{
	return projectionMatrix;
}

void R_OrthographicProjection(float left, float right, float top, float bottom, float zNear, float zFar)
{
	// Deliberately inverting top & bottom here...
	R_SetMatrix(projectionMatrix, R_OrthoMatrix(left, right, bottom, top, zNear, zFar));
	R_Cache2DMatrix();

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_OrthographicProjection(left, right, top, bottom, zNear, zFar);
	}
#endif
}

void R_RotateMatrix(float* matrix, float angle, float x, float y, float z)
{
	vec3_t vec = { x, y, z };
	double s = sin(angle * M_PI / 180);
	double c = cos(angle * M_PI / 180);
	float rotation[16];
	float result[16];

	VectorNormalize(vec);
	x = vec[0];
	y = vec[1];
	z = vec[2];

	// Taken from https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glRotate.xml
	rotation[0] = x * x * (1 - c) + c;
	rotation[4] = x * y * (1 - c) - z * s;
	rotation[8] = x * z * (1 - c) + y * s;
	rotation[12] = 0;
	rotation[1] = y * x * (1 - c) + z * s;
	rotation[5] = y * y * (1 - c) + c;
	rotation[9] = y * z * (1 - c) - x * s;
	rotation[13] = 0;
	rotation[2] = x * z * (1 - c) - y * s;
	rotation[6] = y * z * (1 - c) + x * s;
	rotation[10] = z * z * (1 - c) + c;
	rotation[14] = 0;
	rotation[3] = rotation[7] = rotation[11] = 0;
	rotation[15] = 1;

	R_MultiplyMatrix(rotation, matrix, result);
	R_SetMatrix(matrix, result);
}

void R_RotateVector(vec3_t vector, float angle, float x, float y, float z)
{
	vec3_t vec = { x, y, z };
	double s = sin(angle * M_PI / 180);
	double c = cos(angle * M_PI / 180);
	float rotation[16];
	float input[4] = { vector[0], vector[1], vector[2], 1 };
	float output[4];

	VectorNormalize(vec);
	x = vec[0];
	y = vec[1];
	z = vec[2];

	// Taken from https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glRotate.xml
	rotation[0] = x * x * (1 - c) + c;
	rotation[4] = x * y * (1 - c) - z * s;
	rotation[8] = x * z * (1 - c) + y * s;
	rotation[12] = 0;
	rotation[1] = y * x * (1 - c) + z * s;
	rotation[5] = y * y * (1 - c) + c;
	rotation[9] = y * z * (1 - c) - x * s;
	rotation[13] = 0;
	rotation[2] = x * z * (1 - c) - y * s;
	rotation[6] = y * z * (1 - c) + x * s;
	rotation[10] = z * z * (1 - c) + c;
	rotation[14] = 0;
	rotation[3] = rotation[7] = rotation[11] = 0;
	rotation[15] = 1;

	R_MultiplyVector(rotation, input, output);
	VectorCopy(output, vector);
}

void R_TransformMatrix(float* matrix, float x, float y, float z)
{
	matrix[12] += matrix[0] * x + matrix[4] * y + matrix[8] * z;
	matrix[13] += matrix[1] * x + matrix[5] * y + matrix[9] * z;
	matrix[14] += matrix[2] * x + matrix[6] * y + matrix[10] * z;
	matrix[15] += matrix[3] * x + matrix[7] * y + matrix[11] * z;
}

void R_ScaleMatrix(float* matrix, float x_scale, float y_scale, float z_scale)
{
	matrix[0] *= x_scale;
	matrix[1] *= x_scale;
	matrix[2] *= x_scale;
	matrix[3] *= x_scale;
	matrix[4] *= y_scale;
	matrix[5] *= y_scale;
	matrix[6] *= y_scale;
	matrix[7] *= y_scale;
	matrix[8] *= z_scale;
	matrix[9] *= z_scale;
	matrix[10] *= z_scale;
	matrix[11] *= z_scale;
}

void R_MultiplyMatrix(const float* lhs, const float* rhs, float* target)
{
	target[0] = lhs[0] * rhs[0] + lhs[1] * rhs[4] + lhs[2] * rhs[8] + lhs[3] * rhs[12];
	target[1] = lhs[0] * rhs[1] + lhs[1] * rhs[5] + lhs[2] * rhs[9] + lhs[3] * rhs[13];
	target[2] = lhs[0] * rhs[2] + lhs[1] * rhs[6] + lhs[2] * rhs[10] + lhs[3] * rhs[14];
	target[3] = lhs[0] * rhs[3] + lhs[1] * rhs[7] + lhs[2] * rhs[11] + lhs[3] * rhs[15];

	target[4] = lhs[4] * rhs[0] + lhs[5] * rhs[4] + lhs[6] * rhs[8] + lhs[7] * rhs[12];
	target[5] = lhs[4] * rhs[1] + lhs[5] * rhs[5] + lhs[6] * rhs[9] + lhs[7] * rhs[13];
	target[6] = lhs[4] * rhs[2] + lhs[5] * rhs[6] + lhs[6] * rhs[10] + lhs[7] * rhs[14];
	target[7] = lhs[4] * rhs[3] + lhs[5] * rhs[7] + lhs[6] * rhs[11] + lhs[7] * rhs[15];

	target[8] = lhs[8] * rhs[0] + lhs[9] * rhs[4] + lhs[10] * rhs[8] + lhs[11] * rhs[12];
	target[9] = lhs[8] * rhs[1] + lhs[9] * rhs[5] + lhs[10] * rhs[9] + lhs[11] * rhs[13];
	target[10] = lhs[8] * rhs[2] + lhs[9] * rhs[6] + lhs[10] * rhs[10] + lhs[11] * rhs[14];
	target[11] = lhs[8] * rhs[3] + lhs[9] * rhs[7] + lhs[10] * rhs[11] + lhs[11] * rhs[15];

	target[12] = lhs[12] * rhs[0] + lhs[13] * rhs[4] + lhs[14] * rhs[8] + lhs[15] * rhs[12];
	target[13] = lhs[12] * rhs[1] + lhs[13] * rhs[5] + lhs[14] * rhs[9] + lhs[15] * rhs[13];
	target[14] = lhs[12] * rhs[2] + lhs[13] * rhs[6] + lhs[14] * rhs[10] + lhs[15] * rhs[14];
	target[15] = lhs[12] * rhs[3] + lhs[13] * rhs[7] + lhs[14] * rhs[11] + lhs[15] * rhs[15];
}

void R_MultiplyVector3f(const float* matrix, float x, float y, float z, float* result)
{
	const float vector[4] = { x, y, z, 1 };

	result[0] = matrix[0] * vector[0] + matrix[4] * vector[1] + matrix[8] * vector[2] + matrix[12] * vector[3];
	result[1] = matrix[1] * vector[0] + matrix[5] * vector[1] + matrix[9] * vector[2] + matrix[13] * vector[3];
	result[2] = matrix[2] * vector[0] + matrix[6] * vector[1] + matrix[10] * vector[2] + matrix[14] * vector[3];
	result[3] = matrix[3] * vector[0] + matrix[7] * vector[1] + matrix[11] * vector[2] + matrix[15] * vector[3];
}

void R_MultiplyVector(const float* matrix, const float* vector, float* result)
{
	result[0] = matrix[0] * vector[0] + matrix[4] * vector[1] + matrix[8] * vector[2] + matrix[12] * vector[3];
	result[1] = matrix[1] * vector[0] + matrix[5] * vector[1] + matrix[9] * vector[2] + matrix[13] * vector[3];
	result[2] = matrix[2] * vector[0] + matrix[6] * vector[1] + matrix[10] * vector[2] + matrix[14] * vector[3];
	result[3] = matrix[3] * vector[0] + matrix[7] * vector[1] + matrix[11] * vector[2] + matrix[15] * vector[3];
}

void R_MultiplyVector3fv(const float* matrix, const vec3_t vector, float* result)
{
	result[0] = matrix[0] * vector[0] + matrix[4] * vector[1] + matrix[8] * vector[2] + matrix[12];
	result[1] = matrix[1] * vector[0] + matrix[5] * vector[1] + matrix[9] * vector[2] + matrix[13];
	result[2] = matrix[2] * vector[0] + matrix[6] * vector[1] + matrix[10] * vector[2] + matrix[14];
	result[3] = matrix[3] * vector[0] + matrix[7] * vector[1] + matrix[11] * vector[2] + matrix[15];
}

void R_IdentityModelView(void)
{
	R_SetIdentityMatrix(R_ModelviewMatrix());

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_IdentityModelview();
	}
#endif
}

void R_GetModelviewMatrix(float* matrix)
{
	memcpy(matrix, modelMatrix, sizeof(modelMatrix));
}

void R_GetProjectionMatrix(float* matrix)
{
	memcpy(matrix, projectionMatrix, sizeof(projectionMatrix));
}

void R_RotateModelview(float angle, float x, float y, float z)
{
	if (fmodf(angle, 360.0f) != 0) {
		R_RotateMatrix(modelMatrix, angle, x, y, z);

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
		if (R_UseImmediateOpenGL()) {
			GLC_RotateModelview(angle, x, y, z);
		}
#endif
	}
}

void R_TranslateModelview(float x, float y, float z)
{
	if (x != 0 || y != 0 || z != 0) {
		R_TransformMatrix(modelMatrix, x, y, z);

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
		if (R_UseImmediateOpenGL()) {
			GLC_TranslateModelview(x, y, z);
		}
#endif
	}
}

void R_IdentityProjectionView(void)
{
	R_SetIdentityMatrix(R_ProjectionMatrix());

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_IdentityProjectionView();
	}
#endif
}

void R_PushModelviewMatrix(float* matrix)
{
	memcpy(matrix, modelMatrix, sizeof(modelMatrix));
}

void R_PushProjectionMatrix(float* matrix)
{
	memcpy(matrix, projectionMatrix, sizeof(projectionMatrix));
}

void R_PopModelviewMatrix(const float* matrix)
{
	memcpy(modelMatrix, matrix, sizeof(modelMatrix));

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_PopModelviewMatrix(matrix);
	}
#endif
}

void R_PopProjectionMatrix(const float* matrix)
{
	memcpy(projectionMatrix, matrix, sizeof(projectionMatrix));

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_PopProjectionMatrix(matrix);
	}
#endif
}

void R_ScaleModelview(float xScale, float yScale, float zScale)
{
	R_ScaleMatrix(modelMatrix, xScale, yScale, zScale);

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_ScaleModelview(xScale, yScale, zScale);
	}
#endif
}

void R_Frustum(double left, double right, double bottom, double top, double zNear, double zFar)
{
	float perspective[16] = { 0 };
	float new_projection[16];

	perspective[0] = (2 * zNear) / (right - left);
	perspective[8] = (right + left) / (right - left);
	perspective[5] = (2 * zNear) / (top - bottom);
	perspective[9] = (top + bottom) / (top - bottom);
	perspective[10] = -(zFar + zNear) / (zFar - zNear);
	perspective[11] = -1;
	perspective[14] = -2 * (zFar * zNear) / (zFar - zNear);

	if (glConfig.reversed_depth) {
		perspective[10] = -zFar / (zNear - zFar) - 1;
		perspective[14] = -(zNear * zFar) / (zNear - zFar);
	}

	R_MultiplyMatrix(perspective, R_ProjectionMatrix(), new_projection);
	R_SetMatrix(R_ProjectionMatrix(), new_projection);

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_Frustum(left, right, bottom, top, zNear, zFar);
	}
#endif
}

void GLM_MultiplyMatrixVector(float* matrix, vec3_t vector, float* result)
{
	result[0] = matrix[0] * vector[0] + matrix[4] * vector[1] + matrix[8] * vector[2] + matrix[12] * vector[3];
	result[1] = matrix[1] * vector[0] + matrix[5] * vector[1] + matrix[9] * vector[2] + matrix[13] * vector[3];
	result[2] = matrix[2] * vector[0] + matrix[6] * vector[1] + matrix[10] * vector[2] + matrix[14] * vector[3];
	result[3] = matrix[3] * vector[0] + matrix[7] * vector[1] + matrix[11] * vector[2] + matrix[15] * vector[3];
}

void R_RotateForEntity(const struct entity_s *e)
{
	R_TranslateModelview(e->origin[0], e->origin[1], e->origin[2]);

	R_RotateModelview(e->angles[1], 0, 0, 1);
	R_RotateModelview(-e->angles[0], 0, 1, 0);
	R_RotateModelview(e->angles[2], 1, 0, 0);
}

qbool R_Project3DCoordinates(float objx, float objy, float objz, float* winx, float* winy, float* winz)
{
	float model[16], proj[16];
	float in[4] = { objx, objy, objz, 1.0f };
	float out[4];
	int view[4];
	int i;

	R_GetModelviewMatrix(model);
	R_GetProjectionMatrix(proj);
	R_GetViewport(view);

	for (i = 0; i < 4; i++) {
		out[i] = in[0] * model[0 * 4 + i] + in[1] * model[1 * 4 + i] + in[2] * model[2 * 4 + i] + in[3] * model[3 * 4 + i];
	}

	for (i = 0; i < 4; i++) {
		in[i] = out[0] * proj[0 * 4 + i] + out[1] * proj[1 * 4 + i] + out[2] * proj[2 * 4 + i] + out[3] * proj[3 * 4 + i];
	}

	if (!in[3]) {
		return false;
	}

	VectorScale(in, 1 / in[3], in);
	*winx = view[0] + (1 + in[0]) * view[2] / 2;
	*winy = view[1] + (1 + in[1]) * view[3] / 2;
	*winz = (1 + in[2]) / 2;

	return true;
}


================================================
FILE: src/r_matrix.h
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_R_MATRIX_HEADER
#define EZQUAKE_R_MATRIX_HEADER

qbool R_Project3DCoordinates(float objx, float objy, float objz, float* winx, float* winy, float* winz);

void R_GetModelviewMatrix(float* matrix);
void R_GetProjectionMatrix(float* matrix);
void R_GetViewport(int* view);

void R_IdentityProjectionView(void);
void R_IdentityModelView(void);
void R_RotateModelview(float angle, float x, float y, float z);
void R_ScaleModelview(float xScale, float yScale, float zScale);
void R_TranslateModelview(float x, float y, float z);
void R_Frustum(double left, double right, double bottom, double top, double zNear, double zFar);
void R_OrthographicProjection(float left, float right, float top, float bottom, float zNear, float zFar);

void R_PushModelviewMatrix(float* matrix);
void R_PopModelviewMatrix(const float* matrix);
void R_PushProjectionMatrix(float* matrix);
void R_PopProjectionMatrix(const float* matrix);

void R_ScaleMatrix(float* matrix, float x_scale, float y_scale, float z_scale);
void R_TransformMatrix(float* matrix, float x, float y, float z);
void R_RotateMatrix(float* matrix, float angle, float x, float y, float z);
void R_RotateVector(vec3_t vector, float angle, float x, float y, float z);

void R_SetIdentityMatrix(float* matrix);
float* R_ModelviewMatrix(void);
float* R_ProjectionMatrix(void);

void R_MultiplyMatrix(const float* lhs, const float* rhs, float* target);
void R_MultiplyVector(const float* matrix, const float* vector, float* result);
void R_MultiplyVector3f(const float* matrix, float x, float y, float z, float* result);
void R_MultiplyVector3fv(const float* matrix, const vec3_t vector, float* result);

void R_RotateForEntity(const struct entity_s* e);

#endif // EZQUAKE_R_MATRIX_HEADER


================================================
FILE: src/r_misc.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: r_part.c,v 1.19 2007-10-29 00:13:26 d3urk Exp $

*/

#include "quakedef.h"
#include "r_local.h"


================================================
FILE: src/r_misc.cpp
================================================


================================================
FILE: src/r_model.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: gl_model.c,v 1.41 2007-10-07 08:06:33 tonik Exp $
*/
// gl_model.c  -- model loading and caching

// models are the only shared resource between a client and server running on the same machine.

#include "quakedef.h"
#include "gl_model.h"
#include "teamplay.h"
#include "rulesets.h"
#include "wad.h"
#include "crc.h"
#include "fmod.h"
#include "utils.h"
#include "r_texture.h"
#include "r_renderer.h"

model_t	*loadmodel;
char	loadname[32];	// for hunk tags

static mpic_t simpleitem_textures[MOD_NUMBER_HINTS][MAX_SIMPLE_TEXTURES];

void Mod_LoadSpriteModel(model_t *mod, void *buffer);
void Mod_LoadBrushModel(model_t *mod, void *buffer, int filesize);
void Mod_LoadAliasModel(model_t *mod, void *buffer, int filesize, const char* loadname);
model_t *Mod_LoadModel(model_t *mod, qbool crash);
void Mod_AddModelFlags(model_t *mod);

byte	mod_novis[MAX_MAP_LEAFS/8];

model_t	mod_known[MAX_MODELS];
int		mod_numknown;

void Mod_Init(void)
{
	memset(mod_novis, 0xff, sizeof(mod_novis));
}

//Caches the data if needed
void *Mod_Extradata(model_t *mod)
{
	if (mod->cached_data) {
		return mod->cached_data;
	}

	Mod_LoadModel(mod, true);

	if (!mod->cached_data) {
		Sys_Error("Mod_Extradata: caching failed");
	}
	return mod->cached_data;
}

mleaf_t *Mod_PointInLeaf(vec3_t p, model_t *model)
{
	mnode_t *node;
	float d;
	mplane_t *plane;

	if (!model || !model->nodes) {
		Sys_Error("Mod_PointInLeaf: bad model");
		return NULL;
	}

	node = model->nodes;
	while (1) {
		if (node->contents < 0) {
			return (mleaf_t *)node;
		}
		plane = node->plane;
		d = PlaneDiff(p, plane);
		node = (d > 0) ? node->children[0] : node->children[1];
	}

	return NULL;	// never reached
}

byte *Mod_DecompressVis(byte *in, model_t *model)
{
	static byte	decompressed[MAX_MAP_LEAFS / 8];
	int c, row;
	byte *out;

	row = (model->numleafs + 7) >> 3;
	out = decompressed;

	if (!in) {	// no vis info, so make all visible
		while (row) {
			*out++ = 0xff;
			row--;
		}
		return decompressed;
	}

	do {
		if (*in) {
			*out++ = *in++;
			continue;
		}

		c = in[1];
		in += 2;
		while (c) {
			*out++ = 0;
			c--;
		}
	} while (out - decompressed < row);

	return decompressed;
}

byte *Mod_LeafPVS(mleaf_t *leaf, model_t *model)
{
	if (leaf == model->leafs) {
		return mod_novis;
	}
	return Mod_DecompressVis(leaf->compressed_vis, model);
}

void Mod_ClearAll(void)
{
	int i;
	model_t	*mod;

	for (i = 0, mod = mod_known; i < mod_numknown; i++, mod++) {
		if (mod->type != mod_alias && mod->type != mod_alias3 && mod->type != mod_sprite) {
			mod->needload = true;
		}
	}
}

void Mod_FreeAllCachedData(void)
{
	int i;
	model_t	*mod;

	for (i = 0, mod = mod_known; i < mod_numknown; i++, mod++) {
		Q_free(mod->cached_data);
	}
}

model_t *Mod_FindName(const char *name)
{
	int i;
	model_t	*mod;

	if (!name[0]) {
		Sys_Error("Mod_ForName: NULL name");
	}

	// search the currently loaded models
	for (i = 0, mod = mod_known; i < mod_numknown; i++, mod++) {
		if (!strcmp(mod->name, name)) {
			break;
		}
	}

	if (i == mod_numknown) {
		if (mod_numknown == MAX_MODELS) {
			Sys_Error("mod_numknown == MAX_MOD_KNOWN");
		}
		strlcpy(mod->name, name, sizeof(mod->name));
		mod->needload = true;
		mod_numknown++;
	}
	return mod;
}

void Mod_TouchModel(char *name)
{
	Mod_FindName(name);
}

void Mod_ReloadModels(qbool vid_restart)
{
	int i;

	for (i = 1; i < MAX_MODELS; ++i) {
		model_t* mod = cl.model_precache[i];

		if (mod && (mod == cl.worldmodel || !mod->isworldmodel)) {
			if (mod->type == mod_alias || mod->type == mod_alias3) {
				if (mod->vertsInVBO && !mod->temp_vbo_buffer) {
					// Invalidate cache so VBO buffer gets refilled
					Q_free(mod->cached_data);
				}
			}
			Mod_LoadModel(mod, true);
		}
	}

	for (i = 0; i < MAX_VWEP_MODELS; i++) {
		model_t* mod = cl.vw_model_precache[i];

		if (mod) {
			if (mod->type == mod_alias || mod->type == mod_alias3) {
				if (mod->vertsInVBO && !mod->temp_vbo_buffer) {
					// Invalidate cache so VBO buffer gets refilled
					Q_free(mod->cached_data);
				}
			}
			Mod_LoadModel(mod, true);
		}
	}

	for (i = 0; i < custom_model_count; i++) {
		model_t* mod = cl_custommodels[i];

		if (mod) {
			if (mod->type == mod_alias || mod->type == mod_alias3) {
				if (mod->vertsInVBO && !mod->temp_vbo_buffer) {
					// Invalidate cache so VBO buffer gets refilled
					Q_free(mod->cached_data);
				}
			}
			Mod_LoadModel(mod, true);
		}
	}
}

//Loads a model into the cache
model_t *Mod_LoadModel(model_t *mod, qbool crash)
{
	unsigned *buf;
	int namelen;
	int filesize;

	if (!mod->needload) {
		if (mod->type == mod_alias || mod->type == mod_alias3 || mod->type == mod_sprite) {
			if (mod->cached_data) {
				return mod;
			}
		}
		else {
			return mod; // not cached at all
		}
	}

	namelen = strlen(mod->name);
	buf = NULL;
	if (namelen >= 4 && (!strcmp(mod->name + namelen - 4, ".mdl") ||
		(namelen >= 9 && mod->name[5] == 'b' && mod->name[6] == '_' && !strcmp(mod->name + namelen - 4, ".bsp")))) {
		char newname[MAX_QPATH];
		COM_StripExtension(mod->name, newname, sizeof(newname));
		COM_DefaultExtension(newname, ".md3", sizeof(newname));
		buf = (unsigned *)FS_LoadTempFile(newname, &filesize);
	}

	// load the file
	if (!buf) {
		buf = (unsigned *)FS_LoadTempFile(mod->name, &filesize);
	}
	if (!buf) {
		if (crash) {
			Host_Error("Mod_LoadModel: %s not found", mod->name);
		}
		return NULL;
	}

	// allocate a new model
	COM_FileBase(mod->name, loadname);
	loadmodel = mod;
	FMod_CheckModel(mod->name, buf, filesize);

	// call the apropriate loader
	mod->needload = false;

	switch (LittleLong(*((unsigned *)buf))) {
	case IDPOLYHEADER:
		Mod_LoadAliasModel(mod, buf, filesize, loadname);
		break;

	case MD3_IDENT:
		Mod_LoadAlias3Model(mod, buf, filesize);
		break;

	case IDSPRITEHEADER:
		Mod_LoadSpriteModel(mod, buf);
		break;

	default:
		Mod_LoadBrushModel(mod, buf, filesize);
		break;
	}

	return mod;
}

//Loads in a model for the given name
model_t *Mod_ForName(const char *name, qbool crash)
{
	model_t	*mod = Mod_FindName(name);

	return Mod_LoadModel(mod, crash);
}

qbool Img_HasFullbrights(byte *pixels, int size)
{
	int i;

	for (i = 0; i < size; i++) {
		if (pixels[i] >= 224) {
			return true;
		}
	}

	return false;
}

// this is callback from VID after a vid_restart
void Mod_ReloadModelsTextures(void)
{
	int i, j;
	model_t *m;
	texture_t *tx;

	if (cls.state != ca_active) {
		return; // seems we are not loaded models yet, so no need to reload textures
	}

	// mark all textures as not loaded, for brush models only, this speed up loading.
	// seems textures shared between models, so we mark textures from ALL models than actually load textures, that why we use two for()
	for (i = 1; i < MAX_MODELS; i++)
	{
		if (!cl.model_name[i][0]) {
			break;
		}

		m = cl.model_precache[i];
		if (m->type != mod_brush) {
			continue; // actual only for brush models
		}

		if (!m->textures) {
			continue; // hmm
		}

		for (j = 0; j < m->numtextures; j++) {
			tx = m->textures[j];
			if (!tx) {
				continue;
			}

			tx->loaded = false; // so texture will be reloaded
			R_TextureReferenceInvalidate(tx->gl_texture_array);
		}
	}

	// now actually load textures for brush models
	for (i = 1; i < MAX_MODELS; i++)
	{
		if (!cl.model_name[i][0]) {
			break;
		}

		m = cl.model_precache[i];
		if (m->type != mod_brush) {
			continue; // actual only for brush models
		}

		R_LoadBrushModelTextures(m);
	}
}

float RadiusFromBounds (vec3_t mins, vec3_t maxs)
{
	int i;
	vec3_t corner;

	for (i = 0; i < 3; i++)
		corner[i] = fabs(mins[i]) > fabs(maxs[i]) ? fabs(mins[i]) : fabs(maxs[i]);

	return VectorLength (corner);
}

//============================================================

//=========================================================

//VULT MODELS
//This is incase we want to use a function other than Mod_LoadAliasModel
//It was used in one of the older versions when it supported Q2 Models.
void Mod_AddModelFlags(model_t *mod)
{
	mod->renderfx = 0;
	mod->modhint = mod->modhint_trail = MOD_NORMAL;
	if (!strcmp(mod->name, "progs/caltrop.mdl") ||
		!strcmp(mod->name, "progs/biggren.mdl") ||
/*		!strcmp(mod->name, "progs/detpack.mdl") ||
		!strcmp(mod->name, "progs/detpack2.mdl") ||*/
/*		!strcmp(mod->name, "progs/dgib.mdl") ||
		!strcmp(mod->name, "progs/dgib2.mdl") ||
		!strcmp(mod->name, "progs/dgib3.mdl") ||*/
		!strcmp(mod->name, "progs/flare.mdl") ||
		!strcmp(mod->name, "progs/gren1.bsp") ||
		//!strcmp(mod->name, "progs/grenade.mdl") ||
		//!strcmp(mod->name, "progs/grenade2.mdl") ||
		!strcmp(mod->name, "progs/grenade3.mdl") ||
		!strcmp(mod->name, "progs/hook.mdl") ||
/*		!strcmp(mod->name, "progs/tesgib1.mdl") ||
		!strcmp(mod->name, "progs/tesgib2.mdl") ||
		!strcmp(mod->name, "progs/tesgib3.mdl") ||
		!strcmp(mod->name, "progs/tesgib4.mdl") ||
//		!strcmp(mod->name, "progs/turrgun.mdl") || //turrets have dodgy origins, after all
		!strcmp(mod->name, "progs/tgib1.mdl") ||
		!strcmp(mod->name, "progs/tgib2.mdl") ||
		!strcmp(mod->name, "progs/tgib3.mdl") ||*/
		!strcmp(mod->name, "progs/hgren2.mdl")) {
		mod->modhint_trail = MOD_TF_TRAIL;
	}

	//modhints
	if (!strcmp(mod->name, "progs/player.mdl")) {
		mod->modhint = MOD_PLAYER;
	}
	else if (!strcmp(mod->name, "progs/eyes.mdl")) {
		mod->modhint = MOD_EYES;
	}
	else if (!strcmp(mod->name, "fx_tele.mdl")) {
		//Tei, special
		mod->modhint = MOD_TELEPORTDESTINATION;
	}
	else if (!strcmp(mod->name, "progs/flame.mdl")) {
		mod->modhint = MOD_FLAME;
	}
	else if (!strcmp(mod->name, "progs/flame2.mdl")) {
		mod->modhint = MOD_FLAME2;
	}
	else if (!strcmp(mod->name, "progs/flame0.mdl")) {
		mod->modhint = MOD_FLAME0;
	}
	else if (!strcmp(mod->name, "progs/flame3.mdl")) {
		mod->modhint = MOD_FLAME3;
	}
	else if (!strcmp(mod->name, "progs/bolt.mdl") || !strcmp(mod->name, "progs/bolt2.mdl") || !strcmp(mod->name, "progs/bolt3.mdl")) {
		mod->modhint = MOD_THUNDERBOLT;
	}
	else if (!strcmp(mod->name, "progs/minimissile.mdl")) {
		mod->modhint = MOD_CLUSTER;
	}
	else if (!strcmp(mod->name, "progs/flag.mdl") ||
		!strcmp(mod->name, "progs/tf_flag.mdl") ||
		!strcmp(mod->name, "progs/kkr.mdl") ||
		!strcmp(mod->name, "progs/kkb") ||
		!strcmp(mod->name, "progs/w_g_key.mdl") ||
		!strcmp(mod->name, "progs/w_s_key.mdl") ||
		!strcmp(mod->name, "progs/b_g_key.mdl") ||
		!strcmp(mod->name, "progs/b_s_key.mdl") ||
		!strcmp(mod->name, "progs/stag.mdl") ||
		!strcmp(mod->name, "progs/basrkey.bsp") ||
		!strcmp(mod->name, "progs/basbkey.bsp") ||
		!strcmp(mod->name, "progs/ff_flag.mdl") ||
		!strcmp(mod->name, "progs/harbflag.mdl") ||
		!strcmp(mod->name, "progs/princess.mdl") ||
		!strcmp(mod->name, "progs/tf_stan.mdl")) {
		mod->modhint = MOD_FLAG;
	}
	else if (!strcmp(mod->name, "progs/spike.mdl") ||
		!strcmp(mod->name, "progs/s_spike.mdl") ||
		!strcmp(mod->name, "progs/amf_spike.mdl")) {
		mod->modhint = MOD_SPIKE;
	}
	else if (!strcmp(mod->name, "progs/coil.mdl") || !strcmp(mod->name, "progs/tesla.mdl")) {
		mod->modhint = MOD_TESLA;
	}
	else if (!strcmp(mod->name, "progs/turrgun.mdl")) {
		mod->modhint = MOD_SENTRYGUN;
	}
	else if (!strcmp(mod->name, "progs/detpack.mdl")) {
		mod->modhint = MOD_DETPACK;
	}
	else if (!strcmp(mod->name, "progs/laser.mdl")) {
		mod->modhint = MOD_LASER;
	}
	else if (!strcmp(mod->name, "progs/demon.mdl")/* || !strcmp(mod->name, "progs/shambler.mdl") */) {
		mod->modhint = MOD_DEMON;
	}
	else if (!strcmp(mod->name, "progs/soldier.mdl")) {
		mod->modhint = MOD_SOLDIER;
	}
	else if (!strcmp(mod->name, "progs/enforcer.mdl")) {
		mod->modhint = MOD_ENFORCER;
	}
	else if (!strcmp(mod->name, "progs/ogre.mdl")) {
		mod->modhint = MOD_OGRE;
	}
	else if (!strcmp(mod->name, "progs/shambler.mdl")) {
		mod->modhint = MOD_SHAMBLER;
	}
	else if (!strcmp(mod->name, "progs/v_spike.mdl")) {
		mod->modhint = MOD_VOORSPIKE;
	}
	else if (!strcmp(mod->name, "progs/e_spike1.mdl")) {
		mod->modhint = MOD_RAIL;
	}
	else if (!strcmp(mod->name, "progs/e_spike2.mdl")) {
		mod->modhint = MOD_RAIL2;
	}
	else if (!strcmp(mod->name, "progs/lavaball.mdl")) {
		mod->modhint = MOD_LAVABALL;
	}
	else if (!strcmp(mod->name, "progs/dgib.mdl") ||
		!strcmp(mod->name, "progs/dgib2.mdl") ||
		!strcmp(mod->name, "progs/dgib3.mdl") ||
		!strcmp(mod->name, "progs/tesgib1.mdl") ||
		!strcmp(mod->name, "progs/tesgib2.mdl") ||
		!strcmp(mod->name, "progs/tesgib3.mdl") ||
		!strcmp(mod->name, "progs/tesgib4.mdl") ||
		!strcmp(mod->name, "progs/tgib1.mdl") ||
		!strcmp(mod->name, "progs/tgib2.mdl") ||
		!strcmp(mod->name, "progs/tgib3.mdl")) {
		mod->modhint = MOD_BUILDINGGIBS;
	}
	else if (!strcmp(mod->name, "progs/backpack.mdl")) {
		mod->modhint = MOD_BACKPACK;
	}
	else if (!strcmp(mod->name, "progs/gib1.mdl") ||
		!strcmp(mod->name, "progs/gib2.mdl") ||
		!strcmp(mod->name, "progs/gib3.mdl") ||
		!strcmp(mod->name, "progs/h_player.mdl")) {
		mod->modhint = MOD_GIB;
	}
	else if (!strncasecmp(mod->name, "progs/v_", 8)) {
		qbool suppress_nolerp = false;

		mod->modhint = MOD_VMODEL;

		// the following models are excluded
		suppress_nolerp |= !strcmp(cl_modelnames[mi_vaxe], mod->name);
		suppress_nolerp |= !strcmp(cl_modelnames[mi_vbio], mod->name);
		suppress_nolerp |= !strcmp(cl_modelnames[mi_vgrap], mod->name);
		suppress_nolerp |= !strcmp(cl_modelnames[mi_vknife], mod->name);
		suppress_nolerp |= !strcmp(cl_modelnames[mi_vknife2], mod->name);
		suppress_nolerp |= !strcmp(cl_modelnames[mi_vmedi], mod->name);
		suppress_nolerp |= !strcmp(cl_modelnames[mi_vspan], mod->name);

		mod->renderfx |= (suppress_nolerp ? 0 : RF_LIMITLERP);
	}
	else if (!strcmp(mod->name, "progs/missile.mdl")) {
		mod->modhint = MOD_ROCKET;
	}
	else if (!strcmp(mod->name, "progs/grenade.mdl") ||
		!strcmp(mod->name, "progs/flare.mdl") ||
		!strcmp(mod->name, "progs/hgren2.mdl") ||
		!strcmp(mod->name, "progs/biggren.mdl") ||
		!strcmp(mod->name, "progs/grenade2.mdl") ||
		!strcmp(mod->name, "progs/grenade3.mdl") ||
		!strcmp(mod->name, "progs/caltrop.mdl")) {
		mod->modhint = MOD_GRENADE;
	}
	else if (!strcmp(mod->name, "progs/g_rock2.mdl")) {
		mod->modhint = MOD_ROCKETLAUNCHER;
	}
	else if (!strcmp(mod->name, "progs/g_light.mdl")) {
		mod->modhint = MOD_LIGHTNINGGUN;
	}
	else if (!strcmp(mod->name, "progs/quaddama.mdl")) {
		mod->modhint = MOD_QUAD;
	}
	else if (!strcmp(mod->name, "progs/invulner.mdl")) {
		mod->modhint = MOD_PENT;
	}
	else if (!strcmp(mod->name, "progs/invisibl.mdl")) {
		mod->modhint = MOD_RING;
	}
	else if (!strcmp(mod->name, "maps/b_bh100.bsp")) {
		mod->modhint = MOD_MEGAHEALTH;
	}
	else if (!strcmp(mod->name, "progs/armor.mdl")) {
		mod->modhint = MOD_ARMOR;
	}
	else if (!strcmp(mod->name, "progs/suit.mdl")) {
		mod->modhint = MOD_SUIT;
	}
	else if (!strcmp(mod->name, "progs/g_rock.mdl")) {
		mod->modhint = MOD_GRENADELAUNCHER;
	}
	else {
		mod->modhint = MOD_NORMAL;
	}
}

texture_ref Mod_LoadSimpleTexture(model_t *mod, int skinnum)
{
	texture_ref tex = null_texture_reference;
	int texmode = 0;
	char basename[64], identifier[64];

	if (!mod) {
		return null_texture_reference;
	}

	if (RuleSets_DisallowExternalTexture(mod)) {
		return null_texture_reference;
	}

	// well, it have nothing with luma, but quite same restrictions...
	if (RuleSets_DisallowSimpleTexture(mod)) {
		return null_texture_reference;
	}

	COM_StripExtension(COM_SkipPath(mod->name), basename, sizeof(basename));

	texmode = TEX_MIPMAP | TEX_ALPHA | TEX_PREMUL_ALPHA;
	if (!gl_scaleModelSimpleTextures.integer) {
		texmode |= TEX_NOSCALE;
	}

	snprintf(identifier, sizeof(identifier), "simple_%s_%d", basename, skinnum);

	if (mod->type == mod_brush) {
		tex = R_LoadTextureImage(va("textures/bmodels/%s", identifier), identifier, 0, 0, texmode);
	}
	else if (mod->type == mod_alias || mod->type == mod_alias3) {
		// hack for loading models saved as .bsp under /maps directory
		if (Utils_RegExpMatch("^(?i)maps\\/b_(.*)\\.bsp", mod->name)) {
			tex = R_LoadTextureImage(va("textures/bmodels/%s", identifier), identifier, 0, 0, texmode);
		}
		else {
			tex = R_LoadTextureImage(va("textures/models/%s", identifier), identifier, 0, 0, texmode);
		}
	}

	if (!R_TextureReferenceIsValid(tex)) {
		tex = R_LoadTextureImage(va("textures/%s", identifier), identifier, 0, 0, texmode);
	}

	if (developer.value > 1) {
		Com_Printf("Mod_LoadSimpleTexture: %s %s\n", identifier, R_TextureReferenceIsValid(tex) ? "OK" : "FAIL");
	}

	if (R_TextureReferenceIsValid(tex) && mod->modhint >= 0 && mod->modhint < MOD_NUMBER_HINTS && skinnum >= 0 && skinnum < MAX_SIMPLE_TEXTURES) {
		mpic_t* pic = &simpleitem_textures[mod->modhint][skinnum];
		pic->texnum = tex;
		pic->width = 16;
		pic->height = 16;
		pic->sl = pic->tl = 0;
		pic->sh = pic->th = 1;

		CachePics_MarkAtlasDirty();
	}

	if (R_TextureReferenceIsValid(tex)) {
		renderer.TextureWrapModeClamp(tex);
	}
	return tex;
}

void Mod_ClearSimpleTextures(void)
{
	memset(simpleitem_textures, 0, sizeof(simpleitem_textures));
}

mpic_t* Mod_SimpleTextureForHint(int model_hint, int skinnum)
{
	if (model_hint > 0 && model_hint < MOD_NUMBER_HINTS && skinnum >= 0 && skinnum < MAX_SIMPLE_TEXTURES) {
		return &simpleitem_textures[model_hint][skinnum];
	}

	return 0;
}

const char* custom_model_names[] = {
	"progs/s_explod.spr",    // custom_model_explosion
	"progs/bolt.mdl",        // custom_model_bolt
	"progs/bolt2.mdl",       // custom_model_bolt2
	"progs/bolt3.mdl",       // custom_model_bolt3
	"progs/beam.mdl",        // custom_model_beam
	"progs/flame0.mdl"       // custom_model_flame0
};

#ifdef C_ASSERT
C_ASSERT(sizeof(custom_model_names) / sizeof(custom_model_names[0]) == custom_model_count);
#endif

model_t* Mod_CustomModel(custom_model_id_t id, qbool crash)
{
	if (id >= 0 && id < sizeof(custom_model_names) / sizeof(custom_model_names[0])) {
		return (cl_custommodels[id] = Mod_ForName(custom_model_names[id], crash));
	}
	return NULL;
}

// Used for lerping between frames
int Mod_ExpectedNextFrame(model_t* mod, int framenum, int framecount)
{
	// axe has 0, 1...4, 5...8
	if (!strcmp(mod->name, cl_modelnames[mi_weapon1]) && framenum == 4) {
		return 0;
	}

	// assume it's increasing
	if (framenum < framecount - 1) {
		return framenum + 1;
	}

	// check for continuous-fire weapons
	if (mod->modhint == MOD_VMODEL) {
		if (!strcmp(mod->name, cl_modelnames[mi_weapon4])) {
			return 1;
		}
		if (!strcmp(mod->name, cl_modelnames[mi_weapon5])) {
			return 1;
		}
		if (!strcmp(mod->name, cl_modelnames[mi_weapon8])) {
			return 1;
		}
	}

	// back to the start
	return 0;
}


================================================
FILE: src/r_netgraph.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// gl_ngraph.c

#include "quakedef.h"
#include "hud.h"
#include "hud_common.h"

#define MAX_NET_GRAPHHEIGHT 256

texture_ref netgraphtexture;	// netgraph texture

// HUD -> hexum

/*
==============
R_MQW_NetGraph
==============
*/
void R_MQW_NetGraph(int outgoing_sequence, int incoming_sequence, int *packet_latency,
                int lost, int minping, int avgping, int maxping, int devping,
                int posx, int posy, int width, int height, int revx, int revy)
{
    int     a, x, i, y;
    char st[80];
    float alpha;

    static hud_t *hud = NULL;
    static cvar_t
        *par_alpha, *par_inframes, *par_maxping, *par_dropheight;

    if (hud == NULL)  // first time
    {
        hud = HUD_Find("netgraph");
        par_alpha      = HUD_FindVar(hud, "alpha");
        par_inframes   = HUD_FindVar(hud, "inframes");
        par_maxping    = HUD_FindVar(hud, "scale");
        par_dropheight = HUD_FindVar(hud, "lostscale");
    }

    CL_CalcNet();

    alpha = par_alpha->value;

	if (width < 0) {
		width = NET_TIMINGS;
	}
    width = min(width, 256);
	if (width < 16) {
		return;
	}

	if (height < 0) {
		height = 32;
	}
	if (height > MAX_NET_GRAPHHEIGHT) {
		height = MAX_NET_GRAPHHEIGHT;
	}
	if (height < 1) {
		return;
	}

	if (alpha < 0 || alpha > 1) {
		alpha = 1;
	}

    if (posx < 0  ||  posy < 0) {
        int w, h;

        w = width;
        h = height;
		if (lost >= 0) {
			h += 8;
		}
		if (!HUD_PrepareDraw(hud, w, h, &posx, &posy)) {
			return;
		}
    }

    x = posx;
    y = posy;

    if (lost >= 0) {
        if (avgping < 0) {
            snprintf(st, sizeof (st)," %3i%% packet loss", lost);
            st[(width-1)/8] = 0;
            Draw_String(x+3, y, st);
        }
        else {
            char buf[128];
            if (lost > 99)
                lost = 99;

            strlcpy(st, "\x1D\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1E\x1F", sizeof (st));
            //snprintf(st, sizeof (st), "%3i%% packet loss, %3i ms ping", lost, avgping);
            snprintf (buf, sizeof (buf), " %i \xf %i%% ", avgping, lost);
            strlcpy (st + strlen(st) - strlen(buf) - 3, buf, sizeof (st) - strlen (st) + strlen (buf) + 3);
            Draw_String(x+4, y, st);
        }

        y += 8;
    }

    for (a=0; a < width; a++) {
        int px, py1, py2;
        unsigned char pColor[4];
        int h, color;

        i = (outgoing_sequence-a-1) & NET_TIMINGSMASK;
        h = packet_latency[i];

		if (h == 10000) {
			color = 0x6f;   // yellow   [rate]
		}
		else if (h == 9999) {
			color = 0x4f;   // red      [lost]
		}
		else if (h == 9998) {
			color = 0xd0;   // blue     [delta]
		}
		else if (h == 10001) {
			color = 4;      // gray     [netlimit]
		}
		else {
			color = 0xfe;   // pink     [ms ping]
		}

        if (h < 9000) {
			if (!par_inframes->value) {
				h = h*height / par_maxping->value;
			}
        }
		else {
			h = min(height, height*par_dropheight->value);
		}
        clamp(h, 0, height);

		memcpy(pColor, (unsigned char *)&d_8to24table[(byte)color], 3);
		if (alpha < 1) {
			pColor[0] *= alpha;
			pColor[1] *= alpha;
			pColor[2] *= alpha;
			pColor[3] = (byte)(alpha * 255);
		}
		else {
			pColor[3] = 255;
		}

        px = x + (revx ? a : width-a-1);
        if (revy) {
            py1 = y + 0;
            py2 = y + h;
        }
        else {
            py1 = y + height;
            py2 = y + height-h;
        }

		Draw_AlphaLineRGB(px, py1, px, py2, 1, RGBAVECT_TO_COLOR(pColor));
    }
}


================================================
FILE: src/r_palette.c
================================================
/*
Copyright (C) 2002-2003 A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "r_local.h"

float vid_gamma = 1.0;
byte vid_gamma_table[256];

unsigned short d_8to16table[256];
unsigned d_8to24table[256];
unsigned d_8to24table2[256];

/************************************* VID GAMMA *************************************/
void Check_Gamma(unsigned char *pal)
{
	float inf;
	unsigned char palette[768];
	int i;

	if (R_OldGammaBehaviour() && vid_gamma != 1) {
		for (i = 0; i < 256; i++) {
			inf = 255 * pow((i + 0.5) / 255.5, vid_gamma) + 0.5;
			if (inf > 255) {
				inf = 255;
			}
			vid_gamma_table[i] = inf;
		}
	}
	else {
		for (i = 0; i < 256; i++) {
			vid_gamma_table[i] = i;
		}
	}

	for (i = 0; i < 768; i++) {
		palette[i] = vid_gamma_table[pal[i]];
	}

	memcpy(pal, palette, sizeof(palette));
}

/************************************* HW GAMMA *************************************/

void VID_SetPalette(unsigned char *palette)
{
	int i;
	byte *pal;
	unsigned r, g, b, v, *table;

	// 8 8 8 encoding
	// Macintosh has different byte order
	pal = palette;
	table = d_8to24table;
	for (i = 0; i < 256; i++) {
		r = pal[0];
		g = pal[1];
		b = pal[2];
		pal += 3;
		v = LittleLong((255 << 24) + (r << 0) + (g << 8) + (b << 16));
		*table++ = v;
	}
	d_8to24table[255] = 0;		// 255 is transparent

	// Tonik: create a brighter palette for bmodel textures
	pal = palette;
	table = d_8to24table2;
	for (i = 0; i < 256; i++) {
		r = pal[0] * (2.0 / 1.5); if (r > 255) r = 255;
		g = pal[1] * (2.0 / 1.5); if (g > 255) g = 255;
		b = pal[2] * (2.0 / 1.5); if (b > 255) b = 255;
		pal += 3;
		*table++ = LittleLong((255 << 24) + (r << 0) + (g << 8) + (b << 16));
	}
	d_8to24table2[255] = 0;	// 255 is transparent
}

qbool R_OldGammaBehaviour(void)
{
	return COM_CheckParm(cmdline_param_client_oldgammabehaviour) > 0;
}


================================================
FILE: src/r_part.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: r_part.c,v 1.19 2007-10-29 00:13:26 d3urk Exp $

*/

#include "quakedef.h"
#include "gl_model.h"
#include "particles_classic.h"
#include "r_sprite3d.h"
#include "rulesets.h"
#include "r_texture.h"
#include "qmb_particles.h"
#include "glm_particles.h"
#include "r_state.h"
#include "r_local.h"
#include "r_renderer.h"
#include "r_framestats.h"

#ifndef RENDERER_OPTION_MODERN_OPENGL
int particletexture_array_index = 0;
float particletexture_array_xpos_tr = 0.9999f;
float particletexture_array_ypos_tr = 0.9999f;
float particletexture_array_max_s = 1.0f;
float particletexture_array_max_t = 1.0f;
#else
extern float particletexture_array_max_s;
extern float particletexture_array_max_t;
#endif

texture_ref particletexture;
const int default_size = 32;

extern cvar_t gl_part_blood;
extern cvar_t gl_part_gunshots;
extern cvar_t gl_part_bloodtrails;
extern cvar_t gl_part_trails;
extern cvar_t gl_part_spikes;
extern cvar_t gl_part_explosions;
extern cvar_t gl_part_blobs;
extern cvar_t gl_part_lavasplash;
extern cvar_t gl_part_telesplash;

cvar_t r_particles_count = { "r_particles_count", "2048" };
static cvar_t r_drawparticles = { "r_drawparticles", "1" };

// Which particles to draw this frame
typedef struct glm_particle_s {
	vec3_t      gl_org;
	float       gl_scale;
	byte        gl_color[4];
} glm_particle_t;

qparticle_t particles[ABSOLUTE_MAX_PARTICLES];
glm_particle_t glparticles[ABSOLUTE_MAX_PARTICLES];
r_sprite3d_vert_t glvertices[ABSOLUTE_MAX_PARTICLES * 3];

static int	ramp1[8] = { 0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61 };
static int	ramp2[8] = { 0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66 };
static int	ramp3[8] = { 0x6d, 0x6b, 6, 5, 4, 3 };

static int r_numparticles;
static int r_numactiveparticles;

float crand(void)
{
	return (rand() & 32767) * (2.0 / 32767) - 1;
}

byte* Classic_CreateParticleTexture(int width, int height)
{
	byte* data = Q_malloc(sizeof(byte) * width * height * 4);
	int x, y;
	int size = min(width, height);
	float quarter = size / 4.0f - 0.5f;
	extern cvar_t gl_squareparticles;

	// draw a circle in the top left corner or square, depends of cvar
	if (gl_squareparticles.integer) {
		for (x = 0; x < size / 2; x++) {
			for (y = 0; y < size / 2; y++) {
				data[(x + y * width) * 4 + 0] = 255;
				data[(x + y * width) * 4 + 1] = 255;
				data[(x + y * width) * 4 + 2] = 255;
				data[(x + y * width) * 4 + 3] = 255;
			}
		}
	}
	else {
		for (x = 0; x < size / 2; x++) {
			for (y = 0; y < size / 2; y++) {
				float edge0 = size / 4.0f;
				float dist = sqrt((x - quarter) * (x - quarter) + (y - quarter) * (y - quarter));

				if (dist < edge0) {
					float edge1 = edge0 - size / 16;

					if (dist < edge1) {
						data[(x + y * width) * 4 + 0] = 255;
						data[(x + y * width) * 4 + 1] = 255;
						data[(x + y * width) * 4 + 2] = 255;
						data[(x + y * width) * 4 + 3] = 255;
					}
					else {
						// smoothstep
						float t = bound((dist - edge1) / (edge0 - edge1), 0, 1);
						float f = 1 - t * t * (3.0 - 2.0 * t);

						data[(x + y * width) * 4 + 0] = 255 * f;
						data[(x + y * width) * 4 + 1] = 255 * f;
						data[(x + y * width) * 4 + 2] = 255 * f;
						data[(x + y * width) * 4 + 3] = 255 * f;
					}
				}
			}
		}
	}

	// draw a square in top-right
	for (x = width - 4; x < width; ++x) {
		for (y = height - 4; y < height; ++y) {
			data[(x + y * width) * 4 + 0] = 255;
			data[(x + y * width) * 4 + 1] = 255;
			data[(x + y * width) * 4 + 2] = 255;
			data[(x + y * width) * 4 + 3] = 255;
		}
	}

	return data;
}

void Classic_LoadParticleTexures(int width, int height)
{
	// TEX_NOSCALE - so no affect from gl_picmip and gl_maxsize
	byte* data = Classic_CreateParticleTexture(width, height);
	particletexture = R_LoadTexture("particles:classic", width, height, data, TEX_MIPMAP | TEX_ALPHA | TEX_NOSCALE, 4);
	renderer.TextureWrapModeClamp(particletexture);
	Q_free(data);

	if (!R_TextureReferenceIsValid(particletexture)) {
		Sys_Error("Classic_LoadParticleTexures: can't load texture");
		return;
	}

#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		GLM_LoadParticleTextures();
	}
#endif
}

void Classic_AllocParticles(void)
{
	r_numparticles = bound(ABSOLUTE_MIN_PARTICLES, r_particles_count.integer, ABSOLUTE_MAX_PARTICLES);
}

void Classic_InitParticles(void)
{
	if (!r_numparticles) {
		Classic_AllocParticles();
	}
	else {
		Classic_ClearParticles(); // also re-alloc particles
	}

	Classic_LoadParticleTexures(default_size, default_size);
}

void Classic_ClearParticles(void)
{
	if (!r_numparticles) {
		return;
	}

	Classic_AllocParticles();	// and alloc again

	r_numactiveparticles = 0;
}

#ifndef CLIENTONLY
void R_ReadPointFile_f(void)
{
	vfsfile_t *v;
	char line[1024];
	const char *s;
	vec3_t org;
	int c;
	qparticle_t *p;
	char name[MAX_OSPATH];

	if (!com_serveractive)
		return;

	snprintf(name, sizeof(name), "maps/%s.pts", host_mapname.string);

	if (!(v = FS_OpenVFS(name, "rb", FS_ANY))) {
		Com_Printf("couldn't open %s\n", name);
		return;
	}

	Com_Printf("Reading %s...\n", name);
	c = 0;
	while (1) {
		VFS_GETS(v, line, sizeof(line));
		s = COM_Parse(line);
		org[0] = atof(com_token);

		s = COM_Parse(s);
		if (!s)
			break;
		org[1] = atof(com_token);

		s = COM_Parse(s);
		if (!s)
			break;
		org[2] = atof(com_token);
		if (COM_Parse(s))
			break;

		c++;
		if (r_numactiveparticles >= r_numparticles) {
			Com_Printf("Not enough free particles\n");
			break;
		}
		p = &particles[r_numactiveparticles++];

		p->die = 99999;
		p->color = (-c) & 15;
		p->type = pt_static;
		VectorClear(p->vel);
		VectorCopy(org, p->org);
	}

	VFS_CLOSE(v);
	Com_Printf("%i points read\n", c);
}
#endif

void Classic_ParticleExplosion(vec3_t org)
{
	int	i, j;
	qparticle_t	*p;

	if (r_explosiontype.value != 9) {
		CL_ExplosionSprite(org);
	}

	if (r_explosiontype.value == 1) {
		return;
	}

	for (i = 0; i < 1024; i++) {
		if (r_numactiveparticles >= r_numparticles) {
			return;
		}
		p = &particles[r_numactiveparticles++];

		p->die = r_refdef2.time + 5;
		p->color = ramp1[0];
		p->ramp = rand() & 3;
		if (i & 1) {
			p->type = pt_explode;
			for (j = 0; j < 3; j++) {
				p->org[j] = org[j] + ((rand() % 32) - 16);
				p->vel[j] = (rand() % 512) - 256;
			}
		}
		else {
			p->type = pt_explode2;
			for (j = 0; j < 3; j++) {
				p->org[j] = org[j] + ((rand() % 32) - 16);
				p->vel[j] = (rand() % 512) - 256;
			}
		}
	}
}

void Classic_BlobExplosion(vec3_t org)
{
	int i, j;
	qparticle_t *p;

	for (i = 0; i < 1024; i++) {
		if (r_numactiveparticles >= r_numparticles) {
			return;
		}
		p = &particles[r_numactiveparticles++];

		p->die = r_refdef2.time + 1 + (rand() & 8) * 0.05;

		if (i & 1) {
			p->type = pt_blob;
			p->color = 66 + rand() % 6;
			for (j = 0; j < 3; j++) {
				p->org[j] = org[j] + ((rand() % 32) - 16);
				p->vel[j] = (rand() % 512) - 256;
			}
		}
		else {
			p->type = pt_blob2;
			p->color = 150 + rand() % 6;
			for (j = 0; j < 3; j++) {
				p->org[j] = org[j] + ((rand() % 32) - 16);
				p->vel[j] = (rand() % 512) - 256;
			}
		}
	}
}

void Classic_RunParticleEffect(vec3_t org, vec3_t dir, int color, int count)
{
	int i, j, scale;
	qparticle_t *p;

	scale = (count > 130) ? 3 : (count > 20) ? 2 : 1;

	if (color == 256)	// gunshot magic
		color = 0;

	for (i = 0; i < count; i++) {
		if (r_numactiveparticles >= r_numparticles) {
			return;
		}
		p = &particles[r_numactiveparticles++];

		p->die = r_refdef2.time + 0.1 * (rand() % 5);
		p->color = (color & ~7) + (rand() & 7);
		p->type = pt_grav;
		for (j = 0; j < 3; j++) {
			p->org[j] = org[j] + scale * ((rand() & 15) - 8);
			p->vel[j] = dir[j] * 15;
		}
	}
}

void Classic_LavaSplash(vec3_t org)
{
	int i, j, k;
	qparticle_t *p;
	float vel;
	vec3_t dir;

	for (i = -16; i < 16; i++) {
		for (j = -16; j < 16; j++) {
			for (k = 0; k < 1; k++) {
				if (r_numactiveparticles >= r_numparticles) {
					return;
				}
				p = &particles[r_numactiveparticles++];

				p->die = r_refdef2.time + 2 + (rand() & 31) * 0.02;
				p->color = 224 + (rand() & 7);
				p->type = pt_grav;

				dir[0] = j * 8 + (rand() & 7);
				dir[1] = i * 8 + (rand() & 7);
				dir[2] = 256;

				p->org[0] = org[0] + dir[0];
				p->org[1] = org[1] + dir[1];
				p->org[2] = org[2] + (rand() & 63);

				VectorNormalizeFast(dir);
				vel = 50 + (rand() & 63);
				VectorScale(dir, vel, p->vel);
			}
		}
	}
}

void Classic_TeleportSplash(vec3_t org)
{
	int i, j, k;
	qparticle_t *p;
	float vel;
	vec3_t dir;

	for (i = -16; i < 16; i += 4) {
		for (j = -16; j < 16; j += 4) {
			for (k = -24; k < 32; k += 4) {
				if (r_numactiveparticles >= r_numparticles) {
					return;
				}
				p = &particles[r_numactiveparticles++];

				p->die = r_refdef2.time + 0.2 + (rand() & 7) * 0.02;
				p->color = 7 + (rand() & 7);
				p->type = pt_grav;

				dir[0] = j * 8;
				dir[1] = i * 8;
				dir[2] = k * 8;

				p->org[0] = org[0] + i + (rand() & 3);
				p->org[1] = org[1] + j + (rand() & 3);
				p->org[2] = org[2] + k + (rand() & 3);

				VectorNormalizeFast(dir);
				vel = 50 + (rand() & 63);
				VectorScale(dir, vel, p->vel);
			}
		}
	}
}

void Classic_ParticleTrail(vec3_t start, vec3_t end, vec3_t* trail_stop, trail_type_t type)
{
	vec3_t point, delta, dir;
	float len;
	int i, j, num_particles;
	qparticle_t *p;
	static int tracercount;

	VectorCopy(start, point);
	VectorSubtract(end, start, delta);
	if (!(len = VectorLength(delta))) {
		goto done;
	}
	VectorScale(delta, 1 / len, dir);	//unit vector in direction of trail

	// Convert from AMF/vult particle trail types
	if (type == AMF_ROCKET_TRAIL) {
		type = ALT_ROCKET_TRAIL;
	}
	else if (type == BLEEDING_TRAIL || type == BLEEDING_TRAIL2) {
		type = BLOOD_TRAIL;
	}
	else if (type == RAIL_TRAIL || type == RAIL_TRAIL2) {
		type = RAIL_TRAIL;
	}
	else if (type == LAVA_TRAIL) {
		type = ROCKET_TRAIL;
	}

	switch (type) {
	case ALT_ROCKET_TRAIL:
		len /= 1.5; break;
	case BLOOD_TRAIL:
		len /= 6; break;
	default:
		len /= 3; break;
	}

	if (!(num_particles = (int)len)) {
		goto done;
	}

	VectorScale(delta, 1.0 / num_particles, delta);

	for (i = 0; i < num_particles && r_numactiveparticles < r_numparticles; i++) {
		p = &particles[r_numactiveparticles++];

		VectorClear(p->vel);
		p->die = r_refdef2.time + 2;

		switch (type) {
		case GRENADE_TRAIL:
			p->ramp = (rand() & 3) + 2;
			p->color = ramp3[(int)p->ramp];
			p->type = pt_fire;
			for (j = 0; j < 3; j++)
				p->org[j] = point[j] + ((rand() % 6) - 3);
			break;
		case BLOOD_TRAIL:
			p->type = pt_slowgrav;
			p->color = 67 + (rand() & 3);
			for (j = 0; j < 3; j++)
				p->org[j] = point[j] + ((rand() % 6) - 3);
			break;
		case BIG_BLOOD_TRAIL:
			p->type = pt_slowgrav;
			p->color = 67 + (rand() & 3);
			for (j = 0; j < 3; j++)
				p->org[j] = point[j] + ((rand() % 6) - 3);
			break;
		case TRACER1_TRAIL:
		case TRACER2_TRAIL:
			p->die = r_refdef2.time + 0.5;
			p->type = pt_static;
			if (type == TRACER1_TRAIL)
				p->color = 52 + ((tracercount & 4) << 1);
			else
				p->color = 230 + ((tracercount & 4) << 1);

			tracercount++;

			VectorCopy(point, p->org);
			if (tracercount & 1) {
				p->vel[0] = 90 * dir[1];
				p->vel[1] = 90 * -dir[0];
			}
			else {
				p->vel[0] = 90 * -dir[1];
				p->vel[1] = 90 * dir[0];
			}
			break;
		case VOOR_TRAIL:
			p->color = 9 * 16 + 8 + (rand() & 3);
			p->type = pt_static;
			p->die = r_refdef2.time + 0.3;
			for (j = 0; j < 3; j++)
				p->org[j] = point[j] + ((rand() & 15) - 8);
			break;
		case ALT_ROCKET_TRAIL:
			p->ramp = (rand() & 3);
			p->color = ramp3[(int)p->ramp];
			p->type = pt_fire;
			for (j = 0; j < 3; j++)
				p->org[j] = point[j] + ((rand() % 6) - 3);
			break;
		case RAIL_TRAIL:
		case ROCKET_TRAIL:
		default:
			p->ramp = (rand() & 3);
			p->color = ramp3[(int)p->ramp];
			p->type = pt_fire;
			for (j = 0; j < 3; j++)
				p->org[j] = point[j] + ((rand() % 6) - 3);
			break;
		}

		VectorAdd(point, delta, point);
	}
done:
	if (trail_stop) {
		VectorCopy(point, *trail_stop);
	}
}

// deurk: ported from zquake, thx Tonik
void Classic_ParticleRailTrail(vec3_t start, vec3_t end, int color)
{
	vec3_t          move, vec, right, up, dir;
	float           len, dec, d, c, s;
	int             i, j;
	qparticle_t      *p;

	VectorCopy(start, move);
	VectorSubtract(end, start, vec);
	len = VectorNormalize(vec);

	MakeNormalVectors(vec, right, up);

	// color spiral
	for (i = 0; i < len; i++) {
		if (r_numactiveparticles >= r_numparticles) {
			return;
		}
		p = &particles[r_numactiveparticles++];

		p->type = pt_rail;

		p->die = r_refdef2.time + 2;

		d = i * 0.1;
		c = cos(d);
		s = sin(d);

		VectorScale(right, c, dir);
		VectorMA(dir, s, up, dir);

		//p->alpha = 1.0;
		//p->alphavel = -1.0 / (1+frand()*0.2);
		p->color = color + (rand() & 7);
		for (j = 0; j < 3; j++) {
			p->org[j] = move[j] + dir[j] * 3;
			p->vel[j] = dir[j] * 2; //p->vel[j] = dir[j]*6;
		}

		VectorAdd(move, vec, move);
	}

	dec = 1.5;
	VectorScale(vec, dec, vec);
	VectorCopy(start, move);

	// white core
	while (len > 0) {
		len -= dec;

		if (r_numactiveparticles >= r_numparticles) {
			return;
		}
		p = &particles[r_numactiveparticles++];

		p->type = pt_rail;

		p->die = r_refdef2.time + 2;

		//p->alpha = 1.0;
		//p->alphavel = -1.0 / (0.6+frand()*0.2);
		p->color = 0x0 + (rand() & 15);

		for (j = 0; j < 3; j++) {
			p->org[j] = move[j] + crand() * 2;
			p->vel[j] = crand()*0.5; //p->vel[j] = crand()*3;
		}

		VectorAdd(move, vec, move);
	}
}

static int particles_to_draw = 0;

// Particles are scaled according to distance from player's POV,
//   so in multi-view we need to recalculate each time
void Classic_ReScaleParticles(void)
{
	float r_partscale = 0.004 * tan(r_refdef.fov_x * (M_PI / 180) * 0.5f);
	int i;
	vec3_t up, right, scaled_vpn;
	r_sprite3d_vert_t* vert;
	float dist_precalc = 0;

	if (particles_to_draw == 0) {
		return;
	}

	vert = glvertices;
	VectorScale(vup, 1.5, up);
	VectorScale(vright, 1.5, right);
	VectorScale(vpn, r_partscale, scaled_vpn);

	dist_precalc = 1 - DotProduct(r_origin, scaled_vpn);
	for (i = 0; i < particles_to_draw; ++i, vert += 3) {
		glm_particle_t* glpart = &glparticles[i];
		float scale = glpart->gl_scale = dist_precalc + DotProduct(glpart->gl_org, scaled_vpn);

		R_Sprite3DSetVert(vert, glpart->gl_org[0], glpart->gl_org[1], glpart->gl_org[2], 0, 0, vert->color, particletexture_array_index);
		R_Sprite3DSetVert(vert + 1, glpart->gl_org[0] + up[0] * scale, glpart->gl_org[1] + up[1] * scale, glpart->gl_org[2] + up[2] * scale, particletexture_array_max_s, 0, vert->color, particletexture_array_index);
		R_Sprite3DSetVert(vert + 2, glpart->gl_org[0] + right[0] * scale, glpart->gl_org[1] + right[1] * scale, glpart->gl_org[2] + right[2] * scale, 0, particletexture_array_max_t, vert->color, particletexture_array_index);
	}
}

// Prepares particles to be drawn this frame
static void Classic_PrepareParticles(void)
{
	qparticle_t* p;
	unsigned char *at;
	float theAlpha;
	float scale;
	vec3_t up, right;
	int i;
	float dist_precalc;
	vec3_t scaled_vpn;

	particles_to_draw = 0;
	if (r_numactiveparticles == 0 || (!r_drawparticles.integer && !Rulesets_RestrictParticles())) {
		return;
	}

	frameStats.particle_count = r_numactiveparticles;

	VectorScale(vup, 1.5, up);
	VectorScale(vright, 1.5, right);
	VectorScale(vpn, 0.004 * r_refdef2.distanceScale, scaled_vpn);

	// load texture if not done yet
	if (!R_TextureReferenceIsValid(particletexture)) {
		Classic_LoadParticleTexures(default_size, default_size);
	}

	p = particles;
	dist_precalc = 1 - DotProduct(r_origin, scaled_vpn);
	for (i = 0; i < r_numactiveparticles; ++i, ++p) {
		if (p->die >= r_refdef2.time) {
			glm_particle_t* glpart;
			r_sprite3d_vert_t* vert;

			// hack a scale up to keep particles from disapearing
			scale = dist_precalc + DotProduct(p->org, scaled_vpn);

			glpart = &glparticles[particles_to_draw];
			vert = &glvertices[particles_to_draw * 3];
			at = (byte *)&d_8to24table[(int)p->color];

			if (p->type == pt_fire) {
				theAlpha = (6 - p->ramp) / 6;
				glpart->gl_color[0] = at[0] * theAlpha;
				glpart->gl_color[1] = at[1] * theAlpha;
				glpart->gl_color[2] = at[2] * theAlpha;
				glpart->gl_color[3] = 255 * theAlpha;
			}
			else {
				glpart->gl_color[0] = at[0];
				glpart->gl_color[1] = at[1];
				glpart->gl_color[2] = at[2];
				glpart->gl_color[3] = 255;
			}

			glpart->gl_scale = scale;
			VectorCopy(p->org, glpart->gl_org);

			*((unsigned int*)vert->color) = *(unsigned int*)glpart->gl_color;
			VectorSet(vert->tex, 0, 0, particletexture_array_index);
			VectorSet(vert->position, glpart->gl_org[0], glpart->gl_org[1], glpart->gl_org[2]);
			++vert;

			*((unsigned int*)vert->color) = *(unsigned int*)glpart->gl_color;
			VectorSet(vert->tex, particletexture_array_max_s, 0, particletexture_array_index);
			VectorSet(vert->position, glpart->gl_org[0] + up[0] * scale, glpart->gl_org[1] + up[1] * scale, glpart->gl_org[2] + up[2] * scale);
			++vert;

			*((unsigned int*)vert->color) = *(unsigned int*)glpart->gl_color;
			VectorSet(vert->tex, 0, particletexture_array_max_t, particletexture_array_index);
			VectorSet(vert->position, glpart->gl_org[0] + right[0] * scale, glpart->gl_org[1] + right[1] * scale, glpart->gl_org[2] + right[2] * scale);
			++vert;

			++particles_to_draw;
		}
	}
}

void R_InitParticles(void)
{
	if (!host_initialized) {
		int i;

		Cvar_SetCurrentGroup(CVAR_GROUP_PARTICLES);
		Cvar_Register(&r_particles_count);
		Cvar_Register(&r_drawparticles);
		Cvar_ResetCurrentGroup();

		if ((i = COM_CheckParm(cmdline_param_client_particlecount)) && i + 1 < COM_Argc()) {
			Cvar_SetValue(&r_particles_count, Q_atoi(COM_Argv(i + 1)));
		}
	}

	Classic_InitParticles();
	QMB_InitParticles();
}

void R_ParticleFrame(void)
{
	if (!r_worldentity.model || !cl.worldmodel) {
		return;
	}

	Classic_PrepareParticles();
	QMB_CalculateParticles();
}

void R_ClearParticles(void)
{
	Classic_ClearParticles();
	QMB_ClearParticles();
}

void R_DrawParticles(void)
{
	if (!r_drawparticles.integer && !Rulesets_RestrictParticles()) {
		return;
	}

	if (CL_MultiviewEnabled() && CL_MultiviewCurrentView() != 0) {
		Classic_ReScaleParticles();
	}

	if (particles_to_draw) {
		renderer.DrawClassicParticles(particles_to_draw);
	}
	QMB_DrawParticles();
}

#define RunParticleEffect(var, org, dir, color, count)		\
	if (qmb_initialized && gl_part_##var.value)				\
		QMB_RunParticleEffect(org, dir, color, count);		\
	else													\
		Classic_RunParticleEffect(org, dir, color, count);

void R_RunParticleEffect(vec3_t org, vec3_t dir, int color, int count)
{
	if (color == 73 || color == 225) {
		RunParticleEffect(blood, org, dir, color, count);
		return;
	}

	if (color == 256 /* gunshot magic */) {
		RunParticleEffect(gunshots, org, dir, color, count);
		return;
	}

	switch (count) {
	case 10:
	case 20:
	case 30:
		RunParticleEffect(spikes, org, dir, color, count);
		break;
	case 50: // LG Blood
		RunParticleEffect(blood, org, dir, color, count);
		return;
	default:
		RunParticleEffect(gunshots, org, dir, color, count);
	}
}

// Used for temporary entities and untrackable effects
void R_ParticleTrail(vec3_t start, vec3_t end, trail_type_t type)
{
	switch(type){
		case BLOOD_TRAIL:
		case BIG_BLOOD_TRAIL:
		if (qmb_initialized && gl_part_bloodtrails.integer) {
			QMB_ParticleTrail(start, end, type);
		}
		else {
			Classic_ParticleTrail(start, end, NULL, type);
		}
		break;
		default:
		if (qmb_initialized && gl_part_trails.integer) {
			QMB_ParticleTrail(start, end, type);
		}
		else {
			Classic_ParticleTrail(start, end, NULL, type);
		}
		break;
	}
}

void R_EntityParticleTrail(centity_t* cent, trail_type_t type)
{
	switch(type){
		case BLOOD_TRAIL:
		case BIG_BLOOD_TRAIL:
		if (qmb_initialized && gl_part_bloodtrails.integer) {
			QMB_EntityParticleTrail(cent, type);
		}
		else {
			Classic_ParticleTrail(cent->trails[0].stop, cent->lerp_origin, &cent->trails[0].stop, type);
		}
		break;
		default:
		if (qmb_initialized && gl_part_trails.integer) {
			QMB_EntityParticleTrail(cent, type);
		}
		else {
			Classic_ParticleTrail(cent->trails[0].stop, cent->lerp_origin, &cent->trails[0].stop, type);
		}
		break;
	}
}

#define ParticleFunction(var, name)				\
void R_##name (vec3_t org) {					\
	if (qmb_initialized && gl_part_##var.value)	\
		QMB_##name(org);						\
	else										\
		Classic_##name(org);					\
}

ParticleFunction(explosions, ParticleExplosion);
ParticleFunction(blobs, BlobExplosion);
ParticleFunction(lavasplash, LavaSplash);
ParticleFunction(telesplash, TeleportSplash);

// Moves particles into new locations this frame
static void Classic_MoveParticles(void)
{
	qparticle_t *p;
	int i;
	float time2, time3, time1, dvel, frametime, grav;

	if (r_numactiveparticles == 0) {
		return;
	}

	frametime = cls.frametime;
	if (ISPAUSED) {
		frametime = 0;
	}
	time3 = frametime * 15;
	time2 = frametime * 10; // 15;
	time1 = frametime * 5;
	grav = frametime * 800 * 0.05;
	dvel = 4 * frametime;

	p = particles;
	for (i = 0; i < r_numactiveparticles; ++i, ++p) {
		while (p->die < r_refdef2.time) {
			if (i >= r_numactiveparticles - 1) {
				goto finished;
			}

			*p = particles[r_numactiveparticles - 1];
			--r_numactiveparticles;
		}

		VectorMA(p->org, frametime, p->vel, p->org);

		switch (p->type) {
			case pt_static:
				break;
			case pt_fire:
				p->ramp += time1;
				if (p->ramp >= 6) {
					p->die = -1;
				}
				else {
					p->color = ramp3[(int)p->ramp];
				}
				p->vel[2] += grav;
				break;
			case pt_explode:
				p->ramp += time2;
				if (p->ramp >= 8) {
					p->die = -1;
				}
				else {
					p->color = ramp1[(int)p->ramp];
				}
				VectorMA(p->vel, dvel, p->vel, p->vel);
				p->vel[2] -= grav * 30;
				break;
			case pt_explode2:
				p->ramp += time3;
				if (p->ramp >= 8) {
					p->die = -1;
				}
				else {
					p->color = ramp2[(int)p->ramp];
				}
				VectorMA(p->vel, -frametime, p->vel, p->vel);
				p->vel[2] -= grav * 30;
				break;
			case pt_blob:
				VectorMA(p->vel, dvel, p->vel, p->vel);
				p->vel[2] -= grav;
				break;
			case pt_blob2:
				VectorMA(p->vel, -dvel, p->vel, p->vel);
				p->vel[2] -= grav;
				break;
			case pt_slowgrav:
			case pt_grav:
				p->vel[2] -= grav;
				break;
			case pt_rail:
				break;
		}
	}

finished:
	return;
}

void R_ParticleEndFrame(void)
{
	Classic_MoveParticles();
}


================================================
FILE: src/r_part_trails.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "vx_stuff.h"
#include "qmb_particles.h"

static int fix_trail_num_for_grens(int trail_num)
{
	//trails for rockets and grens are the same
	//only nums 1 and 2 must be swapped
	switch (trail_num) {
		case 1: trail_num = 2; break;
		case 2: trail_num = 1; break;
	}

	return trail_num;
}

static void R_MissileTrail(centity_t *cent, int trail_num)
{
	if ((trail_num == 8 || trail_num == 10 || trail_num == 11) && !qmb_initialized) {
		trail_num = 1;
	}

	if (trail_num == 0) {
		VectorCopy(cent->current.origin, cent->trails[0].stop);
	}
	else if (trail_num == 1) {
		R_EntityParticleTrail(cent, ROCKET_TRAIL);
	}
	else if (trail_num == 2) {
		R_EntityParticleTrail(cent, GRENADE_TRAIL);
	}
	else if (trail_num == 3) {
		R_EntityParticleTrail(cent, ALT_ROCKET_TRAIL);
	}
	else if (trail_num == 4) {
		R_EntityParticleTrail(cent, BLOOD_TRAIL);
	}
	else if (trail_num == 5) {
		R_EntityParticleTrail(cent, BIG_BLOOD_TRAIL);
	}
	else if (trail_num == 6) {
		R_EntityParticleTrail(cent, TRACER1_TRAIL);
	}
	else if (trail_num == 7) {
		R_EntityParticleTrail(cent, TRACER2_TRAIL);
	}
	else if (trail_num == 8) {
		// VULT PARTICLES
		byte color[3];
		color[0] = 0; color[1] = 70; color[2] = 255;
		FireballTrail(cent, color, 2, 0.5);
	}
	else if (trail_num == 9) {
		R_EntityParticleTrail(cent, LAVA_TRAIL);
	}
	else if (trail_num == 10) {
		// VULT PARTICLES
		FuelRodGunTrail(cent);
	}
	else if (trail_num == 11) {
		byte color[3];
		color[0] = 255; color[1] = 70; color[2] = 5;
		FireballTrailWave(cent, color, 2, 0.5, cent->current.angles);
	}
	else if (trail_num == 12) {
		R_EntityParticleTrail(cent, AMF_ROCKET_TRAIL);
	}
	else if (trail_num == 14) {
		R_EntityParticleTrail(cent, RAIL_TRAIL);
	}
	else {
		R_EntityParticleTrail(cent, GRENADE_TRAIL);
	}
}

// Moved out of CL_LinkPacketEntities() so NQD playback can use same code.
void CL_AddParticleTrail(entity_t* ent, centity_t* cent, customlight_t* cst_lt, entity_state_t *state)
{
	extern cvar_t gl_no24bit;
	model_t* model = cl.model_precache[state->modelindex];
	float rocketlightsize = 0.0f;

	if (model->modhint == MOD_LAVABALL) {
		R_EntityParticleTrail(cent, LAVA_TRAIL);
	}
	else {
		if (model->flags & EF_ROCKET) {
			R_MissileTrail(cent, r_rockettrail.integer);

			// Add rocket lights
			rocketlightsize = 200.0 * bound(0, r_rocketlight.value, 1);
			if (rocketlightsize >= 1) {
				extern cvar_t gl_rl_globe;
				int bubble = gl_rl_globe.integer ? 2 : 1;

				if ((r_rockettrail.value < 8 || r_rockettrail.value == 12) && model->modhint != MOD_LAVABALL) {
					dlightColorEx(r_rocketlightcolor.value, r_rocketlightcolor.string, lt_rocket, false, cst_lt);
					CL_NewDlightEx(state->number, ent->origin, rocketlightsize, 0.1, cst_lt, bubble);
					if (!ISPAUSED && amf_coronas.integer) {
						//VULT CORONAS
						R_CoronasEntityNew(C_ROCKETLIGHT, cent);
					}
				}
				else if (r_rockettrail.value == 9 || r_rockettrail.value == 11) {
					CL_NewDlight(state->number, ent->origin, rocketlightsize, 0.1, lt_default, bubble);
				}
				else if (r_rockettrail.value == 8) {
					// PLASMA ROCKETS
					CL_NewDlight(state->number, ent->origin, rocketlightsize, 0.1, lt_blue, bubble);
				}
				else if (r_rockettrail.value == 10) {
					// FUEL ROD GUN
					CL_NewDlight(state->number, ent->origin, rocketlightsize, 0.1, lt_green, bubble);
				}
			}
		}
		else if (model->flags & EF_GRENADE) {
			if (model->modhint == MOD_BUILDINGGIBS) {
				R_EntityParticleTrail(cent, GRENADE_TRAIL);
			}
			else if (r_grenadetrail.integer && model->modhint != MOD_RAIL) {
				R_MissileTrail(cent, fix_trail_num_for_grens(r_grenadetrail.integer));
			}
			else if (r_railtrail.integer && model->modhint == MOD_RAIL) {
				R_MissileTrail(cent, fix_trail_num_for_grens(r_railtrail.integer));
			}
			else {
				R_MissileTrail(cent, 0);
			}
		}
		else if (model->flags & EF_GIB) {
			if (amf_part_gibtrails.integer) {
				R_EntityParticleTrail(cent, BLEEDING_TRAIL);
			}
			else {
				R_EntityParticleTrail(cent, BLOOD_TRAIL);
			}
		}
		else if (model->flags & EF_ZOMGIB) {
			if (model->modhint == MOD_RAIL2) {
				R_EntityParticleTrail(cent, RAIL_TRAIL2);
			}
			else if (amf_part_gibtrails.value) {
				R_EntityParticleTrail(cent, BLEEDING_TRAIL);
			}
			else {
				R_EntityParticleTrail(cent, BIG_BLOOD_TRAIL);
			}
		}
		else if (model->flags & EF_TRACER) {
			// VULT TRACER GLOW
			rocketlightsize = 35 * (1 + bound(0, r_rocketlight.value, 1));
			CL_NewDlight(state->number, ent->origin, rocketlightsize, 0.01, lt_green, true);
			if (!ISPAUSED && amf_coronas.integer) {
				R_CoronasEntityNew(C_WIZLIGHT, cent);
			}

			R_EntityParticleTrail(cent, TRACER1_TRAIL);
		}
		else if (model->flags & EF_TRACER2) {
			// VULT TRACER GLOW
			rocketlightsize = 35 * (1 + bound(0, r_rocketlight.value, 1));
			CL_NewDlight(state->number, ent->origin, rocketlightsize, 0.01, lt_default, true);
			if (!ISPAUSED && amf_coronas.integer) {
				R_CoronasEntityNew(C_KNIGHTLIGHT, cent);
			}

			R_EntityParticleTrail(cent, TRACER2_TRAIL);
		}
		else if (model->flags & EF_TRACER3) {
			// VULT TRACER GLOW
			rocketlightsize = 35 * (1 + bound(0, r_rocketlight.value, 1));
			CL_NewDlight(state->number, ent->origin, rocketlightsize, 0.01, lt_blue, true);
			if (!ISPAUSED && amf_coronas.integer) {
				R_CoronasEntityNew(C_VORELIGHT, cent);
			}

			R_EntityParticleTrail(cent, VOOR_TRAIL);
		}
		else if (model->modhint == MOD_SPIKE && amf_nailtrail.integer && !gl_no24bit.integer) {
			// VULT NAILTRAIL
			if (amf_nailtrail_plasma.integer) {
				byte color[3];
				color[0] = 0; color[1] = 70; color[2] = 255;
				FireballTrail(cent, color, 0.6, 0.3);
			}
			else {
				ParticleNailTrail(cent, 2, 0.4f);
			}
		}
		else if (model->modhint_trail == MOD_TF_TRAIL && amf_extratrails.integer) {
			// VULT TRAILS
			ParticleAlphaTrail(cent, 4, 0.4);
		}
		else if (model->modhint == MOD_LASER && amf_extratrails.integer) {
			rocketlightsize = 35 * (1 + bound(0, r_rocketlight.value, 1));
			CL_NewDlight(state->number, ent->origin, rocketlightsize, 0.01, lt_default, true);
			if (!ISPAUSED && amf_coronas.integer) {
				R_CoronasEntityNew(C_KNIGHTLIGHT, cent);
			}
			if (cent->trails[1].lasttime + 0.01 < particle_time) {
				VX_LightningTrail(cent->trails[1].stop, ent->origin);
				VectorCopy(ent->origin, cent->trails[1].stop);
				cent->trails[1].lasttime = particle_time;
			}
			R_EntityParticleTrail(cent, TRACER2_TRAIL);
		}
		else if (model->modhint == MOD_DETPACK) {
			// VULT CORONAS
			if (qmb_initialized && amf_detpacklights.integer) {
				vec3_t liteorg, forward, right, up;
				VectorCopy(ent->origin, liteorg);
				AngleVectors(ent->angles, forward, right, up);
				VectorMA(liteorg, -15, up, liteorg);
				VectorMA(liteorg, -10, forward, liteorg);

				// MEAG: Fixme, was *old_origin, liteorg, cent->trail_origin - need to add check for detpack in ParticleAlphaTrail (?)
				ParticleAlphaTrail(cent, 10, 0.8);
				if (!ISPAUSED && amf_coronas.integer) {
					if (ent->skinnum > 0) {
						R_CoronasNew(C_REDLIGHT, liteorg);
					}
					else {
						R_CoronasNew(C_GREENLIGHT, liteorg);
					}
				}
			}
		}

		// VULT BUILDING SPARKS
		if (!ISPAUSED && amf_buildingsparks.value && (model->modhint == MOD_BUILDINGGIBS && (rand() % 40 < 2))) {
			vec3_t liteorg, forward, right, up;
			byte col[3] = { 60, 100, 240 };
			VectorCopy(ent->origin, liteorg);
			AngleVectors(ent->angles, forward, right, up);
			VectorMA(liteorg, rand() % 10 - 5, up, liteorg);
			VectorMA(liteorg, rand() % 10 - 5, right, liteorg);
			VectorMA(liteorg, rand() % 10 - 5, forward, liteorg);
			SparkGen(liteorg, col, (int)(6 * amf_buildingsparks.value), 100, 1);
			if (amf_coronas.integer) {
				R_CoronasNew(C_BLUESPARK, liteorg);
			}
		}

		// VULT TESLA CHARGE - Tesla or shambler in charging animation
		if (((model->modhint == MOD_TESLA && ent->frame >= 7 && ent->frame <= 12) ||
			(model->modhint == MOD_SHAMBLER && ent->frame >= 65 && ent->frame <= 68))
			&& !ISPAUSED && amf_cutf_tesla_effect.value) {
			vec3_t liteorg;
			VectorCopy(ent->origin, liteorg);
			liteorg[2] += 32;
			VX_TeslaCharge(liteorg);
		}
	}
}


================================================
FILE: src/r_particles_qmb.c
================================================
/*
Copyright (C) 2002-2003, Dr Labman, A. Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "vx_stuff.h"
#include "pmove.h"
#include "glm_texture_arrays.h"
#include "r_particles_qmb.h"
#include "qmb_particles.h"
#include "r_texture.h"
#include "r_matrix.h"
#include "r_state.h"

//VULT
static float varray_vertex[16];

int ParticleCount, ParticleCountHigh, CoronaCount, CoronaCountHigh;

#define FLAME_FRAME_TOTAL      50  // how many sequences we have, per lifetime
#define FLAME_GRAVITY          10  // how quickly it increases

typedef struct flame_s {
	vec3_t pos;
	unsigned char alpha;
	float size;
} flame_t;

static flame_t flame_frames[FLAME_FRAME_TOTAL][FLAME_FRAME_TOTAL];

static void R_ParticleFlamePrecalculate(void)
{
	int i, p;

	for (i = 0; i < FLAME_FRAME_TOTAL; ++i) {
		// Create first frame
		float vel_x = lhrandom(-3, 3); // (rand() % 6) - 3;
		float vel_y = lhrandom(-3, 3); // (rand() % 6) - 3;

		for (p = 0; p < FLAME_FRAME_TOTAL; ++p) {
			float t = (1.0f / FLAME_FRAME_TOTAL) * p;
			flame_t* f = &flame_frames[(p + i) % FLAME_FRAME_TOTAL][p];

			f->pos[0] = vel_x * t;
			f->pos[1] = vel_y * t;
			f->pos[2] = (1 + FLAME_GRAVITY * t * t) * 4;
			f->alpha = (unsigned char)((1 - (p * 1.0f / FLAME_FRAME_TOTAL)) * 200.0f);
			f->size = 7 - 3.5 * t * 0.8f;
		}
	}
}

//VULT PARTICLES
void RainSplash(vec3_t org);
void ParticleStats (int change);
void VX_ParticleTrail (vec3_t start, vec3_t end, float size, float time, col_t color);
static void R_PreCalcBeamVerts(vec3_t org1, vec3_t org2, vec3_t right1, vec3_t right2);
static void R_CalcBeamVerts(float *vert, const vec3_t org1, const vec3_t org2, const vec3_t right1, const vec3_t right2, float width);

typedef struct part_blend_info_s {
	r_blendfunc_t func;

	func_color_transform_t color_transform;
} part_blend_info_t;

static void blend_premult_alpha(col_t input, col_t output)
{
	float alpha = input[3] / 255.0f;

	output[0] = input[0] * alpha;
	output[1] = input[1] * alpha;
	output[2] = input[2] * alpha;
	output[3] = input[3];
}

static void blend_additive(col_t input, col_t output)
{
	float alpha = input[3] / 255.0f;

	output[0] = input[0] * alpha;
	output[1] = input[1] * alpha;
	output[2] = input[2] * alpha;
	output[3] = 0;
}

static void blend_one_one(col_t input, col_t output)
{
	output[0] = input[0];
	output[1] = input[1];
	output[2] = input[2];
	output[3] = 0;
}

static void blend_color_constant(col_t input, col_t output)
{
	output[0] = output[1] = output[2] = 0;
	output[3] = input[3];
}

static part_blend_info_t blend_options[NUMBER_OF_BLEND_TYPES] = {
	// BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA
	{ r_blendfunc_premultiplied_alpha, blend_premult_alpha },
	// BLEND_GL_SRC_ALPHA_GL_ONE (additive)
	{ r_blendfunc_premultiplied_alpha, blend_additive },
	// BLEND_GL_ONE_GL_ONE, (meag: was blend_additive... telesplash only)
	{ r_blendfunc_premultiplied_alpha, blend_one_one },
	// BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR_CONSTANT
	{ r_blendfunc_premultiplied_alpha, blend_color_constant },
	// BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR, (this is now for varying color only, can't convert?)
	{ r_blendfunc_src_zero_dest_one_minus_src_color, blend_premult_alpha }
};

#define MAX_BEAM_TRAIL 10
#define TEXTURE_DETAILS(x) (R_UseModernOpenGL() ? x->tex_array : x->texnum),(x->tex_index)

static float sint[7] = {0.000000, 0.781832, 0.974928, 0.433884, -0.433884, -0.974928, -0.781832};
static float cost[7] = {1.000000, 0.623490, -0.222521, -0.900969, -0.900969, -0.222521, 0.623490};

static particle_t* particles;
particle_t* free_particles;
particle_texture_t particle_textures[num_particletextures];
particle_type_t particle_types[num_particletypes];
int particle_type_index[num_particletypes];

static int r_numparticles;		
float particle_time;

qbool qmb_initialized = false;

static cvar_t gl_clipparticles = {"gl_clipparticles", "1"};
static cvar_t gl_part_cache = { "gl_part_cache", "1", CVAR_LATCH_GFX };
static cvar_t gl_bounceparticles = {"gl_bounceparticles", "1"};
cvar_t amf_part_fulldetail = { "gl_particle_fulldetail", "0", CVAR_LATCH_GFX };

static int ParticleContents(particle_t* p, vec3_t movement)
{
	if (gl_part_cache.integer) {
		float moved;

		VectorAdd(p->cached_movement, movement, p->cached_movement);
		moved = p->cached_movement[0] * p->cached_movement[0] + p->cached_movement[1] * p->cached_movement[1] + p->cached_movement[2] * p->cached_movement[2];

		if (p->cached_distance <= moved) {
			p->cached_contents = CM_CachedHullPointContents(&cl.clipmodels[1]->hulls[0], 0, p->org, &p->cached_distance);

			VectorClear(p->cached_movement);
			p->cached_distance *= p->cached_distance;
		}

		return p->cached_contents;
	}
	else {
		return CM_HullPointContents(&cl.clipmodels[1]->hulls[0], 0, p->org);
	}
}

qbool TraceLineN (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal)
{
	trace_t trace = PM_TraceLine (start, end);

	VectorCopy (trace.endpos, impact);

	if (normal)
		VectorCopy (trace.plane.normal, normal);

	if (!trace.allsolid)
		return false;

	if (trace.startsolid)
		return false;

	return true;
}

#define ADD_PARTICLE_TEXTURE(_ptex, _texnum, _texindex, _components, _s1, _t1, _s2, _t2)	\
do {																						\
	particle_textures[_ptex].texnum = _texnum;												\
	particle_textures[_ptex].components = _components;										\
	particle_textures[_ptex].coords[_texindex][0] = (_s1 + 1) / 256.0;						\
	particle_textures[_ptex].coords[_texindex][1] = (_t1 + 1) / 256.0;						\
	particle_textures[_ptex].coords[_texindex][2] = (_s2 - 1) / 256.0;						\
	particle_textures[_ptex].coords[_texindex][3] = (_t2 - 1) / 256.0;						\
	memcpy(particle_textures[_ptex].originalCoords, particle_textures[_ptex].coords, sizeof(particle_textures[_ptex].originalCoords)); \
} while(0);

static void QMB_AddParticleType(part_type_t id, part_draw_t drawtype, int blendtype, part_tex_t texture_id, float startalpha, float grav, float accel, part_move_t move, float custom, int verts_per_primitive, int* count, const char* name)
{
	particle_type_t* type = &particle_types[*count];

	if (blend_options[blendtype].func == r_blendfunc_src_zero_dest_one_minus_src_color) {
		if (R_TextureReferenceIsValid(particle_textures[texture_id].texnum)) {
			type->state = r_state_particles_qmb_textured_blood;
		}
		else {
			Sys_Error("No rendering state available for QMB particle type %s", name);
		}
	}
	else if (blend_options[blendtype].func == r_blendfunc_premultiplied_alpha) {
		if (R_TextureReferenceIsValid(particle_textures[texture_id].texnum)) {
			type->state = r_state_particles_qmb_textured;
		}
		else {
			type->state = r_state_particles_qmb_untextured;
		}
	}
	else {
		Sys_Error("No rendering state available for QMB particle type %s", name);
	}
	type->blendtype = blendtype;
	type->id = id;
	type->drawtype = drawtype;
	type->texture = texture_id;
	type->startalpha = startalpha;
	type->grav = 9.8 * grav;
	type->accel = accel;
	type->move = move;
	type->custom = custom;
	type->verts_per_primitive = verts_per_primitive;
	type->billboard_type = SPRITE3D_PARTICLES_NEW_p_spark + id;
	assert(type->billboard_type < SPRITE3D_PARTICLES_NEW_LIMIT);
	particle_type_index[id] = *count;
	*count = *count + 1;
}

static int QMB_CompareParticleType(const void* lhs_, const void* rhs_)
{
	const particle_type_t* lhs = (const particle_type_t*)lhs_;
	const particle_type_t* rhs = (const particle_type_t*)rhs_;
	int comparison;

	comparison = lhs->blendtype - rhs->blendtype;
	comparison = comparison ? comparison : lhs->texture - rhs->texture;

	return comparison;
}

static void QMB_SortParticleTypes(void)
{
	int i;

	// To reduce state changes: Sort by blend mode, then texture
	qsort(particle_types, num_particletypes, sizeof(particle_types[0]), QMB_CompareParticleType);

	// Fix up references
	for (i = 0; i < num_particletypes; ++i) {
		particle_type_index[particle_types[i].id] = i;
	}
}

void QMB_AllocParticles(void)
{
	extern cvar_t r_particles_count;

	r_numparticles = bound(ABSOLUTE_MIN_PARTICLES, r_particles_count.integer, ABSOLUTE_MAX_PARTICLES);

	if (particles || r_numparticles < 1) {
		// seems QMB_AllocParticles() called from wrong place
		Sys_Error("QMB_AllocParticles: internal error");
	}

	// can't alloc on Hunk, using native memory
	particles = (particle_t *)Q_malloc(r_numparticles * sizeof(particle_t));
}

static void QMB_PreMultiplyAlpha(byte* data, int width, int height)
{
	int x, y;

	// Adjust particle font as we simplified the blending rules...
	for (x = 0; x < width; ++x) {
		for (y = 0; y < height; ++y) {
			byte* base = data + (x + y * width) * 4;

			// Pre-multiply alpha
			base[0] = (byte)(((int)base[0] * (int)base[3]) / 255.0);
			base[1] = (byte)(((int)base[1] * (int)base[3]) / 255.0);
			base[2] = (byte)(((int)base[2] * (int)base[3]) / 255.0);
		}
	}
}

static void QMB_LoadTextureSubImage(part_tex_t tex, const char* id, const byte* pixels, byte* temp_buffer, int full_width, int full_height, int texIndex, int components, int sub_x, int sub_y, int sub_x2, int sub_y2)
{
	const int mode = TEX_ALPHA | TEX_COMPLAIN | TEX_NOSCALE | TEX_MIPMAP;
	texture_ref tex_ref;
	int y;
	int width = sub_x2 - sub_x;
	int height = sub_y2 - sub_y;

	width = (width * full_width) / 256;
	height = (height * full_height) / 256;
	sub_x = (sub_x * full_width) / 256;
	sub_y = (sub_y * full_height) / 256;

	for (y = 0; y < height; ++y) {
		memcpy(temp_buffer + y * width * 4, pixels + ((sub_y + y) * full_width + sub_x) * 4, width * 4);
	}

	QMB_PreMultiplyAlpha(temp_buffer, width, height);

	tex_ref = R_LoadTexture(id, width, height, temp_buffer, mode, 4);

	ADD_PARTICLE_TEXTURE(tex, tex_ref, texIndex, components, 0, 0, 256, 256);
}

static texture_ref QMB_LoadTextureImage(const char* path)
{
	const int mode = TEX_ALPHA | TEX_COMPLAIN | TEX_NOSCALE | TEX_MIPMAP | TEX_PREMUL_ALPHA;

	return R_LoadTextureImage(path, NULL, 0, 0, mode);
}

void QMB_InitParticles(void)
{
	int	i, count = 0;
	texture_ref shockwave_texture, lightning_texture, spark_texture;

	Cvar_Register(&amf_part_fulldetail);
	Cvar_Register(&gl_part_cache);
	if (!host_initialized && COM_CheckParm(cmdline_param_client_detailtrails)) {
		Cvar_LatchedSetValue(&amf_part_fulldetail, 1);
	}

	if (!qmb_initialized) {
		if (!host_initialized) {
			Cvar_SetCurrentGroup(CVAR_GROUP_PARTICLES);
			Cvar_Register(&gl_clipparticles);
			Cvar_Register(&gl_bounceparticles);
			Cvar_ResetCurrentGroup();
		}

		Q_free(particles); // yeah, shit happens, work around
		QMB_AllocParticles();
	}

	QMB_ClearParticles(); // re-alloc particles, and create linked list of next free particle
	qmb_initialized = false; // so QMB particle system will be turned off if we fail to load some texture

	ADD_PARTICLE_TEXTURE(ptex_none, null_texture_reference, 0, 1, 0, 0, 0, 0);

	// Move particle fonts off atlas and into their own textures...
	{
		int real_width, real_height;
		byte* original;
		byte* temp_buffer;

		original = R_LoadImagePixels("textures/particles/particlefont", 0, 0, TEX_ALPHA | TEX_COMPLAIN | TEX_NOSCALE | TEX_MIPMAP, &real_width, &real_height);
		if (!original) {
			return;
		}

		temp_buffer = Q_malloc(real_width * real_height * 4);
		QMB_LoadTextureSubImage(ptex_blood1, "qmb:blood1", original, temp_buffer, real_width, real_height, 0, 1, 0, 0, 64, 64);
		QMB_LoadTextureSubImage(ptex_blood2, "qmb:blood2", original, temp_buffer, real_width, real_height, 0, 1, 64, 0, 128, 64);
		QMB_LoadTextureSubImage(ptex_lava, "qmb:lava", original, temp_buffer, real_width, real_height, 0, 1, 128, 0, 192, 64);
		QMB_LoadTextureSubImage(ptex_blueflare, "qmb:blueflare", original, temp_buffer, real_width, real_height, 0, 1, 192, 0, 256, 64);
		QMB_LoadTextureSubImage(ptex_generic, "qmb:generic", original, temp_buffer, real_width, real_height, 0, 1, 0, 96, 96, 192);
		QMB_LoadTextureSubImage(ptex_smoke, "qmb:smoke", original, temp_buffer, real_width, real_height, 0, 1, 96, 96, 192, 192);
		QMB_LoadTextureSubImage(ptex_blood3, "qmb:blood3", original, temp_buffer, real_width, real_height, 0, 1, 192, 96, 256, 160);
		QMB_LoadTextureSubImage(ptex_bubble, "qmb:bubble", original, temp_buffer, real_width, real_height, 0, 1, 192, 160, 224, 192);
		for (i = 0; i < 8; i++) {
			QMB_LoadTextureSubImage(ptex_dpsmoke, va("qmb:smoke%d", i), original, temp_buffer, real_width, real_height, i, 8, i * 32, 64, (i + 1) * 32, 96);
		}
		Q_free(temp_buffer);
		Q_free(original);
	}

	//VULT PARTICLES
	shockwave_texture = QMB_LoadTextureImage("textures/shockwavetex");
	if (!R_TextureReferenceIsValid(shockwave_texture)) {
		return;
	}
	lightning_texture = QMB_LoadTextureImage("textures/zing1");
	if (!R_TextureReferenceIsValid(lightning_texture)) {
		return;
	}
	spark_texture = QMB_LoadTextureImage("textures/sparktex");
	if (!R_TextureReferenceIsValid(spark_texture)) {
		return;
	}
	ADD_PARTICLE_TEXTURE(ptex_shockwave, shockwave_texture, 0, 1, 0, 0, 256, 256);
	ADD_PARTICLE_TEXTURE(ptex_lightning, lightning_texture, 0, 1, 0, 0, 256, 256);
	ADD_PARTICLE_TEXTURE(ptex_spark, spark_texture, 0, 1, 0, 0, 32, 32);

	QMB_AddParticleType(p_spark, pd_spark, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_none, 255, -32, 0, pm_bounce, 1.3, 9, &count, "part:spark");
	QMB_AddParticleType(p_sparkray, pd_sparkray, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_none, 255, -0, 0, pm_nophysics, 0, 9, &count, "part:sparkray");
	QMB_AddParticleType(p_gunblast, pd_spark, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_none, 255, -16, 0, pm_bounce, 1.3, 9, &count, "part:gunblast");

	QMB_AddParticleType(p_fire, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 204, 0, -2.95, pm_die, 0, 4, &count, "part:fire");
	QMB_AddParticleType(p_chunk, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 255, -16, 0, pm_bounce, 1.475, 4, &count, "part:chunk");
	QMB_AddParticleType(p_shockwave, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 255, 0, -4.85, pm_nophysics, 0, 4, &count, "part:shockwave");
	QMB_AddParticleType(p_inferno_flame, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 153, 0, 0, pm_static, 0, 4, &count, "part:inferno_flame");
	QMB_AddParticleType(p_inferno_trail, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 204, 0, 0, pm_die, 0, 4, &count, "part:inferno_trail");
	QMB_AddParticleType(p_trailpart, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 230, 0, 0, pm_static, 0, 4, &count, "part:trailpart");
	QMB_AddParticleType(p_smoke, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_smoke, 140, 3, 0, pm_normal, 0, 4, &count, "part:smoke");
	QMB_AddParticleType(p_dpfire, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_dpsmoke, 144, 0, 0, pm_die, 0, 4, &count, "part:dpfire");
	QMB_AddParticleType(p_dpsmoke, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_dpsmoke, 85, 3, 0, pm_die, 0, 4, &count, "part:dpsmoke");

	QMB_AddParticleType(p_teleflare, pd_billboard, BLEND_GL_ONE_GL_ONE, ptex_blueflare, 255, 0, 0, pm_die, 0, 4, &count, "part:teleflare");
	QMB_AddParticleType(p_blood1, pd_billboard, BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR, ptex_blood1, 255, -20, 0, pm_die, 0, 4, &count, "part:blood1");
	QMB_AddParticleType(p_blood2, pd_billboard_vel, BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR, ptex_blood2, 255, -25, 0, pm_die, 0.018, 4, &count, "part:blood2");

	QMB_AddParticleType(p_lavasplash, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_lava, 170, 0, 0, pm_nophysics, 0, 4, &count, "part:lavasplash");
	QMB_AddParticleType(p_blood3, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_blood3, 255, -20, 0, pm_normal, 0, 4, &count, "part:blood3");
	QMB_AddParticleType(p_bubble, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_bubble, 204, 8, 0, pm_float, 0, 4, &count, "part:bubble");
	QMB_AddParticleType(p_staticbubble, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_bubble, 204, 0, 0, pm_static, 0, 4, &count, "part:staticbubble");

	//VULT PARTICLES
	QMB_AddParticleType(p_rain, pd_hide, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_none, 100, 0, 0, pm_rain, 0, 4, &count, "part:rain");
	QMB_AddParticleType(p_alphatrail, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 100, 0, 0, pm_static, 0, 4, &count, "part:alphatrail");
	QMB_AddParticleType(p_railtrail, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 255, 0, 0, pm_die, 0, 4, &count, "part:railtrail");

	QMB_AddParticleType(p_vxblood, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_blood3, 255, -38, 0, pm_normal, 0, 4, &count, "part:vxblood"); //HyperNewbie - Blood does NOT glow like fairy light
	QMB_AddParticleType(p_streak, pd_hide, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_none, 255, -64, 0, pm_streak, 1.5, 4, &count, "part:streak"); //grav was -64
	QMB_AddParticleType(p_streakwave, pd_hide, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_none, 255, 0, 0, pm_streakwave, 0, 4, &count, "part:streakwave");
	QMB_AddParticleType(p_lavatrail, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 255, 3, 0, pm_normal, 0, 4, &count, "part:lavatrail");
	QMB_AddParticleType(p_vxsmoke, pd_billboard, BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR_CONSTANT, ptex_smoke, 140, 3, 0, pm_normal, 0, 4, &count, "part:vxsmoke");
	QMB_AddParticleType(p_vxsmoke_red, pd_billboard, BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR, ptex_smoke, 140, 3, 0, pm_normal, 0, 4, &count, "part:vxsmoke_red");
	QMB_AddParticleType(p_muzzleflash, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 128, 0, 0, pm_die, 0, 4, &count, "part:muzzleflash");
	QMB_AddParticleType(p_2dshockwave, pd_normal, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_shockwave, 255, 0, 0, pm_static, 0, 4, &count, "part:2dshockwave");
	QMB_AddParticleType(p_vxrocketsmoke, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 128, 0, 0, pm_normal, 0, 4, &count, "part:vxrocketsmoke");
	QMB_AddParticleType(p_flame, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 200, 10, 0, pm_die, 0, 4, &count, "part:flame");
	QMB_AddParticleType(p_trailbleed, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 200, 0, 0, pm_static, 0, 4, &count, "part:flamebleed");
	QMB_AddParticleType(p_bleedspike, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 200, 0, 0, pm_static, 0, 4, &count, "part:bleedspike");
	QMB_AddParticleType(p_lightningbeam, pd_beam, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_lightning, 128, 0, 0, pm_static, 0, 4, &count, "part:lgbeam");
	QMB_AddParticleType(p_bubble2, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_bubble, 204, 1, 0, pm_float, 0, 4, &count, "part:bubble2");
	QMB_AddParticleType(p_bloodcloud, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_generic, 255, -3, 0, pm_normal, 0, 4, &count, "part:bloodcloud");
	QMB_AddParticleType(p_chunkdir, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 255, -32, 0, pm_bounce, 1.475, 4, &count, "part:chunkdir");
	QMB_AddParticleType(p_smallspark, pd_beam, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_spark, 255, -64, 0, pm_bounce, 1.5, 4, &count, "part:smallspark"); //grav was -64

	//HyperNewbie particles
	QMB_AddParticleType(p_slimeglow, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_lava, 72, 0, 0, pm_nophysics, 0, 4, &count, "part:slimeglow"); //Glow
	QMB_AddParticleType(p_slimebubble, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_bubble, 204, 0, 0, pm_static, 0, 4, &count, "part:slimebubble");
	QMB_AddParticleType(p_blacklavasmoke, pd_billboard, BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR_CONSTANT, ptex_smoke, 140, 3, 0, pm_normal, 0, 4, &count, "part:blacklavasmoke");

	//Allow overkill trails
	if (amf_part_fulldetail.integer) {
		QMB_AddParticleType(p_streaktrail, pd_billboard, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 128, 0, 0, pm_static, 0, 4, &count, "part:streaktrail");
	}
	else {
		QMB_AddParticleType(p_streaktrail, pd_beam, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_none, 128, 0, 0, pm_die, 0, 4, &count, "part:streaktrail");
	}

	// meag: new, 'simple' trails following entities, updated as entity moves
	QMB_AddParticleType(p_nailtrail, pd_dynamictrail, BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA, ptex_none, R_SIMPLETRAIL_NEAR_ALPHA, 0, 0, pm_trail, 0, 8, &count, "part:entitytrail");
	QMB_AddParticleType(p_flametorch, pd_torch, BLEND_GL_SRC_ALPHA_GL_ONE, ptex_generic, 200, 10, 0, pm_static, 0, 4, &count, "part:flame");

	QMB_SortParticleTypes();
	R_ParticleFlamePrecalculate();

	qmb_initialized = true;
}

void QMB_ShutdownParticles(void)
{
	Q_free(particles);
}

void QMB_ClearParticles (void)
{
	int	i;

	// FIXME: if r_numparticles hasn't changed, then no-need to reallocate again.
	Q_free(particles);		// free
	QMB_AllocParticles();	// and alloc again

	memset(particles, 0, r_numparticles * sizeof(particle_t));
	free_particles = &particles[0];

	for (i = 0; i + 1 < r_numparticles; i++) {
		particles[i].next = &particles[i + 1];
	}
	particles[r_numparticles - 1].next = NULL;

	for (i = 0; i < num_particletypes; i++) {
		particle_types[i].start = NULL;
	}

	//VULT STATS
	ParticleCount = 0;
	ParticleCountHigh = 0;
}

static void QMB_BillboardAddVert(r_sprite3d_vert_t* vert, particle_type_t* type, float x, float y, float z, float s, float t, col_t color, int texture_index)
{
	part_blend_info_t* blend = &blend_options[type->blendtype];
	col_t new_color;

	blend->color_transform(color, new_color);

	R_Sprite3DSetVert(vert, x, y, z, s, t, new_color, texture_index);
}

__inline static qbool CALCULATE_PARTICLE_BILLBOARD(particle_texture_t* ptex, particle_type_t* type, particle_t * p, vec3_t coord[4])
{
	part_blend_info_t* blend = &blend_options[type->blendtype];
	vec3_t verts[4];
	float scale = p->size;
	r_sprite3d_vert_t* vert;
	col_t new_color;

	vert = R_Sprite3DAddEntry(type->billboard_type, 4);
	if (!vert) {
		return false;
	}

	if (p->rotspeed) {
		matrix3x3_t rotate_matrix;
		Matrix3x3_CreateRotate(rotate_matrix, DEG2RAD(p->rotangle), vpn);

		Matrix3x3_MultiplyByVector(verts[0], (const vec_t (*)[3]) rotate_matrix, coord[0]);
		Matrix3x3_MultiplyByVector(verts[1], (const vec_t (*)[3]) rotate_matrix, coord[1]);
		// do some fast math for verts[2] and verts[3].
		VectorNegate(verts[0], verts[2]);
		VectorNegate(verts[1], verts[3]);

		VectorMA(p->org, scale, verts[0], verts[0]);
		VectorMA(p->org, scale, verts[1], verts[1]);
		VectorMA(p->org, scale, verts[2], verts[2]);
		VectorMA(p->org, scale, verts[3], verts[3]);
	}
	else {
		VectorMA(p->org, scale, coord[0], verts[0]);
		VectorMA(p->org, scale, coord[1], verts[1]);
		VectorMA(p->org, scale, coord[2], verts[2]);
		VectorMA(p->org, scale, coord[3], verts[3]);
	}

	// Set color
	blend->color_transform(p->color, new_color);

	R_Sprite3DSetVert(vert++, verts[0][0], verts[0][1], verts[0][2], ptex->coords[p->texindex][0], ptex->coords[p->texindex][3], new_color, ptex->tex_index);
	R_Sprite3DSetVert(vert++, verts[3][0], verts[3][1], verts[3][2], ptex->coords[p->texindex][2], ptex->coords[p->texindex][3], new_color, ptex->tex_index);
	R_Sprite3DSetVert(vert++, verts[1][0], verts[1][1], verts[1][2], ptex->coords[p->texindex][0], ptex->coords[p->texindex][1], new_color, ptex->tex_index);
	R_Sprite3DSetVert(vert++, verts[2][0], verts[2][1], verts[2][2], ptex->coords[p->texindex][2], ptex->coords[p->texindex][1], new_color, ptex->tex_index);

	return true;
}

static void QMB_FillParticleVertexBuffer(void)
{
	vec3_t billboard[4], velcoord[4];
	particle_type_t* pt;
	particle_t* p;
	int i, j, k;
	int l;

	VectorAdd(vup, vright, billboard[2]);
	VectorSubtract(vright, vup, billboard[3]);
	VectorNegate(billboard[2], billboard[0]);
	VectorNegate(billboard[3], billboard[1]);

	for (i = 0; i < num_particletypes; i++) {
		qbool first = true;

		pt = &particle_types[i];

		if (!pt->start) {
			continue;
		}
		if (pt->drawtype == pd_hide) {
			continue;
		}

		//VULT PARTICLES
		switch (pt->drawtype) {
		case pd_beam:
			for (p = pt->start; p; p = p->next) {
				particle_texture_t* ptex = &particle_textures[ptex_lightning];
				vec3_t right1, right2;
				float half_t = (ptex->coords[0][1] + ptex->coords[0][3]) * 0.5f;
				int trail_parts = min(amf_part_traildetail.integer, MAX_BEAM_TRAIL);

				if (i != particle_type_index[p_lightningbeam]) {
					trail_parts = 1;
				}

				if (particle_time < p->start || particle_time >= p->die) {
					continue;
				}

				if (first) {
					R_Sprite3DInitialiseBatch(pt->billboard_type, pt->state, TEXTURE_DETAILS(ptex), r_primitive_triangle_strip);
					first = false;
				}

				R_PreCalcBeamVerts(p->org, p->endorg, right1, right2);
				for (l = trail_parts; l > 0; l--) {
					r_sprite3d_vert_t* vert = R_Sprite3DAddEntry(pt->billboard_type, 6);
					if (!vert) {
						break;
					}

					R_CalcBeamVerts(varray_vertex, p->org, p->endorg, right1, right2, p->size / (l * amf_part_trailwidth.value));

					QMB_BillboardAddVert(vert++, pt, varray_vertex[4], varray_vertex[5], varray_vertex[6], ptex->coords[0][2], ptex->coords[0][3], p->color, ptex->tex_index);
					QMB_BillboardAddVert(vert++, pt, varray_vertex[8], varray_vertex[9], varray_vertex[10], ptex->coords[0][0], ptex->coords[0][3], p->color, ptex->tex_index);

					// near center
					QMB_BillboardAddVert(vert++, pt, (varray_vertex[0] + varray_vertex[4]) / 2, (varray_vertex[1] + varray_vertex[5]) / 2, (varray_vertex[2] + varray_vertex[6]) / 2, ptex->coords[0][2], half_t, p->color, ptex->tex_index);
					// far center
					QMB_BillboardAddVert(vert++, pt, (varray_vertex[8] + varray_vertex[12]) / 2, (varray_vertex[9] + varray_vertex[13]) / 2, (varray_vertex[10] + varray_vertex[14]) / 2, ptex->coords[0][0], half_t, p->color, ptex->tex_index);

					QMB_BillboardAddVert(vert++, pt, varray_vertex[0], varray_vertex[1], varray_vertex[2], ptex->coords[0][2], ptex->coords[0][1], p->color, ptex->tex_index);
					QMB_BillboardAddVert(vert++, pt, varray_vertex[12], varray_vertex[13], varray_vertex[14], ptex->coords[0][0], ptex->coords[0][1], p->color, ptex->tex_index);
				}
			}
			break;
		case pd_spark:
		case pd_sparkray:
			for (p = pt->start; p; p = p->next) {
				vec3_t neworg;
				float* point;
				byte farColor[4];
				particle_texture_t* ptex = &particle_textures[ptex_none];
				r_sprite3d_vert_t* vert;

				if (particle_time < p->start || particle_time >= p->die) {
					continue;
				}

				if (first) {
					R_Sprite3DInitialiseBatch(pt->billboard_type, pt->state, TEXTURE_DETAILS(ptex), r_primitive_triangle_fan);
					first = false;
				}

				vert = R_Sprite3DAddEntry(pt->billboard_type, pt->verts_per_primitive);
				if (vert) {
					vec3_t v;

					if (!TraceLineN(p->endorg, p->org, neworg, NULL)) {
						VectorCopy(p->org, neworg);
					}

					point = (pt->drawtype == pd_spark ? p->org : p->endorg);
					farColor[0] = p->color[0] >> 1;
					farColor[1] = p->color[1] >> 1;
					farColor[2] = p->color[2] >> 1;
					farColor[3] = 0;

					QMB_BillboardAddVert(vert++, pt, point[0], point[1], point[2], ptex->coords[0][0], ptex->coords[0][1], p->color, -1);
					if (pt->drawtype == pd_spark) {
						for (j = 7; j >= 0; j--) {
							for (k = 0; k < 3; k++) {
								v[k] = p->org[k] - p->vel[k] / 8 + vright[k] * cost[j % 7] * p->size + vup[k] * sint[j % 7] * p->size;
							}
							QMB_BillboardAddVert(vert++, pt, v[0], v[1], v[2], ptex->coords[0][0], ptex->coords[0][1], farColor, -1);
						}
					}
					else {
						for (j = 7; j >= 0; j--) {
							for (k = 0; k < 3; k++) {
								v[k] = neworg[k] + vright[k] * cost[j % 7] * p->size + vup[k] * sint[j % 7] * p->size;
							}
							QMB_BillboardAddVert(vert++, pt, v[0], v[1], v[2], ptex->coords[0][0], ptex->coords[0][1], farColor, -1);
						}
					}
				}
			}
			break;
		case pd_billboard:
		case pd_billboard_vel:
			{
				int drawncount = 0;
				particle_texture_t* ptex = &particle_textures[pt->texture];

				for (p = pt->start; p; p = p->next) {
					if (particle_time < p->start || particle_time >= p->die) {
						continue;
					}

					if (first) {
						R_Sprite3DInitialiseBatch(pt->billboard_type, pt->state, TEXTURE_DETAILS(ptex), r_primitive_triangle_strip);
						first = false;
					}

					if (pt->drawtype == pd_billboard) {
						if (gl_clipparticles.integer) {
							if (drawncount >= 3 && VectorSupCompare(p->org, r_origin, 30)) {
								continue;
							}
							drawncount++;
						}

						CALCULATE_PARTICLE_BILLBOARD(ptex, pt, p, billboard);
					}
					else if (pt->drawtype == pd_billboard_vel) {
						vec3_t up, right;

						VectorCopy(p->vel, up);
						CrossProduct(vpn, up, right);
						VectorNormalizeFast(right);
						VectorScale(up, pt->custom, up);

						VectorAdd(up, right, velcoord[2]);
						VectorSubtract(right, up, velcoord[3]);
						VectorNegate(velcoord[2], velcoord[0]);
						VectorNegate(velcoord[3], velcoord[1]);

						CALCULATE_PARTICLE_BILLBOARD(ptex, pt, p, velcoord);
					}
				}
			}
			break;

			//VULT PARTICLES - This produces the shockwave effect
			//Mind you it can be used for more than that... Decals come to mind first
		case pd_normal:
			{
				float matrix[16];
				particle_texture_t* ptex = &particle_textures[pt->texture];

				for (p = pt->start; p; p = p->next) {
					float vector[4][4];
					r_sprite3d_vert_t* vert;

					if (particle_time < p->start || particle_time >= p->die) {
						continue;
					}

					if (first) {
						R_Sprite3DInitialiseBatch(pt->billboard_type, pt->state, TEXTURE_DETAILS(ptex), r_primitive_triangle_strip);
						first = false;
					}

					vert = R_Sprite3DAddEntry(pt->billboard_type, 4);
					if (vert) {
						R_SetIdentityMatrix(matrix);
						R_TransformMatrix(matrix, p->org[0], p->org[1], p->org[2]);
						R_ScaleMatrix(matrix, p->size, p->size, p->size);
						R_RotateMatrix(matrix, p->endorg[0], 0, 1, 0);
						R_RotateMatrix(matrix, p->endorg[1], 0, 0, 1);
						R_RotateMatrix(matrix, p->endorg[2], 1, 0, 0);

						R_MultiplyVector3f(matrix, -p->size, -p->size, 0, vector[0]);
						R_MultiplyVector3f(matrix, p->size, -p->size, 0, vector[1]);
						R_MultiplyVector3f(matrix, p->size, p->size, 0, vector[2]);
						R_MultiplyVector3f(matrix, -p->size, p->size, 0, vector[3]);

						QMB_BillboardAddVert(vert++, pt, vector[0][0], vector[0][1], vector[0][2], ptex->coords[0][0], ptex->coords[0][1], p->color, ptex->tex_index);
						QMB_BillboardAddVert(vert++, pt, vector[3][0], vector[3][1], vector[3][2], ptex->coords[0][0], ptex->coords[0][3], p->color, ptex->tex_index);
						QMB_BillboardAddVert(vert++, pt, vector[1][0], vector[1][1], vector[1][2], ptex->coords[0][2], ptex->coords[0][1], p->color, ptex->tex_index);
						QMB_BillboardAddVert(vert++, pt, vector[2][0], vector[2][1], vector[2][2], ptex->coords[0][2], ptex->coords[0][3], p->color, ptex->tex_index);

						if ((vert = R_Sprite3DAddEntry(pt->billboard_type, 4))) {
							R_RotateMatrix(matrix, 180, 1, 0, 0);

							R_MultiplyVector3f(matrix, -p->size, -p->size, 0, vector[0]);
							R_MultiplyVector3f(matrix, p->size, -p->size, 0, vector[1]);
							R_MultiplyVector3f(matrix, p->size, p->size, 0, vector[2]);
							R_MultiplyVector3f(matrix, -p->size, p->size, 0, vector[3]);

							QMB_BillboardAddVert(vert++, pt, vector[0][0], vector[0][1], vector[0][2], ptex->coords[0][0], ptex->coords[0][1], p->color, ptex->tex_index);
							QMB_BillboardAddVert(vert++, pt, vector[3][0], vector[3][1], vector[3][2], ptex->coords[0][0], ptex->coords[0][3], p->color, ptex->tex_index);
							QMB_BillboardAddVert(vert++, pt, vector[1][0], vector[1][1], vector[1][2], ptex->coords[0][2], ptex->coords[0][1], p->color, ptex->tex_index);
							QMB_BillboardAddVert(vert++, pt, vector[2][0], vector[2][1], vector[2][2], ptex->coords[0][2], ptex->coords[0][3], p->color, ptex->tex_index);
						}
					}
				}
			}
			break;
		case pd_dynamictrail:
			{
				particle_texture_t* ptex = &particle_textures[pt->texture];

				for (p = pt->start; p; p = p->next) {
					r_sprite3d_vert_t* vert;

					if (particle_time < p->start || particle_time >= p->die) {
						continue;
					}

					if (first) {
						R_Sprite3DInitialiseBatch(pt->billboard_type, pt->state, TEXTURE_DETAILS(ptex), r_primitive_triangle_strip);
						first = false;
					}

					vert = R_Sprite3DAddEntry(pt->billboard_type, pt->verts_per_primitive);
					if (vert) {
						vec3_t points[6];
						col_t near_color;
						
						VectorCopy(p->color, near_color);
						near_color[3] = R_SIMPLETRAIL_NEAR_ALPHA;

						VectorMA(p->endorg, -1, vup, points[0]);
						VectorMA(points[0], -2, vright, points[2]);
						VectorMA(points[0], 2, vright, points[0]);
						VectorMA(p->endorg, 2, vup, points[1]);

						VectorMA(p->org, -0.5, vup, points[3]);
						VectorMA(points[0], -1, vright, points[5]);
						VectorMA(points[3], -1, vright, points[3]);
						VectorMA(p->org, 1, vup, points[4]);

						QMB_BillboardAddVert(vert++, pt, points[0][0], points[0][1], points[0][2], 0, 0, near_color, -1);
						QMB_BillboardAddVert(vert++, pt, points[3][0], points[3][1], points[3][2], 0, 0, p->color, -1);
						QMB_BillboardAddVert(vert++, pt, points[1][0], points[1][1], points[1][2], 0, 0, near_color, -1);
						QMB_BillboardAddVert(vert++, pt, points[4][0], points[4][1], points[4][2], 0, 0, p->color, -1);
						QMB_BillboardAddVert(vert++, pt, points[2][0], points[2][1], points[2][2], 0, 0, near_color, -1);
						QMB_BillboardAddVert(vert++, pt, points[5][0], points[5][1], points[5][2], 0, 0, p->color, -1);
						QMB_BillboardAddVert(vert++, pt, points[0][0], points[0][1], points[0][2], 0, 0, near_color, -1);
						QMB_BillboardAddVert(vert++, pt, points[3][0], points[3][1], points[3][2], 0, 0, p->color, -1);
					}
				}
			}
			break;
		case pd_torch:
			{
				particle_texture_t* ptex = &particle_textures[pt->texture];

				for (p = pt->start; p; p = p->next) {
					int frame = (int)(particle_time * 100) % FLAME_FRAME_TOTAL;
					int i;

					if (particle_time < p->start || particle_time >= p->die) {
						continue;
					}

					if (first) {
						R_Sprite3DInitialiseBatch(pt->billboard_type, pt->state, TEXTURE_DETAILS(ptex), r_primitive_triangle_strip);
						first = false;
					}

					// render multiple billboards
					for (i = 0; i < FLAME_FRAME_TOTAL; ++i) {
						particle_t part = *p;
						flame_t* flame = &flame_frames[frame][i];

						VectorAdd(part.org, flame->pos, part.org);
						if (amf_part_firecolor.string[0]) {
							VectorCopy(amf_part_firecolor.color, part.color);
						}
						part.color[3] = flame->alpha;
						part.size = flame->size;

						if (!CALCULATE_PARTICLE_BILLBOARD(ptex, pt, &part, billboard)) {
							break;
						}
					}
				}
			}
			break;
		default:
			assert(!"QMB_DrawParticles: unexpected drawtype");
			break;
		}
	}
}

void QMB_ProcessParticle(particle_type_t* pt, particle_t* p)
{
	float grav = movevars.gravity / 800.0;
	vec3_t oldorg, stop, normal, movement;
	int contents;
	float bounce;
	float lifetime;

	p->size += p->growth * cls.frametime;

	if (p->size <= 0) {
		p->die = 0;
		return;
	}

	//VULT PARTICLE
	lifetime = ((p->die - particle_time) / (p->die - p->start));
	p->color[3] = p->initial_alpha * lifetime;

	if (p->color[3] <= 0) {
		p->die = 0;
		return;
	}

	if (pt->move == pm_trail || pt->drawtype == pd_torch) {
		extern cvar_t r_drawflame;
		qbool remove = false;

		remove |= (pt->drawtype == pd_torch && (!amf_part_fire.integer || !r_drawflame.integer));
		remove |= (p->entity_ref && cls.state != ca_active);

		if (remove) {
			p->entity_ref = 0;
			p->start = p->die = 0;
			return;
		}

		// velocity isn't used, accel etc is irrelevant...
		if (p->entity_ref > 0) {
			centity_t* cent = &cl_entities[p->entity_ref - 1];

			if (cent->trail_number == p->entity_trailnumber && cent->sequence == cl.validsequence) {
				// update based on entity
				float length;
				vec3_t diff;

				VectorCopy(cent->lerp_origin, p->endorg);
				VectorSubtract(p->org, p->endorg, diff);
				length = VectorLength(diff);
				if (length > R_SIMPLETRAIL_MAXLENGTH) {
					VectorMA(p->endorg, R_SIMPLETRAIL_MAXLENGTH / length, diff, p->org);
				}
				p->die = particle_time + 0.2f;
				cent->trails[p->entity_trailindex].lasttime = particle_time;
			}
			else {
				// disconnect, let it die out
				p->entity_ref = p->entity_trailnumber = 0;

				// length should be reducing as it dies
				//p->size = p->;
				//VectorMA(p->endorg, p->size, diff, p->org);
			}
		}
		else if (p->entity_ref < 0) {
			entity_t* sent = &cl_static_entities[-p->entity_ref - 1];

			if (sent->visframe >= r_framecount - 1) {
				sent->particle_time = particle_time;
				p->start = particle_time;
				p->die = particle_time + 0.8f;
			}
			else {
				// kill it immediately
				p->start = p->die = 0;
			}
		}
		return;
	}

	p->rotangle += p->rotspeed * cls.frametime;
	if (p->hit) {
		return;
	}

	//VULT - switched these around so velocity is scaled before gravity is applied
	VectorScale(p->vel, 1 + pt->accel * cls.frametime, p->vel);
	p->vel[2] += pt->grav * grav * cls.frametime;

	switch (pt->move) {
		case pm_static:
			break;
		case pm_normal:
			VectorCopy(p->org, oldorg);
			VectorScale(p->vel, cls.frametime, movement);
			VectorAdd(p->org, movement, p->org);
			if (ParticleContents(p, movement) == CONTENTS_SOLID) {
				p->hit = 1;
				VectorCopy(oldorg, p->org);
				VectorClear(p->vel);
			}
			break;
		case pm_float:
			VectorScale(p->vel, cls.frametime, movement);
			movement[2] += p->size + 1;
			VectorAdd(p->org, movement, p->org);
			contents = ParticleContents(p, movement);
			if (!ISUNDERWATER(contents)) {
				p->die = 0;
			}
			p->org[2] -= p->size + 1;
			break;
		case pm_nophysics:
			VectorMA(p->org, cls.frametime, p->vel, p->org);
			break;
		case pm_die:
			VectorScale(p->vel, cls.frametime, movement);
			VectorAdd(p->org, movement, p->org);
			if (CONTENTS_SOLID == ParticleContents(p, movement)) {
				p->die = 0;
			}
			break;
		case pm_bounce:
			if (!gl_bounceparticles.value || p->bounces) {
				if (pt->id == p_smallspark) {
					VectorCopy(p->org, p->endorg);
				}

				VectorScale(p->vel, cls.frametime, movement);
				VectorAdd(p->org, movement, p->org);
				if (CONTENTS_SOLID == ParticleContents(p, movement)) {
					p->die = 0;
				}
			}
			else {
				VectorCopy(p->org, oldorg);
				if (pt->id == p_smallspark) {
					VectorCopy(oldorg, p->endorg);
				}
				VectorScale(p->vel, cls.frametime, movement);
				VectorAdd(p->org, movement, p->org);
				if (CONTENTS_SOLID == ParticleContents(p, movement)) {
					if (TraceLineN(oldorg, p->org, stop, normal)) {
						VectorCopy(stop, p->org);
						bounce = -pt->custom * DotProduct(p->vel, normal);
						VectorMA(p->vel, bounce, normal, p->vel);
						p->bounces++;
						if (pt->id == p_smallspark) {
							VectorCopy(stop, p->endorg);
						}
					}
				}
			}
			break;
			//VULT PARTICLES
		case pm_rain:
			VectorCopy(p->org, oldorg);
			VectorScale(p->vel, cls.frametime, movement);
			VectorAdd(p->org, movement, p->org);
			contents = ParticleContents(p, movement);
			if (ISUNDERWATER(contents) || contents == CONTENTS_SOLID) {
				if (!amf_weather_rain_fast.value || amf_weather_rain_fast.value == 2) {
					vec3_t rorg;
					VectorCopy(oldorg, rorg);
					//Find out where the rain should actually hit
					//This is a slow way of doing it, I'll fix it later maybe...
					while (1) {
						rorg[2] = rorg[2] - 0.5f;
						contents = TruePointContents(rorg);
						if (contents == CONTENTS_WATER) {
							if (amf_weather_rain_fast.value == 2) {
								break;
							}
							RainSplash(rorg);
							break;
						}
						else if (contents == CONTENTS_SOLID) {
							byte col[3] = { 128,128,128 };
							SparkGen(rorg, col, 3, 50, 0.15);
							break;
						}
					}
					VectorCopy(rorg, p->org);
					VX_ParticleTrail(oldorg, p->org, p->size, 0.2, p->color);
				}
				p->die = 0;
			}
			else {
				VX_ParticleTrail(oldorg, p->org, p->size, 0.2, p->color);
			}
			break;
			//VULT PARTICLES
		case pm_streak:
			VectorCopy(p->org, oldorg);
			VectorScale(p->vel, cls.frametime, movement);
			VectorAdd(p->org, movement, p->org);
			if (CONTENTS_SOLID == ParticleContents(p, movement)) {
				if (TraceLineN(oldorg, p->org, stop, normal)) {
					VectorCopy(stop, p->org);
					bounce = -pt->custom * DotProduct(p->vel, normal);
					VectorMA(p->vel, bounce, normal, p->vel);
				}
			}
			VX_ParticleTrail(oldorg, p->org, p->size, 0.2, p->color);
			if (VectorLength(p->vel) == 0) {
				p->die = 0;
			}
			break;
		case pm_streakwave:
			VectorCopy(p->org, oldorg);
			VectorMA(p->org, cls.frametime, p->vel, p->org);
			VX_ParticleTrail(oldorg, p->org, p->size, 0.5, p->color);
			p->vel[0] = 19 * p->vel[0] / 20;
			p->vel[1] = 19 * p->vel[1] / 20;
			p->vel[2] = 19 * p->vel[2] / 20;
			break;
		default:
			assert(!"QMB_UpdateParticles: unexpected pt->move");
			break;
	}
}

// TODO: Split up
static void QMB_UpdateParticles(void)
{
	int i;
	particle_type_t *pt;
	particle_t *p;
	particle_t **prev;

	if (!qmb_initialized) {
		return;
	}

	//VULT PARTICLES
	WeatherEffect();

	for (i = 0; i < num_particletypes; i++) {
		pt = &particle_types[i];

#ifdef _WIN32
		if (pt && ((uintptr_t)pt->start == 1)) {
			/* hack! fixme!
			 * for some reason in some occasions - MS VS 2005 compiler
			 * this address doesn't point to 0 as other unitialized do, but to 0x00000001 */
			pt->start = NULL;
			Com_DPrintf("ERROR: particle_type[%i].start == 1\n", i);
		}
#endif // _WIN32

		prev = &pt->start;
		for (p = pt->start; p; ) {
			if (particle_time >= p->die) {
				*prev = p->next;
				p->next = free_particles;
				free_particles = p;
				ParticleStats(-1);
				p = *prev;
			}
			else {
				if (particle_time >= p->start) {
					QMB_ProcessParticle(pt, p);
				}

				prev = &p->next;
				p = p->next;
			}
		}
	}
}

void QMB_CalculateParticles(void)
{
	if (!qmb_initialized) {
		return;
	}

	particle_time = r_refdef2.time;

	if (!ISPAUSED) {
		QMB_UpdateParticles();
	}
}
void QMB_DrawParticles(void)
{
	if (!qmb_initialized) {
		return;
	}

	QMB_FillParticleVertexBuffer();
}

//VULT STATS
void ParticleStats (int change)
{
	if (ParticleCount > ParticleCountHigh)
		ParticleCountHigh = ParticleCount;
	ParticleCount+=change;
}

//from darkplaces engine - finds which corner of a particle goes where, so I don't have to :D
static void R_PreCalcBeamVerts(vec3_t org1, vec3_t org2, vec3_t right1, vec3_t right2)
{
	vec3_t diff, normal;

	VectorSubtract(org2, org1, normal);
	VectorNormalize(normal);

	// calculate 'right' vector for start
	VectorSubtract(r_origin, org1, diff);
	VectorMA(diff, 32, vup, diff);
	VectorNormalize(diff);
	CrossProduct(normal, diff, right1);

	// calculate 'right' vector for end
	VectorSubtract(r_origin, org2, diff);
	VectorMA(diff, 32, vup, diff);
	VectorNormalize(diff);
	CrossProduct(normal, diff, right2);
}

static void R_CalcBeamVerts(float *vert, const vec3_t org1, const vec3_t org2, const vec3_t right1, const vec3_t right2, float width)
{
	VectorMA(org1, +width, right1, &vert[0]);
	VectorMA(org1, -width, right1, &vert[4]);
	VectorMA(org2, -width, right2, &vert[8]);
	VectorMA(org2, +width, right2, &vert[12]);
}

int QMB_ParticleTextureCount(void)
{
	return num_particletextures;
}

void QMB_ImportTextureArrayReferences(texture_flag_t* texture_flags)
{
	part_tex_t tex;
	int i;

	for (tex = 0; tex < num_particletextures; ++tex) {
		if (R_TextureReferenceIsValid(particle_textures[tex].texnum)) {
			texture_array_ref_t* array_ref = &texture_flags[particle_textures[tex].texnum.index].array_ref[TEXTURETYPES_SPRITES];

			particle_textures[tex].tex_array = array_ref->ref;
			particle_textures[tex].tex_index = array_ref->index;
			for (i = 0; i < particle_textures[tex].components; ++i) {
				particle_textures[tex].coords[i][0] *= array_ref->scale_s;
				particle_textures[tex].coords[i][2] *= array_ref->scale_s;
				particle_textures[tex].coords[i][1] *= array_ref->scale_t;
				particle_textures[tex].coords[i][3] *= array_ref->scale_t;
			}
		}
	}
}

void QMB_FlagTexturesForArray(texture_flag_t* texture_flags)
{
	part_tex_t tex;

	for (tex = 0; tex < num_particletextures; ++tex) {
		if (R_TextureReferenceIsValid(particle_textures[tex].texnum)) {
			texture_flags[particle_textures[tex].texnum.index].flags |= (1 << TEXTURETYPES_SPRITES);
			memcpy(particle_textures[tex].coords, particle_textures[tex].originalCoords, sizeof(particle_textures[tex].coords));
		}
	}
}


================================================
FILE: src/r_particles_qmb.h
================================================

#ifndef EZQUAKE_GL_RPART_HEADER
#define EZQUAKE_GL_RPART_HEADER

#include "r_sprite3d.h"
#include "r_state.h"

#define ABSOLUTE_MIN_PARTICLES				256
#define ABSOLUTE_MAX_PARTICLES				32768

//Better rand nums
#define lhrandom(MIN,MAX) ((rand() & 32767) * (((MAX)-(MIN)) * (1.0f / 32767.0f)) + (MIN))

typedef byte col_t[4];

typedef enum {
	p_spark, p_smoke, p_fire, p_bubble, p_lavasplash, p_gunblast, p_chunk, p_shockwave,
	p_inferno_flame, p_inferno_trail, p_sparkray, p_staticbubble, p_trailpart,
	p_dpsmoke, p_dpfire, p_teleflare, p_blood1, p_blood2, p_blood3,
	//VULT PARTICLES
	p_rain,
	p_alphatrail,
	p_railtrail,
	p_streak,
	p_streaktrail,
	p_streakwave,
	p_lightningbeam,
	p_vxblood,
	p_lavatrail,
	p_vxsmoke,
	p_vxsmoke_red,
	p_muzzleflash,
	p_inferno, //VULT - NOT TO BE CONFUSED WITH THE 0.36 FIREBALL
	p_2dshockwave,
	p_vxrocketsmoke,
	p_trailbleed,
	p_bleedspike,
	p_flame,
	p_bubble2,
	p_bloodcloud,
	p_chunkdir,
	p_smallspark,
	//[HyperNewbie] - particles!
	p_slimeglow, //slime glow
	p_slimebubble, //slime yellowish growing popping bubble
	p_blacklavasmoke,
	p_nailtrail,
	p_flametorch,
	num_particletypes,
} part_type_t;

typedef enum {
	pm_static, pm_normal, pm_bounce, pm_die, pm_nophysics, pm_float,
	//VULT PARTICLES
	pm_rain,
	pm_streak,
	pm_streakwave,
	pm_trail
} part_move_t;

typedef enum {
	ptex_none, ptex_smoke, ptex_bubble, ptex_generic, ptex_dpsmoke, ptex_lava,
	ptex_blueflare, ptex_blood1, ptex_blood2, ptex_blood3,
	//VULT PARTICLES
	ptex_shockwave,
	ptex_lightning,
	ptex_spark,
	num_particletextures,
} part_tex_t;

typedef enum {
	pd_spark, pd_sparkray, pd_billboard, pd_billboard_vel,
	//VULT PARTICLES
	pd_beam,
	pd_hide,
	pd_normal,
	pd_dynamictrail,
	pd_torch
} part_draw_t;

typedef enum {
	BLEND_GL_SRC_ALPHA_GL_ONE_MINUS_SRC_ALPHA,
	BLEND_GL_SRC_ALPHA_GL_ONE,
	BLEND_GL_ONE_GL_ONE,
	BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR_CONSTANT,   // ONE_MINUS_SRC_COLOR but r=g=b, so reduce by constant
	BLEND_GL_ZERO_GL_ONE_MINUS_SRC_COLOR,            // ONE_MINUS_SRC_COLOR but different levels for each

	NUMBER_OF_BLEND_TYPES
} part_blend_id;

typedef struct particle_s {
	struct particle_s *next;
	vec3_t      org, endorg;
	col_t       color;
	float       growth;
	vec3_t      vel;
	float       rotangle;
	float       rotspeed;
	float       size;
	float       start;
	float       die;
	byte        hit;
	byte        texindex;
	byte        bounces;
	byte        initial_alpha;

	int         cached_contents;
	vec3_t      cached_movement;
	float       cached_distance;

	int         entity_ref;
	int         entity_trailindex;
	int         entity_trailnumber;
} particle_t;

typedef struct particle_type_s {
	particle_t	  *start;
	part_type_t	  id;
	part_draw_t	  drawtype;
	part_blend_id blendtype;
	part_tex_t	  texture;
	float		  startalpha;
	float		  grav;
	float		  accel;
	part_move_t	  move;
	float		  custom;

	int           verts_per_primitive;
	sprite3d_batch_id billboard_type;

	int           particles;
	r_state_id    state;
} particle_type_t;

#define	MAX_PTEX_COMPONENTS		8
typedef struct particle_texture_s {
	texture_ref texnum;
	texture_ref tex_array;
	int         tex_index;
	int			components;
	float		coords[MAX_PTEX_COMPONENTS][4];
	float		originalCoords[MAX_PTEX_COMPONENTS][4];
} particle_texture_t;

typedef void(*func_color_transform_t)(col_t input, col_t output);
extern particle_type_t particle_types[num_particletypes];
extern int particle_type_index[num_particletypes];
extern particle_t* free_particles;
extern particle_texture_t particle_textures[num_particletextures];

extern cvar_t amf_part_fulldetail;

void QMB_ProcessParticle(particle_type_t* pt, particle_t* p);
qbool TraceLineN(vec3_t start, vec3_t end, vec3_t impact, vec3_t normal);
extern particle_t* free_particles;
void ParticleStats(int change);
byte *ColorForParticle(part_type_t type);
void AddParticle(part_type_t type, vec3_t org, int count, float size, float time, col_t col, vec3_t dir);

#define R_SIMPLETRAIL_MAXLENGTH    100
#define R_SIMPLETRAIL_NEAR_ALPHA    75

#endif // def(EZQUAKE_GL_RPART_HEADER)


================================================
FILE: src/r_particles_qmb_spawn.c
================================================
/*
Copyright (C) 2002-2003, Dr Labman, A. Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "gl_model.h"
#include "vx_stuff.h"
#include "r_particles_qmb.h"
#include "pmove.h"
#include "utils.h"
#include "qmb_particles.h"
#include "r_brushmodel.h" // R_PointIsUnderwater only

static qbool QMB_InWaterEffect(vec3_t org, qbool isFire)
{
	extern cvar_t amf_underwater_fire;
	extern cvar_t amf_underwater_effects;

	if ((isFire ? amf_underwater_fire.integer : amf_underwater_effects.integer)) {
		return R_PointIsUnderwater(org);
	}
	return false;
}

static vec3_t zerodir = { 22, 22, 22 };

byte *ColorForParticle(part_type_t type)
{
	int lambda;
	static col_t color;

	switch (type) {
		case p_spark:
			color[0] = 224 + (rand() & 31); color[1] = 100 + (rand() & 31); color[2] = 0;
			break;
		case p_smoke:
			color[0] = color[1] = color[2] = color[3] = 255;
			break;
		case p_fire:
			color[0] = 255; color[1] = 142; color[2] = 62;
			break;
		case p_slimebubble:
		case p_bubble:
		case p_staticbubble:
			color[0] = color[1] = color[2] = 192 + (rand() & 63);
			break;
		case p_teleflare:
		case p_slimeglow:
		case p_lavasplash:
			color[0] = color[1] = color[2] = 128 + (rand() & 127);
			break;
		case p_gunblast:
			color[0] = 224 + (rand() & 31); color[1] = 170 + (rand() & 31); color[2] = 0;
			break;
		case p_chunk:
			color[0] = color[1] = color[2] = (32 + (rand() & 127));
			break;
		case p_shockwave:
			color[0] = color[1] = color[2] = 64 + (rand() & 31);
			break;
		case p_inferno_flame:
		case p_inferno_trail:
			color[0] = 255; color[1] = 77; color[2] = 13;
			break;
		case p_sparkray:
			color[0] = 255; color[1] = 102; color[2] = 25;
			break;
		case p_dpsmoke:
			color[0] = color[1] = color[2] = 48 + (((rand() & 0xFF) * 48) >> 8);
			break;
		case p_dpfire:
			lambda = rand() & 0xFF;
			color[0] = 160 + ((lambda * 48) >> 8); color[1] = 16 + ((lambda * 148) >> 8); color[2] = 16 + ((lambda * 16) >> 8);
			break;
		case p_blood1:
		case p_blood2:
			color[0] = color[1] = color[2] = 180 + (rand() & 63);
			break;
		case p_blood3:
			color[0] = (100 + (rand() & 31)); color[1] = color[2] = 0;
			break;
		case p_smallspark:
			color[0] = color[1] = color[2] = color[3] = 255;
			break;
		case p_nailtrail:
			color[0] = color[1] = color[2] = color[3] = R_SIMPLETRAIL_NEAR_ALPHA;
			break;
		default:
			//assert(!"ColorForParticle: unexpected type"); -> hexum - FIXME not all types are handled, seems to work ok though
			break;
	}
	return color;
}

__inline static void AddParticleEnt(part_type_t type, vec3_t org, int count, float size, float time, col_t col, vec3_t dir, int entity_id)
{
	byte *color;
	int i, j;
	float tempSize;
	particle_t *p;
	particle_type_t *pt;

	if (!qmb_initialized)
		Sys_Error("QMB particle added without initialization");

	if (size <= 0 || time <= 0) {
		Con_DPrintf("AddParticle() failed, type %d, size %f, time %f\n", type, size, time);
		return;
	}

	if (type >= num_particletypes) {
		Sys_Error("AddParticle: Invalid type (%d)", type);
	}

	pt = &particle_types[particle_type_index[type]];

	for (i = 0; i < count && free_particles; i++) {
		color = col ? col : ColorForParticle(type);
		INIT_NEW_PARTICLE(pt, p, color, size, time);
		p->entity_ref = entity_id;
		p->entity_trailnumber = 0;

		switch (type) {
			case p_spark:
				p->size = 1.175;
				VectorCopy(org, p->org);
				tempSize = size * 2;
				p->vel[0] = (rand() % (int)tempSize) - ((int)tempSize / 2);
				p->vel[1] = (rand() % (int)tempSize) - ((int)tempSize / 2);
				p->vel[2] = (rand() % (int)tempSize) - ((int)tempSize / 3);
				break;
			case p_smoke:
				for (j = 0; j < 3; j++)
					p->org[j] = org[j] + ((rand() & 31) - 16) / 2.0;
				for (j = 0; j < 3; j++)
					p->vel[j] = ((rand() % 10) - 5) / 20.0;
				break;
			case p_fire:
				VectorCopy(org, p->org);
				for (j = 0; j < 3; j++)
					p->vel[j] = ((rand() % 160) - 80) * (size / 25.0);
				break;
			case p_bubble:
				//VULT PARTICLES
				VectorCopy(org, p->org);
				for (j = 0; j < 2; j++)
					p->vel[j] = (rand() % 150) - 75;
				p->vel[2] = (rand() % 64) + 24;
				break;
			case p_lavasplash:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				break;
			case p_slimeglow:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				break;
			case p_gunblast:
				p->size = 1;
				VectorCopy(org, p->org);
				p->vel[0] = (rand() & 127) - 64;
				p->vel[1] = (rand() & 127) - 64;
				p->vel[2] = (rand() & 127) - 10;
				break;
			case p_chunk:
				VectorCopy(org, p->org);
				p->vel[0] = (rand() % 40) - 20;
				p->vel[1] = (rand() % 40) - 20;
				p->vel[2] = (rand() % 40) - 5;
				break;
			case p_shockwave:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				break;
			case p_inferno_trail:
				for (j = 0; j < 3; j++)
					p->org[j] = org[j] + (rand() & 15) - 8;
				for (j = 0; j < 3; j++)
					p->vel[j] = (rand() & 3) - 2;
				p->growth = -1.5;
				break;
			case p_inferno_flame:
				VectorCopy(org, p->org);
				VectorClear(p->vel);
				p->growth = -30;
				break;
			case p_sparkray:
				VectorCopy(org, p->endorg);
				VectorCopy(dir, p->org);
				for (j = 0; j < 3; j++)
					p->vel[j] = (rand() & 127) - 64;
				p->growth = -16;
				break;
			case p_staticbubble:
				VectorCopy(org, p->org);
				VectorClear(p->vel);
				break;
			case p_slimebubble:
				//HyperNewbie - Rising, popping bubbles
				VectorCopy(org, p->org);
				VectorClear(p->vel);
				p->growth = 7.5;
				break;
			case p_teleflare:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				p->growth = 1.75;
				break;
			case p_blood1:
			case p_blood2:
				for (j = 0; j < 3; j++)
					p->org[j] = org[j] + (rand() & 15) - 8;
				for (j = 0; j < 3; j++)
					p->vel[j] = (rand() & 63) - 32;
				break;
			case p_blood3:
				p->size = size * (rand() % 20) / 5.0;
				VectorCopy(org, p->org);
				for (j = 0; j < 3; j++)
					p->vel[j] = (rand() % 40) - 20;
				break;
				//VULT PARTICLES
			case p_rain:
				p->size = 1;
				VectorCopy(org, p->org);
				p->vel[0] = (rand() % 10 + 85)*size;
				p->vel[1] = (rand() % 10 + 85)*size;
				p->vel[2] = (rand() % -100 - 2000)*(size / 3);
				break;
				//VULT PARTICLES
			case p_streaktrail:
			case p_lightningbeam:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->endorg);
				if (amf_part_fulldetail.integer && type == p_streaktrail)
					p->size = size * 3;
				VectorClear(p->vel);
				p->growth = -p->size / time;
				p->initial_alpha = color[3];
				break;
				//VULT PARTICLES
			case p_streak:
			case p_inferno:
			case p_streakwave:
			case p_smallspark:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				break;
				//VULT PARTICLES
			case p_vxblood:
				VectorCopy(org, p->org);
				p->vel[0] = p->vel[1] = 40;
				p->vel[2] = 17;
				break;
				//VULT PARTICLES
			case p_vxsmoke:
			case p_vxsmoke_red:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				p->growth = 4.5;
				p->rotspeed = (rand() & 63) + 96;
				break;
				//VULT PARTICLES
			case p_muzzleflash:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				p->growth = -size / time;
				break;
				//VULT PARTICLES
			case p_2dshockwave:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->endorg);
				VectorClear(p->vel);
				p->size = 1;
				p->growth = size;
				break;
				//VULT PARTICLES
			case p_flame:
				VectorCopy(org, p->org);
				p->org[2] += 4;
				p->growth = -p->size / 2;
				VectorClear(p->vel);
				for (j = 0; j < 2; j++)
					p->vel[j] = (rand() % 6) - 3;
				break;
				//VULT PARTICLES
			case p_bloodcloud:
				for (j = 0; j < 3; j++)
					p->org[j] = org[j] + (rand() & 30) - 15;
				VectorClear(p->vel);
				p->size = (rand() % (int)size) + 10;
				break;
				//HyperNewbie Particles
			case p_blacklavasmoke:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				p->growth = 7.5;
				p->rotspeed = (rand() & 63) + 16;
				break;
			case p_chunkdir:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				break;
			case p_flametorch:
				VectorCopy(org, p->org);
				VectorCopy(dir, p->vel);
				break;
			default:
				assert(!"AddParticle: unexpected type");
				break;
		}

		QMB_ProcessParticle(pt, p);
	}
}

void AddParticle(part_type_t type, vec3_t org, int count, float size, float time, col_t col, vec3_t dir)
{
	AddParticleEnt(type, org, count, size, time, col, dir, 0);
}

//VULT PARTICLES
void DrawMuzzleflash(vec3_t start, vec3_t angle, vec3_t vel)
{
	vec3_t dir, forward, up, right;
	col_t color;
	int i;
	color[0] = 55;
	color[1] = 55;
	color[2] = 55;
	color[3] = 55;
	AngleVectors(angle, forward, right, up);
	VectorClear(dir);
	VectorMA(dir, 20, forward, dir);
	dir[2] += rand() & 5;
	AddParticle(p_vxsmoke, start, 1, 8, 1, color, dir);

	color[0] = 255;
	color[1] = 180;
	color[2] = 55;
	color[3] = 255;
	VectorCopy(start, dir);
	for (i = 60; i > 0; i--) {
		//VULT - i here is basically the length of the gun flame
		VectorMA(dir, 0.33, forward, dir);
		AddParticle(p_muzzleflash, dir, 1, i / 3, 0.1, color, vel);
	}
}

//VULT PARTICLES
void FuelRodExplosion(vec3_t org)
{
	col_t color;
	vec3_t dir, org2, angle;
	int a, i;
	float theta;

	color[0] = 75; color[1] = 255; color[2] = 75;
	color[3] = 255;
	AddParticle(p_fire, org, 10, 20, 0.5, color, zerodir);
	angle[2] = 0;
	if (amf_part_2dshockwaves.value) {
		AddParticle(p_2dshockwave, org, 1, 30, 0.5, NULL, vec3_origin);
	}
	else {
		for (theta = 0; theta < 2 * M_PI; theta += 2 * M_PI / 90) {
			angle[0] = cos(theta) * 900;
			angle[1] = sin(theta) * 900;
			AddParticle(p_shockwave, org, 1, 15, 1, NULL, angle);
		}
	}

	for (a = 0; a < 60 * amf_part_explosion.value; a++) {
		for (i = 0; i < 3; i++) {
			dir[i] = (rand() % 1500) - 750;
		}

		if (amf_part_trailtype.value == 2) {
			AddParticle(p_smallspark, org, 1, 1, 0.5*amf_part_trailtime.value, color, dir);
		}
		else {
			AddParticle(p_streak, org, 1, 1, 0.5*amf_part_trailtime.value, color, dir);
		}
	}

	for (i = 0; i < 5; i++) {
		VectorCopy(org, org2);
		for (a = 0; a < 60; a = a + 10) {
			org2[0] = org2[0] + (rand() % 15) - 7;
			org2[1] = org2[1] + (rand() % 15) - 7;
			org2[2] = org2[2] + 10;
			AddParticle(p_fire, org2, 5, 10, (0.5 + a) / 60, color, zerodir);
		}
	}
	for (i = 0; i < 15; i++) {
		VectorCopy(org, org2);
		org2[2] = org2[2] + 60;
		org2[0] = org2[0] + (rand() % 100) - 50;
		org2[1] = org2[1] + (rand() % 100) - 50;
		AddParticle(p_fire, org2, 5, 10, 1, color, zerodir);
	}

	for (i = 0; i < 5; i++) {
		VectorCopy(org, org2);
		org2[2] = org2[2] + 70;
		org2[0] = org2[0] + (rand() % 70) - 35;
		org2[1] = org2[1] + (rand() % 70) - 35;
		AddParticle(p_fire, org2, 5, 10, 1.05, color, zerodir);
	}
	for (i = 0; i < 5; i++) {
		VectorCopy(org, org2);
		org2[2] = org2[2] + 80;
		org2[0] = org2[0] + (rand() % 50) - 25;
		org2[1] = org2[1] + (rand() % 50) - 25;
		AddParticle(p_fire, org2, 5, 10, 1.1, color, zerodir);
	}
	for (i = 0; i < 5; i++) {
		VectorCopy(org, org2);
		org2[2] = org2[2] + 90;
		org2[0] = org2[0] + (rand() % 25) - 12;
		org2[1] = org2[1] + (rand() % 25) - 12;
		AddParticle(p_fire, org2, 5, 10, 1.15, color, zerodir);
	}
}

//VULT PARTICLES
//Not much, but anything is better than that alias torch
void ParticleTorchFire(entity_t* ent)
{
	col_t color = { 255,100,25, 128 };

	if (ent->entity_id) {
		entity_t* sent = &cl_static_entities[ent->entity_id - 1];
		if (r_refdef2.time - sent->particle_time < MIN_ENTITY_PARTICLE_FRAMETIME) {
			return;
		}
		sent->particle_time = r_refdef2.time;

		AddParticleEnt(p_flametorch, ent->origin, 1, 7, 0.8f, color, zerodir, -ent->entity_id);
	}
	else {
		if (QMB_InWaterEffect(ent->origin, true)) {
			AddParticle(p_bubble, ent->origin, 1, 2.8, 2.5, NULL, zerodir);
		}
		else {
			vec3_t end;
			trace_t trace;

			VectorCopy(ent->origin, end);
			end[2] += 32;
			trace = PM_TraceLine(ent->origin, end);

			AddParticle(p_flame, ent->origin, 1, 7, 0.8 * trace.fraction, amf_part_firecolor.string[0] ? StringToRGB(amf_part_firecolor.string) : color, zerodir);
		}
	}
}

// This is only used by lava surface effect now
void ParticleFire(vec3_t org)
{
	col_t color = { 255,100,25, 128 };

	if (QMB_InWaterEffect(org, true)) {
		AddParticle(p_bubble, org, 1, 2.8, 2.5, NULL, zerodir);
	}
	else {
		vec3_t end;
		trace_t trace;

		VectorCopy(org, end);
		end[2] += 32;
		trace = PM_TraceLine(org, end);

		AddParticle(p_flame, org, 1, 7, 0.8 * trace.fraction, amf_part_firecolor.string[0] ? StringToRGB(amf_part_firecolor.string) : color, zerodir);
	}
}

//TEI PARTICLES
//Idea: lavapool fire, Result: slighty lame
void ParticleFirePool(vec3_t org)
{
	col_t color = { 255,100,25, 128 };

	AddParticle(p_flame, org, 1, lhrandom(1, 32), lhrandom(1, 1), color, zerodir);
}

//TEI PARTICLES
//Idea: slimepool fire, Result: slighty lame
//4 - fantastic
//11 - fantastic
//28 - blood pool ULTRA FANTASTIC (movies?)
void ParticleSlimeHarcore(vec3_t org)
{
	col_t color = { 0,200,150, 240 };
	vec3_t dir = { 0,0,80 };

	AddParticle(p_lavasplash, org, 1, lhrandom(1, 32), lhrandom(1, 3), color, dir);//zerodir);
	AddParticle(p_staticbubble, org, 1, lhrandom(1, 128), lhrandom(1, 10), color, dir);//zerodir);
}

void ParticleSlime(vec3_t org)
{
	col_t color = { 0,200,150, 30 };
	vec3_t dir = { 0,0,80 };

	AddParticle(p_lavasplash, org, 1, lhrandom(1, 32), lhrandom(1, 3), color, dir);//zerodir);
	AddParticle(p_staticbubble, org, 1, lhrandom(1, 32), lhrandom(1, 10), color, dir);//zerodir);
}

//HyperNewbie Particles
void ParticleSmallerFirePool(vec3_t org)
{
	col_t color = { 255,100,25, 78 };

	AddParticle(p_flame, org, 1, lhrandom(4, 7), 0.8, color, zerodir);
}

void ParticleSlimeBubbles(vec3_t org)
{
	col_t color = { 32,32,1, 250 };
	AddParticle(p_slimebubble, org, 1, lhrandom(4, 6), lhrandom(1, 5), color, zerodir);
}

void ParticleSlimeGlow(vec3_t org)
{
	col_t color = { 0,128,128, 200 };
	vec3_t dir = { 0,0,5 };
	AddParticle(p_slimeglow, org, 1, lhrandom(32, 64), lhrandom(7, 8), color, dir);
}

void ParticleLavaSmokePool(vec3_t org)
{
	col_t color = { 15,15,15,15 };
	vec3_t dir = { 0,0,lhrandom(0,1) };

	AddParticle(p_blacklavasmoke, org, 1, lhrandom(14, 23), lhrandom(1, 3), color, dir);
}

//TEI PARTICLES
//Idea: bloodpool 
void ParticleBloodPool(vec3_t org)
{
	col_t color = { 30,100,150, 240 };
	vec3_t dir = { 0,0,80 };

	AddParticle(p_vxsmoke_red, org, 1, lhrandom(1, 11), lhrandom(1, 3), color, dir);
}


//VULT PARTICLES
//This looks quite good with detailtrails on
void VX_TeslaCharge(vec3_t org)
{
	vec3_t pos, vec, dir;
	col_t col = { 60,100,240, 128 };
	float time, len;
	int i;

	for (i = 0; i < 5; i++) {
		VectorClear(vec);
		VectorClear(dir);

		VectorCopy(org, pos);
		pos[0] += (rand() % 200) - 100;
		pos[1] += (rand() % 200) - 100;
		pos[2] += (rand() % 200) - 100;

		VectorSubtract(pos, org, vec);
		len = VectorLength(vec);
		VectorNormalize(vec);
		VectorMA(dir, -200, vec, dir);
		time = len / 200; //

		AddParticle(p_streakwave, pos, 1, 3, time, col, dir);
	}
}

//VULT PARTICLES
//Adds a beam type particle with the lightning texture
void VX_LightningBeam(vec3_t start, vec3_t end)
{
	//col_t color={120,140,255,255};
	AddParticle(p_lightningbeam, start, 1, 100, cls.frametime ? cls.frametime * 2 : 0.013, amf_lightning_color.color, end);
}

//VULT PARTICLES
//Effect for when someone dies
void VX_DeathEffect(vec3_t org)
{
	int a, i;
	vec3_t dir;
	col_t color;
	color[0] = 255;
	color[1] = 225;
	color[2] = 128;
	color[3] = 128;

	for (a = 0; a < 60; a++) {
		for (i = 0; i < 3; i++)
			dir[i] = (rand() % 700) - 300;
		AddParticle(p_streakwave, org, 1, 1, 0.5, color, dir);
	}
}

//VULT PARTICLES
//Effect for when someone dies violently
void VX_GibEffect(vec3_t org)
{
	col_t color;
	color[0] = 55;
	color[1] = 0;
	color[2] = 0;
	color[3] = 128;

	AddParticle(p_bloodcloud, org, 10, 30, 1, color, zerodir);
}

//VULT PARTICLES
//Prototype detpack explosion, yeah, I know, it sucks. Thats why its never actually used
void VX_DetpackExplosion(vec3_t org)
{
	vec3_t angle, neworg;
	float theta;
	col_t color = { 255,102,25,255 };
	int i, j;

	angle[2] = 0;
	for (theta = 0; theta < 2 * M_PI; theta += 2 * M_PI / 90) {
		angle[0] = cos(theta) * 750;
		angle[1] = sin(theta) * 750;
		AddParticle(p_shockwave, org, 1, 20, 1, NULL, angle);
		angle[0] = cos(theta) * 200 + ((rand() % 100) - 50);
		angle[1] = sin(theta) * 200 + ((rand() % 100) - 50);
		angle[2] = rand() % 300;
		AddParticle(p_chunkdir, org, 1, 8, 1, color, angle);
		angle[2] = rand() % 100 - 50;
	}
	AddParticle(p_fire, org, 20, 80, 1, color, zerodir);
	for (i = 0; i < 5; i++) {
		angle[2] = 0;
		for (j = 0; j < 5; j++) {
			AngleVectors(angle, NULL, NULL, neworg);
			VectorMA(org, 180, neworg, neworg);
			AddParticle(p_sparkray, org, 1, 16 + (i & 3), 1, NULL, neworg);
			angle[2] += 360 / 5;
		}
		angle[0] += 180 / 5;
	}
}


//TEI PARTICLES
//Teleport dimensional implosion
//unfinished :(
// testing cvs 
void VX_Implosion(vec3_t org)
{
	//TODO
}

//VULT PARTICLES
//This just adds a little lightning trail to the laser beams
void VX_LightningTrail(vec3_t start, vec3_t end)
{
	col_t color = { 255,77,0,255 };
	AddParticle(p_lightningbeam, start, 1, 50, 0.75, color, end);
}

void QMB_ParticleExplosion(vec3_t org)
{
	if (QMB_InWaterEffect(org, true)) {
		if (r_explosiontype.value != 9) {
			AddParticle(p_fire, org, 12, 14, 0.8, NULL, zerodir);
		}
		AddParticle(p_bubble, org, 6, 3.0, 2.5, NULL, zerodir);
		AddParticle(p_bubble, org, 4, 2.35, 2.5, NULL, zerodir);
		if (r_explosiontype.value != 1) {
			AddParticle(p_spark, org, 50, 100, 0.75, NULL, zerodir);
			AddParticle(p_spark, org, 25, 60, 0.75, NULL, zerodir);
		}
	}
	else {
		if (r_explosiontype.value != 9) {
			AddParticle(p_fire, org, 16, 18, 1, NULL, zerodir);
		}
		if (r_explosiontype.value != 1) {
			AddParticle(p_spark, org, 50, 250, 0.925f, NULL, zerodir);
			AddParticle(p_spark, org, 25, 150, 0.925f, NULL, zerodir);
		}
	}
}

void QMB_RunParticleEffect(vec3_t org, vec3_t dir, int col, int count)
{
	col_t color;
	vec3_t neworg;
	int i, blastcount, blastsize, chunkcount, particlecount, bloodcount, z;
	float scale;
	float blasttime;
	extern cvar_t gl_part_gunshots;

	count = max(1, count);

	if (col == 73) {
		bloodcount = Q_rint(count / 28.0);
		bloodcount = bound(2, bloodcount, 8);
		for (i = 0; i < bloodcount; i++) {
			AddParticle(p_blood1, org, 1, 4.5, 2 + (rand() & 15) / 16.0, NULL, zerodir);
			AddParticle(p_blood2, org, 1, 4.5, 2 + (rand() & 15) / 16.0, NULL, zerodir);
		}
		return;
	}
	else if (col == 225) {
		VectorClear(color);
		scale = (count > 130) ? 3 : (count > 20) ? 2 : 1;
		scale *= 0.758;
		for (i = 0; i < (count >> 1); i++) {
			neworg[0] = org[0] + scale * ((rand() & 15) - 8);
			neworg[1] = org[1] + scale * ((rand() & 15) - 8);
			neworg[2] = org[2] + scale * ((rand() & 15) - 8);
			color[0] = 50 + (rand() & 63);
			AddParticle(p_blood3, org, 1, 1, 2.3, NULL, zerodir);
		}
		return;
	}
	else if (col == 20 && count == 30) {
		color[0] = 51; color[2] = 51; color[1] = 255; color[3] = 255;
		AddParticle(p_chunk, org, 1, 1, 0.75, color, zerodir);
		AddParticle(p_spark, org, 12, 75, 0.4, color, zerodir);
		return;
	}
	else if (col == 226 && count == 20) {
		color[0] = 230; color[1] = 204; color[2] = 26; color[3] = 255;
		AddParticle(p_chunk, org, 1, 1, 0.75, color, zerodir);
		AddParticle(p_spark, org, 12, 75, 0.4, color, zerodir);
		return;
	}

	switch (count) {
		case 10:
			AddParticle(p_spark, org, 4, 70, 0.9, NULL, zerodir);
			break;
		case 30:
			AddParticle(p_chunk, org, 10, 1, 4, NULL, zerodir);
			AddParticle(p_spark, org, 8, 105, 0.9, NULL, zerodir);
			break;
		case 20:
			if (col != 256) {
				AddParticle(p_spark, org, 8, 85, 0.9, NULL, zerodir);
				break;
			}
			/* fall through */
		default:
			if (count > 130) {
				scale = 2.274;
				blastcount = 50; blastsize = 50; blasttime = 0.4;
				chunkcount = 14;
			}
			else if (count > 20) {
				scale = 1.516;
				blastcount = 30; blastsize = 35; blasttime = 0.25;
				chunkcount = 7;
			}
			else {
				scale = 0.758;
				blastcount = 15; blastsize = 5;	blasttime = 0.15;
				chunkcount = 3;
			}
			particlecount = max(1, count >> 1);
			AddParticle(p_gunblast, org, blastcount, blastsize, blasttime, NULL, zerodir);
			for (i = 0; i < particlecount; i++) {
				neworg[0] = org[0] + scale * ((rand() & 15) - 8);
				neworg[1] = org[1] + scale * ((rand() & 15) - 8);
				neworg[2] = org[2] + scale * ((rand() & 15) - 8);

				// col == 256 means it gun shot.
				// So we always USE smoke when it NOT a gun shot, in case of gun shot we DON'T use smoke when gl_part_gunshots == 2
				if (col != 256 || gl_part_gunshots.integer != 2)
					AddParticle(p_smoke, neworg, 1, 4, 0.825f + ((rand() % 10) - 5) / 40.0, NULL, zerodir);

				z = particlecount / chunkcount;
				if (!z || (i % z == 0))
					AddParticle(p_chunk, neworg, 1, 0.75, 3.75, NULL, zerodir);
			}
	}
}

void QMB_BlobExplosion(vec3_t org)
{
	float theta;
	col_t color;
	vec3_t neworg, vel;

	color[0] = 60; color[1] = 100; color[2] = 240; color[3] = 255;
	AddParticle(p_spark, org, 44, 250, 1.15, color, zerodir);

	color[0] = 90; color[1] = 47; color[2] = 207; color[3] = 255;
	AddParticle(p_fire, org, 15, 30, 1.4, color, zerodir);

	vel[2] = 0;
	//VULT PARTICLES
	if (amf_part_shockwaves.integer) {
		//VULT Get 3 rings to fly out
		if (amf_part_2dshockwaves.value) {
			vec3_t shockdir;
			int i;
			color[0] = (60 + (rand() & 15)); color[1] = (65 + (rand() & 15)); color[2] = (200 + (rand() & 15));
			color[3] = 255;
			for (i = 0; i<3; i++)
				shockdir[i] = rand() % 360;
			AddParticle(p_2dshockwave, org, 1, 30, 0.5, color, shockdir);
			for (i = 0; i<3; i++)
				shockdir[i] = rand() % 360;
			AddParticle(p_2dshockwave, org, 1, 30, 0.5, color, shockdir);
			for (i = 0; i<3; i++)
				shockdir[i] = rand() % 360;
			AddParticle(p_2dshockwave, org, 1, 30, 0.5, color, shockdir);
		}
		else {
			for (theta = 0; theta < 2 * M_PI; theta += 2 * M_PI / 70) {
				color[0] = (60 + (rand() & 15)); color[1] = (65 + (rand() & 15)); color[2] = (200 + (rand() & 15));
				color[3] = 255;

				vel[0] = cos(theta) * 125;
				vel[1] = sin(theta) * 125;
				neworg[0] = org[0] + cos(theta) * 6;
				neworg[1] = org[1] + sin(theta) * 6;
				neworg[2] = org[2] + 0 - 10;
				AddParticle(p_shockwave, neworg, 1, 4, 0.8, color, vel);
				neworg[2] = org[2] + 0 + 10;
				AddParticle(p_shockwave, neworg, 1, 4, 0.8, color, vel);


				vel[0] *= 1.15;
				vel[1] *= 1.15;
				neworg[0] = org[0] + cos(theta) * 13;
				neworg[1] = org[1] + sin(theta) * 13;
				neworg[2] = org[2] + 0;
				AddParticle(p_shockwave, neworg, 1, 6, 1.0, color, vel);
			}
		}
	}
}

void QMB_LavaSplash(vec3_t org)
{
	int	i, j;
	float vel;
	vec3_t dir, neworg;

	for (i = -16; i < 16; i++) {
		for (j = -16; j < 16; j++) {
			dir[0] = j * 8 + (rand() & 7);
			dir[1] = i * 8 + (rand() & 7);
			dir[2] = 256;

			neworg[0] = org[0] + dir[0];
			neworg[1] = org[1] + dir[1];
			neworg[2] = org[2] + (rand() & 63);

			VectorNormalizeFast(dir);
			vel = 50 + (rand() & 63);
			VectorScale(dir, vel, dir);

			AddParticle(p_lavasplash, neworg, 1, 4.5, 2.6 + (rand() & 31) * 0.02, NULL, dir);
		}
	}
}

void QMB_TeleportSplash(vec3_t org)
{
	int i, j, k;
	vec3_t neworg, angle;
	col_t color;
	extern cvar_t gl_part_telesplash;

	for (i = -12; i <= 12; i += 6) {
		for (j = -12; j <= 12; j += 6) {
			for (k = -24; k <= 32; k += 8) {
				neworg[0] = org[0] + i + (rand() & 3) - 1;
				neworg[1] = org[1] + j + (rand() & 3) - 1;
				neworg[2] = org[2] + k + (rand() & 3) - 1;
				angle[0] = (rand() & 15) - 7;
				angle[1] = (rand() & 15) - 7;
				angle[2] = (rand() % 160) - 80;
				AddParticle(p_teleflare, neworg, 1, 1.8, 0.30 + (rand() & 7) * 0.02, NULL, angle);
			}
		}
	}

	if (gl_part_telesplash.integer != 2) {
		VectorSet(color, 140, 140, 255);
		color[3] = 255;
		VectorClear(angle);
		for (i = 0; i < 5; i++) {
			angle[2] = 0;
			for (j = 0; j < 5; j++) {
				AngleVectors(angle, NULL, NULL, neworg);
				VectorMA(org, 70, neworg, neworg);
				AddParticle(p_sparkray, org, 1, 6 + (i & 3), 5, color, neworg);
				angle[2] += 360 / 5;
			}
			angle[0] += 180 / 5;
		}
	}
}

void QMB_DetpackExplosion(vec3_t org)
{
	int i, j;
	float theta;
	vec3_t neworg, angle = { 0, 0, 0 };
	extern cvar_t gl_part_detpackexplosion_fire_color, gl_part_detpackexplosion_ray_color;

	byte *f_color = (gl_part_detpackexplosion_fire_color.string[0] ? gl_part_detpackexplosion_fire_color.color : ColorForParticle(p_inferno_flame));
	byte *r_color = (gl_part_detpackexplosion_ray_color.string[0] ? gl_part_detpackexplosion_ray_color.color : NULL);

	if (QMB_InWaterEffect(org, true)) {
		AddParticle(p_bubble, org, 8, 2.8, 2.5, NULL, zerodir);
		AddParticle(p_bubble, org, 6, 2.2, 2.5, NULL, zerodir);
		AddParticle(p_fire, org, 10, 25, 0.75, f_color, zerodir);
	}
	else {
		AddParticle(p_fire, org, 14, 33, 0.75, f_color, zerodir);
	}

	for (i = 0; i < 5; i++) {
		angle[2] = 0;
		for (j = 0; j < 5; j++) {
			AngleVectors(angle, NULL, NULL, neworg);
			VectorMA(org, 90, neworg, neworg);
			AddParticle(p_sparkray, org, 1, 9 + (i & 3), 0.75, r_color, neworg);
			angle[2] += 360 / 5;
		}
		angle[0] += 180 / 5;
	}

	//VULT PARTICLES
	if (amf_part_shockwaves.value) {
		if (amf_part_2dshockwaves.value) {
			AddParticle(p_2dshockwave, org, 1, 30, 0.5, NULL, vec3_origin);
		}
		else {
			angle[2] = 0;
			for (theta = 0; theta < 2 * M_PI; theta += 2 * M_PI / 90) {
				angle[0] = cos(theta) * 350;
				angle[1] = sin(theta) * 350;
				AddParticle(p_shockwave, org, 1, 14, 0.75, NULL, angle);
			}
		}
	}
}

void QMB_InfernoFlame(vec3_t org)
{
	if (cls.frametime) {
		AddParticle(p_inferno_flame, org, 1, 30, 13.125 * cls.frametime, NULL, zerodir);
		AddParticle(p_inferno_trail, org, 2, 1.75, 45.0 * cls.frametime, NULL, zerodir);
		AddParticle(p_inferno_trail, org, 2, 1.0, 52.5 * cls.frametime, NULL, zerodir);
	}
}

void QMB_StaticBubble(entity_t *ent)
{
	AddParticle(p_staticbubble, ent->origin, 1, ent->frame == 1 ? 1.85 : 2.9, ONE_FRAME_ONLY, NULL, zerodir);
}

//VULT PARTICLES
//This WAS supposed to do more than just rain but I haven't really got around to
//writing anything else for it.
void ParticleFirePool(vec3_t);
extern cvar_t tei_lavafire;

void WeatherEffect(void)
{
	vec3_t org, start, impact, normal;
	int i;
	col_t colour = { 128, 128, 128, 75 };

	if (amf_weather_rain.integer) {
		for (i = 0; i <= amf_weather_rain.integer; i++) {
			VectorCopy(r_refdef.vieworg, org);
			org[0] = org[0] + (rand() % 3000) - 1500;
			org[1] = org[1] + (rand() % 3000) - 1500;
			VectorCopy(org, start);
			org[2] = org[2] + 15000;

			//Trace a line straight up, get the impact location

			//trace up slowly until we are in sky
			TraceLineN(start, org, impact, normal);

			//fixme: see is surface above has SURF_DRAWSKY (we'll come back to that, when the important stuff is done fist, eh?)
			//if (TruePointContents (impact) == CONTENTS_SKY && trace) {
			if (Mod_PointInLeaf(impact, cl.worldmodel)->contents == CONTENTS_SKY) {
				VectorCopy(impact, org);
				org[2] = org[2] - 1;
				AddParticle(p_rain, org, 1, 1, 15, colour, zerodir);
			}
		}
	}

	//Tei, lavafire on 2 or superior 
	// this can be more better for some users than "eshaders"
	if (tei_lavafire.integer > 2) {
		for (i = 0; i < tei_lavafire.integer; i++) {
			VectorCopy(r_refdef.vieworg, org);
			org[0] = org[0] + (rand() % 3000) - 1500;
			org[1] = org[1] + (rand() % 3000) - 1500;
			VectorCopy(org, start);
			org[2] = org[2] - 15000;

			TraceLineN(start, org, impact, normal);

			//if (TruePointContents (impact) == CONTENTS_LAVA && trace) {
			if (Mod_PointInLeaf(impact, cl.worldmodel)->contents == CONTENTS_LAVA) {
				ParticleFirePool(impact);
			}
		}
	}
}

//VULT PARTICLES
void RainSplash(vec3_t org)
{
	vec3_t pos;
	col_t colour = { 255,255,255,255 };

	VectorCopy(org, pos);
	pos[2] = pos[2] + 1; //To get above the water on servers that don't use watervis

						 //VULT - Sometimes the shockwave effect isn't noticable enough?
	AddParticle(p_2dshockwave, pos, 1, 5, 0.5, colour, vec3_origin);
}

//VULT PARTICLES
//Cheap function which will generate some sparks for me to be called elsewhere
void SparkGen(vec3_t org, byte col[3], float count, float size, float life)
{
	col_t color;
	vec3_t dir;
	int i, a;

	color[0] = col[0];
	color[1] = col[1];
	color[2] = col[2];
	color[3] = 255;

	if (amf_part_sparks.value) {
		for (a = 0; a<count; a++) {
			for (i = 0; i<3; i++)
				dir[i] = (rand() % (int)size * 2) - ((int)size * 2 / 3);
			if (amf_part_trailtype.value == 2)
				AddParticle(p_smallspark, org, 1, 1, life, color, dir);
			else
				AddParticle(p_streak, org, 1, 1, life, color, dir);

		}
	}
	else
		AddParticle(p_spark, org, count, size, life, color, zerodir);
}

//VULT PARTICLES
//VULT - Does the deed when someone shoots a wall
void VXGunshot(vec3_t org, float count)
{
	col_t color = { 255,80,10, 128 };
	vec3_t dir, neworg;
	int a, i;

	if (amf_part_gunshot_type.value == 2 || amf_part_gunshot_type.value == 3) {
		color[0] = 255;
		color[1] = 242;
		color[2] = 153;
		VectorClear(dir);
		for (i = 0; i < 5; i++) {
			dir[2] = 0;
			for (a = 0; a < 5; a++) {
				AngleVectors(dir, NULL, NULL, neworg);
				VectorMA(org, 40, neworg, neworg);
				AddParticle(p_sparkray, org, 1, 3, 1.5, color, neworg);
				dir[2] += 360 / 5;
			}
			dir[0] += 180 / 5;
		}
		if (amf_coronas.integer) {
			R_CoronasNew(C_WHITELIGHT, org);
		}
		if (amf_part_gunshot_type.value == 3) {
			return;
		}
	}
	else if (amf_part_gunshot_type.value == 4) {
		color[0] = 255;
		color[1] = 80;
		color[2] = 10;
		color[3] = 128;
		if (amf_coronas.integer) {
			R_CoronasNew(C_GUNFLASH, org);
		}
		for (a = 0; a < count*1.5; a++) {
			for (i = 0; i < 3; i++) {
				dir[i] = (rand() % 700) - 300;
			}
			AddParticle(p_streakwave, org, 1, 1, 0.066*amf_part_trailtime.value, color, dir);
		}
		return;
	}
	else if (amf_coronas.integer) {
		R_CoronasNew(C_GUNFLASH, org);
	}

	for (a = 0; a < count; a++) {
		for (i = 0; i < 3; ++i) {
			dir[i] = (rand() % 700) - 350;
		}
		if (amf_part_trailtype.value == 2) {
			AddParticle(p_smallspark, org, 1, 1, 1 * amf_part_trailtime.value, NULL, dir);
		}
		else {
			AddParticle(p_streak, org, 1, 1, 1 * amf_part_trailtime.value, color, dir);
		}
	}

	if (QMB_InWaterEffect(org, false)) {
		AddParticle(p_bubble, org, count / 5, 2.35, 2.5, NULL, zerodir);
	}
}

//VULT PARTICLES
void VXNailhit(vec3_t org, float count)
{
	col_t color;
	vec3_t dir, neworg;
	int a, i;
	if (amf_nailtrail_plasma.integer) {
		color[0] = 10;
		color[1] = 80;
		color[2] = 255;
		color[3] = 128;
		AddParticle(p_fire, org, 15, 5, 0.5, color, zerodir);
	}
	else if (amf_part_spikes_type.integer == 2 || amf_part_spikes_type.integer == 3) {
		color[0] = 255;
		color[1] = 242;
		color[2] = 153;
		color[3] = 255;
		VectorClear(dir);
		for (i = 0; i < 5; i++) {
			dir[2] = 0;
			for (a = 0; a < 5; a++) {
				AngleVectors(dir, NULL, NULL, neworg);
				VectorMA(org, 40, neworg, neworg);
				AddParticle(p_sparkray, org, 1, 3, 1.5, color, neworg);
				dir[2] += 360 / 5;
			}
			dir[0] += 180 / 5;
		}
		if (amf_coronas.integer) {
			R_CoronasNew(C_WHITELIGHT, org);
		}
		if (amf_part_spikes_type.integer == 3) {
			return;
		}
	}
	else if (amf_part_spikes_type.integer == 4) {
		color[0] = 255;
		color[1] = 80;
		color[2] = 10;
		color[3] = 128;
		if (amf_coronas.integer) {
			R_CoronasNew(C_GUNFLASH, org);
		}
		for (a = 0; a<count*1.5; a++) {
			for (i = 0; i < 3; i++) {
				dir[i] = (rand() % 700) - 300;
			}
			AddParticle(p_streakwave, org, 1, 1, 0.066*amf_part_trailtime.value, color, dir);
		}
		return;
	}
	else {
		color[0] = 255;
		color[1] = 80;
		color[2] = 10;
		color[3] = 128;
		if (amf_coronas.integer) {
			R_CoronasNew(C_GUNFLASH, org);
		}
	}

	for (a = 0; a < count; ++a) {
		for (i = 0; i < 3; i++) {
			dir[i] = (rand() % 700) - 350;
		}
		if (amf_part_trailtype.value == 2) {
			if (amf_nailtrail_plasma.value) {
				AddParticle(p_smallspark, org, 1, 1, 1 * amf_part_trailtime.value, color, dir);
			}
			else {
				AddParticle(p_smallspark, org, 1, 1, 1 * amf_part_trailtime.value, NULL, dir);
			}
		}
		else {
			AddParticle(p_streak, org, 1, 1, 1 * amf_part_trailtime.value, color, dir);
		}
	}

	if (QMB_InWaterEffect(org, false)) {
		AddParticle(p_bubble, org, count / 5, 2.35, 2.5, NULL, zerodir);
	}

}

//VULT PARTICLES
void VXExplosion(vec3_t org)
{
	col_t color = { 255,100,25, 128 };
	vec3_t dir;
	int a, i;
	float theta;
	vec3_t angle;

	if (QMB_InWaterEffect(org, true)) {
		if (r_explosiontype.value != 9) {
			AddParticle(p_fire, org, 12, 14, 0.8, NULL, zerodir);
		}
		AddParticle(p_bubble, org, 12, 3.0, 2.5, NULL, zerodir);
		AddParticle(p_bubble, org, 8, 2.35, 2.5, NULL, zerodir);
	}
	else if (r_explosiontype.value != 9) {
		AddParticle(p_fire, org, 16, 18, 1, NULL, zerodir);
	}

	for (a = 0; a < 120 * amf_part_explosion.value; a++) {
		for (i = 0; i < 3; i++) {
			dir[i] = (rand() % 1500) - 750;
		}
		if (amf_part_trailtype.value == 2) {
			AddParticle(p_smallspark, org, 1, 1, 1 * amf_part_trailtime.value, NULL, dir);
		}
		else {
			AddParticle(p_streak, org, 1, 1, 1 * amf_part_trailtime.value, color, dir);
		}
	}

	if (amf_part_shockwaves.value) {
		if (amf_part_2dshockwaves.value) {
			AddParticle(p_2dshockwave, org, 1, 30, 0.5, NULL, vec3_origin);
		}
		else {
			angle[2] = 0;
			for (theta = 0; theta < 2 * M_PI; theta += 2 * M_PI / 90) {
				angle[0] = cos(theta) * 500;
				angle[1] = sin(theta) * 500;
				AddParticle(p_shockwave, org, 1, 10, 0.5, NULL, angle);
			}
		}
	}
}

//VULT PARTICLES
void VXBlobExplosion(vec3_t org)
{
	float theta;
	col_t color;
	vec3_t neworg, vel, dir;
	int a, i;
	color[0] = 60; color[1] = 100; color[2] = 240; color[3] = 128;
	for (a = 0; a < 200 * amf_part_blobexplosion.value; a++) {
		for (i = 0; i < 3; i++) {
			dir[i] = (rand() % 1500) - 750;
		}
		AddParticle(p_streakwave, org, 1, 1, 1 * amf_part_trailtime.value, color, dir);
	}

	color[0] = 90; color[1] = 47; color[2] = 207;
	AddParticle(p_fire, org, 15, 30, 1.4, color, zerodir);

	vel[2] = 0;
	//VULT PARTICLES
	if (amf_part_shockwaves.value) {
		if (amf_part_2dshockwaves.value) {
			vec3_t shockdir;
			int i;
			color[0] = (60 + (rand() & 15)); color[1] = (65 + (rand() & 15)); color[2] = (200 + (rand() & 15));
			for (i = 0; i < 3; i++) {
				shockdir[i] = rand() % 360;
			}
			AddParticle(p_2dshockwave, org, 1, 30, 0.5, color, shockdir);
			for (i = 0; i < 3; i++) {
				shockdir[i] = rand() % 360;
			}
			AddParticle(p_2dshockwave, org, 1, 30, 0.5, color, shockdir);
			for (i = 0; i < 3; i++) {
				shockdir[i] = rand() % 360;
			}
			AddParticle(p_2dshockwave, org, 1, 30, 0.5, color, shockdir);
		}
		else {
			for (theta = 0; theta < 2 * M_PI; theta += 2 * M_PI / 70) {
				color[0] = (60 + (rand() & 15)); color[1] = (65 + (rand() & 15)); color[2] = (200 + (rand() & 15));

				vel[0] = cos(theta) * 125;
				vel[1] = sin(theta) * 125;
				neworg[0] = org[0] + cos(theta) * 6;
				neworg[1] = org[1] + sin(theta) * 6;
				neworg[2] = org[2] + 0 - 10;

				AddParticle(p_shockwave, neworg, 1, 4, 0.8, color, vel);
				neworg[2] = org[2] + 0 + 10;
				AddParticle(p_shockwave, neworg, 1, 4, 0.8, color, vel);

				vel[0] *= 1.15;
				vel[1] *= 1.15;
				neworg[0] = org[0] + cos(theta) * 13;
				neworg[1] = org[1] + sin(theta) * 13;
				neworg[2] = org[2] + 0;
				AddParticle(p_shockwave, neworg, 1, 6, 1.0, color, vel);
			}
		}
	}
}

//VULT PARTICLES
void VXTeleport(vec3_t org)
{
	int i, j, a;
	vec3_t neworg, angle, dir;
	col_t color;

	VectorSet(color, 140, 140, 255);
	VectorClear(angle);
	for (i = 0; i < 5; i++) {
		angle[2] = 0;
		for (j = 0; j < 5; j++) {
			AngleVectors(angle, NULL, NULL, neworg);
			VectorMA(org, 70, neworg, neworg);
			AddParticle(p_sparkray, org, 1, 6 + (i & 3), 5, color, neworg);
			angle[2] += 360 / 5;
		}
		angle[0] += 180 / 5;
	}

	color[0] = color[1] = color[2] = 255;
	color[3] = 128;
	for (a = 0; a < 200 * amf_part_teleport.value; a++) {
		for (i = 0; i < 3; i++)
			dir[i] = (rand() % 1500) - 750;
		AddParticle(p_streakwave, org, 1, 1, 1 * amf_part_trailtime.value, color, dir);
	}
}

//VULT - We need some kind of splatter effect, here it is
void VXBlood(vec3_t org, float count)
{
	col_t color;
	int a, i;
	vec3_t start, end;

	if (amf_part_blood_type.integer) {
		VectorCopy(org, start);

		for (i = 0; i < 15; i++) {
			VectorCopy(start, end);

			end[0] += rand() % 30 - 15;
			end[1] += rand() % 30 - 15;
			end[2] += rand() % 30 - 15;

			QMB_ParticleTrail(start, end, BLEEDING_TRAIL2);
		}
	}

	//blue
	if (amf_part_blood_color.value == 2) {
		color[0] = 55; color[1] = 102; color[2] = 255;
	}
	//green
	else if (amf_part_blood_color.value == 3) {
		color[0] = 80; color[1] = 255; color[2] = 80;
	}
	//red
	else {
		color[0] = 255; color[1] = 0; color[2] = 0;
	}
	color[3] = 255;

	for (a = 0; a < count; a++) {
		AddParticle(p_vxblood, org, 1, 2.5, 2, color, 0);
	}
}


================================================
FILE: src/r_particles_qmb_trails.c
================================================
/*
Copyright (C) 2002-2003, Dr Labman, A. Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "gl_model.h"
#include "vx_stuff.h"
#include "r_particles_qmb.h"
#include "pmove.h"
#include "utils.h"
#include "qmb_particles.h"
#include "r_brushmodel.h" // R_PointIsUnderwater only

//#define qmb_end(cent) ((cent)->current.origin)
#define qmb_end(cent) ((cent)->lerp_origin)

extern cvar_t gl_part_tracer1_color, gl_part_tracer1_size, gl_part_tracer1_time;
extern cvar_t gl_part_tracer2_color, gl_part_tracer2_size, gl_part_tracer2_time;

__inline static void AddParticleTrailImpl(part_type_t type, vec3_t start, vec3_t end, float size, float time, col_t col, centity_t* cent, int trail_index)
{
	byte *color;
	int i, j, num_particles;
	float count = 0.0, theta = 0.0;
	vec3_t point, delta;
	particle_t *p;
	particle_type_t *pt;
	//VULT PARTICLES - for railtrail
	int loops = 0, entity_ref;
	vec3_t vf, vr, radial;

	if (!qmb_initialized) {
		Sys_Error("QMB particle added without initialization");
	}

	entity_ref = cent ? (cent - cl_entities) + 1 : 0;
	entity_ref = bound(0, entity_ref, CL_MAX_EDICTS);

	if (time == 0 || size == 0.0f) {
		return;
	}

	if (type >= num_particletypes) {
		Sys_Error("AddParticle: Invalid type (%d)", type);
	}

	pt = &particle_types[particle_type_index[type]];

	VectorCopy(start, point);
	VectorSubtract(end, start, delta);
	if (pt->drawtype == pd_dynamictrail) {
		count = 1;
	}
	else {
		float length = VectorLength(delta);
		if (length < 1) {
			goto done;
		}

		// length > 140 was old limit in cl_ents.c
		if (length > 140 && entity_ref) {
			VectorCopy(end, point);
			goto done;
		}

		switch (type) {
			case p_alphatrail:
			case p_lavatrail:
			case p_bleedspike:
			case p_bubble:
				count = length / 1.1;
				break;
			case p_bubble2:
				count = length / 5;
				break;
			case p_trailpart:
				count = length / 1.1;
				break;
			case p_blood3:
				count = length / 8;
				break;
			case p_smoke:
			case p_vxrocketsmoke:
				count = length / 3.8;
				break;
			case p_dpsmoke:
				count = length / 2.5;
				break;
			case p_dpfire:
				count = length / 2.8;
				break;
				//VULT PARTICLES
			case p_railtrail:
				count = length * 1.6;
				if (!(loops = (int)length / 13.0)) {
					goto done;
				}
				VectorScale(delta, 1 / length, vf);
				VectorVectors(vf, vr, vup);
				break;
			case p_trailbleed:
				count = length / 1.1;
				break;
			default:
				Com_DPrintf("AddParticleTrail: unexpected type %d\n", type);
				break;
		}
	}

	if (!(num_particles = (int)count)) {
		goto done;
	}

	if (!free_particles) {
		// we hit limit, don't try and draw from old position if this resolves
		VectorCopy(end, point);
		goto done;
	}

	VectorScale(delta, 1.0 / num_particles, delta);
	for (i = 0; i < num_particles && free_particles; i++) {
		color = col ? col : ColorForParticle(type);
		INIT_NEW_PARTICLE(pt, p, color, size, time);
		p->entity_ref = entity_ref;
		p->entity_trailindex = trail_index;
		if (entity_ref) {
			p->entity_trailnumber = cent->trail_number;
		}

		if (pt->drawtype == pd_dynamictrail) {
			VectorCopy(start, p->org);
			VectorCopy(end, p->endorg);
		}
		else {
			switch (type) {
				//VULT PARTICLES
				case p_trailpart:
				case p_alphatrail:
					VectorCopy(point, p->org);
					VectorClear(p->vel);
					p->growth = -size / time;
					break;
				case p_blood3:
					VectorCopy(point, p->org);
					for (j = 0; j < 3; j++) {
						p->org[j] += ((rand() & 15) - 8) / 8.0;
					}
					for (j = 0; j < 3; j++) {
						p->vel[j] = ((rand() & 15) - 8) / 2.0;
					}
					p->size = size * (rand() % 20) / 10.0;
					p->growth = 6;
					break;
				case p_smoke:
					VectorCopy(point, p->org);
					for (j = 0; j < 3; j++) {
						p->org[j] += ((rand() & 7) - 4) / 8.0;
					}
					p->vel[0] = p->vel[1] = 0;
					p->vel[2] = rand() & 3;
					p->growth = 4.5;
					p->rotspeed = (rand() & 63) + 96;
					break;
				case p_dpsmoke:
					VectorCopy(point, p->org);
					for (j = 0; j < 3; j++) {
						p->vel[j] = (rand() % 10) - 5;
					}
					p->growth = 3;
					p->rotspeed = (rand() & 63) + 96;
					break;
				case p_dpfire:
					VectorCopy(point, p->org);
					for (j = 0; j < 3; j++) {
						p->vel[j] = (rand() % 40) - 20;
					}
					break;
					//VULT PARTICLES
				case p_railtrail:
					theta += loops * 2 * M_PI / count;
					for (j = 0; j < 3; j++) {
						radial[j] = vr[j] * cos(theta) + vup[j] * sin(theta);
					}
					VectorMA(point, 2.6, radial, p->org);
					for (j = 0; j < 3; j++) {
						p->vel[j] = radial[j] * 5;
					}
					break;
					//VULT PARTICLES
				case p_bubble:
				case p_bubble2:
					VectorCopy(point, p->org);
					for (j = 0; j < 3; j++) {
						p->vel[j] = (rand() % 10) - 5;
					}
					break;
					//VULT PARTICLES
				case p_lavatrail:
					VectorCopy(point, p->org);
					for (j = 0; j < 3; j++) {
						p->org[j] += ((rand() & 7) - 4);
					}
					p->vel[0] = p->vel[1] = 0;
					p->vel[2] = rand() & 3;
					break;
					//VULT PARTICLES
				case p_vxrocketsmoke:
					VectorCopy(point, p->org);
					for (j = 0; j < 3; j++) {
						p->vel[j] = (rand() % 8) - 4;
					}
					break;
					//VULT PARTICLES
				case p_trailbleed:
					p->size = (rand() % (int)size);
					p->growth = -rand() % 5;
					VectorCopy(point, p->org);
					break;
					//VULT PARTICLES
				case p_bleedspike:
					size = 9 * size / 10;
					VectorCopy(point, p->org);
					break;
				default:
					//assert(!"AddParticleTrail: unexpected type"); -> hexum - FIXME not all types are handled, seems to work ok though
					break;
			}
		}

		VectorAdd(point, delta, point);
	}
done:
	if (cent) {
		VectorCopy(point, cent->trails[trail_index].stop);
	}
}

__inline static void AddEntityParticleTrail(part_type_t type, centity_t* cent, int trail_index, float size, float time, col_t color)
{
	AddParticleTrailImpl(type, cent->trails[trail_index].stop, qmb_end(cent), size, time, color, cent, trail_index);
}

__inline static void AddParticleTrail(part_type_t type, vec3_t start, vec3_t stop, float size, float time, col_t color)
{
	AddParticleTrailImpl(type, start, stop, size, time, color, NULL, 0);
}

//VULT PARTICLES
//VULT - Draw a thin white trail that could be used to represent motion for just about anything
void ParticleAlphaTrail(centity_t* cent, float size, float life)
{
	if (amf_underwater_trails.integer && R_PointIsUnderwater(cent->trails[0].stop)) {
		AddEntityParticleTrail(amf_nailtrail_water.integer ? p_bubble2 : p_bubble, cent, 0, 1.5, 0.825, NULL);
	}
	else {
		col_t color = { 10, 10, 10, 0 };

		AddEntityParticleTrail(p_alphatrail, cent, 0, size, life, color);
	}
}

//MEAG: Draw thin trail for nails etc
void ParticleNailTrail(centity_t* client_ent, float size, float life)
{
	if (amf_underwater_trails.integer && R_PointIsUnderwater(client_ent->trails[0].stop)) {
		AddEntityParticleTrail(amf_nailtrail_water.integer ? p_bubble2 : p_bubble, client_ent, 0, 1.5, 0.825, NULL);
	}
	else {
		if (particle_time - client_ent->trails[0].lasttime < MIN_ENTITY_PARTICLE_FRAMETIME) {
			return;
		}
		client_ent->trails[0].lasttime = particle_time;
		AddEntityParticleTrail(p_nailtrail, client_ent, 0, size, life, NULL);
	}
}

//VULT PARTICLES
void FireballTrail(centity_t* cent, byte col[3], float size, float life)
{
	col_t color;

	color[0] = col[0];
	color[1] = col[1];
	color[2] = col[2];
	color[3] = 255;

	//head
	AddEntityParticleTrail(p_trailpart, cent, 0, size * 7, 0.15, color);

	//head-white part
	color[0] = 255; color[1] = 255; color[2] = 255;
	AddEntityParticleTrail(p_trailpart, cent, 1, size * 5, 0.15, color);

	//medium trail
	color[0] = col[0];
	color[1] = col[1];
	color[2] = col[2];
	AddEntityParticleTrail(p_trailpart, cent, 2, size * 3, life, color);
}

//VULT PARTICLES
void FireballTrailWave(centity_t* cent, byte col[3], float size, float life, vec3_t angle)
{
	int i, j;
	vec3_t dir, vec;
	col_t color;
	color[0] = col[0];
	color[1] = col[1];
	color[2] = col[2];
	color[3] = 255;

	AngleVectors(angle, vec, NULL, NULL);
	vec[2] *= -1;
	FireballTrail(cent, col, size, life);
	if (cent->trails[2].lasttime == particle_time) {
		for (i = 0; i < 3; i++) {
			for (j = 0; j < 3; j++) {
				dir[j] = vec[j] * -600 + ((rand() % 100) - 50);
			}
			AddParticle(p_streakwave, qmb_end(cent), 1, 1, 1, color, dir);
		}
	}
}

//VULT PARTICLES
void FuelRodGunTrail(centity_t* cent)
{
	col_t color;
	int i, j;
	vec3_t dir, vec;
	color[3] = 255;

	color[0] = 0; color[1] = 255; color[2] = 0;
	AddEntityParticleTrail(p_trailpart, cent, 0, 15, 0.2, color);
	color[0] = 255; color[1] = 255; color[2] = 255;
	AddEntityParticleTrail(p_trailpart, cent, 1, 10, 0.2, color);
	color[0] = 0; color[1] = 128; color[2] = 0;
	AddEntityParticleTrail(p_trailpart, cent, 2, 10, 0.5, color);
	color[0] = 0; color[1] = 22; color[2] = 0;
	AddEntityParticleTrail(p_trailpart, cent, 3, 2, 3, color);
	if (cent->trails[3].lasttime == particle_time) {
		AngleVectors(cent->current.angles, vec, NULL, NULL);
		color[0] = 75; color[1] = 255; color[2] = 75;
		for (i = 0; i < 3; i++) {
			for (j = 0; j < 3; j++) {
				dir[j] = vec[j] * -300 + ((rand() % 100) - 50);
			}
			dir[2] = dir[2] + 60;
			if (amf_part_trailtype.integer == 2) {
				AddParticle(p_smallspark, qmb_end(cent), 1, 1, 2, color, dir);
			}
			else {
				AddParticle(p_streak, qmb_end(cent), 1, 1, 2, color, dir);
			}
		}
	}
}

//VULT PARTICLES
//VULT - These trails were my initial motivation behind AMFQUAKE.
void VX_ParticleTrail(vec3_t start, vec3_t end, float size, float time, col_t color)
{
	vec3_t		vec;
	float		len;
	static vec3_t zerodir = { 22, 22, 22 };

	time *= amf_part_traillen.value;
	if (!time) {
		return;
	}

	if (amf_part_fulldetail.integer) {
		VectorSubtract(end, start, vec);
		len = VectorNormalize(vec);

		while (len > 0) {
			//ADD PARTICLE HERE
			AddParticle(p_streaktrail, start, 1, size, time, color, zerodir);
			len--;
			VectorAdd(start, vec, start);
		}
	}
	AddParticle(p_streaktrail, start, 1, size, time, color, end);
}

void QMB_ParticleTrail(vec3_t start, vec3_t end, trail_type_t type)
{
	col_t color;

	switch (type) {
		case GRENADE_TRAIL:
			//VULT PARTICLES
			if (amf_underwater_trails.integer && R_PointIsUnderwater(start)) {
				AddParticleTrail(p_bubble, start, end, 1.8, 0.825, NULL);
			}
			else {
				AddParticleTrail(p_smoke, start, end, 1.45, 0.825, NULL);
			}
			break;
		case BLOOD_TRAIL:
		case BIG_BLOOD_TRAIL:
			AddParticleTrail(p_blood3, start, end, type == BLOOD_TRAIL ? 1.35 : 2.4, 2, NULL);
			break;
		case TRACER1_TRAIL:
			AddParticleTrail(p_trailpart, start, end, gl_part_tracer1_size.value, gl_part_tracer1_time.value, gl_part_tracer1_color.color);
			break;
		case TRACER2_TRAIL:
			AddParticleTrail(p_trailpart, start, end, gl_part_tracer2_size.value, gl_part_tracer2_time.value, gl_part_tracer2_color.color);
			break;
		case VOOR_TRAIL:
			color[0] = 77; color[1] = 0; color[2] = 255; color[3] = 255;
			AddParticleTrail(p_trailpart, start, end, 3.75, 0.5, color);
			break;
		case ALT_ROCKET_TRAIL:
			if (amf_underwater_trails.integer && R_PointIsUnderwater(start)) {
				AddParticleTrail(p_bubble, start, end, 1.8, 0.825, NULL);
			}
			else {
				AddParticleTrail(p_dpfire, start, end, 3, 0.26, NULL);
				AddParticleTrail(p_dpsmoke, start, end, 3, 0.825, NULL);
			}
			break;
			//VULT TRAILS
		case RAIL_TRAIL:
		case RAIL_TRAIL2:
			color[0] = 255; color[1] = 255; color[2] = 255; color[3] = 255;
			//VULT PARTICLES
			AddParticleTrail(p_alphatrail, start, end, 2, 0.525, color);
			if (type == RAIL_TRAIL2) {
				color[0] = 255;
				color[1] = 0;
				color[2] = 0;
			}
			else {
				color[0] = 0;
				color[1] = 0;
				color[2] = 255;
			}
			AddParticleTrail(p_railtrail, start, end, 1.3, 0.525, color);
			break;
			//VULT TRAILS
		case LAVA_TRAIL:
			if (amf_underwater_trails.integer && R_PointIsUnderwater(start)) {
				AddParticleTrail(p_bubble, start, end, 1.8, 0.825, NULL);
				color[0] = 25;
				color[1] = 102;
				color[2] = 255;
				color[3] = 255;
			}
			else {
				color[0] = 255;
				color[1] = 102;
				color[2] = 25;
				color[3] = 255;
			}
			AddParticleTrail(p_lavatrail, start, end, 5, 1, color);
			break;
			//VULT TRAILS
		case AMF_ROCKET_TRAIL:
			if (amf_underwater_trails.integer && R_PointIsUnderwater(start)) {
				AddParticleTrail(p_bubble, start, end, 1.8, 0.825, NULL);
			}
			else {
				color[0] = 128; color[1] = 128; color[2] = 128; color[3] = 255;
				AddParticleTrail(p_alphatrail, start, end, 2, 0.6, color);
				AddParticleTrail(p_vxrocketsmoke, start, end, 3, 0.5, color);

				color[0] = 128; color[1] = 56; color[2] = 9; color[3] = 255;
				AddParticleTrail(p_trailpart, start, end, 4, 0.2, color);
			}
			break;
			//VULT PARTICLES
		case BLEEDING_TRAIL:
		case BLEEDING_TRAIL2:
			if (amf_part_blood_color.value == 2) {
				color[0] = 55; color[1] = 102; color[2] = 255;
			}
			//green
			else if (amf_part_blood_color.value == 3) {
				color[0] = 80; color[1] = 255; color[2] = 80;
			}
			//red
			else {
				color[0] = 128; color[1] = 0; color[2] = 0;
			}
			color[3] = 255;
			AddParticleTrail(type == BLEEDING_TRAIL ? p_trailbleed : p_bleedspike, start, end, 4, type == BLEEDING_TRAIL ? 0.5 : 0.2, color);
			break;
		case ROCKET_TRAIL:
		default:
			color[0] = 255; color[1] = 56; color[2] = 9; color[3] = 255;
			AddParticleTrail(p_trailpart, start, end, 6.2, 0.31, color);
			AddParticleTrail(p_smoke, start, end, 1.8, 0.825, NULL);
			break;
	}
}

void QMB_EntityParticleTrail(centity_t* cent, trail_type_t type)
{
	col_t color;

	switch (type) {
		case GRENADE_TRAIL:
			//VULT PARTICLES
			if (amf_underwater_trails.integer && R_PointIsUnderwater(cent->trails[0].stop)) {
				AddEntityParticleTrail(p_bubble, cent, 0, 1.8, 0.825, NULL);
			}
			else {
				AddEntityParticleTrail(p_smoke, cent, 0, 1.45, 0.825, NULL);
			}
			break;
		case BLOOD_TRAIL:
		case BIG_BLOOD_TRAIL:
			AddEntityParticleTrail(p_blood3, cent, 0, type == BLOOD_TRAIL ? 1.35 : 2.4, 2, NULL);
			break;
		case TRACER1_TRAIL:
			AddEntityParticleTrail(p_trailpart, cent, 0, gl_part_tracer1_size.value, gl_part_tracer1_time.value, gl_part_tracer1_color.color);
			break;
		case TRACER2_TRAIL:
			AddEntityParticleTrail(p_trailpart, cent, 0, gl_part_tracer2_size.value, gl_part_tracer2_time.value, gl_part_tracer2_color.color);
			break;
		case VOOR_TRAIL:
			color[0] = 77; color[1] = 0; color[2] = 255; color[3] = 255;
			AddEntityParticleTrail(p_trailpart, cent, 0, 3.75, 0.5, color);
			break;
		case ALT_ROCKET_TRAIL:
			if (amf_underwater_trails.integer && R_PointIsUnderwater(qmb_end(cent))) {
				AddEntityParticleTrail(p_bubble, cent, 0, 1.8, 0.825, NULL);
			}
			else {
				AddEntityParticleTrail(p_dpfire, cent, 0, 3, 0.26, NULL);
				AddEntityParticleTrail(p_dpsmoke, cent, 1, 3, 0.825, NULL);
			}
			break;
			//VULT TRAILS
		case RAIL_TRAIL:
		case RAIL_TRAIL2:
			color[0] = 255; color[1] = 255; color[2] = 255; color[3] = 255;
			//VULT PARTICLES
			AddEntityParticleTrail(p_alphatrail, cent, 0, 2, 0.525, color);
			if (type == RAIL_TRAIL2) {
				color[0] = 255;
				color[1] = 0;
				color[2] = 0;
			}
			else {
				color[0] = 0;
				color[1] = 0;
				color[2] = 255;
			}
			AddEntityParticleTrail(p_railtrail, cent, 1, 1.3, 0.525, color);
			break;
			//VULT TRAILS
		case LAVA_TRAIL:
			if (amf_underwater_trails.integer && R_PointIsUnderwater(qmb_end(cent))) {
				AddEntityParticleTrail(p_bubble, cent, 0, 1.8, 0.825, NULL);
				color[0] = 25;
				color[1] = 102;
				color[2] = 255;
				color[3] = 255;
			}
			else {
				color[0] = 255;
				color[1] = 102;
				color[2] = 25;
				color[3] = 255;
			}
			AddEntityParticleTrail(p_lavatrail, cent, 1, 5, 1, color);
			break;
			//VULT TRAILS
		case AMF_ROCKET_TRAIL:
			if (amf_underwater_trails.integer && R_PointIsUnderwater(qmb_end(cent))) {
				AddEntityParticleTrail(p_bubble, cent, 0, 1.8, 0.825, NULL);
			}
			else {
				color[0] = 128; color[1] = 128; color[2] = 128; color[3] = 255;
				AddEntityParticleTrail(p_alphatrail, cent, 0, 2, 0.6, color);
				AddEntityParticleTrail(p_vxrocketsmoke, cent, 1, 3, 0.5, color);

				color[0] = 128; color[1] = 56; color[2] = 9; color[3] = 255;
				AddEntityParticleTrail(p_trailpart, cent, 2, 4, 0.2, color);
			}
			break;
			//VULT PARTICLES
		case BLEEDING_TRAIL:
		case BLEEDING_TRAIL2:
			if (amf_part_blood_color.value == 2) {
				color[0] = 55; color[1] = 102; color[2] = 255;
			}
			//green
			else if (amf_part_blood_color.value == 3) {
				color[0] = 80; color[1] = 255; color[2] = 80;
			}
			//red
			else {
				color[0] = 128; color[1] = 0; color[2] = 0;
			}
			color[3] = 255;
			AddEntityParticleTrail(type == BLEEDING_TRAIL ? p_trailbleed : p_bleedspike, cent, 0, 4, type == BLEEDING_TRAIL ? 0.5 : 0.2, color);
			break;
		case ROCKET_TRAIL:
		default:
			color[0] = 255; color[1] = 56; color[2] = 9; color[3] = 255;
			AddEntityParticleTrail(p_trailpart, cent, 0, 6.2, 0.31, color);
			AddEntityParticleTrail(p_smoke, cent, 1, 1.8, 0.825, NULL);
			break;
	}
}

// deurk: QMB version of ported zquake rail trail
void QMB_ParticleRailTrail(vec3_t start, vec3_t end, int color_num)
{
	col_t color;

	color[0] = 255; color[1] = 255; color[2] = 255; color[3] = 255;
	AddParticleTrail(p_alphatrail, start, end, 0.5, 0.5, color);
	switch (color_num) {
		case 180:
			color[0] = 91; color[1] = 74; color[2] = 56;
			break;
		case 35:
			color[0] = 121; color[1] = 118; color[2] = 185;
			break;
		case 224:
			color[0] = 206; color[1] = 0; color[2] = 0;
			break;
		case 133:
			color[0] = 107; color[1] = 70; color[2] = 88;
			break;
		case 192:
			color[0] = 255; color[1] = 242; color[2] = 32;
			break;
		case 6:
			color[0] = 200; color[1] = 200; color[2] = 200;
			break;
		default:
			color[0] = 0; color[1] = 0; color[2] = 255;
			break;
	}
	AddParticleTrail(p_alphatrail, start, end, 2, 1, color);
}


================================================
FILE: src/r_performance.c
================================================

/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// r_surf.c: surface-related refresh code

#include "quakedef.h"
#include "r_framestats.h"
#include "r_local.h"
#include "r_renderer.h"
#include "r_trace.h"

static cvar_t* framestats_shown;

void R_PerformanceBeginFrame(void)
{
	qbool frameStatsVisible;

	if (!framestats_shown) {
		framestats_shown = Cvar_Find("hud_framestats_show");
	}
	frameStatsVisible = framestats_shown && framestats_shown->integer;

	if (r_speeds.integer) {
		renderer.EnsureFinished();
	}

	R_TraceResetRegion(true);

	memcpy(&prevFrameStats, &frameStats, sizeof(prevFrameStats));
	memset(&frameStats, 0, sizeof(frameStats));
	if (r_speeds.integer || frameStatsVisible || cls.timedemo) {
		frameStats.start_time = Sys_DoubleTime();
		R_TraceAPI("[timedemo] start-frame");
	}
	frameStats.hotloop = true;
}

void R_PerformanceEndFrame(void)
{
	qbool frameStatsVisible;

	if (!framestats_shown) {
		framestats_shown = Cvar_Find("hud_framestats_show");
	}
	frameStatsVisible = framestats_shown && framestats_shown->integer;
	frameStats.hotloop = false;

	if (r_speeds.integer || frameStatsVisible || cls.timedemo) {
		frameStats.end_time = Sys_DoubleTime();

		if (cls.timedemo && cls.td_starttime) {
			int ms = (int)ceil((frameStats.end_time - frameStats.start_time) * 10000.0);

			R_TraceAPI("[timedemo] frametime: %dms", ms);
			ms = bound(0, ms, sizeof(cls.td_frametime_stats) / sizeof(cls.td_frametime_stats[0]) - 1);

			if (ms > cls.td_frametime_max) {
				cls.td_frametime_max = ms;
				cls.td_frametime_max_frame = cls.framecount - cls.td_startframe - 1;
				R_TraceAPI("[timedemo] worst-frametime-set");
			}

			++cls.td_frametime_stats[ms];
		}

		if (r_speeds.integer) {
			double time = frameStats.end_time - frameStats.start_time;

			Print_flags[Print_current] |= PR_TR_SKIP;
			if (cl.standby || com_serveractive) {
				Com_Printf("%5.2f ms %4i wpoly, %4i epoly, %4i texbinds\n", (time * 1000), frameStats.classic.polycount[polyTypeWorldModel], frameStats.classic.polycount[polyTypeAliasModel], frameStats.texture_binds);
			}
			else {
				Com_Printf("%5.2f ms %4i wpoly\n", (time * 1000), frameStats.classic.polycount[polyTypeWorldModel]);
			}
		}
	}
}




================================================
FILE: src/r_performance.h
================================================

#ifndef EZQUAKE_R_PERFORMANCE_HEADER
#define EZQUAKE_R_PERFORMANCE_HEADER

void R_PerformanceBeginFrame(void);
void R_PerformanceEndFrame(void);

void GLC_TimeRefresh(void);
void GLM_TimeRefresh(void);

#endif // #ifndef EZQUAKE_R_PERFORMANCE_HEADER

================================================
FILE: src/r_program.h
================================================

#ifndef EZQUAKE_R_PROGRAM_HEADER
#define EZQUAKE_R_PROGRAM_HEADER

typedef enum {
	r_program_none,

	r_program_aliasmodel,
	r_program_brushmodel,
	r_program_sprite3d,
	r_program_hud_images,
	r_program_hud_circles,
	r_program_post_process,

	r_program_post_process_glc,
	r_program_sky_glc,
	r_program_turb_glc,
	r_program_caustics_glc,
	r_program_aliasmodel_std_glc,
	r_program_aliasmodel_shell_glc,
	r_program_aliasmodel_shadow_glc,
	r_program_aliasmodel_outline_glc,
	r_program_world_drawflat_glc,
	r_program_world_textured_glc,
	r_program_world_secondpass_glc,
	r_program_sprites_glc,
	r_program_hud_images_glc,

	r_program_lightmap_compute,

	r_program_fx_world_geometry,
	r_program_brushmodel_alphatested,
	r_program_simple,
	r_program_simple3d,

	r_program_count
} r_program_id;

typedef enum {
	r_program_uniform_aliasmodel_drawmode,
	r_program_uniform_brushmodel_outlines,
	r_program_uniform_brushmodel_sampler,
	r_program_uniform_sprite3d_alpha_test,
	r_program_uniform_hud_circle_matrix,
	r_program_uniform_hud_circle_color,
	r_program_uniform_post_process_glc_gamma,
	r_program_uniform_post_process_glc_base,
	r_program_uniform_post_process_glc_overlay,
	r_program_uniform_post_process_glc_v_blend,
	r_program_uniform_post_process_glc_contrast,
	r_program_uniform_post_process_glc_r_inv_width,
	r_program_uniform_post_process_glc_r_inv_height,
	r_program_uniform_sky_glc_cameraPosition,
	r_program_uniform_sky_glc_speedscale,
	r_program_uniform_sky_glc_speedscale2,
	r_program_uniform_sky_glc_skyTex,
	r_program_uniform_sky_glc_skyWind,
	r_program_uniform_sky_glc_skyDomeTex,
	r_program_uniform_sky_glc_skyDomeCloudTex,
	r_program_uniform_turb_glc_texSampler,
	r_program_uniform_turb_glc_time,
	r_program_uniform_caustics_glc_texSampler,
	r_program_uniform_caustics_glc_time,
	r_program_uniform_aliasmodel_std_glc_angleVector,
	r_program_uniform_aliasmodel_std_glc_shadelight,
	r_program_uniform_aliasmodel_std_glc_ambientlight,
	r_program_uniform_aliasmodel_std_glc_texSampler,
	r_program_uniform_aliasmodel_std_glc_fsTextureEnabled,
	r_program_uniform_aliasmodel_std_glc_fsMinLumaMix,
	r_program_uniform_aliasmodel_std_glc_time,
	r_program_uniform_aliasmodel_std_glc_fsCausticEffects,
	r_program_uniform_aliasmodel_std_glc_lerpFraction,
	r_program_uniform_aliasmodel_std_glc_causticsSampler,
	r_program_uniform_aliasmodel_shell_glc_fsBaseColor1,
	r_program_uniform_aliasmodel_shell_glc_fsBaseColor2,
	r_program_uniform_aliasmodel_shell_glc_texSampler,
	r_program_uniform_aliasmodel_shell_glc_lerpFraction,
	r_program_uniform_aliasmodel_shell_glc_scroll,
	r_program_uniform_aliasmodel_shadow_glc_lerpFraction,
	r_program_uniform_aliasmodel_shadow_glc_shadevector,
	r_program_uniform_aliasmodel_shadow_glc_lheight,
	r_program_uniform_world_drawflat_glc_wallcolor,
	r_program_uniform_world_drawflat_glc_floorcolor,
	r_program_uniform_world_drawflat_glc_skycolor,
	r_program_uniform_world_drawflat_glc_watercolor,
	r_program_uniform_world_drawflat_glc_slimecolor,
	r_program_uniform_world_drawflat_glc_lavacolor,
	r_program_uniform_world_drawflat_glc_telecolor,
	r_program_uniform_world_textured_glc_lightmapSampler,
	r_program_uniform_world_textured_glc_texSampler,
	r_program_uniform_world_textured_glc_lumaSampler,
	r_program_uniform_world_textured_glc_causticSampler,
	r_program_uniform_world_textured_glc_detailSampler,
	r_program_uniform_world_textured_glc_time,
	r_program_uniform_world_textured_glc_lumaScale,
	r_program_uniform_world_textured_glc_fbScale,
	r_program_uniform_world_textured_glc_r_floorcolor,
	r_program_uniform_world_textured_glc_r_wallcolor,
	r_program_uniform_sprites_glc_materialSampler,
	r_program_uniform_sprites_glc_alphaThreshold,
	r_program_uniform_hud_images_glc_primarySampler,
	r_program_uniform_hud_images_glc_secondarySampler,
	r_program_uniform_aliasmodel_outline_glc_lerpFraction,
	r_program_uniform_aliasmodel_outline_glc_outlineScale,
	r_program_uniform_brushmodel_alphatested_outlines,
	r_program_uniform_brushmodel_alphatested_sampler,
	r_program_uniform_turb_glc_alpha,
	r_program_uniform_turb_glc_color,
	r_program_uniform_simple_color,
	r_program_uniform_world_textures_glc_texture_multiplier,
	r_program_uniform_simple3d_color,
	r_program_uniform_lighting_firstLightmap,
	r_program_uniform_sky_glc_fog_skyFogMix,
	r_program_uniform_outline_color,
	r_program_uniform_outline_depth_threshold,
	r_program_uniform_outline_normal_threshold,
	r_program_uniform_outline_scale,
	r_program_uniform_aliasmodel_outline_color_model,
	r_program_uniform_aliasmodel_outline_color_team,
	r_program_uniform_aliasmodel_outline_color_enemy,
	r_program_uniform_aliasmodel_outline_use_player_color,
	r_program_uniform_aliasmodel_outline_scale,
	// Sampler uniforms for GL < 4.2 (no layout(binding=N))
	r_program_uniform_brushmodel_detailtex,
	r_program_uniform_brushmodel_causticstex,
	r_program_uniform_brushmodel_skytex,
	r_program_uniform_brushmodel_skydometex,
	r_program_uniform_brushmodel_skydomecloudtex,
	r_program_uniform_brushmodel_lightmaptex,
	r_program_uniform_brushmodel_materialtex,
	r_program_uniform_brushmodel_at_detailtex,
	r_program_uniform_brushmodel_at_causticstex,
	r_program_uniform_brushmodel_at_skytex,
	r_program_uniform_brushmodel_at_skydometex,
	r_program_uniform_brushmodel_at_skydomecloudtex,
	r_program_uniform_brushmodel_at_lightmaptex,
	r_program_uniform_brushmodel_at_materialtex,
	r_program_uniform_aliasmodel_causticstex,
	r_program_uniform_aliasmodel_samplers,
	r_program_uniform_sprites_materialtex,
	r_program_uniform_postprocess_base,
	r_program_uniform_postprocess_overlay,
	r_program_uniform_fxworldgeometry_normaltex,
	r_program_uniform_hudimage_tex,
	r_program_uniform_aliasmodel_instanceOffset,
	r_program_uniform_brushmodel_instanceOffset,
	r_program_uniform_brushmodel_alphatested_instanceOffset,
	r_program_uniform_count
} r_program_uniform_id;

typedef enum {
	r_program_attribute_aliasmodel_std_glc_flags,
	r_program_attribute_aliasmodel_shell_glc_flags,
	r_program_attribute_aliasmodel_shadow_glc_flags,
	r_program_attribute_aliasmodel_outline_glc_flags,
	r_program_attribute_world_drawflat_style,
	r_program_attribute_world_textured_style,
	r_program_attribute_world_textured_detailCoord,

	r_program_attribute_count
} r_program_attribute_id;

typedef enum {
	r_program_memory_barrier_image_access,
	r_program_memory_barrier_texture_access,
	r_program_memory_barrier_count
} r_program_memory_barrier_id;

void R_ProgramInitialiseState(void);
int R_ProgramCustomOptions(r_program_id program_id);
qbool R_ProgramReady(r_program_id program_id);
void R_ProgramUse(r_program_id program_id);
r_program_id R_ProgramInUse(void);
r_program_id R_ProgramForAttribute(r_program_attribute_id attr_id);
int R_ProgramCustomOptions(r_program_id program_id);
void R_ProgramSetCustomOptions(r_program_id program_id, int options);

void R_ProgramComputeDispatch(r_program_id program_id, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z);
void R_ProgramMemoryBarrier(r_program_id program_id);
void R_ProgramComputeSetMemoryBarrierFlag(r_program_id program_id, r_program_memory_barrier_id barrier_id);

void R_ProgramUniform1i(r_program_uniform_id uniform_id, int value);
void R_ProgramUniform1iArrayBase(r_program_uniform_id uniform_id, int count, int base_value);
void R_ProgramUniform1f(r_program_uniform_id uniform_id, float value);
void R_ProgramUniform4fv(r_program_uniform_id uniform_id, const float* values);
void R_ProgramUniform3f(r_program_uniform_id uniform_id, float x, float y, float z);
void R_ProgramUniform3fv(r_program_uniform_id uniform_id, const float* values);
void R_ProgramUniform2fv(r_program_uniform_id uniform_id, const float* values);
void R_ProgramUniform3fNormalize(r_program_uniform_id uniform_id, const byte* values);
void R_ProgramUniformMatrix4fv(r_program_uniform_id uniform_id, const float* values);
int R_ProgramUniformGet1i(r_program_uniform_id uniform_id, int default_value);

int R_ProgramAttributeLocation(r_program_attribute_id attr_id);

// Check if a program needs to be recompiled
qbool R_ProgramRecompileNeeded(r_program_id program_id, unsigned int options);

// Get program handle (GLuint)
unsigned int R_ProgramId(r_program_id program_id);

// Compiles a simple program
qbool R_ProgramCompile(r_program_id program_id);

// Compiles a program with custom includes based on user's config
qbool R_ProgramCompileWithInclude(r_program_id program_id, const char* included_definitions);

// Asks all programs to compile themselves
void R_ProgramCompileAll(void);

// Switches between sub-programs (allows multiple copies of the same program with different flags)
void R_ProgramSetSubProgram(r_program_id program_id, int sub_index);

// Sets uniforms based on program flags (used for fog at the moment)
void R_ProgramSetStandardUniforms(r_program_id program_id);

#endif // EZQUAKE_R_PROGRAM_HEADER


================================================
FILE: src/r_refrag.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// gl_refrag.c

#include "quakedef.h"
#include "gl_model.h"
#include "r_local.h"

mnode_t	*r_pefragtopnode;

//===========================================================================

/*
===============================================================================
					ENTITY FRAGMENT FUNCTIONS
===============================================================================
*/

efrag_t		**lastlink;
vec3_t		r_emins, r_emaxs;
entity_t	*r_addent;

void R_Init_EFrags (void)
{
	cl.free_efrags = (efrag_t *) Hunk_AllocName (sizeof (efrag_t), "efrag");
	memset (cl.free_efrags, 0, sizeof (efrag_t));
}

void R_Next_Free_EFrag (void)
{
	// advance the linked list, growing it as needed
	if (cl.free_efrags->entnext == NULL)
	{
		cl.free_efrags->entnext = (efrag_t *) Hunk_AllocName (sizeof (efrag_t), "efrag");
		memset (cl.free_efrags->entnext, 0, sizeof (efrag_t));
	}
	cl.free_efrags = cl.free_efrags->entnext;
}

void R_SplitEntityOnNode (mnode_t *node) {
	efrag_t *ef;
	mplane_t *splitplane;
	mleaf_t *leaf;
	int sides;
	
	if (node->contents == CONTENTS_SOLID)
		return;

	// add an efrag if the node is a leaf

	if ( node->contents < 0) {
		if (!r_pefragtopnode)
			r_pefragtopnode = node;

		leaf = (mleaf_t *)node;

		R_Next_Free_EFrag ();

		ef = cl.free_efrags;
		ef->entity = r_addent;

		// add the entity link	
		*lastlink = ef;
		lastlink = &ef->entnext;
		ef->entnext = NULL;

		// set the leaf links
		ef->leaf = leaf;
		ef->leafnext = leaf->efrags;
		leaf->efrags = ef;

		return;
	}

	// NODE_MIXED

	splitplane = node->plane;
	sides = BOX_ON_PLANE_SIDE(r_emins, r_emaxs, splitplane);
	
	if (sides == 3) {
		// split on this plane
		// if this is the first splitter of this bmodel, remember it
		if (!r_pefragtopnode)
			r_pefragtopnode = node;
	}

	// recurse down the contacted sides
	if (sides & 1)
		R_SplitEntityOnNode (node->children[0]);

	if (sides & 2)
		R_SplitEntityOnNode (node->children[1]);
}

void R_AddEfrags (entity_t *ent) {
	model_t *entmodel;
	int i;

	if (!ent->model)
		return;

	r_addent = ent;

	lastlink = &ent->efrag;
	r_pefragtopnode = NULL;

	entmodel = ent->model;

	for (i = 0; i < 3; i++) {
		r_emins[i] = ent->origin[i] + entmodel->mins[i];
		r_emaxs[i] = ent->origin[i] + entmodel->maxs[i];
	}

	R_SplitEntityOnNode (cl.worldmodel->nodes);

	ent->topnode = r_pefragtopnode;
}

void R_StoreEfrags(efrag_t **ppefrag)
{
	entity_t *pent;
	model_t *model;
	efrag_t *pefrag;
	extern cvar_t r_drawflame;

	for (pefrag = *ppefrag; pefrag; pefrag = pefrag->leafnext) {
		pent = pefrag->entity;
		model = pent->model;

		if ((model->modhint == MOD_FLAME || model->modhint == MOD_FLAME2) && !r_drawflame.integer) {
			continue;
		}

		switch (model->type) {
			case mod_alias:
			case mod_alias3:
			case mod_brush:
			case mod_sprite:
				if (pent->visframe != r_framecount) {
					CL_AddEntity(pent);
					pent->visframe = r_framecount;	// mark that we've recorded this entity for this frame
					pent->oldframe = pent->frame;
				}
				break;

			default:
				Sys_Error("R_StoreEfrags: Bad entity type %d", model->type);
		}
	}
}


================================================
FILE: src/r_renderer.h
================================================

#ifndef EZQUAKE_R_RENDERER_HEADER
#define EZQUAKE_R_RENDERER_HEADER

#include "gl_model.h"
#include "r_state.h"
#include "r_vao.h"
#include "gl_framebuffer.h"

typedef enum {
	r_cubemap_right,
	r_cubemap_back,
	r_cubemap_left,
	r_cubemap_front,
	r_cubemap_up,
	r_cubemap_down,

	r_cubemap_direction_count
} r_cubemap_direction_id;

#ifdef RENDERER_METHOD
#undef RENDERER_METHOD
#endif

#define RENDERER_METHOD(returntype, name, ...) returntype (*name)(__VA_ARGS__);

typedef struct renderer_api_s {
#include "r_renderer_structure.h"

	qbool vaos_supported;
} renderer_api_t;

extern renderer_api_t renderer;

#undef RENDERER_METHOD

#endif // EZQUAKE_R_RENDERER_HEADER


================================================
FILE: src/r_renderer_structure.h
================================================

// Meta
RENDERER_METHOD(void, Shutdown, r_shutdown_mode_t mode)
RENDERER_METHOD(void, CvarForceRecompile, cvar_t* cvar)
RENDERER_METHOD(void, PrintGfxInfo, void)
RENDERER_METHOD(const char*, DescriptiveString, void)

// Config/State
RENDERER_METHOD(void, Viewport, int x, int y, int width, int height)
RENDERER_METHOD(void, InvalidateViewport, void)
RENDERER_METHOD(void, ApplyRenderingState, r_state_id state)

// Called after map has been loaded
RENDERER_METHOD(void, PrepareModelRendering, qbool vid_restart)
RENDERER_METHOD(void, PrepareAliasModel, model_t* model, aliashdr_t* hdr)

// Sky surfaces
RENDERER_METHOD(void, DrawSky, void)
RENDERER_METHOD(void, DrawWorld, void)

// Entities
RENDERER_METHOD(void, DrawAliasFrame, entity_t* ent, model_t* model, int pose1, int pose2, texture_ref texture, texture_ref fb_texture, qbool outline, int effects, int render_effects, float lerpfrac)
RENDERER_METHOD(void, DrawAlias3Model, entity_t *ent, qbool outline, qbool additive_pass)
RENDERER_METHOD(void, DrawAliasModelShadow, entity_t* ent)
RENDERER_METHOD(void, DrawAliasModelPowerupShell, entity_t *ent)
RENDERER_METHOD(void, DrawAlias3ModelPowerupShell, entity_t *ent)
RENDERER_METHOD(void, DrawSpriteModel, entity_t *ent)
RENDERER_METHOD(void, DrawSimpleItem, model_t* model, int skin, vec3_t origin, float scale, vec3_t up, vec3_t right)

// Particles
RENDERER_METHOD(void, DrawClassicParticles, int)

// HUD
RENDERER_METHOD(void, DrawImage, float x, float y, float width, float height, float tex_s, float tex_t, float tex_width, float tex_height, byte* color, int flags)
RENDERER_METHOD(void, DrawRectangle, float x, float y, float width, float height, byte* color)
RENDERER_METHOD(void, AdjustImages, int first, int last, float x_offset)
RENDERER_METHOD(void, DrawDisc, void)

// Lightmaps
RENDERER_METHOD(void, UploadLightmap, int textureUnit, int lightmapnum)
RENDERER_METHOD(void, LightmapFrameInit, void)
RENDERER_METHOD(void, RenderDynamicLightmaps, msurface_t* surf, qbool world)
RENDERER_METHOD(void, CreateLightmapTextures, void)
RENDERER_METHOD(void, BuildLightmap, int lightmapnum)
RENDERER_METHOD(void, InvalidateLightmapTextures, void)
RENDERER_METHOD(void, LightmapShutdown, void)

// Rendering loop
RENDERER_METHOD(void, SetupGL, void)
RENDERER_METHOD(void, ChainBrushModelSurfaces, model_t* model, entity_t* ent)
RENDERER_METHOD(void, DrawBrushModel, entity_t* ent, qbool polygonOffset, qbool caustics)
RENDERER_METHOD(int, BrushModelCopyVertToBuffer, model_t* mod, void* vbo_buffer_, int position, float* source, int lightmap, int material, float scaleS, float scaleT, msurface_t* surf, qbool has_fb_texture, qbool has_luma_texture)
RENDERER_METHOD(void, ClearRenderingSurface, qbool clear_color)
RENDERER_METHOD(void, DrawWaterSurfaces, void)
RENDERER_METHOD(void, ScreenDrawStart, void)
RENDERER_METHOD(void, EnsureFinished, void)
RENDERER_METHOD(void, Begin2DRendering, void)
RENDERER_METHOD(qbool, IsFramebufferEnabled3D, void)

// Post-processing (scene)
RENDERER_METHOD(void, RenderView, void)
RENDERER_METHOD(void, PreRenderView, void)

// Post-processing (screen)
RENDERER_METHOD(void, PostProcessScreen, void)
RENDERER_METHOD(void, BrightenScreen, void)
RENDERER_METHOD(void, PolyBlend, float v_blend[4])

// Performance
RENDERER_METHOD(void, TimeRefresh, void)

// Misc
RENDERER_METHOD(void, Screenshot, byte* buffer, size_t size)
RENDERER_METHOD(size_t, ScreenshotWidth, void)
RENDERER_METHOD(size_t, ScreenshotHeight, void)

// Textures
RENDERER_METHOD(void, TextureInitialiseState, void)
RENDERER_METHOD(void, TextureDelete, texture_ref texture)
RENDERER_METHOD(void, TextureMipmapGenerate, texture_ref texture)
RENDERER_METHOD(void, TextureWrapModeClamp, texture_ref tex)
RENDERER_METHOD(void, TextureLabelSet, texture_ref texnum, const char* identifier)
RENDERER_METHOD(qbool, TextureUnitBind, int unit, texture_ref texture)
RENDERER_METHOD(qbool, TextureIsUnitBound, int unit, texture_ref texture)
RENDERER_METHOD(void, TextureUnitMultiBind, int first_unit, int num_textures, texture_ref* textures)
RENDERER_METHOD(void, TextureGet, texture_ref tex, int buffer_size, byte* buffer, int bpp)
RENDERER_METHOD(void, TextureCompressionSet, qbool enabled)
RENDERER_METHOD(void, TextureCreate2D, texture_ref* reference, int width, int height, const char* name, qbool is_lightmap)
RENDERER_METHOD(void, TexturesCreate, r_texture_type_id type, int count, texture_ref* texture)
RENDERER_METHOD(void, TextureReplaceSubImageRGBA, texture_ref ref, int offsetx, int offsety, int width, int height, byte* buffer)
RENDERER_METHOD(void, TextureSetFiltering, texture_ref texture, texture_minification_id minification_filter, texture_magnification_id magnification_filter)
RENDERER_METHOD(void, TextureSetAnisotropy, texture_ref texture, int anisotropy)
RENDERER_METHOD(void, TextureLoadCubemapFace, texture_ref cubemap, r_cubemap_direction_id direction, const byte* data, int width, int height)

// VAOs
RENDERER_METHOD(void, DeleteVAOs, void)
RENDERER_METHOD(void, GenVertexArray, r_vao_id vao, const char* name)
RENDERER_METHOD(void, BindVertexArray, r_vao_id vao)
RENDERER_METHOD(void, BindVertexArrayElementBuffer, r_vao_id vao, r_buffer_id ref)
RENDERER_METHOD(qbool, VertexArrayCreated, r_vao_id vao)

// Sprites
RENDERER_METHOD(void, Prepare3DSprites, void)
RENDERER_METHOD(void, Draw3DSprites, void)
RENDERER_METHOD(void, Draw3DSpritesInline, void)   // FIXME get rid of this and all other inline rendering

// Framebuffers
RENDERER_METHOD(void, RenderFramebuffers, void)
RENDERER_METHOD(qbool, FramebufferCreate, framebuffer_id id, int width, int height)

// Programs
RENDERER_METHOD(void, ProgramsInitialise, void)
RENDERER_METHOD(void, ProgramsShutdown, qbool restarting)


================================================
FILE: src/r_rlight.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "gl_model.h"
#include "r_sprite3d.h"
#include "r_lightmaps.h"
#include "r_state.h"
#include "r_lighting.h"

int	r_dlightframecount;

void R_AnimateLight(void)
{
	int i, j, l1, l2;
	float lerpfrac;

	// light animations : 'm' is normal light, 'a' is no light, 'z' is double bright
	i = (int) (r_refdef2.time * 10);
	lerpfrac = r_refdef2.time * 10 - i;
	for (j = 0; j < MAX_LIGHTSTYLES; j++) {
		if (!cl_lightstyle[j].length) {
			d_lightstylevalue[j] = 256;
			continue;
		}

		l1 = i % cl_lightstyle[j].length;
		l1 = (cl_lightstyle[j].map[l1] - 'a') * 22;
		l2 = (i + 1) % cl_lightstyle[j].length;
		l2 = (cl_lightstyle[j].map[l2] - 'a') * 22;

		if (l1 - l2 > 220 || l2 - l1 > 220) {
			d_lightstylevalue[j] = l2;
		}
		else {
			d_lightstylevalue[j] = l1 + (l2 - l1) * lerpfrac;
		}
	}
}


float bubble_sintable[17], bubble_costable[17];

void R_InitBubble(void)
{
	float a, *bub_sin, *bub_cos;
	int i;

	bub_sin = bubble_sintable;
	bub_cos = bubble_costable;

	for (i = 16; i >= 0; i--) {
		a = i/16.0 * M_PI*2;
		*bub_sin++ = sin(a);
		*bub_cos++ = cos(a);
	}
}

//VULT LIGHTS
/*float bubblecolor[NUM_DLIGHTTYPES][4] = {
	{ 0.2, 0.1, 0.05 },		// dimlight or brightlight (lt_default)
	{ 0.2, 0.1, 0.05 },		// muzzleflash
	{ 0.2, 0.1, 0.05 },		// explosion
	{ 0.2, 0.1, 0.05 },		// rocket
	{ 0.5, 0.05, 0.05 },	// red
	{ 0.05, 0.05, 0.3 },	// blue
	{ 0.5, 0.05, 0.4 },		// red + blue
	{ 0.05, 0.45, 0.05 },	// green
	{ 0.5, 0.5, 0.5},		// white
	{ 0.5, 0.5, 0.5},		// custom
};*/
//VULT LIGHTS - My lighting colours are different, I don't know why, but they've been this way since 0.31 or so
float bubblecolor[NUM_DLIGHTTYPES][4] = {
	{ 0.4,  0.2,  0.1  },	// dimlight or brightlight (lt_default)
	{   1,  0.4,  0.2  },	// muzzleflash
	{ 0.8,  0.4,  0.2  },	// explosion
	{ 0.2,  0.1,  0.05 },	// rocket  fuh : lightbubble
	{ 0.5,  0.05, 0.05 },	// red
	{ 0.05, 0.05, 0.3  },	// blue
	{ 0.5,  0.05, 0.4  },	// red + blue
	{ 0.05, 0.45, 0.05 },	// green
	{ 0.5,  0.45, 0.05 },	// red + green
	{ 0.05, 0.45, 0.4  },	// blue + green
	{ 0.5,  0.5,  0.5  },	// white
	{ 0.5,  0.5,  0.5  },	// custom
};

static qbool first_dlight;

void R_RenderDlight(dlight_t *light)
{
	// muzzleflash keys are negative
	int abs_key = abs(light->key);
	qbool suppress_polyblend = light->bubble != 0 || (abs_key >= 0 && abs_key <= MAX_CLIENTS);

	// don't draw our own powerup glow and muzzleflashes
	if (abs_key == (cl.viewplayernum + 1)) {
		return;
	}

	{
		int i, j;
		vec3_t v, v_right, v_up;
		float length;
		float rad = light->radius * 0.35;
		float *bub_sin, *bub_cos;
		byte center_color[4] = { 255, 255, 255, 0 };
		byte outer_color[4] = { 0, 0, 0, 0 };
		r_sprite3d_vert_t* vert;

		VectorSubtract(light->origin, r_origin, v);
		length = VectorNormalize(v);

		if (light->type == lt_custom) {
			memcpy(center_color, light->color, 3);
		}
		else {
			// FIXME: bubblecolor has 4 elements, but inline spec is only 3... ?
			center_color[0] = bubblecolor[light->type][0] * 255;
			center_color[1] = bubblecolor[light->type][1] * 255;
			center_color[2] = bubblecolor[light->type][2] * 255;
		}

		if (length < rad) {
			// view is inside the dlight
			V_AddLightBlend(center_color[0] / 255.0f, center_color[1] / 255.0f, center_color[2] / 255.0f, light->radius * 0.0015, suppress_polyblend);
			return;
		}

		if (first_dlight) {
			R_Sprite3DInitialiseBatch(SPRITE3D_FLASHBLEND_LIGHTS, r_state_light_bubble, null_texture_reference, 0, r_primitive_triangle_fan);

			first_dlight = false;
		}

		vert = R_Sprite3DAddEntry(SPRITE3D_FLASHBLEND_LIGHTS, 18);
		if (!vert) {
			return;
		}

		VectorVectors(v, v_right, v_up);

		if (length - rad > 8) {
			VectorScale(v, rad, v);
		}
		else {
			// make sure the light bubble will not be clipped by near z clip plane
			VectorScale(v, length - 8, v);
		}

		VectorSubtract(light->origin, v, v);

		if (light->type == lt_custom) {
			memcpy(center_color, light->color, 3);
		}
		else {
			// FIXME: bubblecolor has 4 elements, but inline spec is only 3... ?
			center_color[0] = bubblecolor[light->type][0] * 255;
			center_color[1] = bubblecolor[light->type][1] * 255;
			center_color[2] = bubblecolor[light->type][2] * 255;
		}

		R_Sprite3DSetVert(vert++, v[0], v[1], v[2], 1, 1, center_color, -1);

		bub_sin = bubble_sintable;
		bub_cos = bubble_costable;

		for (i = 16; i >= 0; i--) {
			for (j = 0; j < 3; j++) {
				v[j] = light->origin[j] + (v_right[j] * (*bub_cos) + +v_up[j] * (*bub_sin)) * rad;
			}
			bub_sin++;
			bub_cos++;

			R_Sprite3DSetVert(vert++, v[0], v[1], v[2], 1, 1, outer_color, -1);
		}
	}
}

void R_RenderDlights(void)
{
	unsigned int i;
	unsigned int j;
	dlight_t *l;

	r_dlightframecount = r_framecount;
	first_dlight = true;

	for (i = 0; i < MAX_DLIGHTS / 32; i++) {
		if (cl_dlight_active[i]) {
			for (j = 0; j < 32; j++) {
				if ((cl_dlight_active[i] & (1 << j)) && i * 32 + j < MAX_DLIGHTS) {
					l = cl_dlights + i * 32 + j;

					if (l->bubble == 2) { // light from rl
						if (gl_rl_globe.integer & 1) {
							R_RenderDlight(l);
						}
						if (gl_rl_globe.integer & 2) {
							R_MarkLights(l, 1 << (i * 32 + j), cl.worldmodel->nodes);
						}
						continue;
					}

					R_MarkLights(l, 1 << (i * 32 + j), cl.worldmodel->nodes);

					if (gl_flashblend.integer && !(l->bubble && gl_flashblend.integer != 2)) {
						R_RenderDlight(l);
					}
				}
			}
		}
	}
}

/*
=============================================================================

DYNAMIC LIGHTS

=============================================================================
*/

/*
=============
R_MarkLights
=============
*/
//VULT: Lord Havoc light stuff
void R_MarkLights(dlight_t *light, int bit, mnode_t *node)
{
	float		dist;
	msurface_t	*surf;
	int			i;

	if (!R_SoftwareLighting()) {
		return;
	}

loc0:
	if (node->contents < 0) {
		return;
	}

	dist = PlaneDiff(light->origin, node->plane);
	if (dist > light->radius) {
		// LordHavoc: .lit support begin (actually this is just a major lighting speedup, no relation to color :)
		node = node->children[0];
		goto loc0;
		// LordHavoc: .lit support end
	}
	if (dist < -light->radius) {
		// LordHavoc: .lit support begin (actually this is just a major lighting speedup, no relation to color :)
		node = node->children[1];
		goto loc0;
		// LordHavoc: .lit support end
	}

	// mark the polygons
	surf = cl.worldmodel->surfaces + node->firstsurface;
	for (i = 0; i < node->numsurfaces; i++, surf++) {
		// LordHavoc: .lit support begin (actually this is just a major lighting speedup, no relation to color :)
		if (surf->dlightframe != r_dlightframecount) {
			// not dynamic until now
			surf->dlightbits = bit;
			surf->dlightframe = r_dlightframecount;
		}
		else {
			// already dynamic
			surf->dlightbits |= bit;
		}
	}
	// LordHavoc: .lit support begin (actually this is just a major lighting speedup, no relation to color :)
	if (node->children[0]->contents >= 0) {
		R_MarkLights(light, bit, node->children[0]); // LordHavoc: original code
	}
	if (node->children[1]->contents >= 0) {
		R_MarkLights(light, bit, node->children[1]); // LordHavoc: original code
	}
	// LordHavoc: .lit support end
}

/*
=============
R_PushDlights
=============
*/
void R_PushDlights (void)
{
}


/*
=============================================================================

LIGHT SAMPLING

=============================================================================
*/

mplane_t		*lightplane;

static void R_LightFromSurface(msurface_t* surf, int ds, int dt, vec3_t color)
{
	if (surf->samples) {
		// LordHavoc: enhanced to interpolate lighting
		int maps, line3, dsfrac = ds & 15, dtfrac = dt & 15, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
		float scale;
		line3 = ((surf->extents[0] >> 4) + 1) * 3;

		if (cl.worldmodel->flags & MOD_HDRLIGHTING) {
			uint32_t *lightmap = (uint32_t*)surf->samples + (dt * (surf->extents[0]+1) + ds);
			line3 = (surf->extents[0]+1);
			for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++) {
				float e;
				scale = (1<<7) * (float) d_lightstylevalue[surf->styles[maps]] * 1.0f / 256.0f;
				e = rgb9e5tab[lightmap[      0]>>27] * scale;r00 += ((lightmap[      0]>> 0)&0x1ff) * e;g00 += ((lightmap[      0]>> 9)&0x1ff) * e;b00 += ((lightmap[      0]>> 9)&0x1ff) * e;
				e = rgb9e5tab[lightmap[      1]>>27] * scale;r01 += ((lightmap[      1]>> 0)&0x1ff) * e;g01 += ((lightmap[      1]>> 9)&0x1ff) * e;b01 += ((lightmap[      1]>> 9)&0x1ff) * e;
				e = rgb9e5tab[lightmap[line3+0]>>27] * scale;r10 += ((lightmap[line3+0]>> 0)&0x1ff) * e;g10 += ((lightmap[line3+0]>> 9)&0x1ff) * e;b10 += ((lightmap[line3+0]>> 9)&0x1ff) * e;
				e = rgb9e5tab[lightmap[line3+1]>>27] * scale;r11 += ((lightmap[line3+1]>> 0)&0x1ff) * e;g11 += ((lightmap[line3+1]>> 9)&0x1ff) * e;b11 += ((lightmap[line3+1]>> 9)&0x1ff) * e;
				lightmap += (surf->extents[0]+1) * (surf->extents[1]+1);
			}
		} else {
			byte *lightmap = surf->samples + ((dt >> 4) * ((surf->extents[0] >> 4) + 1) + (ds >> 4)) * 3; // LordHavoc: *3 for color
			for (maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++) {
				scale = (float)d_lightstylevalue[surf->styles[maps]] * 1.0 / 256.0;
				r00 += (float)lightmap[0] * scale; g00 += (float)lightmap[1] * scale; b00 += (float)lightmap[2] * scale;
				r01 += (float)lightmap[3] * scale; g01 += (float)lightmap[4] * scale; b01 += (float)lightmap[5] * scale;
				r10 += (float)lightmap[line3 + 0] * scale; g10 += (float)lightmap[line3 + 1] * scale; b10 += (float)lightmap[line3 + 2] * scale;
				r11 += (float)lightmap[line3 + 3] * scale; g11 += (float)lightmap[line3 + 4] * scale; b11 += (float)lightmap[line3 + 5] * scale;
				lightmap += ((surf->extents[0] >> 4) + 1) * ((surf->extents[1] >> 4) + 1) * 3; // LordHavoc: *3 for colored lighting
			}
		}

		color[0] += (float)((int)((((((((r11 - r10) * dsfrac) >> 4) + r10) - ((((r01 - r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01 - r00) * dsfrac) >> 4) + r00)));
		color[1] += (float)((int)((((((((g11 - g10) * dsfrac) >> 4) + g10) - ((((g01 - g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01 - g00) * dsfrac) >> 4) + g00)));
		color[2] += (float)((int)((((((((b11 - b10) * dsfrac) >> 4) + b10) - ((((b01 - b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01 - b00) * dsfrac) >> 4) + b00)));
	}
}

// LordHavoc: .lit support begin
// LordHavoc: original code replaced entirely
static int RecursiveLightPoint(vec3_t color, mnode_t *node, const vec3_t start, const vec3_t end, vec3_t lightspot)
{
	float		front, back, frac;
	vec3_t		mid;

loc0:
	if (node->contents < 0) {
		// didn't hit anything
		return false;
	}

	// calculate mid point
	front = PlaneDiff(start, node->plane);
	back = PlaneDiff(end, node->plane);

	// LordHavoc: optimized recursion
	if ((back < 0) == (front < 0)) {
		node = node->children[front < 0];
		goto loc0;
	}

	frac = front / (front - back);
	mid[0] = start[0] + (end[0] - start[0])*frac;
	mid[1] = start[1] + (end[1] - start[1])*frac;
	mid[2] = start[2] + (end[2] - start[2])*frac;

	// go down front side
	if (RecursiveLightPoint(color, node->children[front < 0], start, mid, lightspot)) {
		return true;	// hit something
	}
	else {
		int i, ds, dt;
		msurface_t *surf;

		// check for impact on this node
		VectorCopy(mid, lightspot);
		lightplane = node->plane;

		surf = cl.worldmodel->surfaces + node->firstsurface;
		for (i = 0; i < node->numsurfaces; i++, surf++) {
			if (surf->flags & SURF_DRAWTILED) {
				continue;	// no lightmaps
			}

			ds = (int)((float)DotProduct(mid, surf->lmvecs[0]) + surf->lmvecs[0][3]);
			dt = (int)((float)DotProduct(mid, surf->lmvecs[1]) + surf->lmvecs[1][3]);
			if (ds < surf->texturemins[0] || dt < surf->texturemins[1]) {
				continue;
			}

			ds -= surf->texturemins[0];
			dt -= surf->texturemins[1];

			if (ds > surf->extents[0] || dt > surf->extents[1]) {
				continue;
			}

			R_LightFromSurface(surf, ds, dt, color);
			return true; // success
		}

		// go down back side
		return RecursiveLightPoint(color, node->children[front >= 0], mid, end, lightspot);
	}
}

void R_LightEntity(entity_t* ent)
{
	extern cvar_t r_shadows;
	vec3_t		end;
	qbool		full_light = (R_FullBrightAllowed() || !cl.worldmodel->lightdata);

	if (full_light && !r_shadows.integer) {
		VectorSet(ent->lightcolor, 255, 255, 255);
		VectorCopy(ent->origin, ent->lightspot);
		ent->ambientlight = ent->shadelight = 255;
		return;
	}

	end[0] = ent->origin[0];
	end[1] = ent->origin[1];
	end[2] = ent->origin[2] - 2048;

	VectorClear(ent->lightcolor);
	RecursiveLightPoint(ent->lightcolor, cl.worldmodel->nodes, ent->origin, end, ent->lightspot);
	if (full_light) {
		VectorSet(ent->lightcolor, 255, 255, 255);
		ent->ambientlight = ent->shadelight = 255;
		return;
	}

	ent->ambientlight = ent->shadelight = ((ent->lightcolor[0] + ent->lightcolor[1] + ent->lightcolor[2]) / 3.0f);
}
// LordHavoc: .lit support end


================================================
FILE: src/r_rmain.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "vx_stuff.h"
#include "vx_vertexlights.h"
#include "utils.h"
#include "qsound.h"
#include "hud.h"
#include "hud_common.h"
#include "rulesets.h"
#include "teamplay.h"
#include "r_sprite3d.h"
#include "r_performance.h"
#include "r_chaticons.h"
#include "r_matrix.h"
#include "r_local.h"
#include "r_state.h"
#include "r_brushmodel_sky.h"
#include "r_brushmodel.h"
#include "r_lighting.h"
#include "r_buffers.h"
#include "r_draw.h"
#include "r_aliasmodel.h"
#include "r_lightmaps.h"
#include "r_trace.h"
#include "r_renderer.h"

#define R_FogAvailable() (!COM_CheckParm(cmdline_param_client_nomultitexturing))

void GLM_ScreenDrawStart(void);

// Move to API
void GLM_SetupGL(void);
void GLC_SetupGL(void);
void GLM_PreRenderView(void);
void GLC_PreRenderView(void);
void GLM_DrawSpriteModel(entity_t *e);
void GLC_DrawSpriteModel(entity_t *e);
void GLM_PolyBlend(float v_blend[4]);
void GLC_PolyBlend(float v_blend[4]);
void GLM_InitialiseAliasModelBatches(void);

void R_TimeRefresh_f(void);
static void R_DrawEntities(void);
void R_InitOtherTextures(void);
void R_DrawViewModel(void);

void OnChange_gl_clearColor(cvar_t *v, char *s, qbool *cancel);
void SCR_OnChangeMVHudPos(cvar_t *var, char *newval, qbool *cancel);
void OnChange_r_drawflat(cvar_t *v, char *skyname, qbool *cancel);
void OnChange_r_skyname(cvar_t *v, char *s, qbool *cancel);
void R_MarkLeaves(void);
void R_InitBubble(void);
void R_InitAliasModelCvars(void);
void R_CreateWorldTextureChains(void);
static void R_SetupGL(void);

void GLM_RenderView(void);

void SCR_SetupDamageIndicators(void);

extern msurface_t *alphachain;

texture_t *r_notexture_mip = NULL;
refdef2_t r_refdef2;                          // screen size info
refdef_t  r_refdef;                           // screen size info
entity_t  r_worldentity;
mplane_t  frustum[4];
mleaf_t   *r_viewleaf;
mleaf_t   *r_oldviewleaf;
mleaf_t   *r_viewleaf2;                       // for watervis hack
mleaf_t   *r_oldviewleaf2;                    // for watervis hack
vec3_t    vup, vpn, vright;                   // view origin
vec3_t    vup_noroll, vright_noroll;          // view directions, with roll=0
vec3_t    r_origin; // view origin
float     clearColor[3] = {0, 0, 0};
int       r_visframecount;                    // bumped when going to a new PVS
int       r_framecount;                       // used for dlight push checking
int       lightmode = 2;
unsigned int d_lightstylevalue[256];             // 8.8 fraction of base light value
texture_ref underwatertexture, detailtexture, solidwhite_texture, solidblack_texture, transparent_texture;

void OnSquareParticleChange(cvar_t *var, char *value, qbool *cancel)
{
	Cvar_SetIgnoreCallback(var, value);

	Classic_InitParticles();
}

static void OnDynamicLightingChange(cvar_t* var, char* value, qbool* cancel)
{
	if (R_UseImmediateOpenGL() && atoi(value) > 1) {
		Con_Printf("Hardware lighting not supported when not using GLSL\n");
		*cancel = true;
		return;
	}
}

static void OnRemoveCollinearVerticesChanged(cvar_t* var, char* value, qbool* cancel)
{
#if defined(__APPLE__) && defined(__aarch64__)
	// At least arm64 based MacBook laptops are known to require this workaround.
	Cvar_SetIgnoreCallback(var, "1");
	*cancel = true;
#endif
}

cvar_t cl_multiview                        = {"cl_multiview", "0" };
cvar_t cl_mvdisplayhud                     = {"cl_mvdisplayhud", "1"};
cvar_t cl_mvhudvertical                    = {"cl_mvhudvertical", "0"};
cvar_t cl_mvhudflip                        = {"cl_mvhudflip", "0"};
cvar_t cl_mvhudpos                         = {"cl_mvhudpos", "bottom center"};
cvar_t cl_mvinset                          = {"cl_mvinset", "0"};
cvar_t cl_mvinsetcrosshair                 = {"cl_mvinsetcrosshair", "1"};
cvar_t cl_mvinsethud                       = {"cl_mvinsethud", "1"};
cvar_t cl_mvinset_offset_x                 = {"cl_mvinset_offset_x", "0"};
cvar_t cl_mvinset_offset_y                 = {"cl_mvinset_offset_y", "0"};
cvar_t cl_mvinset_size_x                   = {"cl_mvinset_size_x", "0.333"};
cvar_t cl_mvinset_size_y                   = {"cl_mvinset_size_y", "0.333"};
cvar_t cl_mvinset_top                      = {"cl_mvinset_top", "1"};
cvar_t cl_mvinset_right                    = {"cl_mvinset_right", "1"};

cvar_t r_drawentities                      = {"r_drawentities", "1"};
cvar_t r_drawworld                         = {"r_drawworld", "1"};
cvar_t r_lerpframes                        = {"r_lerpframes", "1"};
cvar_t r_drawflame                         = {"r_drawflame", "1"};
cvar_t r_drawdisc                          = {"r_drawdisc", "1"};
cvar_t r_speeds                            = {"r_speeds", "0"};
cvar_t r_fullbright                        = {"r_fullbright", "0"};
cvar_t r_shadows                           = {"r_shadows", "0"};
cvar_t r_wateralpha                        = {"gl_turbalpha", "1"};
#if defined(EZ_MULTIPLE_RENDERERS) || defined(RENDERER_OPTION_MODERN_OPENGL)
cvar_t r_dynamic                           = {"r_dynamic", "2", 0, OnDynamicLightingChange };
#else
cvar_t r_dynamic                           = {"r_dynamic", "1", 0, OnDynamicLightingChange };
#endif
cvar_t r_novis                             = {"r_novis", "0"};
cvar_t r_netgraph                          = {"r_netgraph", "0"};
cvar_t r_netstats                          = {"r_netstats", "0"};
cvar_t r_fastsky                           = {"r_fastsky", "0"};
cvar_t r_fastturb                          = {"r_fastturb", "0"};
cvar_t r_skycolor                          = {"r_skycolor", "40 80 150", CVAR_COLOR};
cvar_t r_telecolor                         = {"r_telecolor", "255 60 60", CVAR_COLOR};
cvar_t r_lavacolor                         = {"r_lavacolor", "80 0 0", CVAR_COLOR};
cvar_t r_slimecolor                        = {"r_slimecolor", "10 60 10", CVAR_COLOR};
cvar_t r_watercolor                        = {"r_watercolor", "10 50 80", CVAR_COLOR};
cvar_t r_drawflat                          = {"r_drawflat", "0", 0, OnChange_r_drawflat};
cvar_t r_drawflat_mode                     = {"r_drawflat_mode", "0", 0, OnChange_r_drawflat};
cvar_t r_wallcolor                         = {"r_wallcolor", "255 255 255", CVAR_COLOR, OnChange_r_drawflat};
cvar_t r_floorcolor                        = {"r_floorcolor", "50 100 150", CVAR_COLOR, OnChange_r_drawflat};
cvar_t gl_textureless                      = {"gl_textureless", "0", 0, OnChange_r_drawflat}; //Qrack
cvar_t r_farclip                           = {"r_farclip", "8192", CVAR_RULESET_MAX | CVAR_RULESET_MIN, NULL, 8192.0f, R_MAXIMUM_FARCLIP, R_MINIMUM_FARCLIP }; // previous default was 4096. 8192 helps some TF players in big maps
cvar_t r_skyname                           = {"r_skyname", "", 0, OnChange_r_skyname};
cvar_t r_skywind                           = {"r_skywind", "1"};
cvar_t gl_detail                           = {"gl_detail","0"};
cvar_t gl_brush_polygonoffset              = {"gl_brush_polygonoffset", "2.0"}; // This is the one to adjust if you notice flicker on lift @ e1m1 for instance, for z-fighting
cvar_t gl_brush_polygonoffset_factor       = {"gl_brush_polygonoffset_factor", "0.05"};
cvar_t gl_caustics                         = {"gl_caustics", "0"}; // 1
cvar_t gl_lumatextures                     = {"gl_lumatextures", "1"};
cvar_t gl_subdivide_size                   = {"gl_subdivide_size", "64"};
cvar_t gl_clear                            = {"gl_clear", "0"};
cvar_t gl_clearColor                       = {"gl_clearColor", "0 0 0", CVAR_COLOR, OnChange_gl_clearColor};
cvar_t gl_polyblend                        = {"gl_polyblend", "1"}; // 0
cvar_t gl_flashblend                       = {"gl_flashblend", "0"};
cvar_t gl_rl_globe                         = {"gl_rl_globe", "0"};
cvar_t gl_playermip                        = {"gl_playermip", "0"};
cvar_t gl_nocolors                         = {"gl_nocolors", "0"};
cvar_t gl_finish                           = {"gl_finish", "0"};
cvar_t gl_fb_bmodels                       = {"gl_fb_bmodels", "1"};
cvar_t gl_fb_models                        = {"gl_fb_models", "1"};
cvar_t gl_lightmode                        = {"gl_lightmode", "1"};
cvar_t gl_loadlitfiles                     = {"gl_loadlitfiles", "1"};
cvar_t gl_oldlitscaling                    = {"gl_oldlitscaling", "0"};
cvar_t gl_colorlights                      = {"gl_colorlights", "1"};
cvar_t gl_squareparticles                  = {"gl_squareparticles", "0", 0, OnSquareParticleChange};
cvar_t gl_part_explosions                  = {"gl_part_explosions", "0"}; // 1
cvar_t gl_part_bloodtrails                 = {"gl_part_bloodtrails", "1"}; // 1 was the default behaviour before this became a cvar
cvar_t gl_part_trails                      = {"gl_part_trails", "0"}; // 1
cvar_t gl_part_tracer1_color               = {"gl_part_tracer1_color", "0 124 0", CVAR_COLOR};
cvar_t gl_part_tracer2_color               = {"gl_part_tracer2_color", "255 77 0", CVAR_COLOR};
cvar_t gl_part_tracer1_size                = {"gl_part_tracer1_size", "3.75", CVAR_RULESET_MAX | CVAR_RULESET_MIN, NULL, 3.75f, 10.f, 0.f};
cvar_t gl_part_tracer1_time                = {"gl_part_tracer1_time", "0.5", CVAR_RULESET_MAX | CVAR_RULESET_MIN, NULL, 0.5f, 3.f, 0.f};
cvar_t gl_part_tracer2_size                = {"gl_part_tracer2_size", "3.75", CVAR_RULESET_MAX | CVAR_RULESET_MIN, NULL, 3.75f, 10.f, 0.f};
cvar_t gl_part_tracer2_time                = {"gl_part_tracer2_time", "0.5", CVAR_RULESET_MAX | CVAR_RULESET_MIN, NULL, 0.5f, 3.f, 0.f};
cvar_t gl_part_spikes                      = {"gl_part_spikes", "0"}; // 1
cvar_t gl_part_gunshots                    = {"gl_part_gunshots", "0"}; // 1
cvar_t gl_part_blood                       = {"gl_part_blood", "0"}; // 1
cvar_t gl_part_telesplash                  = {"gl_part_telesplash", "0"}; // 1
cvar_t gl_part_blobs                       = {"gl_part_blobs", "0"}; // 1
cvar_t gl_part_lavasplash                  = {"gl_part_lavasplash", "0"}; // 1
cvar_t gl_part_inferno                     = {"gl_part_inferno", "0"}; // 1
cvar_t gl_part_bubble                      = {"gl_part_bubble", "1"}; // would prefer 0 but default was 1
cvar_t gl_part_detpackexplosion_fire_color = {"gl_part_detpackexplosion_fire_color", "", CVAR_COLOR};
cvar_t gl_part_detpackexplosion_ray_color  = {"gl_part_detpackexplosion_ray_color", "", CVAR_COLOR};
cvar_t gl_powerupshells                    = {"gl_powerupshells", "1"};

// 0: off, 1: on, 2: in water only
cvar_t r_fx_fog                            = {"r_fx_fog", "0"};
// 0: off, 1: dm & single-player, 2: single-player only
cvar_t r_fx_fog_usemap                     = {"r_fx_fog_usemap", "2"};
cvar_t r_fx_fog_model                      = {"r_fx_fog_model", "2"};
cvar_t r_fx_fog_density                    = {"r_fx_fog_density", "0.125"};
cvar_t r_fx_fog_start                      = {"r_fx_fog_start", "50.0"};
cvar_t r_fx_fog_end                        = {"r_fx_fog_end", "800.0"};
cvar_t r_fx_fog_color_air                  = {"r_fx_fog_color_air", "153 128 103", CVAR_COLOR};
cvar_t r_fx_fog_color_water                = {"r_fx_fog_color_water", "32 64 128", CVAR_COLOR};
cvar_t r_fx_fog_color_lava                 = {"r_fx_fog_color_lava", "255 64 0", CVAR_COLOR};
cvar_t r_fx_fog_color_slime                = {"r_fx_fog_color_slime", "128 255 0", CVAR_COLOR};
cvar_t r_fx_fog_sky                        = {"r_fx_fog_sky", "0.3"};

cvar_t gl_simpleitems                      = {"gl_simpleitems", "0"};
cvar_t gl_simpleitems_size                 = {"gl_simpleitems_size", "16"};
cvar_t gl_simpleitems_orientation          = {"gl_simpleitems_orientation", "2"};
cvar_t gl_modulate                         = {"gl_modulate", "1"};

cvar_t gl_outline                          = {"gl_outline", "0"};
cvar_t gl_outline_color_world              = {"gl_outline_color_world", "0 0 0"};
cvar_t gl_outline_color_model              = {"gl_outline_color_model", "0 0 0"};
cvar_t gl_outline_scale_world              = {"gl_outline_scale_world", "1"};
cvar_t gl_outline_scale_model              = {"gl_outline_scale_model", "1"};
cvar_t gl_outline_world_depth_threshold    = {"gl_outline_world_depth_threshold", "4"};
cvar_t gl_outline_world_normal_threshold   = {"gl_outline_world_normal_threshold", "0.997"};
cvar_t gl_outline_use_player_color         = {"gl_outline_use_player_color", "0"};
cvar_t gl_spec_xray                        = {"gl_spec_xray", "0"};
cvar_t gl_spec_xray_distance               = {"gl_spec_xray_distance", "1500"};
cvar_t gl_outline_color_team               = {"gl_outline_color_team", ""};
cvar_t gl_outline_color_enemy              = {"gl_outline_color_enemy", ""};

cvar_t gl_smoothmodels                     = {"gl_smoothmodels", "1"};

cvar_t gl_vbo_clientmemory                 = {"gl_vbo_clientmemory", "0", CVAR_LATCH_GFX };

cvar_t r_remove_collinear_vertices         = {"r_remove_collinear_vertices", "0", 0, OnRemoveCollinearVerticesChanged};

//Returns true if the box is completely outside the frustom
qbool R_CullBox(vec3_t mins, vec3_t maxs)
{
	int i;

	for (i = 0; i < 4; i++) {
		if (BOX_ON_PLANE_SIDE(mins, maxs, &frustum[i]) == 2) {
			return true;
		}
	}
	return false;
}

//Returns true if the sphere is completely outside the frustum
qbool R_CullSphere(vec3_t centre, float radius)
{
	int i;
	mplane_t *p;

	for (i = 0, p = frustum; i < 4; i++, p++) {
		if (PlaneDiff(centre, p) <= -radius) {
			return true;
		}
	}

	return false;
}

static int SignbitsForPlane(mplane_t *out)
{
	int	bits, j;

	// for fast box on planeside test
	bits = 0;
	for (j = 0; j < 3; j++) {
		if (out->normal[j] < 0) {
			bits |= 1 << j;
		}
	}
	return bits;
}

void R_SetFrustum(void)
{
	int i;

	// rotate VPN right by FOV_X/2 degrees
	RotatePointAroundVector( frustum[0].normal, vup, vpn, -(90-r_refdef.fov_x / 2 ) );
	// rotate VPN left by FOV_X/2 degrees
	RotatePointAroundVector( frustum[1].normal, vup, vpn, 90-r_refdef.fov_x / 2 );
	// rotate VPN up by FOV_X/2 degrees
	RotatePointAroundVector( frustum[2].normal, vright, vpn, 90-r_refdef.fov_y / 2 );
	// rotate VPN down by FOV_X/2 degrees
	RotatePointAroundVector( frustum[3].normal, vright, vpn, -( 90 - r_refdef.fov_y / 2 ) );

	for (i = 0; i < 4; i++) {
		frustum[i].type = PLANE_ANYZ;
		frustum[i].dist = DotProduct (r_origin, frustum[i].normal);
		frustum[i].signbits = SignbitsForPlane (&frustum[i]);
	}
}

static void R_ConfigureFog(int contents)
{
	int i;
	qbool use_map_fog;

	// enable it even if not showing this frame, to prevent potential program re-compiles when going in/out of water
	if (!R_FogAvailable()) {
		r_refdef2.fog_enabled = r_refdef2.fog_render = false;
		return;
	}

	use_map_fog = cl.map_fog_enabled && (r_fx_fog_usemap.integer == 1 || (r_fx_fog_usemap.integer == 2 && Ruleset_IsLocalSinglePlayerGame()));
	r_refdef2.fog_enabled = (use_map_fog || r_fx_fog.integer == 1 || r_fx_fog.integer == 2);
	r_refdef2.fog_render = (use_map_fog || r_fx_fog.integer == 1 || (r_fx_fog.integer == 2 && ISUNDERWATER(contents)));
	r_refdef2.fog_density = 0;
	r_refdef2.fog_calculation = fogcalc_none;

	if (r_refdef2.fog_render) {
		if (use_map_fog) {
			r_refdef2.fog_density = bound(0, cl.map_fog_density * cl.map_fog_density, 1);
			r_refdef2.fog_calculation = fogcalc_exp2;
		}
		else {
			r_refdef2.fog_density = bound(0, r_fx_fog_density.value / 64.0f, 1);

			if (r_fx_fog_model.integer == 0) {
				r_refdef2.fog_calculation = fogcalc_linear;
			}
			else if (r_fx_fog_model.integer == 1) {
				r_refdef2.fog_calculation = fogcalc_exp;
			}
			else if (r_fx_fog_model.integer == 2) {
				r_refdef2.fog_calculation = fogcalc_exp2;
				r_refdef2.fog_density = r_refdef2.fog_density * r_refdef2.fog_density;
			}
		}

		if (use_map_fog && cl.map_fog_sky >= 0) {
			r_refdef2.fog_sky = cl.map_fog_sky;
		}
		else {
			r_refdef2.fog_sky = r_refdef2.fog_density != 0 ? bound(0, r_fx_fog_sky.value, 1) : 0;
		}
	}
	r_refdef2.fog_linear_start = r_fx_fog_start.value;
	r_refdef2.fog_linear_end = r_fx_fog_end.value;

	if (contents == CONTENTS_LAVA) {
		VectorScale(r_fx_fog_color_lava.color, 1 / 255.0f, r_refdef2.fog_color);
	}
	else if (contents == CONTENTS_SLIME) {
		VectorScale(r_fx_fog_color_slime.color, 1 / 255.0f, r_refdef2.fog_color);
	}
	else if (contents == CONTENTS_WATER) {
		VectorScale(r_fx_fog_color_water.color, 1 / 255.0f, r_refdef2.fog_color);
	}
	else if (use_map_fog) {
		VectorCopy(cl.map_fog_color, r_refdef2.fog_color);
	}
	else {
		VectorScale(r_fx_fog_color_air.color, 1 / 255.0f, r_refdef2.fog_color);
	}
	for (i = 0; i < 3; ++i) {
		r_refdef2.fog_skycolor[i] = r_refdef2.fog_color[i] * r_refdef2.fog_sky + r_skycolor.color[i] * (1.0f - r_refdef2.fog_sky) / 255.0f;
	}
	r_refdef2.fog_color[3] = r_refdef2.fog_skycolor[3] = 1.0f;
}

void R_SetupFrame(void)
{
	vec3_t testorigin;
	mleaf_t	*leaf;

	R_AnimateLight ();

	r_framecount++;

	// build the transformation matrix for the given view angles
	VectorCopy (r_refdef.vieworg, r_origin);
	AngleVectors (r_refdef.viewangles, vpn, vright, vup);
	if (r_refdef.viewangles[ROLL] != 0) {
		vec3_t noroll_angles = { r_refdef.viewangles[0], r_refdef.viewangles[1], 0 };

		AngleVectors(noroll_angles, NULL, vright_noroll, vup_noroll);
	}
	else {
		VectorCopy(vright, vright_noroll);
		VectorCopy(vup, vup_noroll);
	}

	// current viewleaf
	r_oldviewleaf = r_viewleaf;
	r_oldviewleaf2 = r_viewleaf2;

	r_viewleaf = Mod_PointInLeaf (r_origin, cl.worldmodel);
	r_viewleaf2 = NULL;

	// FIXME: might need to test falling out bottom of water as well?

	// check above and below so crossing solid water doesn't draw wrong
	if (r_viewleaf->contents <= CONTENTS_WATER && r_viewleaf->contents >= CONTENTS_LAVA) {
		// look up a bit
		VectorCopy (r_origin, testorigin);
		testorigin[2] += 10;
		leaf = Mod_PointInLeaf (testorigin, cl.worldmodel);
		if (leaf->contents == CONTENTS_EMPTY) {
			r_viewleaf2 = leaf;
		}
	}
	else if (r_viewleaf->contents == CONTENTS_EMPTY) {
		// FIXME: If we test down and find CONTENTS_SOLID then we should reduce viewheight_test and try again?

		// look down a bit
		VectorCopy(r_origin, testorigin);
		testorigin[2] -= r_refdef.viewheight_test;
		leaf = Mod_PointInLeaf(testorigin, cl.worldmodel);
		if (leaf->contents <= CONTENTS_WATER && leaf->contents >= CONTENTS_LAVA) {
			r_viewleaf2 = leaf;
		}
	}

	V_SetContentsColor(r_viewleaf->contents);
	R_ConfigureFog(r_viewleaf->contents);
	V_CalcBlend();

	R_LightmapFrameInit();
}

static void MYgluPerspective(double fovy, double aspect, double zNear, double zFar)
{
	double xmin, xmax, ymin, ymax;

	ymax = zNear * tan(fovy * M_PI / 360.0);
	ymin = -ymax;

	xmin = ymin * aspect;
	xmax = ymax * aspect;

	if (cl_multiview.value == 2 && !cl_mvinset.value && cls.mvdplayback) {
		R_Frustum(xmin, xmax, ymin + (ymax - ymin)*0.25, ymax - (ymax - ymin)*0.25, zNear, zFar);
	}
	else if (CL_MultiviewActiveViews() == 3) {
		if (CL_MultiviewCurrentView() == 2) {
			R_Frustum(xmin, xmax, ymin + (ymax - ymin)*0.25, ymax - (ymax - ymin)*0.25, zNear, zFar);
		}
		else {
			R_Frustum(xmin, xmax, ymin, ymax, zNear, zFar);
		}
	}
	else {
		R_Frustum(xmin, xmax, ymin, ymax, zNear, zFar);
	}
}

void R_SetViewports(int glx, int x, int gly, int y2, int w, int h, float max)
{
	//
	// Setup Multiview-viewports
	//
	if (max == 1) {
		R_Viewport(glx + x, gly + y2, w, h);
		return;
	}
	else if (max == 2 && cl_mvinset.value) {
		if (CL_MultiviewCurrentView() == 2) {
			R_Viewport(glx + x, gly + y2, w, h);
		}
		else if (CL_MultiviewCurrentView() == 1) {
			int height = cl_sbar.integer ? h : glheight;
			int inset_left = glx + x + (cl_mvinset_right.integer ? glwidth - cl_mvinset_size_x.value * glwidth : 0) + cl_mvinset_offset_x.value;
			int inset_top = gly + y2 + (cl_mvinset_top.integer ? height - cl_mvinset_size_y.value * height : 0) - cl_mvinset_offset_y.value;
			int inset_width = w * cl_mvinset_size_x.value;
			int inset_height = h * cl_mvinset_size_y.value;

			CL_MultiviewInsetSetScreenCoordinates(inset_left, inset_top, inset_width, inset_height);
			R_Viewport(inset_left, inset_top, inset_width, inset_height);
		}
		else {
			Com_Printf("ERROR!\n");
		}
		return;
	}
	else if (max == 2 && !cl_mvinset.value) {
		if (CL_MultiviewCurrentView() == 2) {
			R_Viewport(0, h / 2, w, h / 2);
		}
		else if (CL_MultiviewCurrentView() == 1) {
			R_Viewport(0, 0, w, h / 2 - 1);
		}
		else {
			Com_Printf("ERROR!\n");
		}
		return;
	}
	else if (max == 3) {
		if (CL_MultiviewCurrentView() == 2) {
			R_Viewport(0, h / 2, w, h / 2);
		}
		else if (CL_MultiviewCurrentView() == 3) {
			R_Viewport(0, 0, w / 2, h / 2 - 1);
		}
		else {
			R_Viewport(w / 2, 0, w / 2, h / 2 - 1);
		}
		return;
	}
	else {
		if (CL_MultiviewCurrentView() == 2) {
			R_Viewport(0, h / 2, w / 2, h / 2);
		}
		else if (CL_MultiviewCurrentView() == 3) {
			R_Viewport(w / 2, h / 2, w / 2, h / 2);
		}
		else if (CL_MultiviewCurrentView() == 4) {
			R_Viewport(0, 0, w / 2, h / 2 - 1);
		}
		else if (CL_MultiviewCurrentView() == 1) {
			R_Viewport(w / 2, 0, w / 2, h / 2 - 1);
		}
	}

	return;
}

float R_FarPlaneZ(void)
{
	return bound(R_MINIMUM_FARCLIP, r_farclip.value, R_MAXIMUM_FARCLIP);
}

float R_NearPlaneZ(void)
{
	extern cvar_t r_nearclip;

	return bound(R_MINIMUM_NEARCLIP, r_nearclip.value, R_MAXIMUM_NEARCLIP);
}

static void R_SetupViewport(void)
{
	float screenaspect;
	extern int glwidth, glheight;
	int x, x2, y2, y, w, h;

	// set up viewpoint
	x = r_refdef.vrect.x * glwidth / vid.width;
	x2 = (r_refdef.vrect.x + r_refdef.vrect.width) * glwidth / vid.width;
	y = (vid.height - r_refdef.vrect.y) * glheight / vid.height;
	y2 = (vid.height - (r_refdef.vrect.y + r_refdef.vrect.height)) * glheight / vid.height;

	// fudge around because of frac screen scale
	if (x > 0) {
		x--;
	}
	if (x2 < glwidth) {
		x2++;
	}
	if (y2 < 0) {
		y2--;
	}
	if (y < glheight) {
		y++;
	}

	w = x2 - x;
	h = y - y2;

	// Multiview
	R_SetFullScreenViewport(glx + x, gly + y2, w, h);
	if (CL_MultiviewEnabled() && CL_MultiviewCurrentView() != 0) {
		R_SetViewports(glx, x, gly, y2, w, h, cl_multiview.value);
	}
	if (!CL_MultiviewEnabled()) {
		R_Viewport(glx + x, gly + y2, w, h);
	}

	screenaspect = (float)r_refdef.vrect.width / r_refdef.vrect.height;

	R_IdentityProjectionView();
	MYgluPerspective(r_refdef.fov_y, screenaspect, R_NearPlaneZ(), R_FarPlaneZ());
}

static void R_SetupGL(void)
{
	R_SetupViewport();

	R_StateDefault3D();

	renderer.SetupGL();
}

void R_Init(void)
{
	R_SkyRegisterCvars();
	Cmd_AddCommand("timerefresh", R_TimeRefresh_f);
#ifndef CLIENTONLY
	Cmd_AddCommand("dev_pointfile", R_ReadPointFile_f);
#endif

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	{
		void GLC_BloomRegisterCvars(void);

		GLC_BloomRegisterCvars();
	}
#endif

	Cvar_SetCurrentGroup(CVAR_GROUP_EYECANDY);
	Cvar_Register(&r_drawentities);
	Cvar_Register(&r_drawworld);
	Cvar_Register(&r_lerpframes);
	Cvar_Register(&r_drawflame);
	Cvar_Register(&r_drawdisc);
	Cvar_Register(&gl_detail);
	Cvar_Register(&gl_powerupshells);

	Cvar_Register(&gl_simpleitems);
	Cvar_Register(&gl_simpleitems_size);
	Cvar_Register(&gl_simpleitems_orientation);

	Cvar_SetCurrentGroup(CVAR_GROUP_PARTICLES);
	Cvar_Register(&gl_part_explosions);
	Cvar_Register(&gl_part_bloodtrails);
	Cvar_Register(&gl_part_trails);
	Cvar_Register(&gl_part_tracer1_color);
	Cvar_Register(&gl_part_tracer1_size);
	Cvar_Register(&gl_part_tracer1_time);
	Cvar_Register(&gl_part_tracer2_color);
	Cvar_Register(&gl_part_tracer2_size);
	Cvar_Register(&gl_part_tracer2_time);
	Cvar_Register(&gl_part_spikes);
	Cvar_Register(&gl_part_gunshots);
	Cvar_Register(&gl_part_blood);
	Cvar_Register(&gl_part_telesplash);
	Cvar_Register(&gl_part_blobs);
	Cvar_Register(&gl_part_lavasplash);
	Cvar_Register(&gl_part_inferno);
	Cvar_Register(&gl_part_bubble);
	Cvar_Register(&gl_squareparticles);

	Cvar_Register(&gl_part_detpackexplosion_fire_color);
	Cvar_Register(&gl_part_detpackexplosion_ray_color);

	Cvar_SetCurrentGroup(CVAR_GROUP_TURB);
	Cvar_Register(&r_skyname);
	Cvar_Register(&r_skywind);
	Cvar_Register(&r_fastsky);
	Cvar_Register(&r_skycolor);
	Cvar_Register(&r_fastturb);

	Cvar_Register(&r_telecolor);
	Cvar_Register(&r_lavacolor);
	Cvar_Register(&r_slimecolor);
	Cvar_Register(&r_watercolor);

	Cvar_Register(&r_novis);
	Cvar_Register(&r_wateralpha);
	Cvar_Register(&gl_caustics);

	// Fog cvars
	if (R_FogAvailable()) {
		Cvar_SetCurrentGroup(CVAR_GROUP_EYECANDY);
		Cvar_Register(&r_fx_fog);
		Cvar_Register(&r_fx_fog_model);
		Cvar_Register(&r_fx_fog_usemap);
		Cvar_Register(&r_fx_fog_density);
		Cvar_Register(&r_fx_fog_start);
		Cvar_Register(&r_fx_fog_end);
		Cvar_Register(&r_fx_fog_sky);
		Cvar_Register(&r_fx_fog_color_air);
		Cvar_Register(&r_fx_fog_color_water);
		Cvar_Register(&r_fx_fog_color_lava);
		Cvar_Register(&r_fx_fog_color_slime);
	}

	Cvar_SetCurrentGroup(CVAR_GROUP_BLEND);
	Cvar_Register(&gl_polyblend);

	R_InitAliasModelCvars();

	Cvar_SetCurrentGroup(CVAR_GROUP_LIGHTING);
	Cvar_Register(&r_dynamic);
	Cvar_Register(&gl_fb_bmodels);
	Cvar_Register(&gl_fb_models);
	Cvar_Register(&gl_lightmode);
	Cvar_Register(&gl_flashblend);
	Cvar_Register(&gl_rl_globe);
	Cvar_Register(&r_shadows);
	Cvar_Register(&r_fullbright);
	Cvar_Register(&gl_loadlitfiles);
	Cvar_Register(&gl_oldlitscaling);
	Cvar_Register(&gl_colorlights);

	Cvar_SetCurrentGroup(CVAR_GROUP_TEXTURES);
	Cvar_Register(&gl_playermip);
	Cvar_Register(&gl_subdivide_size);
	Cvar_Register(&gl_lumatextures);
	Cvar_Register(&r_drawflat);
	Cvar_Register(&r_drawflat_mode);
	Cvar_Register(&r_wallcolor);
	Cvar_Register(&r_floorcolor);
	Cvar_Register(&gl_textureless); //Qrack

	Cvar_SetCurrentGroup(CVAR_GROUP_OPENGL);
	Cvar_Register(&r_farclip);
	Cvar_Register(&gl_clear);
	Cvar_Register(&gl_clearColor);
	Cvar_Register(&gl_brush_polygonoffset);
	Cvar_Register(&gl_brush_polygonoffset_factor);

	Cvar_Register(&gl_nocolors);
	Cvar_Register(&gl_finish);
	Cvar_Register(&gl_modulate);

	Cvar_Register(&gl_outline);
	Cvar_Register(&gl_outline_color_world);
	Cvar_Register(&gl_outline_color_model);
	// Cvar_Register(&gl_outline_scale_world);
	Cvar_Register(&gl_outline_scale_model);
	Cvar_Register(&gl_outline_world_depth_threshold);
	Cvar_Register(&gl_outline_world_normal_threshold);
	Cvar_Register(&gl_outline_use_player_color);
	Cvar_Register(&gl_spec_xray);
	Cvar_Register(&gl_spec_xray_distance);
	Cvar_Register(&gl_outline_color_team);
	Cvar_Register(&gl_outline_color_enemy);
	Cvar_Register(&gl_smoothmodels);

	Cvar_Register(&gl_vbo_clientmemory);

	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);
	if (IsDeveloperMode()) {
		Cvar_Register(&r_speeds);
	}
	Cvar_Register(&r_netgraph);
	Cvar_Register(&r_netstats);

	Cvar_Register(&cl_multiview);
	Cvar_Register(&cl_mvdisplayhud);
	Cvar_Register(&cl_mvhudvertical);
	Cvar_Register(&cl_mvhudflip);
	Cvar_Register(&cl_mvhudpos);
	cl_mvhudpos.OnChange = SCR_OnChangeMVHudPos;
	Cvar_Register(&cl_mvinset);
	Cvar_Register(&cl_mvinsetcrosshair);
	Cvar_Register(&cl_mvinsethud);
	Cvar_Register(&cl_mvinset_offset_x);
	Cvar_Register(&cl_mvinset_offset_y);
	Cvar_Register(&cl_mvinset_size_x);
	Cvar_Register(&cl_mvinset_size_y);
	Cvar_Register(&cl_mvinset_top);
	Cvar_Register(&cl_mvinset_right);

	Cvar_Register(&r_remove_collinear_vertices);

	Cvar_ResetCurrentGroup();

	if (!hud_netgraph) {
		hud_netgraph = HUD_Register(
			"netgraph", /*"r_netgraph"*/ NULL, "Shows your network conditions in graph-form. With netgraph you can monitor your latency (ping), packet loss and network errors.",
			HUD_PLUSMINUS | HUD_ON_SCORES, ca_onserver, 0, SCR_HUD_Netgraph,
			"0", "top", "left", "bottom", "0", "0", "0", "0 0 0", NULL,
			"swap_x", "0",
			"swap_y", "0",
			"inframes", "0",
			"scale", "256",
			"ploss", "1",
			"width", "256",
			"height", "32",
			"lostscale", "1",
			"alpha", "1",
			NULL
		);
	}

	R_InitTextures();	   // FIXME: not sure is this safe re-init
	R_InitBubble();	       // safe re-init
	R_InitParticles();     // safe re-init imo
	R_InitChatIcons();     // safe re-init

	//VULT STUFF
	InitVXStuff(); // safe re-init imo

	InitTracker();
	R_InitOtherTextures(); // safe re-init
	R_InitBloomTextures();
}

void OnChange_gl_clearColor(cvar_t *v, char *s, qbool *cancel) {
	byte *color;
	char buf[MAX_COM_TOKEN];

	strlcpy(buf,s,sizeof(buf));
	color = StringToRGB(buf);

	clearColor[0] = color[0] / 255.0;
	clearColor[1] = color[1] / 255.0;
	clearColor[2] = color[2] / 255.0;

	R_ClearColor(clearColor[0], clearColor[1], clearColor[2], 1.0);
}

static void R_Clear(void)
{
	qbool clear_color = false;

	// This used to cause a bug with some graphics cards when
	// in multiview mode. It would clear all but the last
	// drawn views.
	clear_color |= (!cl_multiview.integer && (gl_clear.integer || (!vid_hwgamma_enabled && v_contrast.value > 1)));

	// If outside level or in wall, sky is usually visible
	clear_color |= (r_viewleaf->contents == CONTENTS_SOLID && (R_UseModernOpenGL() || r_fastsky.integer));

	if (gl_clear.integer) {
		//Tei custom clear color
		if (r_refdef2.fog_render) {
			R_ClearColor(r_refdef2.fog_color[0], r_refdef2.fog_color[1], r_refdef2.fog_color[2], 1.0);
		}
		else {
			R_ClearColor(clearColor[0], clearColor[1], clearColor[2], 1.0);
		}
	}

	renderer.ClearRenderingSurface(clear_color);
}

void R_PostProcessScene(void)
{
	if (R_UseImmediateOpenGL()) {
		R_BloomBlend();
	}
}

static void R_Render3DEffects(void)
{
	// Adds particles (all types)
	R_DrawParticles();

	// Adds chat icons over player's heads (afk etc)
	R_DrawChatIcons();

	// Run corona logic
	R_DrawCoronas();
}

static void R_Render3DHud(void)
{
	// Draw the player's view model (gun)
	if (R_UseImmediateOpenGL()) {
		R_DrawViewModel();
	}

	// While still in 3D mode, calculate the location of labels to be printed in 2D
	SCR_SetupAutoID();
	SCR_SetupDamageIndicators();
}

void R_RenderView(void)
{
	if (!r_worldentity.model || !cl.worldmodel) {
		Sys_Error("R_RenderView: NULL worldmodel");
	}

	// Wait for previous commands to 'complete'
	if (!r_speeds.integer && gl_finish.integer) {
		renderer.EnsureFinished();
	}

	R_SetFrustum();
	R_SetupGL();
	R_Clear();
	R_MarkLeaves();	// done here so we know if we're in water
	R_CreateWorldTextureChains();

	// render normal view
	R_DrawWorld();		// adds static entities to the list

	R_DrawEntities();

	// Adds 3d effects (particles, lights, chat icons etc)
	R_Render3DEffects();

	// Render billboards
	renderer.Draw3DSpritesInline();

	// Draw 3D hud elements
	R_Render3DHud();

	renderer.RenderView();
}

qbool R_PointIsUnderwater(vec3_t point)
{
	int contents = TruePointContents(point);

	return ISUNDERWATER(contents);
}

qbool R_CanDrawSimpleItem(entity_t* e)
{
	int skin;

	if (!gl_simpleitems.integer || !e || !e->model) {
		return false;
	}

	skin = e->skinnum >= 0 && e->skinnum < MAX_SIMPLE_TEXTURES ? e->skinnum : 0;

	if (R_UseModernOpenGL()) {
		return R_TextureReferenceIsValid(e->model->simpletexture_array[skin]);
	}
	else {
		return R_TextureReferenceIsValid(e->model->simpletexture[skin]);
	}
}

static qbool R_DrawTrySimpleItem(entity_t* ent)
{
	int sprtype = gl_simpleitems_orientation.integer;
	float sprsize = bound(1, gl_simpleitems_size.value, 16), autorotate;
	texture_ref simpletexture;
	vec3_t right, up, org, offset;
	int skin;

	if (!ent || !ent->model) {
		return false;
	}

	skin = ent->skinnum >= 0 && ent->skinnum < MAX_SIMPLE_TEXTURES ? ent->skinnum : 0;
	if (R_UseModernOpenGL()) {
		simpletexture = ent->model->simpletexture_array[skin];
	}
	else {
		simpletexture = ent->model->simpletexture[skin];
	}
	if (!R_TextureReferenceIsValid(simpletexture)) {
		return false;
	}

	autorotate = anglemod(100 * cl.time);
	if (sprtype == SPR_ORIENTED) {
		// bullet marks on walls
		vec3_t angles;
		angles[0] = angles[2] = 0;
		angles[1] = anglemod(autorotate);
		AngleVectors(angles, NULL, right, up);
	}
	else if (sprtype == SPR_FACING_UPRIGHT) {
		VectorSet(up, 0, 0, 1);
		right[0] = ent->origin[1] - r_origin[1];
		right[1] = -(ent->origin[0] - r_origin[0]);
		right[2] = 0;
		VectorNormalizeFast(right);
	}
	else if (sprtype == SPR_VP_PARALLEL_UPRIGHT) {
		VectorSet(up, 0, 0, 1);
		VectorCopy(vright, right);
	}
	else {
		// normal sprite
		VectorCopy(vup_noroll, up);
		VectorCopy(vright_noroll, right);
	}

	VectorCopy(ent->origin, org);
	// brush models require some additional centering
	if (ent->model->type == mod_brush) {
		extern cvar_t cl_model_bobbing;

		VectorSubtract(ent->model->maxs, ent->model->mins, offset);
		offset[2] = 0;
		VectorMA(org, 0.5, offset, org);

		if (cl_model_bobbing.value) {
			org[2] += sin(autorotate / 90 * M_PI) * 5 + 5;
		}
	}
	org[2] += sprsize;

	renderer.DrawSimpleItem(ent->model, skin, org, sprsize, up, right);
	return true;
}

static int R_DrawEntitiesSorter(const void* lhs_, const void* rhs_)
{
	const visentity_t* lhs = (const visentity_t*)lhs_;
	const visentity_t* rhs = (const visentity_t*)rhs_;

	float alpha_lhs = lhs->type == mod_sprite ? 0.5 : lhs->ent.alpha == 0 ? 1 : lhs->ent.alpha;
	float alpha_rhs = rhs->type == mod_sprite ? 0.5 : rhs->ent.alpha == 0 ? 1 : rhs->ent.alpha;

	// Draw opaque entities first
	if (alpha_lhs == 1 && alpha_rhs != 1) {
		return -1;
	}
	else if (alpha_lhs != 1 && alpha_rhs == 1) {
		return 1;
	}

	if (alpha_lhs != 1) {
		// Furthest first
		if (lhs->distance > rhs->distance) {
			return -1;
		}
		else if (lhs->distance < rhs->distance) {
			return 1;
		}
	}

	// order by brush/alias/etc for batching
	if (lhs->type != rhs->type) {
		return lhs->type < rhs->type ? -1 : 1;
	}

	// Then by model
	if ((uintptr_t)lhs->ent.model < (uintptr_t)rhs->ent.model) {
		return -1;
	}
	if ((uintptr_t)lhs->ent.model >(uintptr_t)rhs->ent.model) {
		return 1;
	}

	if (alpha_lhs == 1) {
		// Closest first
		if (lhs->distance < rhs->distance) {
			return -1;
		}
		else if (lhs->distance > rhs->distance) {
			return 1;
		}
	}

	// Then by position
	if ((uintptr_t)lhs < (uintptr_t)rhs) {
		return -1;
	}
	if ((uintptr_t)lhs >(uintptr_t)rhs) {
		return 1;
	}
	return 0;
}

static void R_DrawEntitiesOnList(visentlist_t *vislist, visentlist_entrytype_t type)
{
	int i;

	if (r_drawentities.integer && vislist->typecount[type] > 0) {
		for (i = 0; i < vislist->count; i++) {
			visentity_t* todraw = &vislist->list[i];

			if (!todraw->draw[type]) {
				continue;
			}

			switch (todraw->type) {
				case mod_brush:
					R_BrushModelDrawEntity(&todraw->ent);
					break;
				case mod_sprite:
					if (todraw->ent.model->type == mod_sprite) {
						renderer.DrawSpriteModel(&todraw->ent);
					}
					else {
						R_DrawTrySimpleItem(&todraw->ent);
					}
					break;
				case mod_alias:
					if (type != visent_additive) {
						if (type == visent_shells) {
							renderer.DrawAliasModelPowerupShell(&todraw->ent);
						}
						else {
							R_DrawAliasModel(&todraw->ent, type == visent_outlines);
						}
					}
					break;
				case mod_alias3:
					if (type == visent_shells) {
						renderer.DrawAlias3ModelPowerupShell(&todraw->ent);
					}
					else {
						renderer.DrawAlias3Model(&todraw->ent, type == visent_outlines, type == visent_additive);
					}
					break;
				case mod_unknown:
					// keeps compiler happy
					break;
			}
		}
	}
}

void R_PolyBlend(void)
{
	extern cvar_t gl_hwblend;

	if (vid_hwgamma_enabled && gl_hwblend.value && !cl.teamfortress) {
		return;
	}
	if (!v_blend[3]) {
		return;
	}

	renderer.PolyBlend(v_blend);
}

static void R_DrawEntities(void)
{
	visentlist_entrytype_t ent_type;

#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		GLM_InitialiseAliasModelBatches();
	}
#endif

	if (!r_drawentities.integer) {
		return;
	}

	R_TraceEnterNamedRegion("R_DrawEntities");

	R_Sprite3DInitialiseBatch(SPRITE3D_ENTITIES, r_state_sprites_textured, null_texture_reference, 0, r_primitive_triangle_strip);
	qsort(cl_visents.list, cl_visents.count, sizeof(cl_visents.list[0]), R_DrawEntitiesSorter);
	for (ent_type = 0; ent_type < visent_max; ++ent_type) {
		if (ent_type == visent_alpha) {
			// Transluscent before translucent entities, but after opaque ones.
			renderer.DrawWaterSurfaces();
		}
		R_DrawEntitiesOnList(&cl_visents, ent_type);
	}
	if (R_UseModernOpenGL() || R_UseVulkan()) {
		R_DrawViewModel();
	}
	R_TraceLeaveNamedRegion();
}


================================================
FILE: src/r_rmisc.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: gl_rmisc.c,v 1.27 2007-09-17 19:37:55 qqshka Exp $
*/
// gl_rmisc.c

#include "quakedef.h"
#include "vx_stuff.h"
#include "vx_tracker.h"
#include "gl_model.h"
#include "rulesets.h"
#ifndef  __APPLE__
#include "tr_types.h"
#endif
#include "r_brushmodel_sky.h"
#include "r_texture.h"
#include "r_lightmaps.h"
#include "r_local.h"
#include "r_lighting.h"
#include "r_performance.h"
#include "r_aliasmodel.h" // shelltexture only
#include "r_renderer.h"

static texture_ref R_GenerateShellTexture(void)
{
	int x, y, d;
	byte data[32][32][4];

	for (y = 0;y < 32;y++)
	{
		for (x = 0;x < 32;x++)
		{
			d = (sin(x * M_PI / 8.0f) + cos(y * M_PI / 8.0f)) * 64 + 64;
			if (d < 0)
				d = 0;
			if (d > 255)
				d = 255;
			data[y][x][0] = data[y][x][1] = data[y][x][2] = d;
			data[y][x][3] = 255;
		}
	}

	return R_LoadTexture("shelltexture", 32, 32, &data[0][0][0], TEX_MIPMAP, 4);
}

void R_InitOtherTextures(void)
{
	unsigned char solidwhitetexels[] = { 255, 255, 255, 255 };
	unsigned char solidblacktexels[] = { 0, 0, 0, 255 };
	unsigned char transparenttexels[] = { 0, 0, 0, 0 };
	int flags = TEX_MIPMAP | TEX_ALPHA;
	extern cvar_t gl_caustics, gl_detail, gl_powerupshells;

	underwatertexture = R_LoadTextureImage("textures/water_caustic", NULL, 0, 0, flags | (gl_caustics.value ? TEX_COMPLAIN : 0));
	detailtexture = R_LoadTextureImage("textures/detail", NULL, 256, 256, flags | (gl_detail.value ? TEX_COMPLAIN : 0));

	shelltexture = R_LoadTextureImage("textures/shellmap", NULL, 0, 0, flags | TEX_PREMUL_ALPHA | TEX_ZERO_ALPHA | (bound(0, gl_powerupshells.value, 1) ? TEX_COMPLAIN : 0));
	if (!R_TextureReferenceIsValid(shelltexture)) {
		shelltexture = R_GenerateShellTexture();
	}

	solidwhite_texture = R_LoadTexture("billboard:solidwhite", 1, 1, solidwhitetexels, TEX_ALPHA | TEX_NOSCALE, 4);
	solidblack_texture = R_LoadTexture("billboard:solidblack", 1, 1, solidblacktexels, TEX_ALPHA | TEX_NOSCALE, 4);
	transparent_texture = R_LoadTexture("billboard:transparent", 1, 1, transparenttexels, TEX_ALPHA | TEX_NOSCALE, 4);
}

void R_InitTextures(void)
{
	int x, y, m;
	byte *dest;

	if (r_notexture_mip) {
		return; // FIXME: may be do not Hunk_AllocName but made other stuff ???
	}

	// create a simple checkerboard texture for the default
	r_notexture_mip = (texture_t *)Hunk_AllocName(sizeof(texture_t) + 16 * 16 + 8 * 8 + 4 * 4 + 2 * 2, "notexture");

	strlcpy(r_notexture_mip->name, "notexture", sizeof(r_notexture_mip->name));
	r_notexture_mip->width = r_notexture_mip->height = 16;
	r_notexture_mip->offsets[0] = sizeof(texture_t);
	r_notexture_mip->offsets[1] = r_notexture_mip->offsets[0] + 16 * 16;
	r_notexture_mip->offsets[2] = r_notexture_mip->offsets[1] + 8 * 8;
	r_notexture_mip->offsets[3] = r_notexture_mip->offsets[2] + 4 * 4;

	for (m = 0; m < 4; m++) {
		dest = (byte *)r_notexture_mip + r_notexture_mip->offsets[m];
		for (y = 0; y < (16 >> m); y++) {
			for (x = 0; x < (16 >> m); x++) {
				if ((y < (8 >> m)) ^ (x < (8 >> m)))
					*dest++ = 0;
				else
					*dest++ = 0x0e;
			}
		}
	}
}

// Called after models have been downloaded but before they've been loaded into memory
void R_NewMapPreLoad(void)
{
	R_ClearSkyTextures();

	// Set this here so lightmaps & textures both use the same setting...
	lightmode = gl_lightmode.integer ? 2 : 0;
}

static qbool R_ParseWorldspawn(const char* entstring, worldspawn_info_t* worldspawn)
{
	char key[256];
	const char* data;

	memset(worldspawn, 0, sizeof(*worldspawn));
	worldspawn->wateralpha = -1;
	worldspawn->telealpha = -1;
	worldspawn->slimealpha = -1;
	worldspawn->lavaalpha = -1;
	worldspawn->fog_sky = -1;

	// parse the opening brace
	data = COM_Parse(entstring);
	if (!data) {
		return false;
	}
	if (com_token[0] != '{') {
		Con_Printf("R_ParseWorldSpawn: found %s when expecting {", com_token);
		return false;
	}

	while (1) {
		data = COM_Parse(data);
		if (!data) {
			return false; // error
		}
		if (com_token[0] == '}') {
			return true; // end of object: ignore other entities for now
		}
		if (com_token[0] == '_') {
			strlcpy(key, com_token + 1, sizeof(key));
		}
		else {
			strlcpy(key, com_token, sizeof(key));
		}

		data = COM_Parse(data);
		if (!data) {
			return false; // error
		}

		if (!strcmp("sky", key)) {
			strlcpy(worldspawn->skybox_name, com_token, sizeof(worldspawn->skybox_name));
		}
		else if (!strcmp("wateralpha", key)) {
			worldspawn->wateralpha = atof(com_token);
			worldspawn->wateralpha = bound(0, worldspawn->wateralpha, 1);
		}
		else if (!strcmp("lavaalpha", key)) {
			worldspawn->lavaalpha = atof(com_token);
			worldspawn->lavaalpha = bound(0, worldspawn->lavaalpha, 1);
		}
		else if (!strcmp("telealpha", key)) {
			worldspawn->telealpha = atof(com_token);
			worldspawn->telealpha = bound(0, worldspawn->telealpha, 1);
		}
		else if (!strcmp("slimealpha", key)) {
			worldspawn->slimealpha = atof(com_token);
			worldspawn->slimealpha = bound(0, worldspawn->slimealpha, 1);
		}
		else if (!strcmp("fog", key)) {
			// <density> <r> <g> <b>
			tokenizecontext_t fog;
			char temp[MAX_COM_TOKEN];

			// TokenizeString uses com_token unfortunately...
			strlcpy(temp, com_token, sizeof(temp));
			Cmd_TokenizeStringEx(&fog, temp);
			if (Cmd_ArgcEx(&fog) == 4) {
				worldspawn->fog_density = atof(Cmd_ArgvEx(&fog, 0));
				worldspawn->fog_color[0] = atof(Cmd_ArgvEx(&fog, 1));
				worldspawn->fog_color[1] = atof(Cmd_ArgvEx(&fog, 2));
				worldspawn->fog_color[2] = atof(Cmd_ArgvEx(&fog, 3));

				worldspawn->fog_density = bound(0, worldspawn->fog_density, 1);
				worldspawn->fog_color[0] = bound(0, worldspawn->fog_color[0], 1);
				worldspawn->fog_color[1] = bound(0, worldspawn->fog_color[1], 1);
				worldspawn->fog_color[2] = bound(0, worldspawn->fog_color[2], 1);
			}
		}
		else if (!strcmp("skyfog", key) || !strcmp("r_skyfog", key)) {
			worldspawn->fog_sky = atof(com_token);
			worldspawn->fog_sky = bound(0, worldspawn->fog_sky, 1);
		}
	}

	return false;
}

void R_NewMap(qbool vid_restart)
{
	worldspawn_info_t worldspawn;
	int	i;

	extern int R_SetSky(char *skyname);
	extern void HUD_NewRadarMap(void); // hud_common.c

	if (R_ParseWorldspawn(CM_EntityString(), &worldspawn)) {
		// load skybox specified
		if (r_skyname.string[0] == 0 && worldspawn.skybox_name[0]) {
			R_SetSky(worldspawn.skybox_name);
		}
		else {
			R_SetSky(r_skyname.string);
		}

		// set fog controls, if specified
		if (worldspawn.fog_density > 0) {
			VectorCopy(worldspawn.fog_color, cl.map_fog_color);
			cl.map_fog_density = worldspawn.fog_density / 64.0f;
			cl.map_fog_enabled = true;
		}

		if (worldspawn.fog_sky >= 0) {
			cl.map_fog_sky = worldspawn.fog_sky;
		}
	}
	else {
		R_SetSky(r_skyname.string);
	}

	if (!vid_restart) {
		for (i = 0; i < 256; i++) {
			// normal light value
			d_lightstylevalue[i] = 264;
		}
    
		memset (&r_worldentity, 0, sizeof(r_worldentity));
		r_worldentity.model = cl.worldmodel;
    
		// clear out efrags in case the level hasn't been reloaded
		// FIXME: is this one short?
		for (i = 0; i < cl.worldmodel->numleafs; i++) {
			cl.worldmodel->leafs[i].efrags = NULL;
		}

		r_viewleaf = NULL;
		R_ClearParticles ();
	}
	else {
		Mod_ReloadModelsTextures(); // reload textures for brush models
#if defined(WITH_PNG)
		HUD_NewRadarMap();			// Need to reload the radar picture.
#endif
	}

	Mod_ReloadModels(vid_restart);
	R_NewMapPrepare(vid_restart);

	if (!vid_restart) {
		// identify sky texture
		for (i = 0; i < cl.worldmodel->numtextures; i++) {
			if (!cl.worldmodel->textures[i]) {
				continue;
			}
			cl.worldmodel->textures[i]->texturechain = NULL;
			cl.worldmodel->textures[i]->texturechain_tail = &cl.worldmodel->textures[i]->texturechain;
		}

		//VULT CORONAS
		InitCoronas();
		//VULT NAMES
		VX_TrackerClear();
	}
}

void R_TimeRefresh_f(void)
{
	if (cls.state != ca_active) {
		return;
	}

	if (!Rulesets_AllowTimerefresh()) {
		Com_Printf("Timerefresh is disabled during match\n");
		return;
	}

	renderer.TimeRefresh();
}


================================================
FILE: src/r_shared.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// r_shared.h: general refresh-related stuff shared between the refresh and the
// driver

// FIXME: clean up and move into d_iface.h

#ifndef _R_SHARED_H_
#define _R_SHARED_H_

#include "d_iface.h"

#define	MAXVERTS	16					// max points in a surface polygon
#define MAXWORKINGVERTS	(MAXVERTS + 4)	// max points in an intermediate
										// polygon (while processing)
// !!! if this is changed, it must be changed in d_ifacea.h too !!!

#define	MAXHEIGHT	1024
#define	MAXWIDTH	1280

#define INFINITE_DISTANCE	0x10000		// distance that's always guaranteed to
										//  be farther away than anything in the scene

//===================================================================

extern int		cachewidth;
extern pixel_t	*cacheblock;
extern int		screenwidth;

extern	float	pixelAspect;

extern int		r_drawnpolycount;

extern int	sintable[MAXWIDTH + CYCLE];
extern int	intsintable[MAXWIDTH + CYCLE];

extern	vec3_t	vup, base_vup;
extern	vec3_t	vpn, base_vpn;
extern	vec3_t	vright, base_vright;

#define NUMSTACKEDGES		2000
#define	MINEDGES			NUMSTACKEDGES
#define NUMSTACKSURFACES	1000
#define MINSURFACES			NUMSTACKSURFACES
#define	MAXSPANS			3000

// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct espan_s {
	int				u, v, count;
	struct espan_s	*pnext;
} espan_t;

// FIXME: compress, make a union if that will help
// insubmodel is only 1, flags is fewer than 32, spanstate could be a byte
typedef struct surf_s {
	struct surf_s	*next;			// active surface stack in r_edge.c
	struct surf_s	*prev;			// used in r_edge.c for active surf stack
	struct espan_s	*spans;			// pointer to linked list of spans to draw
	int			key;				// sorting key (BSP order)
	int			last_u;				// set during tracing
	int			spanstate;			// 0 = not in span
									// 1 = in span
									// -1 = in inverted span (end before start)
	int			flags;				// currentface flags
	void		*data;				// associated data like msurface_t
	entity_t	*entity;
	float		nearzi;				// nearest 1/z on surface, for mipmapping
	qbool	insubmodel;
	float		d_ziorigin, d_zistepu, d_zistepv;

	int			pad[2];				// to 64 bytes
} surf_t;

extern	surf_t	*surfaces, *surface_p, *surf_max;

// surfaces are generated in back to front order by the bsp, so if a surf
// pointer is greater than another one, it should be drawn in front
// surfaces[1] is the background, and is used as the active surface stack.
// surfaces[0] is a dummy, because index 0 is used to indicate no surface
//  attached to an edge_t

//===================================================================

extern vec3_t	sxformaxis[4];	// s axis transformed into viewspace
extern vec3_t	txformaxis[4];	// t axis transformed into viewspac

extern vec3_t	modelorg, base_modelorg;

extern	float	xcenter, ycenter;
extern	float	xscale, yscale;
extern	float	xscaleinv, yscaleinv;
extern	float	xscaleshrink, yscaleshrink;

extern	unsigned int d_lightstylevalue[256]; // 8.8 frac of base light value

extern void TransformVector (vec3_t in, vec3_t out);
extern void SetUpForLineScan(fixed8_t startvertu, fixed8_t startvertv,
	fixed8_t endvertu, fixed8_t endvertv);

extern int	r_skymade;
extern void R_MakeSky (void);

extern int	ubasestep, errorterm, erroradjustup, erroradjustdown;

// flags in finalvert_t.flags
#define ALIAS_LEFT_CLIP				0x0001
#define ALIAS_TOP_CLIP				0x0002
#define ALIAS_RIGHT_CLIP			0x0004
#define ALIAS_BOTTOM_CLIP			0x0008
#define ALIAS_Z_CLIP				0x0010
// !!! if this is changed, it must be changed in d_ifacea.h too !!!
#define ALIAS_ONSEAM				0x0020	// also defined in modelgen.h;
											//  must be kept in sync
#define ALIAS_XY_CLIP_MASK			0x000F

// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct edge_s {
	fixed16_t		u;
	fixed16_t		u_step;
	struct edge_s	*prev, *next;
	unsigned short	surfs[2];
	struct edge_s	*nextremove;
	float			nearzi;
	medge_t			*owner;
} edge_t;

#endif	// _R_SHARED_H_


================================================
FILE: src/r_sprite3d.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// 3D sprites
#include "quakedef.h"
#include "gl_model.h"
#include "r_sprite3d.h"
#include "r_sprite3d_internal.h"
#include "r_state.h"
#include "r_buffers.h"
#include "tr_types.h"
#include "r_renderer.h"
#include "r_texture.h"

int indexes_start_quads, indexes_start_flashblend, indexes_start_sparks;

static const char* batch_type_names[] = {
	"ENTITIES",
	"PARTICLES_CLASSIC",
	"PARTICLES_NEW_p_spark",
	"PARTICLES_NEW_p_smoke",
	"PARTICLES_NEW_p_fire",
	"PARTICLES_NEW_p_bubble",
	"PARTICLES_NEW_p_lavasplash",
	"PARTICLES_NEW_p_gunblast",
	"PARTICLES_NEW_p_chunk",
	"PARTICLES_NEW_p_shockwave",
	"PARTICLES_NEW_p_inferno_flame",
	"PARTICLES_NEW_p_inferno_trail",
	"PARTICLES_NEW_p_sparkray",
	"PARTICLES_NEW_p_staticbubble",
	"PARTICLES_NEW_p_trailpart",
	"PARTICLES_NEW_p_dpsmoke",
	"PARTICLES_NEW_p_dpfire",
	"PARTICLES_NEW_p_teleflare",
	"PARTICLES_NEW_p_blood1",
	"PARTICLES_NEW_p_blood2",
	"PARTICLES_NEW_p_blood3",

	//VULT PARTICLES
	"PARTICLES_NEW_p_rain",
	"PARTICLES_NEW_p_alphatrail",
	"PARTICLES_NEW_p_railtrail",
	"PARTICLES_NEW_p_streak",
	"PARTICLES_NEW_p_streaktrail",
	"PARTICLES_NEW_p_streakwave",
	"PARTICLES_NEW_p_lightningbeam",
	"PARTICLES_NEW_p_vxblood",
	"PARTICLES_NEW_p_lavatrail",
	"PARTICLES_NEW_p_vxsmoke",
	"PARTICLES_NEW_p_vxsmoke_red",
	"PARTICLES_NEW_p_muzzleflash",
	"PARTICLES_NEW_p_inferno",
	"PARTICLES_NEW_p_2dshockwave",
	"PARTICLES_NEW_p_vxrocketsmoke",
	"PARTICLES_NEW_p_trailbleed",
	"PARTICLES_NEW_p_bleedspike",
	"PARTICLES_NEW_p_flame",
	"PARTICLES_NEW_p_bubble2",
	"PARTICLES_NEW_p_bloodcloud",
	"PARTICLES_NEW_p_chunkdir",
	"PARTICLES_NEW_p_smallspark",
	"PARTICLES_NEW_p_slimeglow",
	"PARTICLES_NEW_p_slimebubble",
	"PARTICLES_NEW_p_blacklavasmoke",
	"PARTICLES_NEW_p_entitytrail",
	"PARTICLES_NEW_p_flametorch",
	"FLASHBLEND_LIGHTS",
	"CORONATEX_STANDARD",
	"CORONATEX_GUNFLASH",
	"CORONATEX_EXPLOSIONFLASH1",
	"CORONATEX_EXPLOSIONFLASH2",
	"CORONATEX_EXPLOSIONFLASH3",
	"CORONATEX_EXPLOSIONFLASH4",
	"CORONATEX_EXPLOSIONFLASH5",
	"CORONATEX_EXPLOSIONFLASH6",
	"CORONATEX_EXPLOSIONFLASH7",
	"CHATICON_AFK_CHAT",
	"CHATICON_CHAT",
	"CHATICON_AFK"
};

#ifdef C_ASSERT
C_ASSERT(sizeof(batch_type_names) / sizeof(batch_type_names[0]) == MAX_SPRITE3D_BATCHES);
#endif

r_sprite3d_vert_t verts[MAX_VERTS_PER_SCENE];
gl_sprite3d_batch_t batches[MAX_SPRITE3D_BATCHES];
unsigned int batchMapping[MAX_SPRITE3D_BATCHES];
unsigned int batchCount;
unsigned int vertexCount;
static unsigned int indexData[INDEXES_MAX_QUADS * 4 + INDEXES_MAX_SPARKS * 9 + INDEXES_MAX_FLASHBLEND * 18 + (INDEXES_MAX_QUADS + INDEXES_MAX_SPARKS + INDEXES_MAX_FLASHBLEND) * 3];
static int sprites_in_batch[sprite_vertpool_count];

sprite_vertpool_id batch_to_vertpool[] = {
	sprite_vertpool_game_entities, // SPRITE3D_ENTITIES,
	sprite_vertpool_simple_particles, // SPRITE3D_PARTICLES_CLASSIC,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_spark,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_smoke,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_fire,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_bubble,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_lavasplash,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_gunblast,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_chunk,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_shockwave,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_inferno_flame,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_inferno_trail,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_sparkray,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_staticbubble,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_trailpart,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_dpsmoke,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_dpfire,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_teleflare,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_blood1,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_blood2,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_blood3,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_rain,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_alphatrail,
	sprite_vertpool_game_annotations, // SPRITE3D_PARTICLES_NEW_p_railtrail,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_streak,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_streaktrail,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_streakwave,
	sprite_vertpool_game_annotations, // SPRITE3D_PARTICLES_NEW_p_lightningbeam,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_vxblood,
	sprite_vertpool_qmb_particles_environment, // SPRITE3D_PARTICLES_NEW_p_lavatrail,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_vxsmoke,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_vxsmoke_red,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_muzzleflash,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_inferno,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_2dshockwave,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_vxrocketsmoke,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_trailbleed,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_bleedspike,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_flame,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_bubble2,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_bloodcloud,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_chunkdir,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_smallspark,
	sprite_vertpool_qmb_particles_environment, // SPRITE3D_PARTICLES_NEW_p_slimeglow,
	sprite_vertpool_qmb_particles_environment, // SPRITE3D_PARTICLES_NEW_p_slimebubble,
	sprite_vertpool_qmb_particles_environment, // SPRITE3D_PARTICLES_NEW_p_blacklavasmoke,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_PARTICLES_NEW_p_entitytrail,
	sprite_vertpool_qmb_particles_environment, // SPRITE3D_PARTICLES_NEW_p_flametorch,
	sprite_vertpool_game_annotations, // SPRITE3D_FLASHBLEND_LIGHTS,  (put it here as it's important to gameplay)
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_STANDARD,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_GUNFLASH,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_EXPLOSIONFLASH1,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_EXPLOSIONFLASH2,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_EXPLOSIONFLASH3,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_EXPLOSIONFLASH4,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_EXPLOSIONFLASH5,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_EXPLOSIONFLASH6,
	sprite_vertpool_qmb_particles_normal, // SPRITE3D_CORONATEX_EXPLOSIONFLASH7,
	sprite_vertpool_game_annotations, // SPRITE3D_CHATICON_AFK_CHAT,
	sprite_vertpool_game_annotations, // SPRITE3D_CHATICON_CHAT,
	sprite_vertpool_game_annotations, // SPRITE3D_CHATICON_AFK
};

#ifdef C_ASSERT
C_ASSERT(sizeof(batch_to_vertpool) / sizeof(batch_to_vertpool[0]) == MAX_SPRITE3D_BATCHES);
#endif

static gl_sprite3d_batch_t* BatchForType(sprite3d_batch_id type, qbool allocate)
{
	unsigned int index = batchMapping[type];

	if (index == 0) {
		if (!allocate || batchCount >= sizeof(batches) / sizeof(batches[0])) {
			return NULL;
		}
		batchMapping[type] = index = ++batchCount;
	}

	return &batches[index - 1];
}

void R_Sprite3DInitialiseBatch(sprite3d_batch_id type, r_state_id state, texture_ref texture, int index, r_primitive_id primitive_type)
{
	gl_sprite3d_batch_t* batch = BatchForType(type, true);

	assert(state != r_state_null);

	batch->rendering_state = state;
	batch->texture = texture;
	batch->count = 0;
	batch->primitive_id = primitive_type;
	batch->allSameNumber = true;
	batch->texture_index = index;
	batch->name = batch_type_names[type];
	batch->id = type;
}

r_sprite3d_vert_t* R_Sprite3DAddEntrySpecific(sprite3d_batch_id type, int verts_required, texture_ref texture, int texture_index)
{
	gl_sprite3d_batch_t* batch = BatchForType(type, false);
	int start = vertexCount;
	int sprite_count = sprites_in_batch[batch_to_vertpool[batch->id]];

	if (!batch || sprite_count >= MAX_3DSPRITES_PER_BATCH || (sprite_count + 1) * verts_required >= MAX_VERTS_PER_BATCH) {
		return NULL;
	}
	if (start + verts_required >= MAX_VERTS_PER_SCENE) {
		return NULL;
	}
	batch->firstVertices[batch->count] = start;
	batch->glFirstVertices[batch->count] = start + buffers.BufferOffset(r_buffer_sprite_vertex_data) / sizeof(verts[0]);
	batch->numVertices[batch->count] = verts_required;
	batch->textures[batch->count] = texture;
	batch->textureIndexes[batch->count] = texture_index;

	if (batch->count) {
		batch->allSameNumber &= verts_required == batch->numVertices[0];
	}
	sprites_in_batch[batch_to_vertpool[batch->id]] += 1;
	++batch->count;
	vertexCount += verts_required;
	return &verts[start];
}

r_sprite3d_vert_t* R_Sprite3DAddEntryFixed(sprite3d_batch_id type, int verts_required)
{
	return R_Sprite3DAddEntrySpecific(type, verts_required, null_texture_reference, 0);
}

r_sprite3d_vert_t* R_Sprite3DAddEntry(sprite3d_batch_id type, int verts_required)
{
	return R_Sprite3DAddEntrySpecific(type, verts_required, null_texture_reference, 0);
}

void R_Sprite3DSetVert(r_sprite3d_vert_t* vert, float x, float y, float z, float s, float t, byte color[4], int texture_index)
{
	extern int particletexture_array_index;
	extern float particletexture_array_xpos_tr;
	extern float particletexture_array_ypos_tr;

	vert->color[0] = color[0];
	vert->color[1] = color[1];
	vert->color[2] = color[2];
	vert->color[3] = color[3];
	VectorSet(vert->position, x, y, z);
	if (texture_index < 0) {
		vert->tex[0] = particletexture_array_xpos_tr;
		vert->tex[1] = particletexture_array_ypos_tr;
		vert->tex[2] = particletexture_array_index;
	}
	else {
		vert->tex[0] = s;
		vert->tex[1] = t;
		vert->tex[2] = texture_index;
	}
}

void R_Sprite3DCreateVBO(void)
{
	if (!R_BufferReferenceIsValid(r_buffer_sprite_vertex_data)) {
		buffers.Create(r_buffer_sprite_vertex_data, buffertype_vertex, "sprite3d-vbo", sizeof(verts), verts, bufferusage_once_per_frame);
	}
}

void R_Sprite3DCreateIndexBuffer(void)
{
	if (!R_BufferReferenceIsValid(r_buffer_sprite_index_data)) {
		// Meag: *3 is for case of primitive restart not being supported
		int i, j;
		int pos = 0;
		int vbo_pos;

		indexes_start_quads = pos;
		for (i = 0, vbo_pos = 0; i < INDEXES_MAX_QUADS; ++i) {
			if (i) {
				if (GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
					indexData[pos++] = ~(unsigned int)0;
				}
				else {
					indexData[pos++] = vbo_pos - 1;
					indexData[pos++] = vbo_pos;
				}
			}
			for (j = 0; j < 4; ++j) {
				indexData[pos++] = vbo_pos++;
			}
		}

		// These are currently only supported/used if primitive restart supported, as they're rendered as triangle fans
		indexes_start_flashblend = pos;
		for (i = 0, vbo_pos = 0; i < INDEXES_MAX_FLASHBLEND; ++i) {
			if (i) {
				if (GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
					indexData[pos++] = ~(unsigned int)0;
				}
				else {
					indexData[pos++] = vbo_pos - 1;
					indexData[pos++] = vbo_pos;
				}
			}
			for (j = 0; j < 18; ++j) {
				indexData[pos++] = vbo_pos++;
			}
		}

		// These are currently only supported/used if primitive restart supported, as they're rendered as triangle fans
		indexes_start_sparks = pos;
		for (i = 0, vbo_pos = 0; i < INDEXES_MAX_SPARKS; ++i) {
			if (i) {
				if (GL_Supported(R_SUPPORT_PRIMITIVERESTART)) {
					indexData[pos++] = ~(unsigned int)0;
				}
				else {
					indexData[pos++] = vbo_pos - 1;
					indexData[pos++] = vbo_pos - 1;
					indexData[pos++] = vbo_pos;
				}
			}
			for (j = 0; j < 9; ++j) {
				indexData[pos++] = vbo_pos++;
			}
		}

		buffers.Create(r_buffer_sprite_index_data, buffertype_index, "3dsprite-indexes", sizeof(indexData), indexData, bufferusage_reuse_many_frames);
	}
}

void R_Sprite3DRender(r_sprite3d_vert_t* vert, vec3_t origin, vec3_t up, vec3_t right, float scale_up, float scale_down, float scale_left, float scale_right, float s, float t, int index)
{
	static byte color_white[4] = { 255, 255, 255, 255 };
	vec3_t points[4];


	VectorMA(origin, scale_up, up, points[0]);
	VectorMA(points[0], scale_left, right, points[0]);
	VectorMA(origin, scale_down, up, points[1]);
	VectorMA(points[1], scale_left, right, points[1]);
	VectorMA(origin, scale_up, up, points[2]);
	VectorMA(points[2], scale_right, right, points[2]);
	VectorMA(origin, scale_down, up, points[3]);
	VectorMA(points[3], scale_right, right, points[3]);

	R_Sprite3DSetVert(vert++, points[0][0], points[0][1], points[0][2], 0, 0, color_white, index);
	R_Sprite3DSetVert(vert++, points[1][0], points[1][1], points[1][2], 0, t, color_white, index);
	R_Sprite3DSetVert(vert++, points[2][0], points[2][1], points[2][2], s, 0, color_white, index);
	R_Sprite3DSetVert(vert++, points[3][0], points[3][1], points[3][2], s, t, color_white, index);
}

void R_Sprite3DClearBatches(void)
{
	batchCount = vertexCount = 0;
	memset(batchMapping, 0, sizeof(batchMapping));
	memset(sprites_in_batch, 0, sizeof(sprites_in_batch));
}


================================================
FILE: src/r_sprite3d.h
================================================

#ifndef EZQUAKE_R_SPRITE3D_HEADER
#define EZQUAKE_R_SPRITE3D_HEADER

#include "r_state.h"

// Billboards
typedef enum {
	SPRITE3D_ENTITIES,
	SPRITE3D_PARTICLES_CLASSIC,
	SPRITE3D_PARTICLES_NEW_p_spark,
	SPRITE3D_PARTICLES_NEW_p_smoke,
	SPRITE3D_PARTICLES_NEW_p_fire,
	SPRITE3D_PARTICLES_NEW_p_bubble,
	SPRITE3D_PARTICLES_NEW_p_lavasplash,
	SPRITE3D_PARTICLES_NEW_p_gunblast,
	SPRITE3D_PARTICLES_NEW_p_chunk,
	SPRITE3D_PARTICLES_NEW_p_shockwave,
	SPRITE3D_PARTICLES_NEW_p_inferno_flame,
	SPRITE3D_PARTICLES_NEW_p_inferno_trail,
	SPRITE3D_PARTICLES_NEW_p_sparkray,
	SPRITE3D_PARTICLES_NEW_p_staticbubble,
	SPRITE3D_PARTICLES_NEW_p_trailpart,
	SPRITE3D_PARTICLES_NEW_p_dpsmoke,
	SPRITE3D_PARTICLES_NEW_p_dpfire,
	SPRITE3D_PARTICLES_NEW_p_teleflare,
	SPRITE3D_PARTICLES_NEW_p_blood1,
	SPRITE3D_PARTICLES_NEW_p_blood2,
	SPRITE3D_PARTICLES_NEW_p_blood3,
	//VULT PARTICLES
	SPRITE3D_PARTICLES_NEW_p_rain,
	SPRITE3D_PARTICLES_NEW_p_alphatrail,
	SPRITE3D_PARTICLES_NEW_p_railtrail,
	SPRITE3D_PARTICLES_NEW_p_streak,
	SPRITE3D_PARTICLES_NEW_p_streaktrail,
	SPRITE3D_PARTICLES_NEW_p_streakwave,
	SPRITE3D_PARTICLES_NEW_p_lightningbeam,
	SPRITE3D_PARTICLES_NEW_p_vxblood,
	SPRITE3D_PARTICLES_NEW_p_lavatrail,
	SPRITE3D_PARTICLES_NEW_p_vxsmoke,
	SPRITE3D_PARTICLES_NEW_p_vxsmoke_red,
	SPRITE3D_PARTICLES_NEW_p_muzzleflash,
	SPRITE3D_PARTICLES_NEW_p_inferno,
	SPRITE3D_PARTICLES_NEW_p_2dshockwave,
	SPRITE3D_PARTICLES_NEW_p_vxrocketsmoke,
	SPRITE3D_PARTICLES_NEW_p_trailbleed,
	SPRITE3D_PARTICLES_NEW_p_bleedspike,
	SPRITE3D_PARTICLES_NEW_p_flame,
	SPRITE3D_PARTICLES_NEW_p_bubble2,
	SPRITE3D_PARTICLES_NEW_p_bloodcloud,
	SPRITE3D_PARTICLES_NEW_p_chunkdir,
	SPRITE3D_PARTICLES_NEW_p_smallspark,
	SPRITE3D_PARTICLES_NEW_p_slimeglow,
	SPRITE3D_PARTICLES_NEW_p_slimebubble,
	SPRITE3D_PARTICLES_NEW_p_blacklavasmoke,
	SPRITE3D_PARTICLES_NEW_p_entitytrail,
	SPRITE3D_PARTICLES_NEW_p_flametorch,
	SPRITE3D_FLASHBLEND_LIGHTS,
	SPRITE3D_CORONATEX_STANDARD,
	SPRITE3D_CORONATEX_GUNFLASH,
	SPRITE3D_CORONATEX_EXPLOSIONFLASH1,
	SPRITE3D_CORONATEX_EXPLOSIONFLASH2,
	SPRITE3D_CORONATEX_EXPLOSIONFLASH3,
	SPRITE3D_CORONATEX_EXPLOSIONFLASH4,
	SPRITE3D_CORONATEX_EXPLOSIONFLASH5,
	SPRITE3D_CORONATEX_EXPLOSIONFLASH6,
	SPRITE3D_CORONATEX_EXPLOSIONFLASH7,
	SPRITE3D_CHATICON_AFK_CHAT,
	SPRITE3D_CHATICON_CHAT,
	SPRITE3D_CHATICON_AFK,

	MAX_SPRITE3D_BATCHES
} sprite3d_batch_id;

// Meag: use this as sanity check that any new particles have had batch created
#define SPRITE3D_PARTICLES_NEW_LIMIT (SPRITE3D_FLASHBLEND_LIGHTS)

typedef struct r_sprite3d_vert_s {
	// 0->12
	float position[3];
	// 12->24
	float tex[3];
	// 24->28
	byte color[4];
	// 28->32
	byte padding[4];
} r_sprite3d_vert_t;

typedef enum {
	r_primitive_triangle_strip,
	r_primitive_triangle_fan,
	r_primitive_triangles,

	r_primitive_count
} r_primitive_id;

void R_Sprite3DInitialiseBatch(sprite3d_batch_id type, r_state_id rendering_state, texture_ref texture, int index, r_primitive_id primitive_type);
r_sprite3d_vert_t* R_Sprite3DAddEntry(sprite3d_batch_id type, int verts_required);
r_sprite3d_vert_t* R_Sprite3DAddEntrySpecific(sprite3d_batch_id type, int verts_required, texture_ref texture, int index);
void R_Sprite3DSetVert(r_sprite3d_vert_t* vert, float x, float y, float z, float s, float t, byte color[4], int texture_index);
void R_Sprite3DRender(r_sprite3d_vert_t* vert, vec3_t origin, vec3_t up, vec3_t right, float scale_up, float scale_down, float scale_left, float scale_right, float s, float t, int index);

// Internal for renderers
void R_Sprite3DCreateIndexBuffer(void);
void R_Sprite3DCreateVBO(void);
void R_Sprite3DClearBatches(void);

#endif // EZQUAKE_R_SPRITE3D_HEADER


================================================
FILE: src/r_sprite3d_internal.h
================================================

#ifndef EZQUAKE_GL_SPRITE3D_INTERNAL
#define EZQUAKE_GL_SPRITE3D_INTERNAL

// Internal only
#define MAX_3DSPRITES_PER_BATCH    16384  // Batches limited to this so they can't break other functionality
#define INDEXES_MAX_QUADS            512
#define INDEXES_MAX_FLASHBLEND         8
#define INDEXES_MAX_SPARKS            16

typedef struct gl_sprite3d_batch_s {
	r_state_id rendering_state;
	r_primitive_id primitive_id;
	texture_ref texture;
	int texture_index;
	qbool allSameNumber;

	int firstVertices[MAX_3DSPRITES_PER_BATCH];
	int glFirstVertices[MAX_3DSPRITES_PER_BATCH];
	int numVertices[MAX_3DSPRITES_PER_BATCH];
	texture_ref textures[MAX_3DSPRITES_PER_BATCH];
	int textureIndexes[MAX_3DSPRITES_PER_BATCH];

	const char* name;
	sprite3d_batch_id id;
	unsigned int count;
} gl_sprite3d_batch_t;

typedef enum {
	sprite_vertpool_game_entities,
	sprite_vertpool_game_annotations,
	sprite_vertpool_simple_particles,
	sprite_vertpool_qmb_particles_normal,
	sprite_vertpool_qmb_particles_environment,

	sprite_vertpool_count
} sprite_vertpool_id;

// FIXME: Bit ugly with these externs here
#define MAX_VERTS_PER_BATCH (MAX_3DSPRITES_PER_BATCH * 4)
#define MAX_VERTS_PER_SCENE (MAX_VERTS_PER_BATCH * sprite_vertpool_count)

extern r_sprite3d_vert_t verts[MAX_VERTS_PER_SCENE];
extern gl_sprite3d_batch_t batches[MAX_SPRITE3D_BATCHES];

extern unsigned int batchCount;
extern unsigned int vertexCount;
#endif


================================================
FILE: src/r_sprites.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
// gl_sprites.c 
// taken from gl_model.c -- model loading and caching

// models are the only shared resource between a client and server running on the same machine.

#include "quakedef.h"
#include "gl_model.h"
#include "r_texture.h"

extern model_t* loadmodel;
extern char     loadname[32];   // for hunk tags

//=============================================================================
static texture_ref Mod_LoadExternalSpriteSkin(char *identifier, int framenum)
{
	char loadpath[64];
	int texmode;
	texture_ref texnum;

	texmode = TEX_MIPMAP | TEX_ALPHA | TEX_PREMUL_ALPHA;
	if (!gl_scaleModelTextures.value && !loadmodel->isworldmodel) {
		texmode |= TEX_NOSCALE;
	}

	snprintf (loadpath, sizeof(loadpath), "textures/sprites/%s", identifier);
	texnum = R_LoadTextureImage (loadpath, identifier, 0, 0, texmode);

	if (!R_TextureReferenceIsValid(texnum)) {
		snprintf (loadpath, sizeof(loadpath), "textures/%s", identifier);
		texnum = R_LoadTextureImage (loadpath, identifier, 0, 0, texmode);
	}

	return texnum;
}

void *Mod_LoadSpriteFrame (void * pin, mspriteframe_t **ppframe, int framenum)
{
	dspriteframe_t *pinframe;
	mspriteframe_t *pspriteframe;
	char basename[64], identifier[64];
	int width, height, size, origin[2], texmode;
	texture_ref texnum;

	texmode = TEX_MIPMAP | TEX_ALPHA;
	if (!gl_scaleModelTextures.value && !loadmodel->isworldmodel) {
		texmode |= TEX_NOSCALE;
	}

	COM_StripExtension(COM_SkipPath(loadmodel->name), basename, sizeof(basename));

	pinframe = (dspriteframe_t *) pin;

	width = LittleLong (pinframe->width);
	height = LittleLong (pinframe->height);
	size = width * height;

	pspriteframe = (mspriteframe_t *) Hunk_AllocName (sizeof (mspriteframe_t),loadname);

	memset (pspriteframe, 0, sizeof (mspriteframe_t));

	*ppframe = pspriteframe;

	pspriteframe->width = width;
	pspriteframe->height = height;
	origin[0] = LittleLong (pinframe->origin[0]);
	origin[1] = LittleLong (pinframe->origin[1]);

	pspriteframe->up = origin[1];
	pspriteframe->down = origin[1] - height;
	pspriteframe->left = origin[0];
	pspriteframe->right = width + origin[0];

	snprintf (identifier, sizeof(identifier), "sprites/%s_%i", basename, framenum);
	texnum = Mod_LoadExternalSpriteSkin(identifier, framenum);
	if (!R_TextureReferenceIsValid(texnum) && width > 0 && height > 0) {
		texnum = R_LoadTexture(identifier, width, height, (byte*)(pinframe + 1), texmode, 1);
	}

	pspriteframe->gl_texturenum = texnum;
	pspriteframe->gl_scalingS = 1.0f;
	pspriteframe->gl_scalingT = 1.0f;

	return (void *) ((byte *) pinframe + sizeof (dspriteframe_t) + size);
}

void *Mod_LoadSpriteGroup (void * pin, mspriteframe_t **ppframe, int framenum) {
	dspritegroup_t *pingroup;
	mspritegroup_t *pspritegroup;
	int i, numframes;
	dspriteinterval_t *pin_intervals;
	float *poutintervals;
	void *ptemp;

	pingroup = (dspritegroup_t *) pin;

	numframes = LittleLong (pingroup->numframes);

	if (numframes < 1) {
		Host_Error("Mod_LoadSpriteGroup: numframes < 1");
	}

	pspritegroup = (mspritegroup_t *) Hunk_AllocName (sizeof (mspritegroup_t) +
		(numframes - 1) * sizeof (pspritegroup->frames[0]), loadname);

	pspritegroup->numframes = numframes;

	*ppframe = (mspriteframe_t *) pspritegroup;

	pin_intervals = (dspriteinterval_t *) (pingroup + 1);

	poutintervals = (float *) Hunk_AllocName (numframes * sizeof (float), loadname);

	pspritegroup->intervals = poutintervals;

	for (i = 0; i < numframes; i++) {
		*poutintervals = LittleFloat (pin_intervals->interval);
		if (*poutintervals <= 0.0) {
			Host_Error("Mod_LoadSpriteGroup: interval <= 0");
		}

		poutintervals++;
		pin_intervals++;
	}

	ptemp = (void *) pin_intervals;
	for (i = 0; i < numframes; i++) {
		ptemp = Mod_LoadSpriteFrame(ptemp, &pspritegroup->frames[i], framenum * 100 + i);
	}

	return ptemp;
}

void Mod_LoadSpriteModel (model_t *mod, void *buffer)
{
	int i, j, version, numframes, size, start, offset, sztmp;
	dsprite_t *pin;
	msprite_t *psprite;
	dspriteframetype_t *pframetype;

	msprite2_t *psprite2;


	// remember point
	start = Hunk_LowMark ();


	pin = (dsprite_t *)buffer;

	version = LittleLong (pin->version);

	if (version != SPRITE_VERSION) {
		Host_Error ("Mod_LoadSpriteModel: %s has wrong version number (%i should be %i)", mod->name, version, SPRITE_VERSION);
		return;
	}

	numframes = LittleLong (pin->numframes);

	size = sizeof (msprite_t) +	(numframes - 1) * sizeof (psprite->frames);

	psprite = (msprite_t *) Hunk_AllocName (size, loadname);

	psprite->type = LittleLong (pin->type);
	psprite->maxwidth = LittleLong (pin->width);
	psprite->maxheight = LittleLong (pin->height);
	psprite->beamlength = LittleFloat (pin->beamlength);
	mod->synctype = LittleLong (pin->synctype);
	psprite->numframes = numframes;

	mod->mins[0] = mod->mins[1] = -psprite->maxwidth/2;
	mod->maxs[0] = mod->maxs[1] = psprite->maxwidth/2;
	mod->mins[2] = -psprite->maxheight/2;
	mod->maxs[2] = psprite->maxheight/2;

	// load the frames
	if (numframes < 1 || numframes > MAX_SPRITE_FRAMES)
		Host_Error ("Mod_LoadSpriteModel: Invalid # of frames: %d\n", numframes);

	mod->numframes = numframes;

	pframetype = (dspriteframetype_t *)(pin + 1);

	size = sizeof(msprite2_t);

	for (i = 0; i < numframes; i++) {
		spriteframetype_t	frametype;

		frametype = LittleLong (pframetype->type);
		psprite->frames[i].type = frametype;

		if (frametype == SPR_SINGLE) {
			pframetype = (dspriteframetype_t *)	Mod_LoadSpriteFrame (pframetype + 1, &psprite->frames[i].frameptr, i);
			size += (int)sizeof(mspriteframe_t);
		} else {
			pframetype = (dspriteframetype_t *)	Mod_LoadSpriteGroup (pframetype + 1, &psprite->frames[i].frameptr, i);
			size += (((mspritegroup_t*)(psprite->frames[i].frameptr))->numframes) * (int)sizeof(mspriteframe2_t);
		}
	}

	psprite2 = Q_malloc(size); // !!!!!!! Q_free

	psprite2->type		= psprite->type;
	psprite2->maxwidth	= psprite->maxwidth;
	psprite2->maxheight	= psprite->maxheight;
	psprite2->numframes	= psprite->numframes;

	for (i = 0, offset = sizeof(msprite2_t); i < numframes; i++) {
		psprite2->frames[i].type   = psprite->frames[i].type;
		psprite2->frames[i].offset = offset;

		if (psprite2->frames[i].type == SPR_SINGLE) {
			psprite2->frames[i].numframes = 1; // always one

			sztmp = (int)sizeof(mspriteframe_t);
			if (offset + sztmp > size)
				Sys_Error("Mod_LoadSpriteModel: internal error");

			memcpy((byte*)(psprite2) + offset, psprite->frames[i].frameptr, sztmp);
			offset += sztmp;
		}
		else {
			psprite2->frames[i].numframes = ((mspritegroup_t*)(psprite->frames[i].frameptr))->numframes;

			for (j = 0; j < psprite2->frames[i].numframes; j++) {
				mspriteframe2_t spr;

				sztmp = (int)sizeof(mspriteframe2_t);
				if (offset + sztmp > size)
					Sys_Error("Mod_LoadSpriteModel: internal error");

				memset(&spr, 0, sizeof(spr));
				spr.frame    = *(((mspritegroup_t*)(psprite->frames[i].frameptr))->frames[j]); // copy whole struct
				spr.interval =   ((mspritegroup_t*)(psprite->frames[i].frameptr))->intervals[j];
				memcpy((byte*)(psprite2) + offset, &spr, sztmp);
				offset += sztmp;
			}
		}
	}

	mod->type = mod_sprite;

	// move the complete, relocatable model to the cache
	mod->cached_data = Q_malloc(size);
	if (mod->cached_data) {
		memcpy(mod->cached_data, psprite2, size);
	}

	Q_free(psprite2);
	Hunk_FreeToLowMark(start);
}

mspriteframe_t *R_GetSpriteFrame(entity_t *e, msprite2_t *psprite)
{
	mspriteframe_t  *pspriteframe;
	mspriteframe2_t *pspriteframe2;
	int i, numframes, frame, offset;
	float fullinterval, targettime, time;

	frame = e->frame;

	if (frame >= psprite->numframes || frame < 0) {
		Com_DPrintf ("R_GetSpriteFrame: no such frame %d (model %s)\n", frame, e->model->name);
		return NULL;
	}

	offset    = psprite->frames[frame].offset;
	numframes = psprite->frames[frame].numframes;

	if (offset < (int)sizeof(msprite2_t) || numframes < 1) {
		Com_Printf ("R_GetSpriteFrame: wrong sprite\n");
		return NULL;
	}

	if (psprite->frames[frame].type == SPR_SINGLE) {
		pspriteframe  = (mspriteframe_t* )((byte*)psprite + offset);
	}
	else {
		pspriteframe2 = (mspriteframe2_t*)((byte*)psprite + offset);

		fullinterval = pspriteframe2[numframes-1].interval;

		time = r_refdef2.time;

		// when loading in Mod_LoadSpriteGroup, we guaranteed all interval values
		// are positive, so we don't have to worry about division by 0
		targettime = time - ((int) (time / fullinterval)) * fullinterval;

		for (i = 0; i < (numframes - 1); i++) {
			if (pspriteframe2[i].interval > targettime) {
				break;
			}
		}

		pspriteframe = &pspriteframe2[i].frame;
	}

	return pspriteframe;
}


================================================
FILE: src/r_state.h
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_R_STATE_HEADER
#define EZQUAKE_R_STATE_HEADER

#include "r_local.h"
#include "r_vao.h"

#define MAX_GLC_TEXTURE_UNIT_STATES    4
#define MAX_GLC_ATTRIBUTES            16

// rendering state
typedef enum {
	r_depthfunc_less,
	r_depthfunc_equal,
	r_depthfunc_lessorequal,
	r_depthfunc_count
} r_depthfunc_t;

typedef enum {
	r_cullface_front,
	r_cullface_back,

	r_cullface_count
} r_cullface_t;

typedef enum {
	r_blendfunc_overwrite,
	r_blendfunc_additive_blending,
	r_blendfunc_premultiplied_alpha,
	r_blendfunc_src_dst_color_dest_zero,
	r_blendfunc_src_dst_color_dest_one,
	r_blendfunc_src_dst_color_dest_src_color,
	r_blendfunc_src_zero_dest_one_minus_src_color,
	r_blendfunc_src_zero_dest_src_color,
	r_blendfunc_src_one_dest_zero,
	r_blendfunc_src_zero_dest_one,
	r_blendfunc_src_one_dest_one_minus_src_color,

	r_blendfunc_count
} r_blendfunc_t;

typedef enum {
	r_polygonmode_fill,
	r_polygonmode_line,

	r_polygonmode_count
} r_polygonmode_t;

typedef enum {
	r_polygonoffset_disabled,
	r_polygonoffset_standard,
	r_polygonoffset_outlines,

	r_polygonoffset_count
} r_polygonoffset_t;

typedef enum {
	r_alphatest_func_always,
	r_alphatest_func_greater,

	r_alphatest_func_count
} r_alphatest_func_t;

typedef enum {
	r_texunit_mode_blend,
	r_texunit_mode_replace,
	r_texunit_mode_modulate,
	r_texunit_mode_decal,
	r_texunit_mode_add,

	r_texunit_mode_count
} r_texunit_mode_t;

typedef enum {
	r_fogmode_disabled,
	r_fogmode_enabled,

	r_fogmode_count
} r_fogmode_t;

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
typedef struct glc_vertex_array_element_s {
	qbool enabled;

	r_buffer_id buf;
	int size;
	unsigned int type;
	int stride;
	void* pointer_or_offset;
} glc_vertex_array_element_t;

typedef struct glc_attribute_s {
	qbool enabled;

	int location;
} glc_attribute_t;
#endif

typedef struct rendering_state_s {
	struct {
		r_depthfunc_t func;
		double nearRange;
		double farRange;
		qbool test_enabled;
		qbool mask_enabled;
	} depth;

	// FIXME: currentWidth & currentHeight should be initialised to dimensions of window
	int currentViewportX, currentViewportY;
	int currentViewportWidth, currentViewportHeight;

	int fullScreenViewportX, fullScreenViewportY;
	int fullScreenViewportWidth, fullScreenViewportHeight;

	qbool framebuffer_srgb;

	struct {
		qbool smooth;
		float width;
		qbool flexible_width;
	} line;

	struct {
		r_fogmode_t mode;
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
		float color[4];
		float density;
		fogcalc_t calculation;
		float start;
		float end;
#endif
	} fog;

	struct {
		r_cullface_t mode;
		qbool enabled;
	} cullface;

	r_blendfunc_t blendFunc;

	struct {
		r_polygonoffset_t option;
		float factor;
		float units;
		qbool fillEnabled;
		qbool lineEnabled;
	} polygonOffset;

	r_polygonmode_t polygonMode;
	float clearColor[4];
	float color[4];
	qbool blendingEnabled;
	qbool colorMask[4];

	r_vao_id vao_id;

	// GLC only...
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	struct {
		qbool enabled;
		r_alphatest_func_t func;
		float value;
	} alphaTesting;

	struct {
		qbool enabled;
		r_texunit_mode_t mode;

		glc_vertex_array_element_t va;
	} textureUnits[MAX_GLC_TEXTURE_UNIT_STATES];

	qbool colorValid;

	glc_vertex_array_element_t vertex_array;
	glc_vertex_array_element_t color_array;
	glc_vertex_array_element_t normal_array;
#endif

	// always false if not classic
	qbool glc_vao_force_rebind;

	// misc (texture downloads, screenshots & atlas building)
	int pack_alignment;

	// meta
	qbool initialized;
	char name[32];
} rendering_state_t;

typedef enum {
	r_state_null,

	r_state_default_opengl,

	r_state_default_3d,
	r_state_sprites_textured,

	r_state_default_2d,
	r_state_brighten_screen,
	r_state_line,
	r_state_hud_images_glc,
	r_state_hud_images_glc_non_glsl,
	r_state_hud_images_alphatested_glc,
	r_state_hud_images_alphatested_glc_non_glsl,
	r_state_poly_blend,
	r_state_hud_images_glm,
	r_state_hud_polygons_glm,

	r_state_sky_fast,
	r_state_skydome_background_pass,
	r_state_skydome_cloud_pass,
	r_state_skydome_single_pass,
	r_state_skydome_single_pass_program,
	r_state_skydome_zbuffer_pass,
	r_state_skydome_zbuffer_pass_fogged,
	r_state_skybox,

	r_state_sky_fast_bmodel,
	r_state_skydome_single_pass_bmodel,
	r_state_skydome_cloud_pass_bmodel,
	r_state_skydome_background_pass_bmodel,

	r_state_world_texture_chain,
	r_state_world_texture_chain_fullbright,
	r_state_world_blend_lightmaps,
	r_state_world_caustics,

	r_state_world_fast_opaque_water,
	r_state_world_fast_translucent_water,
	r_state_world_opaque_water,
	r_state_world_translucent_water,
	r_state_world_alpha_surfaces,
	r_state_world_fullbrights,
	r_state_world_lumas,
	r_state_world_details,
	r_state_world_outline,

	r_state_world_singletexture_glc,
	r_state_world_material_lightmap,
	r_state_world_material_lightmap_luma,
	r_state_world_material_lightmap_fb,
	r_state_world_material_fb_lightmap,
	r_state_world_material_luma_lightmap,

	r_state_alpha_surfaces_offset_glm,
	r_state_opaque_surfaces_offset_glm,
	r_state_alpha_surfaces_glm,
	r_state_opaque_surfaces_glm,

	r_state_aliasmodel_caustics,

	r_state_aliasmodel_powerupshell,
	r_state_weaponmodel_powerupshell,

	// meag: no multitexture_additive: multitex currently only for .mdl files, additive only for .md3
	r_state_aliasmodel_notexture_opaque,
	r_state_aliasmodel_notexture_transparent,
	r_state_aliasmodel_notexture_additive,
	r_state_aliasmodel_singletexture_opaque,
	r_state_aliasmodel_singletexture_transparent,
	r_state_aliasmodel_singletexture_additive,
	r_state_aliasmodel_multitexture_opaque,
	r_state_aliasmodel_multitexture_transparent,
	r_state_aliasmodel_transparent_zpass,
	r_state_weaponmodel_singletexture_opaque,
	r_state_weaponmodel_singletexture_transparent,
	r_state_weaponmodel_singletexture_additive,
	r_state_weaponmodel_multitexture_opaque,
	r_state_weaponmodel_multitexture_transparent,
	r_state_weaponmodel_transparent_zpass,

	r_state_aliasmodel_shadows,
	r_state_aliasmodel_outline,
	r_state_aliasmodel_outline_spec,
	r_state_weaponmodel_outline,

	r_state_aliasmodel_opaque_batch,
	r_state_aliasmodel_translucent_batch,
	r_state_aliasmodel_translucent_batch_zpass,

	r_state_aliasmodel_additive_batch,

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	r_state_postprocess_bloom1,
	r_state_postprocess_bloom2,
	r_state_postprocess_bloom_darkenpass,
	r_state_postprocess_bloom_blurpass,
	r_state_postprocess_bloom_downsample,
	r_state_postprocess_bloom_downsample_blend,
	r_state_postprocess_bloom_restore,
	r_state_postprocess_bloom_draweffect,
#endif

	r_state_light_bubble,
	r_state_chaticon,
	r_state_particles_classic,
	r_state_particles_qmb_textured_blood,
	r_state_particles_qmb_textured,
	r_state_particles_qmb_untextured,
	r_state_coronas,

	r_state_drawflat_with_lightmaps_glc,
	r_state_drawflat_without_lightmaps_glc,
	r_state_drawflat_without_lightmaps_unfogged_glc,

	r_state_fx_world_geometry,

	r_state_count
} r_state_id;

rendering_state_t* R_InitRenderingState(r_state_id id, qbool default_state, const char* name, r_vao_id vao);
rendering_state_t* R_CopyRenderingState(r_state_id id, r_state_id original_id, const char* name);
rendering_state_t* R_Init3DSpriteRenderingState(r_state_id id, const char* name);
void R_ApplyRenderingState(r_state_id id);
void R_BufferInvalidateBoundState(r_buffer_id ref);

void R_CustomColor(float r, float g, float b, float a);
void R_CustomColor4ubv(const byte* color);
void R_CustomLineWidth(float width);
void R_EnableScissorTest(int x, int y, int width, int height);
void R_DisableScissorTest(void);
void R_ClearColor(float r, float g, float b, float a);
void R_CustomPolygonOffset(r_polygonoffset_t mode);

void R_Hud_Initialise(void);

void R_Viewport(int x, int y, int width, int height);
void R_SetFullScreenViewport(int x, int y, int width, int height);
void R_GetFullScreenViewport(int* viewport);

#endif // EZQUAKE_R_STATE_HEADER


================================================
FILE: src/r_states.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// gl_state_resets.c
// moving state init/reset to here with intention of getting rid of all resets

#include "quakedef.h"
#include "gl_model.h"
#include "r_state.h"
#include "r_trace.h"
#include "r_matrix.h"
#include "glc_matrix.h"
#include "glc_state.h"
#include "tr_types.h"

static void R_InitialiseWorldStates(void)
{
	rendering_state_t* state;

	state = R_InitRenderingState(r_state_world_texture_chain, true, "worldTextureChainState", vao_brushmodel);
	state->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);
	R_GLC_TextureUnitSet(state, 1, true, r_texunit_mode_blend);

	state = R_InitRenderingState(r_state_world_texture_chain_fullbright, true, "worldTextureChainFullbrightState", vao_brushmodel);
	state->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);

	state = R_InitRenderingState(r_state_world_blend_lightmaps, true, "blendLightmapState", vao_brushmodel_lightmap_pass);
	state->depth.mask_enabled = false;
	state->depth.func = r_depthfunc_equal;
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_src_zero_dest_one_minus_src_color;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);

	state = R_InitRenderingState(r_state_world_caustics, true, "causticsState", vao_brushmodel_simpletex);
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_decal);
	state->blendFunc = r_blendfunc_src_dst_color_dest_src_color;
	state->blendingEnabled = true;

	state = R_InitRenderingState(r_state_aliasmodel_caustics, true, "aliasModelCausticsState", vao_aliasmodel);
	state->blendFunc = r_blendfunc_src_dst_color_dest_src_color;
	state->blendingEnabled = true;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);
	R_GLC_TextureUnitSet(state, 1, true, r_texunit_mode_decal);

	state = R_InitRenderingState(r_state_world_fast_opaque_water, true, "fastWaterSurfacesState", vao_brushmodel_simpletex);
	state->depth.test_enabled = true;
	state->fog.mode = r_fogmode_enabled;

	state = R_CopyRenderingState(r_state_world_opaque_water, r_state_world_fast_opaque_water, "waterSurfacesState");
	state->cullface.enabled = false;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);

	state = R_CopyRenderingState(r_state_world_translucent_water, r_state_world_fast_opaque_water, "translucentWaterSurfacesState");
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->blendingEnabled = true;
	state->depth.mask_enabled = false; // FIXME: water-alpha < 0.9 only?
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	state = R_CopyRenderingState(r_state_world_fast_translucent_water, r_state_world_translucent_water, "translucentFastWater");
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->blendingEnabled = true;
	R_GLC_TextureUnitSet(state, 0, false, r_texunit_mode_replace);

	state = R_InitRenderingState(r_state_world_alpha_surfaces, true, "alphaChainState", vao_brushmodel);
	R_GLC_ConfigureAlphaTesting(state, true, r_alphatest_func_greater, 0.333f);
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);
	if (glConfig.texture_units >= 2) {
		R_GLC_TextureUnitSet(state, 1, true, r_texunit_mode_blend); // modulate if !inv_lmaps
	}

	state = R_InitRenderingState(r_state_world_fullbrights, true, "fullbrightsState", vao_brushmodel);
	state->depth.mask_enabled = false;
	R_GLC_EnableAlphaTesting(state);
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);

	state = R_InitRenderingState(r_state_world_lumas, true, "lumasState", vao_brushmodel);
	state->depth.mask_enabled = false;
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_additive_blending;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);

	state = R_InitRenderingState(r_state_world_details, true, "detailPolyState", vao_brushmodel_details);
	state->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_decal);
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_src_dst_color_dest_src_color;

	state = R_InitRenderingState(r_state_world_outline, true, "mapOutlineState", vao_brushmodel);
	state->polygonOffset.option = r_polygonoffset_outlines;
	state->polygonMode = r_polygonmode_line;
	state->depth.mask_enabled = false;
	state->depth.test_enabled = false;
	state->cullface.enabled = false;
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;

	state = R_InitRenderingState(r_state_alpha_surfaces_offset_glm, true, "glmAlphaOffsetWorldState", vao_brushmodel);
	state->polygonOffset.option = r_polygonoffset_standard;
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;

	state = R_InitRenderingState(r_state_opaque_surfaces_offset_glm, true, "glmOffsetWorldState", vao_brushmodel);
	state->polygonOffset.option = r_polygonoffset_standard;

	state = R_InitRenderingState(r_state_alpha_surfaces_glm, true, "glmAlphaWorldState", vao_brushmodel);
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->polygonOffset.option = r_polygonoffset_standard;

	R_InitRenderingState(r_state_opaque_surfaces_glm, true, "glmWorldState", vao_brushmodel);
}

static void R_Initialise2DStates(void)
{
	rendering_state_t* state;
	r_vao_id postprocess_vao = R_UseImmediateOpenGL() ? vao_none : vao_postprocess;

	state = R_InitRenderingState(r_state_default_2d, true, "default2DState", postprocess_vao);
	state->depth.test_enabled = false;
	state->cullface.enabled = false;

	state = R_InitRenderingState(r_state_brighten_screen, true, "brightenScreenState", postprocess_vao);
	state->depth.test_enabled = false;
	state->cullface.enabled = false;
	R_GLC_EnableAlphaTesting(state); // really?
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_src_dst_color_dest_one;

	state = R_InitRenderingState(r_state_line, true, "lineState", vao_hud_lines);
	state->depth.test_enabled = false;
	state->cullface.enabled = false;
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->line.flexible_width = true;

	if (R_UseImmediateOpenGL()) {
		state->vao_id = vao_none;
	}

	state = R_InitRenderingState(r_state_hud_images_glc, true, "glcImageDrawState", vao_hud_images);
	state->depth.test_enabled = false;
	state->cullface.enabled = false;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;

	state = R_CopyRenderingState(r_state_hud_images_alphatested_glc, r_state_hud_images_glc, "glcAlphaTestedImageDrawState");
	R_GLC_EnableAlphaTesting(state);

	state = R_CopyRenderingState(r_state_hud_images_glc_non_glsl, r_state_hud_images_glc, "glcImageDrawStateNonGLSL");
	state->vao_id = vao_hud_images_non_glsl;

	state = R_CopyRenderingState(r_state_hud_images_alphatested_glc_non_glsl, r_state_hud_images_alphatested_glc, "glcAlphaTestedImageDrawStateNonGLSL");
	state->vao_id = vao_hud_images_non_glsl;

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	state = R_InitRenderingState(r_state_postprocess_bloom1, true, "glcBloomState", postprocess_vao);
	state->depth.test_enabled = false;
	state->cullface.enabled = false;
	R_GLC_EnableAlphaTesting(state);
	state->blendingEnabled = false;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);

	state = R_CopyRenderingState(r_state_postprocess_bloom_darkenpass, r_state_postprocess_bloom1, "glcBloomState-darken");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_src_dst_color_dest_zero;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	state = R_CopyRenderingState(r_state_postprocess_bloom_blurpass, r_state_postprocess_bloom1, "glcBloomState-blur");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_src_one_dest_one_minus_src_color;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	state = R_CopyRenderingState(r_state_postprocess_bloom_downsample, r_state_postprocess_bloom1, "glcBloomState-downsamp");

	state = R_CopyRenderingState(r_state_postprocess_bloom_downsample_blend, r_state_postprocess_bloom1, "glcBloomState-downsamp-blend");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_additive_blending;

	state = R_CopyRenderingState(r_state_postprocess_bloom_restore, r_state_postprocess_bloom1, "glcBloomState-restore");

	state = R_CopyRenderingState(r_state_postprocess_bloom_draweffect, r_state_postprocess_bloom1, "glcBloomState-restore");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_additive_blending;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);
#endif

	state = R_InitRenderingState(r_state_poly_blend, true, "polyBlendState", postprocess_vao);
	state->depth.test_enabled = false;
	state->cullface.enabled = false;
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;

	state = R_InitRenderingState(r_state_hud_images_glm, true, "glmImageDrawState", vao_hud_images);
	state->depth.test_enabled = false;
	state->cullface.enabled = false;
	R_GLC_DisableAlphaTesting(state);
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;

	state = R_CopyRenderingState(r_state_hud_polygons_glm, r_state_hud_images_glm, "glmPolygonDrawState");
	state->vao_id = vao_hud_polygons;

	state = R_InitRenderingState(r_state_fx_world_geometry, true, "r_state_fx_world_geometry", postprocess_vao);
	state->depth.test_enabled = false;
	state->depth.mask_enabled = false;
	state->cullface.enabled = false;
	R_GLC_EnableAlphaTesting(state); // really?
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
}

static void R_InitialiseSpriteStates(void)
{
	rendering_state_t* state;

	// Simple items
	state = R_Init3DSpriteRenderingState(r_state_sprites_textured, "sprite_entity_state");
	R_GLC_ConfigureAlphaTesting(state, true, r_alphatest_func_greater, 0.333f);
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_replace);

	// Standard particles
	state = R_Init3DSpriteRenderingState(r_state_particles_classic, "particle_state");
	state->depth.mask_enabled = false;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	// QMB particles
	state = R_Init3DSpriteRenderingState(r_state_particles_qmb_textured_blood, "qmb-textured-blood");
	state->blendFunc = r_blendfunc_src_zero_dest_one_minus_src_color;
	state->depth.mask_enabled = false;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	state = R_Init3DSpriteRenderingState(r_state_particles_qmb_textured, "qmb-textured");
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->depth.mask_enabled = false;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	state = R_Init3DSpriteRenderingState(r_state_particles_qmb_untextured, "qmb-untextured");
	state->depth.mask_enabled = false;

	// Flashblend bubbles
	state = R_Init3DSpriteRenderingState(r_state_light_bubble, "bubble-state");
	state->depth.test_enabled = true;
	state->depth.mask_enabled = false;

	// Chaticons
	state = R_Init3DSpriteRenderingState(r_state_chaticon, "chaticon_state");
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	// Coronas
	state = R_Init3DSpriteRenderingState(r_state_coronas, "coronaState");
	state->blendFunc = r_blendfunc_additive_blending;
	state->depth.mask_enabled = false;
	state->depth.test_enabled = false;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);
}

static void R_InitialiseEntityStates(void)
{
	rendering_state_t* state;

	state = R_InitRenderingState(r_state_aliasmodel_powerupshell, true, "powerupShellState", vao_aliasmodel);
	state->fog.mode = r_fogmode_enabled;
	state->cullface.enabled = true;
	state->cullface.mode = r_cullface_front;
	R_GLC_DisableAlphaTesting(state);
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_additive_blending;
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	state = R_CopyRenderingState(r_state_aliasmodel_outline, r_state_aliasmodel_powerupshell, "aliasmodel-outline");
	state->fog.mode = r_fogmode_enabled;
	state->blendingEnabled = false;
	state->cullface.mode = r_cullface_back;

	state = R_CopyRenderingState(r_state_aliasmodel_outline_spec, r_state_aliasmodel_outline, "aliasmodel-outline-spec");
	state->cullface.mode = r_cullface_front;
	state->depth.test_enabled = false;

	state = R_CopyRenderingState(r_state_weaponmodel_outline, r_state_aliasmodel_outline, "weaponmodel-outline");
	state->depth.farRange = R_UseImmediateOpenGL() ? 0.3f : state->depth.farRange;

	state = R_CopyRenderingState(r_state_weaponmodel_powerupshell, r_state_aliasmodel_powerupshell, "weaponmodel-shell");
	state->depth.farRange = R_UseImmediateOpenGL() ? 0.3f : state->depth.farRange;

	state = R_InitRenderingState(r_state_aliasmodel_notexture_opaque, true, "opaqueAliasModelNoTexture", vao_aliasmodel);
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->blendingEnabled = false;
	R_GLC_DisableAlphaTesting(state);
	state->polygonOffset.option = r_polygonoffset_disabled;
	state->cullface.enabled = true;
	state->cullface.mode = r_cullface_front;
	state->polygonMode = r_polygonmode_fill;
	state->line.smooth = false;
	state->fog.mode = r_fogmode_enabled;

	state = R_CopyRenderingState(r_state_aliasmodel_transparent_zpass, r_state_aliasmodel_notexture_opaque, "aliasModelZPass");
	state->colorMask[0] = state->colorMask[1] = state->colorMask[2] = state->colorMask[3] = false;

	state = R_CopyRenderingState(r_state_aliasmodel_singletexture_opaque, r_state_aliasmodel_notexture_opaque, "opaqueAliasModelSingleTex");
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);

	state = R_CopyRenderingState(r_state_aliasmodel_multitexture_opaque, r_state_aliasmodel_notexture_opaque, "opaqueAliasModelMultiTex");
	R_GLC_TextureUnitSet(state, 0, true, r_texunit_mode_modulate);
	R_GLC_TextureUnitSet(state, 1, true, r_texunit_mode_decal);

	// transparent
	state = R_CopyRenderingState(r_state_aliasmodel_notexture_transparent, r_state_aliasmodel_notexture_opaque, "transparentAliasModelNoTex");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state = R_CopyRenderingState(r_state_aliasmodel_singletexture_transparent, r_state_aliasmodel_singletexture_opaque, "transparentAliasModelSingleTex");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state = R_CopyRenderingState(r_state_aliasmodel_multitexture_transparent, r_state_aliasmodel_multitexture_opaque, "transparentAliasModelMultiTex");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;

	// additive
	state = R_CopyRenderingState(r_state_aliasmodel_notexture_additive, r_state_aliasmodel_notexture_opaque, "additiveAliasModelNoTex");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_additive_blending;
	state = R_CopyRenderingState(r_state_aliasmodel_singletexture_additive, r_state_aliasmodel_singletexture_opaque, "additiveAliasModelSingleTex");
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_additive_blending;

	state = R_CopyRenderingState(r_state_weaponmodel_singletexture_opaque, r_state_aliasmodel_singletexture_opaque, "weaponModelSingleOpaque");
	state->depth.farRange = R_UseImmediateOpenGL() ? 0.3f : state->depth.farRange;
	state = R_CopyRenderingState(r_state_weaponmodel_multitexture_opaque, r_state_weaponmodel_singletexture_opaque, "weaponModelMultiOpaque");
	state->depth.farRange = R_UseImmediateOpenGL() ? 0.3f : state->depth.farRange;

	// transparent
	state = R_CopyRenderingState(r_state_weaponmodel_singletexture_transparent, r_state_aliasmodel_singletexture_transparent, "weaponModelSingleTransparent");
	state->depth.farRange = R_UseImmediateOpenGL() ? 0.3f : state->depth.farRange;
	state = R_CopyRenderingState(r_state_weaponmodel_multitexture_transparent, r_state_weaponmodel_singletexture_transparent, "weaponModelMultiTransparent");
	state->depth.farRange = R_UseImmediateOpenGL() ? 0.3f : state->depth.farRange;
	state = R_CopyRenderingState(r_state_weaponmodel_transparent_zpass, r_state_weaponmodel_singletexture_transparent, "weaponModelZPass");
	R_GLC_TextureUnitSet(state, 0, false, r_texunit_mode_replace);
	state->colorMask[0] = state->colorMask[1] = state->colorMask[2] = state->colorMask[3] = false;

	// additive
	state = R_CopyRenderingState(r_state_weaponmodel_singletexture_additive, r_state_aliasmodel_singletexture_additive, "weaponModelSingleAdditive");
	state->depth.farRange = R_UseImmediateOpenGL() ? 0.3f : state->depth.farRange;

	state = R_InitRenderingState(r_state_aliasmodel_shadows, true, "aliasModelShadowState", vao_aliasmodel);
	state->polygonOffset.option = r_polygonoffset_disabled;
	state->cullface.enabled = true;
	state->cullface.mode = r_cullface_front;
	state->polygonMode = r_polygonmode_fill;
	state->line.smooth = false;
	state->fog.mode = r_fogmode_enabled;
	R_GLC_DisableAlphaTesting(state);
	state->blendingEnabled = true;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->color[0] = state->color[1] = state->color[2] = 0;
	state->color[3] = 0.5f;

	state = R_InitRenderingState(r_state_aliasmodel_opaque_batch, true, "aliasModelBatchState", vao_aliasmodel);
	state->cullface.mode = r_cullface_front;
	state->cullface.enabled = true;
	state->depth.mask_enabled = true;
	state->depth.test_enabled = true;
	state->blendingEnabled = false;

	state = R_CopyRenderingState(r_state_aliasmodel_translucent_batch, r_state_aliasmodel_opaque_batch, "aliasModelTranslucentBatchState");
	state->depth.mask_enabled = false;
	state->blendFunc = r_blendfunc_premultiplied_alpha;
	state->blendingEnabled = true;

	state = R_CopyRenderingState(r_state_aliasmodel_translucent_batch_zpass, r_state_aliasmodel_opaque_batch, "aliasModelTranslucentBatchZPass");
	state->colorMask[0] = state->colorMask[1] = state->colorMask[2] = state->colorMask[3] = false;

	state = R_CopyRenderingState(r_state_aliasmodel_additive_batch, r_state_aliasmodel_opaque_batch, "aliasModelTranslucentBatchState");
	state->blendFunc = r_blendfunc_additive_blending;
	state->blendingEnabled = true;
}

static void R_InitialiseBrushModelStates(void)
{
	rendering_state_t* current;

	current = R_InitRenderingState(r_state_drawflat_without_lightmaps_glc, true, "drawFlatNoLightmapState", vao_brushmodel);
	current->fog.mode = r_fogmode_enabled;

	current = R_InitRenderingState(r_state_drawflat_without_lightmaps_unfogged_glc, true, "drawFlatNoLightmapStateUnfogged", vao_brushmodel);
	current->fog.mode = r_fogmode_disabled;

	current = R_InitRenderingState(r_state_drawflat_with_lightmaps_glc, true, "drawFlatLightmapState", vao_brushmodel_lightmap_pass);
	current->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(current, 0, true, r_texunit_mode_blend);

	// Single-texture: all of these are the same so we don't need to bother about others
	current = R_InitRenderingState(r_state_world_singletexture_glc, true, "world:singletex", vao_brushmodel);
	current->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(current, 0, true, r_texunit_mode_replace);

	// material * lightmap
	current = R_InitRenderingState(r_state_world_material_lightmap, true, "r_state_world_material_lightmap", vao_brushmodel_lm_unit1);
	current->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(current, 0, true, r_texunit_mode_replace);
	R_GLC_TextureUnitSet(current, 1, glConfig.texture_units >= 2, r_texunit_mode_blend);

	// material * lightmap + luma
	current = R_InitRenderingState(r_state_world_material_lightmap_luma, true, "r_state_world_material_lightmap_luma", vao_brushmodel_lm_unit1);
	current->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(current, 0, true, r_texunit_mode_replace);
	R_GLC_TextureUnitSet(current, 1, glConfig.texture_units >= 2, r_texunit_mode_blend);
	R_GLC_TextureUnitSet(current, 2, glConfig.texture_units >= 3, r_texunit_mode_add);

	// r_state_world_material_lightmap_fb
	current = R_CopyRenderingState(r_state_world_material_lightmap_fb, r_state_world_material_lightmap_luma, "r_state_world_material_lightmap_fb");
	R_GLC_TextureUnitSet(current, 2, glConfig.texture_units >= 3, r_texunit_mode_decal);

	// no fullbrights, 3 units: blend(material + luma, lightmap) 
	current = R_InitRenderingState(r_state_world_material_fb_lightmap, true, "r_state_world_material_fb_lightmap", vao_brushmodel);
	current->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(current, 0, true, r_texunit_mode_replace);
	R_GLC_TextureUnitSet(current, 1, glConfig.texture_units >= 2, r_texunit_mode_add);
	R_GLC_TextureUnitSet(current, 2, glConfig.texture_units >= 3, r_texunit_mode_blend);

	// lumas enabled, 3 units
	current = R_InitRenderingState(r_state_world_material_luma_lightmap, true, "r_state_world_material_luma_lightmap", vao_brushmodel);
	current->fog.mode = r_fogmode_enabled;
	R_GLC_TextureUnitSet(current, 0, true, r_texunit_mode_replace);
	R_GLC_TextureUnitSet(current, 1, glConfig.texture_units >= 2, r_texunit_mode_add);
	R_GLC_TextureUnitSet(current, 2, glConfig.texture_units >= 3, r_texunit_mode_blend);
}

void R_InitialiseStates(void)
{
	R_InitRenderingState(r_state_default_3d, true, "default3DState", vao_none);

	R_InitialiseSpriteStates();
	R_InitialiseBrushModelStates();
	R_Initialise2DStates();
	R_InitialiseEntityStates();
	R_InitialiseWorldStates();

#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	GLC_InitialiseSkyStates();
#endif
}

float R_WaterAlpha(void)
{
	extern cvar_t r_wateralpha;

	return bound((1 - r_refdef2.max_watervis), r_wateralpha.value, 1);
}

void R_StateDefault3D(void)
{
	R_TraceResetRegion(false);

	R_TraceEnterFunctionRegion;
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_PauseMatrixUpdate();
	}
#endif
	R_IdentityModelView();
	R_RotateModelview(-90, 1, 0, 0);	    // put Z going up
	R_RotateModelview(90, 0, 0, 1);	    // put Z going up
	R_RotateModelview(-r_refdef.viewangles[2], 1, 0, 0);
	R_RotateModelview(-r_refdef.viewangles[0], 0, 1, 0);
	R_RotateModelview(-r_refdef.viewangles[1], 0, 0, 1);
	R_TranslateModelview(-r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		GLC_ResumeMatrixUpdate();
		GLC_LoadModelviewMatrix();
	}
#endif
	R_TraceLeaveFunctionRegion;
}

void R_StateBeginAlphaLineRGB(float thickness)
{
	if (thickness > 0.0) {
		R_CustomLineWidth(thickness);
	}
}

void R_StateBeginDrawAliasModel(const entity_t* ent, aliashdr_t* paliashdr)
{
	extern cvar_t r_viewmodelsize;

	R_TraceEnterRegion(__func__, true);

	R_RotateForEntity(ent);
	if (ent->renderfx & RF_WEAPONMODEL) {
		R_ScaleModelview(0.5 + bound(0, r_viewmodelsize.value, 1) / 2, 1, 1);
	}

	R_TraceLeaveFunctionRegion;
}


================================================
FILE: src/r_texture.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// 
#include "quakedef.h"
#include "gl_model.h"
#include "r_local.h"
#include "r_texture.h"
#include "r_texture_internal.h"
#include "r_lighting.h"
#include "r_aliasmodel.h"
#include "r_brushmodel_sky.h"
#include "r_trace.h"
#include "r_state.h"
#include "gl_texture.h"
#include "r_renderer.h"
#include "image.h"

#ifdef WITH_RENDERING_TRACE
#include "utils.h"
#endif

static void R_AllocateTextureNames(gltexture_t* glt);

gltexture_t  gltextures[MAX_GLTEXTURES];
static int   numgltextures = 1;
static int   next_free_texture = 0;
static texture_ref invalid_texture_reference = { 0 };

static void R_ClearModelTextureReferences(model_t* mod, qbool all_textures)
{
	int j;

	if (!mod) {
		return;
	}

	memset(mod->texture_arrays, 0, sizeof(mod->texture_arrays));
	memset(mod->texture_arrays_scale_s, 0, sizeof(mod->texture_arrays_scale_s));
	memset(mod->texture_arrays_scale_t, 0, sizeof(mod->texture_arrays_scale_t));
	memset(mod->texture_array_first, 0, sizeof(mod->texture_array_first));
	mod->texture_array_count = 0;

	memset(mod->simpletexture_scalingS, 0, sizeof(mod->simpletexture_scalingS));
	memset(mod->simpletexture_scalingT, 0, sizeof(mod->simpletexture_scalingT));
	memset(mod->simpletexture_indexes, 0, sizeof(mod->simpletexture_indexes));
	memset(mod->simpletexture_array, 0, sizeof(mod->simpletexture_array));

	if (all_textures) {
		memset(mod->simpletexture, 0, sizeof(mod->simpletexture));
	}

	// clear brush model data
	if (mod->type == mod_brush) {
		for (j = 0; j < mod->numtextures; ++j) {
			texture_t* tex = mod->textures[j];
			if (tex) {
				if (all_textures) {
					R_TextureReferenceInvalidate(tex->fb_texturenum);
					R_TextureReferenceInvalidate(tex->gl_texturenum);
				}
				tex->gl_texture_scaleS = tex->gl_texture_scaleT = 0;
				R_TextureReferenceInvalidate(tex->gl_texture_array);
				tex->gl_texture_index = 0;
			}
		}
	}

	// clear sprite model data
	if (mod->type == mod_sprite) {
		msprite2_t* psprite = (msprite2_t*)Mod_Extradata(mod);
		int j;

		for (j = 0; j < psprite->numframes; ++j) {
			int offset = psprite->frames[j].offset;
			int numframes = psprite->frames[j].numframes;
			mspriteframe_t* frame;

			if (offset < (int)sizeof(msprite2_t) || numframes < 1) {
				continue;
			}

			frame = ((mspriteframe_t*)((byte*)psprite + offset));

			if (all_textures) {
				R_TextureReferenceInvalidate(frame->gl_texturenum);
			}
			frame->gl_scalingS = frame->gl_scalingT = 0;
			R_TextureReferenceInvalidate(frame->gl_arraynum);
			frame->gl_arrayindex = 0;
		}
	}

	if (mod->type == mod_alias && all_textures) {
		aliashdr_t* paliashdr = (aliashdr_t *)Mod_Extradata(mod);

		memset(paliashdr->gl_texturenum, 0, sizeof(paliashdr->gl_texturenum));
		memset(paliashdr->glc_fb_texturenum, 0, sizeof(paliashdr->glc_fb_texturenum));
	}
	else if (mod->type == mod_alias3 && all_textures) {
		md3model_t* md3Model = (md3model_t *)Mod_Extradata(mod);
		surfinf_t* surfaceInfo = MD3_ExtraSurfaceInfoForModel(md3Model);

		// One day there will be more than one of these...
		R_TextureReferenceInvalidate(surfaceInfo->texnum);
	}
}

void R_TexturesInvalidateAllReferences(void)
{
	int i;

	for (i = 1; i < MAX_MODELS; ++i) {
		R_ClearModelTextureReferences(cl.model_precache[i], true);
	}

	for (i = 0; i < MAX_VWEP_MODELS; i++) {
		R_ClearModelTextureReferences(cl.vw_model_precache[i], true);
	}
}

void R_ClearModelTextureData(void)
{
	int i;

	for (i = 0; i < MAX_MODELS; ++i) {
		R_ClearModelTextureReferences(cl.model_precache[i], false);
	}

	for (i = 0; i < MAX_VWEP_MODELS; ++i) {
		R_ClearModelTextureReferences(cl.vw_model_precache[i], false);
	}
}

qbool R_TextureValid(texture_ref ref)
{
	return ref.index && ref.index < numgltextures && gltextures[ref.index].texnum;
}

qbool R_TexturesAreSameSize(texture_ref tex1, texture_ref tex2)
{
	assert(tex1.index < sizeof(gltextures) / sizeof(gltextures[0]));
	assert(tex2.index < sizeof(gltextures) / sizeof(gltextures[0]));

	return
		(gltextures[tex1.index].texture_width == gltextures[tex2.index].texture_width) &&
		(gltextures[tex1.index].texture_height == gltextures[tex2.index].texture_height);
}

int R_TextureWidth(texture_ref ref)
{
	assert(ref.index && ref.index < numgltextures);
	if (ref.index >= numgltextures) {
		return 0;
	}

	return gltextures[ref.index].texture_width;
}

int R_TextureHeight(texture_ref ref)
{
	assert(ref.index && ref.index < numgltextures);
	if (ref.index >= numgltextures) {
		return 0;
	}

	return gltextures[ref.index].texture_height;
}

int R_TextureDepth(texture_ref ref)
{
	assert(ref.index && ref.index < numgltextures);
	assert(gltextures[ref.index].is_array);
	if (ref.index >= numgltextures || !gltextures[ref.index].is_array) {
		return 0;
	}

	return gltextures[ref.index].depth;
}

void R_TextureModeForEach(void(*func)(texture_ref tex, qbool mipmap, qbool viewmodel))
{
	int i;
	gltexture_t* glt;

	// Make sure we set the proper texture filters for textures.
	for (i = 1, glt = gltextures + 1; i < numgltextures; i++, glt++) {
		if (!R_TextureReferenceIsValid(glt->reference)) {
			continue;
		}

		if (glt->texmode & TEX_NO_TEXTUREMODE) {
			continue;	// This texture must NOT be affected by texture mode changes,
						// for example charset which rather controlled by gl_smoothfont.
		}

		func(glt->reference, glt->texmode & TEX_MIPMAP, glt->texmode & TEX_VIEWMODEL);
	}
}

const char* R_TextureIdentifier(texture_ref ref)
{
	assert(ref.index < sizeof(gltextures) / sizeof(gltextures[0]));

	if (ref.index <= 0 || ref.index >= sizeof(gltextures) / sizeof(gltextures[0])) {
		return "null-texture";
	}

	return gltextures[ref.index].identifier[0] ? gltextures[ref.index].identifier : "unnamed-texture";
}

void R_TextureSetFlag(texture_ref ref, int mode)
{
	if (ref.index <= 0 || ref.index >= sizeof(gltextures) / sizeof(gltextures[0]))
		return;

	gltextures[ref.index].texmode = mode;
}

int R_TextureGetFlag(texture_ref ref)
{
	if (ref.index <= 0 || ref.index >= sizeof(gltextures) / sizeof(gltextures[0]))
		return 0;

	return gltextures[ref.index].texmode;
}

void R_TextureSetDimensions(texture_ref ref, int width, int height)
{
	assert(ref.index < sizeof(gltextures) / sizeof(gltextures[0]));

	gltextures[ref.index].texture_width = width;
	gltextures[ref.index].texture_height = height;
}

void R_Texture_Init(void)
{
	int i;

	// Reset some global vars, probably we need here even more...

	// Reset textures array and linked globals
	for (i = 0; i < numgltextures; i++) {
		if (gltextures[i].texnum) {
			renderer.TextureDelete(gltextures[i].reference);
		}
		Q_free(gltextures[i].pathname);
	}

	memset(gltextures, 0, sizeof(gltextures));

	numgltextures = 1;
	next_free_texture = 0;

	renderer.TextureInitialiseState();

	// Powerup shells.
	R_TextureReferenceInvalidate(shelltexture); // Force reload.

	// Sky.
	memset(skyboxtextures, 0, sizeof(skyboxtextures)); // Force reload.

	R_TextureRegisterCvars();
}

void R_DeleteTexture(texture_ref* texture)
{
	if (!texture || !R_TextureReferenceIsValid(*texture)) {
		return;
	}

	// Delete renderer's version
	if (renderer.TextureDelete) {
		renderer.TextureDelete(*texture);
	}

	// Free structure, updated linked list so we can re-use this slot
	Q_free(gltextures[texture->index].pathname);
	memset(&gltextures[texture->index], 0, sizeof(gltextures[0]));
	gltextures[texture->index].next_free = next_free_texture;
	next_free_texture = texture->index;

	// Invalidate the reference
	texture->index = 0;
}

void R_DeleteCubeMap(texture_ref* texture)
{
	R_DeleteTexture(texture);
}

void R_DeleteTextureArray(texture_ref* texture)
{
	R_DeleteTexture(texture);
}

void R_GenerateMipmapsIfNeeded(texture_ref ref)
{
	assert(ref.index && ref.index < numgltextures);
	if (!ref.index || ref.index >= numgltextures) {
		return;
	}

	if (!gltextures[ref.index].mipmaps_generated) {
		renderer.TextureMipmapGenerate(ref);
		gltextures[ref.index].mipmaps_generated = true;
	}
}

// Called during vid_shutdown
void R_DeleteTextures(void)
{
	extern void R_InvalidateLightmapTextures(void);
	int i;

	R_InvalidateLightmapTextures();
	Skin_InvalidateTextures();

#ifdef RENDERER_OPTION_MODERN_OPENGL
	{
		extern texture_ref particletexture_array;
		R_TextureReferenceInvalidate(particletexture_array);
	}
#endif

	for (i = 0; i < numgltextures; ++i) {
		R_DeleteTexture(&gltextures[i].reference);
	}
	Mod_ClearSimpleTextures();

	memset(gltextures, 0, sizeof(gltextures));
	numgltextures = 0;
	next_free_texture = 0;
}

texture_ref R_CreateCubeMap(const char* identifier, int width, int height, int mode)
{
	qbool new_texture;
	gltexture_t* slot = R_TextureAllocateSlot(texture_type_cubemap, identifier, width, height, 0, 4, mode | TEX_NOSCALE, 0, &new_texture);

	if (!slot) {
		return invalid_texture_reference;
	}

	if (slot && !new_texture) {
		return slot->reference;
	}

	R_TextureUtil_SetFiltering(slot->reference);
	renderer.TextureWrapModeClamp(slot->reference);

	return slot->reference;
}

gltexture_t* R_TextureAllocateSlot(r_texture_type_id type, const char* identifier, int width, int height, int depth, int bpp, int mode, unsigned short crc, qbool* new_texture)
{
	int gl_width, gl_height;
	gltexture_t* glt = NULL;
	qbool load_over_existing = false;
	int miplevels = 1;

	*new_texture = true;

	if (lightmode != 2) {
		mode &= ~TEX_BRIGHTEN;
	}
	if (bpp == 1 && (mode & TEX_FULLBRIGHT)) {
		mode |= TEX_ALPHA;
	}

	R_TextureUtil_ImageDimensionsToTexture(width, height, &gl_width, &gl_height, mode);

	if (mode & TEX_MIPMAP) {
		int temp_w = gl_width;
		int temp_h = gl_height;

		while (temp_w > 1 || temp_h > 1) {
			temp_w = max(1, temp_w / 2);
			temp_h = max(1, temp_h / 2);
			++miplevels;
		}
	}

	// If we were given an identifier for the texture, search through
	// the list of loaded texture and see if we find a match, if so
	// return the texnum for the already loaded texture.
	if (identifier[0]) {
		int i;
		for (i = 0, glt = gltextures; i < numgltextures; i++, glt++) {
			if (!strncmp(identifier, glt->identifier, sizeof(glt->identifier) - 1)) {
				qbool same_dimensions = (width == glt->image_width && height == glt->image_height && depth == glt->depth);
				qbool same_scaling = (gl_width == glt->texture_width && gl_height == glt->texture_height);
				qbool same_format = (glt->bpp == bpp && glt->type == type);
				qbool same_options = (mode & ~(TEX_COMPLAIN | TEX_NOSCALE)) == (glt->texmode & ~(TEX_COMPLAIN | TEX_NOSCALE));

				// Identifier matches, make sure everything else is the same
				// so that we can be really sure this is the correct texture.
				if (same_dimensions && same_scaling && same_format && same_options && crc == glt->crc) {
					*new_texture = false;
					return glt;
				}
				else {
					// Same identifier but different texture, so overwrite
					// the already loaded texture.
					load_over_existing = true;
					break;
				}
			}
		}
	}

	// If the identifier was the same as another textures, we won't bother
	// with taking up a new texture slot, just load the new texture
	// over the old one.
	if (!load_over_existing) {
		glt = R_NextTextureSlot(type);

		strlcpy(glt->identifier, identifier, sizeof(glt->identifier));
		R_AllocateTextureNames(glt);
		renderer.TextureLabelSet(glt->reference, glt->identifier);
	}
	else if (glt && !glt->texnum) {
		R_AllocateTextureNames(glt);
		renderer.TextureLabelSet(glt->reference, glt->identifier);
	}
	else if (glt && glt->storage_allocated) {
		if (gl_width != glt->texture_width || gl_height != glt->texture_height || depth != glt->depth || glt->bpp != bpp) {
			texture_ref ref = glt->reference;

			R_DeleteTexture(&ref);

			return R_TextureAllocateSlot(type, identifier, width, height, depth, bpp, mode, crc, new_texture);
		}
	}

	if (!glt) {
		Sys_Error("R_LoadTexture: glt not initialized\n");
	}

	glt->image_width = width;
	glt->image_height = height;
	glt->depth = depth;
	glt->texmode = mode;
	glt->crc = crc;
	glt->bpp = bpp;
	glt->is_array = (depth > 0);
	glt->texture_width = gl_width;
	glt->texture_height = gl_height;
	glt->miplevels = miplevels;
	Q_free(glt->pathname);
	if (bpp == 4 && fs_netpath[0]) {
		glt->pathname = Q_strdup(fs_netpath);
	}

	// Allocate storage
	if (!glt->storage_allocated && !glt->is_array) {
		if (R_UseImmediateOpenGL() || R_UseModernOpenGL()) {
			GL_AllocateStorage(glt);
		}
		else if (R_UseVulkan()) {
			// VK_AllocateStorage(glt);
		}
		glt->storage_allocated = true;
	}

	return glt;
}

void R_SetTextureArraySize(texture_ref tex, int width, int height, int depth, int bpp)
{
	gltextures[tex.index].bpp = bpp;
	gltextures[tex.index].texture_width = width;
	gltextures[tex.index].texture_height = height;
	gltextures[tex.index].depth = depth;
	gltextures[tex.index].is_array = true;
}

// We could flag the textures as they're created and then move all 2d>3d to this module?
// FIXME: Ensure not called in immediate-mode OpenGL
texture_ref R_CreateTextureArray(const char* identifier, int width, int height, int depth, int mode)
{
	qbool new_texture = false;
	gltexture_t* slot;
	texture_ref gl_texturenum;

	slot = R_TextureAllocateSlot(texture_type_2d_array, identifier, width, height, depth, 4, mode | TEX_NOSCALE, 0, &new_texture);
	if (!slot) {
		return invalid_texture_reference;
	}

	if (slot && !new_texture) {
		return slot->reference;
	}

	gl_texturenum = slot->reference;

#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		texture_ref tex = slot->reference;

		renderer.TextureUnitBind(0, tex);
		if (GLM_TextureAllocateArrayStorage(slot)) {
			R_TextureUtil_SetFiltering(slot->reference);
			return tex;
		}

		R_DeleteTexture(&tex);
		return null_texture_reference;
	}
#endif
#ifdef RENDERER_OPTION_VULKAN
	if (R_UseVulkan()) {

	}
#endif

	return gl_texturenum;
}

gltexture_t* R_NextTextureSlot(r_texture_type_id type)
{
	int slot;
	gltexture_t* glt;

	// Re-use a deleted slot if possible
	if (next_free_texture) {
		slot = next_free_texture;
		next_free_texture = gltextures[slot].next_free;
		gltextures[slot].next_free = 0;
	}
	else if (numgltextures >= MAX_GLTEXTURES) {
		Sys_Error("R_LoadTexture: numgltextures == MAX_GLTEXTURES");
		return NULL;
	}
	else {
		slot = numgltextures++;
	}

	glt = &gltextures[slot];
	glt->reference.index = slot;
	glt->type = type;
	return glt;
}

static void R_AllocateTextureNames(gltexture_t* glt)
{
	if (R_UseImmediateOpenGL()) {
		GL_AllocateTextureNames(glt);
	}
	else if (R_UseModernOpenGL()) {
		GL_AllocateTextureNames(glt);
	}
	else if (R_UseVulkan()) {
		// VK_AllocateTextureNames(...);
	}
}

gltexture_t* R_FindTexture(const char *identifier)
{
	int i;

	for (i = 0; i < numgltextures; i++) {
		if (!strcmp(identifier, gltextures[i].identifier)) {
			return &gltextures[i];
		}
	}

	return NULL;
}

void R_AllocateTextureReferences(r_texture_type_id type_id, int width, int height, int mode, int number, texture_ref* references)
{
	int i;

	for (i = 0; i < number; ++i) {
		qbool new_texture;
		gltexture_t* slot = R_TextureAllocateSlot(type_id, "", width, height, 0, 4, mode | TEX_NOSCALE, 0, &new_texture);

		if (slot) {
			references[i] = slot->reference;
		}
		else {
			references[i] = null_texture_reference;
		}
	}
}

r_texture_type_id R_TextureType(texture_ref ref)
{
	return gltextures[ref.index].type;
}

void R_TextureFindIdentifierByReference(unsigned int ref, char* label, int labelsize)
{
	int i;

	for (i = 0; i < numgltextures; ++i) {
		if (gltextures[i].texnum == ref) {
			strlcpy(label, gltextures[i].identifier, labelsize);
			return;
		}
	}

	label[0] = '\0';
}

// re-scale texture to match underlying (useful for fullbrights/lumas etc)
void R_TextureRescaleOverlay(byte** overlay_pixels, int* overlay_width, int* overlay_height, int underlying_width, int underlying_height)
{
	if (underlying_width != *overlay_width || underlying_height != *overlay_height) {
		byte* new_pixels = Q_malloc(underlying_width * underlying_height * 4);

		Image_Resample(*overlay_pixels, *overlay_width, *overlay_height, new_pixels, underlying_width, underlying_height, 4, true);

		Q_free(*overlay_pixels);
		*overlay_pixels = new_pixels;
		*overlay_width = underlying_width;
		*overlay_height = underlying_height;
	}
}

int R_TextureCount(void)
{
	return numgltextures;
}

#ifdef WITH_RENDERING_TRACE
void Dev_TextureList(void)
{
	int i = 0;

	for (i = 1; i < numgltextures; ++i) {
		if (Cmd_Argc() > 1 && !Utils_RegExpMatch(Cmd_Argv(1), gltextures[i].identifier)) {
			continue;
		}

		if (gltextures[i].texnum && gltextures[i].texture_width) {
			Con_Printf("%03d: %s, %d (%dx%d %d)\n", i, gltextures[i].identifier, gltextures[i].texture_width, gltextures[i].texture_height, gltextures[i].texmode);
		}
	}
}
#endif


================================================
FILE: src/r_texture.h
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_R_TEXTURE_H
#define EZQUAKE_R_TEXTURE_H

#define TEX_COMPLAIN        (1<<0)  // shout if texture missing while loading
#define TEX_MIPMAP          (1<<1)  // use mipmaps generation while loading texture
#define TEX_ALPHA           (1<<2)  // use transparency in texture
// Note: if (TEX_LUMA & TEX_FULLBRIGHT) specified, colours close to black (determined by gl_luma_level) will be turned transparent
#define TEX_LUMA            (1<<3)  // do not apply gamma adjustment to texture when loading
#define TEX_FULLBRIGHT      (1<<4)  // make all non-fullbright colours transparent (8-bit only).
#define TEX_NOSCALE         (1<<5)  // do no use gl_max_size or gl_picmap variables while loading texture
#define TEX_BRIGHTEN        (1<<6)  // use brighter 8bit => 24bit conversion during load
#define TEX_NOCOMPRESS      (1<<7)  // do not use texture compression extension
#define TEX_NO_PCX          (1<<8)  // do not load pcx images
#define TEX_NO_TEXTUREMODE  (1<<9)  // ignore gl_texturemode* changes for texture
#define TEX_PREMUL_ALPHA    (1<<10) // pre-multiply alpha
#define TEX_ZERO_ALPHA      (1<<11) // after pre-multiplying alpha, set alpha to 0 (additive blending)
#define TEX_MERGED_LUMA     (1<<12) // alpha channel signifies luma %
#define TEX_FLOAT           (1<<13) // floating point texture format
#define TEX_VIEWMODEL       (1<<14) // use viewmodel texture mode, not normal

#define MAX_GLTEXTURES 8192	//dimman: old value 1024 isn't enough when using high framecount sprites (according to Spike)
#define MAX_CHARSETS 256
#define MAX_USER_CHARSETS 0xE0

#define PRIVATE_USE_TRACKERIMAGES_CHARSET 0xE0
// reservations:
//   0xE000 - 0xE0FF = Tracker weapon images

typedef struct charset_s {
	mpic_t glyphs[256];
	texture_ref master;
	float custom_scale_x;
	float custom_scale_y;
} charset_t;

extern charset_t char_textures[MAX_CHARSETS];

/*
typedef struct texture_api_s {
	texture_ref (*Load)(const char *identifier, int width, int height, byte *data, int mode, int bpp);
	texture_ref (*LoadPic)(const char *name, mpic_t *pic, byte *data);
	texture_ref (*LoadFromPixels)(byte *data, const char *identifier, int width, int height, int mode);
	texture_ref (*LoadFromFile)(const char *filename, const char *identifier, int matchwidth, int matchheight, int mode);
	texture_ref (*CreateArray)(const char* identifier, int width, int height, int* depth, int mode, int minimum_depth);
	texture_ref (*CreateCubeMap)(const char* identifier, int width, int height, int mode);
	void (*DeleteArray)(texture_ref* texture);
	void (*DeleteCubeMap)(texture_ref* texture);
	void (*Delete)(texture_ref* texture);
	void (*DeleteAll)(void);

	qbool (*SameSize)(texture_ref tex1, texture_ref tex2);

	int (*Width)(texture_ref ref);
	int (*Height)(texture_ref ref);
	int (*Depth)(texture_ref ref);
	void (*GenerateMipmaps)(texture_ref ref);

	void (*InvalidateAll)(void);
	void (*CreateInternal)(texture_ref* reference, int width, int height, const char* name);
	void (*ReplaceSubImageRGBA)(texture_ref ref, int offsetx, int offsety, int width, int height, byte* buffer);

	void (*R_TextureWrapModeClamp)(texture_ref tex);

#ifdef WITH_RENDERING_TRACE
	const char* (*Identifier)(texture_ref ref);
#endif

} texture_api_t;

extern texture_api_t textures;
*/

void R_Texture_Init(void);

void R_TextureAnisotropyChanged(texture_ref tex, qbool mipmap, qbool viewmodel);

mpic_t* R_LoadPicImage(const char *filename, char *id, int matchwidth, int matchheight, int mode);
byte* R_LoadImagePixels(const char *filename, int matchwidth, int matchheight, int mode, int *real_width, int *real_height);
qbool R_LoadCharsetImage(char *filename, char *identifier, int flags, charset_t* pic);
void R_ImagePreMultiplyAlpha(byte* image, int width, int height, qbool zero);

texture_ref R_LoadTexture(const char *identifier, int width, int height, byte *data, int mode, int bpp);
texture_ref R_LoadPicTexture(const char *name, mpic_t *pic, byte *data);
texture_ref R_LoadTexturePixels(byte *data, const char *identifier, int width, int height, int mode);
texture_ref R_LoadTextureImage(const char *filename, const char *identifier, int matchwidth, int matchheight, int mode);
texture_ref R_CreateTextureArray(const char* identifier, int width, int height, int depth, int mode);
texture_ref R_CreateCubeMap(const char* identifier, int width, int height, int mode);
void R_DeleteTextureArray(texture_ref* texture);
void R_DeleteCubeMap(texture_ref* texture);
void R_DeleteTexture(texture_ref* texture);
void R_DeleteTextures(void);

qbool R_TexturesAreSameSize(texture_ref tex1, texture_ref tex2);
qbool R_TextureValid(texture_ref ref);
int R_TextureWidth(texture_ref ref);
int R_TextureHeight(texture_ref ref);
int R_TextureDepth(texture_ref ref);
r_texture_type_id R_TextureType(texture_ref ref);
void R_GenerateMipmapsIfNeeded(texture_ref ref);

void R_TexturesInvalidateAllReferences(void);

qbool R_ExternalTexturesEnabled(qbool worldmodel);

void R_SetNonPowerOfTwoSupport(qbool supported);
void R_TextureSizeRoundUp(int orig_width, int orig_height, int* width, int* height);

#ifdef WITH_RENDERING_TRACE
const char* R_TextureIdentifier(texture_ref ref);
#endif

extern cvar_t gl_max_size, gl_scaleModelTextures, gl_scaleTurbTextures, gl_scaleAlphaTextures, gl_scaleModelSimpleTextures, gl_miptexLevel, gl_scaleskytextures;
extern cvar_t gl_no24bit;
extern texture_ref underwatertexture, detailtexture, solidwhite_texture, solidblack_texture, transparent_texture;

void R_ClearModelTextureData(void);

void R_AllocateTextureReferences(r_texture_type_id type_id, int width, int height, int mode, int number, texture_ref* references);
void R_TextureRescaleOverlay(byte** overlay_pixels, int* overlay_width, int* overlay_height, int underlying_width, int underlying_height);
int R_TextureCount(void);
void R_TextureFindIdentifierByReference(unsigned int ref, char* label, int labelsize);
int R_TextureGetFlag(texture_ref ref);
void R_TextureSetFlag(texture_ref ref, int mode);

void R_SetTextureArraySize(texture_ref tex, int width, int height, int depth, int bpp);

#endif	// EZQUAKE_R_TEXTURE_H


================================================
FILE: src/r_texture_cvars.c
================================================
/*
Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: gl_texture.c,v 1.44 2007-10-05 19:06:24 johnnycz Exp $
*/

#include "quakedef.h"
#include "r_local.h"
#include "r_texture.h"
#include "r_texture_internal.h"
#include "tr_types.h"
#include "gl_texture.h"
#include "r_renderer.h"

static void OnChange_gl_max_size(cvar_t *var, char *string, qbool *cancel);
static void OnChange_gl_texturemode(cvar_t *var, char *string, qbool *cancel);
static void OnChange_gl_miptexLevel(cvar_t *var, char *string, qbool *cancel);
static void OnChange_gl_anisotropy(cvar_t *var, char *string, qbool *cancel);

cvar_t gl_lerpimages = { "gl_lerpimages", "1", CVAR_RELOAD_GFX };
static cvar_t gl_externalTextures_world = { "gl_externalTextures_world", "1", CVAR_RELOAD_GFX };
static cvar_t gl_externalTextures_bmodels = { "gl_externalTextures_bmodels", "1", CVAR_RELOAD_GFX };
cvar_t gl_wicked_luma_level = { "gl_luma_level", "1", CVAR_RELOAD_GFX };

static int anisotropy_tap = 1; //  1 - is off

cvar_t gl_max_size = { "gl_max_size", "2048", CVAR_RELOAD_GFX, OnChange_gl_max_size };
cvar_t gl_picmip = { "gl_picmip", "0", CVAR_RELOAD_GFX };
cvar_t gl_miptexLevel = { "gl_miptexLevel", "0", CVAR_RELOAD_GFX, OnChange_gl_miptexLevel };
cvar_t gl_texturemode = { "gl_texturemode", "GL_LINEAR_MIPMAP_LINEAR", 0, OnChange_gl_texturemode };
cvar_t gl_texturemode_viewmodels = { "gl_texturemode_viewmodels", "GL_LINEAR", 0, OnChange_gl_texturemode };
cvar_t gl_anisotropy = { "gl_anisotropy","16", 0, OnChange_gl_anisotropy };
cvar_t gl_scaleModelTextures = { "gl_scaleModelTextures", "0", CVAR_RELOAD_GFX };
cvar_t gl_scaleModelSimpleTextures = { "gl_scaleModelSimpleTextures", "0", CVAR_RELOAD_GFX };
cvar_t gl_scaleTurbTextures = { "gl_scaleTurbTextures", "1", CVAR_RELOAD_GFX };
cvar_t gl_scaleAlphaTextures = { "gl_scaleAlphaTextures", "0", CVAR_RELOAD_GFX };
cvar_t gl_scaleskytextures = { "gl_scaleskytextures", "0", CVAR_RELOAD_GFX };
cvar_t gl_no24bit = { "gl_no24bit", "0", CVAR_RELOAD_GFX };

static void OnChange_gl_max_size(cvar_t *var, char *string, qbool *cancel)
{
	int i;
	float newvalue = Q_atof(string);

	if (newvalue > glConfig.gl_max_size_default) {
		Com_Printf("Your hardware doesn't support texture sizes bigger than %dx%d\n", glConfig.gl_max_size_default, glConfig.gl_max_size_default);
		*cancel = true;
		return;
	}

	Q_ROUND_POWER2(newvalue, i);

	if (i != newvalue) {
		Com_Printf("Valid values for %s are powers of 2 only\n", var->name);
		*cancel = true;
		return;
	}
}

void R_TextureAnisotropyChanged(texture_ref tex, qbool mipmap, qbool viewmodel)
{
	if (mipmap || viewmodel) {
		renderer.TextureSetAnisotropy(tex, anisotropy_tap);
	}
}

static void OnChange_gl_anisotropy(cvar_t *var, char *string, qbool *cancel)
{
	int newvalue = Q_atoi(string);

	anisotropy_tap = max(1, newvalue); // 0 is bad, 1 is off, 2 and higher are valid modes

	R_TextureModeForEach(R_TextureAnisotropyChanged);
}

static void OnChange_gl_miptexLevel(cvar_t *var, char *string, qbool *cancel)
{
	float newval = Q_atof(string);

	if (newval != 0 && newval != 1 && newval != 2 && newval != 3) {
		Com_Printf("Valid values for %s are 0,1,2,3 only\n", var->name);
		*cancel = true;
	}
}

typedef struct {
	char *name;
	texture_minification_id	minimize;
	texture_magnification_id maximize;
} glmode_t;

static glmode_t modes[] = {
	{ "GL_NEAREST", texture_minification_nearest, texture_magnification_nearest },
	{ "GL_LINEAR", texture_minification_linear, texture_magnification_linear },
	{ "GL_NEAREST_MIPMAP_NEAREST", texture_minification_nearest_mipmap_nearest, texture_magnification_nearest },
	{ "GL_LINEAR_MIPMAP_NEAREST", texture_minification_linear_mipmap_nearest, texture_magnification_linear },
	{ "GL_NEAREST_MIPMAP_LINEAR", texture_minification_nearest_mipmap_linear, texture_magnification_nearest },
	{ "GL_LINEAR_MIPMAP_LINEAR", texture_minification_linear_mipmap_linear, texture_magnification_linear }
};

static texture_minification_id gl_filter_min = texture_minification_linear_mipmap_nearest;
static texture_magnification_id gl_filter_max = texture_magnification_linear;
static texture_minification_id gl_filter_viewmodel_min = texture_minification_linear;
static texture_magnification_id gl_filter_viewmodel_max = texture_magnification_linear;
static const texture_minification_id gl_filter_min_2d = texture_minification_linear;
static const texture_magnification_id gl_filter_max_2d = texture_magnification_linear;   // no longer controlled by cvar

void R_TextureModeChanged(texture_ref tex, qbool mipmap, qbool viewmodel)
{
	if (viewmodel) {
		renderer.TextureSetFiltering(tex, gl_filter_viewmodel_min, gl_filter_viewmodel_max);
	}
	else if (mipmap) {
		renderer.TextureSetFiltering(tex, gl_filter_min, gl_filter_max);
	}
	else {
		renderer.TextureSetFiltering(tex, gl_filter_min_2d, gl_filter_max_2d);
	}
}

static void OnChange_gl_texturemode(cvar_t *var, char *string, qbool *cancel)
{
	int i;

	for (i = 0; i < (sizeof(modes) / sizeof(glmode_t)); i++) {
		if (!strcasecmp(modes[i].name, string)) {
			break;
		}
	}

	if (i == (sizeof(modes) / sizeof(glmode_t))) {
		Com_Printf("bad filter name: %s\n", string);
		*cancel = true;
		return;
	}

	if (var == &gl_texturemode) {
		gl_filter_min = modes[i].minimize;
		gl_filter_max = modes[i].maximize;
	}
	else if (var == &gl_texturemode_viewmodels) {
		gl_filter_viewmodel_min = modes[i].minimize;
		gl_filter_viewmodel_max = modes[i].maximize;
	}
	else {
		Sys_Error("OnChange_gl_texturemode: unexpected cvar!");
		return;
	}

	R_TextureModeForEach(R_TextureModeChanged);
}

qbool R_ExternalTexturesEnabled(qbool worldmodel)
{
	return !gl_no24bit.integer && (worldmodel ? gl_externalTextures_world.integer : gl_externalTextures_bmodels.integer);
}

void R_TextureRegisterCvars(void)
{
	int i;
	cvar_t* cv;

	if (!host_initialized) {
		Cvar_SetCurrentGroup(CVAR_GROUP_TEXTURES);
		Cvar_Register(&gl_max_size);
		Cvar_Register(&gl_scaleModelTextures);
		Cvar_Register(&gl_scaleModelSimpleTextures);
		Cvar_Register(&gl_scaleTurbTextures);
		Cvar_Register(&gl_scaleskytextures);
		Cvar_Register(&gl_scaleAlphaTextures);
		Cvar_Register(&gl_miptexLevel);
		Cvar_Register(&gl_picmip);
		Cvar_Register(&gl_lerpimages);
		Cvar_Register(&gl_texturemode);
		Cvar_Register(&gl_texturemode_viewmodels);
		Cvar_Register(&gl_anisotropy);
		Cvar_Register(&gl_externalTextures_world);
		Cvar_Register(&gl_externalTextures_bmodels);

		Cvar_Register(&gl_no24bit);
		Cvar_Register(&gl_wicked_luma_level);
		Cvar_ResetCurrentGroup();
	}

	// This way user can specify gl_max_size in his cfg.
	i = (cv = Cvar_Find(gl_max_size.name)) ? cv->integer : 0;
	Cvar_SetDefaultAndValue(&gl_max_size, glConfig.gl_max_size_default, i ? i : glConfig.gl_max_size_default);
}


================================================
FILE: src/r_texture_internal.h
================================================

#ifndef EZQUAKE_R_TEXTURE_INTERNAL_HEADER
#define EZQUAKE_R_TEXTURE_INTERNAL_HEADER

#include "r_texture.h"

typedef struct gltexture_s {
	// Internal handle
	unsigned int texnum;

	// 
	r_texture_type_id type;
	char        identifier[MAX_QPATH];
	char*       pathname;
	int         image_width, image_height;
	int         texture_width, texture_height;
	int         texmode;
	unsigned    crc;
	int         bpp;
	int         miplevels;

	// Arrays
	qbool       is_array;
	int         depth;

	texture_ref reference;
	int         next_free;

	qbool       mipmaps_generated;
	qbool       storage_allocated;

	texture_minification_id minification_filter;
	texture_magnification_id magnification_filter;
} gltexture_t;

extern gltexture_t gltextures[MAX_GLTEXTURES];

void R_TextureSetDimensions(texture_ref ref, int width, int height);
gltexture_t* R_TextureAllocateSlot(r_texture_type_id type, const char* identifier, int width, int height, int depth, int bpp, int mode, unsigned short crc, qbool* new_texture);

void R_TextureUtil_ScaleDimensions(int width, int height, int *scaled_width, int *scaled_height, int mode);
void R_TextureUtil_Brighten32(byte *data, int size);
void R_TextureUtil_ImageDimensionsToTexture(int imageWidth, int imageHeight, int* textureWidth, int* textureHeight, int mode);

void R_TextureUtil_SetFiltering(texture_ref texture);

gltexture_t* R_NextTextureSlot(r_texture_type_id target);
gltexture_t* R_FindTexture(const char *identifier);

void R_TextureRegisterCvars(void);
void R_TextureModeChanged(texture_ref tex, qbool mipmap, qbool viewmodel);
void R_TextureModeForEach(void(*func)(texture_ref tex, qbool mipmap, qbool viewmodel));

#endif // EZQUAKE_R_TEXTURE_HEADER


================================================
FILE: src/r_texture_load.c
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "r_texture_internal.h"
#include "r_local.h"
#include "image.h"
#include "crc.h"
#include "gl_texture.h"
#include "r_trace.h"

static void R_LoadTextureData(gltexture_t* glt, int width, int height, byte *data, int mode, int bpp);

// 
#define CHARSET_CHARS_PER_ROW	16
#define CHARSET_WIDTH			1.0
#define CHARSET_HEIGHT			1.0
#define CHARSET_CHAR_WIDTH		(CHARSET_WIDTH / CHARSET_CHARS_PER_ROW)
#define CHARSET_CHAR_HEIGHT		(CHARSET_HEIGHT / CHARSET_CHARS_PER_ROW)

static const texture_ref invalid_texture_reference = { 0 };
static qbool r_texture_support_non_power_of_two;

#define Block24BitTextures (COM_CheckParm(cmdline_param_client_no24bittextures) || gl_no24bit.integer)
#define ForceTextureReload (COM_CheckParm(cmdline_param_client_forcetexturereload))

static qbool CheckTextureLoaded(gltexture_t* current_texture)
{
	if (!ForceTextureReload) {
		if (current_texture && current_texture->pathname && !strcmp(fs_netpath, current_texture->pathname)) {
			int textureWidth, textureHeight;

			R_TextureUtil_ImageDimensionsToTexture(current_texture->image_width, current_texture->image_height, &textureWidth, &textureHeight, current_texture->texmode);

			if (current_texture->texture_width == textureWidth && current_texture->texture_height == textureHeight) {
				return true;
			}
		}
	}
	return false;
}

texture_ref R_LoadTextureImage(const char *filename, const char *identifier, int matchwidth, int matchheight, int mode)
{
	texture_ref reference;
	byte *data;
	int image_width = -1, image_height = -1;
	gltexture_t *gltexture;

	R_TraceAPI("R_LoadTextureImage(filename=%s, identifier=%s, matchwidth=%d, matchheight=%d, mode=%d)", filename, identifier, matchwidth, matchheight, mode);
	if (Block24BitTextures) {
		return invalid_texture_reference;
	}

	if (!identifier) {
		identifier = filename;
	}

	gltexture = R_FindTexture(identifier);
	if (CheckTextureLoaded(gltexture)) {
		return gltexture->reference;
	}
	if (!(data = R_LoadImagePixels(filename, matchwidth, matchheight, mode, &image_width, &image_height))) {
		if (gltexture) {
			reference = gltexture->reference;
			R_DeleteTexture(&reference);
		}
		return invalid_texture_reference;
	}
	else {
		reference = R_LoadTexturePixels(data, identifier, image_width, image_height, mode);
		Q_free(data);	// Data was Q_malloc'ed by R_LoadImagePixels.
	}

	return reference;
}

void R_ImagePreMultiplyAlpha(byte* image, int width, int height, qbool zero)
{
	// Pre-multiply alpha component
	int pos;

	for (pos = 0; pos < width * height * 4; pos += 4) {
		float alpha = image[pos + 3] / 255.0f;

		image[pos] *= alpha;
		image[pos + 1] *= alpha;
		image[pos + 2] *= alpha;
		if (zero) {
			image[pos + 3] = 0;
		}
	}
}

mpic_t* R_LoadPicImage(const char *filename, char *id, int matchwidth, int matchheight, int mode)
{
	int width, height, i, real_width, real_height;
	char identifier[MAX_QPATH] = "pic:";
	byte *data, *src, *dest, *buf;
	static mpic_t pic;

	// this is 2D texture loading so it must not have MIP MAPS
	mode &= ~TEX_MIPMAP;

	R_TraceAPI("R_LoadPicImage(filename=%s, identifier=%s, matchwidth=%d, matchheight=%d, mode=%d)", filename, id, matchwidth, matchheight, mode);
	if (Block24BitTextures) {
		return NULL;
	}

	// Load the image data from file.
	if (!(data = R_LoadImagePixels(filename, matchwidth, matchheight, 0, &real_width, &real_height))) {
		return NULL;
	}

	pic.width = real_width;
	pic.height = real_height;

	// Check if there's any actual alpha transparency in the image.
	if (mode & TEX_ALPHA) {
		mode &= ~TEX_ALPHA;
		for (i = 0; i < real_width * real_height; i++) {
			if (((((unsigned *)data)[i] >> 24) & 0xFF) < 255) {
				mode |= TEX_ALPHA;
				break;
			}
		}
	}

	if (mode & TEX_ALPHA) {
		R_ImagePreMultiplyAlpha(data, real_width, real_height, false);
	}

	R_TextureSizeRoundUp(pic.width, pic.height, &width, &height);

	strlcpy(identifier + 4, id ? id : filename, sizeof(identifier) - 4);

	// Upload the texture to OpenGL.
	if (width == pic.width && height == pic.height) {
		// Size of the image is scaled by the power of 2 so we can just
		// load the texture as it is.
		pic.texnum = R_LoadTexture(identifier, pic.width, pic.height, data, mode, 4);
		pic.sl = 0;
		pic.sh = 1;
		pic.tl = 0;
		pic.th = 1;
	}
	else {
		// The size of the image data is not a power of 2, so we
		// need to load it into a bigger texture and then set the
		// texture coordinates so that only the relevant part of it is used.

		buf = (byte *)Q_calloc(width * height, 4);

		src = data;
		dest = buf;

		for (i = 0; i < pic.height; i++) {
			memcpy(dest, src, pic.width * 4);
			src += pic.width * 4;	// Next line in the source.
			dest += width * 4;		// Next line in the target.
		}

		pic.texnum = R_LoadTexture(identifier, width, height, buf, mode, 4);
		pic.sl = 0;
		pic.sh = (float)pic.width / width;
		pic.tl = 0;
		pic.th = (float)pic.height / height;
		Q_free(buf);
	}

	Q_free(data);	// Data was Q_malloc'ed by R_LoadImagePixels
	return &pic;
}

qbool R_LoadCharsetImage(char *filename, char *identifier, int flags, charset_t* pic)
{
	int i, j, image_size, real_width, real_height;
	byte *data, *buf = NULL, *dest, *src;
	texture_ref tex;

	R_TraceEnterRegion(va("R_LoadCharsetImage(filename=%s, identifier=%s, flags=%d)", filename, identifier, flags), true);
	if (Block24BitTextures) {
		R_TraceAPI("24-bit textures blocked");
		R_TraceLeaveRegion(true);
		return false;
	}

	if (!(data = R_LoadImagePixels(filename, 0, 0, flags, &real_width, &real_height))) {
		R_TraceAPI("Failed to load image pixels");
		R_TraceLeaveRegion(true);
		return false;
	}

	R_ImagePreMultiplyAlpha(data, real_width, real_height, false);

	if (!identifier) {
		identifier = filename;
	}

	image_size = real_width * real_height;

	buf = dest = (byte *)Q_calloc(image_size * 4, 4);
	src = data;
	for (j = 0; j < real_height; ++j) {
		for (i = 0; i < real_width; ++i) {
			int x_offset = (i / (real_width >> 4)) * (real_width >> 4);
			int y_offset = (j / (real_height >> 4)) * (real_height >> 4);

			memcpy(&buf[(i + x_offset + 2 * real_width * (j + y_offset)) * 4], &src[(i + real_width * j) * 4], 4);
		}
	}

	tex = R_LoadTexture(identifier, real_width * 2, real_height * 2, buf, flags, 4);
	Q_free(buf);
	if (R_TextureReferenceIsValid(tex)) {
		memset(pic->glyphs, 0, sizeof(pic->glyphs));
		for (i = 0; i < 255; ++i) {
			float char_height = 1.0f / (2 * CHARSET_CHARS_PER_ROW);
			float char_width = 1.0f / (2 * CHARSET_CHARS_PER_ROW);
			float frow = (i >> 4) * char_height * 2;
			float fcol = (i & 0x0F) * char_width * 2;

			pic->glyphs[i].texnum = tex;
			pic->glyphs[i].sl = fcol;
			pic->glyphs[i].sh = fcol + char_width;
			pic->glyphs[i].tl = frow;
			pic->glyphs[i].th = frow + char_height;
			pic->glyphs[i].width = real_width >> 4;
			pic->glyphs[i].height = real_height >> 4;
		}

		pic->master = tex;
	}

	pic->custom_scale_x = 1;
	pic->custom_scale_y = 1;

	Q_free(data);	// data was Q_malloc'ed by R_LoadImagePixels
	R_TraceLeaveRegion(true);
	return R_TextureReferenceIsValid(tex);
}

typedef byte* (*ImageLoadFunction)(vfsfile_t *fin, const char *filename, int matchwidth, int matchheight, int *real_width, int *real_height);
typedef struct image_load_format_s {
	const char* extension;
	ImageLoadFunction function;
	int filter_mask;
} image_load_format_t;

byte* R_LoadImagePixels(const char *filename, int matchwidth, int matchheight, int mode, int *real_width, int *real_height)
{
	char basename[MAX_QPATH], name[MAX_QPATH];
	byte *c, *data = NULL;
	vfsfile_t *f;

	COM_StripExtension(filename, basename, sizeof(basename));
	for (c = (byte *)basename; *c; c++) {
		if (*c == '*') {
			*c = '#';
		}
	}

	snprintf(name, sizeof(name), "%s.link", basename);
	if ((f = FS_OpenVFS(name, "rb", FS_ANY))) {
		char link[128];
		int len;
		VFS_GETS(f, link, sizeof(link));

		len = strlen(link);

		// Strip endline.
		if (link[len - 1] == '\n') {
			link[len - 1] = '\0';
			--len;
		}

		if (link[len - 1] == '\r') {
			link[len - 1] = '\0';
			--len;
		}

		snprintf(name, sizeof(name), "textures/%s", link);
		if ((f = FS_OpenVFS(name, "rb", FS_ANY))) {
			if (!data && !strcasecmp(link + len - 3, "tga")) {
				data = Image_LoadTGA(f, name, matchwidth, matchheight, real_width, real_height);
			}

#ifdef WITH_PNG
			if (!data && !strcasecmp(link + len - 3, "png")) {
				data = Image_LoadPNG(f, name, matchwidth, matchheight, real_width, real_height);
			}
#endif // WITH_PNG

#ifdef WITH_JPEG
			if (!data && !strcasecmp(link + len - 3, "jpg")) {
				data = Image_LoadJPEG(f, name, matchwidth, matchheight, real_width, real_height);
			}
#endif // WITH_JPEG

			// TEX_NO_PCX - preventing loading skins here
			if (!(mode & TEX_NO_PCX) && !data && !strcasecmp(link + len - 3, "pcx")) {
				data = Image_LoadPCX_As32Bit(f, name, matchwidth, matchheight, real_width, real_height);
			}

			if (data)
				return data;
		}
	}

	image_load_format_t formats[] = {
		{ "tga", Image_LoadTGA, 0 },
#ifdef WITH_PNG
		{ "png", Image_LoadPNG, 0 },
#endif
#ifdef WITH_JPEG
		{ "jpg", Image_LoadJPEG, 0 },
#endif
		{ "pcx", Image_LoadPCX_As32Bit, TEX_NO_PCX }
	};
	int i = 0;

	image_load_format_t* best = NULL;
	for (i = 0; i < sizeof(formats) / sizeof(formats[0]); ++i) {
		vfsfile_t *file = NULL;

		if (mode & formats[i].filter_mask) {
			continue;
		}

		snprintf(name, sizeof(name), "%s.%s", basename, formats[i].extension);
		if ((file = FS_OpenVFS(name, "rb", FS_ANY))) {
			if (f == NULL || (f->copyprotected && !file->copyprotected)) {
				if (f) {
					VFS_CLOSE(f);
				}
				f = file;
				best = &formats[i];
			}
			else {
				VFS_CLOSE(file);
			}
		}
	}

	if (best && f) {
		snprintf(name, sizeof(name), "%s.%s", basename, best->extension);
		if ((data = best->function(f, name, matchwidth, matchheight, real_width, real_height))) {
			return data;
		}
	}

	if (mode & TEX_COMPLAIN) {
		if (!Block24BitTextures) {
			Com_Printf_State(PRINT_FAIL, "Couldn't load %s image\n", COM_SkipPath(filename));
		}
	}

	return NULL;
}

texture_ref R_LoadTexturePixels(byte *data, const char *identifier, int width, int height, int mode)
{
	int i, j, image_size;
	qbool gamma;
	extern byte vid_gamma_table[256];
	extern float vid_gamma;

	image_size = width * height;
	gamma = (vid_gamma != 1);

	if (mode & TEX_LUMA) {
		gamma = false;
	}
	else if (mode & TEX_ALPHA) {
		mode &= ~TEX_ALPHA;

		for (j = 0; j < image_size; j++) {
			if (((((unsigned *)data)[j] >> 24) & 0xFF) < 255) {
				mode |= TEX_ALPHA;
				break;
			}
		}
	}

	if ((mode & TEX_ALPHA) && (mode & TEX_PREMUL_ALPHA)) {
		R_ImagePreMultiplyAlpha(data, width, height, mode & TEX_ZERO_ALPHA);
	}

	if (R_OldGammaBehaviour() && gamma) {
		for (i = 0; i < image_size; i++) {
			data[4 * i] = vid_gamma_table[data[4 * i]];
			data[4 * i + 1] = vid_gamma_table[data[4 * i + 1]];
			data[4 * i + 2] = vid_gamma_table[data[4 * i + 2]];
		}
	}

	return R_LoadTexture(identifier, width, height, data, mode, 4);
}

texture_ref R_LoadPicTexture(const char *name, mpic_t *pic, byte *data)
{
	int glwidth, glheight, i;
	char fullname[MAX_QPATH] = "pic:";
	byte *src, *dest, *buf;

	R_TextureSizeRoundUp(pic->width, pic->height, &glwidth, &glheight);

	strlcpy(fullname + 4, name, sizeof(fullname) - 4);
	if (glwidth == pic->width && glheight == pic->height) {
		pic->texnum = R_LoadTexture(fullname, glwidth, glheight, data, TEX_ALPHA, 1);
		pic->sl = 0;
		pic->sh = 1;
		pic->tl = 0;
		pic->th = 1;
	}
	else {
		buf = Q_calloc(glwidth * glheight, 1);

		src = data;
		dest = buf;
		for (i = 0; i < pic->height; i++) {
			memcpy(dest, src, pic->width);
			src += pic->width;
			dest += glwidth;
		}
		pic->texnum = R_LoadTexture(fullname, glwidth, glheight, buf, TEX_ALPHA, 1);
		pic->sl = 0;
		pic->sh = (float)pic->width / glwidth;
		pic->tl = 0;
		pic->th = (float)pic->height / glheight;
		Q_free(buf);
	}

	return pic->texnum;
}

texture_ref R_LoadTexture(const char *identifier, int width, int height, byte *data, int mode, int bpp)
{
	unsigned short crc = identifier[0] && data ? CRC_Block(data, width * height * bpp) : 0;
	qbool new_texture = false;
	gltexture_t *glt = R_TextureAllocateSlot(texture_type_2d, identifier, width, height, 0, bpp, mode, crc, &new_texture);

	R_TraceEnterFunctionRegion;
	R_TraceAPI("R_LoadTexture(id=%s, width=%d, height=%d, mode=%d, bpp=%d)", identifier, width, height, mode, bpp);
	if (glt && !new_texture) {
		R_TraceLeaveFunctionRegion;
		return glt->reference;
	}
	else if (!glt) {
		R_TraceLeaveFunctionRegion;
		return null_texture_reference;
	}

	if (data) {
		R_LoadTextureData(glt, width, height, data, mode, bpp);
	}

	R_TraceLeaveFunctionRegion;
	return glt->reference;
}

//
// Uploads a 32-bit texture to OpenGL. Makes sure it's the correct size and creates mipmaps if requested.
//
static void R_Upload32(gltexture_t* glt, unsigned *data, int width, int height, int mode)
{
	// Tell OpenGL the texnum of the texture before uploading it.
	extern cvar_t gl_lerpimages, gl_wicked_luma_level;
	int	tempwidth, tempheight;
	byte *newdata;

	R_TextureSizeRoundUp(width, height, &tempwidth, &tempheight);

	newdata = Q_malloc(tempwidth * tempheight * 4);

	// Resample the image if it's not scaled to the power of 2,
	// we take care of this when drawing using the texture coordinates.
	if (width < tempwidth || height < tempheight) {
		Image_Resample(data, width, height, newdata, tempwidth, tempheight, 4, !!gl_lerpimages.value);
		width = tempwidth;
		height = tempheight;
	}
	else {
		// Scale is a power of 2, just copy the data.
		memcpy(newdata, data, width * height * 4);
	}

	if ((mode & TEX_FULLBRIGHT) && (mode & TEX_LUMA) && gl_wicked_luma_level.integer > 0) {
		int i, cnt = width * height * 4, level = gl_wicked_luma_level.integer;

		for (i = 0; i < cnt; i += 4) {
			if (newdata[i] < level && newdata[i + 1] < level && newdata[i + 2] < level) {
				// make black pixels transparent, well not always black, depends of level...
				newdata[i] = newdata[i + 1] = newdata[i + 2] = newdata[i + 3] = 0;
			}
		}
	}

	// Get the scaled dimension (scales according to gl_picmip and max allowed texture size).
	R_TextureUtil_ScaleDimensions(width, height, &tempwidth, &tempheight, mode);

	// If the image size is bigger than the max allowed size or 
	// set picmip value we calculate it's next closest mip map.
	while (width > tempwidth || height > tempheight) {
		Image_MipReduce(newdata, newdata, &width, &height, 4);
	}

	glt->texture_width = width;
	glt->texture_height = height;

	if (mode & TEX_MIPMAP) {
		int largest = max(width, height);
		while (largest) {
			largest /= 2;
		}
	}

	if (mode & TEX_BRIGHTEN) {
		R_TextureUtil_Brighten32(newdata, width * height * 4);
	}

	if (R_UseImmediateOpenGL() || R_UseModernOpenGL()) {
		GL_UploadTexture(glt->reference, glt->texmode, width, height, newdata);
	}
	else if (R_UseVulkan()) {
		//VK_UploadTexture(glt->reference, glt->texmode, width, height, newdata);
	}

	R_TextureUtil_SetFiltering(glt->reference);

	Q_free(newdata);
}

static void R_Upload8(gltexture_t* glt, byte *data, int width, int height, int mode)
{
	static unsigned* trans;
	static int trans_size;
	int	i, image_size, p;
	unsigned *table;

	table = (mode & TEX_BRIGHTEN) ? d_8to24table2 : d_8to24table;
	image_size = width * height;

	if (image_size * 4 > trans_size) {
		unsigned* newmem = Q_realloc(trans, image_size * 4);
		if (newmem == NULL) {
			Sys_Error("GL_Upload8: image too big (%s: %dx%d)", glt->identifier[0] ? glt->identifier : "?unknown?", width, height);
		}
		trans = newmem;
		trans_size = image_size * 4;
	}

	if (mode & TEX_FULLBRIGHT) {
		qbool was_alpha = mode & TEX_ALPHA;

		// This is a fullbright mask, so make all non-fullbright colors transparent.
		mode |= TEX_ALPHA;

		for (i = 0; i < image_size; i++) {
			p = data[i];
			if (p < 224 || (p == 255 && was_alpha)) {
				trans[i] = 0; // Transparent.
			}
			else {
				trans[i] = (p == 255) ? LittleLong(0xff535b9f) : table[p]; // Fullbright. Disable transparancy on fullbright colors (255).
			}
		}
	}
	else if (mode & TEX_ALPHA) {
		// If there are no transparent pixels, make it a 3 component
		// texture even if it was specified as otherwise
		mode &= ~TEX_ALPHA;

		for (i = 0; i < image_size; i++) {
			if ((p = data[i]) == 255) {
				mode |= TEX_ALPHA;
			}
			trans[i] = table[p];
		}
	}
	else {
		if (image_size & 3) {
			Sys_Error("GL_Upload8: image_size & 3");
		}

		// Convert the 8-bit colors to 24-bit.
		for (i = 0; i < image_size; i += 4) {
			trans[i] = table[data[i]];
			trans[i + 1] = table[data[i + 1]];
			trans[i + 2] = table[data[i + 2]];
			trans[i + 3] = table[data[i + 3]];
		}
	}

	R_Upload32(glt, trans, width, height, mode & ~TEX_BRIGHTEN);
}

static void R_LoadTextureData(gltexture_t* glt, int width, int height, byte *data, int mode, int bpp)
{
	// Upload the texture to OpenGL based on the bytes per pixel.
	switch (bpp) {
		case 1:
			R_Upload8(glt, data, width, height, mode);
			break;
		case 4:
			R_Upload32(glt, (void *)data, width, height, mode);
			break;
		default:
			Sys_Error("R_LoadTexture: unknown bpp\n");
			break;
	}
}

void R_TextureSizeRoundUp(int orig_width, int orig_height, int* width, int* height)
{
	if (r_texture_support_non_power_of_two) {
		*width = orig_width;
		*height = orig_height;
	}
	else {
		Q_ROUND_POWER2(orig_width, (*width));
		Q_ROUND_POWER2(orig_height, (*height));
	}
}

void R_SetNonPowerOfTwoSupport(qbool supported)
{
	r_texture_support_non_power_of_two = supported;
}


================================================
FILE: src/r_texture_util.c
================================================

#include "quakedef.h"
#include "r_texture.h"
#include "r_texture_internal.h"
#include "tr_types.h"

void R_TextureUtil_ScaleDimensions(int width, int height, int *scaled_width, int *scaled_height, int mode)
{
	int maxsize, picmip;
	qbool scale = (mode & TEX_MIPMAP) && !(mode & TEX_NOSCALE);
	extern cvar_t gl_picmip;

	R_TextureSizeRoundUp(width, height, scaled_width, scaled_height);

	if (scale) {
		picmip = (int)bound(0, gl_picmip.value, 16);
		*scaled_width >>= picmip;
		*scaled_height >>= picmip;
	}

	maxsize = scale ? gl_max_size.value : glConfig.gl_max_size_default;

	*scaled_width = bound(1, *scaled_width, maxsize);
	*scaled_height = bound(1, *scaled_height, maxsize);
}

void R_TextureUtil_Brighten32(byte *data, int size)
{
	byte *p;
	int i;

	p = data;
	for (i = 0; i < size / 4; i++) {
		p[0] = min(p[0] * 2.0 / 1.5, 255);
		p[1] = min(p[1] * 2.0 / 1.5, 255);
		p[2] = min(p[2] * 2.0 / 1.5, 255);
		p += 4;
	}
}

void R_TextureUtil_ImageDimensionsToTexture(int imageWidth_, int imageHeight_, int* textureWidth, int* textureHeight, int mode)
{
	int imageWidth, imageHeight;
	int scaledWidth, scaledHeight;

	R_TextureSizeRoundUp(imageWidth_, imageHeight_, &imageWidth, &imageHeight);
	R_TextureUtil_ScaleDimensions(imageWidth, imageHeight, &scaledWidth, &scaledHeight, mode);
	while (imageWidth > scaledWidth || imageHeight > scaledHeight) {
		imageWidth = max(1, imageWidth / 2);
		imageHeight = max(1, imageHeight / 2);
	}
	*textureWidth = imageWidth;
	*textureHeight = imageHeight;
}

void R_TextureUtil_SetFiltering(texture_ref texture)
{
	int mode = gltextures[texture.index].texmode;

	R_TextureModeChanged(texture, mode & TEX_MIPMAP, mode & TEX_VIEWMODEL);
	R_TextureAnisotropyChanged(texture, mode & TEX_MIPMAP, mode & TEX_VIEWMODEL);
}


================================================
FILE: src/r_trace.h
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_R_TRACE_HEADER
#define EZQUAKE_R_TRACE_HEADER

#ifdef WITH_RENDERING_TRACE
#define R_TraceEnterFunctionRegion R_TraceEnterRegion(__FUNCTION__, true)
#define R_TraceLeaveFunctionRegion R_TraceLeaveRegion(true)
#define R_TraceEnterNamedRegion(x) R_TraceEnterRegion(x, false)
#define R_TraceLeaveNamedRegion() R_TraceLeaveRegion(false)
void R_TraceEnterRegion(const char* regionName, qbool trace_only);
void R_TraceLeaveRegion(qbool trace_only);
void R_TracePrintState(FILE* output, int indent);
void R_TraceDebugState(void);
void R_TraceResetRegion(qbool start);
void R_TraceLogAPICallDirect(const char* message, ...);
#define R_TraceLogAPICall(...) { R_TraceLogAPICallDirect(__VA_ARGS__); }
void R_TraceAPI(const char* formatString, ...);
qbool R_TraceLoggingEnabled(void);
void R_TraceTextureLabelGet(unsigned int name, int bufSize, int* length, char* label);
#else
#define R_TraceEnterFunctionRegion
#define R_TraceLeaveFunctionRegion
#define R_TraceEnterNamedRegion(x)
#define R_TraceLeaveNamedRegion()
#define R_TraceEnterRegion(...)
#define R_TraceLeaveRegion(...)
#define R_TracePrintState(...)
#define R_TraceDebugState()
#define R_TraceResetRegion(x)
#define R_TraceLogAPICallDirect(x, ...)
#define R_TraceLogAPICall(...)
#define R_TraceAPI(formatString, ...)
#define R_TraceLoggingEnabled() (false)
#define R_TraceTextureLabelSet(...)
#define R_TraceTextureLabelGet(...)
#endif

#endif // EZQUAKE_R_TRACE_HEADER


================================================
FILE: src/r_vao.h
================================================
/*
Copyright (C) 2018 ezQuake team.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_R_VAO_HEADER
#define EZQUAKE_R_VAO_HEADER

#include "r_buffers.h"

typedef enum {
	vao_none,
	vao_aliasmodel,
	vao_brushmodel,
	vao_3dsprites,
	vao_hud_circles,
	vao_hud_images,
	vao_hud_lines,
	vao_hud_polygons,
	vao_postprocess,

	// non-shader (classic OpenGL) only
	vao_aliasmodel_powerupshell,
	vao_brushmodel_details,
	vao_brushmodel_lightmap_pass,
	vao_brushmodel_lm_unit1,
	vao_brushmodel_simpletex,
	vao_hud_images_non_glsl,

	vao_count
} r_vao_id;

void R_GenVertexArray(r_vao_id vao);
void R_BindVertexArray(r_vao_id vao);
qbool R_VertexArrayCreated(r_vao_id vao);
void R_InitialiseVAOState(void);
qbool R_VAOBound(void);
void R_BindVertexArrayElementBuffer(r_buffer_id ref);

typedef struct r_vaos_api_s {
	void(*Bind)(r_vao_id vao);
} r_vaos_api_t;

#endif // EZQUAKE_R_VAO_HEADER


================================================
FILE: src/render.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// refresh.h -- public interface to refresh functions

#define	TOP_RANGE		16			// soldier uniform colors
#define	BOTTOM_RANGE	96

//=============================================================================

typedef struct efrag_s {
	struct mleaf_s		*leaf;
	struct efrag_s		*leafnext;
	struct entity_s		*entity;
	struct efrag_s		*entnext;
} efrag_t;

#define RF_WEAPONMODEL       1
#define RF_NOSHADOW          2
#define RF_LIMITLERP         4
#define RF_PLAYERMODEL       8
#define RF_NORMALENT        16
#define RF_CAUSTICS         32
#define RF_ALPHABLEND       64   // bit of a hack - always enable blending (used for 2nd pass when multi-texturing disabled)
#define RF_ADDITIVEBLEND   128
#define RF_ROCKETPACK      256
#define RF_LGPACK          512
#define RF_BEHINDWALL     1024
#define RF_VWEPMODEL      2048
#define RF_FORCECOLOURMOD 4096

#define RF_BACKPACK_FLAGS (RF_ROCKETPACK | RF_LGPACK)

typedef struct custom_model_color_s {
	cvar_t color_cvar;
	cvar_t fullbright_cvar;
	cvar_t* amf_cvar;
	int model_hint;
	int renderfx;
	qbool disable_texturing;
} custom_model_color_t;

typedef struct entity_s {
	vec3_t					origin;
	vec3_t					angles;	
	struct model_s			*model;			// NULL = no model
	byte					*colormap;
	int						skinnum;		// for Alias models
	struct player_info_s	*scoreboard;	// identify player
	int						renderfx;		// RF_ bit mask
	int						effects;		// EF_ flags like EF_BLUE and etc, atm this used for powerup shells

	int						oldframe;
	int						frame;
	float					framelerp;

	struct efrag_s			*efrag;			// linked list of efrags (FIXME)
	int						visframe;		// last frame this entity was found in an active leaf. only used for static objects

	//int						dlightframe;	// dynamic lighting
	//int						dlightbits;

	//VULT MOTION TRAILS
	float alpha;

	// FIXME: could turn these into a union
	struct mnode_s			*topnode;		// for bmodels, first world node that splits bmodel, or NULL if not split

	qbool     full_light;

	float     r_modelcolor[3];
	float     r_modelalpha;
	float     shadelight;
	float     ambientlight;
	custom_model_color_t* custom_model;
	vec3_t    lightcolor; // LordHavoc: used by model rendering
	vec3_t    lightspot;  // used for shadows

	// vertex lighting only
	int       bestlight;
	int       entity_id;
	int       corona_id;
	double    particle_time;

	// outlining
	float     outlineScale;
} entity_t;

// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct {
	vrect_t		vrect;				// subwindow in video for refresh
									// FIXME: not need vrect next field here?
	vrect_t		aliasvrect;			// scaled Alias version
	int			vrectright, vrectbottom;	// right & bottom screen coords
	int			aliasvrectright, aliasvrectbottom;	// scaled Alias versions
	float		vrectrightedge;			// rightmost right edge we care about,
										//  for use in edge list
	float		fvrectx, fvrecty;		// for floating-point compares
	float		fvrectx_adj, fvrecty_adj; // left and top edges, for clamping
	int			vrect_x_adj_shift20;	// (vrect.x + 0.5 - epsilon) << 20
	int			vrectright_adj_shift20;	// (vrectright + 0.5 - epsilon) << 20
	float		fvrectright_adj, fvrectbottom_adj;
										// right and bottom edges, for clamping
	float		fvrectright;			// rightmost edge, for Alias clamping
	float		fvrectbottom;			// bottommost edge, for Alias clamping
	float		horizontalFieldOfView;	// at Z = 1.0, this many X is visible 
										// 2.0 = 90 degrees
	float		xOrigin;			// should probably always be 0.5
	float		yOrigin;			// between be around 0.3 to 0.5

	vec3_t		vieworg;
	vec3_t		viewangles;
	int         viewheight_test;

	float		fov_x, fov_y;
	
	int			ambientlight;
} refdef_t;

typedef enum {
	fogcalc_none,
	fogcalc_linear,
	fogcalc_exp,
	fogcalc_exp2
} fogcalc_t;

// eye position, enitity list, etc - filled in before calling R_RenderView (TODO: port from ZQuake)
typedef struct {
	double			time;
	qbool			allow_cheats;
	qbool			allow_lumas;
	float			max_watervis;	// how much water transparency we allow: 0..1 (reverse of alpha)
	float			max_fbskins;	// max player skin brightness 0..1
//	int				viewplayernum;  // don't draw own glow when gl_flashblend 1

//	lightstyle_t    *lightstyles;
	qbool           fog_enabled;    // fog is enabled (glsl programs etc should have fog enabled)
	qbool           fog_render;     // fog should be rendered
	fogcalc_t       fog_calculation;
	float           fog_linear_start;
	float           fog_linear_end;
	float           fog_density;    // 0+
	float           fog_color[4];
	float           fog_skycolor[4];// 
	float           fog_sky;        // 0..1 - how much sky is affected by fog

	float           cos_time;
	float           sin_time;

	float           wateralpha;
	qbool           drawFlatFloors;
	qbool           drawFlatWalls;
	qbool           solidTexTurb;
	qbool           drawCaustics;
	qbool           drawWorldOutlines;
	float           distanceScale;

	vec3_t          outline_vpn;
	float           outlineBase;

	float           powerup_scroll_params[4];
} refdef2_t;


// refresh

extern refdef_t	r_refdef;
extern refdef2_t r_refdef2;
extern vec3_t r_origin, vpn, vright, vup;
extern vec3_t vright_noroll, vup_noroll;

extern struct texture_s	*r_notexture_mip;

extern entity_t r_worldentity;

void R_Init(void);
void R_InitTextures(void);
void R_PostProcessScene(void);
void R_RenderView(void);		// must set r_refdef first

void R_Init_EFrags (void);
void R_AddEfrags(entity_t *ent);
void R_NewMap(qbool vid_restart);
void R_NewMapPreLoad(void);

void R_PushDlights(void);


================================================
FILE: src/resource.h
================================================
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by ezQuake.rc
//
#define IDI_ICON1                       101

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        102
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1001
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif


================================================
FILE: src/rulesets.c
================================================
/*
Copyright (C) 2001-2002 A Nourai
Copyright (C) 2015 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "rulesets.h"
#include "input.h"

/* FIXME: Figure out a nicer way to do all this */

static void Rulesets_OnChange_ruleset (cvar_t *var, char *value, qbool *cancel);

typedef struct rulesetDef_s {
	ruleset_t ruleset;
	float maxfps;
	qbool restrictTriggers;
	qbool restrictPacket;
	qbool restrictParticles;
	qbool restrictPlay;
	qbool restrictLogging;
	qbool restrictRollAngle;
	qbool restrictIPC;
	qbool restrictExec;
	qbool restrictSetCalc;
	qbool restrictSetEval;
	qbool restrictSetEx;
} rulesetDef_t;

static rulesetDef_t rulesetDef = {
	rs_default,    // ruleset
	72.0,          // maxfps
	false,         // restrict triggers
	false,         // restrict /packet command
	false,         // restrict particles
	false,         // restrict sound
	false,         // restrict logging
	false,         // restrict rollangle
	false,         // restrict IPC
	false,         // restrict /exec command
	false,         // restrict /set_calc command
	false,         // restrict /set_eval command
	false          // restrict /set_ex command
};

cvar_t ruleset = {"ruleset", "default", 0, Rulesets_OnChange_ruleset};

qbool RuleSets_DisallowExternalTexture(struct model_s *mod)
{
	switch (mod->modhint) {
		case MOD_EYES:
			return true;
		case MOD_BACKPACK:
			return rulesetDef.ruleset == rs_smackdown || rulesetDef.ruleset == rs_qcon || rulesetDef.ruleset == rs_smackdrive;
		default:
			return false;
	}
}

qbool RuleSets_DisallowSimpleTexture(model_t* mod)
{
	switch (mod->modhint) {
		case MOD_EYES:
		case MOD_PLAYER:
		case MOD_SENTRYGUN: // tf
		case MOD_DETPACK:   // tf
			return true; // no replacement allowed

		case MOD_BACKPACK:
			// Now allowed in Thunderdome...
			return rulesetDef.ruleset == rs_smackdown || rulesetDef.ruleset == rs_qcon || rulesetDef.ruleset == rs_smackdrive;

		default:
			return false; // replacement always allowed
	}
}

// for models (gl_outline 1 and 3)
qbool RuleSets_DisallowModelOutline(struct model_s *mod)
{
	if (mod == NULL) {
		// World model - only allow in default ruleset, cheats enabled
		return !(r_refdef2.allow_cheats && rulesetDef.ruleset == rs_default);
	}

	switch (mod->modhint) {
		case MOD_EYES:
		case MOD_THUNDERBOLT:
			return true;
		case MOD_BACKPACK:
			return !cls.demoplayback && (rulesetDef.ruleset == rs_qcon || rulesetDef.ruleset == rs_smackdown || rulesetDef.ruleset == rs_smackdrive);
		default:
			// return to just rs_qcon once backface outlining tested
//			return !cls.demoplayback && (rulesetDef.ruleset == rs_qcon || rulesetDef.ruleset == rs_smackdown || rulesetDef.ruleset == rs_smackdrive);
			return !cls.demoplayback && (rulesetDef.ruleset == rs_qcon);
	}
}

// gl_outline_scale_model
// 0-1 for smackdown and qcon, 0-5 for others
float RuleSets_ModelOutlineScale(void) {
	extern cvar_t gl_outline_scale_model;
	switch(rulesetDef.ruleset) {
		case rs_smackdown:
		case rs_smackdrive:
		case rs_qcon:
			return bound(0.0f, gl_outline_scale_model.value, 1.0f);
		default:
			return bound(0.0f, gl_outline_scale_model.value, 5.0f);
	}
}

// for edges (gl_outline 2 and 3)
qbool RuleSets_AllowEdgeOutline(void)
{
	switch(rulesetDef.ruleset) {
		case rs_qcon:
			return false;
		default:
			return true;
	}
}

qbool Rulesets_AllowTimerefresh(void)
{
	switch(rulesetDef.ruleset) {
		case rs_smackdown:
		case rs_smackdrive:
		case rs_thunderdome:
		case rs_qcon:
			return (cl.standby || cl.spectator || cls.demoplayback);
		default:
			return true;
	}
}

qbool Rulesets_AllowNoShadows(void)
{
	switch(rulesetDef.ruleset) {
		case rs_mtfl:
		case rs_smackdown:
		case rs_smackdrive:
		case rs_thunderdome:
		case rs_qcon:
			return false;
		default:
			return true;
	}
}

qbool Rulesets_AllowAlternateModel (const char* modelName)
{
	switch(rulesetDef.ruleset) {
	case rs_qcon:
		if (! strcmp (modelName, "progs/player.mdl"))
			return false;
		return true;
	default:
		return true;
	}
}

float Rulesets_MaxFPS(void)
{
	return rulesetDef.maxfps;
}

qbool Rulesets_RestrictTriggers(void)
{
	return rulesetDef.restrictTriggers;
}

qbool Rulesets_RestrictPlay(const char* name)
{
	if (!rulesetDef.restrictPlay) {
		return false;
	}

	if (cls.state == ca_active && (cl.spectator || cls.demoplayback || cl.standby)) {
		return false;
	}

	if (name == NULL || cbuf_current != &cbuf_svc) {
		return true;
	}

	if (strstr(name, "ktsound")) {
		return true;
	}

	return false;
}

qbool Rulesets_RestrictPacket(void)
{
	return cls.state == ca_active && !cl.spectator && !cls.demoplayback && !cl.standby && rulesetDef.restrictPacket;
}

qbool Rulesets_RestrictParticles(void)
{
	return !cl.spectator && !cls.demoplayback && !cl.standby && rulesetDef.restrictParticles && !r_refdef2.allow_cheats;
}

qbool Rulesets_RestrictIPC(void)
{
	return cls.state == ca_active && !cl.spectator && !cls.demoplayback && !cl.standby && rulesetDef.restrictIPC && cls.server_adr.type != NA_LOOPBACK;;
}

qbool Rulesets_RestrictExec(void)
{
	return cls.state == ca_active && !cl.spectator && !cls.demoplayback && !cl.standby && rulesetDef.restrictExec && cls.server_adr.type != NA_LOOPBACK;
}

qbool Rulesets_RestrictSetCalc(void)
{
	return cls.state == ca_active && !cl.spectator && !cls.demoplayback && !cl.standby && rulesetDef.restrictSetCalc;
}

qbool Rulesets_RestrictSetEval(void)
{
	return cls.state == ca_active && !cl.spectator && !cls.demoplayback && !cl.standby && rulesetDef.restrictSetEval;
}

qbool Rulesets_RestrictSetEx(void)
{
	return cls.state == ca_active && !cl.spectator && !cls.demoplayback && !cl.standby && rulesetDef.restrictSetEx;
}

qbool Rulesets_RestrictTCL(void)
{
	switch(rulesetDef.ruleset) {
		case rs_smackdown:
		case rs_smackdrive:
		case rs_thunderdome:
		case rs_qcon:
			return true;
		case rs_mtfl:
		default:
			return false;
	}
}

const char *Rulesets_Ruleset(void)
{
	switch(rulesetDef.ruleset) {
		case rs_mtfl:
			return "MTFL";
		case rs_smackdown:
			return "smackdown";
		case rs_thunderdome:
			return "thunderdome";
		case rs_qcon:
			return "qcon";
		case rs_smackdrive:
			return "smackdrive";
		default:
			return "default";
	}
}

static void Rulesets_Smackdown(qbool enable)
{
	extern cvar_t cl_independentPhysics, cl_c2spps;
	extern cvar_t cl_hud;
	extern cvar_t cl_rollalpha;
	extern cvar_t r_shiftbeam;
	extern cvar_t allow_scripts;
	extern cvar_t cl_iDrive;
	extern cvar_t scr_allowsnap;
	int i;

	locked_cvar_t disabled_cvars[] = {
		{&allow_scripts, "0"},  // disable movement scripting
		{&cl_iDrive, "0"},      // disable strafing aid
		{&cl_hud, "0"},         // allows you place any text on the screen & filter incoming messages (hud strings)
		{&cl_rollalpha, "20"},  // allows you to not dodge while seeing enemies dodging
		{&r_shiftbeam, "0"},    // perphaps some people would think this allows you to aim better (maybe should be added for demo playback and spectating only)
		{&scr_allowsnap, "1"}
	};

	if (enable) {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++) {
			Cvar_RulesetSet(disabled_cvars[i].var, disabled_cvars[i].value, 2);
			Cvar_Set(disabled_cvars[i].var, disabled_cvars[i].value);
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) | CVAR_ROM);
		}

		if (cl_independentPhysics.value) {
			Cvar_Set(&cl_c2spps, "0"); // people were complaining that player move is jerky with this. however this has not much to do with independent physics, but people are too paranoid about it
			Cvar_SetFlags(&cl_c2spps, Cvar_GetFlags(&cl_c2spps) | CVAR_ROM);
		}

		rulesetDef.maxfps = 77;
		rulesetDef.restrictTriggers = true;
		rulesetDef.restrictPacket = true; // packet command could have been exploited for external timers
		rulesetDef.restrictParticles = true;
		rulesetDef.restrictLogging = true;
		rulesetDef.restrictRollAngle = true;
		rulesetDef.ruleset = rs_smackdown;
		rulesetDef.restrictIPC = true;
		rulesetDef.restrictExec = true;
		rulesetDef.restrictSetCalc = true;
		rulesetDef.restrictSetEval = true;
		rulesetDef.restrictSetEx = true;
		rulesetDef.restrictPlay = true;
	} else {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++)
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) & ~CVAR_ROM);

		if (cl_independentPhysics.value)
			Cvar_SetFlags(&cl_c2spps, Cvar_GetFlags(&cl_c2spps) & ~CVAR_ROM);

		rulesetDef.maxfps = 72.0;
		rulesetDef.restrictTriggers = false;
		rulesetDef.restrictPacket = false;
		rulesetDef.restrictParticles = false;
		rulesetDef.restrictLogging = false;
		rulesetDef.restrictRollAngle = false;
		rulesetDef.ruleset = rs_default;
		rulesetDef.restrictIPC = false;
		rulesetDef.restrictExec = false;
		rulesetDef.restrictSetCalc = false;
		rulesetDef.restrictSetEval = false;
		rulesetDef.restrictSetEx = false;
		rulesetDef.restrictPlay = false;
	}
}

static void Rulesets_Qcon(qbool enable)
{
	extern cvar_t cl_independentPhysics, cl_c2spps;
	extern cvar_t cl_hud;
	extern cvar_t cl_rollalpha;
	extern cvar_t r_shiftbeam;
	extern cvar_t allow_scripts;
	extern cvar_t cl_iDrive;
	int i;

	locked_cvar_t disabled_cvars[] = {
		{&allow_scripts, "0"},  // disable movement scripting
		{&cl_iDrive, "0"},      // disable strafing aid
		{&cl_hud, "0"},         // allows you place any text on the screen & filter incoming messages (hud strings)
		{&cl_rollalpha, "20"},  // allows you to not dodge while seeing enemies dodging
		{&r_shiftbeam, "0"}     // perphaps some people would think this allows you to aim better (maybe should be added for demo playback and spectating only)
	};

	if (enable) {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++) {
			Cvar_RulesetSet(disabled_cvars[i].var, disabled_cvars[i].value, 2);
			Cvar_Set(disabled_cvars[i].var, disabled_cvars[i].value);
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) | CVAR_ROM);
		}

		if (cl_independentPhysics.value) {
			Cvar_Set(&cl_c2spps, "0"); // people were complaining that player move is jerky with this. however this has not much to do with independent physics, but people are too paranoid about it
			Cvar_SetFlags(&cl_c2spps, Cvar_GetFlags(&cl_c2spps) | CVAR_ROM);
		}

		rulesetDef.maxfps = 77;
		rulesetDef.restrictTriggers = true;
		rulesetDef.restrictPacket = true; // packet command could have been exploited for external timers
		rulesetDef.restrictParticles = true;
		rulesetDef.restrictPlay = true;
		rulesetDef.restrictLogging = true;
		rulesetDef.restrictRollAngle = true;
		rulesetDef.ruleset = rs_qcon;
		rulesetDef.restrictIPC = true;
		rulesetDef.restrictExec = true;
		rulesetDef.restrictSetCalc = true;
		rulesetDef.restrictSetEval = true;
		rulesetDef.restrictSetEx = true;
	} else {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++)
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) & ~CVAR_ROM);

		if (cl_independentPhysics.value)
			Cvar_SetFlags(&cl_c2spps, Cvar_GetFlags(&cl_c2spps) & ~CVAR_ROM);

		rulesetDef.maxfps = 72.0;
		rulesetDef.restrictTriggers = false;
		rulesetDef.restrictPacket = false;
		rulesetDef.restrictParticles = false;
		rulesetDef.restrictPlay = false;
		rulesetDef.restrictLogging = false;
		rulesetDef.restrictRollAngle = false;
		rulesetDef.ruleset = rs_default;
		rulesetDef.restrictIPC = false;
		rulesetDef.restrictExec = false;
		rulesetDef.restrictSetCalc = false;
		rulesetDef.restrictSetEval = false;
		rulesetDef.restrictSetEx = false;
	}
}
static void Rulesets_Thunderdome(qbool enable)
{
	extern cvar_t cl_independentPhysics, cl_c2spps;
	extern cvar_t cl_hud;
	extern cvar_t r_shiftbeam;
	extern cvar_t allow_scripts;
	extern cvar_t cl_iDrive;
	int i;

	locked_cvar_t disabled_cvars[] = {
		{&allow_scripts, "0"},  // disable movement scripting
		{&cl_iDrive, "0"},      // disable strafing aid
		{&cl_hud, "0"},         // allows you place any text on the screen & filter incoming messages (hud strings)
		{&r_shiftbeam, "0"}     // perphaps some people would think this allows you to aim better (maybe should be added for demo playback and spectating only)
	};

	if (enable) {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++) {
			Cvar_RulesetSet(disabled_cvars[i].var, disabled_cvars[i].value, 2);
			Cvar_Set(disabled_cvars[i].var, disabled_cvars[i].value);
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) | CVAR_ROM);
		}

		if (cl_independentPhysics.value) {
			Cvar_Set(&cl_c2spps, "0"); // people were complaining that player move is jerky with this. however this has not much to do with independent physics, but people are too paranoid about it
			Cvar_SetFlags(&cl_c2spps, Cvar_GetFlags(&cl_c2spps) | CVAR_ROM);
		}

		rulesetDef.maxfps = 77;
		rulesetDef.restrictTriggers = true;
		rulesetDef.restrictPacket = true; // packet command could have been exploited for external timers
		rulesetDef.restrictParticles = false;
		rulesetDef.restrictLogging = true;
		rulesetDef.restrictRollAngle = true;
		rulesetDef.ruleset = rs_thunderdome;
		rulesetDef.restrictIPC = true;
		rulesetDef.restrictExec = true;
		rulesetDef.restrictSetCalc = true;
		rulesetDef.restrictSetEval = true;
		rulesetDef.restrictSetEx = true;
		rulesetDef.restrictPlay = true;
	} else {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++)
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) & ~CVAR_ROM);

		if (cl_independentPhysics.value)
			Cvar_SetFlags(&cl_c2spps, Cvar_GetFlags(&cl_c2spps) & ~CVAR_ROM);

		rulesetDef.maxfps = 72.0;
		rulesetDef.restrictTriggers = false;
		rulesetDef.restrictPacket = false;
		rulesetDef.restrictParticles = false;
		rulesetDef.restrictLogging = false;
		rulesetDef.restrictRollAngle = false;
		rulesetDef.ruleset = rs_default;
		rulesetDef.restrictIPC = false;
		rulesetDef.restrictExec = false;
		rulesetDef.restrictSetCalc = false;
		rulesetDef.restrictSetEval = false;
		rulesetDef.restrictSetEx = false;
		rulesetDef.restrictPlay = false;
	}
}
static void Rulesets_MTFL(qbool enable)
{
	/* TODO:
	   f_flashout trigger
	   block all other ways to made textures flat(simple)
	   ?disable external textures for detpacks, grenades, sentry, disp, etc?
	 */
	extern cvar_t cl_c2spps, r_fullbrightSkins;
	extern cvar_t amf_detpacklights;
	extern cvar_t gl_picmip, gl_max_size, r_drawflat;
	extern cvar_t vid_hwgammacontrol;
	extern cvar_t gl_textureless;

	int i = 0;

	locked_cvar_t disabled_cvars[] = {
		{&r_drawflat, "0"},
		{&amf_detpacklights, "0"},
		{&gl_textureless, "0"},
		{&r_fullbrightSkins, "0"},
		{&vid_hwgammacontrol, "2"},
		{&cl_c2spps, "0"},
	};

	limited_cvar_max_t limited_max_cvars[] = {
		{&gl_picmip, "3"},
	};

	limited_cvar_min_t limited_min_cvars[] = {
		{&gl_max_size, "512"},
	};

	if (enable) {
		for (; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++) {
			Cvar_RulesetSet(disabled_cvars[i].var, disabled_cvars[i].value, 2);
			Cvar_Set(disabled_cvars[i].var, disabled_cvars[i].value);
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) | CVAR_ROM);
		}

		for (i = 0; i < (sizeof(limited_max_cvars) / sizeof(limited_max_cvars[0])); i++) {
			Cvar_RulesetSet(limited_max_cvars[i].var, limited_max_cvars[i].maxrulesetvalue, 1);
			Cvar_SetFlags(limited_max_cvars[i].var, Cvar_GetFlags(limited_max_cvars[i].var) | CVAR_RULESET_MAX);
		}

		for (i = 0; i < (sizeof(limited_min_cvars) / sizeof(limited_min_cvars[0])); i++) {
			Cvar_RulesetSet(limited_min_cvars[i].var, limited_min_cvars[i].minrulesetvalue, 0);
			Cvar_SetFlags(limited_min_cvars[i].var, Cvar_GetFlags(limited_min_cvars[i].var) | CVAR_RULESET_MIN);
		}

		rulesetDef.restrictRollAngle = false;
		rulesetDef.ruleset = rs_mtfl;
		v_gamma.modified = true;
	} else {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++)
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) & ~CVAR_ROM);

		for (i = 0; i < (sizeof(limited_max_cvars) / sizeof(limited_max_cvars[0])); i++)
			Cvar_SetFlags(limited_max_cvars[i].var, Cvar_GetFlags(limited_max_cvars[i].var) & ~CVAR_RULESET_MAX);

		for (i = 0; i < (sizeof(limited_min_cvars) / sizeof(limited_min_cvars[0])); i++)
			Cvar_SetFlags(limited_min_cvars[i].var, Cvar_GetFlags(limited_min_cvars[i].var) & ~CVAR_RULESET_MIN);

		rulesetDef.ruleset = rs_default;
		rulesetDef.restrictRollAngle = false;
		v_gamma.modified = true;
	}
}

static void Rulesets_Smackdrive(qbool enable)
{
	extern cvar_t cl_independentPhysics, cl_c2spps;
	extern cvar_t cl_hud;
	extern cvar_t cl_rollalpha;
	extern cvar_t r_shiftbeam;
	extern cvar_t allow_scripts;
	extern cvar_t scr_allowsnap;
	int i;

	locked_cvar_t disabled_cvars[] = {
		{&allow_scripts, "0"},  // disable movement scripting
		{&cl_hud, "0"},         // allows you place any text on the screen & filter incoming messages (hud strings)
		{&cl_rollalpha, "20"},  // allows you to not dodge while seeing enemies dodging
		{&r_shiftbeam, "0"},    // perphaps some people would think this allows you to aim better (maybe should be added for demo playback and spectating only)
		{&scr_allowsnap, "1"}
	};

	if (enable) {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++) {
			Cvar_RulesetSet(disabled_cvars[i].var, disabled_cvars[i].value, 2);
			Cvar_Set(disabled_cvars[i].var, disabled_cvars[i].value);
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) | CVAR_ROM);
		}

		if (cl_independentPhysics.value) {
			Cvar_Set(&cl_c2spps, "0"); // people were complaining that player move is jerky with this. however this has not much to do with independent physics, but people are too paranoid about it
			Cvar_SetFlags(&cl_c2spps, Cvar_GetFlags(&cl_c2spps) | CVAR_ROM);
		}

		rulesetDef.maxfps = 77;
		rulesetDef.restrictTriggers = true;
		rulesetDef.restrictPacket = true; // packet command could have been exploited for external timers
		rulesetDef.restrictParticles = true;
		rulesetDef.restrictLogging = true;
		rulesetDef.restrictRollAngle = true;
		rulesetDef.ruleset = rs_smackdrive;
		rulesetDef.restrictIPC = true;
		rulesetDef.restrictExec = true;
		rulesetDef.restrictSetCalc = true;
		rulesetDef.restrictSetEval = true;
		rulesetDef.restrictSetEx = true;
		rulesetDef.restrictPlay = true;
	} else {
		for (i = 0; i < (sizeof(disabled_cvars) / sizeof(disabled_cvars[0])); i++)
			Cvar_SetFlags(disabled_cvars[i].var, Cvar_GetFlags(disabled_cvars[i].var) & ~CVAR_ROM);

		if (cl_independentPhysics.value)
			Cvar_SetFlags(&cl_c2spps, Cvar_GetFlags(&cl_c2spps) & ~CVAR_ROM);

		rulesetDef.maxfps = 72.0;
		rulesetDef.restrictTriggers = false;
		rulesetDef.restrictPacket = false;
		rulesetDef.restrictParticles = false;
		rulesetDef.restrictLogging = false;
		rulesetDef.restrictRollAngle = false;
		rulesetDef.ruleset = rs_default;
		rulesetDef.restrictIPC = false;
		rulesetDef.restrictExec = false;
		rulesetDef.restrictSetCalc = false;
		rulesetDef.restrictSetEval = false;
		rulesetDef.restrictSetEx = false;
		rulesetDef.restrictPlay = false;
	}
}

static void Rulesets_Default(void)
{
	rulesetDef.ruleset = rs_default;
}

void Rulesets_Init(void)
{
	int temp;

	Cvar_SetCurrentGroup(CVAR_GROUP_USERINFO);
	Cvar_Register(&ruleset);

	if ((temp = COM_CheckParm(cmdline_param_client_ruleset)) && temp + 1 < COM_Argc()) {
		if (!strcasecmp(COM_Argv(temp + 1), "smackdown")) {
			Cvar_Set(&ruleset, "smackdown");
			return;
		} else if (!strcasecmp(COM_Argv(temp + 1), "thunderdome")) {
			Cvar_Set(&ruleset, "thunderdome");
			return;
		} else if (!strcasecmp(COM_Argv(temp + 1), "mtfl")) {
			Cvar_Set(&ruleset, "mtfl");
			return;
		} else if (strcasecmp(COM_Argv(temp + 1), "qcon")) {
			Cvar_Set(&ruleset, "qcon");
			return;
		} else if (strcasecmp(COM_Argv(temp + 1), "default")){
			Cvar_Set(&ruleset, "default");
			return;
		} else {
			Rulesets_Default();
			return;
		}
	}
}

void Rulesets_OnChange_indphys(cvar_t *var, char *value, qbool *cancel)
{
	if (cls.state != ca_disconnected) {
		Com_Printf("%s can be changed only when disconnected\n", var->name);
		*cancel = true;
	}
	else *cancel = false;
}

void Rulesets_OnChange_r_fullbrightSkins(cvar_t *var, char *value, qbool *cancel)
{
	char *fbs;
	qbool fbskins_policy = (cls.demoplayback || cl.spectator) ? 1 :
		*(fbs = Info_ValueForKey(cl.serverinfo, "fbskins")) ? bound(0, Q_atof(fbs), 1) :
		cl.teamfortress ? 0 : 1;
	float fbskins = bound(0.0, Q_atof (value), fbskins_policy);

	if (!cl.spectator && cls.state != ca_disconnected) {
		if (fbskins > 0.0) {
			Cbuf_AddText(va("say all skins %d%% fullbright\n", (int) (fbskins * 100.0)));
		} else {
			Cbuf_AddText(va("say not using fullbright skins\n"));
		}
	}
}

void Rulesets_OnChange_allow_scripts (cvar_t *var, char *value, qbool *cancel)
{
	char *p;
	qbool progress;
	int val;

	p = Info_ValueForKey(cl.serverinfo, "status");
	progress = (strstr (p, "left")) ? true : false;
	val = Q_atoi(value);

	if (cls.state >= ca_connected && progress && !cl.spectator) {
		Com_Printf ("%s changes are not allowed during the match.\n", var->name);
		*cancel = true;
		return;
	}

	IN_ClearProtectedKeys ();

	if (!cl.spectator && cls.state != ca_disconnected) {
		if (val < 1) {
			Cbuf_AddText("say not using scripts\n");
		} else if (val < 2) {
			Cbuf_AddText("say using simple scripts\n");
		} else {
			Cbuf_AddText("say using advanced scripts\n");
		}
	}
}

void Rulesets_OnChange_cl_delay_packet(cvar_t *var, char *value, qbool *cancel)
{
	int ival = Q_atoi(value);

	if (ival == var->integer) {
		// no change
		return;
	}

	if (var == &cl_delay_packet && (ival < 0 || ival > CL_MAX_PACKET_DELAY * 2)) {
		Com_Printf("%s must be between 0 and %d\n", var->name, CL_MAX_PACKET_DELAY * 2);
		*cancel = true;
		return;
	}

	if (var == &cl_delay_packet_dev && (ival < 0 || ival > CL_MAX_PACKET_DELAY_DEVIATION)) {
		Com_Printf("%s must be between 0 and %d\n", var->name, CL_MAX_PACKET_DELAY_DEVIATION);
		*cancel = true;
		return;
	}

	if (var == &cl_delay_packet_target && (ival < 0 || ival > CL_MAX_PACKET_DELAY_TARGET)) {
		Com_Printf("%s must be between 0 and %d\n", var->name, CL_MAX_PACKET_DELAY_TARGET);
		*cancel = true;
		return;
	}

	if (cls.state == ca_active) {
		if ((cl.standby) || (cl.teamfortress)) {
			char announce[128];
			int delay_target_ms = (var == &cl_delay_packet_target ? ival : cl_delay_packet_target.integer);
			int delay_deviation = (var == &cl_delay_packet_dev ? ival : cl_delay_packet_dev.integer);
			int delay_constant = (var == &cl_delay_packet ? ival : cl_delay_packet.integer);

			if (delay_target_ms) {
				snprintf(announce, sizeof(announce), "say delay packet: target ping %d ms (%dms dev)\n", delay_target_ms, delay_deviation);
			}
			else if (delay_constant) {
				snprintf(announce, sizeof(announce), "say delay packet: adding %d ms (%dms dev)\n", delay_constant, delay_deviation);
			}
			else {
				snprintf(announce, sizeof(announce), "say delay packet: off\n");
			}

			// allow in standby or teamfortress. For teamfortress, more often than not
			// People 1on1 without "match mode" and they may want to sync pings.
			Cbuf_AddText(announce);
		}
		else {
			// disallow during the match
			Com_Printf("%s changes are not allowed during the match\n", var->name);
			*cancel = true;
		}
	}
	else {
		// allow in not fully connected state
	}
}

void Rulesets_OnChange_cl_iDrive(cvar_t *var, char *value, qbool *cancel)
{
	int ival = Q_atoi(value);	// this is used in the code
	float fval = Q_atof(value); // this is used to check value validity

	if (ival == var->integer && fval == var->value) {
		// no change
		return;
	}

	if (fval != 0 && fval != 1) {
		Com_Printf("Invalid value for %s, use 0 or 1.\n", var->name);
		*cancel = true;
		return;
	}

	if (cls.state == ca_active) {
		if (cl.standby) {
			// allow in standby
			Cbuf_AddText(va("say side step aid (strafescript): %s\n", ival ? "on" : "off"));
		}
		else {
			// disallow during the match
			Com_Printf("%s changes are not allowed during the match\n", var->name);
			*cancel = true;
		}
	} else {
		// allow in not fully connected state
	}
}

void Rulesets_OnChange_cl_fakeshaft(cvar_t *var, char *value, qbool *cancel)
{
	float fakeshaft = Q_atof(value);


	if (!cl.spectator && cls.state != ca_disconnected) {
		if (fakeshaft == 2)
			Cbuf_AddText("say fakeshaft 2 (emulation of fakeshaft 0 for servers with antilag feature)\n");
		else if (fakeshaft > 0.999)
			Cbuf_AddText("say fakeshaft on\n");
		else if (fakeshaft < 0.001)
			Cbuf_AddText("say fakeshaft off\n");
		else
			Cbuf_AddText(va("say fakeshaft %.1f%%\n", fakeshaft * 100.0));
	}
}

static void Rulesets_OnChange_ruleset(cvar_t *var, char *value, qbool *cancel)
{
	extern void Cmd_ReInitAllMacro(void);

	if (cls.state != ca_disconnected) {
		Com_Printf("%s can be changed only when disconnected\n", var->name);
		*cancel = true;
		return;
	}

	if (strncasecmp(value, "smackdown", sizeof("smackdown")) &&
			strncasecmp(value, "thunderdome", sizeof("thunderdome")) &&
			strncasecmp(value, "mtfl", sizeof("mtfl")) &&
			strncasecmp(value, "qcon", sizeof("qcon")) &&
			strncasecmp(value, "smackdrive", sizeof("smackdrive")) &&
			strncasecmp(value, "default", sizeof("default"))) {
		Com_Printf_State(PRINT_INFO, "Unknown ruleset \"%s\"\n", value);
		*cancel = true;
		return;
	}

	// All checks passed  so we can remove old ruleset and set a new one
	switch (rulesetDef.ruleset) {
		case rs_mtfl:
			Rulesets_MTFL(false);
			break;
		case rs_smackdown:
			Rulesets_Smackdown(false);
			break;
		case rs_qcon:
			Rulesets_Qcon(false);
			break;
		case rs_thunderdome:
			Rulesets_Thunderdome(false);
			break;
		case rs_smackdrive:
			Rulesets_Smackdrive(false);
		case rs_default:
			break;
		default:
			break;
	}

	// we need to mark custom textures in the memory (like for backpack and eyes) to be reloaded again
	Cache_Flush();

	if (!strncasecmp(value, "smackdown", sizeof("smackdown"))) {
		Rulesets_Smackdown(true);
		Com_Printf_State(PRINT_OK, "Ruleset Smackdown initialized\n");
	} else if (!strncasecmp(value, "mtfl", sizeof("mtfl"))) {
		Rulesets_MTFL(true);
		Com_Printf_State(PRINT_OK, "Ruleset MTFL initialized\n");
	} else if (!strncasecmp(value, "thunderdome", sizeof("thunderdome"))) {
		Rulesets_Thunderdome(true);
		Com_Printf_State(PRINT_OK, "Ruleset Thunderdome initialized\n");
	} else if (!strncasecmp(value, "qcon", sizeof("qcon"))) {
		Rulesets_Qcon(true);
		Com_Printf_State(PRINT_OK, "Ruleset Qcon initialized\n");
	} else if (!strncasecmp(value, "smackdrive", sizeof("smackdrive"))) {
		Rulesets_Smackdrive(true);
		Com_Printf_State(PRINT_OK, "Ruleset Smackdrive initialized\n");
	} else if (!strncasecmp(value, "default", sizeof("default"))) {
		Rulesets_Default();
		Com_Printf_State(PRINT_OK, "Ruleset default initialized\n");
	} else {
		Sys_Error("OnChange_ruleset: WTF?\n");
		// this will never happen
		*cancel = true;
		return;
	}

	Cmd_ReInitAllMacro();
	IN_ClearProtectedKeys();
	Info_SetValueForStarKey(cls.userinfo, "*rsn", value, MAX_INFO_STRING);
}

int Rulesets_MaxSequentialWaitCommands(void)
{
	switch (rulesetDef.ruleset) {
	case rs_qcon:
		return 10;
	default:
		return 32768;
	}
}

qbool Ruleset_BlockHudPicChange(void)
{
	switch (rulesetDef.ruleset) {
	case rs_qcon:
	case rs_smackdown:
	case rs_smackdrive:
	case rs_thunderdome:
		return cls.state != ca_disconnected && !(cl.standby || cl.spectator || cls.demoplayback);
	default:
		return false;
	}
}

qbool Ruleset_AllowPolygonOffset(entity_t* ent)
{
	switch (rulesetDef.ruleset) {
	case rs_qcon:
		return false;
	case rs_default:
		return true;
	default:
		return ent->model && ent->model->isworldmodel;
	}
}

// Not technically ruleset-based but limits functionaly for similar reasons...
qbool Ruleset_IsLumaAllowed(struct model_s *mod)
{
	switch (mod->modhint)
	{
	case MOD_EYES:
	case MOD_BACKPACK:
	case MOD_PLAYER:

	case MOD_SENTRYGUN: // tf
	case MOD_DETPACK:   // tf

		return false; // no luma for such models

	default:

		return true; // luma allowed
	}
}

qbool Rulesets_ToggleWhenFlashed(void)
{
	return rulesetDef.ruleset == rs_mtfl;
}

qbool Rulesets_FullbrightModel(struct model_s* model)
{
	extern cvar_t gl_fb_models;
	qbool protected_model = (model->modhint == MOD_EYES || model->modhint == MOD_BACKPACK) && rulesetDef.ruleset != rs_default;
	qbool fb_requested = gl_fb_models.integer == 1 && model->modhint != MOD_GIB && model->modhint != MOD_VMODEL && !Ruleset_IsLocalSinglePlayerGame();

	return !protected_model && fb_requested;
}

const char* Ruleset_BlockPlayerCountMacros(void)
{
	if (rulesetDef.ruleset == rs_mtfl) {
		return BANNED_BY_MTFL;
	}
	return NULL;
}

qbool Ruleset_AllowPowerupShell(model_t* model)
{
	// always allow powerupshells for specs or demos.
	// do not allow powerupshells for eyes in other cases
	extern cvar_t gl_powerupshells;

	return (bound(0, gl_powerupshells.value, 1) && ((cls.demoplayback || cl.spectator) || model->modhint != MOD_EYES));
}

qbool Ruleset_CanLogConsole(void)
{
	return cls.demoplayback || cls.state != ca_active || cl.standby || cl.countdown || !rulesetDef.restrictLogging;
}

qbool Ruleset_AllowNoHardwareGamma(void)
{
	return rulesetDef.ruleset != rs_mtfl;
}

float Ruleset_RollAngle(void)
{
	extern cvar_t cl_rollangle;

	if (cls.demoplayback || cl.spectator || !rulesetDef.restrictRollAngle) {
		return fabs(cl_rollangle.value);
	}

	return bound(0.0f, cl_rollangle.value, 5.0f);
}

#ifndef CLIENTONLY
extern cvar_t     maxclients;
qbool Ruleset_IsLocalSinglePlayerGame(void)
{
	return com_serveractive && cls.state == ca_active && !cl.deathmatch && maxclients.integer == 1;
}
#endif


================================================
FILE: src/rulesets.h
================================================
/*
Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"

#define BANNED_BY_MTFL "banned by MTFL ruleset"
#define MTFL_FLASH_GAMMA (0.55)
#define MTFL_FLASH_CONTRAST (1.0)

typedef struct locked_cvar_s {
	cvar_t *var;
	char *value;
} locked_cvar_t;

typedef struct limited_cvar_max_s {
	cvar_t *var;
	char *maxrulesetvalue;
} limited_cvar_max_t;

typedef struct limited_cvar_min_s {
	cvar_t *var;
	char *minrulesetvalue;
} limited_cvar_min_t;

typedef enum {
	rs_default,
	rs_smackdown,
	rs_thunderdome,
	rs_qcon,
	rs_mtfl,
	rs_smackdrive
} ruleset_t;

void  Rulesets_Init(void);
const char* Rulesets_Ruleset(void);
qbool Rulesets_AllowTimerefresh(void);
float Rulesets_MaxFPS(void);
qbool Rulesets_RestrictTriggers(void);
qbool Rulesets_RestrictPacket(void);
qbool Rulesets_RestrictParticles(void);
qbool Rulesets_RestrictExec(void);
qbool Rulesets_RestrictIPC(void);
qbool Rulesets_RestrictSetCalc(void);
qbool Rulesets_RestrictSetEval(void);
qbool Rulesets_RestrictSetEx(void);
qbool Rulesets_AllowNoShadows(void);
qbool Rulesets_RestrictTCL(void);
qbool Rulesets_RestrictPlay(const char* name);
int Rulesets_MaxSequentialWaitCommands(void);
qbool Ruleset_BlockHudPicChange(void);
qbool Ruleset_AllowPolygonOffset(entity_t* ent);
qbool Rulesets_AllowAlternateModel(const char* modelName);
qbool RuleSets_DisallowModelOutline(struct model_s *mod);
float RuleSets_ModelOutlineScale(void);
qbool RuleSets_AllowEdgeOutline(void);
qbool RuleSets_DisallowExternalTexture(struct model_s *mod);
qbool Ruleset_IsLumaAllowed(struct model_s *mod);
qbool Ruleset_AllowPowerupShell(struct model_s* mod);
qbool RuleSets_DisallowSimpleTexture(struct model_s *mod);
qbool Ruleset_AllowNoHardwareGamma(void);

// OnChange functions controling when a variable value changes
void Rulesets_OnChange_indphys (cvar_t *var, char *value, qbool *cancel);
void Rulesets_OnChange_r_fullbrightSkins (cvar_t *var, char *value, qbool *cancel);
void Rulesets_OnChange_allow_scripts (cvar_t *var, char *value, qbool *cancel);
void Rulesets_OnChange_cl_fakeshaft (cvar_t *var, char *value, qbool *cancel);
void Rulesets_OnChange_cl_delay_packet(cvar_t *var, char *value, qbool *cancel);
void Rulesets_OnChange_cl_iDrive(cvar_t *var, char *value, qbool *cancel);

qbool Rulesets_ToggleWhenFlashed(void);
qbool Rulesets_FullbrightModel(struct model_s* model);
const char* Ruleset_BlockPlayerCountMacros(void);

qbool Ruleset_CanLogConsole(void);
float Ruleset_RollAngle(void);

#ifndef CLIENTONLY
extern cvar_t     maxclients;
qbool Ruleset_IsLocalSinglePlayerGame(void);
#else
#define Ruleset_IsLocalSinglePlayerGame() (0)
#endif


================================================
FILE: src/sbar.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: sbar.c,v 1.42 2007-09-14 13:29:29 disconn3ct Exp $
*/
// sbar.c -- status bar code

#include "quakedef.h"
#include <jansson.h>
#ifndef CLIENTONLY
#include "server.h"
#endif
#include "hud.h"
#include "hud_common.h"
#include "vx_stuff.h"
#include "gl_model.h"
#include "r_texture.h"
#include "teamplay.h"
#include "utils.h"
#include "sbar.h"
#include "keys.h"
#include "common_draw.h"

#include "qsound.h"

int CL_LoginImageId(const char* name);
static int JSON_readint(json_t* json);
static const char* JSON_readstring(json_t* json);
static mpic_t* CL_LoginFlag(int id);
qbool CL_LoginImageLoad(const char* path);
static void OnChange_scr_scoreboard_login_flagfile(cvar_t*, char*, qbool*);

typedef struct loginimage_s {
	char name[16];
	mpic_t pic;
} loginimage_t;

static struct {
	loginimage_t* images;
	size_t image_count;
	int bot_image_index;
	int max_width;
	int max_height;
} login_image_data;

#define FONT_WIDTH                 8 // Used for allocating space for scoreboard columns
#define SHORT_SPECTATOR_NAME_LEN   5 // if it's not teamplay, there is only room for 4 characters here

int sb_updates;		// if >= vid.numpages, no update needed

// --> mqwcl 0.96 oldhud customisation
//cvar_t  sbar_teamfrags = {"scr_sbar_teamfrags", "1"};
//cvar_t  sbar_fraglimit = {"scr_sbar_fraglimit", "1"};

cvar_t  sbar_drawfaceicon   = {"scr_sbar_drawfaceicon",     "1"};
cvar_t  sbar_drawammoicon   = {"scr_sbar_drawammoicon",     "1"};
cvar_t  sbar_drawarmoricon  = {"scr_sbar_drawarmoricon",    "1"};
cvar_t  sbar_drawguns       = {"scr_sbar_drawguns",         "1"};
cvar_t  sbar_drawammocounts = {"scr_sbar_drawammocounts",   "1"};
cvar_t  sbar_drawitems      = {"scr_sbar_drawitems",        "1"};
cvar_t  sbar_drawsigils     = {"scr_sbar_drawsigils",       "1"};
cvar_t  sbar_drawhealth     = {"scr_sbar_drawhealth",       "1"};
cvar_t  sbar_drawarmor      = {"scr_sbar_drawarmor",        "1"};
cvar_t  sbar_drawarmor666   = {"scr_sbar_drawarmor666",     "1"};
cvar_t  sbar_drawammo       = {"scr_sbar_drawammo",         "1"};
cvar_t  sbar_lowammo        = {"scr_sbar_lowammo",          "5"};

cvar_t  hud_centerranking              = { "scr_scoreboard_centered",   "1" };
cvar_t  hud_rankingpos_y               = { "scr_scoreboard_posy",       "0" };
cvar_t  hud_rankingpos_x               = { "scr_scoreboard_posx",       "0" };
cvar_t  hud_faderankings               = { "scr_scoreboard_fadescreen", "0" };
cvar_t  scr_scoreboard_login_names     = { "scr_scoreboard_login_names", "1" };
cvar_t  scr_scoreboard_login_indicator = { "scr_scoreboard_login_indicator", "&cffc*&r" };
cvar_t  scr_scoreboard_login_color     = { "scr_scoreboard_login_color", "255 255 192" };
cvar_t  scr_scoreboard_login_flagfile  = { "scr_scoreboard_login_flagfile", "flags", 0, OnChange_scr_scoreboard_login_flagfile };

//cvar_t  hud_ranks_separate  = {"scr_ranks_separate",   "1"};
// <-- mqwcl 0.96 oldhud customisation

mpic_t		*sb_nums[2][11];
mpic_t		*sb_colon, *sb_slash;
mpic_t		*sb_ibar;
mpic_t		*sb_sbar;
mpic_t		*sb_scorebar;
mpic_t      sb_ib_ammo[4];

mpic_t		*sb_weapons[7][8];	// 0 is active, 1 is owned, 2-5 are flashes
mpic_t		*sb_ammo[4];
mpic_t		*sb_sigil[4];
mpic_t		*sb_armor[3];
mpic_t		*sb_items[32];

mpic_t	*sb_faces[5][2];		// 0 is dead, 1-4 are alive
// 0 is static, 1 is temporary animation
mpic_t	*sb_face_invis;
mpic_t	*sb_face_quad;
mpic_t	*sb_face_invuln;
mpic_t	*sb_face_invis_invuln;

qbool	sb_showscores;
qbool	sb_showteamscores;

int			sb_lines;			// scan lines to draw

static int	sbar_xofs;

cvar_t	scr_centerSbar                = {"scr_centerSbar",                "1"};

cvar_t	scr_compactHud                = {"scr_compactHud",                "0"};
cvar_t	scr_compactHudAlign           = {"scr_compactHudAlign",           "0"};

cvar_t	scr_drawHFrags                = {"scr_drawHFrags",                "1"};
cvar_t	scr_drawVFrags                = {"scr_drawVFrags",                "1"};

cvar_t scr_scoreboard_afk             = {"scr_scoreboard_afk",            "1"};
cvar_t scr_scoreboard_afk_style       = {"scr_scoreboard_afk_style",      "1"};

cvar_t	scr_scoreboard_teamsort       = {"scr_scoreboard_teamsort",       "1"};
cvar_t	scr_scoreboard_forcecolors    = {"scr_scoreboard_forcecolors",    "1"};
cvar_t	scr_scoreboard_showfrags      = {"scr_scoreboard_showfrags",      "1"};
cvar_t	scr_scoreboard_showflagstats  = {"scr_scoreboard_showflagstats",  "0"};
cvar_t	scr_scoreboard_drawtitle      = {"scr_scoreboard_drawtitle",      "1"};
cvar_t	scr_scoreboard_borderless     = {"scr_scoreboard_borderless",     "1"};
cvar_t	scr_scoreboard_spectator_name = {"scr_scoreboard_spectator_name", "\xF3\xF0\xE5\xE3\xF4\xE1\xF4\xEF\xF2"}; // brown "spectator". old: &cF20s&cF50p&cF80e&c883c&cA85t&c668a&c55At&c33Bo&c22Dr
cvar_t	scr_scoreboard_fillalpha      = {"scr_scoreboard_fillalpha",      "0.7"};
cvar_t	scr_scoreboard_fillcolored    = {"scr_scoreboard_fillcolored",    "2"};
cvar_t  scr_scoreboard_proportional   = {"scr_scoreboard_proportional",   "0"};
cvar_t  scr_scoreboard_wipeout	 	  = {"scr_scoreboard_wipeout",   	  "1"};
cvar_t	scr_scoreboard_classic        = {"scr_scoreboard_classic", "0"};
cvar_t	scr_scoreboard_highlightself  = {"scr_scoreboard_highlightself", "1"};
cvar_t	scr_scoreboard_showclock      = {"scr_scoreboard_showclock", "0"};
cvar_t	scr_scoreboard_showmapname    = {"scr_scoreboard_showmapname", "0"};

static void OnChange_scr_scoreboard_showqtvusers(cvar_t *old_value, char *new_value, qbool*);
cvar_t scr_scoreboard_showqtvusers = {"scr_scoreboard_showqtvusers", "1", 0, OnChange_scr_scoreboard_showqtvusers};
cvar_t scr_scoreboard_qtv_name = {"scr_scoreboard_qtv_name", "\xF1\xF4\xF6"};

// VFrags: only draw the frags for the first player when using mvinset
#define MULTIVIEWTHISPOV() ((!cl_multiview.value) || (cl_mvinset.value && CL_MultiviewCurrentView() == 1))

qbool Sbar_IsStandardBar(void)
{
	// Old status bar is turned on, or the screen size is less than full width
	return cl_sbar.value || scr_viewsize.value < 100;
}

static qbool Sbar_ShowScoreboardIndicator (void)
{
	if (!cls.mvdplayback || !cl_multiview.value)
		return true;

	if (cl_multiview.integer == 1 || (cl_multiview.integer == 2 && cl_mvinset.integer))
		return true;

	return false;
}

/********************************** CONTROL **********************************/

//Tab key down
void Sbar_ShowTeamScores (void) {
	if (sb_showteamscores)
		return;

	sb_showteamscores = true;
	sb_updates = 0;
}

//Tab key up
void Sbar_DontShowTeamScores (void) {
	sb_showteamscores = false;
	sb_updates = 0;
}

//Tab key down
void Sbar_ShowScores (void) {
	if (sb_showscores)
		return;

	sb_showscores = true;
	sb_updates = 0;
}

//Tab key up
void Sbar_DontShowScores (void) {
	sb_showscores = false;
	sb_updates = 0;
}

void Sbar_Changed (void) {
	sb_updates = 0;	// update next frame
}

/************************************ INIT ************************************/

void Sbar_Init(void)
{
	int i;

	for (i = 0; i < 10; i++) {
		sb_nums[0][i] = Draw_CacheWadPic(va("num_%i", i), WADPIC_NUM_0 + i);
		sb_nums[1][i] = Draw_CacheWadPic(va("anum_%i", i), WADPIC_ANUM_0 + i);
	}

	sb_nums[0][10] = Draw_CacheWadPic("num_minus", WADPIC_NUM_MINUS);
	sb_nums[1][10] = Draw_CacheWadPic("anum_minus", WADPIC_ANUM_MINUS);

	sb_colon = Draw_CacheWadPic("num_colon", WADPIC_NUM_COLON);
	sb_slash = Draw_CacheWadPic("num_slash", WADPIC_NUM_SLASH);

	sb_weapons[0][0] = Draw_CacheWadPic("inv_shotgun", WADPIC_INV_SHOTGUN);
	sb_weapons[0][1] = Draw_CacheWadPic("inv_sshotgun", WADPIC_INV_SSHOTGUN);
	sb_weapons[0][2] = Draw_CacheWadPic("inv_nailgun", WADPIC_INV_NAILGUN);
	sb_weapons[0][3] = Draw_CacheWadPic("inv_snailgun", WADPIC_INV_SNAILGUN);
	sb_weapons[0][4] = Draw_CacheWadPic("inv_rlaunch", WADPIC_INV_RLAUNCH);
	sb_weapons[0][5] = Draw_CacheWadPic("inv_srlaunch", WADPIC_INV_SRLAUNCH);
	sb_weapons[0][6] = Draw_CacheWadPic("inv_lightng", WADPIC_INV_LIGHTNG);

	sb_weapons[1][0] = Draw_CacheWadPic("inv2_shotgun", WADPIC_INV2_SHOTGUN);
	sb_weapons[1][1] = Draw_CacheWadPic("inv2_sshotgun", WADPIC_INV2_SSHOTGUN);
	sb_weapons[1][2] = Draw_CacheWadPic("inv2_nailgun", WADPIC_INV2_NAILGUN);
	sb_weapons[1][3] = Draw_CacheWadPic("inv2_snailgun", WADPIC_INV2_SNAILGUN);
	sb_weapons[1][4] = Draw_CacheWadPic("inv2_rlaunch", WADPIC_INV2_RLAUNCH);
	sb_weapons[1][5] = Draw_CacheWadPic("inv2_srlaunch", WADPIC_INV2_SRLAUNCH);
	sb_weapons[1][6] = Draw_CacheWadPic("inv2_lightng", WADPIC_INV2_LIGHTNG);

	for (i = 0; i < 5; i++) {
		sb_weapons[2 + i][0] = Draw_CacheWadPic(va("inva%i_shotgun", i + 1), WADPIC_INVA1_SHOTGUN + i);
		sb_weapons[2 + i][1] = Draw_CacheWadPic(va("inva%i_sshotgun", i + 1), WADPIC_INVA1_SSHOTGUN + i);
		sb_weapons[2 + i][2] = Draw_CacheWadPic(va("inva%i_nailgun", i + 1), WADPIC_INVA1_NAILGUN + i);
		sb_weapons[2 + i][3] = Draw_CacheWadPic(va("inva%i_snailgun", i + 1), WADPIC_INVA1_SNAILGUN + i);
		sb_weapons[2 + i][4] = Draw_CacheWadPic(va("inva%i_rlaunch", i + 1), WADPIC_INVA1_RLAUNCH + i);
		sb_weapons[2 + i][5] = Draw_CacheWadPic(va("inva%i_srlaunch", i + 1), WADPIC_INVA1_SRLAUNCH + i);
		sb_weapons[2 + i][6] = Draw_CacheWadPic(va("inva%i_lightng", i + 1), WADPIC_INVA1_LIGHTNG + i);
	}

	sb_ammo[0] = Draw_CacheWadPic("sb_shells", WADPIC_SB_SHELLS);
	sb_ammo[1] = Draw_CacheWadPic("sb_nails", WADPIC_SB_NAILS);
	sb_ammo[2] = Draw_CacheWadPic("sb_rocket", WADPIC_SB_ROCKET);
	sb_ammo[3] = Draw_CacheWadPic("sb_cells", WADPIC_SB_CELLS);

	sb_armor[0] = Draw_CacheWadPic("sb_armor1", WADPIC_SB_ARMOR1);
	sb_armor[1] = Draw_CacheWadPic("sb_armor2", WADPIC_SB_ARMOR2);
	sb_armor[2] = Draw_CacheWadPic("sb_armor3", WADPIC_SB_ARMOR3);

	sb_items[0] = Draw_CacheWadPic("sb_key1", WADPIC_SB_KEY1);
	sb_items[1] = Draw_CacheWadPic("sb_key2", WADPIC_SB_KEY2);
	sb_items[2] = Draw_CacheWadPic("sb_invis", WADPIC_SB_INVIS);
	sb_items[3] = Draw_CacheWadPic("sb_invuln", WADPIC_SB_INVULN);
	sb_items[4] = Draw_CacheWadPic("sb_suit", WADPIC_SB_SUIT);
	sb_items[5] = Draw_CacheWadPic("sb_quad", WADPIC_SB_QUAD);

	sb_sigil[0] = Draw_CacheWadPic("sb_sigil1", WADPIC_SB_SIGIL1);
	sb_sigil[1] = Draw_CacheWadPic("sb_sigil2", WADPIC_SB_SIGIL2);
	sb_sigil[2] = Draw_CacheWadPic("sb_sigil3", WADPIC_SB_SIGIL3);
	sb_sigil[3] = Draw_CacheWadPic("sb_sigil4", WADPIC_SB_SIGIL4);

	sb_faces[4][0] = Draw_CacheWadPic("face1", WADPIC_SB_FACE1);
	sb_faces[4][1] = Draw_CacheWadPic("face_p1", WADPIC_SB_FACE_P1);
	sb_faces[3][0] = Draw_CacheWadPic("face2", WADPIC_SB_FACE2);
	sb_faces[3][1] = Draw_CacheWadPic("face_p2", WADPIC_SB_FACE_P2);
	sb_faces[2][0] = Draw_CacheWadPic("face3", WADPIC_SB_FACE3);
	sb_faces[2][1] = Draw_CacheWadPic("face_p3", WADPIC_SB_FACE_P3);
	sb_faces[1][0] = Draw_CacheWadPic("face4", WADPIC_SB_FACE4);
	sb_faces[1][1] = Draw_CacheWadPic("face_p4", WADPIC_SB_FACE_P4);
	sb_faces[0][0] = Draw_CacheWadPic("face5", WADPIC_SB_FACE5);
	sb_faces[0][1] = Draw_CacheWadPic("face_p5", WADPIC_SB_FACE_P5);

	sb_face_invis = Draw_CacheWadPic("face_invis", WADPIC_FACE_INVIS);
	sb_face_invuln = Draw_CacheWadPic("face_invul2", WADPIC_FACE_INVUL2);
	sb_face_invis_invuln = Draw_CacheWadPic("face_inv2", WADPIC_FACE_INV2);
	sb_face_quad = Draw_CacheWadPic("face_quad", WADPIC_FACE_QUAD);

	sb_sbar = Draw_CacheWadPic("sbar", WADPIC_SB_SBAR);
	sb_ibar = Draw_CacheWadPic("ibar", WADPIC_SB_IBAR);
	sb_scorebar = Draw_CacheWadPic("scorebar", WADPIC_SB_SCOREBAR);

	Cvar_SetCurrentGroup(CVAR_GROUP_SBAR);
	Cvar_Register(&scr_centerSbar);

	Cvar_Register(&scr_compactHud);
	Cvar_Register(&scr_compactHudAlign);

	// --> mqwcl 0.96 oldhud customisation
	//Cvar_Register (&sbar_teamfrags);
	//Cvar_Register (&sbar_fraglimit);
	Cvar_Register(&sbar_drawfaceicon);
	Cvar_Register(&sbar_drawammoicon);
	Cvar_Register(&sbar_drawarmoricon);
	Cvar_Register(&sbar_drawguns);
	Cvar_Register(&sbar_drawammocounts);
	Cvar_Register(&sbar_drawitems);
	Cvar_Register(&sbar_drawsigils);
	Cvar_Register(&sbar_drawhealth);
	Cvar_Register(&sbar_drawarmor);
	Cvar_Register(&sbar_drawarmor666);
	Cvar_Register(&sbar_drawammo);
	Cvar_Register(&sbar_lowammo);
	Cvar_Register(&hud_centerranking);
	Cvar_Register(&hud_rankingpos_y);
	Cvar_Register(&hud_rankingpos_x);
	Cvar_Register(&hud_faderankings);
	Cvar_Register(&scr_scoreboard_login_names);
	Cvar_Register(&scr_scoreboard_login_indicator);
	Cvar_Register(&scr_scoreboard_login_color);
	Cvar_Register(&scr_scoreboard_login_flagfile);
	//Cvar_Register (&hud_ranks_separate);
	// <-- mqwcl 0.96 oldhud customisation

	Cvar_Register(&scr_scoreboard_afk);
	Cvar_Register(&scr_scoreboard_afk_style);

	Cvar_Register(&scr_drawHFrags);
	Cvar_Register(&scr_drawVFrags);
	Cvar_Register(&scr_scoreboard_teamsort);
	Cvar_Register(&scr_scoreboard_forcecolors);
	Cvar_Register(&scr_scoreboard_showfrags);
	Cvar_Register(&scr_scoreboard_showflagstats);
	Cvar_Register(&scr_scoreboard_drawtitle);
	Cvar_Register(&scr_scoreboard_borderless);
	Cvar_Register(&scr_scoreboard_spectator_name);
	Cvar_Register(&scr_scoreboard_fillalpha);
	Cvar_Register(&scr_scoreboard_fillcolored);
	Cvar_Register(&scr_scoreboard_proportional);
	Cvar_Register(&scr_scoreboard_wipeout);
	Cvar_Register(&scr_scoreboard_classic);
	Cvar_Register(&scr_scoreboard_highlightself);
	Cvar_Register(&scr_scoreboard_showclock);
	Cvar_Register(&scr_scoreboard_showmapname);
	Cvar_Register(&scr_scoreboard_showqtvusers);
	Cvar_Register(&scr_scoreboard_qtv_name);

	Cvar_ResetCurrentGroup();

	Cmd_AddCommand("+showscores", Sbar_ShowScores);
	Cmd_AddCommand("-showscores", Sbar_DontShowScores);

	Cmd_AddCommand("+showteamscores", Sbar_ShowTeamScores);
	Cmd_AddCommand("-showteamscores", Sbar_DontShowTeamScores);

	CL_LoginImageLoad(scr_scoreboard_login_flagfile.string);
}

void Request_Pings (void)
{
	if (cls.state == ca_active && cls.realtime - cl.last_ping_request > 2)
	{
		cl.last_ping_request = cls.realtime;
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		SZ_Print (&cls.netchan.message, "pings");
	}
}

/****************************** SUPPORT ROUTINES ******************************/

// drawing routines are relative to the status bar location

void Sbar_DrawPic (int x, int y, mpic_t *pic)
{
	Draw_Pic (x + sbar_xofs, y + (vid.height - SBAR_HEIGHT), pic);
}

//JACK: Draws a portion of the picture in the status bar.
static void Sbar_DrawSubPic(int x, int y, mpic_t *pic, int srcx, int srcy, int width, int height)
{
	Draw_SubPic (x, y + (vid.height - SBAR_HEIGHT), pic, srcx, srcy, width, height);
}

static void Sbar_DrawTransPic (int x, int y, mpic_t *pic)
{
	Draw_TransPic (x + sbar_xofs, y + (vid.height - SBAR_HEIGHT), pic);
}

//Draws one solid graphics character
static void Sbar_DrawCharacter (int x, int y, int num)
{
	Draw_Character (x + 4 + sbar_xofs, y + vid.height - SBAR_HEIGHT, num);
}

void Sbar_DrawString(int x, int y, char *str)
{
	Draw_String(x + sbar_xofs, y + vid.height - SBAR_HEIGHT, str);
}

static void Sbar_DrawAltString (int x, int y, char *str) {
	Draw_Alt_String(x + sbar_xofs, y + vid.height - SBAR_HEIGHT, str, 1, false);
}

static int Sbar_itoa (int num, char *buf) {
	char *str;
	int pow10, dig;

	str = buf;

	if (num < 0) {
		*str++ = '-';
		num = -num;
	}

	for (pow10 = 10 ; num >= pow10 ; pow10 *= 10)
		;

	do {
		pow10 /= 10;
		dig = num / pow10;
		*str++ = '0' + dig;
		num -= dig * pow10;
	} while (pow10 != 1);

	*str = 0;

	return str - buf;
}

void Sbar_DrawNum (int x, int y, int num, int digits, int color) {
	char str[12], *ptr;
	int l, frame;

	l = Sbar_itoa (num, str);
	ptr = str;
	if (l > digits)
		ptr += (l - digits);
	if (l < digits)
		x += (digits - l) * 24;

	while (*ptr) {
		frame = (*ptr == '-') ? STAT_MINUS : *ptr -'0';

		Sbar_DrawTransPic (x, y, sb_nums[color][frame]);
		x += 24;
		ptr++;
	}
}

// this used to be static function
int	Sbar_ColorForMap (int m) {
	return m == 16 ? 0 : 16 * bound(0, m, 15) + 8;
}

// HUD -> hexum
int Sbar_TopColor(player_info_t *player)
{
	return Sbar_ColorForMap(cl.teamfortress ? player->known_team_color : player->topcolor);
}

int Sbar_TopColorScoreboard(player_info_t* player)
{
	return Sbar_ColorForMap(cl.teamfortress ? player->known_team_color : (scr_scoreboard_forcecolors.integer ? player->topcolor : player->real_topcolor));
}

int Sbar_BottomColor(player_info_t *player)
{
	return Sbar_ColorForMap(cl.teamfortress ? player->known_team_color : player->bottomcolor);
}

int Sbar_BottomColorScoreboard(player_info_t* player)
{
	return Sbar_ColorForMap(cl.teamfortress ? player->known_team_color : (scr_scoreboard_forcecolors.integer ? player->bottomcolor : player->real_bottomcolor));
}

// ** HUD -> hexum

/********************************* FRAG SORT *********************************/

static int fragsort[MAX_CLIENTS];
static int scoreboardlines;

#define SCR_TEAM_T_MAXTEAMSIZE	(16 + 1)

typedef struct {
	char team[SCR_TEAM_T_MAXTEAMSIZE];
	int frags;
	int caps;
	int players;
	int plow, phigh, ptotal;
	int topcolor, bottomcolor;
	int known_team_number;
	qbool myteam;
} team_t;
static team_t teams[MAX_CLIENTS];

static int teamsort[MAX_CLIENTS];
static int scoreboardteams;

static __inline int Sbar_PlayerNum(void) {
	int mynum = cl.playernum;

	if (cl.spectator) {
		mynum = Cam_TrackNum ();

		if (mynum < 0)
			mynum = cl.playernum;
	}

	return mynum;
}


static __inline qbool Sbar_IsSpectator(int mynum) {

	return (mynum == cl.playernum) ? cl.spectator : cl.players[mynum].spectator;
}

static qbool Sbar_SortFrags(qbool spec) {
	int i, j, k;
	static int lastframecount = 0;
	static qbool any_flags = false;

	if (!spec && lastframecount && lastframecount == cls.framecount) {
		return any_flags;
	}

	any_flags = false;
	lastframecount = spec ? 0 : cls.framecount;

	// sort by frags
	scoreboardlines = 0;
	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0]) {
			if (spec || !cl.players[i].spectator) {
				fragsort[scoreboardlines] = i;
				scoreboardlines++;
				if (cl.players[i].spectator) {
					cl.players[i].frags = -999;
				}
			}
			any_flags |= cl.players[i].loginname[0];
		}
	}

	for (i = 0; i < scoreboardlines; i++) {
		for (j = 0; j < scoreboardlines - 1 - i; j++) {
			if (cl.players[fragsort[j]].frags < cl.players[fragsort[j + 1]].frags) {
				k = fragsort[j];
				fragsort[j] = fragsort[j + 1];
				fragsort[j + 1] = k;
			}
		}
	}

	return any_flags;
}

static void Sbar_SortTeams (void) {
	int i, j, k, mynum, playertoteam[MAX_CLIENTS];
	player_info_t *s;
	char t[SCR_TEAM_T_MAXTEAMSIZE];
	static int lastframecount = 0;

	if (!cl.teamplay)
		return;

	if (lastframecount && lastframecount == cls.framecount)
		return;
	lastframecount = cls.framecount;

	scoreboardteams = 0;

	for (i = 0; i < MAX_CLIENTS; i++)
		playertoteam[i] = -1;

	// sort the teams
	memset(teams, 0, sizeof(teams));
	for (i = 0; i < MAX_CLIENTS; i++)
		teams[i].plow = 999;

	mynum = Sbar_PlayerNum();

	for (i = 0; i < MAX_CLIENTS; i++) {
		int flagstats[] = { 0, 0, 0 };

		s = &cl.players[i];
		if (!s->name[0] || s->spectator)
			continue;

		// find his team in the list
		strlcpy (t, s->team, sizeof(t));
		if (!t[0])
			continue; // not on team

		Stats_GetFlagStats(s - cl.players, flagstats);

		for (j = 0; j < scoreboardteams; j++) {
			if (!strcmp(teams[j].team, t)) {
				playertoteam[i] = j;

				if (cl.scoring_system == SCORING_SYSTEM_TEAMFRAGS) {
					if (teams[j].players == 0) {
						teams[j].frags = s->frags;
						teams[j].caps = flagstats[2];
					}
					else {
						teams[j].frags = max(s->frags, teams[j].frags);
						teams[j].caps = max(flagstats[2], teams[j].caps);
					}
				}
				else {
					teams[j].frags += s->frags;
					teams[j].caps += flagstats[2];
				}
				teams[j].players++;
				if (!cl.teamfortress && i == mynum) {
					teams[j].topcolor = scr_scoreboard_forcecolors.value ? s->topcolor : s->real_topcolor;
					teams[j].bottomcolor = scr_scoreboard_forcecolors.value ? s->bottomcolor : s->real_bottomcolor;
				}
				break;
			}
		}
		if (j == scoreboardteams) { // must add him
			j = scoreboardteams++;
			playertoteam[i] = j;

			teams[j].frags = s->frags;
			teams[j].caps = flagstats[2];
			teams[j].players = 1;
			teams[j].known_team_number = s->known_team_color;
			if (cl.teamfortress) {
				teams[j].topcolor = teams[j].bottomcolor = Utils_TF_TeamToColor(t);
			} else {
				teams[j].bottomcolor = scr_scoreboard_forcecolors.value ? s->bottomcolor : s->real_bottomcolor;
				teams[j].topcolor = scr_scoreboard_forcecolors.value ? s->topcolor : s->real_topcolor;
			}
			strlcpy(teams[j].team, t, sizeof(teams[j].team));

			if (!Sbar_IsSpectator(mynum) && !strncmp(cl.players[mynum].team, t, sizeof(t) - 1))
				teams[j].myteam = true;
			else
				teams[j].myteam = false;
		}
		teams[j].plow = min(s->ping, teams[j].plow);
		teams[j].phigh = max(s->ping, teams[j].phigh);
		teams[j].ptotal += s->ping;
	}

	//prepare for sort
	for (i = 0; i < scoreboardteams; i++)
		teamsort[i] = i;

	// good 'ol bubble sort
	for (i = 0; i < scoreboardteams - 1; i++) {
		for (j = i + 1; j < scoreboardteams; j++) {
			if (teams[teamsort[i]].frags < teams[teamsort[j]].frags) {
				k = teamsort[i];
				teamsort[i] = teamsort[j];
				teamsort[j] = k;
			}
		}
	}

	if (cl.teamfortress && (cl.scoring_system == SCORING_SYSTEM_DEFAULT)) {
		for (i = 0; i < scoreboardteams; i++) {
			float frags = (float) teams[i].frags / teams[i].players;

			if (frags != (int) frags)
				return;

			for (j = 0; j < MAX_CLIENTS; j++) {
				s = &cl.players[j];
				if (!s->name[0] || s->spectator || playertoteam[j] != i)
					continue;

				if (s->frags != frags)
					return;
			}
		}

		for (i = 0; i < scoreboardteams; i++) {
			teams[i].frags /= teams[i].players;
		}
	}
}



static int Sbar_SortTeamsAndFrags_Compare(int a, int b) {
	int team_comp, frag_comp;
	char *team_one, *team_two;
	player_info_t *p1, *p2;

	p1 = &cl.players[a];
	p2 = &cl.players[b];

	if (p1->spectator)
		return p2->spectator ? strcasecmp(p1->name, p2->name) : 1;
	else if (p2->spectator)
		return -1;

	team_one = cl.teamfortress ? Utils_TF_ColorToTeam(p1->real_bottomcolor) : p1->team;
	team_two = cl.teamfortress ? Utils_TF_ColorToTeam(p2->real_bottomcolor) : p2->team;

	if ((team_comp = strcmp(team_one, team_two))) {
		int i;
		team_t *t1 = NULL, *t2 = NULL;

		for (i = 0; i < scoreboardteams; i++) {
			if (!strcmp(team_one, teams[i].team)) {
				t1 = &teams[i];
				break;
			}
		}
		for (i = 0; i < scoreboardteams; i++) {
			if (!strcmp(team_two, teams[i].team)) {
				t2 = &teams[i];
				break;
			}
		}
		return (t1 && t2 && t1->frags != t2->frags) ? (t2->frags - t1->frags) : team_comp;
	} else {
		return (frag_comp = p2->frags - p1->frags) ? frag_comp : strcasecmp(p1->name, p2->name);
	}
}

static qbool Sbar_SortTeamsAndFrags(qbool specs) {
	int i, j, k;
	qbool real_teamplay;
	qbool any_flags = false;

	real_teamplay = cl.teamplay && (TP_CountPlayers() > 2);

	if (!real_teamplay || !scr_scoreboard_teamsort.value) {
		return Sbar_SortFrags(specs);
	}

	scoreboardlines = 0;
	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0]) {
			if (specs || !cl.players[i].spectator) {
				fragsort[scoreboardlines++] = i;
				if (cl.players[i].spectator) {
					cl.players[i].frags = -999;
				}
			}
			any_flags |= cl.players[i].loginname[0];
		}
	}

	Sbar_SortTeams();

	for (i = 0; i < scoreboardlines; i++) {
		for (j = 0; j < scoreboardlines - 1 - i ; j++) {
			if (Sbar_SortTeamsAndFrags_Compare(fragsort[j], fragsort[j + 1]) > 0) {
				k = fragsort[j];
				fragsort[j] = fragsort[j + 1];
				fragsort[j + 1] = k;
			}
		}
	}
	return any_flags;
}



/********************************* INVENTORY *********************************/
static void Sbar_DrawInventory(void)
{
	int i, flashon;
	char num[6];
	float time;
	qbool headsup, hudswap;

	headsup = !Sbar_IsStandardBar();
	hudswap = cl_hudswap.integer;

	if (!headsup) {
		Draw_TileClear (sbar_xofs, vid.height - sb_lines, sbar_xofs + 320, 24);
		Sbar_DrawPic (0, -24, sb_ibar);
	}

	// weapons
	if (sbar_drawguns.integer) { // kazik
		for (i = 0; i < 7; i++) {
			if (cl.stats[STAT_ITEMS] & (IT_SHOTGUN << i) ) {
				time = cl.item_gettime[i];
				flashon = (int)((cl.time - time) * 10);
				if (flashon < 0) {
					flashon = 0;
				}
				if (flashon >= 10) {
					flashon = (cl.stats[STAT_ACTIVEWEAPON] == (IT_SHOTGUN << i)) ? 1 : 0;
				}
				else {
					flashon = (flashon % 5) + 2;
				}

				if (headsup) {
					if (i || vid.height > 200)
						Sbar_DrawSubPic (hudswap ? 0 : vid.width - 24,-68 - (7 - i) * 16 , sb_weapons[flashon][i], 0, 0, 24, 16);

				} else {
					Sbar_DrawPic (i * 24, -16, sb_weapons[flashon][i]);
				}

				if (flashon > 1)
					sb_updates = 0;		// force update to remove flash
			}
		}
	}

	// ammo counts
	if (sbar_drawammocounts.integer) { // kazik
		for (i = 0; i < 4; i++) {
			snprintf (num, sizeof(num), "%3i", cl.stats[STAT_SHELLS + i]);
			if (headsup) {
				Sbar_DrawSubPic(hudswap ? 0 : vid.width - 42, -24 - (4 - i) * 11, sb_ibar, 3 + (i * 48), 0, 42, 11);
				if (num[0] != ' ')
					Draw_Character (hudswap ? 7: vid.width - 35, vid.height - SBAR_HEIGHT - 24 - (4 - i) * 11, 18 + num[0] - '0');
				if (num[1] != ' ')
					Draw_Character (hudswap ? 15: vid.width - 27, vid.height - SBAR_HEIGHT - 24 - (4 - i) * 11, 18 + num[1] - '0');
				if (num[2] != ' ')
					Draw_Character (hudswap ? 23: vid.width - 19, vid.height - SBAR_HEIGHT - 24 - (4 - i) * 11, 18 + num[2] - '0');
			}
			else {
				if (num[0] != ' ')
					Sbar_DrawCharacter ((6 * i + 1) * 8 - 2, -24, 18 + num[0] - '0');
				if (num[1] != ' ')
					Sbar_DrawCharacter ((6 * i + 2) * 8 - 2, -24, 18 + num[1] - '0');
				if (num[2] != ' ')
					Sbar_DrawCharacter ((6 * i + 3) * 8 - 2, -24, 18 + num[2] - '0');
			}
		}
	}

	// items
	flashon = 0;
	if (sbar_drawitems.integer) { // kazik
		for (i = 0; i < 6; i++) {
			if (cl.stats[STAT_ITEMS] & (1 << (17 + i))) {
				time = cl.item_gettime[17 + i];
				if (time && time > cl.time - 2 && flashon) {
					// flash frame
					sb_updates = 0;
				}
				else {
					Sbar_DrawPic(192 + i * 16, -16, sb_items[i]);
				}

				if (time && time > cl.time - 2) {
					sb_updates = 0;
				}
			}
		}
	}

	// sigils
	if (sbar_drawsigils.integer) { // kazik
		for (i = 0; i < 4; i++) {
			if (cl.stats[STAT_ITEMS] & (1 << (28 + i)))	{
				time = cl.item_gettime[28 + i];
				if (time && time > cl.time - 2 && flashon) {
					// flash frame
					sb_updates = 0;
				}
				else {
					Sbar_DrawPic(320 - 32 + i * 8, -16, sb_sigil[i]);
				}

				if (time && time > cl.time - 2) {
					sb_updates = 0;
				}
			}
		}
	}
}

/************************************ HUD ************************************/

static void Sbar_DrawFrags_DrawCellPlayer(int x, int y, player_info_t* player, int brackets)
{
	char num[4];

	// draw background
	Draw_Fill (sbar_xofs + x * 8 + 10, y, 28, 4, Sbar_TopColorScoreboard(player));
	Draw_Fill (sbar_xofs + x * 8 + 10, y + 4, 28, 3, Sbar_BottomColorScoreboard(player));

	// draw number
	snprintf (num, sizeof(num), "%3i", bound(-99, player->frags, 999));

	Sbar_DrawCharacter ((x + 1) * 8 , -24, num[0]);
	Sbar_DrawCharacter ((x + 2) * 8 , -24, num[1]);
	Sbar_DrawCharacter ((x + 3) * 8 , -24, num[2]);

	if (brackets) {
		Sbar_DrawCharacter (x * 8 + 2, -24, 16);
		Sbar_DrawCharacter ((x + 4) * 8 - 4, -24, 17);
	}
}

static void Sbar_DrawFrags_DrawTeamCell(int x, int y, team_t* team)
{
	char num[4];
	int frags = team->frags;
	player_info_t p = { 0 };
	p.topcolor = team->topcolor;
	p.bottomcolor = team->bottomcolor;
	p.known_team_color = team->known_team_number;

	// draw background
	Draw_Fill(sbar_xofs + x * 8 + 10, y, 28, 4, Sbar_TopColorScoreboard(&p));
	Draw_Fill(sbar_xofs + x * 8 + 10, y + 4, 28, 3, Sbar_BottomColorScoreboard(&p));

	// draw number
	snprintf(num, sizeof(num), "%3i", bound(-99, frags, 999));

	Sbar_DrawCharacter((x + 1) * 8, -24, num[0]);
	Sbar_DrawCharacter((x + 2) * 8, -24, num[1]);
	Sbar_DrawCharacter((x + 3) * 8, -24, num[2]);

	if (team->myteam) {
		Sbar_DrawCharacter(x * 8 + 2, -24, 16);
		Sbar_DrawCharacter((x + 4) * 8 - 4, -24, 17);
	}
}

static void Sbar_DrawFrags (void) {
	int i, k, l, x, y, mynum, myteam = -1;
	player_info_t *s;
	team_t *tm;
	qbool drawn_self = false, drawn_self_team = false;

	if (!scr_drawHFrags.value)
		return;

	x = 23;
	y = vid.height - SBAR_HEIGHT - 23;

	mynum = Sbar_PlayerNum();

	if (!cl.teamplay || scr_drawHFrags.value == 1) {
		Sbar_SortFrags (false);
		l = min(scoreboardlines, 4);

		for (i = 0; i < l; i++) {
			if (i + 1 == l && !drawn_self && !Sbar_IsSpectator(mynum)) {
				k = mynum;
			}
			else {
				k = fragsort[i];
			}

			s = &cl.players[k];

			if (!s->name[0] || s->spectator) {
				continue;
			}

			Sbar_DrawFrags_DrawCellPlayer(x, y, s, k == mynum);

			drawn_self |= (k == mynum);

			x += 4;
		}
	}
	else {
		Sbar_SortTeams();

		for (i = 0; i < scoreboardteams; i++) {
			if (teams[i].myteam) {
				myteam = i;
				break;
			}
		}

		l = min(scoreboardteams, 4);
		for (i = 0; i < l; i++) {
			if (myteam != -1 && i + 1 == l && !drawn_self_team)
				k = myteam;
			else
				k = teamsort[i];

			tm = &teams[k];
			Sbar_DrawFrags_DrawTeamCell(x, y, tm);

			if (k == myteam)
				drawn_self_team = true;

			x += 4;
		}

		if (scr_drawHFrags.value != 3 && l <= 2 && !Sbar_IsSpectator(mynum)) {

			x += 4 * (3 - l);

			s = &cl.players[mynum];

			Sbar_DrawFrags_DrawCellPlayer(x, y, s, 1);
		}
	}
}

static void Sbar_DrawFace (void) {
	int f, anim;

	if ( (cl.stats[STAT_ITEMS] & (IT_INVISIBILITY | IT_INVULNERABILITY) )
			== (IT_INVISIBILITY | IT_INVULNERABILITY) )	{
		Sbar_DrawPic (112, 0, sb_face_invis_invuln);
		return;
	}
	if (cl.stats[STAT_ITEMS] & IT_QUAD) {
		Sbar_DrawPic (112, 0, sb_face_quad );
		return;
	}
	if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) {
		Sbar_DrawPic (112, 0, sb_face_invis );
		return;
	}
	if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) {
		Sbar_DrawPic (112, 0, sb_face_invuln);
		return;
	}

	f = cl.stats[STAT_HEALTH] / 20;
	f = bound (0, f, 4);

	if (cl.time <= cl.faceanimtime)	{
		anim = 1;
		sb_updates = 0;		// make sure the anim gets drawn over
	} else {
		anim = 0;
	}
	Sbar_DrawPic (112, 0, sb_faces[f][anim]);
}

static void Sbar_DrawNormal (void)
{
	if (Sbar_IsStandardBar())
		Sbar_DrawPic (0, 0, sb_sbar);

	// armor
	if ((cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) && sbar_drawarmor666.value)	{
		if (sbar_drawarmor.value)
			Sbar_DrawNum (24, 0, 666, 3, 1);
		if (sbar_drawarmoricon.value)
			Sbar_DrawPic (0, 0, draw_disc);
	} else {
		if (sbar_drawarmor.value)
			Sbar_DrawNum (24, 0, cl.stats[STAT_ARMOR], 3, cl.stats[STAT_ARMOR] <= 25);
		if (sbar_drawarmoricon.value)
		{
			if (cl.stats[STAT_ITEMS] & IT_ARMOR3)
				Sbar_DrawPic (0, 0, sb_armor[2]);
			else if (cl.stats[STAT_ITEMS] & IT_ARMOR2)
				Sbar_DrawPic (0, 0, sb_armor[1]);
			else if (cl.stats[STAT_ITEMS] & IT_ARMOR1)
				Sbar_DrawPic (0, 0, sb_armor[0]);
		}

		if (amf_stat_loss.value)
			Draw_AMFStatLoss (STAT_ARMOR, NULL);
	}

	// face
	if (sbar_drawfaceicon.value)
		Sbar_DrawFace ();

	// health
	if (sbar_drawhealth.value)
	{
		Sbar_DrawNum (136, 0, cl.stats[STAT_HEALTH], 3, cl.stats[STAT_HEALTH] <= 25);
		if (amf_stat_loss.value)
			Draw_AMFStatLoss (STAT_HEALTH, NULL);
	}

	// ammo icon
	if (sbar_drawammoicon.value)    // kazik
	{
		if (cl.stats[STAT_ITEMS] & IT_SHELLS)
			Sbar_DrawPic (224, 0, sb_ammo[0]);
		else if (cl.stats[STAT_ITEMS] & IT_NAILS)
			Sbar_DrawPic (224, 0, sb_ammo[1]);
		else if (cl.stats[STAT_ITEMS] & IT_ROCKETS)
			Sbar_DrawPic (224, 0, sb_ammo[2]);
		else if (cl.stats[STAT_ITEMS] & IT_CELLS)
			Sbar_DrawPic (224, 0, sb_ammo[3]);
	}
	if (sbar_drawammo.value)
		Sbar_DrawNum (248, 0, cl.stats[STAT_AMMO], 3, cl.stats[STAT_AMMO] <= 10);
}

static void Sbar_DrawCompact_WithIcons(void) {
	int i, align, old_sbar_xofs;
	char str[4];

	if (Sbar_IsStandardBar())
		Sbar_DrawPic (0, 0, sb_sbar);

	old_sbar_xofs = sbar_xofs;
	sbar_xofs = scr_centerSbar.value ? (vid.width - 158) >> 1: 0;

	if ((cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) && sbar_drawarmor666.value)
		Sbar_DrawNum (2, 0, 666, 3, 1);
	else
		Sbar_DrawNum (2, 0, cl.stats[STAT_ARMOR], 3, cl.stats[STAT_ARMOR] <= 25);

	if (cl.stats[STAT_ITEMS] & IT_ARMOR3)
		Sbar_DrawPic (-24, 0, sb_armor[2]);
	else if (cl.stats[STAT_ITEMS] & IT_ARMOR2)
		Sbar_DrawPic (-24, 0, sb_armor[1]);
	else if (cl.stats[STAT_ITEMS] & IT_ARMOR1)
		Sbar_DrawPic (-24, 0, sb_armor[0]);

	Sbar_DrawNum (86, 0, cl.stats[STAT_HEALTH], 3, cl.stats[STAT_HEALTH] <= 25);

	align = scr_compactHudAlign.value ? 1 : 0;
	for (i = 0; i < 4; i++) {
		snprintf(str, sizeof(str), "%d", cl.stats[STAT_SHELLS + i]);
		if (cl.stats[STAT_SHELLS + i] <= sbar_lowammo.integer)
			Sbar_DrawAltString(align * 8 * (3 - strlen(str)) + 24 + 32 * i, -16, str);
		else
			Sbar_DrawString(align * 8 * (3 - strlen(str)) + 24 + 32 * i, -16, str);
	}
	for (i = 0; i < 7; i++) {
		if (cl.stats[STAT_ITEMS] & (IT_SHOTGUN << i) ) {
			if (cl.stats[STAT_ACTIVEWEAPON] == (IT_SHOTGUN << i))
				Sbar_DrawPic (align * 8 + 18 + 16 * i, -32, sb_weapons[1][i]);
			else
				Sbar_DrawPic (align * 8 + 18 + 16 * i, -32, sb_weapons[0][i]);
		}
	}
	sbar_xofs = old_sbar_xofs;
}

static void Sbar_DrawCompact(void) {
	int i, align, old_sbar_xofs;
	static char *weapons[7] = {"sg", "bs", "ng", "sn", "gl", "rl", "lg"};
	char str[4];

	if (Sbar_IsStandardBar())
		Sbar_DrawPic (0, 0, sb_sbar);

	old_sbar_xofs = sbar_xofs;
	sbar_xofs = scr_centerSbar.value ? (vid.width - 306) >> 1: 0;

	if ((cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) && sbar_drawarmor666.value)
		Sbar_DrawNum (2, 0, 666, 3, 1);
	else
		Sbar_DrawNum (2, 0, cl.stats[STAT_ARMOR], 3, cl.stats[STAT_ARMOR] <= 25);

	Sbar_DrawNum (86, 0, cl.stats[STAT_HEALTH], 3, cl.stats[STAT_HEALTH] <= 25);

	align = scr_compactHudAlign.value ? 1 : 0;
	for (i = 0; i < 4; i++) {
		snprintf(str, sizeof(str), "%d", cl.stats[STAT_SHELLS + i]);
		if (cl.stats[STAT_SHELLS + i] <= sbar_lowammo.integer)
			Sbar_DrawAltString(align * 8 * (3 - strlen(str)) + 174 + 32 * i, 3, str);
		else
			Sbar_DrawString(align * 8 * (3 - strlen(str)) + 174 + 32 * i, 3, str);
	}
	for (i = 0; i < 7; i++) {
		if (cl.stats[STAT_ITEMS] & (IT_SHOTGUN << i)) {
			if (cl.stats[STAT_ACTIVEWEAPON] == (IT_SHOTGUN << i))
				Sbar_DrawAltString(166 + 5 * 4 * i, 14, weapons[i]);
			else
				Sbar_DrawString(166 + 5 * 4 * i, 14, weapons[i]);
		}
	}
	sbar_xofs = old_sbar_xofs;
}

static void Sbar_DrawCompact_TF(void) {
	int i, align, old_sbar_xofs;
	char str[4];

	if (Sbar_IsStandardBar())
		Sbar_DrawPic (0, 0, sb_sbar);

	old_sbar_xofs = sbar_xofs;
	sbar_xofs = scr_centerSbar.value ? (vid.width - 222) >> 1: 0;

	align = scr_compactHudAlign.value ? 1 : 0;
	if ((cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) && sbar_drawarmor666.value)
		Sbar_DrawNum (2, 0, 666, 3, 1);
	else
		Sbar_DrawNum (2, 0, cl.stats[STAT_ARMOR], 3, cl.stats[STAT_ARMOR] <= 25);
	Sbar_DrawNum (86, 0, cl.stats[STAT_HEALTH], 3, cl.stats[STAT_HEALTH] <= 25);
	for (i = 0; i < 4; i++) {
		snprintf(str, sizeof(str), "%d", cl.stats[STAT_SHELLS + i]);
		if (cl.stats[STAT_SHELLS + i] <= sbar_lowammo.integer)
			Sbar_DrawAltString(align * 8 * (3 - strlen(str)) + 166 + 32 * (i % 2), i >= 2 ? 14 : 3, str);
		else
			Sbar_DrawString(align * 8 * (3 - strlen(str)) + 166 + 32 * (i % 2), i >= 2 ? 14 : 3, str);
	}
	sbar_xofs = old_sbar_xofs;
}

static void Sbar_DrawCompact_Bare (void) {
	int old_sbar_xofs;

	if (Sbar_IsStandardBar())
		Sbar_DrawPic (0, 0, sb_sbar);

	old_sbar_xofs = sbar_xofs;
	sbar_xofs = scr_centerSbar.value ? (vid.width - 158) >> 1: 0;

	if ((cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) && sbar_drawarmor666.value)
		Sbar_DrawNum (2, 0, 666, 3, 1);
	else
		Sbar_DrawNum (2, 0, cl.stats[STAT_ARMOR], 3, cl.stats[STAT_ARMOR] <= 25);
	Sbar_DrawNum (86, 0, cl.stats[STAT_HEALTH], 3, cl.stats[STAT_HEALTH] <= 25);
	sbar_xofs = old_sbar_xofs;
}

/******************************** SCOREBOARD ********************************/

/*
   ===============
   Sbar_SoloScoreboard -- johnfitz -- new layout
   ===============
   */
void Sbar_SoloScoreboard (void)
{
	char	str[256];
	int	len;
	int	clock_y;
	int	mapname_y;

	if (cl.gametype == GAME_COOP)
	{
		sprintf (str,"Kills: %i/%i", cl.stats[STAT_MONSTERS], cl.stats[STAT_TOTALMONSTERS]);
		Sbar_DrawString (8, 12, str);

		sprintf (str,"Secrets: %i/%i", cl.stats[STAT_SECRETS], cl.stats[STAT_TOTALSECRETS]);
		Sbar_DrawString (312 - strlen(str)*8, 12, str);
#ifndef CLIENTONLY
		sprintf (str,"skill %i", (int)(skill.value + 0.5));
		Sbar_DrawString (160 - strlen(str)*4, 12, str);
#endif
		strlcpy(str, cl.levelname, sizeof(str));
		strlcat(str, " (", sizeof(str));
		strlcat(str, host_mapname.string, sizeof(str));
		strlcat(str, ")", sizeof(str));
		len = strlen (str);
		Sbar_DrawString (160 - len*4, 4, str);
	}
	else
	{
		if ((scr_scoreboard_showclock.integer && !scr_scoreboard_showmapname.integer))
		{
			clock_y = -10;
		}
		else if (!scr_scoreboard_showclock.integer && scr_scoreboard_showmapname.integer)
		{
			mapname_y = -10;
		}
		else if (scr_scoreboard_showclock.integer && scr_scoreboard_showmapname.integer == 3)
		{
			clock_y = 2;
			mapname_y = -10;
		}
		else
		{
			clock_y = -10;
			mapname_y = 2;
		}

		if (scr_scoreboard_showclock.integer)
		{
			snprintf(str, sizeof(str), "%s", SCR_GetTimeString(TIMETYPE_CLOCK, "%H:%M:%S"));
			Sbar_DrawString(160 - strlen(str) * 4, clock_y, str);
		}

		if (scr_scoreboard_showmapname.integer)
		{
			switch (scr_scoreboard_showmapname.integer)
			{
				case 2:
					snprintf(str, sizeof(str), "%s", cl.levelname);
					break;
				case 3:
					snprintf(str, sizeof(str), "%s", host_mapname.string);
					break;
				default:
					snprintf(str, sizeof(str), "%s (%s)", cl.levelname, host_mapname.string);
					break;
			}

			Sbar_DrawString (160 - strlen(str) * 4, mapname_y, str);
		}
	}
}

#define SCOREBOARD_LASTROW		(vid.height - 34)

#define	RANK_WIDTH_BASICSTATS	(11 * 8)
#define	RANK_WIDTH_TEAMSTATS	(4 * 8)
#define	RANK_WIDTH_TCHSTATS		(5 * 8)
#define	RANK_WIDTH_CAPSTATS		(5 * 8)

#define RANK_WIDTH_DM				(-8 + 168 + (MAX_SCOREBOARDNAME * 8))
#define RANK_WIDTH_TEAM				(-8 + 208 + (MAX_SCOREBOARDNAME * 8))

#define SCOREBOARD_ALPHA			(0.5 * bound(0, scr_scoreboard_fillalpha.value, 1))
#define SCOREBOARD_HEADINGALPHA		(bound(0, scr_scoreboard_fillalpha.value, 1))

static qbool Sbar_ShowTeamKills(void)
{
	if (cl.teamfortress) {
		return ((cl.teamplay & 21) != 21); // 21 = (1)Teamplay On + (4)Team-members take No damage from direct fire + (16)Team-members take No damage from area-affect weaponry, so its like teamplay is off??
	}
	else {
		// in teamplay 3 and 4 it's not possible to make teamkills
		return !(cl.teamplay == 3 || cl.teamplay == 4);
	}
}

extern qtvuser_t *qtvuserlist;

static void Sbar_DeathmatchOverlay(int start)
{
	int stats_team, stats_touches, stats_caps, playerstats[7];
	int scoreboardsize, colors_thickness, statswidth, stats_xoffset = 0;
	int i, k, x, y, xofs, total, p, skip = 10, fragsint;
	int rank_width, leftover, startx, tempx, mynum;
	char num[12];
	char myminutes[11];
	char fragsstr[10];
	player_info_t *s;
	ti_player_t *ti_cl;
	mpic_t *pic;
	float scale = 1.0f;
	float alpha = 1.0f;
	float ca_alpha;	// alpha value for scoreboard elements during clan arena / wipeout
	qbool proportional = scr_scoreboard_proportional.integer;
	qbool any_flags = false;
	extern ti_player_t ti_clients[MAX_CLIENTS];
	int is_classic = scr_scoreboard_classic.integer;
	qbool is_classic_spec;
	qtvuser_t *qu;

	if (!start && hud_faderankings.value) {
		Draw_FadeScreen(hud_faderankings.value);
	}

#ifndef CLIENTONLY
	// FIXME
	// check number of connections instead?
	if (cl.gametype == GAME_COOP && com_serveractive && !coop.value) {
		return;
	}
#endif

	if (cls.state == ca_active && !cls.demoplayback) {
		// request new ping times every two seconds
		if (cls.realtime - cl.last_ping_request >= 2) {
			cl.last_ping_request = cls.realtime;
			MSG_WriteByte(&cls.netchan.message, clc_stringcmd);
			SZ_Print(&cls.netchan.message, "pings");
		}
	}

	scr_copyeverything = 1;
	scr_fullupdate = 0;

	mynum = Sbar_PlayerNum();

	rank_width = (cl.teamplay ? RANK_WIDTH_TEAM : RANK_WIDTH_DM);

	statswidth = 0;
	stats_team = stats_touches = stats_caps = 0;
	if (scr_scoreboard_showfrags.value && Stats_IsActive()) {
		if (rank_width + statswidth + RANK_WIDTH_BASICSTATS < vid.width - 16) {
			statswidth += RANK_WIDTH_BASICSTATS;
			if (cl.teamplay) {
				if (rank_width + statswidth + RANK_WIDTH_TEAMSTATS < vid.width - 16) {
					if (Sbar_ShowTeamKills()) {
						statswidth += RANK_WIDTH_TEAMSTATS;
						stats_team++;
					}
				}
				if ((cl.teamfortress || scr_scoreboard_showflagstats.value) && Stats_IsFlagsParsed()) {
					if (rank_width + statswidth + RANK_WIDTH_TCHSTATS < vid.width - 16) {
						statswidth += RANK_WIDTH_TCHSTATS;
						stats_touches++;
					}
					if (rank_width + statswidth + RANK_WIDTH_CAPSTATS < vid.width - 16) {
						statswidth += RANK_WIDTH_CAPSTATS;
						stats_caps++;
					}
				}
			}
		}
	}
	rank_width += statswidth;

	leftover = rank_width;
	rank_width = bound(0, rank_width, vid.width - 16);
	leftover = max(0, leftover - rank_width);
	if (hud_centerranking.value) {
		xofs = ((vid.width - rank_width) >> 1) + hud_rankingpos_x.value;
	}
	else {
		xofs = hud_rankingpos_x.value;
	}

	if (start) {
		y = start;
	}
	else {
		y = hud_rankingpos_y.value;
		if (y < 0 || y > vid.height / 2) {
			y = 0;
		}
	}

	if (!start) {
		if (scr_scoreboard_drawtitle.value) {
			pic = Draw_CachePic(CACHEPIC_RANKING);
			Draw_Pic(xofs + (rank_width - pic->width) / 2, y, pic);
			start = 36 + hud_rankingpos_y.value;
		}
		else {
			start = 12 + hud_rankingpos_y.value;
		}
	}

	for (i = 0; i < scoreboardlines && y <= SCOREBOARD_LASTROW; i++) {
		k = fragsort[i];
		s = &cl.players[k];

		if (!s->name[0]) {
			continue;
		}

		any_flags |= (s->loginname[0] && scr_scoreboard_login_indicator.string[0]);
	}

	y = start;

	if (!scr_scoreboard_borderless.value) {
		Draw_Fill(xofs - 1, y - 9, rank_width + 2, 1, 0);						//Border - Top
	}

	if (!is_classic)
		Draw_AlphaFill(xofs, y - 8, rank_width, 9, 1, SCOREBOARD_HEADINGALPHA);	//Draw heading row

	x = xofs + 1;
	// teamplay: " ping pl  fps frags team name" | " ping pl time frags team name"
	// non-tp  : " ping pl  fps frags name" | " ping pl time frags name"

	x += FONT_WIDTH;
	Draw_SStringAligned(x, y - 8, "ping", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
	if (is_classic)
		Draw_SStringAligned(x, y, is_classic == 2 ? "----" : "\x1d\x1e\x1e\x1f", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
	x += 5 * FONT_WIDTH;
	Draw_SStringAligned(x, y - 8, "pl", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 2);
	if (is_classic)
		Draw_SStringAligned(x, y, is_classic == 2 ? "--" : "\x1d\x1f", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 2);
	x += 3 * FONT_WIDTH;
	Draw_SStringAligned(x, y - 8, "time", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
	if (is_classic)
		Draw_SStringAligned(x, y, is_classic == 2 ? "----" : "\x1d\x1e\x1e\x1f", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
	x += 5 * FONT_WIDTH;
	Draw_SStringAligned(x, y - 8, "frags", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 5);
	if (is_classic)
		Draw_SStringAligned(x, y, is_classic == 2 ? "-----" : "\x1d\x1e\x1e\x1e\x1f", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 5);
	x += 6 * FONT_WIDTH;
	if (cl.teamplay) {
		Draw_SStringAligned(x, y - 8, "team", scale, alpha, proportional, text_align_center, x + FONT_WIDTH * 4);
		if (is_classic)
			Draw_SStringAligned(x, y, is_classic == 2 ? "----" : "\x1d\x1e\x1e\x1f", scale, alpha, proportional, text_align_center, x + FONT_WIDTH * 4);
		x += 5 * FONT_WIDTH;
	}

	if (any_flags) {
		x += FONT_WIDTH;
	}

	Draw_SStringAligned(x, y - 8, "name", scale, alpha, proportional, text_align_left, x + FONT_WIDTH * 15);

	if (is_classic)
		Draw_SStringAligned(x, y, is_classic == 2 ? "---------------" : "\x1d\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1f", scale, alpha, proportional, text_align_left, x + FONT_WIDTH * 15);
	x += (any_flags ? 15 : 16) * FONT_WIDTH;
	if (!is_classic && statswidth) {
		stats_xoffset = x;

		Draw_SStringAligned(x, y - 8, "kills", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 5);
		x += FONT_WIDTH * 6;
		if (stats_team) {
			Draw_SStringAligned(x, y - 8, "tks", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 3);
			x += FONT_WIDTH * 4;
		}
		Draw_SStringAligned(x, y - 8, "dths", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
		x += FONT_WIDTH * 5;

		if (stats_touches) {
			Draw_SStringAligned(x, y - 8, "tchs", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
			x += FONT_WIDTH * 5;
		}

		if (stats_caps) {
			Draw_SStringAligned(x, y - 8, "caps", scale, alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
			x += FONT_WIDTH * 5;
		}
	}

	x = xofs + 1;

	if (!is_classic)
		Draw_Fill(xofs, y + 1, rank_width, 1, 0);	//Border - Top (under header)

	// If scr_scoreboard_classic is true, we've added an extra line for the
	// separator, which must be accounted for.
	y += is_classic ? 10 : 2;				//dont go over the black border, move the rest down
	if (!scr_scoreboard_borderless.value) {
		Draw_Fill(xofs - 1, y - 10, 1, 10, 0);						//Border - Left
		Draw_Fill(xofs - 1 + rank_width + 1, y - 10, 1, 10, 0);	//Border - Right
	}
	startx = x = xofs + 8;

	tempx = xofs + rank_width - MAX_SCOREBOARDNAME * 8 - (48 + statswidth) + leftover;

	Sbar_SortTeamsAndFrags(true);	// scores

	for (i = scoreboardsize = 0; i < scoreboardlines; i++) {
		k = fragsort[i];
		s = &cl.players[k];

		if (s->name[0]) {
			scoreboardsize++;
		}
	}

	if (y + (scoreboardsize - 1) * skip > SCOREBOARD_LASTROW) {
		colors_thickness = 3;
		skip = 8;
	}
	else {
		colors_thickness = 4;
	}

	for (i = 0; i < scoreboardlines && y <= SCOREBOARD_LASTROW; i++) {
		color_t background;
		float bk_alpha;
		byte c;
		clrinfo_t color;

		k = fragsort[i];
		s = &cl.players[k];
		is_classic_spec = is_classic && s->spectator;
		ti_cl = &ti_clients[k];
		ca_alpha = (check_ktx_ca_wo() && scr_scoreboard_wipeout.value && ti_cl->isdead) ? 0.25f : 1.0f; // fade dead players in CA/wipeout

		if (!s->name[0]) {
			continue;
		}

		//render the main background transparencies behind players row
		if (is_classic) {
			bk_alpha = 0;
		}
		else if (k == mynum && scr_scoreboard_highlightself.value) {
			bk_alpha = 1.7 * SCOREBOARD_ALPHA;
			bk_alpha = min(alpha, 0.75);
		}
		else {
			bk_alpha = SCOREBOARD_ALPHA;
		}

		if (!cl.teamplay || s->spectator || !scr_scoreboard_fillcolored.value ||
			(scr_scoreboard_fillcolored.value == 2 && !scr_scoreboard_teamsort.value)) {
			c = 2;
		}
		else {
			c = Sbar_BottomColorScoreboard(s);
		}

		if (S_Voip_Speaking(k)) {
			background = RGBA_TO_COLOR(0, 255, 0, (byte)(bk_alpha * 255));
		}
		else {
			background = RGBA_TO_COLOR(host_basepal[c * 3], host_basepal[c * 3 + 1], host_basepal[c * 3 + 2], (byte)(bk_alpha * 255));
		}

		Draw_AlphaFillRGB(xofs, y, rank_width, skip, background);

		if (!scr_scoreboard_borderless.value) {
			Draw_Fill(xofs - 1, y, 1, skip, 0);					//Border - Left
			Draw_Fill(xofs - 1 + rank_width + 1, y, 1, skip, 0);	//Border - Right
		}

		// draw ping
		p = s->ping;
		if (p < 0 || p > 999) {
			p = 999;
		}
		snprintf(num, sizeof(num), "%i", p);
		color.c = is_classic
			? RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(ca_alpha * 255))
			: RGBA_TO_COLOR(0xAA, 0xAA, 0xDD, (byte)(ca_alpha * 255));
		color.i = 0;
		Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha * ca_alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
		x += 4 * FONT_WIDTH; // move it forward, ready to print next column

		// draw pl
		p = s->pl;
		snprintf(num, sizeof(num), "%i", p);

		if (is_classic)
			color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(ca_alpha * 255));
		else {
			if (p == 0) {
				// 0 - white
				color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(ca_alpha * 255));
			}
			else if (p < 3) {
				// 1-2 - yellow
				color.c = RGBA_TO_COLOR(0xCC, 0xDD, 0xDD, (byte)(ca_alpha * 255));
			}
			else if (p < 6) {
				// 3-5 orange
				color.c = RGBA_TO_COLOR(0xFF, 0x55, 0x00, (byte)(ca_alpha * 255));
			}
			else {	// 6+ - red
				color.c = RGBA_TO_COLOR(0xFF, 0x00, 0x00, (byte)(ca_alpha * 255));
			}
		}

		if (!is_classic_spec)
			Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha * ca_alpha, proportional, text_align_right, x + 3 * FONT_WIDTH);

		x += 4 * FONT_WIDTH;

		// draw time
		total = (cl.intermission ? cl.completed_time : cls.demoplayback ? cls.demotime : cls.realtime) - s->entertime;
		total = (int)total / 60;
		total = bound(0, total, 999); // limit to 3 symbols int

		color.c = RGBA_TO_COLOR(255, 255, 255, 255);
		myminutes[0] = '\0';

		// overwrite time column with spawn times in KTX wipeout
		if (check_ktx_wo() && scr_scoreboard_wipeout.value && (ti_cl->isdead == 1) && (ti_cl->timetospawn > 0) && (ti_cl->timetospawn < 999)){
			color.c = RGBA_TO_COLOR(0xFF, 0xAA, 0x00, 255);
			snprintf(myminutes, sizeof(myminutes), "%d", ti_cl->timetospawn);

			if (!is_classic_spec)
				Draw_SColoredStringAligned(x, y, myminutes, &color, 1, scale * 0.85, alpha, proportional, text_align_right, x + 4 * FONT_WIDTH);
		}

		else if (!check_ktx_wo() || !scr_scoreboard_wipeout.value)
		{
			snprintf(myminutes, sizeof(myminutes), "%i", total);

			if (scr_scoreboard_afk.integer && (s->chatflag & CIF_AFK)) {
				color.c = RGBA_TO_COLOR(0xFF, 0x11, 0x11, 0xFF);
				if (scr_scoreboard_afk_style.integer == 1) {
					snprintf(myminutes, sizeof(myminutes), "afk");
				}
			}

			if (!is_classic_spec)
				Draw_SColoredStringAligned(x, y, myminutes, &color, 1, scale, alpha, proportional, text_align_right, x + 4 * FONT_WIDTH);
		}

		x += 5 * FONT_WIDTH;

		// draw spectator
		if (s->spectator) {
			if (cl.teamplay) {
				// use columns frags and team
				Draw_SStringAligned(is_classic_spec ? x - (8 * FONT_WIDTH) : x, y, is_classic_spec ? "(spectator)" : scr_scoreboard_spectator_name.string, scale, alpha, proportional, text_align_left, x + 10 * FONT_WIDTH);
			}
			else {
				// use only frags column
				Draw_SStringAligned(is_classic_spec ? x - (8 * FONT_WIDTH): x, y, is_classic_spec ? "(spectator)" : scr_scoreboard_spectator_name.string, scale, alpha, proportional, text_align_left, x + SHORT_SPECTATOR_NAME_LEN * FONT_WIDTH);
			}

			x += (cl.teamplay ? 11 : 6) * FONT_WIDTH; // move across to print the name

			if (s->loginname[0] && scr_scoreboard_login_indicator.string[0]) {
				mpic_t* flag = CL_LoginFlag(s->loginflag_id);
				if (s->loginflag[0] && flag) {
					Draw_FitPicAlphaCenter(x - FONT_WIDTH * 0.75, y, FONT_WIDTH * 1.6, FONT_WIDTH, flag, 1.0f);
				}
				else {
					Draw_SStringAligned(x - FONT_WIDTH * 0.75, y, scr_scoreboard_login_indicator.string, scale, alpha, proportional, text_align_center, x + FONT_WIDTH * 1.6);
				}
			}
			if (any_flags) {
				x += FONT_WIDTH;
			}
			if (s->loginname[0] && scr_scoreboard_login_names.integer) {
				if (scr_scoreboard_login_color.string[0]) {
					color.c = RGBAVECT_TO_COLOR(scr_scoreboard_login_color.color);
					Draw_SColoredStringAligned(x, y, s->loginname, &color, 1, scale, alpha, proportional, text_align_left, x + FONT_WIDTH * 15);
				}
				else {
					Draw_SStringAligned(x, y, s->loginname, scale, alpha, proportional, text_align_left, x + FONT_WIDTH * 15);
				}
			}
			else {
				Draw_SStringAligned(x, y, s->name, scale, ca_alpha, proportional, text_align_left, x + FONT_WIDTH * 15);
			}

			y += skip;
			x = startx;
			continue;
		}

		// print the shirt/pants colour bars
		// use Draw_AlphaFill with additional alpha arg for wipeout deaths
		Draw_AlphaFill(cl.teamplay ? tempx - 40 : tempx, y + 4 - colors_thickness, 40, colors_thickness, Sbar_TopColorScoreboard(s), ca_alpha);
		Draw_AlphaFill(cl.teamplay ? tempx - 40 : tempx, y + 4, 40, 4, Sbar_BottomColorScoreboard(s), ca_alpha);

		// frags
		if (Sbar_ShowScoreboardIndicator() && k == mynum) {
			Draw_Character(x, y, 16);
		}
		fragsint = bound(-999, s->frags, 9999); // limit to 4 symbols int
		snprintf(fragsstr, sizeof(fragsstr), "%i", fragsint);
		
		if (check_ktx_ca_wo() && scr_scoreboard_wipeout.value && ti_cl->isdead)
		{
			color.c = RGBA_TO_COLOR(85, 85, 85, 255 * ca_alpha);	// change team/name to gray transparent text if dead in ca/wipeout
		}
		else
		{
			color.c = RGBA_TO_COLOR(255, 255, 255, 255 * ca_alpha);
		}
		
		Draw_SColoredStringAligned(x, y, fragsstr, &color, 1, scale, alpha * ca_alpha, proportional, text_align_right, x + 4 * FONT_WIDTH);
		x += 4 * FONT_WIDTH;
		if (Sbar_ShowScoreboardIndicator() && k == mynum) {
			Draw_Character(x, y, 17);
		}
		x += 2 * FONT_WIDTH;

		// team
		if (cl.teamplay) {
			Draw_SColoredStringAligned(x, y, s->team, &color, 1, scale, alpha * ca_alpha, proportional, text_align_center, x + 4 * FONT_WIDTH);
			x += 5 * FONT_WIDTH;
		}

		if (s->loginname[0] && scr_scoreboard_login_indicator.string[0]) {
			mpic_t* flag = CL_LoginFlag(s->loginflag_id);
			if (s->loginflag[0] && flag) {
				Draw_FitPicAlphaCenter(x - FONT_WIDTH * 0.75, y, FONT_WIDTH * 1.6, FONT_WIDTH, flag, 1.0f * ca_alpha);
			}
			else {
				Draw_SStringAligned(x - FONT_WIDTH * 0.75, y, scr_scoreboard_login_indicator.string, scale, alpha * ca_alpha, proportional, text_align_center, x + FONT_WIDTH * 1.6);
			}
		}
		if (any_flags) {
			x += FONT_WIDTH;
		}
		if (s->loginname[0] && scr_scoreboard_login_names.integer) {
			if (scr_scoreboard_login_color.string[0]) {
				color.c = RGBAVECT_TO_COLOR(scr_scoreboard_login_color.color);
				Draw_SColoredStringAligned(x, y, s->loginname, &color, 1, scale, alpha * ca_alpha, proportional, text_align_left, x + FONT_WIDTH * 15);
			}
			else {
				Draw_SStringAligned(x, y, s->loginname, scale, alpha * ca_alpha, proportional, text_align_left, x + FONT_WIDTH * 15);
			}
		}
		else {
			Draw_SColoredStringAligned(x, y, s->name, &color, 1, scale, alpha * ca_alpha, proportional, text_align_left, x + FONT_WIDTH * 15);
		}

		if (statswidth) {
			x = stats_xoffset;
			Stats_GetBasicStats(s - cl.players, playerstats);
			if (stats_touches || stats_caps) {
				Stats_GetFlagStats(s - cl.players, playerstats + 4);
			}

			// kills
			if (check_ktx_wo() && scr_scoreboard_wipeout.value)
			{
				snprintf(num, sizeof(num), "%d", ti_cl->round_kills);
				color.c = (ti_cl->round_kills == 0 ? RGBA_TO_COLOR(255, 255, 255, 255) : RGBA_TO_COLOR(0, 187, 68, 255));
			}
			else
			{
				snprintf(num, sizeof(num), "%5i", playerstats[0]);
				color.c = (playerstats[0] == 0 ? RGBA_TO_COLOR(255, 255, 255, 255) : RGBA_TO_COLOR(0, 187, 68, 255));
			}
			Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha, proportional, text_align_right, x + 5 * FONT_WIDTH);
			x += 6 * FONT_WIDTH;

			// teamkills
			if (stats_team) {
				snprintf(num, sizeof(num), "%3i", playerstats[2]);
				color.c = (playerstats[2] == 0 ? RGBA_TO_COLOR(255, 255, 255, 255) : RGBA_TO_COLOR(255, 255, 0, 255));
				Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha, proportional, text_align_right, x + 3 * FONT_WIDTH);
				x += 4 * FONT_WIDTH;
			}

			// deaths
			if (check_ktx_wo() && scr_scoreboard_wipeout.value)
			{
				snprintf(num, sizeof(num), "%d", ti_cl->round_deaths);
				color.c = (ti_cl->round_deaths == 0 ? RGBA_TO_COLOR(255, 255, 255, 255) : RGBA_TO_COLOR(255, 0, 0, 255));
			}
			else{
				snprintf(num, sizeof(num), "%4i", playerstats[1]);
				color.c = (playerstats[1] == 0 ? RGBA_TO_COLOR(255, 255, 255, 255) : RGBA_TO_COLOR(255, 0, 0, 255));
			}
			Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha, proportional, text_align_right, x + 4 * FONT_WIDTH);
			x += 5 * FONT_WIDTH;

			if (stats_touches) {
				// flag touches
				if (playerstats[4] < 1) {
					// 0 flag touches white
					color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, 0xFF);
				}
				else if (playerstats[4] < 2) {
					// 1 flag touches yellow
					color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0x00, 0xFF);
				}
				else if (playerstats[4] < 5) {
					// 2-4 flag touches orange
					color.c = RGBA_TO_COLOR(0xFF, 0x55, 0x00, 0xFF);
				}
				else if (playerstats[4] < 10) {
					// 5-9 flag touches pink
					color.c = RGBA_TO_COLOR(0xBB, 0x33, 0xBB, 0xFF);
				}
				else {
					// >9 flag touches green
					color.c = RGBA_TO_COLOR(0x00, 0xFF, 0x00, 0xFF);
				}
				snprintf(num, sizeof(num), "%4i", playerstats[4]);
				Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha, proportional, text_align_right, x + 4 * FONT_WIDTH);
				x += 5 * FONT_WIDTH;
			}

			if (stats_caps) // flag captures
			{
				if (playerstats[6] < 1) {
					// 0 caps white
					color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, 0xFF);
				}
				else if (playerstats[6] < 2) {
					// 1 cap yellow
					color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0x00, 0xFF);
				}
				else if (playerstats[6] < 5) {
					// 2-4 caps orange
					color.c = RGBA_TO_COLOR(0xFF, 0x55, 0x00, 0xFF);
				}
				else if (playerstats[6] < 10) {
					// 5-9 caps pink
					color.c = RGBA_TO_COLOR(0xBB, 0x33, 0xBB, 0xFF);
				}
				else {
					// >9 caps green
					color.c = RGBA_TO_COLOR(0x00, 0xFF, 0x00, 0xFF);
				}
				snprintf(num, sizeof(num), "%4i", playerstats[6]);
				Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha, proportional, text_align_right, x + 4 * FONT_WIDTH);
				x += 5 * FONT_WIDTH;
			}
		}

		y += skip;
		x = startx;
	}

	if (!scr_scoreboard_showqtvusers.value) {
		goto finalize;
	}

	for (qu = qtvuserlist; qu && y <= SCOREBOARD_LASTROW; qu = qu->next) {
		color_t background;
		float bk_alpha;
		byte c = 2;
		clrinfo_t color;
		ca_alpha = 1.0f;

		if (!qu->name[0]) {
			continue;
		}

		if (is_classic) {
			bk_alpha = 0;
		} else if (k == mynum && scr_scoreboard_highlightself.value) {
			bk_alpha = 1.7 * SCOREBOARD_ALPHA;
			bk_alpha = min(alpha, 0.75);
		} else {
			bk_alpha = SCOREBOARD_ALPHA;
		}

		background = RGBA_TO_COLOR(host_basepal[c * 3], host_basepal[c * 3 + 1], host_basepal[c * 3 + 2], (byte)(bk_alpha * 255));
		Draw_AlphaFillRGB(xofs, y, rank_width, skip, background);

		if (!scr_scoreboard_borderless.value) {
			Draw_Fill(xofs - 1, y, 1, skip, 0);
			Draw_Fill(xofs - 1 + rank_width + 1, y, 1, skip, 0);
		}

		snprintf(num, sizeof(num), "%i", 0);

		color.c = is_classic
			? RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(ca_alpha * 255))
			: RGBA_TO_COLOR(0xAA, 0xAA, 0xDD, (byte)(ca_alpha * 255));
		color.i = 0;
		Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha * ca_alpha, proportional, text_align_right, x + FONT_WIDTH * 4);
		x += 4 * FONT_WIDTH;

		if (is_classic) {
			color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(ca_alpha * 255));
		} else {
			if (p == 0) {
				// 0 - white
				color.c = RGBA_TO_COLOR(0xFF, 0xFF, 0xFF, (byte)(ca_alpha * 255));
			} else if (p < 3) {
				// 1-2 - yellow
				color.c = RGBA_TO_COLOR(0xCC, 0xDD, 0xDD, (byte)(ca_alpha * 255));
			} else if (p < 6) {
				// 3-5 orange
				color.c = RGBA_TO_COLOR(0xFF, 0x55, 0x00, (byte)(ca_alpha * 255));
			} else {
				// 6+ - red
				color.c = RGBA_TO_COLOR(0xFF, 0x00, 0x00, (byte)(ca_alpha * 255));
			}
		}

		if (!is_classic) {
			Draw_SColoredStringAligned(x, y, num, &color, 1, scale, alpha * ca_alpha, proportional, text_align_right, x + 3 * FONT_WIDTH);
		}

		x += 4 * FONT_WIDTH;

		color.c = RGBA_TO_COLOR(255, 255, 255, 255);

		if (!is_classic) {
			snprintf(myminutes, sizeof(myminutes), "%i", 0);
			Draw_SColoredStringAligned(x, y, myminutes, &color, 1, scale, alpha, proportional, text_align_right, x + 4 * FONT_WIDTH);
		}

		x += 5 * FONT_WIDTH;

		if (cl.teamplay) {
			Draw_SStringAligned(is_classic ? x - (8 * FONT_WIDTH) : x, y, is_classic ? "(qtv)" : scr_scoreboard_qtv_name.string, scale, alpha, proportional, text_align_left, x + 10 * FONT_WIDTH);
		} else {
			Draw_SStringAligned(is_classic ? x - (8 * FONT_WIDTH): x, y, is_classic ? "(qtv)" : scr_scoreboard_qtv_name.string, scale, alpha, proportional, text_align_left, x + SHORT_SPECTATOR_NAME_LEN * FONT_WIDTH);
		}

		x += (cl.teamplay ? 11 : 6) * FONT_WIDTH;
		Draw_SStringAligned(x, y, qu->name, scale, ca_alpha, proportional, text_align_left, x + FONT_WIDTH * 15);
		y += skip;
		x = startx;
	}

finalize:
	if (!scr_scoreboard_borderless.value) {
		Draw_Fill(xofs - 1, y - 1, rank_width + 2, 1, 0); //Border - Bottom
	}
}

static void Sbar_TeamOverlay(void)
{
	int i, k, x, y, xofs, plow, phigh, pavg, rank_width, skip = 10;
	char num[12], team[5];
	team_t *tm;
	mpic_t *pic;
	qbool proportional = scr_scoreboard_proportional.integer;
	float lhs;
	int is_classic = scr_scoreboard_classic.integer;

	if (key_dest == key_console && !SCR_TakingAutoScreenshot())
		return;

#ifndef CLIENTONLY
	// FIXME
	// check number of connections instead?
	if (cl.gametype == GAME_COOP && com_serveractive && !coop.value)
		return;
#endif

	if (!cl.teamplay) {
		Sbar_DeathmatchOverlay(0);
		return;
	}

	if (hud_faderankings.value)
		Draw_FadeScreen(hud_faderankings.value);

	scr_copyeverything = 1;
	scr_fullupdate = 0;

	rank_width = cl.teamplay ? RANK_WIDTH_TEAM : RANK_WIDTH_DM;
	rank_width = bound(0, rank_width, vid.width - 16);

	y = hud_rankingpos_y.value;
	if (y < 0 || y > vid.height / 2) {
		y = 0;
	}

	if (hud_centerranking.value) {
		xofs = ((vid.width - rank_width) >> 1) + hud_rankingpos_x.value;
	}
	else {
		xofs = hud_rankingpos_x.value;
	}

	if (scr_scoreboard_drawtitle.value) {
		pic = Draw_CachePic(CACHEPIC_RANKING);
		Draw_Pic(xofs + (rank_width - pic->width) / 2, y, pic);
		y = 26 + hud_rankingpos_y.value;
	}
	else {
		y = 2 + hud_rankingpos_y.value;
	}

	if (!scr_scoreboard_borderless.value) {
		Draw_Fill(xofs - 1, y + 1, rank_width + 2, 1, 0);							//Border - Top
	}

	if (!is_classic) {
		Draw_AlphaFill(xofs, y + 2, rank_width, skip, 1, SCOREBOARD_HEADINGALPHA); //draw heading row
		Draw_Fill(xofs, y + 11, rank_width, 1, 0); //Border - Top (under header)
	}
	y += 2;																		//dont go over the black border, move the rest down
	if (!scr_scoreboard_borderless.value) {
		Draw_Fill(xofs - 1, y, 1, skip, 0);										//Border - Left
		Draw_Fill(xofs - 1 + rank_width + 1, y, 1, skip, 0);						//Border - Right
	}

	x = xofs + rank_width * 0.1 + 8;

	lhs = x;

	Draw_SStringAligned(x, y, "low", 1, 1, proportional, text_align_right, x + 3 * FONT_WIDTH);
	if (is_classic)
		Draw_SStringAligned(x, y + 8, is_classic == 2 ? "---" : "\x1d\x1e\x1e", 1, 1, proportional, text_align_right, x + 3 * FONT_WIDTH);
	x += 3 * FONT_WIDTH;
	Draw_SStringAligned(x, y, "/", 1, 1, proportional, text_align_right, x + FONT_WIDTH);
	if (is_classic)
		Draw_SStringAligned(x, y + 8, is_classic == 2 ? "-" : "\x1e", 1, 1, proportional, text_align_right, x + FONT_WIDTH);
	x += FONT_WIDTH;
	Draw_SStringAligned(x, y, "avg", 1, 1, proportional, text_align_right, x + FONT_WIDTH * 3);
	if (is_classic)
		Draw_SStringAligned(x, y + 8, is_classic == 2 ? "---" : "\x1e\x1e\x1e", 1, 1, proportional, text_align_right, x + FONT_WIDTH * 3);
	x += 3 * FONT_WIDTH;
	Draw_SStringAligned(x, y, "/", 1, 1, proportional, text_align_right, x + FONT_WIDTH);
	if (is_classic)
		Draw_SStringAligned(x, y + 8, is_classic == 2 ? "-" : "\x1e", 1, 1, proportional, text_align_right, x + FONT_WIDTH);
	x += FONT_WIDTH;
	Draw_SStringAligned(x, y, "high", 1, 1, proportional, text_align_right, x + FONT_WIDTH * 4);
	if (is_classic)
		Draw_SStringAligned(x, y + 8, is_classic == 2 ? "----" : "\x1e\x1e\x1e\x1f", 1, 1, proportional, text_align_right, x + FONT_WIDTH * 4);
	x += 4 * FONT_WIDTH;
	x += FONT_WIDTH;
	Draw_SStringAligned(x, y, "team", 1, 1, proportional, text_align_center, x + FONT_WIDTH * 4);
	if (is_classic)
		Draw_SStringAligned(x, y + 8, is_classic == 2 ? "----" : "\x1d\x1e\x1e\x1f", 1, 1, proportional, text_align_center, x + FONT_WIDTH * 4);
	x += 4 * FONT_WIDTH;
	x += FONT_WIDTH;
	Draw_SStringAligned(x, y, (cl.scoring_system == SCORING_SYSTEM_TEAMFRAGS ? "score" : "total"), 1, 1, proportional, text_align_right, x + FONT_WIDTH * 5);
	if (is_classic)
		Draw_SStringAligned(x, y + 8, is_classic == 2 ? "-----" : "\x1d\x1e\x1e\x1e\x1f", 1, 1, proportional, text_align_right, x + FONT_WIDTH * 5);
	x += 5 * FONT_WIDTH;
	x += FONT_WIDTH;
	if ((cl.teamfortress || scr_scoreboard_showflagstats.value) && Stats_IsFlagsParsed() && !is_classic) {
		Draw_SStringAligned(x, y, "caps", 1, 1, proportional, text_align_center, x + FONT_WIDTH * 4);
		x += 4 * FONT_WIDTH;
		x += FONT_WIDTH;
	}

	Draw_SStringAligned(x, y, "players", 1, 1, proportional, text_align_left, x + FONT_WIDTH * 7);
	if (is_classic)
		Draw_SStringAligned(x, y + 8, is_classic == 2 ? "-------" : "\x1d\x1e\x1e\x1e\x1e\x1e\x1f", 1, 1, proportional, text_align_left, x + FONT_WIDTH * 7);
	x = lhs;

	// If scr_scoreboard_classic is true, we've added an extra line for the
	// separator, which must be accounted for.
	y += is_classic ? 18 : 10;

	Sbar_SortTeams();		// sort the teams

	for (i = 0; i < scoreboardteams && y <= SCOREBOARD_LASTROW; i++) {
		k = teamsort[i];
		tm = teams + k;
		x = lhs;

		if (!is_classic)
			Draw_AlphaFill(xofs, y, rank_width, skip, 2, SCOREBOARD_ALPHA);

		if (!scr_scoreboard_borderless.value) {
			Draw_Fill(xofs - 1, y, 1, skip, 0);						//Border - Left
			Draw_Fill(xofs - 1 + rank_width + 1, y, 1, skip, 0);		//Border - Right
		}

		// draw pings
		plow = tm->plow;
		if (plow < 0 || plow > 999) {
			plow = 999;
		}

		phigh = tm->phigh;
		if (phigh < 0 || phigh > 999) {
			phigh = 999;
		}

		pavg = tm->players ? tm->ptotal / tm->players : 999;
		if (pavg < 0 || pavg > 999) {
			pavg = 999;
		}

		snprintf(num, sizeof(num), "%3i", plow);
		Draw_SStringAligned(x, y, num, 1, 1, proportional, text_align_right, x + 3 * FONT_WIDTH);
		x += 3 * FONT_WIDTH;
		Draw_SStringAligned(x, y, "/", 1, 1, proportional, text_align_right, x + FONT_WIDTH);
		x += FONT_WIDTH;
		snprintf(num, sizeof(num), "%3i", pavg);
		Draw_SStringAligned(x, y, num, 1, 1, proportional, text_align_right, x + 3 * FONT_WIDTH);
		x += 3 * FONT_WIDTH;
		Draw_SStringAligned(x, y, "/", 1, 1, proportional, text_align_right, x + FONT_WIDTH);
		x += FONT_WIDTH;
		snprintf(num, sizeof(num), "%3i", phigh);
		Draw_SStringAligned(x, y, num, 1, 1, proportional, text_align_right, x + 3 * FONT_WIDTH);
		x += 3 * FONT_WIDTH;
		x += FONT_WIDTH;

		// draw team
		if (Sbar_ShowScoreboardIndicator() && tm->myteam) {
			Draw_SStringAligned(x, y, "\020", 1, 1, proportional, text_align_right, x + FONT_WIDTH);
		}
		x += FONT_WIDTH;
		strlcpy(team, tm->team, sizeof(team));
		Draw_SStringAligned(x, y, team, 1, 1, proportional, text_align_center, x + 4 * FONT_WIDTH);
		x += 4 * FONT_WIDTH;
		if (Sbar_ShowScoreboardIndicator() && tm->myteam) {
			Draw_SStringAligned(x, y, "\021", 1, 1, proportional, text_align_left, x + FONT_WIDTH);
		}
		x += FONT_WIDTH;

		// draw total
		snprintf(num, sizeof(num), "%5i", tm->frags);
		Draw_SStringAligned(x, y, num, 1, 1, proportional, text_align_right, x + 5 * FONT_WIDTH);
		x += 5 * FONT_WIDTH;
		x += FONT_WIDTH;

		if ((cl.teamfortress || scr_scoreboard_showflagstats.value) && Stats_IsFlagsParsed()) {
			snprintf(num, sizeof(num), "%4i", tm->caps);
			Draw_SStringAligned(x, y, num, 1, 1, proportional, text_align_right, x + 4 * FONT_WIDTH);
			x += 4 * FONT_WIDTH;
			x += FONT_WIDTH;
		}

		// draw players
		snprintf(num, sizeof(num), "%7i", tm->players);
		Draw_SStringAligned(x, y, num, 1, 1, proportional, text_align_left, x + 7 * FONT_WIDTH);

		y += skip;
	}

	if (!scr_scoreboard_borderless.value) {
		Draw_Fill(xofs - 1, y - 1, rank_width + 2, 1, 0);              //Border - Bottom
	}

	y += 14;
	Sbar_DeathmatchOverlay(y);
}


static void Sbar_MiniDeathmatchOverlay (void) {
	int i, k, x, y, mynum, numlines;
	char num[4 + 1], name[16 + 1], team[4 + 1];
	player_info_t *s;
	team_t *tm;

	if (!scr_drawVFrags.value)
		return;

	if (!sb_lines)
		return; // not enuff room

	scr_copyeverything = 1;
	scr_fullupdate = 0;

	mynum = Sbar_PlayerNum();

	x = 324;


	if (vid.width < 640 && cl.teamplay && scr_drawVFrags.value == 2)
		goto drawteams;

	// scores
	Sbar_SortFrags (false);

	if (!scoreboardlines)
		return; // no one there?

	// draw the text
	y = vid.height - sb_lines - 1;
	numlines = sb_lines / 8;
	if (numlines < 3)
		return; // not enough room

	// find us
	for (i = 0; i < scoreboardlines; i++)
		if (fragsort[i] == mynum)
			break;

	if (i == scoreboardlines)	// we're not there, we are probably a spectator, just display top
		i = 0;
	else						// figure out start
		i = i - numlines / 2;

	i = bound(0, i, scoreboardlines - numlines);

	for ( ; i < scoreboardlines && y < vid.height - 8 + 1; i++) {
		k = fragsort[i];
		s = &cl.players[k];

		if (!s->name[0]) {
			continue;
		}

		Draw_Fill(x, y + 1, 40, 3, Sbar_TopColorScoreboard(s));
		Draw_Fill(x, y + 4, 40, 4, Sbar_BottomColorScoreboard(s));

		// draw number
		snprintf (num, sizeof(num), "%3i", bound(-99, s->frags, 999));

		Draw_Character (x + 8 , y, num[0]);
		Draw_Character (x + 16, y, num[1]);
		Draw_Character (x + 24, y, num[2]);

		if (Sbar_ShowScoreboardIndicator()) {
			if (k == mynum) {
				Draw_Character (x, y, 16);
				Draw_Character (x + 32, y, 17);
			}
		}

		// team
		if (cl.teamplay) {
			strlcpy (team, s->team, sizeof(team));
			Draw_String (x + 48, y, team);
		}

		// draw name
		strlcpy (name, s->name, sizeof(name));
		if (cl.teamplay) {
			Draw_String(x + 48 + 40, y, name);
		}
		else {
			Draw_String(x + 48, y, name);
		}

		y += 8;
	}

	// draw teams if room
	if (vid.width < 640 || !cl.teamplay) {
		return;
	}

	Sbar_SortTeams();
	if (!scoreboardteams) {
		return;
	}

	// draw seperator
	x += 208;
	for (y = vid.height - sb_lines; y < vid.height - 6; y += 2) {
		Draw_Character(x, y, 14);
	}

	x += 16;

drawteams:
	Sbar_SortTeams();

	y = vid.height - sb_lines;
	for (i = 0; i < scoreboardteams && y < vid.height - 8 + 1; i++) {
		k = teamsort[i];
		tm = teams + k;

		//draw name
		strlcpy(team, tm->team, sizeof(team));
		Draw_String(x, y, team);

		// draw total
		Draw_Fill(x + 40, y + 1, 48, 3, Sbar_ColorForMap(tm->topcolor));
		Draw_Fill(x + 40, y + 4, 48, 4, Sbar_ColorForMap(tm->bottomcolor));
		snprintf(num, sizeof(num), "%4i", bound(-999, tm->frags, 9999));
		Draw_Character(x + 40 + 8, y, num[0]);
		Draw_Character(x + 40 + 16, y, num[1]);
		Draw_Character(x + 40 + 24, y, num[2]);
		Draw_Character(x + 40 + 32, y, num[3]);

		if (tm->myteam) {
			Draw_Character(x + 40, y, 16);
			Draw_Character(x + 40 + 40, y, 17);
		}

		y += 8;
	}
}

static void Sbar_IntermissionNumber (int x, int y, int num, int digits, int color, int rightadjustify) {
	char str[12], *ptr;
	int l, frame;

	l = Sbar_itoa (num, str);
	ptr = str;
	if (l > digits)
		ptr += (l - digits);
	if (rightadjustify && l < digits)
		x += (digits - l) * 24;

	while (*ptr) {
		frame = (*ptr == '-') ? STAT_MINUS : *ptr -'0';
		Draw_TransPic (x, y, sb_nums[color][frame]);
		x += 24;
		ptr++;
	}
}

void Sbar_IntermissionOverlay (void) {
	mpic_t *pic;
	float time;
	int	dig, num, xofs;

	scr_copyeverything = 1;
	scr_fullupdate = 0;

	if (cl.gametype == GAME_DEATHMATCH)	{
		if (cl.teamplay && !sb_showscores)
			Sbar_TeamOverlay ();
		else
			Sbar_DeathmatchOverlay (0);
		return;
	}

	xofs = (vid.width - 320 ) >> 1;

	pic = Draw_CachePic(CACHEPIC_COMPLETE);
	Draw_Pic (xofs + 64, 24, pic);

	pic = Draw_CachePic(CACHEPIC_INTER);
	Draw_TransPic (xofs, 56, pic);

	if (cl.servertime_works)
		time = cl.solo_completed_time;	// we know the exact time
	else
		time = cl.completed_time - cl.players[cl.playernum].entertime;	// use an estimate

	//time
	dig = time / 60;
	dig = max(dig, 0);
	Sbar_IntermissionNumber (xofs + 152, 64, dig, 3, 0, true);
	num = time - dig * 60;
	Draw_TransPic (xofs + 224, 64, sb_colon);
	Draw_TransPic (xofs + 248, 64, sb_nums[0][num / 10]);
	Draw_TransPic (xofs + 272, 64, sb_nums[0][num % 10]);

	//secrets
	Sbar_IntermissionNumber (xofs + 152, 104, cl.stats[STAT_SECRETS], 3, 0, true);
	Draw_TransPic (xofs + 224, 104, sb_slash);
	Sbar_IntermissionNumber (xofs + 248, 104, cl.stats[STAT_TOTALSECRETS], 3, 0, false);

	//monsters
	Sbar_IntermissionNumber (xofs + 152, 144, cl.stats[STAT_MONSTERS], 3, 0, true);
	Draw_TransPic (xofs + 224, 144, sb_slash);
	Sbar_IntermissionNumber (xofs + 248, 144, cl.stats[STAT_TOTALMONSTERS], 3, 0, false);
}

void Sbar_FinaleOverlay (void) {
	mpic_t *pic;

	scr_copyeverything = 1;

	pic = Draw_CachePic (CACHEPIC_FINALE);
	Draw_TransPic ( (vid.width-pic->width)/2, 16, pic);
}

/********************************* INTERFACE *********************************/
void Sbar_Draw(void) {
	qbool headsup;
	extern cvar_t scr_newHud;

	headsup = !Sbar_IsStandardBar();
	if (sb_updates >= vid.numpages && !headsup)
	{
		// Always show who we're tracking
		Sbar_DrawTrackingString();

		return;
	}

	scr_copyeverything = 1;

	sb_updates++;

	if (scr_centerSbar.value)
		sbar_xofs = (vid.width - 320) >> 1;
	else
		sbar_xofs = 0;

	// Top line. Do not show with +showscores
	if (sb_lines > 24 && scr_newHud.value != 1 && !sb_showscores && !sb_showteamscores) 
	{ 
		if (!cl.spectator || cl.autocam == CAM_TRACK)
			Sbar_DrawInventory();

		if (cl.gametype == GAME_DEATHMATCH && (!headsup || vid.width < 512 || (vid.width >= 512 && scr_centerSbar.value )))
			Sbar_DrawFrags();
	}

	// main area
	if (sb_lines > 0 && scr_newHud.value != 1) {  // HUD -> hexum
		if (cl.spectator) {
			if (cl.autocam != CAM_TRACK) {
				Sbar_DrawSpectatorMessage();
			}
			else {
				if (sb_showscores || sb_showteamscores || cl.stats[STAT_HEALTH] <= 0)
					Sbar_SoloScoreboard ();

				else if (scr_compactHud.value == 4)
					Sbar_DrawCompact_WithIcons();
				else if (scr_compactHud.value == 3)
					Sbar_DrawCompact_Bare();
				else if (scr_compactHud.value == 2)
					Sbar_DrawCompact_TF();
				else if (scr_compactHud.value == 1)
					Sbar_DrawCompact();
				else
					Sbar_DrawNormal();

				Sbar_DrawTrackingString();
			}
		} else if (sb_showscores || sb_showteamscores || cl.stats[STAT_HEALTH] <= 0) {
			Sbar_SoloScoreboard();
		} else if (scr_compactHud.value == 4) {
			Sbar_DrawCompact_WithIcons();
		} else if (scr_compactHud.value == 3) {
			Sbar_DrawCompact_Bare();
		} else if (scr_compactHud.value == 2) {
			Sbar_DrawCompact_TF();
		} else if (scr_compactHud.value == 1) {
			Sbar_DrawCompact();
		} else {
			Sbar_DrawNormal();
		}
	}
	if (sb_lines > 0 && scr_newHud.value == 1 && cl.deathmatch == 0
			&& (sb_showscores || sb_showteamscores || cl.stats[STAT_HEALTH] <= 0)) {
		Sbar_SoloScoreboard();
	}

	//VULT STAT LOSS
	if (amf_stat_loss.value && cl.stats[STAT_HEALTH] <= 0)
	{
		Amf_Reset_DamageStats();
	}

	// main screen deathmatch rankings
	// if we're dead show team scores in team games
	if (cl.stats[STAT_HEALTH] <= 0 && !cl.spectator) {
		if (cl.teamplay && !sb_showscores)
			Sbar_TeamOverlay();
		else
			Sbar_DeathmatchOverlay (0);
	} else if (sb_showscores) {
		Sbar_DeathmatchOverlay (0);
	} else if (sb_showteamscores) {
		Sbar_TeamOverlay();
	}

	if (sb_showscores || sb_showteamscores || cl.stats[STAT_HEALTH] <= 0)
		sb_updates = 0;

	if (scr_newHud.value == 1) // HUD -> hexum
		return;

	// clear unused areas in GL
	if (vid.width > 320 && !headsup) {
		if (scr_centerSbar.value)	// left
			Draw_TileClear (0, vid.height - sb_lines, sbar_xofs, sb_lines);
		Draw_TileClear (320 + sbar_xofs, vid.height - sb_lines, vid.width - (320 + sbar_xofs), sb_lines);	// right
	}
	if (!headsup && cl.spectator && cl.autocam != CAM_TRACK && sb_lines > SBAR_HEIGHT)
		Draw_TileClear (sbar_xofs, vid.height - sb_lines, 320, sb_lines - SBAR_HEIGHT);

	if (vid.width >= 512 && sb_lines > 0 
			&& cl.gametype == GAME_DEATHMATCH && !scr_centerSbar.value 
			&& MULTIVIEWTHISPOV())
	{
		Sbar_MiniDeathmatchOverlay ();
	}
}

int CL_LoginImageId(const char* name)
{
	int index = -1;
	int i;

	if (name[0]) {
		for (i = 0; i < login_image_data.image_count; ++i) {
			if (!strcasecmp(name, login_image_data.images[i].name)) {
				return i;
			}
		}
	}
	return index;
}

int CL_LoginImageBot(void)
{
	return login_image_data.bot_image_index;
}

qbool CL_LoginImageLoad(const char* path)
{
	json_error_t error;
	char truepath[MAX_OSPATH];
	json_t* json;
	loginimage_t* new_login_images;
	size_t new_login_image_count = 0;
	int new_login_bot_image = -1;
	int i, tex_width, tex_height, max_width = 0, max_height = 0;
	json_t* val;

	if (!path[0]) {
		Q_free(login_image_data.images);
		login_image_data.image_count = 0;
		login_image_data.bot_image_index = -1;
		return true;
	}

	strlcpy(truepath, "textures/scoreboard/", sizeof(truepath));
	strlcat(truepath, path, sizeof(truepath));
	COM_ForceExtensionEx(truepath, ".json", sizeof(truepath));
	{
		int json_len;
		char* json_bytes = (char*)FS_LoadHeapFile(truepath, &json_len);
		if (!json_bytes) {
			Con_Printf("Unable to load %s\n", truepath);
			return false;
		}

		json = json_loadb(json_bytes, json_len, 0, &error);
		Q_free(json_bytes);
	}
	if (!json || !json_is_array(json)) {
		Con_Printf("Invalid json file %s\n", truepath);
		if (json) {
			json_decref(json);
		}
		return false;
	}

	new_login_image_count = json_array_size(json);
	new_login_images = Q_malloc(sizeof(new_login_images[0]) * new_login_image_count);
	json_array_foreach(json, i, val) {
		const char* code = JSON_readstring(json_object_get(val, "code"));
		const char* path = JSON_readstring(json_object_get(val, "file"));
		int x = JSON_readint(json_object_get(val, "x"));
		int y = JSON_readint(json_object_get(val, "y"));
		int width = JSON_readint(json_object_get(val, "width"));
		int height = JSON_readint(json_object_get(val, "height"));
		texture_ref texture;

		strlcpy(truepath, "textures/scoreboard/", sizeof(truepath));
		strlcat(truepath, path, sizeof(truepath));
		COM_StripExtension(truepath, truepath, sizeof(truepath));

		if (code == NULL || !code[0]) {
			Q_free(new_login_images);
			Con_Printf("Failed to load screenshot flags: json error on element#%d\n", i);
			return false;
		}

		texture = R_LoadTextureImage(truepath, truepath, 0, 0, TEX_ALPHA | TEX_PREMUL_ALPHA | TEX_NOSCALE);
		if (!R_TextureReferenceIsValid(texture)) {
			Con_Printf("Unable to load %s\n", truepath);
			return false;
		}
		tex_width = R_TextureWidth(texture);
		tex_height = R_TextureHeight(texture);

		x = max(x, 0);
		y = max(y, 0);
		width = (width < 0 ? tex_width : width);
		height = (height < 0 ? tex_height : height);

		width = min(width, tex_width - x);
		height = min(height, tex_height - y);

		strlcpy(new_login_images[i].name, code, sizeof(new_login_images[i].name));
		new_login_images[i].pic.width = width;
		new_login_images[i].pic.height = height;
		new_login_images[i].pic.texnum = texture;
		new_login_images[i].pic.sl = (1.0f * x) / tex_width;
		new_login_images[i].pic.tl = (1.0f * y) / tex_height;
		new_login_images[i].pic.sh = (1.0f * width) / tex_width;
		new_login_images[i].pic.th = (1.0f * height) / tex_height;

		max_width = max(width, max_width);
		max_height = max(height, max_height);
	}

	login_image_data.images = new_login_images;
	login_image_data.image_count = new_login_image_count;
	login_image_data.bot_image_index = new_login_bot_image;
	login_image_data.max_width = max_width;
	login_image_data.max_width = max_height;

	for (i = 0; i < sizeof(cl.players) / sizeof(cl.players[0]); ++i) {
		cl.players[i].loginflag_id = CL_LoginImageId(cl.players[i].loginflag);
	}

	json_decref(json);
	return true;
}

static void OnChange_scr_scoreboard_login_flagfile(cvar_t* cv, char* newvalue, qbool* cancel)
{
	*cancel = CL_LoginImageLoad(newvalue);
}

static void OnChange_scr_scoreboard_showqtvusers(cvar_t *old_value, char *new_value, qbool *cancel)
{
	qbool is_set = (new_value && *new_value == '1');
	Info_SetValueForKey (cls.userinfo, "qul", is_set ? "1" : "0", MAX_INFO_STRING);

	if (cls.state >= ca_connected)
	{
		MSG_WriteByte(&cls.netchan.message, clc_stringcmd);
		SZ_Print(&cls.netchan.message, va("setinfo \"qul\" \"%s\"", is_set ? "1" : "0"));
	}

	if (!is_set)
	{
		QTV_FreeUserList();
	}
}

static mpic_t* CL_LoginFlag(int id)
{
	if (id < 0 || id >= login_image_data.image_count) {
		return NULL;
	}
	return &login_image_data.images[id].pic;
}

static int JSON_readint(json_t* json)
{
	if (json_is_integer(json)) {
		return (int)json_integer_value(json);
	}
	return -1;
}

static const char* JSON_readstring(json_t* json)
{
	if (json_is_string(json)) {
		return json_string_value(json);
	}
	return "";
}


================================================
FILE: src/sbar.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// the status bar is only redrawn if something has changed, but if anything
// does, the entire thing will be redrawn for the next vid.numpages frames.

#ifndef EZQUAKE_SBAR_HEADER
#define EZQUAKE_SBAR_HEADER

#define	SBAR_HEIGHT		24

extern	int			sb_lines;			// scan lines to draw

void Sbar_Init (void);

void Sbar_Changed (void);
// call whenever any of the client stats represented on the sbar changes

void Sbar_Draw (void);
// called every frame by screen

void Sbar_IntermissionOverlay (void);
// called each frame after the level has been completed

void Sbar_FinaleOverlay (void);

int Sbar_TopColor(player_info_t *player);
int Sbar_BottomColor(player_info_t *player);

void Sbar_DrawNum (int x, int y, int num, int digits, int color);

// covert quake pallete color number to rgb color
int Sbar_ColorForMap (int m);

#define STAT_MINUS		10	// num frame for '-' stats digit

void Sbar_DrawPic(int x, int y, mpic_t *pic);
void Sbar_DrawString(int x, int y, char *str);
qbool Sbar_IsStandardBar(void);

void Sbar_DrawTrackingString(void);
void Sbar_DrawSpectatorMessage(void);

#endif // #ifdef EZQUAKE_SBAR_HEADER


================================================
FILE: src/screen.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

/**
  $Id: screen.h,v 1.10 2007-09-26 21:51:33 tonik Exp $
  
  Common declarations for modules associated with drawing on screen
  cl_screen.c, sbar.c
*/

#ifndef EZQUAKE_SCREEN_HEADER
#define EZQUAKE_SCREEN_HEADER

#define		SCR_NEED_CONSOLE_BACKGROUND		(cls.state < ca_active && !cl.intermission)

void SCR_Init (void);

#define UPDATESCREEN_MULTIVIEW   1
#define UPDATESCREEN_POSTPROCESS 2
#define UPDATESCREEN_3D_ONLY     4
#define UPDATESCREEN_2D_ONLY     8

qbool SCR_UpdateScreen (void);
qbool SCR_UpdateScreenPrePlayerView (void);
void SCR_UpdateScreenPlayerView(int flags);
void SCR_UpdateScreenHudOnly(void);
void SCR_UpdateScreenPostPlayerView (void);

void SCR_UpdateWholeScreen (void);
void SCR_AutoScreenshot(char *matchname);
qbool SCR_TakingAutoScreenshot(void);

void SCR_CenterPrint(const char *str);
void SCR_CenterPrint_Clear(void);
void SCR_CenterPrint_Init(void);
void SCR_CenterString_Draw(void);

extern	float		scr_con_current;
extern	float		scr_conlines;		// lines of console to display

extern	int			scr_fullupdate;	// set to 0 to force full redraw
extern	int			sb_lines;	// sbar.c !!

extern	int			clearnotify;	// set to 0 whenever notify text is drawn
extern	qbool		scr_disabled_for_loading;

extern	cvar_t		scr_viewsize;

// only the refresh window will be updated unless these variables are flagged 
extern	int			scr_copytop;
extern	int			scr_copyeverything;

extern	qbool		scr_skipupdate;
extern	qbool		block_drawing;

// QW262 HUD
typedef char* (*Hud_Func)(void);

#define		HUD_CVAR		1
#define		HUD_FUNC		2
#define		HUD_STRING		4
#define		HUD_BLINK_F		8
#define		HUD_BLINK_B		16
#define		HUD_IMAGE		32
#define		HUD_ENABLED		512

typedef struct hud_element_s {
	struct hud_element_s*	next;
	char					*name;
	unsigned				flags;
	signed char				coords[4]; // pos_type, x, y, bg
	unsigned				width;
	float					blink;
	void*					contents;
	//int					charset;
	float					alpha;
	char					*f_hover, *f_button;
	unsigned				scr_width, scr_height;
} hud_element_t;

void Hud_262Init (void);
void Hud_262LoadOnFirstStart(void);
void Hud_262CatchStringsOnLoad(char *line);

qbool Hud_ElementExists(const char* name);

// Flash & Conc for TF
extern qbool	concussioned;
extern qbool flashed;

#define	ELEMENT_X_COORD(var)	((var##_x.value < 0) ? vid.width - strlen(str) * 8 + 8 * var##_x.value: 8 * var##_x.value)
#define	ELEMENT_Y_COORD(var)	((var##_y.value < 0) ? vid.height - sb_lines + 8 * var##_y.value : 8 * var##_y.value)

void SCR_OnChangeMVHudPos(cvar_t *var, char *newval, qbool *cancel);
void SCR_TileClear(void);
void SCR_RestoreAutoID(void);
void SCR_SaveAutoID(void);
void SCR_SetupAutoID(void);
void SCR_RegisterAutoIDCvars(void);
void SCR_DrawAutoID(void);
void SCR_DrawAntilagIndicators(void);
void SShot_RegisterCvars(void);
qbool SCR_TakingAutoScreenshot(void);
void SCR_CheckAutoScreenshot(void);

// the current position of the mouse pointer
extern double cursor_x, cursor_y;

// kazik, HUD, incremented every screen update, never reset
extern  int         host_screenupdatecount;

// scr_teaminfo

#define TEAMINFO_SHOWSELF() ((scr_teaminfo.integer == 1) && (scr_teaminfo_show_self.integer >= 1 && cls.mvdplayback))
#define TEAMINFO_NICKLEN 5
#define FONTWIDTH (8)

/*do not show player if no info about him during this time, affect us if we lagging too*/
#define TI_TIMEOUT (5)

typedef struct ti_player_s {

	int 		client;

	vec3_t		org;
	int			items;
	int			health;
	int			armor;
	int			shells;
	int			nails;
	int			rockets;
	int 		cells;
	int			camode;
	int			isdead;
	int			timetospawn;
	int			round_kills;
	int			round_deaths;
	char		nick[TEAMINFO_NICKLEN]; // yeah, nick is nick, must be short
	double		time; // when we recive last update about this player, so we can guess disconnects and etc

} ti_player_t;

char *SCR_GetWeaponShortNameByFlag (int flag);

//Must be called whenever vid changes
void SCR_CalcRefdef(void);
void SCR_DrawMultiviewIndividualElements(void);

// end - scr_teaminfo

#endif // EZQUAKE_SCREEN_HEADER


================================================
FILE: src/server.h
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// server.h
#ifndef __SERVER_H__
#define __SERVER_H__

#include "progs.h"
#ifdef USE_PR2
#include "vm.h"
#include "pr2.h"
#include "g_public.h"
#endif
#ifndef SERVERONLY
#include "qtv.h"
#endif

#define CHAT_ICON_EXPERIMENTAL 1

#define	MAX_MASTERS 8 // max recipients for heartbeat packets

#define	MAX_SIGNON_BUFFERS 16

// sv_specprint stuff
#define SPECPRINT_CENTERPRINT	0x1
#define SPECPRINT_SPRINT	0x2
#define SPECPRINT_STUFFCMD	0x4

typedef enum {
	ss_dead,	// no map loaded
	ss_loading,	// spawning level edicts
	ss_active	// actively running
} server_state_t;
// some qc commands are only valid before the server has finished
// initializing (precache commands, static sounds / objects, etc)

typedef struct packet_s
{
	double		time;
	sizebuf_t	msg;
	byte		buf[MSG_BUF_SIZE]; // ?MAX_MSGLEN?
	struct packet_s *next;
} packet_t;

#define MAX_DELAYED_PACKETS 1024 // maxclients 32 * 77fps * max minping 0.3 = 739.2
#define MAP_NAME_LEN 64
typedef struct
{
	server_state_t	state;				// precache commands are only valid during load

	double		time;
	double		old_time;			// bumped by SV_Physics
	double      old_bot_time;       // bumped by SV_RunBots

	double		physicstime;		// last time physics was run

	int			lastcheck;			// used by PF_checkclient
	double		lastchecktime;			// for monster ai

	qbool		paused;				// are we paused?
	double		pausedsince;		// Sys_DoubleTime() when pause started

	qbool		loadgame;			// handle connections specially

	//check player/eyes models for hacks
	unsigned	model_player_checksum;
	unsigned	model_newplayer_checksum;
	unsigned	eyes_player_checksum;

	char		mapname[MAP_NAME_LEN];		// map name
	char		modelname[MAX_QPATH];		// maps/<name>.bsp, for model_precache[0]
	unsigned	map_checksum;
	unsigned	map_checksum2;
	cmodel_t	*worldmodel;
	char		*model_precache[MAX_MODELS];	// NULL terminated
	char		*vw_model_name[MAX_VWEP_MODELS];	// NULL terminated
	char		*sound_precache[MAX_SOUNDS];	// NULL terminated
	char		*lightstyles[MAX_LIGHTSTYLES];
	cmodel_t	*models[MAX_MODELS];

	int         num_edicts;         // increases towards MAX_EDICTS
	int         num_baseline_edicts;// number of entities that have baselines

	edict_t		edicts[MAX_EDICTS];
	entvars_t	*game_edicts;		// can NOT be array indexed, because entvars_t is variable sized

	int         max_edicts;         // might not MAX_EDICTS if mod allocates memory

	byte		*pvs, *phs;			// fully expanded and decompressed

	// added to every client's unreliable buffer each frame, then cleared
	sizebuf_t	datagram;
	byte		datagram_buf[MAX_DATAGRAM];

	// added to every client's reliable buffer each frame, then cleared
	sizebuf_t	reliable_datagram;
	byte		reliable_datagram_buf[MAX_MSGLEN];

	// the multicast buffer is used to send a message to a set of clients
	sizebuf_t	multicast;
	byte		multicast_buf[MAX_MSGLEN];

	// the signon buffer will be sent to each client as they connect
	// includes the entity baselines, the static entities, etc
	// large levels will have >MAX_DATAGRAM sized signons, so 
	// multiple signon messages are kept
	sizebuf_t      signon;
	unsigned int   num_signon_buffers;
	int            signon_buffer_size[MAX_SIGNON_BUFFERS];
	byte           signon_buffers[MAX_SIGNON_BUFFERS][MAX_DATAGRAM];

	qbool		   mvdrecording;

	entity_state_t static_entities[MAX_STATIC_ENTITIES];
	int            static_entity_count;
} server_t;

#define	NUM_SPAWN_PARMS 16

// { sv_antilag related
typedef struct
{
	qbool present;
	vec3_t laggedpos;
} laggedentinfo_t;
// }

typedef enum
{
	cs_free,		// can be reused for a new connection
	cs_zombie,		// client has been disconnected, but don't reuse
				// connection for a couple seconds
	cs_preconnected,	// has been assigned, but login/realip not settled yet
	cs_connected,		// has been assigned to a client_t, but not in game yet
	cs_spawned		// client is fully in game
} sv_client_state_t;		// FIXME

typedef struct
{
	// received from client

	// reply
	double			senttime;
	float			ping_time;

// { sv_antilag
	double				sv_time;
// }

	packet_entities_t	entities;
} client_frame_t;

typedef struct
{
	double			localtime;
	vec3_t			origin;
} antilag_position_t;

#define MAX_ANTILAG_POSITIONS      128
#define MAX_BACK_BUFFERS           128
#define MAX_STUFFTEXT              256
#define	CLIENT_LOGIN_LEN            16
#define	CLIENT_NAME_LEN             32
#define LOGIN_CHALLENGE_LENGTH     128
#define LOGIN_FLAG_LENGTH            8
#define LOGIN_MIN_RETRY_TIME         5    // 1 login attempt per x seconds

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
#define MAX_WEAPONSWITCH_OPTIONS    10
#endif

typedef struct client_s
{
	sv_client_state_t	state;

	int				extensions;			// what ZQuake extensions the client supports
	int				spectator;			// non-interactive
	int				vip;

	qbool			sendinfo;			// at end of frame, send info to all
							// this prevents malicious multiple broadcasts
	float			lastnametime;			// time of last name change
	int				lastnamecount;			// time of last name change
	unsigned		checksum;			// checksum for calcs
	qbool			drop;				// lose this guy next opportunity
	int				lossage;			// loss percentage

	int				userid;				// identifying number
	ctxinfo_t		_userinfo_ctx_;			// infostring
	ctxinfo_t		_userinfoshort_ctx_;	// infostring

	antilag_position_t	antilag_positions[MAX_ANTILAG_POSITIONS];
	int				antilag_position_next;

	usercmd_t		lastcmd;			// for filling in big drops and partial predictions
	double			localtime;			// of last message
	qbool			jump_held;

	float			maxspeed;			// localized maxspeed
	float			entgravity;			// localized ent gravity

	edict_t			*edict;				// EDICT_NUM(clientnum+1)
#ifdef USE_PR2
	int				isBot;
	usercmd_t		botcmd;				// bot movment
#endif
	char			name[CLIENT_NAME_LEN];		// for printing to other people

	char			team[CLIENT_NAME_LEN];
	// extracted from userinfo
	int				messagelevel;			// for filtering printed messages

	// the datagram is written to after every frame, but only cleared
	// when it is sent out to the client.  overflow is tolerated.
	sizebuf_t		datagram;
	byte			datagram_buf[MAX_DATAGRAM];

	// back buffers for client reliable data
	sizebuf_t		backbuf;
	int				num_backbuf;
	int				backbuf_size[MAX_BACK_BUFFERS];
	byte			backbuf_data[MAX_BACK_BUFFERS][MAX_MSGLEN];

	char			stufftext_buf[MAX_STUFFTEXT];

	// Use SV_ClientConnectedTime & SV_ClientGameTime instead
	double          connection_started_realtime; // or time of disconnect for zombies
	double          connection_started_curtime;  // like connection_started but curtime (not affected by pause)
	qbool           send_message;                // set on frames a datagram arrived on

// { sv_antilag related
	laggedentinfo_t	laggedents[MAX_CLIENTS];
	unsigned int	laggedents_count;
	float			laggedents_frac;
	float           laggedents_time;
// }

	// spawn parms are carried from level to level
	float			spawn_parms[NUM_SPAWN_PARMS];

	// client known data for deltas
	int				old_frags;

	int				stats[MAX_CL_STATS];

	double			lastservertimeupdate;		// last realtime we sent STAT_TIME to the client

	client_frame_t	frames[UPDATE_BACKUP];		// updates can be deltad from here

	vfsfile_t		*download;			// file being downloaded
	int             dupe;               // duplicate packets requested
#ifdef PROTOCOL_VERSION_FTE
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	int				download_chunks_perframe;
#endif
#endif
	int				downloadsize;			// total bytes
	int				downloadcount;			// bytes sent

	// demo download list for internal cmd dl function
	// Added by VVD {
	int				demonum[MAX_ARGS];
	qbool			demolist;
	// } Added by VVD

	int             spec_track;             // entnum of player tracking

	double          whensaid[10];           // JACK: For floodprots
	int             whensaidhead;           // Head value for floodprots
	double          lockedtill;

	FILE			*upload;
	char			uploadfn[MAX_QPATH];
	netadr_t		snap_from;
	qbool			remote_snap;

	char			login[CLIENT_LOGIN_LEN];
	char            login_alias[CLIENT_NAME_LEN];
	char            login_flag[LOGIN_FLAG_LENGTH];
	char            login_confirmation[LOGIN_CHALLENGE_LENGTH];
	char            login_challenge[LOGIN_CHALLENGE_LENGTH];
	int				logged;
	qbool           logged_in_via_web;
	double          login_request_time;

	int				spawncount;			// for tracking map changes during downloading

//bliP: additional ->
	int				file_percent;
	qbool			special;
	int				logincount;
	float			lasttoptime;			// time of last topcolor change
	int				lasttopcount;			// count of last topcolor change
	int				spec_print;
	double			cuff_time;
//bliP: 24/9 anti speed ->
	int				msecs;
	double			last_check;
//<-
//<-
	float			lastuserinfotime;		// time of last userinfo change
	int				lastuserinfocount;		// count of last userinfo change

#ifdef PROTOCOL_VERSION_FTE
	unsigned int	fteprotocolextensions;
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
	unsigned int	fteprotocolextensions2;
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
	unsigned int    mvdprotocolextensions1;
#endif

#ifdef FTE_PEXT2_VOICECHAT
	unsigned int voice_read;	/*place in ring*/
	unsigned char voice_mute[MAX_CLIENTS/8];
	qbool voice_active;
	enum
	{
		/*note - when recording an mvd, only 'all' will be received by non-spectating viewers. all other chat will only be heard when spectating the receiver(or sender) of said chat*/

		/*should we add one to respond to the last speaker? or should that be an automagic +voip_reply instead?*/
		VT_TEAM,
		VT_ALL,
		VT_NONMUTED,	/*cheap, but allows custom private channels with no external pesters*/
		VT_PLAYERSLOT0
		/*player0+...*/
	} voice_target;
#endif

	//===== NETWORK ============
	qbool           process_pext;             // true if we wait for reply from client on "cmd pext" command.
	int             chokecount;
	int             delta_sequence;           // -1 = no compression
	netchan_t       netchan;
	netadr_t        realip;                   // client's ip, not latest proxy's
	int             realip_num;               // random value
	int             realip_count;
	int             rip_vip;
	double          delay;
	double          disable_updates_stop;     // Vladis
	qbool           maxping_met;              // set if user meets maxping requirements
	packet_t        *packets, *last_packet;

#ifdef MVD_PEXT1_HIGHLAGTELEPORT
	// lagged-teleport extension
	qbool           lastteleport_teleport;    // true if teleport, otherwise it was spawn
	int             lastteleport_outgoingseq; // outgoing sequence# when the player teleported
	int             lastteleport_incomingseq; // incoming sequence# when the player teleported
	float           lastteleport_teleportyaw; // new yaw angle, post-teleport
#endif

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	// server-side weapons extension
	int             weaponswitch_sequence_set; // need to remember what packet current choices were sent in for forgetorder
	qbool           weaponswitch_pending;
	qbool           weaponswitch_hide;         // automatically flick back when not firing
	qbool           weaponswitch_hide_on_death;// switch back to 2 1 when dying
	qbool           weaponswitch_wasfiring;    // fire pressed on previous frame (will only hide if so)

	qbool           weaponswitch_enabled;      // allow user to disable while connected
	int             weaponswitch_mode;         // user preference
	qbool           weaponswitch_forgetorder;  // if set, decide best weapon immediately and don't rank on fire
	byte            weaponswitch_priority[MAX_WEAPONSWITCH_OPTIONS];
#endif

	qbool           mvd_write_usercmds;
} client_t;

// a client can leave the server in one of four ways:
// dropping properly by quiting or disconnecting
// timing out if no valid messages are received for timeout.value seconds
// getting kicked off by the server operator
// a program error, like an overflowed reliable buffer

typedef struct
{
	int				parsecount;

	vec3_t			origin;
	vec3_t			angles;
	int				weaponframe;
	int				frame;
	int				skinnum;
	int				model;
	int				effects;
	int				flags;

	qbool			fixangle;

	float			sec;

} demo_client_t;

typedef struct
{
	demo_client_t	clients[MAX_CLIENTS];
	double			time;
	qbool           paused;
	byte            pause_duration;

// { reset each time frame wroten with SV_MVDWritePackets()
	sizebuf_t		_buf_;
	// !!! OUCH OUCH OUCH, 64 frames, so it about 2mb !!!
	// here data with mvd headers, so it up to 4 mvd msg with maximum size, however basically here alot of small msgs,
	// so this size pathetic
	byte			_buf__data[(MAX_MVD_SIZE + 10) * 4];

	int				lastto;
	int				lasttype;
	int				lastsize;
	int				lastsize_offset; // this is tricky
// }

} demo_frame_t;

//qtv proxies are meant to send a small header now, bit like http
//this header gives supported version numbers and stuff
typedef struct mvdpendingdest_s
{
	qbool error; //disables writers, quit ASAP.
	int socket;

	char inbuffer[2048];
	char outbuffer[2048];

	char challenge[64];
	qbool hasauthed;

	int insize;
	int outsize;

	qbool			must_be_qizmo_tcp_connect; // HACK, this stream should not be allowed but just checked ONLY AND ONLY for qizmo tcp connection

	double			io_time; // when last IO occur on socket, so we can timeout this dest
	netadr_t		na;

	struct mvdpendingdest_s *nextdest;
} mvdpendingdest_t;

typedef enum {DEST_NONE, DEST_FILE, DEST_BUFFEREDFILE, DEST_STREAM} desttype_t;

#define MAX_PROXY_INBUFFER		4096 /* qqshka: too small??? */

typedef struct mvddest_s
{
	qbool error; //disables writers, quit ASAP.

	desttype_t desttype;

	int socket;
	FILE *file;

	char name[MAX_QPATH];
	char path[MAX_QPATH];

	char *cache;
	int cacheused;
	int maxcachesize;

	unsigned int totalsize;

// { used by QTV
	double			io_time; // when last IO occur on socket, so we can timeout this dest
	int				id; // dest id, used by QTV only
	netadr_t		na;

	char			inbuffer[MAX_PROXY_INBUFFER];
	int				inbuffersize;

	char			qtvname[64];

	qtvuser_t		*qtvuserlist;

	char            qtvaddress[128];
	int             qtvstreamid;
// }

	struct mvddest_s *nextdest;
} mvddest_t;

typedef struct
{
	sizebuf_t		datagram;
	byte			datagram_data[MAX_MVD_SIZE]; // data without mvd header

	double          time;             // sv.time
	double          curtime;          // curtime
	double          pingtime;         // compare to curtime

	// Something like time of last mvd message, so we can guess delta milliseconds for next message.
	// you better not relay on this variable...
	double			prevtime;

	client_t		recorder;

	qbool			fixangle[MAX_CLIENTS];

	int				stats[MAX_CLIENTS][MAX_CL_STATS];

	int				parsecount;  // current frame, to which we add demo data
	int				lastwritten; // lastwriten frame

	demo_frame_t	frames[UPDATE_BACKUP]; // here we store all previous frames
	demo_client_t	clients[MAX_CLIENTS]; // we store here what we wrote last time so we can delta

	// =====================================
	char			mem_set_point; // fields below, like ->dest and ->pendingdest must not be memset to 0
	// =====================================

	struct mvddest_s		*dest;
	struct mvdpendingdest_s *pendingdest;

	// last recorded demo's names for command "cmd dl . .." (maximum 15 dots)
	char			*lastdemosname[16];
	int				lastdemospos;
} demo_t;

//=============================================================================


#define	STATFRAMES	100
typedef struct
{
	double			active;
	double			idle;
	double			demo;
	int				count;
	int				packets;

	double			latched_active;
	double			latched_idle;
	double			latched_demo;
	int				latched_packets;
} svstats_t;

// MAX_CHALLENGES is made large to prevent a denial
// of service attack that could cycle all of them
// out before legitimate users connected
#define	MAX_CHALLENGES	1024

typedef struct
{
	netadr_t		adr;
	int				challenge;
	int				time;
} challenge_t;

// TCPCONNECT -->
typedef struct svtcpstream_s
{
	int                     socketnum;                         // socket
	qbool                   waitingforprotocolconfirmation;    // wait for "qizmo\n", first 6 bytes before confirming that is tcpconnection
	int                     inlen;                             // how much bytes we have in inbuffer
	char                    inbuffer[1500];                    // recv buffer
	int                     outlen;                            // how much bytes we have in outbuffer
	char                    outbuffer[1500 * 5];               // send buffer
	qbool                   drop;                              // do we need drop that connection ASAP
	float                   timeouttime;                       // I/O timeout
	netadr_t                remoteaddr;                        // peer remoter addr
	struct svtcpstream_s    *next;                             // next tcpconnection in list
} svtcpstream_t;
// <-- TCPCONNECT

typedef struct
{
	int				spawncount;		// number of servers spawned since start,
									// used to check late spawns
	int				lastuserid;		// userid of last spawned client

	socket_t		socketip;		// main server UDP socket.

// TCPCONNECT -->
	int				sockettcp;		// server TCP socket, used for QTV/TCPCONNECT.
	svtcpstream_t *	tcpstreams;
// <-- TCPCONNECT

	client_t        clients[MAX_CLIENTS];
	int             serverflags;    // episode completion information

	double          last_heartbeat;
	int             heartbeat_sequence;
	svstats_t       stats;

	char            info[MAX_SERVERINFO_STRING];

#ifdef PROTOCOL_VERSION_FTE
	unsigned int fteprotocolextensions;
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
	unsigned int fteprotocolextensions2;
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
	unsigned int mvdprotocolextension1;
#endif

	// log messages are used so that fraglog processes can get stats
	int				logsequence;		// the message currently being filled
	double			logtime;		// time of last swap
	sizebuf_t		log[2];
	byte			log_buf[2][MAX_DATAGRAM];

	challenge_t		challenges[MAX_CHALLENGES];	// to prevent invalid IPs from connecting

	packet_t		*free_packets;
} server_static_t;

//=============================================================================

// edict->movetype values
#define	MOVETYPE_NONE			0		// never moves
#define	MOVETYPE_ANGLENOCLIP		1
#define	MOVETYPE_ANGLECLIP		2
#define	MOVETYPE_WALK			3		// gravity
#define	MOVETYPE_STEP			4		// gravity, special edge handling
#define	MOVETYPE_FLY			5
#define	MOVETYPE_TOSS			6		// gravity
#define	MOVETYPE_PUSH			7		// no clip to world, push and crush
#define	MOVETYPE_NOCLIP			8
#define	MOVETYPE_FLYMISSILE		9		// extra size to monsters
#define	MOVETYPE_BOUNCE			10
#define	MOVETYPE_LOCK			15		// server controls view angles

// edict->solid values
#define	SOLID_NOT			0		// no interaction with other objects
#define	SOLID_TRIGGER			1		// touch on edge, but not blocking
#define	SOLID_BBOX			2		// touch on edge, block
#define	SOLID_SLIDEBOX			3		// touch on edge, but not an onground
#define	SOLID_BSP			4		// bsp clip, touch on edge, block

// edict->deadflag values
#define	DAMAGE_NO			0
#define	DAMAGE_YES			1
#define	DAMAGE_AIM			2

// edict->flags
#define	FL_FLY				1
#define	FL_SWIM				2
#define	FL_GLIMPSE			4
#define	FL_CLIENT			8
#define	FL_INWATER			16
#define	FL_MONSTER			32
#define	FL_GODMODE			64
#define	FL_NOTARGET			128
#define	FL_ITEM				256
#define	FL_ONGROUND			512
#define	FL_PARTIALGROUND		1024	// not all corners are valid
#define	FL_WATERJUMP			2048	// player jumping out of water

// { sv_antilag
#define FL_LAGGEDMOVE			(1<<16)
// }

#define	SPAWNFLAG_NOT_EASY		256
#define	SPAWNFLAG_NOT_MEDIUM		512
#define	SPAWNFLAG_NOT_HARD		1024
#define	SPAWNFLAG_NOT_DEATHMATCH	2048

#define	MULTICAST_ALL			0
#define	MULTICAST_PHS			1
#define	MULTICAST_PVS			2

#define	MULTICAST_ALL_R			3
#define	MULTICAST_PHS_R			4
#define	MULTICAST_PVS_R			5

#define MULTICAST_KTX1_EXT      6  // Only send to those using ktx1 protocol extension (todo)
#define MULTICAST_MVD_HIDDEN    7  // Insert into MVD stream only, as dem_multiple(0)

#define MAX_LOCALINFOS			10000
// maps in localinfo {
#define LOCALINFO_MAPS_LIST_START	1000
#define LOCALINFO_MAPS_LIST_END		4999
// }

#define MAX_REDIRECTMESSAGES	128
#define OUTPUTBUF_SIZE			8000

// { server flags

// force player enter server as spectator if all players's slots are busy and
// if there are empty slots for spectators and sv_forcespec_onfull == 2
#define SVF_SPEC_ONFULL			(1<<0)
// do not join server as spectator if server full and sv_forcespec_onfull == 1
#define SVF_NO_SPEC_ONFULL		(1<<1)

// } server flags

//============================================================================

extern	cvar_t	sv_paused; // 1 - normal, 2 - auto (single player), 3 - both
extern	cvar_t	sv_maxspeed;
extern	cvar_t	sv_mintic, sv_maxtic, sv_maxfps;
extern	cvar_t	sv_antilag, sv_antilag_no_pred, sv_antilag_projectiles;

extern	int current_skill;

extern	cvar_t	spawn;
extern	cvar_t	teamplay;
extern	cvar_t	serverdemo;
extern	cvar_t	deathmatch;
extern	cvar_t	fraglimit;
extern	cvar_t	timelimit;
extern	cvar_t	skill;
extern	cvar_t	coop;
extern	cvar_t	maxclients;

extern	cvar_t	sv_specprint;	//bliP: spectator print

extern	server_static_t	svs;	// persistant server info
extern	server_t	sv;	// local server
extern	demo_t		demo;	// server demo struct

extern	client_t	*sv_client;
extern	edict_t		*sv_player;

#define	MODEL_NAME_LEN	6
extern	char		localmodels[MAX_MODELS][MODEL_NAME_LEN]; // inline model names for precache
//extern	char		localinfo[MAX_LOCALINFO_STRING+1];
extern  ctxinfo_t _localinfo_;

extern	qbool		sv_error;

extern char			master_rcon_password[128];

//===========================================================

//
// sv_main.c
//

extern	double	realtime; // not bounded in any way, changed at start of every frame, never reset

typedef enum {
	ipft_ban,
	ipft_safe
} ipfiltertype_t;

typedef struct
{
	unsigned	mask;
	unsigned	compare;
	int			level;
	double		time; // for ban expiration
	ipfiltertype_t type;
} ipfilter_t;

//bliP: penalty filters ->
typedef enum {
	ft_mute,
	ft_cuff
} filtertype_t;

typedef struct
{
	byte		ip[4];
	double		time;
	filtertype_t	type;
} penfilter_t;
//<-

void SV_Frame (double time);
void SV_FinalMessage (const char *message);
void SV_DropClient (client_t *drop);

int SV_CalcPing (client_t *cl);
void SV_FullClientUpdate (client_t *client, sizebuf_t *buf);
void SV_FullClientUpdateToClient (client_t *client, client_t *cl);

qbool SV_CheckBottom (edict_t *ent);
qbool SV_movestep (edict_t *ent, vec3_t move, qbool relink);

qbool SV_CloseEnough (edict_t *ent, edict_t *goal, float dist);
qbool SV_StepDirection (edict_t *ent, float yaw, float dist);
void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist);

void SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg);

void SV_MoveToGoal (void);

void SV_InitOperatorCommands (void);

void SV_SendServerinfo (client_t *client);
void SV_ExtractFromUserinfo (client_t *cl, qbool namechanged);
int SV_BoundRate (qbool dl, int rate);

typedef struct
{
	int sec;
	int min;
	int hour;
	int day;
	int mon;
	int year;
	char str[128];
} date_t;

void SV_TimeOfDay(date_t *date, char *timeformat);


//bliP: init ->
void SV_ListFiles_f (void);
void SV_RemoveFile_f (void);
void SV_RemoveDirectory_f (void);

#define	MAX_PENFILTERS 512
void SV_RemoveIPFilter (int i);
//static qbool SV_IPCompare (byte *a, byte *b);
//static void SV_IPCopy (byte *dest, byte *src);
void SV_SavePenaltyFilter (client_t *cl, filtertype_t type, double pentime);
double SV_RestorePenaltyFilter (client_t *cl, filtertype_t type);

qbool SV_FilterPacket (void);
void SV_SendBan (void);
qbool GameStarted(void);
//<-
void SV_Script_f (void);
int SV_GenerateUserID (void);

//
// sv_init.c
//
int SV_ModelIndex (char *name);
void SV_FlushSignon (void);
void SV_SpawnServer (char *server, qbool devmap, char* entityfile, qbool loading_savegame);


//
// sv_phys.c
//
void SV_ProgStartFrame (qbool isBotFrame);
void SV_Physics (void);
void SV_CheckVelocity (edict_t *ent);
void SV_AddGravity (edict_t *ent, float scale);
qbool SV_RunThink (edict_t *ent);
void SV_Physics_Toss (edict_t *ent);
void SV_RunNewmis (void);
void SV_RunNQNewmis (void);
void SV_Impact (edict_t *e1, edict_t *e2);
void SV_SetMoveVars(void);
#ifdef USE_PR2
void SV_RunBots(void);
#endif

//
// sv_send.c
//
typedef enum {RD_NONE, RD_CLIENT, RD_PACKET, RD_MOD} redirect_t;
void SV_BeginRedirect (redirect_t rd);
void SV_EndRedirect (void);
qbool SV_AddToRedirect(char *msg);

void SV_Multicast(vec3_t origin, int to);
void SV_MulticastEx(vec3_t origin, int to, const char *cl_reliable_key);
void SV_StartParticle(vec3_t org, vec3_t dir, int color, int count, int replacement_te, int replacement_count);
void SV_StartSound(edict_t *entity, int channel, char *sample, int volume, float attenuation);
void SV_ClientPrintf(client_t *cl, int level, char *fmt, ...);
void SV_ClientPrintf2(client_t *cl, int level, char *fmt, ...);
void SV_BroadcastPrintf(int level, char *fmt, ...);
#define BPRINT_IGNOREINDEMO  (1<<0) // broad cast print will be not put in demo
#define BPRINT_IGNORECLIENTS (1<<1) // broad cast print will not be seen by clients, but may be seen in demo
#define BPRINT_QTVONLY       (1<<2) // if broad cast print goes to demo, then it will be only qtv sream, but not file
#define BPRINT_IGNORECONSOLE (1<<3) // broad cast print will not be put in server console
void SV_BroadcastPrintfEx (int level, int flags, char *fmt, ...);
void SV_BroadcastCommand (char *fmt, ...);
void SV_SendClientMessages (void);
void SV_SendDemoMessage(void);
void SV_SendMessagesToAll (void);
void SV_FindModelNumbers (void);


//
// sv_user.c
//
void SV_ExecuteClientMessage (client_t *cl);
void SV_UserInit (void);
void SV_TogglePause (const char *msg, int bit);
void ProcessUserInfoChange (client_t* sv_client, const char* key, const char* old_value);
void SV_RotateCmd(client_t* cl, usercmd_t* cmd);

#ifdef FTE_PEXT2_VOICECHAT
void SV_VoiceInitClient(client_t *client);
void SV_VoiceSendPacket(client_t *client, sizebuf_t *buf);
#endif

//
// sv_ccmds.c
//
void SV_Status_f (void);
void SV_ServerinfoChanged (char *key, char *string);
void SV_SendServerInfoChange (char *key, char *value);
void SV_KickClient(client_t* client, const char* reason);

//
// sv_ents.c
//
void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qbool recorder);
void SV_SetVisibleEntitiesForBot (client_t* client);

//
// sv_nchan.c
//
void ClientReliableCheckBlock(client_t *cl, int maxsize);
void ClientReliable_FinishWrite(client_t *cl);
void ClientReliableWrite_Begin(client_t *cl, int c, int maxsize);
void ClientReliableWrite_Angle(client_t *cl, float f);
void ClientReliableWrite_Angle16(client_t *cl, float f);
void ClientReliableWrite_Byte(client_t *cl, int c);
void ClientReliableWrite_Char(client_t *cl, int c);
void ClientReliableWrite_Float(client_t *cl, float f);
void ClientReliableWrite_Coord(client_t *cl, float f);
void ClientReliableWrite_Long(client_t *cl, int c);
void ClientReliableWrite_Short(client_t *cl, int c);
void ClientReliableWrite_String(client_t *cl, char *s);
void ClientReliableWrite_SZ(client_t *cl, void *data, int len);
void SV_ClearReliable (client_t *cl); // clear cl->netchan.message and backbuf

//
// sv_demo.c
//

void MVD_MSG_WriteChar   (const int c);
void MVD_MSG_WriteByte   (const int c);
void MVD_MSG_WriteShort  (const int c);
void MVD_MSG_WriteLong   (const int c);
void MVD_MSG_WriteFloat  (const float f);
void MVD_MSG_WriteString (const char *s);
void MVD_MSG_WriteCoord  (const float f);
void MVD_MSG_WriteAngle  (const float f);
void MVD_SZ_Write        (const void *data, int length);

qbool MVDWrite_Begin(byte type, int to, int size);
qbool MVDWrite_HiddenBlockBegin(int length);
qbool MVDWrite_HiddenBlock(const void* data, int length);

void SV_MVD_Record_f (void);
void SV_MVDEasyRecord_f (void);

void SV_MVDStop (int reason, qbool mvdonly);
void SV_MVDStop_f (void);
qbool SV_MVDWritePackets (int num);
void SV_MVD_SendInitialGamestate(mvddest_t *dest);
qbool SV_MVD_Record (mvddest_t *dest, qbool mapchange);

mvddest_t	*DestByName (char *name);
void		DestClose (mvddest_t *d, qbool destroyfiles);

int DemoWriteDest (void *data, int len, mvddest_t *d);

extern demo_t	demo; // server demo struct

extern cvar_t	sv_demoUseCache;
extern cvar_t	sv_demoCacheSize;
extern cvar_t	sv_demoMaxDirSize;
extern cvar_t	sv_demoClearOld;
extern cvar_t	sv_demoDir;
extern cvar_t	sv_demoDirAlt;
extern cvar_t	sv_demofps;
extern cvar_t	sv_demoPings;
extern cvar_t	sv_demoMaxSize;
extern cvar_t	sv_demoExtraNames;

extern cvar_t	sv_demoPrefix;
extern cvar_t	sv_demoSuffix;
extern cvar_t	sv_demotxt;
extern cvar_t	sv_onrecordfinish;

extern cvar_t	sv_ondemoremove;
extern cvar_t	sv_demoRegexp;

extern cvar_t	sv_silentrecord;

void SV_MVDInit (void);
char *SV_MVDNum(int num);

//
// sv_demo_misc.c
//

char	*SV_PrintTeams (void);
void	Run_sv_demotxt_and_sv_onrecordfinish (const char *dest_name, const char *dest_path, qbool destroyfiles);
qbool	SV_DirSizeCheck (void);
char	*SV_CleanName (unsigned char *name);
int     Dem_CountPlayers (void);
char	*Dem_Team (int num);
char	*Dem_PlayerName (int num);
char	*Dem_PlayerNameTeam (char *t);
int		Dem_CountTeamPlayers (char *t);
char	*quote (char *str);
void	CleanName_Init (void);
void	SV_LastScores_f (void);
void	SV_LastStats_f (void);
void	SV_DemoList_f (void);
void	SV_DemoListRegex_f (void);
void	SV_MVDRemove_f (void);
void	SV_MVDRemoveNum_f (void);
void	SV_MVDInfoAdd_f (void);
void	SV_MVDInfoRemove_f (void);
void	SV_MVDInfo_f (void);
void	SV_LastScores_f (void);
char*   SV_MVDName2Txt (const char *name);
void SV_MVDEmbedInfo_f(void);

//
// sv_demo_qtv.c
//

extern cvar_t	qtv_streamtimeout;


void SV_MVDStream_Poll(void);
void SV_MVDCloseStreams(void);
void SV_QTV_Init(void);

void DemoWriteQTV (sizebuf_t *msg);
void QTVsv_FreeUserList(mvddest_t *d);
void QTV_Streams_List (void);
void QTV_Streams_UserList (void);
const char* SV_MVDDemoName(void);

//
// sv_login.c
//

void SV_LoadAccounts(void);
void SV_CreateAccount_f(void);
void SV_RemoveAccount_f(void);
void SV_ListAccount_f (void);
void Login_Init (void);
qbool SV_Login(client_t *cl);
void SV_Logout(client_t *cl);
void SV_ParseWebLogin(client_t* cl);
void SV_ParseLogin(client_t *cl);
void SV_LoginCheckTimeOut(client_t *cl);
void SV_LoginWebCheck(client_t* cl);
void SV_LoginWebFailed(client_t* cl);
qbool SV_LoginRequired(client_t* cl);
qbool SV_LoginBlockJoinRequest(client_t* cl);

// sv_master.c
void SV_SetMaster_f (void);
void SV_Heartbeat_f (void);
void Master_Shutdown (void);
void Master_Heartbeat (void);

// sv_save.c 
void SV_SaveGame_f (void); 
void SV_LoadGame_f (void); 

//
void SV_WriteDelta(client_t* client, entity_state_t *from, entity_state_t *to, sizebuf_t *msg, qbool force);
qbool SV_SkipCommsBotMessage(client_t* client);

// 
#ifdef SERVERONLY
#include "central.h"
#else
extern qbool server_cfg_done;
#endif

// These functions tell us how much time has passed since the client connected
// Sometimes this should be affected by pause (scoreboards) and sometimes not (spam, networking)
// GameTime() stops while game is paused, Connected() continues as normal
// Both return 0 if client hasn't connected yet
double SV_ClientConnectedTime(client_t* client);    // real-world time passed
double SV_ClientGameTime(client_t* client);         // affected by pause
void SV_SetClientConnectionTime(client_t* client);

#ifdef SERVERONLY
// mvdsv not changed over to enums yet, which was more about documentation
#define SV_CommandLineEnableCheats() (COM_CheckParm("-cheats"))
#define SV_CommandLineEnableLocalCommand() (COM_CheckParm("-enablelocalcommand"))
#define SV_CommandLineDemoCacheArgument() (COM_CheckParm("-democache"))
#define SV_CommandLineProgTypeArgument() (COM_CheckParm("-progtype"))
#define SV_CommandLineUseMinimumMemory() (COM_CheckParm("-minmemory"))
#define SV_CommandLineHeapSizeMemoryKB() (COM_CheckParm("-heapsize"))
#define SV_CommandLineHeapSizeMemoryMB() (COM_CheckParm("-mem"))
#else
#define SV_CommandLineEnableCheats() (COM_CheckParm(cmdline_param_server_enablecheats))
#define SV_CommandLineEnableLocalCommand() (COM_CheckParm(cmdline_param_server_enablelocalcommand))
#define SV_CommandLineDemoCacheArgument() (COM_CheckParm(cmdline_param_server_democache_kb))
#define SV_CommandLineProgTypeArgument() (COM_CheckParm(cmdline_param_server_progtype))
#define SV_CommandLineUseMinimumMemory() (COM_CheckParm(cmdline_param_host_memory_minimum))
#define SV_CommandLineHeapSizeMemoryKB() (COM_CheckParm(cmdline_param_host_memory_kb))
#define SV_CommandLineHeapSizeMemoryMB() (COM_CheckParm(cmdline_param_host_memory_mb))
#endif

#endif /* !__SERVER_H__ */


================================================
FILE: src/settings.h
================================================
/*
Copyright (C) 2011 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
// used by settings_page and menu_options modules

//
// Macros
// Use following macros to create array of 'setting' variables
// see settings_page.h for further info
//

#ifndef __SETTINGS_H__
#define __SETTINGS_H__

#include "Ctrl.h"

// start advanced settings section
#define ADDSET_ADVANCED_SECTION() { stt_advmark, NULL, false, NULL, 0, 0, 0, NULL, NULL, NULL, NULL }

// starts basic settings setion (terminates advanced settings section) (started by default)
#define ADDSET_BASIC_SECTION() { stt_basemark, NULL, false, NULL, 0, 0, 0, NULL, NULL, NULL, NULL }

// separator: decorating purpose
#define ADDSET_SEPARATOR(label) { stt_separator, label, false, NULL, 0, 0, 0, NULL, NULL, NULL, NULL }

// blank: decorating purpose
#define ADDSET_BLANK() { stt_blank, NULL, false, NULL, 0, 0, 0, NULL, NULL, NULL, NULL }

// action: user can hit enter to execute function assigned to this setting
#define ADDSET_ACTION(label,fnc,desc) { stt_action, label, false, NULL, 0, 0, 0, NULL, NULL, fnc, NULL, NULL, desc }

// number: will show a slider allowing you to choose setting from range min..max 
#define ADDSET_NUMBER(label, var, min, max, step) { stt_num, label, false, &var, min, max, step, NULL, NULL, NULL, NULL }

// intnumber: same like number, but we change a "int", not a "cvar_t"
#define ADDSET_INTNUMBER(label, var, min, max, step) { stt_intnum, label, false, (cvar_t *) &var, min, max, step, NULL, NULL, NULL, NULL }

// enum: custom name for each custom value .. works like "named", but you specify the range of values too
#define ADDSET_ENUM(label, var, strs) { stt_enum, label, false, &var, 0, (sizeof(strs)/sizeof(char*))/2-1, 1, NULL, NULL, NULL, strs }

// bool: will display on/off option
#define ADDSET_BOOL(label, var) { stt_bool, label, false, &var, 0, 0, 0, NULL, NULL, NULL, NULL }

// latebool: use for cvars that don't exist on compile time - be carefull when using this, may lead to crashes!
#define ADDSET_BOOLLATE(label, var) { stt_bool, label, false, NULL, 0, 0, 0, NULL, NULL, NULL, NULL, #var }

// string: will show an edit box allowing you to edit teh value
#define ADDSET_STRING(label, var) { stt_string, label, false, &var, 0, 0, 0, NULL, NULL, NULL, NULL }

// named: give it array of strings, will assign values 0, 1, ... to the variable
#define ADDSET_NAMED(label, var, strs) { stt_named, label, false, &var, 0, sizeof(strs)/sizeof(char*)-1, 1, NULL, NULL, NULL, strs }

// color
#define ADDSET_COLOR(label, var) { stt_playercolor, label, false, &var, -1, 16, 1, NULL, NULL, NULL, NULL }

// key bind
#define ADDSET_BIND(label, cmd) { stt_bind, label, false, NULL, 0, 0, 0, NULL, NULL, NULL, NULL, cmd }

// custom: completely customizable setting, define your own reading and writing function
// see below for function types
#define ADDSET_CUSTOM(label, readfnc, togglefnc, desc) { stt_custom, label, false, NULL, 0, 0, 0, readfnc, togglefnc, NULL, NULL, NULL, desc }

// skin setting
#define ADDSET_SKIN(label, var) { stt_skin, label, false, &var, 0, 0, 0, NULL, NULL, NULL, NULL, NULL }


//
// function types:
//

typedef const char* (*enum_readfnc) (void);
typedef void (*enum_togglefnc) (qbool);
typedef void (*action_fnc) (void);


//
// internal structures
//

typedef enum  {
	stt_separator,             // decorating purpose only, needs only type+label then
	stt_num,                   // integer or float variable, needs cvar, min, max and step are required
	stt_intnum,                // integer non-quake-variable
	stt_bool,                  // simple boolean setting, needs cvar
	stt_custom,                // fully customizable setting, needs readfnc and togglefnc
	stt_named,                 // named integer 0..max, max is number of elements in array of strings assigned to readfnc
	stt_enum,                  // named enum, pairs of "name", "value"
	stt_action,                // function is assigned to this, pointer must be stored in togglefnc
	stt_string,                // string - fully editable by the user, needs only cvar
	stt_playercolor,           // named enum 0..16
	stt_skin,                  // player skin
	stt_bind,                  // keybinding
	stt_advmark,               // denotes advanced settings area
	stt_basemark,              // denotes basic settings area
	stt_blank
} setting_type;

typedef struct {
	setting_type type;         // see above; always required
	const char* label;         // to be displayed on screen; always required
	qbool advanced;            // is this settings advanced?
	cvar_t* cvar;              // assigned variable; required for num, bool, named
	float min;                 // min value; required for num, named
	float max;                 // max value; required for num, named
	float step;                // change step; required for num, named
	enum_readfnc readfnc;      // reading function pointer; required for enum
	enum_togglefnc togglefnc;  // toggle function pointer; required for enum
	action_fnc actionfnc;      // action function pointer; required for stt_action
	const char** named_ints;   // array of strings; required for sett_named and stt_enum
	const char* varname;       // name of a non-static cvar_t, also used for command name for bind
	const char* description;   // manual-like description
	int top;                   // distance of the setting from the top of the settings page
} setting;

typedef struct {
	setting* settings;         // array of settings
	int count;                 // amount of elements in set_tab
	int marked;                // currently selected element in settings
	int viewpoint;		   // where rendering start (internal)
	PScrollBar  scrollbar;     // scrollbar gui element
	enum {
		SPM_NORMAL,
		SPM_BINDING,
		SPM_VIEWHELP,
		SPM_CHOOSESKIN
	} mode;
	int width;                 // last drawn width
	int height;                // last drawn height
	qbool mini;                // minimalistic version (doesn't display help and has infinite scrolling)
} settings_page;

char* SettingColorName(int color);

#endif // __SETTINGS_H__


================================================
FILE: src/settings_page.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**

	Settings page module

	made by johnnycz, Jan 2007
	last edit:
		$Id: settings_page.c,v 1.46 2007-09-30 22:59:23 disconn3ct Exp $

*/

#include "quakedef.h"
#include "settings.h"
#include "Ctrl.h"
#include "Ctrl_EditBox.h"
#include "EX_FileList.h"
#include "help.h"
#include "crc.h"
#include "sbar.h"
#include "menu.h"
#include "keys.h"


CEditBox editbox;

extern cvar_t menu_advanced;

filelist_t skins_filelist;

#define LETW 8
#define LINEHEIGHT 8
#define PADDING 1
#define EDITBOXWIDTH 16
#define EDITBOXMAXLENGTH 64
#define HELPLINES 5
#define SKINPREVIEWHEIGHT 120

#define ENUM_NAME(setting_pointer,position) (setting_pointer->named_ints[position*2])
#define ENUM_VALUE(setting_pointer,position) (setting_pointer->named_ints[position*2+1])
#define ENUM_ITEM_NOT_FOUND	-1

static float SliderPos(float min, float max, float val) { return (val-min)/(max-min); }

static const char* colors[17] = { "White", "Brown", "Lavender", "Khaki", "Red", "Light Brown", "Peach", "Light Peach", "Purple", "Dark Purple", "Tan", "Green", "Yellow", "Blue", "Orange", "Bright Red", "Black"};
#define COLORNAME(x) colors[bound(0, ((int) x), sizeof(colors) / sizeof(char*) - 1)]

char* SettingColorName(int color)
{
	static char tempBuffer[64];

	if (color < 0 || color > sizeof(colors) / sizeof(colors[0]))
		Host_Error("SettingColorName(color %d) out of range.\n", color);

	strlcpy(tempBuffer, colors[color], sizeof(tempBuffer));

	return tempBuffer;
}

float VARFVAL(const cvar_t *v)
{
	if ((v->flags & CVAR_LATCH) && v->latchedString)
		return atof(v->latchedString);
	else return v->value;
}

char* VARSVAL(const cvar_t *v)
{
	if (v->flags & CVAR_LATCH && v->latchedString)
		return v->latchedString;
	else return v->string;
}

static int STHeight(setting* s) {
	if (s->advanced && !menu_advanced.value)
	{
		return 0;
	}
	switch (s->type) {
		case stt_separator: return LINEHEIGHT*3;
		case stt_advmark: case stt_basemark: return 0;
		default: return LINEHEIGHT+PADDING;
	}
}

static int Setting_PrintLabel(int x, int y, int w, const char *l, qbool active)
{
	int startpos = x + w/2 - min(strlen(l), w/2)*LETW;
	UI_Print(startpos, y, l, (int) active);
	x = w/2 + x;
	// if (active) UI_DrawCharacter(x, y, FLASHINGARROW());
	return x + LETW*2;
}

// tells what is the horizontal position of the left corner of the slider
static int Slider_Startpos(int w)
{
	return w/2 + LETW*2;
}

static void Setting_DrawIntNum(int x, int y, int w, setting* setting, qbool active)
{
	char buf[16];
	x = Setting_PrintLabel(x,y,w, setting->label, active);
	x = UI_DrawSlider (x, y, SliderPos(setting->min, setting->max, *((int *) setting->cvar)));
	snprintf(buf, sizeof(buf), "%3d", *((int *) setting->cvar));

	UI_Print(x + LETW, y, buf, active);
}

static void Setting_DrawNum(int x, int y, int w, setting* setting, qbool active)
{
	char buf[16];
	x = Setting_PrintLabel(x,y,w, setting->label, active);
	x = UI_DrawSlider (x, y, SliderPos(setting->min, setting->max, VARFVAL(setting->cvar)));
	if (setting->step > 0.99)
		snprintf(buf, sizeof(buf), "%3d", (int) VARFVAL(setting->cvar));
	else if (((setting->step)*10) < 1)
		snprintf(buf, sizeof(buf), "%3.2f", VARFVAL(setting->cvar));
	else
		snprintf(buf, sizeof(buf), "%3.1f", VARFVAL(setting->cvar));

	UI_Print(x + LETW, y, buf, active);
}

static void Setting_DrawBool(int x, int y, int w, setting* setting, qbool active)
{
	x = Setting_PrintLabel(x,y,w, setting->label, active);
	UI_Print(x, y, VARFVAL(setting->cvar) ? "on" : "off", active);
}

static void Setting_DrawBoolAdv(int x, int y, int w, setting* setting, qbool active)
{
	const char* val;
	x = Setting_PrintLabel(x,y,w, setting->label, active);
	val = setting->readfnc ? setting->readfnc() : "off";
	UI_Print(x, y, val, active);
}

static void Setting_DrawSeparator(int x, int y, int w, setting* set)
{
	char buf[32];
	snprintf(buf, sizeof(buf), "\x1d %s \x1f", set->label);
	UI_Print_Center(x, y+LINEHEIGHT+LINEHEIGHT/2, w, buf, true);
}

static void Setting_DrawAction(int x, int y, int w, setting* set, qbool active)
{
	// this will make it centered
	UI_Print_Center(x, y, w, set->label, active);

	// this will make it aligned to the left side from the center
	// Setting_PrintLabel(x, y, w, set->label, active);
}

static void Setting_DrawNamed(int x, int y, int w, setting* set, qbool active)
{
	x = Setting_PrintLabel(x, y, w, set->label, active);
	UI_Print(x, y, set->named_ints[(int) bound(set->min, VARFVAL(set->cvar), set->max)], active);
}

static int Enum_Find_ValueCode(setting* set)
{
	int i;

	for (i = 0; i <= set->max; i++)
	{
		if (!strcasecmp(VARSVAL(set->cvar), ENUM_VALUE(set, i)))
			return i;
	}
	return ENUM_ITEM_NOT_FOUND;
}

static void Setting_DrawEnum(int x, int y, int w, setting* set, qbool active)
{
	int i;
	x = Setting_PrintLabel(x, y, w, set->label, active);
	i = Enum_Find_ValueCode(set);
	if (i == ENUM_ITEM_NOT_FOUND) {
		UI_Print(x, y, "custom", active);
	} else {
		UI_Print(x, y, ENUM_NAME(set, i), active);
	}
}

static void Setting_DrawString(int x, int y, int w, setting* setting, qbool active)
{
	int x0 = x;
	x = Setting_PrintLabel(x,y,w, setting->label, active);
	if (active) {
		editbox.width = (w - x + x0) / 8;
		CEditBox_Draw(&editbox, x, y, true);
	} else {
		UI_Print(x, y, VARSVAL(setting->cvar), false);
	}
}

static void Setting_DrawColor(int x, int y, int w, setting* set, qbool active)
{
	x = Setting_PrintLabel(x, y, w, set->label, active);
	if (VARFVAL(set->cvar) >= 0) {
		Draw_Fill(x, y, LETW*3, LINEHEIGHT, Sbar_ColorForMap(VARFVAL(set->cvar)));
		UI_Print(x + 4*LETW, y, va("%i (%s)", (int) VARFVAL(set->cvar), COLORNAME(VARFVAL(set->cvar))), active);
	} else
		UI_Print(x, y, "off", active);
}

static void Setting_DrawSkin(int x, int y, int w, setting* set, qbool active)
{
	x = Setting_PrintLabel(x, y, w, set->label, active);
	UI_Print(x, y, set->cvar->string, active);
}

static void Setting_DrawBind(int x, int y, int w, setting* set, qbool active, qbool bindmode)
{
	int keys[2];
	char *name;
	char c[2];

	c[0] = FLASHINGARROW();
	c[1] = 0;

	x = Setting_PrintLabel(x, y, w, set->label, active);

	if (bindmode && active) {
		UI_Print(x, y, c, active);
	}

	//x += LETW*2;

	M_FindKeysForCommand (set->varname, keys);

	if (keys[0] == -1) {
		UI_Print (x, y, "???", active);
	} else {
		name = Key_KeynumToString (keys[0]);
		UI_Print (x, y, name, active);
		x += strlen(name)*8;
		if (keys[1] != -1) {
			UI_Print (x + 8, y, "or", active);
			UI_Print (x + 4*8, y, Key_KeynumToString (keys[1]), active);
		}
	}

}

static void Setting_IncreaseEnum(setting* set, int step)
{
	int i;
	if (set->type != stt_enum) return;
	i = Enum_Find_ValueCode(set) + step;
	if (i > set->max) i = 0;
	if (i < 0) i = set->max;
	// Cvar_Set doesn't take const char*
	Cvar_Set(set->cvar, va("%s", ENUM_VALUE(set, i)));
}

static void Setting_Increase(setting* set) {
	float newval;

	switch (set->type) {
		case stt_bool: Cvar_Set (set->cvar, VARFVAL(set->cvar) ? "0" : "1"); break;
		case stt_custom: if (set->togglefnc) set->togglefnc(false); break;
		case stt_num:
		case stt_named:
		case stt_playercolor:
					 newval = VARFVAL(set->cvar) + set->step;
					 if (set->max >= newval)
						 Cvar_SetValue(set->cvar, newval);
					 else if (set->type == stt_named || set->type == stt_playercolor)
						 Cvar_SetValue(set->cvar, set->min);
					 break;
		case stt_action: if (set->actionfnc) set->actionfnc(); break;
		case stt_enum: Setting_IncreaseEnum(set, set->step); break;
		case stt_intnum:
			       *((int *)set->cvar) += set->step;
			       if (*((int *) set->cvar) > set->max) {
				       *((int *)set->cvar) = set->max;
			       }
			       break;

			       // unhandled
		case stt_separator:
		case stt_string:
		case stt_bind:
		case stt_skin:
		case stt_advmark:
		case stt_basemark:
		case stt_blank:
			       break;
	}
}

static void Setting_Decrease(setting* set) {
	float newval;

	switch (set->type) {
		case stt_bool: Cvar_Set (set->cvar, VARFVAL(set->cvar) ? "0" : "1"); break;
		case stt_custom: if (set->togglefnc) set->togglefnc(true); break;
		case stt_num:
		case stt_named:
		case stt_playercolor:
					 newval = VARFVAL(set->cvar) - set->step;
					 if (set->min <= newval)
						 Cvar_SetValue(set->cvar, newval);
					 else if (set->type == stt_named || set->type == stt_playercolor)
						 Cvar_SetValue(set->cvar, set->max);
					 break;

		case stt_enum: Setting_IncreaseEnum(set, -set->step); break;
		case stt_intnum:
			       *((int *)set->cvar) -= set->step;
			       if (*((int *) set->cvar) < set->min) {
				       *((int *)set->cvar) = set->min;
			       }
			       break;

			       //unhandled
		case stt_separator:
		case stt_action:
		case stt_string:
		case stt_bind:
		case stt_skin:
		case stt_advmark:
		case stt_basemark:
		case stt_blank:
			       break;
	}
}

static void Setting_Reset(setting* set)
{
	switch (set->type) {
		case stt_num:
		case stt_string:
		case stt_named:
		case stt_bool:
			Cvar_ResetVar(set->cvar);
			break;
			// unhandled
		case stt_bind:
		case stt_separator:
		case stt_custom:
		case stt_enum:
		case stt_action:
		case stt_playercolor:
		case stt_skin:
		case stt_advmark:
		case stt_basemark:
		case stt_intnum:
		case stt_blank:
			break;
	}
}

static void Setting_BindKey(setting* set, int key)
{
	Key_SetBinding(key, set->varname);
}

static void M_UnbindCommand (const char *command) {
	int j, l;
	char *b;

	l = strlen(command) + 1;

	for (j = 0; j < (sizeof(keybindings) / sizeof(*keybindings)); j++) {
		b = keybindings[j];
		if (!b)
			continue;
		if (!strncmp (b, command, l) )
			Key_Unbind (j);
	}
}

static void Setting_UnbindKey(setting* set)
{
	M_UnbindCommand(set->varname);
}

static int Settings_PageHeight(const settings_page *page)
{
	return page->settings[page->count - 1].top + STHeight(page->settings + page->count - 1);
}

// will find the lowest number of the setting on 'page' that can be used as the lowest viewpoint
// and will ensure that whole bottom of the page is still visible
static int Settings_LowestViewpoint(const settings_page *page)
{
	int bottom = Settings_PageHeight(page);

	// represents the 'top' number we are looking for
	int best_top = bottom - page->height;

	// presume the lowest viewpoint is the last entry
	int lwp = page->count - 1;

	// this is when the page fits whole on the screen
	if (bottom < page->height) return 0;

	if (!page->count) return 0;

	// it can only get better from now
	while (lwp && page->settings[lwp].top >= best_top) lwp--;

	return lwp + 1;
}

// adjusts current viewed area of the settings page
static void CheckViewpoint(settings_page *tab)
{
	int lwp = Settings_LowestViewpoint(tab);

	tab->viewpoint = bound(0, tab->viewpoint, lwp);

	if (tab->marked == 1 && tab->settings[0].type == stt_separator) tab->viewpoint = 0;

	if (tab->viewpoint > tab->marked) {
		// marked entry is above us
		tab->viewpoint = tab->marked;
	} else while(STHeight(tab->settings + tab->marked) + tab->settings[tab->marked].top > tab->settings[tab->viewpoint].top + tab->height) {
		// marked entry is below
		tab->viewpoint++;
	}
}

static void CheckCursor(settings_page *tab, qbool up)
{	// this makes sure that cursor doesn't point at some meta-entry, section heading or hidden setting
	setting *s;
	while (tab->marked < 0) {
		if (tab->mini) {
			tab->marked = tab->count - 1;
		}
		else {
			tab->marked = 0;
		}
		up = false;
	}
	if (tab->marked >= tab->count) {
		if (tab->mini) {
			tab->marked = 1;
		}
		else {
			tab->marked = tab->count - 1;
		}
		up = true;
	}
	s = tab->settings + tab->marked;
	if (s->type == stt_separator || (s->advanced && !menu_advanced.value) || s->type == stt_advmark || s->type == stt_basemark || s->type == stt_blank) {
		tab->marked += up ? -1 : +1;
		CheckCursor(tab, up);
	}
}

static void StringEntryLeave(setting* set) {
	Cvar_Set(set->cvar, editbox.text);
}

static void StringEntryEnter(setting* set) {
	CEditBox_Init(&editbox, EDITBOXWIDTH, EDITBOXMAXLENGTH);
	strlcpy(editbox.text, set->cvar->string, EDITBOXMAXLENGTH);
}

static void EditBoxCheck(settings_page* tab, int oldm, int newm)
{
	if (tab->settings[oldm].type == stt_string && oldm != newm)
		StringEntryLeave(tab->settings + oldm);
	if (tab->settings[newm].type == stt_string && oldm != newm)
		StringEntryEnter(tab->settings + newm);
}

static void RecalcPositions(settings_page* page)
{	// especially when "show advanced options" is being changed
	// we need to recalculate where each option is
	int i;
	int curtop = 0;
	setting *s;

	for (i = 0; i < page->count; i++)
	{
		s = page->settings + i;
		s->top = curtop;

		curtop += STHeight(s);
	}
}

static int Setting_DrawHelpBox(int x, int y, int w, int h, settings_page* page, qbool full)
{
	setting* s;
	char buf[2048];
	const char *helptext = "";
	int maxh;
	const char *cp;

	s = page->settings + page->marked;

	switch (s->type) {
		case stt_bool:
		case stt_named:
		case stt_num:
		case stt_string:
		case stt_playercolor:
		case stt_enum:
			buf[0] = 0;
			helptext = "Further info not available...";
			Help_VarDescription (s->cvar->name, buf, sizeof(buf));
			helptext = buf;
			break;

		case stt_bind:
			if (page->mode == SPM_BINDING)
				helptext = "Press the key you want to assiciate with given action";
			else
				helptext = "Press Enter to change the associated key; Press Del to remove the binding";
			break;

		case stt_skin:
			helptext = "Press [Enter] to choose a skin image for this type of player";
			break;

		default:
			if (s->description)
				helptext = s->description;
			break;
	}

	if (full) {
		// add some lines for wrapped words, just a rough approximation here
		maxh = (int) ((((double) strlen(helptext) / (w / LETW - 2)) + 2) * 1.33) * LETW;
		cp = helptext;
		while (*cp) { if (*cp++ == '\n') maxh += LETW; } // add new line for each newline
		maxh = max((HELPLINES + 2) * LETW, maxh);
		if (maxh < h) {
			y += h - maxh;
			h = maxh;
		}
	}

	UI_DrawBox(x, y, w, h);

	if (!UI_PrintTextBlock(x + LETW, y + LETW, w - LETW*2, h - LETW*2, helptext, false) && !full)
		UI_Print(x + LETW, y + h - LETW, "Press [F1] to read more...", true);

	return h;
}

// will draw the skin preview in given window
static void Setting_DrawSkinPreview(int x, int y, int w, int h, char *skinfile)
{
	static mpic_t *curpic = NULL;
	static char lastpicname[MAX_PATH] = "";

	if (!skinfile) return;

	// this means the length of "qw/"
#define QWDIRLEN 3

	UI_DrawBox(x, y, w, h);
	x += LETTERWIDTH;
	y += LETTERHEIGHT;
	w -= LETTERWIDTH;
	h -= LETTERHEIGHT;

	if (strcmp(lastpicname, skinfile))
	{
		char *c;
		char buf[MAX_PATH];

		// get the "qw/skins/freddy" part from the full path
		if (strlen(skinfile) <= strlen(com_basedir) + QWDIRLEN)
		{
			return;
		}
		c = skinfile + strlen(com_basedir) + QWDIRLEN + 1;
		COM_StripExtension(c, buf, sizeof(buf));

		curpic = Draw_CachePicSafe(buf, false, true);
		strlcpy(lastpicname, skinfile, sizeof(lastpicname));
	}

	if (curpic)
	{
		Draw_FitPic(x, y, w, h, curpic);
	}
#undef QWDIRLEN
}

static int FindSetting_AtPos(const settings_page *page, int top)
{
	int i, r = 0;
	for (i = 0; i < page->count; i++)
	{
		if (page->settings[i].top < top)
			r = i;
	}
	return r;
}

// will choose correct value for the selected setting according to
// where the user has clicked on the slidebar
static void Setting_Slider_Click(const settings_page *page, const mouse_state_t *ms)
{
	double p, vmin, vmax, vnew, vsteps;
	setting* s = page->settings + page->marked;

	p = (ms->x - Slider_Startpos(page->width)) / UI_SliderWidth();
	p = bound(0, p, 1);

	if (s->type != stt_num && s->type != stt_intnum) return;

	vmin = s->min;
	vmax = s->max;
	vnew = vmin + (vmax-vmin) * p;
	for (vsteps = vmin; vsteps < vmax && vsteps < vnew; vsteps += s->step) ; // empty body

	if (s->type == stt_intnum) {
		*((int *) s->cvar) = vsteps;
	}
	else {
		Cvar_SetValue(s->cvar, vsteps);
	}
}

qbool Settings_Key(settings_page* tab, int key, wchar unichar)
{
	qbool up = false;
	setting_type type;
	int oldm = tab->marked;
	char *skinpath;
	qbool skip_check_viewpoint = false;

	type = tab->settings[tab->marked].type;

	if (tab->mode == SPM_BINDING) {
		if (key != K_ESCAPE)
			Setting_BindKey(tab->settings + tab->marked, key);

		tab->mode = SPM_NORMAL;
		return true;
	}

	if (tab->mode == SPM_CHOOSESKIN) {
		if (key == K_ENTER || key == K_MOUSE1) {
			char buf[MAX_PATH];
			skinpath = FL_GetCurrentPath(&skins_filelist);
			if (skinpath) {
				COM_StripExtension(COM_SkipPath(skinpath), buf, sizeof(buf));
				if (strcmp(buf, "."))
					Cvar_Set(tab->settings[tab->marked].cvar, buf);
			}
			tab->mode = SPM_NORMAL;
			return true;
		}

		if (key == K_ESCAPE || key == K_MOUSE2) {
			tab->mode = SPM_NORMAL;
			return true;
		}

		return FL_Key(&skins_filelist, key);
	}

	if (tab->mode == SPM_VIEWHELP) {
		tab->mode = SPM_NORMAL;
		return true;
	}

	switch (key) {
		case K_DOWNARROW:   tab->marked++; break;
		case K_UPARROW:     tab->marked--; up = true; break;
		case K_MWHEELDOWN:
				    if (tab->viewpoint < Settings_LowestViewpoint(tab))
					    tab->viewpoint++;

				    skip_check_viewpoint = true;
				    break;

		case K_MWHEELUP:
				    if (tab->viewpoint > 0)
					    tab->viewpoint--;
				    skip_check_viewpoint = true;
				    break;

		case K_PGDN: tab->marked += 5; break;
		case K_PGUP: tab->marked -= 5; up = true; break;
		case K_END: tab->marked = tab->count - 1; up = true; break;
		case K_HOME: tab->marked = 0; break;

		case K_RIGHTARROW:
			switch (type) {
				case stt_string:
					CEditBox_Key(&editbox, key, unichar);
					break;
				default:
					Setting_Increase(tab->settings + tab->marked);
					break;
			}
			break;
		case K_LEFTARROW:
			switch (type) {
				case stt_string:
					CEditBox_Key(&editbox, key, unichar);
					break;
				default:
					Setting_Decrease(tab->settings + tab->marked);
					break;
			}
			break;
		case K_ENTER:
		case K_MOUSE1:
		case '=':
		case KP_PLUS:
			     switch (type) {
				     case stt_string: StringEntryLeave(tab->settings + tab->marked); break;
				     case stt_bind: tab->mode = SPM_BINDING; break;
				     case stt_skin: tab->mode = SPM_CHOOSESKIN; break;
				     default: Setting_Increase(tab->settings + tab->marked); break;
			     }
			     return true;

		case K_BACKSPACE: case '-': case KP_MINUS:
			     switch (type) {
				     case stt_action: return false;
				     case stt_string: CEditBox_Key(&editbox, key, unichar); return true;
				     default: Setting_Decrease(tab->settings + tab->marked);	return true;
			     }

		case K_DEL:
			     switch (type) {
				     case stt_string: CEditBox_Key(&editbox, key, unichar); return true;
				     case stt_bind: Setting_UnbindKey(tab->settings + tab->marked); return true;
				     default: Setting_Reset(tab->settings + tab->marked); return true;
			     }

		case K_F1:
		case K_INS:
			     switch (tab->mode) {
				     case SPM_NORMAL: tab->mode = SPM_VIEWHELP; return true;
				     case SPM_VIEWHELP: tab->mode = SPM_NORMAL; return true;
							// unhandled
				     case SPM_BINDING:
				     case SPM_CHOOSESKIN:
							break;
			     }
			     break;

		case K_MOUSE2:
			     if (tab->mode == SPM_VIEWHELP) {
				     tab->mode = SPM_NORMAL; return true;
			     } else return false;

		case K_ESCAPE:
			     if (tab->mode == SPM_VIEWHELP) {
				     tab->mode = SPM_NORMAL;
				     return true;
			     } else return false;

		default:
			     switch (type) {
				     case stt_string:
					     if (key != K_TAB && key != K_ESCAPE && key != K_LEFTARROW && key != K_RIGHTARROW) {
						     CEditBox_Key(&editbox, key, unichar);
						     return true;
					     }
					     return false;

				     default: return false;
			     }
	}

	CheckCursor(tab, up);

	if (!skip_check_viewpoint)
		CheckViewpoint(tab);

	EditBoxCheck(tab, oldm, tab->marked);
	return true;
}

static void Setting_Click(settings_page* page, const mouse_state_t *ms)
{
	// don't accept clicks on the label
	if (ms->x < page->width/2 && (page->settings + page->marked)->type != stt_action) return;

	if (page->settings[page->marked].type == stt_num) {
		Setting_Slider_Click(page, ms);
	} else Settings_Key(page, K_MOUSE1, 0);
}

static void Settings_AdjustScrollBar(settings_page *page)
{
	double lwp = Settings_LowestViewpoint(page);
	double percentage = lwp ? (double) page->viewpoint / lwp : 0;

	// do not adjust the scrollbar if we are scrolling, it would look weird
	if (page->scrollbar->mouselocked) return;

	page->scrollbar->curpos = bound(0, percentage, 1);
}

void Settings_Draw(int x, int y, int w, int h, settings_page* tab)
{
	int i;
	int ch;
	//int nexttop;
	int hbh = 0;	// help box height
	setting *set;
	qbool active;
	static qbool prev_adv_state = false;

	if (!tab->count) return;

	if (prev_adv_state != (qbool) menu_advanced.value) {
		// someone toggled menu_advanced setting right in the currently viewed menu!
		RecalcPositions(tab);
		prev_adv_state = (qbool) menu_advanced.value;
	}

	//nexttop = tab->settings[0].top;

	if (tab->mode == SPM_CHOOSESKIN)
	{
		FL_Draw(&skins_filelist, x, y, w, h - SKINPREVIEWHEIGHT);
		Setting_DrawSkinPreview(x, y + h - SKINPREVIEWHEIGHT, w, SKINPREVIEWHEIGHT, FL_GetCurrentPath(&skins_filelist));
		return;
	}

	w -= tab->scrollbar->width;

	if (!tab->mini) {
		if (tab->mode != SPM_VIEWHELP) {
			hbh = HELPLINES * LINEHEIGHT;
			h -= Setting_DrawHelpBox(x, y + h - hbh, w, hbh, tab, false);
		} else {
			hbh = h - LINEHEIGHT * 4;
			h -= Setting_DrawHelpBox(x, y + h - hbh, w, hbh, tab, true);
		}
	}

	tab->width = w; tab->height = h;

	Settings_AdjustScrollBar(tab);
	if (tab->height < Settings_PageHeight(tab))
		ScrollBar_Draw(tab->scrollbar, x + w, y, h);

	for (i = tab->viewpoint; i < tab->count && tab->settings[i].top + STHeight(tab->settings + i) <= h + tab->settings[tab->viewpoint].top; i++)
	{
		active = i == tab->marked;
		set = tab->settings + i;
		ch = STHeight(tab->settings + i);
		if ((set->advanced && !menu_advanced.value) || set->type == stt_advmark || set->type == stt_basemark) continue;

		if (active && set->type != stt_separator) {
			UI_DrawGrayBox(x, y, w, ch);
		}
		switch (set->type) {
			case stt_bool: if (set->cvar) Setting_DrawBool(x, y, w, set, active); break;
			case stt_custom: Setting_DrawBoolAdv(x, y, w, set, active); break;
			case stt_num: Setting_DrawNum(x, y, w, set, active); break;
			case stt_intnum: Setting_DrawIntNum(x, y, w, set, active); break;
			case stt_separator: Setting_DrawSeparator(x, y, w, set); break;
			case stt_action: Setting_DrawAction(x, y, w, set, active); break;
			case stt_named: Setting_DrawNamed(x, y, w, set, active); break;
			case stt_enum: Setting_DrawEnum(x, y, w, set, active); break;
			case stt_string: Setting_DrawString(x, y, w, set, active); break;
			case stt_playercolor: Setting_DrawColor(x, y, w, set, active); break;
			case stt_skin: Setting_DrawSkin(x, y, w, set, active); break;
			case stt_bind: Setting_DrawBind(x, y, w, set, active, tab->mode == SPM_BINDING); break;
				       // unhandled
			case stt_advmark:
			case stt_basemark:
			case stt_blank:
				       break;
		}
		y += ch;
		//if (i < tab->count)
		//	nexttop = tab->settings[i+1].top;
	}
}

void Settings_OnShow(settings_page *page)
{
	RecalcPositions(page);

	CheckCursor(page, false);

	if (page->settings[page->marked].type == stt_string)
		StringEntryEnter(page->settings + page->marked);
}

qbool Settings_Mouse_Event(settings_page *page, const mouse_state_t *ms)
{
	int nmark;
	int omark = page->marked;

	// scrollbar associated with this page handles the event
	// page has to be in normal mode and user is already scrolling or
	// just started scrolling
	if (page->mode == SPM_NORMAL && (page->scrollbar->mouselocked ||
				(ms->x > (page->width - page->scrollbar->width))))
	{
		if (ScrollBar_MouseEvent(page->scrollbar, ms))
		{
			page->viewpoint = Settings_LowestViewpoint(page) * page->scrollbar->curpos;
		}

		return true;
	}

	if (page->mode == SPM_NORMAL && ms->button_up == 1) {
		Setting_Click(page, ms);
		return true;
	}

	switch (page->mode) {
		case SPM_BINDING:
			if (ms->button_down) return true;
			if (ms->button_up) {
				Setting_BindKey(page->settings + page->marked, K_MOUSE1 + ms->button_up - 1);
				page->mode = SPM_NORMAL;
				return true;
			}
			break;

		case SPM_CHOOSESKIN:
			if (FL_Mouse_Event(&skins_filelist, ms)) return true;
			else if (ms->button_up == 1) Settings_Key(page, K_MOUSE1, 0);
			return true;
			break;

		case SPM_NORMAL:
			nmark = FindSetting_AtPos(page, page->settings[page->viewpoint].top + ms->y);
			nmark = bound(0, nmark, page->count - 1);
			if ((page->settings[nmark].type == stt_num || page->settings[nmark].type == stt_intnum)
					&& ms->buttons[1] == true)
			{
				Setting_Slider_Click(page, ms);
			}
			else if (page->settings[nmark].type != stt_separator)
			{
				page->marked = nmark;
				CheckCursor(page, ms->x < ms->x_old);
				EditBoxCheck(page, omark, nmark);
			}
			return true;

		case SPM_VIEWHELP:
			return false;
			break;
	}
	return false;
}

void Settings_Init(settings_page *page, setting *arr, int size, const char* name)
{
	int i;
	qbool onlyseparators = true;
	qbool advancedmode = false;

	page->count = size;
	page->marked = 0;
	page->settings = arr;
	page->viewpoint = 0;
	page->mode = SPM_NORMAL;
	page->scrollbar = ScrollBar_Create(NULL, name);
	page->mini = false;

	for (i = 0; i < size; i++) {
		if (arr[i].type == stt_advmark) advancedmode = true;
		if (arr[i].type == stt_basemark) advancedmode = false;
		arr[i].advanced = advancedmode;

		if (onlyseparators && arr[i].type != stt_separator) {
			onlyseparators = false;
			page->marked = i;
		}
		if (arr[i].varname && !arr[i].cvar && arr[i].type == stt_bool) {
			arr[i].cvar = Cvar_Find(arr[i].varname);
			arr[i].varname = NULL;
			if (!arr[i].cvar)
				Cbuf_AddText(va("Warning: variable %s not found\n", arr[i].varname));
		}
	}

	RecalcPositions(page);

	if (onlyseparators) {
		Cbuf_AddText("Warning (Settings_Init): menu contained only separators\n");
		page->count = 0;
	}
}

void Settings_Shutdown(settings_page *page)
{
	Q_free(page->scrollbar);
}

void Settings_MainInit(void)
{
	FL_Init(&skins_filelist, "./qw/skins");

	FL_SetDirUpOption(&skins_filelist, false);
	FL_SetDirsOption(&skins_filelist, false);
	FL_AddFileType(&skins_filelist, 0, ".pcx");
	FL_AddFileType(&skins_filelist, 1, ".png");
	FL_AddFileType(&skins_filelist, 2, ".jpg");
	FL_AddFileType(&skins_filelist, 3, ".tga");
}

void Settings_MainShutdown(void)
{
	FL_Shutdown(&skins_filelist);
}


================================================
FILE: src/settings_page.h
================================================
/*
Copyright (C) 2011 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/** Guide to create settings page:
	1) make new variables:
		a) 'settings_page' variable
		b) array of 'setting' elements, use macros from settings.h to do this
	2) in some Init function call Settings_Page_Init(a, b); - a and b are variables from steps a and b
	3) place calls to _Draw and _Key functions to appropriate places
 */

#ifndef __SETTINGS_PAGE_H__
#define __SETTINGS_PAGE_H__

#include "keys.h"

#define Settings_Page_Init(set_page, settings) Settings_Init(&set_page, settings, (int)(sizeof(settings) / sizeof(setting)), #set_page)
#define Settings_Page_SetMinit(set_page) { set_page.mini = true; }

// initializes the page structure
void Settings_Init(settings_page *page, setting *settings, int size, const char* name);

void Settings_Shutdown(settings_page *page);

// initilalize settings pages structures
void Settings_MainInit(void);
void Settings_MainShutdown(void);

// draw request handler
void Settings_Draw(int x, int y, int w, int h, settings_page* page);

// optonal call at the moment of first display
void Settings_OnShow(settings_page *tab);

// key press handler
qbool Settings_Key(settings_page* page, int key, wchar unichar);

// mouse move handler
qbool Settings_Mouse_Event(settings_page * page, const mouse_state_t *ms);

#endif // __SETTINGS_PAGE_H__


================================================
FILE: src/sha1.c
================================================
/*
SHA-1 in C
By Steve Reid <steve@edmweb.com>
100% Public Domain

Test Vectors (from FIPS PUB 180-1)
"abc"
  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
A million repetitions of "a"
  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F

	$Id: sha1.c,v 1.11 2007-08-08 00:53:29 disconn3ct Exp $
*/

/* #define SHA1HANDSOFF * Copies data before messing with it. */

#include <stdio.h>
#include <string.h>
#include "sha1.h"
#include "common.h"

/* Hash a single 512-bit block. This is the core of the algorithm. */

void SHA1Transform(unsigned int state[5], unsigned char buffer[64])
{
    unsigned int a, b, c, d, e;
    typedef union {
        unsigned char c[64];
        unsigned int l[16];
    } CHAR64LONG16;
    CHAR64LONG16* block;
#ifdef SHA1HANDSOFF
    static unsigned char workspace[64];
    block = (CHAR64LONG16*)workspace;
    memcpy(block, buffer, 64);
#else
    block = (CHAR64LONG16*)buffer;
#endif
    /* Copy context->state[] to working vars */
    a = state[0];
    b = state[1];
    c = state[2];
    d = state[3];
    e = state[4];
    /* 4 rounds of 20 operations each. Loop unrolled. */
    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
    /* Add the working vars back into context.state[] */
    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;
    state[4] += e;
    /* Wipe variables */
    a = b = c = d = e = 0;
}


/* SHA1Init - Initialize new context */

void SHA1Init(SHA1_CTX* context)
{
    /* SHA1 initialization constants */
    context->state[0] = 0x67452301;
    context->state[1] = 0xEFCDAB89;
    context->state[2] = 0x98BADCFE;
    context->state[3] = 0x10325476;
    context->state[4] = 0xC3D2E1F0;
    context->count[0] = context->count[1] = 0;
}


/* Run your data through this. */

void SHA1Update(SHA1_CTX* context, unsigned char* data, size_t len)
{
	volatile unsigned int i, j;

    j = (context->count[0] >> 3) & 63;
	if ((context->count[0] += len << 3) < (len << 3)) {
		context->count[1]++;
	}
    context->count[1] += (len >> 29);
    if ((j + len) > 63) {
        memcpy(&context->buffer[j], data, (i = 64-j));
        SHA1Transform(context->state, context->buffer);
        for ( ; i + 63 < len; i += 64) {
            SHA1Transform(context->state, &data[i]);
        }
        j = 0;
    }
	else {
		i = 0;
	}
    memcpy(&context->buffer[j], &data[i], len - i);
}


/* Add padding and return the message digest. */

void SHA1Final(unsigned char digest[DIGEST_SIZE], SHA1_CTX* context)
{
unsigned int i, j;
unsigned char finalcount[8];

    for (i = 0; i < 8; i++) {
        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
    }
    SHA1Update(context, (unsigned char *)"\200", 1);
    while ((context->count[0] & 504) != 448) {
        SHA1Update(context, (unsigned char *)"\0", 1);
    }
    SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
    for (i = 0; i < DIGEST_SIZE; i++) {
        digest[i] = (unsigned char)
         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
    }
    /* Wipe variables */
    i = j = 0;
    memset(context->buffer, 0, 64);
    memset(context->state, 0, 20);
    memset(context->count, 0, 8);
    memset(&finalcount, 0, 8);
#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite it's own static vars */
    SHA1Transform(context->state, context->buffer);
#endif
}

//VVD: SHA1 crypt
char *bin2hex(unsigned char *d)
{
	static char	ret[DIGEST_SIZE * 2 + 1];
	int		i;
	for (i = 0; i < DIGEST_SIZE * 2; i += 2, d++)
		snprintf(ret + i, DIGEST_SIZE * 2 + 1 - i, "%02X", *d);
	return ret;
}

char *SHA1(char *string)
{
	SHA1_CTX	context;
	unsigned char	digest[DIGEST_SIZE];
	SHA1Init(&context);
	SHA1Update(&context, (unsigned char*) string, strlen(string));
	SHA1Final(digest, &context);
	return bin2hex(digest);
}

SHA1_CTX	context;
void SHA1_Init(void)
{
	SHA1Init(&context);
}
void SHA1_Update(unsigned char *string)
{
	SHA1Update(&context, string, strlen((char *)string));
}
char *SHA1_Final(void)
{
	unsigned char	digest[DIGEST_SIZE];
	SHA1Final(digest, &context);
	return bin2hex(digest);
}


================================================
FILE: src/sha1.h
================================================
/*
SHA-1 in C
By Steve Reid <steve@edmweb.com>
100% Public Domain

Test Vectors (from FIPS PUB 180-1)
"abc"
  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
A million repetitions of "a"
  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F

	$Id: sha1.h,v 1.9 2007-08-08 00:53:29 disconn3ct Exp $
*/

#define SHA1HANDSOFF /* Copies data before messing with it. */
#ifndef _SHA1
#define _SHA1
typedef struct {
    unsigned int state[5];
    size_t count[2];
    unsigned char buffer[64];
} SHA1_CTX;

#define DIGEST_SIZE 20
void SHA1Transform(unsigned int state[5], unsigned char buffer[64]);
void SHA1Init(SHA1_CTX* context);
void SHA1Update(SHA1_CTX* context, unsigned char* data, size_t len);
void SHA1Final(unsigned char digest[DIGEST_SIZE], SHA1_CTX* context);

#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))

/* blk0() and blk() perform the initial expand. */
/* I got the idea of expanding during the round function from SSLeay */
/*
#ifdef __BIG_ENDIAN
#define blk0(i) block->l[i]
#else
#define blk0(i) (block->l[i] =	(rol(block->l[i], 24) & 0xFF00FF00) | \
							    (rol(block->l[i],  8) & 0x00FF00FF))
#endif
*/

#define blk0(i) (block->l[i] = BigLong(block->l[i]))

#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
    ^block->l[(i+2)&15]^block->l[i&15],1))

/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);

//VVD: SHA1 crypt
char *SHA1(char *string);
void SHA1_Init(void);
void SHA1_Update(unsigned char* data);
char *SHA1_Final(void);
char *bin2hex(unsigned char *d);
#endif //_SHA1


================================================
FILE: src/sha3.c
================================================
/* -------------------------------------------------------------------------
 * Works when compiled for either 32-bit or 64-bit targets, optimized for 
 * 64 bit.
 *
 * Canonical implementation of Init/Update/Finalize for SHA-3 byte input. 
 *
 * SHA3-256, SHA3-384, SHA-512 are implemented. SHA-224 can easily be added.
 *
 * Based on code from http://keccak.noekeon.org/ .
 *
 * I place the code that I wrote into public domain, free to use. 
 *
 * I would appreciate if you give credits to this work if you used it to 
 * write or test * your code.
 *
 * Aug 2015. Andrey Jivsov. crypto@brainhub.org
 * ---------------------------------------------------------------------- */

#include <stdio.h>
#include <stdint.h>
#include <string.h>

#include "sha3.h"

#define SHA3_ASSERT( x )
#define SHA3_TRACE( format, ...)
#define SHA3_TRACE_BUF(format, buf, l)

/* 
 * This flag is used to configure "pure" Keccak, as opposed to NIST SHA3.
 */
#define SHA3_USE_KECCAK_FLAG 0x80000000
#define SHA3_CW(x) ((x) & (~SHA3_USE_KECCAK_FLAG))


#if defined(_MSC_VER)
#define SHA3_CONST(x) x
#else
#define SHA3_CONST(x) x##L
#endif

#ifndef SHA3_ROTL64
#define SHA3_ROTL64(x, y) \
	(((x) << (y)) | ((x) >> ((sizeof(uint64_t)*8) - (y))))
#endif

static const uint64_t keccakf_rndc[24] = {
    SHA3_CONST(0x0000000000000001UL), SHA3_CONST(0x0000000000008082UL),
    SHA3_CONST(0x800000000000808aUL), SHA3_CONST(0x8000000080008000UL),
    SHA3_CONST(0x000000000000808bUL), SHA3_CONST(0x0000000080000001UL),
    SHA3_CONST(0x8000000080008081UL), SHA3_CONST(0x8000000000008009UL),
    SHA3_CONST(0x000000000000008aUL), SHA3_CONST(0x0000000000000088UL),
    SHA3_CONST(0x0000000080008009UL), SHA3_CONST(0x000000008000000aUL),
    SHA3_CONST(0x000000008000808bUL), SHA3_CONST(0x800000000000008bUL),
    SHA3_CONST(0x8000000000008089UL), SHA3_CONST(0x8000000000008003UL),
    SHA3_CONST(0x8000000000008002UL), SHA3_CONST(0x8000000000000080UL),
    SHA3_CONST(0x000000000000800aUL), SHA3_CONST(0x800000008000000aUL),
    SHA3_CONST(0x8000000080008081UL), SHA3_CONST(0x8000000000008080UL),
    SHA3_CONST(0x0000000080000001UL), SHA3_CONST(0x8000000080008008UL)
};

static const unsigned keccakf_rotc[24] = {
    1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62,
    18, 39, 61, 20, 44
};

static const unsigned keccakf_piln[24] = {
    10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20,
    14, 22, 9, 6, 1
};

/* generally called after SHA3_KECCAK_SPONGE_WORDS-ctx->capacityWords words 
 * are XORed into the state s 
 */
static void
keccakf(uint64_t s[25])
{
    int i, j, round;
    uint64_t t, bc[5];
#define KECCAK_ROUNDS 24

    for(round = 0; round < KECCAK_ROUNDS; round++) {

        /* Theta */
        for(i = 0; i < 5; i++)
            bc[i] = s[i] ^ s[i + 5] ^ s[i + 10] ^ s[i + 15] ^ s[i + 20];

        for(i = 0; i < 5; i++) {
            t = bc[(i + 4) % 5] ^ SHA3_ROTL64(bc[(i + 1) % 5], 1);
            for(j = 0; j < 25; j += 5)
                s[j + i] ^= t;
        }

        /* Rho Pi */
        t = s[1];
        for(i = 0; i < 24; i++) {
            j = keccakf_piln[i];
            bc[0] = s[j];
            s[j] = SHA3_ROTL64(t, keccakf_rotc[i]);
            t = bc[0];
        }

        /* Chi */
        for(j = 0; j < 25; j += 5) {
            for(i = 0; i < 5; i++)
                bc[i] = s[j + i];
            for(i = 0; i < 5; i++)
                s[j + i] ^= (~bc[(i + 1) % 5]) & bc[(i + 2) % 5];
        }

        /* Iota */
        s[0] ^= keccakf_rndc[round];
    }
}

/* *************************** Public Inteface ************************ */

/* For Init or Reset call these: */
sha3_return_t
sha3_Init(void *priv, unsigned bitSize) {
    sha3_context *ctx = (sha3_context *) priv;
    if( bitSize != 256 && bitSize != 384 && bitSize != 512 )
        return SHA3_RETURN_BAD_PARAMS;
    memset(ctx, 0, sizeof(*ctx));
    ctx->capacityWords = 2 * bitSize / (8 * sizeof(uint64_t));
    return SHA3_RETURN_OK;
}

void
sha3_Init256(void *priv)
{
    sha3_Init(priv, 256);
}

void
sha3_Init384(void *priv)
{
    sha3_Init(priv, 384);
}

void
sha3_Init512(void *priv)
{
    sha3_Init(priv, 512);
}

enum SHA3_FLAGS
sha3_SetFlags(void *priv, enum SHA3_FLAGS flags)
{
    sha3_context *ctx = (sha3_context *) priv;
    flags &= SHA3_FLAGS_KECCAK;
    ctx->capacityWords |= (flags == SHA3_FLAGS_KECCAK ? SHA3_USE_KECCAK_FLAG : 0);
    return flags;
}


void
sha3_Update(void *priv, void const *bufIn, size_t len)
{
    sha3_context *ctx = (sha3_context *) priv;

    /* 0...7 -- how much is needed to have a word */
    unsigned old_tail = (8 - ctx->byteIndex) & 7;

    size_t words;
    unsigned tail;
    size_t i;

    const uint8_t *buf = bufIn;

    SHA3_TRACE_BUF("called to update with:", buf, len);

    SHA3_ASSERT(ctx->byteIndex < 8);
    SHA3_ASSERT(ctx->wordIndex < sizeof(ctx->u.s) / sizeof(ctx->u.s[0]));

    if(len < old_tail) {        /* have no complete word or haven't started 
                                 * the word yet */
        SHA3_TRACE("because %d<%d, store it and return", (unsigned)len,
                (unsigned)old_tail);
        /* endian-independent code follows: */
        while (len--)
            ctx->saved |= (uint64_t) (*(buf++)) << ((ctx->byteIndex++) * 8);
        SHA3_ASSERT(ctx->byteIndex < 8);
        return;
    }

    if(old_tail) {              /* will have one word to process */
        SHA3_TRACE("completing one word with %d bytes", (unsigned)old_tail);
        /* endian-independent code follows: */
        len -= old_tail;
        while (old_tail--)
            ctx->saved |= (uint64_t) (*(buf++)) << ((ctx->byteIndex++) * 8);

        /* now ready to add saved to the sponge */
        ctx->u.s[ctx->wordIndex] ^= ctx->saved;
        SHA3_ASSERT(ctx->byteIndex == 8);
        ctx->byteIndex = 0;
        ctx->saved = 0;
        if(++ctx->wordIndex ==
                (SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(ctx->capacityWords))) {
            keccakf(ctx->u.s);
            ctx->wordIndex = 0;
        }
    }

    /* now work in full words directly from input */

    SHA3_ASSERT(ctx->byteIndex == 0);

    words = len / sizeof(uint64_t);
    tail = len - words * sizeof(uint64_t);

    SHA3_TRACE("have %d full words to process", (unsigned)words);

    for(i = 0; i < words; i++, buf += sizeof(uint64_t)) {
        const uint64_t t = (uint64_t) (buf[0]) |
                ((uint64_t) (buf[1]) << 8 * 1) |
                ((uint64_t) (buf[2]) << 8 * 2) |
                ((uint64_t) (buf[3]) << 8 * 3) |
                ((uint64_t) (buf[4]) << 8 * 4) |
                ((uint64_t) (buf[5]) << 8 * 5) |
                ((uint64_t) (buf[6]) << 8 * 6) |
                ((uint64_t) (buf[7]) << 8 * 7);
#if defined(__x86_64__ ) || defined(__i386__)
        SHA3_ASSERT(memcmp(&t, buf, 8) == 0);
#endif
        ctx->u.s[ctx->wordIndex] ^= t;
        if(++ctx->wordIndex ==
                (SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(ctx->capacityWords))) {
            keccakf(ctx->u.s);
            ctx->wordIndex = 0;
        }
    }

    SHA3_TRACE("have %d bytes left to process, save them", (unsigned)tail);

    /* finally, save the partial word */
    SHA3_ASSERT(ctx->byteIndex == 0 && tail < 8);
    while (tail--) {
        SHA3_TRACE("Store byte %02x '%c'", *buf, *buf);
        ctx->saved |= (uint64_t) (*(buf++)) << ((ctx->byteIndex++) * 8);
    }
    SHA3_ASSERT(ctx->byteIndex < 8);
    SHA3_TRACE("Have saved=0x%016" PRIx64 " at the end", ctx->saved);
}

/* This is simply the 'update' with the padding block.
 * The padding block is 0x01 || 0x00* || 0x80. First 0x01 and last 0x80 
 * bytes are always present, but they can be the same byte.
 */
void const *
sha3_Finalize(void *priv)
{
    sha3_context *ctx = (sha3_context *) priv;

    SHA3_TRACE("called with %d bytes in the buffer", ctx->byteIndex);

    /* Append 2-bit suffix 01, per SHA-3 spec. Instead of 1 for padding we
     * use 1<<2 below. The 0x02 below corresponds to the suffix 01.
     * Overall, we feed 0, then 1, and finally 1 to start padding. Without
     * M || 01, we would simply use 1 to start padding. */

    uint64_t t;

    if( ctx->capacityWords & SHA3_USE_KECCAK_FLAG ) {
        /* Keccak version */
        t = (uint64_t)(((uint64_t) 1) << (ctx->byteIndex * 8));
    }
    else {
        /* SHA3 version */
        t = (uint64_t)(((uint64_t)(0x02 | (1 << 2))) << ((ctx->byteIndex) * 8));
    }

    ctx->u.s[ctx->wordIndex] ^= ctx->saved ^ t;

    ctx->u.s[SHA3_KECCAK_SPONGE_WORDS - SHA3_CW(ctx->capacityWords) - 1] ^=
            SHA3_CONST(0x8000000000000000UL);
    keccakf(ctx->u.s);

    /* Return first bytes of the ctx->s. This conversion is not needed for
     * little-endian platforms e.g. wrap with #if !defined(__BYTE_ORDER__)
     * || !defined(__ORDER_LITTLE_ENDIAN__) || __BYTE_ORDER__!=__ORDER_LITTLE_ENDIAN__ 
     *    ... the conversion below ...
     * #endif */
    {
        unsigned i;
        for(i = 0; i < SHA3_KECCAK_SPONGE_WORDS; i++) {
            const unsigned t1 = (uint32_t) ctx->u.s[i];
            const unsigned t2 = (uint32_t) ((ctx->u.s[i] >> 16) >> 16);
            ctx->u.sb[i * 8 + 0] = (uint8_t) (t1);
            ctx->u.sb[i * 8 + 1] = (uint8_t) (t1 >> 8);
            ctx->u.sb[i * 8 + 2] = (uint8_t) (t1 >> 16);
            ctx->u.sb[i * 8 + 3] = (uint8_t) (t1 >> 24);
            ctx->u.sb[i * 8 + 4] = (uint8_t) (t2);
            ctx->u.sb[i * 8 + 5] = (uint8_t) (t2 >> 8);
            ctx->u.sb[i * 8 + 6] = (uint8_t) (t2 >> 16);
            ctx->u.sb[i * 8 + 7] = (uint8_t) (t2 >> 24);
        }
    }

    SHA3_TRACE_BUF("Hash: (first 32 bytes)", ctx->u.sb, 256 / 8);

    return (ctx->u.sb);
}

sha3_return_t sha3_HashBuffer( unsigned bitSize, enum SHA3_FLAGS flags, const void *in, unsigned inBytes, void *out, unsigned outBytes ) {
    sha3_return_t err;
    sha3_context c;

    err = sha3_Init(&c, bitSize);
    if( err != SHA3_RETURN_OK )
        return err;
    if( sha3_SetFlags(&c, flags) != flags ) {
        return SHA3_RETURN_BAD_PARAMS;
    }
    sha3_Update(&c, in, inBytes);
    const void *h = sha3_Finalize(&c);

    if(outBytes > bitSize/8)
        outBytes = bitSize/8;
    memcpy(out, h, outBytes);
    return SHA3_RETURN_OK;
}

//=========================================================================

static void byte_to_hex(uint8_t b, char s[3])
{
    unsigned i = 1;
    s[0] = s[1] = '0';
    s[2] = '\0';
    while(b) {
        unsigned t = b & 0x0f;
        if( t < 10 ) {
            s[i] = '0' + t;
        } else {
            s[i] = 'a' + t - 10;
        }
        i--;
        b >>= 4;
    }
}

void sha3_512_ByteToHex(char out[SHA3_512_DIGEST_HEX_STR_SIZE], const uint8_t in[SHA3_512_DIGEST_SIZE])
{
    int i;
    for (i = 0; i < SHA3_512_DIGEST_SIZE; i++) {
        byte_to_hex(in[i], out + i * 2);
    }
}


================================================
FILE: src/sha3.h
================================================
#ifndef SHA3_H
#define SHA3_H

#include <stdint.h>

/* -------------------------------------------------------------------------
 * Works when compiled for either 32-bit or 64-bit targets, optimized for 
 * 64 bit.
 *
 * Canonical implementation of Init/Update/Finalize for SHA-3 byte input. 
 *
 * SHA3-256, SHA3-384, SHA-512 are implemented. SHA-224 can easily be added.
 *
 * Based on code from http://keccak.noekeon.org/ .
 *
 * I place the code that I wrote into public domain, free to use. 
 *
 * I would appreciate if you give credits to this work if you used it to 
 * write or test * your code.
 *
 * Aug 2015. Andrey Jivsov. crypto@brainhub.org
 * ---------------------------------------------------------------------- */

/* 'Words' here refers to uint64_t */
#define SHA3_KECCAK_SPONGE_WORDS \
	(((1600)/8/*bits to byte*/)/sizeof(uint64_t))
typedef struct sha3_context_ {
    uint64_t saved;             /* the portion of the input message that we
                                 * didn't consume yet */
    union {                     /* Keccak's state */
        uint64_t s[SHA3_KECCAK_SPONGE_WORDS];
        uint8_t sb[SHA3_KECCAK_SPONGE_WORDS * 8];
    } u;
    unsigned byteIndex;         /* 0..7--the next byte after the set one
                                 * (starts from 0; 0--none are buffered) */
    unsigned wordIndex;         /* 0..24--the next word to integrate input
                                 * (starts from 0) */
    unsigned capacityWords;     /* the double size of the hash output in
                                 * words (e.g. 16 for Keccak 512) */
} sha3_context;

enum SHA3_FLAGS {
    SHA3_FLAGS_NONE=0,
    SHA3_FLAGS_KECCAK=1
};

enum SHA3_RETURN {
    SHA3_RETURN_OK=0,
    SHA3_RETURN_BAD_PARAMS=1
};
typedef enum SHA3_RETURN sha3_return_t;

/* For Init or Reset call these: */
sha3_return_t sha3_Init(void *priv, unsigned bitSize);

void sha3_Init256(void *priv);
void sha3_Init384(void *priv);
void sha3_Init512(void *priv);

enum SHA3_FLAGS sha3_SetFlags(void *priv, enum SHA3_FLAGS);

void sha3_Update(void *priv, void const *bufIn, size_t len);

void const *sha3_Finalize(void *priv);

/* Single-call hashing */
sha3_return_t sha3_HashBuffer( 
    unsigned bitSize,   /* 256, 384, 512 */
    enum SHA3_FLAGS flags, /* SHA3_FLAGS_NONE or SHA3_FLAGS_KECCAK */
    const void *in, unsigned inBytes, 
    void *out, unsigned outBytes );     /* up to bitSize/8; truncation OK */

//=========================================================================

#define SHA3_512_DIGEST_SIZE (512 / 8)
#define SHA3_512_DIGEST_HEX_STR_SIZE (SHA3_512_DIGEST_SIZE * 2 + 1)

void sha3_512_ByteToHex(char out[SHA3_512_DIGEST_HEX_STR_SIZE], const uint8_t in[SHA3_512_DIGEST_SIZE]);

#endif


================================================
FILE: src/skin.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: skin.c,v 1.24 2007-10-04 15:52:04 dkure Exp $
*/

#include "quakedef.h"
#include "gl_model.h"
#include "teamplay.h"
#include "image.h"
#include "qtv.h"
#include "utils.h"
#include "tr_types.h"
#include "r_texture.h"
#include "rulesets.h"

extern cvar_t gl_playermip;
extern cvar_t gl_nocolors;

typedef struct player_skin_s {
	texture_ref base;       // The standard skin.
	texture_ref fb;         // Fullbright - for PCX textures only?
	texture_ref dead;       // Skin to use for corpses (if null, use base instead)

	qbool owned[3];
} player_skin_t;

static player_skin_t playerskins[MAX_CLIENTS];
static qbool skins_need_preache = true;

static byte* Skin_Cache(skin_t *skin, qbool no_baseskin);
static void Skin_Blend(byte* original, skin_t* skin, int skin_number);

void OnChangeSkinForcing(cvar_t *var, char *string, qbool *cancel);

cvar_t	noskins = { "noskins", "0", CVAR_RELOAD_GFX };

cvar_t  enemyforceskins     = {"enemyforceskins", "0", 0, OnChangeSkinForcing};
cvar_t  teamforceskins      = {"teamforceskins", "0", 0, OnChangeSkinForcing};

static cvar_t  baseskin = { "baseskin", "base", CVAR_RELOAD_GFX };
static cvar_t  cl_name_as_skin     = {"cl_name_as_skin", "0", 0, OnChangeSkinForcing};
cvar_t  r_enemyskincolor    = {"r_enemyskincolor", "", CVAR_COLOR, OnChangeSkinForcing};
cvar_t  r_teamskincolor     = {"r_teamskincolor",  "", CVAR_COLOR, OnChangeSkinForcing};
static cvar_t  r_skincolormode     = {"r_skincolormode",  "0", 0, OnChangeSkinForcing};
static cvar_t  r_skincolormodedead = {"r_skincolormodedead", "-1", 0, OnChangeSkinForcing};
cvar_t  r_fullbrightSkins = { "r_fullbrightSkins", "1", 0, Rulesets_OnChange_r_fullbrightSkins };

char	allskins[MAX_OSPATH];

#define	MAX_CACHED_SKINS	128
static skin_t	skins[MAX_CACHED_SKINS];

static int numskins;

// return type of skin forcing if it's allowed for the player in the POV
static int Skin_ForcingType(const char *team)
{
	if (teamforceskins.integer && TP_ThisPOV_IsHisTeam(team)) {
		return teamforceskins.integer;	// allow for teammates
	}

	if (enemyforceskins.integer && !TP_ThisPOV_IsHisTeam(team)) {
		if (cls.demoplayback || cl.spectator) { // allow for demos
			return enemyforceskins.integer;
		}
		else {  // for gameplay respect the FPD
			if (!(cl.fpd & FPD_NO_FORCE_SKIN) && !(cl.fpd & FPD_NO_FORCE_COLOR)) {
				return enemyforceskins.integer;
			}
			else {
				return 0;
			}
		}
	}

	// this was always only for demos
	if (cl_name_as_skin.integer && (cls.demoplayback || cl.spectator)) {
		return cl_name_as_skin.integer;
	}

	return 0;
}

// get player skin as player name or player id
static char* Skin_AsNameOrId(player_info_t *sc)
{
	static char name[MAX_OSPATH];
	int pn;
	char* mask;

	switch (Skin_ForcingType(sc->team)) {
	case 1: // get skin as player name
		Util_ToValidFileName(sc->name, name, sizeof(name));
		Q_strlwr(name);
		return name;
		break;

	case 2: // get skin as id
		snprintf(name, sizeof(name), "%d", sc->userid);
		return name;
		break;

	case 3: // get player's number (first teammate gets 1, second 2, ...)
		pn = TP_PlayersNumber(sc->userid, sc->team);
		if (pn) {
			mask = TP_ThisPOV_IsHisTeam(sc->team) ? "t%d" : "e%d";
			snprintf(name, sizeof(name), mask, pn);
			return name;
		}
		break;
	}

	return NULL;
}

static char* Skin_FindName(player_info_t* sc, qbool* is_teammate)
{
	static char name[MAX_OSPATH];

	if (is_teammate) {
		*is_teammate = false;
	}
	if (allskins[0]) {
		strlcpy(name, allskins, sizeof(name));
	}
	else {
		char *s = Skin_AsNameOrId(sc);

		if (!s || !s[0]) {
			s = Info_ValueForKey(sc->userinfo, "skin");
		}

		if (s && s[0]) {
			strlcpy(name, s, sizeof(name));
		}
		else {
			strlcpy(name, baseskin.string, sizeof(name));
		}
	}

	skinforcing_team = TP_SkinForcingTeam();

	if (!cl.teamfortress && !(cl.fpd & FPD_NO_FORCE_SKIN)) {
		char *skinname = NULL;
		player_state_t *state;
		qbool teammate = (cl.teamplay && !strcmp(sc->team, skinforcing_team));
		if (is_teammate) {
			*is_teammate = teammate;
		}

		if (!cl.validsequence) {
			goto nopowerups;
		}

		state = cl.frames[cl.parsecount & UPDATE_MASK].playerstate + (sc - cl.players);

		if (state->messagenum != cl.parsecount) {
			goto nopowerups;
		}

		if ((state->effects & (EF_BLUE | EF_RED)) == (EF_BLUE | EF_RED)) {
			skinname = teammate ? cl_teambothskin.string : cl_enemybothskin.string;
		}
		else if (state->effects & EF_BLUE) {
			skinname = teammate ? cl_teamquadskin.string : cl_enemyquadskin.string;
		}
		else if (state->effects & EF_RED) {
			skinname = teammate ? cl_teampentskin.string : cl_enemypentskin.string;
		}

	nopowerups:
		if (!skinname || !skinname[0]) {
			skinname = teammate ? cl_teamskin.string : cl_enemyskin.string;
		}
		if (skinname[0]) {
			strlcpy(name, skinname, sizeof(name));
		}
	}

	if (strstr(name, "..") || *name == '.') {
		strlcpy(name, baseskin.string, sizeof(name));
	}

	return name;
}

//Determines the best skin for the given scoreboard slot, and sets scoreboard->skin
static void Skin_Find_Ex(player_info_t *sc, char *skin_name)
{
	skin_t *skin;
	int i;
	char name[MAX_OSPATH];

	if (!skin_name || !skin_name[0]) {
		skin_name = baseskin.string;

		if (!skin_name[0]) {
			skin_name = "base";
		}
	}

	strlcpy(name, skin_name, sizeof(name));
	COM_StripExtension(name, name, sizeof(name));

	for (i = 0; i < numskins; i++) {
		if (!strcmp(name, skins[i].name)) {
			if (sc) {
				sc->skin = &skins[i];
			}

			return;
		}
	}

	if (numskins == MAX_CACHED_SKINS) {
		// ran out of spots, so flush everything
		Com_Printf("MAX_CACHED_SKINS reached, flushing skins\n");
		Skin_Skins_f(); // this must set numskins to 0
	}

	skin = &skins[numskins];
	if (sc) {
		sc->skin = skin;
	}
	numskins++;

	memset(skin, 0, sizeof(*skin));
	strlcpy(skin->name, name, sizeof(skin->name));
}

static void Skin_Find(player_info_t *sc)
{
	Skin_Find_Ex(sc, Skin_FindName(sc, NULL));
}

static byte* Skin_PixelsLoad(char *name, int *max_w, int *max_h, int *bpp, int *real_width, int *real_height)
{
	byte *pic;

	*max_w = *max_h = *bpp = 0;

	// PCX skins loads different, so using TEX_NO_PCX
	if (gl_no24bit.integer == 0 && (pic = R_LoadImagePixels(name, 0, 0, TEX_NO_PCX, real_width, real_height))) {
		// No limit in gl.
		*max_w = *real_width;
		*max_h = *real_height;
		*bpp = 4; // 32 bit.

		return pic;
	}

	if ((pic = Image_LoadPCX(NULL, name, 0, 0, real_width, real_height))) {
		// PCX is limited.
		*max_w = 320;
		*max_h = 200;
		*bpp = 1; // 8 bit

		return pic;
	}

	return NULL;
}

// "HACK"
// Called before rendering scene, chance to load textures again if skin
//   rules have changed
void Skins_PreCache(void)
{
	int i;
	byte *tex;

	if (!skins_need_preache) {
		// no need, we have all skins we need
		return;
	}

	skins_need_preache = false;

	// this must register skins with such names in skins[] array
	Skin_Find_Ex(NULL, cl_teamskin.string);
	Skin_Find_Ex(NULL, cl_enemyskin.string);
	Skin_Find_Ex(NULL, cl_teamquadskin.string);
	Skin_Find_Ex(NULL, cl_enemyquadskin.string);
	Skin_Find_Ex(NULL, cl_teampentskin.string);
	Skin_Find_Ex(NULL, cl_enemypentskin.string);
	Skin_Find_Ex(NULL, cl_teambothskin.string);
	Skin_Find_Ex(NULL, cl_enemybothskin.string);
	Skin_Find_Ex(NULL, baseskin.string);
	Skin_Find_Ex(NULL, "base");

	// now load all 24 bit skins in skins[] array
	for (i = 0; i < numskins; i++) {
		tex = Skin_Cache(&skins[i], false); // this precache skin file in mem

		if (!tex) {
			continue; // nothing more we can do
		}

		if (skins[i].bpp != 4) {
			// we interested in 24 bit skins only
			continue;
		}

		if (R_TextureReferenceIsValid(skins[i].texnum[skin_base])) {
			// seems skin alredy loaded, at least we have some texture
			continue;
		}

		Skin_Blend(tex, &skins[i], i);

		Com_DPrintf("skin precache: %s, texnum %d\n", skins[i].name, skins[i].texnum[skin_base]);
	}
}

// Returns a pointer to the skin bitmap, or NULL to use the default
static byte* Skin_Cache(skin_t *skin, qbool no_baseskin)
{
	int y, max_w, max_h, bpp, real_width = -1, real_height = -1;
	byte *pic = NULL, *out, *pix;
	char name[MAX_OSPATH];

	// JACK: So NOSKINS > 1 will show skins, but not download new ones.
	if (noskins.integer == 1) {
		return NULL;
	}

	if (skin->failedload) {
		return NULL;
	}

	if (skin->cached_data) {
		return skin->cached_data;
	}

	// not cached, load from HDD
	snprintf(name, sizeof(name), "skins/%s.pcx", skin->name);
	if (!(pic = Skin_PixelsLoad(name, &max_w, &max_h, &bpp, &real_width, &real_height)) || real_width > max_w || real_height > max_h) {
		Q_free(pic);

		if (no_baseskin) {
			skin->warned = true;
			return NULL; // well, we not set skin->failedload = true, that how I need it here
		}
		else if (!skin->warned && strcmp(skin->name, "base")) {
			Com_Printf("&cf22Couldn't load skin:&r %s\n", name);
		}

		skin->warned = true;
	}

	if (!pic) {
		// Attempt load at least default/base.
		snprintf(name, sizeof(name), "skins/%s.pcx", baseskin.string);

		if (!(pic = Skin_PixelsLoad(name, &max_w, &max_h, &bpp, &real_width, &real_height)) || real_width > max_w || real_height > max_h) {
			Q_free(pic);
			skin->failedload = true;
			return NULL;
		}
	}

	if (!(out = pix = skin->cached_data = (byte *)Q_malloc_named(max_w * max_h * bpp, skin->name))) {
		Sys_Error("Skin_Cache: couldn't allocate");
	}

	memset(out, 0, max_w * max_h * bpp);
	for (y = 0; y < real_height; y++, pix += (max_w * bpp)) {
		memcpy(pix, pic + y * real_width * bpp, real_width * bpp);
	}

	Q_free(pic);
	skin->bpp = bpp;
	skin->width = real_width;
	skin->height = real_height;

	// Comments about not requiring cache for 24-bit skins removed...
	//   now each player gets their own copy
	skin->failedload = false;

	return out;
}

void Skin_NextDownload(void)
{
	player_info_t *sc;
	int i;

	if (cls.downloadnumber == 0)
		if (!com_serveractive || developer.value)
			Com_DPrintf("Checking skins...\n");

	cls.downloadtype = dl_skin;

	for (; cls.downloadnumber >= 0 && cls.downloadnumber < MAX_CLIENTS; cls.downloadnumber++) {
		sc = &cl.players[cls.downloadnumber];
		if (!sc->name[0]) {
			continue;
		}

		Skin_Find(sc);

		if (noskins.integer) {
			continue;
		}

		if (Skin_Cache(sc->skin, true)) {
			continue; // we have it in cache, that mean we somehow able load this skin
		}

		if (!CL_CheckOrDownloadFile(va("skins/%s.pcx", sc->skin->name))) {
			return;   // started a download
		}
	}

	cls.downloadtype = dl_none;

	// now load them in for real
	for (i = 0; i < MAX_CLIENTS; i++) {
		sc = &cl.players[i];
		if (!sc->name[0]) {
			continue;
		}

		if (!sc->skin) {
			Skin_Find(sc);
		}

		Skin_Cache(sc->skin, false);
		sc->skin = NULL; // this way triggered skin loading, as i understand in R_TranslatePlayerSkin()
	}

	if (cls.state == ca_onserver /* && cbuf_current != &cbuf_main */) {	//only download when connecting
		MSG_WriteByte(&cls.netchan.message, clc_stringcmd);
		MSG_WriteString(&cls.netchan.message, va("begin %i", cl.servercount));
	}
}

void Skin_Clear(qbool download)
{
	int i;

	for (i = 0; i < numskins; i++) {
		Q_free(skins[i].cached_data);
	}
	numskins = 0;

	skins_need_preache = true; // we need precache it ASAP

	if (download) {
		cls.downloadnumber = 0;
		cls.downloadtype = dl_skin;
		Skin_NextDownload();

		if (cls.mvdplayback == QTV_PLAYBACK && cbuf_current != &cbuf_main) {
			cls.qtv_donotbuffer = false;
		}
	}
}

//Refind all skins, downloading if needed.
void Skin_Skins_f(void)
{
	Skin_Clear(true);
}

//Sets all skins to one specific one
void Skin_AllSkins_f(void)
{
	if (Cmd_Argc() == 1) {
		Com_Printf("allskins set to \"%s\"\n", allskins);
		return;
	}
	if (Cmd_Argc() != 2) {
		Com_Printf("Usage: %s [skin]\n", Cmd_Argv(0));
		return;
	}
	strlcpy(allskins, Cmd_Argv(1), sizeof(allskins));
	Skin_Skins_f();
}

//Just show skins which ezquake assign to each player, that depends on alot of variables and different conditions,
//so may be useful for checking settings
void Skin_ShowSkins_f(void)
{
	int i, count, maxlen;

	maxlen = sizeof("name") - 1;

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0] && !cl.players[i].spectator) {
			// get len of longest name, but no more than 17
			maxlen = bound(maxlen, strlen(cl.players[i].name), 17);
		}
	}

	for (i = count = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0] && !cl.players[i].spectator) {
			if (!count) {
				Com_Printf("\x02%-*.*s %s\n", maxlen, maxlen, "name", "skin");
			}

			Com_Printf("%-*.*s %s\n", maxlen, maxlen, cl.players[i].name, Skin_FindName(&cl.players[i], NULL));

			count++;
		}
	}
}

static texture_ref Skin_ApplyRGBColor(byte* original, int width, int height, byte* specific, byte* color, int mode, const char* texture_name)
{
	int x, y;
	float fColor[3];

	if (color) {
		VectorScale(color, 1 / 255.0f, fColor);
	}
	else {
		VectorSet(fColor, 1, 1, 1);
	}
	memcpy(specific, original, width * height * 4);
	for (x = 0; x < width; ++x) {
		for (y = 0; y < height; ++y) {
			byte* src = &original[(x + y * width) * 4];
			byte* dst = &specific[(x + y * width) * 4];

			switch (mode) {
				case 0:
					// Solid colour
					if (color) {
						VectorCopy(color, dst);
					}
					break;
				case 1: // GL_REPLACE, no action
				case 3: // GL_DECAL... should be affected by alpha but it's RGB, so it's the same (?)
					break;
				case 2: // GL_BLEND
					dst[0] = fColor[0] * (255 - src[0]);
					dst[1] = fColor[1] * (255 - src[1]);
					dst[2] = fColor[2] * (255 - src[2]);
					break;
				case 4: // GL_ADD
					if (color) {
						dst[0] = min(255, src[0] + color[0]);
						dst[1] = min(255, src[1] + color[1]);
						dst[2] = min(255, src[2] + color[2]);
					}
					break;
				default: // GL_MODULATE
					dst[0] = fColor[0] * src[0];
					dst[1] = fColor[1] * src[1];
					dst[2] = fColor[2] * src[2];
					break;
			}
		}
	}

	return R_LoadTexture(texture_name, width, height, specific, TEX_MIPMAP | TEX_NOSCALE, 4);
}

static void Skin_Blend(byte* original, skin_t* skin, int skin_number)
{
	const char* types[skin_textures] = { "$skin-base", "$skin-base-tm", "$skin-fb", "$skin-dead", "$skin-dead-tm" };
	qbool teammates[skin_textures] = { false, true, false, false, true };
	int i;
	byte* specific;
	char texture_name[128];
	qbool block_adjustments = (cl.teamfortress || (cl.fpd & (FPD_NO_FORCE_SKIN | FPD_NO_FORCE_COLOR)));

	// FIXME: Delete old, don't leave lying around.  Watch out for solidtexture references
	memset(skin->texnum, 0, sizeof(skin->texnum));

	// If config says no color adjustments, load as normal skin
	block_adjustments |= (!r_teamskincolor.string[0] && !r_enemyskincolor.string[0]) || (r_skincolormodedead.integer <= 0 && r_skincolormode.integer == 0);
	if (block_adjustments) {
		snprintf(texture_name, sizeof(texture_name), "%s-%02d", types[skin_base], skin_number);
		skin->texnum[skin_base] = R_LoadTexture(texture_name, skin->width, skin->height, original, TEX_MIPMAP | TEX_NOSCALE, 4);
		return;
	}

	specific = Q_malloc(skin->width * skin->height * 4);
	for (i = 0; i < skin_textures; ++i) {
		cvar_t* color = teammates[i] ? &r_teamskincolor : &r_enemyskincolor;
		int mode = (i == skin_dead || i == skin_dead_teammate) && r_skincolormodedead.integer >= 0 ? r_skincolormodedead.integer : r_skincolormode.integer;

		snprintf(texture_name, sizeof(texture_name), "%s-%02d", types[i], skin_number);
		if (!color->string[0]) {
			// If no color adjustment required then we only need one version
			if (i == skin_base) {
				// Load normal texture
				skin->texnum[skin_base] = R_LoadTexture(texture_name, skin->width, skin->height, original, TEX_MIPMAP | TEX_NOSCALE, 4);
			}
			continue;
		}

		// Modify the original as per mapping to OpenGL functions
		skin->texnum[i] = Skin_ApplyRGBColor(original, skin->width, skin->height, specific, color->color, mode, texture_name);
	}
	Q_free(specific);
}

static void Skin_RemoveSkinsForPlayer(int playernum)
{
	if (playerskins[playernum].owned[0]) {
		R_DeleteTexture(&playerskins[playernum].base);
	}
	if (playerskins[playernum].owned[1]) {
		R_DeleteTexture(&playerskins[playernum].fb);
	}
	if (playerskins[playernum].owned[2]) {
		R_DeleteTexture(&playerskins[playernum].dead);
	}
	R_TextureReferenceInvalidate(playerskins[playernum].base);
	R_TextureReferenceInvalidate(playerskins[playernum].fb);
	R_TextureReferenceInvalidate(playerskins[playernum].dead);
	memset(playerskins[playernum].owned, 0, sizeof(playerskins[playernum].owned));
}

static void R_BlendPlayerSkin(skin_t* skin, qbool teammate, int playernum, byte* original, int width, int height, qbool fullbright)
{
	cvar_t* color = teammate ? &r_teamskincolor : &r_enemyskincolor;
	byte* specific = Q_malloc(width * height * 4);
	texture_ref blended;
	char texture_name[128];

	snprintf(texture_name, sizeof(texture_name), "$player-skin-%d", playernum);
	blended = Skin_ApplyRGBColor(original, width, height, specific, color->string[0] ? color->color : NULL, r_skincolormode.integer, texture_name);
	if (fullbright) {
		playerskins[playernum].fb = blended;
		playerskins[playernum].owned[1] = true;
	}
	else {
		playerskins[playernum].base = blended;
		playerskins[playernum].owned[0] = true;

		if (r_skincolormodedead.integer >= 0 && r_skincolormodedead.integer != r_skincolormode.integer) {
			strlcat(texture_name, "-dead", sizeof(texture_name));
			playerskins[playernum].dead = Skin_ApplyRGBColor(original, width, height, specific, color->color, r_skincolormodedead.integer, texture_name);
			playerskins[playernum].owned[2] = true;
		}
	}
	Q_free(specific);
}

//Translates a skin texture by the per-player color lookup
void R_TranslatePlayerSkin(int playernum)
{
	byte translate[256], *inrow, *original;
	char s[512];
	int	top, bottom, i, j, scaled_width, scaled_height, inwidth, inheight, tinwidth, tinheight;
	unsigned translate32[256], *out, frac, fracstep;
	unsigned pixels[512 * 256];
	extern byte player_8bit_texels[256 * 256];
	extern cvar_t gl_scaleModelTextures;
	player_info_t *player;
	qbool teammate = false;

	player = &cl.players[playernum];
	if (!player->name[0]) {
		return;
	}

	strlcpy(s, Skin_FindName(player, &teammate), sizeof(s));
	COM_StripExtension(s, s, sizeof(s));

	if (player->skin && strcasecmp(s, player->skin->name)) {
		player->skin = NULL;
	}

	if (player->_topcolor == player->topcolor && player->_bottomcolor == player->bottomcolor && player->skin && player->teammate == player->_teammate) {
		return;
	}

	player->_topcolor = player->topcolor;
	player->_bottomcolor = player->bottomcolor;
	player->_teammate = player->teammate;

	if (!player->skin) {
		Skin_Find(player);
	}

	Skin_RemoveSkinsForPlayer(playernum);

	if (R_TextureReferenceIsValid(player->skin->texnum[skin_base]) && player->skin->bpp == 4 && !(r_enemyskincolor.string[0] || r_teamskincolor.string[0])) {
		// do not even bother call Skin_Cache(), we have texture num already
		if (teammate && R_TextureReferenceIsValid(player->skin->texnum[skin_base_teammate])) {
			playerskins[playernum].base = player->skin->texnum[skin_base_teammate];
		}
		else {
			playerskins[playernum].base = player->skin->texnum[skin_base];
		}

		if (teammate && R_TextureReferenceIsValid(player->skin->texnum[skin_dead_teammate])) {
			playerskins[playernum].dead = player->skin->texnum[skin_dead_teammate];
		}
		else {
			playerskins[playernum].dead = player->skin->texnum[skin_dead];
		}
		if (!R_TextureReferenceIsValid(playerskins[playernum].dead)) {
			playerskins[playernum].dead = playerskins[playernum].base;
		}
		return;
	}

	if ((original = Skin_Cache(player->skin, false)) != NULL) {
		switch (player->skin->bpp) {
		case 4:
			// 32 bit skin
			R_BlendPlayerSkin(player->skin, teammate, playernum, original, player->skin->width, player->skin->height, false);
			return;

		case 1:
			break;

		default:
			Sys_Error("R_TranslatePlayerSkin: wrong bpp %d", player->skin->bpp);
		}

		//skin data width
		inwidth = 320;
		inheight = 200;
	}
	else {
		original = player_8bit_texels;
		inwidth = 296;
		inheight = 194;
	}

	// locate the original skin pixels
	// real model width
	tinwidth = 296;
	tinheight = 194;

	top = bound(0, player->topcolor, 13) * 16;
	bottom = bound(0, player->bottomcolor, 13) * 16;

	for (i = 0; i < 256; i++) {
		translate[i] = i;
	}

	for (i = 0; i < 16; i++) {
		// the artists made some backwards ranges.  sigh.
		translate[TOP_RANGE + i] = (top < 128) ? (top + i) : (top + 15 - i);
		translate[BOTTOM_RANGE + i] = (bottom < 128) ? (bottom + i) : (bottom + 15 - i);
	}

	scaled_width = gl_scaleModelTextures.value ? min(gl_max_size.value, tinwidth) : min(glConfig.gl_max_size_default, tinwidth);
	scaled_height = gl_scaleModelTextures.value ? min(gl_max_size.value, tinheight) : min(glConfig.gl_max_size_default, tinheight);

	// allow users to crunch sizes down even more if they want
	scaled_width >>= (int)gl_playermip.value;
	scaled_height >>= (int)gl_playermip.value;
	if (scaled_width < 1) {
		scaled_width = 1;
	}
	if (scaled_height < 1) {
		scaled_height = 1;
	}

	for (i = 0; i < 256; i++) {
		translate32[i] = d_8to24table[translate[i]];
	}

	out = pixels;
	memset(pixels, 0, sizeof(pixels));
	fracstep = tinwidth * 0x10000 / scaled_width;
	for (i = 0; i < scaled_height; i++, out += scaled_width) {
		inrow = original + inwidth*(i * tinheight / scaled_height);
		frac = fracstep >> 1;
		for (j = 0; j < scaled_width; j += 4) {
			out[j] = translate32[inrow[frac >> 16]];
			frac += fracstep;
			out[j + 1] = translate32[inrow[frac >> 16]];
			frac += fracstep;
			out[j + 2] = translate32[inrow[frac >> 16]];
			frac += fracstep;
			out[j + 3] = translate32[inrow[frac >> 16]];
			frac += fracstep;
		}
	}

	R_BlendPlayerSkin(player->skin, teammate, playernum, (byte*)pixels, scaled_width, scaled_height, false);

	// TODO: Dead skins

	if (Img_HasFullbrights((byte *)original, inwidth * inheight)) {
		out = pixels;
		memset(pixels, 0, sizeof(pixels));
		fracstep = tinwidth * 0x10000 / scaled_width;

		// make all non-fullbright colors transparent
		for (i = 0; i < scaled_height; i++, out += scaled_width) {
			inrow = original + inwidth * (i * tinheight / scaled_height);
			frac = fracstep >> 1;
			for (j = 0; j < scaled_width; j += 4) {
				if (inrow[frac >> 16] < 224) {
					out[j] = translate32[inrow[frac >> 16]] & LittleLong(0x00FFFFFF); // transparent
				}
				else {
					out[j] = translate32[inrow[frac >> 16]]; // fullbright
				}
				frac += fracstep;
				if (inrow[frac >> 16] < 224) {
					out[j + 1] = translate32[inrow[frac >> 16]] & LittleLong(0x00FFFFFF);
				}
				else {
					out[j + 1] = translate32[inrow[frac >> 16]];
				}
				frac += fracstep;
				if (inrow[frac >> 16] < 224) {
					out[j + 2] = translate32[inrow[frac >> 16]] & LittleLong(0x00FFFFFF);
				}
				else {
					out[j + 2] = translate32[inrow[frac >> 16]];
				}
				frac += fracstep;
				if (inrow[frac >> 16] < 224) {
					out[j + 3] = translate32[inrow[frac >> 16]] & LittleLong(0x00FFFFFF);
				}
				else {
					out[j + 3] = translate32[inrow[frac >> 16]];
				}
				frac += fracstep;
			}
		}

		R_BlendPlayerSkin(player->skin, teammate, playernum, (byte*)pixels, scaled_width, scaled_height, true);
	}
}

void R_SetSkinForPlayerEntity(entity_t* ent, texture_ref* texture, texture_ref* fb_texture, byte** color32bit)
{
	qbool is_player_model = (ent->model->modhint == MOD_PLAYER || ent->renderfx & RF_PLAYERMODEL);
	int playernum = ent->scoreboard - cl.players;

	if (!gl_nocolors.integer) {
		// we can't dynamically colormap textures, so they are cached separately for the players.  Heads are just uncolored.
		if (!ent->scoreboard->skin) {
			CL_NewTranslation(playernum);
		}

		*fb_texture = playerskins[playernum].fb;
		if (ISDEAD(ent->frame) && r_skincolormodedead.integer != -1 && r_skincolormodedead.integer != r_skincolormode.integer) {
			if (r_skincolormodedead.integer && R_TextureReferenceIsValid(playerskins[playernum].dead)) {
				*texture = playerskins[playernum].dead;
			}
		}
		else {
			*texture = playerskins[playernum].base;
		}

		if (is_player_model && R_TextureReferenceEqual(*texture, solidwhite_texture)) {
			qbool custom_skins_blocked = cl.teamfortress || (cl.fpd & (FPD_NO_FORCE_SKIN | FPD_NO_FORCE_COLOR));
			if (!custom_skins_blocked) {
				cvar_t* cv = &r_enemyskincolor;
				if (cl.teamplay && !strcmp(cl.players[playernum].team, TP_SkinForcingTeam())) {
					cv = &r_teamskincolor;
				}
				if (cv->string[0]) {
					*color32bit = cv->color;
				}
			}
		}
	}
}

void Skin_InvalidateTextures(void)
{
	memset(playerskins, 0, sizeof(playerskins));
}

void Skin_RegisterCvars(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SKIN);
	Cvar_Register(&noskins);
	Cvar_Register(&baseskin);
	Cvar_Register(&cl_name_as_skin);
	Cvar_Register(&enemyforceskins);
	Cvar_Register(&teamforceskins);
	Cvar_Register(&r_fullbrightSkins);
	Cvar_Register(&r_enemyskincolor);
	Cvar_Register(&r_teamskincolor);
	Cvar_Register(&r_skincolormode);
	Cvar_Register(&r_skincolormodedead);
}

// Called when connected to server and skin-forcing rules have changed
void Skin_Refresh(void)
{
	int oldskins = noskins.integer;
	int oldflags = noskins.flags;

	noskins.flags &= ~(CVAR_RELOAD_GFX);
	Cvar_SetValue(&noskins, 2);

	con_suppress = true;
	Skin_Skins_f();
	con_suppress = false;

	Cvar_SetValue(&noskins, oldskins);
	noskins.flags = oldflags;
}

void Skin_UserInfoChange(int slot, player_info_t* player, const char* key)
{
	qbool update_skin;
	int mynum;

	if (!cl.spectator || (mynum = Cam_TrackNum()) == -1) {
		mynum = cl.playernum;
	}

	update_skin = !key || (!player->spectator && (!strcmp(key, "skin") || !strcmp(key, "topcolor") ||
		!strcmp(key, "bottomcolor") || !strcmp(key, "team") ||
		(!strcmp(key, "name") && cl_name_as_skin.value)));

	if (slot == mynum && TP_NeedRefreshSkins() && strcmp(player->team, player->_team)) {
		TP_RefreshSkins();
	}
	else if (update_skin) {
		TP_RefreshSkin(slot);
	}
}

void OnChangeSkinForcing(cvar_t *var, char *string, qbool *cancel)
{
	extern cvar_t cl_name_as_skin, enemyforceskins;

	if (cl.teamfortress || (cl.fpd & FPD_NO_FORCE_SKIN)) {
		return;
	}

	if (var == &cl_name_as_skin && (!cls.demoplayback && !cl.spectator)) {
		return; // allow in demos or for specs
	}

	if (var == &enemyforceskins && (!cl.spectator && cls.state != ca_disconnected)) {
		if (!cl.standby && !cl.countdown) {
			Con_Printf("%s cannot be changed during match\n", var->name);
			return;
		}

		if (Q_atoi(string)) {
			Cbuf_AddText("say Individual enemy skins: enabled\n");
		}
		else if (strcmp(var->string, string)) {
			Cbuf_AddText("say Individual enemy skins: disabled\n");
		}
	}

	if (cls.state == ca_active) {
		Cvar_Set(var, string);

		Skin_Refresh();
		*cancel = true;
		return;
	}
}


================================================
FILE: src/snd_main.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: snd_dma.c,v 1.48 2007-09-26 21:51:34 tonik Exp $
*/
// snd_dma.c -- main control for any streaming sound output device

#include <SDL.h>
#include "quakedef.h"
#include "qsound.h"
#include "utils.h"
#include "rulesets.h"
#include "fmod.h"
#define SELF_SOUND_ENTITY 0xFFEFFFFF // [EZH] Fan told me 0xFFEFFFFF is damn cool value for it :P
#define PLAY_SOUND_ENTITY 0xFFEFFFFE // /play or /playvol command, take distance & direction into account

#include "movie.h" // /demo_capture

extern qbool ActiveApp, Minimized;
extern cvar_t sys_inactivesound;

static void OnChange_s_khz (cvar_t *var, char *string, qbool *cancel);
static void OnChange_s_desiredsamples (cvar_t *var, char *string, qbool *cancel);
static void S_Play_f (void);
static void S_MuteSound_f (void);
static void S_SoundList_f (void);
static void S_Update_ (void);
static void S_StopSoundScript_f(void);
static void S_StopAllSounds_f (void);
static void S_Register_LatchCvars(void);
void S_Voip_RegisterCvars (void);

// =======================================================================
// Internal sound data & structures
// =======================================================================

channel_t	channels[MAX_CHANNELS] = { {0} };
unsigned int	total_channels;

qbool		snd_initialized = false;
qbool		snd_started = false;

int		soundtime;

static vec3_t	listener_origin;
static vec3_t	listener_forward;
static vec3_t	listener_right;
static vec3_t	listener_up;
#define sound_nominal_clip_dist 1000.0

// during registration it is possible to have more sounds
// than could actually be referenced during gameplay,
// because we don't want to free anything until we are
// sure we won't need it.

#define MAX_SFX (MAX_SOUNDS*2) // 256 * 2 = 512

static sfx_t	*known_sfx;
static int	num_sfx;

static qbool	sound_spatialized = false;

static sfx_t	*ambient_sfx[NUM_AMBIENTS] = {0};

// ====================================================================
// User-setable variables
// ====================================================================


cvar_t bgmvolume = {"bgmvolume", "1"}; // CD music volume
cvar_t s_volume = {"volume", "0.7"};
cvar_t s_raw_volume = {"s_raw_volume", "1"};
cvar_t s_nosound = {"s_nosound", "0"};
cvar_t s_precache = {"s_precache", "1"};
cvar_t s_loadas8bit = {"s_loadas8bit", "0"};
cvar_t s_ambientlevel = {"s_ambientlevel", "0.3"};
cvar_t s_ambientfade = {"s_ambientfade", "100"};
cvar_t s_show = {"s_show", "0"};
cvar_t s_swapstereo = {"s_swapstereo", "0"};
cvar_t s_linearresample = {"s_linearresample", "0", CVAR_LATCH_SOUND };
cvar_t s_linearresample_stream = {"s_linearresample_stream", "0"};
cvar_t s_khz = {"s_khz", "11", CVAR_NONE, OnChange_s_khz}; // If > 11, default sounds are noticeably different.
cvar_t s_desiredsamples = {"s_desiredsamples", "0", CVAR_AUTO, OnChange_s_desiredsamples };
cvar_t s_audiodevice = {"s_audiodevice", "0", CVAR_LATCH_SOUND };
cvar_t s_silent_racing = { "s_silent_racing", "0" };

SDL_mutex *smutex;
soundhw_t *shw;
static SDL_AudioDeviceID audiodevid;

static void S_ListDrivers(void)
{
	int i = 0, numdrivers;

	numdrivers = SDL_GetNumAudioDrivers();

	Com_Printf("Audio driver support compiled into SDL:\n");
	for (; i < numdrivers; i++) {
		Com_Printf("%s\n", SDL_GetAudioDriver(i));
	}
}

static void S_ListAudioDevicesInternal(qbool capture)
{
	int i = 0, numdevices;

	numdevices = SDL_GetNumAudioDevices(capture); /* arg is iscapture */
	for (; i < numdevices; i++) {
		Com_Printf(" %2d  %s\n", i+1, SDL_GetAudioDeviceName(i, 0));
	}
}

static void S_ListAudioDevices(void)
{
	Com_Printf("Playback devices:\n");
	Com_Printf(" id  device name\n-------------------------\n");
	Com_Printf("  0  system default\n");
	S_ListAudioDevicesInternal (false);

	Com_Printf("\nInput devices:\n");
	Com_Printf(" id  device name\n-------------------------\n");
	Com_Printf("  0  system default\n");
	S_ListAudioDevicesInternal (true);
}

static void S_LockMixer(void)
{
	SDL_LockMutex(smutex);
}

static void S_UnlockMixer(void)
{
	SDL_UnlockMutex(smutex);
}

static void S_SoundInfo_f (void)
{
	if (!shw) {
		Com_Printf ("sound system not started\n");
		return;
	}
	Com_Printf("%5d speakers\n", shw->numchannels);
	Com_Printf("%5d samples\n", shw->samples);
	Com_Printf("%5d samplepos\n", shw->samplepos);
	Com_Printf("%5d samplebits\n", shw->samplebits);
	Com_Printf("%5d kHz\n", shw->khz);
	Com_Printf("%5u total_channels\n", total_channels);
}

static void S_SDL_callback(void *userdata, Uint8 *stream, int len)
{
	// Mixer is run in main thread when capturing, play silence instead
	if (Movie_IsCapturing()) {
		SDL_memset(stream, 0, len);
		return;
	}

	S_LockMixer();
	shw->buffer = stream;
	shw->samples = len / shw->numchannels;
	S_Update_();
	shw->snd_sent += len;
	S_UnlockMixer();

	// Implicit Minimized in first case
	if ((sys_inactivesound.integer == 0 && !ActiveApp) || (sys_inactivesound.integer == 2 && Minimized) || cls.demoseeking) {
		SDL_memset(stream, 0, len);
	}
}

static void S_SDL_Shutdown(void)
{
	Con_Printf("Shutting down SDL audio.\n");

	SDL_CloseAudioDevice(audiodevid);
	audiodevid = 0;

	if (SDL_WasInit(SDL_INIT_AUDIO) != 0)
		SDL_QuitSubSystem(SDL_INIT_AUDIO);

	if (smutex) {
		SDL_DestroyMutex(smutex);
		smutex = NULL;
	}

	if (shw != NULL) {
		Q_free(shw);
		shw = NULL;
	}
}

static qbool S_SDL_Init(void)
{
	SDL_AudioSpec desired, obtained;
	soundhw_t *shw_tmp = NULL;
	int ret = 0;
	const char *requested_device = NULL;

	if (SDL_WasInit(SDL_INIT_AUDIO) == 0)
		ret = SDL_InitSubSystem(SDL_INIT_AUDIO);

	if (ret == -1) {
		Con_Printf("Couldn't initialize SDL audio: %s\n", SDL_GetError());
		return false;
	}

	if (!smutex) {
		smutex = SDL_CreateMutex();
	}

	memset(&desired, 0, sizeof(desired));
	switch (s_khz.integer) {
		case 48:
			desired.freq = 48000;
			desired.samples = 512;
			break;
		case 44:
			desired.freq = 44100;
			desired.samples = 512;
			break;
		case 22:
			desired.freq = 22050;
			desired.samples = 256;
			break;
		default:
			desired.freq = 11025;
			desired.samples = 128;
			break;
	}

	desired.format = AUDIO_S16LSB;
	desired.channels = 2;
	if (s_desiredsamples.integer) {
		int desired_samples = 1;

		// make sure it's a power of 2
		while (desired_samples < s_desiredsamples.integer)
			desired_samples <<= 1;

		desired.samples = desired_samples;
	}
	desired.callback = S_SDL_callback;

	/* Make audiodevice list start from index 1 so that 0 can be system default */
	if (s_audiodevice.integer > 0) {
		requested_device = SDL_GetAudioDeviceName(s_audiodevice.integer - 1, 0);
	}

	if ((audiodevid = SDL_OpenAudioDevice(requested_device, 0, &desired, &obtained, 0)) <= 0) {
		Com_Printf("sound: couldn't open SDL audio: %s\n", SDL_GetError());
		if (requested_device != NULL) {
			Com_Printf("sound: retrying with default audio device\n");
			if ((audiodevid = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0)) <= 0) {
				Com_Printf("sound: failure again, aborting...\n");
				return false;
			}
			Cvar_LatchedSet(&s_audiodevice, "0");
		}
		return false;
	}

	if (obtained.format != AUDIO_S16LSB) {
		Com_Printf("SDL audio format %d unsupported.\n", obtained.format);
		goto fail;
	}

	if (obtained.channels != 1 && obtained.channels != 2) {
		Com_Printf("SDL audio channels %d unsupported.\n", obtained.channels);
		goto fail;
	}

	shw_tmp = Q_calloc(1, sizeof(*shw));
	if (!shw_tmp) {
		Com_Printf("Failed to alloc memory for sound structure\n");
		goto fail;
	}

	shw_tmp->khz = obtained.freq;
	shw_tmp->numchannels = obtained.channels;
	shw_tmp->samplebits = obtained.format & 0xFF;
	shw_tmp->samples = 65536;

	Cvar_AutoSetInt(&s_desiredsamples, obtained.samples);

	shw = shw_tmp;

	Com_Printf("Using SDL audio driver: %s @ %d Hz\n", SDL_GetCurrentAudioDriver(), obtained.freq);

	SDL_PauseAudioDevice(audiodevid, 0);

	return true;

fail:
	S_SDL_Shutdown();
	return false;
}

static void S_FModCheckExtraSounds(void)
{
	char *soundlist[] = {
		"sound/misc/menu1.wav",
		"sound/misc/menu2.wav",
		"sound/misc/menu3.wav",
		"sound/misc/basekey.wav",
		"sound/misc/talk.wav",
		"sound/doors/runeuse.wav",
	};
	byte *data;
	int filesize;
	int i;

	for (i = 0; i < (sizeof(soundlist)/sizeof(*soundlist)); i++) {
		if (!(data = FS_LoadTempFile(soundlist[i], &filesize))) {
			Com_Printf("Couldn't load file, ignoring FMod check for '%s'\n", soundlist[i]);
			continue;
		}

		FMod_CheckModel(soundlist[i], data, filesize);
	}
}

static qbool S_Startup (void)
{
	if (!snd_initialized)
		return false;

	S_Register_LatchCvars();

	if (known_sfx == NULL) {
		known_sfx = Q_malloc(MAX_SFX * sizeof(sfx_t));
	}
	num_sfx = 0;

	if (!S_SDL_Init()) {
		Com_Printf ("S_Startup: S_Init failed.\n");
		snd_started = false;
		sound_spatialized = false;
		return false;
	}

	snd_started = true;

	ambient_sfx[AMBIENT_WATER] = S_PrecacheSound("ambience/water1.wav");
	ambient_sfx[AMBIENT_SKY] = S_PrecacheSound("ambience/wind2.wav");

	/* Make sure all extra sounds are processed through FMod checks */
	S_FModCheckExtraSounds();

	S_StopAllSounds();

	return true;
}

void S_Shutdown (void)
{
	if (!shw)
		return;

	/* FIXME: this one free's sfx->buf's in channels array, is that correct ?? */
	S_StopAllSounds();
#ifdef FTE_PEXT2_VOICECHAT
	S_Capture_Shutdown();
#endif
	S_SDL_Shutdown();

	if (known_sfx != NULL) {
		int i;
		for (i = 0; i < num_sfx; i++) {
			if (known_sfx[i].buf != NULL) {
				Q_free(known_sfx[i].buf);
			}
		}
	}
	Q_free(known_sfx);
	num_sfx = 0;

	snd_started = false;
	sound_spatialized = false;
}

static void S_Restart_f (void)
{
	int i;

	Com_DPrintf("Restarting sound system....\n");
	S_Shutdown();
	S_Startup();

	CL_InitTEnts();
	for (i=1; i < MAX_SOUNDS; i++) {

		if (!cl.sound_name[i][0])
			break;
		cl.sound_precache[i] = S_PrecacheSound(cl.sound_name[i]);
	}

}

static void OnChange_s_khz (cvar_t *var, char *string, qbool *cancel) {
	if (shw && shw->khz / 1000 != Q_atoi(string)) {
		Cbuf_AddText("s_restart\n");
	}
}

static void OnChange_s_desiredsamples (cvar_t *var, char *string, qbool *cancel) {
	if (atoi (string) != var->integer) {
		Cbuf_AddText("s_restart\n");
	}
}

static void S_Register_RegularCvarsAndCommands(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SOUND);
	Cvar_Register(&bgmvolume);
	Cvar_Register(&s_volume);
	Cvar_Register(&s_raw_volume);
	Cvar_Register(&s_nosound);
	Cvar_Register(&s_precache);
	Cvar_Register(&s_loadas8bit);
	Cvar_Register(&s_khz);
	Cvar_Register(&s_ambientlevel);
	Cvar_Register(&s_ambientfade);
	Cvar_Register(&s_show);
	Cvar_Register(&s_swapstereo);
	Cvar_Register(&s_linearresample_stream);
	Cvar_Register(&s_desiredsamples);
	Cvar_Register(&s_silent_racing);

	Cvar_ResetCurrentGroup();

	// compatibility with old configs
	Cmd_AddLegacyCommand("snd_restart", "s_restart"); // and snd_restart a legacy command

	Cmd_AddCommand("s_restart", S_Restart_f); // dimman: made s_restart the actual command
	Cmd_AddCommand("mutesound", S_MuteSound_f);
	Cmd_AddCommand("play", S_Play_f);
	Cmd_AddCommand("playvol", S_Play_f);
	Cmd_AddCommand("stopsound", S_StopAllSounds_f);
	Cmd_AddCommand("stopsound_script", S_StopSoundScript_f);
	Cmd_AddCommand("soundlist", S_SoundList_f);
	Cmd_AddCommand("soundinfo", S_SoundInfo_f);
	Cmd_AddCommand("s_listdrivers", S_ListDrivers);

	/* Naming it like this to be seen together with s_audiodevice cvar */
	Cmd_AddCommand("s_audiodevicelist", S_ListAudioDevices);

#ifdef FTE_PEXT2_VOICECHAT
	S_Voip_RegisterCvars ();
#endif
}

static void S_Register_LatchCvars(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SOUND);

	Cvar_Register(&s_linearresample);
	Cvar_Register(&s_audiodevice);

	Cvar_ResetCurrentGroup();
}

void S_Init (void)
{
	Com_DPrintf("\n[sound] Initialization\n");
	if (snd_initialized) { //whoops
		Com_Printf_State (PRINT_INFO, "[sound] Sound is already initialized!\n");
		return;
	}
	if (COM_CheckParm(cmdline_param_client_nosound)) {
		Cmd_AddLegacyCommand ("play", ""); // just suppress warnings
		return;
	}	
	if (host_memsize < 0x800000) {
		Cvar_Set (&s_loadas8bit, "1");
		Com_Printf ("[sound] Not enough memory. Loading all sounds as 8bit\n");
	}

	S_Register_RegularCvarsAndCommands();
	S_Register_LatchCvars();
	SND_InitScaletable ();

	known_sfx = Q_malloc(MAX_SFX * sizeof(sfx_t));
	num_sfx = 0;

	snd_initialized = true;

	S_Startup();
}

// =======================================================================
// Load a sound
// =======================================================================

static sfx_t *S_FindName (char *name)
{
	int i;
	sfx_t *sfx;

	if (!snd_initialized || !snd_started)
		return NULL;

	if (!name)
		Sys_Error ("S_FindName: NULL");

	if (strlen(name) >= MAX_QPATH) {
		Com_Printf ("S_FindName: sound name too long (%s)\n", name);
		return NULL;
	}

	// see if already loaded
	for (i = 0; i < num_sfx; i++) {
		if (!strcmp(known_sfx[i].name, name))
			return &known_sfx[i];
	}

	if (num_sfx == MAX_SFX)
		Sys_Error ("S_FindName: out of sfx_t");

	sfx = &known_sfx[i];
	strlcpy (sfx->name, name, sizeof (sfx->name));

	num_sfx++;

	return sfx;
}

sfx_t *S_PrecacheSound (char *name)
{
	sfx_t *sfx;
	if (!snd_initialized || !snd_started || s_nosound.value)
		return NULL;

	if (name == NULL || name[0] == 0)
		return NULL;

	sfx = S_FindName (name);
	if (sfx == NULL)
		return NULL;

	// cache it in
	if (s_precache.value)
		S_LoadSound (sfx);

	return sfx;
}

//=============================================================================

// picks a channel based on priorities, empty slots, number of channels
static channel_t *SND_PickChannel (int entnum, int entchannel)
{
	int ch_idx, first_to_die, life_left;

	// Check for replacement sound, or find the best one to replace
	first_to_die = -1;
	life_left = 0x7fffffff;
	for (ch_idx = NUM_AMBIENTS; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS; ch_idx++) {
		if (entchannel != 0		// channel 0 never overrides
		        && channels[ch_idx].entnum == entnum
		        && (channels[ch_idx].entchannel == entchannel || entchannel == -1) ) {
			// always override sound from same entity
			first_to_die = ch_idx;
			break;
		}

		// don't let monster sounds override player sounds
		if (channels[ch_idx].entnum == cl.playernum+1 && entnum != cl.playernum+1 && channels[ch_idx].sfx)
			continue;

		if (channels[ch_idx].end - shw->paintedtime < life_left) {
			life_left = channels[ch_idx].end - shw->paintedtime;
			first_to_die = ch_idx;
		}
	}

	if (first_to_die == -1)
		return NULL;

	if (channels[first_to_die].sfx)
		channels[first_to_die].sfx = NULL;

	return &channels[first_to_die];
}

// spatializes a channel
static void SND_Spatialize (channel_t *ch)
{
	vec_t dot, dist, lscale, rscale, scale;
	vec3_t source_vec;

	// anything coming from the view entity will always be full volume
	if ((ch->entnum == cl.playernum + 1) || (ch->entnum == SELF_SOUND_ENTITY)) {
		ch->leftvol = ch->master_vol;
		ch->rightvol = ch->master_vol;
		return;
	}

	// calculate stereo seperation and distance attenuation
	VectorSubtract(ch->origin, listener_origin, source_vec);

	dist = VectorNormalize(source_vec) * ch->dist_mult;
	dot = DotProduct(listener_right, source_vec);

	if (shw->numchannels == 1) {
		rscale = 1.0;
		lscale = 1.0;
	} else {
		rscale = 1.0 + dot;
		lscale = 1.0 - dot;
	}

	// add in distance effect
	scale = (1.0 - dist) * rscale;
	ch->rightvol = (int) (ch->master_vol * scale);
	if (ch->rightvol < 0)
		ch->rightvol = 0;

	scale = (1.0 - dist) * lscale;
	ch->leftvol = (int) (ch->master_vol * scale);
	if (ch->leftvol < 0)
		ch->leftvol = 0;
}

// =======================================================================
// Start a sound effect
// =======================================================================

void S_StartSound (int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float fvol, float attenuation)
{
	channel_t *target_chan, *check;
	sfxcache_t *sc;
	int ch_idx, skip;

	if (!shw || !sfx || s_nosound.value)
		return;

	S_LockMixer();

	// pick a channel to play on
	target_chan = SND_PickChannel(entnum, entchannel);
	if (!target_chan) {
		S_UnlockMixer();
		return;
	}

	// spatialize
	memset (target_chan, 0, sizeof(*target_chan));
	VectorCopy(origin, target_chan->origin);
	target_chan->dist_mult = attenuation / sound_nominal_clip_dist;
	target_chan->master_vol = (int) (fvol * 255);
	target_chan->entnum = entnum;
	target_chan->entchannel = entchannel;
	SND_Spatialize(target_chan);

	if (!target_chan->leftvol && !target_chan->rightvol) {
		S_UnlockMixer();
		return; // not audible at all
	}

	// new channel
	sc = S_LoadSound (sfx);
	if (!sc) {
		target_chan->sfx = NULL;
		S_UnlockMixer();
		return; // couldn't load the sound's data
	}

	target_chan->sfx = sfx;
	target_chan->pos = 0.0;
	target_chan->end = shw->paintedtime + (int) sc->total_length;

	// if an identical sound has also been started this frame, offset the pos
	// a bit to keep it from just making the first one louder
	check = &channels[NUM_AMBIENTS];
	for (ch_idx=NUM_AMBIENTS; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS; ch_idx++, check++) {
		if (check == target_chan)
			continue;
		if (check->sfx == sfx && !check->pos) {
			skip = rand () % (int)(0.1 * shw->khz);
			if (skip >= target_chan->end)
				skip = target_chan->end - 1;
			target_chan->pos += skip;
			target_chan->end -= skip;
			break;
		}
	}
	S_UnlockMixer();
}

void S_StopSound (int entnum, int entchannel)
{
	unsigned int i;

	S_LockMixer();

	for (i = 0; i < MAX_DYNAMIC_CHANNELS; i++) {
		if (channels[i].entnum == entnum && channels[i].entchannel == entchannel) {
			channels[i].end = 0;
			channels[i].sfx = NULL;
			S_UnlockMixer();
			return;
		}
	}
	S_UnlockMixer();
}

static void S_StopSoundScript_f(void) {
	S_StopSound(SELF_SOUND_ENTITY, 0);
}

void S_StopAllSounds(void)
{
	if (!shw)
		return;

	total_channels = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS; // no statics

	S_LockMixer();

	memset(channels, 0, MAX_CHANNELS * sizeof(channel_t));

	shw->numwraps = shw->oldsamplepos = shw->paintedtime = shw->samplepos = shw->snd_sent = 0;

	S_UnlockMixer();
}

static void S_StopAllSounds_f(void)
{
	S_StopAllSounds();
}

void S_StaticSound (sfx_t *sfx, vec3_t origin, float vol, float attenuation)
{
	channel_t *ss;
	sfxcache_t *sc;

	if (!shw || !sfx || s_nosound.value)
		return;

	S_LockMixer();

	if (total_channels == MAX_CHANNELS) {
		Com_Printf ("total_channels == MAX_CHANNELS\n");
		S_UnlockMixer();
		return;
	}

	ss = &channels[total_channels];
	total_channels++;

	sc = S_LoadSound (sfx);
	if (!sc) {
		S_UnlockMixer();
		return;
	}

	if (sc->loopstart == -1) {
		Com_Printf ("Sound %s not looped\n", sfx->name);
		S_UnlockMixer();
		return;
	}

	ss->sfx = sfx;
	VectorCopy (origin, ss->origin);
	ss->master_vol = (int) vol;
	ss->dist_mult = (attenuation/64) / sound_nominal_clip_dist;
	ss->end = shw->paintedtime + (int) sc->total_length;

	SND_Spatialize (ss);

	S_UnlockMixer();
}

//=============================================================================

static void S_UpdateAmbientSounds (void)
{
	static double last_adjusted = 0;
	struct cleaf_s *leaf;
	int vol;
	int ambient_channel;
	channel_t *chan;
	double frametime = (last_adjusted ? cls.realtime - last_adjusted : cls.frametime);
	int adjustment = Q_rint (frametime * s_ambientfade.value);

	if (cls.state != ca_active) {
		last_adjusted = 0;
		return;
	}

	leaf = CM_PointInLeaf (listener_origin);
	if (!CM_Leafnum(leaf) || !s_ambientlevel.value) {
		for (ambient_channel = 0 ; ambient_channel< NUM_AMBIENTS ; ambient_channel++)
			channels[ambient_channel].sfx = NULL;
		last_adjusted = cls.realtime;
		return;
	}

	if (!adjustment) {
		return;
	}

	last_adjusted = cls.realtime;

	for (ambient_channel = 0 ; ambient_channel< NUM_AMBIENTS ; ambient_channel++) {
		chan = &channels[ambient_channel];
		chan->sfx = ambient_sfx[ambient_channel];

		vol = (int) (s_ambientlevel.value * CM_LeafAmbientLevel(leaf, ambient_channel));
		if (vol < 8)
			vol = 0;

		// don't adjust volume too fast
		if (chan->master_vol < vol) {
			chan->master_vol += adjustment;
			if (chan->master_vol > vol)
				chan->master_vol = vol;
		} else if (chan->master_vol > vol) {
			chan->master_vol -= adjustment;
			if (chan->master_vol < vol)
				chan->master_vol = vol;
		}

		chan->leftvol = chan->rightvol = chan->master_vol;
	}
}

//Called once each time through the main loop
void S_Update (vec3_t origin, vec3_t forward, vec3_t right, vec3_t up)
{
	unsigned int i, j, total;
	static unsigned int printed_total = 0;
	channel_t *ch, *combine;

	if (!snd_initialized || !snd_started || !shw)
		return;

	S_LockMixer();

	VectorCopy(origin, listener_origin);
	VectorCopy(forward, listener_forward);
	VectorCopy(right, listener_right);
	VectorCopy(up, listener_up);

	// update general area ambient sound sources
	S_UpdateAmbientSounds ();

	combine = NULL;

	// update spatialization for static and dynamic sounds
	ch = channels + NUM_AMBIENTS;
	for (i = NUM_AMBIENTS; i < total_channels; i++, ch++) {
		if (!ch->sfx)
			continue;
		SND_Spatialize(ch); // respatialize channel
		if (!ch->leftvol && !ch->rightvol)
			continue;

		// try to combine static sounds with a previous channel of the same
		// sound effect so we don't mix five torches every frame

		if (i >= MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS) {
			// see if it can just use the last one
			if (combine && combine->sfx == ch->sfx) {
				combine->leftvol += ch->leftvol;
				combine->rightvol += ch->rightvol;
				ch->leftvol = ch->rightvol = 0;
				continue;
			}
			// search for one
			combine = channels+MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;
			for (j = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS; j < i; j++, combine++)
				if (combine->sfx == ch->sfx)
					break;

			if (j == total_channels) {
				combine = NULL;
			} else {
				if (combine != ch) {
					combine->leftvol += ch->leftvol;
					combine->rightvol += ch->rightvol;
					ch->leftvol = ch->rightvol = 0;
				}
				continue;
			}
		}
	}

	sound_spatialized = true;

	// debugging output
	if (s_show.value) {
		total = 0;
		ch = channels;

		for (i = 0; i < total_channels; i++, ch++)
			if (ch->sfx && (ch->leftvol || ch->rightvol)) {
				if ((cl.standby || cls.demoplayback) && s_show.value == 2)
					Com_Printf ("%3i %3i %s\n", ch->leftvol, ch->rightvol, ch->sfx->name); // s_show 2
				total++;
			}

		Print_flags[Print_current] |= PR_TR_SKIP;
		
		if (total != printed_total) { // This if statement is needed so we don't get spammed by the message
			Com_Printf ("%i sound(s) playing\n", total); // s_show 1
			printed_total = total;
		}
	}

	if (Movie_IsCapturing()) {
		Movie_MixFrameSound(S_Update_);
	}

	S_UnlockMixer();
}

static void GetSoundtime(void)
{
	shw->samplepos = shw->snd_sent/2;

	if (shw->samplepos < shw->oldsamplepos) {
		shw->numwraps++; // buffer wrapped

		if (shw->paintedtime > 0x40000000) {
			// time to chop things off to avoid 32 bit limits
			shw->numwraps = 0;
			shw->paintedtime = shw->samples / shw->numchannels;
			//S_StopAllSounds (true);
		}
	}

	shw->oldsamplepos = shw->samplepos;

	soundtime = shw->numwraps * (shw->samples / shw->numchannels) + shw->samplepos / shw->numchannels;
}

static void S_Update_(void)
{
	unsigned int endtime;
	int samps;

	if (!shw) {
		return;
	}

	// Updates soundtime
	GetSoundtime();

	endtime = soundtime + shw->samples / shw->numchannels;
	soundtime = shw->paintedtime;
	samps = shw->samples / shw->numchannels;

	if (endtime - soundtime > samps) {
		endtime = soundtime + samps;
	}

	S_PaintChannels(endtime);
}

/*
===============================================================================
console functions
===============================================================================
*/

static void S_Play_f (void)
{
	char name[256];
	sfx_t *sfx;
	int i;
	qbool playvol = (strcmp(Cmd_Argv(0), "playvol") == 0);

	if (!snd_initialized || !snd_started || s_nosound.value)
		return;

	for (i = 1; i < Cmd_Argc(); ++i) {
		float vol = 1.0f;                 // Set by playvol command
		float attenuation = 0.0f;         // full volume regardless of distance
		vec3_t sound_origin;
		int entity = SELF_SOUND_ENTITY;   // ezhfan: pnum+1 changed to SELF_SOUND to make sound not to disappear

		strlcpy (name, Cmd_Argv(i), sizeof(name));
		if (Rulesets_RestrictPlay(name)) {
			Com_Printf("The use of play is not allowed during matches\n");
			continue;
		}

		VectorCopy(listener_origin, sound_origin);
		COM_DefaultExtension (name, ".wav", sizeof(name));
		sfx = S_PrecacheSound(name);
		if (playvol)
			vol = Q_atof(Cmd_Argv(++i));

		// Allow sounds to be created elsewhere on the map, to hear what spawns sound like
		if (i < Cmd_Argc () - 4 && strcmp (Cmd_Argv (i + 1), "@") == 0) {
			sound_origin[0] = Q_atof (Cmd_Argv (i + 2));
			sound_origin[1] = Q_atof (Cmd_Argv (i + 3));
			sound_origin[2] = Q_atof (Cmd_Argv (i + 4));
			i += 4;
			entity = PLAY_SOUND_ENTITY;
			attenuation = 1.0f;                 // distance should matter
		}
		S_StartSound(entity, 0, sfx, sound_origin, vol, attenuation);
	}
}

static void S_MuteSound_f(void)
{
	static float old_volume;
	static int is_muted;

	if (is_muted == 0) {
		old_volume = s_volume.value;
		Cvar_SetValue(&s_volume, 0);
		Com_Printf("%s\n", CharsToBrownStatic("Mute"));
		is_muted = 1;
	}
	else if (is_muted == 1) {
		Cvar_SetValue(&s_volume, old_volume);
		Com_Printf("%s %.2f\n", CharsToBrownStatic("Volume is now"), s_volume.value);
		is_muted = 0;
	}
}

static void S_SoundList_f (void)
{
	int i, total = 0;
	unsigned int size;
	sfx_t *sfx;
	sfxcache_t *sc;

	S_LockMixer();

	for (sfx = known_sfx, i = 0; i < num_sfx; i++, sfx++) {
		sc = (sfxcache_t *) sfx->buf;
		if (!sc)
			continue;
		size = sc->total_length * sc->format.width * (sc->format.channels);
		total += size;
		if (sc->loopstart >= 0)
			Com_Printf ("L");
		else
			Com_Printf (" ");
		Com_Printf ("(%2db) %6i : %s\n",sc->format.width*8,  size, sfx->name);
	}
	Com_Printf ("Total resident: %i\n", total);

	S_UnlockMixer();
}

void S_LocalSound (char *sound)
{
	sfx_t *sfx;

	if (!snd_initialized || !snd_started || s_nosound.value)
		return;

	if (!(sfx = S_PrecacheSound (sound))) {
		Com_Printf ("S_LocalSound: can't cache %s\n", sound);
		return;
	}

	S_StartSound (cl.playernum+1, -1, sfx, vec3_origin, 1, 0);
}

void S_LocalSoundWithVol(char *sound, float volume)
{
	sfx_t *sfx;

	clamp(volume, 0, 1.0);

	if (!snd_initialized || !snd_started || s_nosound.value)
		return;

	if (!(sfx = S_PrecacheSound (sound))) {
		Com_Printf ("S_LocalSound: can't cache %s\n", sound);
		return;
	}

	S_StartSound (cl.playernum+1, -1, sfx, vec3_origin, volume, 1);
}


//===================================================================
// Streaming audio.
// This is useful when there is one source, and the sound is to be played with no attenuation.
//===================================================================

#define MAX_RAW_CACHE (1024 * 32) // have no idea which size it actually should be.

typedef struct
{
	qbool			inuse;
	int				id;
	sfx_t			sfx;
} streaming_t;

static void S_RawClearStream(streaming_t *s);

#define MAX_RAW_SOURCES (MAX_CLIENTS+1)

streaming_t s_streamers[MAX_RAW_SOURCES] = {{0}};

void S_RawClear(void)
{
	int i;
	streaming_t *s;

	for (s = s_streamers, i = 0; i < MAX_RAW_SOURCES; i++, s++) {
		S_RawClearStream(s);
	}

	memset(s_streamers, 0, sizeof(s_streamers));
}

// Stop playing particular stream and make it free.
static void S_RawClearStream(streaming_t *s)
{
	int i;
	sfxcache_t * currentcache;

	if (!s)
		return;

	// get current cache if any.
	currentcache = s->sfx.buf;
	if (currentcache) {
		currentcache->loopstart = -1;	//stop mixing it
	}

	// remove link on sfx from the channels array.
	for (i = 0; i < total_channels; i++)
	{
		if (channels[i].sfx == &s->sfx)
		{
			channels[i].sfx = NULL;
			break;
		}
	}

	// free cache.
	//if (s->sfx.buf)
	//	Cache_Free(&s->sfx.cache);

	// clear whole struct.
	memset(s, 0, sizeof(*s));
}

// Searching for free slot or re-use previous one with the same sourceid.
static streaming_t * S_RawGetFreeStream(int sourceid)
{
	int i;
	streaming_t *s, *free = NULL;

	for (s = s_streamers, i = 0; i < MAX_RAW_SOURCES; i++, s++)
	{
		if (!s->inuse)
		{
			if (!free)
			{
				free = s;	// found free stream slot.
			}

			continue;
		}

		if (s->id == sourceid)
		{
			return s; // re-using slot.
		}
	}

	return free;
}

// Streaming audio.
// This is useful when there is one source, and the sound is to be played with no attenuation.
void S_RawAudio(int sourceid, byte *data, unsigned int speed, unsigned int samples, unsigned int channelsnum, unsigned int width)
{
	unsigned int	i;
	int				newsize;
	int				prepadl;
	int				spare;
	int				outsamples;
	int				raw_flags;
	float			raw_volume;
	double			speedfactor;
	sfxcache_t *	currentcache;
	streaming_t *	s;

	S_LockMixer();

	raw_flags = (sourceid >= 0 && sourceid <= RAW_SOURCE_QIZMO_VOICE) ? CHANNEL_FLAG_VOICE : 0;
	raw_volume = (raw_flags & CHANNEL_FLAG_VOICE) ? 1 : s_raw_volume.value;

	// search for free slot or re-use previous one with the same sourceid.
	s = S_RawGetFreeStream(sourceid);

	if (!s) {
		Com_DPrintf("No free audio streams or stream not found\n");
		S_UnlockMixer();
		return;
	}

	// empty data mean someone tell us to shut up particular slot.
	if (!data) {
		S_RawClearStream(s);
		S_UnlockMixer();
		return;
	}

	// attempting to add new stream
	if (!s->inuse) {
		sfxcache_t* newcache;

		// clear whole struct.
		memset(s, 0, sizeof(*s));
		// allocate cache.
		newsize = MAX_RAW_CACHE; //sizeof(sfxcache_t)

		if (newsize < sizeof (sfxcache_t)) {
			S_UnlockMixer ();
			Sys_Error ("MAX_RAW_CACHE too small %d", newsize);
		}

		newcache = Q_malloc(newsize);
		if (!newcache) {
			Com_DPrintf("Cache_Alloc failed\n");
			S_UnlockMixer();
			return;
		}

		s->inuse = true;
		s->id = sourceid;
		//		strcpy(s->sfx.name, ""); // FIXME: probably we should put some specific tag name here?
		s->sfx.buf = newcache;
		newcache->format.speed = shw->khz;
		newcache->format.channels = channelsnum;
		newcache->format.width = width;
		newcache->loopstart = -1;
		newcache->total_length = 0;
		newcache = NULL;
	}

	// get current cache if any.
	currentcache = (sfxcache_t *)s->sfx.buf;
	if (!currentcache) {
		Com_DPrintf("Cache_Check failed\n");
		S_RawClearStream(s);
		S_UnlockMixer();
		return;
	}

	if (   currentcache->format.speed != shw->khz
		|| currentcache->format.channels != channelsnum
		|| currentcache->format.width != width)
	{
		currentcache->format.speed = shw->khz;
		currentcache->format.channels = channelsnum;
		currentcache->format.width = width;
		//		newcache->loopstart = -1;
		currentcache->total_length = 0;
		//		Com_Printf("Restarting raw stream\n");
	}

	speedfactor	= (double)speed/shw->khz;
	outsamples = samples/speedfactor;

	prepadl = 0x7fffffff;
	// FIXME: qqshka: I have no idea that spike is doing here, really. WTF is prepadl??? PITCHSHIFT ???
	// spike: make sure that we have a prepad.
	for (i = 0; i < total_channels; i++)
	{
		if (channels[i].sfx == &s->sfx)
		{
			if (prepadl > (channels[i].pos/*>>PITCHSHIFT*/))
				prepadl = (channels[i].pos/*>>PITCHSHIFT*/);
			break;
		}
	}

	if (prepadl == 0x7fffffff)
	{
		if (s_show.integer)
			Com_Printf("Wasn't playing\n");
		prepadl = 0;
		spare = 0;
		if (spare > shw->khz)
		{
			Com_DPrintf("Sacrificed raw sound stream\n");
			spare = 0;	//too far out. sacrifice it all
		}
	}
	else
	{
		if (prepadl < 0)
			prepadl = 0;
		spare = currentcache->total_length - prepadl;
		if (spare < 0)	//remaining samples since last time
			spare = 0;

		if (spare > shw->khz * 2) { // more than 2 seconds of sound
			Com_DPrintf("Sacrificed raw sound stream\n");
			spare = 0;	//too far out. sacrifice it all
		}
	}

	newsize = sizeof(sfxcache_t) + (spare + outsamples) * currentcache->format.channels * currentcache->format.width;
	if (newsize >= MAX_RAW_CACHE)
	{
		Com_DPrintf("Cache buffer overflowed\n");
		S_RawClearStream(s);
		S_UnlockMixer();
		return;
	}
	// move along spare/remaning samples in the begging of the buffer.
	memmove(currentcache->data, 
		currentcache->data + prepadl * currentcache->format.channels * currentcache->format.width,
		spare * currentcache->format.channels * currentcache->format.width);

	currentcache->total_length = spare + outsamples;

	// resample.
	{
		extern cvar_t s_linearresample_stream;
		short *outpos = (short *)(currentcache->data + spare * currentcache->format.channels * currentcache->format.width);
		SND_ResampleStream(data,
			speed,
			width,
			channelsnum,
			samples,
			outpos,
			shw->khz,
			currentcache->format.width,
			currentcache->format.channels,
			s_linearresample_stream.integer
		);
	}

	currentcache->loopstart = -1;//currentcache->total_length;
	for (i = 0; i < total_channels; i++)
	{
		if (channels[i].sfx == &s->sfx)
		{
#if 0
			// FIXME: qqshka: hrm, should it be just like this all the time??? I think it should.
			channels[i].pos = 0;
			channels[i].end = paintedtime + currentcache->total_length;
#else
			channels[i].pos -= prepadl; // * channels[i].rate;
			channels[i].end += outsamples;
			channels[i].master_vol = (int) (raw_volume * 255); // this should changed volume on alredy playing sound.
			channels[i].flags = raw_flags;

			if (channels[i].end < shw->paintedtime)
			{
				channels[i].pos = 0;
				channels[i].end = shw->paintedtime + currentcache->total_length;
			}
#endif
			break;
		}
	}

	//this one wasn't playing, lets start it then.
	if (i == total_channels) {
		S_StartSound(SELF_SOUND_ENTITY, 0, &s->sfx, r_origin, raw_volume, 0);
		for (i = 0; i < total_channels; i++) {
			if (channels[i].sfx == &s->sfx) {
				channels[i].flags = raw_flags;
				break;
			}
		}
	}

	S_UnlockMixer();
}


================================================
FILE: src/snd_mem.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: snd_mem.c,v 1.16 2007-10-25 14:54:30 dkure Exp $
*/
// snd_mem.c -- sound caching

#include "quakedef.h"
#include "fmod.h"
#include "qsound.h"
#ifndef OLD_WAV_LOADING
#include "sndfile.h"
#endif

#define LINEARUPSCALE(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = inrate / (double)outrate; \
		infrac = floor(scale * 65536); \
		outsamps = insamps / scale; \
		inaccum = 0; \
		outnlsamps = floor(1.0 / scale); \
		outsamps -= outnlsamps; \
	\
		while (outsamps) \
		{ \
			*out = ((0xFFFF - inaccum)*in[0] + inaccum*in[1]) >> (16 - outlshift + outrshift); \
			inaccum += infrac; \
			in += (inaccum >> 16); \
			inaccum &= 0xFFFF; \
			out++; \
			outsamps--; \
		} \
		while (outnlsamps) \
		{ \
			*out = (*in >> outrshift) << outlshift; \
			out++; \
			outnlsamps--; \
		} \
	}

#define LINEARUPSCALESTEREO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = inrate / (double)outrate; \
		infrac = floor(scale * 65536); \
		outsamps = insamps / scale; \
		inaccum = 0; \
		outnlsamps = floor(1.0 / scale); \
		outsamps -= outnlsamps; \
	\
		while (outsamps) \
		{ \
			out[0] = ((0xFFFF - inaccum)*in[0] + inaccum*in[2]) >> (16 - outlshift + outrshift); \
			out[1] = ((0xFFFF - inaccum)*in[1] + inaccum*in[3]) >> (16 - outlshift + outrshift); \
			inaccum += infrac; \
			in += (inaccum >> 16) * 2; \
			inaccum &= 0xFFFF; \
			out += 2; \
			outsamps--; \
		} \
		while (outnlsamps) \
		{ \
			out[0] = (in[0] >> outrshift) << outlshift; \
			out[1] = (in[1] >> outrshift) << outlshift; \
			out += 2; \
			outnlsamps--; \
		} \
	}

#define LINEARUPSCALESTEREOTOMONO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = inrate / (double)outrate; \
		infrac = floor(scale * 65536); \
		outsamps = insamps / scale; \
		inaccum = 0; \
		outnlsamps = floor(1.0 / scale); \
		outsamps -= outnlsamps; \
	\
		while (outsamps) \
		{ \
			*out = ((((0xFFFF - inaccum)*in[0] + inaccum*in[2]) >> (16 - outlshift + outrshift)) + \
				(((0xFFFF - inaccum)*in[1] + inaccum*in[3]) >> (16 - outlshift + outrshift))) >> 1; \
			inaccum += infrac; \
			in += (inaccum >> 16) * 2; \
			inaccum &= 0xFFFF; \
			out++; \
			outsamps--; \
		} \
		while (outnlsamps) \
		{ \
			out[0] = (((in[0] >> outrshift) << outlshift) + ((in[1] >> outrshift) << outlshift)) >> 1; \
			out++; \
			outnlsamps--; \
		} \
	}

#define LINEARDOWNSCALE(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = outrate / (double)inrate; \
		infrac = floor(scale * 65536); \
		inaccum = 0; \
		insamps--; \
		outsampleft = 0; \
	\
		while (insamps) \
		{ \
			inaccum += infrac; \
			if (inaccum >> 16) \
			{ \
				inaccum &= 0xFFFF; \
				outsampleft += (infrac - inaccum) * (*in); \
				*out = outsampleft >> (16 - outlshift + outrshift); \
				out++; \
				outsampleft = inaccum * (*in); \
			} \
			else \
				outsampleft += infrac * (*in); \
			in++; \
			insamps--; \
		} \
		outsampleft += (0xFFFF - inaccum) * (*in);\
		*out = outsampleft >> (16 - outlshift + outrshift); \
	}

#define LINEARDOWNSCALESTEREO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = outrate / (double)inrate; \
		infrac = floor(scale * 65536); \
		inaccum = 0; \
		insamps--; \
		outsampleft = 0; \
		outsampright = 0; \
	\
		while (insamps) \
		{ \
			inaccum += infrac; \
			if (inaccum >> 16) \
			{ \
				inaccum &= 0xFFFF; \
				outsampleft += (infrac - inaccum) * in[0]; \
				outsampright += (infrac - inaccum) * in[1]; \
				out[0] = outsampleft >> (16 - outlshift + outrshift); \
				out[1] = outsampright >> (16 - outlshift + outrshift); \
				out += 2; \
				outsampleft = inaccum * in[0]; \
				outsampright = inaccum * in[1]; \
			} \
			else \
			{ \
				outsampleft += infrac * in[0]; \
				outsampright += infrac * in[1]; \
			} \
			in += 2; \
			insamps--; \
		} \
		outsampleft += (0xFFFF - inaccum) * in[0];\
		outsampright += (0xFFFF - inaccum) * in[1];\
		out[0] = outsampleft >> (16 - outlshift + outrshift); \
		out[1] = outsampright >> (16 - outlshift + outrshift); \
	}

#define LINEARDOWNSCALESTEREOTOMONO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = outrate / (double)inrate; \
		infrac = floor(scale * 65536); \
		inaccum = 0; \
		insamps--; \
		outsampleft = 0; \
	\
		while (insamps) \
		{ \
			inaccum += infrac; \
			if (inaccum >> 16) \
			{ \
				inaccum &= 0xFFFF; \
				outsampleft += (infrac - inaccum) * ((in[0] + in[1]) >> 1); \
				*out = outsampleft >> (16 - outlshift + outrshift); \
				out++; \
				outsampleft = inaccum * ((in[0] + in[1]) >> 1); \
			} \
			else \
				outsampleft += infrac * ((in[0] + in[1]) >> 1); \
			in += 2; \
			insamps--; \
		} \
		outsampleft += (0xFFFF - inaccum) * ((in[0] + in[1]) >> 1);\
		*out = outsampleft >> (16 - outlshift + outrshift); \
	}

#define STANDARDRESCALE(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = inrate / (double)outrate; \
		infrac = floor(scale * 65536); \
		outsamps = insamps / scale; \
		inaccum = 0; \
	\
		while (outsamps) \
		{ \
			*out = (*in >> outrshift) << outlshift; \
			inaccum += infrac; \
			in += (inaccum >> 16); \
			inaccum &= 0xFFFF; \
			out++; \
			outsamps--; \
		} \
	}

#define STANDARDRESCALESTEREO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = inrate / (double)outrate; \
		infrac = floor(scale * 65536); \
		outsamps = insamps / scale; \
		inaccum = 0; \
	\
		while (outsamps) \
		{ \
			out[0] = (in[0] >> outrshift) << outlshift; \
			out[1] = (in[1] >> outrshift) << outlshift; \
			inaccum += infrac; \
			in += (inaccum >> 16) * 2; \
			inaccum &= 0xFFFF; \
			out += 2; \
			outsamps--; \
		} \
	}

#define STANDARDRESCALESTEREOTOMONO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
	{ \
		scale = inrate / (double)outrate; \
		infrac = floor(scale * 65536); \
		outsamps = insamps / scale; \
		inaccum = 0; \
	\
		while (outsamps) \
		{ \
			out[0] = (((in[0] >> outrshift) << outlshift) + ((in[1] >> outrshift) << outlshift)) >> 1; \
			inaccum += infrac; \
			in += (inaccum >> 16) * 2; \
			inaccum &= 0xFFFF; \
			out++; \
			outsamps--; \
		} \
	}

#define QUICKCONVERT(in, insamps, out, outlshift, outrshift) \
	{ \
		while (insamps) \
		{ \
			*out = (*in >> outrshift) << outlshift; \
			out++; \
			in++; \
			insamps--; \
		} \
	}

#define QUICKCONVERTSTEREOTOMONO(in, insamps, out, outlshift, outrshift) \
	{ \
		while (insamps) \
		{ \
			*out = (((in[0] >> outrshift) << outlshift) + ((in[1] >> outrshift) << outlshift)) >> 1; \
			out++; \
			in += 2; \
			insamps--; \
		} \
	}

// SND_ResampleStream: takes a sound stream and converts with given parameters. Limited to
// 8-16-bit signed conversions and mono-to-mono/stereo-to-stereo conversions.
// Not an in-place algorithm.
void SND_ResampleStream (void *in, int inrate, int inwidth, int inchannels, int insamps, void *out, int outrate, int outwidth, int outchannels, int resampstyle)
{
	double scale;
	signed char *in8 = (signed char *)in;
	short *in16 = (short *)in;
	signed char *out8 = (signed char *)out;
	short *out16 = (short *)out;
	int outsamps, outnlsamps, outsampleft, outsampright;
	int infrac, inaccum;

	if (insamps <= 0)
		return;

	if (inchannels == outchannels && inwidth == outwidth && inrate == outrate)
	{
		memcpy(out, in, inwidth*insamps*inchannels);
		return;
	}

	if (inchannels == 1 && outchannels == 1)
	{
		if (inwidth == 1)
		{
			if (outwidth == 1)
			{
				if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALE(in8, inrate, insamps, out8, outrate, 0, 0)
					else
						STANDARDRESCALE(in8, inrate, insamps, out8, outrate, 0, 0)
				}
				else // downsample
				{
					if (resampstyle > 1)
						LINEARDOWNSCALE(in8, inrate, insamps, out8, outrate, 0, 0)
					else
						STANDARDRESCALE(in8, inrate, insamps, out8, outrate, 0, 0)
				}
				return;
			}
			else
			{
				if (inrate == outrate) // quick convert
					QUICKCONVERT(in8, insamps, out16, 8, 0)
				else if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALE(in8, inrate, insamps, out16, outrate, 8, 0)
					else
						STANDARDRESCALE(in8, inrate, insamps, out16, outrate, 8, 0)
				}
				else // downsample
				{
					if (resampstyle > 1)
						LINEARDOWNSCALE(in8, inrate, insamps, out16, outrate, 8, 0)
					else
						STANDARDRESCALE(in8, inrate, insamps, out16, outrate, 8, 0)
				}
				return;
			}
		}
		else // 16-bit
		{
			if (outwidth == 2)
			{
				if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALE(in16, inrate, insamps, out16, outrate, 0, 0)
					else
						STANDARDRESCALE(in16, inrate, insamps, out16, outrate, 0, 0)
				}
				else // downsample
				{
					if (resampstyle > 1)
						LINEARDOWNSCALE(in16, inrate, insamps, out16, outrate, 0, 0)
					else
						STANDARDRESCALE(in16, inrate, insamps, out16, outrate, 0, 0)
				}
				return;
			}
			else
			{
				if (inrate == outrate) // quick convert
					QUICKCONVERT(in16, insamps, out8, 0, 8)
				else if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALE(in16, inrate, insamps, out8, outrate, 0, 8)
					else
						STANDARDRESCALE(in16, inrate, insamps, out8, outrate, 0, 8)
				}
				else // downsample
				{
					if (resampstyle > 1)
						LINEARDOWNSCALE(in16, inrate, insamps, out8, outrate, 0, 8)
					else
						STANDARDRESCALE(in16, inrate, insamps, out8, outrate, 0, 8)
				}
				return;
			}
		}
	}
	else if (outchannels == 2 && inchannels == 2)
	{
		if (inwidth == 1)
		{
			if (outwidth == 1)
			{
				if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALESTEREO(in8, inrate, insamps, out8, outrate, 0, 0)
					else
						STANDARDRESCALESTEREO(in8, inrate, insamps, out8, outrate, 0, 0)
				}
				else // downsample
				{
					if (resampstyle > 1)
						LINEARDOWNSCALESTEREO(in8, inrate, insamps, out8, outrate, 0, 0)
					else
						STANDARDRESCALESTEREO(in8, inrate, insamps, out8, outrate, 0, 0)
				}
			}
			else
			{
				if (inrate == outrate) // quick convert
				{
					insamps *= 2;
					QUICKCONVERT(in8, insamps, out16, 8, 0)
				}
				else if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALESTEREO(in8, inrate, insamps, out16, outrate, 8, 0)
					else
						STANDARDRESCALESTEREO(in8, inrate, insamps, out16, outrate, 8, 0)
				}
				else // downsample
				{
					if (resampstyle > 1)
						LINEARDOWNSCALESTEREO(in8, inrate, insamps, out16, outrate, 8, 0)
					else
						STANDARDRESCALESTEREO(in8, inrate, insamps, out16, outrate, 8, 0)
				}
			}
		}
		else // 16-bit
		{
			if (outwidth == 2)
			{
				if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALESTEREO(in16, inrate, insamps, out16, outrate, 0, 0)
					else
						STANDARDRESCALESTEREO(in16, inrate, insamps, out16, outrate, 0, 0)
				}
				else // downsample
				{
					if (resampstyle > 1)
						LINEARDOWNSCALESTEREO(in16, inrate, insamps, out16, outrate, 0, 0)
					else
						STANDARDRESCALESTEREO(in16, inrate, insamps, out16, outrate, 0, 0)
				}
			}
			else 
			{
				if (inrate == outrate) // quick convert
				{
					insamps *= 2;
					QUICKCONVERT(in16, insamps, out8, 0, 8)
				}
				else if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALESTEREO(in16, inrate, insamps, out8, outrate, 0, 8)
					else
						STANDARDRESCALESTEREO(in16, inrate, insamps, out8, outrate, 0, 8)
				}
				else // downsample
				{
					if (resampstyle > 1)
						LINEARDOWNSCALESTEREO(in16, inrate, insamps, out8, outrate, 0, 8)
					else
						STANDARDRESCALESTEREO(in16, inrate, insamps, out8, outrate, 0, 8)
				}
			}
		}
	}
#if 0
	else if (outchannels == 1 && inchannels == 2)
	{
		if (inwidth == 1)
		{
			if (outwidth == 1)
			{
				if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALESTEREOTOMONO(in8, inrate, insamps, out8, outrate, 0, 0)
					else
						STANDARDRESCALESTEREOTOMONO(in8, inrate, insamps, out8, outrate, 0, 0)
				}
				else // downsample
					STANDARDRESCALESTEREOTOMONO(in8, inrate, insamps, out8, outrate, 0, 0)
			}
			else
			{
				if (inrate == outrate) // quick convert
					QUICKCONVERTSTEREOTOMONO(in8, insamps, out16, 8, 0)
				else if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALESTEREOTOMONO(in8, inrate, insamps, out16, outrate, 8, 0)
					else
						STANDARDRESCALESTEREOTOMONO(in8, inrate, insamps, out16, outrate, 8, 0)
				}
				else // downsample
					STANDARDRESCALESTEREOTOMONO(in8, inrate, insamps, out16, outrate, 8, 0)
			}
		}
		else // 16-bit
		{
			if (outwidth == 2)
			{
				if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALESTEREOTOMONO(in16, inrate, insamps, out16, outrate, 0, 0)
					else
						STANDARDRESCALESTEREOTOMONO(in16, inrate, insamps, out16, outrate, 0, 0)
				}
				else // downsample
					STANDARDRESCALESTEREOTOMONO(in16, inrate, insamps, out16, outrate, 0, 0)
			}
			else 
			{
				if (inrate == outrate) // quick convert
					QUICKCONVERTSTEREOTOMONO(in16, insamps, out8, 0, 8)
				else if (inrate < outrate) // upsample
				{
					if (resampstyle)
						LINEARUPSCALESTEREOTOMONO(in16, inrate, insamps, out8, outrate, 0, 8)
					else
						STANDARDRESCALESTEREOTOMONO(in16, inrate, insamps, out8, outrate, 0, 8)
				}
				else // downsample
					STANDARDRESCALESTEREOTOMONO(in16, inrate, insamps, out8, outrate, 0, 8)
			}
		}
	}
#endif
}

/*
================
ResampleSfx
================
*/
static void ResampleSfx (sfx_t *sfx, int inrate, int inchannels, int inwidth, int insamps, int inloopstart, byte *data)
{
	extern cvar_t s_linearresample;
	double scale;
	sfxcache_t	*sc;
	int len;
	int outsamps;
	int outwidth;
	int outchannels = 1; // inchannels;

	scale = shw->khz / (double)inrate;
	outsamps = insamps * scale;
	if (s_loadas8bit.integer < 0)
		outwidth = 2;
	else if (s_loadas8bit.integer)
		outwidth = 1;
	else
		outwidth = inwidth;
	len = outsamps * outwidth * outchannels;

	sc = sfx->buf = Q_malloc(len + sizeof(sfxcache_t));
	if (!sc)
	{
		return;
	}

	sc->format.channels = outchannels;
	sc->format.width = outwidth;
	sc->format.speed = shw->khz;
	sc->total_length = outsamps;
	if (inloopstart == -1)
		sc->loopstart = inloopstart;
	else
		sc->loopstart = inloopstart * scale;

	SND_ResampleStream (data, 
		inrate, 
		inwidth, 
		inchannels, 
		insamps, 
		sc->data, 
		sc->format.speed, 
		sc->format.width, 
		sc->format.channels, 
		s_linearresample.integer);
}

#ifndef OLD_WAV_LOADING

/*
===============================================================================
WAV loading
===============================================================================
*/

typedef struct sfviodata_s {
	char *path;
	int filesize;
	int position;
	unsigned char *data;
} sfviodata_t;

sf_count_t SFVIO_GetFilelen(void *user_data)
{
	sfviodata_t *sfviodata;

	sfviodata = user_data;
	return sfviodata->filesize;
}

sf_count_t SFVIO_Seek(sf_count_t offset, int whence, void *user_data)
{
	sfviodata_t *sfviodata;

	sfviodata = user_data;
	if (whence == SEEK_CUR)
	{
		sfviodata->position += offset;
	}
	else if (whence == SEEK_SET)
	{
		sfviodata->position = offset;
	}
	else if (whence == SEEK_END)
	{
		sfviodata->position = sfviodata->filesize + offset;
	}
	if (sfviodata->position > sfviodata->filesize)
	{
		sfviodata->position = sfviodata->filesize;
	}
	else if (sfviodata->position < 0)
	{
		sfviodata->position = 0;
	}
	return sfviodata->position;
}

sf_count_t SFVIO_Read(void *ptr, sf_count_t count, void *user_data)
{
	int i = 0;
	sfviodata_t *sfviodata;

	sfviodata = user_data;
	for (i = 0; i < count; ++i)
	{
		if (sfviodata->position == sfviodata->filesize)
		{
			return i;
		}
		((char *)ptr)[i] = sfviodata->data[sfviodata->position];
		sfviodata->position++;
	}
	return count;
}

sf_count_t SFVIO_Tell(void *user_data)
{
	sfviodata_t *sfviodata;

	sfviodata = user_data;
	return sfviodata->position;
}

static qbool S_ParseCueMark(const byte* chunk, int len, int cue_point_id, int* sample_length)
{
	int pos = 0;
	unsigned int size = 1;

	*sample_length = 0;
	while ((pos < (len - 8)) && (size != 0)) {
		size = BuffLittleLong(chunk + pos + 4);

		// Looking for ltxt chunk with purpose "mark"
		if (size >= 20 && !strncmp(chunk + pos, "ltxt", 4) && !strncmp(chunk + pos + 16, "mark", 4)) {
			// Might be for a different cue point
			if (cue_point_id == BuffLittleLong(chunk + pos + 8)) {
				*sample_length = BuffLittleLong(chunk + pos + 12);
				return true;
			}
		}

		pos += size;
	}

	return false;
}

static qbool S_FindCuePointSampleLength(SNDFILE* sndfile, int cue_point_id, int* sample_length)
{
	SF_CHUNK_INFO chunk_info;
	chunk_info.datalen = 0;
	strlcpy(chunk_info.id, "LIST", sizeof(chunk_info.id));
	chunk_info.id_size = 4;
	SF_CHUNK_ITERATOR* iterator = sf_get_chunk_iterator(sndfile, &chunk_info);
	byte chunk_data[1024];

	*sample_length = 0;

	while (iterator != NULL) {
		if (sf_get_chunk_size(iterator, &chunk_info) != SF_ERR_NO_ERROR) {
			break;
		}

		if (chunk_info.datalen >= 24 && chunk_info.datalen <= sizeof(chunk_data)) {
			chunk_info.data = chunk_data;

			if (sf_get_chunk_data(iterator, &chunk_info) != SF_ERR_NO_ERROR) {
				break;
			}
			else if (chunk_data[0] == 'a' && chunk_data[1] == 'd' && chunk_data[2] == 't' && chunk_data[3] == 'l') {
				if (S_ParseCueMark(chunk_data + 4, chunk_info.datalen - 4, cue_point_id, sample_length)) {
					return true;
				}
			}
		}

		iterator = sf_next_chunk_iterator(iterator);
	}

	return false;
}

sfxcache_t *S_LoadSound (sfx_t *s)
{
	char namebuffer[256];
	unsigned char *data;
	int filesize;
	SF_VIRTUAL_IO sfvio;
	SF_INFO sfinfo;
	sfviodata_t sfviodata;
	short *buf; 
	uint32_t cue_count;
	int loopstart;
	SF_CUES sfcues;
	SNDFILE *sndfile;

	// see if allocated
	if (s->buf)
		return s->buf;

	// load it in
	snprintf(namebuffer, sizeof(namebuffer), "sound/%s", s->name);

	if (!(data = FS_LoadTempFile(namebuffer, &filesize))) {
		Com_Printf ("Couldn't load %s\n", namebuffer);
		return NULL;
	}

	FMod_CheckModel(namebuffer, data, filesize);

	sfvio.get_filelen = SFVIO_GetFilelen;
	sfvio.seek = SFVIO_Seek;
	sfvio.read = SFVIO_Read;
	sfvio.tell = SFVIO_Tell;

	sfinfo.format = 0;

	sfviodata.path = namebuffer;
	sfviodata.position = 0;
	sfviodata.data = data;
	sfviodata.filesize = filesize;

	sndfile = sf_open_virtual(&sfvio, SFM_READ, &sfinfo, &sfviodata);

	buf = (short *)Q_malloc(sfinfo.frames * sfinfo.channels * sizeof(short));
	sf_readf_short(sndfile, buf, sfinfo.frames);
	cue_count = 0;
	sf_command(sndfile, SFC_GET_CUE_COUNT, &cue_count, sizeof(cue_count));
	loopstart = -1;

	if (cue_count != 0) {
		int loop_sample_count;

		sf_command(sndfile, SFC_GET_CUE, &sfcues, sizeof(sfcues)) ;

		if (S_FindCuePointSampleLength(sndfile, sfcues.cue_points[0].position, &loop_sample_count)) {
			loopstart = sfcues.cue_points[0].sample_offset;
			if (loopstart + loop_sample_count > sfinfo.frames) {
				Sys_Error("Sound %s has a bad loop length", s->name);
			}
			sfinfo.frames = loopstart + loop_sample_count;
		}
	}

	sf_close(sndfile);

	if (sfinfo.channels < 1 || sfinfo.channels > 2) {
		Com_Printf("%s has an unsupported number of channels (%i)\n", s->name, sfinfo.channels);
		Q_free(buf);
		return NULL;
	}

	ResampleSfx (s, sfinfo.samplerate, sfinfo.channels, sizeof(short), sfinfo.frames, loopstart, (byte *)buf);
	Q_free(buf);

	return s->buf;
}

#else

/*
===============================================================================
Old WAV loading
===============================================================================
*/

static unsigned char *data_p;
static unsigned char *iff_end;
static unsigned char *last_chunk;
static unsigned char *iff_data;
static int iff_chunk_len;

static short GetLittleShort(void)
{
	short val;

	val = BuffLittleShort (data_p);
	data_p += 2;

	return val;
}

static int GetLittleLong(void)
{
	int val = 0;

	val = BuffLittleLong (data_p);
	data_p += 4;

	return val;
}

static void FindNextChunk(char *name)
{
	while (1) {
		data_p=last_chunk;

		if (data_p >= iff_end) { // didn't find the chunk
			data_p = NULL;
			return;
		}

		data_p += 4;
		iff_chunk_len = GetLittleLong();
		if (iff_chunk_len < 0) {
			data_p = NULL;
			return;
		}

		data_p -= 8;
		last_chunk = data_p + 8 + ( (iff_chunk_len + 1) & ~1 );
		if (!strncmp((const char *)data_p, name, 4))
			return;
	}
}

static void FindChunk(char *name)
{
	last_chunk = iff_data;
	FindNextChunk (name);
}

static wavinfo_t GetWavinfo (char *name, unsigned char *wav, int wavlength)
{
	int samples, format, i;
	wavinfo_t info;

	memset (&info, 0, sizeof(info));

	if (!wav)
		return info;

	iff_data = wav;
	iff_end = wav + wavlength;

	// find "RIFF" chunk
	FindChunk("RIFF");
	if (!(data_p && !strncmp((const char *)(data_p+8), "WAVE", 4))) {
		Com_Printf ("Missing RIFF/WAVE chunks\n");
		return info;
	}

	// get "fmt " chunk
	iff_data = data_p + 12;
	FindChunk("fmt ");
	if (!data_p) {
		Com_Printf ("Missing fmt chunk\n");
		return info;
	}

	data_p += 8;
	format = GetLittleShort();
	if (format != 1) {
		Com_Printf ("Microsoft PCM format only\n");
		return info;
	}

	info.channels = GetLittleShort();
	info.rate = GetLittleLong();
	data_p += 4 + 2;
	info.width = GetLittleShort() / 8;

	// get cue chunk
	FindChunk("cue ");
	if (data_p) {
		data_p += 32;
		info.loopstart = GetLittleLong();

		// if the next chunk is a LIST chunk, look for a cue length marker
		FindNextChunk ("LIST");
		if (data_p) {
			// this is not a proper parse, but it works with cooledit...
			if (!strncmp ((const char *)(data_p + 28), "mark", 4)) {
				data_p += 24;
				i = GetLittleLong (); // samples in loop
				info.samples = info.loopstart + i;
			}
		}
	} else
		info.loopstart = -1;

	// find data chunk
	FindChunk("data");
	if (!data_p) {
		Com_Printf ("Missing data chunk\n");
		return info;
	}

	data_p += 4;
	samples = GetLittleLong () / info.width / info.channels;

	if (info.samples) {
		if (samples < info.samples)
			Sys_Error ("Sound %s has a bad loop length", name);
	} else
		info.samples = samples;

	info.dataofs = data_p - wav;

	return info;
}


//=============================================================================

static void COM_SwapLittleShortBlock (short *s, int size)
{
//FIXME: qqshka: I have no idea that we have to do for PDP endian.

#if defined __BIG_ENDIAN__
//	if (!bigendian)
//		return;

	if (size <= 0)
		return;

	while (size)
	{
		*s = ShortSwap(*s);
		s++;
		size--;
	}
#endif
}

static void COM_CharBias (signed char *c, int size)
{
	if (size <= 0)
		return;

	while (size)
	{
		*c = (*(unsigned char *)c) - 128;
		c++;
		size--;
	}
}

sfxcache_t *S_LoadSound (sfx_t *s)
{
	char namebuffer[256];
	unsigned char *data;
	wavinfo_t info;
	int filesize;

	// see if allocated
	if (s->buf)
		return (sfxcache_t*)s->buf;

	// load it in
	snprintf(namebuffer, sizeof(namebuffer), "sound/%s", s->name);

	if (!(data = FS_LoadTempFile(namebuffer, &filesize))) {
		Com_Printf ("Couldn't load %s\n", namebuffer);
		return NULL;
	}

	FMod_CheckModel(namebuffer, data, filesize);

	info = GetWavinfo (s->name, data, filesize);

	// Stereo sounds are allowed (intended for music)
	if (info.channels < 1 || info.channels > 2) {
		Com_Printf("%s has an unsupported number of channels (%i)\n",s->name, info.channels);
		return NULL;
	}

	if (info.dataofs + info.samples * info.channels > filesize) {
		Com_Printf("%s is corrupt/truncated, delete and re-download\n", s->name);
		return NULL;
	}

	if (info.width == 1)
		COM_CharBias((signed char*)data + info.dataofs, info.samples * info.channels);
	else if (info.width == 2)
		COM_SwapLittleShortBlock((short *)(data + info.dataofs), info.samples * info.channels);

	ResampleSfx (s, info.rate, info.channels, info.width, info.samples, info.loopstart, data + info.dataofs);

	return s->buf;
}

int SND_Rate(int rate)
{
	switch (rate)
	{
		case 48:
			return 48000;
		case 44:
			return 44100;
		case 32:
			return 32000;
		case 24:
			return 24000;
		case 22:
			return 22050;
		case 16:
			return 16000;
		case 12:
			return 12000;
		case 8:
			return 8000;
		default:
			return 11025;
	}
}

#endif


================================================
FILE: src/snd_mix.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: snd_mix.c,v 1.15 2007-03-11 06:01:42 disconn3ct Exp $

*/
// snd_mix.c -- portable code to mix sounds for snd_dma.c

#include "quakedef.h"
#include "qsound.h"
#include "movie.h" // /demo_capture


#define PAINTBUFFER_SIZE 512
typedef struct portable_samplepair_s {
	int left;
	int right;
} portable_samplepair_t;
portable_samplepair_t paintbuffer[PAINTBUFFER_SIZE];
static portable_samplepair_t voice_paintbuffer[PAINTBUFFER_SIZE];
static portable_samplepair_t *painttarget = paintbuffer;
int snd_scaletable[32][256];
int snd_vol, *snd_p;
static int *voice_snd_p;

static int snd_linear_count;
static short *snd_out;

static void Snd_WriteLinearBlastStereo16 (int* input_buffer, int* voice_input_buffer, short* output_buffer, int snd_vol, int voice_vol)
{
	int val, i;

	for (i = 0; i < snd_linear_count; i += 2) {
		val = ((input_buffer[i] * snd_vol) + (voice_input_buffer[i] * voice_vol)) >> 8;
		output_buffer[i] = bound (-32768, val, 32767);
		val = ((input_buffer[i + 1] * snd_vol) + (voice_input_buffer[i + 1] * voice_vol)) >> 8;
		output_buffer[i+1] = bound (-32768, val, 32767);
	}
}

static void Snd_WriteLinearBlastStereo16_SwapStereo (int* input_buffer, int* voice_input_buffer, short* output_buffer, int snd_vol, int voice_vol)
{
	int val, i;

	for (i = 0; i < snd_linear_count; i +=2 ) {
		val = ((input_buffer[i + 1] * snd_vol) + (voice_input_buffer[i + 1] * voice_vol)) >> 8;
		output_buffer[i] = bound (-32768, val, 32767);
		val = ((input_buffer[i] * snd_vol) + (voice_input_buffer[i] * voice_vol)) >> 8;
		output_buffer[i+1] = bound (-32768, val, 32767);
	}
}

static void S_TransferStereo16 (int endtime)
{
	int lpaintedtime, lpos, clientVolume;
	int voiceVolume;
	DWORD *pbuf;

	clientVolume = snd_vol = (s_volume.value * S_VoipVoiceTransmitVolume()) * 256;
	voiceVolume = max(0, s_raw_volume.value * 256);

	snd_p = (int *) paintbuffer;
	voice_snd_p = (int *) voice_paintbuffer;
	lpaintedtime = shw->paintedtime;

	pbuf = (DWORD *)shw->buffer;
	while (lpaintedtime < endtime) {

		// handle recirculating buffer issues
		lpos = lpaintedtime % ((shw->samples>>1));
		snd_out = (short *) pbuf + (lpos << 1);

		snd_linear_count = (shw->samples>>1) - lpos;
		if (lpaintedtime + snd_linear_count > endtime)
			snd_linear_count = endtime - lpaintedtime;

		snd_linear_count <<= 1;

		// write a linear blast of samples
		if (s_swapstereo.value)
			Snd_WriteLinearBlastStereo16_SwapStereo (snd_p, voice_snd_p, snd_out, clientVolume, voiceVolume);
		else
			Snd_WriteLinearBlastStereo16 (snd_p, voice_snd_p, snd_out, clientVolume, voiceVolume);

		if (Movie_IsCapturing()) {
			Movie_TransferSound (snd_out, snd_linear_count);
		}

		snd_p += snd_linear_count;
		voice_snd_p += snd_linear_count;
		lpaintedtime += (snd_linear_count>>1);
	}
}

static void S_TransferPaintBuffer(int endtime)
{
	DWORD *pbuf;
	int *p;
	int out_idx;
	int out_mask;
	int count;
	int step;
	int val;
	int snd_vol;
	int voice_vol;
	int *voice_p;

	if (shw->samplebits == 16 && shw->numchannels == 2) {
		S_TransferStereo16(endtime);
		return;
	}

	p = (int *) paintbuffer;
	voice_p = (int *) voice_paintbuffer;
	count = (endtime - shw->paintedtime) * shw->numchannels;
	out_mask = shw->samples - 1;
	out_idx = shw->paintedtime * shw->numchannels & out_mask;
	step = 3 - shw->numchannels;
	snd_vol = (s_volume.value * S_VoipVoiceTransmitVolume()) * 256;
	voice_vol = max(0, s_raw_volume.value * 256);

	pbuf = (DWORD *)shw->buffer;

	if (shw->samplebits == 16) {
		short *out = (short *) pbuf;
		while (count--) {
			val = ((*p * snd_vol) + (*voice_p * voice_vol)) >> 8;
			p+= step;
			voice_p += step;
			if (val > 0x7fff)
				val = 0x7fff;
			else if (val < (int)0x8000)
				val = (int)0x8000;
			out[out_idx] = val;
			out_idx = (out_idx + 1) & out_mask;
		}
	} else if (shw->samplebits == 8) {
		unsigned char *out = (unsigned char *) pbuf;
		while (count--) {
			val = ((*p * snd_vol) + (*voice_p * voice_vol)) >> 8;
			p+= step;
			voice_p += step;
			if (val > 0x7fff)
				val = 0x7fff;
			else if (val < (int)0x8000)
				val = (int)0x8000;
			out[out_idx] = (val>>8) + 128;
			out_idx = (out_idx + 1) & out_mask;
		}
	}
}


/*
===============================================================================
CHANNEL MIXING
===============================================================================
*/

static void SND_PaintChannelFrom8 (channel_t *ch, sfxcache_t *sc, int count)
{
	int data, i;
	int *lscale, *rscale;
	unsigned char *sfx;

	if (ch->leftvol > 255)
		ch->leftvol = 255;
	if (ch->rightvol > 255)
		ch->rightvol = 255;

	lscale = snd_scaletable[ch->leftvol >> 3];
	rscale = snd_scaletable[ch->rightvol >> 3];
	sfx = (unsigned char *) ((signed char *)sc->data + ch->pos);

	for (i = 0; i < count ;i++) {
		data = sfx[i];
		painttarget[i].left += lscale[data];
		painttarget[i].right += rscale[data];
	}

	ch->pos += count;
}

static void SND_PaintChannelFrom16 (channel_t *ch, sfxcache_t *sc, int count)
{
	int data, left, right, leftvol, rightvol, i;
	signed short *sfx;

	leftvol = ch->leftvol;
	rightvol = ch->rightvol;
	sfx = (signed short *)sc->data + ch->pos;

	for (i = 0; i < count ;i++) {
		data = sfx[i];
		left = (data * leftvol) >> 8;
		right = (data * rightvol) >> 8;
		painttarget[i].left += left;
		painttarget[i].right += right;
	}

	ch->pos += count;
}

void SND_InitScaletable (void)
{
	int i, j;

	for (i = 0 ; i < 32; i++)
		for (j = 0; j < 256; j++)
			snd_scaletable[i][j] = ((j < 128) ? j : j - 0xff) * i * 8;
}

void S_PaintChannels(int endtime)
{
	int ltime, count, end;
	unsigned int i;
	sfxcache_t *sc;
	channel_t *ch;
	extern cvar_t s_silent_racing;

	while (shw->paintedtime < endtime) {
		// if paintbuffer is smaller than DMA buffer
		end = endtime;
		if (endtime - shw->paintedtime > PAINTBUFFER_SIZE)
			end = shw->paintedtime + PAINTBUFFER_SIZE;

		// clear the paint buffer
		memset (paintbuffer, 0, (end - shw->paintedtime) * sizeof(portable_samplepair_t));
		memset (voice_paintbuffer, 0, (end - shw->paintedtime) * sizeof(portable_samplepair_t));

		// paint in the channels.
		ch = channels;
		for (i = 0; i < total_channels; i++, ch++) {
			if (!ch->sfx)
				continue;
			if (!ch->leftvol && !ch->rightvol)
				continue;
			if (cl.racing && s_silent_racing.integer && ch->entnum > 0 && ch->entnum <= MAX_CLIENTS) {
				if (cl.spectator) {
					if (Cam_TrackNum() < 0) {
						// silence all racers
						continue;
					}
					else if (ch->entnum - 1 != Cam_TrackNum()) {
						// not the tracked player
						continue;
					}
				}
				else if (ch->entnum - 1 != cl.playernum) {
					// a different player
					continue;
				}
			}
			sc = S_LoadSound (ch->sfx);
			if (!sc)
				continue;

			painttarget = (ch->flags & CHANNEL_FLAG_VOICE) ? voice_paintbuffer : paintbuffer;
			ltime = shw->paintedtime;

			while (ltime < end) { // paint up to end
				count = (ch->end < end) ? (ch->end - ltime) : (end - ltime);

				if (count > 0) {
					if (sc->format.width == 1)
						SND_PaintChannelFrom8(ch, sc, count);
					else
						SND_PaintChannelFrom16(ch, sc, count);

					ltime += count;
				}

				// if at end of loop, restart
				if (ltime >= ch->end) {
					if (sc->loopstart >= 0) {
						ch->pos = bound(0, sc->loopstart, (int) sc->total_length - 1);
						ch->end = ltime + (int) sc->total_length - ch->pos;
					} else { // channel just stopped
						ch->sfx = NULL;
						break;
					}
				}
			}
		}
		painttarget = paintbuffer;

		// transfer out according to DMA format
		S_TransferPaintBuffer(end);
		shw->paintedtime = end;
	}
}


================================================
FILE: src/snd_qizmo.c
================================================
/*
 * Copyright (C) 2026 Oscar Linderholm <osm@recv.se>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#include "quakedef.h"
#include "qsound.h"
#include "sndfile.h"

#define QIZMO_VOICE_GSM_BYTES	33
#define QIZMO_VOICE_RATE	8000
#define QIZMO_VOICE_PCM_SAMPLES	160

// Keep a bounded GSM segment so libsndfile decodes with prior GSM state. Each
// frame is 20 ms, at the cap, playback continues from a fresh segment.
#define QIZMO_VOICE_MAX_FRAMES	1024

// libsndfile decodes from file-like objects, so expose the accumulated GSM
// bytes as a read-only in-memory file.
typedef struct qizmo_voice_sfvio_s {
	const byte *data;
	sf_count_t size;
	sf_count_t position;
} qizmo_voice_sfvio_t;

static sf_count_t S_QizmoVoice_GetFileLen(void *user_data)
{
	qizmo_voice_sfvio_t *vio = user_data;
	return vio->size;
}

static sf_count_t S_QizmoVoice_Seek(sf_count_t offset, int whence, void *user_data)
{
	qizmo_voice_sfvio_t *vio = user_data;

	if (whence == SEEK_CUR) {
		vio->position += offset;
	}
	else if (whence == SEEK_SET) {
		vio->position = offset;
	}
	else if (whence == SEEK_END) {
		vio->position = vio->size + offset;
	}

	if (vio->position < 0) {
		vio->position = 0;
	}
	else if (vio->position > vio->size) {
		vio->position = vio->size;
	}

	return vio->position;
}

static sf_count_t S_QizmoVoice_Read(void *ptr, sf_count_t count, void *user_data)
{
	qizmo_voice_sfvio_t *vio = user_data;
	sf_count_t available = vio->size - vio->position;

	if (count > available) {
		count = available;
	}

	memcpy(ptr, vio->data + vio->position, count);
	vio->position += count;
	return count;
}

static sf_count_t S_QizmoVoice_Tell(void *user_data)
{
	qizmo_voice_sfvio_t *vio = user_data;
	return vio->position;
}

// Decode the segment from the beginning so the GSM decoder sees the prior
// frame history it needs. The caller submits only the newest decoded frame.
static sf_count_t S_QizmoVoice_DecodeSegment(const byte *gsm_segment,
	int segment_frames, short *decoded_pcm)
{
	static SF_VIRTUAL_IO sfvio = {
		S_QizmoVoice_GetFileLen,
		S_QizmoVoice_Seek,
		S_QizmoVoice_Read,
		NULL,
		S_QizmoVoice_Tell
	};
	SF_INFO sfinfo;
	qizmo_voice_sfvio_t sfviodata;
	SNDFILE *sndfile;
	sf_count_t decoded_samples;

	memset(&sfinfo, 0, sizeof(sfinfo));
	sfinfo.samplerate = QIZMO_VOICE_RATE;
	sfinfo.channels = 1;
	sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_GSM610;

	sfviodata.data = gsm_segment;
	sfviodata.size = segment_frames * QIZMO_VOICE_GSM_BYTES;
	sfviodata.position = 0;

	sndfile = sf_open_virtual(&sfvio, SFM_READ, &sfinfo, &sfviodata);
	if (!sndfile) {
		Com_DPrintf("Qizmo voice: could not open GSM frame: %s\n", sf_strerror(NULL));
		return 0;
	}

	decoded_samples = sf_readf_short(sndfile, decoded_pcm,
		segment_frames * QIZMO_VOICE_PCM_SAMPLES);
	sf_close(sndfile);
	return decoded_samples;
}

void S_QizmoVoice_PlayFrame(int sequence, int voice_id, const byte *frame_data, int bytes)
{
	static byte gsm_segment[QIZMO_VOICE_MAX_FRAMES * QIZMO_VOICE_GSM_BYTES];
	static short decoded_pcm[QIZMO_VOICE_MAX_FRAMES * QIZMO_VOICE_PCM_SAMPLES];
	static int last_sequence;
	static int last_voice_id;
	static int segment_frames;
	static qbool have_sequence;
	sf_count_t decoded_samples;
	short *latest_pcm_frame;
	byte *gsm_frame;

	if (!snd_initialized || !snd_started) {
		return;
	}

	if (bytes != QIZMO_VOICE_GSM_BYTES) {
		Com_DPrintf("Qizmo voice: unexpected GSM frame size %d\n", bytes);
		return;
	}

	// The Qizmo sequence groups packets into one voice transmission. A new
	// voice id, sequence, gap, or the bounded history limit starts a fresh GSM
	// decoder segment.
	if (sequence == 0 || !have_sequence ||
		last_voice_id != voice_id ||
		((last_sequence + 1) & 0x3ff) != sequence ||
		segment_frames >= QIZMO_VOICE_MAX_FRAMES) {
		segment_frames = 0;
	}

	gsm_frame = gsm_segment + segment_frames * QIZMO_VOICE_GSM_BYTES;
	memcpy(gsm_frame, frame_data, QIZMO_VOICE_GSM_BYTES);

	// Qizmo stores GSM frames with a different high nibble than standard raw
	// GSM 06.10. Preserve the low bits and normalize the magic nibble.
	gsm_frame[0] = (gsm_frame[0] & 0x0f) | 0xd0;

	segment_frames++;
	last_sequence = sequence;
	last_voice_id = voice_id;
	have_sequence = true;

	decoded_samples = S_QizmoVoice_DecodeSegment(gsm_segment, segment_frames, decoded_pcm);
	if (decoded_samples < QIZMO_VOICE_PCM_SAMPLES) {
		Com_DPrintf("Qizmo voice: decoded only %d PCM samples\n", (int)decoded_samples);
		return;
	}

	latest_pcm_frame = decoded_pcm + decoded_samples - QIZMO_VOICE_PCM_SAMPLES;

	S_RawAudio(RAW_SOURCE_QIZMO_VOICE,
		(byte *)latest_pcm_frame,
		QIZMO_VOICE_RATE,
		QIZMO_VOICE_PCM_SAMPLES,
		1,
		sizeof(short));
}


================================================
FILE: src/snd_voip.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// snd_voip.c -- voice over ip (mm3)
// Original code taken from ezquake 2.2, which used speex
// Now using SDL audio capture (requires SDL 2.0.5 or above)

#include <SDL.h>
#include "quakedef.h"
#include "qsound.h"

#ifdef FTE_PEXT2_VOICECHAT

#include <speex/speex.h>
#include <speex/speex_preprocess.h>

// FTEQW type and naming compatibility
// it's not really necessary, simple find & replace would do the job too
#ifdef _MSC_VER
#define VARGS __cdecl
#endif
#ifndef VARGS
#define VARGS
#endif

static void S_Voip_Play_Callback (cvar_t *var, char *string, qbool *cancel);
void CL_SendClientCommand (qbool reliable, char *format, ...);

static cvar_t s_inputdevice = { "s_inputdevice", "0" };                                // SDL device to use as microphone
static cvar_t cl_voip_send = { "cl_voip_send", "0" };                                  // Sends voice-over-ip data to the server whenever it is set.
static cvar_t cl_voip_vad_threshhold = { "cl_voip_vad_threshhold", "15" };             // This is the threshhold for voice-activation-detection when sending voip data.
static cvar_t cl_voip_vad_delay = { "cl_voip_vad_delay", "0.3" };                      // Keeps sending voice data for this many seconds after voice activation would normally stop.
static cvar_t cl_voip_capturingvol = { "cl_voip_capturingvol", "0.5" };                // Multiplier applied while capturing, to avoid your audio from being heard by others.
static cvar_t cl_voip_play = { "cl_voip_play", "1", CVAR_NONE, S_Voip_Play_Callback }; // Enables voip playback from other clients connected to server.
static cvar_t cl_voip_micamp = { "cl_voip_micamp", "2" };                              // Amplifies your microphone when using voip.
static cvar_t cl_voip_demorecord = { "cl_voip_demorecord", "1" };                      // Record VOIP in demo.
static cvar_t cl_voip_showmeter = { "cl_voip_showmeter", "1" };                        // Show speech volume above the hud.  0 = hide, 1=when transmitting, 2=even when voice-activation not triggered
static cvar_t cl_voip_showmeter_x = { "cl_voip_showmeter_x", "0" };                    // horizontal coordinate
static cvar_t cl_voip_showmeter_y = { "cl_voip_showmeter_y", "0" };                    // vertical coordinate

static float voicevolumemod = 1; // voice volume modifier.

float S_VoipVoiceTransmitVolume(void)
{
	return voicevolumemod;
}

static struct
{
	qbool inited;
	qbool loaded;

	SpeexBits encbits;
	void *encoder;
	SpeexPreprocessState *preproc;
	unsigned int framesize;
	unsigned int samplerate;

	SpeexBits decbits[MAX_CLIENTS];
	void *decoder[MAX_CLIENTS];
	unsigned char decseq[MAX_CLIENTS];	/*sender's sequence, to detect+cover minor packetloss*/
	unsigned char decgen[MAX_CLIENTS];	/*last generation. if it changes, we flush speex to reset packet loss*/
	float decamp[MAX_CLIENTS];	/*amplify them by this*/
	float lastspoke[MAX_CLIENTS];	/*time when they're no longer considered talking. if future, they're talking*/

	unsigned char capturebuf[32768]; /*pending data*/
	unsigned int capturepos;/*amount of pending data*/
	unsigned int encsequence;/*the outgoing sequence count*/
	unsigned int generation;/*incremented whenever capture is restarted*/
	qbool wantsend;	/*set if we're capturing data to send*/
	float voiplevel;	/*your own voice level*/
	unsigned int dumps;	/*trigger a new generation thing after a bit*/
	unsigned int keeps;	/*for vad_delay*/

	void *driverctx;	/*capture driver context*/
} s_speex;

static qbool S_Speex_Init (void)
{
	int i;
	const SpeexMode *mode;
	if (s_speex.inited)
		return s_speex.loaded;
	s_speex.inited = true;

	mode = speex_lib_get_mode (SPEEX_MODEID_NB);
	speex_bits_init (&s_speex.encbits);
	speex_bits_reset (&s_speex.encbits);

	s_speex.encoder = speex_encoder_init (mode);

	speex_encoder_ctl (s_speex.encoder, SPEEX_GET_FRAME_SIZE, &s_speex.framesize);
	speex_encoder_ctl (s_speex.encoder, SPEEX_GET_SAMPLING_RATE, &s_speex.samplerate);
	s_speex.samplerate = 11025;
	speex_encoder_ctl (s_speex.encoder, SPEEX_SET_SAMPLING_RATE, &s_speex.samplerate);

	s_speex.preproc = speex_preprocess_state_init (s_speex.framesize, s_speex.samplerate);

	i = 1;
	speex_preprocess_ctl (s_speex.preproc, SPEEX_PREPROCESS_SET_DENOISE, &i);

	i = 1;
	speex_preprocess_ctl (s_speex.preproc, SPEEX_PREPROCESS_SET_AGC, &i);

	for (i = 0; i < MAX_CLIENTS; i++) {
		speex_bits_init (&s_speex.decbits[i]);
		speex_bits_reset (&s_speex.decbits[i]);
		s_speex.decoder[i] = speex_decoder_init (mode);
		s_speex.decamp[i] = 1;
	}
	s_speex.loaded = true;
	return s_speex.loaded;
}

static int S_CaptureDriverInit (int sampleRate)
{
	SDL_AudioDeviceID inputdevid = 0;
	SDL_AudioSpec desired, obtained;
	int ret = 0;
	const char *requested_device = NULL;

	if (SDL_WasInit (SDL_INIT_AUDIO) == 0)
		ret = SDL_InitSubSystem (SDL_INIT_AUDIO);

	if (ret == -1) {
		Con_Printf ("Couldn't initialize SDL audio: %s\n", SDL_GetError ());
		return false;
	}

	memset (&desired, 0, sizeof (desired));
	desired.freq = sampleRate;
	desired.samples = 64;
	desired.format = AUDIO_S16LSB;
	desired.channels = 1;

	/* Make audiodevice list start from index 1 so that 0 can be system default */
	if (s_inputdevice.integer > 0) {
		requested_device = SDL_GetAudioDeviceName (s_inputdevice.integer - 1, 0);
	}

	if ((inputdevid = SDL_OpenAudioDevice (requested_device, 1, &desired, &obtained, 0)) <= 0) {
		Com_Printf ("sound: couldn't open SDL audio: %s\n", SDL_GetError ());
		if (requested_device != NULL) {
			Com_Printf ("sound: retrying with default audio device\n");
			if ((inputdevid = SDL_OpenAudioDevice (NULL, 1, &desired, &obtained, 0)) <= 0) {
				Com_Printf ("sound: failure again, aborting...\n");
				return 0;
			}
			Cvar_LatchedSet (&s_inputdevice, "0");
		}
	}

	if (obtained.format != AUDIO_S16LSB) {
		Com_Printf ("SDL audio format %d unsupported.\n", obtained.format);
		SDL_CloseAudioDevice (inputdevid);
		inputdevid = 0;
		return 0;
	}

	if (obtained.channels != 1 && obtained.channels != 2) {
		Com_Printf ("SDL audio channels %d unsupported.\n", obtained.channels);
		SDL_CloseAudioDevice (inputdevid);
		inputdevid = 0;
		return 0;
	}

	Com_Printf ("Using SDL audio capture driver: %s @ %d Hz (samplerate %d)\n", SDL_GetCurrentAudioDriver (), obtained.freq, obtained.samples);
	SDL_PauseAudioDevice (inputdevid, 0);

	return inputdevid;
}

static void S_CaptureDriverStart (void *ctx)
{
	SDL_AudioDeviceID inputdevid = (SDL_AudioDeviceID)ctx;

	SDL_PauseAudioDevice (inputdevid, 0);
}

static void S_CaptureDriverStop (void *ctx)
{
	SDL_AudioDeviceID inputdevid = (SDL_AudioDeviceID)ctx;

	SDL_PauseAudioDevice (inputdevid, 1);
}

static void S_CaptureDriverShutdown (void *ctx)
{
	SDL_AudioDeviceID inputdevid = (SDL_AudioDeviceID)ctx;

	if (inputdevid) {
		SDL_CloseAudioDevice (inputdevid);
	}
}

static unsigned int S_CaptureDriverUpdate (void* driverContext, unsigned char* buffer, int minBytes, int maxBytes)
{
	SDL_AudioDeviceID inputdevid = (SDL_AudioDeviceID)driverContext;
	unsigned int available = SDL_GetQueuedAudioSize (inputdevid);

	if (available > minBytes) {
		return SDL_DequeueAudio (inputdevid, buffer, maxBytes);
	}

	return 0;
}

typedef struct voip_data_s {
	unsigned int sender;
	unsigned char gen;
	unsigned char seq;
	int bytes;
	unsigned char data[1024];
} voip_data_t;

// Called when data is received from server
// TODO: store the voip data and then process in the main S_Update() call
void S_Voip_Parse (void)
{
	unsigned int sender;
	int bytes;
	unsigned char data[1024], *start;
	short decodebuf[1024];
	unsigned int decodesamps, len, newseq, drops;
	unsigned char seq, gen;
	float amp = 1;
	unsigned int i;

	sender = MSG_ReadByte ();
	gen = MSG_ReadByte ();
	seq = MSG_ReadByte ();
	bytes = MSG_ReadShort ();

	if (bytes > sizeof (data) || !cl_voip_play.integer || !S_Speex_Init () || (gen & 0xf0)) {
		Com_DPrintf ("skip data: %d\n", bytes);
		MSG_ReadSkip (bytes);
		return;
	}
	MSG_ReadData (data, bytes);

	sender &= MAX_CLIENTS - 1;

	amp = s_speex.decamp[sender];

	decodesamps = 0;
	newseq = 0;
	drops = 0;
	start = data;

	s_speex.lastspoke[sender] = cls.realtime + 0.5;
	if (s_speex.decgen[sender] != gen) {
		speex_bits_reset (&s_speex.decbits[sender]);
		s_speex.decgen[sender] = gen;
		s_speex.decseq[sender] = seq;
	}

	while (bytes > 0) {
		if (decodesamps + s_speex.framesize > sizeof (decodebuf) / sizeof (decodebuf[0])) {
			S_RawAudio (sender, (byte*)decodebuf, s_speex.samplerate, decodesamps, 1, 2);
			decodesamps = 0;
		}

		if (s_speex.decseq[sender] != seq) {
			speex_decode_int (s_speex.decoder[sender], NULL, decodebuf + decodesamps);
			s_speex.decseq[sender]++;
			drops++;
		}
		else {
			bytes--;
			len = *start++;
			speex_bits_read_from (&s_speex.decbits[sender], (char *)start, len);
			bytes -= len;
			start += len;
			speex_decode_int (s_speex.decoder[sender], &s_speex.decbits[sender], decodebuf + decodesamps);
			newseq++;
		}
		if (amp != 1) {
			for (i = decodesamps; i < decodesamps + s_speex.framesize; i++)
				decodebuf[i] *= amp;
		}
		decodesamps += s_speex.framesize;
	}
	s_speex.decseq[sender] += newseq;

	if (drops)
		Con_DPrintf ("%i dropped audio frames\n", drops);

	if (decodesamps > 0) {
		S_RawAudio (sender, (byte*)decodebuf, s_speex.samplerate, decodesamps, 1, 2);
	}
}

// Called just prior to sending command to server
void S_Voip_Transmit (unsigned char clc, sizebuf_t *buf)
{
	unsigned char outbuf[1024];
	unsigned int outpos;//in bytes
	unsigned int encpos;//in bytes
	short *start;
	unsigned char initseq;//in frames
	unsigned int i;
	unsigned int samps;
	float level, f;
	float micamp = cl_voip_micamp.value;
	qbool voipsendenable = (cl_voip_play.integer && (cls.fteprotocolextensions2 & FTE_PEXT2_VOICECHAT));

	if (!voipsendenable) {
		S_Capture_Shutdown();
		return;
	}

	voipsendenable = cl_voip_send.integer > 0;

	if (!s_speex.driverctx) {
		s_speex.voiplevel = -1;
		/*only init the first time capturing is requested*/
		if (!voipsendenable)
			return;

		/*see if we can init speex...*/
		if (!S_Speex_Init ())
			return;

		s_speex.driverctx = (void*)S_CaptureDriverInit (s_speex.samplerate);
	}

	/*couldn't init a driver?*/
	if (!s_speex.driverctx) {
		return;
	}

	if (!voipsendenable && s_speex.wantsend) {
		s_speex.wantsend = false;
		s_speex.capturepos += S_CaptureDriverUpdate (s_speex.driverctx, (unsigned char*)s_speex.capturebuf + s_speex.capturepos, 1, sizeof (s_speex.capturebuf) - s_speex.capturepos);
		S_CaptureDriverStop (s_speex.driverctx);
		/*note: we still grab audio to flush everything that was captured while it was active*/
	}
	else if (voipsendenable && !s_speex.wantsend) {
		s_speex.wantsend = true;
		if (!s_speex.capturepos) {	/*if we were actually still sending, it was probably only off for a single frame, in which case don't reset it*/
			s_speex.dumps = 0;
			s_speex.generation++;
			s_speex.encsequence = 0;
			speex_bits_reset (&s_speex.encbits);
		}
		else {
			s_speex.capturepos += S_CaptureDriverUpdate (s_speex.driverctx, (unsigned char*)s_speex.capturebuf + s_speex.capturepos, 1, sizeof (s_speex.capturebuf) - s_speex.capturepos);
		}
		S_CaptureDriverStart (s_speex.driverctx);

		voicevolumemod = cl_voip_capturingvol.value;
	}

	s_speex.capturepos += S_CaptureDriverUpdate (s_speex.driverctx, (unsigned char*)s_speex.capturebuf + s_speex.capturepos, s_speex.framesize * 2, sizeof (s_speex.capturebuf) - s_speex.capturepos);
	if (!s_speex.wantsend && s_speex.capturepos < s_speex.framesize * 2) {
		s_speex.voiplevel = -1;
		s_speex.capturepos = 0;
		voicevolumemod = 1;
		return;
	}

	initseq = s_speex.encsequence;
	level = 0;
	samps = 0;
	for (encpos = 0, outpos = 0; s_speex.capturepos - encpos >= s_speex.framesize * 2 && sizeof (outbuf) - outpos > 64; s_speex.encsequence++) {
		start = (short*)(s_speex.capturebuf + encpos);

		speex_preprocess_run (s_speex.preproc, start);

		for (i = 0; i < s_speex.framesize; i++) {
			f = start[i] * micamp;
			start[i] = f;
			f = (float)abs(start[i]);
			level += f*f;
		}
		samps += s_speex.framesize;

		speex_bits_reset (&s_speex.encbits);
		speex_encode_int (s_speex.encoder, start, &s_speex.encbits);
		outbuf[outpos] = speex_bits_write (&s_speex.encbits, (char *)outbuf + outpos + 1, sizeof (outbuf) - (outpos + 1));
		outpos += 1 + outbuf[outpos];
		encpos += s_speex.framesize * 2;
	}

	if (samps) {
		float nl = (3000 * level) / (32767.0f * 32767 * samps);

		s_speex.voiplevel = (s_speex.voiplevel * 7 + nl) / 8;
		if (s_speex.voiplevel < cl_voip_vad_threshhold.integer && !(cl_voip_send.integer & 2)) {
			/*try and dump it, it was too quiet, and they're not pressing +voip*/
			if (s_speex.keeps > samps) {
				/*but not instantly*/
				s_speex.keeps -= samps;
			}
			else {
				outpos = 0;
				s_speex.dumps += samps;
				s_speex.keeps = 0;
			}
		}
		else {
			s_speex.keeps = s_speex.samplerate * cl_voip_vad_delay.value;
		}

		if (outpos) {
			if (s_speex.dumps > s_speex.samplerate / 4) {
				s_speex.generation++;
			}
			s_speex.dumps = 0;
		}
	}

	if (outpos && buf->maxsize - buf->cursize >= outpos + 4) {
		MSG_WriteByte (buf, clc);
		MSG_WriteByte (buf, (s_speex.generation & 0x0f)); /*gonna leave that nibble clear here... in this version, the client will ignore packets with those bits set. can use them for codec or something*/
		MSG_WriteByte (buf, initseq);
		MSG_WriteShort (buf, outpos);
		SZ_Write (buf, outbuf, outpos);
	}

	/*remove sent data*/
	memmove (s_speex.capturebuf, s_speex.capturebuf + encpos, s_speex.capturepos - encpos);
	s_speex.capturepos -= encpos;
}

// Called when VOIP playback is toggled - pass stop/start to server
static void S_Voip_Play_Callback (cvar_t *var, char *string, qbool *cancel)
{
	if (cls.fteprotocolextensions2 & FTE_PEXT2_VOICECHAT) {
		if (atoi (string))
			CL_SendClientCommand (true, "unmuteall");
		else
			CL_SendClientCommand (true, "muteall");
	}
}

// Add to the ignore list
void S_Voip_Ignore (unsigned int slot, qbool ignore)
{
	if (cls.fteprotocolextensions2 & FTE_PEXT2_VOICECHAT) {
		CL_SendClientCommand (true, "vignore %i %i", slot, ignore);
	}
}

// +voip
static void S_Voip_Enable_f (void)
{
	Cvar_SetValue (&cl_voip_send, cl_voip_send.integer | 2);
}

// -voip
static void S_Voip_Disable_f (void)
{
	Cvar_SetValue (&cl_voip_send, cl_voip_send.integer & ~2);
}

// 
void S_Voip_RegisterCvars (void)
{
	Cvar_SetCurrentGroup (CVAR_GROUP_SOUND);
	Cvar_Register (&cl_voip_send);
	Cvar_Register (&cl_voip_vad_threshhold);
	Cvar_Register (&cl_voip_vad_delay);
	Cvar_Register (&cl_voip_capturingvol);
	Cvar_Register (&cl_voip_play);
	Cvar_Register (&cl_voip_micamp);
	Cvar_Register (&cl_voip_demorecord);
	Cvar_Register (&cl_voip_showmeter);
	Cvar_Register (&cl_voip_showmeter_x);
	Cvar_Register (&cl_voip_showmeter_y);

	Cmd_AddCommand ("+voip", S_Voip_Enable_f);
	Cmd_AddCommand ("-voip", S_Voip_Disable_f);
}

// Called after new serverdata received
void S_Voip_MapChange (void)
{
	Cvar_ForceCallback (&cl_voip_play);
}

int S_Voip_Loudness(void)
{
	qbool ignorevad = cl_voip_showmeter.integer == 2;

	if (s_speex.voiplevel > 100)
		return 100;
	if (!s_speex.driverctx || (!ignorevad && s_speex.dumps))
		return -1;
	return s_speex.voiplevel;
}

qbool S_Voip_ShowMeter (int* x, int* y)
{
	*x = cl_voip_showmeter_x.integer + 10;
	*y = cl_voip_showmeter_y.integer + vid.height - 8 - 10;

	return cl_voip_showmeter.integer;
}

qbool S_Voip_Speaking(unsigned int plno)
{
	if (!snd_initialized) {
		return false;
	}

	if (plno == cl.playernum) {
		return s_speex.voiplevel >= cl_voip_vad_threshhold.integer || (cl_voip_send.integer & 2);
	}

	return plno < MAX_CLIENTS && s_speex.lastspoke[plno] > cls.realtime;
}

void S_Capture_Shutdown(void)
{
	S_CaptureDriverShutdown (s_speex.driverctx);
	memset(&s_speex, 0, sizeof(s_speex));
}

#endif


================================================
FILE: src/spritegn.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
//
// spritegn.h: header file for sprite generation program
//

// **********************************************************
// * This file must be identical in the spritegen directory *
// * and in the Quake directory, because it's used to       *
// * pass data from one to the other via .spr files.        *
// **********************************************************

//-------------------------------------------------------
// This program generates .spr sprite package files.
// The format of the files is as follows:
//
// dsprite_t file header structure
// <repeat dsprite_t.numframes times>
//   <if spritegroup, repeat dspritegroup_t.numframes times>
//     dspriteframe_t frame header structure
//     sprite bitmap
//   <else (single sprite frame)>
//     dspriteframe_t frame header structure
//     sprite bitmap
// <endrepeat>
//-------------------------------------------------------

#ifdef INCLUDELIBS

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>

#include "cmdlib.h"
#include "scriplib.h"
#include "dictlib.h"
#include "trilib.h"
#include "lbmlib.h"
#include "mathlib.h"

#endif

#define SPRITE_VERSION		1

// must match definition in modelgen.h
#ifndef SYNCTYPE_T
#define SYNCTYPE_T
typedef enum {ST_SYNC=0, ST_RAND } synctype_t;
#endif

// TODO: shorten these?
typedef struct {
	int			ident;
	int			version;
	int			type;
	float		boundingradius;
	int			width;
	int			height;
	int			numframes;
	float		beamlength;
	synctype_t	synctype;
} dsprite_t;

#define SPR_VP_PARALLEL_UPRIGHT		0
#define SPR_FACING_UPRIGHT			1
#define SPR_VP_PARALLEL				2
#define SPR_ORIENTED				3
#define SPR_VP_PARALLEL_ORIENTED	4

typedef struct {
	int			origin[2];
	int			width;
	int			height;
} dspriteframe_t;

typedef struct {
	int			numframes;
} dspritegroup_t;

typedef struct {
	float	interval;
} dspriteinterval_t;

typedef enum { SPR_SINGLE=0, SPR_GROUP } spriteframetype_t;

typedef struct {
	spriteframetype_t	type;
} dspriteframetype_t;

#define IDSPRITEHEADER	(('P'<<24)+('S'<<16)+('D'<<8)+'I')
														// little-endian "IDSP"



================================================
FILE: src/stats_grid.c
================================================
/*
Copyright (C) 2011 Cokeman

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "stats_grid.h"
#include "sbar.h"
#include "hud.h"
#include "utils.h"
#include "fonts.h"

static hud_t* teamholdinfo;
static hud_t* teamholdbar;

stats_weight_grid_t *stats_grid = NULL;
stats_entities_t *stats_important_ents = NULL;

void StatsGrid_Remove(stats_weight_grid_t **grid)
{
	int row;

	// Nothing to remove.
	if((*grid) == NULL)
	{
		return;
	}

	// Free all the rows.
	if((*grid)->cells != NULL)
	{
		for(row = 0; row < (*grid)->row_count; row++)
		{
			// Make sure it hasn't already been freed.
			if((*grid)->cells[row] != NULL)
			{
				Q_free((*grid)->cells[row]);
			}
		}
	}

	// Free all columns.
	Q_free((*grid)->cells);

	// Free the grid itself.
	Q_free((*grid));
}


void StatsGrid_Init(stats_weight_grid_t **grid,
						 float falloff_interval,
						 float falloff_value,
						 int cell_length,
						 float grid_width,
						 float grid_height,
						 float hold_threshold)
{
	int row;
	int col;

	// Allocate the grid.
	(*grid) = (stats_weight_grid_t *)Q_malloc(sizeof(stats_weight_grid_t));
	memset((*grid), 0, sizeof(stats_weight_grid_t));

	if((*grid) == NULL)
	{
		// Failure.
		return;
	}

	// Get the row and col count.
	(*grid)->row_count = Q_rint(grid_height / cell_length);
	(*grid)->col_count = Q_rint(grid_width / cell_length);

	// Allocate the rows.
	(*grid)->cells = (stats_cell_t **)Q_calloc((*grid)->row_count, sizeof(stats_cell_t *));

	// If we failed allocating the rows, cleanup and return.
	if((*grid)->cells == NULL)
	{
		Q_free(*grid);
		return;
	}

	// Allocate the columns for each row.
	for(row = 0; row < (*grid)->row_count; row++)
	{
		// Allocate memory for the current rows columns.
		(*grid)->cells[row] = (stats_cell_t *)Q_calloc((*grid)->col_count, sizeof(stats_cell_t));

		// If something went wrong cleanup and return.
		if((*grid)->cells[row] == NULL)
		{
			// Make sure we're not trying to free more than we allocated.
			(*grid)->row_count = row;

			// Remove the grid.
			StatsGrid_Remove(grid);

			// Failure.
			return;
		}

		// Set initial values for all the cells.
		for(col = 0; col < (*grid)->col_count; col++)
		{
			(*grid)->cells[row][col].teams[STATS_TEAM1].weight = 0.0;
			(*grid)->cells[row][col].teams[STATS_TEAM1].change_time = 0.0;
			(*grid)->cells[row][col].teams[STATS_TEAM1].death_weight = 0.0;

			(*grid)->cells[row][col].teams[STATS_TEAM2].weight = 0.0;
			(*grid)->cells[row][col].teams[STATS_TEAM2].change_time = 0.0;
			(*grid)->cells[row][col].teams[STATS_TEAM2].death_weight = 0.0;

			// Save the quake coordinates of the cells upper left corner.
			(*grid)->cells[row][col].tl_x = cl.worldmodel->mins[0] + (col * cell_length);
			(*grid)->cells[row][col].tl_y = cl.worldmodel->mins[1] + (row * cell_length);
		}
	}

	// If everything went well set the rest of the stuff.
	(*grid)->falloff_interval	= falloff_interval;
	(*grid)->falloff_value		= falloff_value;
	(*grid)->cell_length		= cell_length;
	(*grid)->width				= grid_width;
	(*grid)->height				= grid_height;

	// We will wait with setting these until the match has started.

	(*grid)->teams[STATS_TEAM1].color			= 0;
	(*grid)->teams[STATS_TEAM2].color			= 0;
	(*grid)->teams[STATS_TEAM1].hold_count		= 0;
	(*grid)->teams[STATS_TEAM2].hold_count		= 0;
	(*grid)->teams[STATS_TEAM1].color			= 0;
	(*grid)->teams[STATS_TEAM2].color			= 0;
	(*grid)->hold_threshold						= hold_threshold;
}

#define STATS_MAX_IMPORTANT_ENTS	16

void StatsGrid_ResetHoldItemsOrder(void)
{
	int i;

	if (stats_important_ents == NULL)
	{
		return;
	}

	for (i = 0; i < stats_important_ents->count; i++)
	{
		stats_important_ents->list[i].order = STATS_MAX_IMPORTANT_ENTS;
	}
}

void StatsGrid_SetHoldItemOrder(const char *item_name, int order)
{
	int i;
	int len = strlen(item_name);

	if (stats_important_ents == NULL)
	{
		return;
	}

	for (i = 0; i < stats_important_ents->count; i++)
	{
		if (!strncasecmp(stats_important_ents->list[i].name, item_name, len))
		{
			stats_important_ents->list[i].order = order;
		}
	}
}

void StatsGrid_SetHoldItemName(char *dst_name, const char *src_name, int count)
{
	// If there are more than one of this item already then name it "ITEM#"
	// RL, RL2, RL3 and so on.
	if(count > 1)
	{
		strcpy(dst_name, va("%s%d", src_name, count));
	}
	else
	{
		strcpy(dst_name, src_name);
	}
}

void StatsGrid_InitHoldItems(void)
{
	int i;
	int ents_count = 0;

	// This is used to keep count of how many of the different
	// types of items that exist on the map, so that they
	// can be named "RL" "RL2" and so on.
	int pent_count	= 0;
	int quad_count	= 0;
	int ring_count	= 0;
	int suit_count	= 0;
	int rl_count	= 0;
	int gl_count	= 0;
	int lg_count	= 0;
	int sng_count	= 0;
	int mega_count	= 0;
	int ra_count	= 0;
	int ya_count	= 0;
	int ga_count	= 0;

	// Buffer.
	stats_entity_t temp_ents[STATS_MAX_IMPORTANT_ENTS];

	// Entities (weapons and such). cl_main.c
	extern visentlist_t cl_visents;

	// Don't create the list before we have any entities to work with.
	if(cl_visents.count <= 0)
	{
		return;
	}

	stats_important_ents = (stats_entities_t *)Q_malloc(sizeof(stats_entities_t));

	// Something bad happened.
	if(stats_important_ents == NULL)
	{
		return;
	}

	// Go through the entities and check for the important ones
	// and save their name and location.
	for (i = 0; i < cl_visents.count && (ents_count < STATS_MAX_IMPORTANT_ENTS); i++)
	{
		if(cl_visents.list[i].ent.model->modhint == MOD_PENT)
		{
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "PENT", ++pent_count);
		}
		else if(cl_visents.list[i].ent.model->modhint == MOD_QUAD)
		{
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "QUAD", ++quad_count);
		}
		else if(cl_visents.list[i].ent.model->modhint == MOD_RING)
		{
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "RING", ++ring_count);
		}
		else if(cl_visents.list[i].ent.model->modhint == MOD_SUIT)
		{
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "SUIT", ++suit_count);
		}
		else if(cl_visents.list[i].ent.model->modhint == MOD_ROCKETLAUNCHER)
		{
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "RL", ++rl_count);
		}
		else if(cl_visents.list[i].ent.model->modhint == MOD_LIGHTNINGGUN)
		{
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "LG", ++lg_count);
		}
		else if(cl_visents.list[i].ent.model->modhint == MOD_GRENADELAUNCHER)
		{
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "GL", ++gl_count);
		}
		else if(!strcmp(cl_visents.list[i].ent.model->name, "progs/g_nail2.mdl"))
		{
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "SNG", ++sng_count);
		}
		else if (cl_visents.list[i].ent.model->modhint == MOD_MEGAHEALTH)
		{
			// Megahealth.
			StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "MH", ++mega_count);
		}
		else if (cl_visents.list[i].ent.model->modhint == MOD_ARMOR)
		{
			if(cl_visents.list[i].ent.skinnum == 0)
			{
				StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "GA", ++ga_count);
			}
			else if(cl_visents.list[i].ent.skinnum == 1)
			{
				StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "YA", ++ya_count);
			}
			else if(cl_visents.list[i].ent.skinnum == 2)
			{
				StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "RA", ++ra_count);
			}
			else
			{
				continue;
			}
		}
		else
		{
			// The entity wasn't one we wanted.
			continue;
		}

		// Copy the position of the entity into the buffer.
		VectorCopy(cl_visents.list[i].ent.origin, temp_ents[ents_count].origin);

		// Reset the team values.
		temp_ents[ents_count].teams_hold_count[STATS_TEAM1] = 0;
		temp_ents[ents_count].teams_hold_count[STATS_TEAM2] = 0;

		ents_count++;
	}

	// Set the count of found entities and allocate memory for the
	// final list of items.
	stats_important_ents->count = ents_count;
	stats_important_ents->list = Q_calloc(ents_count, sizeof(stats_entity_t));

	// Something bad happened, cleanup.
	if(stats_important_ents->list == NULL)
	{
		Q_free(stats_important_ents);
		return;
	}

	// Copy the entities from the buffer to the final list.
	for(i = 0; i < ents_count; i++)
	{
		memcpy(&stats_important_ents->list[i], &temp_ents[i], sizeof(stats_entity_t));
	}

	// Set the radius around the items that decides if it's being
	// held by a team or not.
	stats_important_ents->hold_radius = 264.0;

	// Get the entity with the longest name to use for padding
	// (so we don't have to calculate this more than once).
	stats_important_ents->longest_name = 0;
	for(i = 0; i < stats_important_ents->count; i++)
	{
		int current = strlen(stats_important_ents->list[i].name);
		stats_important_ents->longest_name = max(current, stats_important_ents->longest_name);
	}
}

void StatsGrid_InitTeamNames(stats_weight_grid_t *grid)
{
	int i;

	// Go through the rest of the players until another team is found, that must be team2.
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		// Skip spectators.
		if(!cl.players[i].name[0] || cl.players[i].spectator)
		{
			continue;
		}

		// Get the first player's team and set that as team1.
		if(!grid->teams[STATS_TEAM1].name[0])
		{
			strlcpy(grid->teams[STATS_TEAM1].name, cl.players[i].team, MAX_INFO_STRING);
			grid->teams[STATS_TEAM1].color = Sbar_BottomColor(&cl.players[i]);
		}

		// If this players team isn't the same as the first players team
		// set this players team as team 2.
		if(strcmp(grid->teams[STATS_TEAM1].name, cl.players[i].team))
		{
			strlcpy(grid->teams[STATS_TEAM2].name, cl.players[i].team, MAX_INFO_STRING);
			grid->teams[STATS_TEAM2].color = Sbar_BottomColor(&cl.players[i]);
			break;
		}
	}
}

void StatsGrid_ValidateTeamColors(void)
{
	// This is needed to handle when a user switches the player being tracked
	// and has "teamcolor" and "enemycolor" set. When you switch to a player
	// that has another team than the one you tracked at match start, the team
	// colors saved on the stats grid will not match the team color of the actual
	// players on the level.

	int player_color;
	player_info_t *player_info;
	int tracked = Cam_TrackNum();

	if (tracked < 0)
	{
		return;
	}

	// Get the tracked player.
	player_info = &cl.players[tracked];

	// Get the team color of the tracked player.
	player_color = Sbar_BottomColor(player_info);

	if (!stats_important_ents || !stats_grid)
	{
		return;
	}

	// If the player being tracked is a member of team 1 for instance but has a
	// team color that doesn't match the one saved for team 1 in the
	// stats grid, then swap the team colors in the stats grid.
	if (!strncmp(stats_grid->teams[STATS_TEAM1].name, player_info->team, sizeof(stats_grid->teams[STATS_TEAM1].name))
		&& stats_grid->teams[STATS_TEAM1].color != player_color)
	{
		int old_team1_color = stats_grid->teams[STATS_TEAM1].color;
		stats_grid->teams[STATS_TEAM1].color = stats_important_ents->teams[STATS_TEAM1].color = player_color;
		stats_grid->teams[STATS_TEAM2].color = stats_important_ents->teams[STATS_TEAM2].color = old_team1_color;
	}
	else if (!strncmp(stats_grid->teams[STATS_TEAM2].name, player_info->team, sizeof(stats_grid->teams[STATS_TEAM2].name))
		&& stats_grid->teams[STATS_TEAM2].color != player_color)
	{
		int old_team2_color = stats_grid->teams[STATS_TEAM2].color;
		stats_grid->teams[STATS_TEAM2].color = stats_important_ents->teams[STATS_TEAM2].color = player_color;
		stats_grid->teams[STATS_TEAM1].color = stats_important_ents->teams[STATS_TEAM1].color = old_team2_color;
	}
}

void StatsGrid_Change(stats_weight_grid_t *grid,
							float falloff_interval,
							float falloff_value,
							int grid_width,
							int grid_height)
{
	int row;
	int col;
	int cell_length;

	// Don't do something stupid.
	if(grid == NULL)
	{
		return;
	}

	// Calculate the new cell length.
	cell_length = grid_height / grid->row_count;

	for(row = 0; row < grid->row_count; row++)
	{
		// Reset the location of the cells.
		for(col = 0; col < grid->col_count; col++)
		{
			grid->cells[row][col].tl_x = col * cell_length;
			grid->cells[row][col].tl_y = row * cell_length;
		}
	}

	grid->falloff_interval	= falloff_interval;
	grid->falloff_value		= falloff_value;
}

void StatsGrid_DecreaseWeight(cell_weight_t *weight, stats_weight_grid_t *grid)
{
	// Decrease the weight of the specified cell.
	if(weight->weight > 0 && (cls.demotime - weight->change_time >= grid->falloff_interval))
	{
		weight->change_time = cls.demotime;
		weight->weight -= grid->falloff_value;
	}
}

void StatsGrid_ResetHoldItems(void)
{
	// Nothing to reset.
	if(stats_important_ents == NULL)
	{
		return;
	}

	// Free any entities in the list.
	if(stats_important_ents->list != NULL)
	{
		Q_free(stats_important_ents->list);
	}

	// Reset.
	Q_free(stats_important_ents);
}

void StatsGrid_ResetHoldItemCounts(void)
{
	int i = 0;

	if(stats_important_ents == NULL)
	{
		return;
	}

	for(i = 0; i < stats_important_ents->count; i++)
	{
		stats_important_ents->list[i].teams_hold_count[STATS_TEAM1] = 0;
		stats_important_ents->list[i].teams_hold_count[STATS_TEAM2] = 0;
	}
}

static int StatsGrid_CompareHoldItems(const void *it1, const void *it2)
{
	const stats_entity_t *ent1 = (stats_entity_t *)it1;
	const stats_entity_t *ent2 = (stats_entity_t *)it2;

	return ent1->order - ent2->order;
}

void StatsGrid_SortHoldItems(void)
{
	if (stats_important_ents == NULL)
	{
		return;
	}

	qsort(stats_important_ents->list, stats_important_ents->count, sizeof(stats_entity_t), StatsGrid_CompareHoldItems);
}

void StatsGrid_CalculateHoldItem(stats_weight_grid_t *grid, int row, int col, float hold_threshold, int team_id)
{
	int i = 0;

	if(stats_important_ents == NULL || stats_important_ents->list == NULL)
	{
		return;
	}

	for(i = 0; i < stats_important_ents->count; i++)
	{
		// Check if the cell is within the "hold radius" for this item
		// if it is, increase the hold count for this team for this item.
		// The team with the most "owned" cells within this radius around
		// the item is considered to hold it.
		if(fabs(grid->cells[row][col].tl_x - stats_important_ents->list[i].origin[0]) <= stats_important_ents->hold_radius
			&& fabs(grid->cells[row][col].tl_y - stats_important_ents->list[i].origin[1]) <= stats_important_ents->hold_radius)
		{
			stats_important_ents->list[i].teams_hold_count[team_id]++;

			// If this is the first time, set the name of the team in the entity struct.
			if(!stats_important_ents->teams[team_id].name[0])
			{
				strlcpy(stats_important_ents->teams[team_id].name, grid->teams[team_id].name, MAX_INFO_STRING);
				stats_important_ents->teams[team_id].color = grid->teams[team_id].color;
			}
		}
	}
}

void StatsGrid_DecreaseTeamWeights(stats_weight_grid_t *grid, int row, int col, float hold_threshold)
{
	// Don't try to do something stupid.
	if(grid == NULL || row < 0 || col < 0)
	{
		return;
	}

	// No point in doing anything if the weights are all zero.
	if(grid->cells[row][col].teams[STATS_TEAM1].weight + grid->cells[row][col].teams[STATS_TEAM2].weight <= 0)
	{
		return;
	}

	// Increase the amount of cells that is being "hold" by the teams.
	if(grid->cells[row][col].teams[STATS_TEAM1].weight > grid->cells[row][col].teams[STATS_TEAM2].weight)
	{
		if(grid->cells[row][col].teams[STATS_TEAM1].weight > hold_threshold)
		{
			grid->teams[STATS_TEAM1].hold_count++;
			StatsGrid_CalculateHoldItem(grid, row, col, hold_threshold, STATS_TEAM1);
		}
	}
	else
	{
		if(grid->cells[row][col].teams[STATS_TEAM2].weight > hold_threshold)
		{
			grid->teams[STATS_TEAM2].hold_count++;
			StatsGrid_CalculateHoldItem(grid, row, col, hold_threshold, STATS_TEAM2);
		}
	}

	// Decrease the weights for both teams.
	StatsGrid_DecreaseWeight(&grid->cells[row][col].teams[STATS_TEAM1], grid);
	StatsGrid_DecreaseWeight(&grid->cells[row][col].teams[STATS_TEAM2], grid);
}

void StatsGrid_SetWeightForPlayer(stats_weight_grid_t *grid,
								  player_state_t *player_state,
								  player_info_t *player_info)
{
	float weight = 0.0;
	int row, col;
	int team_id = 0;

	int row_top;
	int row_bottom;
	int col_left;
	int col_right;

	// FIXME : Bad hack!
	// HACK: This is so that I can keep death status of the players
	// and since all I have to differentiate them is the userid,
	// I have to have enough room to fit the players. Most of this
	// space is unused. Too lazy to do something more fancy atm :S
	#define DEAD_SIZE 1024
	static qbool isdead[DEAD_SIZE];

	// Don't calculate any weights before a match has started.
	// Don't allow setting the weight at the exact time the countdown
	// or standby ends (cl.gametime == 0), that will result in a weight
	// being set in the position that the player was the milisecond before
	// he spawned, so wait one second before starting to set any weights.
	if(cl.countdown				|| cl.standby			|| cl.gametime <= 1
		|| grid == NULL			|| grid->cells == NULL
		|| grid->col_count <= 0 || grid->row_count <= 0
		|| player_info == NULL	|| player_state == NULL )
	{
		return;
	}

	// Set the team names.
	if(!grid->teams[STATS_TEAM1].name[0] || !grid->teams[STATS_TEAM2].name[0])
	{
		StatsGrid_InitTeamNames(grid);
	}

	// TODO: Make this properly (this is just a quick hack atm). Use autotrack values?
	if(player_info->stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER)
	{
		weight += 0.5;
	}
	else if(player_info->stats[STAT_ITEMS] & IT_LIGHTNING)
	{
		weight += 0.4;
	}
	else if(player_info->stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER)
	{
		weight += 0.3;
	}
	else if(player_info->stats[STAT_ITEMS] & IT_SUPER_NAILGUN)
	{
		weight += 0.2;
	}
	else if(player_info->stats[STAT_ITEMS] & IT_SUPER_SHOTGUN)
	{
		weight += 0.2;
	}
	else if(player_info->stats[STAT_ITEMS] & IT_NAILGUN)
	{
		weight += 0.05;
	}

	weight += player_info->stats[STAT_HEALTH] / 1000.0;

	if(player_info->stats[STAT_ITEMS] & IT_ARMOR3)
	{
		weight += (player_info->stats[STAT_ARMOR] * (200.0/500.0)) / 1000.0;
	}
	else if(player_info->stats[STAT_ITEMS] & IT_ARMOR2)
	{
		weight += (player_info->stats[STAT_ARMOR] * (150.0/500.0)) / 1000.0;
	}
	else if(player_info->stats[STAT_ITEMS] & IT_ARMOR1)
	{
		weight += (player_info->stats[STAT_ARMOR] * (100.0/500.0)) / 1000.0;
	}

	//
	// Get the grid cell that the player is located in based on it's quake coordinates.
	//
	row = fabs(cl.worldmodel->mins[1] - player_state->origin[1]) / grid->cell_length;
	col = fabs(cl.worldmodel->mins[0] - player_state->origin[0]) / grid->cell_length;

	// Make sure we're not out of bounds.
	row = min(row, grid->row_count - 1);
	col = min(col, grid->col_count - 1);

	//
	// Get the neighbours
	//
	{
		// The row above (make sure it's >= 0).
		row_top = row - 1;
		row_top = max(0, row_top);

		// Row below.
		row_bottom = row + 1;
		row_bottom = min(grid->row_count - 1, row_bottom);

		// Column to the left.
		col_left = col - 1;
		col_left = max(0, col_left);

		// Column to the right.
		col_right = col + 1;
		col_right = min(grid->col_count - 1, col_right);
	}

	// Get the team.
	team_id = !strcmp(player_info->team, grid->teams[STATS_TEAM1].name) ? STATS_TEAM1 : STATS_TEAM2;

	// Raise the death weight for this cell if the player is dead.
	if((player_info->stats[STAT_HEALTH] > 0) && (player_info->userid < DEAD_SIZE) && isdead[player_info->userid])
	{
		isdead[player_info->userid] = false;
	}

	if(player_info->stats[STAT_HEALTH] <= 0 && (player_info->userid < DEAD_SIZE) && !isdead[player_info->userid])
	{
		#define DEATH_WEIGHT		0.2
		#define DEATH_WEIGHT_CLOSE	DEATH_WEIGHT * 0.8
		#define DEATH_WEIGHT_FAR	DEATH_WEIGHT * 0.5

		isdead[player_info->userid] = true;
		grid->cells[row][col].teams[team_id].death_weight += DEATH_WEIGHT;

		// Top.
		grid->cells[row_top][col].teams[team_id].death_weight += DEATH_WEIGHT_CLOSE;

		// Top Right.
		grid->cells[row_top][col_right].teams[team_id].death_weight = DEATH_WEIGHT_FAR;

		// Right.
		grid->cells[row][col_right].teams[team_id].death_weight = DEATH_WEIGHT_CLOSE;

		// Bottom Right.
		grid->cells[row_bottom][col_right].teams[team_id].death_weight = DEATH_WEIGHT_FAR;

		// Bottom.
		grid->cells[row_bottom][col].teams[team_id].death_weight = DEATH_WEIGHT_CLOSE;

		// Bottom Left.
		grid->cells[row_bottom][col_left].teams[team_id].death_weight = DEATH_WEIGHT_FAR;

		// Left.
		grid->cells[row][col_left].teams[team_id].death_weight = DEATH_WEIGHT_CLOSE;

		// Top Left.
		grid->cells[row_top][col_left].teams[team_id].death_weight = DEATH_WEIGHT_FAR;
	}

	// Only change the weight if the new weight is greater than the current one.
	if(weight >= grid->cells[row][col].teams[team_id].weight)
	{
		float neighbour_weight_close;
		float neighbour_weight_far;

		// Fade the weights for the neighbours. The edge corners
		// are at 50% opacity, and the ones at top/bottom, left/right at 80%.
		neighbour_weight_close	= weight * 0.8;
		neighbour_weight_far	= weight * 0.5;

		// Set the team weight for the current cell + surrounding cells.
		{
			// The current cell.
			grid->cells[row][col].teams[team_id].weight = weight;
			grid->cells[row][col].teams[team_id].change_time = cls.demotime;

			// Top.
			grid->cells[row_top][col].teams[team_id].weight = max(grid->cells[row_top][col].teams[team_id].weight, neighbour_weight_close);
			grid->cells[row_top][col].teams[team_id].change_time = cls.demotime;

			// Top right.
			grid->cells[row_top][col_right].teams[team_id].weight = max(grid->cells[row_top][col_right].teams[team_id].weight, neighbour_weight_far);
			grid->cells[row_top][col_right].teams[team_id].change_time = cls.demotime;

			// Right.
			grid->cells[row][col_right].teams[team_id].weight = max(grid->cells[row][col_right].teams[team_id].weight, neighbour_weight_close);
			grid->cells[row][col_right].teams[team_id].change_time = cls.demotime;

			// Bottom right.
			grid->cells[row_bottom][col_right].teams[team_id].weight = max(grid->cells[row_bottom][col_right].teams[team_id].weight, neighbour_weight_far);
			grid->cells[row_bottom][col_right].teams[team_id].change_time = cls.demotime;

			// Bottom.
			grid->cells[row_bottom][col].teams[team_id].weight = max(grid->cells[row_bottom][col].teams[team_id].weight, neighbour_weight_close);
			grid->cells[row_bottom][col].teams[team_id].change_time = cls.demotime;

			// Bottom left.
			grid->cells[row_bottom][col_left].teams[team_id].weight = max(grid->cells[row_bottom][col_left].teams[team_id].weight, neighbour_weight_far);
			grid->cells[row_bottom][col_left].teams[team_id].change_time = cls.demotime;

			// Left.
			grid->cells[row][col_left].teams[team_id].weight = max(grid->cells[row][col_left].teams[team_id].weight, neighbour_weight_close);
			grid->cells[row][col_left].teams[team_id].change_time = cls.demotime;

			// Top left.
			grid->cells[row_top][col_left].teams[team_id].weight = max(grid->cells[row_top][col_left].teams[team_id].weight, neighbour_weight_far);
			grid->cells[row_top][col_left].teams[team_id].change_time = cls.demotime;
		}
	}
}

void StatsGrid_Gather(void)
{
	int i;
	int row, col;
	static int lastframecount = -1;
	player_state_t *state;
	player_info_t *info;

	// Initiate the grid if it hasn't already been initiated.
	// The grid is reset on all level changes.
	if (stats_grid == NULL) {
		if (!cl.worldmodel) {
			return;
		}

		// TODO: Create cvars that let us set these values.
		StatsGrid_Init(&stats_grid, // The grid to initiate.
			5.0,					// The time in miliseconds between fall offs.
			0.2,					// At each fall off period, how much should be substracted from the weight?
			50,						// The length in quad coordinates of a cells side length.
			fabs(cl.worldmodel->maxs[0] - cl.worldmodel->mins[0]), // Width of the map in quake coordinates.
			fabs(cl.worldmodel->maxs[1] - cl.worldmodel->mins[1]), // Height (if we're talking 2D where Y = height).
			0.0);					// The threshold before a team is considered to "hold" a cell.

		// We failed initializing the grid, so don't do anything.
		if(stats_grid == NULL) {
			return;
		}
	}

	// If it's the first time for this level initiate.
	if (stats_important_ents == NULL) {
		StatsGrid_InitHoldItems();
	}

	if (teamholdinfo == NULL || teamholdbar == NULL) {
		return;
	}
	if (teamholdinfo->show->value == 0 && teamholdbar->show->value == 0) {
		return;
	}

	// Only gather once per frame.
	if (cls.framecount == lastframecount) {
		return;
	}
	lastframecount = cls.framecount;

	if (!cl.oldparsecount || !cl.parsecount || cls.state < ca_active) {
		return;
	}

	// Make sure the team colors are correct.
	StatsGrid_ValidateTeamColors();

	// Get player state so we can know where he is (or on rare occassions, she).
	state = cl.frames[cl.oldparsecount & UPDATE_MASK].playerstate;

	// Get the info for the player.
	info = cl.players;

	for (i = 0; i < MAX_CLIENTS; i++, info++, state++) {
		// Skip spectators.
		if(!cl.players[i].name[0] || cl.players[i].spectator) {
			continue;
		}

		// Calculate the weight for this player and set it at the
		// cell the player is located on in the grid.
		StatsGrid_SetWeightForPlayer(stats_grid, state, info);
	}

	// Reset the amount of cells that each team "holds" since
	// they will be recalculated when the weights are decreased.
	stats_grid->teams[STATS_TEAM1].hold_count = 0;
	stats_grid->teams[STATS_TEAM2].hold_count = 0;
	StatsGrid_ResetHoldItemCounts();

	// Go through all the cells and decrease their weights.
	for(row = 0; row < stats_grid->row_count; row++) {
		for(col = 0; col < stats_grid->col_count; col++) {
			StatsGrid_DecreaseTeamWeights(stats_grid, row, col, stats_grid->hold_threshold);
		}
	}
}




// HUD rendering

#define HUD_TEAMHOLDINFO_STYLE_TEAM_NAMES		0
#define HUD_TEAMHOLDINFO_STYLE_PERCENT_BARS		1
#define HUD_TEAMHOLDINFO_STYLE_PERCENT_BARS2	2

// Team hold filters.
static qbool teamhold_show_pent = false;
static qbool teamhold_show_quad = false;
static qbool teamhold_show_ring = false;
static qbool teamhold_show_suit = false;
static qbool teamhold_show_rl = false;
static qbool teamhold_show_lg = false;
static qbool teamhold_show_gl = false;
static qbool teamhold_show_sng = false;
static qbool teamhold_show_mh = false;
static qbool teamhold_show_ra = false;
static qbool teamhold_show_ya = false;
static qbool teamhold_show_ga = false;

void TeamHold_DrawBars(int x, int y, int width, int height,
					   float team1_percent, float team2_percent,
					   int team1_color, int team2_color,
					   float opacity)
{
	int team1_width = 0;
	int team2_width = 0;
	int bar_height = 0;

	bar_height = Q_rint(height / 2.0);
	team1_width = (int)(width * team1_percent);
	team2_width = (int)(width * team2_percent);

	clamp(team1_width, 0, width);
	clamp(team2_width, 0, width);

	Draw_AlphaFill(x, y, team1_width, bar_height, team1_color, opacity);

	y += bar_height;

	Draw_AlphaFill(x, y, team2_width, bar_height, team2_color, opacity);
}

void TeamHold_DrawPercentageBar(
	int x, int y, int width, int height,
	float team1_percent, float team2_percent,
	int team1_color, int team2_color,
	int show_text, int vertical,
	int vertical_text, float opacity, float scale,
	qbool proportional
)
{
	int _x, _y;
	int _width, _height;

	if (vertical) {
		//
		// Draw vertical.
		//

		// Team 1.
		_x = x;
		_y = y;
		_width = max(0, width);
		_height = Q_rint(height * team1_percent);
		_height = max(0, height);

		Draw_AlphaFill(_x, _y, _width, _height, team1_color, opacity);

		// Team 2.
		_x = x;
		_y = Q_rint(y + (height * team1_percent));
		_width = max(0, width);
		_height = Q_rint(height * team2_percent);
		_height = max(0, _height);

		Draw_AlphaFill(_x, _y, _width, _height, team2_color, opacity);

		// Show the percentages in numbers also.
		if (show_text) {
			// TODO: Move this to a separate function (since it's prett much copy and paste for both teams).
			// Team 1.
			if (team1_percent > 0.05) {
				if (vertical_text) {
					int percent = 0;
					int percent10 = 0;
					int percent100 = 0;

					_x = x + (width / 2) - FontFixedWidth(1, scale / 2, true, proportional);
					_y = Q_rint(y + (height * team1_percent) / 2 - 8 * 1.5 * scale);

					percent = Q_rint(100 * team1_percent);

					if ((percent100 = percent / 100)) {
						Draw_SString(_x, _y, va("%d", percent100), scale, proportional);
						_y += 8 * scale;
					}

					if ((percent10 = percent / 10)) {
						Draw_SString(_x, _y, va("%d", percent10), scale, proportional);
						_y += 8 * scale;
					}

					Draw_SString(_x, _y, va("%d", percent % 10), scale, proportional);
					_y += 8 * scale;

					Draw_SString(_x, _y, "%", scale, proportional);
				}
				else {
					_x = x + (width / 2) - FontFixedWidth(1, 1.5 * scale, 1, proportional);
					_y = Q_rint(y + (height * team1_percent) / 2 - 8 * scale * 0.5);
					Draw_SString(_x, _y, va("%2.0f%%", 100 * team1_percent), scale, false);
				}
			}

			// Team 2.
			if (team2_percent > 0.05) {
				if (vertical_text) {
					int percent = 0;
					int percent10 = 0;
					int percent100 = 0;

					_x = x + (width / 2) - FontFixedWidth(1, scale / 2, true, proportional);
					_y = Q_rint(y + (height * team1_percent) + (height * team2_percent) / 2 - 12);

					percent = Q_rint(100 * team2_percent);

					if ((percent100 = percent / 100)) {
						Draw_SString(_x, _y, va("%d", percent100), scale, proportional);
						_y += 8;
					}

					if ((percent10 = percent / 10)) {
						Draw_SString(_x, _y, va("%d", percent10), scale, proportional);
						_y += 8;
					}

					Draw_SString(_x, _y, va("%d", percent % 10), scale, proportional);
					_y += 8;

					Draw_SString(_x, _y, "%", scale, proportional);
				}
				else {
					_x = x + (width / 2) - FontFixedWidth(1, scale * 1.5, true, proportional);
					_y = Q_rint(y + (height * team1_percent) + (height * team2_percent) / 2 - 4);
					Draw_SString(_x, _y, va("%2.0f%%", 100 * team2_percent), scale, proportional);
				}
			}
		}
	}
	else {
		//
		// Draw horizontal.
		//

		// Team 1.
		_x = x;
		_y = y;
		_width = Q_rint(width * team1_percent);
		_width = max(0, _width);
		_height = max(0, height);

		Draw_AlphaFill(_x, _y, _width, _height, team1_color, opacity);

		// Team 2.
		_x = Q_rint(x + (width * team1_percent));
		_y = y;
		_width = Q_rint(width * team2_percent);
		_width = max(0, _width);
		_height = max(0, height);

		Draw_AlphaFill(_x, _y, _width, _height, team2_color, opacity);

		// Show the percentages in numbers also.
		if (show_text) {
			// Team 1.
			if (team1_percent > 0.05) {
				_x = Q_rint(x + (width * team1_percent) / 2 - FontFixedWidth(1, scale, true, proportional));
				_y = y + (height / 2) - 4 * scale;
				Draw_SString(_x, _y, va("%2.0f%%", 100 * team1_percent), scale, proportional);
			}

			// Team 2.
			if (team2_percent > 0.05) {
				_x = Q_rint(x + (width * team1_percent) + (width * team2_percent) / 2 - FontFixedWidth(1, scale, true, proportional));
				_y = y + (height / 2) - 4 * scale;
				Draw_SString(_x, _y, va("%2.0f%%", 100 * team2_percent), scale, proportional);
			}
		}
	}
}

static void TeamHold_OnChangeItemFilterInfo(cvar_t *var, char *s, qbool *cancel)
{
	char *start = s;
	char *end = start;
	int order = 0;

	// Parse the item filter.
	teamhold_show_rl = Utils_RegExpMatch("RL", s);
	teamhold_show_quad = Utils_RegExpMatch("QUAD", s);
	teamhold_show_ring = Utils_RegExpMatch("RING", s);
	teamhold_show_pent = Utils_RegExpMatch("PENT", s);
	teamhold_show_suit = Utils_RegExpMatch("SUIT", s);
	teamhold_show_lg = Utils_RegExpMatch("LG", s);
	teamhold_show_gl = Utils_RegExpMatch("GL", s);
	teamhold_show_sng = Utils_RegExpMatch("SNG", s);
	teamhold_show_mh = Utils_RegExpMatch("MH", s);
	teamhold_show_ra = Utils_RegExpMatch("RA", s);
	teamhold_show_ya = Utils_RegExpMatch("YA", s);
	teamhold_show_ga = Utils_RegExpMatch("GA", s);

	// Reset the ordering of the items.
	StatsGrid_ResetHoldItemsOrder();

	// Trim spaces from the start of the word.
	while (*start && *start == ' ') {
		start++;
	}

	end = start;

	// Go through the string word for word and set a
	// rising order for each hold item based on their
	// order in the string.
	while (*end) {
		if (*end != ' ') {
			// Not at the end of the word yet.
			end++;
			continue;
		}
		else {
			// We've found a word end.
			char temp[256];

			// Try matching the current word with a hold item
			// and set it's ordering according to it's placement
			// in the string.
			strlcpy(temp, start, min(end - start, sizeof(temp)));
			StatsGrid_SetHoldItemOrder(temp, order);
			order++;

			// Get rid of any additional spaces.
			while (*end && *end == ' ') {
				end++;
			}

			// Start trying to find a new word.
			start = end;
		}
	}

	// Order the hold items.
	StatsGrid_SortHoldItems();
}

void SCR_HUD_DrawTeamHoldInfo(hud_t *hud)
{
	int i;
	int x, y;
	int width, height;

	static cvar_t
		*hud_teamholdinfo_style = NULL,
		*hud_teamholdinfo_opacity,
		*hud_teamholdinfo_width,
		*hud_teamholdinfo_height,
		*hud_teamholdinfo_onlytp,
		*hud_teamholdinfo_itemfilter,
		*hud_teamholdinfo_scale,
		*hud_teamholdinfo_proportional;

	if (hud_teamholdinfo_style == NULL)    // first time
	{
		char val[256];

		hud_teamholdinfo_style = HUD_FindVar(hud, "style");
		hud_teamholdinfo_opacity = HUD_FindVar(hud, "opacity");
		hud_teamholdinfo_width = HUD_FindVar(hud, "width");
		hud_teamholdinfo_height = HUD_FindVar(hud, "height");
		hud_teamholdinfo_onlytp = HUD_FindVar(hud, "onlytp");
		hud_teamholdinfo_itemfilter = HUD_FindVar(hud, "itemfilter");
		hud_teamholdinfo_scale = HUD_FindVar(hud, "scale");
		hud_teamholdinfo_proportional = HUD_FindVar(hud, "proportional");

		// Unecessary to parse the item filter string on each frame.
		hud_teamholdinfo_itemfilter->OnChange = TeamHold_OnChangeItemFilterInfo;

		// Parse the item filter the first time (trigger the OnChange function above).
		strlcpy(val, hud_teamholdinfo_itemfilter->string, sizeof(val));
		Cvar_Set(hud_teamholdinfo_itemfilter, val);
	}

	// Get the height based on how many items we have, or what the user has set it to.
	height = max(0, hud_teamholdinfo_height->value);
	width = max(0, hud_teamholdinfo_width->value);

	// Don't show when not in teamplay/demoplayback.
	if (!HUD_ShowInDemoplayback(hud_teamholdinfo_onlytp->value)) {
		HUD_PrepareDraw(hud, width, height, &x, &y);
		return;
	}

	// We don't have anything to show.
	if (stats_important_ents == NULL || stats_grid == NULL) {
		HUD_PrepareDraw(hud, width, height, &x, &y);
		return;
	}

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		int _y = 0;

		_y = y;

		// Go through all the items and print the stats for them.
		for (i = 0; i < stats_important_ents->count; i++) {
			float team1_percent;
			float team2_percent;
			int team1_hold_count = 0;
			int team2_hold_count = 0;
			int names_width = 0;

			// Don't draw outside the specified height.
			if ((_y - y) + 8 * hud_teamholdinfo_scale->value > height) {
				break;
			}

			// If the item isn't of the specified type, then skip it.
			if (!((teamhold_show_rl && !strncmp(stats_important_ents->list[i].name, "RL", 2))
				|| (teamhold_show_quad && !strncmp(stats_important_ents->list[i].name, "QUAD", 4))
				|| (teamhold_show_ring && !strncmp(stats_important_ents->list[i].name, "RING", 4))
				|| (teamhold_show_pent && !strncmp(stats_important_ents->list[i].name, "PENT", 4))
				|| (teamhold_show_suit && !strncmp(stats_important_ents->list[i].name, "SUIT", 4))
				|| (teamhold_show_lg && !strncmp(stats_important_ents->list[i].name, "LG", 2))
				|| (teamhold_show_gl && !strncmp(stats_important_ents->list[i].name, "GL", 2))
				|| (teamhold_show_sng && !strncmp(stats_important_ents->list[i].name, "SNG", 3))
				|| (teamhold_show_mh && !strncmp(stats_important_ents->list[i].name, "MH", 2))
				|| (teamhold_show_ra && !strncmp(stats_important_ents->list[i].name, "RA", 2))
				|| (teamhold_show_ya && !strncmp(stats_important_ents->list[i].name, "YA", 2))
				|| (teamhold_show_ga && !strncmp(stats_important_ents->list[i].name, "GA", 2))
				)) {
				continue;
			}

			// Calculate the width of the longest item name so we can use it for padding.
			names_width = FontFixedWidth(stats_important_ents->longest_name + 1, hud_teamholdinfo_scale->value, false, hud_teamholdinfo_proportional->integer);

			// Calculate the percentages of this item that the two teams holds.
			team1_hold_count = stats_important_ents->list[i].teams_hold_count[STATS_TEAM1];
			team2_hold_count = stats_important_ents->list[i].teams_hold_count[STATS_TEAM2];

			team1_percent = ((float)team1_hold_count) / (team1_hold_count + team2_hold_count);
			team2_percent = ((float)team2_hold_count) / (team1_hold_count + team2_hold_count);

			team1_percent = fabs(max(0, team1_percent));
			team2_percent = fabs(max(0, team2_percent));

			// Write the name of the item.
			Draw_SColoredStringBasic(x, _y, va("&cff0%s:", stats_important_ents->list[i].name), 0, hud_teamholdinfo_scale->value, hud_teamholdinfo_proportional->integer);

			if (hud_teamholdinfo_style->value == HUD_TEAMHOLDINFO_STYLE_TEAM_NAMES) {
				//
				// Prints the team name that holds the item.
				//
				if (team1_percent > team2_percent) {
					Draw_SColoredStringBasic(x + names_width, _y, stats_important_ents->teams[STATS_TEAM1].name, 0, hud_teamholdinfo_scale->value, hud_teamholdinfo_proportional->integer);
				}
				else if (team1_percent < team2_percent) {
					Draw_SColoredStringBasic(x + names_width, _y, stats_important_ents->teams[STATS_TEAM2].name, 0, hud_teamholdinfo_scale->value, hud_teamholdinfo_proportional->integer);
				}
			}
			else if (hud_teamholdinfo_style->value == HUD_TEAMHOLDINFO_STYLE_PERCENT_BARS) {
				//
				// Show a percentage bar for the item.
				//
				TeamHold_DrawPercentageBar(
					x + names_width, _y,
					Q_rint(hud_teamholdinfo_width->value - names_width), 8,
					team1_percent, team2_percent,
					stats_important_ents->teams[STATS_TEAM1].color,
					stats_important_ents->teams[STATS_TEAM2].color,
					0, // Don't show percentage values, get's too cluttered.
					false,
					false,
					hud_teamholdinfo_opacity->value,
					hud_teamholdinfo_scale->value,
					hud_teamholdinfo_proportional->integer
				);
			}
			else if (hud_teamholdinfo_style->value == HUD_TEAMHOLDINFO_STYLE_PERCENT_BARS2) {
				TeamHold_DrawBars(x + names_width, _y,
								  Q_rint(hud_teamholdinfo_width->value - names_width), 8,
								  team1_percent, team2_percent,
								  stats_important_ents->teams[STATS_TEAM1].color,
								  stats_important_ents->teams[STATS_TEAM2].color,
								  hud_teamholdinfo_opacity->value);
			}

			// Next line.
			_y += 8 * hud_teamholdinfo_scale->value;
		}
	}
}

void SCR_HUD_DrawTeamHoldBar(hud_t *hud)
{
	int x, y;
	int height = 8;
	int width = 0;
	float team1_percent = 0;
	float team2_percent = 0;

	static cvar_t
		*hud_teamholdbar_style = NULL,
		*hud_teamholdbar_opacity,
		*hud_teamholdbar_width,
		*hud_teamholdbar_height,
		*hud_teamholdbar_vertical,
		*hud_teamholdbar_show_text,
		*hud_teamholdbar_onlytp,
		*hud_teamholdbar_vertical_text,
		*hud_teamholdbar_scale,
		*hud_teamholdbar_proportional;

	if (hud_teamholdbar_style == NULL)    // first time
	{
		hud_teamholdbar_style = HUD_FindVar(hud, "style");
		hud_teamholdbar_opacity = HUD_FindVar(hud, "opacity");
		hud_teamholdbar_width = HUD_FindVar(hud, "width");
		hud_teamholdbar_height = HUD_FindVar(hud, "height");
		hud_teamholdbar_vertical = HUD_FindVar(hud, "vertical");
		hud_teamholdbar_show_text = HUD_FindVar(hud, "show_text");
		hud_teamholdbar_onlytp = HUD_FindVar(hud, "onlytp");
		hud_teamholdbar_vertical_text = HUD_FindVar(hud, "vertical_text");
		hud_teamholdbar_scale = HUD_FindVar(hud, "scale");
		hud_teamholdbar_proportional = HUD_FindVar(hud, "proportional");
	}

	height = max(1, hud_teamholdbar_height->value);
	width = max(0, hud_teamholdbar_width->value);

	// Don't show when not in teamplay/demoplayback.
	if (!HUD_ShowInDemoplayback(hud_teamholdbar_onlytp->value)) {
		HUD_PrepareDraw(hud, width, height, &x, &y);
		return;
	}

	if (HUD_PrepareDraw(hud, width, height, &x, &y)) {
		// We need something to work with.
		if (stats_grid != NULL) {
			// Check if we have any hold values to calculate from.
			if (stats_grid->teams[STATS_TEAM1].hold_count + stats_grid->teams[STATS_TEAM2].hold_count > 0) {
				// Calculate the percentage for the two teams for the "team strength bar".
				team1_percent = ((float)stats_grid->teams[STATS_TEAM1].hold_count) / (stats_grid->teams[STATS_TEAM1].hold_count + stats_grid->teams[STATS_TEAM2].hold_count);
				team2_percent = ((float)stats_grid->teams[STATS_TEAM2].hold_count) / (stats_grid->teams[STATS_TEAM1].hold_count + stats_grid->teams[STATS_TEAM2].hold_count);

				team1_percent = fabs(max(0, team1_percent));
				team2_percent = fabs(max(0, team2_percent));
			}
			else {
				Draw_AlphaFill(x, y, hud_teamholdbar_width->value, height, 0, hud_teamholdbar_opacity->value*0.5);
				return;
			}

			// Draw the percentage bar.
			TeamHold_DrawPercentageBar(
				x, y, width, height,
				team1_percent, team2_percent,
				stats_grid->teams[STATS_TEAM1].color,
				stats_grid->teams[STATS_TEAM2].color,
				hud_teamholdbar_show_text->value,
				hud_teamholdbar_vertical->value,
				hud_teamholdbar_vertical_text->value,
				hud_teamholdbar_opacity->value,
				hud_teamholdbar_scale->value,
				hud_teamholdbar_proportional->integer
			);
		}
		else {
			// If there's no stats grid available we don't know what to show, so just show a black frame.
			Draw_AlphaFill(x, y, hud_teamholdbar_width->value, height, 0, hud_teamholdbar_opacity->value * 0.5);
		}
	}
}

void TeamHold_HudInit(void)
{
	teamholdinfo = HUD_Register(
		"teamholdinfo", NULL, "Shows which important items in the level that are being held by the teams.",
		HUD_PLUSMINUS, ca_active, 0, SCR_HUD_DrawTeamHoldInfo,
		"0", "top", "left", "bottom", "0", "0", "0", "0 0 0", NULL,
		"opacity", "0.8",
		"width", "200",
		"height", "8",
		"onlytp", "0",
		"style", "1",
		"itemfilter", "quad ra ya ga mega pent rl quad",
		"scale", "1",
		"proportional", "0",
		NULL
	);

	teamholdbar = HUD_Register(
		"teamholdbar", NULL, "Shows how much of the level (in percent) that is currently being held by either team.",
		HUD_PLUSMINUS, ca_active, 0, SCR_HUD_DrawTeamHoldBar,
		"0", "top", "left", "bottom", "0", "0", "0", "0 0 0", NULL,
		"opacity", "0.8",
		"width", "200",
		"height", "8",
		"vertical", "0",
		"vertical_text", "0",
		"show_text", "1",
		"onlytp", "0",
		"scale", "1",
		"proportional", "0",
		NULL
	);
}


================================================
FILE: src/stats_grid.h
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "common.h"
#include "q_shared.h"

#ifndef __STATS_GRID__H__
#define __STATS_GRID__H__

#define TEAM_COUNT		2
#define STATS_TEAM1		0
#define STATS_TEAM2		1

typedef struct cell_weight_s
{
	float			weight;					// Weight of the box. Between 0.0 and 1.0
	float			change_time;			// The last time the weight was changed. (Used for fading weight).
	float			death_weight;			// The amount of deaths by this team in this cell (Never fades).
} cell_weight_t;

typedef struct stats_cell_s
{
	cell_weight_t	teams[TEAM_COUNT];		// The team weights for this cell.
	float			tl_x;					// Top left x position of the cell.
	float			tl_y;					// Top left y position of the cell.
} stats_cell_t;

typedef struct stats_team_s
{
	char	name[MAX_INFO_STRING];			// Team name.
	int		color;							// Team color.
	int		hold_count;						// The amount of visited cells that this team "holds".
} stats_team_t;

typedef struct stats_weight_grid_s
{
	stats_cell_t	**cells;				// The cells.
	float			falloff_interval;		// The duration since the last weight change
											// to decrease the weight of the cells in the grid.
	float			falloff_value;			// The amount the cell weight should decrease by
											// at each falloff interval.
	int				cell_length;			// Cell side length.
	int				row_count;				// Row count.
	int				col_count;				// Column count.
	int				width;					// The width of the grid.
	int				height;					// The height of the grid.
	stats_team_t	teams[TEAM_COUNT];		// The teams (No more than 2). 
	float			hold_threshold;			// The threshold for the weight that is required before
											// a cell is considered being held by a team. (0.0 is default).
} stats_weight_grid_t;

typedef struct stats_entity_s
{
	char			name[MAX_INFO_STRING];	// The name of the entity (RA, RL, YA, QUAD).
	vec3_t			origin;					// The entitys origin.
	int				teams_hold_count[TEAM_COUNT];
	int				order;
} stats_entity_t;

typedef struct
{
	stats_entity_t	*list;
	int				count;
	float			hold_radius;
	int				longest_name;
	stats_team_t	teams[TEAM_COUNT];
} stats_entities_t;

void StatsGrid_Remove(stats_weight_grid_t **grid);
void StatsGrid_Init(stats_weight_grid_t **grid, 
						 float falloff_interval, 
						 float falloff_value,
						 int cell_length,
						 float grid_width, 
						 float grid_height,
						 float hold_threshold);
void StatsGrid_InitTeamNames(stats_weight_grid_t *grid);
void StatsGrid_Change(stats_weight_grid_t *grid,
							float falloff_interval,
							float falloff_value,
							int grid_width,
							int grid_height);
void StatsGrid_DecreaseWeight(cell_weight_t *weight, stats_weight_grid_t *grid);
void StatsGrid_Gather(void);
void StatsGrid_ResetHoldItems(void);
void StatsGrid_SortHoldItems(void);
void StatsGrid_SetHoldItemOrder(const char *item_name, int order);
void StatsGrid_ResetHoldItemsOrder(void);

extern stats_weight_grid_t	*stats_grid;			// The weight grid for all the statistics.
extern stats_entities_t		*stats_important_ents;	// A list of "important" entities on the map, and counts on what team holds it.

#endif


================================================
FILE: src/sv_ccmds.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
	
*/

#ifndef CLIENTONLY
#include "qwsvdef.h"

cvar_t	sv_cheats = {"sv_cheats", "0"};
qbool	sv_allow_cheats = false;

int fp_messages=4, fp_persecond=4, fp_secondsdead=10;
char fp_msg[255] = { 0 };
extern	cvar_t		sv_logdir; //bliP: 24/7 logdir
extern	redirect_t	sv_redirected;

void SV_Localinfo_Set (const char *name, const char *value);

/*
===============================================================================

OPERATOR CONSOLE ONLY COMMANDS

These commands can only be entered from stdin or by a remote operator datagram
===============================================================================
*/

/*
==================
SV_Quit
==================
*/
void SV_Quit (qbool restart)
{
	SV_Shutdown ("Server shutdown.\n");
#ifdef SERVERONLY
	Sys_Quit (restart);
#else
	Host_Quit(); // will also call SV_Shutdown(), but it is not an issue.
#endif
}

/*
==================
SV_Quit_f
==================
*/
void SV_Quit_f (void)
{
	SV_Quit(false);
}

/*
==================
SV_Restart_f
==================
*/
void SV_Restart_f (void)
{
	SV_Quit(true);
}

/*
============
SV_Logfile
============
*/
void SV_Logfile (int sv_log, qbool newlog)
{
	int		sv_port = NET_UDPSVPort();
	char	name[MAX_OSPATH];
	int		i;

	// newlog - stands for: we want open new log file

	if (logs[sv_log].sv_logfile)
	{
		// turn off logging

		fclose (logs[sv_log].sv_logfile);
		logs[sv_log].sv_logfile = NULL;

		// in case of NON "newlog" we do some additional work and exit function
		if (!newlog)
		{
			Con_Printf ("%s", logs[sv_log].message_off);
			logs[sv_log].log_level = 0;
			return;
		}
	}

	// always use new log file for frag log
	if (sv_log == FRAG_LOG || sv_log == MOD_FRAG_LOG)
		newlog = true;

	for (i = 0; i < 1000; i++)
	{
		snprintf (name, sizeof(name), "%s/%s%d_%04d.log", sv_logdir.string, logs[sv_log].file_name, sv_port, i);

		if (!COM_FileExists(name))
			break; // file doesn't exist
	}

	if (!newlog) //use last log if possible
		snprintf (name, sizeof(name), "%s/%s%d_%04d.log",  sv_logdir.string, logs[sv_log].file_name, sv_port, (int)max(0, i - 1));

	Con_Printf ("Logging %s to %s\n", logs[sv_log].message_on, name);

	if (!(logs[sv_log].sv_logfile = fopen (name, "a")))
	{
		Con_Printf ("Failed.\n");
		logs[sv_log].sv_logfile = NULL;
		return;
	}

	switch (sv_log)
	{
	case TELNET_LOG:
		logs[TELNET_LOG].log_level = Cvar_Value("telnet_log_level");
		break;
	case CONSOLE_LOG:
		logs[CONSOLE_LOG].log_level = Cvar_Value("qconsole_log_say");
		break;
	default:
		logs[sv_log].log_level = 1;
	}
}

/*
============
SV_Logfile_f
============
*/
void SV_Logfile_f (void)
{
	SV_Logfile(CONSOLE_LOG, false);
}

/*
============
SV_ErrorLogfile_f
============
*/
void SV_ErrorLogfile_f (void)
{
	SV_Logfile(ERROR_LOG, false);
}

/*
============
SV_RconLogfile_f
============
*/
void SV_RconLogfile_f (void)
{
	SV_Logfile(RCON_LOG, false);
}

/*
============
SV_RconLogfile_f
============
*/
void SV_TelnetLogfile_f (void)
{
	SV_Logfile(TELNET_LOG, false);
}

/*
============
SV_FragLogfile_f
============
*/
void SV_FragLogfile_f (void)
{
	SV_Logfile(FRAG_LOG, false);
}

//bliP: player log
/*
============
SV_PlayerLogfile_f
============
*/
void SV_PlayerLogfile_f (void)
{
	SV_Logfile(PLAYER_LOG, false);
}
//<-

/*
============
SV_ModFragLogfile_f
============
*/
void SV_ModFragLogfile_f (void)
{
	SV_Logfile(MOD_FRAG_LOG, false);
}

log_t	logs[MAX_LOG] =
    {
        {NULL, "logfile",        "qconsole_", "File logging off.\n",          "console",  SV_Logfile_f,        0},
        {NULL, "logerrors",      "qerror_",   "Error logging off.\n",         "errors",   SV_ErrorLogfile_f,   0},
        {NULL, "logrcon",        "rcon_",     "Rcon logging off.\n",          "rcon",     SV_RconLogfile_f,    0},
        {NULL, "logtelnet",      "qtelnet_",  "Telnet logging off.\n",        "telnet",   SV_TelnetLogfile_f,  0},
        {NULL, "fraglogfile",    "frag_",     "Frag file logging off.\n",     "frags",    SV_FragLogfile_f,    0},
        {NULL, "logplayers",     "player_",   "Player logging off.\n",        "players",  SV_PlayerLogfile_f,  0},//bliP: player logging
        {NULL, "modfraglogfile", "modfrag_",  "Mod frag file logging off.\n", "modfrags", SV_ModFragLogfile_f, 0}
    };

/*
==================
SV_SetPlayer
 
Sets sv_client and sv_player to the player with idnum Cmd_Argv(1)
==================
*/
qbool SV_SetPlayer (void)
{
	client_t	*cl;
	int			i;
	int			idnum;

	idnum = Q_atoi(Cmd_Argv(1));

	// HACK: for cheat commands which comes from client rather than from server console
	if (sv_client && sv_redirected == RD_CLIENT)
	{
		idnum = sv_client->userid;
	}

	for (i=0,cl=svs.clients ; i<MAX_CLIENTS ; i++,cl++)
	{
		if (!cl->state)
			continue;
		if (cl->userid == idnum)
		{
			sv_client = cl;
			sv_player = sv_client->edict;
			return true;
		}
	}
	Con_Printf ("Userid %i is not on the server\n", idnum);
	return false;
}


/*
==================
SV_God_f
 
Sets client to godmode
==================
*/
void SV_God_f (void)
{
	if (!sv_allow_cheats)
	{
		Con_Printf ("Cheats are not allowed on this server\n");
		return;
	}

	if (!SV_SetPlayer ())
		return;

	sv_player->v->flags = (int)sv_player->v->flags ^ FL_GODMODE;
	if (!((int)sv_player->v->flags & FL_GODMODE) )
		SV_ClientPrintf (sv_client, PRINT_HIGH, "godmode OFF\n");
	else
		SV_ClientPrintf (sv_client, PRINT_HIGH, "godmode ON\n");
}


void SV_Noclip_f (void)
{
	if (!sv_allow_cheats)
	{
		Con_Printf ("Cheats are not allowed on this server\n");
		return;
	}

	if (!SV_SetPlayer ())
		return;

	if (sv_player->v->movetype != MOVETYPE_NOCLIP)
	{
		sv_player->v->movetype = MOVETYPE_NOCLIP;
		SV_ClientPrintf (sv_client, PRINT_HIGH, "noclip ON\n");
	}
	else
	{
		sv_player->v->movetype = MOVETYPE_WALK;
		SV_ClientPrintf (sv_client, PRINT_HIGH, "noclip OFF\n");
	}
}


/*
==================
SV_Give_f
==================
*/
void SV_Give_f (void)
{
	char	*t;
	int		v, cnt;

	if (!sv_allow_cheats)
	{
		Con_Printf ("Cheats are not allowed on this server\n");
		return;
	}

	if (!SV_SetPlayer ())
		return;

	// HACK: for cheat commands which comes from client rather than from server console
	cnt = (sv_redirected == RD_CLIENT ? 1 : 2);

	t = Cmd_Argv(cnt++);
	v = Q_atoi (Cmd_Argv(cnt++));

	switch (t[0])
	{
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
		sv_player->v->items = (int)sv_player->v->items | IT_SHOTGUN<< (t[0] - '2');
		break;

	case 's':
		sv_player->v->ammo_shells = v;
		break;
	case 'n':
		sv_player->v->ammo_nails = v;
		break;
	case 'r':
		sv_player->v->ammo_rockets = v;
		break;
	case 'h':
		sv_player->v->health = v;
		break;
	case 'c':
		sv_player->v->ammo_cells = v;
		break;
	}
}

void SV_Fly_f (void)
{
	if (!sv_allow_cheats)
	{
		Con_Printf ("Cheats are not allowed on this server\n");
		return;
	}

	if (!SV_SetPlayer ())
		return;

	if (sv_player->v->solid != SOLID_SLIDEBOX)
		return;		// dead don't fly

	if (sv_player->v->movetype != MOVETYPE_FLY)
	{
		sv_player->v->movetype = MOVETYPE_FLY;
		SV_ClientPrintf (sv_client, PRINT_HIGH, "flymode ON\n");
	}
	else
	{
		sv_player->v->movetype = MOVETYPE_WALK;
		SV_ClientPrintf (sv_client, PRINT_HIGH, "flymode OFF\n");
	}
}

/*
======================
SV_Map_f

handle a 
map <mapname>
command from the console or progs.
======================
*/
void SV_Map (qbool now)
{
	static char     level[MAX_QPATH];
	static char     expanded[MAX_QPATH];
	static char     entityfile[MAX_QPATH];
	static qbool    changed = false;

	char	*s;

	// if now, change it
	if (now)
	{
		if (!changed)
			return;

		changed = false;

		if (!FS_FLocateFile(expanded, FSLFRT_IFFOUND, NULL))
		{
			Sys_Printf ("Can't find %s\n", expanded);
			return;
		}

		if (sv.mvdrecording)
			SV_MVDStop_f();

#ifndef SERVERONLY
		CL_BeginLocalConnection ();
#endif

		// -> scream
		if ((int)frag_log_type.value)
		{
			//bliP: date check ->
			date_t date;
			SV_TimeOfDay(&date, "%a %b %d, %H:%M:%S %Y");
			s = va("\\newmap\\%s\\\\\\\\%d-%d-%d %d:%d:%d\\\n",
			       level,
			       date.year,
			       date.mon+1,
			       //bliP: check me - date.mon or date.mon+1? existing code was date.mon+1
			       date.day,
			       date.hour,
			       date.min,
			       date.sec);
			//<-
			if (logs[FRAG_LOG].sv_logfile)
				SZ_Print (&svs.log[svs.logsequence&1], s);
			SV_Write_Log(FRAG_LOG, 0, s);
		}
		// <-

		SV_SpawnServer (level, !strcasecmp(Cmd_Argv(0), "devmap"), entityfile, false);

#ifdef SERVERONLY
		SV_BroadcastCommand ("changing\n"
		                     "reconnect\n");
		SV_SendMessagesToAll ();
#else
		SV_BroadcastCommand ("reconnect\n");
#endif

		return;
	}

	// get the map name, but don't change now, could be executed from progs.dat

	if (Cmd_Argc() < 2 || Cmd_Argc() > 3)
	{
		Con_Printf ("map <levelname> [<entityfile>] : continue game on a new level\n");
		return;
	}

	strlcpy (level, Cmd_Argv(1), MAX_QPATH);

	memset(entityfile, 0, sizeof(entityfile));
	if (Cmd_Argc() >= 3)
		strlcpy (entityfile, Cmd_Argv(2), MAX_QPATH);

	// check to make sure the level exists
	snprintf (expanded, MAX_QPATH, "maps/%s.bsp", level);

	// Flush FS cache on each map change.
	FS_FlushFSHash();

	if (!FS_FLocateFile(expanded, FSLFRT_IFFOUND, NULL))
	{
		Con_Printf ("Can't find %s\n", expanded);
		return;
	}

	changed = true;
#ifndef SERVERONLY
	if (!com_serveractive) {
		Host_EndGame();
	}
	com_serveractive = true;
#endif
}

void SV_Map_f (void)
{
	SV_Map(false);
}

/*==================
SV_ReplaceChar
Replace char in string
==================*/
void SV_ReplaceChar(char *s, char from, char to)
{
	if (s)
		for ( ;*s ; ++s)
			if (*s == from)
				*s = to;
}
//bliP: ls, rm, rmdir, chmod ->
/*==================
SV_ListFiles_f
Lists files
==================*/
void SV_ListFiles_f (void)
{
	dir_t	dir;
	file_t	*list;
	char	*key;
	char	*dirname;
	int	i;

	if (Cmd_Argc() < 2)
	{
		Con_Printf ("ls <directory> <match>\n");
		return;
	}

	dirname = Cmd_Argv(1);
	SV_ReplaceChar(dirname, '\\', '/');

	// Double-check then move to FS_UnsafeFilename() ?
	if (	!strncmp(dirname, "../", 3) || strstr(dirname, "/../") || *dirname == '/'
	        ||	( (i = strlen(dirname)) < 3 ? 0 : !strncmp(dirname + i - 3, "/..", 4) )
	        ||	!strncmp(dirname, "..", 3)
#ifdef _WIN32
	        ||	( dirname[1] == ':' && ((*dirname >= 'a' && *dirname <= 'z') ||
	                                   (*dirname >= 'A' && *dirname <= 'Z'))
	           )
#endif //_WIN32
	   )
	{
		Con_Printf("Unable to list %s\n", dirname);
		return;
	}

	Con_Printf("Content of %s/*.*\n", dirname);
	dir = Sys_listdir(va("%s", dirname), ".*", SORT_BY_NAME);
	list = dir.files;
	if (!list->name[0])
	{
		Con_Printf("No files\n");
		return;
	}

	key = (Cmd_Argc() == 3) ? Cmd_Argv(2) : (char *) "";

	//directories...
	for (; list->name[0]; list++)
	{
		if (!strstr(list->name, key) || !list->isdir)
			continue;
		Con_Printf("- %s\n", list->name);
	}

	list = dir.files;

	//files...
	for (; list->name[0]; list++)
	{
		if (!strstr(list->name, key) || list->isdir)
			continue;
		if ((int)list->size / 1024 > 0)
			Con_Printf("%s %.0fKB (%.2fMB)\n", list->name,
			           (float)list->size / 1024, (float)list->size / 1024 / 1024);
		else
			Con_Printf("%s %dB\n", list->name, list->size);
	}
	Con_Printf("Total: %d files, %.0fKB (%.2fMB)\n", dir.numfiles,
	           (float)dir.size / 1024, (float)dir.size / 1024 / 1024);
}

/*==================
SV_RemoveDirectory_f
Removes an empty directory
==================*/
void SV_RemoveDirectory_f (void)
{
	char	*dirname;

	if (Cmd_Argc() != 2)
	{
		Con_Printf("rmdir <directory>\n");
		return;
	}

	dirname = Cmd_Argv(1);
	SV_ReplaceChar(dirname, '\\', '/');

	if (	!strncmp(dirname, "../", 3) || strstr(dirname, "/../") || *dirname == '/'
#ifdef _WIN32
	        ||	( dirname[1] == ':' && ((*dirname >= 'a' && *dirname <= 'z') ||
	                                   (*dirname >= 'A' && *dirname <= 'Z'))
	           )
#endif //_WIN32
	   )
	{
		Con_Printf("Unable to remove\n");
		return;
	}

	if (!Sys_rmdir(dirname))
		Con_Printf("Directory %s successfully removed\n", dirname);
	else
		Con_Printf("Unable to remove directory %s\n", dirname);
}

/*==================
SV_RemoveFile_f
Remove a file
==================*/
void SV_RemoveFile_f (void)
{
	char *dirname;
	char *filename;
	int i;

	if (Cmd_Argc() < 3)
	{
		Con_Printf("rm <directory> {<filename> | *<token> | *} - removes a file | with token | all\n");
		return;
	}

	dirname = Cmd_Argv(1);
	filename = Cmd_Argv(2);
	SV_ReplaceChar(dirname, '\\', '/');
	SV_ReplaceChar(filename, '\\', '/');

	if (	!strncmp(dirname, "../", 3) || strstr(dirname, "/../")
	        ||	*dirname == '/'             || strchr(filename, '/')
	        ||	( (i = strlen(filename)) < 3 ? 0 : !strncmp(filename + i - 3, "/..", 4) )
#ifdef _WIN32
	        ||	( dirname[1] == ':' && ((*dirname >= 'a' && *dirname <= 'z') ||
	                                   (*dirname >= 'A' && *dirname <= 'Z'))
	           )
#endif //_WIN32
	   )
	{
		Con_Printf("Unable to remove\n");
		return;
	}

	if (*filename == '*') //token, many files
	{
		dir_t dir;
		file_t *list;

		// remove all files with specified token
		filename++;

		dir = Sys_listdir(va("%s", dirname), ".*", SORT_BY_NAME);
		list = dir.files;
		for (i = 0; list->name[0]; list++)
		{
			if (!list->isdir && strstr(list->name, filename))
			{
				if (!Sys_remove(va("%s/%s", dirname, list->name)))
				{
					Con_Printf("Removing %s...\n", list->name);
					i++;
				}
			}
		}
		if (i)
			Con_Printf("%d files removed\n", i);
		else
			Con_Printf("No matching found\n");
	}
	else // 1 file
	{
		if (!Sys_remove(va("%s/%s", dirname, filename)))
			Con_Printf("File %s successfully removed\n", filename);
		else
			Con_Printf("Unable to remove file %s\n", filename);
	}

	// force cache rebuild.
	FS_FlushFSHash();
}

/*==================
SV_ChmodFile_f
Chmod a script
==================*/
#ifndef _WIN32
void SV_ChmodFile_f (void)
{
	char	*_mode, *filename;
	unsigned int	mode, m;

	if (Cmd_Argc() != 3)
	{
		Con_Printf("chmod <mode> <file>\n");
		return;
	}

	_mode = Cmd_Argv(1);
	filename = Cmd_Argv(2);

	if (!strncmp(filename, "../",  3) || strstr(filename, "/../") ||
	        *filename == '/'              || strlen(_mode) != 3 ||
	        ( (m = strlen(filename)) < 3 ? 0 : !strncmp(filename + m - 3, "/..", 4) ))
	{
		Con_Printf("Unable to chmod\n");
		return;
	}
	for (mode = 0; *_mode; _mode++)
	{
		m = *_mode - '0';
		if (m > 7)
		{
			Con_Printf("Unable to chmod\n");
			return;
		}
		mode = (mode << 3) + m;
	}

	if (chmod(filename, mode))
		Con_Printf("Unable to chmod %s\n", filename);
	else
		Con_Printf("Chmod %s successful\n", filename);
}
#endif //_WIN32

/*==================
SV_LocalCommand_f
Execute system command
==================*/
//bliP: REMOVE ME REMOVE ME REMOVE ME REMOVE ME REMOVE ME ->
void SV_LocalCommand_f (void)
{
	int i, c;
	char str[1024], *temp_file = "__output_temp_file__";

	if ((c = Cmd_Argc()) < 2)
	{
		Con_Printf("localcommand [command]\n");
		return;
	}

	str[0] = 0;
	for (i = 1; i < c; i++)
	{
		strlcat (str, Cmd_Argv(i), sizeof(str));
		strlcat (str, " ", sizeof(str));
	}
	strlcat (str, va("> %s 2>&1\n", temp_file), sizeof(str));

	if (system(str) == -1)
		Con_Printf("command failed\n");
	else
	{
		char	buf[512];
		FILE	*f;
		if ((f = fopen(temp_file, "rt")) == NULL)
			Con_Printf("(empty)\n");
		else
		{
			while (!feof(f))
			{
				buf[fread (buf, 1, sizeof(buf) - 1, f)] = 0;
				Con_Printf("%s", buf);
			}
			fclose(f);
			if (Sys_remove(temp_file))
				Con_Printf("Unable to remove file %s\n", temp_file);
		}
	}

}
//REMOVE ME REMOVE ME REMOVE ME REMOVE ME REMOVE ME

/*
==================
SV_Kick_f
 
Kick a user off of the server
==================
*/
void SV_Kick_f (void)
{
	int			i, j;
	client_t	*cl;
	int			uid;
	int			c;
	char		reason[80] = "";

	c = Cmd_Argc ();
	if (c < 2)
	{
#ifndef SERVERONLY
		// some mods use a "kick" alias for their own needs, sigh
		if (CL_ClientState() && Cmd_FindAlias("kick"))
		{
			Cmd_ExecuteString (Cmd_AliasString("kick"));
			return;
		}
#endif
		Con_Printf ("kick <userid> [reason]\n");
		return;
	}

	uid = Q_atoi(Cmd_Argv(1));

	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (!cl->state)
			continue;
		if (cl->userid == uid)
		{
			if (c > 2)
			{
				strlcpy (reason, " (", sizeof(reason));
				for (j=2 ; j<c; j++)
				{
					strlcat (reason, Cmd_Argv(j), sizeof(reason)-4);
					if (j < c-1)
						strlcat (reason, " ", sizeof(reason)-4);
				}
				if (strlen(reason) < 3)
					reason[0] = '\0';
				else
					strlcat (reason, ")", sizeof(reason));
			}

			SV_KickClient(cl, reason);
			return;
		}
	}

	Con_Printf ("Couldn't find user number %i\n", uid);
}

void SV_KickClient(client_t* cl, const char* reason)
{
	sv_client_state_t saved_state = cl->state;
	cl->state = cs_free; // HACK: don't broadcast to this client
	SV_BroadcastPrintf(PRINT_HIGH, "%s was kicked%s\n", cl->name, reason);
	cl->state = (sv_client_state_t)saved_state;
	SV_ClientPrintf(cl, PRINT_HIGH, "You were kicked from the game%s\n", reason);
	SV_LogPlayer(cl, va("kick%s\n", reason), 1); //bliP: logging
	SV_DropClient(cl);
}

//bliP: mute, cuff ->
int SV_MatchUser (char *s)
{
	int         i;
	client_t   *cl;

	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (!cl->state)
			continue;
		if (!strcmp (cl->name, s))
			return cl->userid;
	}
	i = Q_atoi(s);
	return i;
}

/*
================
SV_Cuff_f
================
*/
#define MAXPENALTY 1200.0
void SV_Cuff_f (void)
{
	int         c, i, uid;
	double      mins = 0.5;
	qbool    done = false;
	qbool    print = true;
	client_t    *cl;
	char        reason[80];
	char        text[100];

	if ((c = Cmd_Argc()) < 2)
	{
		Con_Printf ("usage: cuff <userid/name> <minutes> [reason]\n(default = 0.5, 0 = cancel cuff).\n");
		return;
	}

	uid = SV_MatchUser(Cmd_Argv(1));
	if (!uid)
	{
		Con_Printf ("Couldn't find user %s\n", Cmd_Argv(1));
		return;
	}

	if (c >= 3)
	{
		mins = Q_atof(Cmd_Argv(2));
		if (mins < 0.0 || mins > MAXPENALTY)
		{
			mins = MAXPENALTY;
		}
	}

	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (!cl->state)
			continue;
		if (cl->userid == uid)
		{
			cl->cuff_time = curtime + (mins * 60.0);
			done = true;
			break;
		}
	}
	if (done)
	{
		reason[0] = 0;
		if (c > 2)
		{
			for (i = 3; i < c; i++)
			{
				strlcat (reason, Cmd_Argv(i), sizeof(reason) - 1 - strlen(reason));
				if (i < c - 1)
					strlcat (reason, " ", sizeof(reason) - strlen(reason));
			}
		}

		if (mins)
		{
			SV_BroadcastPrintf (PRINT_CHAT, "%s cuffed for %.1f minutes%s%s\n", cl->name, mins, reason[0] ? ": " : "", reason[0] ? reason : "");

			snprintf(text, sizeof(text), "You are cuffed for %.1f minutes%s%s\n", mins, reason[0] ? "\n\n" : "", reason[0] ? reason : "");
			ClientReliableWrite_Begin(cl,svc_centerprint, 2+strlen(text));
			ClientReliableWrite_String (cl, text);
		}
		else
		{
			if (print)
			{
				SV_BroadcastPrintf (PRINT_CHAT, "%s un-cuffed.\n", cl->name);
			}
		}
	}
	else
	{
		Con_Printf ("Couldn't find user %s\n", Cmd_Argv(1));
	}
}

/*
================
SV_Mute_f
================
*/
void SV_Mute_f (void)
{
	int         c, i, uid;
	double      mins = 0.5;
	qbool    done = false;
	qbool    print = true;
	client_t    *cl;
	char        reason[1024];
	char        text[1024];
	char        *ptr;

	if ((c = Cmd_Argc()) < 2)
	{
		Con_Printf ("usage: mute <userid/name> <minutes> [reason]\n(default = 0.5, 0 = cancel mute).\n");
		return;
	}

	uid = SV_MatchUser(Cmd_Argv(1));
	if (!uid)
	{
		Con_Printf ("Couldn't find user %s\n", Cmd_Argv(1));
		return;
	}

	if (c >= 3)
	{
		ptr = Cmd_Argv(2);
		if (*ptr == '*')
		{
			ptr++;
			print = false;
		}
		mins = Q_atof(ptr);
		if (mins < 0.0 || mins > MAXPENALTY)
			mins = MAXPENALTY;
	}
	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (!cl->state)
			continue;
		if (cl->userid == uid)
		{
			cl->lockedtill = curtime + (mins * 60.0);
			done = true;
			break;
		}
	}
	if (done)
	{
		reason[0] = 0;
		if (c > 2)
		{
			for (i = 3; i < c; i++)
			{
				strlcat (reason, Cmd_Argv(i), sizeof(reason) - 1 - strlen(reason));
				if (i < c - 1)
					strlcat (reason, " ", sizeof(reason) - strlen(reason));
			}
		}

		if (mins)
		{
			if (print)
				SV_BroadcastPrintf (PRINT_CHAT, "%s muted for %.1f minutes%s%s\n", cl->name, mins, reason[0] ? ": " : "", reason[0] ? reason : "");
			snprintf(text, sizeof(text), "You are muted for %.1f minutes%s%s\n", mins, reason[0] ? "\n\n" : "", reason[0] ? reason : "");
			ClientReliableWrite_Begin(cl, svc_centerprint, 2+strlen(text));
			ClientReliableWrite_String (cl, text);
		}
		else
		{
			if (print)
			{
				SV_BroadcastPrintf (PRINT_CHAT, "%s un-muted.\n", cl->name);
			}
		}
	}
	else
	{
		Con_Printf ("Couldn't find user %s\n", Cmd_Argv(1));
	}
}

void SV_RemovePenalty_f (void)
{
	int     i;
	int     num;
	extern int numpenfilters;

	if (Cmd_Argc() != 2)
	{
		Con_Printf ("penaltyremove [num]\n");
		return;
	}

	num = Q_atoi(Cmd_Argv(1));

	for (i = 0; i < numpenfilters; i++)
	{
		if (i == num)
		{
			SV_RemoveIPFilter (i);
			Con_Printf ("Removed.\n");
			return;
		}
	}
	Con_Printf ("Didn't find penalty filter %i.\n", num);
}

void SV_ListPenalty_f (void)
{
	client_t *cl;
	int     i;
	char		s[8];
	extern int numpenfilters;
	extern penfilter_t penfilters[MAX_PENFILTERS];

	Con_Printf ("Active Penalty List:\n");
	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (!cl->state)
			continue;

		if (cl->lockedtill >= curtime)
		{
			Con_Printf ("%i %s mute (remaining: %d)\n", cl->userid, cl->name, (cl->lockedtill) ? (int)(cl->lockedtill - curtime) : 0);
		}
		if (cl->cuff_time >= curtime)
		{
			Con_Printf ("%i %s cuff (remaining: %d)\n", cl->userid, cl->name, (cl->cuff_time) ? (int)(cl->cuff_time - curtime) : 0);
		}
	}

	Con_Printf ("Saved Penalty List:\n");
	for (i = 0; i < numpenfilters; i++)
	{
		switch (penfilters[i].type)
		{
		case ft_mute: strlcpy(s, "Mute", sizeof(s)); break;
		case ft_cuff: strlcpy(s, "Cuff", sizeof(s)); break;
		default: strlcpy(s, "Unknown", sizeof(s)); break;
		}
		Con_Printf ("%i: %s for %i.%i.%i.%i (remaining: %d)\n", i, s,
		            penfilters[i].ip[0],
		            penfilters[i].ip[1],
		            penfilters[i].ip[2],
		            penfilters[i].ip[3],
		            (penfilters[i].time) ? (int)(penfilters[i].time - realtime) : 0);
	}
}
//<-

/*
================
SV_Resolve
 
resolve IP via DNS lookup
================
*/
char *SV_Resolve(char *addr)
{
#if defined (__linux__) || defined (_WIN32)
	unsigned long ip;
#else
	in_addr_t ip;
#endif

	struct hostent *hp;

	ip = inet_addr(addr);
	if ((hp = gethostbyaddr((const char *)&ip, sizeof(ip), AF_INET)) != NULL)
		addr = hp->h_name;
	return addr;
}

/*
==================
SV_Nslookup_f
==================
*/
void SV_Nslookup_f (void)
{
	char		*ip, *name;

	if (Cmd_Argc() != 2)
	{
		Con_Printf ("Usage: nslookup <IP address>\n");
		return;
	}

	ip = Cmd_Argv(1);
	name = SV_Resolve(ip);
	if (ip != name)
		Con_Printf ("Name:    %s\nAddress:  %s\n", name, ip);
	else
		Con_Printf ("Couldn't resolve %s\n", ip);

}

/*
================
SV_Status_f
================
*/
extern cvar_t sv_use_dns;
void SV_Status_f (void)
{
	int i;
	client_t *cl;
	float cpu, avg, pak, demo1 = 0.0;
	char *s;

	cpu = (svs.stats.latched_active + svs.stats.latched_idle);

	if (cpu)
	{
		demo1 = 100.0 * svs.stats.latched_demo  / cpu;
		cpu  = 100.0 * svs.stats.latched_active / cpu;
	}

	avg = 1000 * svs.stats.latched_active  / STATFRAMES;
	pak = (float)svs.stats.latched_packets / STATFRAMES;

	Con_Printf ("net address                 : %s\n"
				"cpu utilization (overall)   : %3i%%\n"
				"cpu utilization (recording) : %3i%%\n"
				"avg response time           : %i ms\n"
				"packets/frame               : %5.2f (%d)\n",
				NET_AdrToString (net_local_sv_ipadr),
				(int)cpu,
				(int)demo1,
				(int)avg,
				pak, num_prstr);

	switch (sv_redirected)
	{
		case RD_NONE:
			Con_Printf ("name             ping frags   id   address                real ip\n"
						"---------------- ---- ----- ------ ---------------------- ---------------\n");
			for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
			{
				if (!cl->state)
					continue;
				s = NET_BaseAdrToString(cl->netchan.remote_address);
				Con_Printf ("%-16s %4i %5i %6i %-22s ", cl->name, (int)SV_CalcPing(cl),
						(int)cl->edict->v->frags, cl->userid, (int)sv_use_dns.value ? SV_Resolve(s) : s);
				if (cl->realip.ip[0])
					Con_Printf ("%-15s", NET_BaseAdrToString (cl->realip));
				Con_Printf (cl->spectator ? (char *) "(s)" : (char *) "");

				switch (cl->state)
				{
					case cs_connected:
					case cs_preconnected:
						Con_Printf (" CONNECTING\n");
						continue;
					case cs_zombie:
						Con_Printf (" ZOMBIE\n");
						continue;
					default:
						Con_Printf ("\n");
				}
			}
			break;
		//case RD_MOD:
		//case RD_CLIENT:
		//case RD_PACKET:
		default:
			// most remote clients are 40 columns
			//           01234567890123456789012345678901234567890123456789
			Con_Printf ("name               ping frags   id\n");
			Con_Printf ("  address\n");
			Con_Printf ("  real ip\n");
			Con_Printf ("------------------ ---- ----- ------\n");
			for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
			{
				if (!cl->state)
					continue;

				s = NET_BaseAdrToString(cl->netchan.remote_address);
				Con_Printf ("%-18s %4i %5i %6s %s\n%-36s\n", cl->name, (int)SV_CalcPing(cl),
							(int)cl->edict->v->frags, Q_yelltext((unsigned char*)va("%d", cl->userid)),
							cl->spectator ? " (s)" : "", (int)sv_use_dns.value ? SV_Resolve(s) : s);

				if (cl->realip.ip[0])
					Con_Printf ("%-36s\n", NET_BaseAdrToString (cl->realip));

				switch (cl->state)
				{
					case cs_connected:
					case cs_preconnected:
						Con_Printf ("CONNECTING\n");
						continue;
					case cs_zombie:
						Con_Printf ("ZOMBIE\n");
						continue;
					default:;
				}
			}
	} // switch
	Con_Printf ("\n");
}

/*
==================
SV_Check_maps_f
==================
*/
void SV_Check_maps_f(void)
{
	dir_t d;
	file_t *list;
	int i, j, maps_id1;

	d = Sys_listdir("id1/maps", ".bsp$", SORT_BY_NAME);
	list = d.files;
	for (i = LOCALINFO_MAPS_LIST_START; list->name[0] && i <= LOCALINFO_MAPS_LIST_END; list++, i++)
	{
		list->name[strlen(list->name) - 4] = 0;
		if (!list->name[0])
			continue;

		SV_Localinfo_Set(va("%d", i), list->name);
	}
	maps_id1 = i - 1;

	d = Sys_listdir("qw/maps", ".bsp$", SORT_BY_NAME);
	list = d.files;
	for (; list->name[0] && i <= LOCALINFO_MAPS_LIST_END; list++, i++)
	{
		list->name[strlen(list->name) - 4] = 0;
		if (!list->name[0])
			continue;

		for (j = LOCALINFO_MAPS_LIST_START; j <= maps_id1; j++)
			if (!strncmp(Info_Get(&_localinfo_, va("%d", j)), list->name, MAX_KEY_STRING))
				break;
		if (j <= maps_id1)
			continue;

		SV_Localinfo_Set(va("%d", i), list->name);
	}

	for (; i <= LOCALINFO_MAPS_LIST_END; i++)
	{
		SV_Localinfo_Set(va("%d", i), "");
	}
}

/*
==================
SV_ConSay_f
==================
*/
void SV_ConSay_f(void)
{
	client_t *client;
	int		j;
	char	*p;
	char	text[1024] = "console: ";

	if (Cmd_Argc () < 2)
		return;

	p = Cmd_Args();

	if (*p == '"')
	{
		p++;
		p[strlen(p)-1] = 0;
	}

	strlcat(text,    p, sizeof(text));
	strlcat(text, "\n", sizeof(text));

	for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
	{
		if (client->state != cs_spawned)
			continue;
		SV_ClientPrintf2(client, PRINT_CHAT, "%s", text);
	}

	if (sv.mvdrecording)
	{
		if (MVDWrite_Begin (dem_all, 0, strlen(text)+3))
		{
			MVD_MSG_WriteByte (svc_print);
			MVD_MSG_WriteByte (PRINT_CHAT);
			MVD_MSG_WriteString (text);
		}
	}

	Sys_Printf("%s", text);
	SV_Write_Log(CONSOLE_LOG, 1, text);
}

void SV_SendServerInfoChange(char *key, char *value)
{
	if (!sv.state)
		return;

	MSG_WriteByte (&sv.reliable_datagram, svc_serverinfo);
	MSG_WriteString (&sv.reliable_datagram, key);
	MSG_WriteString (&sv.reliable_datagram, value);
}

//Cvar system calls this when a CVAR_SERVERINFO cvar changes
void SV_ServerinfoChanged (char *key, char *string)
{
	string = Cvar_ServerInfoValue(key, string);

	if (strcmp(string, Info_ValueForKey (svs.info, key))) {
		Info_SetValueForKey (svs.info, key, string, MAX_SERVERINFO_STRING);
		SV_SendServerInfoChange (key, string);
	}
}

/*
===========
SV_Serverinfo_f

Examine or change the serverinfo string
===========
*/
void SV_Serverinfo_f (void)
{
	cvar_t	*var;
	char *s;
	char	*key, *value;

	if (Cmd_Argc() == 1)
	{
		Con_Printf ("Server info settings:\n");
		Info_Print (svs.info);
		Con_Printf ("[%d/%d]\n", strlen(svs.info), MAX_SERVERINFO_STRING);
		return;
	}

	//bliP: sane serverinfo usage (mercury) ->
	if (Cmd_Argc() == 2)
	{
		s = Info_ValueForKey(svs.info, Cmd_Argv(1));
		if (*s)
			Con_Printf ("Serverinfo %s: \"%s\"\n", Cmd_Argv(1), s);
		else
			Con_Printf ("No such key %s\n", Cmd_Argv(1));
		return;
	}
	//<-

	if (Cmd_Argc() != 3)
	{
		Con_Printf ("usage: serverinfo [ <key> [ <value> ] ]\n");
		return;
	}

	key = Cmd_Argv(1);
	value = Cmd_Argv(2);

	if (key[0] == '*')
	{
		Con_Printf ("Star variables cannot be changed.\n");
		return;
	}

	// force serverinfo "0" vars to be ""
	if (!strcmp(value, "0"))
		value = "";

	// if the key is also a serverinfo cvar, change it too
	var = Cvar_Find(key);
	if (var && (var->flags & CVAR_SERVERINFO))
	{
		Cvar_Set (var, value); // this call SV_ServerinfoChanged() as well.
	}
	else
	{
		SV_ServerinfoChanged(key, value);
	}
}

void SV_Localinfo_Set (const char *name, const char *value)
{
	char *old_value;

	if (!name || !*name)
		return;

	if (!value)
		value = "";

	old_value = Info_Get(&_localinfo_, name); // remember old value.
	Info_Set (&_localinfo_, name, value); // set new value.

	if (mod_localinfoChanged)
	{
		pr_global_struct->time = sv.time;
		pr_global_struct->self = 0;
		PR_SetTmpString(&G_INT(OFS_PARM0), name);
		PR_SetTmpString(&G_INT(OFS_PARM1), old_value);
		PR_SetTmpString(&G_INT(OFS_PARM2), Info_Get(&_localinfo_, name));
		PR_ExecuteProgram (mod_localinfoChanged);
	}
}

/*
===========
SV_Localinfo_f
 
  Examine or change the localinfo string
===========
*/
void SV_Localinfo_f (void)
{
	if (Cmd_Argc() == 1)
	{
		char info[MAX_LOCALINFO_STRING];

		Con_Printf ("Local info settings:\n");
		Info_ReverseConvert(&_localinfo_, info, sizeof(info));
		Info_Print (info);
		Con_Printf ("[%d/%d]\n", strlen(info), sizeof(info));
		return;
	}

	//bliP: sane localinfo usage (mercury) ->
	if (Cmd_Argc() == 2)
	{
		char *s = Info_Get(&_localinfo_, Cmd_Argv(1));

		if (*s)
			Con_Printf ("Localinfo %s: \"%s\"\n", Cmd_Argv(1), s);
		else
			Con_Printf ("No such key %s\n", Cmd_Argv(1));
		return;
	}
	//<-

	if (Cmd_Argc() != 3)
	{
		Con_Printf ("usage: localinfo [ <key> <value> ]\n");
		return;
	}

	if (Cmd_Argv(1)[0] == '*')
	{
		Con_Printf ("Star variables cannot be changed.\n");
		return;
	}

	SV_Localinfo_Set(Cmd_Argv(1), Cmd_Argv(2));
}


/*
===========
SV_User_f
 
Examine a users info strings
===========
*/
void SV_User_f (void)
{
	char info[MAX_EXT_INFO_STRING];

	if (Cmd_Argc() != 2)
	{
		Con_Printf ("Usage: user <userid>\n");
		return;
	}

	if (!SV_SetPlayer ())
		return;

	Info_ReverseConvert(&sv_client->_userinfo_ctx_, info, sizeof(info));
	Info_Print(info);
	Con_DPrintf ("[%d/%d]\n", strlen(info), sizeof(info));
}

/*
================
SV_Gamedir
 
Sets the fake *gamedir to a different directory.
================
*/
void SV_Gamedir (void)
{
	char			*dir;

	if (Cmd_Argc() == 1)
	{
		Con_Printf ("Current *gamedir: %s\n", Info_ValueForKey (svs.info, "*gamedir"));
		return;
	}

	if (Cmd_Argc() != 2)
	{
		Con_Printf ("Usage: sv_gamedir <newgamedir>\n");
		return;
	}

	dir = Cmd_Argv(1);

	if (strstr(dir, "..") || strchr(dir, '/')
	        || strchr(dir, '\\') || strchr(dir, ':') )
	{
		Con_Printf ("*Gamedir should be a single filename, not a path\n");
		return;
	}

	Info_SetValueForStarKey (svs.info, "*gamedir", dir, MAX_SERVERINFO_STRING);
}

/*
================
SV_Floodport_f
 
Sets the gamedir and path to a different directory.
================
*/

void SV_Floodprot_f (void)
{
	int arg1, arg2, arg3;

	if (Cmd_Argc() == 1)
	{
		if (fp_messages)
		{
			Con_Printf ("Current floodprot settings: \nAfter %d msgs per %d seconds, silence for %d seconds\n",
			            fp_messages, fp_persecond, fp_secondsdead);
			return;
		}
		else
			Con_Printf ("No floodprots enabled.\n");
	}

	if (Cmd_Argc() != 4)
	{
		Con_Printf ("Usage: floodprot <# of messages> <per # of seconds> <seconds to silence>\n");
		Con_Printf ("Use floodprotmsg to set a custom message to say to the flooder.\n");
		return;
	}

	arg1 = Q_atoi(Cmd_Argv(1));
	arg2 = Q_atoi(Cmd_Argv(2));
	arg3 = Q_atoi(Cmd_Argv(3));

	if (arg1<=0 || arg2 <= 0 || arg3<=0)
	{
		Con_Printf ("All values must be positive numbers\n");
		return;
	}

	if (arg1 > 10)
	{
		Con_Printf ("Can only track up to 10 messages.\n");
		return;
	}

	fp_messages	= arg1;
	fp_persecond = arg2;
	fp_secondsdead = arg3;
}

void SV_Floodprotmsg_f (void)
{
	if (Cmd_Argc() == 1)
	{
		Con_Printf("Current msg: %s\n", fp_msg);
		return;
	}
	else if (Cmd_Argc() != 2)
	{
		Con_Printf("Usage: floodprotmsg \"<message>\"\n");
		return;
	}
	snprintf(fp_msg, sizeof(fp_msg), "%s", Cmd_Argv(1));
}

/*
================
SV_Gamedir_f
 
Sets the gamedir and path to a different directory.
================
*/
void SV_Gamedir_f (void)
{
	char			*dir;

	if (Cmd_Argc() == 1)
	{
		Con_Printf ("Current gamedir: %s\n", fs_gamedir);
		return;
	}

	if (Cmd_Argc() != 2)
	{
		Con_Printf ("Usage: gamedir <newdir>\n");
		return;
	}

	dir = Cmd_Argv(1);

	if (strstr(dir, "..") || strchr(dir, '/') || strchr(dir, '\\') || strchr(dir, ':') )
	{
		Con_Printf ("Gamedir should be a single filename, not a path\n");
		return;
	}

#ifndef SERVERONLY
	if (CL_ClientState())
	{
		Con_Printf ("you must disconnect before changing gamedir\n");
		return;
	}
#endif

	FS_SetGamedir (dir, false);
	Info_SetValueForStarKey (svs.info, "*gamedir", dir, MAX_SERVERINFO_STRING);
}

/*
================
SV_Snap
================
*/
void SV_Snap (int uid)
{
	client_t *cl;
	char pcxname[80];
	char checkname[MAX_OSPATH];
	int i;
	FILE *f;

	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (cl->state < cs_preconnected)
			continue;
		if (cl->userid == uid)
			break;
	}
	if (i >= MAX_CLIENTS)
	{
		Con_Printf ("userid not found\n");
		return;
	}

	FS_CreatePath (va ("%s/snap/", fs_gamedir));
	snprintf (pcxname, sizeof (pcxname), "%d-00.pcx", uid);

	for (i=0 ; i<=99 ; i++)
	{
		pcxname[strlen(pcxname) - 6] = i/10 + '0';
		pcxname[strlen(pcxname) - 5] = i%10 + '0';
		snprintf (checkname, MAX_OSPATH, "%s/snap/%s", fs_gamedir, pcxname);
		f = fopen (checkname, "rb");
		if (!f)
			break; // file doesn't exist
		fclose (f);
	}
	if (i==100)
	{
		Con_Printf ("Snap: Couldn't create a file, clean some out.\n");
		return;
	}
	strlcpy(cl->uploadfn, checkname, MAX_QPATH);

	memcpy(&cl->snap_from, &net_from, sizeof(net_from));
	if (sv_redirected != RD_NONE)
		cl->remote_snap = true;
	else
		cl->remote_snap = false;

	ClientReliableWrite_Begin (cl, svc_stufftext, 24);
	ClientReliableWrite_String (cl, "cmd snap\n");
	Con_Printf ("Requesting snap from user %d...\n", uid);
}

/*
================
SV_Snap_f
================
*/
void SV_Snap_f (void)
{
	int			uid;

	if (Cmd_Argc() != 2)
	{
		Con_Printf ("Usage:  snap <userid>\n");
		return;
	}

	uid = Q_atoi(Cmd_Argv(1));

	SV_Snap(uid);
}

/*
================
SV_Snap
================
*/
void SV_SnapAll_f (void)
{
	client_t *cl;
	int			i;

	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (cl->state < cs_preconnected || cl->spectator)
			continue;
		SV_Snap(cl->userid);
	}
}

// QW262 -->
/*
================
SV_MasterPassword
================
*/
void SV_MasterPassword_f (void)
{
#ifdef SERVERONLY
	if (!host_everything_loaded)
#else
	if (!server_cfg_done)
#endif
		strlcpy(master_rcon_password, Cmd_Argv(1), sizeof(master_rcon_password));
	else
		Con_DPrintf("master_rcon_password can be set only in server.cfg\n");
}
// <-- QW262

/*
==================
SV_InitOperatorCommands
==================
*/
void SV_InitOperatorCommands (void)
{
	int i;

	Cvar_Register (&sv_cheats);

	if (SV_CommandLineEnableCheats())
	{
		sv_allow_cheats = true;
		Cvar_SetValue (&sv_cheats, 1);
		Info_SetValueForStarKey (svs.info, "*cheats", "ON", MAX_SERVERINFO_STRING);
	}

	for (i = MIN_LOG; i < MAX_LOG; ++i)
		Cmd_AddCommand (logs[i].command, logs[i].function);

#ifdef SERVERONLY
	Cmd_AddCommand ("nslookup", SV_Nslookup_f);
#endif
	Cmd_AddCommand ("check_maps", SV_Check_maps_f);
	Cmd_AddCommand ("snap", SV_Snap_f);
	Cmd_AddCommand ("snapall", SV_SnapAll_f);
	Cmd_AddCommand ("kick", SV_Kick_f);

	// Add sv_status as client allows 'status' alias to over-ride (ezQuake #532)
	Cmd_AddCommand ("status", SV_Status_f);
	Cmd_AddCommand ("sv_status", SV_Status_f);

#ifdef SERVERONLY
	//bliP: init ->
	Cmd_AddCommand ("rmdir", SV_RemoveDirectory_f);
	Cmd_AddCommand ("rm", SV_RemoveFile_f);
	Cmd_AddCommand ("ls", SV_ListFiles_f);
#endif

	Cmd_AddCommand ("mute", SV_Mute_f);
	Cmd_AddCommand ("cuff", SV_Cuff_f);

	Cmd_AddCommand ("penaltylist", SV_ListPenalty_f);
	Cmd_AddCommand ("penaltyremove", SV_RemovePenalty_f);

#ifdef SERVERONLY
#ifndef _WIN32
	Cmd_AddCommand ("chmod", SV_ChmodFile_f);
#endif //_WIN32
	//<-
	if (SV_CommandLineEnableLocalCommand())
		Cmd_AddCommand ("localcommand", SV_LocalCommand_f);
#endif

	Cmd_AddCommand ("map", SV_Map_f);
#ifdef SERVERONLY
	Cmd_AddCommand ("devmap", SV_Map_f);
#else
	if (IsDeveloperMode()) {
		Cmd_AddCommand("devmap", SV_Map_f);
	}
#endif
	Cmd_AddCommand ("setmaster", SV_SetMaster_f);

	Cmd_AddCommand ("heartbeat", SV_Heartbeat_f);
	Cmd_AddCommand ("save", SV_SaveGame_f); 
	Cmd_AddCommand ("load", SV_LoadGame_f); 

#ifdef SERVERONLY
	Cmd_AddCommand ("say", SV_ConSay_f);
	Cmd_AddCommand ("quit", SV_Quit_f);
	Cmd_AddCommand ("restart", SV_Restart_f);
#endif

#ifdef SERVERONLY
	Cmd_AddCommand ("god", SV_God_f);
	Cmd_AddCommand ("give", SV_Give_f);
	Cmd_AddCommand ("noclip", SV_Noclip_f);
#endif

	Cmd_AddCommand ("localinfo", SV_Localinfo_f);

#ifdef SERVERONLY
	Cmd_AddCommand ("serverinfo", SV_Serverinfo_f);
	Cmd_AddCommand ("user", SV_User_f); // FIXME: probably should be done like CL_Serverinfo_f().
#endif

	Cmd_AddCommand ("gamedir", SV_Gamedir_f);
	Cmd_AddCommand ("sv_gamedir", SV_Gamedir);

// I wonder why it registered in host.c in ezquake...
#ifdef SERVERONLY
	Cmd_AddCommand ("floodprot", SV_Floodprot_f);
	Cmd_AddCommand ("floodprotmsg", SV_Floodprotmsg_f);
#endif

	Cmd_AddCommand ("master_rcon_password", SV_MasterPassword_f);
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_demo.c
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    
*/

// sv_demo.c - mvd demo related code

#ifndef CLIENTONLY
#include "qwsvdef.h"

// minimal cache which can be used for demos, must be few times greater than DEMO_FLUSH_CACHE_IF_LESS_THAN_THIS
#define DEMO_CACHE_MIN_SIZE 0x1000000

// flush demo cache if we have less than this free bytes
#define DEMO_FLUSH_CACHE_IF_LESS_THAN_THIS	65536


static void sv_demoDir_OnChange(cvar_t *cvar, char *value, qbool *cancel);

cvar_t  sv_demoUseCache     = {"sv_demoUseCache",   "0"};
cvar_t  sv_demoCacheSize    = {"sv_demoCacheSize",  "0", CVAR_ROM};
cvar_t  sv_demoMaxDirSize   = {"sv_demoMaxDirSize", "102400"};
cvar_t  sv_demoClearOld     = {"sv_demoClearOld",   "0"};
cvar_t  sv_demoDir          = {"sv_demoDir",        "demos", 0, sv_demoDir_OnChange};
cvar_t  sv_demoDirAlt       = {"sv_demoDirAlt",     "", 0, sv_demoDir_OnChange };
cvar_t  sv_demofps          = {"sv_demofps",        "30"};
cvar_t  sv_demoIdlefps      = {"sv_demoIdlefps",    "10"};
cvar_t  sv_demoPings        = {"sv_demopings",      "3"};
cvar_t  sv_demoMaxSize      = {"sv_demoMaxSize",    "20480"};
cvar_t  sv_demoExtraNames   = {"sv_demoExtraNames", "0"};

cvar_t	sv_demoPrefix		= {"sv_demoPrefix",		""};
cvar_t	sv_demoSuffix		= {"sv_demoSuffix",		""};
cvar_t	sv_demotxt			= {"sv_demotxt",		"1"};
cvar_t	sv_onrecordfinish	= {"sv_onRecordFinish", ""};

cvar_t	sv_ondemoremove		= {"sv_onDemoRemove",	""};
cvar_t	sv_demoRegexp		= {"sv_demoRegexp",		"\\.mvd(\\.(gz|bz2|rar|zip))?$"};

cvar_t	sv_silentrecord		= {"sv_silentrecord",   "0"};

cvar_t	extralogname		= {"extralogname",		"unset"}; // no sv_ prefix? WTF!

mvddest_t			*singledest;

// only one .. is allowed (security)
static void sv_demoDir_OnChange(cvar_t *cvar, char *value, qbool *cancel)
{
	if (cvar == &sv_demoDir && !value[0]) {
		*cancel = true;
		return;
	}

	if (value[0] == '.' && value[1] == '.') {
		value += 2;
	}

	if (strstr(value, "/..")) {
		*cancel = true;
		return;
	}
}

// { MVD writing functions, just wrappers

void MVD_MSG_WriteChar (const int c)
{
	MSG_WriteChar (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, c);
}

void MVD_MSG_WriteByte (const int c)
{
	MSG_WriteByte (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, c);
}

void MVD_MSG_WriteShort (const int c)
{
	MSG_WriteShort (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, c);
}

void MVD_MSG_WriteLong (const int c)
{
	MSG_WriteLong (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, c);
}

void MVD_MSG_WriteFloat (const float f)
{
	MSG_WriteFloat (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, f);
}

void MVD_MSG_WriteString (const char *s)
{
	MSG_WriteString (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, s);
}

void MVD_MSG_WriteCoord (const float f)
{
	MSG_WriteCoord (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, f);
}

void MVD_MSG_WriteAngle (const float f)
{
	MSG_WriteAngle (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, f);
}

void MVD_SZ_Write (const void *data, int length)
{
	SZ_Write (&demo.frames[demo.parsecount&UPDATE_MASK]._buf_, data, length);
}

// }

mvddest_t *DestByName (char *name)
{
	mvddest_t *d;

	for (d = demo.dest; d; d = d->nextdest)
		if (!strncmp(name, d->name, sizeof(d->name)-1))
			return d;

	return NULL;
}

void DestClose (mvddest_t *d, qbool destroyfiles)
{
	char path[MAX_OSPATH];

	if (d->cache)
		Q_free(d->cache);
	if (d->file)
		fclose(d->file);
	if (d->socket)
		closesocket(d->socket);
	if (d->qtvuserlist)
		QTVsv_FreeUserList(d);

	if (destroyfiles)
	{
		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, d->path, d->name);
		Sys_remove(path);
		strlcpy(path + strlen(path) - 3, "txt", MAX_OSPATH - strlen(path) + 3);
		Sys_remove(path);

		// force cache rebuild.
		FS_FlushFSHash();
	}

	Q_free(d);
}

//
// complete - just force flush for cached dests (dest->desttype == DEST_BUFFEREDFILE)
//
void DestFlush (qbool complete)
{
	int len;
	mvddest_t *d, *t;

	if (!demo.dest)
		return;

	while (demo.dest->error)
	{
		d = demo.dest;
		demo.dest = d->nextdest;

		DestClose(d, false);

		if (!demo.dest)
		{
			SV_MVDStop(3, false);
			return;
		}
	}

	for (d = demo.dest; d; d = d->nextdest)
	{
		switch(d->desttype)
		{
		case DEST_FILE:
			fflush (d->file);
			break;

		case DEST_BUFFEREDFILE:
			if (d->cacheused + DEMO_FLUSH_CACHE_IF_LESS_THAN_THIS > d->maxcachesize || complete)
			{
				len = (int)fwrite(d->cache, 1, d->cacheused, d->file);
				if (len != d->cacheused)
				{
					Sys_Printf("DestFlush: fwrite() error\n");
					d->error = true;
				}
				fflush(d->file);

				d->cacheused = 0;
			}
			break;

		case DEST_STREAM:
			if (d->io_time + qtv_streamtimeout.value <= Sys_DoubleTime())
			{
				// problem what send() have internal buffer, so send() success some time even peer side does't read,
				// this may take some time before internal buffer overflow and timeout trigger, depends of buffer size.
				Sys_Printf("DestFlush: stream timeout\n");
				d->error = true;
			}

			if (d->cacheused && !d->error)
			{
				len = send(d->socket, d->cache, d->cacheused, 0);

				if (len == 0) //client died
				{
//					d->error = true;
					// man says: The calls return the number of characters sent, or -1 if an error occurred.   
					// so 0 is legal or what?
				}
				else if (len > 0) //we put some data through
				{ //move up the buffer
					d->cacheused -= len;
					memmove(d->cache, d->cache+len, d->cacheused);

					d->io_time = Sys_DoubleTime(); // update IO activity
				}
				else
				{ //error of some kind. would block or something
					if (qerrno != EWOULDBLOCK && qerrno != EAGAIN)
					{
						Sys_Printf("DestFlush: error on stream\n");
						d->error = true;
					}
				}
			}
			break;

		case DEST_NONE:
		default:
			Sys_Error("DestFlush: encountered bad dest.");
		}

		if (d->desttype != DEST_STREAM) // no max size for stream
		{
			if ((unsigned int)sv_demoMaxSize.value && d->totalsize > ((unsigned int)sv_demoMaxSize.value * 1024))
			{
				Sys_Printf("DestFlush: sv_demoMaxSize = %db trigger for dest\n", (int)sv_demoMaxSize.value);
				d->error = true;
			}
		}

		while (d->nextdest && d->nextdest->error)
		{
			t = d->nextdest;
			d->nextdest = t->nextdest;

			DestClose(t, false);
		}
	}
}

// if param "mvdonly" == true then close only demos, not QTV's steams
static int DestCloseAllFlush (qbool destroyfiles, qbool mvdonly)
{
	int numclosed = 0;
	mvddest_t *d, **prev, *next;

	DestFlush(true); //make sure it's all written.

	prev = &demo.dest;
	d = demo.dest;
	while (d)
	{
		next = d->nextdest;

		if (!mvdonly || d->desttype != DEST_STREAM)
		{
			desttype_t dt = d->desttype;
			char dest_name[sizeof(d->name)];
			char dest_path[sizeof(d->path)];

			strlcpy(dest_name, d->name, sizeof(dest_name));
			strlcpy(dest_path, d->path, sizeof(dest_path));

			*prev = d->nextdest;
			DestClose(d, destroyfiles); // NOTE: this free dest struck, so we can't use 'd' below
			numclosed++;

			if (dt != DEST_STREAM && dest_name[0]) // ignore stream or empty file name
				Run_sv_demotxt_and_sv_onrecordfinish (dest_name, dest_path, destroyfiles);
		}
		else
			prev = &d->nextdest;

		d = next;
	}

	return numclosed;
}

int DemoWriteDest (void *data, int len, mvddest_t *d)
{
	int ret;

	if (d->error)
		return 0;

	d->totalsize += len;

	switch(d->desttype)
	{
		case DEST_FILE:
			ret = (int)fwrite(data, 1, len, d->file);
			if (ret != len)
			{
				Sys_Printf("DemoWriteDest: fwrite() error\n");
				d->error = true;
				return 0;
			}

			break;
		case DEST_BUFFEREDFILE:	//these write to a cache, which is flushed later
		case DEST_STREAM:
			if (d->cacheused + len > d->maxcachesize)
			{
				Sys_Printf("DemoWriteDest: cache overflow %d > %d\n", d->cacheused + len, d->maxcachesize);
				d->error = true;
				return 0;
			}
			memcpy(d->cache + d->cacheused, data, len);
			d->cacheused += len;

			break;
		case DEST_NONE:
		default:
			Sys_Error("DemoWriteDest: encountered bad dest.");
	}
	return len;
}

static void DemoWrite (void *data, int len) //broadcast to all proxies/mvds
{
	mvddest_t *d;
	for (d = demo.dest; d; d = d->nextdest)
	{
		if (singledest && singledest != d)
			continue;

		DemoWriteDest(data, len, d);
	}
}

/*
====================
MVDWrite_Begin
====================
*/

static qbool MVDWrite_BeginEx (byte type, int to, int size)
{
	qbool new_mvd_msg;

	if (!sv.mvdrecording)
		return false;

	// we alredy overflowed, sorry but it no go
	if (demo.frames[demo.parsecount&UPDATE_MASK]._buf_.overflowed)
		return false; // ERROR

	if (size > MAX_MVD_SIZE)
	{
		Sys_Printf("MVDWrite_Begin: bad demo message size: %d > MAX_MVD_SIZE\n", size);
		return false; // ERROR
	}

	// check we have proper demo message type
	switch (type)
	{
	case dem_all: case dem_multiple: case dem_single: case dem_stats:
		break;
	default:
		Sys_Printf("MVDWrite_Begin: bad demo message type: %d\n", type);
		return false; // ERROR
	}

	new_mvd_msg =    demo.frames[demo.parsecount&UPDATE_MASK].lasttype != type
				  || demo.frames[demo.parsecount&UPDATE_MASK].lastto   != to
				  || demo.frames[demo.parsecount&UPDATE_MASK].lastsize + size > MAX_MVD_SIZE;

	if (new_mvd_msg)
	{
		// we need add mvd header for next message since "type" or "to" differ from previous message,
		// or it first message in this frame.

		MVD_MSG_WriteByte(0); // 0 milliseconds

		demo.frames[demo.parsecount&UPDATE_MASK].lasttype = type;
		demo.frames[demo.parsecount&UPDATE_MASK].lastto   = to;
		demo.frames[demo.parsecount&UPDATE_MASK].lastsize = size; // set initial size

		switch (type)
		{
		case dem_all:
			MVD_MSG_WriteByte(dem_all);
			break;
		case dem_multiple:
			MVD_MSG_WriteByte(dem_multiple);
			MVD_MSG_WriteLong(to);
			break;
		case dem_single:
		case dem_stats:
			MVD_MSG_WriteByte(type | (to << 3)); // msg "type" and "to" incapsulated in one byte
			break;
		default:
			return false; // ERROR: wrong type
		}

		MVD_MSG_WriteLong(size); // msg size

		if (demo.frames[demo.parsecount&UPDATE_MASK]._buf_.overflowed)
			return false; // ERROR: overflow

		// THIS IS TRICKY, SORRY.
		// remember size offset, so latter we can access it
		demo.frames[demo.parsecount&UPDATE_MASK].lastsize_offset = demo.frames[demo.parsecount&UPDATE_MASK]._buf_.cursize - 4;
	}
	else
	{
		// we must alredy have mvd header here of previous message, so just change size in header
		byte *buf;
		int lastsize;

		demo.frames[demo.parsecount&UPDATE_MASK].lastsize += size;

		// THIS IS TRICKY, SORRY.
		// and here we use size offset
		lastsize = demo.frames[demo.parsecount&UPDATE_MASK].lastsize;

		buf = demo.frames[demo.parsecount&UPDATE_MASK]._buf_.data + demo.frames[demo.parsecount&UPDATE_MASK].lastsize_offset;

		buf[0] = lastsize&0xff;
		buf[1] = (lastsize>> 8)&0xff;
		buf[2] = (lastsize>>16)&0xff;
		buf[3] = (lastsize>>24)&0xff;
	}

	return (sv.mvdrecording ? true : false);
}

qbool MVDWrite_Begin (byte type, int to, int size)
{
	if (!sv.mvdrecording)
		return false;

	if (!MVDWrite_BeginEx(type, to, size))
	{
		Con_DPrintf("MVDWrite_Begin: error\n");

		if (sv.mvdrecording)
			SV_MVDStop(4, false); // stop all mvd recording

		return false;
	}

	return (sv.mvdrecording ? true : false);
}

qbool MVDWrite_HiddenBlockBegin(int length)
{
	return MVDWrite_Begin(dem_multiple, 0, length);
}

qbool MVDWrite_HiddenBlock(const void* data, int length)
{
	if (MVDWrite_HiddenBlockBegin(length)) {
		MVD_SZ_Write(data, length);
		return true;
	}
	return false;
}

/*
====================
MVD_FrameDeltaTime

Get frame time mark (delta between two demo frames).

Also advance demo.prevtime.

====================
*/
static byte MVD_FrameDeltaTime (double time1)
{
	int	msec;

	if (!sv.mvdrecording)
		return 0;

	msec = (time1 - demo.prevtime) * 1000;
	demo.prevtime += 0.001 * msec;

	if (msec > 255)
		msec = 255;
	if (msec < 2)
		msec = 0; // uh, why 0 but not 2? 

	return (byte)msec;
}

/*
====================
MVD_WriteMessage
====================
*/
static qbool MVD_WriteMessage (sizebuf_t *msg, byte msec)
{
	int		len;
	byte	c;

	if (!sv.mvdrecording)
		return false;

	if (msg && msg->overflowed)
		return false; // ERROR

	c = msec;
	DemoWrite(&c, sizeof(c));

	c = dem_all;
	DemoWrite (&c, sizeof(c));

	if (msg && msg->cursize)
	{
		len = LittleLong (msg->cursize);
		DemoWrite (&len, 4);
		DemoWrite (msg->data, msg->cursize);
	}
	else
	{
		len = LittleLong (0);
		DemoWrite (&len, 4);
	}

	return (sv.mvdrecording ? true : false);
}

static void SV_MVDWritePausedTimeToStreams(demo_frame_t* frame)
{
	// When writing out a paused frame, send a packet to let QTV keep delay in sync
	if (frame->paused) {
		mvddest_t* d;
		sizebuf_t msg;
		byte msg_buffer[128];
		byte duration = frame->pause_duration;

		SZ_Init(&msg, msg_buffer, sizeof(msg_buffer));
		MSG_WriteByte(&msg, 0);                                           //     0: duration == 0, for demos
		MSG_WriteByte(&msg, dem_multiple);                                //     1: target of the packet
		MSG_WriteLong(&msg, 0);                                           //  2- 5: 0 ... demo_multiple(0) => hidden packet
		MSG_WriteLong(&msg, LittleLong(sizeof(short) + sizeof(byte)));    //  6-10: length = <short> + <byte>
		MSG_WriteShort(&msg, LittleShort(mvdhidden_paused_duration));     // 11-12: tell QTV how much time has really passed
		MSG_WriteByte(&msg, duration);                                    //    13: true ms value, as demo packets will have 0

		for (d = demo.dest; d; d = d->nextdest) {
			if (d->desttype == DEST_STREAM) {
				DemoWriteDest(msg.data, msg.cursize, d);
			}
		}
	}
}

/*
====================
SV_MVDWritePackets

Interpolates to get exact players position for current frame
and writes packets to the disk/memory
====================
*/
static qbool SV_MVDWritePacketsEx (int num)
{
	demo_frame_t	*frame, *nextframe;
	demo_client_t	*cl, *nextcl = NULL, *last_cl;
	int				i, j, flags;
	qbool			valid;
	double			time1, playertime, nexttime;
	vec3_t			origin, angles;
	sizebuf_t		msg;
	byte			msg_buf[MAX_MVD_SIZE]; // data without mvd header
	byte			msec;

	if (!sv.mvdrecording)
		return false;

	// allow overflow, but cancel demo recording in case of overflow
	SZ_InitEx(&msg, msg_buf, sizeof(msg_buf), true);

	if (num > demo.parsecount - demo.lastwritten + 1)
		num = demo.parsecount - demo.lastwritten + 1;

	// 'num' frames to write
	for ( ; num; num--, demo.lastwritten++)
	{
		SZ_Clear(&msg);

		frame = &demo.frames[demo.lastwritten&UPDATE_MASK];
		time1 = frame->time;
		nextframe = frame;

		SV_MVDWritePausedTimeToStreams(frame);

		// find two frames
		// one before the exact time (time - msec) and one after,
		// then we can interpolte exact position for current frame
		for (i = 0, cl = frame->clients, last_cl = demo.clients; i < MAX_CLIENTS; i++, cl++, last_cl++)
		{
			if (cl->parsecount != demo.lastwritten)
				continue; // not valid

			if (!cl->parsecount && svs.clients[i].state != cs_spawned)
				continue; // not valid, occur on first frame

			nexttime = playertime = time1 - cl->sec;

			valid = false;

			for (j = demo.lastwritten+1; nexttime < time1 && j < demo.parsecount; j++)
			{
				nextframe = &demo.frames[j&UPDATE_MASK];
				nextcl = &nextframe->clients[i];

				if (nextcl->parsecount != j)
					break; // disconnected?
				if (nextcl->fixangle)
					break; // respawned, or walked into teleport, do not interpolate!
				if (!(nextcl->flags & DF_DEAD) && (cl->flags & DF_DEAD))
					break; // respawned, do not interpolate

				nexttime = nextframe->time - nextcl->sec;

				if (nexttime >= time1)
				{
					// good, found what we were looking for
					valid = true;
					break;
				}
			}

			if (valid)
			{
				float f = 0;
				float z = nexttime - playertime;

				if ( z )
					f = (time1 - nexttime) / z;

				for (j = 0; j < 3; j++)
				{
					angles[j] = AdjustAngle(cl->angles[j], nextcl->angles[j], 1.0 + f);
					origin[j] = nextcl->origin[j] + f * (nextcl->origin[j] - cl->origin[j]);
				}
			}
			else
			{
				VectorCopy(cl->origin, origin);
				VectorCopy(cl->angles, angles);
			}

			// now write it to buf
			flags = cl->flags;

			for (j = 0; j < 3; j++)
				if (origin[j] != last_cl->origin[j])
					flags |= DF_ORIGIN << j;

			for (j = 0; j < 3; j++)
				if (angles[j] != last_cl->angles[j])
					flags |= DF_ANGLES << j;

			if (cl->model != last_cl->model)
				flags |= DF_MODEL;
			if (cl->effects != last_cl->effects)
				flags |= DF_EFFECTS;
			if (cl->skinnum != last_cl->skinnum)
				flags |= DF_SKINNUM;
			if (cl->weaponframe != last_cl->weaponframe)
				flags |= DF_WEAPONFRAME;

			MSG_WriteByte (&msg, svc_playerinfo);
			MSG_WriteByte (&msg, i);
			MSG_WriteShort (&msg, flags);

			MSG_WriteByte (&msg, cl->frame);

			for (j = 0 ; j < 3 ; j++)
				if (flags & (DF_ORIGIN << j))
					MSG_WriteCoord (&msg, origin[j]);

			for (j = 0 ; j < 3 ; j++)
				if (flags & (DF_ANGLES << j))
					MSG_WriteAngle16 (&msg, angles[j]);

			if (flags & DF_MODEL)
				MSG_WriteByte (&msg, cl->model);

			if (flags & DF_SKINNUM)
				MSG_WriteByte (&msg, cl->skinnum);

			if (flags & DF_EFFECTS)
				MSG_WriteByte (&msg, cl->effects);

			if (flags & DF_WEAPONFRAME)
				MSG_WriteByte (&msg, cl->weaponframe);

			cl->flags = flags;

			// save in last_cl what we wrote to msg so later we can delta from it
			*last_cl = *cl; // struct copy
		}

		// get frame time mark (delta between two frames)
		msec = MVD_FrameDeltaTime(time1);

		if (demo.frames[demo.lastwritten&UPDATE_MASK]._buf_.overflowed)
		{
			Con_DPrintf("SV_MVDWritePackets: error: in _buf_.overflowed\n");
			return false; // ERROR
		}

		// write cumulative data from different sources
		if (demo.frames[demo.lastwritten&UPDATE_MASK]._buf_.cursize)
		{
			// well, first byte must be milliseconds, set it then
			demo.frames[demo.lastwritten&UPDATE_MASK]._buf_.data[0] = msec;
			DemoWrite(demo.frames[demo.lastwritten&UPDATE_MASK]._buf_.data, demo.frames[demo.lastwritten&UPDATE_MASK]._buf_.cursize);

			msec = 0; // That matter, we wrote time mark, so next data(if any) in this frame follow with zero milliseconds offset, since it same frame.
					  // NOTE: demo.frames[demo.lastwritten&UPDATE_MASK]._buf_.cursize possible to be zero, in this case we wrote msec below...
		}

		// Write data about players, if we have data.
		// also if we does't have data and did't wrote msec above, we wrote it here, even packet will be empty, this will break fuh,
		// but I think I correct, also it doubtfull what we did't wrote msec above.
		if (msg.cursize || msec)
		{
			if (!MVD_WriteMessage(&msg, msec))
			{
				Con_DPrintf("SV_MVDWritePackets: error: in msg\n");
				return false; // ERROR
			}
		}

		// { reset frame for future usage
		SZ_Clear(&demo.frames[demo.lastwritten&UPDATE_MASK]._buf_);

		demo.frames[demo.lastwritten&UPDATE_MASK].lastto = 0;
		demo.frames[demo.lastwritten&UPDATE_MASK].lasttype = 0;
		demo.frames[demo.lastwritten&UPDATE_MASK].lastsize = 0;
		demo.frames[demo.lastwritten&UPDATE_MASK].lastsize_offset = 0;
		// }

		if (!sv.mvdrecording)
		{
			Con_DPrintf("SV_MVDWritePackets: error: in sv.mvdrecording\n");
			return false; // ERROR
		}
	}

	if (!sv.mvdrecording)
		return false; // ERROR

	if (demo.lastwritten > demo.parsecount)
		demo.lastwritten = demo.parsecount;

	return true;
}

qbool SV_MVDWritePackets (int num)
{
	if (!sv.mvdrecording)
		return false;

	if (!SV_MVDWritePacketsEx(num))
	{
		Con_DPrintf("SV_MVDWritePackets: error\n");

		if (sv.mvdrecording)
			SV_MVDStop(4, false); // stop all mvd recording

		return false;
	}

	return (sv.mvdrecording ? true : false);
}

/*
====================
SV_InitRecord
====================
*/
static mvddest_t *SV_InitRecordFile (char *name)
{
	char *s;
	mvddest_t *dst;
	FILE *file;

	char path[MAX_OSPATH];

	Con_DPrintf("SV_InitRecordFile: Demo name: \"%s\"\n", name);
	file = fopen (name, "wb");
	if (!file)
	{
		Con_Printf ("ERROR: couldn't open \"%s\"\n", name);
		return NULL;
	}

	dst = (mvddest_t*) Q_malloc (sizeof(mvddest_t));

	if (!(int)sv_demoUseCache.value)
	{
		dst->desttype = DEST_FILE;
		dst->file = file;
		dst->maxcachesize = 0;
	}
	else
	{
		dst->desttype = DEST_BUFFEREDFILE;
		dst->file = file;
		dst->maxcachesize = 1024 * (int) sv_demoCacheSize.value;
		dst->cache = (char *) Q_malloc (dst->maxcachesize);
	}

	s = name + strlen(name);
	while (*s != '/') s--;
	strlcpy(dst->name, s+1, sizeof(dst->name));
	strlcpy(dst->path, sv_demoDir.string, sizeof(dst->path));

	if ( !sv_silentrecord.value )
		SV_BroadcastPrintf (PRINT_CHAT, "Server starts recording (%s):\n%s\n",
		                    (dst->desttype == DEST_BUFFEREDFILE) ? "memory" : "disk", s+1);
	Cvar_SetROM(&serverdemo, dst->name);

	strlcpy(path, name, MAX_OSPATH);
	strlcpy(path + strlen(path) - 3, "txt", MAX_OSPATH - strlen(path) + 3);

	if ((int)sv_demotxt.value)
	{
		FILE *f;
		char *text;

		if (sv_demotxt.value == 2)
		{
			if ((f = fopen (path, "a+t")))
				fclose(f); // at least made empty file
		}
		else if ((f = fopen (path, "w+t")))
		{
			text = SV_PrintTeams();
			fwrite(text, strlen(text), 1, f);
			fflush(f);
			fclose(f);
		}
	}
	else
		Sys_remove(path);

	// force cache rebuild.
	FS_FlushFSHash();

	return dst;
}

static void SV_AddLastDemo(void)
{
	char *name = NULL;
	mvddest_t *d;

	for (d = demo.dest; d; d = d->nextdest)
	{
		if (d->desttype != DEST_STREAM && d->name[0])
		{
			name = d->name;
			break; // we found file dest with non empty name, use it as last demo name
		}
	}

	if (name && name[0])
	{
		size_t name_len = strlen(name) + 1;

		demo.lastdemospos = (demo.lastdemospos + 1) & 0xF;
		Q_free(demo.lastdemosname[demo.lastdemospos]);
		demo.lastdemosname[demo.lastdemospos] = (char *) Q_malloc(name_len);
		strlcpy(demo.lastdemosname[demo.lastdemospos], name, name_len);
		Con_DPrintf("SV_MVDStop: Demo name for 'cmd dl .': \"%s\"\n", demo.lastdemosname[demo.lastdemospos]);
	}
}

/*
====================
SV_MVDStop

stop recording a demo
====================
*/
void SV_MVDStop (int reason, qbool mvdonly)
{
	static qbool instop = false;

	int numclosed;

	if (instop)
	{
		Con_Printf("SV_MVDStop: recursion\n");
		return;
	}

	if (!sv.mvdrecording)
	{
		Con_Printf ("Not recording a demo.\n");
		return;
	}

	instop = true; // SET TO TRUE, DON'T FORGET SET TO FALSE ON RETURN

	if (reason == 2 || reason == 3 || reason == 4)
	{
		if (reason == 4)
			mvdonly = false; // if serious error, then close all dests including qtv streams

		// stop and remove
		DestCloseAllFlush(true, mvdonly);

		if (!demo.dest)
			sv.mvdrecording = false;

		if (reason == 4)
			SV_BroadcastPrintf (PRINT_CHAT, "Error in MVD/QTV recording, recording stopped\n");
		else if (reason == 3)
			SV_BroadcastPrintf (PRINT_CHAT, "QTV disconnected\n");
		else
		{
			if ( !sv_silentrecord.value )
				SV_BroadcastPrintf (PRINT_CHAT, "Server recording canceled, demo removed\n");
		}

		Cvar_SetROM(&serverdemo, "");

		instop = false; // SET TO FALSE

		return;
	}
	
	// write a disconnect message to the demo file
	// FIXME: qqshka: add clearup to be sure message will fit!!!

	if (MVDWrite_Begin(dem_all, 0, 2+strlen("EndOfDemo")))
	{
		MVD_MSG_WriteByte (svc_disconnect);
		MVD_MSG_WriteString ("EndOfDemo");
	}

	// finish up
	SV_MVDWritePackets(demo.parsecount - demo.lastwritten + 1);

	// last recorded demo's names for command "cmd dl . .." (maximum 15 dots)
	SV_AddLastDemo();

	numclosed = DestCloseAllFlush(false, mvdonly);

	if (!demo.dest)
		sv.mvdrecording = false;

	if (numclosed)
	{
		if (!reason)
		{
			if ( !sv_silentrecord.value )
				SV_BroadcastPrintf (PRINT_CHAT, "Server recording completed\n");
		}
		else
			SV_BroadcastPrintf (PRINT_CHAT, "Server recording stopped\nMax demo size exceeded\n");
	}

	Cvar_SetROM(&serverdemo, "");

	instop = false; // SET TO FALSE
}

/*
====================
SV_MVDStop_f
====================
*/
void SV_MVDStop_f (void)
{
	SV_MVDStop(0, true);
}

/*
====================
SV_MVD_Cancel_f

Stops recording, and removes the demo
====================
*/
void SV_MVD_Cancel_f (void)
{
	SV_MVDStop(2, true);
}

/*
====================
SV_WriteRecordMVDMessage
====================
*/
static void SV_WriteRecordMVDMessage (sizebuf_t *msg)
{
	int len;
	byte c;

	if (!sv.mvdrecording)
		return;

	if (!msg->cursize)
		return;

	c = 0;
	DemoWrite (&c, sizeof(c));

	c = dem_all;
	DemoWrite (&c, sizeof(c));

	len = LittleLong (msg->cursize);
	DemoWrite (&len, 4);

	DemoWrite (msg->data, msg->cursize);
}

/*
====================
SV_WriteRecordMVDStatsMessage
====================
*/
static void SV_WriteRecordMVDStatsMessage (sizebuf_t *msg, int client)
{
	int len;
	byte c;

	if (!sv.mvdrecording)
		return;

	if (!msg->cursize)
		return;

	if (client < 0 || client >= MAX_CLIENTS)
		return;

	c = 0;
	DemoWrite (&c, sizeof(c));

	c = dem_stats | (client << 3) ; // msg "type" and "to" incapsulated in one byte
	DemoWrite (&c, sizeof(c));

	len = LittleLong (msg->cursize);
	DemoWrite (&len, 4);

	DemoWrite (msg->data, msg->cursize);
}


/*
static void SV_WriteSetMVDMessage (void)
{
	int len;
	byte c;

	if (!sv.mvdrecording)
		return;

	c = 0;
	DemoWrite (&c, sizeof(c));

	c = dem_set;
	DemoWrite (&c, sizeof(c));


	len = LittleLong(0);
	DemoWrite (&len, 4);
	len = LittleLong(0);
	DemoWrite (&len, 4);
}
*/

// mvd/qtv related stuff
// Well, here is a chance what player connect after demo recording started,
// so demo.info[edictnum - 1].model == player_model so SV_MVDWritePackets() will not wrote player model index,
// so client during playback this demo will got invisible model, because model index will be 0.
// Fixing that.
// Btw, struct demo contain different client specific structs, may be they need clearing too, not sure.
void MVD_PlayerReset(int player)
{
	if (player < 0 || player >= MAX_CLIENTS) { // protect from lamers
		Con_Printf("MVD_PlayerReset: wrong player num %d\n", player);
		return;
	}

	memset(&(demo.clients[player]), 0, sizeof(demo.clients[0]));
}

qbool SV_MVD_Record (mvddest_t *dest, qbool mapchange)
{
	int i;

	if (mapchange)
	{
		if (dest) // during mapchange dest must be NULL
			return false;
	}
	else
	{
		if (!dest) // in non mapchange dest must be not NULL
			return false;
	}

	// If we initialize MVD recording, then reset some data structs
	if (!sv.mvdrecording)
	{
		// this is either mapchange and we have QTV connected
		// or we just use /record or whatever command first time and here no recording yet

    	// and here we memset() not whole demo_t struct, but part,
    	// so demo.dest and demo.pendingdest is not overwriten
		memset(&demo, 0, (int)((uintptr_t)&(((demo_t *)0)->mem_set_point)));

		for (i = 0; i < UPDATE_BACKUP; i++)
		{
			// set up buffer for record in each frame
			SZ_InitEx(&demo.frames[i]._buf_, demo.frames[i]._buf__data, sizeof(demo.frames[0]._buf__data), true);
		}

		// set up buffer for non releable data
		SZ_InitEx(&demo.datagram, demo.datagram_data, sizeof(demo.datagram_data), true);
	}

	if (mapchange)
	{
		//
		// map change, sent initial stats to all dests
		//
		SV_MVD_SendInitialGamestate(NULL);
	}
	else
	{
		//
		// seems we initializing new dest, sent initial stats only to this dest
		//
		dest->nextdest = demo.dest;
		demo.dest = dest;

		SV_MVD_SendInitialGamestate(dest);
	}

	// done
	return true;
}

void SV_MVD_SendInitialGamestate(mvddest_t* dest)
{
	sizebuf_t	buf;
	unsigned char buf_data[MAX_MSGLEN];
	unsigned int n;
	char* s, info[MAX_EXT_INFO_STRING];

	client_t* player;
	edict_t* ent;
	char* gamedir;
	int i;

	if (!demo.dest)
		return;

	sv.mvdrecording = true; // NOTE:  afaik set to false on map change, so restore it here
	demo.pingtime = demo.time = sv.time;
	singledest = dest;

	/*-------------------------------------------------*/

	// serverdata
	// send the info about the new client to all connected clients
	SZ_Init(&buf, buf_data, sizeof(buf_data));

	// send the serverdata

	gamedir = Info_ValueForKey(svs.info, "*gamedir");
	if (!gamedir[0])
		gamedir = "qw";

	MSG_WriteByte(&buf, svc_serverdata);

#ifdef FTE_PEXT_256PACKETENTITIES
	demo.recorder.fteprotocolextensions |= FTE_PEXT_256PACKETENTITIES;
#endif
#ifdef FTE_PEXT_MODELDBL
	demo.recorder.fteprotocolextensions |= FTE_PEXT_MODELDBL;
#endif
#ifdef FTE_PEXT_ENTITYDBL
	demo.recorder.fteprotocolextensions |= FTE_PEXT_ENTITYDBL;
#endif
#ifdef FTE_PEXT_ENTITYDBL2
	demo.recorder.fteprotocolextensions |= FTE_PEXT_ENTITYDBL2;
#endif
#ifdef FTE_PEXT_SPAWNSTATIC2
	demo.recorder.fteprotocolextensions |= FTE_PEXT_SPAWNSTATIC2;
#endif
#ifdef FTE_PEXT_TRANS
	demo.recorder.fteprotocolextensions |= FTE_PEXT_TRANS;
#endif
#ifdef FTE_PEXT_COLOURMOD
	demo.recorder.fteprotocolextensions |= FTE_PEXT_COLOURMOD;
#endif
#ifdef FTE_PEXT2_VOICECHAT
	demo.recorder.fteprotocolextensions2 |= FTE_PEXT2_VOICECHAT;
#endif

#ifdef FTE_PEXT_FLOATCOORDS
	//fix up extensions to match sv_bigcoords correctly. sorry for old clients not working.
	if (msg_coordsize == 4)
		demo.recorder.fteprotocolextensions |= FTE_PEXT_FLOATCOORDS;
	else
		demo.recorder.fteprotocolextensions &= ~FTE_PEXT_FLOATCOORDS;
#endif

#ifdef PROTOCOL_VERSION_FTE
	if (demo.recorder.fteprotocolextensions)
	{
		MSG_WriteLong(&buf, PROTOCOL_VERSION_FTE);
		MSG_WriteLong(&buf, demo.recorder.fteprotocolextensions);
	}
#endif

#ifdef PROTOCOL_VERSION_FTE2
	if (demo.recorder.fteprotocolextensions2)
	{
		MSG_WriteLong(&buf, PROTOCOL_VERSION_FTE2);
		MSG_WriteLong(&buf, demo.recorder.fteprotocolextensions2);
	}
#endif

#ifdef PROTOCOL_VERSION_MVD1
	demo.recorder.mvdprotocolextensions1 |= MVD_PEXT1_HIDDEN_MESSAGES;
	if (demo.recorder.mvdprotocolextensions1)
	{
		MSG_WriteLong(&buf, PROTOCOL_VERSION_MVD1);
		MSG_WriteLong(&buf, demo.recorder.mvdprotocolextensions1);
	}
#endif

	MSG_WriteLong (&buf, PROTOCOL_VERSION);
	MSG_WriteLong (&buf, svs.spawncount);
	MSG_WriteString (&buf, gamedir);


	MSG_WriteFloat (&buf, sv.time);

	// send full levelname
	MSG_WriteString (&buf, PR_GetEntityString(sv.edicts->v->message));

	// send the movevars
	MSG_WriteFloat(&buf, movevars.gravity);
	MSG_WriteFloat(&buf, movevars.stopspeed);
	MSG_WriteFloat(&buf, movevars.maxspeed);
	MSG_WriteFloat(&buf, movevars.spectatormaxspeed);
	MSG_WriteFloat(&buf, movevars.accelerate);
	MSG_WriteFloat(&buf, movevars.airaccelerate);
	MSG_WriteFloat(&buf, movevars.wateraccelerate);
	MSG_WriteFloat(&buf, movevars.friction);
	MSG_WriteFloat(&buf, movevars.waterfriction);
	MSG_WriteFloat(&buf, movevars.entgravity);

	// send music
	MSG_WriteByte (&buf, svc_cdtrack);
	MSG_WriteByte (&buf, 0); // none in demos

	// send server info string
	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, va("fullserverinfo \"%s\"\n", svs.info) );

	// flush packet
	SV_WriteRecordMVDMessage (&buf);
	SZ_Clear (&buf);

	// soundlist
	MSG_WriteByte (&buf, svc_soundlist);
	MSG_WriteByte (&buf, 0);

	n = 0;
	s = sv.sound_precache[n+1];
	while (s)
	{
		MSG_WriteString (&buf, s);
		if (buf.cursize > MAX_MSGLEN/2)
		{
			MSG_WriteByte (&buf, 0);
			MSG_WriteByte (&buf, n);
			SV_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
			MSG_WriteByte (&buf, svc_soundlist);
			MSG_WriteByte (&buf, n + 1);
		}
		n++;
		s = sv.sound_precache[n+1];
	}

	if (buf.cursize)
	{
		MSG_WriteByte (&buf, 0);
		MSG_WriteByte (&buf, 0);
		SV_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	// modellist
	MSG_WriteByte (&buf, svc_modellist);
	MSG_WriteByte (&buf, 0);

	n = 0;
	s = sv.model_precache[n+1];
	while (s)
	{
		MSG_WriteString (&buf, s);
		if (buf.cursize > MAX_MSGLEN/2 && n & 0xff)
		{
			// partial flush as long as not at a zero boundary
			MSG_WriteByte (&buf, 0);
			MSG_WriteByte (&buf, n);
			SV_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
			if (n + 1 > 0xff)
			{
				MSG_WriteByte (&buf, svc_fte_modellistshort);
				MSG_WriteShort (&buf, n + 1);
			} else
			{
				MSG_WriteByte (&buf, svc_modellist);
				MSG_WriteByte (&buf, n + 1);
			}
		}
		n++;
		s = sv.model_precache[n+1];
	}

	if (buf.cursize)
	{
		MSG_WriteByte (&buf, 0);
		MSG_WriteByte (&buf, 0);
		SV_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	// static entities
	{
		int i, j;
		entity_state_t from = { 0 };

		for (i = 0; i < sv.static_entity_count; ++i) {
			entity_state_t* s = &sv.static_entities[i];

			if (buf.cursize >= MAX_MSGLEN/2) {
				SV_WriteRecordMVDMessage (&buf);
				SZ_Clear (&buf);
			}

			if (demo.recorder.fteprotocolextensions & FTE_PEXT_SPAWNSTATIC2) {
				MSG_WriteByte(&buf, svc_fte_spawnstatic2);
				SV_WriteDelta(&demo.recorder, &from, s, &buf, true);
			}
			else if (s->modelindex < 256) {
				MSG_WriteByte(&buf, svc_spawnstatic);
				MSG_WriteByte(&buf, s->modelindex);
				MSG_WriteByte(&buf, s->frame);
				MSG_WriteByte(&buf, s->colormap);
				MSG_WriteByte(&buf, s->skinnum);
				for (j = 0; j < 3; ++j) {
					MSG_WriteCoord(&buf, s->origin[j]);
					MSG_WriteAngle(&buf, s->angles[j]);
				}
			}
		}
	}

	// entity baselines
	{
		static entity_state_t empty_baseline = { 0 };
		int i, j;

		for (i = 0; i < sv.num_baseline_edicts; ++i) {
			edict_t* svent = EDICT_NUM(i);
			entity_state_t* s = &svent->e.baseline;

			if (buf.cursize >= MAX_MSGLEN/2) {
				SV_WriteRecordMVDMessage (&buf);
				SZ_Clear (&buf);
			}

			if (!s->number || !s->modelindex || !memcmp(s, &empty_baseline, sizeof(empty_baseline))) {
				continue;
			}

			if (demo.recorder.fteprotocolextensions & FTE_PEXT_SPAWNSTATIC2) {
				MSG_WriteByte(&buf, svc_fte_spawnbaseline2);
				SV_WriteDelta(&demo.recorder, &empty_baseline, s, &buf, true);
			}
			else if (s->modelindex < 256) {
				MSG_WriteByte(&buf, svc_spawnbaseline);
				MSG_WriteShort(&buf, i);
				MSG_WriteByte(&buf, s->modelindex);
				MSG_WriteByte(&buf, s->frame);
				MSG_WriteByte(&buf, s->colormap);
				MSG_WriteByte(&buf, s->skinnum);
				for (j = 0; j < 3; j++) {
					MSG_WriteCoord(&buf, s->origin[j]);
					MSG_WriteAngle(&buf, s->angles[j]);
				}
			}
		}
	}

	// prespawn
	for (n = 0; n < sv.num_signon_buffers; n++)
	{
		if (buf.cursize+sv.signon_buffer_size[n] > MAX_MSGLEN/2)
		{
			SV_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
		}
		SZ_Write (&buf,
		          sv.signon_buffers[n],
		          sv.signon_buffer_size[n]);
	}

	if (buf.cursize > MAX_MSGLEN/2)
	{
		SV_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, va("cmd spawn %i 0\n",svs.spawncount) );

	if (buf.cursize)
	{
		SV_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	// send current status of all other players

	for (i = 0; i < MAX_CLIENTS; i++)
	{
		player = svs.clients + i;

		// there spectators NOT ignored, since this info required, at least userinfo

		MSG_WriteByte (&buf, svc_updatefrags);
		MSG_WriteByte (&buf, i);
		MSG_WriteShort (&buf, player->old_frags);

		MSG_WriteByte (&buf, svc_updateping);
		MSG_WriteByte (&buf, i);
		MSG_WriteShort (&buf, SV_CalcPing(player));

		MSG_WriteByte (&buf, svc_updatepl);
		MSG_WriteByte (&buf, i);
		MSG_WriteByte (&buf, player->lossage);

		MSG_WriteByte (&buf, svc_updateentertime);
		MSG_WriteByte (&buf, i);
		MSG_WriteFloat (&buf, SV_ClientGameTime(player));

		Info_ReverseConvert(&player->_userinfoshort_ctx_, info, sizeof(info));
		Info_RemovePrefixedKeys (info, '_');	// server passwords, etc

		MSG_WriteByte (&buf, svc_updateuserinfo);
		MSG_WriteByte (&buf, i);
		MSG_WriteLong (&buf, player->userid);
		MSG_WriteString (&buf, info);

		if (buf.cursize > MAX_MSGLEN/2)
		{
			SV_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
		}
	}

	if (buf.cursize)
	{
		SV_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	// this set proper model origin and angles etc for players
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		vec3_t origin, angles;
		int j, flags;

		player = svs.clients + i;
		ent = player->edict;

		if (player->state != cs_spawned)
			continue;

		if (player->spectator)
			continue; // ignore specs

		flags =   (DF_ORIGIN << 0) | (DF_ORIGIN << 1) | (DF_ORIGIN << 2)
				| (DF_ANGLES << 0) | (DF_ANGLES << 1) | (DF_ANGLES << 2)
				| DF_EFFECTS | DF_SKINNUM 
				| (ent->v->health <= 0 ? DF_DEAD : 0)
				| (ent->v->mins[2] != -24 ? DF_GIB : 0)
				| DF_WEAPONFRAME | DF_MODEL;

		VectorCopy(ent->v->origin, origin);
		VectorCopy(ent->v->angles, angles);
		angles[0] *= -3;
#ifdef USE_PR2
		if( player->isBot )
			VectorCopy(ent->v->v_angle, angles);
#endif
		angles[2] = 0; // no roll angle

		if (ent->v->health <= 0)
		{	// don't show the corpse looking around...
			angles[0] = 0;
			angles[1] = ent->v->angles[1];
			angles[2] = 0;
		}

		MSG_WriteByte (&buf, svc_playerinfo);
		MSG_WriteByte (&buf, i);
		MSG_WriteShort (&buf, flags);

		MSG_WriteByte (&buf, ent->v->frame);

		for (j = 0 ; j < 3 ; j++)
			if (flags & (DF_ORIGIN << j))
				MSG_WriteCoord (&buf, origin[j]);

		for (j = 0 ; j < 3 ; j++)
			if (flags & (DF_ANGLES << j))
				MSG_WriteAngle16 (&buf, angles[j]);

		if (flags & DF_MODEL)
			MSG_WriteByte (&buf, ent->v->modelindex);

		if (flags & DF_SKINNUM)
			MSG_WriteByte (&buf, ent->v->skin);

		if (flags & DF_EFFECTS)
			MSG_WriteByte (&buf, ent->v->effects);

		if (flags & DF_WEAPONFRAME)
			MSG_WriteByte (&buf, ent->v->weaponframe);

		if (buf.cursize > MAX_MSGLEN/2)
		{
			SV_WriteRecordMVDMessage (&buf);
			SZ_Clear (&buf);
		}
	}

	// we really need clear buffer before sending stats
	if (buf.cursize)
	{
		SV_WriteRecordMVDMessage (&buf);
		SZ_Clear (&buf);
	}

	// send stats
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		int		stats[MAX_CL_STATS];
		int		j;

		player = svs.clients + i;
		ent = player->edict;

		if (player->state != cs_spawned)
			continue;

		if (player->spectator)
			continue;

		memset(stats, 0, sizeof(stats));

		stats[STAT_HEALTH]       = ent->v->health;
		stats[STAT_WEAPON]       = SV_ModelIndex(PR_GetEntityString(ent->v->weaponmodel));
		stats[STAT_AMMO]         = ent->v->currentammo;
		stats[STAT_ARMOR]        = ent->v->armorvalue;
		stats[STAT_SHELLS]       = ent->v->ammo_shells;
		stats[STAT_NAILS]        = ent->v->ammo_nails;
		stats[STAT_ROCKETS]      = ent->v->ammo_rockets;
		stats[STAT_CELLS]        = ent->v->ammo_cells;
		stats[STAT_ACTIVEWEAPON] = ent->v->weapon;

		if (ent->v->health > 0) // viewheight for PF_DEAD & PF_GIB is hardwired
			stats[STAT_VIEWHEIGHT] = ent->v->view_ofs[2];

		// stuff the sigil bits into the high bits of items for sbar
		stats[STAT_ITEMS] = (int) ent->v->items | ((int) PR_GLOBAL(serverflags) << 28);

		for (j = 0; j < MAX_CL_STATS; j++)
		{
			if (stats[j] >= 0 && stats[j] <= 255)
			{
				MSG_WriteByte(&buf, svc_updatestat);
				MSG_WriteByte(&buf, j);
				MSG_WriteByte(&buf, stats[j]);
			}
			else
			{
				MSG_WriteByte(&buf, svc_updatestatlong);
				MSG_WriteByte(&buf, j);
				MSG_WriteLong(&buf, stats[j]);
			}
		}

		if (buf.cursize)
		{
			SV_WriteRecordMVDStatsMessage(&buf, i);
			SZ_Clear (&buf);
		}
	}

	// above stats writing must clear buffer
	if (buf.cursize)
	{
		Sys_Error("SV_MVD_SendInitialGamestate: buf.cursize %d", buf.cursize);
	}

	// send all current light styles
	for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
	{
		MSG_WriteByte (&buf, svc_lightstyle);
		MSG_WriteByte (&buf, (char)i);
		MSG_WriteString (&buf, sv.lightstyles[i]);
	}

	// get the client to check and download skins
	// when that is completed, a begin command will be issued
	MSG_WriteByte (&buf, svc_stufftext);
	MSG_WriteString (&buf, "skins\n");

	SV_WriteRecordMVDMessage (&buf);

//	SV_WriteSetMVDMessage();

	singledest = NULL;
}

/*
====================
SV_MVD_Record_f

record <demoname>
====================
*/
void SV_MVD_Record_f (void)
{
	int c;
	char name[MAX_OSPATH+MAX_DEMO_NAME];
	char newname[MAX_DEMO_NAME];

	c = Cmd_Argc();
	if (c != 2)
	{
		Con_Printf ("record <demoname>\n");
		return;
	}

	if (sv.state != ss_active)
	{
		Con_Printf ("Not active yet.\n");
		return;
	}

	// clear old demos
	if (!SV_DirSizeCheck())
		return;

	strlcpy(newname, va("%s%s%s", sv_demoPrefix.string, SV_CleanName((unsigned char*)Cmd_Argv(1)),
						sv_demoSuffix.string), sizeof(newname) - 4);

	Sys_mkdir(va("%s/%s", fs_gamedir, sv_demoDir.string));

	snprintf (name, sizeof(name), "%s/%s/%s", fs_gamedir, sv_demoDir.string, newname);

	if ((c = strlen(name)) > 3)
		if (strcmp(name + c - 4, ".mvd"))
			strlcat(name, ".mvd", sizeof(name));

	//
	// open the demo file and start recording
	//
	SV_MVD_Record (SV_InitRecordFile(name), false);
}

/*
====================
SV_MVDEasyRecord_f

easyrecord [demoname]
====================
*/

void SV_MVDEasyRecord_f (void)
{
	int		c;
	char	name[MAX_DEMO_NAME];
	char	name2[MAX_OSPATH*7]; // scream
	char	name4[MAX_OSPATH*7]; // scream

	int		i;
	dir_t	dir;
	char	*name3;

	c = Cmd_Argc();
	if (c > 2)
	{
		Con_Printf ("easyrecord [demoname]\n");
		return;
	}

	if (!SV_DirSizeCheck()) // clear old demos
		return;

	if (c == 2)
		strlcpy (name, Cmd_Argv(1), sizeof(name));
	else
	{
		i = Dem_CountPlayers();
		if ((int)teamplay.value >= 1 && i > 2)
		{
			// Teamplay
			snprintf (name, sizeof(name), "%don%d_", Dem_CountTeamPlayers(Dem_Team(1)), Dem_CountTeamPlayers(Dem_Team(2)));
			if ((int)sv_demoExtraNames.value > 0)
			{
				strlcat (name, va("[%s]_%s_vs_[%s]_%s_%s",
				                  Dem_Team(1), Dem_PlayerNameTeam(Dem_Team(1)),
				                  Dem_Team(2), Dem_PlayerNameTeam(Dem_Team(2)),
				                  sv.mapname), sizeof(name));
			}
			else
				strlcat (name, va("%s_vs_%s_%s", Dem_Team(1), Dem_Team(2), sv.mapname), sizeof(name));
		}
		else
		{
			if (i == 2)
			{
				// Duel
				snprintf (name, sizeof(name), "duel_%s_vs_%s_%s",
				          Dem_PlayerName(1),
				          Dem_PlayerName(2),
				          sv.mapname);
			}
			else
			{
				// FFA
				snprintf (name, sizeof(name), "ffa_%s(%d)", sv.mapname, i);
			}
		}
	}

	// <-

	// Make sure the filename doesn't contain illegal characters
	strlcpy(name, va("%s%s%s", sv_demoPrefix.string,
			 SV_CleanName((unsigned char*)name), sv_demoSuffix.string), MAX_DEMO_NAME);
	strlcpy(name2, name, sizeof(name2));
	Sys_mkdir(va("%s/%s", fs_gamedir, sv_demoDir.string));

	// FIXME: very SLOW
	if (!(name3 = quote(name2)))
		return;
	dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string),
					  va("^%s%s", name3, sv_demoRegexp.string), SORT_NO);
	Q_free(name3);
	for (i = 1; dir.numfiles; )
	{
		snprintf(name2, sizeof(name2), "%s_%02i", name, i++);
		if (!(name3 = quote(name2)))
			return;
		dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string),
						  va("^%s%s", name3, sv_demoRegexp.string), SORT_NO);
		Q_free(name3);
	}

	strlcpy(name4, name2, sizeof(name4));
	snprintf(name2, sizeof(name2), "%s", va("%s/%s/%s.mvd", fs_gamedir, sv_demoDir.string, name2));
	snprintf(name4, sizeof(name4), "%s", va("%s/%s.xml", sv_demoDir.string, name4));
	Cvar_Set(&extralogname, name4);

	SV_MVD_Record (SV_InitRecordFile(name2), false);
}

//============================================================

static void MVD_Init (void)
{
	int p, size = DEMO_CACHE_MIN_SIZE;

	memset(&demo, 0, sizeof(demo)); // clear whole demo struct at least once
	
	Cvar_Register (&sv_demofps);
	Cvar_Register (&sv_demoIdlefps);
	Cvar_Register (&sv_demoPings);
	Cvar_Register (&sv_demoUseCache);
	Cvar_Register (&sv_demoCacheSize);
	Cvar_Register (&sv_demoMaxSize);
	Cvar_Register (&sv_demoMaxDirSize);
	Cvar_Register (&sv_demoClearOld); //bliP: 24/9 clear old demos
	Cvar_Register (&sv_demoDir);
	Cvar_Register (&sv_demoDirAlt);
	Cvar_Register (&sv_demoPrefix);
	Cvar_Register (&sv_demoSuffix);
	Cvar_Register (&sv_onrecordfinish);
	Cvar_Register (&sv_ondemoremove);
	Cvar_Register (&sv_demotxt);
	Cvar_Register (&sv_demoExtraNames);
	Cvar_Register (&sv_demoRegexp);
	Cvar_Register (&sv_silentrecord);

	Cvar_Register (&extralogname);

	p = SV_CommandLineDemoCacheArgument();
	if (p)
	{
		if (p < COM_Argc()-1)
			size = Q_atoi (COM_Argv(p+1)) * 1024;
		else
			Sys_Error ("MVD_Init: you must specify a size in KB after -democache");
	}

	if (size < DEMO_CACHE_MIN_SIZE)
	{
		Con_Printf("Minimum memory size for demo cache is %dk\n", DEMO_CACHE_MIN_SIZE / 1024);
		size = DEMO_CACHE_MIN_SIZE;
	}

	Cvar_SetROM(&sv_demoCacheSize, va("%d", size/1024));
	CleanName_Init();
}

void SV_UserCmdTrace_f(void)
{
	const char* user = Cmd_Argv(1);
	const char* option_ = Cmd_Argv(2);
	qbool option = false;
	int uid, i;

	if (Cmd_Argc() != 3) {
		Con_Printf("Usage: %s userid (on | off)\n", Cmd_Argv(0));
		return;
	}

	if (!strcmp(option_, "on")) {
		option = true;
	}
	else if (strcmp(option_, "off")) {
		Con_Printf("Usage: %s userid (on | off)\n", Cmd_Argv(0));
		return;
	}

	uid = atoi(user);
	if (!uid) {
		Con_Printf("Usage: %s userid (on | off)\n", Cmd_Argv(0));
		return;
	}

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!svs.clients[i].state) {
			continue;
		}
		if (svs.clients[i].userid == uid) {
			svs.clients[i].mvd_write_usercmds = option;
			return;
		}
	}

	Con_Printf("Couldn't find userid %d\n", uid);
	return;
}

void SV_MVDInit(void)
{
	MVD_Init();

#ifdef SERVERONLY
	// name clashes with client.
	// would be nice to prefix it with sv_demo*,
	// but mods use it like that already, so we keep it for backward compatibility.
	Cmd_AddCommand ("record",			SV_MVD_Record_f);
	Cmd_AddCommand ("easyrecord",		SV_MVDEasyRecord_f);
	Cmd_AddCommand ("stop",				SV_MVDStop_f);
#endif
	// that how thouse commands should be called.
	Cmd_AddCommand ("sv_demorecord",	SV_MVD_Record_f);
	Cmd_AddCommand ("sv_demoeasyrecord",SV_MVDEasyRecord_f);
	Cmd_AddCommand ("sv_demostop",		SV_MVDStop_f);

	// that one does not clashes with client, but keep name for backward compatibility.
	Cmd_AddCommand ("cancel",			SV_MVD_Cancel_f);
	// that how thouse commands should be called.
	Cmd_AddCommand ("sv_democancel",	SV_MVD_Cancel_f);
	// this ones prefixed OK.
	Cmd_AddCommand ("sv_lastscores",	SV_LastScores_f);
	Cmd_AddCommand ("sv_demolist",		SV_DemoList_f);
	Cmd_AddCommand ("sv_demolistr",		SV_DemoListRegex_f);
	Cmd_AddCommand ("sv_demolistregex",	SV_DemoListRegex_f);
	Cmd_AddCommand ("sv_demoremove",	SV_MVDRemove_f);
	Cmd_AddCommand ("sv_demonumremove",	SV_MVDRemoveNum_f);
	Cmd_AddCommand ("sv_demoinfoadd",	SV_MVDInfoAdd_f);
	Cmd_AddCommand ("sv_demoinforemove",SV_MVDInfoRemove_f);
	Cmd_AddCommand ("sv_demoinfo",		SV_MVDInfo_f);
	Cmd_AddCommand ("sv_demoembedinfo", SV_MVDEmbedInfo_f);
	// not prefixed.
#ifdef SERVERONLY
	Cmd_AddCommand ("script",			SV_Script_f);
#endif

	Cmd_AddCommand ("sv_usercmdtrace",  SV_UserCmdTrace_f);

	SV_QTV_Init();
}

const char* SV_MVDDemoName(void)
{
	mvddest_t* d;

	for (d = demo.dest; d; d = d->nextdest) {
		if (d->desttype == DEST_STREAM) {
			continue; // streams are not saved on to HDD, so ignore it...
		}
		if (d->name[0]) {
			return d->name;
		}
	}

	return NULL;
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_demo_misc.c
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    
*/

// sv_demo_misc.c - misc demo related stuff, helpers

#ifndef CLIENTONLY
#include "qwsvdef.h"
#ifndef SERVERONLY
#include "pcre2.h"
#endif

#define MAX_DEMOINFO_SIZE (1024 * 200)
static char chartbl[256];

/*
====================
CleanName_Init

sets chararcter table for quake text->filename translation
====================
*/
void CleanName_Init (void)
{
	int i;

	for (i = 0; i < 256; i++)
		chartbl[i] = (((i&127) < 'a' || (i&127) > 'z') && ((i&127) < '0' || (i&127) > '9')) ? '_' : (i&127);

	// special cases

	// numbers
	for (i = 18; i < 29; i++)
		chartbl[i] = chartbl[i + 128] = i + 30;

	// allow lowercase only
	for (i = 'A'; i <= 'Z'; i++)
		chartbl[i] = chartbl[i+128] = i + 'a' - 'A';

	// brackets
	chartbl[29] = chartbl[29+128] = chartbl[128] = '(';
	chartbl[31] = chartbl[31+128] = chartbl[130] = ')';
	chartbl[16] = chartbl[16 + 128]= '[';
	chartbl[17] = chartbl[17 + 128] = ']';

	// dot
	chartbl[5] = chartbl[14] = chartbl[15] = chartbl[28] = chartbl[46] = '.';
	chartbl[5 + 128] = chartbl[14 + 128] = chartbl[15 + 128] = chartbl[28 + 128] = chartbl[46 + 128] = '.';

	// !
	chartbl[33] = chartbl[33 + 128] = '!';

	// #
	chartbl[35] = chartbl[35 + 128] = '#';

	// %
	chartbl[37] = chartbl[37 + 128] = '%';

	// &
	chartbl[38] = chartbl[38 + 128] = '&';

	// '
	chartbl[39] = chartbl[39 + 128] = '\'';

	// (
	chartbl[40] = chartbl[40 + 128] = '(';

	// )
	chartbl[41] = chartbl[41 + 128] = ')';

	// +
	chartbl[43] = chartbl[43 + 128] = '+';

	// -
	chartbl[45] = chartbl[45 + 128] = '-';

	// @
	chartbl[64] = chartbl[64 + 128] = '@';

	// ^
	//	chartbl[94] = chartbl[94 + 128] = '^';


	chartbl[91] = chartbl[91 + 128] = '[';
	chartbl[93] = chartbl[93 + 128] = ']';

	chartbl[16] = chartbl[16 + 128] = '[';
	chartbl[17] = chartbl[17 + 128] = ']';

	chartbl[123] = chartbl[123 + 128] = '{';
	chartbl[125] = chartbl[125 + 128] = '}';
}

/*
====================
SV_CleanName

Cleans the demo name, removes restricted chars, makes name lowercase
====================
*/
char *SV_CleanName (unsigned char *name)
{
	static char text[1024];
	char *out = text;

	if (!name || !*name)
	{
		*out = '\0';
		return text;
	}

	*out = chartbl[*name++];

	while (*name && ((out - text) < (int) sizeof(text)))
		if (*out == '_' && chartbl[*name] == '_')
			name++;
		else *++out = chartbl[*name++];

	*++out = 0;
	return text;
}

/*
====================
SV_DirSizeCheck

Deletes sv_demoClearOld files from demo dir if out of space
====================
*/
qbool SV_DirSizeCheck (void)
{
	dir_t	dir;
	file_t	*list;
	int	n;

	if ((int)sv_demoMaxDirSize.value)
	{
		dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string), ".*", SORT_NO/*BY_DATE*/);
		if ((float)dir.size > sv_demoMaxDirSize.value * 1024)
		{
			if ((int)sv_demoClearOld.value <= 0)
			{
				Con_Printf("Insufficient directory space, increase sv_demoMaxDirSize\n");
				return false;
			}
			list = dir.files;
			n = (int) sv_demoClearOld.value;
			Con_Printf("Clearing %d old demos\n", n);
			// HACK!!! HACK!!! HACK!!!
			if ((int)sv_demotxt.value) // if our server record demos and txts, then to remove
				n <<= 1;  // 50 demos, we have to remove 50 demos and 50 txts = 50*2 = 100 files

			qsort((void *)list, dir.numfiles, sizeof(file_t), Sys_compare_by_date);
			for (; list->name[0] && n > 0; list++)
			{
				if (list->isdir)
					continue;
				Sys_remove(va("%s/%s/%s", fs_gamedir, sv_demoDir.string, list->name));
				//Con_Printf("Remove %d - %s/%s/%s\n", n, fs_gamedir, sv_demoDir.string, list->name);
				n--;
			}

			// force cache rebuild.
			FS_FlushFSHash();
		}
	}
	return true;
}

void Run_sv_demotxt_and_sv_onrecordfinish (const char *dest_name, const char *dest_path, qbool destroyfiles)
{
	char path[MAX_OSPATH];

	snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, dest_path, dest_name);
	strlcpy(path + strlen(path) - 3, "txt", MAX_OSPATH - strlen(path) + 3);

	if ((int)sv_demotxt.value && !destroyfiles) // dont keep txt's for deleted demos
	{
		FILE *f;
		char *text;

		if (sv_demotxt.value == 2)
		{
			if ((f = fopen (path, "a+t")))
				fclose(f); // at least made empty file, but do not owerwite
		}
		else if ((f = fopen (path, "w+t")))
		{
			text = SV_PrintTeams();
			fwrite(text, strlen(text), 1, f);
			fflush(f);
			fclose(f);
		}
	}

	if (sv_onrecordfinish.string[0] && !destroyfiles) // dont gzip deleted demos
	{
		extern redirect_t sv_redirected;
		redirect_t old = sv_redirected;
		char *p;
	
		if ((p = strchr(sv_onrecordfinish.string, ' ')) != NULL)
			*p = 0; // strip parameters
	
		strlcpy(path, dest_name, sizeof(path));
#ifdef SERVERONLY
		COM_StripExtension(path);
#else
		COM_StripExtension(path, path, sizeof(path));
#endif

		sv_redirected = RD_NONE; // onrecord script is called always from the console
		Cmd_TokenizeString(va("script %s \"%s\" \"%s\" %s", sv_onrecordfinish.string, dest_path, path, p != NULL ? p+1 : ""));

		if (p)
			*p = ' '; // restore params

		SV_Script_f();
	
		sv_redirected = old;
	}

	// force cache rebuild.
	FS_FlushFSHash();
}

char *SV_PrintTeams (void)
{
	char			*teams[MAX_CLIENTS];
	int				i, j, numcl = 0, numt = 0, scores;
	client_t		*clients[MAX_CLIENTS];
	char			buf[2048];
	static char		lastscores[2048];
	extern cvar_t	teamplay;
	date_t			date;
	SV_TimeOfDay(&date, "%a %b %d, %H:%M:%S %Y");

	// count teams and players
	for (i=0; i < MAX_CLIENTS; i++)
	{
		if (svs.clients[i].state != cs_spawned)
			continue;
		if (svs.clients[i].spectator)
			continue;

		clients[numcl++] = &svs.clients[i];
		for (j = 0; j < numt; j++)
			if (!strcmp(svs.clients[i].team, teams[j]))
				break;
		if (j != numt)
			continue;

		teams[numt++] = svs.clients[i].team;
	}

	// create output
	lastscores[0] = 0;
	snprintf(buf, sizeof(buf),
		"date %s\nmap %s\nteamplay %d\ndeathmatch %d\ntimelimit %d\n",
		date.str, sv.mapname, (int)teamplay.value, (int)deathmatch.value,
		(int)timelimit.value);
	if (numcl == 2) // duel
	{
		snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
			"player1: %s (%i)\nplayer2: %s (%i)\n",
			clients[0]->name, clients[0]->old_frags,
			clients[1]->name, clients[1]->old_frags);
		snprintf(lastscores, sizeof(lastscores), "duel: %s vs %s @ %s - %i:%i\n",
			clients[0]->name, clients[1]->name, sv.mapname,
			clients[0]->old_frags, clients[1]->old_frags);
	}
	else if (!(int)teamplay.value) // ffa
	{
		snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "players:\n");
		snprintf(lastscores, sizeof(lastscores), "ffa:");
		for (i = 0; i < numcl; i++)
		{
			snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
				"  %s (%i)\n", clients[i]->name, clients[i]->old_frags);
			snprintf(lastscores + strlen(lastscores), sizeof(lastscores) - strlen(lastscores),
				"  %s(%i)", clients[i]->name, clients[i]->old_frags);
		}
		snprintf(lastscores + strlen(lastscores),
			sizeof(lastscores) - strlen(lastscores), " @ %s\n", sv.mapname);
	}
	else
	{ // teamplay
		snprintf(lastscores, sizeof(lastscores), "tp:");
		for (j = 0; j < numt; j++)
		{
			snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
				"team[%i] %s:\n", j, teams[j]);
			snprintf(lastscores + strlen(lastscores), sizeof(lastscores) - strlen(lastscores),
				"%s[", teams[j]);
			scores = 0;
			for (i = 0; i < numcl; i++)
				if (!strcmp(clients[i]->team, teams[j]))
				{
					snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
						"  %s (%i)\n", clients[i]->name, clients[i]->old_frags);
					snprintf(lastscores + strlen(lastscores), sizeof(lastscores) - strlen(lastscores),
						" %s(%i) ", clients[i]->name, clients[i]->old_frags);
					scores += clients[i]->old_frags;
				}
			snprintf(lastscores + strlen(lastscores), sizeof(lastscores) - strlen(lastscores),
				"](%i)  ", scores);

		}
		snprintf(lastscores + strlen(lastscores),
			sizeof(lastscores) - strlen(lastscores), "@ %s\n", sv.mapname);
	}

	Q_normalizetext(buf);
	Q_normalizetext(lastscores);
	strlcat(lastscores, buf, sizeof(lastscores));
	return lastscores;
}


void SV_DemoList (qbool use_regex)
{
	mvddest_t *d;
	dir_t	dir;
	file_t	*list;
	float	free_space;
	int		i, j, n;
	int		files[MAX_DIRFILES + 1];

	PCRE2_SIZE	error_offset;
	pcre2_code	*preg;
	pcre2_match_data *match_data = NULL;
	int error;

	memset(files, 0, sizeof(files));

	Con_Printf("Listing content of %s/%s/%s\n", fs_gamedir, sv_demoDir.string, sv_demoRegexp.string);
	dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string), sv_demoRegexp.string, SORT_BY_DATE);
	list = dir.files;
	if (!list->name[0])
	{
		Con_Printf("no demos\n");
	}

	for (i = 1, n = 0; list->name[0]; list++, i++)
	{
		for (j = 1; j < Cmd_Argc(); j++)
		{
			if (use_regex)
			{
				if (!(preg = pcre2_compile((PCRE2_SPTR)Q_normalizetext(Cmd_Argv(j)), PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &error, &error_offset, NULL)))
				{
					PCRE2_UCHAR error_str[256];
					pcre2_get_error_message(error, error_str, sizeof(error_str));
					Con_Printf("SV_DemoList: pcre2_compile(%s) error: %s at offset %d\n",
					           Cmd_Argv(j), error_str, error_offset);
					pcre2_code_free(preg);
					break;
				}
				match_data = pcre2_match_data_create_from_pattern(preg, NULL);
				error = pcre2_match(preg, (PCRE2_SPTR)list->name, strlen(list->name), 0, 0, match_data, NULL);
				pcre2_match_data_free(match_data);
				pcre2_code_free(preg);
				if (error < 0)
				{
					if (error != PCRE2_ERROR_NOMATCH) {
						Con_Printf("SV_DemoList: pcre2_match(%s, %s) error code: %d\n",
							Cmd_Argv(j), list->name, error);
					}
					break;
				}
			}
			else
			{
				if (strstr(list->name, Cmd_Argv(j)) == NULL)
					break;
			}
		}

		if (Cmd_Argc() == j)
		{
			files[n++] = i;
		}
	}

	list = dir.files;
	for (j = (GameStarted() && n > 100) ? n - 100 : 0; files[j]; j++)
	{
		i = files[j];

		if ((d = DestByName(list[i - 1].name)))
			Con_Printf("*%4d: %s (%dk)\n", i, list[i - 1].name, d->totalsize / 1024);
		else
			Con_Printf("%4d: %s (%dk)\n", i, list[i - 1].name, list[i - 1].size / 1024);
	}

	for (d = demo.dest; d; d = d->nextdest)
	{
		if (d->desttype == DEST_STREAM)
			continue; // streams are not saved on to HDD, so inogre it...
		dir.size += d->totalsize;
	}

	Con_Printf("\ndirectory size: %.1fMB\n", (float)dir.size / (1024 * 1024));
	if ((int)sv_demoMaxDirSize.value)
	{
		free_space = (sv_demoMaxDirSize.value * 1024 - dir.size) / (1024 * 1024);
		if (free_space < 0)
			free_space = 0;
		Con_Printf("space available: %.1fMB\n", free_space);
	}
}

void SV_DemoList_f (void)
{
	SV_DemoList (false);
}

void SV_DemoListRegex_f (void)
{
	SV_DemoList (true);
}

char *SV_MVDNum (int num)
{
	file_t	*list;
	dir_t	dir;

	if (!num)
		return NULL;

	// last recorded demo's names for command "cmd dl . .." (maximum 15 dots)
	if (num & 0xFF000000)
	{
		char *name = demo.lastdemosname[(demo.lastdemospos - (num >> 24) + 1) & 0xF];
		char *name2;
		int c;

		if (!(name2 = quote(name)))
			return NULL;
		if ((c = strlen(name2)) > 5)
			name2[c - 5] = '\0'; // crop quoted extension '\.mvd'

		dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string),
						  va("^%s%s", name2, sv_demoRegexp.string), SORT_NO);
		list = dir.files;
		if (dir.numfiles > 1)
		{
			Con_Printf("SV_MVDNum: where are %d demos with name: %s%s\n",
						dir.numfiles, name2, sv_demoRegexp.string);
		}
		if (!dir.numfiles)
		{
			Con_Printf("SV_MVDNum: where are no demos with name: %s%s\n",
						name2, sv_demoRegexp.string);
			return NULL;
		}
		Q_free(name2);
		//Con_Printf("%s", dir.files[0].name);
		return dir.files[0].name;
	}

	dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string), sv_demoRegexp.string, SORT_BY_DATE);
	list = dir.files;

	if (num & 0x00800000)
	{
		num |= 0xFF000000;
		num += dir.numfiles;
	}
	else
	{
		--num;
	}

	if (num > dir.numfiles)
		return NULL;

	while (list->name[0] && num)
	{
		list++;
		num--;
	}

	return list->name[0] ? list->name : NULL;
}

#define OVECCOUNT 3
char *SV_MVDName2Txt (const char *name)
{
	char	s[MAX_OSPATH];
	int		len;

	PCRE2_SIZE	error_offset;
	pcre2_code	*preg;
	int error;
	pcre2_match_data *match_data = NULL;

	if (!name)
		return NULL;

	if (!*name)
		return NULL;

	strlcpy(s, name, MAX_OSPATH);
	len = strlen(s);

	if (!(preg = pcre2_compile((PCRE2_SPTR)sv_demoRegexp.string, PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &error, &error_offset, NULL)))
	{
		PCRE2_UCHAR error_str[256];
		pcre2_get_error_message(error, error_str, sizeof(error_str));
		Con_Printf("SV_MVDName2Txt: pcre2_compile(%s) error: %s at offset %d\n",
					sv_demoRegexp.string, error_str, error_offset);
		pcre2_code_free(preg);
		return NULL;
	}
	match_data = pcre2_match_data_create_from_pattern(preg, NULL);
	error = pcre2_match(preg, (PCRE2_SPTR)s, len, 0, 0, match_data, NULL);

	if (error < 0)
	{
		pcre2_match_data_free(match_data);
		pcre2_code_free(preg);

		switch (error)
		{
		case PCRE2_ERROR_NOMATCH:
			return NULL;
		default:
			Con_Printf("SV_MVDName2Txt: pcre2_match(%s, %s) error code: %d\n",
						sv_demoRegexp.string, s, error);
			return NULL;
		}
	}
	else
	{
		PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);

		if (ovector[0] + 5 > MAX_OSPATH)
			len = MAX_OSPATH - 5;
		else
			len = ovector[0];
	}
	s[len++] = '.';
	s[len++] = 't';
	s[len++] = 'x';
	s[len++] = 't';
	s[len]   = '\0';

	pcre2_match_data_free(match_data);
	pcre2_code_free(preg);

	//Con_Printf("%d) %s, %s\n", r, name, s);
	return va("%s", s);
}

static char *SV_MVDTxTNum (int num)
{
	return SV_MVDName2Txt (SV_MVDNum(num));
}


void SV_MVDRemove_f (void)
{
	char name[MAX_DEMO_NAME], *ptr;
	char path[MAX_OSPATH];
	int i;

	if (Cmd_Argc() != 2)
	{
		Con_Printf("rmdemo <demoname> - removes the demo\nrmdemo *<token>   - removes demo with <token> in the name\nrmdemo *          - removes all demos\n");
		return;
	}

	ptr = Cmd_Argv(1);
	if (*ptr == '*')
	{
		dir_t dir;
		file_t *list;

		// remove all demos with specified token
		ptr++;

		dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string), sv_demoRegexp.string, SORT_BY_DATE);
		list = dir.files;
		for (i = 0;list->name[0]; list++)
		{
			if (strstr(list->name, ptr))
			{
				if (sv.mvdrecording && DestByName(list->name)/*!strcmp(list->name, demo.name)*/)
					SV_MVDStop_f(); // FIXME: probably we must stop not all demos, but only partial dest

				// stop recording first;
				snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, list->name);
				if (!Sys_remove(path))
				{
					Con_Printf("removing %s...\n", list->name);
					i++;
				}

				Sys_remove(SV_MVDName2Txt(path));
			}
		}

		if (i)
		{
			Con_Printf("%d demos removed\n", i);
		}
		else
		{
			Con_Printf("no match found\n");
		}

		// force cache rebuild.
		FS_FlushFSHash();

		return;
	}

	strlcpy(name, Cmd_Argv(1), MAX_DEMO_NAME);
	COM_DefaultExtension(name, ".mvd", sizeof(name));

	snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, name);

	if (sv.mvdrecording && DestByName(name) /*!strcmp(name, demo.name)*/)
		SV_MVDStop_f(); // FIXME: probably we must stop not all demos, but only partial dest

	if (!Sys_remove(path))
	{
		Con_Printf("demo %s successfully removed\n", name);

		if (*sv_ondemoremove.string)
		{
			extern redirect_t sv_redirected;
			redirect_t old = sv_redirected;

			sv_redirected = RD_NONE; // this script is called always from the console
			Cmd_TokenizeString(va("script %s \"%s\" \"%s\"", sv_ondemoremove.string, sv_demoDir.string, name));
			SV_Script_f();

			sv_redirected = old;
		}
	}
	else
		Con_Printf("unable to remove demo %s\n", name);

	Sys_remove(SV_MVDName2Txt(path));

	// force cache rebuild.
	FS_FlushFSHash();
}

void SV_MVDRemoveNum_f (void)
{
	int		num;
	char	*val, *name;
	char path[MAX_OSPATH];

	if (Cmd_Argc() != 2)
	{
		Con_Printf("rmdemonum <#>\n");
		return;
	}

	val = Cmd_Argv(1);
	if ((num = Q_atoi(val)) == 0 && val[0] != '0')
	{
		Con_Printf("rmdemonum <#>\n");
		return;
	}

	name = SV_MVDNum(num);

	if (name != NULL)
	{
		if (sv.mvdrecording && DestByName(name)/*!strcmp(name, demo.name)*/)
			SV_MVDStop_f(); // FIXME: probably we must stop not all demos, but only partial dest

		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, name);
		if (!Sys_remove(path))
		{
			Con_Printf("demo %s successfully removed\n", name);
			if (*sv_ondemoremove.string)
			{
				extern redirect_t sv_redirected;
				redirect_t old = sv_redirected;

				sv_redirected = RD_NONE; // this script is called always from the console
				Cmd_TokenizeString(va("script %s \"%s\" \"%s\"", sv_ondemoremove.string, sv_demoDir.string, name));
				SV_Script_f();

				sv_redirected = old;
			}
		}
		else
			Con_Printf("unable to remove demo %s\n", name);

		Sys_remove(SV_MVDName2Txt(path));

		// force cache rebuild.
		FS_FlushFSHash();
	}
	else
		Con_Printf("invalid demo num\n");
}

void SV_MVDInfoAdd_f (void)
{
	char *name, *args, path[MAX_OSPATH];
	FILE *f;

	if (Cmd_Argc() < 3)
	{
		Con_Printf("usage:demoInfoAdd <demonum> <info string>\n<demonum> = * for currently recorded demo\n");
		return;
	}

	if (!strcmp(Cmd_Argv(1), "*") || !strcmp(Cmd_Argv(1), "**")) {
		const char* demoname = SV_MVDDemoName();

		if (!sv.mvdrecording || !demoname) {
			Con_Printf("Not recording demo!\n");
			return;
		}

		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, SV_MVDName2Txt(demoname));
	}
	else {
		name = SV_MVDTxTNum(Q_atoi(Cmd_Argv(1)));

		if (!name) {
			Con_Printf("invalid demo num\n");
			return;
		}

		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, name);
	}

	if ((f = fopen(path, !strcmp(Cmd_Argv(1), "**") ? "a+b" : "a+t")) == NULL)
	{
		Con_Printf("failed to open the file\n");
		return;
	}

	if (!strcmp(Cmd_Argv(1), "**"))
	{
		// put content of one file to another
		FILE *src;

		snprintf(path, MAX_OSPATH, "%s/%s", fs_gamedir, Cmd_Argv(2));

		if ((src = fopen(path, "rb")) == NULL) // open src
		{
			Con_Printf("failed to open input file\n");
		}
		else
		{
			byte buf[1024 * 200] = { 0 }; // 200 kb
			size_t sz = fread((void*)buf, 1, sizeof(buf), src); // read from src

			if (sz <= 0) {
				Con_Printf("failed to read or empty input file\n");
			}
			else {
				// write to f
				if (sz != fwrite((void*)buf, 1, sz, f)) {
					Con_Printf("failed write to file\n");
				}
			}

			fclose(src); // close src
		}
	}
	else
	{
		// skip demonum
		args = Cmd_Args();

		while (*args > 32) args++;
		while (*args && *args <= 32) args++;

		fwrite(args, strlen(args), 1, f);
		fwrite("\n", 1, 1, f);
	}

	fflush(f);
	fclose(f);

	// force cache rebuild.
	FS_FlushFSHash();
}

// Put content of one file into .mvd
void SV_MVDEmbedInfo_f(void)
{
	// put content of one file to another
	FILE* src;
	byte* buf;
	size_t sz;
	char name[MAX_OSPATH];
	char path[MAX_OSPATH];

	if (Cmd_Argc() == 1) {
		Con_Printf("Embeds contents of a file into mvd/qtv stream\n");
		Con_Printf("Usage: %s <filename>\n", Cmd_Argv(0));
		return;
	}

	// No config files, no sub-directories
	strlcpy(name, Cmd_Argv(1), sizeof(name));
	snprintf(path, MAX_OSPATH, "%s/%s", fs_gamedir, Cmd_Argv(1));
	if (FS_UnsafeFilename(path) || !strcasecmp(COM_FileExtension(name), "cfg")) {
		Con_Printf("Unsafe filename detected - cancelled\n");
		return;
	}

	if ((src = fopen(path, "rb")) == NULL) {
		Con_Printf("failed to open input file\n");
		return;
	}

	buf = Q_malloc(MAX_DEMOINFO_SIZE);
	sz = fread((void*)buf, 1, MAX_DEMOINFO_SIZE, src);
	fclose(src);
	if (sz <= 0) {
		Con_Printf("failed to read or empty input file\n");
		Q_free(buf);
		return;
	}

	Con_Printf("Embedding (%s):\n", path);

	// embed in .mvd/qtv (sanity check limits)
	if (sz < 2 * 1024 * 1024) {
		mvdhidden_block_header_t header;
		byte* data = buf;
		short block_number = 1;

		while (sz > 0) {
			int prefix_length = sizeof_mvdhidden_block_header_t_range0 + sizeof(block_number);
			int length = (int)min(sz + prefix_length, MAX_MVD_SIZE);

			if (MVDWrite_HiddenBlockBegin(length)) {
				length -= prefix_length;

				sz -= length;
				if (sz == 0) {
					block_number = 0;
				}

				header.length = LittleLong(length + sizeof(short));
				header.type_id = LittleShort(mvdhidden_demoinfo);
				MVD_SZ_Write(&header.length, sizeof(header.length));
				MVD_SZ_Write(&header.type_id, sizeof(header.type_id));
				MVD_SZ_Write(&block_number, sizeof(block_number));
				MVD_SZ_Write(data, length);

				data += length;
				++block_number;
			}
			else {
				Con_Printf("failed write to mvd/qtv\n");
				Q_free(buf);
				break;
			}
		}
	}

	Q_free(buf);
}

void SV_MVDInfoRemove_f (void)
{
	char *name, path[MAX_OSPATH];

	if (Cmd_Argc() < 2)
	{
		Con_Printf("usage:demoInfoRemove <demonum>\n<demonum> = * for currently recorded demo\n");
		return;
	}

	if (!strcmp(Cmd_Argv(1), "*"))
	{
		if (!sv.mvdrecording || !demo.dest)
		{
			Con_Printf("Not recording demo!\n");
			return;
		}

//		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, demo.path, SV_MVDName2Txt(demo.name));
// FIXME: dunno is this right, just using first dest, also may be we must use demo.dest->path instead of sv_demoDir
		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, SV_MVDName2Txt(demo.dest->name));
	}
	else
	{
		name = SV_MVDTxTNum(Q_atoi(Cmd_Argv(1)));

		if (!name)
		{
			Con_Printf("invalid demo num\n");
			return;
		}

		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, name);
	}

	if (Sys_remove(path))
		Con_Printf("failed to remove the file %s\n", path);
	else
		Con_Printf("file %s removed\n", path);

	// force cache rebuild.
	FS_FlushFSHash();
}

void SV_MVDInfo_f (void)
{
	unsigned char buf[512];
	FILE *f = NULL;
	char *name, path[MAX_OSPATH];

	if (Cmd_Argc() < 2)
	{
		Con_Printf("usage: demoinfo <demonum>\n<demonum> = * for currently recorded demo\n");
		return;
	}

	if (!strcmp(Cmd_Argv(1), "*"))
	{
		if (!sv.mvdrecording || !demo.dest)
		{
			Con_Printf("Not recording demo!\n");
			return;
		}

//		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, demo.path, SV_MVDName2Txt(demo.name));
// FIXME: dunno is this right, just using first dest, also may be we must use demo.dest->path instead of sv_demoDir
		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, SV_MVDName2Txt(demo.dest->name));
	}
	else
	{
		name = SV_MVDTxTNum(Q_atoi(Cmd_Argv(1)));

		if (!name)
		{
			Con_Printf("invalid demo num\n");
			return;
		}

		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string, name);
	}

	if ((f = fopen(path, "rt")) == NULL)
	{
		Con_Printf("(empty)\n");
		return;
	}

	while (!feof(f))
	{
		buf[fread (buf, 1, sizeof(buf) - 1, f)] = 0;
		Con_Printf("%s", Q_yelltext(buf));
	}

	fclose(f);
}

#define MAXDEMOS			10
#define MAXDEMOS_RD_PACKET	100
void SV_LastScores_f (void)
{
	int		demos = MAXDEMOS, i;
	char	buf[512];
	FILE	*f = NULL;
	char	path[MAX_OSPATH];
	dir_t	dir;
	extern redirect_t sv_redirected;

	if (Cmd_Argc() > 2)
	{
		Con_Printf("usage: lastscores [<numlastdemos>]\n<numlastdemos> = '0' for all demos\n<numlastdemos> = '' for last %i demos\n", MAXDEMOS);
		return;
	}

	if (Cmd_Argc() == 2)
		if ((demos = Q_atoi(Cmd_Argv(1))) <= 0)
			demos = MAXDEMOS;

	dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string),
	                  sv_demoRegexp.string, SORT_BY_DATE);
	if (!dir.numfiles)
	{
		Con_Printf("No demos.\n");
		return;
	}

	if (demos > dir.numfiles)
		demos = dir.numfiles;

	if (demos > MAXDEMOS && GameStarted())
		Con_Printf("<numlastdemos> was decreased to %i: match is in progress.\n",
					demos = MAXDEMOS);

	if (demos > MAXDEMOS_RD_PACKET && sv_redirected == RD_PACKET)
		Con_Printf("<numlastdemos> was decreased to %i: command from connectionless packet.\n",
					demos = MAXDEMOS_RD_PACKET);

	Con_Printf("List of %d last demos:\n", demos);

	for (i = dir.numfiles - demos; i < dir.numfiles; )
	{
		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string,
					SV_MVDName2Txt(dir.files[i].name));

		Con_Printf("%i. ", ++i);
		if ((f = fopen(path, "rt")) == NULL)
			Con_Printf("(empty)\n");
		else
		{
			if (!feof(f))
			{
				char *nl;

				buf[fread (buf, 1, sizeof(buf) - 1, f)] = 0;
				if ((nl = strchr(buf, '\n')))
					nl[0] = 0;
				Con_Printf("%s\n", Q_yelltext((unsigned char*)buf));
			}
			else
				Con_Printf("(empty)\n");
			fclose(f);
		}
	}
}

#define STATS_LIMIT_DEFAULT 10
#define STATS_LIMIT_MAX     50
void SV_LastStats_f (void)
{
	int limit = STATS_LIMIT_DEFAULT;
	int i;
	char buf[512];
	FILE *f = NULL;
	char path[MAX_OSPATH];
	dir_t dir;
	extern redirect_t sv_redirected;

	if (sv_redirected != RD_PACKET)
	{
		return;
	}

	if (Cmd_Argc() > 2)
	{
		Con_Printf("usage: laststats [<limit>]\n<limit> = '0' for last %i stats\n<limit> = 'n' for last n stats (max %i)\n<limit> = '' (empty) for last %i stats\n", STATS_LIMIT_MAX, STATS_LIMIT_MAX, STATS_LIMIT_DEFAULT);
		return;
	}
	else if (Cmd_Argc() == 2)
	{
		limit = Q_atoi(Cmd_Argv(1));

		if (limit <= 0 || limit > STATS_LIMIT_MAX)
		{
			limit = STATS_LIMIT_MAX;
		}
	}

	dir = Sys_listdir(va("%s/%s", fs_gamedir, sv_demoDir.string), sv_demoRegexp.string,
			SORT_BY_DATE);

	if (!dir.numfiles)
	{
		Con_Printf("laststats 0:\n");
		Con_Printf("[]\n");
		return;
	}

	if (limit > dir.numfiles)
	{
		limit = dir.numfiles;
	}

	Con_Printf("laststats %i\n", limit);
	Con_Printf("[\n");

	for (i = dir.numfiles - limit; i < dir.numfiles; i++)
	{
		snprintf(path, MAX_OSPATH, "%s/%s/%s", fs_gamedir, sv_demoDir.string,
					SV_MVDName2Txt(dir.files[i].name));

		if ((f = fopen(path, "rt")) != NULL)
		{
			if (FS_FileLength(f) == 0) {
			    continue;
			}

			if (i != dir.numfiles - limit)
			{
				Con_Printf(",\n");
			}

			while (fread(buf, 1, sizeof(buf)-1, f))
			{
				Con_Printf("%s", (unsigned char*)buf);
				memset(buf, 0, sizeof(buf));
			}
			fclose(f);
		}
	}

	Con_Printf("\n]\n");
}

// easyrecord helpers

int Dem_CountPlayers (void)
{
	int	i, count;

	count = 0;
	for (i = 0; i < MAX_CLIENTS ; i++)
	{
		if (svs.clients[i].name[0] && !svs.clients[i].spectator)
			count++;
	}

	return count;
}

char *Dem_Team (int num)
{
	int i;
	static char *lastteam[2];
	qbool first = true;
	client_t *client;
	static int index1 = 0;

	index1 = 1 - index1;

	for (i = 0, client = svs.clients; num && i < MAX_CLIENTS; i++, client++)
	{
		if (!client->name[0] || client->spectator)
			continue;

		if (first || strcmp(lastteam[index1], client->team))
		{
			first = false;
			num--;
			lastteam[index1] = client->team;
		}
	}

	if (num)
		return "";

	return lastteam[index1];
}

char *Dem_PlayerName (int num)
{
	int i;
	client_t *client;

	for (i = 0, client = svs.clients; i < MAX_CLIENTS; i++, client++)
	{
		if (!client->name[0] || client->spectator)
			continue;

		if (!--num)
			return client->name;
	}

	return "";
}

char *Dem_PlayerNameTeam (char *t)
{
	int	i;
	client_t *client;
	static char	n[1024];
	int	sep;

	n[0] = 0;

	sep = 0;

	for (i = 0, client = svs.clients; i < MAX_CLIENTS; i++, client++)
	{
		if (!client->name[0] || client->spectator)
			continue;

		if (strcmp(t, client->team)==0)
		{
			if (sep >= 1)
				strlcat (n, "_", sizeof(n));
			//				snprintf (n, sizeof(n), "%s_", n);
			strlcat (n, client->name, sizeof(n));
			//			snprintf (n, sizeof(n),"%s%s", n, client->name);
			sep++;
		}
	}

	return n;
}

int Dem_CountTeamPlayers (char *t)
{
	int	i, count;

	count = 0;
	for (i = 0; i < MAX_CLIENTS ; i++)
	{
		if (svs.clients[i].name[0] && !svs.clients[i].spectator)
			if (strcmp(&svs.clients[i].team[0], t)==0)
				count++;
	}

	return count;
}

char *quote (char *str)
{
	char *out, *s;
	if (!str)
		return NULL;
	if (!*str)
		return NULL;

	s = out = (char *) Q_malloc (strlen(str) * 2 + 1);
	while (*str)
	{
		if (!isdigit(*str) && !isalpha(*str))
			*s++ = '\\';
		*s++ = *str++;
	}
	*s = '\0';
	return out;
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_demo_qtv.c
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    
*/

//	sv_demo_qtv.c - misc QTV's code

#ifndef CLIENTONLY
#include "qwsvdef.h"

static cvar_t qtv_streamport     = {"qtv_streamport",      "0"};
static cvar_t qtv_maxstreams     = {"qtv_maxstreams",      "1"};
static cvar_t qtv_password       = {"qtv_password",         ""};
static cvar_t qtv_pendingtimeout = {"qtv_pendingtimeout",  "5"}; // 5  seconds must be enough
static cvar_t qtv_sayenabled     = {"qtv_sayenabled",      "0"}; // allow mod to override GameStarted() logic
cvar_t qtv_streamtimeout         = {"qtv_streamtimeout",  "45"}; // 45 seconds

static unsigned short int	listenport		= 0;
static double				warned_time		= 0;

static mvddest_t *SV_InitStream (int socket1, netadr_t na, char *userinfo)
{
	static int lastdest = 0;
	int count;
	mvddest_t *dst;
	char name[sizeof(dst->qtvname)];
	char address[sizeof(dst->qtvaddress)];
	int streamid = 0;

	// extract name
	strlcpy(name, Info_ValueForKey(userinfo, "name"), sizeof(name));
	strlcpy(address, Info_ValueForKey(userinfo, "address"), sizeof(address));
	streamid = atoi(Info_ValueForKey(userinfo, "streamid"));

	count = 0;
	for (dst = demo.dest; dst; dst = dst->nextdest)
	{
		if (dst->desttype == DEST_STREAM)
		{
			if (name[0] && !strcasecmp(name, dst->qtvname))
				return NULL; // duplicate name, well empty names may still duplicates...

			count++;
		}
	}

	if ((int)qtv_maxstreams.value > 0 && count >= (int)qtv_maxstreams.value)
		return NULL; //sorry

	dst = (mvddest_t *) Q_malloc (sizeof(mvddest_t));

	dst->desttype = DEST_STREAM;
	dst->socket = socket1;
	dst->maxcachesize = 65536;	//is this too small?
	dst->cache = (char *) Q_malloc(dst->maxcachesize);
	dst->io_time = Sys_DoubleTime();
	dst->id = ++lastdest;
	dst->na = na;

	strlcpy(dst->qtvname, name, sizeof(dst->qtvname));
	strlcpy(dst->qtvaddress, address, sizeof(dst->qtvaddress));
	dst->qtvstreamid = streamid;

	if (dst->qtvname[0])
		Con_Printf ("Connected to QTV(%s)\n", dst->qtvname);
	else
		Con_Printf ("Connected to QTV\n");

	return dst;
}

static void SV_MVD_InitPendingStream (int socket1, netadr_t na, qbool must_be_qizmo_tcp_connect)
{
	mvdpendingdest_t *dst;
	unsigned int i;
	dst = (mvdpendingdest_t*) Q_malloc(sizeof(mvdpendingdest_t));
	dst->socket = socket1;
	dst->io_time = Sys_DoubleTime();
	dst->na = na;
	dst->must_be_qizmo_tcp_connect = must_be_qizmo_tcp_connect;

	strlcpy(dst->challenge, NET_AdrToString(dst->na), sizeof(dst->challenge));
	for (i = strlen(dst->challenge); i < sizeof(dst->challenge)-1; i++)
		dst->challenge[i] = rand()%(127-33) + 33;	//generate a random challenge

	dst->nextdest = demo.pendingdest;
	demo.pendingdest = dst;
}

void SV_MVDCloseStreams(void)
{
	mvddest_t *d;
	mvdpendingdest_t *p;

	for (d = demo.dest; d; d = d->nextdest)
		if (!d->error && d->desttype == DEST_STREAM)
			d->error = true; // mark demo stream dest to close later

	for (p = demo.pendingdest; p; p = p->nextdest)
		if (!p->error)
			p->error = true; // mark pending dest to close later
}

static void SV_CheckQTVPort(void)
{
	qbool changed;
	// so user can't specify something stupid
	unsigned short int streamport = bound(0, (unsigned short int)qtv_streamport.value, 65534);

	// if we have non zero stream port, but fail to open listen socket, repeat open listen socket after some time
	changed = ( streamport != listenport // port changed.
	    || (streamport  && NET_GetSocket(NS_SERVER, true) == INVALID_SOCKET && warned_time + 10 < Sys_DoubleTime()) // stream port non zero but socket still not open, lets open socket then.
	    || (!streamport && NET_GetSocket(NS_SERVER, true) != INVALID_SOCKET) // stream port is zero but socket still open, lets close socket then.
	);

	// port not changed
	if (!changed)
		return;

	SV_MVDCloseStreams(); // also close ative connects if any, this will help actually close listen socket, so later we can bind to port again

	warned_time = Sys_DoubleTime(); // so we repeat warning time to time

	// port was changed, lets remember
	listenport = streamport;

	// open/close/reopen TCP port.
	NET_InitServer_TCP(listenport);
}

void SV_MVDStream_Poll (void)
{
	int client;
	qbool must_be_qizmo_tcp_connect = false;
	netadr_t na;
	struct sockaddr_storage addr;
	socklen_t addrlen;
	int count;
	mvddest_t *dest;
	unsigned long _true = true;

	if (sv.state != ss_active)
		return;

	SV_CheckQTVPort(); // open/close/switch qtv port

	if (NET_GetSocket(NS_SERVER, true) == INVALID_SOCKET) // we can't accept connection from QTV
	{
		SV_MVDCloseStreams(); // also close ative connects if any, this will help actually close listen socket, so later we can bind to port again
		return;
	}

	addrlen = sizeof(addr);
	client = accept (NET_GetSocket(NS_SERVER, true), (struct sockaddr *)&addr, &addrlen);

	if (client == INVALID_SOCKET)
		return;

	if (ioctlsocket (client, FIONBIO, &_true) == SOCKET_ERROR) {
		Con_Printf ("SV_MVDStream_Poll: ioctl FIONBIO: (%i): %s\n", qerrno, strerror (qerrno));
		closesocket(client);
		return;
	}

	if (!TCP_Set_KEEPALIVE(client))
	{
		Con_Printf ("SV_MVDStream_Poll: TCP_Set_KEEPALIVE: failed\n");
		closesocket(client);
		return;
	}

	if ((int)qtv_maxstreams.value > 0)
	{
		count = 0;
		for (dest = demo.dest; dest; dest = dest->nextdest)
		{
			if (dest->desttype == DEST_STREAM)
			{
				count++;
			}
		}

		if (count >= (int)qtv_maxstreams.value)
		{
			// we use + 3 so there qizmo tcp connection have chance...
			if (count >= (int)qtv_maxstreams.value + 3)
			{
				//sorry, there really way too much connections
				char *goawaymessage = "QTVSV 1\nERROR: This server enforces a limit on the number of proxies connected at any one time. Please try again later\n\n";

				send(client, goawaymessage, strlen(goawaymessage), 0);
				closesocket(client);
				return;
			}
			else
			{
				// ok, give qizmo tcp connect a chance, but only and only for tcp connect
				must_be_qizmo_tcp_connect = true;
			}
		}
	}

	SockadrToNetadr(&addr, &na);
	Con_Printf("MVD streaming client connected from %s\n", NET_AdrToString(na));

	SV_MVD_InitPendingStream(client, na, must_be_qizmo_tcp_connect);
}

void SV_MVD_RunPendingConnections (void)
{
	unsigned short ushort_result;
	char *e;
	int len;
	mvdpendingdest_t *p;
	mvdpendingdest_t *np;
	char userinfo[1024] = {0};

	if (!demo.pendingdest)
		return;

	for (p = demo.pendingdest; p; p = p->nextdest)
		if (p->io_time + qtv_pendingtimeout.value <= Sys_DoubleTime())
		{
			Con_Printf("Pending dest timeout\n");
			p->error = true;
		}

	while (demo.pendingdest && demo.pendingdest->error)
	{
		np = demo.pendingdest->nextdest;

		if (demo.pendingdest->socket != -1)
			closesocket(demo.pendingdest->socket);
		Q_free(demo.pendingdest);
		demo.pendingdest = np;
	}

	for (p = demo.pendingdest; p && p->nextdest; p = p->nextdest)
	{
		if (p->nextdest->error)
		{
			np = p->nextdest->nextdest;
			if (p->nextdest->socket != -1)
				closesocket(p->nextdest->socket);
			Q_free(p->nextdest);
			p->nextdest = np;
		}
	}

	for (p = demo.pendingdest; p; p = p->nextdest)
	{
		if (p->outsize && !p->error)
		{
			len = send(p->socket, p->outbuffer, p->outsize, 0);

			if (len == 0) //client died
			{
//				p->error = true;
				// man says: The calls return the number of characters sent, or -1 if an error occurred.   
				// so 0 is legal or what?
			}
			else if (len > 0)	//we put some data through
			{
				p->io_time = Sys_DoubleTime(); // update IO activity

				//move up the buffer
				p->outsize -= len;
				memmove(p->outbuffer, p->outbuffer+len, p->outsize );

			}
			else
			{ //error of some kind. would block or something
				if (qerrno != EWOULDBLOCK && qerrno != EAGAIN)
					p->error = true;
			}
		}

		if (!p->error)
		{
			len = recv(p->socket, p->inbuffer + p->insize, sizeof(p->inbuffer) - p->insize - 1, 0);

			if (len > 0)
			{ //fixme: cope with extra \rs
				char *end;

				p->io_time = Sys_DoubleTime(); // update IO activity

				p->insize += len;
				p->inbuffer[p->insize] = 0;

// TCPCONNECT -->
// kinda hack to allow both qtv and qizmo tcp connection work on the same server port

				// check for qizmo tcp connection
				if (p->insize >=6)
				{
					if (strncmp(p->inbuffer, "qizmo\n", 6))
					{
						// no. seems it like QTV client... but if we expect qizmo so we better drop it ASAP
						if (p->must_be_qizmo_tcp_connect)
						{
							p->error = true;
							continue;
						}
					}
					else
					{
						// new qizmo tcpconnection

						extern svtcpstream_t *sv_tcp_connection_new(int sock, netadr_t from, char *buf, int buf_len, qbool link);
						extern int sv_tcp_connection_count(void);

						svtcpstream_t *st = sv_tcp_connection_new(p->socket, p->na, p->inbuffer, p->insize, true);
						int _true = true;

						// set some timeout
						st->timeouttime = Sys_DoubleTime() + 10;
						// send protocol confirmation
						if (send(st->socketnum, "qizmo\n", 6, 0) != 6)
						{
							st->drop = true; // failed miserable to send some chunk of data				
						}

						if (sv_tcp_connection_count() >= MAX_CLIENTS)
						{
							st->drop = true;
						}

						if (setsockopt(st->socketnum, IPPROTO_TCP, TCP_NODELAY, (char *)&_true, sizeof(_true)) == -1)
						{
							Con_DPrintf ("SV_MVD_RunPendingConnections: setsockopt: (%i): %s\n", qerrno, strerror(qerrno));
						}

						p->error = true;
						p->socket = -1;	//so it's not cleared wrongly.
						continue;
					}
				}

				if (p->must_be_qizmo_tcp_connect)
					continue; // HACK, this stream should not be allowed but just checked ONLY AND ONLY for qizmo tcp connection
// <--TCPCONNECT

				for (end = p->inbuffer; ; end++)
				{
					if (*end == '\0')
					{
						end = NULL;
						break;	//not enough data
					}

					if (end[0] == '\n')
					{
						if (end[1] == '\n')
						{
							end[1] = '\0';
							break;
						}
					}
				}
				if (end)
				{ //we found the end of the header
					char *start, *lineend;
					int versiontouse = 0;
					int raw = 0;
					char password[256] = "";
					typedef enum {
						QTVAM_NONE,
						QTVAM_PLAIN,
						QTVAM_CCITT,
						QTVAM_MD4,
						QTVAM_SHA3_512,
					} authmethod_t;
					authmethod_t authmethod = QTVAM_NONE;
					start = p->inbuffer;

					lineend = strchr(start, '\n');
					if (!lineend)
					{
//						char *e;
//						e = "This is a QTV server.";
//						send(p->socket, e, strlen(e), 0);

						p->error = true;
						continue;
					}
					*lineend = '\0';
					COM_ParseToken(start, NULL);
					start = lineend+1;
					if (strcmp(com_token, "QTV"))
					{ //it's an error if it's not qtv.
						p->error = true;
						lineend = strchr(start, '\n');
						continue;
					}

					for(;;)
					{
						lineend = strchr(start, '\n');
						if (!lineend)
							break;
						*lineend = '\0';
						start = COM_ParseToken(start, NULL);
						if (*start == ':')
						{
//VERSION: a list of the different qtv protocols supported. Multiple versions can be specified. The first is assumed to be the prefered version.
//RAW: if non-zero, send only a raw mvd with no additional markup anywhere (for telnet use). Doesn't work with challenge-based auth, so will only be accepted when proxy passwords are not required.
//AUTH: specifies an auth method, the exact specs varies based on the method
//		PLAIN: the password is sent as a PASSWORD line
//		MD4: the server responds with an "AUTH: MD4\n" line as well as a "CHALLENGE: somerandomchallengestring\n" line, the client sends a new 'initial' request with CHALLENGE: MD4\nRESPONSE: hexbasedmd4checksumhere\n"
//		CCITT: same as md4, but using the CRC stuff common to all quake engines.
//		if the supported/allowed auth methods don't match, the connection is silently dropped.
//SOURCE: which stream to play from, DEFAULT is special. Without qualifiers, it's assumed to be a tcp address.
//COMPRESSION: Suggests a compression method (multiple are allowed). You'll get a COMPRESSION response, and compression will begin with the binary data.

							start = start+1;
							Con_Printf("qtv, got (%s) (%s)\n", com_token, start);
							if (!strcmp(com_token, "VERSION"))
							{
								start = COM_ParseToken(start, NULL);
								if (atoi(com_token) == 1)
									versiontouse = 1;
							}
							else if (!strcmp(com_token, "RAW"))
							{
								start = COM_ParseToken(start, NULL);
								raw = atoi(com_token);
							}
							else if (!strcmp(com_token, "PASSWORD"))
							{
								start = COM_ParseToken(start, NULL);
								strlcpy(password, com_token, sizeof(password));
							}
							else if (!strcmp(com_token, "AUTH"))
							{
								authmethod_t thisauth;
								start = COM_ParseToken(start, NULL);
								if (!strcmp(com_token, "NONE"))
									thisauth = QTVAM_PLAIN;
								else if (!strcmp(com_token, "PLAIN"))
									thisauth = QTVAM_PLAIN;
								else if (!strcmp(com_token, "CCITT"))
									thisauth = QTVAM_CCITT;
								else if (!strcmp(com_token, "MD4"))
									thisauth = QTVAM_MD4;
								else if (!strcmp(com_token, "SHA3_512"))
									thisauth = QTVAM_SHA3_512;
								else
								{
									thisauth = QTVAM_NONE;
									Con_DPrintf("qtv: received unrecognised auth method (%s)\n", com_token);
								}

								if (authmethod < thisauth)
									authmethod = thisauth;
							}
							else if (!strcmp(com_token, "SOURCE"))
							{
								//servers don't support source, and ignore it.
								//source is only useful for qtv proxy servers.
							}
							else if (!strcmp(com_token, "COMPRESSION"))
							{
								//compression not supported yet
							}
							else if (!strcmp(com_token, "USERINFO"))
							{
								start = COM_ParseToken(start, NULL);
								strlcpy(userinfo, com_token, sizeof(userinfo));
							}
							else
							{
								//not recognised.
							}
						}
						start = lineend+1;
					}

					len = (end - p->inbuffer)+2;
					p->insize -= len;
					memmove(p->inbuffer, p->inbuffer + len, p->insize);
					p->inbuffer[p->insize] = 0;

					e = NULL;
					if (p->hasauthed)
					{
					}
					else if (!*qtv_password.string)
						p->hasauthed = true; //no password, no need to auth.
					else if (*password)
					{
						switch (authmethod)
						{
						case QTVAM_NONE:
							e = ("QTVSV 1\n"
								 "PERROR: You need to provide a common auth method.\n\n");
							break;

						case QTVAM_PLAIN:
							p->hasauthed = !strcmp(qtv_password.string, password);
							break;

						case QTVAM_CCITT:
							CRC_Init(&ushort_result);
							CRC_AddBlock(&ushort_result, (byte *) p->challenge, strlen(p->challenge));
							CRC_AddBlock(&ushort_result, (byte *) qtv_password.string, strlen(qtv_password.string));
							p->hasauthed = (ushort_result == Q_atoi(password));
							break;

						case QTVAM_MD4:
							{
								char hash[512];
								int md4sum[4];
								
								snprintf (hash, sizeof(hash), "%s%s", p->challenge, qtv_password.string);
								Com_BlockFullChecksum (hash, strlen(hash), (unsigned char*)md4sum);
								snprintf (hash, sizeof(hash), "%X%X%X%X", md4sum[0], md4sum[1], md4sum[2], md4sum[3]);
								p->hasauthed = !strcmp(password, hash);
							}
							break;

						case QTVAM_SHA3_512:
							{
								sha3_context c;
								const uint8_t *byte_hash;
								char hash[SHA3_512_DIGEST_HEX_STR_SIZE] = {0};

								sha3_Init512(&c);
								sha3_Update(&c, p->challenge, strlen(p->challenge));
								sha3_Update(&c, qtv_password.string, strlen(qtv_password.string));
								byte_hash = sha3_Finalize(&c);
								sha3_512_ByteToHex(hash, byte_hash);
								p->hasauthed = !strcmp(password, hash);
							}
							break;

						default:
							e = ("QTVSV 1\n"
								 "PERROR: FTEQWSV bug detected.\n\n");
							break;
						}
						if (!p->hasauthed && !e)
						{
							if (raw)
								e = "";
							else
								e = ("QTVSV 1\n"
									 "PERROR: Bad password.\n\n");
						}
					}
					else
					{
						//no password, and not automagically authed
						switch (authmethod)
						{
						case QTVAM_NONE:
							if (raw)
								e = "";
							else
								e = ("QTVSV 1\n"
									 "PERROR: You need to provide a common auth method.\n\n");
							break;

						case QTVAM_PLAIN:
							p->hasauthed = !strcmp(qtv_password.string, password);
							break;

						case QTVAM_CCITT:
							e =	("QTVSV 1\n"
								"AUTH: CCITT\n"
								"CHALLENGE: ");

							send(p->socket, e, strlen(e), 0);
							send(p->socket, p->challenge, strlen(p->challenge), 0);
							e = "\n\n";
							send(p->socket, e, strlen(e), 0);
							continue;

						case QTVAM_MD4:
							e = ("QTVSV 1\n"
								"AUTH: MD4\n"
								"CHALLENGE: ");

							send(p->socket, e, strlen(e), 0);
							send(p->socket, p->challenge, strlen(p->challenge), 0);
							e = "\n\n";
							send(p->socket, e, strlen(e), 0);
							continue;

						case QTVAM_SHA3_512:
							e = ("QTVSV 1\n"
								"AUTH: SHA3_512\n"
								"CHALLENGE: ");

							send(p->socket, e, strlen(e), 0);
							send(p->socket, p->challenge, strlen(p->challenge), 0);
							e = "\n\n";
							send(p->socket, e, strlen(e), 0);
							continue;

						default:
							e = ("QTVSV 1\n"
								 "PERROR: FTEQWSV bug detected.\n\n");
							break;
						}
					}

					if (e)
					{
					}
					else if (!versiontouse)
					{
						e = ("QTVSV 1\n"
							 "PERROR: Incompatible version (valid version is v1)\n\n");
					}
					else if (raw)
					{
						if (p->hasauthed == false)
						{
							e =	"";
						}
						else
						{
							mvddest_t *tmpdest;

							if ((tmpdest = SV_InitStream(p->socket, p->na, userinfo)))
							{
								if (!SV_MVD_Record(tmpdest, false))
									DestClose(tmpdest, false); // can't start record for some reason, close dest then

								p->socket = -1;	//so it's not cleared wrongly.
							}
							else
							{
								// RAW mode, can't sent error, right?
//								e = ("QTVSV 1\n"
//									"ERROR: Can't init stream, probably server reach a limit on the number of proxies connected at any one time.\n\n");
							}
						}
						p->error = true;
					}
					else
					{
						if (p->hasauthed == true)
						{
							mvddest_t *tmpdest;

							if ((tmpdest = SV_InitStream(p->socket, p->na, userinfo)))
							{
								e = ("QTVSV 1\n"
								 	"BEGIN\n\n");
								send(p->socket, e, strlen(e), 0);
								e = NULL;

								if (!SV_MVD_Record(tmpdest, false))
									DestClose(tmpdest, false); // can't start record for some reason, close dest then

								p->socket = -1;	//so it's not cleared wrongly.
							}
							else
							{
								e = ("QTVSV 1\n"
									"ERROR: Can't init stream, probably server reach a limit on the number of proxies connected at any one time.\n\n");
							}
						}
						else
						{
							e = ("QTVSV 1\n"
								"PERROR: You need to provide a password.\n\n");
						}
						p->error = true;
					}

					if (e)
					{
						send(p->socket, e, strlen(e), 0);
						p->error = true;
					}
				}
			}
			else if (len == 0)
				p->error = true;
			else
			{	//error of some kind. would block or something
				int err;
				err = qerrno;
				if (err != EWOULDBLOCK && err != EAGAIN)
					p->error = true;
			}
		}
	}
}

//============================================================
//
// QTV user input
//
//============================================================

// { qtv commands

// say [say_game] text
// say_team [say_game] text
// say_game text

void QTVcmd_Say_f(mvddest_t *d)
{
	qbool gameStarted;
	client_t *client;
	int		j;
	char	*p;
	char	text[1024], text2[1024], *cmd;

	if (Cmd_Argc () < 2)
		return;

	if (qtv_sayenabled.value || !strcasecmp(Info_ValueForKey(svs.info, "status"), "Countdown"))
		gameStarted	= false; // if status is "Countdown" then game is not started yet
	else
		gameStarted = GameStarted();

	p = Cmd_Args();

	if (*p == '"' && (j = strlen(p)) > 2)
	{
		p[j-1] = 0;
		p++;
	}

	cmd = Cmd_Argv(0);

	// strip leading say_game but not in case of "cmd say_game say_game"
	if (strcmp(cmd, "say_game") && !strncasecmp(p, "say_game ", sizeof("say_game ") - 1))
	{
		p += sizeof("say_game ") - 1;
	}

	if (!strcmp(cmd, "say_game"))
		cmd = "say"; // this makes qtv_%s_game looks right

	if (!strcmp(cmd, "say_team"))
		gameStarted = true; // send to specs only

	if (gameStarted)
		cmd = "say_team"; // we can accept only this command, since we will send to specs only

	// for clients and demo
	snprintf(text, sizeof(text), "#0:qtv_%s_game:#%d:%s: %s\n", cmd, d->id, d->qtvname, p);
	// for server console and logs
	snprintf(text2, sizeof(text2), "qtv: #0:qtv_%s_game:#%d:%s: %s\n", cmd, d->id, d->qtvname, p);

	for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
	{
		if (client->state != cs_spawned)
			continue;

		if (gameStarted && !client->spectator)
			continue; // game started, don't send QTV chat to players, specs still get QTV chat

		SV_ClientPrintf2(client, PRINT_CHAT, "%s", text);
	}

	if (sv.mvdrecording) {
		sizebuf_t		msg;
		byte			msg_buf[1024];

		SZ_InitEx(&msg, msg_buf, sizeof(msg_buf), true);
		MSG_WriteByte (&msg, svc_print);
		MSG_WriteByte (&msg, PRINT_CHAT);
		MSG_WriteString (&msg, text);

		DemoWriteQTV(&msg);
	}

	Sys_Printf("%s", text2);
	SV_Write_Log(CONSOLE_LOG, 1, text2);
}

// }

// {

static qtvuser_t *QTVsv_UserById(mvddest_t *d, int id)
{
	qtvuser_t *current;

	for (current = d->qtvuserlist; current; current = current->next)
		if (current->id == id)
			return current;

	return NULL;
}

static void QTVsv_SetUser(qtvuser_t *to, qtvuser_t *from)
{
	*to = *from;
}

static int QTVsv_UsersCount(mvddest_t *d)
{
	qtvuser_t *current;
	int c = 0;

	for (current = d->qtvuserlist; current; current = current->next)
		c++;

	return c;
}

// allocate data and set fields, perform linkage to qtvuserlist
// Well, instead of QTVsv_NewUser(int id, char *name, ...) I pass params with single qtvuser_t *user struct, well its OK for current struct.
static qtvuser_t *QTVsv_NewUser(mvddest_t *d, qtvuser_t *user)
{
	// check, may be user alredy exist, so reuse it
	qtvuser_t *newuser = QTVsv_UserById(d, user->id);

	if (!newuser)
	{
		// user does't exist, alloc data
		if (QTVsv_UsersCount(d) > 2048)
		{
			Con_Printf("QTVsv_NewUser: too much users, haxors? Dropping dest\n");
			d->error = true; // drop dest later
			return NULL;
		}

		newuser = Q_malloc(sizeof(*newuser)); // alloc

		QTVsv_SetUser(newuser, user);

		// perform linkage
		newuser->next = d->qtvuserlist;
		d->qtvuserlist = newuser;
	}
	else
	{
		// we do not need linkage, just save current
		qtvuser_t *oldnext = newuser->next; // we need save this before assign all fields

		QTVsv_SetUser(newuser, user);

		newuser->next = oldnext;
	}

	return newuser;
}

// free data, perform unlink if requested
static void QTVsv_FreeUser(mvddest_t *d, qtvuser_t *user, qbool unlink)
{
	if (!user)
		return;

	if (unlink)
	{
		qtvuser_t *next, *prev, *current;

		prev = NULL;
		current = d->qtvuserlist;

		for ( ; current; )
		{
			next = current->next;

			if (user == current)
			{
				if (prev)
					prev->next = next;
				else
					d->qtvuserlist = next;

				break;
			}

			prev = current;
			current = next;
		}
	}

	Q_free(user);
}

// free whole qtvuserlist
void QTVsv_FreeUserList(mvddest_t *d)
{
	qtvuser_t *next, *current;

	current = d->qtvuserlist;

	for ( ; current; current = next)
	{
		next = current->next;
		QTVsv_FreeUser(d, current, false);
	}

	d->qtvuserlist = NULL;
}

#define QTV_EVENT_PREFIX "QTV: "

// user join qtv
void QTVsv_JoinEvent(mvddest_t *d, qtvuser_t *user)
{
	// make it optional message
//	if (!qtv_event_join.string[0])
//		return;

	// do not show "user joined" at moment of connection to QTV, it mostly QTV just spammed userlist to us.
//	if (cls.state <= ca_demostart)
//		return;

	if (QTVsv_UserById(d, user->id))
	{
		// we alredy have this user, do not double trigger
		return;
	}

	Con_Printf("%s%s: %s%s\n", QTV_EVENT_PREFIX, d->qtvname, user->name, /*qtv_event_join.string*/ " join");
}

// user leaved/left qtv
void QTVsv_LeaveEvent(mvddest_t *d, qtvuser_t *user)
{
	qtvuser_t *olduser;

	// make it optional message
//	if (!qtv_event_leave.string[0])
//		return;

	if (!(olduser = QTVsv_UserById(d, user->id)))
	{
		// we do not have this user
		return;
	}

	Con_Printf("%s%s: %s%s\n", QTV_EVENT_PREFIX, d->qtvname, olduser->name, /*qtv_event_leave.string*/ " left");
}

// user changed name on qtv
void QTVsv_ChangeEvent(mvddest_t *d, qtvuser_t *user)
{
	qtvuser_t *olduser;

	// well, too spammy, make it as option
//	if (!qtv_event_changename.string[0])
//		return;

	if (!(olduser = QTVsv_UserById(d, user->id)))
	{
		// we do not have this user yet
		Con_DPrintf("qtv: change event without olduser\n");
		return;
	}

	Con_Printf("%s%s: %s%s%s\n", QTV_EVENT_PREFIX, d->qtvname, olduser->name, /*qtv_event_changename.string*/ " changed name to ", user->name);
}

static void QTVcmd_QtvUserList_f(mvddest_t *d)
{
	qtvuser_t		tmpuser;
	qtvuserlist_t	action;
	int				cnt = 1;
	
	memset(&tmpuser, 0, sizeof(tmpuser));

	// action id [\"name\"]

//	Cmd_TokenizeString( s );

	action 		= atoi( Cmd_Argv( cnt++ ) );
	tmpuser.id	= atoi( Cmd_Argv( cnt++ ) );
	strlcpy(tmpuser.name, Cmd_Argv( cnt++ ), sizeof(tmpuser.name)); // name is optional in some cases

	switch ( action )
	{
		case QUL_ADD:
			QTVsv_JoinEvent(d, &tmpuser);
			QTVsv_NewUser(d, &tmpuser);

		break;
		
		case QUL_CHANGE:
			QTVsv_ChangeEvent(d, &tmpuser);
			QTVsv_NewUser(d, &tmpuser);

		break;

		case QUL_DEL:
			QTVsv_LeaveEvent(d, &tmpuser);
			QTVsv_FreeUser(d, QTVsv_UserById(d, tmpuser.id), true);

		break;

		default:
			Con_Printf("Parse_QtvUserList: unknown action %d\n", action);

		return;
	}
}

// this issued remotely by user
void Cmd_Qtvusers_f (void)
{
	mvddest_t *d;
	qbool found = false;

	for (d = demo.dest; d; d = d->nextdest)
	{
		qtvuser_t *current;
		int c;

		if (d->desttype != DEST_STREAM)
			continue;

		found = true;

		c = 0;
		Con_Printf ("Proxy name: %s, id: %d\n", d->qtvname, d->id);
		Con_Printf ("userid name\n");
		Con_Printf ("------ ----\n");

		for (current = d->qtvuserlist; current; current = current->next)
		{
			Con_Printf ("%6i %s\n", current->id, current->name);
			c++;
		}

		Con_Printf ("%i total users\n", c);
	}

	if (!found)
	{
		Con_Printf ("no QTVs connected\n");
		return;
	}
}


// }

char QTV_cmd[MAX_PROXY_INBUFFER]; // global so it does't allocated on stack, this save some CPU I think

typedef struct
{
	char	*name;
	void	(*func) (mvddest_t *d);
}
qtv_ucmd_t;

static qtv_ucmd_t ucmds[] =
{
	{"say", 			QTVcmd_Say_f},
	{"say_team",		QTVcmd_Say_f},
	{"say_game",		QTVcmd_Say_f},

	{"qul",				QTVcmd_QtvUserList_f},

	{NULL, NULL}
};

// { qtv utils

typedef struct {
	unsigned int readpos;
	unsigned int cursize;
	unsigned int maxsize;
	char *data;
	unsigned int startpos;
//	qbool overflowed;
//	qbool allowoverflow;
} netmsg_t;

static void InitNetMsg(netmsg_t *b, char *buffer, int bufferlength)
{
	memset(b, 0, sizeof(netmsg_t));

	b->data    = buffer;
	b->maxsize = bufferlength;
}

//probably not the place for these any more..
static unsigned char ReadByte(netmsg_t *b)
{
	if (b->readpos >= b->cursize)
	{
		b->readpos = b->cursize+1;
		return 0;
	}
	return b->data[b->readpos++];
}

static unsigned short ReadShort(netmsg_t *b)
{
	int b1, b2;
	b1 = ReadByte(b);
	b2 = ReadByte(b);

	return b1 | (b2<<8);
}

static void ReadString(netmsg_t *b, char *string, int maxlen)
{
	maxlen--;	//for null terminator
	while(maxlen)
	{
		*string = ReadByte(b);
		if (!*string)
			return;
		string++;
		maxlen--;
	}
	*string++ = '\0';	//add the null
}

// }

void QTV_ExecuteCmd(mvddest_t *d, char *cmd)
{
    char *arg0;
    qbool found = false;
	qtv_ucmd_t *u;

//	Sys_Printf("qtv cmd: %s\n", cmd);

	Cmd_TokenizeString (cmd);

	arg0 = Cmd_Argv(0);

//	Sys_RedirectStart(???);

	for (u = ucmds; u->name; u++)
	{
		if (!strcmp(arg0, u->name))
		{
			if (u->func)
				u->func(d);
			found = true;
			break;
		}
	}

	if (!found)
	{
		if (developer.value)
			Sys_Printf("Bad QTV command: %s\n", arg0);
	}

//	Sys_RedirectStop();
}

void QTV_ReadInput( mvddest_t *d )
{
	int len, parse_end, clc;
	netmsg_t buf;

	if (d->error)
		return;

	len = sizeof(d->inbuffer) - d->inbuffersize - 1; // -1 since it null terminated

	if (len)
	{
		len = recv(d->socket, d->inbuffer + d->inbuffersize, len, 0);

		if (len == 0)
		{
			Sys_Printf("QTV_ReadInput: read error from QTV client, dropping\n");
			d->error = true;
			return;
		}
		else if (len < 0)
		{
			len = 0;
		}

		d->inbuffersize += len;
		d->inbuffer[d->inbuffersize] = 0; // null terminated
	}

	if (d->inbuffersize < 2)
		return; // we need at least size

	InitNetMsg(&buf, d->inbuffer, d->inbuffersize);
	buf.cursize	= d->inbuffersize; // we laredy have some data in buffer

	parse_end	= 0;

	while(buf.readpos < buf.cursize)
	{
//		Sys_Printf("%d %d\n", buf.readpos, buf.cursize);

		if (buf.readpos > buf.cursize)
		{
			d->error = true;
			Sys_Printf("QTV_ReadInput: Read past end of parse buffer\n");
			return;
		}

		buf.startpos = buf.readpos;

		if (buf.cursize - buf.startpos < 2)
			break; // we need at least size

		len = ReadShort(&buf);

		if (len > (int)sizeof(d->inbuffer) - 1 || len < 3)
		{
			d->error = true;
			Sys_Printf("QTV_ReadInput: can't handle such long/short message: %i\n", len);
			return;
		}

		if (len > buf.cursize - buf.startpos)
			break; // not enough data yet

		parse_end = buf.startpos + len; // so later we know which part of buffer we alredy served

		switch (clc = ReadByte(&buf))
		{
		#define qtv_clc_stringcmd    1

		case qtv_clc_stringcmd:
			QTV_cmd[0] = 0;
			ReadString(&buf, QTV_cmd, sizeof(QTV_cmd));
			QTV_ExecuteCmd(d, QTV_cmd);
			break;

		default:
			d->error = true;
			Sys_Printf("QTV_ReadInput: can't handle clc %i\n", clc);
			return;
		}
	}

	if (parse_end)
	{
		d->inbuffersize -= parse_end;
		memmove(d->inbuffer, d->inbuffer + parse_end, d->inbuffersize);
	}
}

void QTV_ReadDests( void )
{
	mvddest_t *d;

	for (d = demo.dest; d; d = d->nextdest)
	{
		if (d->desttype != DEST_STREAM)
			continue;

		if (d->error)
			continue;

		QTV_ReadInput(d);
	}
}

//============================================================ 




/*
void DemoWriteQTVTimePad (int msecs)	//broadcast to all proxies
{
	mvddest_t *d;
	unsigned char buffer[6];
	while (msecs > 0)
	{
		//duration
		if (msecs > 255)
			buffer[0] = 255;
		else
			buffer[0] = msecs;
		msecs -= buffer[0];
		//message type
		buffer[1] = dem_read;
		//length
		buffer[2] = 0;
		buffer[3] = 0;
		buffer[4] = 0;
		buffer[5] = 0;

		for (d = demo.dest; d; d = d->nextdest)
		{
			if (d->desttype == DEST_STREAM)
			{
				DemoWriteDest(buffer, sizeof(buffer), d);
			}
		}
	}
}
*/

//broadcast to all proxies
void DemoWriteQTV (sizebuf_t *msg)
{
	mvddest_t		*d;
	sizebuf_t		mvdheader;
	byte			mvdheader_buf[6];

	SZ_InitEx(&mvdheader, mvdheader_buf, sizeof(mvdheader_buf), false);

	//duration
	MSG_WriteByte (&mvdheader, 0);
	//message type
	MSG_WriteByte (&mvdheader, dem_all);
	//length
	MSG_WriteLong (&mvdheader, msg->cursize);

	for (d = demo.dest; d; d = d->nextdest)
	{
		if (d->desttype == DEST_STREAM)
		{
			DemoWriteDest(mvdheader.data, mvdheader.cursize, d);
			DemoWriteDest(msg->data, msg->cursize, d);
		}
	}
}

void Qtv_List_f(void)
{
	mvddest_t *d;
	int cnt;

	for (cnt = 0, d = demo.dest; d; d = d->nextdest)
	{
		if (d->desttype != DEST_STREAM)
			continue; // not qtv

		if (!cnt) // print banner
			Con_Printf ("QTV list:\n"
						"%4.4s %s\n", "#Id", "Addr");

		cnt++;

		Con_Printf ("%4d %s\n", d->id, NET_AdrToString(d->na));
	}

	if (!cnt)
		Con_Printf ("QTV list: empty\n");
}

// Very similar to Qtv_list_f, but for disconnected clients.
void QTV_Streams_List (void)
{
	mvddest_t *dst;
	for (dst = demo.dest; dst; dst = dst->nextdest) {
		if (dst->desttype == DEST_STREAM) {
			int qtv_users = QTVsv_UsersCount (dst);

			if (dst->qtvaddress[0])
				Con_Printf ("qtv %d \"%s\" \"%d@%s\" %d\n", dst->id, dst->qtvname, dst->qtvstreamid, dst->qtvaddress, qtv_users);
			else
				Con_Printf ("qtv %d \"%s\" \"\" %d\n", dst->id, dst->qtvname, qtv_users);
		}
	}
}

// Expose user list to disconnected clients.
void QTV_Streams_UserList (void)
{
	mvddest_t *dst;
	for (dst = demo.dest; dst; dst = dst->nextdest) {
		if (dst->desttype == DEST_STREAM) {
			qtvuser_t *current;

			Con_Printf ("qtvusers %d", dst->id);
			for (current = dst->qtvuserlist; current; current = current->next)
				Con_Printf (" \"%s\"", current->name);
			Con_Printf ("\n");
		}
	}
}

void Qtv_Close_f(void)
{
	mvddest_t *d;
	int id, cnt;
	qbool all;

	if (Cmd_Argc() < 2 || !*Cmd_Argv(1))  // not less than one param, first param non empty
	{
		Con_Printf ("Usage: %s <#id | all>\n", Cmd_Argv(0));
		return;
	}

	for (d = demo.dest; d; d = d->nextdest)
		if (d->desttype == DEST_STREAM)
			break; // at least one qtv present

	if (!d) {
		Con_Printf ("QTV list alredy empty\n");
		return;
	}

	id  = atoi(Cmd_Argv(1));
	all = !strcasecmp(Cmd_Argv(1), "all");
	cnt = 0;

	for (d = demo.dest; d; d = d->nextdest)
	{
		if (d->desttype != DEST_STREAM)
			continue; // not qtv

		if (all || d->id == id) {
			Con_Printf ("QTV id:%d aka %s will be dropped asap\n", d->id, NET_AdrToString(d->na));
			d->error = true;
			cnt++;
		}
	}

	if (!cnt)
		Con_Printf ("QTV id:%d not found\n", id);
}

void Qtv_Status_f(void)
{
	int cnt;
	mvddest_t *d;
	mvdpendingdest_t *p;

	Con_Printf ("QTV status\n");
	Con_Printf ("Listen socket  : %s\n", NET_GetSocket(NS_SERVER, true) == INVALID_SOCKET ? "invalid" : "listen");
	Con_Printf ("Port           : %d\n", listenport);

	for (cnt = 0, d = demo.dest; d; d = d->nextdest)
		if (d->desttype == DEST_STREAM)
			cnt++;

	Con_Printf ("Streams        : %d\n", cnt);

	for (cnt = 0, p = demo.pendingdest; p; p = p->nextdest)
		cnt++;

	Con_Printf ("Pending streams: %d\n", cnt);
}

//====================================

void SV_QTV_Init(void)
{
	Cvar_Register (&qtv_streamport);
	Cvar_Register (&qtv_maxstreams);
	Cvar_Register (&qtv_password);
	Cvar_Register (&qtv_pendingtimeout);
	Cvar_Register (&qtv_streamtimeout);
	Cvar_Register (&qtv_sayenabled);

	Cmd_AddCommand ("qtv_list", Qtv_List_f);
	Cmd_AddCommand ("qtv_close", Qtv_Close_f);
	Cmd_AddCommand ("qtv_status", Qtv_Status_f);
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_ents.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

#ifndef CLIENTONLY
#include "qwsvdef.h"


//=============================================================================

// because there can be a lot of nails, there is a special
// network protocol for them
#define MAX_NAILS 32
static edict_t *nails[MAX_NAILS];
static int numnails;
static int nailcount = 0;

extern	int sv_nailmodel, sv_supernailmodel, sv_playermodel;

cvar_t	sv_nailhack	= {"sv_nailhack", "1"};

// Maximum packet we will send - currently 256 if extension supported
#define MAX_PACKETENTITIES_POSSIBLE 256

static qbool SV_AddNailUpdate (edict_t *ent)
{
	if ((int)sv_nailhack.value)
		return false;

	if (ent->v->modelindex != sv_nailmodel && ent->v->modelindex != sv_supernailmodel)
		return false;

	if (msg_coordsize != 2)
		return false; // Do not allow nailhack in case of sv_bigcoords.

	if (numnails == MAX_NAILS)
		return true;

	nails[numnails] = ent;
	numnails++;
	return true;
}

static void SV_EmitNailUpdate (sizebuf_t *msg, qbool recorder)
{
	int x, y, z, p, yaw, n, i;
	byte bits[6]; // [48 bits] xyzpy 12 12 12 4 8
	edict_t *ent;


	if (!numnails)
		return;

	if (recorder)
		MSG_WriteByte (msg, svc_nails2);
	else
		MSG_WriteByte (msg, svc_nails);

	MSG_WriteByte (msg, numnails);

	for (n=0 ; n<numnails ; n++)
	{
		ent = nails[n];
		if (recorder)
		{
			if (!ent->v->colormap)
			{
				if (!((++nailcount)&255)) nailcount++;
				ent->v->colormap = nailcount&255;
			}

			MSG_WriteByte (msg, (byte)ent->v->colormap);
		}

		x = ((int)(ent->v->origin[0] + 4096 + 1) >> 1) & 4095;
		y = ((int)(ent->v->origin[1] + 4096 + 1) >> 1) & 4095;
		z = ((int)(ent->v->origin[2] + 4096 + 1) >> 1) & 4095;
		p = Q_rint(ent->v->angles[0]*(16.0/360.0)) & 15;
		yaw = Q_rint(ent->v->angles[1]*(256.0/360.0)) & 255;

		bits[0] = x;
		bits[1] = (x>>8) | (y<<4);
		bits[2] = (y>>4);
		bits[3] = z;
		bits[4] = (z>>8) | (p<<4);
		bits[5] = yaw;

		for (i=0 ; i<6 ; i++)
			MSG_WriteByte (msg, bits[i]);
	}
}

//=============================================================================


/*
==================
SV_WriteDelta

Writes part of a packetentities message.
Can delta from either a baseline or a previous packet_entity
==================
*/
void SV_WriteDelta(client_t* client, entity_state_t *from, entity_state_t *to, sizebuf_t *msg, qbool force)
{
	int bits, i;
#ifdef PROTOCOL_VERSION_FTE
	int evenmorebits = 0;
	unsigned int required_extensions = 0;
	unsigned int fte_extensions = client->fteprotocolextensions;
#endif

	// send an update
	bits = 0;

	for (i = 0; i < 3; i++)
		if (to->origin[i] != from->origin[i])
			bits |= U_ORIGIN1 << i;

	if (to->angles[0] != from->angles[0])
		bits |= U_ANGLE1;

	if (to->angles[1] != from->angles[1])
		bits |= U_ANGLE2;

	if (to->angles[2] != from->angles[2])
		bits |= U_ANGLE3;

	if (to->colormap != from->colormap)
		bits |= U_COLORMAP;

	if (to->skinnum != from->skinnum)
		bits |= U_SKIN;

	if (to->frame != from->frame)
		bits |= U_FRAME;

	if (to->effects != from->effects)
		bits |= U_EFFECTS;

	if (to->modelindex != from->modelindex) {
		bits |= U_MODEL;
#ifdef FTE_PEXT_ENTITYDBL
		if (to->modelindex > 255) {
			if (to->modelindex >= 512) {
				bits &= ~U_MODEL;
			}
			evenmorebits |= U_FTE_MODELDBL;
			required_extensions |= FTE_PEXT_MODELDBL;
		}
#endif
	}

	if (bits & U_CHECKMOREBITS)
		bits |= U_MOREBITS;

	if (to->flags & U_SOLID)
		bits |= U_SOLID;

	// Taken from FTE
	if (msg->cursize + 40 > msg->maxsize && !MSG_HasOverflowHandler(msg))
	{
		// not enough space in the buffer, don't send the entity this frame. (not sending means nothing changes, and it takes no bytes!!)
		int oldnum = to->number;
		*to = *from;
		if (oldnum && !from->number) {
			to->number = oldnum;
		}
		return;
	}

	//
	// write the message
	//
	if (!to->number)
		SV_Error("Unset entity number");

#ifdef PROTOCOL_VERSION_FTE
	if (to->number >= 512)
	{
		if (to->number >= 1024)
		{
			if (to->number >= 1024 + 512) {
				evenmorebits |= U_FTE_ENTITYDBL;
				required_extensions |= FTE_PEXT_ENTITYDBL;
			}

			evenmorebits |= U_FTE_ENTITYDBL2;
			required_extensions |= FTE_PEXT_ENTITYDBL2;
			if (to->number >= 2048)
				SV_Error ("Entity number >= 2048");
		}
		else {
			evenmorebits |= U_FTE_ENTITYDBL;
			required_extensions |= FTE_PEXT_ENTITYDBL;
		}
	}

#ifdef U_FTE_TRANS
	if (to->trans != from->trans && (fte_extensions & FTE_PEXT_TRANS)) {
		evenmorebits |= U_FTE_TRANS;
		required_extensions |= FTE_PEXT_TRANS;
	}
#endif

#ifdef U_FTE_COLOURMOD
	if ((to->colourmod[0] != from->colourmod[0] ||
	     to->colourmod[1] != from->colourmod[1] ||
	     to->colourmod[2] != from->colourmod[2]) && (fte_extensions & FTE_PEXT_COLOURMOD)) {
		evenmorebits |= U_FTE_COLOURMOD;
		required_extensions |= FTE_PEXT_COLOURMOD;
	}
#endif

	if (evenmorebits&0xff00)
		evenmorebits |= U_FTE_YETMORE;
	if (evenmorebits&0x00ff)
		bits |= U_FTE_EVENMORE;
	if (bits & 511)
		bits |= U_MOREBITS;
#endif

	if (to->number >= sv.max_edicts) {
		/*SV_Error*/
		Con_Printf("Entity number >= MAX_EDICTS (%d), set to MAX_EDICTS - 1\n", sv.max_edicts);
		to->number = sv.max_edicts - 1;
	}

#ifdef PROTOCOL_VERSION_FTE
	if (evenmorebits && (fte_extensions & required_extensions) != required_extensions) {
		return;
	}
#endif
	if (!bits && !force) {
		return;		// nothing to send!
	}
	i = (to->number & U_CHECKMOREBITS) | (bits&~U_CHECKMOREBITS);
	if (i & U_REMOVE)
		Sys_Error("U_REMOVE");
	MSG_WriteShort(msg, i);

	if (bits & U_MOREBITS)
		MSG_WriteByte(msg, bits & 255);
#ifdef PROTOCOL_VERSION_FTE
	if (bits & U_FTE_EVENMORE)
		MSG_WriteByte (msg, evenmorebits&255);
	if (evenmorebits & U_FTE_YETMORE)
		MSG_WriteByte (msg, (evenmorebits>>8)&255);
#endif

	if (bits & U_MODEL)
		MSG_WriteByte(msg, to->modelindex & 255);
	else if (evenmorebits & U_FTE_MODELDBL)
		MSG_WriteShort(msg, to->modelindex);
	if (bits & U_FRAME)
		MSG_WriteByte(msg, to->frame);
	if (bits & U_COLORMAP)
		MSG_WriteByte(msg, to->colormap);
	if (bits & U_SKIN)
		MSG_WriteByte(msg, to->skinnum);
	if (bits & U_EFFECTS)
		MSG_WriteByte(msg, to->effects);
	if (bits & U_ORIGIN1) {
		if (client->mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
			MSG_WriteLongCoord(msg, to->origin[0]);
		}
		else {
			MSG_WriteCoord(msg, to->origin[0]);
		}
	}
	if (bits & U_ANGLE1) {
		MSG_WriteAngle(msg, to->angles[0]);
	}
	if (bits & U_ORIGIN2) {
		if (client->mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
			MSG_WriteLongCoord(msg, to->origin[1]);
		}
		else {
			MSG_WriteCoord(msg, to->origin[1]);
		}
	}
	if (bits & U_ANGLE2) {
		MSG_WriteAngle(msg, to->angles[1]);
	}
	if (bits & U_ORIGIN3) {
		if (client->mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
			MSG_WriteLongCoord(msg, to->origin[2]);
		}
		else {
			MSG_WriteCoord(msg, to->origin[2]);
		}
	}
	if (bits & U_ANGLE3) {
		MSG_WriteAngle(msg, to->angles[2]);
	}

#ifdef U_FTE_TRANS
	if (evenmorebits & U_FTE_TRANS)
		MSG_WriteByte (msg, to->trans);
#endif

#ifdef U_FTE_COLOURMOD
	if (evenmorebits & U_FTE_COLOURMOD)
	{
		MSG_WriteByte (msg, to->colourmod[0]);
		MSG_WriteByte (msg, to->colourmod[1]);
		MSG_WriteByte (msg, to->colourmod[2]);
	}
#endif
}

/*
=============
SV_EmitPacketEntities

Writes a delta update of a packet_entities_t to the message.

=============
*/
static void SV_EmitPacketEntities (client_t *client, packet_entities_t *to, sizebuf_t *msg)
{
	int oldindex, newindex, oldnum, newnum, oldmax;
	client_frame_t	*fromframe;
	packet_entities_t *from1;
	edict_t	*ent;

	// this is the frame that we are going to delta update from
	if (client->delta_sequence != -1)
	{
		fromframe = &client->frames[client->delta_sequence & UPDATE_MASK];
		from1 = &fromframe->entities;
		oldmax = from1->num_entities;

		MSG_WriteByte (msg, svc_deltapacketentities);
		MSG_WriteByte (msg, client->delta_sequence);
	}
	else
	{
		oldmax = 0;	// no delta update
		from1 = NULL;

		MSG_WriteByte (msg, svc_packetentities);
	}

	newindex = 0;
	oldindex = 0;
	//Con_Printf ("---%i to %i ----\n", client->delta_sequence & UPDATE_MASK
	//			, client->netchan.outgoing_sequence & UPDATE_MASK);
	while (newindex < to->num_entities || oldindex < oldmax)
	{
		newnum = newindex >= to->num_entities ? 9999 : to->entities[newindex].number;
		oldnum = oldindex >= oldmax ? 9999 : from1->entities[oldindex].number;

		if (newnum == oldnum)
		{	// delta update from old position
			//Con_Printf ("delta %i\n", newnum);
			SV_WriteDelta (client, &from1->entities[oldindex], &to->entities[newindex], msg, false);
			oldindex++;
			newindex++;
			continue;
		}

		if (newnum < oldnum)
		{	// this is a new entity, send it from the baseline
			if (newnum == 9999)
			{
				Sys_Printf("LOL, %d, %d, %d, %d %d %d\n", // nice message
				           newnum, oldnum, to->num_entities, oldmax,
				           client->netchan.incoming_sequence & UPDATE_MASK,
				           client->delta_sequence & UPDATE_MASK);
				if (client->edict == NULL)
					Sys_Printf("demo\n");
			}
			ent = EDICT_NUM(newnum);
			//Con_Printf ("baseline %i\n", newnum);
			SV_WriteDelta (client, &ent->e.baseline, &to->entities[newindex], msg, true);
			newindex++;
			continue;
		}

		if (newnum > oldnum)
		{
			// the old entity isn't present in the new message
			if (oldnum >= 512) {
				//yup, this is expensive.
				MSG_WriteShort (msg, oldnum | U_REMOVE | U_MOREBITS);
				MSG_WriteByte (msg, U_FTE_EVENMORE);
				if (oldnum >= 1024) {
					if (oldnum >= 1024 + 512) {
						MSG_WriteByte(msg, U_FTE_ENTITYDBL | U_FTE_ENTITYDBL2);
					}
					else {
						MSG_WriteByte(msg, U_FTE_ENTITYDBL2);
					}
				}
				else {
					MSG_WriteByte(msg, U_FTE_ENTITYDBL);
				}
			}
			else {
				MSG_WriteShort(msg, oldnum | U_REMOVE);
			}

			oldindex++;
			continue;
		}
	}

	MSG_WriteShort (msg, 0);	// end of packetentities
}

static int TranslateEffects (edict_t *ent)
{
	int fx = (int)ent->v->effects;
	if (pr_nqprogs)
		fx &= ~EF_MUZZLEFLASH;
	if (pr_nqprogs && (fx & EF_DIMLIGHT)) {
		if ((int)ent->v->items & IT_QUAD)
			fx |= EF_BLUE;
		if ((int)ent->v->items & IT_INVULNERABILITY)
			fx |= EF_RED;
	}
	return fx;
}

/*
=============
SV_MVD_WritePlayersToClient
=============
*/
static void SV_MVD_WritePlayersToClient ( void )
{
	int j;
	demo_frame_t *demo_frame;
	demo_client_t *dcl;
	client_t *cl;
	edict_t *ent;

	if ( !sv.mvdrecording )
		return;

	demo_frame = &demo.frames[demo.parsecount&UPDATE_MASK];

	for (j = 0, cl = svs.clients, dcl = demo_frame->clients; j < MAX_CLIENTS; j++, cl++, dcl++)
	{
		if ( cl->state != cs_spawned || cl->spectator )
			continue;

		ent = cl->edict;

		dcl->parsecount = demo.parsecount;

		VectorCopy(ent->v->origin, dcl->origin);
		VectorCopy(ent->v->angles, dcl->angles);
		dcl->angles[0] *= -3;
#ifdef USE_PR2
		if( cl->isBot )
			VectorCopy(ent->v->v_angle, dcl->angles);
#endif
		dcl->angles[2] = 0; // no roll angle

		if (ent->v->health <= 0)
		{	// don't show the corpse looking around...
			dcl->angles[0] = 0;
			dcl->angles[1] = ent->v->angles[1];
			dcl->angles[2] = 0;
		}

		dcl->weaponframe = ent->v->weaponframe;
		dcl->frame       = ent->v->frame;
		dcl->skinnum     = ent->v->skin;
		dcl->model       = ent->v->modelindex;
		dcl->effects     = TranslateEffects(ent);
		dcl->flags       = 0;

		dcl->fixangle    = demo.fixangle[j];
		demo.fixangle[j] = 0;

		dcl->sec         = sv.time - cl->localtime;

		if (ent->v->health <= 0)
			dcl->flags |= DF_DEAD;
		if (ent->v->mins[2] != -24)
			dcl->flags |= DF_GIB;

		continue;
	}
}

/*
=============
SV_PlayerVisibleToClient
=============
*/
qbool SV_PlayerVisibleToClient (client_t* client, int j, byte* pvs, edict_t* self_ent, edict_t* ent)
{
	client_t* cl = &svs.clients[j];

	// ZOID visibility tracking
	if (ent != self_ent && !(client->spec_track && client->spec_track - 1 == j))
	{
		int i;

		if (cl->spectator)
			return false;

		if (pvs && ent->e.num_leafs >= 0) {
			// ignore if not touching a PV leaf
			for (i = 0; i < ent->e.num_leafs; i++) {
				if (pvs[ent->e.leafnums[i] >> 3] & (1 << (ent->e.leafnums[i] & 7))) {
					break;
				}
			}
			if (i == ent->e.num_leafs) {
				return false; // not visible
			}
		}
	}

	return true;
}

/*
=============
SV_WritePlayersToClient
=============
*/

int SV_PMTypeForClient (client_t *cl);
static void SV_WritePlayersToClient (client_t *client, client_frame_t *frame, byte *pvs, qbool disable_updates, sizebuf_t *msg)
{
	int msec, pflags, pm_type = 0, pm_code = 0, i, j;
	usercmd_t cmd;
	int hideent = 0;
	int trackent = 0;
	qbool hide_players = fofs_hide_players && ((eval_t *)((byte *)(client->edict)->v + fofs_hide_players))->_int;

	if (fofs_hideentity)
		hideent = ((eval_t *)((byte *)(client->edict)->v + fofs_hideentity))->_int / pr_edict_size;

	if (fofs_trackent)
	{
		trackent = ((eval_t *)((byte *)(client->edict)->v + fofs_trackent))->_int;
		if (trackent < 1 || trackent > MAX_CLIENTS || svs.clients[trackent - 1].state != cs_spawned)
			trackent = 0;
	}

	frame->sv_time = sv.time;

	for (j = 0; j < MAX_CLIENTS; j++)
	{
		client_t*   cl = &svs.clients[j];
		edict_t*    ent = NULL;
		edict_t*    self_ent = NULL;
		edict_t*    track_ent = NULL;

		if (fofs_visibility) {
			// Presume not visible
			((eval_t *)((byte *)(cl->edict)->v + fofs_visibility))->_int &= ~(1 << (client - svs.clients));
		}

		if (cl->state != cs_spawned)
			continue;

		if (client != cl && hide_players)
			continue;

		if (trackent && cl == client)
		{
			cl = &svs.clients[trackent - 1]; // fakenicking.

			track_ent = svs.clients[trackent - 1].edict;

			self_ent = track_ent;
			ent = track_ent;
		}
		else
		{
			self_ent = client->edict;
			ent = cl->edict;
		}

		// set up edicts.
		if (!SV_PlayerVisibleToClient (client, j, pvs, self_ent, ent))
			continue;

		if (fofs_visibility) {
			// Update flags so mods can tell what was visible
			((eval_t *)((byte *)(ent)->v + fofs_visibility))->_int |= (1 << (client - svs.clients));
		}

		if (j == hideent - 1)
			continue;

		if (j == trackent - 1)
			continue;

		if (disable_updates && ent != self_ent)
		{ // Vladis
			continue;
		}

		//====================================================
		// OK, seems we must send info about this player below

		pflags = PF_MSEC | PF_COMMAND;

		if (ent->v->modelindex != sv_playermodel)
			pflags |= PF_MODEL;
		for (i=0 ; i<3 ; i++)
			if (ent->v->velocity[i])
				pflags |= PF_VELOCITY1<<i;
		if (ent->v->effects)
			pflags |= PF_EFFECTS;
		if (ent->v->skin || ent->v->modelindex >= 256)
			pflags |= PF_SKINNUM;
		if (ent->v->health <= 0)
			pflags |= PF_DEAD;
		if (ent->v->mins[2] != -24)
			pflags |= PF_GIB;

		if (cl->spectator)
		{	// only sent origin and velocity to spectators
			pflags &= PF_VELOCITY1 | PF_VELOCITY2 | PF_VELOCITY3;
		}
		else if (ent == self_ent)
		{	// don't send a lot of data on personal entity
			pflags &= ~(PF_MSEC|PF_COMMAND);
			if (ent->v->weaponframe)
				pflags |= PF_WEAPONFRAME;
		}

#ifdef FTE_PEXT_TRANS
		if (client->fteprotocolextensions & FTE_PEXT_TRANS && ent->xv.alpha > 0.0f && ent->xv.alpha < 1.0f)
		{
			pflags |= PF_TRANS_Z;
		}
#endif

		// Z_EXT_PM_TYPE protocol extension
		// encode pm_type and jump_held into pm_code
		pm_type = track_ent ? PM_LOCK : SV_PMTypeForClient (cl);
		switch (pm_type)
		{
			case PM_DEAD:
				pm_code = PMC_NORMAL; // plus PF_DEAD
				break;
			case PM_NORMAL:
				pm_code = PMC_NORMAL;
				if (cl->jump_held)
					pm_code = PMC_NORMAL_JUMP_HELD;
				break;
			case PM_OLD_SPECTATOR:
				pm_code = PMC_OLD_SPECTATOR;
				break;
			case PM_SPECTATOR:
				pm_code = PMC_SPECTATOR;
				break;
			case PM_FLY:
				pm_code = PMC_FLY;
				break;
			case PM_NONE:
				pm_code = PMC_NONE;
				break;
			case PM_LOCK:
				pm_code = PMC_LOCK;
				break;
			default:
				assert (false);
		}

		pflags |= pm_code << PF_PMC_SHIFT;

		// Z_EXT_PF_ONGROUND protocol extension
		if ((int)ent->v->flags & FL_ONGROUND)
			pflags |= PF_ONGROUND;

		// Z_EXT_PF_SOLID protocol extension
		if (ent->v->solid == SOLID_BBOX || ent->v->solid == SOLID_SLIDEBOX)
			pflags |= PF_SOLID;

		if (pm_type == PM_LOCK && ent == self_ent)
			pflags |= PF_COMMAND;	// send forced view angles

		if (client->spec_track && client->spec_track - 1 == j && ent->v->weaponframe)
			pflags |= PF_WEAPONFRAME;

		MSG_WriteByte (msg, svc_playerinfo);
		MSG_WriteByte (msg, j);

#if defined(FTE_PEXT_TRANS)
		if (client->fteprotocolextensions & FTE_PEXT_TRANS)
		{
			if (pflags & 0xff0000)
			{
				pflags |= PF_EXTRA_PFS;
			}
			MSG_WriteShort (msg, pflags & 0xffff);
			if (pflags & PF_EXTRA_PFS)
			{
				MSG_WriteByte(msg, (pflags & 0xff0000) >> 16);
			}
		}
		else
		{
			// Without PEXT_TRANS there's no PF_EXTRA_PFS, move
			// PF_ONGROUND and PF_SOLID to their expected offsets.
			MSG_WriteShort (msg, pflags & 0x3fff | (pflags & 0xc00000) >> 8);
		}
#else
		MSG_WriteShort (msg, pflags);
#endif

		if (client->mvdprotocolextensions1 & MVD_PEXT1_FLOATCOORDS) {
			MSG_WriteLongCoord(msg, ent->v->origin[0]);
			MSG_WriteLongCoord(msg, ent->v->origin[1]);
			MSG_WriteLongCoord(msg, ent->v->origin[2]);
		}
		else {
			MSG_WriteCoord(msg, ent->v->origin[0]);
			MSG_WriteCoord(msg, ent->v->origin[1]);
			MSG_WriteCoord(msg, ent->v->origin[2]);
		}

		MSG_WriteByte (msg, ent->v->frame);

		if (pflags & PF_MSEC)
		{
			msec = 1000*(sv.time - cl->localtime);
			if (msec > 255)
				msec = 255;
			MSG_WriteByte (msg, msec);
		}

		if (pflags & PF_COMMAND)
		{
			cmd = cl->lastcmd;

			if (ent->v->health <= 0)
			{	// don't show the corpse looking around...
				cmd.angles[0] = 0;
				cmd.angles[1] = ent->v->angles[1];
				cmd.angles[0] = 0;
			}

			cmd.buttons = 0;	// never send buttons
			cmd.impulse = 0;	// never send impulses

			if (ent == self_ent)
			{
				// this is PM_LOCK, we only want to send view angles
				VectorCopy(ent->v->v_angle, cmd.angles);
				cmd.forwardmove = 0;
				cmd.sidemove = 0;
				cmd.upmove = 0;
			}

			if ((client->extensions & Z_EXT_VWEP) && sv.vw_model_name[0] && fofs_vw_index) {
				cmd.impulse = EdictFieldFloat (ent, fofs_vw_index);
			}

			MSG_WriteDeltaUsercmd (msg, &nullcmd, &cmd, 0);
		}

		for (i=0 ; i<3 ; i++)
			if (pflags & (PF_VELOCITY1<<i) )
				MSG_WriteShort (msg, ent->v->velocity[i]);

		if (pflags & PF_MODEL)
			MSG_WriteByte (msg, ent->v->modelindex);

		if (pflags & PF_SKINNUM)
			MSG_WriteByte (msg, (int)ent->v->skin | (((pflags & PF_MODEL)&&(ent->v->modelindex >= 256))<<7));

		if (pflags & PF_EFFECTS)
			MSG_WriteByte (msg, TranslateEffects(ent));

		if (pflags & PF_WEAPONFRAME)
			MSG_WriteByte (msg, ent->v->weaponframe);

#ifdef FTE_PEXT_TRANS
		if (pflags & PF_TRANS_Z)
		{
			MSG_WriteByte (msg, bound(1, (byte)(ent->xv.alpha * 254.0f), 254));
		}
#endif
	}
}

/*
=============
SV_EntityVisibleToClient
=============
*/
qbool SV_EntityVisibleToClient (client_t* client, int e, byte* pvs)
{
	edict_t* ent = EDICT_NUM (e);

	if (pr_nqprogs)
	{
		// don't send the player's model to himself
		if (e < MAX_CLIENTS + 1 && svs.clients[e-1].state != cs_free)
			return false;
	}

	// ignore ents without visible models
	if (!ent->v->modelindex || !*PR_GetEntityString(ent->v->model))
		return false;

	if ( pvs && ent->e.num_leafs >= 0 )
	{
		int i;

		// ignore if not touching a PV leaf
		for (i=0 ; i < ent->e.num_leafs ; i++)
			if (pvs[ent->e.leafnums[i] >> 3] & (1 << (ent->e.leafnums[i]&7) ))
				break;

		if (i == ent->e.num_leafs)
			return false;		// not visible
	}

	return true;
}

/*
=============
SV_WriteEntitiesToClient

Encodes the current state of the world as
a svc_packetentities messages and possibly
a svc_nails message and
svc_playerinfo messages
=============
*/

void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qbool recorder)
{
	qbool disable_updates; // disables sending entities to the client
	int e, i, max_packet_entities;
	packet_entities_t *pack;
	client_frame_t *frame;
	entity_state_t *state;
	edict_t *ent;
	byte *pvs;
	int hideent;
	unsigned int client_flag = (1 << (client - svs.clients));
	edict_t	*clent = client->edict;

	float distances[MAX_PACKETENTITIES_POSSIBLE] = { 0 };
	float distance;
	int position;
	vec3_t org;

	if ( recorder )
	{
		if ( !sv.mvdrecording )
			return;
	}

	// this is the frame we are creating
	frame = &client->frames[client->netchan.incoming_sequence & UPDATE_MASK];

	// find the client's PVS
	if ( recorder )
	{// demo
		hideent = 0;
		pvs = NULL; // ignore PVS for demos
		max_packet_entities = MAX_MVD_PACKET_ENTITIES;
		disable_updates = false; // updates always allowed in demos
	}
	else
	{// normal client
		vec3_t org;
		int trackent = 0;

		if (fofs_hideentity)
			hideent = ((eval_t *)((byte *)(client->edict)->v + fofs_hideentity))->_int / pr_edict_size;
		else
			hideent = 0;

		if (fofs_trackent)
		{
			trackent = ((eval_t *)((byte *)(client->edict)->v + fofs_trackent))->_int;
			if (trackent < 1 || trackent > MAX_CLIENTS || svs.clients[trackent - 1].state != cs_spawned)
				trackent = 0;
		}

		// we should use org of tracked player in case or trackent.
		if (trackent)
		{
			VectorAdd (svs.clients[trackent - 1].edict->v->origin, svs.clients[trackent - 1].edict->v->view_ofs, org);		
		}
		else
		{
			VectorAdd (client->edict->v->origin, client->edict->v->view_ofs, org);
		}

		pvs = CM_FatPVS (org); // search some PVS
		max_packet_entities = (client->fteprotocolextensions & FTE_PEXT_256PACKETENTITIES) ? MAX_PEXT256_PACKET_ENTITIES : MAX_PACKET_ENTITIES;

		if (client->disable_updates_stop > realtime)
		{
			#define ISUNDERWATER(x) ((x) == CONTENTS_WATER || (x) == CONTENTS_SLIME || (x) == CONTENTS_LAVA)

			// server flash should not work underwater
			int content = CM_HullPointContents(&sv.worldmodel->hulls[0], 0, client->edict->v->origin);
			disable_updates = !ISUNDERWATER(content);

			#undef ISUNDERWATER
		}
		else
		{
			disable_updates = false;
		}
	}

	// send over the players in the PVS
	if ( recorder )
		SV_MVD_WritePlayersToClient (); // nice, no params at all!
	else
		SV_WritePlayersToClient (client, frame, pvs, disable_updates, msg);

	// put other visible entities into either a packet_entities or a nails message
	pack = &frame->entities;
	pack->num_entities = 0;

	numnails = 0;

	if (!disable_updates)
	{// Vladis, server flash

		// QW protocol can only handle 512 entities. Any entity with number >= 512 will be invisible
		// from ZQuake unless using protocol extensions.
		// max_edicts = min(sv.num_edicts, MAX_EDICTS);

		for (e = pr_nqprogs ? 1 : MAX_CLIENTS + 1, ent = EDICT_NUM(e); e < sv.num_edicts; e++, ent = NEXT_EDICT(ent))
		{
			if (!SV_EntityVisibleToClient(client, e, pvs)) {
				if (fofs_visibility) {
					((eval_t *)((byte *)(ent)->v + fofs_visibility))->_int &= ~client_flag;
				}
				continue;
			}

			if (fofs_visibility) {
				// Don't include other filters in logic for setting this field
				((eval_t *)((byte *)(ent)->v + fofs_visibility))->_int |= (1 << (client - svs.clients));
			}

			if (e == hideent) {
				continue;
			}

			if (SV_AddNailUpdate (ent))
				continue; // added to the special update list

			if (clent) {
				VectorAdd(ent->v->absmin, ent->v->absmax, org);
				VectorMA(clent->v->origin, -0.5, org, org);
				distance = DotProduct(org, org);	//Length

				// add to the packetentities
				if (pack->num_entities == max_packet_entities) {
					// replace the furthest entity
					float furthestdist = -1;
					int best = -1;
					for (i = 0; i < max_packet_entities; i++) {
						if (furthestdist < distances[i]) {
							furthestdist = distances[i];
							best = i;
						}
					}

					if (furthestdist <= distance || best == -1) {
						continue;
					}

					// shuffle other entities down, add to end
					if (best < pack->num_entities - 1) {
						memmove(&pack->entities[best], &pack->entities[best + 1], sizeof(pack->entities[0]) * (pack->num_entities - 1 - best));
						memmove(&distances[best], &distances[best + 1], sizeof(distances[0]) * (pack->num_entities - 1 - best));
					}
					position = pack->num_entities - 1;
				}
				else {
					position = pack->num_entities++;
				}

				distances[position] = distance;
			}
			else {
				if (pack->num_entities == max_packet_entities) {
					continue;
				}

				position = pack->num_entities++;
			}

			state = &pack->entities[position];
			memset(state, 0, sizeof(*state));

			state->number = e;
			state->flags = 0;
			VectorCopy (ent->v->origin, state->origin);
			VectorCopy (ent->v->angles, state->angles);
			state->modelindex = ent->v->modelindex;
			state->frame = ent->v->frame;
			state->colormap = ent->v->colormap;
			state->skinnum = ent->v->skin;
			state->effects = TranslateEffects(ent);
#ifdef FTE_PEXT_TRANS
			state->trans = ent->xv.alpha >= 1.0f ? 0 : bound(0, (byte)(ent->xv.alpha * 254.0f), 254);
#endif
#ifdef FTE_PEXT_COLOURMOD
			if (ent->xv.colourmod[0] != 1.0f && ent->xv.colourmod[1] != 1.0f && ent->xv.colourmod[2] != 1.0f)
			{
				state->colourmod[0] = bound(0, ent->xv.colourmod[0] * (256.0f / 8.0f), 255);
				state->colourmod[1] = bound(0, ent->xv.colourmod[1] * (256.0f / 8.0f), 255);
				state->colourmod[2] = bound(0, ent->xv.colourmod[2] * (256.0f / 8.0f), 255);
			}
#endif
		}
	} // server flash

	// encode the packet entities as a delta from the
	// last packetentities acknowledged by the client

	SV_EmitPacketEntities (client, pack, msg);

	// now add the specialized nail update
	SV_EmitNailUpdate (msg, recorder);

	// Translate NQ progs' EF_MUZZLEFLASH to svc_muzzleflash
	if (pr_nqprogs)
	{
		for (e=1, ent=EDICT_NUM(e) ; e < sv.num_edicts ; e++, ent = NEXT_EDICT(ent))
		{
			// ignore ents without visible models
			if (!ent->v->modelindex || !*PR_GetEntityString(ent->v->model))
				continue;

			// ignore if not touching a PV leaf (meag: this does nothing... complete or remove?)
			if (pvs && ent->e.num_leafs >= 0) {
				for (i = 0; i < ent->e.num_leafs; i++)
					if (pvs[ent->e.leafnums[i] >> 3] & (1 << (ent->e.leafnums[i] & 7)))
						break;
			}

			if ((int)ent->v->effects & EF_MUZZLEFLASH) {
				ent->v->effects = (int)ent->v->effects & ~EF_MUZZLEFLASH;
				MSG_WriteByte (msg, svc_muzzleflash);
				MSG_WriteShort (msg, e);
			}
		}
	}
}

/*
============
SV_SetVisibleEntitiesForBot
============
*/
void SV_SetVisibleEntitiesForBot (client_t* client)
{
	int j = 0;
	int e = 0;
	unsigned int client_flag = 1 << (client - svs.clients);
	vec3_t org;
	byte* pvs = NULL;

	if (!fofs_visibility)
		return;

	VectorAdd (client->edict->v->origin, client->edict->v->view_ofs, org);
	pvs = CM_FatPVS (org); // search some PVS

	// players first
	for (j = 0; j < MAX_CLIENTS; j++)
	{
		if (SV_PlayerVisibleToClient(client, j, pvs, client->edict, svs.clients[j].edict)) {
			((eval_t *)((byte *)(svs.clients[j].edict)->v + fofs_visibility))->_int |= client_flag;
		}
		else {
			((eval_t *)((byte *)(svs.clients[j].edict)->v + fofs_visibility))->_int &= ~client_flag;
		}
	}

	// Other entities
	for (e = pr_nqprogs ? 1 : MAX_CLIENTS + 1; e < sv.num_edicts; e++)
	{
		edict_t* ent = EDICT_NUM (e);

		if (SV_EntityVisibleToClient(client, e, pvs)) {
			((eval_t *)((byte *)(ent)->v + fofs_visibility))->_int |= client_flag;
		}
		else {
			((eval_t *)((byte *)(ent)->v + fofs_visibility))->_int &= ~client_flag;
		}
	}
}

qbool SV_SkipCommsBotMessage(client_t* client)
{
	extern cvar_t sv_serveme_fix;

	return sv_serveme_fix.value && client->spectator && !strcmp(client->name, "[ServeMe]");
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_init.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

#ifndef CLIENTONLY
#include "qwsvdef.h"

#ifndef SERVERONLY
void CL_ClearState(void);
void CL_ClearQueuedPackets(void);
#endif

server_static_t	svs;				// persistent server info
server_t		sv;					// local server
demo_t			demo;				// server demo struct

char	localmodels[MAX_MODELS][MODEL_NAME_LEN];	// inline model names for precache

//char localinfo[MAX_LOCALINFO_STRING+1]; // local game info
ctxinfo_t _localinfo_;

int fofs_items2;
int fofs_maxspeed, fofs_gravity;
int fofs_movement;
int fofs_vw_index;
int fofs_hideentity;
int fofs_trackent;
int fofs_visibility;
int fofs_hide_players;
int fofs_teleported;

/*
================
SV_ModelIndex

================
*/
int SV_ModelIndex (char *name)
{
	int i;

	if (!name || !name[0])
		return 0;

	for (i=0 ; i<MAX_MODELS && sv.model_precache[i] ; i++)
		if (!strcmp(sv.model_precache[i], name))
			return i;
	if (i==MAX_MODELS || !sv.model_precache[i])
		SV_Error ("SV_ModelIndex: model %s not precached", name);
	return i;
}

/*
================
SV_FlushSignon

Moves to the next signon buffer if needed
================
*/
void SV_FlushSignon (void)
{
	if (sv.signon.cursize < sv.signon.maxsize - 512)
		return;

	if (sv.num_signon_buffers == MAX_SIGNON_BUFFERS-1)
		SV_Error ("sv.num_signon_buffers == MAX_SIGNON_BUFFERS-1");

	sv.signon_buffer_size[sv.num_signon_buffers-1] = sv.signon.cursize;
	sv.signon.data = sv.signon_buffers[sv.num_signon_buffers];
	sv.num_signon_buffers++;
	sv.signon.cursize = 0;
}

/*
================
SV_CreateBaseline

Entity baselines are used to compress the update messages
to the clients -- only the fields that differ from the
baseline will be transmitted
================
*/
static void SV_CreateBaseline (void)
{
	edict_t  *svent;
	int      entnum;

	for (entnum = 0; entnum < sv.num_edicts ; entnum++)
	{
		svent = EDICT_NUM(entnum);
		if (svent->e.free)
			continue;
		// create baselines for all player slots,
		// and any other edict that has a visible model
		if (entnum > MAX_CLIENTS && !svent->v->modelindex)
			continue;

		//
		// create entity baseline
		//
		svent->e.baseline.number = entnum;
		VectorCopy (svent->v->origin, svent->e.baseline.origin);
		VectorCopy (svent->v->angles, svent->e.baseline.angles);
		svent->e.baseline.frame = svent->v->frame;
		svent->e.baseline.skinnum = svent->v->skin;
		if (entnum > 0 && entnum <= MAX_CLIENTS)
		{
			svent->e.baseline.colormap = entnum;
			svent->e.baseline.modelindex = SV_ModelIndex("progs/player.mdl");
		}
		else
		{
			svent->e.baseline.colormap = 0;
			svent->e.baseline.modelindex = svent->v->modelindex;
		}

#ifdef FTE_PEXT_TRANS
		svent->e.baseline.trans = svent->xv.alpha >= 1.0f ? 0 : bound(0, (byte)(svent->xv.alpha * 254.0), 254);
#endif
#ifdef FTE_PEXT_COLOURMOD
		svent->e.baseline.colourmod[0] = bound(0, svent->xv.colourmod[0] * (256.0f / 8.0f), 255);
		svent->e.baseline.colourmod[1] = bound(0, svent->xv.colourmod[1] * (256.0f / 8.0f), 255);
		svent->e.baseline.colourmod[2] = bound(0, svent->xv.colourmod[2] * (256.0f / 8.0f), 255);
#endif

	}
	sv.num_baseline_edicts = sv.num_edicts;
}

/*
================
SV_SaveSpawnparms

Grabs the current state of the progs serverinfo flags 
and each client for saving across the
transition to another level
================
*/
static void SV_SaveSpawnparms (void)
{
	int i, j;

	if (!sv.state)
		return;		// no progs loaded yet

	// serverflags is the only game related thing maintained
	svs.serverflags = PR_GLOBAL(serverflags);

	for (i=0, sv_client = svs.clients ; i<MAX_CLIENTS ; i++, sv_client++)
	{
		if (sv_client->state != cs_spawned)
			continue;

		// needs to reconnect
		sv_client->state = cs_connected;

		// call the progs to get default spawn parms for the new client
		pr_global_struct->self = EDICT_TO_PROG(sv_client->edict);
		PR_GameSetChangeParms();
		for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
			sv_client->spawn_parms[j] = (&PR_GLOBAL(parm1))[j];
	}
}

static unsigned SV_CheckModel(char *mdl)
{
	unsigned char *buf;
	unsigned short crc;
	int filesize;
	int mark;

	mark = Hunk_LowMark ();
	buf = (byte *) FS_LoadHunkFile (mdl, &filesize);
	if (!buf)
	{
		if (!strcmp (mdl, "progs/player.mdl"))
			return 33168;
		else if (!strcmp (mdl, "progs/newplayer.mdl"))
			return 62211;
		else if (!strcmp (mdl, "progs/eyes.mdl"))
			return 6967;
		else
			SV_Error ("SV_CheckModel: could not load %s\n", mdl);
	}

	crc = CRC_Block (buf, filesize);
	Hunk_FreeToLowMark (mark);

	return crc;
}

/*
================
SV_SpawnServer

Change the server to a new map, taking all connected
clients along with it.

This is called from the SV_Map_f() function, and when loading .sav files
================
*/
void SV_SpawnServer(char *mapname, qbool devmap, char* entityfile, qbool loading_savegame)
{
	extern func_t ED_FindFunctionOffset (char *name);

	edict_t *ent;
	int i;
	int skill_level = current_skill;

	extern cvar_t sv_loadentfiles, sv_loadentfiles_dir;
	char *entitystring;
	char oldmap[MAP_NAME_LEN];
	extern qbool	sv_allow_cheats;
	extern cvar_t	sv_cheats, sv_paused, sv_bigcoords;

	sv_error = false;

	// store old map name
	snprintf (oldmap, MAP_NAME_LEN, "%s", sv.mapname);

	Con_DPrintf ("SpawnServer: %s\n",mapname);

#ifndef SERVERONLY
	// As client+server we do it here.
	// As serveronly we do it in NET_Init().
	NET_InitServer();
#endif

	SV_SaveSpawnparms ();
	SV_LoadAccounts();

#ifdef USE_PR2
	// remove bot clients
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		if( sv_vm && svs.clients[i].isBot )
		{
			svs.clients[i].old_frags = 0;
			svs.clients[i].edict->v->frags = 0.0;
			svs.clients[i].name[0] = 0;
			svs.clients[i].state = cs_free;
			Info_RemoveAll(&svs.clients[i]._userinfo_ctx_);
			Info_RemoveAll(&svs.clients[i]._userinfoshort_ctx_);
			SV_FullClientUpdate(&svs.clients[i], &sv.reliable_datagram);
			svs.clients[i].isBot = 0;
		}
	}
#endif

	// Shutdown game.
	PR_GameShutDown();
	PR_UnLoadProgs();

	svs.spawncount++; // any partially connected client will be restarted

#ifndef SERVERONLY
	com_serveractive = false;
#endif
	sv.state = ss_dead;
	sv.paused = false;
	Cvar_SetROM(&sv_paused, "0");

	Host_ClearMemory();

#ifndef SERVERONLY
	if (!oldmap[0]) {
		Cbuf_InsertTextEx(&cbuf_server, "exec server.cfg\n");
		Cbuf_ExecuteEx(&cbuf_server);
	}
#endif

	if (loading_savegame) {
		Cvar_SetValue(&skill, skill_level);
		Cvar_SetValue(&deathmatch, 0);
		Cvar_SetValue(&coop, 0);
		Cvar_SetValue(&teamplay, 0);
		Cvar_SetValue(&maxclients, 1);
		Cvar_Set(&sv_progsname, "spprogs"); // force progsname
#ifdef USE_PR2
		Cvar_SetValue(&sv_progtype, 0); // force .dat
#endif
	}

#ifdef FTE_PEXT_FLOATCOORDS
	if (sv_bigcoords.value)
	{
		msg_coordsize = 4;
		msg_anglesize = 2;
	}
	else
	{
		msg_coordsize = 2;
		msg_anglesize = 1;
	}
#endif

	if ((int)coop.value)
		Cvar_Set (&deathmatch, "0");
	current_skill = (int) (skill.value + 0.5);
	if (current_skill < 0)
		current_skill = 0;
	Cvar_Set (&skill, va("%d", current_skill));
	if (current_skill > 3)
		current_skill = 3;

	if ((sv_cheats.value || devmap) && !sv_allow_cheats) {
		sv_allow_cheats = true;
		Info_SetValueForStarKey (svs.info, "*cheats", "ON", MAX_SERVERINFO_STRING);
	}
	else if ((!sv_cheats.value && !devmap) && sv_allow_cheats) {
		sv_allow_cheats = false;
		Info_SetValueForStarKey (svs.info, "*cheats", "", MAX_SERVERINFO_STRING);
	}


	// wipe the entire per-level structure
	// NOTE: this also set sv.mvdrecording to false, so calling SV_MVD_Record() at end of function
	memset (&sv, 0, sizeof(sv));
	sv.max_edicts = MAX_EDICTS_SAFE;

	sv.datagram.maxsize = sizeof(sv.datagram_buf);
	sv.datagram.data = sv.datagram_buf;
	sv.datagram.allowoverflow = true;

	sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
	sv.reliable_datagram.data = sv.reliable_datagram_buf;

	sv.multicast.maxsize = sizeof(sv.multicast_buf);
	sv.multicast.data = sv.multicast_buf;

	sv.signon.maxsize = sizeof(sv.signon_buffers[0]);
	sv.signon.data = sv.signon_buffers[0];
	sv.num_signon_buffers = 1;

	sv.time = 1.0;

	// load progs to get entity field count
	// which determines how big each edict is
	// and allocate edicts
	PR_LoadProgs ();
#ifdef WITH_NQPROGS
	PR_InitPatchTables();
#endif
	PR_InitProg();

	for (i = 0; i < sv.max_edicts; i++)
	{
		sv.edicts[i].v = (entvars_t *)((byte *)sv.game_edicts + i * pr_edict_size);
		sv.edicts[i].e.entnum = i;
		sv.edicts[i].e.area.ed = &sv.edicts[i]; // yeah, pretty funny, but this help to find which edict_t own this area (link_t)
		PR_ClearEdict(&sv.edicts[i]);
	}

	fofs_items2 = ED_FindFieldOffset ("items2"); // ZQ_ITEMS2 extension
	fofs_maxspeed = ED_FindFieldOffset ("maxspeed");
	fofs_gravity = ED_FindFieldOffset ("gravity");
	fofs_movement = ED_FindFieldOffset ("movement");
	fofs_vw_index = ED_FindFieldOffset ("vw_index");
	fofs_hideentity = ED_FindFieldOffset ("hideentity");
	fofs_trackent = ED_FindFieldOffset ("trackent");
	fofs_visibility = ED_FindFieldOffset ("visclients");
	fofs_hide_players = ED_FindFieldOffset ("hideplayers");
	fofs_teleported = ED_FindFieldOffset ("teleported");

#ifdef MVD_PEXT1_HIGHLAGTELEPORT
	if (fofs_teleported) {
		svs.mvdprotocolextension1 |= MVD_PEXT1_HIGHLAGTELEPORT;
	}
	else {
		svs.mvdprotocolextension1 &= ~MVD_PEXT1_HIGHLAGTELEPORT;
	}
#endif
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	{
		extern cvar_t sv_pext_mvdsv_serversideweapon;

		// Cheap 'ktx' detection
		if (sv_pext_mvdsv_serversideweapon.value && strstr(Cvar_String("qwm_name"), "KTX")) {
			svs.mvdprotocolextension1 |= MVD_PEXT1_SERVERSIDEWEAPON;
#ifdef MVD_PEXT1_SERVERSIDEWEAPON2
			svs.mvdprotocolextension1 |= MVD_PEXT1_SERVERSIDEWEAPON2;
#endif
		}
		else {
			svs.mvdprotocolextension1 &= ~MVD_PEXT1_SERVERSIDEWEAPON;
#ifdef MVD_PEXT1_SERVERSIDEWEAPON2
			svs.mvdprotocolextension1 &= ~MVD_PEXT1_SERVERSIDEWEAPON2;
#endif
		}

	}
#endif
#ifdef MVD_PEXT1_DEBUG_ANTILAG
	{
		extern cvar_t sv_debug_antilag;

		if (sv_debug_antilag.value) {
			svs.mvdprotocolextension1 |= MVD_PEXT1_DEBUG_ANTILAG;
		}
		else {
			svs.mvdprotocolextension1 &= ~MVD_PEXT1_DEBUG_ANTILAG;
		}
	}
#endif
#ifdef MVD_PEXT1_DEBUG_WEAPON
	{
		extern cvar_t sv_debug_weapons;

		if (sv_debug_weapons.value) {
			svs.mvdprotocolextension1 |= MVD_PEXT1_DEBUG_WEAPON;
		}
		else {
			svs.mvdprotocolextension1 &= ~MVD_PEXT1_DEBUG_WEAPON;
		}
	}
#endif

	// find optional QC-exported functions.
	// we have it here, so we set it to NULL in case of PR2 progs.
	mod_SpectatorConnect = ED_FindFunctionOffset ("SpectatorConnect");
	mod_SpectatorThink = ED_FindFunctionOffset ("SpectatorThink");
	mod_SpectatorDisconnect = ED_FindFunctionOffset ("SpectatorDisconnect");
	mod_ChatMessage = ED_FindFunctionOffset ("ChatMessage");
	mod_UserInfo_Changed = ED_FindFunctionOffset ("UserInfo_Changed");
	mod_ConsoleCmd = ED_FindFunctionOffset ("ConsoleCmd");
	mod_UserCmd = ED_FindFunctionOffset ("UserCmd");
	mod_localinfoChanged = ED_FindFunctionOffset ("localinfoChanged");
	GE_ClientCommand = ED_FindFunctionOffset ("GE_ClientCommand");
	GE_PausedTic = ED_FindFunctionOffset ("GE_PausedTic");
	GE_ShouldPause = ED_FindFunctionOffset ("GE_ShouldPause");

	// leave slots at start for clients only
	sv.num_edicts = MAX_CLIENTS+1;
	for (i=0 ; i<MAX_CLIENTS ; i++)
	{
		ent = EDICT_NUM(i+1);
		// restore client name.
		PR_SetEntityString(ent, ent->v->netname, svs.clients[i].name);
		// reserve edict.
		svs.clients[i].edict = ent;
		//ZOID - make sure we update frags right
		svs.clients[i].old_frags = 0;
	}

	// fill sv.mapname and sv.modelname with new map name
	strlcpy (sv.mapname, mapname, sizeof(sv.mapname));
	snprintf (sv.modelname, sizeof(sv.modelname), "maps/%s.bsp", sv.mapname);
#ifndef SERVERONLY
	// set cvar
	Cvar_ForceSet (&host_mapname, mapname);
#endif

	if (!(sv.worldmodel = CM_LoadMap (sv.modelname, false, &sv.map_checksum, &sv.map_checksum2))) // true if bad map
	{
		Con_Printf ("Cant load map %s, falling back to %s\n", mapname, oldmap);

		// fill mapname, sv.mapname and sv.modelname with old map name
		strlcpy (sv.mapname, oldmap, sizeof(sv.mapname)); 
		snprintf (sv.modelname, sizeof(sv.modelname), "maps/%s.bsp", sv.mapname);
		mapname = oldmap;

		// and re-load old map
		sv.worldmodel = CM_LoadMap (sv.modelname, false, &sv.map_checksum, &sv.map_checksum2);

		// this should never happen
		if (!sv.worldmodel)
			SV_Error ("CM_LoadMap: bad map");
	}

	{
		extern cvar_t sv_extlimits, sv_bspversion;

		if (sv_extlimits.value == 0 || (sv_extlimits.value == 2 && sv_bspversion.value < 2)) {
			sv.max_edicts = min(sv.max_edicts, MAX_EDICTS_SAFE);
		}
	}

	sv.map_checksum2 = Com_TranslateMapChecksum (sv.mapname, sv.map_checksum2);
	sv.static_entity_count = 0;

	SV_ClearWorld (); // clear physics interaction links

#ifdef USE_PR2
	if ( sv_vm )
	{
		sv.sound_precache[0] = "";
		sv.model_precache[0] = "";
	}
	else
#endif
	{
		sv.sound_precache[0] = pr_strings;
		sv.model_precache[0] = pr_strings;
	}
	sv.model_precache[1] = sv.modelname;
	sv.models[1] = sv.worldmodel;
	for (i = 1; i < CM_NumInlineModels(); i++)
	{
		sv.model_precache[1+i] = localmodels[i];
		sv.models[i+1] =  CM_InlineModel (localmodels[i]);
	}

	//check player/eyes models for hacks
	sv.model_player_checksum = SV_CheckModel("progs/player.mdl");
	sv.model_newplayer_checksum = SV_CheckModel("progs/newplayer.mdl");
	sv.eyes_player_checksum = SV_CheckModel("progs/eyes.mdl");

	//
	// spawn the rest of the entities on the map
	//

	// precache and static commands can be issued during
	// map initialization
	sv.state = ss_loading;
#ifndef SERVERONLY
	com_serveractive = true;
#endif

	ent = EDICT_NUM(0);
	ent->e.free = false;
	PR_SetEntityString(ent, ent->v->model, sv.modelname);
	ent->v->modelindex = 1;		// world model
	ent->v->solid = SOLID_BSP;
	ent->v->movetype = MOVETYPE_PUSH;

	// information about the server
	PR_SetEntityString(ent, ent->v->netname, VersionStringFull());
	PR_SetEntityString(ent, ent->v->targetname, SERVER_NAME);
	ent->v->impulse = VERSION_NUM;
	ent->v->items = pr_numbuiltins - 1;

	PR_SetGlobalString(PR_GLOBAL(mapname), sv.mapname);
	// serverflags are for cross level information (sigils)
	PR_GLOBAL(serverflags) = svs.serverflags;
	if (pr_nqprogs)
	{
		pr_globals[35] = deathmatch.value;
		pr_globals[36] = coop.value;
		pr_globals[37] = teamplay.value;
		NQP_Reset ();
	}

	if (pr_nqprogs)
	{
		// register the cvars that NetQuake provides for mod use
		const char **var, *nqcvars[] = {"gamecfg", "scratch1", "scratch2", "scratch3", "scratch4",
			"saved1", "saved2", "saved3", "saved4", "savedgamecfg", "temp1", NULL};
		for (var = nqcvars; *var; var++)
			Cvar_Create((char *)/*stupid const warning*/ *var, "0", 0);
	}

	// run the frame start qc function to let progs check cvars
	if (!pr_nqprogs)
		SV_ProgStartFrame (false);

	// ********* External Entity support (.ent file(s) in gamedir/maps) pinched from ZQuake *********
	// load and spawn all other entities
	entitystring = NULL;
	if ((int)sv_loadentfiles.value)
	{
		char ent_path[1024] = {0};

		if (!entityfile || !entityfile[0])
			entityfile = sv.mapname;

		// first try maps/sv_loadentfiles_dir/
		if (sv_loadentfiles_dir.string[0])
		{
			snprintf(ent_path, sizeof(ent_path), "maps/%s/%s.ent", sv_loadentfiles_dir.string, entityfile);
			entitystring = (char *) FS_LoadHunkFile(ent_path, NULL);
		}

		// try maps/ if not loaded yet.
		if (!entitystring)
		{
			snprintf(ent_path, sizeof(ent_path), "maps/%s.ent", entityfile);
			entitystring = (char *) FS_LoadHunkFile(ent_path, NULL);
		}

		if (entitystring) {
			Con_DPrintf ("Using entfile %s\n", ent_path);
		}
	}

	if (!entitystring) {
		entitystring = CM_EntityString();
	}

	PR_LoadEnts(entitystring);
	// ********* End of External Entity support code *********

	// look up some model indexes for specialized message compression
	SV_FindModelNumbers ();

	// all spawning is completed, any further precache statements
	// or prog writes to the signon message are errors
	sv.state = ss_active;

	// run two frames to allow everything to settle
	SV_Physics ();
	sv.time += 0.1;
	SV_Physics ();
	sv.time += 0.1;
	sv.old_time = sv.time;

	// save movement vars
	SV_SetMoveVars();

	// create a baseline for more efficient communications
	SV_CreateBaseline ();
	sv.signon_buffer_size[sv.num_signon_buffers-1] = sv.signon.cursize;

	Info_SetValueForKey (svs.info, "map", sv.mapname, MAX_SERVERINFO_STRING);

	// calltimeofday.
	{
		extern void PF_calltimeofday (void);
		pr_global_struct->time = sv.time;
		pr_global_struct->self = 0;

		PF_calltimeofday();
	}

	Con_DPrintf ("Server spawned.\n");

	// we change map - clear whole demo struct and sent initial state to all dest if any (for QTV only I thought)
	SV_MVD_Record(NULL, true);

#ifndef SERVERONLY
	CL_ClearState();
	CL_ClearQueuedPackets();
#endif
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_log.h
================================================
/*
Copyright (C) 2004 VVD (vvd0@sorceforge.net).

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef __LOG_H__
#define __LOG_H__

enum {	MIN_LOG = 0, CONSOLE_LOG = 0, ERROR_LOG,  RCON_LOG,
		TELNET_LOG,  FRAG_LOG,        PLAYER_LOG, MOD_FRAG_LOG, MAX_LOG};

typedef struct log_s {
	FILE		*sv_logfile;
	char		*command;
	char		*file_name;
	char		*message_off;
	char		*message_on;
	xcommand_t	function;
	int			log_level;
} log_t;

extern	log_t	logs[MAX_LOG];
extern	cvar_t	frag_log_type;
extern	cvar_t	telnet_log_level;

//bliP: logging
void	SV_Logfile (int sv_log, qbool newlog);
void	SV_LogPlayer(client_t *cl, char *msg, int level);
//<-
void	SV_Write_Log(int sv_log, int level, char *msg);

#endif /* !__LOG_H__ */


================================================
FILE: src/sv_login.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


*/

#ifndef CLIENTONLY
#include "qwsvdef.h"

#ifdef WEBSITE_LOGIN_SUPPORT
#undef WEBSITE_LOGIN_SUPPORT
#endif
#if defined(SERVERONLY) && defined(WWW_INTEGRATION)
#define WEBSITE_LOGIN_SUPPORT
#include "central.h"
#endif

#define MAX_ACCOUNTS 1000
#define MAX_FAILURES 10
#define MAX_LOGINNAME (DIGEST_SIZE * 2 + 1)
#define ACC_FILE "accounts"
#define ACC_DIR "users"

cvar_t sv_login = { "sv_login", "0" };	// if enabled, login required
#ifdef WEBSITE_LOGIN_SUPPORT
cvar_t sv_login_web = { "sv_login_web", "1" }; // 0=local files, 1=auth via website (bans can be in local files), 2=mandatory auth (must have account in local files)
#define LoginModeFileBased() ((int)sv_login_web.value == 0)
#define LoginModeOptionalWeb() ((int)sv_login_web.value == 1)
#define LoginModeMandatoryWeb() ((int)sv_login_web.value == 2)
#define LoginMustHaveLocalAccount() (LoginModeMandatoryWeb() || LoginModeFileBased())
#define WebLoginsEnabled() (!LoginModeFileBased())
#else
#define LoginModeFileBased() (1)
#define LoginModeOptionalWeb() (0)
#define LoginModeMandatoryWeb() (0)
#define LoginMustHaveLocalAccount() (1)
#define WebLoginsEnabled() (0)
#endif

extern cvar_t sv_hashpasswords;
static void SV_SuccessfulLogin(client_t* cl);
static void SV_BlockedLogin(client_t* cl);
static void SV_ForceClientName(client_t* cl, const char* forced_name);

typedef enum { a_free, a_ok, a_blocked } acc_state_t;
typedef enum { use_log, use_ip } quse_t;

typedef struct
{
	char        login[MAX_LOGINNAME];
	char        pass[MAX_LOGINNAME];
	int         failures;
	int         inuse;
	ipfilter_t  address;
	acc_state_t state;
	quse_t      use;
} account_t;

static account_t accounts[MAX_ACCOUNTS];
static int       num_accounts = 0;

static qbool validAcc(char* acc)
{
	char* s = acc;

	for (; *acc; acc++)
	{
		if (*acc < 'a' || *acc > 'z')
			if (*acc < 'A' || *acc > 'Z')
				if (*acc < '0' || *acc > '9')
					if (*acc != '.' && *acc != '_')
						return false;
	}

	return acc - s <= MAX_LOGINNAME && acc - s >= 3;
}

/*
=================
WriteAccounts

Writes account list to disk
=================
*/

static void WriteAccounts(void)
{
	int c;
	FILE* f;
	account_t* acc;

	//Sys_mkdir(ACC_DIR);
	if ((f = fopen(va("%s/" ACC_FILE, fs_gamedir), "wt")) == NULL)
	{
		Con_Printf("Warning: couldn't open for writing " ACC_FILE "\n");
		return;
	}

	for (acc = accounts, c = 0; c < num_accounts; acc++)
	{
		if (acc->state == a_free)
			continue;

		if (acc->use == use_log)
			fprintf(f, "%s %s %d %d\n", acc->login, acc->pass, acc->state, acc->failures);
		else
			fprintf(f, "%s %s %d\n", acc->login, acc->pass, acc->state);

		c++;
	}

	fclose(f);

	// force cache rebuild.
	FS_FlushFSHash();
}

/*
=================
SV_LoadAccounts

loads account list from disk
=================
*/
qbool StringToFilter(char* s, ipfilter_t* f);
void SV_LoadAccounts(void)
{
	int i;
	FILE* f;
	account_t* acc = accounts;
	client_t* cl;

	if ((f = fopen(va("%s/" ACC_FILE, fs_gamedir), "rt")) == NULL)
	{
		Con_DPrintf("couldn't open " ACC_FILE "\n");
		// logout
		num_accounts = 0;
		for (cl = svs.clients; cl - svs.clients < MAX_CLIENTS; cl++)
		{
			if (cl->logged > 0) {
				cl->logged = 0;
			}
			if (!cl->logged_in_via_web) {
				cl->login[0] = 0;
			}
		}
		return;
	}

	while (!feof(f))
	{
		memset(acc, 0, sizeof(account_t));
		// Is realy safe to use 'fscanf(f, "%s", s)'? FIXME!
		if (fscanf(f, "%s", acc->login) != 1) {
			Con_Printf("Error reading account data\n");
			break;
		}
		if (StringToFilter(acc->login, &acc->address))
		{
			strlcpy(acc->pass, acc->login, MAX_LOGINNAME);
			acc->use = use_ip;
			if (fscanf(f, "%s %d\n", acc->pass, (int*)&acc->state) != 2) {
				Con_Printf("Error reading account data\n");
				break;
			}
		}
		else {
			if (fscanf(f, "%s %d %d\n", acc->pass, (int*)&acc->state, &acc->failures) != 3) {
				Con_Printf("Error reading account data\n");
				break;
			}
		}

		if (acc->state != a_free) // lol?
			acc++;
	}

	num_accounts = acc - accounts;

	fclose(f);

	// for every connected client check if their login is still valid
	for (cl = svs.clients; cl - svs.clients < MAX_CLIENTS; cl++)
	{
		if (cl->state < cs_connected)
			continue;

		if (cl->logged <= 0)
			continue;

		if (cl->logged_in_via_web)
			continue;

		for (i = 0, acc = accounts; i < num_accounts; i++, acc++)
			if ((acc->use == use_log && !strncmp(acc->login, cl->login, CLIENT_LOGIN_LEN))
				|| (acc->use == use_ip && !strcmp(acc->login, va("%d.%d.%d.%d", cl->realip.ip[0], cl->realip.ip[1], cl->realip.ip[2], cl->realip.ip[3]))))
				break;

		if (i < num_accounts && acc->state == a_ok)
		{
			// login again if possible
			if (!acc->inuse || acc->use == use_ip)
			{
				cl->logged = i + 1;
				if (acc->use == use_ip)
					strlcpy(cl->login, acc->pass, CLIENT_LOGIN_LEN);

				acc->inuse++;
				continue;
			}
		}
		// login is not valid anymore, logout
		cl->logged = 0;
		cl->login[0] = 0;
	}
}

/*
=================
SV_CreateAccount_f

acc_create <login> [<password>]
if password is not given, login will be used for password
login/pass has to be max 16 chars and at least 3, only regular chars are acceptable
=================
*/
void SV_CreateAccount_f(void)
{
	int i, spot, c;
	ipfilter_t adr;
	quse_t use;

	if (Cmd_Argc() < 2)
	{
		Con_Printf("usage: acc_create <login> [<password>]\n       acc_create <address> <username>\nmaximum %d characters for login/pass\n", MAX_LOGINNAME - 1); //bliP: address typo
		return;
	}

	if (num_accounts == MAX_ACCOUNTS)
	{
		Con_Printf("MAX_ACCOUNTS reached\n");
		return;
	}

	if (StringToFilter(Cmd_Argv(1), &adr))
	{
		use = use_ip;
		if (Cmd_Argc() < 3)
		{
			Con_Printf("usage: acc_create <address> <username>\nmaximum %d characters for username\n", MAX_LOGINNAME - 1); //bliP; address typo
			return;
		}
	}
	else
	{
		use = use_log;

		// validate user login/pass
		if (!validAcc(Cmd_Argv(1)))
		{
			Con_Printf("Invalid login!\n");
			return;
		}

		if (Cmd_Argc() == 4 && !validAcc(Cmd_Argv(2)))
		{
			Con_Printf("Invalid pass!\n");
			return;
		}
	}

	// find free spot, check if login exist;
	for (i = 0, c = 0, spot = -1; c < num_accounts; i++)
	{
		if (accounts[i].state == a_free)
		{
			if (spot == -1)	spot = i;
			continue;
		}

		if (!strcasecmp(accounts[i].login, Cmd_Argv(1)) ||
			(use == use_ip && !strcasecmp(accounts[i].login, Cmd_Argv(2))))
			break;

		c++;
	}

	if (c < num_accounts)
	{
		Con_Printf("Login already in use\n");
		return;
	}

	if (spot == -1)
		spot = i;

	// create an account
	num_accounts++;
	strlcpy(accounts[spot].login, Cmd_Argv(1), MAX_LOGINNAME);
	if (Cmd_Argc() == 3)
		i = 2;
	else
		i = 1;
	strlcpy(accounts[spot].pass, (int)sv_hashpasswords.value && use == use_log ?
		SHA1(Cmd_Argv(i)) : Cmd_Argv(i), MAX_LOGINNAME);

	accounts[spot].state = a_ok;
	accounts[spot].use = use;

	Con_Printf("login %s created\n", Cmd_Argv(1));
	WriteAccounts();
}

/*
=================
SV_RemoveAccount_f

acc_remove <login>
removes the login
=================
*/
void SV_RemoveAccount_f(void)
{
	int i, c, j;

	if (Cmd_Argc() < 2)
	{
		Con_Printf("usage: acc_remove <login>\n");
		return;
	}

	for (i = 0, c = 0; c < num_accounts; i++)
	{
		if (accounts[i].state == a_free)
			continue;

		if (!strcasecmp(accounts[i].login, Cmd_Argv(1))) {
			// Logout anyone using this login
			if ((int)sv_login.value == 1) {
				// Mandatory web logins, or using local files
				if (LoginMustHaveLocalAccount()) {
					for (j = 0; j < MAX_CLIENTS; ++j) {
						client_t* cl = &svs.clients[j];

						if (!strcasecmp(cl->login, Cmd_Argv(1))) {
							SV_Logout(cl);
							SV_DropClient(cl);
						}
					}
				}
			}

			// Update 'logged' pointers back to accounts list
			if (i != num_accounts - 1) {
				memcpy(&accounts[i], &accounts[num_accounts - 1], sizeof(accounts[i]));
				memset(&accounts[num_accounts - 1], 0, sizeof(accounts[num_accounts - 1]));

				// Update references from the last account which we just moved
				for (j = 0; j < MAX_CLIENTS; ++j) {
					client_t* cl = &svs.clients[j];
					if (cl->logged == num_accounts) {
						cl->logged = i + 1;
					}
				}
			}

			num_accounts--;
			Con_Printf("login %s removed\n", Cmd_Argv(1));
			WriteAccounts();
			return;
		}

		c++;
	}

	Con_Printf("account for %s not found\n", Cmd_Argv(1));
}

/*
=================
SV_ListAccount_f

shows the list of accounts
=================
*/
void SV_ListAccount_f(void)
{
	int i, c;

	if (!num_accounts)
	{
		Con_Printf("account list is empty\n");
		return;
	}

	Con_Printf("account list:\n");

	for (i = 0, c = 0; c < num_accounts; i++)
	{
		if (accounts[i].state != a_free)
		{
			Con_Printf("%.16s %s\n", accounts[i].login, accounts[i].state == a_ok ? "" : "blocked");
			c++;
		}
	}

	Con_Printf("%d login(s) found\n", num_accounts);
}

/*
=================
SV_blockAccount

blocks/unblocks an account
=================
*/
void SV_blockAccount(qbool block)
{
	int i, j;

	for (i = 0; i < num_accounts; i++)
	{
		if (accounts[i].state == a_free)
			continue;

		if (!strcasecmp(accounts[i].login, Cmd_Argv(1)))
		{
			if (block) {
				accounts[i].state = a_blocked;
				Con_Printf("account %s blocked\n", Cmd_Argv(1));

				for (j = 0; j < MAX_CLIENTS; ++j) {
					if (!strcasecmp(svs.clients[j].login, accounts[i].login)) {
						SV_DropClient(&svs.clients[j]);
						break;
					}
				}
				return;
			}

			if (accounts[i].state != a_blocked) {
				Con_Printf("account %s not blocked\n", Cmd_Argv(1));
			}
			else {
				accounts[i].state = a_ok;
				accounts[i].failures = 0;
				Con_Printf("account %s unblocked\n", Cmd_Argv(1));
			}

			return;
		}
	}

	Con_Printf("account %s not found\n", Cmd_Argv(1));
}

void SV_UnblockAccount_f(void)
{
	if (Cmd_Argc() < 2)
	{
		Con_Printf("usage: acc_unblock <login>\n");
		return;
	}

	SV_blockAccount(false);
	WriteAccounts();
}

void SV_BlockAccount_f(void)
{
	if (Cmd_Argc() < 2)
	{
		Con_Printf("usage: acc_block <login>\n");
		return;
	}

	SV_blockAccount(true);
	WriteAccounts();
}


/*
=================
checklogin

returns positive value if login/pass are valid
values <= 0 indicates a failure
=================
*/
static int checklogin(char* log1, char* pass, quse_t use)
{
	int i, c;

	for (i = 0, c = 0; c < num_accounts; i++)
	{
		if (accounts[i].state == a_free)
			continue;

		if (use == accounts[i].use &&
			/*use == use_log && accounts[i].use == use_log && */
			!strcasecmp(log1, accounts[i].login))
		{
			if (accounts[i].state == a_blocked)
				return -2;

			// Only do logins/failures if using file-based login list
			if (LoginMustHaveLocalAccount()) {
				if (accounts[i].inuse && accounts[i].use == use_log) {
					return -1;
				}

				if (use == use_ip ||
					(!(int)sv_hashpasswords.value && !strcasecmp(pass,       accounts[i].pass)) ||
					( (int)sv_hashpasswords.value && !strcasecmp(SHA1(pass), accounts[i].pass)))
				{
					accounts[i].failures = 0;
					accounts[i].inuse++;
					return i + 1;
				}

				if (++accounts[i].failures >= MAX_FAILURES) {
					Sys_Printf("account %s blocked after %d failed login attempts\n", accounts[i].login, accounts[i].failures);
					accounts[i].state = a_blocked;
				}
				WriteAccounts();
			}
			else {
				return i + 1;
			}

			return 0;
		}

		c++;
	}

	return 0;
}

void Login_Init(void)
{
	Cvar_Register(&sv_login);
#ifdef WEBSITE_LOGIN_SUPPORT
	Cvar_Register(&sv_login_web);
#endif

	Cmd_AddCommand("acc_create", SV_CreateAccount_f);
	Cmd_AddCommand("acc_remove", SV_RemoveAccount_f);
	Cmd_AddCommand("acc_list", SV_ListAccount_f);
	Cmd_AddCommand("acc_unblock", SV_UnblockAccount_f);
	Cmd_AddCommand("acc_block", SV_BlockAccount_f);

	// load account list
	//SV_LoadAccounts();
}

/*
===============
SV_Login

called on connect after cmd new is issued
===============
*/
qbool SV_Login(client_t* cl)
{
	extern cvar_t sv_registrationinfo;
	char* ip;

	// is sv_login is disabled, login is not necessery
	if (!(int)sv_login.value) {
		// If using local files then logout
		if (!cl->logged_in_via_web) {
			SV_Logout(cl);
			cl->logged = -1;
		}
		return true;
	}

	// if we're already logged return (probably map change)
	if (cl->logged > 0 || cl->logged_in_via_web) {
		return true;
	}

	// sv_login == 1 -> spectators don't login
	if ((int)sv_login.value == 1 && cl->spectator)
	{
		SV_Logout(cl);
		cl->logged = -1;
		return true;
	}

	// check for account for ip
	ip = va("%d.%d.%d.%d", cl->realip.ip[0], cl->realip.ip[1], cl->realip.ip[2], cl->realip.ip[3]);
	if ((cl->logged = checklogin(ip, ip, use_ip)) > 0)
	{
		strlcpy(cl->login, accounts[cl->logged - 1].pass, CLIENT_LOGIN_LEN);
		return true;
	}

	// need to login before connecting
	cl->logged = 0;
	cl->login[0] = 0;

	if (sv_registrationinfo.string[0])
		SV_ClientPrintf2(cl, PRINT_HIGH, "%s\n", sv_registrationinfo.string);

	if (WebLoginsEnabled()) {
		char buffer[128];
		strlcpy(buffer, "//authprompt\n", sizeof(buffer));

		ClientReliableWrite_Begin(cl, svc_stufftext, 2 + strlen(buffer));
		ClientReliableWrite_String(cl, buffer);

		SV_ClientPrintf2(cl, PRINT_HIGH, "Enter username:\n");
	}
	else {
		SV_ClientPrintf2(cl, PRINT_HIGH, "Enter login & password:\n");
	}

	return false;
}

void SV_Logout(client_t* cl)
{
	if (cl->logged > 0 && cl->logged <= sizeof(accounts) / sizeof(accounts[0])) {
		accounts[cl->logged - 1].inuse--;
	}

	Info_SetStar(&cl->_userinfo_ctx_, "*auth", "");
	Info_SetStar(&cl->_userinfo_ctx_, "*flag", "");
	ProcessUserInfoChange(cl, "*auth", cl->login);
	ProcessUserInfoChange(cl, "*flag", cl->login_flag);

	memset(cl->login, 0, sizeof(cl->login));
	memset(cl->login_alias, 0, sizeof(cl->login_alias));
	memset(cl->login_flag, 0, sizeof(cl->login_flag));
	memset(cl->login_challenge, 0, sizeof(cl->login_challenge));
	memset(cl->login_confirmation, 0, sizeof(cl->login_confirmation));
	cl->logged = 0;
	cl->logged_in_via_web = false;
}

#ifdef WEBSITE_LOGIN_SUPPORT
void SV_ParseWebLogin(client_t* cl)
{
	char parameter[128] = { 0 };
	char* p;

	strlcpy(parameter, Cmd_Argv(1), sizeof(parameter));
	for (p = parameter; *p > 32; ++p) {
	}
	*p = '\0';

	if (!parameter[0]) {
		return;
	}

	if (cl->login_challenge[0]) {
		// This is response to challenge, treat as password
		Central_VerifyChallengeResponse(cl, cl->login_challenge, parameter);

		SV_ClientPrintf2(cl, PRINT_HIGH, "Challenge received, please wait...\n");
	}
	else if (curtime - cl->login_request_time < LOGIN_MIN_RETRY_TIME) {
		SV_ClientPrintf2(cl, PRINT_HIGH, "Please wait and try again\n");
	}
	else {
		// Treat as username
		Central_GenerateChallenge(cl, parameter, true);

		SV_ClientPrintf2(cl, PRINT_HIGH, "Generating challenge, please wait...\n");
	}
}
#else
void SV_ParseWebLogin(client_t* cl)
{
}
#endif

void SV_ParseLogin(client_t* cl)
{
	char *log1, *pass;

	if (WebLoginsEnabled()) {
		SV_ParseWebLogin(cl);
		return;
	}

	if (Cmd_Argc() > 2)
	{
		log1 = Cmd_Argv(1);
		pass = Cmd_Argv(2);
	}
	else
	{
		// bah usually whole text in 'say' is put into ""
		log1 = pass = Cmd_Argv(1);
		while (*pass && *pass != ' ')
			pass++;

		if (*pass)
			*pass++ = 0;

		while (*pass == ' ')
			pass++;
	}

	// if login is parsed, we read just a password
	if (cl->login[0])
	{
		pass = log1;
		log1 = cl->login;
	}
	else
	{
		strlcpy(cl->login, log1, CLIENT_LOGIN_LEN);
	}

	if (!*pass)
	{
		strlcpy(cl->login, log1, CLIENT_LOGIN_LEN);
		SV_ClientPrintf2(cl, PRINT_HIGH, "Enter password for %s:\n", cl->login);

		return;
	}

	cl->logged = checklogin(log1, pass, use_log);

	switch (cl->logged)
	{
	case -2:
		SV_BlockedLogin(cl);
		break;
	case -1:
		SV_ClientPrintf2(cl, PRINT_HIGH, "Login in use!\ntry again:\n");
		cl->logged = 0;
		cl->login[0] = 0;
		break;
	case 0:
		SV_ClientPrintf2(cl, PRINT_HIGH, "Access denied\nPassword for %s:\n", cl->login);
		break;
	default:
		strlcpy(cl->login_alias, cl->login, sizeof(cl->login_alias));
		SV_SuccessfulLogin(cl);
		break;
	}
}

static void SV_BlockedLogin(client_t* cl)
{
	SV_ClientPrintf2(cl, PRINT_HIGH, "Login blocked\n");
	SV_DropClient(cl);
}

static void SV_SuccessfulLogin(client_t* cl)
{
	extern cvar_t sv_forcenick;

	if (!cl->spectator || !GameStarted()) {
		SV_BroadcastPrintf(PRINT_HIGH, "%s logged in as %s\n", cl->name, cl->login);
	}
	if (cl->state < cs_spawned) {
		SV_ClientPrintf2(cl, PRINT_HIGH, "Welcome %s\n", cl->login);
	}

	//VVD: forcenick ->
	if ((int)sv_forcenick.value)
	{
		const char* forced_name = cl->login_alias[0] ? cl->login_alias : cl->login;

		if (forced_name[0]) {
			SV_ForceClientName(cl, forced_name);
		}
	}
	//<-

	if (cl->state < cs_spawned) {
		MSG_WriteByte(&cl->netchan.message, svc_stufftext);
		MSG_WriteString(&cl->netchan.message, "cmd new\n");
	}
}

static void SV_ForceClientName(client_t* cl, const char* forced_name)
{
	char oldval[MAX_EXT_INFO_STRING];
	int i;

	// If any other clients are using this name, kick them
	for (i = 0; i < MAX_CLIENTS; ++i) {
		client_t* other = &svs.clients[i];

		if (!other->state)
			continue;
		if (other == cl) {
			continue;
		}

		if (!Q_namecmp(other->name, forced_name)) {
			SV_KickClient(other, " (using authenticated user's name)");
		}
	}

	// Set server-side name: allow colors/case changes
	if (!Q_namecmp(cl->name, forced_name)) {
		return;
	}
	strlcpy(oldval, cl->name, MAX_EXT_INFO_STRING);
	Info_Set(&cl->_userinfo_ctx_, "name", forced_name);
	ProcessUserInfoChange(cl, "name", oldval);

	// Change name cvar in client
	MSG_WriteByte(&cl->netchan.message, svc_stufftext);
	MSG_WriteString(&cl->netchan.message, va("name %s\n", forced_name));
}

void SV_LoginCheckTimeOut(client_t* cl)
{
	double connected = SV_ClientConnectedTime(cl);

	if (connected && connected > 60)
	{
		Sys_Printf("Login time out for %s\n", cl->name);

		SV_ClientPrintf2(cl, PRINT_HIGH, "Login timeout expired\n");
		SV_DropClient(cl);
	}
}

void SV_LoginWebCheck(client_t* cl)
{
	int status = checklogin(cl->login, cl->login, use_log);

	if (status < 0) {
		// Server admin explicitly blocked this account
		SV_BlockedLogin(cl);
	}
	else if (status == 0 && LoginMustHaveLocalAccount()) {
		// Server admin needs to create accounts for people to use
		SV_BlockedLogin(cl);
	}
	else {
		// Continue logging in
		SV_SuccessfulLogin(cl);
	}
}

void SV_LoginWebFailed(client_t* cl)
{
	memset(cl->login_challenge, 0, sizeof(cl->login_challenge));
	cl->login_request_time = 0;

	SV_ClientPrintf2(cl, PRINT_HIGH, "Challenge response failed.\n");
	if (cl->state < cs_spawned) {
		SV_BlockedLogin(cl);
	}
}

qbool SV_LoginRequired(client_t* cl)
{
	int login = (int)sv_login.value;

	if (login == 2 || (login == 1 && !cl->spectator)) {
		if (WebLoginsEnabled()) {
			return !cl->logged_in_via_web;
		}
		else {
			return !cl->logged;
		}
	}
	return false;
}

qbool SV_LoginBlockJoinRequest(client_t* cl)
{
	if (WebLoginsEnabled()) {
		if (!cl->logged_in_via_web && (int)sv_login.value) {
			SV_ClientPrintf(cl, PRINT_HIGH, "This server requires users to login.  Please authenticate first (/cmd login <username>).\n");
			return true;
		}
	}
	else if (cl->logged <= 0 && (int)sv_login.value) {
		SV_ClientPrintf(cl, PRINT_HIGH, "This server requires users to login.  Please disconnect and reconnect as a player.\n");
		return true;
	}

	// Allow
	return false;
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_main.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

#ifndef CLIENTONLY
#include "qwsvdef.h"

#ifdef SERVERONLY

qbool       host_initialized;
qbool       host_everything_loaded;	// true if OnChange() applied to every var, end of Host_Init()

double      curtime;			// not bounded or scaled, shared by local client and server.
double      realtime;			// affected by pause, you should not use it unless it something like physics and such.

static int  host_hunklevel;

#else

qbool       server_cfg_done = false;
double      realtime;			// affected by pause, you should not use it unless it something like physics and such.

#endif

int		current_skill;			// for entity spawnflags checking

client_t	*sv_client;			// current client

char		master_rcon_password[128] = "";	//bliP: password for remote server commands

cvar_t	sv_mintic = {"sv_mintic","0.013"};	// bound the size of the
cvar_t	sv_maxtic = {"sv_maxtic","0.1"};	// physics time tic
cvar_t	sv_maxfps = {"maxfps", "77", CVAR_SERVERINFO};  // It actually should be called maxpps (max packets per second).
														// It was serverinfo variable for quite long time, lets legolize it as cvar.
														// Sad part is what we can't call it like sv_maxfps since clients relay on its name 'maxfps' already.

void OnChange_sysselecttimeout_var (cvar_t *var, char *value, qbool *cancel);
cvar_t	sys_select_timeout = {"sys_select_timeout", "10000", 0, OnChange_sysselecttimeout_var}; // microseconds.

cvar_t	sys_restart_on_error = {"sys_restart_on_error", "0"};
cvar_t  sv_mod_extensions = { "sv_mod_extensions", "2", CVAR_ROM };

#ifdef SERVERONLY
cvar_t  sys_simulation = { "sys_simulation", "0" };
cvar_t	developer = {"developer", "0"};		// show extra messages
cvar_t	version = {"version", "", CVAR_ROM};
#endif

cvar_t	timeout = {"timeout", "65"};		// seconds without any message
cvar_t	zombietime = {"zombietime", "2"};	// seconds to sink messages
// after disconnect

#ifdef SERVERONLY
cvar_t	rcon_password = {"rcon_password", ""};	// password for remote server commands
cvar_t	password = {"password", ""};	// password for entering the game
#else
// client already have such variables.
extern cvar_t rcon_password;
extern cvar_t password;
#endif

cvar_t	sv_hashpasswords = {"sv_hashpasswords", "1"}; // 0 - plain passwords; 1 - hashed passwords
cvar_t	sv_crypt_rcon = {"sv_crypt_rcon", "1"}; // use SHA1 for encryption of rcon_password and using timestamps
// Time in seconds during which in rcon command this encryption is valid (change only with master_rcon_password).
cvar_t	sv_timestamplen = {"sv_timestamplen", "60"};
cvar_t	sv_rconlim = {"sv_rconlim", "10"};	// rcon bandwith limit: requests per second

//bliP: telnet log level
void OnChange_telnetloglevel_var (cvar_t *var, char *string, qbool *cancel);
cvar_t  telnet_log_level = {"telnet_log_level", "0", 0, OnChange_telnetloglevel_var};
//<-

cvar_t	frag_log_type = {"frag_log_type", "0"};
//	frag log type:
//		0 - old style (  qwsv - v0.165)
//		1 - new style (v0.168 - v0.172)

void OnChange_qconsolelogsay_var (cvar_t *var, char *string, qbool *cancel);
cvar_t	qconsole_log_say = {"qconsole_log_say", "0", 0, OnChange_qconsolelogsay_var};
// logging "say" and "say_team" messages to the qconsole_PORT.log file

cvar_t	sys_command_line = {"sys_command_line", "", CVAR_ROM};

cvar_t	sv_use_dns = {"sv_use_dns", "0"}; // 1 - use DNS lookup in status command, 0 - don't use
cvar_t	spectator_password = {"spectator_password", ""};	// password for entering as a sepctator
cvar_t	vip_password = {"vip_password", ""};	// password for entering as a VIP sepctator
cvar_t	vip_values = {"vip_values", ""};

cvar_t	allow_download = {"allow_download", "1"};
cvar_t	allow_download_skins = {"allow_download_skins", "1"};
cvar_t	allow_download_models = {"allow_download_models", "1"};
cvar_t	allow_download_sounds = {"allow_download_sounds", "1"};
cvar_t	allow_download_maps	= {"allow_download_maps", "1"};
cvar_t	allow_download_pakmaps = {"allow_download_pakmaps", "1"};
cvar_t	allow_download_demos = {"allow_download_demos", "1"};
cvar_t	allow_download_other = {"allow_download_other", "0"};
//bliP: init ->
cvar_t	download_map_url = {"download_map_url", ""};

cvar_t	sv_specprint = {"sv_specprint", "0"};
cvar_t	sv_reconnectlimit = {"sv_reconnectlimit", "0"};

void OnChange_admininfo_var (cvar_t *var, char *string, qbool *cancel);
cvar_t  sv_admininfo = {"sv_admininfo", "", 0, OnChange_admininfo_var};

cvar_t	sv_unfake = {"sv_unfake", "1"}; //bliP: 24/9 kickfake to unfake
cvar_t	sv_kicktop = {"sv_kicktop", "1"};

cvar_t	sv_allowlastscores = {"sv_allowlastscores", "1"};

cvar_t	sv_maxlogsize = {"sv_maxlogsize", "0"};
//bliP: 24/9 ->
void OnChange_logdir_var (cvar_t *var, char *string, qbool *cancel);
cvar_t  sv_logdir = {"sv_logdir", ".", 0, OnChange_logdir_var};

cvar_t  sv_speedcheck = {"sv_speedcheck", "1"};
//<-
//<-
//cvar_t	sv_highchars = {"sv_highchars", "1"};
cvar_t	sv_phs = {"sv_phs", "1"};
cvar_t	pausable = {"pausable", "0"};
cvar_t	sv_maxrate = {"sv_maxrate", "0"};
cvar_t	sv_getrealip = {"sv_getrealip", "1"};
cvar_t	sv_serverip = {"sv_serverip", ""};
cvar_t	sv_forcespec_onfull = {"sv_forcespec_onfull", "2"};
cvar_t	sv_maxdownloadrate = {"sv_maxdownloadrate", "0"};

cvar_t  sv_loadentfiles = {"sv_loadentfiles", "1"}; //loads .ent files by default if there
cvar_t  sv_loadentfiles_dir = {"sv_loadentfiles_dir", ""}; // check for .ent file in maps/sv_loadentfiles_dir first then just maps/
cvar_t	sv_default_name = {"sv_default_name", "unnamed"};

void sv_mod_msg_file_OnChange(cvar_t *cvar, char *value, qbool *cancel);
cvar_t	sv_mod_msg_file = {"sv_mod_msg_file", "", CVAR_NONE, sv_mod_msg_file_OnChange};

cvar_t  sv_reliable_sound = {"sv_reliable_sound", "0"};

//
// game rules mirrored in svs.info
//
cvar_t	fraglimit = {"fraglimit","0",CVAR_SERVERINFO};
cvar_t	timelimit = {"timelimit","0",CVAR_SERVERINFO};
cvar_t	teamplay = {"teamplay","0",CVAR_SERVERINFO};
cvar_t	maxclients = {"maxclients","24",CVAR_SERVERINFO};
cvar_t	maxspectators = {"maxspectators","8",CVAR_SERVERINFO};
cvar_t	maxvip_spectators = {"maxvip_spectators","0"/*,CVAR_SERVERINFO*/};
cvar_t	deathmatch = {"deathmatch","3",CVAR_SERVERINFO};
cvar_t	watervis = {"watervis","0",CVAR_SERVERINFO};
cvar_t	serverdemo = {"serverdemo","",CVAR_SERVERINFO | CVAR_ROM};

cvar_t	samelevel = {"samelevel","1"}; // dont delete this variable - it used by mods
cvar_t	skill = {"skill", "1"}; // dont delete this variable - it used by mods
cvar_t	coop = {"coop", "0"}; // dont delete this variable - it used by mods

cvar_t	sv_paused = {"sv_paused", "0", CVAR_ROM};

cvar_t	hostname = {"hostname", "unnamed", CVAR_SERVERINFO};

cvar_t sv_forcenick = {"sv_forcenick", "0"}; //0 - don't force; 1 - as login;
cvar_t sv_registrationinfo = {"sv_registrationinfo", ""}; // text shown before "enter login"

// We need this cvar, because some mods didn't allow us to go at some placeses of, for example, start map.
cvar_t registered = {"registered", "1", CVAR_ROM};

cvar_t	sv_halflifebsp = {"halflifebsp", "0", CVAR_ROM};
cvar_t  sv_bspversion = {"sv_bspversion", "1", CVAR_ROM};

// If set, don't send broadcast messages, entities or player info to ServeMe bot
cvar_t sv_serveme_fix = { "sv_serveme_fix", "1", CVAR_ROM };

#ifdef FTE_PEXT_FLOATCOORDS
cvar_t sv_bigcoords = {"sv_bigcoords", "", CVAR_SERVERINFO};
#endif
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
// Only enabled on KTX mod (see sv_init)
cvar_t sv_pext_mvdsv_serversideweapon = { "sv_pext_mvdsv_serversideweapon", "1" };
#endif

cvar_t sv_extlimits = { "sv_extlimits", "2" };

#if defined(FTE_PEXT_TRANS)
cvar_t sv_pext_ezquake_verfortrans = {"pext_ezquake_verfortrans", "7814", CVAR_NONE};
#endif

qbool sv_error = false;

client_t *WatcherId = NULL; // QW262

//============================================================================

qbool GameStarted(void)
{
	mvddest_t *d;

	for (d = demo.dest; d; d = d->nextdest)
		if (d->desttype != DEST_STREAM) // oh, its not stream, treat as "game is started"
			break;

	return (d || strncasecmp(Info_ValueForKey(svs.info, "status"), "Standby", 8));
}
/*
================
SV_Shutdown

Quake calls this before calling Sys_Quit or Sys_Error
================
*/
void SV_Shutdown (char *finalmsg)
{
	int i;

	if (!sv.state)
		return; // already shutdown. FIXME: what about error during SV_SpawnServer() ?

	SV_FinalMessage(finalmsg);

	Master_Shutdown ();

	for (i = MIN_LOG; i < MAX_LOG; ++i)
	{
		if (logs[i].sv_logfile)
		{
			fclose (logs[i].sv_logfile);
			logs[i].sv_logfile = NULL;
		}
	}
	if (sv.mvdrecording)
		SV_MVDStop_f();

#ifndef SERVER_ONLY
	NET_CloseServer ();
#endif

#if defined(SERVERONLY) && defined(WWW_INTEGRATION)
	Central_Shutdown();
#endif

	// Shutdown game.
	PR_GameShutDown();
	PR_UnLoadProgs();

	memset (&sv, 0, sizeof(sv));
	sv.state = ss_dead;
#ifndef SERVERONLY
	com_serveractive = false;
	{
		extern  ctxinfo_t _localinfo_;

		Info_RemoveAll(&_localinfo_);
		for (i = 0; i < MAX_CLIENTS; ++i) {
			Info_RemoveAll(&svs.clients[i]._userinfo_ctx_);
			Info_RemoveAll(&svs.clients[i]._userinfoshort_ctx_);
		}
	}
#endif

	memset (svs.clients, 0, sizeof(svs.clients));
	svs.lastuserid = 0;
	svs.serverflags = 0;
}

/*
================
SV_Error

Sends a datagram to all the clients informing them of the server crash,
then stops the server
================
*/
void SV_Error (char *error, ...)
{
	static char string[1024];
	va_list argptr;

	sv_error = true;

	va_start (argptr, error);
	vsnprintf (string, sizeof (string), error, argptr);
	va_end (argptr);

	SV_Shutdown (va ("SV_Error: %s\n", string));

	Host_EndGame();
	Host_Error("SV_Error: %s", string);
}

static void SV_FreeHeadDelayedPacket(client_t *cl) {
	if (cl->packets) {
		packet_t *next = cl->packets->next;
		cl->packets->next = svs.free_packets;
		svs.free_packets = cl->packets;
		cl->packets = next;
	}
}


void SV_FreeDelayedPackets (client_t *cl) {
	while (cl->packets)
		SV_FreeHeadDelayedPacket(cl);
}

/*
==================
SV_FinalMessage

Used by SV_Error and SV_Quit_f to send a final message to all connected
clients before the server goes down.  The messages are sent immediately,
not just stuck on the outgoing message list, because the server is going
to totally exit after returning from this function.
==================
*/
void SV_FinalMessage (const char *message)
{
	client_t *cl;
	int i;

	SZ_Clear (&net_message);
	MSG_WriteByte (&net_message, svc_print);
	MSG_WriteByte (&net_message, PRINT_HIGH);
	MSG_WriteString (&net_message, message);
	MSG_WriteByte (&net_message, svc_disconnect);

	for (i=0, cl = svs.clients ; i<MAX_CLIENTS ; i++, cl++)
		if (cl->state >= cs_spawned
#ifdef USE_PR2
			&& !cl->isBot
#endif
		) {
			Netchan_Transmit(&cl->netchan, net_message.cursize
				, net_message.data);
		}
}



/*
=====================
SV_DropClient

Called when the player is totally leaving the server, either willingly
or unwillingly.  This is NOT called if the entire server is quiting
or crashing.
=====================
*/
void SV_DropClient(client_t* drop)
{
	//bliP: cuff, mute ->
	SV_SavePenaltyFilter (drop, ft_mute, drop->lockedtill);
	SV_SavePenaltyFilter (drop, ft_cuff, drop->cuff_time);
	//<-

	//bliP: player logging
	if (drop->name[0])
		SV_LogPlayer(drop, "disconnect", 1);
	//<-

	// add the disconnect
#ifdef USE_PR2
	if( drop->isBot )
	{
		extern void RemoveBot(client_t *cl);
		RemoveBot(drop);
		return;
	}
#endif
	MSG_WriteByte (&drop->netchan.message, svc_disconnect);

	if (drop->state == cs_spawned)
	{
		// call the prog function for removing a client
		// this will set the body to a dead frame, among other things
		pr_global_struct->self = EDICT_TO_PROG(drop->edict);
		PR_GameClientDisconnect(drop->spectator);
	}

	if (drop->spectator)
		Con_Printf ("Spectator %s removed\n",drop->name);
	else
		Con_Printf ("Client %s removed\n",drop->name);

	if (drop->download)
	{
		VFS_CLOSE(drop->download);
		drop->download = NULL;
	}
	if (drop->upload)
	{
		fclose (drop->upload);
		drop->upload = NULL;
	}
	*drop->uploadfn = 0;

	SV_Logout(drop);

	drop->state = cs_zombie;		    // become free in a few seconds
	SV_SetClientConnectionTime(drop);   // for zombie timeout

// MD -->
	if (drop == WatcherId)
		WatcherId = NULL;
// <-- MD

	drop->old_frags = 0;
	drop->edict->v->frags = 0.0;
	drop->name[0] = 0;

	Info_RemoveAll(&drop->_userinfo_ctx_);
	Info_RemoveAll(&drop->_userinfoshort_ctx_);

	// send notification to all remaining clients
	SV_FullClientUpdate(drop, &sv.reliable_datagram);
}


//====================================================================

/*
===================
SV_CalcPing

===================
*/
int SV_CalcPing (client_t *cl)
{
	register client_frame_t *frame;
	int count, i;
	float ping;


	//bliP: 999 ping for connecting players
	if (cl->state != cs_spawned)
		return 999;
	//<-

	ping = 0;
	count = 0;
#ifdef USE_PR2
	if (cl->isBot) {
		return 10;
	}
#endif
	for (frame = cl->frames, i=0 ; i<UPDATE_BACKUP ; i++, frame++)
	{
		if (frame->ping_time > 0)
		{
			ping += frame->ping_time;
			count++;
		}
	}
	if (!count)
		return 9999;
	ping /= count;

	return ping*1000;
}

/*
===================
SV_FullClientUpdate

Writes all update values to a sizebuf
===================
*/
void SV_FullClientUpdate (client_t *client, sizebuf_t *buf)
{
	char info[MAX_EXT_INFO_STRING];
	int i;

	i = client - svs.clients;

	//Sys_Printf("SV_FullClientUpdate:  Updated frags for client %d\n", i);

	MSG_WriteByte (buf, svc_updatefrags);
	MSG_WriteByte (buf, i);
	MSG_WriteShort (buf, client->old_frags);

	MSG_WriteByte (buf, svc_updateping);
	MSG_WriteByte (buf, i);
	MSG_WriteShort (buf, SV_CalcPing (client));

	MSG_WriteByte (buf, svc_updatepl);
	MSG_WriteByte (buf, i);
	MSG_WriteByte (buf, client->lossage);

	MSG_WriteByte (buf, svc_updateentertime);
	MSG_WriteByte (buf, i);
	MSG_WriteFloat (buf, SV_ClientGameTime(client));

	Info_ReverseConvert(&client->_userinfoshort_ctx_, info, sizeof(info));
	Info_RemovePrefixedKeys (info, '_');	// server passwords, etc

	MSG_WriteByte (buf, svc_updateuserinfo);
	MSG_WriteByte (buf, i);
	MSG_WriteLong (buf, client->userid);
	MSG_WriteString (buf, info);
}

/*
===================
SV_FullClientUpdateToClient

Writes all update values to a client's reliable stream
===================
*/
void SV_FullClientUpdateToClient (client_t *client, client_t *cl)
{
	char info[MAX_EXT_INFO_STRING];

	Info_ReverseConvert(&client->_userinfoshort_ctx_, info, sizeof(info));

	ClientReliableCheckBlock(cl, 24 + strlen(info));
	if (cl->num_backbuf)
	{
		SV_FullClientUpdate (client, &cl->backbuf);
		ClientReliable_FinishWrite(cl);
	}
	else
		SV_FullClientUpdate (client, &cl->netchan.message);
}

//Returns a unique userid in [1..MAXUSERID] range
#define MAXUSERID 99
int SV_GenerateUserID (void)
{
	client_t *cl;
	int i;


	do {
		svs.lastuserid++;
		if (svs.lastuserid == 1 + MAXUSERID)
			svs.lastuserid = 1;
		for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
			if (cl->state != cs_free && cl->userid == svs.lastuserid)
				break;
	} while (i != MAX_CLIENTS);

	return svs.lastuserid;
}

/*
==============================================================================

CONNECTIONLESS COMMANDS

==============================================================================
*/

/*
SVC_QTVStreams

Responds with info on connected QTV users
*/
static void SVC_QTVUsers (void)
{
	SV_BeginRedirect (RD_PACKET);
	QTV_Streams_UserList ();
	SV_EndRedirect ();
}

/*
================
SVC_Status

Responds with all the info that qplug or qspy can see
This message can be up to around 5k with worst case string lengths.
================
*/
#define STATUS_OLDSTYLE                 0
#define STATUS_SERVERINFO               1
#define STATUS_PLAYERS                  2
#define STATUS_SPECTATORS               4
#define STATUS_SPECTATORS_AS_PLAYERS    8 //for ASE - change only frags: show as "S"
#define STATUS_SHOWTEAMS                16
#define STATUS_SHOWQTV                  32
#define STATUS_SHOWFLAGS                64

static void SVC_Status (void)
{
	int top, bottom, ping, i, opt = 0;
	char *name, *frags;
	client_t *cl;


	if (Cmd_Argc() > 1)
		opt = Q_atoi(Cmd_Argv(1));

	SV_BeginRedirect (RD_PACKET);
	if (opt == STATUS_OLDSTYLE || (opt & STATUS_SERVERINFO))
		Con_Printf ("%s\n", svs.info);
	if (opt == STATUS_OLDSTYLE || (opt & (STATUS_PLAYERS | STATUS_SPECTATORS)))
		for (i = 0; i < MAX_CLIENTS; i++)
		{
			cl = &svs.clients[i];
			if ( (cl->state >= cs_preconnected/* || cl->state == cs_spawned */) &&
			        ( (!cl->spectator && ((opt & STATUS_PLAYERS) || opt == STATUS_OLDSTYLE)) ||
			          ( cl->spectator && ( opt & STATUS_SPECTATORS)) ) )
			{
				top    = Q_atoi(Info_Get (&cl->_userinfo_ctx_, "topcolor"));
				bottom = Q_atoi(Info_Get (&cl->_userinfo_ctx_, "bottomcolor"));
				top    = (top    < 0) ? 0 : ((top    > 13) ? 13 : top);
				bottom = (bottom < 0) ? 0 : ((bottom > 13) ? 13 : bottom);
				ping   = SV_CalcPing (cl);
				name   = cl->name;
				if (cl->spectator)
				{
					if (opt & STATUS_SPECTATORS_AS_PLAYERS)
						frags = "S";
					else
					{
						ping  = -ping;
						frags = "-9999";
						name  = va("\\s\\%s", name);
					}
				}
				else
					frags = va("%i", cl->old_frags);

				Con_Printf ("%i %s %i %i \"%s\" \"%s\" %i %i", cl->userid, frags,
				            (int)(SV_ClientConnectedTime(cl) / 60.0f), ping, name,
				            Info_Get (&cl->_userinfo_ctx_, "skin"), top, bottom);

				if (opt & STATUS_SHOWTEAMS) {
					Con_Printf(" \"%s\"", cl->team);
				}

				if (opt & STATUS_SHOWFLAGS) {
					if (cl->login_flag[0]) {
						Con_Printf(" \"%s\"", cl->login_flag);
					}
					else if (cl->logged_in_via_web || cl->logged > 0) {
						Con_Printf(" \"none\"");
					}
					else {
						Con_Printf(" \"\"");
					}
				}

				Con_Printf("\n");
			}
		}

	if (opt & STATUS_SHOWQTV)
		QTV_Streams_List ();
	SV_EndRedirect ();
}

/*
===================
SVC_LastScores

===================
*/
void SV_LastScores_f (void);
static void SVC_LastScores (void)
{
	if(!(int)sv_allowlastscores.value)
		return;

	SV_BeginRedirect (RD_PACKET);
	SV_LastScores_f ();
	SV_EndRedirect ();
}

/*
===================
SVC_LastStats
===================
*/
void SV_LastStats_f (void);
static void SVC_LastStats (void)
{
	if(!(int)sv_allowlastscores.value)
		return;

	SV_BeginRedirect (RD_PACKET);
	SV_LastStats_f ();
	SV_EndRedirect ();
}

/*
===================
SVC_DemoList
SVC_DemoListRegex
===================
*/
void SV_DemoList_f (void);
static void SVC_DemoList (void)
{
	SV_BeginRedirect (RD_PACKET);
	SV_DemoList_f ();
	SV_EndRedirect ();
}
void SV_DemoListRegex_f (void);
static void SVC_DemoListRegex (void)
{
	SV_BeginRedirect (RD_PACKET);
	SV_DemoListRegex_f ();
	SV_EndRedirect ();
}

/*
===================
SV_CheckLog

===================
*/
#define	LOG_HIGHWATER	(MAX_DATAGRAM - 128)
#define	LOG_FLUSH		10*60
static void SV_CheckLog (void)
{
	sizebuf_t *sz;

	if (sv.state != ss_active)
		return;

	sz = &svs.log[svs.logsequence&1];

	// bump sequence if allmost full, or ten minutes have passed and
	// there is something still sitting there
	if (sz->cursize > LOG_HIGHWATER
	        || (realtime - svs.logtime > LOG_FLUSH && sz->cursize) )
	{
		// swap buffers and bump sequence
		svs.logtime = realtime;
		svs.logsequence++;
		sz = &svs.log[svs.logsequence&1];
		sz->cursize = 0;
		Con_DPrintf ("beginning fraglog sequence %i\n", svs.logsequence);
	}

}

/*
================
SVC_Log

Responds with all the logged frags for ranking programs.
If a sequence number is passed as a parameter and it is
the same as the current sequence, an A2A_NACK will be returned
instead of the data.
================
*/
static void SVC_Log (void)
{
	char data[MAX_DATAGRAM+64];
	int seq;


	if (Cmd_Argc() == 2)
		seq = Q_atoi(Cmd_Argv(1));
	else
		seq = -1;

	if (seq == svs.logsequence-1 || !logs[FRAG_LOG].sv_logfile)
	{	// they already have this data, or we aren't logging frags
		data[0] = A2A_NACK;
		NET_SendPacket (NS_SERVER, 1, data, net_from);
		return;
	}

	Con_DPrintf ("sending log %i to %s\n", svs.logsequence-1, NET_AdrToString(net_from));

	snprintf (data, MAX_DATAGRAM + 64, "stdlog %i\n", svs.logsequence-1);
	strlcat (data, (char *)svs.log_buf[((svs.logsequence-1)&1)], MAX_DATAGRAM + 64);

	NET_SendPacket (NS_SERVER, strlen(data)+1, data, net_from);
}

/*
================
SVC_Ping

Just responds with an acknowledgement
================
*/
static void SVC_Ping (void)
{
	char data = A2A_ACK;

	NET_SendPacket (NS_SERVER, 1, &data, net_from);
}

/*
=================
SVC_GetChallenge

Returns a challenge number that can be used
in a subsequent client_connect command.
We do this to prevent denial of service attacks that
flood the server with invalid connection IPs.  With a
challenge, they must give a valid IP address.
=================
*/
static void SVC_GetChallenge (void)
{
	int oldestTime, oldest, i;
	char buf[256], *over;


	oldest = 0;
	oldestTime = 0x7fffffff;

	// see if we already have a challenge for this ip
	for (i = 0 ; i < MAX_CHALLENGES ; i++)
	{
		if (NET_CompareBaseAdr (net_from, svs.challenges[i].adr))
			break;
		if (svs.challenges[i].time < oldestTime)
		{
			oldestTime = svs.challenges[i].time;
			oldest = i;
		}
	}

	if (i == MAX_CHALLENGES)
	{
		// overwrite the oldest
		svs.challenges[oldest].challenge = (rand() << 16) ^ rand();
		svs.challenges[oldest].adr = net_from;
		svs.challenges[oldest].time = realtime;
		i = oldest;
	}

	// send it back
	snprintf(buf, sizeof(buf), "%c%i", S2C_CHALLENGE, svs.challenges[i].challenge);
	over = buf + strlen(buf) + 1;

#ifdef PROTOCOL_VERSION_FTE
	//tell the client what fte extensions we support
	if (svs.fteprotocolextensions)
	{
		int lng;

		lng = LittleLong(PROTOCOL_VERSION_FTE);
		memcpy(over, &lng, sizeof(int));
		over += 4;

		lng = LittleLong(svs.fteprotocolextensions);
		memcpy(over, &lng, sizeof(int));
		over += 4;
	}
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
	//tell the client what fte extensions2 we support
	if (svs.fteprotocolextensions2)
	{
		int lng;

		lng = LittleLong(PROTOCOL_VERSION_FTE2);
		memcpy(over, &lng, sizeof(int));
		over += 4;

		lng = LittleLong(svs.fteprotocolextensions2);
		memcpy(over, &lng, sizeof(int));
		over += 4;
	}
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
	// tell the client what mvdsv extensions we support
	if (svs.mvdprotocolextension1) {
		int lng;

		lng = LittleLong(PROTOCOL_VERSION_MVD1);
		memcpy(over, &lng, sizeof(int));
		over += 4;

		lng = LittleLong(svs.mvdprotocolextension1);
		memcpy(over, &lng, sizeof(int));
		over += 4;
	}
#endif

	Netchan_OutOfBand(NS_SERVER, net_from, over-buf, (byte*) buf);
}

static qbool ValidateUserInfo (char *userinfo)
{
	if (strstr(userinfo, "&c") || strstr(userinfo, "&r"))
		return false;

	while (*userinfo)
	{
		if (*userinfo == '\\')
			userinfo++;

		if (*userinfo++ == '\\')
			return false;
		while (*userinfo && *userinfo != '\\')
			userinfo++;
	}
	return true;
}

//==============================================

void FixMaxClientsCvars(void)
{
	if ((int)maxclients.value > MAX_CLIENTS)
		Cvar_SetValue (&maxclients, MAX_CLIENTS);

	if ((int)maxspectators.value > MAX_CLIENTS)
		Cvar_SetValue (&maxspectators, MAX_CLIENTS);

	if ((int)maxvip_spectators.value > MAX_CLIENTS)
		Cvar_SetValue (&maxvip_spectators, MAX_CLIENTS);

	if ((int)maxspectators.value + maxclients.value > MAX_CLIENTS)
		Cvar_SetValue (&maxspectators, MAX_CLIENTS - (int)maxclients.value);

	if ((int)maxspectators.value + maxclients.value + maxvip_spectators.value > MAX_CLIENTS)
		Cvar_SetValue (&maxvip_spectators, MAX_CLIENTS - (int)maxclients.value - (int)maxspectators.value);

}

//==============================================

// see if the challenge is valid
qbool CheckChallange( int challenge )
{
	int i;

	if (net_from.type == NA_LOOPBACK)
		return true; // local client do not need challenge

	for (i = 0; i < MAX_CHALLENGES; i++)
	{
		if (NET_CompareBaseAdr (net_from, svs.challenges[i].adr))
		{
			if (challenge == svs.challenges[i].challenge)
				break;		// good

			Netchan_OutOfBandPrint (NS_SERVER, net_from, "%c\nBad challenge.\n", A2C_PRINT);
			return false;
		}
	}

	if (i == MAX_CHALLENGES)
	{
		Netchan_OutOfBandPrint (NS_SERVER, net_from, "%c\nNo challenge for address.\n", A2C_PRINT);
		return false;
	}

	return true;
}

//==============================================

qbool CheckProtocol( int ver )
{
	if (ver != PROTOCOL_VERSION)
	{
		Netchan_OutOfBandPrint (NS_SERVER, net_from, "%c\nServer is version " QW_VERSION ".\n", A2C_PRINT);
		Con_Printf ("* rejected connect from version %i\n", ver);
		return false;
	}

	return true;
}

//==============================================

qbool CheckUserinfo( char *userinfobuf, unsigned int bufsize, char *userinfo )
{
	strlcpy (userinfobuf, userinfo, bufsize);

	// and now validate userinfo
	if ( !ValidateUserInfo( userinfobuf ) )
	{
		Netchan_OutOfBandPrint (NS_SERVER, net_from, "%c\nInvalid userinfo, perhaps &c sequences. Restart your qwcl\n", A2C_PRINT);
		return false;
	}

	return true;
}

//==============================================

int SV_VIPbyIP(netadr_t adr);
int SV_VIPbyPass (char *pass);

qbool CheckPasswords( char *userinfo, int userinfo_size, qbool *spass_ptr, qbool *vip_ptr, int *spectator_ptr )
{
	int spectator;
	qbool spass, vip;

	char *s = Info_ValueForKey (userinfo, "spectator");
	char *pwd;

	spass = vip = spectator = false;

	if (s[0] && strcmp(s, "0"))
	{
		spass = true;

		// first the pass, then ip
		if ( !( vip = SV_VIPbyPass( s ) ) )
		{
			if ( !( vip = SV_VIPbyPass( Info_ValueForKey( userinfo, "password") ) ) )
			{
				vip = SV_VIPbyIP( net_from );
			}
		}

		pwd = spectator_password.string;

		if (pwd[0] && strcasecmp(pwd, "none") && strcmp(pwd, s))
		{
			spass = false; // failed
		}

		if (!vip && !spass)
		{
			Con_Printf ("%s:spectator password failed\n", NET_AdrToString (net_from));
			Netchan_OutOfBandPrint (NS_SERVER, net_from, "%c\nrequires a spectator password\n\n", A2C_PRINT);

			return false;
		}

		Info_RemoveKey (userinfo, "spectator"); // remove passwd
		Info_SetValueForStarKey (userinfo, "*spectator", "1", userinfo_size);

		spectator = Q_atoi(s);

		if (!spectator)
			spectator = true;
	}
	else
	{
		s = Info_ValueForKey (userinfo, "password");

		// first the pass, then ip
		if (!(vip = SV_VIPbyPass(s)))
		{
			vip = SV_VIPbyIP(net_from);
		}

		pwd = password.string;

		if (!vip && pwd[0] && strcasecmp(pwd, "none") && strcmp(pwd, s))
		{
			Con_Printf ("%s:password failed\n", NET_AdrToString (net_from));
			Netchan_OutOfBandPrint (NS_SERVER, net_from, "%c\nserver requires a password\n\n", A2C_PRINT);

			return false;
		}

		Info_RemoveKey (userinfo, "spectator"); // remove "spectator 0" for example

		spectator = false;
	}

	Info_RemoveKey (userinfo, "password"); // remove passwd

	// copy 
	*spass_ptr     = spass;
	*vip_ptr       = vip;
	*spectator_ptr = spectator;

	return true;
}

//==============================================

qbool CheckReConnect( netadr_t adr, int qport )
{
	int i;
	client_t *cl;

	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (cl->state == cs_free)
			continue;

		if (NET_CompareBaseAdr (adr, cl->netchan.remote_address) &&
			(cl->netchan.qport == qport || adr.port == cl->netchan.remote_address.port))
		{
			if (SV_ClientConnectedTime(cl) < sv_reconnectlimit.value)
			{
				Con_Printf ("%s:reconnect rejected: too soon\n", NET_AdrToString (adr));
				return false;
			}

			switch ( cl->state )
			{
				case cs_zombie: // zombie already dropped.
					break;

				case cs_preconnected:
				case cs_connected:
				case cs_spawned:

					SV_DropClient (cl);
					SV_ClearReliable (cl);	// don't send the disconnect
					break;

				default:
					return false; // unknown state, should not be the case.
			}

			cl->state = cs_free;
			Con_Printf ("%s:reconnect\n", NET_AdrToString (adr));
			break;
		}
	}

	return true;
}

//==============================================

void CountPlayersSpecsVips(int *clients_ptr, int *spectators_ptr, int *vips_ptr, client_t **newcl_ptr)
{
	client_t *cl = NULL, *newcl = NULL;
	int clients = 0, spectators = 0, vips = 0;
	int i;

	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (cl->state == cs_free)
		{
			if (!newcl)
				newcl = cl; // grab first available slot

			continue;
		}

		if (cl->spectator)
		{
			if (cl->vip)
				vips++;
			else
				spectators++;
		}
		else
		{
			clients++;
		}
	}

	if (clients_ptr)
		*clients_ptr = clients;
	if (spectators_ptr)
		*spectators_ptr = spectators;
	if (vips_ptr)
		*vips_ptr = vips;
	if (newcl_ptr)
		*newcl_ptr = newcl;
}

//==============================================

qbool SpectatorCanConnect(int vip, int spass, int spectators, int vips)
{
	FixMaxClientsCvars(); // not a bad idea

	if (vip)
	{
		if (spass && (spectators < (int)maxspectators.value || vips < (int)maxvip_spectators.value))
			return true;
	}
	else
	{
		if (spass && spectators < (int)maxspectators.value)
			return true;
	}

	return false;
}

qbool PlayerCanConnect(int clients)
{
	FixMaxClientsCvars(); // not a bad idea

	if (clients < (int)maxclients.value)
		return true;

	return false;
}

/*
==================
SVC_DirectConnect

A connection request that did not come from the master
==================
*/
extern void MVD_PlayerReset(int player);

extern char *shortinfotbl[];

static void SVC_DirectConnect (void)
{
	int spectator;
	qbool spass, vip, rip_vip;

	int clients, spectators, vips;
	int qport, i, edictnum;

	client_t *newcl;

	char userinfo[1024];
	char *s;
	netadr_t adr;
	edict_t *ent;

#ifdef PROTOCOL_VERSION_FTE
	unsigned int protextsupported = 0;
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
	unsigned int protextsupported2 = 0;
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
	unsigned int mvdext_supported1 = 0;
#endif

	// check version/protocol
	if ( !CheckProtocol( Q_atoi( Cmd_Argv( 1 ) ) ) )
		return; // wrong protocol number

	// get qport
	qport = Q_atoi( Cmd_Argv( 2 ) );

	// see if the challenge is valid
	if ( !CheckChallange( Q_atoi( Cmd_Argv( 3 ) ) ) )
		return; // wrong challange

	// and now validate userinfo
	if ( !CheckUserinfo( userinfo, sizeof( userinfo ), Cmd_Argv( 4 ) ) )
		return; // wrong userinfo

//
// WARNING: WARNING: WARNING: using Cmd_TokenizeString() so do all Cmd_Argv() above.
//

	while( !msg_badread )
	{
		Cmd_TokenizeString( MSG_ReadStringLine() );

		switch( Q_atoi( Cmd_Argv( 0 ) ) )
		{
#ifdef PROTOCOL_VERSION_FTE
		case PROTOCOL_VERSION_FTE:
			protextsupported = Q_atoi( Cmd_Argv( 1 ) );
			Con_DPrintf("Client supports 0x%x fte extensions\n", protextsupported);
			break;
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
		case PROTOCOL_VERSION_FTE2:
			protextsupported2 = Q_atoi( Cmd_Argv( 1 ) );
			Con_DPrintf("Client supports 0x%x fte extensions2\n", protextsupported2);
			break;
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
		case PROTOCOL_VERSION_MVD1:
			mvdext_supported1 = Q_atoi( Cmd_Argv( 1 ) );
			Con_DPrintf("Client supports 0x%x mvdsv extensions\n", mvdext_supported1);
			break;
#endif
		}
	}

	msg_badread = false;

	spass = vip = rip_vip = spectator = false;

	// check for password or spectator_password
	if ( !CheckPasswords( userinfo, sizeof(userinfo), &spass, &vip, &spectator) )
		return; // pass was wrong

	adr = net_from;

	// if there is already a slot for this ip, reuse (changed from drop) it
	if ( !CheckReConnect( adr, qport ) )
		return; // can't do that for some reason

	// count up the clients and spectators
	CountPlayersSpecsVips(&clients, &spectators, &vips, &newcl);

	FixMaxClientsCvars();

	// if at server limits, refuse connection

	if ((spectator && !SpectatorCanConnect(vip, spass, spectators, vips)) || 
	    (!spectator && !PlayerCanConnect(clients)) || 
	    !newcl)
	{
		Sys_Printf ("%s:full connect\n", NET_AdrToString (adr));

		// no way to connect does't matter VIP or whatever, just no free slots
		if (!newcl)
		{
			Netchan_OutOfBandPrint (NS_SERVER, adr, "%c\nserver is full\n\n", A2C_PRINT);
			return;
		}

		// !!! SPECTATOR 2 FEATURE !!!
		if (spectator == 2 && !vip &&  vips < (int)maxvip_spectators.value)
		{
			vip = rip_vip = 1; // yet can be connected if realip is on vip list
		}
		else if (    !spectator && spectators < (int)maxspectators.value
				  && (
				  	      ( (int)sv_forcespec_onfull.value == 2
							&&   (Q_atoi(Info_ValueForKey(userinfo, "svf")) & SVF_SPEC_ONFULL)
				  	      ) 
				   	   		||
						  ( (int)sv_forcespec_onfull.value == 1
							&&   !(Q_atoi(Info_ValueForKey(userinfo, "svf")) & SVF_NO_SPEC_ONFULL)
						  )
				   	 )
				)
		{
			Netchan_OutOfBandPrint (NS_SERVER, adr, "%c\nserver is full: connecting as spectator\n", A2C_PRINT);
			Info_SetValueForStarKey (userinfo, "*spectator", "1", sizeof(userinfo));
			spectator = true;
		}
		else
		{
			Netchan_OutOfBandPrint (NS_SERVER, adr, "%c\nserver is full\n\n", A2C_PRINT);
			return;
		}
	}

	// build a new connection
	// accept the new client
	// this is the only place a client_t is ever initialized
	memset (newcl, 0, sizeof(*newcl));

	newcl->userid = SV_GenerateUserID();

#ifdef PROTOCOL_VERSION_FTE
	newcl->fteprotocolextensions = protextsupported;
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
	newcl->fteprotocolextensions2 = protextsupported2;
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
	newcl->mvdprotocolextensions1 = mvdext_supported1;
#endif

	newcl->_userinfo_ctx_.max      = MAX_CLIENT_INFOS;
	newcl->_userinfoshort_ctx_.max = MAX_CLIENT_INFOS;
	Info_Convert(&newcl->_userinfo_ctx_, userinfo);

	// request protocol extensions.
	if (*Info_Get(&newcl->_userinfo_ctx_, "Qizmo")
		|| *Info_Get(&newcl->_userinfo_ctx_, "*qtv")
	)
	{
		newcl->process_pext = false; // this whould not work over such proxies.
	}
	else
	{
		newcl->process_pext = true;
	}

	Netchan_OutOfBandPrint (NS_SERVER, adr, "%c", S2C_CONNECTION);

	Netchan_Setup (NS_SERVER, &newcl->netchan, adr, qport, Q_atoi(Info_Get(&newcl->_userinfo_ctx_, "mtu")));

	newcl->state = cs_preconnected;

	newcl->datagram.allowoverflow = true;
	newcl->datagram.data = newcl->datagram_buf;
	newcl->datagram.maxsize = sizeof(newcl->datagram_buf);

	// spectator mode can ONLY be set at join time
	newcl->spectator = spectator;
	newcl->vip = vip;
	newcl->rip_vip = rip_vip;

	// extract extensions mask
	newcl->extensions = Q_atoi(Info_Get(&newcl->_userinfo_ctx_, "*z_ext"));
	Info_Remove (&newcl->_userinfo_ctx_, "*z_ext");

	edictnum = (newcl-svs.clients)+1;
	ent = EDICT_NUM(edictnum);
	ent->e.free = false;
	newcl->edict = ent;
	// restore client name.
	PR_SetEntityString(ent, ent->v->netname, newcl->name);

	s = ( vip ? va("%d", vip) : "" );

	Info_SetStar (&newcl->_userinfo_ctx_, "*VIP", s);

	// copy the most important userinfo into userinfoshort
	// {

	// parse some info from the info strings
	SV_ExtractFromUserinfo (newcl, true);

	for (i = 0; shortinfotbl[i] != NULL; i++)
	{
		s = Info_Get(&newcl->_userinfo_ctx_, shortinfotbl[i]);
		Info_SetStar (&newcl->_userinfoshort_ctx_, shortinfotbl[i], s);
	}

	// move star keys to infoshort
	Info_CopyStar( &newcl->_userinfo_ctx_, &newcl->_userinfoshort_ctx_ );

	// }

	// JACK: Init the floodprot stuff.
	memset(newcl->whensaid, 0, sizeof(newcl->whensaid));
	newcl->whensaidhead = 0;
	newcl->lockedtill = 0;
	newcl->disable_updates_stop = -1.0; // Vladis

	newcl->realip_num = rand();

	//bliP: init
	newcl->spec_print = (int)sv_specprint.value;
	newcl->logincount = 0;
	//<-

#ifdef FTE_PEXT2_VOICECHAT
	SV_VoiceInitClient(newcl);
#endif

	// call the progs to get default spawn parms for the new client
	PR_GameSetNewParms();

	for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
		newcl->spawn_parms[i] = (&PR_GLOBAL(parm1))[i];

	// mvd/qtv related stuff
	// Well, here is a chance what player connect after demo recording started,
	// so demo.info[edictnum - 1].model == player_model so SV_MVDWritePackets() will not wrote player model index,
	// so client during playback this demo will got invisible model, because model index will be 0.
	// Fixing that.
	// Btw, struct demo contain different client specific structs, may be they need clearing too, not sure.
	// Also, we have Cmd_Join_f()/Cmd_Observe_f() which have close behaviour to SVC_DirectConnect(),
	// so I put same demo fix in mentioned functions too.
	MVD_PlayerReset(NUM_FOR_EDICT(newcl->edict) - 1);

	newcl->sendinfo = true;
}

static int char2int (int c)
{
	if (c <= '9' && c >= '0')
		return c - '0';
	else if (c <= 'f' && c >= 'a')
		return c - 'a' + 10;
	else if (c <= 'F' && c >= 'A')
		return c - 'A' + 10;
	return 0;
}
/*
 * rcon_bandlim() - check for rcon requests bandwidth limit
 *
 *      From kernel of the FreeBSD 4.10 release:
 *      sys/netinet/ip_icmp.c(846): int badport_bandlim(int which);
 *
 *	Return false if it is ok to check rcon_password, true if we have
 *	hit our bandwidth limit and it is not ok.
 *
 *	If sv_rconlim.value is <= 0, the feature is disabled and false is returned.
 *
 *	Note that the printing of the error message is delayed so we can
 *	properly print the rcon limit error rate that the system was trying to do
 *	(i.e. 22000/100 rcon pps, etc...).  This can cause long delays in printing
 *	the 'final' error, but it doesn't make sense to solve the printing
 *	delay with more complex code.
 */
static qbool rcon_bandlim (void)
{
	static double lticks = 0;
	static int lpackets = 0;

	/*
	 * Return ok status if feature disabled or argument out of
	 * ranage.
	 */

	if ((int)sv_rconlim.value <= 0)
		return false;

	/*
	 * reset stats when cumulative dt exceeds one second.
	 */

	if (realtime - lticks > 1.0)
	{
		if (lpackets > (int)sv_rconlim.value)
			Sys_Printf("WARNING: Limiting rcon response from %d to %d rcon pequests per second from %s\n",
			           lpackets, (int)sv_rconlim.value, NET_AdrToString(net_from));
		lticks = realtime;
		lpackets = 0;
	}

	/*
	 * bump packet count
	 */

	if (++lpackets > (int)sv_rconlim.value)
		return true;

	return false;
}

//bliP: master rcon/logging ->
int Rcon_Validate (char *client_string, char *password1)
{
	unsigned int i;

	if (rcon_bandlim()) {
		return 0;
	}

	if (!strlen(password1)) {
		return 0;
	}

	if ((int)sv_crypt_rcon.value) {
		const char* digest = Cmd_Argv(1);
		const char* time_start = Cmd_Argv(1) + DIGEST_SIZE * 2;

		if (strlen(digest) < DIGEST_SIZE * 2 + sizeof(time_t) * 2) {
			return 0;
		}

		if ((int)sv_timestamplen.value) {
			time_t server_time, client_time = 0;
			double difftime_server_client;

			time(&server_time);
			for (i = 0; i < sizeof(client_time) * 2; i += 2) {
				client_time += (char2int((unsigned char)time_start[i]) << (4 + i * 4)) +
				               (char2int((unsigned char)time_start[i + 1]) << (i * 4));
			}
			difftime_server_client = difftime(server_time, client_time);

			if (difftime_server_client > (double)sv_timestamplen.value || difftime_server_client < -(double)sv_timestamplen.value) {
				return 0;
			}
		}
		SHA1_Init();
		SHA1_Update((unsigned char*)Cmd_Argv(0));
		SHA1_Update((unsigned char*)" ");
		SHA1_Update((unsigned char*)password1);
		SHA1_Update((unsigned char*)time_start);
		SHA1_Update((unsigned char*)" ");
		for (i = 2; (int) i < Cmd_Argc(); i++) {
			SHA1_Update((unsigned char*)Cmd_Argv(i));
			SHA1_Update((unsigned char*)" ");
		}
		if (strncmp(digest, SHA1_Final(), DIGEST_SIZE * 2)) {
			return 0;
		}
	}
	else if (strcmp(Cmd_Argv(1), password1)) {
		return 0;
	}
	return 1;
}

int Master_Rcon_Validate (void)
{
	int i, client_string_len = Cmd_Argc() + 1;
	char *client_string;

	for (i = 0; i < Cmd_Argc(); ++i) {
		client_string_len += strlen(Cmd_Argv(i));
	}
	client_string = (char *) Q_malloc (client_string_len);

	*client_string = 0;
	for (i = 0; i < Cmd_Argc(); ++i) {
		strlcat(client_string, Cmd_Argv(i), client_string_len);
		strlcat(client_string, " ", client_string_len);
	}
	i = Rcon_Validate (client_string, master_rcon_password);
	Q_free(client_string);
	return i;
}

// QW262 -->
void SV_Admin_f (void)
{
	client_t *cl;
	int i = 0;

	if (Cmd_Argc () == 2 && !strcmp (Cmd_Argv (1), "off") && WatcherId &&
			NET_CompareAdr (WatcherId->netchan.remote_address, net_from))
	{
		Con_Printf ("Rcon Watch stopped\n");
		WatcherId = NULL;
		return;
	}

	if (WatcherId)
		Con_Printf ("Rcon Watch is already being made by %s\n", WatcherId->name);
	else
	{
		for (cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
		{
			if (cl->state != cs_spawned)
				continue;

			if (NET_CompareAdr (cl->netchan.remote_address, net_from))
				break;
		}

		if (i == MAX_CLIENTS)
		{
			Con_Printf ("You are not connected to server!\n");
			return;
		}

		WatcherId = cl;
		Con_Printf ("Rcon Watch started for %s\n", cl->name);
	}
}
// <-- QW262

/*
===============
SVC_RemoteCommand

A client issued an rcon command.
Shift down the remaining args
Redirect all printfs
===============
*/
static void SVC_RemoteCommand (char *remote_command)
{
	int			i;
	char		str[1024];
	char		plain[32];
	char		*p;
	unsigned char *hide;
	client_t	*cl;
	qbool		admin_cmd = false;
	qbool		do_cmd = false;
	qbool		bad_cmd = false;
	qbool		banned = false;


	if (Rcon_Validate (remote_command, master_rcon_password))
	{
		if (SV_FilterPacket()) //banned players can't use rcon, but we log it
			banned = true;
		else
			do_cmd = true;
	}
	else if (Rcon_Validate (remote_command, rcon_password.string))
	{
		admin_cmd = true;
		if (SV_FilterPacket()) //banned players can't use rcon, but we log it
		{
			bad_cmd = true;
			banned = true;
		}
		else
		{
			//
			// the following line prevents exploits like:
			//   coop rm
			//   $coop . *
			// which expands to:
			//   rm . *

			Cmd_ExpandString (remote_command, str); // check *expanded* command

			//
			// since the execution parser is not case sensitive, we
			// must check not only for chmod, but also CHMOD, ChmoD, etc.
			// so we lowercase the whole temporary line before checking

			// VVD: strcmp => strcasecmp and we don't need to do this (yes?)
			//for(i = 0; str[i]; i++)
			//	str[i] = (char)tolower(str[i]);

			Cmd_TokenizeString (str);		// must check *all* tokens, because
											// a command/var may not be the first
											// token -- example: "" ls .

			//
			// normal rcon can't use these commands
			//
			// NOTE: this would still be vulnerable to semicolons if
			// they were still allowed, so keep that in mind before
			// re-enabling them

			for (i = 2; i < Cmd_Argc(); i++)
			{
				const char *tstr = Cmd_Argv(i);

				if(!tstr[0]) // skip leading empty tokens
					continue;

				if (!strcasecmp(tstr, "rm") ||
					!strcasecmp(tstr, "rmdir") ||
					!strcasecmp(tstr, "ls") ||
					!strcasecmp(tstr, "chmod") ||
					!strcasecmp(tstr, "sv_admininfo") ||
					!strcasecmp(tstr, "if") ||
					!strcasecmp(tstr, "localcommand") ||
					!strcasecmp(tstr, "sv_crypt_rcon") ||
					!strcasecmp(tstr, "sv_timestamplen") ||
					!strncasecmp(tstr, "log", 3) ||
					!strcasecmp(tstr, "sys_command_line")
					)
				{
					bad_cmd = true;
				}
				break; // stop after first non-empty token
			}

			Cmd_TokenizeString (remote_command); // restore original tokens
		}
		do_cmd = !bad_cmd;
	}

	//find player name if rcon came from someone on server
	plain[0] = '\0';
	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (cl->state == cs_free)
			continue;
#ifdef USE_PR2
		if (cl->isBot)
			continue;
#endif
		if (!NET_CompareBaseAdr(net_from, cl->netchan.remote_address))
			continue;
		if (cl->netchan.remote_address.port != net_from.port)
			continue;

		strlcpy(plain, cl->name, sizeof(plain));
		Q_normalizetext(plain);

		// we found what we need
		break;
	}

	if (do_cmd)
	{
		if (!(int)sv_crypt_rcon.value)
		{
			hide = net_message.data + 9;
			p = admin_cmd ? rcon_password.string : master_rcon_password;
			while (*p)
			{
				p++;
				*hide++ = '*';
			}
		}

		if (plain[0])
			SV_Write_Log(RCON_LOG, 1, va("Rcon from %s (%s): %s\n", NET_AdrToString(net_from), plain, net_message.data + 4));
		else
			SV_Write_Log(RCON_LOG, 1, va("Rcon from %s: %s\n", NET_AdrToString(net_from), net_message.data + 4));

		Con_Printf("Rcon from %s:\n%s\n", NET_AdrToString(net_from), net_message.data + 4);

		SV_BeginRedirect(RD_PACKET);

		str[0] = '\0';
		for (i = 2; i < Cmd_Argc(); i++)
		{
			strlcat(str, Cmd_Argv(i), sizeof(str));
			strlcat(str, " ", sizeof(str));
		}

		Cmd_ExecuteString(str);
	}
	else
	{
		if (admin_cmd && !(int)sv_crypt_rcon.value)
		{
			hide = net_message.data + 9;
			p = admin_cmd ? rcon_password.string : master_rcon_password;
			while (*p)
			{
				p++;
				*hide++ = '*';
			}
		}

		Con_Printf ("Bad rcon from %s: %s\n", NET_AdrToString(net_from), net_message.data + 4);

		if (!banned)
		{
			if (plain[0])
				SV_Write_Log(RCON_LOG, 1, va("Bad rcon from %s (%s):\n%s\n", NET_AdrToString(net_from), plain, net_message.data + 4));
			else
				SV_Write_Log(RCON_LOG, 1, va("Bad rcon from %s:\n%s\n",	NET_AdrToString (net_from), net_message.data + 4));
		}
		else
		{
			SV_Write_Log(RCON_LOG, 1, va("Rcon from banned IP: %s: %s\n", NET_AdrToString(net_from), net_message.data + 4));
			SV_SendBan();
			return;
		}

		SV_BeginRedirect (RD_PACKET);
		if (admin_cmd)
			Con_Printf ("Command not valid.\n");
		else
			Con_Printf ("Bad rcon_password.\n");
	}
	SV_EndRedirect ();
}
//<-

static void SVC_IP(void)
{
	int num;
	client_t *client;

	if (Cmd_Argc() < 3)
		return;

	num = Q_atoi(Cmd_Argv(1));

	if (num < 0 || num >= MAX_CLIENTS)
		return;

	client = &svs.clients[num];
	if (client->state != cs_preconnected)
		return;

	// prevent cheating
	if (client->realip_num != Q_atoi(Cmd_Argv(2)))
		return;

	// don't override previously set ip
	if (client->realip.ip[0])
		return;

	client->realip = net_from;

	// if banned drop
	if (SV_FilterPacket()/* && !client->vip*/)
		SV_DropClient(client);

}


/*
=================
SV_ConnectionlessPacket

A connectionless packet has four leading 0xff
characters to distinguish it from a game channel.
Clients that are in the game can still send
connectionless packets.
=================
*/

static void SV_ConnectionlessPacket (void)
{
	char	*s;
	char	*c;

	MSG_BeginReading ();
	MSG_ReadLong ();		// skip the -1 marker

	s = MSG_ReadStringLine ();

	Cmd_TokenizeString (s);

	c = Cmd_Argv(0);

	if (!strcmp(c, "ping") || ( c[0] == A2A_PING && (c[1] == 0 || c[1] == '\n')) )
		SVC_Ping ();
	else if (c[0] == A2A_ACK && (c[1] == 0 || c[1] == '\n') )
		Con_Printf ("A2A_ACK from %s\n", NET_AdrToString (net_from));
	else if (!strcmp(c,"status"))
		SVC_Status ();
	else if (!strcmp(c,"log"))
		SVC_Log ();
	else if (!strcmp(c, "rcon"))
		SVC_RemoteCommand (s);
	else if (!strcmp(c, "ip"))
		SVC_IP();
	else if (!strcmp(c,"connect"))
		SVC_DirectConnect ();
	else if (!strcmp(c,"getchallenge"))
		SVC_GetChallenge ();
	else if (!strcmp(c,"lastscores"))
		SVC_LastScores ();
	else if (!strcmp(c,"laststats"))
		SVC_LastStats ();
	else if (!strcmp(c,"dlist"))
		SVC_DemoList ();
	else if (!strcmp(c,"dlistr"))
		SVC_DemoListRegex ();
	else if (!strcmp(c,"dlistregex"))
		SVC_DemoListRegex ();
	else if (!strcmp(c,"demolist"))
		SVC_DemoList ();
	else if (!strcmp(c,"demolistr"))
		SVC_DemoListRegex ();
	else if (!strcmp(c,"demolistregex"))
		SVC_DemoListRegex ();
	else if (!strcmp(c,"qtvusers"))
		SVC_QTVUsers ();
	else
		Con_Printf ("bad connectionless packet from %s:\n%s\n"
		            , NET_AdrToString (net_from), s);
}

/*
==============================================================================

PACKET FILTERING


You can add or remove addresses from the filter list with:

addip <ip>
removeip <ip>

The ip address is specified in dot format, and any unspecified digits will match any value, so you can specify an entire class C network with "addip 192.246.40".

Removeip will only remove an address specified exactly the same way.  You cannot addip a subnet, then removeip a single host.

listip
Prints the current list of filters.

writeip
Dumps "addip <ip>" commands to listip.cfg so it can be execed at a later date.  The filter lists are not saved and restored by default, because I beleive it would cause too much confusion.

filterban <0 or 1>

If 1 (the default), then ip addresses matching the current list will be prohibited from entering the game.  This is the default setting.

If 0, then only addresses matching the list will be allowed.  This lets you easily set up a private game, or a game that only allows players from your local network.


==============================================================================
*/


/*typedef struct
{
	unsigned	mask;
	unsigned	compare;
	int			level;
} ipfilter_t;
*/

#define	MAX_IPFILTERS	1024

ipfilter_t	ipfilters[MAX_IPFILTERS];
int		numipfilters;

ipfilter_t	ipvip[MAX_IPFILTERS];
int		numipvips;

//bliP: cuff, mute ->
penfilter_t	penfilters[MAX_PENFILTERS];
int		numpenfilters;
//<-

cvar_t	filterban = {"filterban", "1"};

/*
=================
StringToFilter
=================
*/
qbool StringToFilter (char *s, ipfilter_t *f)
{
	char	num[128];
	int		i, j;
	byte	b[4];
	byte	m[4];

	for (i=0 ; i<4 ; i++)
	{
		b[i] = 0;
		m[i] = 0;
	}

	for (i=0 ; i<4 ; i++)
	{
		if (*s < '0' || *s > '9')
		{
			//Con_Printf ("Bad filter address: %s\n", s);
			return false;
		}

		j = 0;
		while (*s >= '0' && *s <= '9')
		{
			num[j++] = *s++;
		}
		num[j] = 0;
		b[i] = Q_atoi(num);
		if (b[i] != 0)
			m[i] = 255;

		if (!*s)
			break;
		s++;
	}

	f->mask = *(unsigned *)m;
	f->compare = *(unsigned *)b;

	return true;
}

/*
=================
SV_AddIPVIP_f
=================
*/
static void SV_AddIPVIP_f (void)
{
	int		i, l;
	ipfilter_t f;

	if (!StringToFilter (Cmd_Argv(1), &f))
	{
		Con_Printf ("Bad filter address: %s\n", Cmd_Argv(1));
		return;
	}

	l = Q_atoi(Cmd_Argv(2));

	if (l < 1) l = 1;

	for (i=0 ; i<numipvips ; i++)
		if (ipvip[i].compare == 0xffffffff || (ipvip[i].mask == f.mask
		                                       && ipvip[i].compare == f.compare))
			break;		// free spot
	if (i == numipvips)
	{
		if (numipvips == MAX_IPFILTERS)
		{
			Con_Printf ("VIP spectator IP list is full\n");
			return;
		}
		numipvips++;
	}

	ipvip[i] = f;
	ipvip[i].level = l;
}

/*
=================
SV_RemoveIPVIP_f
=================
*/
static void SV_RemoveIPVIP_f (void)
{
	ipfilter_t	f;
	int		i, j;

	if (!StringToFilter (Cmd_Argv(1), &f))
	{
		Con_Printf ("Bad filter address: %s\n", Cmd_Argv(1));
		return;
	}
	for (i=0 ; i<numipvips ; i++)
		if (ipvip[i].mask == f.mask
		        && ipvip[i].compare == f.compare)
		{
			for (j=i+1 ; j<numipvips ; j++)
				ipvip[j-1] = ipvip[j];
			numipvips--;
			Con_Printf ("Removed.\n");
			return;
		}
	Con_Printf ("Didn't find %s.\n", Cmd_Argv(1));
}

/*
=================
SV_ListIP_f
=================
*/
static void SV_ListIPVIP_f (void)
{
	int		i;
	byte	b[4];

	Con_Printf ("VIP list:\n");
	for (i=0 ; i<numipvips ; i++)
	{
		*(unsigned *)b = ipvip[i].compare;
		Con_Printf ("%3i.%3i.%3i.%3i   level %d\n", b[0], b[1], b[2], b[3], ipvip[i].level);
	}
}

/*
=================
SV_WriteIPVIP_f
=================
*/
static void SV_WriteIPVIP_f (void)
{
	FILE	*f;
	char	name[MAX_OSPATH];
	byte	b[4];
	int		i;

	snprintf (name, MAX_OSPATH, "%s/vip_ip.cfg", fs_gamedir);

	Con_Printf ("Writing %s.\n", name);

	f = fopen (name, "wb");
	if (!f)
	{
		Con_Printf ("Couldn't open %s\n", name);
		return;
	}

	for (i=0 ; i<numipvips ; i++)
	{
		*(unsigned *)b = ipvip[i].compare;
		fprintf (f, "vip_addip %i.%i.%i.%i %d\n", b[0], b[1], b[2], b[3], ipvip[i].level);
	}

	fclose (f);

	// force cache rebuild.
	FS_FlushFSHash();
}


/*
=================
SV_AddIP_f
=================
*/
static void SV_AddIP_f (void)
{
	int		i;
	double	t = 0;
	char	*s;
	time_t	long_time = time(NULL);
	ipfilter_t f;
	ipfiltertype_t ipft = ipft_ban; // default is ban

	if (!StringToFilter (Cmd_Argv(1), &f) || f.compare == 0)
	{
		Con_Printf ("Bad filter address: %s\n", Cmd_Argv(1));
		return;
	}

	s = Cmd_Argv(2);
	if ( !s[0] || !strcmp(s, "ban"))
		ipft = ipft_ban;
	else if (!strcmp(s, "safe"))
		ipft = ipft_safe;
	else {
		Con_Printf ("Wrong filter type %s, use ban or safe\n", Cmd_Argv(2));
		return;
	}

	s = Cmd_Argv(3);
	if (long_time > 0) {
		if (*s == '+')     // "addip 127.0.0.1 ban +10" will ban for 10 seconds from current time
			s++;
		else
			long_time = 0; // "addip 127.0.0.1 ban 1234567" will ban for some seconds since 00:00:00 GMT, January 1, 1970

		t = (sscanf(s, "%lf", &t) == 1) ? t + long_time : 0;
	}

	f.time = t;
	f.type = ipft;

	for (i=0 ; i<numipfilters ; i++)
		if (ipfilters[i].compare == 0xffffffff || (ipfilters[i].mask == f.mask
		        && ipfilters[i].compare == f.compare))
			break;		// free spot
	if (i == numipfilters)
	{
		if (numipfilters == MAX_IPFILTERS)
		{
			Con_Printf ("IP filter list is full\n");
			return;
		}
		numipfilters++;
	}

	ipfilters[i] = f;
}

/*
=================
SV_RemoveIP_f
=================
*/
static void SV_RemoveIP_f (void)
{
	ipfilter_t	f;
	int			i, j;

	if (!StringToFilter (Cmd_Argv(1), &f))
	{
		Con_Printf ("Bad filter address: %s\n", Cmd_Argv(1));
		return;
	}

	for (i=0 ; i<numipfilters ; i++)
		if (ipfilters[i].mask == f.mask
		        && ipfilters[i].compare == f.compare)
		{
			for (j=i+1 ; j<numipfilters ; j++)
				ipfilters[j-1] = ipfilters[j];
			numipfilters--;
			Con_Printf ("Removed.\n");
			return;
		}
	Con_Printf ("Didn't find %s.\n", Cmd_Argv(1));
}

/*
=================
SV_ListIP_f
=================
*/
static void SV_ListIP_f (void)
{
	time_t	long_time = time(NULL);
	int		i;
	byte	b[4];

	Con_Printf ("Filter list:\n");
	for (i=0 ; i<numipfilters ; i++)
	{
		*(unsigned *)b = ipfilters[i].compare;
		Con_Printf ("%3i.%3i.%3i.%3i | ", b[0], b[1], b[2], b[3]);
		switch((int)ipfilters[i].type){
			case ipft_ban:  Con_Printf (" ban"); break;
			case ipft_safe: Con_Printf ("safe"); break;
			default: Con_Printf ("unkn"); break;
		}
		if (ipfilters[i].time)
			Con_Printf (" | %i s", (int)(ipfilters[i].time-long_time));
		Con_Printf ("\n");
	}
}

/*
=================
SV_WriteIP_f
=================
*/
static void SV_WriteIP_f (void)
{
	FILE	*f;
	char	name[MAX_OSPATH], *s;
	byte	b[4];
	int		i;

	snprintf (name, MAX_OSPATH, "%s/listip.cfg", fs_gamedir);

	Con_Printf ("Writing %s.\n", name);

	f = fopen (name, "wb");
	if (!f)
	{
		Con_Printf ("Couldn't open %s\n", name);
		return;
	}

	// write safe filters first
	for (i=0 ; i<numipfilters ; i++)
	{
		if(ipfilters[i].type != ipft_safe)
			continue;

		*(unsigned *)b = ipfilters[i].compare;
		fprintf (f, "addip %i.%i.%i.%i safe %.0f\n", b[0], b[1], b[2], b[3], ipfilters[i].time);
	}

	for (i=0 ; i<numipfilters ; i++)
	{
		if(ipfilters[i].type == ipft_safe)
			continue; // ignore safe, we already save it

		switch((int)ipfilters[i].type){
			case ipft_ban:  s = " ban"; break;
			case ipft_safe: s = "safe"; break;
			default: s = "unkn"; break;
		}
		*(unsigned *)b = ipfilters[i].compare;
		fprintf (f, "addip %i.%i.%i.%i %s %.0f\n", b[0], b[1], b[2], b[3], s, ipfilters[i].time);
	}

	fclose (f);

	// force cache rebuild.
	FS_FlushFSHash();
}

/*
=================
SV_SendBan
=================
*/
void SV_SendBan (void)
{
	char		data[128];

	data[0] = data[1] = data[2] = data[3] = 0xff;
	data[4] = A2C_PRINT;
	data[5] = 0;
	strlcat (data, "\nbanned.\n", sizeof(data));

	NET_SendPacket (NS_SERVER, strlen(data), data, net_from);
}

/*
=================
SV_FilterPacket
=================
*/
qbool SV_FilterPacket (void)
{
	int		i;
	unsigned	in;

	in = *(unsigned *)net_from.ip;

	for (i=0 ; i<numipfilters ; i++)
		if ( ipfilters[i].type == ipft_ban && (in & ipfilters[i].mask) == ipfilters[i].compare )
			return (int)filterban.value;

	return !(int)filterban.value;
}

// { server internal BAN support

#define AF_REAL_ADMIN    (1<<1)    // pass/vip granted admin.

void Do_BanList(ipfiltertype_t ipft)
{
	time_t	long_time = time(NULL);
	int		i;
	byte	b[4];

	for (i=0 ; i<numipfilters ; i++)
	{
		if (ipfilters[i].type != ipft)
			continue;

		*(unsigned *)b = ipfilters[i].compare;
		Con_Printf ("%3i|%3i.%3i.%3i.%3i", i, b[0], b[1], b[2], b[3]);
		switch((int)ipfilters[i].type){
			case ipft_ban:  Con_Printf ("| ban"); break;
			case ipft_safe: Con_Printf ("|safe"); break;
			default: Con_Printf ("|unkn"); break;
		}

		if (ipfilters[i].time) {
			long df = ipfilters[i].time-long_time;
			long d, h, m, s;
			d = df / (60*60*24);
			df -= d * 60*60*24;
			h = df / (60*60);
			df -= h * 60*60;
			m = df /  60;
			df -= m * 60;
			s = df;

			if (d)
				Con_Printf ("|%4ldd:%2ldh", d, h);
			else if (h)
				Con_Printf ("|%4ldh:%2ldm", h, m);
			else
				Con_Printf ("|%4ldm:%2lds", m, s);
		}
		else
			Con_Printf ("|permanent");
		Con_Printf ("\n");
	}
}

void SV_BanList (void)
{
	unsigned char blist[64] = "Ban list:", id[64] = "id", ipmask[64] = "ip mask", type[64] = "type", expire[64] = "expire";

	if (numipfilters < 1) {
		Con_Printf ("Ban list: empty\n");
		return;
	}

	Con_Printf ("%s\n"
				"\235\236\236\236\236\236\236\236\236\236\236\236\236\236\236\236"
				"\236\236\236\236\236\236\236\236\236\236\236\236\236\236\236\236\236\237\n"
				"%3.3s|%15.15s|%4.4s|%9.9s\n",
				Q_redtext(blist), Q_redtext(id), Q_redtext(ipmask), Q_redtext(type), Q_redtext(expire));

	Do_BanList(ipft_safe);
	Do_BanList(ipft_ban);
}

qbool SV_CanAddBan (ipfilter_t *f)
{
	int i;

	if (f->compare == 0)
		return false;

	for (i=0 ; i<numipfilters ; i++)
		if (ipfilters[i].mask == f->mask && ipfilters[i].compare == f->compare && ipfilters[i].type == ipft_safe)
			return false; // can't add filter f because present "safe" filter

	return true;
}

void SV_RemoveBansIPFilter (int i)
{
	for (; i + 1 < numipfilters; i++)
		ipfilters[i] = ipfilters[i + 1];

	numipfilters--;
}

void SV_CleanBansIPList (void)
{
	time_t	long_time = time(NULL);
	int     i;

	if (sv.state != ss_active)
		return;

	for (i = 0; i < numipfilters;)
	{
		if (ipfilters[i].time && ipfilters[i].time <= long_time)
		{
			SV_RemoveBansIPFilter (i);
		}
		else
			i++;
	}
}

void SV_Cmd_Ban_f(void)
{
	edict_t	*ent;
	eval_t *val;
	double		d;
	int			i, j, t;
	client_t	*cl;
	ipfilter_t  f;
	int			uid;
	int			c;
	char		reason[80] = "", arg2[32], arg2c[sizeof(arg2)], *s;

	// set up the edict
	ent = sv_client->edict;

// ============
// get ADMIN rights from MOD via "mod_admin" field, mod MUST export such field if wanna server ban support
// ============

	val = PR_GetEdictFieldValue(ent, "mod_admin");
	if (!val || !(val->_int & AF_REAL_ADMIN) ) {
		Con_Printf("You are not an admin\n");
		return;
	}

	c = Cmd_Argc ();
	if (c < 3)
	{
		Con_Printf("usage: cmd ban <id/nick> <time<s m h d>> [reason]\n");
		return;
	}

	uid = Q_atoi(Cmd_Argv(1));

	strlcpy(arg2, Cmd_Argv(2), sizeof(arg2));

	// sscanf safe here since sizeof(arg2) == sizeof(arg2c), right?
	if (sscanf(arg2, "%d%s", &t, arg2c) != 2 || strlen(arg2c) != 1) {
		Con_Printf("ban: wrong time arg\n");
		return;
	}

	d = t = bound(0, t, 999);
	switch(arg2c[0]) {
		case 's': break; // seconds is seconds
		case 'm': d *= 60; break; // 60 seconds per minute
		case 'h': d *= 60*60; break; // 3600 seconds per hour
		case 'd': d *= 60*60*24; break; // 86400 seconds per day
		default:
		Con_Printf("ban: wrong time arg\n");
		return;
	}

	for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (!cl->state)
			continue;
		if (cl->userid == uid || !strcmp(Cmd_Argv(1), cl->name))
		{
			if (c > 3) // serve reason arguments
			{
				strlcpy (reason, " (", sizeof(reason));
				for (j=3 ; j<c; j++)
				{
					strlcat (reason, Cmd_Argv(j), sizeof(reason)-4);
					if (j < c-1)
						strlcat (reason, " ", sizeof(reason)-4);
				}
				if (strlen(reason) < 3)
					reason[0] = '\0';
				else
					strlcat (reason, ")", sizeof(reason));
			}

			s = NET_BaseAdrToString(cl->netchan.remote_address);
			if (!StringToFilter (s, &f))
			{
				Con_Printf ("ban: bad ip address: %s\n", s);
				return;
			}

			if (!SV_CanAddBan(&f))
			{
				Con_Printf ("ban: can't ban such ip: %s\n", s);
				return;
			}

			SV_BroadcastPrintf (PRINT_HIGH, "%s was banned for %d%s%s\n", cl->name, t, arg2c, reason);

			Cbuf_AddText(va("addip %s ban %s%.0lf\n", s, d ? "+" : "", d));
			Cbuf_AddText("writeip\n");
			return;
		}
	}

	Con_Printf ("Couldn't find user %s\n", Cmd_Argv(1));
}

void SV_Cmd_Banip_f(void)
{
	edict_t	*ent;
	eval_t *val;
	byte	b[4];
	double		d;
	int			c, t;
	ipfilter_t  f;
	char		arg2[32], arg2c[sizeof(arg2)];

	// set up the edict
	ent = sv_client->edict;

// ============
// get ADMIN rights from MOD via "mod_admin" field, mod MUST export such field if wanna server ban support
// ============

	val = PR_GetEdictFieldValue(ent, "mod_admin");
	if (!val || !(val->_int & AF_REAL_ADMIN) ) {
		Con_Printf("You are not an admin\n");
		return;
	}

	c = Cmd_Argc ();
	if (c < 3)
	{
		Con_Printf("usage: cmd banip <ip> <time<s m h d>>\n");
		return;
	}

	if (!StringToFilter (Cmd_Argv(1), &f))
	{
		Con_Printf ("ban: bad ip address: %s\n", Cmd_Argv(1));
		return;
	}

	if (!SV_CanAddBan(&f))
	{
		Con_Printf ("ban: can't ban such ip: %s\n", Cmd_Argv(1));
		return;
	}

	strlcpy(arg2, Cmd_Argv(2), sizeof(arg2));

	// sscanf safe here since sizeof(arg2) == sizeof(arg2c), right?
	if (sscanf(arg2, "%d%s", &t, arg2c) != 2 || strlen(arg2c) != 1) {
		Con_Printf("ban: wrong time arg\n");
		return;
	}

	d = t = bound(0, t, 999);
	switch(arg2c[0]) {
		case 's': break; // seconds is seconds
		case 'm': d *= 60; break; // 60 seconds per minute
		case 'h': d *= 60*60; break; // 3600 seconds per hour
		case 'd': d *= 60*60*24; break; // 86400 seconds per day
		default:
		Con_Printf("ban: wrong time arg\n");
		return;
	}

	*(unsigned *)b = f.compare;
	SV_BroadcastPrintf (PRINT_HIGH, "%3i.%3i.%3i.%3i was banned for %d%s\n", b[0], b[1], b[2], b[3], t, arg2c);

	Cbuf_AddText(va("addip %i.%i.%i.%i ban %s%.0lf\n", b[0], b[1], b[2], b[3], d ? "+" : "", d));
	Cbuf_AddText("writeip\n");
}

void SV_Cmd_Banremove_f(void)
{
	edict_t	*ent;
	eval_t *val;
	byte	b[4];
	int		id;

	// set up the edict
	ent = sv_client->edict;

// ============
// get ADMIN rights from MOD via "mod_admin" field, mod MUST export such field if wanna server ban support
// ============

	val = PR_GetEdictFieldValue(ent, "mod_admin");
	if (!val || !(val->_int & AF_REAL_ADMIN) ) {
		Con_Printf("You are not an admin\n");
		return;
	}

	if (Cmd_Argc () < 2)
	{
		Con_Printf("usage: cmd banrem [banid]\n");
		SV_BanList();
		return;
	}

	id = Q_atoi(Cmd_Argv(1));

	if (id < 0 || id >= numipfilters) {
		Con_Printf ("Wrong ban id: %d\n", id);
		return;
	}

	if (ipfilters[id].type == ipft_safe) {
		Con_Printf ("Can't remove such ban with id: %d\n", id);
		return;
	}

	*(unsigned *)b = ipfilters[id].compare;
	SV_BroadcastPrintf (PRINT_HIGH, "%3i.%3i.%3i.%3i was unbanned\n", b[0], b[1], b[2], b[3]);

	SV_RemoveBansIPFilter (id);
	Cbuf_AddText("writeip\n");
}

// } server internal BAN support

/*
=================
SV_VIPbyIP
=================
*/
int SV_VIPbyIP (netadr_t adr)
{
	int		i;
	unsigned	in;

	in = *(unsigned *)adr.ip;

	for (i=0 ; i<numipvips ; i++)
		if ( (in & ipvip[i].mask) == ipvip[i].compare)
			return ipvip[i].level;

	return 0;
}

/*
=================
SV_VIPbyPass
=================
*/
int SV_VIPbyPass (char *pass)
{
	qbool use_value = false;
	int vip_value[MAX_ARGS];
	int i;

	if (!vip_password.string[0] || !strcasecmp(vip_password.string, "none"))
		return 0;

	if (vip_values.string[0]) {
		use_value = true;
		// 2VVD: vip_password count may be not equal vip_values count, what we must do in this case?
		memset((void*)vip_value, 0, sizeof(vip_value));
		Cmd_TokenizeString(vip_values.string);
		for (i = 0; i < Cmd_Argc(); i++)
			vip_value[i] = atoi(Cmd_Argv(i));
	}

	Cmd_TokenizeString(vip_password.string);

	for (i = 0; i < Cmd_Argc(); i++)
		if (!strcmp(Cmd_Argv(i), pass) && strcasecmp(Cmd_Argv(i), "none"))
			return (use_value ? vip_value[i] : i+1);

	return 0;
}

static char *DecodeArgs(char *args)
{
	static char string[1024];
	char *p, key[32], *s, *value, ch, tmp_value[512];

	string[0] = 0;
	p = string;

	while (*args)
	{
		// skip whitespaces
		while (*args && *args <= 32)
			*p++ = *args++;

		if (*args == '\"')
		{
			do *p++ = *args++; while (*args && *args != '\"');
			*p++ = '\"';
			if (*args)
				args++;
		}
		else if (*args == '@' || *args == '$')
		{
			// get the key and read value from localinfo
			ch = *args;
			s = key;
			args++;
			while (*args > 32)
				*s++ = *args++;
			*s = 0;

			if ((value = Info_ValueForKey (svs.info, key)) == NULL || !*value)
				value = Info_Get(&_localinfo_, key);

			if (ch == '$' && value)
			{
				strlcpy(tmp_value, value, sizeof(tmp_value));
				Q_normalizetext(tmp_value);
				value = tmp_value;
			}

			*p++ = '\"';
			if (value)
			{
				while (*value)
					*p++ = *value++;
			}
			*p++ = '\"';
		}
		else {
			while (*args > 32) {
				*p++ = *args++;
			}
		}
	}

	*p = 0;

	return string;
}

void SV_Script_f (void)
{
	char *path, *p;
	extern redirect_t sv_redirected;

	if (Cmd_Argc() < 2)
	{
		Con_Printf("usage: script <path> [<args>]\n");
		return;
	}

	path = Cmd_Argv(1);

	//bliP: 24/9 need subdirs here ->
	if (!strncmp(path, "../", 3) || !strncmp(path, "..\\", 3))
		path += 3;

	if (strstr(path, ".."))
	{
		Con_Printf("Invalid path.\n");
		return;
	}
	//<-

	path = Cmd_Argv(1);

	p = Cmd_Args();
	while (*p > 32)
		p++;
	while (*p && *p <= 32)
		p++;

	p = DecodeArgs(p);

	if (sv_redirected != RD_MOD)
		Sys_Printf("Running %s.qws\n", path);

	Sys_Script(path, va("%d %s", sv_redirected, p));

}

//============================================================================

//bliP: cuff, mute ->
void SV_RemoveIPFilter (int i)
{
	for (; i + 1 < numpenfilters; i++)
		penfilters[i] = penfilters[i + 1];

	numpenfilters--;
}

static void SV_CleanIPList (void)
{
	int     i;

	if (sv.state != ss_active)
		return;

	for (i = 0; i < numpenfilters;)
	{
		if (penfilters[i].time && (penfilters[i].time <= realtime))
		{
			SV_RemoveIPFilter (i);
		}
		else
			i++;
	}
}

static qbool SV_IPCompare (byte *a, byte *b)
{
	int i;

	for (i = 0; i < 1; i++)
		if (((unsigned int *)a)[i] != ((unsigned int *)b)[i])
			return false;

	return true;
}

static void SV_IPCopy (byte *dest, byte *src)
{
	int i;

	for (i = 0; i < 1; i++)
		((unsigned int *)dest)[i] = ((unsigned int *)src)[i];
}

void SV_SavePenaltyFilter (client_t *cl, filtertype_t type, double pentime)
{
	int i;

	if (pentime < curtime)   // no point
		return;

	for (i = 0; i < numpenfilters; i++)
		if (SV_IPCompare (penfilters[i].ip, cl->realip.ip)	&& penfilters[i].type == type)
		{
			return;
		}

	if (numpenfilters == MAX_IPFILTERS)
	{
		return;
	}

	SV_IPCopy (penfilters[numpenfilters].ip, cl->realip.ip);
	penfilters[numpenfilters].time = pentime;
	penfilters[numpenfilters].type = type;
	numpenfilters++;
}

double SV_RestorePenaltyFilter (client_t *cl, filtertype_t type)
{
	int i;
	double time1 = 0.0;

	// search for existing penalty filter of same type
	for (i = 0; i < numpenfilters; i++)
	{
		if (type == penfilters[i].type && SV_IPCompare (cl->realip.ip, penfilters[i].ip))
		{
			time1 = penfilters[i].time;
			SV_RemoveIPFilter (i);
			return time1;
		}
	}
	return time1;
}
//<-

//============================================================================

/*
=================
SV_ReadPackets
=================
*/
static void SV_ReadPackets (void)
{
	client_t *cl;
	int qport;
	int i;

	if (sv.state != ss_active)
		return;

	// first deal with delayed packets from connected clients
	for (i = 0, cl=svs.clients; i < MAX_CLIENTS; i++, cl++)
	{
		if (cl->state == cs_free)
			continue;

		net_from = cl->netchan.remote_address;

		while (cl->packets && (realtime - cl->packets->time >= cl->delay || sv.paused))
		{
			SZ_Clear(&net_message);
			SZ_Write(&net_message, cl->packets->msg.data, cl->packets->msg.cursize);
			SV_ExecuteClientMessage(cl);
			SV_FreeHeadDelayedPacket(cl);
		}
	}

	// now deal with new packets
	while (NET_GetPacket(NS_SERVER))
	{
		if (SV_FilterPacket ())
		{
			SV_SendBan ();	// tell them we aren't listening...
			continue;
		}

		// check for connectionless packet (0xffffffff) first
		if (*(int *)net_message.data == -1)
		{
			SV_ConnectionlessPacket ();
			continue;
		}

		// read the qport out of the message so we can fix up
		// stupid address translating routers
		MSG_BeginReading ();
		MSG_ReadLong (); // sequence number
		MSG_ReadLong (); // sequence number
		qport = MSG_ReadShort () & 0xffff;

		// check which client sent this packet
		for (i=0, cl=svs.clients ; i<MAX_CLIENTS ; i++,cl++)
		{
			if (cl->state == cs_free)
				continue;
			if (!NET_CompareBaseAdr (net_from, cl->netchan.remote_address))
				continue;
			if (cl->netchan.qport != qport)
				continue;
			if (cl->netchan.remote_address.port != net_from.port)
			{
				Con_DPrintf ("SV_ReadPackets: fixing up a translated port\n");
				cl->netchan.remote_address.port = net_from.port;
			}

			break;
		}

		if (i == MAX_CLIENTS)
			continue;

		// ok, we know who sent this packet, but do we need to delay executing it?
		if (cl->delay > 0)
		{
			if (!svs.free_packets) // packet has to be dropped..
				break;

			// insert at end of list
			if (!cl->packets) {
				cl->last_packet = cl->packets = svs.free_packets;
			} else {
				// this works because '=' associates from right to left
				cl->last_packet = cl->last_packet->next = svs.free_packets;
			}

			svs.free_packets = svs.free_packets->next;
			cl->last_packet->next = NULL;

			cl->last_packet->time = realtime;
			SZ_Clear(&cl->last_packet->msg);
			SZ_Write(&cl->last_packet->msg, net_message.data, net_message.cursize);
		}
		else
		{
			SV_ExecuteClientMessage (cl);
		}
	}
}


/*
==================
SV_CheckTimeouts

If a packet has not been received from a client in timeout.value
seconds, drop the conneciton.

When a client is normally dropped, the client_t goes into a zombie state
for a few seconds to make sure any final reliable message gets resent
if necessary
==================
*/
static void SV_CheckTimeouts (void)
{
	int i, nclients;
	float droptime;
	client_t *cl;

	if (sv.state != ss_active)
		return;

	droptime = curtime - timeout.value;
	nclients = 0;

	for (i=0,cl=svs.clients ; i<MAX_CLIENTS ; i++,cl++)
	{
#ifdef USE_PR2
		if( cl->isBot )
			continue;
#endif
		if (cl->state >= cs_preconnected /*|| cl->state == cs_spawned*/)
		{
			if (!cl->spectator)
				nclients++;
			if (cl->netchan.last_received < droptime)
			{
				SV_BroadcastPrintf (PRINT_HIGH, "%s timed out\n", cl->name);
				SV_DropClient (cl);
				cl->state = cs_free;	// don't bother with zombie state
			}
			if (!cl->logged && !cl->logged_in_via_web) {
				SV_LoginCheckTimeOut(cl);
			}
		}
		if (cl->state == cs_zombie && SV_ClientConnectedTime(cl) > zombietime.value)
		{
			cl->state = cs_free;	// can now be reused
		}
	}
	if ((sv.paused & 1) && !nclients)
	{
		// nobody left, unpause the server
		if (GE_ShouldPause) {
			pr_global_struct->time = sv.time;
			pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
			G_FLOAT(OFS_PARM0) = 0 /* newstate = false */;
			PR_ExecuteProgram (GE_ShouldPause);
			if (!G_FLOAT(OFS_RETURN))
				return;		// progs said don't unpause
		}
		SV_TogglePause("Pause released since no players are left.\n", 1);
	}
}

#ifdef SERVERONLY
/*
===================
SV_GetConsoleCommands

Add them exactly as if they had been typed at the console
===================
*/
static void SV_GetConsoleCommands (void)
{
	char	*cmd;

	while (1)
	{
		cmd = Sys_ConsoleInput ();
		if (!cmd)
			break;
		Cbuf_AddText (cmd);
		Cbuf_AddText ("\n");
	}
}
#endif

/*
===================
SV_BoundRate
===================
*/
int SV_BoundRate (qbool dl, int rate)
{
	if (!rate)
		rate = 2500;
	if (dl)
	{
		if (!(int)sv_maxdownloadrate.value && (int)sv_maxrate.value && rate > (int)sv_maxrate.value)
			rate = (int)sv_maxrate.value;

		if (sv_maxdownloadrate.value && rate > sv_maxdownloadrate.value)
			rate = (int)sv_maxdownloadrate.value;
	}
	else
		if ((int)sv_maxrate.value && rate > (int) sv_maxrate.value)
			rate = (int)sv_maxrate.value;

	if (rate < 500)
		rate = 500;

	if (rate > 100000 * MAX_DUPLICATE_PACKETS)
		rate = 100000 * MAX_DUPLICATE_PACKETS;

	return rate;
}


/*
===================
SV_CheckVars

===================
*/

static void SV_CheckVars (void)
{
	static char pw[MAX_KEY_STRING] = {0}, spw[MAX_KEY_STRING] = {0}, vspw[MAX_KEY_STRING]= {0};
	static float old_maxrate = 0, old_maxdlrate = 0;
	int v;

	if (sv.state != ss_active)
		return;

	// check password and spectator_password
	if (strcmp(password.string, pw) ||
		strcmp(spectator_password.string, spw) || strcmp(vip_password.string, vspw))
	{
		strlcpy (pw, password.string, sizeof(pw));
		strlcpy (spw, spectator_password.string, sizeof(spw));
		strlcpy (vspw, vip_password.string, sizeof(vspw));
		Cvar_Set (&password, pw);
		Cvar_Set (&spectator_password, spw);
		Cvar_Set (&vip_password, vspw);

		v = 0;
		if (pw[0] && strcmp(pw, "none"))
			v |= 1;
		if (spw[0] && strcmp(spw, "none"))
			v |= 2;
		if (vspw[0] && strcmp(vspw, "none"))
			v |= 4;

		Con_DPrintf ("Updated needpass.\n");
		if (!v)
			Info_SetValueForKey (svs.info, "needpass", "", MAX_SERVERINFO_STRING);
		else
			Info_SetValueForKey (svs.info, "needpass", va("%i",v), MAX_SERVERINFO_STRING);
	}

	// check sv_maxrate
	if ((int)sv_maxrate.value != old_maxrate || (int)sv_maxdownloadrate.value != old_maxdlrate )
	{
		client_t	*cl;
		int			i;
		char		*val;

		old_maxrate = (int)sv_maxrate.value;
		old_maxdlrate = (int)sv_maxdownloadrate.value;

		for (i=0, cl = svs.clients ; i<MAX_CLIENTS ; i++, cl++)
		{
			if (cl->state < cs_preconnected)
				continue;

			val = Info_Get (&cl->_userinfo_ctx_, cl->download ? "drate" : "rate");
			cl->netchan.rate = 1.0 / SV_BoundRate (cl->download != NULL, Q_atoi(*val ? val : "99999"));
		}
	}
}

static void PausedTic (void)
{
	if (sv.state != ss_active)
		return;

	PR_PausedTic(Sys_DoubleTime() - sv.pausedsince);
}

/*
==================
SV_Frame

==================
*/
void SV_Map (qbool now);
void SV_Frame (double time1)
{
	static double start, end;
	double demo_start, demo_end;

	start = Sys_DoubleTime ();
	svs.stats.idle += start - end;

	// keep the random time dependent
	rand ();

	// decide the simulation time
	if (!sv.paused)
	{
		realtime += time1;
		sv.time += time1;
	}

	// check timeouts
	SV_CheckTimeouts ();

	//bliP: cuff, mute ->
	// clean out expired cuffs/mutes
	SV_CleanIPList ();
	//<-

	// clean out bans
	SV_CleanBansIPList ();

	// toggle the log buffer if full
	SV_CheckLog ();

	SV_MVDStream_Poll();

#ifdef SERVERONLY
	// check for commands typed to the host
	SV_GetConsoleCommands ();

	// process console commands
	Cbuf_Execute ();
#endif

	// check for map change;
	SV_Map(true);

	SV_CheckVars ();

	// get packets
	SV_ReadPackets ();

	// move autonomous things around if enough time has passed
	if (!sv.paused) {
		SV_Physics();
#ifdef USE_PR2
		SV_RunBots();
#endif
	}
	else
		PausedTic ();

	// send messages back to the clients that had packets read this frame
	SV_SendClientMessages ();

#if defined(SERVERONLY) && defined(WWW_INTEGRATION)
	Central_ProcessResponses();
#endif

	demo_start = Sys_DoubleTime ();
	SV_SendDemoMessage();
	demo_end = Sys_DoubleTime ();
	svs.stats.demo += demo_end - demo_start;

	// send a heartbeat to the master if needed
	Master_Heartbeat ();

	// collect timing statistics
	end = Sys_DoubleTime ();
	svs.stats.active += end-start;
	if (++svs.stats.count == STATFRAMES)
	{
		svs.stats.latched_active = svs.stats.active;
		svs.stats.latched_idle = svs.stats.idle;
		svs.stats.latched_packets = svs.stats.packets;
		svs.stats.latched_demo = svs.stats.demo;
		svs.stats.active = 0;
		svs.stats.idle = 0;
		svs.stats.packets = 0;
		svs.stats.count = 0;
		svs.stats.demo = 0;
	}
}

/*
===============
SV_InitLocal
===============
*/
void SV_InitLocal (void)
{
	int		i;
	char	cmd_line[1024] = {0};

	extern	cvar_t	sv_maxvelocity;
	extern	cvar_t	sv_gravity;
	extern	cvar_t	sv_stopspeed;
	extern	cvar_t	sv_spectatormaxspeed;
	extern	cvar_t	sv_accelerate;
	extern	cvar_t	sv_airaccelerate;
	extern	cvar_t	sv_wateraccelerate;
	extern	cvar_t	sv_friction;
	extern	cvar_t	sv_waterfriction;
	extern	cvar_t	sv_nailhack;

	extern cvar_t	sv_maxpitch;
	extern cvar_t	sv_minpitch;

	extern	cvar_t	pm_airstep;
	extern	cvar_t	pm_pground;
	extern  cvar_t  pm_rampjump;
	extern	cvar_t	pm_slidefix;
	extern	cvar_t	pm_ktjump;
	extern	cvar_t	pm_bunnyspeedcap;

	// qws = QuakeWorld Server information
	static cvar_t qws_name = { "qws_name", SERVER_NAME, CVAR_ROM };
	static cvar_t qws_fullname = { "qws_fullname", SERVER_FULLNAME, CVAR_ROM };
	static cvar_t qws_version = { "qws_version", SERVER_VERSION, CVAR_ROM };
	static cvar_t qws_buildnum = { "qws_buildnum", "unknown", CVAR_ROM };
	static cvar_t qws_platform = { "qws_platform", QW_PLATFORM_SHORT, CVAR_ROM };
	static cvar_t qws_builddate = { "qws_builddate", BUILD_DATE, CVAR_ROM };
	static cvar_t qws_homepage = { "qws_homepage", SERVER_HOME_URL, CVAR_ROM };
	// qwm = QuakeWorld Mod information placeholders
	static cvar_t qwm_name = { "qwm_name", "" };
	static cvar_t qwm_fullname = { "qwm_fullname", "" };
	static cvar_t qwm_version = { "qwm_version", "" };
	static cvar_t qwm_buildnum = { "qwm_buildnum", "" };
	static cvar_t qwm_platform = { "qwm_platform", "" };
	static cvar_t qwm_builddate = { "qwm_builddate", "" };
	static cvar_t qwm_homepage = { "qwm_homepage", "" };

	packet_t *packet_freeblock; // initialise delayed packet free block

	SV_InitOperatorCommands	();
	SV_UserInit ();

	Cvar_Register (&sv_getrealip);
	Cvar_Register (&sv_maxdownloadrate);
	Cvar_Register (&sv_serverip);
	Cvar_Register (&sv_forcespec_onfull);

#ifdef SERVERONLY
	Cvar_Register (&rcon_password);
	Cvar_Register (&password);
#endif

	Cvar_Register (&sv_hashpasswords);
	//Added by VVD {
	Cvar_Register (&sv_crypt_rcon);
	Cvar_Register (&sv_timestamplen);
	Cvar_Register (&sv_rconlim);

	Cvar_Register (&telnet_log_level);

	Cvar_Register (&frag_log_type);
	Cvar_Register (&qconsole_log_say);
	Cvar_Register (&sv_use_dns);

	for (i = 0; i < COM_Argc(); i++)
	{
		if (i)
			strlcat(cmd_line, " ", sizeof(cmd_line));
		strlcat(cmd_line, COM_Argv(i), sizeof(cmd_line));
	}
	Cvar_Register (&sys_command_line);
	Cvar_SetROM(&sys_command_line, cmd_line);

	//Added by VVD }
	Cvar_Register (&spectator_password);
	Cvar_Register (&vip_password);
	Cvar_Register (&vip_values);

	Cvar_Register (&sv_nailhack);

	Cvar_Register (&sv_mintic);
	Cvar_Register (&sv_maxtic);
	Cvar_Register (&sv_maxfps);
	Cvar_Register (&sys_select_timeout);
	Cvar_Register (&sys_restart_on_error);

	Cvar_Register (&sv_maxpitch);
	Cvar_Register (&sv_minpitch);

	Cvar_Register (&skill);
	Cvar_Register (&coop);

	Cvar_Register (&fraglimit);
	Cvar_Register (&timelimit);
	Cvar_Register (&teamplay);
	Cvar_Register (&samelevel);
	Cvar_Register (&maxclients);
	Cvar_Register (&maxspectators);
	Cvar_Register (&maxvip_spectators);
	Cvar_Register (&hostname);
	Cvar_Register (&deathmatch);
	Cvar_Register (&watervis);
	Cvar_Register (&serverdemo);
	Cvar_Register (&sv_paused);

	Cvar_Register (&timeout);
	Cvar_Register (&zombietime);

	Cvar_Register (&sv_maxvelocity);
	Cvar_Register (&sv_gravity);
	Cvar_Register (&sv_stopspeed);
	Cvar_Register (&sv_maxspeed);
	Cvar_Register (&sv_spectatormaxspeed);
	Cvar_Register (&sv_accelerate);
	Cvar_Register (&sv_airaccelerate);
	Cvar_Register (&sv_wateraccelerate);
	Cvar_Register (&sv_friction);
	Cvar_Register (&sv_waterfriction);

	Cvar_Register (&sv_antilag);
	Cvar_Register (&sv_antilag_no_pred);
	Cvar_Register (&sv_antilag_projectiles);

	Cvar_Register (&pm_bunnyspeedcap);
	Cvar_Register (&pm_ktjump);
	Cvar_Register (&pm_slidefix);
	Cvar_Register (&pm_pground);
	Cvar_Register (&pm_airstep);
	Cvar_Register (&pm_rampjump);

	Cvar_Register (&filterban);

	Cvar_Register (&allow_download);
	Cvar_Register (&allow_download_skins);
	Cvar_Register (&allow_download_models);
	Cvar_Register (&allow_download_sounds);
	Cvar_Register (&allow_download_maps);
	Cvar_Register (&allow_download_pakmaps);
	Cvar_Register (&allow_download_demos);
	Cvar_Register (&allow_download_other);
	//bliP: init ->
	Cvar_Register (&download_map_url);

	Cvar_Register (&sv_specprint);
	Cvar_Register (&sv_admininfo);
	Cvar_Register (&sv_reconnectlimit);
	Cvar_Register (&sv_maxlogsize);
	//bliP: 24/9 ->
	Cvar_Register (&sv_logdir);
	Cvar_Register (&sv_speedcheck);
	Cvar_Register (&sv_unfake); // kickfake to unfake
	//<-
	Cvar_Register (&sv_kicktop);
	//<-
	Cvar_Register (&sv_allowlastscores);
//	Cvar_Register (&sv_highchars);
	Cvar_Register (&sv_phs);
	Cvar_Register (&pausable);
	Cvar_Register (&sv_maxrate);
	Cvar_Register (&sv_loadentfiles);
	Cvar_Register (&sv_loadentfiles_dir);
	Cvar_Register (&sv_default_name);
	Cvar_Register (&sv_mod_msg_file);
	Cvar_Register (&sv_forcenick);
	Cvar_Register (&sv_registrationinfo);
	Cvar_Register (&registered);

	Cvar_Register (&sv_halflifebsp);
	Cvar_Register (&sv_bspversion);
	Cvar_Register (&sv_serveme_fix);

#ifdef FTE_PEXT_FLOATCOORDS
	Cvar_Register (&sv_bigcoords);
#endif

	Cvar_Register (&sv_extlimits);
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	Cvar_Register (&sv_pext_mvdsv_serversideweapon);
#endif

#ifdef FTE_PEXT_TRANS
	Cvar_Register(&sv_pext_ezquake_verfortrans);
#endif

	Cvar_Register (&sv_reliable_sound);

	Cvar_Register(&qws_name);
	Cvar_Register(&qws_fullname);
	Cvar_Register(&qws_version);
	if (GIT_COMMIT[0]) {
		qws_buildnum.string = GIT_COMMIT;
	}
	Cvar_Register(&qws_buildnum);
	Cvar_Register(&qws_platform);
	Cvar_Register(&qws_builddate);
	Cvar_Register(&qws_homepage);
	Cvar_Register(&qwm_name);
	Cvar_Register(&qwm_fullname);
	Cvar_Register(&qwm_version);
	Cvar_Register(&qwm_buildnum);
	Cvar_Register(&qwm_platform);
	Cvar_Register(&qwm_builddate);
	Cvar_Register(&qwm_homepage);

	Cvar_Register(&sv_mod_extensions);

// QW262 -->
	Cmd_AddCommand ("svadmin", SV_Admin_f);
// <-- QW262

	Cmd_AddCommand ("addip", SV_AddIP_f);
	Cmd_AddCommand ("removeip", SV_RemoveIP_f);
	Cmd_AddCommand ("listip", SV_ListIP_f);
	Cmd_AddCommand ("writeip", SV_WriteIP_f);
	Cmd_AddCommand ("vip_addip", SV_AddIPVIP_f);
	Cmd_AddCommand ("vip_removeip", SV_RemoveIPVIP_f);
	Cmd_AddCommand ("vip_listip", SV_ListIPVIP_f);
	Cmd_AddCommand ("vip_writeip", SV_WriteIPVIP_f);


	for (i=0 ; i<MAX_MODELS ; i++)
		snprintf (localmodels[i], MODEL_NAME_LEN, "*%i", i);

#ifdef FTE_PEXT_ACCURATETIMINGS
	svs.fteprotocolextensions |= FTE_PEXT_ACCURATETIMINGS;
#endif
#ifdef FTE_PEXT_256PACKETENTITIES
	svs.fteprotocolextensions |= FTE_PEXT_256PACKETENTITIES;
#endif
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	svs.fteprotocolextensions |= FTE_PEXT_CHUNKEDDOWNLOADS;
#endif
#ifdef FTE_PEXT_FLOATCOORDS
	svs.fteprotocolextensions |= FTE_PEXT_FLOATCOORDS;
#endif
#ifdef FTE_PEXT_MODELDBL
	svs.fteprotocolextensions |= FTE_PEXT_MODELDBL;
#endif
#ifdef FTE_PEXT_ENTITYDBL
	svs.fteprotocolextensions |= FTE_PEXT_ENTITYDBL;
#endif
#ifdef FTE_PEXT_ENTITYDBL2
	svs.fteprotocolextensions |= FTE_PEXT_ENTITYDBL2;
#endif
#ifdef FTE_PEXT_SPAWNSTATIC2
	svs.fteprotocolextensions |= FTE_PEXT_SPAWNSTATIC2;
#endif
#ifdef FTE_PEXT_TRANS
    svs.fteprotocolextensions |= FTE_PEXT_TRANS;
#endif
#ifdef FTE_PEXT_COLOURMOD
	svs.fteprotocolextensions |= FTE_PEXT_COLOURMOD;
#endif
#ifdef FTE_PEXT2_VOICECHAT
	svs.fteprotocolextensions2 |= FTE_PEXT2_VOICECHAT;
#endif

#ifdef MVD_PEXT1_FLOATCOORDS
	svs.mvdprotocolextension1 |= MVD_PEXT1_FLOATCOORDS;
#endif
#ifdef MVD_PEXT1_HIGHLAGTELEPORT
	svs.mvdprotocolextension1 |= MVD_PEXT1_HIGHLAGTELEPORT;
#endif
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	svs.mvdprotocolextension1 |= MVD_PEXT1_SERVERSIDEWEAPON;
#endif
#ifdef MVD_PEXT1_HIDDEN_MESSAGES
	svs.mvdprotocolextension1 |= MVD_PEXT1_HIDDEN_MESSAGES;
#endif
#ifdef MVD_PEXT1_SERVERSIDEWEAPON2
	svs.mvdprotocolextension1 |= MVD_PEXT1_SERVERSIDEWEAPON2;
#endif

	Info_SetValueForStarKey (svs.info, "*version", SERVER_NAME " " SERVER_VERSION, MAX_SERVERINFO_STRING);
	Info_SetValueForStarKey (svs.info, "*z_ext", va("%i", SERVER_EXTENSIONS), MAX_SERVERINFO_STRING);

	// init fraglog stuff
	svs.logsequence = 1;
	svs.logtime = realtime;
	svs.log[0].data = svs.log_buf[0];
	svs.log[0].maxsize = sizeof(svs.log_buf[0]);
	svs.log[0].cursize = 0;
	svs.log[0].allowoverflow = true;
	svs.log[1].data = svs.log_buf[1];
	svs.log[1].maxsize = sizeof(svs.log_buf[1]);
	svs.log[1].cursize = 0;
	svs.log[1].allowoverflow = true;

	packet_freeblock = (packet_t *) Hunk_AllocName (MAX_DELAYED_PACKETS * sizeof(packet_t), "delayed_packets");

	for (i = 0; i < MAX_DELAYED_PACKETS; i++) {
		SZ_Init (&packet_freeblock[i].msg, packet_freeblock[i].buf, sizeof(packet_freeblock[i].buf));
		packet_freeblock[i].next = &packet_freeblock[i + 1];
	}
	packet_freeblock[MAX_DELAYED_PACKETS - 1].next = NULL;
	svs.free_packets = &packet_freeblock[0];
}


//============================================================================

/*
=================
SV_ExtractFromUserinfo

Pull specific info from a newly changed userinfo string
into a more C freindly form.
=================
*/
void SV_ExtractFromUserinfo (client_t *cl, qbool namechanged)
{
	char	*val, *p;
	int		i;
	client_t	*client;
	int		dupc = 1;
	char	newname[CLIENT_NAME_LEN];

	if (namechanged)
	{
		// name for C code
		val = Info_Get (&cl->_userinfo_ctx_, "name");

		// trim user name
		strlcpy (newname, val, sizeof(newname));

		for (p = val; *p; p++)
		{
			if ((*p & 127) == '\\' || *p == '\r' || *p == '\n' || *p == '$' || *p == '#' || *p == '"' || *p == ';')
			{ // illegal characters in name, set some default
				strlcpy(newname, sv_default_name.string, sizeof(newname));
				break;
			}
		}

		for (p = newname; *p && (*p & 127) == ' '; p++)
			; // empty operator

		if (p != newname) // skip prefixed spaces, if any, even whole string of spaces
			strlcpy(newname, p, sizeof(newname));

		for (p = newname + strlen(newname) - 1; p >= newname; p--)
		{
			if (*p && (*p & 127) != ' ') // skip spaces in suffix, if any
			{
				p[1] = 0;
				break;
			}
		}

		if (strcmp(val, newname))
		{
			Info_Set (&cl->_userinfo_ctx_, "name", newname);
			val = Info_Get (&cl->_userinfo_ctx_, "name");
		}

		if (!val[0] || !Q_namecmp(val, "console") || strstr(val, "&c") || strstr(val, "&r"))
		{
			Info_Set (&cl->_userinfo_ctx_, "name", sv_default_name.string);
			val = Info_Get (&cl->_userinfo_ctx_, "name");
		}

		// check to see if another user by the same name exists
		while ( 1 )
		{
			for (i = 0, client = svs.clients ; i<MAX_CLIENTS ; i++, client++)
			{
				if (client->state != cs_spawned || client == cl)
					continue;

				if (!Q_namecmp(client->name, val))
					break;
			}
			if (i != MAX_CLIENTS)
			{ // dup name
				if (strlen(val) > CLIENT_NAME_LEN - 1)
					val[CLIENT_NAME_LEN - 4] = 0;
				p = val;

				if (val[0] == '(')
				{
					if (val[2] == ')')
						p = val + 3;
					else if (val[3] == ')')
						p = val + 4;
				}

				snprintf(newname, sizeof(newname), "(%d)%-.10s", dupc++, p);
				Info_Set (&cl->_userinfo_ctx_, "name", newname);
				val = Info_Get (&cl->_userinfo_ctx_, "name");
			}
			else
				break;
		}

		if (strncmp(val, cl->name, strlen(cl->name) + 1))
		{
			if (!cl->lastnametime || curtime - cl->lastnametime > 5) {
				cl->lastnamecount = 0;
				cl->lastnametime = curtime;
			}
			else if (cl->lastnamecount++ > 4) {
				SV_BroadcastPrintf(PRINT_HIGH, "%s was kicked for name spamming\n", cl->name);
				SV_ClientPrintf(cl, PRINT_HIGH, "You were kicked from the game for name spamming\n");
				SV_LogPlayer(cl, "name spam", 1); //bliP: player logging
				SV_DropClient(cl);
				return;
			}

			if (cl->state >= cs_spawned && !cl->spectator) {
				SV_BroadcastPrintf(PRINT_HIGH, "%s changed name to %s\n", cl->name, val);
			}
		}

		strlcpy(cl->name, val, CLIENT_NAME_LEN);

		if (cl->state >= cs_spawned) //bliP: player logging
			SV_LogPlayer(cl, "name change", 1);
	}

	// team
	val = Info_Get (&cl->_userinfo_ctx_, "team");
	if (strstr(val, "&c") || strstr(val, "&r"))
		Info_Set (&cl->_userinfo_ctx_, "team", "none");
	strlcpy (cl->team, Info_Get (&cl->_userinfo_ctx_, "team"), sizeof(cl->team));

	// rate
	val = Info_Get (&cl->_userinfo_ctx_, cl->download ? "drate" : "rate");
	cl->netchan.rate = 1.0 / SV_BoundRate (cl->download != NULL, Q_atoi(*val ? val : "99999"));

	// s2c packet dupes
	val = Info_Get(&cl->_userinfo_ctx_, "dupe");
	cl->dupe = atoi(val);
	cl->dupe = (int)bound(0, cl->dupe, MAX_DUPLICATE_PACKETS); // 0=1 packet (aka: no dupes)
	cl->netchan.dupe = (cl->download ? 0 : cl->dupe);

	// message level
	val = Info_Get (&cl->_userinfo_ctx_, "msg");
	if (val[0])
		cl->messagelevel = Q_atoi(val);

	//spectator print
	val = Info_Get(&cl->_userinfo_ctx_, "sp");
	if (val[0])
		cl->spec_print = Q_atoi(val);
}


//============================================================================

void OnChange_sysselecttimeout_var (cvar_t *var, char *value, qbool *cancel)
{
	int t = Q_atoi (value);

	if (t < 1000 || t > 1000000)
	{
		Con_Printf("WARNING: sys_select_timeout can't be less then 1000 (1 millisecond) and more then 1 000 000 (1 second).\n");
		*cancel = true;
		return;
	}
}

//bliP: 24/9 logdir ->
void OnChange_logdir_var (cvar_t *var, char *value, qbool *cancel)
{
	if (strstr(value, ".."))
	{
		*cancel = true;
		return;
	}	

	if (value[0])
		Sys_mkdir (value);
}
//<-

//bliP: admininfo ->
void OnChange_admininfo_var (cvar_t *var, char *value, qbool *cancel)
{
	if (value[0])
		Info_SetValueForStarKey (svs.info, "*admin", value, MAX_SERVERINFO_STRING);
	else
		Info_RemoveKey (svs.info, "*admin");
}
//<-

//bliP: telnet log level ->
void OnChange_telnetloglevel_var (cvar_t *var, char *value, qbool *cancel)
{
	logs[TELNET_LOG].log_level = Q_atoi(value);
}
//<-
void OnChange_qconsolelogsay_var (cvar_t *var, char *value, qbool *cancel)
{
	logs[CONSOLE_LOG].log_level = Q_atoi(value);
}

#ifdef SERVERONLY

void COM_Init (void)
{
	Cvar_Register (&developer);
	Cvar_Register (&version);
	Cvar_Register (&sys_simulation);

	Cvar_SetROM(&version, SERVER_NAME " " SERVER_VERSION);
}

//Free hunk memory up to host_hunklevel
//Can only be called when changing levels!
void Host_ClearMemory (void)
{
	if (!host_initialized)
		Sys_Error ("Host_ClearMemory before host initialized");

	CM_InvalidateMap ();

	// any data previously allocated on hunk is no longer valid
	Hunk_FreeToLowMark (host_hunklevel);
}

//memsize is the recommended amount of memory to use for hunk
void Host_InitMemory (int memsize)
{
	int t;

	if (SV_CommandLineUseMinimumMemory())
		memsize = MINIMUM_MEMORY;

	if ((t = SV_CommandLineHeapSizeMemoryKB()) != 0 && t + 1 < COM_Argc())
		memsize = Q_atoi (COM_Argv(t + 1)) * 1024;

	if ((t = SV_CommandLineHeapSizeMemoryMB()) != 0 && t + 1 < COM_Argc())
		memsize = Q_atoi (COM_Argv(t + 1)) * 1024 * 1024;

	if (memsize < MINIMUM_MEMORY)
		Sys_Error ("Only %4.1f megs of memory reported, can't execute game", memsize / (float)0x100000);

	Memory_Init (Q_malloc(memsize), memsize);
}

void Host_Init (int argc, char **argv, int default_memsize)
{
	extern int		hunk_size;
	cvar_t			*v;

	srand((unsigned)time(NULL));

	COM_InitArgv (argc, argv);

	Host_InitMemory (default_memsize);

	Con_Printf ("============= Starting %s =============\n", VersionStringFull());

	Cbuf_Init ();
	Cmd_Init ();
	Cvar_Init ();
	COM_Init ();

	FS_Init ();
	NET_Init ();

	Netchan_Init ();

	Sys_Init ();
	CM_Init ();

	SV_Init ();

	Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
	host_hunklevel = Hunk_LowMark ();

	host_initialized = true;

	// walk through all vars and forse OnChange event if cvar was modified,
	// also apply that to variables which mirrored in userinfo because of cl_parsefunchars was't applyed as this moment,
	// same for serverinfo and may be this fix something also.
	for ( v = NULL; (v = Cvar_Next ( v )); )
	{
		if ( Cvar_GetFlags( v ) & (CVAR_ROM) )
			continue;

		Cvar_Set(v, v->string);
	}

	Con_Printf ("%4.1f megabyte heap\n", (float)hunk_size / (1024 * 1024));
	Con_Printf ("QuakeWorld Initialized\n");
#ifndef	WWW_INTEGRATION
	Con_Printf ("www authentication disabled (no curl support)\n");
#endif

	Cbuf_InsertText ("exec server.cfg\n");

	// process command line arguments
	Cmd_StuffCmds_f ();
	Cbuf_Execute ();

	host_everything_loaded = true;

	SV_Map(true);

	// if a map wasn't specified on the command line, spawn mvdsv-kg map
	if (sv.state == ss_dead)
	{
		Cmd_ExecuteString ("map mvdsv-kg");
		SV_Map(true);
	}

	// last resort - start map
	if (sv.state == ss_dead)
	{
		Cmd_ExecuteString ("map start");
		SV_Map(true);
	}

	if (sv.state == ss_dead)
		SV_Error ("Couldn't spawn a server");

#if defined (_WIN32) && !defined(_CONSOLE)
	{
		void SetWindowText_(char*);
		SetWindowText_(va(SERVER_NAME ":%d - QuakeWorld server", NET_UDPSVPort()));
	}
#endif
}

#endif // SERVERONLY

/*
====================
SV_Init
====================
*/

void SV_Init (void)
{
	memset(&_localinfo_, 0, sizeof(_localinfo_));
	_localinfo_.max = MAX_LOCALINFOS;

	PR_Init ();

	// send immediately
	svs.last_heartbeat = -99999;

	SV_InitLocal ();

	SV_MVDInit ();
	Login_Init ();
#ifndef SERVERONLY
	server_cfg_done = true;
#endif

#if defined(SERVERONLY) && defined(WWW_INTEGRATION)
	Central_Init ();
#endif
}

/*
============
SV_TimeOfDay
============
*/
void SV_TimeOfDay(date_t *date, char *timeformat)
{
	struct tm *newtime;
	time_t long_time;

	time(&long_time);
	newtime = localtime(&long_time);

	//bliP: date check ->
	if (!newtime)
	{
		date->day = 0;
		date->mon = 0;
		date->year = 0;
		date->hour = 0;
		date->min = 0;
		date->sec = 0;
		strlcpy(date->str, "#bad date#", sizeof(date->str));
		return;
	}
	//<-

	date->day = newtime->tm_mday;
	date->mon = newtime->tm_mon;
	date->year = newtime->tm_year + 1900;
	date->hour = newtime->tm_hour;
	date->min = newtime->tm_min;
	date->sec = newtime->tm_sec;
	strftime(date->str, sizeof(date->str)-1, timeformat, newtime);
}

//bliP: player logging ->
/*
============
SV_LogPlayer
============
*/
void SV_LogPlayer(client_t *cl, char *msg, int level)
{
	char info[MAX_EXT_INFO_STRING];
	char name[CLIENT_NAME_LEN];

	Info_ReverseConvert(&cl->_userinfo_ctx_, info, sizeof(info));
	Q_normalizetext(info);
	strlcpy(name, cl->name, sizeof(name));
	Q_normalizetext(name);

	SV_Write_Log(PLAYER_LOG, level,
	             va("%s\\%s\\%i\\%s\\%s\\%i%s\n",
	                msg,
	                name,
	                cl->userid,
	                NET_BaseAdrToString(cl->netchan.remote_address),
	                NET_BaseAdrToString(cl->realip),
	                cl->netchan.remote_address.port,
	                info
	               )
	            );
}

/*
============
SV_Write_Log
============
*/
void SV_Write_Log(int sv_log, int level, char *msg)
{
	static date_t date;
	char *log_msg, *error_msg;

	if (!(logs[sv_log].sv_logfile && *msg))
		return;

	if (logs[sv_log].log_level < level)
		return;

	SV_TimeOfDay(&date, "%a %b %d, %H:%M:%S %Y");

	switch (sv_log)
	{
	case FRAG_LOG:
	case MOD_FRAG_LOG:
		log_msg = msg; // these logs aren't in fs_gamedir
		error_msg = va("Can't write in %s log file: "/*%s/ */"%sN.log.\n",
		               /*fs_gamedir,*/ logs[sv_log].message_on,
		               logs[sv_log].file_name);
		break;
	default:
		log_msg = va("[%s].[%d] %s", date.str, level, msg);
		error_msg = va("Can't write in %s log file: "/*%s/ */"%s%i.log.\n",
		               /*fs_gamedir,*/ logs[sv_log].message_on,
		               logs[sv_log].file_name, NET_UDPSVPort());
	}

	if (fprintf(logs[sv_log].sv_logfile, "%s", log_msg) < 0)
	{
		//bliP: Sys_Error to Con_DPrintf ->
		//VVD: Con_DPrintf to Sys_Printf ->
		Sys_Printf("%s", error_msg);
		//<-
		SV_Logfile(sv_log, false);
	}
	else
	{
		fflush(logs[sv_log].sv_logfile);
		if ((int)sv_maxlogsize.value &&
		        (FS_FileLength(logs[sv_log].sv_logfile) > (int)sv_maxlogsize.value))
		{
			SV_Logfile(sv_log, true);
		}
	}
}

/*
============
Sys_compare_by functions for sort files in list
============
*/
int Sys_compare_by_date (const void *a, const void *b)
{
	return (int)(((file_t *)a)->time - ((file_t *)b)->time);
}

int Sys_compare_by_name (const void *a, const void *b)
{
	return strncmp(((file_t *)a)->name, ((file_t *)b)->name, MAX_DEMO_NAME);
}

// real-world time passed
double SV_ClientConnectedTime(client_t* client)
{
	if (!client->connection_started_curtime) {
		return 0;
	}
	return curtime - client->connection_started_curtime;
}

// affected by pause
double SV_ClientGameTime(client_t* client)
{
	if (!client->connection_started_realtime) {
		return 0;
	}

	return realtime - client->connection_started_realtime;
}

void SV_SetClientConnectionTime(client_t* client)
{
	client->connection_started_realtime = realtime;
	client->connection_started_curtime = curtime;
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_master.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    
*/
// sv_master.c - send heartbeats to master server

#ifndef CLIENTONLY
#include "qwsvdef.h"

#define HEARTBEAT_SECONDS 300

static netadr_t master_adr[MAX_MASTERS]; // address of group servers

/*
====================
SV_SetMaster_f

Make a master server current
====================
*/
void SV_SetMaster_f (void)
{
	char data[2];
	int i;

	memset (&master_adr, 0, sizeof(master_adr));

	for (i=1 ; i<Cmd_Argc() ; i++)
	{
		if (!strcmp(Cmd_Argv(i), "none") || !NET_StringToAdr (Cmd_Argv(i), &master_adr[i-1]))
		{
			Con_Printf ("Setting nomaster mode.\n");
			return;
		}
		if (master_adr[i-1].port == 0)
			master_adr[i-1].port = BigShort (27000);

		Con_Printf ("Master server at %s\n", NET_AdrToString (master_adr[i-1]));

		Con_Printf ("Sending a ping.\n");

		data[0] = A2A_PING;
		data[1] = 0;
		NET_SendPacket (NS_SERVER, 2, data, master_adr[i-1]);
	}

	svs.last_heartbeat = -99999;
}

/*
==================
SV_Heartbeat_f
==================
*/
void SV_Heartbeat_f (void)
{
	svs.last_heartbeat = -99999;
}

/*
================
Master_Heartbeat

Send a message to the master every few minutes to
let it know we are alive, and log information
================
*/
void Master_Heartbeat (void)
{
	char string[2048];
	int active;
	int i;

	if (sv.state != ss_active)
		return;

	if (realtime - svs.last_heartbeat < HEARTBEAT_SECONDS)
		return; // not time to send yet

	svs.last_heartbeat = realtime;

	//
	// count active users
	//
	active = 0;
	for (i=0 ; i<MAX_CLIENTS ; i++)
		if (svs.clients[i].state == cs_connected ||
				svs.clients[i].state == cs_spawned )
			active++;

	svs.heartbeat_sequence++;
	snprintf (string, sizeof(string), "%c\n%i\n%i\n", S2M_HEARTBEAT,
		  svs.heartbeat_sequence, active);


	// send to group master
	for (i=0 ; i<MAX_MASTERS ; i++)
		if (master_adr[i].port)
		{
			Con_Printf ("Sending heartbeat to %s\n", NET_AdrToString (master_adr[i]));
			NET_SendPacket (NS_SERVER, strlen(string), string, master_adr[i]);
		}
}

/*
=================
Master_Shutdown

Informs all masters that this server is going down
=================
*/
void Master_Shutdown (void)
{
	char string[2048];
	int i;

	snprintf (string, sizeof(string), "%c\n", S2M_SHUTDOWN);

	// send to group master
	for (i=0 ; i<MAX_MASTERS ; i++)
		if (master_adr[i].port)
		{
			Con_Printf ("Sending heartbeat to %s\n", NET_AdrToString (master_adr[i]));
			NET_SendPacket (NS_SERVER, strlen(string), string, master_adr[i]);
		}
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_mod_frags.c
================================================
/*
 * mvdsv_mod_frags.c
 * main mod_frags file
 * cases all functions in "stdout" form
 * to use it at console
 * and main function with example of using
 * (c) kreon 2005
 * Idea by gLAd
 *
 */
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
	
*/

#ifndef CLIENTONLY
#include "qwsvdef.h"
#ifndef SERVERONLY
#include "pcre2.h"
#endif
#include "sv_mod_frags.h"

qwmsg_t *qwmsg[MOD_MSG_MAX + 1];
static qbool qwm_static = true;

void free_qwmsg_t(qwmsg_t **qwmsg1)
{
	int i;

	if (!qwm_static) {
		for (i = 0; qwmsg1[i]; i++) {
			Q_free(qwmsg1[i]->str);
			Q_free(qwmsg1[i]);
		}
	}
}

void sv_mod_msg_file_OnChange(cvar_t *cvar, char *value, qbool *cancel)
{
	FILE *fp = NULL;
	char *str_tok, buf[128];
	size_t len;
	int i;

	free_qwmsg_t(qwmsg);

	if (value[0])
		fp = fopen(value, "r");

	if (fp == NULL)
	{
		if (value[0])
			Con_Printf("WARNING: sv_mod_msg_file_OnChange: can't open file %s.\n", value);

		for (i = 0; i < MOD_MSG_MAX && qwmsg_def[i].str; i++) {
			qwmsg[i] = &qwmsg_def[i];
		}
		qwm_static = true;
		Con_DPrintf("Initialized default mod messages.\nTotal: %d messages.\n", i);
	}
	else
	{
		for (i = 0; i < MOD_MSG_MAX && !feof(fp); i++)
		{
			if (fgets(buf, sizeof(buf), fp))
			{
				qwmsg[i] = (qwmsg_t *) Q_malloc (sizeof(qwmsg_t));
				// fill system_id
				str_tok = (char *)strtok(buf, "#");
				qwmsg[i]->msg_type = Q_atoi(str_tok);
				// fill weapon_id
				str_tok = (char *)strtok(NULL, "#");
				qwmsg[i]->id = Q_atoi(str_tok);
				// fill pl_count
				str_tok = (char *)strtok(NULL, "#");
				qwmsg[i]->pl_count = Q_atoi(str_tok) == 1 ? 1 : 2;
				// fill reverse
				str_tok = (char *)strtok(NULL, "#");
				qwmsg[i]->reverse = Q_atoi(str_tok) ? true : false;
				// fill str
				str_tok = (char *)strtok(NULL, "#");

				len = strlen (str_tok) + 1;
				qwmsg[i]->str =  (char *) Q_malloc (len);
				strlcpy(qwmsg[i]->str, str_tok, len);
			}
			else
				break;
			//            Sys_Printf("msg_type = %d, id = %d, pl_count = %d, str = %s, reverse = %d\n",
			//	qwmsg[i]->msg_type, qwmsg[i]->id, qwmsg[i]->pl_count, qwmsg[i]->str, qwmsg[i]->reverse);
		}
		qwm_static = false;
		Con_DPrintf("Initialized mod messages from file %s.\nTotal: %d messages.\n", value, i);
		fclose(fp);
	}
	qwmsg[i] = NULL;
	*cancel = false;
}

const char **qwmsg_pcre_check(const char *str, const char *qwm_str, int str_len)
{
	pcre2_code *reg;
	int error;
	PCRE2_SIZE error_offset = 0;
	const char **buf = NULL;
	int stringcount;
	pcre2_match_data *match_data = NULL;

	if (!(reg = pcre2_compile((PCRE2_SPTR)qwm_str, PCRE2_ZERO_TERMINATED, 0, &error, &error_offset, NULL)))
	{
		PCRE2_UCHAR error_str[256];
		pcre2_get_error_message(error, error_str, sizeof(error_str));
		Sys_Printf("WARNING: qwmsg_pcre_check: pcre2_compile(%s) error %s\n", qwm_str, error_str);
		return NULL;
	}

	match_data = pcre2_match_data_create_from_pattern(reg, NULL);
	stringcount = pcre2_match(reg, (PCRE2_SPTR)str, str_len, 0, 0, match_data, NULL);

	if (stringcount < 0) {
		pcre2_match_data_free (match_data);
		pcre2_code_free(reg);
		return NULL;
	}

	pcre2_substring_list_get(match_data, (PCRE2_UCHAR8***)&buf, NULL);
	pcre2_match_data_free (match_data);
	pcre2_code_free(reg);
	return buf;
}

// main function
char *parse_mod_string(char *str)
{
	const char **buf;
	int i, str_len = strlen(str);
	char *ret = NULL;
	for (i = 0; qwmsg[i]; i++)
	{
		if ((buf = qwmsg_pcre_check(str, qwmsg[i]->str, str_len)))
		{
			int pl1, pl2;
			switch (qwmsg[i]->msg_type)
			{
			case WEAPON:
				pl1 = pl2 = 1;
				switch (qwmsg[i]->pl_count)
				{
				case 2:
					pl2 += qwmsg[i]->reverse;
					pl1 = 3 - pl2;
				case 1:
					str_len = strlen(buf[pl1]) + strlen(buf[pl2]) + strlen(qw_weapon[qwmsg[i]->id]) + 5 + 10;
					ret = (char *) Q_malloc (str_len);
					snprintf(ret, str_len, "%s\\%s\\%s\\%d\n", buf[pl1], buf[pl2], qw_weapon[qwmsg[i]->id], (int)time(NULL));
					break;
				default: ret = NULL;
				}
				break;
			case SYSTEM:
				str_len = strlen(buf[1]) * 2 + strlen(qw_system[qwmsg[i]->id]) + 4 + 10;
				ret = (char *) Q_malloc (str_len);
				snprintf(ret, str_len, "%s\\%s\\%d\n", buf[1], qw_system[qwmsg[i]->id], (int)time(NULL));
				break;
			default: ret = NULL;
			}
			pcre2_substring_list_free((const PCRE2_UCHAR8**)buf);
			break;
		}
	}
	return ret;
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_mod_frags.h
================================================
/*
 * sv_mod_frags.h
 * QuakeWorld message definitions
 * For glad & vvd
 * (C) kreon 2005
 * Messages from fuhquake's fragfile.dat
 */
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef __SV_MOD_FRAGS__
#define __SV_MOD_FRAGS__

extern cvar_t	sv_mod_msg_file;
#define MOD_MSG_MAX	512
// weapons definitions

char *qw_weapon[] = {
    "die", 
    "axe",
    "sg",
    "ssg",
    "ng",
    "sng",
    "gl",
    "rl",
    "lg",
    "rail",
    "drown",
    "trap",
    "tele",
    "dschrg",
    "squish",
    "fall",
    "team",
    "stomps"
};
// system messages (not released yet) definitions
char *qw_system[] = {
    "start",
    "end",
    "connect",
    "disconnect",
    "timeout"
};
// main struct for mod's messages searching
typedef struct qw_message
{
    int msg_type; // type of message 
    int id; // id of weapon id for WEAPON
    int pl_count; // count of players in each message
    char *str; // pointer to string
    qbool reverse; // reversing message? (a->b or b->a)
} qwmsg_t;
// messages types
enum {	MIN_TYPE = 0, WEAPON = 0, SYSTEM, MAX_TYPE};

// DEFAULT mod messages
// From fuhquake's fragfile.dat

qwmsg_t qwmsg_def[] =
{
    {WEAPON, 10, 1, "(.*) sleeps with the fishes", false},
    {WEAPON, 10, 1, "(.*) sucks it down", false},
    {WEAPON, 10, 1, "(.*) gulped a load of slime", false},
    {WEAPON, 10, 1, "(.*) can't exist on slime alone", false},
    {WEAPON, 10, 1, "(.*) burst into flames", false},
    {WEAPON, 10, 1, "(.*) turned into hot slag", false},
    {WEAPON, 10, 1, "(.*) visits the Volcano God", false},
    {WEAPON, 15, 1, "(.*) cratered", false},
    {WEAPON, 15, 1, "(.*) fell to his death", false},
    {WEAPON, 15, 1, "(.*) fell to her death", false},
    {WEAPON, 11, 1, "(.*) blew up", false},
    {WEAPON, 11, 1, "(.*) was spiked", false},
    {WEAPON, 11, 1, "(.*) was zapped", false},
    {WEAPON, 11, 1, "(.*) ate a lavaball", false},
    {WEAPON, 12, 1, "(.*) was telefragged by his teammate", false},
    {WEAPON, 12, 1, "(.*) was telefragged by her teammate", false},
    {WEAPON,  0, 1, "(.*) died", false},
    {WEAPON,  0, 1, "(.*) tried to leave", false},
    {WEAPON, 14, 1, "(.*) was squished", false},
    {WEAPON,  0, 1, "(.*) suicides", false},
    {WEAPON,  6, 1, "(.*) tries to put the pin back in", false},
    {WEAPON,  7, 1, "(.*) becomes bored with life", false},
    {WEAPON,  7, 1, "(.*) discovers blast radius", false},
    {WEAPON, 13, 1, "(.*) electrocutes himself.", false},
    {WEAPON, 13, 1, "(.*) electrocutes herself.", false},
    {WEAPON, 13, 1, "(.*) discharges into the slime", false},
    {WEAPON, 13, 1, "(.*) discharges into the lava", false},
    {WEAPON, 13, 1, "(.*) discharges into the water", false},
    {WEAPON, 13, 1, "(.*) heats up the water", false},
    {WEAPON, 16, 1, "(.*) squished a teammate", false},
    {WEAPON, 16, 1, "(.*) mows down a teammate", false},
    {WEAPON, 16, 1, "(.*) checks his glasses", false},
    {WEAPON, 16, 1, "(.*) checks her glasses", false},
    {WEAPON, 16, 1, "(.*) gets a frag for the other team", false},
    {WEAPON, 16, 1, "(.*) loses another friend", false},
    {WEAPON,  1, 2, "(.*) was ax-murdered by (.*)", false},
    {WEAPON,  2, 2, "(.*) was lead poisoned by (.*)", false},
    {WEAPON,  2, 2, "(.*) chewed on (.*)'s boomstick", false},
    {WEAPON,  3, 2, "(.*) ate 8 loads of (.*)'s buckshot", false},
    {WEAPON,  3, 2, "(.*) ate 2 loads of (.*)'s buckshot", false},
    {WEAPON,  4, 2, "(.*) was body pierced by (.*)", false},
    {WEAPON,  4, 2, "(.*) was nailed by (.*)", false},
    {WEAPON,  5, 2, "(.*) was perforated by (.*)", false},
    {WEAPON,  5, 2, "(.*) was punctured by (.*)", false},
    {WEAPON,  5, 2, "(.*) was ventilated by (.*)", false},
    {WEAPON,  5, 2, "(.*) was straw-cuttered by (.*)", false},
    {WEAPON,  6, 2, "(.*) eats (.*)'s pineapple", false},
    {WEAPON,  6, 2, "(.*) was gibbed by (.*)'s grenade", false},
    {WEAPON,  7, 2, "(.*) was smeared by (.*)'s quad rocket", false},
    {WEAPON,  7, 2, "(.*) was brutalized by (.*)'s quad rocket", false},
    {WEAPON,  7, 2, "(.*) rips (.*) a new one", true},
    {WEAPON,  7, 2, "(.*) was gibbed by (.*)'s rocket", false},
    {WEAPON,  7, 2, "(.*) rides (.*)'s rocket", false},
    {WEAPON,  8, 2, "(.*) accepts (.*)'s shaft", false},
    {WEAPON,  9, 2, "(.*) was railed by (.*)", false},
    {WEAPON, 12, 2, "(.*) was telefragged by (.*)", false},
    {WEAPON, 14, 2, "(.*) squishes (.*)", true},
    {WEAPON, 13, 2, "(.*) accepts (.*)'s discharge", false},
    {WEAPON, 13, 2, "(.*) drains (.*)'s batteries", false},
    {WEAPON,  8, 2, "(.*) gets a natural disaster from (.*)", false},
    {     0,  0, 0, NULL, 0}
};
// end

#endif /* !__SV_MOD_FRAGS__ */


================================================
FILE: src/sv_move.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
	
*/
// sv_move.c -- monster movement

#ifndef CLIENTONLY
#include "qwsvdef.h"

#define	STEPSIZE	18

/*
=============
SV_CheckBottom
 
Returns false if any part of the bottom of the entity is off an edge that
is not a staircase.
 
=============
*/
qbool SV_CheckBottom (edict_t *ent)
{
	vec3_t	mins, maxs, start, stop;
	trace_t	trace;
	int		x, y;
	float	mid, bottom;

	VectorAdd (ent->v->origin, ent->v->mins, mins);
	VectorAdd (ent->v->origin, ent->v->maxs, maxs);

	// if all of the points under the corners are solid world, don't bother
	// with the tougher checks
	// the corners must be within 16 of the midpoint
	start[2] = mins[2] - 1;
	for	(x=0 ; x<=1 ; x++)
		for	(y=0 ; y<=1 ; y++)
		{
			start[0] = x ? maxs[0] : mins[0];
			start[1] = y ? maxs[1] : mins[1];
			if (SV_PointContents (start) != CONTENTS_SOLID)
				goto realcheck;
		}
	return true;		// we got out easy

realcheck:
	//
	// check it for real...
	//
	start[2] = mins[2];

	// the midpoint must be within 16 of the bottom
	start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
	start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
	stop[2] = start[2] - 2*STEPSIZE;
	trace = SV_Trace (start, vec3_origin, vec3_origin, stop, true, ent);

	if (trace.fraction == 1.0)
		return false;
	mid = bottom = trace.endpos[2];

	// the corners must be within 16 of the midpoint
	for	(x=0 ; x<=1 ; x++)
		for	(y=0 ; y<=1 ; y++)
		{
			start[0] = stop[0] = x ? maxs[0] : mins[0];
			start[1] = stop[1] = y ? maxs[1] : mins[1];

			trace = SV_Trace (start, vec3_origin, vec3_origin, stop, true, ent);

			if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
				bottom = trace.endpos[2];
			if (trace.fraction == 1.0 || mid - trace.endpos[2] > STEPSIZE)
				return false;
		}
	return true;
}


/*
=============
SV_movestep
 
Called by monster program code.
The move will be adjusted for slopes and stairs, but if the move isn't
possible, no move is done, false is returned, and
pr_global_struct->trace_normal is set to the normal of the blocking wall
=============
*/
qbool SV_movestep (edict_t *ent, vec3_t move, qbool relink)
{
	float		dz;
	vec3_t		oldorg, neworg, end;
	trace_t		trace;
	int			i;
	edict_t		*enemy;

	// try the move
	VectorCopy (ent->v->origin, oldorg);
	VectorAdd (ent->v->origin, move, neworg);

	// flying monsters don't step up
	if ( (int)ent->v->flags & (FL_SWIM | FL_FLY) )
	{
		// try one move with vertical motion, then one without
		for (i=0 ; i<2 ; i++)
		{
			VectorAdd (ent->v->origin, move, neworg);
			enemy = PROG_TO_EDICT(ent->v->enemy);
			if (i == 0 && enemy != sv.edicts)
			{
				dz = ent->v->origin[2] - PROG_TO_EDICT(ent->v->enemy)->v->origin[2];
				if (dz > 40)
					neworg[2] -= 8;
				if (dz < 30)
					neworg[2] += 8;
			}
			trace = SV_Trace (ent->v->origin, ent->v->mins, ent->v->maxs, neworg, false, ent);

			if (trace.fraction == 1)
			{
				if ( ((int)ent->v->flags & FL_SWIM) && SV_PointContents(trace.endpos) == CONTENTS_EMPTY )
					return false;	// swim monster left water

				VectorCopy (trace.endpos, ent->v->origin);
				if (relink)
					SV_LinkEdict (ent, true);
				return true;
			}

			if (enemy == sv.edicts)
				break;
		}

		return false;
	}

	// push down from a step height above the wished position
	neworg[2] += STEPSIZE;
	VectorCopy (neworg, end);
	end[2] -= STEPSIZE*2;

	trace = SV_Trace (neworg, ent->v->mins, ent->v->maxs, end, false, ent);

	if (trace.allsolid)
		return false;

	if (trace.startsolid)
	{
		neworg[2] -= STEPSIZE;
		trace = SV_Trace (neworg, ent->v->mins, ent->v->maxs, end, false, ent);
		if (trace.allsolid || trace.startsolid)
			return false;
	}
	if (trace.fraction == 1)
	{
		// if monster had the ground pulled out, go ahead and fall
		if ( (int)ent->v->flags & FL_PARTIALGROUND )
		{
			VectorAdd (ent->v->origin, move, ent->v->origin);
			if (relink)
				SV_LinkEdict (ent, true);
			ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
			//	Con_Printf ("fall down\n");
			return true;
		}

		return false;		// walked off an edge
	}

	// check point traces down for dangling corners
	VectorCopy (trace.endpos, ent->v->origin);

	if (!SV_CheckBottom (ent))
	{
		if ( (int)ent->v->flags & FL_PARTIALGROUND )
		{	// entity had floor mostly pulled out from underneath it
			// and is trying to correct
			if (relink)
				SV_LinkEdict (ent, true);
			return true;
		}
		VectorCopy (oldorg, ent->v->origin);
		return false;
	}

	if ( (int)ent->v->flags & FL_PARTIALGROUND )
	{
		//		Con_Printf ("back on ground\n");
		ent->v->flags = (int)ent->v->flags & ~FL_PARTIALGROUND;
	}
	ent->v->groundentity = EDICT_TO_PROG(trace.e.ent);

	// the move is ok
	if (relink)
		SV_LinkEdict (ent, true);
	return true;
}


//============================================================================

/*
======================
SV_StepDirection
 
Turns to the movement direction, and walks the current distance if
facing it.
 
======================
*/
void PF_changeyaw (void);
qbool SV_StepDirection (edict_t *ent, float yaw, float dist)
{
	vec3_t		move, oldorigin;
	float		delta;

	ent->v->ideal_yaw = yaw;

	PF_changeyaw(); // OUCH OUCH: its relay on what ent == self ? I'm not even mention about PR2...

	yaw = yaw*M_PI*2 / 360;
	move[0] = cos(yaw)*dist;
	move[1] = sin(yaw)*dist;
	move[2] = 0;

	VectorCopy (ent->v->origin, oldorigin);
	if (SV_movestep (ent, move, false))
	{
		delta = ent->v->angles[YAW] - ent->v->ideal_yaw;
		if (delta > 45 && delta < 315)
		{		// not turned far enough, so don't take the step
			VectorCopy (oldorigin, ent->v->origin);
		}
		SV_LinkEdict (ent, true);
		return true;
	}
	SV_LinkEdict (ent, true);

	return false;
}

/*
======================
SV_FixCheckBottom
 
======================
*/
void SV_FixCheckBottom (edict_t *ent)
{
	//	Con_Printf ("SV_FixCheckBottom\n");

	ent->v->flags = (int)ent->v->flags | FL_PARTIALGROUND;
}



/*
================
SV_NewChaseDir
 
================
*/
#define	DI_NODIR	-1
void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist)
{
	float		deltax,deltay;
	float			d[3];
	float		tdir, olddir, turnaround;

	olddir = anglemod( (int)(actor->v->ideal_yaw/45)*45 );
	turnaround = anglemod(olddir - 180);

	deltax = enemy->v->origin[0] - actor->v->origin[0];
	deltay = enemy->v->origin[1] - actor->v->origin[1];
	if (deltax>10)
		d[1]= 0;
	else if (deltax<-10)
		d[1]= 180;
	else
		d[1]= DI_NODIR;
	if (deltay<-10)
		d[2]= 270;
	else if (deltay>10)
		d[2]= 90;
	else
		d[2]= DI_NODIR;

	// try direct route
	if (d[1] != DI_NODIR && d[2] != DI_NODIR)
	{
		if (d[1] == 0)
			tdir = d[2] == 90 ? 45 : 315;
		else
			tdir = d[2] == 90 ? 135 : 215;

		if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
			return;
	}

	// try other directions
	if ( ((rand()&3) & 1) || fabs(deltay) > fabs(deltax))
	{
		tdir=d[1];
		d[1]=d[2];
		d[2]=tdir;
	}

	if (d[1] != DI_NODIR && d[1] != turnaround && SV_StepDirection(actor, d[1], dist))
		return;

	if (d[2] != DI_NODIR && d[2] != turnaround && SV_StepDirection(actor, d[2], dist))
		return;

	/* there is no direct path to the player, so pick another direction */

	if (olddir != DI_NODIR && SV_StepDirection(actor, olddir, dist))
		return;

	if (rand()&1) 	/*randomly determine direction of search*/
	{
		for (tdir=0 ; tdir<=315 ; tdir += 45)
			if (tdir!=turnaround && SV_StepDirection(actor, tdir, dist) )
				return;
	}
	else
	{
		for (tdir=315 ; tdir >=0 ; tdir -= 45)
			if (tdir!=turnaround && SV_StepDirection(actor, tdir, dist) )
				return;
	}

	if (turnaround != DI_NODIR && SV_StepDirection(actor, turnaround, dist) )
		return;

	actor->v->ideal_yaw = olddir;		// can't move

	// if a bridge was pulled out from underneath a monster, it may not have
	// a valid standing position at all

	if (!SV_CheckBottom (actor))
		SV_FixCheckBottom (actor);

}

/*
======================
SV_CloseEnough
 
======================
*/
qbool SV_CloseEnough (edict_t *ent, edict_t *goal, float dist)
{
	int		i;

	for (i=0 ; i<3 ; i++)
	{
		if (goal->v->absmin[i] > ent->v->absmax[i] + dist)
			return false;
		if (goal->v->absmax[i] < ent->v->absmin[i] - dist)
			return false;
	}
	return true;
}

/*
======================
SV_MoveToGoal
 
======================
*/

// NOTE: If you change this, then change PF2_MoveToGoal too!!!

void SV_MoveToGoal (void)
{
	edict_t		*ent, *goal;
	float		dist;

	ent = PROG_TO_EDICT(pr_global_struct->self);
	goal = PROG_TO_EDICT(ent->v->goalentity);
	dist = G_FLOAT(OFS_PARM0);

	if ( !( (int)ent->v->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
	{
		G_FLOAT(OFS_RETURN) = 0;
		return;
	}

	// if the next step hits the enemy, return immediately
	if ( PROG_TO_EDICT(ent->v->enemy) != sv.edicts && SV_CloseEnough (ent, goal, dist) )
		return;

	// bump around...
	if ( (rand()&3)==1 || !SV_StepDirection (ent, ent->v->ideal_yaw, dist))
	{
		SV_NewChaseDir (ent, goal, dist);
	}
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_nchan.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
	
*/
// sv_nchan.c, user reliable data stream writes

#ifndef CLIENTONLY
#include "qwsvdef.h"

// check to see if client block will fit, if not, rotate buffers
void ClientReliableCheckBlock(client_t *cl, int maxsize)
{
	if (cl->num_backbuf
		|| cl->netchan.message.cursize > cl->netchan.message.maxsize - maxsize - 1)
	{
		// we would probably overflow the buffer, save it for next
		if (!cl->num_backbuf || cl->backbuf.cursize > cl->backbuf.maxsize - maxsize - 1)
		{
			if (cl->num_backbuf == MAX_BACK_BUFFERS)
			{
				Sys_Printf ("WARNING: MAX_BACK_BUFFERS for %s\n", cl->name);
				cl->backbuf.cursize = 0; // don't overflow without allowoverflow set
				cl->netchan.message.overflowed = true; // this will drop the client
				return;
			}
			memset(&cl->backbuf, 0, sizeof(cl->backbuf));
			cl->backbuf.allowoverflow = true;
			cl->backbuf.data = cl->backbuf_data[cl->num_backbuf];
			cl->backbuf.maxsize = cl->netchan.message.maxsize;
			cl->backbuf_size[cl->num_backbuf] = 0;
			cl->num_backbuf++;
		}
	}
}

// begin a client block, estimated maximum size
void ClientReliableWrite_Begin(client_t *cl, int c, int maxsize)
{
	ClientReliableCheckBlock(cl, maxsize);
	ClientReliableWrite_Byte(cl, c);
}

void ClientReliable_FinishWrite(client_t *cl)
{
	if (cl->num_backbuf)
	{
		cl->backbuf_size[cl->num_backbuf - 1] = cl->backbuf.cursize;

		if (cl->backbuf.overflowed)
		{
			Sys_Printf ("WARNING: backbuf [%d] reliable overflow for %s\n",cl->num_backbuf,cl->name);
			cl->netchan.message.overflowed = true; // this will drop the client
		}
	}
}

void ClientReliableWrite_Angle(client_t *cl, float f)
{
	if (cl->num_backbuf)
	{
		MSG_WriteAngle(&cl->backbuf, f);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteAngle(&cl->netchan.message, f);
}

void ClientReliableWrite_Angle16(client_t *cl, float f)
{
	if (cl->num_backbuf)
	{
		MSG_WriteAngle16(&cl->backbuf, f);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteAngle16(&cl->netchan.message, f);
}

void ClientReliableWrite_Byte(client_t *cl, int c)
{
	if (cl->num_backbuf)
	{
		MSG_WriteByte(&cl->backbuf, c);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteByte(&cl->netchan.message, c);
}

void ClientReliableWrite_Char(client_t *cl, int c)
{
	if (cl->num_backbuf)
	{
		MSG_WriteChar(&cl->backbuf, c);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteChar(&cl->netchan.message, c);
}

void ClientReliableWrite_Float(client_t *cl, float f)
{
	if (cl->num_backbuf)
	{
		MSG_WriteFloat(&cl->backbuf, f);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteFloat(&cl->netchan.message, f);
}

void ClientReliableWrite_Coord(client_t *cl, float f)
{
	if (cl->num_backbuf)
	{
		MSG_WriteCoord(&cl->backbuf, f);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteCoord(&cl->netchan.message, f);
}

void ClientReliableWrite_Long(client_t *cl, int c)
{
	if (cl->num_backbuf)
	{
		MSG_WriteLong(&cl->backbuf, c);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteLong(&cl->netchan.message, c);
}

void ClientReliableWrite_Short(client_t *cl, int c)
{
	if (cl->num_backbuf)
	{
		MSG_WriteShort(&cl->backbuf, c);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteShort(&cl->netchan.message, c);
}

void ClientReliableWrite_String(client_t *cl, char *s)
{
	if (cl->num_backbuf)
	{
		MSG_WriteString(&cl->backbuf, s);
		ClientReliable_FinishWrite(cl);
	}
	else
		MSG_WriteString(&cl->netchan.message, s);
}

void ClientReliableWrite_SZ(client_t *cl, void *data, int len)
{
	if (cl->num_backbuf)
	{
		SZ_Write(&cl->backbuf, data, len);
		ClientReliable_FinishWrite(cl);
	}
	else
		SZ_Write(&cl->netchan.message, data, len);
}

void SV_ClearBackbuf (client_t *cl)
{
	cl->num_backbuf = 0;
}

// clears both cl->netchan.message and backbuf
void SV_ClearReliable (client_t *cl)
{
	SZ_Clear (&cl->netchan.message);
	SV_ClearBackbuf (cl);
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_null.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// sv_null.c -- this file can stub out the entire server system
// for pure net-only clients

void SV_Init (void)
{
}
void SV_Shutdown (char *finalmsg)
{
}
void SV_Frame (double time)
{
}


================================================
FILE: src/sv_phys.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/
// sv_phys.c

#ifndef CLIENTONLY
#include "qwsvdef.h"

/*


pushmove objects do not obey gravity, and do not interact with each other or trigger fields, but block normal movement and push normal objects when they move.

onground is set for toss objects when they come to a complete rest.  it is set for steping or walking objects 

doors, plats, etc are SOLID_BSP, and MOVETYPE_PUSH
bonus items are SOLID_TRIGGER touch, and MOVETYPE_TOSS
corpses are SOLID_NOT and MOVETYPE_TOSS
crates are SOLID_BBOX and MOVETYPE_TOSS
walking monsters are SOLID_SLIDEBOX and MOVETYPE_STEP
flying/floating monsters are SOLID_SLIDEBOX and MOVETYPE_FLY

solid_edge items only clip against bsp models.

*/

cvar_t	sv_maxvelocity		= { "sv_maxvelocity","2000"};

cvar_t	sv_gravity		= { "sv_gravity", "800"};
cvar_t	sv_stopspeed		= { "sv_stopspeed", "100"};
cvar_t	sv_maxspeed		= { "sv_maxspeed", "320"};
cvar_t	sv_spectatormaxspeed 	= { "sv_spectatormaxspeed", "500"};
cvar_t	sv_accelerate		= { "sv_accelerate", "10"};
cvar_t	sv_airaccelerate	= { "sv_airaccelerate", "10"};

cvar_t	sv_antilag		= { "sv_antilag", "", CVAR_SERVERINFO};
cvar_t	sv_antilag_no_pred	= { "sv_antilag_no_pred", "", CVAR_SERVERINFO}; // "negative" cvar so it doesn't show on serverinfo for no reason
cvar_t	sv_antilag_projectiles	= { "sv_antilag_projectiles", "", CVAR_SERVERINFO};

cvar_t	sv_wateraccelerate	= { "sv_wateraccelerate", "10"};
cvar_t	sv_friction		= { "sv_friction", "4"};
cvar_t	sv_waterfriction	= { "sv_waterfriction", "4"};
cvar_t	pm_ktjump		= { "pm_ktjump", "1", CVAR_SERVERINFO};
cvar_t	pm_bunnyspeedcap	= { "pm_bunnyspeedcap", "", CVAR_SERVERINFO};
cvar_t	pm_slidefix		= { "pm_slidefix", "", CVAR_SERVERINFO};
void OnChange_pm_airstep (cvar_t *var, char *value, qbool *cancel);
cvar_t	pm_airstep		= { "pm_airstep", "", CVAR_SERVERINFO, OnChange_pm_airstep};
cvar_t	pm_pground		= { "pm_pground", "", CVAR_SERVERINFO|CVAR_ROM};
cvar_t  pm_rampjump     = { "pm_rampjump", "", CVAR_SERVERINFO };

double	sv_frametime;


// when pm_airstep is 1, set pm_pground to 1, and vice versa
// airstep works best with pground on
void OnChange_pm_airstep (cvar_t *var, char *value, qbool *cancel)
{
	float val = Q_atoi(value);
	Cvar_SetROM (&pm_pground, val ? "1" : "");
}


void SV_Physics_Toss (edict_t *ent);


/*
================
SV_CheckVelocity
================
*/
void SV_CheckVelocity (edict_t *ent)
{
	int i;
	float wishspeed;

	//
	// bound velocity
	//
	for (i=0 ; i<3 ; i++)
	{
		if (IS_NAN(ent->v->velocity[i]))
		{
			Con_DPrintf ("Got a NaN velocity on %s\n", PR_GetEntityString(ent->v->classname));
			ent->v->velocity[i] = 0;
		}
		if (IS_NAN(ent->v->origin[i]))
		{
			Con_DPrintf ("Got a NaN origin on %s\n", PR_GetEntityString(ent->v->classname));
			ent->v->origin[i] = 0;
		}
/*		if (ent->v->velocity[i] > sv_maxvelocity.value)
			ent->v->velocity[i] = sv_maxvelocity.value;
		else if (ent->v->velocity[i] < -sv_maxvelocity.value)
			ent->v->velocity[i] = -sv_maxvelocity.value;
*/
	}

	// SV_MAXVELOCITY fix by Maddes
	wishspeed = VectorLength(ent->v->velocity);
	if (wishspeed > sv_maxvelocity.value)
	{
		VectorScale (ent->v->velocity, sv_maxvelocity.value/wishspeed, ent->v->velocity);
		wishspeed = sv_maxvelocity.value;
	}
}

/*
=============
SV_RunThink

Runs thinking code if time.  There is some play in the exact time the think
function will be called, because it is called before any movement is done
in a frame.  Not used for pushmove objects, because they must be exact.
Returns false if the entity removed itself.
=============
*/
qbool SV_RunThink (edict_t *ent)
{
	float thinktime;

	do
	{
		thinktime = ent->v->nextthink;
		if (thinktime <= 0)
			return true;
		if (thinktime > sv.time + sv_frametime)
			return true;

		if (thinktime < sv.time)
			thinktime = sv.time; // don't let things stay in the past.
		// it is possible to start that way
		// by a trigger with a local time.
		ent->v->nextthink = 0;
		pr_global_struct->time = thinktime;
		pr_global_struct->self = EDICT_TO_PROG(ent);
		pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
		PR_EdictThink(ent->v->think);

		if (ent->e.free)
			return false;
	} while (1);

	return true;
}

/*
==================
SV_Impact

Two entities have touched, so run their touch functions
==================
*/
void SV_Impact (edict_t *e1, edict_t *e2)
{
	int old_self, old_other;

	old_self = pr_global_struct->self;
	old_other = pr_global_struct->other;

	pr_global_struct->time = sv.time;
	if (e1->v->touch && e1->v->solid != SOLID_NOT)
	{
		pr_global_struct->self = EDICT_TO_PROG(e1);
		pr_global_struct->other = EDICT_TO_PROG(e2);
		PR_EdictTouch(e1->v->touch);
	}

	if (e2->v->touch && e2->v->solid != SOLID_NOT)
	{
		pr_global_struct->self = EDICT_TO_PROG(e2);
		pr_global_struct->other = EDICT_TO_PROG(e1);
		PR_EdictTouch(e2->v->touch);
	}

	pr_global_struct->self = old_self;
	pr_global_struct->other = old_other;
}


/*
==================
ClipVelocity

Slide off of the impacting object
==================
*/
#define	STOP_EPSILON	0.1

void ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
{
	float backoff;
	float change;
	int i;


	backoff = DotProduct (in, normal) * overbounce;

	for (i=0 ; i<3 ; i++)
	{
		change = normal[i]*backoff;
		out[i] = in[i] - change;
		if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
			out[i] = 0;
	}
}


/*
============
SV_FlyMove

The basic solid body movement clip that slides along multiple planes
Returns the clipflags if the velocity was modified (hit something solid)
1 = floor
2 = wall / step
4 = dead stop
If steptrace is not NULL, the trace of any vertical wall hit will be stored
============
*/
#define MAX_CLIP_PLANES	5
int SV_FlyMove (edict_t *ent, float time1, trace_t *steptrace, int type)
{
	int		bumpcount, numbumps;
	vec3_t	dir;
	float	d;
	int		numplanes;
	vec3_t	planes[MAX_CLIP_PLANES];
	vec3_t	primal_velocity, original_velocity, new_velocity;
	int		i, j;
	trace_t	trace;
	vec3_t	end;
	float	time_left;
	int		blocked;

	numbumps = 4;

	blocked = 0;
	VectorCopy (ent->v->velocity, original_velocity);
	VectorCopy (ent->v->velocity, primal_velocity);
	numplanes = 0;

	time_left = time1;

	for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
	{
		for (i=0 ; i<3 ; i++)
			end[i] = ent->v->origin[i] + time_left * ent->v->velocity[i];

		trace = SV_Trace (ent->v->origin, ent->v->mins, ent->v->maxs, end, type, ent);

		if (trace.allsolid)
		{	// entity is trapped in another solid
			VectorClear (ent->v->velocity);
			return 3;
		}

		if (trace.fraction > 0)
		{	// actually covered some distance
			VectorCopy (trace.endpos, ent->v->origin);
			VectorCopy (ent->v->velocity, original_velocity);
			numplanes = 0;
		}

		if (trace.fraction == 1)
			break; // moved the entire distance

		if (!trace.e.ent)
			SV_Error ("SV_FlyMove: !trace.e.ent");

		if (trace.plane.normal[2] > 0.7)
		{
			blocked |= 1; // floor
			if (trace.e.ent->v->solid == SOLID_BSP)
			{
				ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
				ent->v->groundentity = EDICT_TO_PROG(trace.e.ent);
			}
		}
		if (!trace.plane.normal[2])
		{
			blocked |= 2; // step
			if (steptrace)
				*steptrace = trace; // save for player extrafriction
		}

		//
		// run the impact function
		//
		SV_Impact (ent, trace.e.ent);
		if (ent->e.free)
			break;	 // removed by the impact function


		time_left -= time_left * trace.fraction;

		// cliped to another plane
		if (numplanes >= MAX_CLIP_PLANES)
		{	// this shouldn't really happen
			VectorClear (ent->v->velocity);
			return 3;
		}

		VectorCopy (trace.plane.normal, planes[numplanes]);
		numplanes++;

		//
		// modify original_velocity so it parallels all of the clip planes
		//
		for (i=0 ; i<numplanes ; i++)
		{
			ClipVelocity (original_velocity, planes[i], new_velocity, 1);
			for (j=0 ; j<numplanes ; j++)
				if (j != i)
				{
					if (DotProduct (new_velocity, planes[j]) < 0)
						break; // not ok
				}
			if (j == numplanes)
				break;
		}

		if (i != numplanes)
		{	// go along this plane
			VectorCopy (new_velocity, ent->v->velocity);
		}
		else
		{	// go along the crease
			if (numplanes != 2)
			{
				// Con_Printf ("clip velocity, numplanes == %i\n",numplanes);
				VectorClear (ent->v->velocity);
				return 7;
			}
			CrossProduct (planes[0], planes[1], dir);
			d = DotProduct (dir, ent->v->velocity);
			VectorScale (dir, d, ent->v->velocity);
		}

		//
		// if original velocity is against the original velocity, stop dead
		// to avoid tiny occilations in sloping corners
		//
		if (DotProduct (ent->v->velocity, primal_velocity) <= 0)
		{
			VectorClear (ent->v->velocity);
			return blocked;
		}
	}

	return blocked;
}


/*
============
SV_AddGravity
============
*/
void SV_AddGravity (edict_t *ent, float scale)
{
	ent->v->velocity[2] -= scale * movevars.gravity * sv_frametime;
}

/*
===============================================================================

PUSHMOVE

===============================================================================
*/

/*
============
SV_PushEntity

Does not change the entities velocity at all
============
*/
trace_t SV_PushEntity (edict_t *ent, vec3_t push, unsigned int traceflags)
{
	trace_t	trace;
	vec3_t	end;

	VectorAdd (ent->v->origin, push, end);

	if ((int)ent->v->flags&FL_LAGGEDMOVE)
		traceflags |= MOVE_LAGGED;

	if (ent->v->movetype == MOVETYPE_FLYMISSILE)
		trace = SV_Trace (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_MISSILE|traceflags, ent);
	else if (ent->v->solid == SOLID_TRIGGER || ent->v->solid == SOLID_NOT)
		// only clip against bmodels
		trace = SV_Trace (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NOMONSTERS|traceflags, ent);
	else
		trace = SV_Trace (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL|traceflags, ent);

	VectorCopy (trace.endpos, ent->v->origin);
	SV_LinkEdict (ent, true);

	if (trace.e.ent)
		SV_Impact (ent, trace.e.ent);

	return trace;
}


/*
============
SV_Push

============
*/
qbool SV_Push (edict_t *pusher, vec3_t move)
{
	int			i, e;
	edict_t		*check, *block;
	vec3_t		mins, maxs;
	vec3_t		pushorig;
	int			num_moved;
	edict_t		*moved_edict[MAX_EDICTS];
	vec3_t		moved_from[MAX_EDICTS];
	float		solid_save;

	for (i=0 ; i<3 ; i++)
	{
		mins[i] = pusher->v->absmin[i] + move[i];
		maxs[i] = pusher->v->absmax[i] + move[i];
	}

	VectorCopy (pusher->v->origin, pushorig);

	// move the pusher to its final position

	VectorAdd (pusher->v->origin, move, pusher->v->origin);
	SV_LinkEdict (pusher, false);

	// see if any solid entities are inside the final position
	num_moved = 0;
	check = NEXT_EDICT(sv.edicts);
	for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check))
	{
		if (check->e.free)
			continue;
		if (check->v->movetype == MOVETYPE_PUSH
		|| check->v->movetype == MOVETYPE_NONE
		|| check->v->movetype == MOVETYPE_NOCLIP)
			continue;

		solid_save = pusher->v->solid;
		pusher->v->solid = SOLID_NOT;
		block = SV_TestEntityPosition (check);
		pusher->v->solid = solid_save;
		if (block)
			continue;

		// if the entity is standing on the pusher, it will definately be moved
		if ( ! ( ((int)check->v->flags & FL_ONGROUND)
		&& PROG_TO_EDICT(check->v->groundentity) == pusher) )
		{
			if ( check->v->absmin[0] >= maxs[0]
			|| check->v->absmin[1] >= maxs[1]
			|| check->v->absmin[2] >= maxs[2]
			|| check->v->absmax[0] <= mins[0]
			|| check->v->absmax[1] <= mins[1]
			|| check->v->absmax[2] <= mins[2] )
				continue;

			// see if the ent's bbox is inside the pusher's final position
			if (!SV_TestEntityPosition (check))
				continue;
		}

		// remove the onground flag for non-players
		if (check->v->movetype != MOVETYPE_WALK)
			check->v->flags = (int)check->v->flags & ~FL_ONGROUND;

		VectorCopy (check->v->origin, moved_from[num_moved]);
		moved_edict[num_moved] = check;
		num_moved++;

		// try moving the contacted entity
		VectorAdd (check->v->origin, move, check->v->origin);
		block = SV_TestEntityPosition (check);
		if (!block)
		{	// pushed ok
			SV_LinkEdict (check, false);
			continue;
		}

		// if it is ok to leave in the old position, do it
		VectorSubtract (check->v->origin, move, check->v->origin);
		block = SV_TestEntityPosition (check);
		if (!block)
		{
			//if leaving it where it was, allow it to drop to the floor again (useful for plats that move downward)
			//check->v->flags = (int)check->v->flags & ~FL_ONGROUND; // disconnect: is it needed?

			num_moved--;
			continue;
		}

		// if it is still inside the pusher, block
		if (check->v->mins[0] == check->v->maxs[0])
		{
			SV_LinkEdict (check, false);
			continue;
		}
		if (check->v->solid == SOLID_NOT || check->v->solid == SOLID_TRIGGER)
		{	// corpse
			check->v->mins[0] = check->v->mins[1] = 0;
			VectorCopy (check->v->mins, check->v->maxs);
			SV_LinkEdict (check, false);
			continue;
		}

		VectorCopy (pushorig, pusher->v->origin);
		SV_LinkEdict (pusher, false);

		// if the pusher has a "blocked" function, call it
		// otherwise, just stay in place until the obstacle is gone
		if (pusher->v->blocked)
		{
			pr_global_struct->self = EDICT_TO_PROG(pusher);
			pr_global_struct->other = EDICT_TO_PROG(check);
			PR_EdictBlocked (pusher->v->blocked);
		}

		// move back any entities we already moved
		for (i=0 ; i<num_moved ; i++)
		{
			VectorCopy (moved_from[i], moved_edict[i]->v->origin);
			SV_LinkEdict (moved_edict[i], false);
		}
		return false;
	}

	return true;
}

/*
============
SV_PushMove

============
*/
void SV_PushMove (edict_t *pusher, float movetime)
{
	int i;
	vec3_t move;

	if (!pusher->v->velocity[0] && !pusher->v->velocity[1] && !pusher->v->velocity[2])
	{
		pusher->v->ltime += movetime;
		return;
	}

	for (i=0 ; i<3 ; i++)
		move[i] = pusher->v->velocity[i] * movetime;

	if (SV_Push (pusher, move))
		pusher->v->ltime += movetime;
}


/*
================
SV_Physics_Pusher

================
*/
void SV_Physics_Pusher (edict_t *ent)
{
	float thinktime;
	float oldltime;
	float movetime;
	float l;
	vec3_t oldorg, move;

	oldltime = ent->v->ltime;

	thinktime = ent->v->nextthink;
	if (thinktime < ent->v->ltime + sv_frametime)
	{
		movetime = thinktime - ent->v->ltime;
		if (movetime < 0)
			movetime = 0;
	}
	else
		movetime = sv_frametime;

	if (movetime)
	{
		SV_PushMove (ent, movetime);	// advances ent->v->ltime if not blocked
	}

	if (thinktime > oldltime && thinktime <= ent->v->ltime)
	{
		VectorCopy (ent->v->origin, oldorg);
		ent->v->nextthink = 0;
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(ent);
		pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
		PR_EdictThink(ent->v->think);

		if (ent->e.free)
			return;
		VectorSubtract (ent->v->origin, oldorg, move);

		l = VectorLength(move);
		if (l > 1.0/64)
		{
			// Con_Printf ("**** snap: %f\n", VectorLength (l));
			VectorCopy (oldorg, ent->v->origin);
			SV_Push (ent, move);
		}
	}
}

/*
=============
SV_Physics_None

Non moving objects can only think
=============
*/
void SV_Physics_None (edict_t *ent)
{
	// regular thinking
	SV_RunThink (ent);
}

/*
=============
SV_Physics_Noclip

A moving object that doesn't obey physics
=============
*/
void SV_Physics_Noclip (edict_t *ent)
{
	// regular thinking
	if (!SV_RunThink (ent))
		return;

	VectorMA (ent->v->angles, sv_frametime, ent->v->avelocity, ent->v->angles);
	VectorMA (ent->v->origin, sv_frametime, ent->v->velocity, ent->v->origin);

	SV_LinkEdict (ent, false);
}

/*
==============================================================================

TOSS / BOUNCE

==============================================================================
*/

/*
=============
SV_CheckWaterTransition

=============
*/
void SV_CheckWaterTransition (edict_t *ent)
{
	int cont;

	cont = SV_PointContents (ent->v->origin);
	if (!ent->v->watertype)
	{	// just spawned here
		ent->v->watertype = cont;
		ent->v->waterlevel = 1;
		return;
	}

	if (cont <= CONTENTS_WATER)
	{
		if (ent->v->watertype == CONTENTS_EMPTY)
		{	// just crossed into water
			SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
		}
		ent->v->watertype = cont;
		ent->v->waterlevel = 1;
	}
	else
	{
		if (ent->v->watertype != CONTENTS_EMPTY)
		{	// just crossed into water
			SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1);
		}
		ent->v->watertype = CONTENTS_EMPTY;
		ent->v->waterlevel = cont;
	}
}

/*
=============
SV_Physics_Toss

Toss, bounce, and fly movement.  When onground, do nothing.
=============
*/
void SV_Physics_Toss (edict_t *ent)
{
	trace_t	trace;
	vec3_t	move;
	float	backoff;

	// regular thinking
	if (!SV_RunThink (ent))
		return;

	if (ent->v->velocity[2] > 0)
		ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;

	// if onground, return without moving
	if ( ((int)ent->v->flags & FL_ONGROUND) )
		return;

	SV_CheckVelocity (ent);

	// add gravity
	if (ent->v->movetype != MOVETYPE_FLY
	&& ent->v->movetype != MOVETYPE_FLYMISSILE)
		SV_AddGravity (ent, 1.0);

	// move angles
	VectorMA (ent->v->angles, sv_frametime, ent->v->avelocity, ent->v->angles);

	// move origin
	VectorScale (ent->v->velocity, sv_frametime, move);
	trace = SV_PushEntity (ent, move, (sv_antilag.value == 2 && sv_antilag_projectiles.value) ? MOVE_LAGGED:0);
	if (trace.fraction == 1)
		return;
	if (ent->e.free)
		return;

	if (ent->v->movetype == MOVETYPE_BOUNCE)
		backoff = 1.5;
	else
		backoff = 1;

	ClipVelocity (ent->v->velocity, trace.plane.normal, ent->v->velocity, backoff);

	// stop if on ground
	if (trace.plane.normal[2] > 0.7)
	{
		if (ent->v->velocity[2] < 60 || ent->v->movetype != MOVETYPE_BOUNCE )
		{
			ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
			ent->v->groundentity = EDICT_TO_PROG(trace.e.ent);
			VectorClear (ent->v->velocity);
			VectorClear (ent->v->avelocity);
		}
	}

	// check for in water
	SV_CheckWaterTransition (ent);
}

/*
===============================================================================

STEPPING MOVEMENT

===============================================================================
*/

/*
=============
SV_Physics_Step

Monsters freefall when they don't have a ground entity, otherwise
all movement is done with discrete steps.

This is also used for objects that have become still on the ground, but
will fall if the floor is pulled out from under them.
FIXME: is this true?
=============
*/
void SV_Physics_Step (edict_t *ent)
{
	qbool hitsound;

	// frefall if not onground
	if ( ! ((int)ent->v->flags & (FL_ONGROUND | FL_FLY | FL_SWIM) ) )
	{
		if (ent->v->velocity[2] < movevars.gravity*-0.1)
			hitsound = true;
		else
			hitsound = false;

		SV_AddGravity (ent, 1.0);
		SV_CheckVelocity (ent);
		// Tonik: the check for SOLID_NOT is to fix the way dead bodies and
		// gibs behave (should not be blocked by players & monsters);
		// The SOLID_TRIGGER check is disabled lest we break frikbots
		if (ent->v->solid == SOLID_NOT /* || ent->v->solid == SOLID_TRIGGER*/)
			SV_FlyMove (ent, sv_frametime, NULL, MOVE_NOMONSTERS);
		else
			SV_FlyMove (ent, sv_frametime, NULL, MOVE_NORMAL);
		SV_LinkEdict (ent, true);

		if ( (int)ent->v->flags & FL_ONGROUND ) // just hit ground
		{
			if (hitsound)
				SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1);
		}
	}

	// regular thinking
	SV_RunThink (ent);

	SV_CheckWaterTransition (ent);
}

//============================================================================

void SV_ProgStartFrame (qbool isBotFrame)
{
	// let the progs know that a new frame has started
	pr_global_struct->self = EDICT_TO_PROG(sv.edicts);
	pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
	pr_global_struct->time = sv.time;
	PR_GameStartFrame(isBotFrame);
}

/*
================
SV_RunEntity
================
*/
void SV_RunEntity (edict_t *ent)
{
	if (ent->e.lastruntime == sv.time)
		return;
	ent->e.lastruntime = sv.time;

	switch ((int)ent->v->movetype)
	{
	case MOVETYPE_PUSH:
		SV_Physics_Pusher (ent);
		break;
	case MOVETYPE_NONE:
	case MOVETYPE_LOCK:
		SV_Physics_None (ent);
		break;
	case MOVETYPE_NOCLIP:
		SV_Physics_Noclip (ent);
		break;
	case MOVETYPE_STEP:
		SV_Physics_Step (ent);
		break;
	case MOVETYPE_TOSS:
	case MOVETYPE_BOUNCE:
	case MOVETYPE_FLY:
	case MOVETYPE_FLYMISSILE:
		SV_Physics_Toss (ent);
		break;
	default:
		SV_Error ("SV_Physics: bad movetype %i", (int)ent->v->movetype);
	}
}

/*
** SV_RunNQNewmis
** 
** sv_player will be valid
*/
void SV_RunNQNewmis (void)
{
	edict_t	*ent;
	double save_frametime;
	int i, pl;

	pl = EDICT_TO_PROG(sv_player);
	ent = NEXT_EDICT(sv.edicts);
	for (i=1 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
	{
		if (ent->e.free)
			continue;
		if (ent->e.lastruntime || ent->v->owner != pl)
			continue;
		if (ent->v->movetype != MOVETYPE_FLY &&
			ent->v->movetype != MOVETYPE_FLYMISSILE && 
			ent->v->movetype != MOVETYPE_BOUNCE) 
			continue;
		if (ent->v->solid != SOLID_BBOX && ent->v->solid != SOLID_TRIGGER)
			continue;

		save_frametime = sv_frametime;
		sv_frametime = 0.05;
		SV_RunEntity (ent);
		sv_frametime = save_frametime;
		return;
	}
}

/*
================
SV_RunNewmis
================
*/
void SV_RunNewmis (void)
{
	edict_t	*ent;
	double save_frametime;

	if (pr_nqprogs)
		return;

	if (!pr_global_struct->newmis)
		return;

	ent = PROG_TO_EDICT(pr_global_struct->newmis);
	pr_global_struct->newmis = 0;

	save_frametime = sv_frametime;
	sv_frametime = 0.05;

	SV_RunEntity (ent);

	sv_frametime = save_frametime;
}

/*
================
SV_Physics
================
*/
void SV_Physics (void)
{
	int i;
	client_t *cl,*savehc;
	edict_t *savesvpl;
	edict_t *ent;

	if (sv.state != ss_active)
		return;

	if (sv.old_time)
	{
		// don't bother running a frame if sv_mintic seconds haven't passed
		sv_frametime = sv.time - sv.old_time;
		if (sv_frametime < (double) sv_mintic.value)
			return;
		if (sv_frametime > (double) sv_maxtic.value)
			sv_frametime = (double) sv_maxtic.value;
		sv.old_time = sv.time;
	}
	else
		sv_frametime = 0.1; // initialization frame

	sv.physicstime = sv.time;

	if (pr_nqprogs)
		NQP_Reset ();

	PR_GLOBAL(frametime) = sv_frametime;

	SV_ProgStartFrame(false);

	//
	// treat each object in turn
	// even the world gets a chance to think
	//
	ent = sv.edicts;
	for (i=0 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
	{
		if (ent->e.free)
			continue;

		if (PR_GLOBAL(force_retouch))
			SV_LinkEdict (ent, true);	// force retouch even for stationary

		if (i > 0 && i <= MAX_CLIENTS)
			continue;		// clients are run directly from packets

		SV_RunEntity (ent);
		SV_RunNewmis ();
	}

	if (PR_GLOBAL(force_retouch))
		PR_GLOBAL(force_retouch)--;

	savesvpl = sv_player;
	savehc = sv_client;

	// so spec will have right goalentity - if speccing someone
	for ( i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++ )
	{
		if ( cl->state == cs_free )
			continue;

		sv_client = cl;
		sv_player = cl->edict;

		if (sv_client->spectator && sv_client->spec_track > 0)
			sv_player->v->goalentity = EDICT_TO_PROG(svs.clients[sv_client->spec_track-1].edict);
	}

	sv_player = savesvpl;
	sv_client = savehc;
}

#ifdef USE_PR2
void SV_RunBots(void)
{
	int i;
	client_t *cl,*savehc;
	edict_t *savesvpl;
	double max_physfps = sv_maxfps.value;
#ifdef SERVERONLY
	static double extramsec = 0;
#endif

	if (max_physfps < 20 || max_physfps > 1000) {
		max_physfps = 77.0;
	}

	if (sv.state != ss_active || !sv.physicstime)
		return;

#ifdef SERVERONLY
	if (sv.old_bot_time) {
		// don't bother running a frame if 1/fps seconds haven't passed
		double required = (double) 1.0f / max_physfps;

		extramsec += (sv.time - sv.old_bot_time);
		sv.old_bot_time = sv.time;
		if (extramsec < required) {
			return;
		}
		sv_frametime = required;
		extramsec -= required;
	}
	else {
		sv_frametime = 1.0f / max_physfps; // initialization frame
		extramsec = 0;
		sv.old_bot_time = sv.time;
	}
#else
	// On internal server, try and match the user's framerate
	// ... don't run if no time passed, that is a user packet only
	if (sv.old_bot_time && sv.old_bot_time == sv.time) {
		return;
	}
	sv.old_bot_time = sv.time;
#endif

	savesvpl = sv_player;
	savehc = sv_client;

	PR_GLOBAL(frametime) = sv_frametime;
	SV_ProgStartFrame (true);

	//
	// Run bots physics.
	//
	for ( i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++ )
	{
		extern void SV_PreRunCmd(void);
		extern void SV_RunCmd (usercmd_t *ucmd, qbool inside, qbool simulate);
		extern void SV_PostRunCmd(void);

		if ( cl->state == cs_free )
			continue;
		if ( !cl->isBot )
			continue;

		sv_client = cl;
		sv_player = cl->edict;

		SV_PreRunCmd();
		SV_RunCmd (&cl->botcmd, false, false);
		SV_PostRunCmd();

		cl->lastcmd = cl->botcmd;
		cl->lastcmd.buttons = 0;

		memset(&cl->botcmd,0,sizeof(cl->botcmd));

		cl->localtime = sv.time;
		cl->delta_sequence = -1;	// no delta unless requested

		if (sv_antilag.value) {
			if (cl->antilag_position_next == 0 || cl->antilag_positions[(cl->antilag_position_next - 1) % MAX_ANTILAG_POSITIONS].localtime < cl->localtime) {
				cl->antilag_positions[cl->antilag_position_next % MAX_ANTILAG_POSITIONS].localtime = cl->localtime;
				VectorCopy(cl->edict->v->origin, cl->antilag_positions[cl->antilag_position_next % MAX_ANTILAG_POSITIONS].origin);
				cl->antilag_position_next++;
			}
		}
		else {
			cl->antilag_position_next = 0;
		}
	}

	sv_player = savesvpl;
	sv_client = savehc;
}
#endif

void SV_SetMoveVars(void)
{
	movevars.gravity            = sv_gravity.value;
	movevars.stopspeed          = sv_stopspeed.value;
	movevars.maxspeed           = sv_maxspeed.value;
	movevars.spectatormaxspeed  = sv_spectatormaxspeed.value;
	movevars.accelerate         = sv_accelerate.value;
	movevars.airaccelerate      = sv_airaccelerate.value;
	movevars.wateraccelerate    = sv_wateraccelerate.value;
	movevars.friction           = sv_friction.value;
	movevars.waterfriction      = sv_waterfriction.value;
	movevars.entgravity         = 1.0;
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_save.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/

// sv_save.c

#ifndef CLIENTONLY
#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "quakedef.h"
#include "vfs.h"
#include "server.h"
#include "sv_world.h"
#endif

extern cvar_t maxclients;

#define	SAVEGAME_COMMENT_LENGTH	39
#define	SAVEGAME_VERSION	6

#ifdef SERVERONLY
static void SV_SaveGameFileName(char* buffer, int buffer_size, char* name)
{
	snprintf(buffer, buffer_size, "%s/save/%s", fs_gamedir, name);
}
#else
static void SV_SaveGameFileName(char* buffer, int buffer_size, char* name)
{
	FS_SaveGameDirectory(buffer, buffer_size);
	strlcat(buffer, name, buffer_size);
}
#endif

//Writes a SAVEGAME_COMMENT_LENGTH character comment
void SV_SavegameComment (char *buffer) {
	int i;
	char kills[20];
#ifdef SERVERONLY
	char *mapname = sv.mapname;
	int killed_monsters = (int)PR_GLOBAL(killed_monsters);
	int total_monsters = (int)PR_GLOBAL(total_monsters);
#else
	char *mapname = cl.levelname;
	int killed_monsters = cl.stats[STAT_MONSTERS];
	int total_monsters = cl.stats[STAT_TOTALMONSTERS];
#endif
	if (!mapname || !*mapname)
		mapname = "Unnamed_Level";

	for (i = 0; i < SAVEGAME_COMMENT_LENGTH; i++)
		buffer[i] = ' ';
	memcpy (buffer, mapname, min(strlen(mapname), 21));
	snprintf (kills, sizeof (kills), "kills:%3i/%-3i", killed_monsters, total_monsters);
	memcpy (buffer + 22, kills, strlen(kills));

	// convert space to _ to make stdio happy
	for (i = 0; i < SAVEGAME_COMMENT_LENGTH; i++)
		if (buffer[i] == ' ')
			buffer[i] = '_';

	buffer[SAVEGAME_COMMENT_LENGTH] = 0;
}

void SV_SaveGame_f(void)
{
	char fname[MAX_OSPATH], comment[SAVEGAME_COMMENT_LENGTH+1];
	FILE *f;
	int i;

	if (Cmd_Argc() != 2) {
		Con_Printf ("Usage: %s <savefname> : save a game\n", Cmd_Argv(0));
		return;
	} else if (strstr(Cmd_Argv(1), "..")) {
		Con_Printf ("Relative pathfnames are not allowed.\n");
		return;
	} else if (sv.state != ss_active) {
		Con_Printf ("Not playing a local game.\n");
		return;
#ifndef SERVERONLY
	} else if (cl.intermission) {
		Con_Printf ("Can't save in intermission.\n");
		return;
#endif
	} else if (deathmatch.value != 0 || coop.value != 0 || maxclients.value != 1) {
		Con_Printf ("Can't save multiplayer games.\n");
		return;
	}

	for (i = 1; i < MAX_CLIENTS; i++) {
		if (svs.clients[i].state == cs_spawned) {
			Con_Printf ("Can't save multiplayer games.\n");
			return;
		}
	}	

	if (svs.clients[0].state != cs_spawned) {
		Con_Printf ("Can't save, client #0 not spawned.\n");
		return;
	} else if (svs.clients[0].edict->v->health <= 0) {
		Con_Printf ("Can't save game with a dead player\n");
		// in fact, we can, but does it make sense?
		return;
	}

	SV_SaveGameFileName (fname, sizeof(fname), Cmd_Argv(1));
	COM_DefaultExtension (fname, ".sav", sizeof(fname));
	
	Con_Printf ("Saving game to %s...\n", fname);
	if (!(f = fopen (fname, "w"))) {		
		FS_CreatePath (fname);
		if (!(f = fopen (fname, "w"))) {
			Con_Printf ("ERROR: couldn't open.\n");
			return;
		}
	}

	fprintf (f, "%i\n", SAVEGAME_VERSION);
	SV_SavegameComment (comment);
	fprintf (f, "%s\n", comment);
	for (i = 0 ; i < NUM_SPAWN_PARMS; i++)
		fprintf (f, "%f\n", svs.clients->spawn_parms[i]);
	fprintf (f, "%d\n", current_skill);
	fprintf (f, "%s\n", sv.mapname);
	fprintf (f, "%f\n", sv.time);

	// write the light styles
	for (i = 0; i < MAX_LIGHTSTYLES; i++) {
		if (sv.lightstyles[i])
			fprintf (f, "%s\n", sv.lightstyles[i]);
		else
			fprintf (f,"m\n");
	}

	ED_WriteGlobals (f);
	for (i = 0; i < sv.num_edicts; i++) {
		ED_Write (f, EDICT_NUM(i));
		fflush (f);
	}
	fclose (f);
	Con_Printf ("done.\n");

	// force cache rebuild.
	FS_FlushFSHash();
}

void SV_LoadGame_f(void)
{
	char name[MAX_OSPATH], mapname[MAX_QPATH], str[32 * 1024];
	const char* start;
	FILE *f;
	float time, tfloat, spawn_parms[NUM_SPAWN_PARMS];
	edict_t *ent;
	int entnum, version, r;
	unsigned int i;

	if (Cmd_Argc() != 2) {
		Con_Printf ("Usage: %s <savename> : load a game\n", Cmd_Argv(0));
		return;
	}

	SV_SaveGameFileName (name, sizeof(name), Cmd_Argv(1));
	COM_DefaultExtension (name, ".sav", sizeof(name));

	Con_Printf ("Loading game from %s...\n", name);
	if (!(f = fopen (name, "rb"))) {
		Con_Printf ("ERROR: couldn't open.\n");
		return;
	}

	if (fscanf (f, "%i\n", &version) != 1) {
		fclose (f);
		Con_Printf ("Error reading savegame data\n");
		return;
	}

	if (version != SAVEGAME_VERSION) {
		fclose (f);
		Con_Printf ("Savegame is version %i, not %i\n", version, SAVEGAME_VERSION);
		return;
	}

	if (fscanf (f, "%s\n", str) != 1) {
		fclose (f);
		Con_Printf ("Error reading savegame data\n");
		return;
	}
	for (i = 0; i < NUM_SPAWN_PARMS; i++) {
		if (fscanf (f, "%f\n", &spawn_parms[i]) != 1) {
			fclose (f);
			Con_Printf ("Error reading savegame data\n");
			return;
		}
	}

	// this silliness is so we can load 1.06 save files, which have float skill values
	if (fscanf (f, "%f\n", &tfloat) != 1) {
		fclose (f);
		Con_Printf ("Error reading savegame data\n");
		return;
	}
	current_skill = (int)(tfloat + 0.1);

	if (fscanf (f, "%s\n", mapname) != 1) {
		fclose (f);
		Con_Printf ("Error reading savegame data\n");
		return;
	}
	if (fscanf (f, "%f\n", &time) != 1) {
		fclose (f);
		Con_Printf ("Error reading savegame data\n");
		return;
	}

#ifndef SERVERONLY
	Host_EndGame();
	CL_BeginLocalConnection ();
#endif

	SV_SpawnServer(mapname, false, NULL, true);

	if (sv.state != ss_active) {
		Con_Printf ("Couldn't load map\n");
		fclose (f);
		return;
	}

	// load the light styles
	for (i = 0; i < MAX_LIGHTSTYLES; i++) {
		int length;
		if (fscanf (f, "%s\n", str) != 1) {
			Con_Printf("Couldn't read lightstyles\n");
			fclose (f);
			return;
		}
		str[sizeof(str) - 1] = '\0';
		length = strlen(str) + 1;
		sv.lightstyles[i] = (char *) Hunk_AllocName (length, "lightstyle");
		strlcpy (sv.lightstyles[i], str, length);
	}

	// pause until all clients connect
	if (!(sv.paused & 1))
		SV_TogglePause (NULL, 1);

	sv.loadgame = true;

	// load the edicts out of the savegame file
	entnum = -1;		// -1 is the globals
	while (!feof(f)) {
		for (i = 0; i < sizeof(str) - 1; i++) {
			r = fgetc (f);
			if (r == EOF || !r)
				break;
			str[i] = r;
			if (r == '}') {
				i++;
				break;
			}
		}
		if (i == sizeof(str)-1)
			Host_Error ("Loadgame buffer overflow");
		str[i] = 0;
		start = str;
		start = COM_Parse(str);
		if (!com_token[0])
			break;		// end of file

		if (strcmp(com_token,"{"))
			Host_Error ("First token isn't a brace");

		if (entnum == -1) {	
			// parse the global vars
			ED_ParseGlobals (start);
		}
		else {	
			// parse an edict
			ent = EDICT_NUM(entnum);
			ED_ClearEdict (ent); // FIXME: we also clear world edict here, is it OK?
			ED_ParseEdict (start, ent);

			// link it into the bsp tree
			if (!ent->e.free)
				SV_LinkEdict (ent, false);
		}
		entnum++;
	}

	sv.num_edicts = entnum;
	sv.time = time;

	fclose (f);

	for (i = 0; i < NUM_SPAWN_PARMS; i++)
		svs.clients->spawn_parms[i] = spawn_parms[i];
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_send.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
	
*/

#ifndef CLIENTONLY
#include "qwsvdef.h"

static void SV_BotWriteDamage(client_t* c, int i);

#define CHAN_AUTO   0
#define CHAN_WEAPON 1
#define CHAN_VOICE  2
#define CHAN_ITEM   3
#define CHAN_BODY   4

/*
=============================================================================
 
Con_Printf redirection
 
=============================================================================
*/

char	outputbuf[OUTPUTBUF_SIZE];

redirect_t	sv_redirected;
static int	sv_redirectbufcount;

qbool SV_SkipCommsBotMessage(client_t* client);
extern cvar_t sv_phs, sv_reliable_sound;

/*
==================
SV_FlushRedirect
==================
*/
void SV_FlushRedirect (void)
{
	char send1[OUTPUTBUF_SIZE + 6];

	if (sv_redirected == RD_PACKET)
	{
		send1[0] = 0xff;
		send1[1] = 0xff;
		send1[2] = 0xff;
		send1[3] = 0xff;
		send1[4] = A2C_PRINT;
		memcpy (send1 + 5, outputbuf, strlen(outputbuf) + 1);

		NET_SendPacket (NS_SERVER, strlen(send1) + 1, send1, net_from);
	}
	else if (sv_redirected == RD_CLIENT && sv_redirectbufcount < MAX_REDIRECTMESSAGES)
	{
		ClientReliableWrite_Begin (sv_client, svc_print, strlen(outputbuf)+3);
		ClientReliableWrite_Byte (sv_client, PRINT_HIGH);
		ClientReliableWrite_String (sv_client, outputbuf);
		sv_redirectbufcount++;
	}
	else if (sv_redirected == RD_MOD)
	{
		//return;
	}
	else if (sv_redirected > RD_MOD && sv_redirectbufcount < MAX_REDIRECTMESSAGES)
	{
		client_t *cl;

		cl = svs.clients + sv_redirected - RD_MOD - 1;

		if (cl->state == cs_spawned)
		{
			ClientReliableWrite_Begin (cl, svc_print, strlen(outputbuf)+3);
			ClientReliableWrite_Byte (cl, PRINT_HIGH);
			ClientReliableWrite_String (cl, outputbuf);
			sv_redirectbufcount++;
		}
	}

	// clear it
	outputbuf[0] = 0;
}


/*
==================
SV_BeginRedirect
 
  Send Con_Printf data to the remote client
  instead of the console
==================
*/
void SV_BeginRedirect (redirect_t rd)
{
	sv_redirected = rd;
	outputbuf[0] = 0;
	sv_redirectbufcount = 0;

}

void SV_EndRedirect (void)
{
	SV_FlushRedirect ();
	sv_redirected = RD_NONE;
}

qbool SV_AddToRedirect(char *msg)
{
	if (!sv_redirected)
		return false;

	// FIXME: probably we should check client's MTU instead of fixed MIN_MTU.
	if (strlen(msg) + strlen(outputbuf) > /* MAX_MSGLEN */ MIN_MTU - 10)
		SV_FlushRedirect ();

	strlcat(outputbuf, msg, sizeof(outputbuf));

	return true;
}

#ifdef SERVERONLY

/*
================
Con_Printf

Handles cursor positioning, line wrapping, etc
================
*/
#define	MAXPRINTMSG	4096
void Con_Printf (char *fmt, ...)
{
	va_list argptr;
	char msg[MAXPRINTMSG];

	va_start (argptr,fmt);
	vsnprintf (msg, MAXPRINTMSG, fmt, argptr);
	va_end (argptr);

	// add to redirected message
	if (SV_AddToRedirect(msg))
		return; // added.

	Sys_Printf ("%s", msg);	// also echo to debugging console
	SV_Write_Log(CONSOLE_LOG, 0, msg);

	// dumb error message to log file if
	if (sv_error)
		SV_Write_Log(ERROR_LOG, 1, msg);
}

/*
================
Con_DPrintf

A Con_Printf that only shows up if the "developer" cvar is set
================
*/
void Con_DPrintf (char *fmt, ...)
{
	va_list		argptr;
	char		msg[MAXPRINTMSG];

	if (!(int)developer.value)
		return;

	va_start (argptr,fmt);
	vsnprintf (msg, MAXPRINTMSG, fmt, argptr);
	va_end (argptr);

	Con_Printf ("%s", msg);
}

#endif // SERVERONLY

/*
=============================================================================
 
EVENT MESSAGES
 
=============================================================================
*/

static void SV_PrintToClient(client_t *cl, int level, char *string)
{
	if (cl->state < cs_preconnected)
	{
		Sys_Printf("SV_PrintToClient: client not ready.");
		return;
	}

	ClientReliableWrite_Begin (cl, svc_print, strlen(string)+3);
	ClientReliableWrite_Byte (cl, level);
	ClientReliableWrite_String (cl, string);
}


/*
=================
SV_ClientPrintf
 
Sends text across to be displayed if the level passes
=================
*/
void SV_ClientPrintf (client_t *cl, int level, char *fmt, ...)
{
	va_list		argptr;
	char		string[1024];

	if (level < cl->messagelevel)
		return;

	va_start (argptr,fmt);
	vsnprintf (string, sizeof(string), fmt, argptr);
	va_end (argptr);

	if (sv.mvdrecording)
	{
		if (MVDWrite_Begin (dem_single, cl - svs.clients, strlen(string)+3))
		{
			MVD_MSG_WriteByte (svc_print);
			MVD_MSG_WriteByte (level);
			MVD_MSG_WriteString (string);
		}
	}

	SV_PrintToClient(cl, level, string);
}

void SV_ClientPrintf2 (client_t *cl, int level, char *fmt, ...)
{
	va_list		argptr;
	char		string[1024];

	if (level < cl->messagelevel)
		return;

	va_start (argptr,fmt);
	vsnprintf (string, sizeof(string), fmt, argptr);
	va_end (argptr);

	SV_PrintToClient(cl, level, string);
}


/*
=================
SV_BroadcastPrintf

Sends text to all active clients
=================
*/
char *parse_mod_string(char *str);
void SV_DoBroadcastPrintf (int level, int flags, char *string)
{
	char		*fraglog;
	static char	string2[1024] = {0};
	client_t	*cl;
	int			i;

	if (!(flags & BPRINT_IGNORECONSOLE))
		Sys_Printf ("%s", string);	// print to the console

	if (!(flags & BPRINT_IGNORECLIENTS))
	{
		for (i=0, cl = svs.clients ; i<MAX_CLIENTS ; i++, cl++)
		{
			if (level < cl->messagelevel)
				continue;
			if (cl->state < cs_connected)
				continue;

			SV_PrintToClient(cl, level, string); // this does't go to mvd demo
		}
	}

	if (!(flags & BPRINT_IGNOREINDEMO))
	{
		if (flags & BPRINT_QTVONLY)
		{
			sizebuf_t		msg;
			byte			msg_buf[1024];

			SZ_InitEx(&msg, msg_buf, sizeof(msg_buf), true);
			MSG_WriteByte (&msg, svc_print);
			MSG_WriteByte (&msg, level);
			MSG_WriteString (&msg, string);

			DemoWriteQTV(&msg);
		}
		else
		{
			if (sv.mvdrecording)
			{
				if (MVDWrite_Begin (dem_all, 0, strlen(string)+3))
				{
					MVD_MSG_WriteByte (svc_print);
					MVD_MSG_WriteByte (level);
					MVD_MSG_WriteString (string);
				}
			}
		}
	}

	//	SV_Write_Log(MOD_FRAG_LOG, 1, "=== SV_BroadcastPrintf ===\n");
	//	SV_Write_Log(MOD_FRAG_LOG, 1, va("%d\n===>", time(NULL)));
	//	SV_Write_Log(MOD_FRAG_LOG, 1, string);
	//	SV_Write_Log(MOD_FRAG_LOG, 1, "<===\n");
	if (string[0] && logs[MOD_FRAG_LOG].sv_logfile)
	{
		if (string[strlen(string) - 1] == '\n')
		{
			strlcat(string2, string, sizeof(string2));
			//			SV_Write_Log(MOD_FRAG_LOG, 1, "=== SV_BroadcastPrintf ==={\n");
			//			SV_Write_Log(MOD_FRAG_LOG, 1, string2);
			//			SV_Write_Log(MOD_FRAG_LOG, 1, "}==========================\n");
			if ((fraglog = parse_mod_string(string2)))
			{
				SV_Write_Log(MOD_FRAG_LOG, 1, fraglog);
				Q_free(fraglog);
			}
			string2[0] = 0;
		}
		else
			strlcat(string2, string, sizeof(string2));
	}
	//	SV_Write_Log(MOD_FRAG_LOG, 1, "==========================\n\n");
}

void SV_BroadcastPrintf (int level, char *fmt, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr,fmt);
	vsnprintf (string, sizeof(string), fmt, argptr);
	va_end (argptr);

	SV_DoBroadcastPrintf (level, 0, string);
}

void SV_BroadcastPrintfEx (int level, int flags, char *fmt, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr,fmt);
	vsnprintf (string, sizeof(string), fmt, argptr);
	va_end (argptr);

	SV_DoBroadcastPrintf (level, flags, string);
}

/*
=================
SV_BroadcastCommand
 
Sends text to all active clients
=================
*/
void SV_BroadcastCommand (char *fmt, ...)
{
	va_list		argptr;
	char		string[1024];

	if (!sv.state)
		return;
	va_start (argptr,fmt);
	vsnprintf (string, sizeof(string), fmt, argptr);
	va_end (argptr);

	MSG_WriteByte (&sv.reliable_datagram, svc_stufftext);
	MSG_WriteString (&sv.reliable_datagram, string);
}


/*
=================
SV_Multicast

Sends the contents of sv.multicast to a subset of the clients,
then clears sv.multicast.

MULTICAST_ALL	same as broadcast
MULTICAST_PVS	send to clients potentially visible from org
MULTICAST_PHS	send to clients potentially hearable from org
=================
*/
void SV_MulticastEx (vec3_t origin, int to, const char *cl_reliable_key)
{
	client_t*   client;
	byte*       mask;
	int         leafnum;
	int         j;
	qbool       reliable;
	vec3_t      vieworg;
	qbool       mvd_only = false;

	reliable = false;

	switch (to)
	{
	case MULTICAST_ALL_R:
		reliable = true;	// intentional fallthrough
	case MULTICAST_ALL:
		mask = NULL;		// everything
		break;

	case MULTICAST_PHS_R:
		reliable = true;	// intentional fallthrough
	case MULTICAST_PHS:
		mask = CM_LeafPHS (CM_PointInLeaf(origin));
		break;

	case MULTICAST_PVS_R:
		reliable = true;	// intentional fallthrough
	case MULTICAST_PVS:
		mask = CM_LeafPVS (CM_PointInLeaf (origin));
		break;
	case MULTICAST_MVD_HIDDEN:
		mask = NULL;
		mvd_only = true;
		break;

	default:
		mask = NULL;
		SV_Error ("SV_Multicast: bad to:%i", to);
	}

	// send the data to all relevent clients
	for (j = 0, client = svs.clients; j < MAX_CLIENTS && !mvd_only; j++, client++)
	{
		int trackent = 0;

		if (client->state != cs_spawned)
			continue;
		if (SV_SkipCommsBotMessage(client))
			continue;

		if (!mask)
			goto inrange; // multicast to all

		// in case of trackent we have to reflect his origin so PHS work right.
		if (fofs_trackent)
		{
			trackent = ((eval_t *)((byte *)(client->edict)->v + fofs_trackent))->_int;
			if (trackent < 1 || trackent > MAX_CLIENTS || svs.clients[trackent - 1].state != cs_spawned)
				trackent = 0;
		}

		if (trackent)
		{
			VectorAdd (svs.clients[trackent - 1].edict->v->origin, svs.clients[trackent - 1].edict->v->view_ofs, vieworg);
		}
		else
		{
			VectorAdd (client->edict->v->origin, client->edict->v->view_ofs, vieworg);
		}

		if (to == MULTICAST_PHS_R || to == MULTICAST_PHS)
		{
			vec3_t delta;
			VectorSubtract(origin, vieworg, delta);
			if (VectorLength(delta) <= 1024)
				goto inrange;
		}

		leafnum = CM_Leafnum(CM_PointInLeaf(vieworg));
		if (leafnum)
		{
			// -1 is because pvs rows are 1 based, not 0 based like leafs
			leafnum = leafnum - 1;
			if ( !(mask[leafnum>>3] & (1<<(leafnum&7)) ) )
			{
				// Con_Printf ("supressed multicast\n");
				continue;
			}
		}

inrange:
		if (reliable || (cl_reliable_key && *cl_reliable_key && strcmp("0", Info_Get(&client->_userinfo_ctx_, cl_reliable_key))))
		{
			ClientReliableCheckBlock(client, sv.multicast.cursize);
			ClientReliableWrite_SZ(client, sv.multicast.data, sv.multicast.cursize);
		}
		else
			SZ_Write (&client->datagram, sv.multicast.data, sv.multicast.cursize);
	}

	if (sv.mvdrecording) {
		if (mvd_only) {
			mvdhidden_block_header_t header;
			header.length = sv.multicast.cursize - 2;
			// header.type_id = ...; < up to the mod to fill this part in

			// write to dem_multiple(0), which will be skipped by all major clients (ezQuake, FTE, fod)
			if (MVDWrite_HiddenBlockBegin(sv.multicast.cursize + sizeof(header.length))) {
				MVD_SZ_Write(&header.length, sizeof(header.length));
				MVD_SZ_Write(sv.multicast.data, sv.multicast.cursize);
			}
		}
		else if (reliable) {
			if (MVDWrite_Begin(dem_all, 0, sv.multicast.cursize)) {
				MVD_SZ_Write(sv.multicast.data, sv.multicast.cursize);
			}
		}
		else {
			SZ_Write(&demo.datagram, sv.multicast.data, sv.multicast.cursize);
		}
	}

	SZ_Clear (&sv.multicast);
}

void SV_Multicast (vec3_t origin, int to)
{
	SV_MulticastEx(origin, to, NULL);
}

void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count,
					   int replacement_te, int replacement_count)
{
	int		i, v;
	qbool	send_count;

	//if (AllClientsWantSVCParticle())
	if (0)
	{
		MSG_WriteByte (&sv.multicast, nq_svc_particle);
		MSG_WriteCoord (&sv.multicast, org[0]);
		MSG_WriteCoord (&sv.multicast, org[1]);
		MSG_WriteCoord (&sv.multicast, org[2]);
		for (i=0 ; i<3 ; i++)
		{
			v = dir[i]*16;
			if (v > 127)
				v = 127;
			else if (v < -128)
				v = -128;
			MSG_WriteChar (&sv.multicast, v);
		}
		MSG_WriteByte (&sv.multicast, count);
		MSG_WriteByte (&sv.multicast, color);
	}
	else
	{
		if (replacement_te == TE_EXPLOSION || replacement_te == TE_LIGHTNINGBLOOD)
			send_count = false;
		else if (replacement_te == TE_BLOOD || replacement_te == TE_GUNSHOT)
			send_count = true;
		else
			return;		// don't send anything

		MSG_WriteByte (&sv.multicast, svc_temp_entity);
		MSG_WriteByte (&sv.multicast, replacement_te);
		if (send_count)
			MSG_WriteByte (&sv.multicast, replacement_count);
		MSG_WriteCoord (&sv.multicast, org[0]);
		MSG_WriteCoord (&sv.multicast, org[1]);
		MSG_WriteCoord (&sv.multicast, org[2]);
	}

	SV_Multicast (org, MULTICAST_PVS);
}


/*
==================
SV_StartSound
 
Each entity can have eight independant sound sources, like voice,
weapon, feet, etc.
 
Channel 0 is an auto-allocate channel, the others override anything
already running on that entity/channel pair.
 
An attenuation of 0 will play full volume everywhere in the level.
Larger attenuations will drop off.  (max 4 attenuation)
 
==================
*/
void SV_StartSound (edict_t *entity, int channel, char *sample, int volume, float attenuation)
{
	int     sound_num;
	int     i;
	int     ent;
	vec3_t  origin;
	qbool   use_phs;
	qbool   reliable = false;

	if (volume < 0 || volume > 255)
		SV_Error ("SV_StartSound: volume = %i", volume);

	if (attenuation < 0 || attenuation > 4)
		SV_Error ("SV_StartSound: attenuation = %f", attenuation);

	if (channel < 0 || channel > 15)
		SV_Error ("SV_StartSound: channel = %i", channel);

	// find precache number for sound
	for (sound_num=1 ; sound_num<MAX_SOUNDS
	        && sv.sound_precache[sound_num] ; sound_num++)
		if (!strcmp(sample, sv.sound_precache[sound_num]))
			break;

	if ( sound_num == MAX_SOUNDS || !sv.sound_precache[sound_num] )
	{
		Con_Printf ("SV_StartSound: %s not precached\n", sample);
		return;
	}

	ent = NUM_FOR_EDICT(entity);

	if ((channel & 8) || !(int)sv_phs.value)	// no PHS flag
	{
		if (channel & 8)
			reliable = true; // sounds that break the phs are reliable
		use_phs = false;
		channel &= 7;
	}
	else
		use_phs = true;

	//	if (channel == CHAN_BODY || channel == CHAN_VOICE)
	//		reliable = true;

	channel = (ent<<3) | channel;

	if (volume != DEFAULT_SOUND_PACKET_VOLUME)
		channel |= SND_VOLUME;
	if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
		channel |= SND_ATTENUATION;

	// use the entity origin unless it is a bmodel or a trigger
	if (entity->v->solid == SOLID_BSP || (entity->v->solid == SOLID_TRIGGER && entity->v->modelindex == 0))
	{
		for (i=0 ; i<3 ; i++)
			origin[i] = entity->v->origin[i]+0.5*(entity->v->mins[i]+entity->v->maxs[i]);
	}
	else
	{
		VectorCopy (entity->v->origin, origin);
	}

	MSG_WriteByte (&sv.multicast, svc_sound);
	MSG_WriteShort (&sv.multicast, channel);
	if (channel & SND_VOLUME)
		MSG_WriteByte (&sv.multicast, volume);
	if (channel & SND_ATTENUATION)
		MSG_WriteByte (&sv.multicast, attenuation*64);
	MSG_WriteByte (&sv.multicast, sound_num);
	for (i=0 ; i<3 ; i++)
		MSG_WriteCoord (&sv.multicast, origin[i]);

	if (use_phs)
		SV_MulticastEx (origin, reliable ? MULTICAST_PHS_R : MULTICAST_PHS, sv_reliable_sound.value ? "rsnd" : NULL);
	else
		SV_MulticastEx (origin, reliable ? MULTICAST_ALL_R : MULTICAST_ALL, sv_reliable_sound.value ? "rsnd" : NULL);
}


/*
===============================================================================
 
FRAME UPDATES
 
===============================================================================
*/

int		sv_nailmodel, sv_supernailmodel, sv_playermodel;

void SV_FindModelNumbers (void)
{
	int		i;

	sv_nailmodel = -1;
	sv_supernailmodel = -1;
	sv_playermodel = -1;

	for (i=0 ; i<MAX_MODELS ; i++)
	{
		if (!sv.model_precache[i])
			break;
		if (!strcmp(sv.model_precache[i],"progs/spike.mdl"))
			sv_nailmodel = i;
		if (!strcmp(sv.model_precache[i],"progs/s_spike.mdl"))
			sv_supernailmodel = i;
		if (!strcmp(sv.model_precache[i],"progs/player.mdl"))
			sv_playermodel = i;
	}
}


/*
==================
SV_WriteClientdataToMessage
 
==================
*/
void SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg)
{
	int		i, clnum;
	edict_t	*other;
	edict_t	*ent;

	ent = client->edict;

	clnum = NUM_FOR_EDICT(ent) - 1;

	// send the chokecount for r_netgraph
	if (client->chokecount)
	{
		MSG_WriteByte (msg, svc_chokecount);
		MSG_WriteByte (msg, client->chokecount);
		client->chokecount = 0;
	}

	// send a damage message if the player got hit this frame
	if (ent->v->dmg_take || ent->v->dmg_save)
	{
		other = PROG_TO_EDICT(ent->v->dmg_inflictor);
		MSG_WriteByte (msg, svc_damage);
		MSG_WriteByte (msg, ent->v->dmg_save);
		MSG_WriteByte (msg, ent->v->dmg_take);
		for (i=0 ; i<3 ; i++)
			MSG_WriteCoord (msg, other->v->origin[i] + 0.5*(other->v->mins[i] + other->v->maxs[i]));

		ent->v->dmg_take = 0;
		ent->v->dmg_save = 0;
	}

	// add this to server demo
	if (sv.mvdrecording && msg->cursize)
	{
		if (MVDWrite_Begin(dem_single, clnum, msg->cursize))
		{
			MVD_SZ_Write(msg->data, msg->cursize);
		}
	}

	// a fixangle might get lost in a dropped packet.  Oh well.
	if (ent->v->fixangle)
	{
		ent->v->fixangle = 0;
		demo.fixangle[clnum] = true;

		MSG_WriteByte(msg, svc_setangle);

#ifdef MVD_PEXT1_HIGHLAGTELEPORT
		if (client->mvdprotocolextensions1 & MVD_PEXT1_HIGHLAGTELEPORT) {
			if (fofs_teleported) {
				client->lastteleport_teleport = ((eval_t *)((byte *)(client->edict)->v + fofs_teleported))->_int;
				if (client->lastteleport_teleport) {
					MSG_WriteByte(msg, 1); // signal a teleport
				}
				else {
					MSG_WriteByte(msg, 2); // respawn
				}
				client->lastteleport_outgoingseq = client->netchan.outgoing_sequence;
				client->lastteleport_incomingseq = client->netchan.incoming_sequence;
				client->lastteleport_teleportyaw = (client->edict)->v->angles[YAW] - client->lastcmd.angles[YAW];

				((eval_t *)((byte *)(client->edict)->v + fofs_teleported))->_int = 0;
				SV_RotateCmd(client, &client->lastcmd);
			}
			else {
				MSG_WriteByte(msg, 0); // we don't know, so no changes made...
			}
		}
#endif

		for (i=0 ; i < 3 ; i++)
			MSG_WriteAngle (msg, ent->v->angles[i] );

		if (sv.mvdrecording)
		{
			MSG_WriteByte (&demo.datagram, svc_setangle);
			MSG_WriteByte (&demo.datagram, clnum);
			for (i=0 ; i < 3 ; i++)
				MSG_WriteAngle (&demo.datagram, ent->v->angles[i] );
		}
	}

	// Z_EXT_TIME protocol extension
	// every now and then, send an update so that extrapolation
	// on client side doesn't stray too far off
#ifdef FTE_PEXT_ACCURATETIMINGS
	if (client->fteprotocolextensions & FTE_PEXT_ACCURATETIMINGS)
	{	//the fte pext causes the server to send out accurate timings, allowing for perfect interpolation.
		if (sv.physicstime - client->lastservertimeupdate > 0)
		{
			MSG_WriteByte(msg, svc_updatestatlong);
			MSG_WriteByte(msg, STAT_TIME);
			MSG_WriteLong(msg, (int)(sv.physicstime * 1000));

			client->lastservertimeupdate = sv.physicstime;
		}
	}
	else
#endif
	if ((SERVER_EXTENSIONS & Z_EXT_SERVERTIME) && (client->extensions & Z_EXT_SERVERTIME))
	{	//the zquake ext causes the server to send out peridoic timings, allowing for moderatly accurate game time.
		if (realtime - client->lastservertimeupdate > 5)
		{
			MSG_WriteByte(msg, svc_updatestatlong);
			MSG_WriteByte(msg, STAT_TIME);
			MSG_WriteLong(msg, (int) (sv.time * 1000));

			client->lastservertimeupdate = realtime;
		}
	}
}

/*
=======================
SV_UpdateClientStats
 
Performs a delta update of the stats array.  This should only be performed
when a reliable message can be delivered this frame.
=======================
*/
void SV_UpdateClientStats (client_t *client)
{
	edict_t *ent;
	int stats[MAX_CL_STATS], i;

	memset (stats, 0, sizeof(stats));

	ent = client->edict;

	// if we are a spectator and we are tracking a player, we get his stats
	// so our status bar reflects his
	if (client->spectator && client->spec_track > 0)
		ent = svs.clients[client->spec_track - 1].edict;

	// in case of trackent we have to reflect his stats like for spectator.
	if (fofs_trackent)
	{
		int trackent = ((eval_t *)((byte *)(client->edict)->v + fofs_trackent))->_int;
		if (trackent < 1 || trackent > MAX_CLIENTS || svs.clients[trackent - 1].state != cs_spawned)
			trackent = 0;

		if (trackent)
			ent = svs.clients[trackent - 1].edict;
	}

	stats[STAT_HEALTH] = ent->v->health;
	stats[STAT_WEAPON] = SV_ModelIndex(PR_GetEntityString(ent->v->weaponmodel));
	stats[STAT_AMMO] = ent->v->currentammo;
	stats[STAT_ARMOR] = ent->v->armorvalue;
	stats[STAT_SHELLS] = ent->v->ammo_shells;
	stats[STAT_NAILS] = ent->v->ammo_nails;
	stats[STAT_ROCKETS] = ent->v->ammo_rockets;
	stats[STAT_CELLS] = ent->v->ammo_cells;
	if (!client->spectator || client->spec_track > 0)
		stats[STAT_ACTIVEWEAPON] = ent->v->weapon;
	// stuff the sigil bits into the high bits of items for sbar
	stats[STAT_ITEMS] = (int) ent->v->items | ((int) PR_GLOBAL(serverflags) << 28);
	if (fofs_items2)	// ZQ_ITEMS2 extension
		stats[STAT_ITEMS] |= (int)EdictFieldFloat(ent, fofs_items2) << 23;

	if (ent->v->health > 0 || client->spectator) // viewheight for PF_DEAD & PF_GIB is hardwired
		stats[STAT_VIEWHEIGHT] = ent->v->view_ofs[2];

	for (i=0 ; i<MAX_CL_STATS ; i++)
		if (stats[i] != client->stats[i])
		{
			client->stats[i] = stats[i];
			if (stats[i] >=0 && stats[i] <= 255)
			{
				ClientReliableWrite_Begin(client, svc_updatestat, 3);
				ClientReliableWrite_Byte(client, i);
				ClientReliableWrite_Byte(client, stats[i]);
			}
			else
			{
				ClientReliableWrite_Begin(client, svc_updatestatlong, 6);
				ClientReliableWrite_Byte(client, i);
				ClientReliableWrite_Long(client, stats[i]);
			}
		}
}

/*
=======================
SV_SendClientDatagram
=======================
*/
void SV_SendClientDatagram (client_t *client, int client_num)
{
	byte		buf[MAX_DATAGRAM];
	sizebuf_t	msg;
	//	packet_t	*pack;

	SZ_InitEx(&msg, buf, sizeof(buf), true);

	// for faster downloading skip half the frames
	/*if (client->download && client->netchan.outgoing_sequence & 1)
	{
		// we're sending fake invalid delta update, so that client won't update screen
		MSG_WriteByte (&msg, svc_deltapacketentities);
		MSG_WriteByte (&msg, 0);
		MSG_WriteShort (&msg, 0);

		Netchan_Transmit (&client->netchan, msg.cursize, buf);
	}
	*/

	if (!SV_SkipCommsBotMessage(client)) {
		// add the client specific data to the datagram
		SV_WriteClientdataToMessage(client, &msg);

		// send over all the objects that are in the PVS
		// this will include clients, a packetentities, and
		// possibly a nails update
		SV_WriteEntitiesToClient(client, &msg, false);

#ifdef FTE_PEXT2_VOICECHAT
		SV_VoiceSendPacket(client, &msg);
#endif
	}

	// copy the accumulated multicast datagram
	// for this client out to the message
	if (client->datagram.overflowed)
		Con_Printf ("WARNING: datagram overflowed for %s\n", client->name);
	else
		SZ_Write (&msg, client->datagram.data, client->datagram.cursize);
	SZ_Clear (&client->datagram);

	// send deltas over reliable stream
	if (Netchan_CanReliable (&client->netchan))
		SV_UpdateClientStats (client);

	if (msg.overflowed)
	{
		Con_Printf ("WARNING: msg overflowed for %s\n", client->name);
		SZ_Clear (&msg);
	}

	// send the datagram
	Netchan_Transmit (&client->netchan, msg.cursize, buf);
}

/*
=======================
SV_UpdateToReliableMessages
=======================
*/
static void SV_UpdateToReliableMessages (void)
{
	int i, j;
	client_t *client;
	edict_t *ent;

	// check for changes to be sent over the reliable streams to all clients
	for (i=0, sv_client = svs.clients ; i<MAX_CLIENTS ; i++, sv_client++)
	{
		if (sv_client->state != cs_spawned)
			continue;

		if (sv_client->sendinfo)
		{
			sv_client->sendinfo = false;
			SV_FullClientUpdate (sv_client, &sv.reliable_datagram);
		}

		ent = sv_client->edict;

		if (sv_client->old_frags != (int)ent->v->frags)
		{
			for (j=0, client = svs.clients ; j<MAX_CLIENTS ; j++, client++)
			{
				if (client->state < cs_preconnected)
					continue;
				ClientReliableWrite_Begin(client, svc_updatefrags, 4);
				ClientReliableWrite_Byte(client, i);
				ClientReliableWrite_Short(client, (int) ent->v->frags);
			}

			if (sv.mvdrecording)
			{
				if (MVDWrite_Begin(dem_all, 0, 4))
				{
					MVD_MSG_WriteByte(svc_updatefrags);
					MVD_MSG_WriteByte(i);
					MVD_MSG_WriteShort((int)ent->v->frags);
				}
			}

			sv_client->old_frags = (int) ent->v->frags;
		}

		// maxspeed/entgravity changes
		if (fofs_gravity && sv_client->entgravity != EdictFieldFloat(ent, fofs_gravity))
		{
			sv_client->entgravity = EdictFieldFloat(ent, fofs_gravity);
			ClientReliableWrite_Begin(sv_client, svc_entgravity, 5);
			ClientReliableWrite_Float(sv_client, sv_client->entgravity);
			if (sv.mvdrecording)
			{
				if (MVDWrite_Begin(dem_single, i, 5))
				{
					MVD_MSG_WriteByte(svc_entgravity);
					MVD_MSG_WriteFloat(sv_client->entgravity);
				}
			}
		}

		if (fofs_maxspeed && sv_client->maxspeed != EdictFieldFloat(ent, fofs_maxspeed))
		{
			sv_client->maxspeed = EdictFieldFloat(ent, fofs_maxspeed);
			ClientReliableWrite_Begin(sv_client, svc_maxspeed, 5);
			ClientReliableWrite_Float(sv_client, sv_client->maxspeed);
			if (sv.mvdrecording)
			{
				if (MVDWrite_Begin(dem_single, i, 5))
				{
					MVD_MSG_WriteByte(svc_maxspeed);
					MVD_MSG_WriteFloat(sv_client->maxspeed);
				}
			}
		}

	}

	if (sv.datagram.overflowed)
		SZ_Clear (&sv.datagram);

	// append the broadcast messages to each client messages
	for (j=0, client = svs.clients ; j<MAX_CLIENTS ; j++, client++)
	{
		if (client->state < cs_preconnected)
			continue; // reliables go to all connected or spawned

		ClientReliableCheckBlock(client, sv.reliable_datagram.cursize);
		ClientReliableWrite_SZ(client, sv.reliable_datagram.data, sv.reliable_datagram.cursize);

		if (client->state != cs_spawned)
			continue; // datagrams only go to spawned

		SZ_Write (&client->datagram, sv.datagram.data, sv.datagram.cursize);
	}

	if (sv.mvdrecording && sv.reliable_datagram.cursize)
	{
		if (MVDWrite_Begin(dem_all, 0, sv.reliable_datagram.cursize))
		{
			MVD_SZ_Write(sv.reliable_datagram.data, sv.reliable_datagram.cursize);
		}
	}

	if (sv.mvdrecording)
		SZ_Write(&demo.datagram, sv.datagram.data, sv.datagram.cursize); // FIXME: ???

	SZ_Clear (&sv.reliable_datagram);
	SZ_Clear (&sv.datagram);
}

//#ifdef _WIN32
//#pragma optimize( "", off )
//#endif



/*
=======================
SV_SendClientMessages
=======================
*/
void SV_SendClientMessages (void)
{
	int			i, j;
	client_t	*c;

	if (sv.state != ss_active)
		return;

	// update frags, names, etc
	SV_UpdateToReliableMessages ();

	if (fofs_visibility) {
		for (i = 0; i < MAX_CLIENTS; ++i) {
			((eval_t *)((byte *)(svs.clients[i].edict)->v + fofs_visibility))->_int = 0;
		}
	}

	// build individual updates
	for (i=0, c = svs.clients ; i<MAX_CLIENTS ; i++, c++)
	{
		if (!c->state)
			continue;

		if (c->drop)
		{
			SV_DropClient(c);
			c->drop = false;
			continue;
		}

		// check to see if we have a backbuf to stick in the reliable
		if (c->num_backbuf)
		{
			// will it fit?
			if (c->netchan.message.cursize + c->backbuf_size[0] <
			        c->netchan.message.maxsize)
			{

				Con_DPrintf("%s: backbuf %d bytes\n",
				            c->name, c->backbuf_size[0]);

				// it'll fit
				SZ_Write(&c->netchan.message, c->backbuf_data[0],
				         c->backbuf_size[0]);

				//move along, move along
				for (j = 1; j < c->num_backbuf; j++)
				{
					memcpy(c->backbuf_data[j - 1], c->backbuf_data[j],
					       c->backbuf_size[j]);
					c->backbuf_size[j - 1] = c->backbuf_size[j];
				}

				c->num_backbuf--;
				if (c->num_backbuf)
				{
					memset(&c->backbuf, 0, sizeof(c->backbuf));
					c->backbuf.data = c->backbuf_data[c->num_backbuf - 1];
					c->backbuf.cursize = c->backbuf_size[c->num_backbuf - 1];
					c->backbuf.maxsize = c->netchan.message.maxsize;
				}
			}
		}

#ifdef USE_PR2
		if (c->isBot) {
			// Write damage to bot clients too (for mvd playback)
			SV_BotWriteDamage(c, i);

			SZ_Clear(&c->netchan.message);
			SZ_Clear(&c->datagram);
			c->num_backbuf = 0;

			// Need to tell mod what the bot would have seen
			SV_SetVisibleEntitiesForBot(c);
			continue;
		}
#endif
		// if the reliable message overflowed,
		// drop the client
		if (c->netchan.message.overflowed)
		{
			SZ_Clear (&c->netchan.message);
			SZ_Clear (&c->datagram);
			SV_BroadcastPrintf (PRINT_HIGH, "%s overflowed\n", c->name);
			Con_Printf ("WARNING: reliable overflow for %s\n",c->name);
			SV_DropClient (c);
			c->send_message = true;
			c->netchan.cleartime = 0;	// don't choke this message
		}

		// only send messages if the client has sent one
		// and the bandwidth is not choked
		if (!c->send_message)
			continue;
		c->send_message = false;	// try putting this after choke?
		if (!sv.paused && !Netchan_CanPacket (&c->netchan))
		{
			c->chokecount++;
			continue;		// bandwidth choke
		}

		if (c->state == cs_spawned)
			SV_SendClientDatagram (c, i);
		else {
			Netchan_Transmit (&c->netchan, c->datagram.cursize, c->datagram.data);	// just update reliable
			c->datagram.cursize = 0;
		}
	}
}

static void SV_BotWriteDamage(client_t* c, int i)
{
	edict_t* ent = c->edict;

	if (c->edict->v->dmg_take || c->edict->v->dmg_save) {
		if (ent->v->dmg_take || ent->v->dmg_save) {
			int length = 3 + 3 * msg_coordsize;

			if (MVDWrite_Begin(dem_single, i, length)) {
				edict_t* other = PROG_TO_EDICT(ent->v->dmg_inflictor);

				MVD_MSG_WriteByte(svc_damage);
				MVD_MSG_WriteByte(ent->v->dmg_save);
				MVD_MSG_WriteByte(ent->v->dmg_take);
				for (i = 0; i < 3; i++)
					MVD_MSG_WriteCoord(other->v->origin[i] + 0.5 * (other->v->mins[i] + other->v->maxs[i]));
			}

			ent->v->dmg_take = 0;
			ent->v->dmg_save = 0;
		}
	}
}

void SV_MVDPings (void)
{
	client_t *client;
	int j;

	for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
	{
		if (client->state != cs_spawned)
			continue;

		if (MVDWrite_Begin (dem_all, 0, 7))
		{
			MVD_MSG_WriteByte (svc_updateping);
			MVD_MSG_WriteByte (j);
			MVD_MSG_WriteShort(SV_CalcPing(client));
			MVD_MSG_WriteByte (svc_updatepl);
			MVD_MSG_WriteByte (j);
			MVD_MSG_WriteByte (client->lossage);
		}
	}
}

void MVD_WriteStats(void)
{
	client_t	*c;
	int i, j;
	edict_t		*ent;
	int			stats[MAX_CL_STATS];

	for (i = 0, c = svs.clients ; i < MAX_CLIENTS ; i++, c++)
	{
		if (c->state != cs_spawned)
			continue;	// datagrams only go to spawned

		if (c->spectator)
			continue;

		ent = c->edict;
		memset (stats, 0, sizeof(stats));

		stats[STAT_HEALTH] = ent->v->health;
		stats[STAT_WEAPON] = SV_ModelIndex(PR_GetEntityString(ent->v->weaponmodel));
		stats[STAT_AMMO] = ent->v->currentammo;
		stats[STAT_ARMOR] = ent->v->armorvalue;
		stats[STAT_SHELLS] = ent->v->ammo_shells;
		stats[STAT_NAILS] = ent->v->ammo_nails;
		stats[STAT_ROCKETS] = ent->v->ammo_rockets;
		stats[STAT_CELLS] = ent->v->ammo_cells;
		stats[STAT_ACTIVEWEAPON] = ent->v->weapon;

		if (ent->v->health > 0) // viewheight for PF_DEAD & PF_GIB is hardwired
			stats[STAT_VIEWHEIGHT] = ent->v->view_ofs[2];

		// stuff the sigil bits into the high bits of items for sbar
		stats[STAT_ITEMS] = (int) ent->v->items | ((int) PR_GLOBAL(serverflags) << 28);

		for (j = 0 ; j < MAX_CL_STATS; j++)
		{
			if (stats[j] != demo.stats[i][j])
			{
				demo.stats[i][j] = stats[j];
				if (stats[j] >= 0 && stats[j] <= 255)
				{
					if (MVDWrite_Begin(dem_stats, i, 3))
					{
						MVD_MSG_WriteByte(svc_updatestat);
						MVD_MSG_WriteByte(j);
						MVD_MSG_WriteByte(stats[j]);
					}
				}
				else
				{
					if (MVDWrite_Begin(dem_stats, i, 6))
					{
						MVD_MSG_WriteByte(svc_updatestatlong);
						MVD_MSG_WriteByte(j);
						MVD_MSG_WriteLong(stats[j]);
					}
				}
			}
		}
	}
}

void DestFlush(qbool compleate);
void SV_MVD_RunPendingConnections(void);
void QTV_ReadDests( void );

void SV_SendDemoMessage(void)
{
	int			i, cls = 0;
	client_t	*c;
	sizebuf_t	msg;
	byte		msg_buf[MAX_MVD_SIZE]; // data without mvd header

	float		min_fps;
	extern		cvar_t sv_demofps, sv_demoIdlefps;
	extern		cvar_t sv_demoPings;

	if (sv.state != ss_active)
		return;

	SV_MVD_RunPendingConnections();

	if (!sv.mvdrecording)
	{
		DestFlush(false); // well, this may help close some fucked up dests
		return;
	}

	for (i = 0, c = svs.clients; i < MAX_CLIENTS; i++, c++)
	{
		if (c->state != cs_spawned)
			continue;	// datagrams only go to spawned

		cls |= 1 << i;
	}

	// if no players or paused, use idle fps
	if (cls && !sv.paused)
		min_fps = max(4.0, (int)sv_demofps.value ? (int)sv_demofps.value : 20.0);
	else
		min_fps = bound(4.0, (int)sv_demoIdlefps.value, 30);

	if (curtime - demo.curtime < 1.0 / min_fps) {
		return;
	}

	SZ_InitEx(&msg, msg_buf, sizeof(msg_buf), true);

	if ((int)sv_demoPings.value)
	{
		if (curtime - demo.pingtime > sv_demoPings.value)
		{
			SV_MVDPings();
			demo.pingtime = curtime;
		}
	}

	MVD_WriteStats();

	// send over all the objects that are in the PVS
	// this will include clients, a packetentities, and
	// possibly a nails update

	if (!demo.recorder.delta_sequence)
		demo.recorder.delta_sequence = -1;

	SV_WriteEntitiesToClient (&demo.recorder, &msg, true);

	if (msg.overflowed)
	{
		Sys_Printf("WARNING: msg overflowed in SV_SendDemoMessage\n");
	}
	else
	{
		if (msg.cursize)
		{
			if (MVDWrite_Begin(dem_all, 0, msg.cursize))
			{
				MVD_SZ_Write(msg.data, msg.cursize);
			}
		}
	}

	SZ_Clear(&msg);

	// copy the accumulated multicast datagram
	// for this client out to the message
	if (demo.datagram.overflowed)
	{
		Sys_Printf("WARNING: demo.datagram overflowed in SV_SendDemoMessage\n");
	}
	else
	{
		if (demo.datagram.cursize)
		{
			if (MVDWrite_Begin(dem_all, 0, demo.datagram.cursize))
			{
				MVD_SZ_Write (demo.datagram.data, demo.datagram.cursize);
			}
		}
	}

	SZ_Clear (&demo.datagram);

	demo.recorder.delta_sequence = demo.recorder.netchan.incoming_sequence&255;
	demo.recorder.netchan.incoming_sequence++;
	demo.frames[demo.parsecount & UPDATE_MASK].time = sv.time;
	demo.frames[demo.parsecount & UPDATE_MASK].paused = sv.paused;
	demo.frames[demo.parsecount & UPDATE_MASK].pause_duration = (int)bound(0, (curtime - demo.curtime) * 1000.0f, 255);
	demo.curtime = curtime;
	demo.time = sv.time;

	// let's not wait so much time (was 60)
	if (demo.parsecount - demo.lastwritten > 5) {
		SV_MVDWritePackets(1);
	}

	// flush once per demo frame
	DestFlush(false);

	// read QTV input once per demo frame
	QTV_ReadDests();

	if (!sv.mvdrecording)
		return;

	demo.parsecount++;
}


//#ifdef _WIN32
//#pragma optimize( "", on )
//#endif



/*
=======================
SV_SendMessagesToAll
 
FIXME: does this sequence right?
=======================
*/
void SV_SendMessagesToAll (void)
{
	int			i;
	client_t	*c;

	for (i=0, c = svs.clients ; i<MAX_CLIENTS ; i++, c++)
		if (c->state >= cs_connected)		// FIXME: should this only send to active?
			c->send_message = true;

	SV_SendClientMessages ();
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_sys_unix.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: sv_sys_unix.c,v 1.11 2006-12-30 11:24:54 disconn3ct Exp $

*/
#include <sys/types.h>
#include "qwsvdef.h"

#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
#include <sys/stat.h>
#include <unistd.h>
#include <sys/time.h>
#include <errno.h>
#else
#include <sys/dir.h>
#endif

cvar_t	sys_nostdout = {"sys_nostdout","0"};
cvar_t	sys_extrasleep = {"sys_extrasleep","0"};

qbool stdin_ready;
int do_stdin = 1;

/*
===============================================================================

				REQUIRED SYS FUNCTIONS

===============================================================================
*/


/*
============
Sys_mkdir

============
*/
void Sys_mkdir (const char *path)
{
	if (mkdir (path, 0777) != -1)
		return;
	if (errno != EEXIST)
		Sys_Error ("mkdir %s: %s",path, strerror(errno)); 
}


/*
================
Sys_DoubleTime
================
*/
double Sys_DoubleTime (void)
{
	struct timeval tp;
	struct timezone tzp;
	static int		secbase;

	gettimeofday(&tp, &tzp);
	
	if (!secbase)
	{
		secbase = tp.tv_sec;
		return tp.tv_usec/1000000.0;
	}
	
	return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
}


/*
================
Sys_Error
================
*/
void Sys_Error (char *error, ...)
{
	va_list argptr;
	char string[1024];
	
	va_start (argptr ,error);
	vsnprintf (string, sizeof(string), error, argptr);
	va_end (argptr);
	printf ("Fatal error: %s\n",string);
	
	exit (1);
}


/*
================
Sys_Printf
================
*/
void Sys_Printf (char *fmt, ...)
{
	va_list argptr;
	static char text[2048];
	unsigned char *p;

	va_start (argptr, fmt);
	vsnprintf (text, sizeof(text), fmt, argptr);
	va_end (argptr);

	if (sys_nostdout.value)
		return;

	for (p = (unsigned char *)text; *p; p++) {
		*p &= 0x7f;
		if ((*p > 128 || *p < 32) && *p != 10 && *p != 13 && *p != 9)
			printf("[%02x]", *p);
		else
			putc(*p, stdout);
	}
	fflush(stdout);
}


/*
================
Sys_Quit
================
*/
void Sys_Quit (void)
{
	exit (0);		// appkit isn't running
}


/*
=============
Sys_Init

Quake calls this so the system can register variables before host_hunklevel
is marked
=============
*/
void Sys_Init (void)
{
	Cvar_Register (&sys_nostdout);
	Cvar_Register (&sys_extrasleep);
}

/*
=============
main
=============
*/
int main (int argc, char *argv[])
{
	double	time, oldtime, newtime;

	Host_Init (argc, argv, 16*1024*1024);

//
// main loop
//
	oldtime = Sys_DoubleTime () - 0.1;
	while (1)
	{
		// select on the net socket and stdin
		NET_Sleep (10);

		// find time passed since last cycle
		newtime = Sys_DoubleTime ();
		time = newtime - oldtime;
		oldtime = newtime;
		
		Host_Frame (time);		
		
		// extrasleep is just a way to generate a fucked up connection on purpose
		if (sys_extrasleep.value)
			usleep (sys_extrasleep.value);
	}	
}



================================================
FILE: src/sv_sys_win.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/

#include "qwsvdef.h"
#include <mmsystem.h>
#include <io.h>

extern cvar_t sys_restart_on_error;
extern cvar_t sys_select_timeout, sys_simulation;

cvar_t	sys_nostdout	= {"sys_nostdout", "0"};
cvar_t	sys_sleep		= {"sys_sleep", "8"};

static char title[16];

static qbool	isdaemon = false;

//==============================================================================
// WINDOWS CMD LINE CRAP
//==============================================================================

static int			argc;
static char			*argv[MAX_NUM_ARGVS];

char *Sys_GetModuleName(void)
{
	static char	exename[1024] = {0}; // static
	int i;

	if (exename[0])
		return exename;

	if(!(i = GetModuleFileName(NULL, exename, sizeof(exename)-1))) // here we get loong string, with full path
	{
		exename[0] = 0; // oh, something bad
	}
	else 
	{
		exename[i] = 0; // ensure null terminator
	}

	return exename;
}

#ifdef _CONSOLE
void ParseCommandLine (int ac, char **av)
{
	argc = 1;
	argv[0] = Sys_GetModuleName();

	for( ; argc < MAX_NUM_ARGVS && ac > 0; argc++, ac--)
	{
		argv[argc] = av[argc-1];
	}
}
#else
void ParseCommandLine (char *lpCmdLine)
{
	argc = 1;
	argv[0] = Sys_GetModuleName();

	while (*lpCmdLine && (argc < MAX_NUM_ARGVS))
	{
		while (*lpCmdLine && ((*lpCmdLine <= 32) || (*lpCmdLine > 126)))
			lpCmdLine++;

		if (*lpCmdLine)
		{
			if (*lpCmdLine == '\"')
			{
				lpCmdLine++;

				argv[argc] = lpCmdLine;
				argc++;

				while (*lpCmdLine && *lpCmdLine != '\"') // this include chars less that 32 and greate than 126... is that evil?
					lpCmdLine++;
			}
			else
			{
				argv[argc] = lpCmdLine;
				argc++;

				while (*lpCmdLine && ((*lpCmdLine > 32) && (*lpCmdLine <= 126)))
					lpCmdLine++;
			}

			if (*lpCmdLine)
			{
				*lpCmdLine = 0;
				lpCmdLine++;
			}
		}
	}
}
#endif

/*
================
Sys_FileTime
================
*/
int	Sys_FileTime (const char *path)
{
	struct _stat buf;
	return _stat (path, &buf) == -1 ? -1 : buf.st_mtime;
}

/*
================
Sys_mkdir
================
*/
void Sys_mkdir (const char *path)
{
	_mkdir(path);
}

/*
================
Sys_remove
================
*/
int Sys_remove (const char *path)
{
	return remove(path);
}

//bliP: rmdir ->
/*
================
Sys_rmdir
================
*/
int Sys_rmdir (const char *path)
{
	return _rmdir(path);
}
//<-

/*
================
Sys_listdir
================
*/

dir_t Sys_listdir (const char *path, const char *ext, int sort_type)
{
	static file_t	list[MAX_DIRFILES];
	dir_t	dir;
	HANDLE	h;
	WIN32_FIND_DATA fd;
	char	pathname[MAX_DEMO_NAME];
	qbool all;

	PCRE2_SIZE	error_offset;
	pcre2_code	*preg;
	pcre2_match_data *match_data = NULL;
	int error;

	memset(list, 0, sizeof(list));
	memset(&dir, 0, sizeof(dir));

	dir.files = list;
	all = !strncmp(ext, ".*", 3);
	if (!all)
		if (!(preg = pcre2_compile((PCRE2_SPTR)ext, PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &error, &error_offset, NULL)))
		{
			PCRE2_UCHAR error_str[256];
			pcre2_get_error_message(error, error_str, sizeof(error_str));
			Con_Printf("Sys_listdir: pcre2_compile(%s) error: %s at offset %d\n",
			           ext, error_str, error_offset);
			pcre2_code_free(preg);
			return dir;
		}

	snprintf(pathname, sizeof(pathname), "%s/*.*", path);
	if ((h = FindFirstFile (pathname , &fd)) == INVALID_HANDLE_VALUE)
	{
		if (!all)
			pcre2_code_free(preg);
		return dir;
	}

	do
	{
		if (!strncmp(fd.cFileName, ".", 2) || !strncmp(fd.cFileName, "..", 3))
			continue;
		if (!all)
		{
			match_data = pcre2_match_data_create_from_pattern(preg, NULL);
			error = pcre2_match(preg, (PCRE2_SPTR)fd.cFileName,
				strlen(fd.cFileName), 0, 0, match_data, NULL);
			if (error < 0) {
				if (error != PCRE2_ERROR_NOMATCH) {
					Con_Printf("Sys_listdir: pcre2_match(%s, %s) error code: %d\n",
						ext, fd.cFileName, error);
				}
				continue;
			}
		}

		if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) //bliP: list dir
		{
			dir.numdirs++;
			list[dir.numfiles].isdir = true;
			list[dir.numfiles].size = list[dir.numfiles].time = 0;
		}
		else
		{
			list[dir.numfiles].isdir = false;
			snprintf(pathname, sizeof(pathname), "%s/%s", path, fd.cFileName);
			list[dir.numfiles].time = Sys_FileTime(pathname);
			dir.size += (list[dir.numfiles].size = fd.nFileSizeLow);
		}
		strlcpy (list[dir.numfiles].name, fd.cFileName, sizeof(list[0].name));

		if (++dir.numfiles == MAX_DIRFILES - 1)
			break;

	}
	while (FindNextFile(h, &fd));

	FindClose (h);
	if (!all)
		pcre2_code_free(preg);

	switch (sort_type)
	{
	case SORT_NO: break;
	case SORT_BY_DATE:
		qsort((void *)list, dir.numfiles, sizeof(file_t), Sys_compare_by_date);
		break;
	case SORT_BY_NAME:
		qsort((void *)list, dir.numfiles, sizeof(file_t), Sys_compare_by_name);
		break;
	}
	return dir;
}

int Sys_EnumerateFiles (char *gpath, char *match, int (*func)(char *, int, void *), void *parm)
{
	HANDLE r;
	WIN32_FIND_DATA fd; 
	char apath[MAX_OSPATH];
	char apath2[MAX_OSPATH];
	char file[MAX_OSPATH];
	char *s;
	int go;
	if (!gpath)
		return 0;

	snprintf(apath, sizeof(apath), "%s/%s", gpath, match);
	for (s = apath+strlen(apath)-1; s> apath; s--)
	{
		if (*s == '/') 
			break;
	}
	*s = '\0';

	// This is what we ask windows for.
	snprintf(file, sizeof(file), "%s/*.*", apath);

	// We need to make apath contain the path in match but not gpath
	strlcpy(apath2, match, sizeof(apath));
	match = s+1;
	for (s = apath2+strlen(apath2)-1; s> apath2; s--)
	{
		if (*s == '/')
			break;
	}
	*s = '\0';
	if (s != apath2)
		strlcat (apath2, "/", sizeof (apath2));

	r = FindFirstFile(file, &fd);
	if (r==(HANDLE)-1)
		return 1;
	go = true;
	do
	{
		if (*fd.cFileName == '.');  // Don't ever find files with a name starting with '.'
		else if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)    //is a directory
		{
			if (wildcmp(match, fd.cFileName))
			{
				snprintf(file, sizeof(file), "%s%s/", apath2, fd.cFileName);
				go = func(file, fd.nFileSizeLow, parm);
			}
		}
		else
		{
			if (wildcmp(match, fd.cFileName))
			{
				snprintf(file, sizeof(file), "%s%s", apath2, fd.cFileName);
				go = func(file, fd.nFileSizeLow, parm);
			}
		}
	}
	while(FindNextFile(r, &fd) && go);
	FindClose(r);

	return go;
}

/*
================
Sys_Exit
================
*/
void Sys_Exit(int code)
{
#ifndef _CONSOLE
	RemoveNotifyIcon();
#endif
	exit(code);
}

/*
================
Sys_Quit
================
*/

void myInvalidParameterHandler(const wchar_t* expression,
   const wchar_t* function, 
   const wchar_t* file, 
   unsigned int line, 
   uintptr_t pReserved)
{
	// nothing
}

void Sys_Quit (qbool restart)
{
	if (restart)
	{
#ifndef __MINGW32__
		int maxfd = 131072; // well, should be enough for everyone...

		_set_invalid_parameter_handler(myInvalidParameterHandler); // so close() does not crash our program on invalid handle...

		// close all file descriptors even stdin stdout and stderr, seems that not hurt...
		for (; maxfd > -1; maxfd--)
		{
			close(maxfd);
			closesocket(maxfd); // yeah, windows separate sockets and files, so you can't close socket with close() like on *nix.
		}

		if (execv(argv[0], com_argv) == -1)
#endif
		{
#ifdef _CONSOLE
			if (!((int)sys_nostdout.value || isdaemon))
				printf("Restart failed: (%i): %s\n", qerrno, strerror(qerrno));
#else
			if (!(COM_CheckParm("-noerrormsgbox") || isdaemon))
				MessageBox(NULL, strerror(qerrno), "Restart failed", 0 /* MB_OK */ );
#endif
			Sys_Exit(1);
		}
	}
	Sys_Exit(0);
}

/*
================
Sys_Error
================
*/
void Sys_Error (const char *error, ...)
{
	static qbool inerror = false;
	va_list argptr;
	char text[1024];

	sv_error = true;

	if (inerror)
		Sys_Exit (1);

	inerror = true;

	va_start (argptr, error);
	vsnprintf (text, sizeof (text), error, argptr);
	va_end (argptr);

#ifdef _CONSOLE
	if (!((int)sys_nostdout.value || isdaemon))
		printf ("ERROR: %s\n", text);
#else
	if (!(COM_CheckParm ("-noerrormsgbox") || isdaemon))
		MessageBox (NULL, text, "Error", 0 /* MB_OK */ );
	else
		Sys_Printf ("ERROR: %s\n", text);

#endif

	if (logs[ERROR_LOG].sv_logfile)
	{
		SV_Write_Log (ERROR_LOG, 1, va ("ERROR: %s\n", text));
//		fclose (logs[ERROR_LOG].sv_logfile);
	}

// FIXME: hack - checking SV_Shutdown with svs.socketip set in -1 NET_Shutdown
	if (svs.socketip != -1)
		SV_Shutdown (va("ERROR: %s\n", text));

	if ((int)sys_restart_on_error.value)
		Sys_Quit (true);

	Sys_Exit (1);
}

static double pfreq;
static qbool hwtimer = false;
static __int64 startcount;
void Sys_InitDoubleTime (void)
{
	__int64 freq;

	if (!COM_CheckParm("-nohwtimer") &&
		QueryPerformanceFrequency ((LARGE_INTEGER *)&freq) && freq > 0)
	{
		// hardware timer available
		pfreq = (double)freq;
		hwtimer = true;
		QueryPerformanceCounter ((LARGE_INTEGER *)&startcount);
	}
	else
	{
		// make sure the timer is high precision, otherwise
		// NT gets 18ms resolution
		timeBeginPeriod (1);
	}
}

double Sys_DoubleTime (void)
{
	__int64 pcount;

	static DWORD starttime;
	static qbool first = true;
	DWORD now;

	if (hwtimer)
	{
		QueryPerformanceCounter ((LARGE_INTEGER *)&pcount);
		if (first) {
			first = false;
			startcount = pcount;
			return 0.0;
		}
		// TODO: check for wrapping; is it necessary?
		return (pcount - startcount) / pfreq;
	}

	now = timeGetTime();

	if (first)
	{
		first = false;
		starttime = now;
		return 0.0;
	}

	if (now < starttime) // wrapped?
		return (now / 1000.0) + (LONG_MAX - starttime / 1000.0);

	if (now - starttime == 0)
		return 0.0;

	return (now - starttime) / 1000.0;
}

/*
================
Sys_ConsoleInput
================
*/
char *Sys_ConsoleInput (void)
{
#ifdef _CONSOLE

	static char	text[256], *t;
	static int	len = 0;

	int		c;

	// read a line out
	if (!isdaemon)
		while (_kbhit())
		{
			c = _getch();

			if (c == 224)
			{
				if (_kbhit())
				{
					// assume escape sequence (arrows etc), skip
					_getch();
					continue;
				}
				// assume character
			}

			if (c < 32 && c != '\r' && c != 8)
				continue;

			putch (c);
			if (c == '\r')
			{
				text[len] = 0;
				putch ('\n');
				len = 0;
				return text;
			}
			if (c == 8)
			{
				if (len)
				{
					putch (' ');
					putch (c);
					len--;
					text[len] = 0;
				}
				continue;
			}

			text[len] = c;
			len++;
			text[len] = 0;
			if (len == sizeof(text))
				len = 0;
		}
#endif

	// If you searching where input added under non console application, then you should check DialogFunc WM_COMMAND.

	return NULL;
}

/*
================
Sys_Printf
================
*/
void Sys_Printf(char* fmt, ...)
{
	va_list argptr;
	char text[MAXCMDBUF];
	char* startpos;
	char* endpos;
	date_t      date;

#ifdef _CONSOLE
	if ((int)sys_nostdout.value) {
		return;
	}
#endif

	if (isdaemon) {
		return;
	}

	va_start(argptr, fmt);
	vsnprintf(text, MAXCMDBUF, fmt, argptr);
	va_end(argptr);

	// normalize text before add to console.
	Q_normalizetext(text);

#ifndef _CONSOLE
	ConsoleAddText(text);
#else
	SV_TimeOfDay(&date, "%Y-%m-%d %H:%M:%S");
	startpos = text;
	while (startpos && startpos[0]) {
		endpos = strchr(startpos, '\n');
		if (endpos) {
			*endpos = '\0';
		}
		fprintf(stdout, "[%s] %s\n", date.str, startpos);
		fflush(stdout);
		if (endpos) {
			startpos = endpos + 1;
			if (startpos[0] == (char)10) {
				++startpos;
			}
		}
		else {
			break;
		}
	}
#endif //_CONSOLE
}

/*
=============
Sys_Init
 
Quake calls this so the system can register variables before host_hunklevel
is marked
=============
*/
void Sys_Init (void)
{
	qbool	WinNT;
	OSVERSIONINFO	vinfo;

	// make sure the timer is high precision, otherwise
	// NT gets 18ms resolution
	timeBeginPeriod( 1 );

	vinfo.dwOSVersionInfoSize = sizeof(vinfo);

	if (!GetVersionEx (&vinfo))
		Sys_Error ("Couldn't get OS info");

	if (vinfo.dwMajorVersion < 4 || vinfo.dwPlatformId == VER_PLATFORM_WIN32s)
		Sys_Error (SERVER_NAME " requires at least Win95 or NT 4.0");

	WinNT = (vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT ? true : false);

	Cvar_Register (&sys_nostdout);
	Cvar_Register (&sys_sleep);

	if (COM_CheckParm ("-nopriority"))
	{
		Cvar_Set (&sys_sleep, "0");
	}
	else
	{
		if ( ! SetPriorityClass (GetCurrentProcess(), HIGH_PRIORITY_CLASS))
			Con_Printf ("SetPriorityClass() failed\n");
		else
			Con_Printf ("Process priority class set to HIGH\n");

		// sys_sleep > 0 seems to cause packet loss on WinNT (why?)
		if (WinNT)
			Cvar_Set (&sys_sleep, "0");
	}

	Sys_InitDoubleTime ();
}

void Sys_Sleep (unsigned long ms)
{
	Sleep (ms);
}

int Sys_Script (const char *path, const char *args)
{
	STARTUPINFO			si;
	PROCESS_INFORMATION	pi;
	char cmdline[1024], curdir[MAX_OSPATH];

	memset (&si, 0, sizeof(si));
	si.cb = sizeof(si);
	si.dwFlags = STARTF_USESHOWWINDOW;
	si.wShowWindow = SW_SHOWMINNOACTIVE;

	GetCurrentDirectory(sizeof(curdir), curdir);


	snprintf(cmdline, sizeof(cmdline), "%s\\sh.exe %s.qws %s", curdir, path, args);
	strlcat(curdir, va("\\%s", fs_gamedir+2), MAX_OSPATH);

	return CreateProcess (NULL, cmdline, NULL, NULL,
	                      FALSE, 0/*DETACHED_PROCESS /*CREATE_NEW_CONSOLE*/ , NULL, curdir, &si, &pi);
}

DL_t Sys_DLOpen (const char *path)
{
	return LoadLibrary (path);
}

qbool Sys_DLClose (DL_t dl)
{
	return FreeLibrary (dl);
}

void *Sys_DLProc (DL_t dl, const char *name)
{
	return (void *) GetProcAddress (dl, name);
}

int Sys_CreateThread(DWORD (WINAPI *func)(void *), void *param)
{
    DWORD threadid;
    HANDLE thread;

    thread = CreateThread (
        NULL,               // pointer to security attributes
        0,                  // initial thread stack size
        func,               // pointer to thread function
        param,              // argument for new thread
        CREATE_SUSPENDED,   // creation flags
        &threadid);         // pointer to receive thread ID

    ResumeThread(thread);

    return 1;
}

#ifdef _CONSOLE
/*
==================
main
 
==================
*/

int main(int ac, char *av[])
{
	double			newtime, time, oldtime;
	int				sleep_msec;

	ParseCommandLine (ac, av);

	COM_InitArgv (argc, argv);

	GetConsoleTitle(title, sizeof(title));

	Host_Init(argc, argv, DEFAULT_MEM_SIZE);

	// run one frame immediately for first heartbeat
	SV_Frame (0.1);

	//
	// main loop
	//
	oldtime = Sys_DoubleTime () - 0.1;

	while (1)
	{
		sleep_msec = (int)sys_sleep.value;
		if (sleep_msec > 0)
		{
			if (sleep_msec > 13)
				sleep_msec = 13;
			Sleep (sleep_msec);
		}

		// select on the net socket and stdin
		// the only reason we have a timeout at all is so that if the last
		// connected client times out, the message would not otherwise
		// be printed until the next event.
		if (!sys_simulation.value) {
			NET_Sleep((int)sys_select_timeout.value / 1000, false);
		}

		// find time passed since last cycle
		newtime = Sys_DoubleTime ();
		time = newtime - oldtime;
		oldtime = newtime;

		curtime = newtime;
		SV_Frame (time);
	}

	return true;
}

#else  // _CONSOLE

int APIENTRY WinMain(   HINSTANCE   hInstance,
						HINSTANCE   hPrevInstance,
						LPSTR       lpCmdLine,
						int         nCmdShow)
{
	static MSG			msg;
	static double		newtime, time, oldtime;
	register int		sleep_msec;

	static qbool		disable_gpf = false;

	ParseCommandLine(lpCmdLine);

	COM_InitArgv (argc, argv);

	// create main window
	if (!CreateMainWindow(hInstance, nCmdShow))
		return 1;

	if (COM_CheckParm("-noerrormsgbox"))
		disable_gpf = true;

	if (COM_CheckParm ("-d"))
	{
		isdaemon = disable_gpf = true;
		//close(0); close(1); close(2);
	}

	if (disable_gpf)
	{
		DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
		SetErrorMode(dwMode | SEM_NOGPFAULTERRORBOX);
	}
	
	Host_Init(argc, argv, DEFAULT_MEM_SIZE);

	// if stared miminize update notify icon message (with correct port)
	if (minimized)
		UpdateNotifyIconMessage(va(SERVER_NAME ":%d", NET_UDPSVPort()));

	// run one frame immediately for first heartbeat
	SV_Frame (0.1);

	//
	// main loop
	//
	oldtime = Sys_DoubleTime () - 0.1;

	while(1)
	{
		// get messeges sent to windows
		if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
		{
			if( !GetMessage( &msg, NULL, 0, 0 ) )
				break;
			if(!IsDialogMessage(DlgHwnd, &msg))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}

		CheckIdle();

		// server frame

		sleep_msec = (int)sys_sleep.value;
		if (sleep_msec > 0)
		{
			if (sleep_msec > 13)
				sleep_msec = 13;
			Sleep (sleep_msec);
		}

		// select on the net socket and stdin
		// the only reason we have a timeout at all is so that if the last
		// connected client times out, the message would not otherwise
		// be printed until the next event.
		if (!sys_simulation.value) {
			NET_Sleep((int)sys_select_timeout.value / 1000, false);
		}

		// find time passed since last cycle
		newtime = Sys_DoubleTime ();
		time = newtime - oldtime;
		oldtime = newtime;

		curtime = newtime;
		SV_Frame (time);
	}


	Sys_Exit(msg.wParam);

	return msg.wParam;
}

#endif // _CONSOLE


================================================
FILE: src/sv_user.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	
*/
// sv_user.c -- server code for moving users

#ifndef CLIENTONLY
#include "qwsvdef.h"

static void SV_ClientDownloadComplete(client_t* cl);

edict_t	*sv_player;

usercmd_t	cmd;

cvar_t	sv_spectalk = {"sv_spectalk", "1"};
cvar_t	sv_sayteam_to_spec = {"sv_sayteam_to_spec", "1"};
cvar_t	sv_mapcheck = {"sv_mapcheck", "1"};
cvar_t	sv_minping = {"sv_minping", "0"};
cvar_t	sv_maxping = {"sv_maxping", "0"};
cvar_t	sv_enable_cmd_minping = {"sv_enable_cmd_minping", "1"};

cvar_t	sv_kickuserinfospamtime = {"sv_kickuserinfospamtime", "3"};
cvar_t	sv_kickuserinfospamcount = {"sv_kickuserinfospamcount", "300"};

cvar_t	sv_maxuploadsize = {"sv_maxuploadsize", "1048576"};

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
cvar_t  sv_downloadchunksperframe = {"sv_downloadchunksperframe", "15"};
#endif

#ifdef FTE_PEXT2_VOICECHAT
// Enable reception of voice packets.
cvar_t sv_voip = {"sv_voip", "1"};
// Record voicechat into mvds. Requires player support. 0=noone, 1=everyone, 2=spectators only.
cvar_t sv_voip_record = {"sv_voip_record", "0"};
// Echo voice packets back to their sender, a debug/test setting.
cvar_t sv_voip_echo = {"sv_voip_echo", "0"};
#endif

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
static qbool SV_ClientExtensionWeaponSwitch(client_t* cl);
#endif

#ifdef MVD_PEXT1_DEBUG
typedef struct {
	int msec;
	byte model;
	vec3_t pos;
	qbool present;
} antilag_client_info_t;

static struct {
	antilag_client_info_t antilag_clients[MAX_CLIENTS];
} debug_info;

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
static void SV_DebugServerSideWeaponScript(client_t* cl, int best_impulse);
static void SV_DebugServerSideWeaponInstruction(client_t* cl);
#endif
cvar_t sv_debug_weapons = { "sv_debug_weapons", "0" };
#endif

// These don't need any protocol extensions
cvar_t sv_debug_usercmd = { "sv_debug_usercmd", "0" };
cvar_t sv_debug_antilag = { "sv_debug_antilag", "0" };


#ifdef MVD_PEXT1_SERVERSIDEWEAPON
static void SV_UserSetWeaponRank(client_t* cl, const char* new_wrank);
#endif
static void SV_DebugClientCommand(byte playernum, const usercmd_t* cmd, int dropnum_);

extern	vec3_t	player_mins;

extern int	fp_messages, fp_persecond, fp_secondsdead;
extern char	fp_msg[];
extern cvar_t   pausable;
extern cvar_t   pm_bunnyspeedcap;
extern cvar_t   pm_ktjump;
extern cvar_t   pm_slidefix;
extern cvar_t   pm_airstep;
extern cvar_t   pm_pground;
extern cvar_t   pm_rampjump;
extern double	sv_frametime;

//bliP: init ->
extern cvar_t	sv_unfake; //bliP: 24/9 kickfake to unfake
extern cvar_t	sv_kicktop;
extern cvar_t	sv_speedcheck; //bliP: 24/9
//<-

static void OnChange_sv_maxpitch (cvar_t *var, char *str, qbool *cancel);
static void OnChange_sv_minpitch (cvar_t *var, char *str, qbool *cancel);
cvar_t	sv_maxpitch = {"sv_maxpitch", "80", 0, OnChange_sv_maxpitch};
cvar_t	sv_minpitch = {"sv_minpitch", "-70", 0, OnChange_sv_minpitch};

static void SetUpClientEdict (client_t *cl, edict_t *ent);

static qbool IsLocalIP(netadr_t a)
{
	return a.ip[0] == 10 || (a.ip[0] == 172 && (a.ip[1] & 0xF0) == 16)
	       || (a.ip[0] == 192 && a.ip[1] == 168) || a.ip[0] >= 224;
}
static qbool IsInetIP(netadr_t a)
{
	return a.ip[0] != 127 && !IsLocalIP(a);
}

//
// pitch clamping
//
// All this OnChange code is because we want the cvar names to have sv_ prefixes,
// but don't want them in serverinfo (save a couple of bytes of space)
// Value sanity checks are also done here
//
static void OnChange_sv_maxpitch (cvar_t *var, char *str, qbool *cancel)
{
	float	newval;
	char	*newstr;

	*cancel = true;

	newval = bound (0, Q_atof(str), 89.9f);
	if (newval == var->value)
		return;

	Cvar_SetValue (var, newval);
	newstr = (newval == 80.0f) ? (char *)"" : var->string;	// don't show default values in serverinfo
	SV_ServerinfoChanged("maxpitch", newstr);
}

static void OnChange_sv_minpitch (cvar_t *var, char *str, qbool *cancel)
{
	float	newval;
	char	*newstr;

	*cancel = true;

	newval = bound (-89.9f, Q_atof(str), 0.0f);
	if (newval == var->value)
		return;

	Cvar_SetValue (var, newval);
	newstr = (newval == -70.0f) ? (char *)"" : var->string;	// don't show default values in serverinfo
	SV_ServerinfoChanged("minpitch", newstr);
}

/*
============================================================

USER STRINGCMD EXECUTION

sv_client and sv_player will be valid.
============================================================
*/

/*
==================
PlayerCheckPing

Check that player's ping falls below sv_maxping value
==================
*/
qbool PlayerCheckPing(void)
{

	if (sv_client->maxping_met) return true;

	int maxping = Q_atof(sv_maxping.string);
	int playerping = sv_client->frames[sv_client->netchan.incoming_acknowledged & UPDATE_MASK].ping_time * 1000;

	if (maxping && playerping > maxping)
	{
		SV_ClientPrintf(sv_client, PRINT_HIGH, "\nYour ping is too high for this server!  Maximum ping is set to %i, your ping is %i.\nForcing spectator.\n\n", maxping, playerping);
		return false;
	}
	sv_client->maxping_met = true;
	return true;
}

/*
================
Cmd_New_f

Sends the first message from the server to a connected client.
This will be sent on the initial connection and upon each server load.
================
*/
int SV_VIPbyIP (netadr_t adr);
static void Cmd_New_f (void)
{
	char		*gamedir;
	int			playernum;
	extern cvar_t sv_serverip;
	extern cvar_t sv_getrealip;

	if (sv_client->state == cs_spawned)
		return;

	if (!SV_ClientConnectedTime(sv_client) || sv_client->state == cs_connected) {
		SV_SetClientConnectionTime(sv_client);
	}

	sv_client->spawncount = svs.spawncount;

	// request protocol extensions.
	if (sv_client->process_pext)
	{
		MSG_WriteByte (&sv_client->netchan.message, svc_stufftext);
		MSG_WriteString (&sv_client->netchan.message, "cmd pext\n");
		return;
	}

	// do not proceed if realip is unknown
    if (sv_client->state == cs_preconnected && !sv_client->realip.ip[0] && (int)sv_getrealip.value)
	{
		char *server_ip = sv_serverip.string[0] ? sv_serverip.string : NET_AdrToString(net_local_sv_ipadr);

		if (!((IsLocalIP(net_local_sv_ipadr) && IsLocalIP(sv_client->netchan.remote_address))  ||
		        (IsInetIP (net_local_sv_ipadr) && IsInetIP (sv_client->netchan.remote_address))) &&
		        sv_client->netchan.remote_address.ip[0] != 127 && !sv_serverip.string[0])
		{
			Sys_Printf ("WARNING: Incorrect server ip address: %s\n"
			            "Set hostname in your operation system or set correctly sv_serverip cvar.\n",
			            server_ip);
			*(int *)&sv_client->realip = *(int *)&sv_client->netchan.remote_address;
			sv_client->state = cs_connected;
		}
		else
		{
			if (sv_client->realip_count++ < 10)
			{
				sv_client->state = cs_preconnected;
				MSG_WriteByte (&sv_client->netchan.message, svc_stufftext);
				MSG_WriteString (&sv_client->netchan.message,
								 va("packet %s \"ip %d %d\"\ncmd new\n", server_ip,
									sv_client - svs.clients, sv_client->realip_num));
			}
			if (SV_ClientConnectedTime(sv_client) > 3 || sv_client->realip_count > 10) {
				if ((int)sv_getrealip.value == 2) {
					Netchan_OutOfBandPrint (NS_SERVER, net_from, "%c\nFailed to validate client's IP.\n\n", A2C_PRINT);
					sv_client->rip_vip = 2;
				}
				sv_client->state = cs_connected;
			}
			else {
				return;
			}
		}
	}

	// rip_vip means that client can be connected if he has VIP for he's real ip
	// drop him if he hasn't
	if (sv_client->rip_vip == 1)
	{
		if ((sv_client->vip = SV_VIPbyIP(sv_client->realip)) == 0)
		{
			Sys_Printf ("%s:full connect\n", NET_AdrToString (net_from));
			Netchan_OutOfBandPrint (NS_SERVER, net_from,
			                        "%c\nserver is full\n\n", A2C_PRINT);
		}
		else
			sv_client->rip_vip = 0;
	}

	// we can be connected now, announce it, and possibly login
	if (!sv_client->rip_vip)
	{
		if (sv_client->state == cs_preconnected)
		{
			// get highest VIP level
			if (sv_client->vip < SV_VIPbyIP(sv_client->realip))
				sv_client->vip = SV_VIPbyIP(sv_client->realip);

			if (sv_client->vip && sv_client->spectator)
				Sys_Printf ("VIP spectator %s connected\n", sv_client->name);
			else if (sv_client->spectator)
				Sys_Printf ("Spectator %s connected\n", sv_client->name);
			else
				Sys_Printf ("Client %s connected\n", sv_client->name);

			Info_SetStar (&sv_client->_userinfo_ctx_, "*VIP", sv_client->vip ? va("%d", sv_client->vip) : "");

			// now we are connected
			sv_client->state = cs_connected;
		}

		if (!SV_Login(sv_client))
			return;

		// If logins are mandatory, check
		if (SV_LoginRequired(sv_client)) {
			return;
		}

		//bliP: cuff, mute ->
		sv_client->lockedtill = SV_RestorePenaltyFilter(sv_client, ft_mute);
		sv_client->cuff_time = SV_RestorePenaltyFilter(sv_client, ft_cuff);
		//<-
	}
	// send the info about the new client to all connected clients
	//	SV_FullClientUpdate (sv_client, &sv.reliable_datagram);
	//	sv_client->sendinfo = true;

	gamedir = Info_ValueForKey (svs.info, "*gamedir");
	if (!gamedir[0])
		gamedir = "qw";

#ifdef FTE_PEXT_FLOATCOORDS
	if (msg_coordsize > 2 && !(sv_client->fteprotocolextensions & FTE_PEXT_FLOATCOORDS))
	{
		SV_ClientPrintf(sv_client, 2, "\n\n\n\n"
			"Your client lacks the necessary extensions\n"
			"  to connect to this server.\n"
			"Set /cl_pext_floatcoords 1, or upgrade.\n"
			"Please upgrade to one of the following:\n"
			"> ezQuake 2.2 (https://ezquake.github.io)\n"
			"> fodquake 0.4 (http://fodquake.net)\n"
			"> FTEQW (http://fte.triptohell.info/)\n");
		if (!sv_client->spectator) {
			SV_DropClient (sv_client);
			return;
		}
		if (!SV_SkipCommsBotMessage(sv_client)) {
			return;
		}
	}
#endif

#ifdef FTE_PEXT_ENTITYDBL
	if (sv.max_edicts > 512 && !(sv_client->fteprotocolextensions & FTE_PEXT_ENTITYDBL)) {
		SV_ClientPrintf(sv_client, 2, "\n\nWARNING:\n"
			"Your client lacks support for extended\n"
			"  entity limits, some enemies/projectiles\n"
			"  may be invisible to you.\n"
			"Please upgrade to one of the following:\n"
			"> ezQuake 2.2 (https://ezquake.github.io)\n"
			"> fodquake 0.4 (http://fodquake.net)\n"
			"> FTEQW (http://fte.triptohell.info/)\n");
	}
#endif

#if defined(FTE_PEXT_TRANS)
	if (sv_client->fteprotocolextensions & FTE_PEXT_TRANS)
	{
		const char *client_string = Info_Get(&sv_client->_userinfo_ctx_, "*client");
		char *ptr = strchr(client_string, ' ');
		if (ptr != NULL) {
			ptr++;
			if (strncmp(client_string, "ezQuake", 7) == 0 && *ptr != '\0')
			{
				extern cvar_t sv_pext_ezquake_verfortrans;
				char *endptr;
				long revision = strtol(ptr, &endptr, 10);
				if (*endptr != '\0' || (revision > 0 && revision < sv_pext_ezquake_verfortrans.value))
				{
					SV_ClientPrintf(sv_client, PRINT_HIGH, "\n\nWARNING:\n"
						"Alpha support disabled due to buggy client, "
						"if the map contains transparency you may be at a disadvantage.\n"
						"Please upgrade to one of the following:\n"
						"> ezQuake (https://www.ezquake.com)\n"
						"> FTEQW (http://fte.triptohell.info/)\n");
					sv_client->fteprotocolextensions &= ~FTE_PEXT_TRANS;
				}
			}
		}
	}
#endif

	//NOTE:  This doesn't go through ClientReliableWrite since it's before the user
	//spawns.  These functions are written to not overflow
	if (sv_client->num_backbuf)
	{
		Con_Printf("WARNING %s: [SV_New] Back buffered (%d0), clearing\n",
		           sv_client->name, sv_client->netchan.message.cursize);
		sv_client->num_backbuf = 0;
		SZ_Clear(&sv_client->netchan.message);
	}

	// send the serverdata
	MSG_WriteByte  (&sv_client->netchan.message, svc_serverdata);
#ifdef PROTOCOL_VERSION_FTE
	if (sv_client->fteprotocolextensions) // let the client know
	{
		unsigned int ext = sv_client->fteprotocolextensions;

#ifdef FTE_PEXT_FLOATCOORDS
		if (msg_coordsize == 2) //we're not using float orgs on this level.
			ext &= ~FTE_PEXT_FLOATCOORDS;
#endif

		MSG_WriteLong (&sv_client->netchan.message, PROTOCOL_VERSION_FTE);
		MSG_WriteLong (&sv_client->netchan.message, ext);
	}
#endif
#ifdef PROTOCOL_VERSION_FTE2
	if (sv_client->fteprotocolextensions2) // let the client know
	{
		MSG_WriteLong (&sv_client->netchan.message, PROTOCOL_VERSION_FTE2);
		MSG_WriteLong (&sv_client->netchan.message, sv_client->fteprotocolextensions2);
	}
#endif // PROTOCOL_VERSION_FTE2
#ifdef PROTOCOL_VERSION_MVD1
	if (sv_client->mvdprotocolextensions1) {
		MSG_WriteLong (&sv_client->netchan.message, PROTOCOL_VERSION_MVD1);
		MSG_WriteLong (&sv_client->netchan.message, sv_client->mvdprotocolextensions1);
	}
#endif
	MSG_WriteLong  (&sv_client->netchan.message, PROTOCOL_VERSION);
	MSG_WriteLong  (&sv_client->netchan.message, svs.spawncount);
	MSG_WriteString(&sv_client->netchan.message, gamedir);

	playernum = NUM_FOR_EDICT(sv_client->edict)-1;
	if (sv_client->spectator)
		playernum |= 128;
	MSG_WriteByte (&sv_client->netchan.message, playernum);

	// send full levelname
	if (sv_client->rip_vip)
		MSG_WriteString (&sv_client->netchan.message, "");
	else
		MSG_WriteString (&sv_client->netchan.message, PR_GetEntityString(sv.edicts->v->message));

	// send the movevars
	MSG_WriteFloat(&sv_client->netchan.message, movevars.gravity);
	MSG_WriteFloat(&sv_client->netchan.message, movevars.stopspeed);
	MSG_WriteFloat(&sv_client->netchan.message, /* sv_client->maxspeed */ movevars.maxspeed); // FIXME: this does't work, Tonik?
	MSG_WriteFloat(&sv_client->netchan.message, movevars.spectatormaxspeed);
	MSG_WriteFloat(&sv_client->netchan.message, movevars.accelerate);
	MSG_WriteFloat(&sv_client->netchan.message, movevars.airaccelerate);
	MSG_WriteFloat(&sv_client->netchan.message, movevars.wateraccelerate);
	MSG_WriteFloat(&sv_client->netchan.message, movevars.friction);
	MSG_WriteFloat(&sv_client->netchan.message, movevars.waterfriction);
	MSG_WriteFloat(&sv_client->netchan.message, /* sv_client->entgravity */ movevars.entgravity); // FIXME: this does't work, Tonik?

	if (!sv_client->spectator) {
		if (!PlayerCheckPing()) {
			sv_client->old_frags = 0;
			SV_SetClientConnectionTime(sv_client);
			sv_client->spectator = true;
			sv_client->spec_track = 0;
			Info_SetStar(&sv_client->_userinfo_ctx_, "*spectator", "1");
			Info_SetStar(&sv_client->_userinfoshort_ctx_, "*spectator", "1");
		}
	}

	if (sv_client->rip_vip)
	{
		SV_LogPlayer(sv_client, va("dropped %d", sv_client->rip_vip), 1);
		SV_DropClient (sv_client);
		return;
	}

	// send music
	MSG_WriteByte (&sv_client->netchan.message, svc_cdtrack);
	MSG_WriteByte (&sv_client->netchan.message, sv.edicts->v->sounds);

	// send server info string
	MSG_WriteByte (&sv_client->netchan.message, svc_stufftext);
	MSG_WriteString (&sv_client->netchan.message, va("fullserverinfo \"%s\"\n", svs.info) );

	//bliP: player logging
	SV_LogPlayer(sv_client, "connect", 1);
}

/*
==================
Cmd_Soundlist_f
==================
*/
static void Cmd_Soundlist_f (void)
{
	char		**s;
	unsigned	n;

	if (sv_client->state != cs_connected)
	{
		Con_Printf ("soundlist not valid -- already spawned\n");
		return;
	}

	// handle the case of a level changing while a client was connecting
	if (Q_atoi(Cmd_Argv(1)) != svs.spawncount)
	{
		SV_ClearReliable (sv_client);
		Con_Printf ("SV_Soundlist_f from different level\n");
		Cmd_New_f ();
		return;
	}

	n = Q_atoi(Cmd_Argv(2));
	if (n >= MAX_SOUNDS)
	{
		SV_ClearReliable (sv_client);
		SV_ClientPrintf (sv_client, PRINT_HIGH,
		                 "SV_Soundlist_f: Invalid soundlist index\n");
		SV_DropClient (sv_client);
		return;
	}

	//NOTE:  This doesn't go through ClientReliableWrite since it's before the user
	//spawns.  These functions are written to not overflow
	if (sv_client->num_backbuf)
	{
		Con_Printf("WARNING %s: [SV_Soundlist] Back buffered (%d0), clearing\n", sv_client->name, sv_client->netchan.message.cursize);
		sv_client->num_backbuf = 0;
		SZ_Clear(&sv_client->netchan.message);
	}

	MSG_WriteByte (&sv_client->netchan.message, svc_soundlist);
	MSG_WriteByte (&sv_client->netchan.message, n);
	for (s = sv.sound_precache+1 + n ;
	        *s && sv_client->netchan.message.cursize < (MAX_MSGLEN/2);
	        s++, n++)
		MSG_WriteString (&sv_client->netchan.message, *s);

	MSG_WriteByte (&sv_client->netchan.message, 0);

	// next msg
	if (*s)
		MSG_WriteByte (&sv_client->netchan.message, n);
	else
		MSG_WriteByte (&sv_client->netchan.message, 0);
}

static char *TrimModelName (const char *full)
{
	static char shortn[MAX_QPATH];
	int len;

	if (!strncmp(full, "progs/", 6) && !strchr(full + 6, '/'))
		strlcpy (shortn, full + 6, sizeof(shortn));		// strip progs/
	else
		strlcpy (shortn, full, sizeof(shortn));

	len = strlen(shortn);
	if (len > 4 && !strcmp(shortn + len - 4, ".mdl")
		&& strchr(shortn, '.') == shortn + len - 4)
	{	// strip .mdl
		shortn[len - 4] = '\0';
	}

	return shortn;
}

/*
==================
Cmd_Modellist_f
==================
*/
static void Cmd_Modellist_f (void)
{
	char		**s;
	unsigned	n;
	int         i;
	unsigned    maxclientsupportedmodels;

	if (sv_client->state != cs_connected) {
		Con_Printf ("modellist not valid -- already spawned\n");
		return;
	}

	// handle the case of a level changing while a client was connecting
	if (Q_atoi(Cmd_Argv(1)) != svs.spawncount) {
		SV_ClearReliable (sv_client);
		Con_Printf ("SV_Modellist_f from different level\n");
		Cmd_New_f ();
		return;
	}

	n = Q_atoi(Cmd_Argv(2));
	if (n >= MAX_MODELS) {
		SV_ClearReliable (sv_client);
		SV_ClientPrintf (sv_client, PRINT_HIGH, "SV_Modellist_f: Invalid modellist index\n");
		SV_DropClient (sv_client);
		return;
	}

	if (n == 0 && (sv_client->extensions & Z_EXT_VWEP) && sv.vw_model_name[0]) {
		int i;
		char ss[1024] = "//vwep ";
		// send VWep precaches
		for (i = 0, s = sv.vw_model_name; i < MAX_VWEP_MODELS; s++, i++) {
			if (!*s || !**s) {
				break;
			}
			if (i > 0) {
				strlcat(ss, " ", sizeof(ss));
			}
			strlcat(ss, TrimModelName(*s), sizeof(ss));
		}
		strlcat(ss, "\n", sizeof(ss));
		if (ss[strlen(ss) - 1] == '\n') {       // didn't overflow?
			ClientReliableWrite_Begin (sv_client, svc_stufftext, 2 + strlen(ss));
			ClientReliableWrite_String (sv_client, ss);
		}
	}

	//NOTE:  This doesn't go through ClientReliableWrite since it's before the user
	//spawns.  These functions are written to not overflow
	if (sv_client->num_backbuf) {
		Con_Printf("WARNING %s: [SV_Modellist] Back buffered (%d0), clearing\n", sv_client->name, sv_client->netchan.message.cursize);
		sv_client->num_backbuf = 1;

		SZ_Clear(&sv_client->netchan.message);
	}

#ifdef FTE_PEXT_MODELDBL
	if (n > 255) {
		MSG_WriteByte(&sv_client->netchan.message, svc_fte_modellistshort);
		MSG_WriteShort(&sv_client->netchan.message, n);
	}
	else
#endif
	{
		MSG_WriteByte(&sv_client->netchan.message, svc_modellist);
		MSG_WriteByte(&sv_client->netchan.message, n);
	}

	maxclientsupportedmodels = 256;
#ifdef FTE_PEXT_MODELDBL
	if (sv_client->fteprotocolextensions & FTE_PEXT_MODELDBL) {
		maxclientsupportedmodels = MAX_MODELS;
	}
#endif

	s = sv.model_precache + 1 + n;
	for (i = 1 + n; i < maxclientsupportedmodels && *s && (((i-1)&255) == 0 || sv_client->netchan.message.cursize < (MAX_MSGLEN/2)); i++, s++) {
		MSG_WriteString (&sv_client->netchan.message, *s);
	}
	n = i - 1;

	if (!s[0] || n == maxclientsupportedmodels - 1) {
		n = 0;
	}

	// next msg (nul terminator then next request indicator)
	MSG_WriteByte (&sv_client->netchan.message, 0);
	MSG_WriteByte (&sv_client->netchan.message, n);
}

/*
==================
Cmd_PreSpawn_f
==================
*/
static void Cmd_PreSpawn_f (void)
{
	unsigned int buf;
	unsigned int check;
	int i, j;

	if (sv_client->state != cs_connected)
	{
		Con_Printf ("prespawn not valid -- already spawned\n");
		return;
	}

	// handle the case of a level changing while a client was connecting
	if (Q_atoi(Cmd_Argv(1)) != svs.spawncount)
	{
		SV_ClearReliable (sv_client);
		Con_Printf ("SV_PreSpawn_f from different level\n");
		Cmd_New_f ();
		return;
	}

	buf = Q_atoi(Cmd_Argv(2));
	if (buf >= sv.num_signon_buffers + sv.static_entity_count + sv.num_baseline_edicts)
		buf = 0;

	if (!buf)
	{
		// should be three numbers following containing checksums
		check = Q_atoi(Cmd_Argv(3));

		//		Con_DPrintf("Client check = %d\n", check);

		if ((int)sv_mapcheck.value && check != sv.map_checksum &&
			check != sv.map_checksum2)
		{
			SV_ClientPrintf (sv_client, PRINT_HIGH,
			                 "Map model file does not match (%s), %i != %i/%i.\n"
			                 "You may need a new version of the map, or the proper install files.\n",
					 sv.modelname, check, sv.map_checksum, sv.map_checksum2);
			SV_DropClient (sv_client);
			return;
		}
		sv_client->checksum = check;
	}

	if (SV_SkipCommsBotMessage(sv_client)) {
		// skip pre-spawning
		MSG_WriteByte (&sv_client->netchan.message, svc_stufftext);
		MSG_WriteString (&sv_client->netchan.message, va("cmd spawn %i 0\n", svs.spawncount) );
		return;
	}

	//NOTE:  This doesn't go through ClientReliableWrite since it's before the user
	//spawns.  These functions are written to not overflow
	if (sv_client->num_backbuf)
	{
		Con_Printf("WARNING %s: [SV_PreSpawn] Back buffered (%d0), clearing\n", sv_client->name, sv_client->netchan.message.cursize);
		sv_client->num_backbuf = 0;
		SZ_Clear(&sv_client->netchan.message);
	}

	if (buf < sv.static_entity_count) {
		entity_state_t from = { 0 };

		while (buf < sv.static_entity_count) {
			entity_state_t* s = &sv.static_entities[buf];

			if (sv_client->netchan.message.cursize >= (sv_client->netchan.message.maxsize / 2)) {
				break;
			}

			if (sv_client->fteprotocolextensions & FTE_PEXT_SPAWNSTATIC2) {
				MSG_WriteByte(&sv_client->netchan.message, svc_fte_spawnstatic2);
				SV_WriteDelta(sv_client, &from, s, &sv_client->netchan.message, true);
			}
			else if (s->modelindex < 256) {
				MSG_WriteByte(&sv_client->netchan.message, svc_spawnstatic);
				MSG_WriteByte(&sv_client->netchan.message, s->modelindex);
				MSG_WriteByte(&sv_client->netchan.message, s->frame);
				MSG_WriteByte(&sv_client->netchan.message, s->colormap);
				MSG_WriteByte(&sv_client->netchan.message, s->skinnum);
				for (i = 0; i < 3; ++i) {
					MSG_WriteCoord(&sv_client->netchan.message, s->origin[i]);
					MSG_WriteAngle(&sv_client->netchan.message, s->angles[i]);
				}
			}

			++buf;
		}
	}
	else if (buf < sv.static_entity_count + sv.num_baseline_edicts) {
		static entity_state_t empty_baseline = { 0 };

		for (i = buf - sv.static_entity_count; i < sv.num_baseline_edicts; ++i) {
			edict_t* svent = EDICT_NUM(i);
			entity_state_t* s = &svent->e.baseline;

			if (sv_client->netchan.message.cursize >= (sv_client->netchan.message.maxsize / 2)) {
				break;
			}

			if (!s->number || !s->modelindex || !memcmp(s, &empty_baseline, sizeof(empty_baseline))) {
				++buf;
				continue;
			}

			if (sv_client->fteprotocolextensions & FTE_PEXT_SPAWNSTATIC2) {
				MSG_WriteByte(&sv_client->netchan.message, svc_fte_spawnbaseline2);
				SV_WriteDelta(sv_client, &empty_baseline, s, &sv_client->netchan.message, true);
			}
			else if (s->modelindex < 256) {
				MSG_WriteByte(&sv_client->netchan.message, svc_spawnbaseline);
				MSG_WriteShort(&sv_client->netchan.message, i);
				MSG_WriteByte(&sv_client->netchan.message, svent->e.baseline.modelindex);
				MSG_WriteByte(&sv_client->netchan.message, svent->e.baseline.frame);
				MSG_WriteByte(&sv_client->netchan.message, svent->e.baseline.colormap);
				MSG_WriteByte(&sv_client->netchan.message, svent->e.baseline.skinnum);
				for (j = 0; j < 3; j++) {
					MSG_WriteCoord(&sv_client->netchan.message, svent->e.baseline.origin[j]);
					MSG_WriteAngle(&sv_client->netchan.message, svent->e.baseline.angles[j]);
				}
			}
			++buf;
		}
	}
	else {
		SZ_Write(
			&sv_client->netchan.message,
			sv.signon_buffers[buf - sv.static_entity_count - sv.num_baseline_edicts],
			sv.signon_buffer_size[buf - sv.static_entity_count - sv.num_baseline_edicts]
		);
		++buf;
	}

	if (buf == sv.num_signon_buffers + sv.static_entity_count + sv.num_baseline_edicts) {
		// all done prespawning
		MSG_WriteByte (&sv_client->netchan.message, svc_stufftext);
		MSG_WriteString (&sv_client->netchan.message, va("cmd spawn %i 0\n", svs.spawncount) );
	}
	else {
		// need to prespawn more
		MSG_WriteByte (&sv_client->netchan.message, svc_stufftext);
		MSG_WriteString (&sv_client->netchan.message,
		                 va("cmd prespawn %i %i\n", svs.spawncount, buf) );
	}
}

/*
==================
Cmd_Spawn_f
==================
*/
static void Cmd_Spawn_f (void)
{
	int         i;
	client_t    *client;
	unsigned    n;

	if (sv_client->state != cs_connected)
	{
		Con_Printf ("Spawn not valid -- already spawned\n");
		return;
	}

	// handle the case of a level changing while a client was connecting
	if (Q_atoi(Cmd_Argv(1)) != svs.spawncount)
	{
		SV_ClearReliable (sv_client);
		Con_Printf ("SV_Spawn_f from different level\n");
		Cmd_New_f ();
		return;
	}

	n = Q_atoi(Cmd_Argv(2));
	if (n >= MAX_CLIENTS)
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH,
		                 "SV_Spawn_f: Invalid client start\n");
		SV_DropClient (sv_client);
		return;
	}

	// send all current names, colors, and frag counts
	// FIXME: is this a good thing?
	SZ_Clear (&sv_client->netchan.message);

	// send current status of all other players

	// normally this could overflow, but no need to check due to backbuf
	for (i=n, client = svs.clients + n ; i<MAX_CLIENTS && sv_client->netchan.message.cursize < (MAX_MSGLEN/2); i++, client++)
		SV_FullClientUpdateToClient (client, sv_client);

	if (i < MAX_CLIENTS)
	{
		MSG_WriteByte (&sv_client->netchan.message, svc_stufftext);
		MSG_WriteString (&sv_client->netchan.message,
		                 va("cmd spawn %i %d\n", svs.spawncount, i) );
		return;
	}

	// send all current light styles
	for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
	{
		ClientReliableWrite_Begin (sv_client, svc_lightstyle,
		                           3 + (sv.lightstyles[i] ? strlen(sv.lightstyles[i]) : 1));
		ClientReliableWrite_Byte (sv_client, (char)i);
		ClientReliableWrite_String (sv_client, sv.lightstyles[i]);
	}

	if (sv.loadgame)
	{
		// loaded games are already fully initialized 
		// if this is the last client to be connected, unpause

		// gravity and maxspeed are optional, set it if save file omited it.
		edict_t	*ent = sv_client->edict;
		sv_client->entgravity = fofs_gravity ? EdictFieldFloat(ent, fofs_gravity) : 1.0;
		sv_client->maxspeed = fofs_maxspeed? EdictFieldFloat(ent, fofs_maxspeed) : (int)sv_maxspeed.value;

		if (sv.paused & 1)
			SV_TogglePause (NULL, 1);
	}
	else
	{
		SetUpClientEdict(sv_client, sv_client->edict);
	}

	//
	// force stats to be updated
	//
	memset (sv_client->stats, 0, sizeof(sv_client->stats));

	ClientReliableWrite_Begin (sv_client, svc_updatestatlong, 6);
	ClientReliableWrite_Byte (sv_client, STAT_TOTALSECRETS);
	ClientReliableWrite_Long (sv_client, PR_GLOBAL(total_secrets));

	ClientReliableWrite_Begin (sv_client, svc_updatestatlong, 6);
	ClientReliableWrite_Byte (sv_client, STAT_TOTALMONSTERS);
	ClientReliableWrite_Long (sv_client, PR_GLOBAL(total_monsters));

	ClientReliableWrite_Begin (sv_client, svc_updatestatlong, 6);
	ClientReliableWrite_Byte (sv_client, STAT_SECRETS);
	ClientReliableWrite_Long (sv_client, PR_GLOBAL(found_secrets));

	ClientReliableWrite_Begin (sv_client, svc_updatestatlong, 6);
	ClientReliableWrite_Byte (sv_client, STAT_MONSTERS);
	ClientReliableWrite_Long (sv_client, PR_GLOBAL(killed_monsters));

	// get the client to check and download skins
	// when that is completed, a begin command will be issued
	ClientReliableWrite_Begin (sv_client, svc_stufftext, 8);
	ClientReliableWrite_String (sv_client, "skins\n" );
}

/*
==================
SV_SpawnSpectator
==================
*/
static void SV_SpawnSpectator (void)
{
	int i;
	edict_t *e;

	VectorClear (sv_player->v->origin);
	VectorClear (sv_player->v->view_ofs);
	sv_player->v->view_ofs[2] = 22;
	sv_player->v->fixangle = true;
	sv_player->v->movetype = MOVETYPE_NOCLIP; // progs can change this to MOVETYPE_FLY, for example

	// search for an info_playerstart to spawn the spectator at
	for (i=MAX_CLIENTS-1 ; i<sv.num_edicts ; i++)
	{
		e = EDICT_NUM(i);
		if (!strcmp(PR_GetEntityString(e->v->classname), "info_player_start"))
		{
			VectorCopy (e->v->origin, sv_player->v->origin);
			VectorCopy (e->v->angles, sv_player->v->angles);
			return;
		}
	}
}

/*
==================
Cmd_Begin_f
==================
*/
static void Cmd_Begin_f (void)
{
	unsigned pmodel = 0, emodel = 0;
	int i;

	if (sv_client->state == cs_spawned)
		return; // don't begin again

	// handle the case of a level changing while a client was connecting
	if (Q_atoi(Cmd_Argv(1)) != svs.spawncount)
	{
		SV_ClearReliable (sv_client);
		Con_Printf ("SV_Begin_f from different level\n");
		Cmd_New_f ();
		return;
	}

	sv_client->state = cs_spawned;

	if (!sv.loadgame)
	{
		if (sv_client->spectator)
			SV_SpawnSpectator ();

		// copy spawn parms out of the client_t
		for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
			(&PR_GLOBAL(parm1))[i] = sv_client->spawn_parms[i];

		// call the spawn function
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(sv_player);
		G_FLOAT(OFS_PARM0) = (float) sv_client->vip;
		PR_GameClientConnect(sv_client->spectator);

		// actually spawn the player
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(sv_player);
		PR_GamePutClientInServer(sv_client->spectator);
	}

	// clear the net statistics, because connecting gives a bogus picture
	sv_client->netchan.frame_latency = 0;
	sv_client->netchan.frame_rate = 0;
	sv_client->netchan.drop_count = 0;
	sv_client->netchan.good_count = 0;

	//check he's not cheating
	if (!sv_client->spectator)
	{
		if (!*Info_Get (&sv_client->_userinfo_ctx_, "pmodel") ||
		        !*Info_Get (&sv_client->_userinfo_ctx_, "emodel")) //bliP: typo? 2nd pmodel to emodel
			SV_BroadcastPrintf (PRINT_HIGH, "%s WARNING: missing player/eyes model checksum\n", sv_client->name);
		else
		{
			pmodel = Q_atoi(Info_Get (&sv_client->_userinfo_ctx_, "pmodel"));
			emodel = Q_atoi(Info_Get (&sv_client->_userinfo_ctx_, "emodel"));

			if (!(pmodel == sv.model_newplayer_checksum || pmodel == sv.model_player_checksum) || emodel != sv.eyes_player_checksum)
				SV_BroadcastPrintf (PRINT_HIGH, "%s WARNING: non standard player/eyes model detected\n", sv_client->name);
		}
	}

	// if we are paused, tell the client
	if (sv.paused)
	{
		ClientReliableWrite_Begin (sv_client, svc_setpause, 2);
		ClientReliableWrite_Byte (sv_client, sv.paused);
		SV_ClientPrintf(sv_client, PRINT_HIGH, "Server is paused.\n");
	}

	if (sv.loadgame)
	{
		// send a fixangle over the reliable channel to make sure it gets there
		// Never send a roll angle, because savegames can catch the server
		// in a state where it is expecting the client to correct the angle
		// and it won't happen if the game was just loaded, so you wind up
		// with a permanent head tilt
		edict_t *ent;

		ent = EDICT_NUM( 1 + (sv_client - svs.clients) );
		MSG_WriteByte (&sv_client->netchan.message, svc_setangle);
		for (i = 0; i < 2; i++)
			MSG_WriteAngle (&sv_client->netchan.message, ent->v->v_angle[i]);
		MSG_WriteAngle (&sv_client->netchan.message, 0);
	}

	sv_client->lastservertimeupdate = -99; // update immediately
}

//=============================================================================

/*
==================
SV_DownloadNextFile
==================
*/
static qbool SV_DownloadNextFile (void)
{
	int		num;
	char		*name, n[MAX_OSPATH];
	unsigned char	all_demos_downloaded[]	= "All demos downloaded.\n";
	unsigned char	incorrect_demo_number[]	= "Incorrect demo number.\n";

	switch (sv_client->demonum[0])
	{
	case 1:
		if (sv_client->demolist)
		{
			Con_Printf((char *)Q_redtext(all_demos_downloaded));
			sv_client->demolist = false;
		}
		sv_client->demonum[0] = 0;
	case 0:
		return false;
	default:;
	}

	num = sv_client->demonum[--(sv_client->demonum[0])];
	if (num == 0)
	{
		Con_Printf((char *)Q_redtext(incorrect_demo_number));
		return SV_DownloadNextFile();
	}
	if (!(name = SV_MVDNum(num)))
	{
		Con_Printf((char *)Q_yelltext((unsigned char*)va("Demo number %d not found.\n",
			(num & 0xFF000000) ? -(num >> 24) : 
				((num & 0x00800000) ? (num | 0xFF000000) : num) )));
		return SV_DownloadNextFile();
	}
	//Con_Printf("downloading demos/%s\n",name);
	snprintf(n, sizeof(n), "download demos/%s\n", name);

	ClientReliableWrite_Begin (sv_client, svc_stufftext, strlen(n) + 2);
	ClientReliableWrite_String (sv_client, n);

	return true;
}

/*
==================
SV_CompleteDownoload
==================

This is a sub routine for  SV_NextDownload(), called when download complete, we set up some fields for sv_client.

*/

void SV_CompleteDownoload(void)
{
	unsigned char download_completed[] = "Download completed.\n";

	if (!sv_client->download)
		return;

	SV_ClientDownloadComplete(sv_client);

	Con_Printf((char *)Q_redtext(download_completed));

	if (SV_DownloadNextFile())
		return;

	// if map changed tell the client to reconnect
	if (sv_client->spawncount != svs.spawncount)
	{
		char *str = "changing\n"
		            "reconnect\n";

		ClientReliableWrite_Begin (sv_client, svc_stufftext, strlen(str)+2);
		ClientReliableWrite_String (sv_client, str);
	}
}

/*
==================
Cmd_NextDownload_f
==================
*/

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS

// qqshka: percent is optional, u can't relay on it

void SV_NextChunkedDownload(int chunknum, int percent, int chunked_download_number)
{
#define CHUNKSIZE 1024
	char buffer[CHUNKSIZE];
	int i;
	int maxchunks = bound(1, (int)sv_downloadchunksperframe.value, 30);

	sv_client->file_percent = bound(0, percent, 100); //bliP: file percent

	if (chunknum < 0)
	{  // qqshka: FTE's chunked download does't have any way of signaling what client complete dl-ing, so doing it this way.
		SV_CompleteDownoload();
		return;
	}

	// Check if too much requests or client sent something wrong
	if (sv_client->download_chunks_perframe >= maxchunks || chunked_download_number < 1)
		return;

	if (!sv_client->download_chunks_perframe) // ignore "rate" if not first packet per frame
		if (sv_client->datagram.cursize + CHUNKSIZE+5+50 > sv_client->datagram.maxsize)
			return;	//choked!

	if (VFS_SEEK(sv_client->download, chunknum*CHUNKSIZE, SEEK_SET))
		return; // FIXME: ERROR of some kind

	i = VFS_READ(sv_client->download, buffer, CHUNKSIZE, NULL);

	if (i > 0)
	{
		byte data[1+ (sizeof("\\chunk")-1) + 4 + 1 + 4 + CHUNKSIZE]; // byte + (sizeof("\\chunk")-1) + long + byte + long + CHUNKSIZE
		sizebuf_t *msg, msg_oob;

		if (sv_client->download_chunks_perframe)
		{
			msg = &msg_oob;

			SZ_Init (&msg_oob, data, sizeof(data));

			MSG_WriteByte(msg, A2C_PRINT);
			SZ_Write(msg, "\\chunk", sizeof("\\chunk")-1);
			MSG_WriteLong(msg, chunked_download_number); // return back, so they sure what it proper chunk
		}
		else
			msg = &sv_client->datagram;

		if (i != CHUNKSIZE)
			memset(buffer+i, 0, CHUNKSIZE-i);

		MSG_WriteByte(msg, svc_download);
		MSG_WriteLong(msg, chunknum);
		SZ_Write(msg, buffer, CHUNKSIZE);

		if (sv_client->download_chunks_perframe)
			Netchan_OutOfBand (NS_SERVER, sv_client->netchan.remote_address, msg->cursize, msg->data);
	}
	else {
		; // FIXME: EOF/READ ERROR
	}

	sv_client->download_chunks_perframe++;
}

#endif

static void Cmd_NextDownload_f (void)
{
	byte    buffer[FILE_TRANSFER_BUF_SIZE];
	int     r, tmp;
	int     percent;
	int     size;
	double  frametime;

	if (!sv_client->download)
		return;

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	if (sv_client->fteprotocolextensions & FTE_PEXT_CHUNKEDDOWNLOADS)
	{
		SV_NextChunkedDownload(atoi(Cmd_Argv(1)), atoi(Cmd_Argv(2)), atoi(Cmd_Argv(3)));
		return;
	}
#endif

	tmp = sv_client->downloadsize - sv_client->downloadcount;

	frametime = max(0.05, min(0, sv_client->netchan.frame_rate));
	//Sys_Printf("rate:%f\n", sv_client->netchan.frame_rate);

	r = (int)((curtime + frametime - sv_client->netchan.cleartime)/sv_client->netchan.rate);
	if (r <= 10)
		r = 10;
	if (r > FILE_TRANSFER_BUF_SIZE)
		r = FILE_TRANSFER_BUF_SIZE;

	// don't send too much if already buffering
	if (sv_client->num_backbuf)
		r = 10;

	if (r > tmp)
		r = tmp;

	Con_DPrintf("Downloading: %d", r);
	r = VFS_READ(sv_client->download, buffer, r, NULL);
	Con_DPrintf(" => %d, total: %d => %d", r, sv_client->downloadsize, sv_client->downloadcount);
	ClientReliableWrite_Begin (sv_client, svc_download, 6 + r);
	ClientReliableWrite_Short (sv_client, r);
	sv_client->downloadcount += r;
	if (!(size = sv_client->downloadsize))
		size = 1;
	percent = (sv_client->downloadcount * (double)100.) / size;
	if (percent == 100 && sv_client->downloadcount != sv_client->downloadsize)
		percent = 99;
	else if (percent != 100 && sv_client->downloadcount == sv_client->downloadsize)
		percent = 100;
	Con_DPrintf("; %d\n", percent);
	ClientReliableWrite_Byte (sv_client, percent);
	ClientReliableWrite_SZ (sv_client, buffer, r);
	sv_client->file_percent = percent; //bliP: file percent

	if (sv_client->downloadcount == sv_client->downloadsize)
		SV_CompleteDownoload();
}

static void OutofBandPrintf(netadr_t where, char *fmt, ...)
{
	va_list	 argptr;
	char send1[1024];

	send1[0] = 0xff;
	send1[1] = 0xff;
	send1[2] = 0xff;
	send1[3] = 0xff;
	send1[4] = A2C_PRINT;
	va_start (argptr, fmt);
	vsnprintf (send1 + 5, sizeof(send1) - 5, fmt, argptr);
	va_end (argptr);

	NET_SendPacket (NS_SERVER, strlen(send1) + 1, send1, where);
}

/*
==================
SV_NextUpload
==================
*/
void SV_ReplaceChar(char *s, char from, char to);
void SV_CancelUpload(void)
{
	SV_ClientPrintf(sv_client, PRINT_HIGH, "Upload denied\n");
	ClientReliableWrite_Begin (sv_client, svc_stufftext, 8);
	ClientReliableWrite_String (sv_client, "stopul");
	if (sv_client->upload)
	{
		fclose (sv_client->upload);
		sv_client->upload = NULL;
		sv_client->file_percent = 0; //bliP: file percent
	}
}
static void SV_NextUpload (void)
{
	int	percent;
	int	size;
	char	*name = sv_client->uploadfn;
	//	Sys_Printf("-- %s\n", name);

	SV_ReplaceChar(name, '\\', '/');
	if (!*name || !strncmp(name, "../", 3) || strstr(name, "/../") || *name == '/'
#ifdef _WIN32
	        || (isalpha(*name) && name[1] == ':')
#endif //_WIN32
	   )
	{ //bliP: can't upload back a directory
		SV_CancelUpload();
		// suck out rest of packet
		size = MSG_ReadShort ();
		MSG_ReadByte ();
		if (size > 0)
			msg_readcount += size;
		return;
	}

	size = MSG_ReadShort ();
	sv_client->file_percent = percent = MSG_ReadByte ();

	if (size <= 0 || size >= MAX_DATAGRAM || percent < 0 || percent > 100)
	{
		SV_CancelUpload();
		return;
	}

	if (sv_client->upload)
	{
		int pos = ftell(sv_client->upload);
		if (pos == -1 || (sv_client->remote_snap && (pos + size) > (int)sv_maxuploadsize.value))
		{
			msg_readcount += size;
			SV_CancelUpload();
			return;
		}
	}
	else
	{
		sv_client->upload = fopen(name, "wb");
		if (!sv_client->upload)
		{
			Sys_Printf("Can't create %s\n", name);
			ClientReliableWrite_Begin (sv_client, svc_stufftext, 8);
			ClientReliableWrite_String (sv_client, "stopul");
			*name = 0;
			return;
		}
		Sys_Printf("Receiving %s from %d...\n", name, sv_client->userid);
		if (sv_client->remote_snap)
			OutofBandPrintf(sv_client->snap_from, "Server receiving %s from %d...\n",
			                name, sv_client->userid);

		// force cache rebuild.
		FS_FlushFSHash();
	}

	Sys_Printf("-");
	fwrite (net_message.data + msg_readcount, 1, size, sv_client->upload);
	msg_readcount += size;

	Con_DPrintf ("UPLOAD: %d received\n", size);

	if (percent != 100)
	{
		ClientReliableWrite_Begin (sv_client, svc_stufftext, 8);
		ClientReliableWrite_String (sv_client, "nextul\n");
	}
	else
	{
		fclose (sv_client->upload);
		sv_client->upload = NULL;
		sv_client->file_percent = 0; //bliP: file percent

		Sys_Printf("\n%s upload completed.\n", name);

		if (sv_client->remote_snap)
		{
			char *p;

			if ((p = strchr(name, '/')) != NULL)
				p++;
			else
				p = name;
			OutofBandPrintf(sv_client->snap_from,
			                "%s upload completed.\nTo download, enter:\ndownload %s\n",
			                name, p);
		}
	}
}

static void SV_UserCleanFilename(char* name)
{
	char* p;

	// lowercase name (needed for casesen file systems)
	for (p = name; *p; p++) {
		*p = (char)tolower(*p);
	}
}

/*
==================
Cmd_Download_f
==================
*/
//void SV_ReplaceChar(char *s, char from, char to);
static void Cmd_Download_f(void)
{
	char	*name, n[MAX_OSPATH], *val;
	char alternative_path[MAX_OSPATH];
	extern	cvar_t	allow_download;
	extern	cvar_t	allow_download_skins;
	extern	cvar_t	allow_download_models;
	extern	cvar_t	allow_download_sounds;
	extern	cvar_t	allow_download_maps;
	extern  cvar_t	allow_download_pakmaps;
	extern	cvar_t	allow_download_demos;
	extern	cvar_t	allow_download_other;
	extern  cvar_t  download_map_url; //bliP: download url
	extern	cvar_t	sv_demoDir;
	int i;
	qbool allow_dl = false;

	if (Cmd_Argc() != 2)
	{
		Con_Printf("download [filename]\n");
		return;
	}

	name = Cmd_Argv(1);

	SV_ReplaceChar(name, '\\', '/');

	// couple of checks to not allow dl-ing anything except in quake dir
	if (
		//TODO: split name to pathname and filename and check for 'bad symbols' only in pathname
		*name == '/' // no absolute
		|| !strncmp(name, "../", 3) // no leading ../
		|| strstr(name, "/../") // no /../
		|| ((i = strlen(name)) < 3 ? 0 : !strncmp(name + i - 3, "/..", 4)) // no /.. at end
		|| *name == '.' //relative is pointless
		|| ((i = strlen(name)) < 4 ? 0 : !strncasecmp(name + i - 4, ".log", 5)) // no logs
#ifdef _WIN32
		// no leading X:
	   	|| ( name[0] && name[1] == ':' && ((*name >= 'a' && *name <= 'z') || (*name >= 'A' && *name <= 'Z')))
#endif //_WIN32
	   )
		goto deny_download;

	if (sv_client->special)
		allow_dl = true; // NOTE: user used techlogin, allow dl anything in quake dir in such case!
	else if (!strstr(name, "/"))
		allow_dl = false; // should be in subdir
	else if (!(int)allow_download.value)
		allow_dl = false; // global allow check
	else if (!strncmp(name, "skins/", 6))
		allow_dl = allow_download_skins.value; // skins
	else if (!strncmp(name, "progs/", 6))
		allow_dl = allow_download_models.value; // models
	else if (!strncmp(name, "sound/", 6))
		allow_dl = allow_download_sounds.value; // sounds
	else if (!strncmp(name, "maps/", 5)) // maps, note usage of allow_download_pakmaps a bit below
		allow_dl = allow_download_maps.value; // maps
	else if (!strncmp(name, "demos/", 6) || !strncmp(name, "demonum/", 8))
		allow_dl = allow_download_demos.value; // demos
	else
		allow_dl = allow_download_other.value; // all other stuff

	if (!allow_dl)
		goto deny_download;

	SV_ClientDownloadComplete(sv_client);

	memset(alternative_path, 0, sizeof(alternative_path));
	if ( !strncmp(name, "demos/", 6) && sv_demoDir.string[0])
	{
		snprintf(n,sizeof(n), "%s/%s", sv_demoDir.string, name + 6);
		name = n;

		if (sv_demoDirAlt.string[0]) {
			strlcpy(alternative_path, sv_demoDirAlt.string, sizeof(alternative_path));
			strlcat(alternative_path, "/", sizeof(alternative_path));
			strlcat(alternative_path, name + 6, sizeof(alternative_path));
		}
	}
	else if (!strncmp(name, "demonum/", 8))
	{
		int num = Q_atoi(name + 8);
		if (num == 0 && name[8] != '0')
		{
			char *num_s = name + 8;
			int num_s_len = strlen(num_s);
			for (num = 0; num < num_s_len; num++)
				if (num_s[num] != '.')
				{
					Con_Printf("usage: download demonum/num\n"
					           "if num is negative then download the Nth to last recorded demo, "
					           "also can type any quantity of dots and "
					           "where N dots is the Nth to last recorded demo\n");

					goto deny_download;
				}
			num &= 0xF;
			num <<= 24;
		}
		else
			num &= 0x00FFFFFF;
		name = SV_MVDNum(num);
		if (!name)
		{
			Con_Printf((char *)Q_yelltext((unsigned char*)va("Demo number %d not found.\n",
				(num & 0xFF000000) ? -(num >> 24) : ((num & 0x00800000) ? (num | 0xFF000000) : num) )));
			goto deny_download;
		}
		//Con_Printf("downloading demos/%s\n",name);
		snprintf(n, sizeof(n), "download demos/%s\n", name);

		ClientReliableWrite_Begin (sv_client, svc_stufftext,strlen(n) + 2);
		ClientReliableWrite_String (sv_client, n);
		return;
	}

	SV_UserCleanFilename(name);
	SV_UserCleanFilename(alternative_path);

	sv_client->downloadcount = 0;

#ifdef SERVERONLY
#define CLIENT_DOWNLOAD_RELATIVE_BASE FS_GAME // FIXME: Should we use FS_BASE ???
#else
#define CLIENT_DOWNLOAD_RELATIVE_BASE FS_BASE
#endif

	sv_client->download = FS_OpenVFS(name, "rb", CLIENT_DOWNLOAD_RELATIVE_BASE);
	if (!sv_client->download && alternative_path[0]) {
		sv_client->download = FS_OpenVFS(alternative_path, "rb", CLIENT_DOWNLOAD_RELATIVE_BASE);
	}
	if (sv_client->download) {
		sv_client->downloadsize = VFS_GETLEN(sv_client->download);
	}

	// if not techlogin, perform extra check to block .pak maps
	if (!sv_client->special) {
		// special check for maps that came from a pak file
		if (sv_client->download && !strncmp(name, "maps/", 5) && VFS_COPYPROTECTED(sv_client->download) && !(int)allow_download_pakmaps.value) {
			SV_ClientDownloadComplete(sv_client);
			goto deny_download;
		}
	}

	if (!sv_client->download)
	{
		Sys_Printf ("Couldn't download %s to %s\n", name, sv_client->name);
		goto deny_download;
	}

	// set donwload rate
	val = Info_Get (&sv_client->_userinfo_ctx_, "drate");
	sv_client->netchan.rate = 1. / SV_BoundRate(true, Q_atoi(*val ? val : "99999"));
	// disable duplicate packet setting while downloading
	sv_client->netchan.dupe = 0;

	// all checks passed, start downloading

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	if (sv_client->fteprotocolextensions & FTE_PEXT_CHUNKEDDOWNLOADS)
	{
		ClientReliableWrite_Begin (sv_client, svc_download, 10+strlen(name));
		ClientReliableWrite_Long (sv_client, -1);
		ClientReliableWrite_Long (sv_client, sv_client->downloadsize);
		ClientReliableWrite_String (sv_client, name);
	}
#endif

	Cmd_NextDownload_f ();
	Sys_Printf ("Downloading %s to %s\n", name, sv_client->name);

	//bliP: download info/download url ->
	if (!strncmp(name, "maps/", 5))
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Map %s is %.0fKB (%.2fMB)\n",
		                 name, (float)sv_client->downloadsize / 1024,
		                 (float)sv_client->downloadsize / 1024 / 1024);
		if (download_map_url.string[0])
		{
			name += 5;
			SV_ClientPrintf (sv_client, PRINT_HIGH, "Download this map faster:\n");
			SV_ClientPrintf (sv_client, PRINT_HIGH, "%s%s\n\n",
			                 download_map_url.string, name);
		}
	}
	else
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "File %s is %.0fKB (%.2fMB)\n",
		                 name, (float)sv_client->downloadsize / 1024,
		                 (float)sv_client->downloadsize / 1024 / 1024);
	}
	//<-

	return;

deny_download:

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	if (sv_client->fteprotocolextensions & FTE_PEXT_CHUNKEDDOWNLOADS)
	{
		ClientReliableWrite_Begin (sv_client, svc_download, 10+strlen(name));
		ClientReliableWrite_Long (sv_client, -1);
		ClientReliableWrite_Long (sv_client, -1); // FIXME: -1 = Couldn't download, -2 = deny, we always use -1 atm
		ClientReliableWrite_String (sv_client, name);
	}
	else
#endif
	{
		ClientReliableWrite_Begin (sv_client, svc_download, 4);
		ClientReliableWrite_Short (sv_client, -1);
		ClientReliableWrite_Byte (sv_client, 0);
	}

	SV_DownloadNextFile();

	return;
}

/*
==================
Cmd_DemoDownload_f
==================
*/
static void Cmd_StopDownload_f(void);

static void Cmd_DemoDownload_f(void)
{
	int		i, num, cmd_argv_i_len;
	char		*cmd_argv_i;
	unsigned char	download_queue_cleared[] = "Download queue cleared.\n";
	unsigned char	download_queue_empty[] = "Download queue empty.\n";
	unsigned char	download_queue_already_exists[]	= "Download queue already exists.\n";
	unsigned char	cmdhelp_dldesc[] = "Download a demo from the server your are connected to";
	unsigned char	cmdhelp_dl[] = "cmd dl";
	unsigned char	cmdhelp_pound[] = "#";
	unsigned char	cmdhelp_dot[] = ".";
	unsigned char	cmdhelp_bs[] = "\\";
	unsigned char	cmdhelp_stop[] = "stop";
	unsigned char	cmdhelp_cancel[] = "cancel";

	if (Cmd_Argc() < 2)
	{
		Con_Printf("\n%s\n"
		           "Usage:\n"
		           "  %s %s [%s [%s]]\n"
		           "    \"#\" is one or several numbers from the demo list\n"
		           "  %s %s [%s%s [%s%s%s]]\n"
		           "    Each number of dots represents the Nth last recorded demo\n"
		           "    (Note that you can mix numbers and groups of dots)\n"
		           "  %s [%s|%s|%s]\n"
		           "     \"\\\", \"stop\" or \"cancel\" clear the download queue\n\n",
		           Q_redtext(cmdhelp_dldesc),
		           Q_redtext(cmdhelp_dl), Q_redtext(cmdhelp_pound), Q_redtext(cmdhelp_pound), Q_redtext(cmdhelp_pound),
		           Q_redtext(cmdhelp_dl), Q_redtext(cmdhelp_dot), Q_redtext(cmdhelp_dot), Q_redtext(cmdhelp_dot),
		           Q_redtext(cmdhelp_dot), Q_redtext(cmdhelp_dot), Q_redtext(cmdhelp_dot),
		           Q_redtext(cmdhelp_dl), Q_redtext(cmdhelp_bs), Q_redtext(cmdhelp_stop), Q_redtext(cmdhelp_cancel)
		);
		return;
	}

	if (!strcmp(Cmd_Argv(1), "cancel") || !strcmp(Cmd_Argv(1), "stop"))
	{
		Cmd_StopDownload_f(); // should not have any arguments, so it's OK
		return;
	}

	if (!strcmp(Cmd_Argv(1), "\\"))
	{
		if (sv_client->demonum[0])
		{
			Con_Printf((char *)Q_redtext(download_queue_cleared));
			sv_client->demonum[0] = 0;
		}
		else
			Con_Printf((char *)Q_redtext(download_queue_empty));
		return;
	}

	if (sv_client->demonum[0])
	{
		Con_Printf((char *)Q_redtext(download_queue_already_exists));
		return;
	}

	sv_client->demolist = ((sv_client->demonum[0] = Cmd_Argc()) > 2);
	for (i = 1; i < sv_client->demonum[0]; i++)
	{
		cmd_argv_i = Cmd_Argv(i);
		cmd_argv_i_len = strlen(cmd_argv_i);
		num = Q_atoi(cmd_argv_i);
		if (num == 0 && cmd_argv_i[0] != '0')
		{
			for (num = 0; num < cmd_argv_i_len; num++)
				if (cmd_argv_i[num] != '.')
				{
					num = 0;
					break;
				}
			if (num)
			{
				num &= 0xF;
				num <<= 24;
			}
		}
		else
			num &= 0x00FFFFFF;
		sv_client->demonum[sv_client->demonum[0] - i] = num;
	}
	SV_DownloadNextFile();
}

/*
==================
Cmd_StopDownload_f
==================
*/
static void Cmd_StopDownload_f(void)
{
	unsigned char	download_stopped[] = "Download stopped and download queue cleared.\n";

	if (!sv_client->download)
		return;

	sv_client->downloadcount = sv_client->downloadsize;
	SV_ClientDownloadComplete(sv_client);

#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	if (sv_client->fteprotocolextensions & FTE_PEXT_CHUNKEDDOWNLOADS)
	{
		char *name = ""; // FIXME: FTE's chunked dl does't support "cmd stopdl", work around

		ClientReliableWrite_Begin (sv_client, svc_download, 10+strlen(name));
		ClientReliableWrite_Long (sv_client, -1);
		ClientReliableWrite_Long (sv_client, -3); // -3 = dl was stopped
		ClientReliableWrite_String (sv_client, name);
	}
	else
#endif
	{
		ClientReliableWrite_Begin (sv_client, svc_download, 6);
		ClientReliableWrite_Short (sv_client, 0);
		ClientReliableWrite_Byte (sv_client, 100);
	}

	sv_client->demonum[0] = 0;
	sv_client->demolist = false;

	Con_Printf ((char *)Q_redtext(download_stopped));
}
//=============================================================================

/*
==================
SV_Say
==================
*/

static void SV_Say (qbool team)
{
	qbool    fake = false;
	client_t *client;
	int      j, tmp, cls = 0;
	char     *p;                  // used basically for QC based mods.
	char     text[2048] = {0};    // used if mod does not have own support for say/say_team.
	qbool    write_begin;

	if (Cmd_Argc () < 2)
		return;

	p = Cmd_Args();

	// unfake if requested.
	if (!team && sv_unfake.value)
	{
		char *ch;

		for (ch = p; *ch; ch++)
			if (*ch == 13)
				*ch = '#';
	}

	// remove surrounding " if any.
	if (p[0] == '"' && (j = (int)strlen(p)) > 2 && p[j-1] == '"')
	{
		// form text[].
		snprintf(text, sizeof(text), "%s", p + 1); // skip opening " and copy rest text including closing ".
		text[max(0,(int)strlen(text)-1)] = '\n';   // replace closing " with new line.
	}
	else
	{
		// form text[].
		snprintf(text, sizeof(text), "%s\n", p);
	}

	if (!sv_client->logged && !sv_client->logged_in_via_web)
	{
		SV_ParseLogin(sv_client);
		return;
	}

	// try handle say in the mod.
	SV_EndRedirect ();

	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(sv_player);

	j = PR_ClientSay(team, p);

	SV_BeginRedirect (RD_CLIENT);

	if (j)
		return; // say was handled by mod.

	if (sv_client->spectator && (!(int)sv_spectalk.value || team))
		strlcpy(text, va("[SPEC] %s: %s", sv_client->name, text), sizeof(text));
	else if (team)
		strlcpy(text, va("(%s): %s", sv_client->name, text), sizeof(text));
	else
	{
		strlcpy(text, va("%s: %s", sv_client->name, text), sizeof(text));
	}

	if (fp_messages) {
		if (curtime < sv_client->lockedtill) {
			SV_ClientPrintf(sv_client, PRINT_CHAT, "You can't talk for %d more seconds\n", (int) (sv_client->lockedtill - curtime));
			return;
		}
		tmp = sv_client->whensaidhead - fp_messages + 1;
		if (tmp < 0)
			tmp = 10+tmp;
		if (sv_client->whensaid[tmp] && (curtime - sv_client->whensaid[tmp] < fp_persecond)) {
			sv_client->lockedtill = curtime + fp_secondsdead;
			if (fp_msg[0]) {
				SV_ClientPrintf(sv_client, PRINT_CHAT, "FloodProt: %s\n", fp_msg);
			}
			else {
				SV_ClientPrintf(sv_client, PRINT_CHAT, "FloodProt: You can't talk for %d seconds.\n", fp_secondsdead);
			}
			return;
		}
		sv_client->whensaidhead++;
		if (sv_client->whensaidhead > 9)
			sv_client->whensaidhead = 0;
		sv_client->whensaid[sv_client->whensaidhead] = curtime;
	}

	Sys_Printf ("%s", text);
	SV_Write_Log(CONSOLE_LOG, 1, text);

	fake = ( strchr(text, 13) ? true : false ); // check if string contain "$\"

	for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
	{
		if (client->state < cs_preconnected)
			continue;

		if (team)
		{
			// the spectator team
			if (sv_client->spectator)
			{
				if (!client->spectator)
					continue;	// on different teams
			}
			else
			{
				if (sv_client == client)
					; // send msg to self anyway
				else if (client->spectator)
				{
					if( !sv_sayteam_to_spec.value // player can't say_team to spec in this case
					    || !fake // self say_team does't contain $\ so this is treat as private message
					    || (client->spec_track <= 0 && strcmp(sv_client->team, client->team)) // spec do not track player and on different team
					    || (client->spec_track > 0 && strcmp(sv_client->team, svs.clients[client->spec_track - 1].team)) // spec track player on different team
					)
						continue;	// on different teams
				}
				else if (coop.value)
					; // allow team messages to everyone in coop from players.
				else if (!teamplay.value)
					continue; // non team game
				else if (strcmp(sv_client->team, client->team))
					continue; // on different teams
			}
		}
		else
		{
			if (sv_client->spectator)
			{
				// check for spectalk off.
				if (!client->spectator && !(int)sv_spectalk.value)
					continue; // off - specs can't talk to players.
			}
		}

		cls |= 1 << j;
		SV_ClientPrintf2(client, PRINT_CHAT, "%s", text);
	}

	if (!sv.mvdrecording || !cls)
		return;

	// non-team messages should be seen always, even if not tracking any player
	if (!team && ((sv_client->spectator && (int)sv_spectalk.value) || !sv_client->spectator))
	{
		write_begin = MVDWrite_Begin (dem_all, 0, strlen(text)+3);
	}
	else
	{
		write_begin = MVDWrite_Begin (dem_multiple, cls, strlen(text)+3);
	}

	if (write_begin)
	{
		MVD_MSG_WriteByte (svc_print);
		MVD_MSG_WriteByte (PRINT_CHAT);
		MVD_MSG_WriteString (text);
	}
}

/*
==================
Cmd_Say_f
==================
*/
static void Cmd_Say_f(void)
{
	SV_Say (false);
}
/*
==================
Cmd_Say_Team_f
==================
*/
static void Cmd_Say_Team_f(void)
{
	SV_Say (true);
}



//============================================================================

/*
=================
Cmd_Pings_f

The client is showing the scoreboard, so send new ping times for all
clients
=================
*/
static void Cmd_Pings_f (void)
{
	client_t *client;
	int j;

	for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
	{
		if (!(client->state == cs_spawned || (client->state == cs_connected/* && client->spawncount != svs.spawncount*/)) )
			continue;

		ClientReliableWrite_Begin (sv_client, svc_updateping, 4);
		ClientReliableWrite_Byte (sv_client, j);
		ClientReliableWrite_Short (sv_client, SV_CalcPing(client));
		ClientReliableWrite_Begin (sv_client, svc_updatepl, 4);
		ClientReliableWrite_Byte (sv_client, j);
		ClientReliableWrite_Byte (sv_client, client->lossage);
	}
}


/*
==================
Cmd_Kill_f
==================
*/
static void Cmd_Kill_f (void)
{
	if (sv_player->v->health <= 0)
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Can't suicide -- already dead!\n");
		return;
	}

	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	PR_ClientKill();
}

static void SV_NotifyStreamsOfPause(void)
{
	if (sv.mvdrecording) {
		sizebuf_t		msg;
		byte			msg_buf[20];

		SZ_InitEx(&msg, msg_buf, sizeof(msg_buf), true);
		MSG_WriteByte(&msg, svc_setpause);
		MSG_WriteByte(&msg, sv.paused ? 1 : 0);

		DemoWriteQTV(&msg);
	}
}

/*
==================
SV_TogglePause
==================
*/
void SV_TogglePause (const char *msg, int bit)
{
	int i;
	client_t *cl;
	extern cvar_t sv_paused;

	sv.paused ^= bit;
	
	Cvar_SetROM (&sv_paused, va("%i", sv.paused));

	if (sv.paused)
		sv.pausedsince = Sys_DoubleTime();

	if (msg)
		SV_BroadcastPrintf (PRINT_HIGH, "%s", msg);

	// send notification to all clients
	for (i=0, cl = svs.clients ; i<MAX_CLIENTS ; i++, cl++)
	{
		if (!cl->state)
			continue;
		ClientReliableWrite_Begin (cl, svc_setpause, 2);
		ClientReliableWrite_Byte (cl, sv.paused ? 1 : 0);

		cl->lastservertimeupdate = -99; // force an update to be sent
	}

	// send notification to all streams
	SV_NotifyStreamsOfPause();
}


/*
==================
Cmd_Pause_f
==================
*/
static void Cmd_Pause_f (void)
{
	char st[CLIENT_NAME_LEN + 32];
	qbool newstate;

	newstate = sv.paused ^ 1;

	if (!(int)pausable.value)
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Pause not allowed.\n");
		return;
	}

	if (sv_client->spectator)
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Spectators can not pause.\n");
		return;
	}

	if (GE_ShouldPause) {
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(sv_player);
		G_FLOAT(OFS_PARM0) = newstate;
		PR_ExecuteProgram (GE_ShouldPause);
		if (!G_FLOAT(OFS_RETURN))
			return;		// progs said ignore the request
	}

	if (newstate & 1)
		snprintf (st, sizeof(st), "%s paused the game\n", sv_client->name);
	else
		snprintf (st, sizeof(st), "%s unpaused the game\n", sv_client->name);

	SV_TogglePause(st, 1);
}


/*
=================
Cmd_Drop_f

The client is going to disconnect, so remove the connection immediately
=================
*/
static void Cmd_Drop_f (void)
{
	SV_EndRedirect ();
	if (sv_client->state == cs_zombie) // FIXME
		return; // FIXME
	if (!sv_client->spectator)
		SV_BroadcastPrintf (PRINT_HIGH, "%s dropped\n", sv_client->name);
	SV_DropClient (sv_client);
}

/*
=================
Cmd_PTrack_f

Change the bandwidth estimate for a client
=================
*/
static void Cmd_PTrack_f (void)
{
	int		i;
	edict_t *ent, *tent;

	if (!sv_client->spectator)
		return;

	if (Cmd_Argc() != 2)
	{
		// turn off tracking
		sv_client->spec_track = 0;
		ent = EDICT_NUM(sv_client - svs.clients + 1);
		tent = EDICT_NUM(0);
		ent->v->goalentity = EDICT_TO_PROG(tent);
		return;
	}

	i = Q_atoi(Cmd_Argv(1));
	if (i < 0 || i >= MAX_CLIENTS || svs.clients[i].state != cs_spawned || svs.clients[i].spectator)
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Invalid client to track\n");
		sv_client->spec_track = 0;
		ent = EDICT_NUM(sv_client - svs.clients + 1);
		tent = EDICT_NUM(0);
		ent->v->goalentity = EDICT_TO_PROG(tent);
		return;
	}
	sv_client->spec_track = i + 1; // now tracking

	ent = EDICT_NUM(sv_client - svs.clients + 1);
	tent = EDICT_NUM(i + 1);
	ent->v->goalentity = EDICT_TO_PROG(tent);
}

/*
=================
Cmd_Rate_f

Change the bandwidth estimate for a client
=================
*/
static void Cmd_Rate_f (void)
{
	int		rate;

	if (Cmd_Argc() != 2)
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Current rate is %i\n",
		                 (int)(1.0/sv_client->netchan.rate + 0.5));
		return;
	}

	rate = SV_BoundRate (sv_client->download != NULL, Q_atoi(Cmd_Argv(1)));

	SV_ClientPrintf (sv_client, PRINT_HIGH, "Net rate set to %i\n", rate);
	sv_client->netchan.rate = 1.0/rate;
}

//bliP: upload files ->
/*
=================
Cmd_TechLogin_f
Login to upload
=================
*/
int Master_Rcon_Validate (void);
static void Cmd_TechLogin_f (void)
{
	if (sv_client->logincount > 4) //denied
		return;

	if (Cmd_Argc() < 2)
	{
		if (sv_client->special)
		{
			sv_client->special = false;
			sv_client->logincount = 0;
			SV_ClientPrintf (sv_client, PRINT_HIGH, "Logged out.\n");
		}
		return;
	}

	if (!Master_Rcon_Validate()) //don't even let them know they're wrong
	{
		sv_client->logincount++;
		return;
	}

	sv_client->special = true;
	SV_ClientPrintf (sv_client, PRINT_HIGH, "Logged in.\n");
}

/*
================
Cmd_Upload_f
================
*/
static void Cmd_Upload_f (void)
{
	FILE *f;
	char str[MAX_OSPATH];

	if (sv_client->state != cs_spawned)
		return;

	if (!sv_client->special)
	{
		Con_Printf ("Client not tagged to upload.\n");
		return;
	}

	if (Cmd_Argc() != 3)
	{
		Con_Printf ("upload [local filename] [remote filename]\n");
		return;
	}

	snprintf(sv_client->uploadfn, sizeof(sv_client->uploadfn), "%s", Cmd_Argv(2));

	if (!sv_client->uploadfn[0])
	{ //just in case..
		Con_Printf ("Bad file name.\n");
		return;
	}

	if ((f = fopen(sv_client->uploadfn, "rb")))
	{
		Con_Printf ("File already exists.\n");
		fclose(f);
		return;
	}

	sv_client->remote_snap = false;
	FS_CreatePath (sv_client->uploadfn); //fixed, need to create path
	snprintf (str, sizeof (str), "cmd fileul \"%s\"\n", Cmd_Argv(1));
	ClientReliableWrite_Begin (sv_client, svc_stufftext, strlen(str) + 2);
	ClientReliableWrite_String (sv_client, str);
}
//<-

/*
==================
Cmd_SetInfo_f

Allow clients to change userinfo
==================
*/

char *shortinfotbl[] =
{
	"name",
	"team",
	"skin",
	"topcolor",
	"bottomcolor",
#ifdef CHAT_ICON_EXPERIMENTAL
	"chat",
#endif
	"gender",
	"*auth",
	"*flag",
	//"*client",
	//"*spectator",
	//"*VIP",
	NULL
};

static void Cmd_SetInfo_f (void)
{
	extern cvar_t sv_forcenick;
	sv_client_state_t saved_state;
	char oldval[MAX_EXT_INFO_STRING];
	char info[MAX_EXT_INFO_STRING];

	if (sv_kickuserinfospamtime.value > 0 && (int)sv_kickuserinfospamcount.value > 0)
	{
		if (!sv_client->lastuserinfotime ||
			curtime - sv_client->lastuserinfotime > sv_kickuserinfospamtime.value)
		{
			sv_client->lastuserinfocount = 0;
			sv_client->lastuserinfotime = curtime;
		}
		else if (++(sv_client->lastuserinfocount) > (int)sv_kickuserinfospamcount.value)
		{
			if (!sv_client->drop)
			{
				saved_state = sv_client->state;
				sv_client->state = cs_free;
				SV_BroadcastPrintf (PRINT_HIGH,
				                    "%s was kicked for userinfo spam\n", sv_client->name);
				sv_client->state = saved_state;
				SV_ClientPrintf (sv_client, PRINT_HIGH,
			    	             "You were kicked from the game for userinfo spamming\n");
				SV_LogPlayer (sv_client, "userinfo spam", 1);
				sv_client->drop = true;
			}
			return;
		}
	}

	switch (Cmd_Argc())
	{
		case 1:
			Con_Printf ("User info settings:\n");

			Info_ReverseConvert(&sv_client->_userinfo_ctx_, info, sizeof(info));
			Info_Print(info);
			Con_DPrintf ("[%d/%d]\n", strlen(info), sizeof(info));

			if (developer.value)
			{
				Con_Printf ("User info settings short:\n");
				Info_ReverseConvert(&sv_client->_userinfoshort_ctx_, info, sizeof(info));
				Info_Print(info);
				Con_DPrintf ("[%d/%d]\n", strlen(info), sizeof(info));
			}

			return;
		case 3:
			break;
		default:
			Con_Printf ("usage: setinfo [ <key> <value> ]\n");
			return;
	}

	if (Cmd_Argv(1)[0] == '*')
		return;		// don't set privileged values

	if (strchr(Cmd_Argv(1), '\\') || strchr(Cmd_Argv(2), '\\'))
		return;		// illegal char

	if (strstr(Cmd_Argv(1), "&c") || strstr(Cmd_Argv(1), "&r") || strstr(Cmd_Argv(2), "&c") || strstr(Cmd_Argv(2), "&r"))
		return;

	strlcpy(oldval, Info_Get(&sv_client->_userinfo_ctx_, Cmd_Argv(1)), sizeof(oldval));

	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	if (PR_UserInfoChanged(0))
		return; // does not allowed to be changed by mod.

	Info_Set (&sv_client->_userinfo_ctx_, Cmd_Argv(1), Cmd_Argv(2));
	// name is extracted below in ExtractFromUserInfo
	//	strlcpy (sv_client->name, Info_ValueForKey (sv_client->userinfo, "name")
	//		, CLIENT_NAME_LEN);
	//	SV_FullClientUpdate (sv_client, &sv.reliable_datagram);
	//	sv_client->sendinfo = true;

	//Info_ValueForKey(sv_client->userinfo, Cmd_Argv(1));
	if (!strcmp(Info_Get(&sv_client->_userinfo_ctx_, Cmd_Argv(1)), oldval))
		return; // key hasn't changed

	if (!strcmp(Cmd_Argv(1), "name"))
	{
		//bliP: mute ->
		if (curtime < sv_client->lockedtill)
		{
			SV_ClientPrintf(sv_client, PRINT_CHAT, "You can't change your name while you're muted\n");
			return;
		}
		//<-
		//VVD: forcenick ->
		//meag: removed sv_login check to allow optional logins... sv_forcenick should still take effect
		if ((int)sv_forcenick.value && /*(int)sv_login.value &&*/ sv_client->login[0])
		{
			// allow differences in case, redtext
			if (Q_namecmp(sv_client->login, Cmd_Argv(2))) {
				SV_ClientPrintf(sv_client, PRINT_CHAT, "You can't change your name while logged in on this server.\n");
				Info_Set(&sv_client->_userinfo_ctx_, "name", sv_client->login);
				strlcpy(sv_client->name, sv_client->login, CLIENT_NAME_LEN);
				MSG_WriteByte(&sv_client->netchan.message, svc_stufftext);
				MSG_WriteString(&sv_client->netchan.message, va("name %s\n", sv_client->login));
				MSG_WriteByte(&sv_client->netchan.message, svc_stufftext);
				MSG_WriteString(&sv_client->netchan.message, va("setinfo name %s\n", sv_client->login));
				return;
			}
		}
		//<-
	}

	//bliP: kick top ->
	if ((int)sv_kicktop.value && !strcmp(Cmd_Argv(1), "topcolor"))
	{
		if (!sv_client->lasttoptime || curtime - sv_client->lasttoptime > 8)
		{
			sv_client->lasttopcount = 0;
			sv_client->lasttoptime = curtime;
		}
		else if (sv_client->lasttopcount++ > 5)
		{
			if (!sv_client->drop)
			{
				saved_state = sv_client->state;
				sv_client->state = cs_free;
				SV_BroadcastPrintf (PRINT_HIGH,
				                    "%s was kicked for topcolor spam\n", sv_client->name);
				sv_client->state = saved_state;
				SV_ClientPrintf (sv_client, PRINT_HIGH,
				                 "You were kicked from the game for topcolor spamming\n");
				SV_LogPlayer (sv_client, "topcolor spam", 1);
				sv_client->drop = true;
			}
			return;
		}
	}
	//<-

	ProcessUserInfoChange (sv_client, Cmd_Argv (1), oldval);
	PR_UserInfoChanged(1);
}

void ProcessUserInfoChange (client_t* sv_client, const char* key, const char* old_value)
{
	int i;

	// process any changed values
	SV_ExtractFromUserinfo (sv_client, !strcmp(key, "name"));

	if (mod_UserInfo_Changed)
	{
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(sv_client->edict);
		PR_SetTmpString(&G_INT(OFS_PARM0), key);
		PR_SetTmpString(&G_INT(OFS_PARM1), old_value);
		PR_SetTmpString(&G_INT(OFS_PARM2), Info_Get(&sv_client->_userinfo_ctx_, key));
		PR_ExecuteProgram (mod_UserInfo_Changed);
	}

	for (i = 0; shortinfotbl[i] != NULL; i++)
	{
		if (!strcmp(key, shortinfotbl[i]))
		{
			char *nuw = Info_Get(&sv_client->_userinfo_ctx_, key);

			Info_SetStar (&sv_client->_userinfoshort_ctx_, key, nuw);

			i = sv_client - svs.clients;
			MSG_WriteByte (&sv.reliable_datagram, svc_setinfo);
			MSG_WriteByte (&sv.reliable_datagram, i);
			MSG_WriteString (&sv.reliable_datagram, key);
			MSG_WriteString (&sv.reliable_datagram, nuw);
			break;
		}
	}
}

/*
==================
SV_ShowServerinfo_f

Dumps the serverinfo info string
==================
*/
static void Cmd_ShowServerinfo_f (void)
{
	Info_Print (svs.info);
}

static void Cmd_NoSnap_f(void)
{
	if (*sv_client->uploadfn)
	{
		*sv_client->uploadfn = 0;
		SV_BroadcastPrintf (PRINT_HIGH, "%s refused remote screenshot\n", sv_client->name);
	}
}

/*
==============
Cmd_MinPing_f
==============
*/
static void Cmd_MinPing_f (void)
{
	float minping;
	switch (Cmd_Argc())
	{
	case 2:
		if (GameStarted())
			Con_Printf("Can't change sv_minping: demo recording or match in progress.\n");
		else if (!(int)sv_enable_cmd_minping.value)
			Con_Printf("Can't change sv_minping: sv_enable_cmd_minping == 0.\n");
		else
		{
			minping = Q_atof(Cmd_Argv(1));
			if (minping < 0 || minping > 300)
				Con_Printf("Value must be >= 0 and <= 300.\n");
			else
				Cvar_SetValue (&sv_minping, (int)minping);
		}
	case 1:
		Con_Printf("sv_minping = %s\n", sv_minping.string);
		break;
	default:
		Con_Printf("usage: minping [<value>]\n<value> = '' show current sv_minping value\n");
	}
}

/*
==============
Cmd_AirStep_f
==============
*/
static void Cmd_AirStep_f (void)
{
	int val;
	unsigned char red_airstep[64] = "pm_airstep";

	if (sv_client->spectator) {
		Con_Printf("Spectators can't change pm_airstep\n");
		return;
	}

	switch (Cmd_Argc())
	{
	case 2:
		if (GameStarted())
			Con_Printf("Can't change pm_airstep: demo recording in progress or serverinfo key status is not 'Standby'.\n");
		else
		{
			val = Q_atoi(Cmd_Argv(1));
			if (val != 0 && val != 1)
				Con_Printf("Value must be 0 or 1.\n");
			else {
				float old = pm_airstep.value; // remember
				Cvar_Set (&pm_airstep, val ? "1" : ""); // set new value

				if (pm_airstep.value != old) { // seems value was changed
					SV_BroadcastPrintf (2, "%s turns %s %s\n", 
								sv_client->name, Q_redtext(red_airstep), pm_airstep.value ? "on" : "off");
					break;
				}
			}
		}
	case 1:
		Con_Printf("pm_airstep = %s\n", pm_airstep.string);
		break;
	default:
		Con_Printf("usage: airstep [0 | 1]\n");
	}
}

/*
==============
Cmd_ShowMapsList_f
==============
*/
static void Cmd_ShowMapsList_f(void)
{
	char	*value, *key;
	int	i, j, len, i_mod_2 = 1;
	unsigned char	ztndm3[] = "ztndm3";
	unsigned char	list_of_custom_maps[] = "list of custom maps";
	unsigned char	end_of_list[] = "end of list";

	Con_Printf("Vote for maps by typing the mapname, for example \"%s\"\n\n---%s\n",
	           Q_redtext(ztndm3), Q_redtext(list_of_custom_maps));

	for (i = LOCALINFO_MAPS_LIST_START; i <= LOCALINFO_MAPS_LIST_END; i++)
	{
		key = va("%d", i);
		value = Info_Get(&_localinfo_, key);
		if (*value)
		{

			if (!(i_mod_2 = i % 2))
			{
				if ((len = 19 - strlen(value)) < 1)
					len = 1;
				for (j = 0; j < len; j++)
					strlcat(value, " ", MAX_KEY_STRING);
			}
			Con_Printf("%s%s", value, i_mod_2 ? "\n" : "");
		}
		else
			break;
	}
	Con_Printf("%s---%s\n", i_mod_2 ? "" : "\n", Q_redtext(end_of_list));
}

static void SetUpClientEdict (client_t *cl, edict_t *ent)
{
	ED_ClearEdict(ent);
	// restore client name.
	PR_SetEntityString(ent, ent->v->netname, cl->name);
	// so spec will have right goalentity - if speccing someone
	if(cl->spectator && cl->spec_track > 0)
		ent->v->goalentity = EDICT_TO_PROG(svs.clients[cl->spec_track-1].edict);

	ent->v->colormap = NUM_FOR_EDICT(ent);

	ent->v->team = 0; // FIXME

	cl->entgravity = 1.0;
	if (fofs_gravity)
		EdictFieldFloat(ent, fofs_gravity) = 1.0;

	cl->maxspeed = sv_maxspeed.value;
	if (fofs_maxspeed)
		EdictFieldFloat(ent, fofs_maxspeed) = (int)sv_maxspeed.value;
}

extern cvar_t spectator_password, password;
extern void MVD_PlayerReset(int player);
extern void CountPlayersSpecsVips(int *clients_ptr, int *spectators_ptr, int *vips_ptr, client_t **newcl_ptr);
extern qbool SpectatorCanConnect(int vip, int spass, int spectators, int vips);
extern qbool PlayerCanConnect(int clients);

/*
==================
Cmd_Join_f

Set client to player mode without reconnecting
==================
*/
static void Cmd_Join_f (void)
{
	int i;
	int clients;

	if (sv_client->state != cs_spawned)
		return;

	if (!sv_client->spectator)
		return; // already a player

	if (!(sv_client->extensions & Z_EXT_JOIN_OBSERVE)) {
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Your QW client doesn't support this command\n");
		return;
	}

	if (password.string[0] && strcmp (password.string, "none")) {
		SV_ClientPrintf (sv_client, PRINT_HIGH, "This server requires a %s password. Please disconnect, set the password and reconnect as %s.\n", "player", "player");
		return;
	}

	// Might have been 'not necessary' for spectator but needed for player
	if (SV_LoginBlockJoinRequest(sv_client)) {
		return;
	}

	if (SV_ClientConnectedTime(sv_client) < 5) {
		SV_ClientPrintf(sv_client, PRINT_HIGH, "Wait %d seconds\n", 5 - (int)SV_ClientConnectedTime(sv_client));
		return;
	}

	// count players already on server
	CountPlayersSpecsVips(&clients, NULL, NULL, NULL);
	if (!PlayerCanConnect(clients)) {
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Can't join, all player slots full\n");
		return;
	}

	if (!PlayerCheckPing()) {
		return;
	}

	// call the prog function for removing a client
	// this will set the body to a dead frame, among other things
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	PR_GameClientDisconnect(1);

	// this is like SVC_DirectConnect.
	// turn the spectator into a player
	sv_client->old_frags = 0;
	SV_SetClientConnectionTime(sv_client);
	sv_client->spectator = false;
	sv_client->spec_track = 0;
	Info_Remove(&sv_client->_userinfo_ctx_, "*spectator");
	Info_Remove(&sv_client->_userinfoshort_ctx_, "*spectator");

	// like Cmd_Spawn_f()
	SetUpClientEdict (sv_client, sv_client->edict);

	// call the progs to get default spawn parms for the new client
	PR_GameSetNewParms();

	// copy spawn parms out of the client_t
	for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
		sv_client->spawn_parms[i] = (&PR_GLOBAL(parm1))[i];

	// call the spawn function
	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	G_FLOAT(OFS_PARM0) = (float) sv_client->vip;
	PR_GameClientConnect(0);

	// actually spawn the player
	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	G_FLOAT(OFS_PARM0) = (float) sv_client->vip;
	PR_GamePutClientInServer(0);

	// look in SVC_DirectConnect() for for extended comment whats this for
	MVD_PlayerReset(NUM_FOR_EDICT(sv_player) - 1);

	// send notification to all clients
	sv_client->sendinfo = true;
}

/*
==================
Cmd_Observe_f

Set client to spectator mode without reconnecting
==================
*/
static void Cmd_Observe_f (void)
{
	int i;
	int spectators, vips;

	if (sv_client->state != cs_spawned)
		return;
	if (sv_client->spectator)
		return; // already a spectator

	if (!(sv_client->extensions & Z_EXT_JOIN_OBSERVE)) {
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Your QW client doesn't support this command\n");
		return;
	}

	if (spectator_password.string[0] && strcmp (spectator_password.string, "none")) {
		SV_ClientPrintf (sv_client, PRINT_HIGH, "This server requires a %s password. Please disconnect, set the password and reconnect as %s.\n", "spectator", "spectator");
		return;
	}

	if (SV_ClientConnectedTime(sv_client) < 5)
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Wait %d seconds\n", 5 - (int)SV_ClientConnectedTime(sv_client));
		return;
	}

	// count spectators already on server
	CountPlayersSpecsVips(NULL, &spectators, &vips, NULL);

	if (!SpectatorCanConnect(sv_client->vip, true/*kinda HACK*/, spectators, vips))
	{
		SV_ClientPrintf (sv_client, PRINT_HIGH, "Can't join, all spectator/vip slots full\n");
		return;
	}

	// call the prog function for removing a client
	// this will set the body to a dead frame, among other things
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	PR_GameClientDisconnect(0);

	// this is like SVC_DirectConnect.
	// turn the player into a spectator
	sv_client->old_frags = 0;
	SV_SetClientConnectionTime(sv_client);
	sv_client->spectator = true;
	sv_client->spec_track = 0;
	Info_SetStar (&sv_client->_userinfo_ctx_, "*spectator", "1");
	Info_SetStar (&sv_client->_userinfoshort_ctx_, "*spectator", "1");

	// like Cmd_Spawn_f()
	SetUpClientEdict (sv_client, sv_client->edict);

	// call the progs to get default spawn parms for the new client
	PR_GameSetNewParms();

	SV_SpawnSpectator ();

	// copy spawn parms out of the client_t
	for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
		sv_client->spawn_parms[i] = (&PR_GLOBAL(parm1))[i];

	// call the spawn function
	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	G_FLOAT(OFS_PARM0) = (float) sv_client->vip;
	PR_GameClientConnect(1);

	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	PR_GamePutClientInServer(1); // let mod know we put spec not player

	// look in SVC_DirectConnect() for for extended comment whats this for
	MVD_PlayerReset(NUM_FOR_EDICT(sv_player) - 1);

	// send notification to all clients
	sv_client->sendinfo = true;
}

#ifdef FTE_PEXT2_VOICECHAT
/*
Privacy issues:
By sending voice chat to a server, you are unsure who might be listening.
Voice can be recorded to an mvd, potentially including voice.
Spectators tracking you are able to hear team chat of your team.
You're never quite sure if anyone might join the server and your team before you finish saying a sentance.
You run the risk of sounds around you being recorded by quake, including but not limited to: TV channels, loved ones, phones, YouTube videos featuring certain moans.
Default on non-team games is to broadcast.
*/

// FTEQW type and naming compatibility
// it's not really necessary, simple find & replace would do the job too

#define qboolean qbool
#define host_client sv_client
#define ival value // for cvars compatibility

#define VOICE_RING_SIZE 512 /*POT*/
struct
{
	struct voice_ring_s
	{
		unsigned int sender;
		unsigned char receiver[MAX_CLIENTS/8];
		unsigned char gen;
		unsigned char seq;
		unsigned int datalen;
		unsigned char data[1024];
	} ring[VOICE_RING_SIZE];
	unsigned int write;
} voice;

void SV_VoiceReadPacket(void)
{
	unsigned int vt = host_client->voice_target;
	unsigned int j;
	struct voice_ring_s *ring;
	unsigned short bytes;
	client_t *cl;
	unsigned char gen = MSG_ReadByte();
	unsigned char seq = MSG_ReadByte();
	/*read the data from the client*/
	bytes = MSG_ReadShort();
	ring = &voice.ring[voice.write & (VOICE_RING_SIZE-1)];
	if (bytes > sizeof(ring->data) || curtime < host_client->lockedtill || !sv_voip.ival) {
		MSG_ReadSkip(bytes);
		return;
	}
	else {
		voice.write++;
		MSG_ReadData(ring->data, bytes);
	}

	ring->datalen = bytes;
	ring->sender = host_client - svs.clients;
	ring->gen = gen;
	ring->seq = seq;

	/*broadcast it its to their team, and its not teamplay*/
	if (vt == VT_TEAM && !teamplay.ival)
		vt = VT_ALL;

	/*figure out which team members are meant to receive it*/
	for (j = 0; j < MAX_CLIENTS/8; j++)
		ring->receiver[j] = 0;
	for (j = 0, cl = svs.clients; j < MAX_CLIENTS; j++, cl++)
	{
		if (cl->state != cs_spawned && cl->state != cs_connected)
			continue;
		/*spectators may only talk to spectators*/
		if (host_client->spectator && !sv_spectalk.ival)
			if (!cl->spectator)
				continue;

		if (vt == VT_TEAM)
		{
			// the spectator team
			if (host_client->spectator)
			{
				if (!cl->spectator)
					continue;
			}
			else
			{
				if (strcmp(cl->team, host_client->team) || cl->spectator)
					continue;	// on different teams
			}
		}
		else if (vt == VT_NONMUTED)
		{
			if (host_client->voice_mute[j>>3] & (1<<(j&3)))
				continue;
		}
		else if (vt >= VT_PLAYERSLOT0)
		{
			if (j != vt - VT_PLAYERSLOT0)
				continue;
		}

		ring->receiver[j>>3] |= 1<<(j&3);
	}

	if (sv.mvdrecording && sv_voip_record.ival && !(sv_voip_record.ival == 2 && !host_client->spectator))
	{
		// non-team messages should be seen always, even if not tracking any player
		if (vt == VT_ALL && (!host_client->spectator || sv_spectalk.ival))
		{
			MVDWrite_Begin (dem_all, 0, ring->datalen+6);
		}
		else
		{
			unsigned int cls;
			cls = ring->receiver[0] |
				(ring->receiver[1]<<8) |
				(ring->receiver[2]<<16) |
				(ring->receiver[3]<<24);

			if (!cls) {
				// prevent dem_multiple(0) being sent
				return;
			}

			MVDWrite_Begin(dem_multiple, cls, ring->datalen + 6);
		}

		MVD_MSG_WriteByte( svc_fte_voicechat);
		MVD_MSG_WriteByte( ring->sender);
		MVD_MSG_WriteByte( ring->gen);
		MVD_MSG_WriteByte( ring->seq);
		MVD_MSG_WriteShort( ring->datalen);
		MVD_SZ_Write(       ring->data, ring->datalen);
	}
}

void SV_VoiceInitClient(client_t *client)
{
	client->voice_target = VT_TEAM;
	client->voice_active = false;
	client->voice_read = voice.write;
	memset(client->voice_mute, 0, sizeof(client->voice_mute));
}

void SV_VoiceSendPacket(client_t *client, sizebuf_t *buf)
{
	unsigned int clno;
	qboolean send;
	struct voice_ring_s *ring;
//	client_t *split;

//	if (client->controller)
//		client = client->controller;
	clno = client - svs.clients;

	if (!(client->fteprotocolextensions2 & FTE_PEXT2_VOICECHAT))
		return;
	if (!client->voice_active || client->num_backbuf)
	{
		client->voice_read = voice.write;
		return;
	}

	while(client->voice_read < voice.write)
	{
		/*they might be too far behind*/
		if (client->voice_read+VOICE_RING_SIZE < voice.write)
			client->voice_read = voice.write - VOICE_RING_SIZE;

		ring = &voice.ring[(client->voice_read) & (VOICE_RING_SIZE-1)];

		/*figure out if it was for us*/
		send = false;
		if (ring->receiver[clno>>3] & (1<<(clno&3)))
			send = true;

		// FIXME: qqshka: well, is it RIGHTWAY at all???
#if 0  // qqshka: I am turned it off.
		/*if you're spectating, you can hear whatever your tracked player can hear*/
		if (client->spectator && client->spec_track)
			if (ring->receiver[(client->spec_track-1)>>3] & (1<<((client->spec_track-1)&3)))
				send = true;
#endif

		if (client->voice_mute[ring->sender>>3] & (1<<(ring->sender&3)))
			send = false;

		if (ring->sender == clno && !sv_voip_echo.ival)
			send = false;

		/*additional ways to block voice*/
		if (client->download)
			send = false;

		if (send)
		{
			if (buf->maxsize - buf->cursize < ring->datalen+5)
				break;
			MSG_WriteByte(buf, svc_fte_voicechat);
			MSG_WriteByte(buf, ring->sender);
			MSG_WriteByte(buf, ring->gen);
			MSG_WriteByte(buf, ring->seq);
			MSG_WriteShort(buf, ring->datalen);
			SZ_Write(buf, ring->data, ring->datalen);
		}
		client->voice_read++;
	}
}

void SV_Voice_Ignore_f(void)
{
	unsigned int other;
	int type = 0;

	if (Cmd_Argc() < 2)
	{
		/*only a name = toggle*/
		type = 0;
	}
	else
	{
		/*mute if 1, unmute if 0*/
		if (atoi(Cmd_Argv(2)))
			type = 1;
		else
			type = -1;
	}
	other = atoi(Cmd_Argv(1));
	if (other >= MAX_CLIENTS)
		return;

	switch(type)
	{
	case -1:
		host_client->voice_mute[other>>3] &= ~(1<<(other&3));
		break;
	case 0:	
		host_client->voice_mute[other>>3] ^= (1<<(other&3));
		break;
	case 1:
		host_client->voice_mute[other>>3] |= (1<<(other&3));
	}
}

void SV_Voice_Target_f(void)
{
	unsigned int other;
	char *t = Cmd_Argv(1);
	if (!strcmp(t, "team"))
		host_client->voice_target = VT_TEAM;
	else if (!strcmp(t, "all"))
		host_client->voice_target = VT_ALL;
	else if (!strcmp(t, "nonmuted"))
		host_client->voice_target = VT_NONMUTED;
	else if (*t >= '0' && *t <= '9')
	{
		other = atoi(t);
		if (other >= MAX_CLIENTS)
			return;
		host_client->voice_target = VT_PLAYERSLOT0 + other;
	}
	else
	{
		/*don't know who you mean, futureproofing*/
		host_client->voice_target = VT_TEAM;
	}
}

void SV_Voice_MuteAll_f(void)
{
	host_client->voice_active = false;
}

void SV_Voice_UnmuteAll_f(void)
{
	host_client->voice_active = true;
}

#endif // FTE_PEXT2_VOICECHAT

/*
 * Parse protocol extensions which supported by client.
 * This is workaround for the proxy case, like: qwfwd. We can't use it in case of qizmo thought.
 */
void Cmd_PEXT_f(void)
{
	int idx;
	int proto_ver, proto_value;

	if (!sv_client->process_pext)
		return; // sorry, we do not expect it right now.

	sv_client->process_pext = false;

	for ( idx = 1; idx < Cmd_Argc(); )
	{
		proto_ver   = Q_atoi(Cmd_Argv(idx++));
		proto_value = Q_atoi(Cmd_Argv(idx++));

		switch( proto_ver )
		{
#ifdef PROTOCOL_VERSION_FTE
		case PROTOCOL_VERSION_FTE:
			// do not reset it.
			if (!sv_client->fteprotocolextensions)
			{
				sv_client->fteprotocolextensions = proto_value & svs.fteprotocolextensions;
				if (sv_client->fteprotocolextensions)
					Con_DPrintf("PEXT: Client supports 0x%x fte extensions\n", sv_client->fteprotocolextensions);
			}
			break;
#endif // PROTOCOL_VERSION_FTE

#ifdef PROTOCOL_VERSION_FTE2
		case PROTOCOL_VERSION_FTE2:
			// do not reset it.
			if (!sv_client->fteprotocolextensions2)
			{
				sv_client->fteprotocolextensions2 = proto_value & svs.fteprotocolextensions2;
				if (sv_client->fteprotocolextensions2)
					Con_DPrintf("PEXT: Client supports 0x%x fte extensions2\n", sv_client->fteprotocolextensions2);
			}
			break;
#endif // PROTOCOL_VERSION_FTE2

#ifdef PROTOCOL_VERSION_MVD1
		case PROTOCOL_VERSION_MVD1:
			if (!sv_client->mvdprotocolextensions1)
			{
				sv_client->mvdprotocolextensions1 = proto_value & svs.mvdprotocolextension1;
				if (sv_client->mvdprotocolextensions1)
					Con_DPrintf("PEXT: Client supports 0x%x mvdsv extensions\n", sv_client->mvdprotocolextensions1);
			}
			break;
#endif
		}
	}

	// we are ready for new command now.
	MSG_WriteByte (&sv_client->netchan.message, svc_stufftext);
	MSG_WriteString (&sv_client->netchan.message, "cmd new\n");
}

#if defined(SERVERONLY) && defined(WWW_INTEGRATION)
// { Central login
void Cmd_Login_f(void)
{
	extern cvar_t sv_login;

	if (sv_client->state != cs_spawned && !(int)sv_login.value) {
		SV_ClientPrintf2(sv_client, PRINT_HIGH, "Cannot login during connection\n");
		return;
	}

	if (Cmd_Argc() != 2) {
		SV_ClientPrintf2(sv_client, PRINT_HIGH, "Usage: login <username>\n");
		return;
	}

	if (curtime - sv_client->login_request_time < LOGIN_MIN_RETRY_TIME) {
		SV_ClientPrintf2(sv_client, PRINT_HIGH, "Please wait and try again\n");
		return;
	}

	if (sv_client->logged_in_via_web) {
		SV_ClientPrintf2(sv_client, PRINT_HIGH, "You are already logged in as '%s'\n", sv_client->login);
		return;
	}

	if (sv_client->state != cs_spawned) {
		SV_ParseWebLogin(sv_client);
	}
	else {
		Central_GenerateChallenge(sv_client, Cmd_Argv(1), false);
	}
}

void Cmd_ChallengeResponse_f(void)
{
	if (Cmd_Argc() != 2) {
		MSG_WriteByte(&sv_client->netchan.message, svc_print);
		MSG_WriteByte(&sv_client->netchan.message, PRINT_HIGH);
		MSG_WriteString(&sv_client->netchan.message, "Usage: challenge-response <response>\n");
		return;
	}

	if (!sv_client->login_challenge[0]) {
		MSG_WriteByte(&sv_client->netchan.message, svc_print);
		MSG_WriteByte(&sv_client->netchan.message, PRINT_HIGH);
		MSG_WriteString(&sv_client->netchan.message, "Please wait and try again\n");
		return;
	}

	Central_VerifyChallengeResponse(sv_client, sv_client->login_challenge, Cmd_Argv(1));
}

void Cmd_Logout_f(void)
{
	extern cvar_t sv_login;

	if (sv_client->logged_in_via_web) {
		if (sv_client->login[0]) {
			SV_BroadcastPrintf(PRINT_HIGH, "%s logged out\n", sv_client->name);
		}

		SV_Logout(sv_client);

		// 
		if (!(int)sv_login.value || ((int)sv_login.value == 1 && sv_client->spectator)) {
			sv_client->logged = -1;
		}
	}

	// If logins are mandatory then treat as disconnect
	if ((int)sv_login.value > 1 || ((int)sv_login.value == 1 && !sv_client->spectator)) {
		SV_DropClient(sv_client);
	}
}
// } Central login
#endif

void SV_DemoList_f(void);
void SV_DemoListRegex_f(void);
void SV_MVDInfo_f(void);
void SV_LastScores_f(void);

// { bans
void SV_Cmd_Ban_f(void);
void SV_Cmd_Banip_f(void);
void SV_Cmd_Banremove_f(void);
// } bans

// { qtv
void Cmd_Qtvusers_f (void);
// }

// { cheats
void SV_God_f (void);
void SV_Give_f (void);
void SV_Noclip_f (void);
void SV_Fly_f (void);
// }

#if defined(SERVERONLY) && defined(WWW_INTEGRATION)
// { central login
void Cmd_Login_f(void);
void Cmd_Logout_f(void);
void Cmd_ChallengeResponse_f(void);
// }
#endif

typedef struct
{
	char	*name;
	void	(*func) (void);
	qbool	overrideable;
}
ucmd_t;


static ucmd_t ucmds[] =
{
	{"new", Cmd_New_f, false},
	{"modellist", Cmd_Modellist_f, false},
	{"soundlist", Cmd_Soundlist_f, false},
	{"prespawn", Cmd_PreSpawn_f, false},
	{"spawn", Cmd_Spawn_f, false},
	{"begin", Cmd_Begin_f, false},

	{"drop", Cmd_Drop_f, false},
	{"pings", Cmd_Pings_f, false},

	// issued by hand at client consoles
	{"rate", Cmd_Rate_f, true},
	{"kill", Cmd_Kill_f, true},
	{"pause", Cmd_Pause_f, true},

	{"say", Cmd_Say_f, true},
	{"say_team", Cmd_Say_Team_f, true},

	{"setinfo", Cmd_SetInfo_f, false},

	{"serverinfo", Cmd_ShowServerinfo_f, false},

	{"download", Cmd_Download_f, false},
	{"nextdl", Cmd_NextDownload_f, false},
	{"dl", Cmd_DemoDownload_f, false},

	{"ptrack", Cmd_PTrack_f, false}, //ZOID - used with autocam

	//bliP: file upload ->
	{"techlogin", Cmd_TechLogin_f, false},
	{"upload", Cmd_Upload_f, false},
	//<-

	{"snap", Cmd_NoSnap_f, false},
	{"stopdownload", Cmd_StopDownload_f, false},
	{"stopdl", Cmd_StopDownload_f, false},
	{"dlist", SV_DemoList_f, false},
	{"dlistr", SV_DemoListRegex_f, false},
	{"dlistregex", SV_DemoListRegex_f, false},
	{"demolist", SV_DemoList_f, false},
	{"demolistr", SV_DemoListRegex_f, false},
	{"demolistregex", SV_DemoListRegex_f, false},
	{"demoinfo", SV_MVDInfo_f, false},
	{"lastscores", SV_LastScores_f, false},
	{"minping", Cmd_MinPing_f, true},
	{"airstep", Cmd_AirStep_f, true},
	{"maps", Cmd_ShowMapsList_f, true},
	{"ban", SV_Cmd_Ban_f, true}, // internal server ban support
	{"banip", SV_Cmd_Banip_f, true}, // internal server ban support
	{"banrem", SV_Cmd_Banremove_f, true}, // internal server ban support

	{"join", Cmd_Join_f, true},
	{"observe", Cmd_Observe_f, true},

	{"qtvusers", Cmd_Qtvusers_f, true},

	// cheat commands
	{"god", SV_God_f, true},
	{"give", SV_Give_f, true},
	{"noclip", SV_Noclip_f, true},
	{"fly", SV_Fly_f, true},

#ifdef FTE_PEXT2_VOICECHAT
	{"voicetarg", SV_Voice_Target_f, false},
	{"vignore", SV_Voice_Ignore_f, false},	/*ignore/mute specific player*/
	{"muteall", SV_Voice_MuteAll_f, false},	/*disables*/
	{"unmuteall", SV_Voice_UnmuteAll_f, false}, /*reenables*/
#endif

	{"pext", Cmd_PEXT_f, false}, // user reply with supported protocol extensions.

#if defined(SERVERONLY) && defined(WWW_INTEGRATION)
	{"login", Cmd_Login_f, false},
	{"login-response", Cmd_ChallengeResponse_f, false},
	{"logout", Cmd_Logout_f, false},
#endif

	{NULL, NULL}
};

static qbool SV_ExecutePRCommand (void)
{
	pr_global_struct->time = sv.time;
	pr_global_struct->self = EDICT_TO_PROG(sv_player);
	return PR_ClientCmd();
}

/*
==================
SV_ExecuteUserCommand
==================
*/
static void SV_ExecuteUserCommand (char *s)
{
	ucmd_t *u;

	Cmd_TokenizeString (s);
	sv_player = sv_client->edict;

	SV_BeginRedirect (RD_CLIENT);

	for (u=ucmds ; u->name ; u++) {
		if (!strcmp (Cmd_Argv(0), u->name) ) {
			if (!u->overrideable) {
				u->func();
				goto out;
			}
			break;
		}
	}

	if (SV_ExecutePRCommand())
		goto out;

	if (u->name)
		u->func();	
	else
		Con_Printf("Bad user command: %s\n", Cmd_Argv(0));

out:
	SV_EndRedirect ();
}

/*
===========================================================================

USER CMD EXECUTION

===========================================================================
*/

/*
====================
AddLinksToPmove

====================
*/
static void AddLinksToPmove ( areanode_t *node )
{
	link_t		*l, *next;
	edict_t		*check;
	int 		pl;
	int 		i;
	physent_t	*pe;
	vec3_t		pmove_mins, pmove_maxs;

	for (i=0 ; i<3 ; i++)
	{
		pmove_mins[i] = pmove.origin[i] - 256;
		pmove_maxs[i] = pmove.origin[i] + 256;
	}

	pl = EDICT_TO_PROG(sv_player);

	// touch linked edicts
	for (l = node->solid_edicts.next ; l != &node->solid_edicts ; l = next)
	{
		next = l->next;
		check = EDICT_FROM_AREA(l);

		if (check->v->owner == pl)
			continue;		// player's own missile
		if (check->v->solid == SOLID_BSP
				|| check->v->solid == SOLID_BBOX
				|| check->v->solid == SOLID_SLIDEBOX)
		{
			if (check == sv_player)
				continue;

			for (i=0 ; i<3 ; i++)
				if (check->v->absmin[i] > pmove_maxs[i]
				|| check->v->absmax[i] < pmove_mins[i])
					break;
			if (i != 3)
				continue;
			if (pmove.numphysent == MAX_PHYSENTS)
				return;
			pe = &pmove.physents[pmove.numphysent];
			pmove.numphysent++;

			VectorCopy (check->v->origin, pe->origin);
			pe->info = NUM_FOR_EDICT(check);
			if (check->v->solid == SOLID_BSP) {
				if ((unsigned)check->v->modelindex >= MAX_MODELS)
					SV_Error ("AddLinksToPmove: check->v->modelindex >= MAX_MODELS");
				pe->model = sv.models[(int)(check->v->modelindex)];
				if (!pe->model)
					SV_Error ("SOLID_BSP with a non-bsp model");
			}
			else
			{
				pe->model = NULL;
				VectorCopy (check->v->mins, pe->mins);
				VectorCopy (check->v->maxs, pe->maxs);
			}
		}
	}

	// recurse down both sides
	if (node->axis == -1)
		return;

	if ( pmove_maxs[node->axis] > node->dist )
		AddLinksToPmove ( node->children[0] );
	if ( pmove_mins[node->axis] < node->dist )
		AddLinksToPmove ( node->children[1] );
}

int SV_PMTypeForClient (client_t *cl)
{
	if (cl->edict->v->movetype == MOVETYPE_NOCLIP) {
		if (cl->extensions & Z_EXT_PM_TYPE_NEW)
			return PM_SPECTATOR;
		return PM_OLD_SPECTATOR;
	}

	if (cl->edict->v->movetype == MOVETYPE_FLY)
		return PM_FLY;

	if (cl->edict->v->movetype == MOVETYPE_NONE)
		return PM_NONE;

	if (cl->edict->v->movetype == MOVETYPE_LOCK)
		return PM_LOCK;

	if (cl->edict->v->health <= 0)
		return PM_DEAD;

	return PM_NORMAL;
}

/*
===========
SV_PreRunCmd
===========
Done before running a player command.  Clears the touch array
*/
static byte playertouch[(MAX_EDICTS+7)/8];

void SV_PreRunCmd(void)
{
	memset(playertouch, 0, sizeof(playertouch));
}

/*
===========
SV_RunCmd
===========
*/
void SV_RunCmd (usercmd_t *ucmd, qbool inside, qbool second_attempt) //bliP: 24/9
{
	int i, n;
	vec3_t originalvel, offset;
	qbool onground;
	//bliP: 24/9 anti speed ->
	int tmp_time;
	int blocked;

	if (!inside && (int)sv_speedcheck.value
#ifdef USE_PR2
		&& !sv_client->isBot
#endif
	)
	{
		/* AM101 method */
		tmp_time = Q_rint((realtime - sv_client->last_check) * 1000); // ie. Old 'timepassed'
		if (tmp_time)
		{
			if (ucmd->msec > tmp_time)
			{
				tmp_time += sv_client->msecs; // use accumulated msecs
				if (ucmd->msec > tmp_time)
				{ // If still over...
					ucmd->msec = tmp_time;
					sv_client->msecs = 0;
				}
				else
				{
					sv_client->msecs = tmp_time - ucmd->msec; // readjust to leftovers
				}
			}
			else
			{
				// Add up extra msecs
				sv_client->msecs += (tmp_time - ucmd->msec);
			}
		}

		sv_client->last_check = realtime;

		/* Cap it */
		if (sv_client->msecs > 500)
			sv_client->msecs = 500;
		else if (sv_client->msecs < 0)
			sv_client->msecs = 0;
	}
	//<-
	cmd = *ucmd;

	// chop up very long command
	if (cmd.msec > 50)
	{
		int oldmsec;
		oldmsec = ucmd->msec;
		cmd.msec = oldmsec/2;
		SV_RunCmd (&cmd, true, second_attempt);
		cmd.msec = oldmsec/2;
		cmd.impulse = 0;
		SV_RunCmd (&cmd, true, second_attempt);
		return;
	}

	// copy humans' intentions to progs
	sv_player->v->button0 = ucmd->buttons & 1;
	sv_player->v->button2 = (ucmd->buttons & 2) >> 1;
	sv_player->v->button1 = (ucmd->buttons & 4) >> 2;
	if (ucmd->impulse)
		sv_player->v->impulse = ucmd->impulse;
	if (fofs_movement) {
		EdictFieldVector(sv_player, fofs_movement)[0] = ucmd->forwardmove;
		EdictFieldVector(sv_player, fofs_movement)[1] = ucmd->sidemove;
		EdictFieldVector(sv_player, fofs_movement)[2] = ucmd->upmove;
	}
	// bliP: cuff
	if (sv_client->cuff_time > curtime)
		sv_player->v->button0 = sv_player->v->impulse = 0;
	//<-

	// clamp view angles
	ucmd->angles[PITCH] = bound(sv_minpitch.value, ucmd->angles[PITCH], sv_maxpitch.value);
	if (!sv_player->v->fixangle && ! second_attempt)
		VectorCopy (ucmd->angles, sv_player->v->v_angle);

	// model angles
	// show 1/3 the pitch angle and all the roll angle
	if (sv_player->v->health > 0)
	{
		if (!sv_player->v->fixangle)
		{
			sv_player->v->angles[PITCH] = -sv_player->v->v_angle[PITCH]/3;
			sv_player->v->angles[YAW] = sv_player->v->v_angle[YAW];
		}
		sv_player->v->angles[ROLL] = 0;
	}

	sv_frametime = ucmd->msec * 0.001;
	if (sv_frametime > 0.1)
		sv_frametime = 0.1;

	// Don't run think function twice...
	if (!sv_client->spectator && !second_attempt)
	{
		vec3_t	oldvelocity;
		float	old_teleport_time;

		VectorCopy (sv_player->v->velocity, originalvel);
		onground = (int) sv_player->v->flags & FL_ONGROUND;

		VectorCopy (sv_player->v->velocity, oldvelocity);
		old_teleport_time = sv_player->v->teleport_time;

		PR_GLOBAL(frametime) = sv_frametime;
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(sv_player);
		PR_GameClientPreThink(0);

		if (pr_nqprogs)
		{
			sv_player->v->teleport_time = old_teleport_time;
			VectorCopy (oldvelocity, sv_player->v->velocity);
		}

		if ( onground && originalvel[2] < 0 && sv_player->v->velocity[2] == 0 &&
		     originalvel[0] == sv_player->v->velocity[0] &&
		     originalvel[1] == sv_player->v->velocity[1] )
		{
			// don't let KTeams mess with physics
			sv_player->v->velocity[2] = originalvel[2];
		}

		SV_RunThink (sv_player);
	}

	// copy player state to pmove
	VectorSubtract (sv_player->v->mins, player_mins, offset);
	VectorAdd (sv_player->v->origin, offset, pmove.origin);
	VectorCopy (sv_player->v->velocity, pmove.velocity);
	VectorCopy (sv_player->v->v_angle, pmove.angles);
	pmove.waterjumptime = sv_player->v->teleport_time;
	pmove.cmd = *ucmd;
	pmove.pm_type = SV_PMTypeForClient (sv_client);
	pmove.onground = ((int)sv_player->v->flags & FL_ONGROUND) != 0;
	pmove.jump_held = sv_client->jump_held;
	pmove.jump_msec = 0;
	
	// let KTeams "broken ankle" code work
	if (
#if 0
FIXME
	PR_GetEdictFieldValue(sv_player, "brokenankle")
	&&
#endif
	(pmove.velocity[2] == -270) && (pmove.cmd.buttons & BUTTON_JUMP))
		pmove.jump_held = true;

	// build physent list
	pmove.numphysent = 1;
	pmove.physents[0].model = sv.worldmodel;
	AddLinksToPmove ( sv_areanodes );

	// fill in movevars
	movevars.entgravity = sv_client->entgravity;
	movevars.maxspeed = sv_client->maxspeed;
	movevars.bunnyspeedcap = pm_bunnyspeedcap.value;
	movevars.ktjump = pm_ktjump.value;
	movevars.slidefix = ((int)pm_slidefix.value != 0);
	movevars.airstep = ((int)pm_airstep.value != 0);
	movevars.pground = ((int)pm_pground.value != 0);
	movevars.rampjump = ((int)pm_rampjump.value != 0);

	// do the move
	blocked = PM_PlayerMove ();

#ifdef USE_PR2
	// This is a temporary hack for Frogbots, who adjust after bumping into things
	// Better would be to provide a way to simulate a move command, but at least this doesn't require API change
	if (blocked && !second_attempt && sv_client->isBot && sv_player->v->blocked)
	{
		pr_global_struct->self = EDICT_TO_PROG(sv_player);

		// Don't store in the bot's entity as we will run this again
		VectorSubtract (pmove.origin, offset, pr_global_struct->trace_endpos);
		VectorCopy (pmove.velocity, pr_global_struct->trace_plane_normal);
		if (pmove.onground)
		{
			pr_global_struct->trace_allsolid = (int) sv_player->v->flags | FL_ONGROUND;
			pr_global_struct->trace_ent = EDICT_TO_PROG(EDICT_NUM(pmove.physents[pmove.groundent].info));
		} else {
			pr_global_struct->trace_allsolid = (int) sv_player->v->flags & ~FL_ONGROUND;
		}

		// Give the mod a chance to replace the command
		PR_EdictBlocked (sv_player->v->blocked);

		// Run the command again
		SV_RunCmd (ucmd, false, true);
		return;
	}
#endif

	// get player state back out of pmove
	sv_client->jump_held = pmove.jump_held;
	sv_player->v->teleport_time = pmove.waterjumptime;
	if (pr_nqprogs)
		sv_player->v->flags = ((int)sv_player->v->flags & ~FL_WATERJUMP) | (pmove.waterjumptime ? FL_WATERJUMP : 0);
	sv_player->v->waterlevel = pmove.waterlevel;
	sv_player->v->watertype = pmove.watertype;
	if (pmove.onground)
	{
		sv_player->v->flags = (int) sv_player->v->flags | FL_ONGROUND;
		sv_player->v->groundentity = EDICT_TO_PROG(EDICT_NUM(pmove.physents[pmove.groundent].info));
	} else {
		sv_player->v->flags = (int) sv_player->v->flags & ~FL_ONGROUND;
	}

	VectorSubtract (pmove.origin, offset, sv_player->v->origin);
	VectorCopy (pmove.velocity, sv_player->v->velocity);

	VectorCopy (pmove.angles, sv_player->v->v_angle);

	if (sv_player->v->solid != SOLID_NOT)
	{
		// link into place and touch triggers
		SV_LinkEdict (sv_player, true);

		// touch other objects
		for (i=0 ; i<pmove.numtouch ; i++)
		{
			edict_t *ent;
			n = pmove.physents[pmove.touchindex[i]].info;
			ent = EDICT_NUM(n);
			if (!ent->v->touch || (playertouch[n/8]&(1<<(n%8))))
				continue;
			pr_global_struct->self = EDICT_TO_PROG(ent);
			pr_global_struct->other = EDICT_TO_PROG(sv_player);
			PR_EdictTouch (ent->v->touch);
			playertouch[n/8] |= 1 << (n%8);
		}
	}
}

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
typedef struct ssw_info_s {
	int impulse_set;
	int hide_weapon;
	int best_weapon;
	qbool hiding;
	qbool firing;
} ssw_info_t;

// Ranks best weapon for player
void SV_ServerSideWeaponRank(client_t* client, int* best_weapon, int* best_impulse, int* hide_weapon, int* hide_impulse)
{
	entvars_t* ent = client->edict->v;
	int i;
	int items = (int)ent->items;
	int weapon = (int)ent->weapon;
	int shells = (int)ent->ammo_shells;
	int nails = (int)ent->ammo_nails;
	int rockets = (int)ent->ammo_rockets;
	int cells = (int)ent->ammo_cells;

	if (client->weaponswitch_hide == 2 && shells > 0) {
		*hide_weapon = IT_SHOTGUN;
		*hide_impulse = 2;
	}
	else if (client->weaponswitch_hide == 1) {
		*hide_weapon = IT_AXE;
		*hide_impulse = 1;
	}
	else {
		*hide_weapon = 0;
		*hide_impulse = 0;
	}

	// Default to staying on the current weapon, regardless of ammo
	*best_weapon = weapon;
	*best_impulse = 0;

	for (i = 0; i < sizeof(client->weaponswitch_priority) / sizeof(client->weaponswitch_priority[0]); ++i) {
		switch (client->weaponswitch_priority[i]) {
			case 0:
				// end of list
				return;
			case 1:
				if (items & IT_AXE) {
					*best_weapon = IT_AXE;
					*best_impulse = 1;
					return;
				}
				break;
			case 2:
				if ((items & IT_SHOTGUN) && shells > 0) {
					*best_weapon = IT_SHOTGUN;
					*best_impulse = 2;
					return;
				}
				break;
			case 3:
				if ((items & IT_SUPER_SHOTGUN) && shells > 1) {
					*best_weapon = IT_SUPER_SHOTGUN;
					*best_impulse = 3;
					return;
				}
				break;
			case 4:
				if ((items & IT_NAILGUN) && nails > 0) {
					*best_weapon = IT_NAILGUN;
					*best_impulse = 4;
					return;
				}
				break;
			case 5:
				if ((items & IT_SUPER_NAILGUN) && nails > 1) {
					*best_weapon = IT_SUPER_NAILGUN;
					*best_impulse = 5;
					return;
				}
				break;
			case 6:
				if ((items & IT_GRENADE_LAUNCHER) && rockets > 0) {
					*best_weapon = IT_GRENADE_LAUNCHER;
					*best_impulse = 6;
					return;
				}
				break;
			case 7:
				if ((items & IT_ROCKET_LAUNCHER) && rockets > 0) {
					*best_weapon = IT_ROCKET_LAUNCHER;
					*best_impulse = 7;
					return;
				}
				break;
			case 8:
				if ((items & IT_LIGHTNING) && cells > 0) {
					*best_weapon = IT_LIGHTNING;
					*best_impulse = 8;
					return;
				}
				break;
		}
	}

	return;
}

static void SV_NotifyUserOfBestWeapon(client_t* sv_client, int new_impulse)
{
	char stuffcmd_buffer[64];

	strlcpy(stuffcmd_buffer, va("//mvdsv_ssw %d %d\n", sv_client->weaponswitch_sequence_set, new_impulse), sizeof(stuffcmd_buffer));

	ClientReliableWrite_Begin(sv_client, svc_stufftext, 2 + strlen(stuffcmd_buffer));
	ClientReliableWrite_String(sv_client, stuffcmd_buffer);
}

static void SV_ExecuteServerSideWeaponForgetOrder(client_t* sv_client, int best_impulse, int hide_impulse)
{
	char new_wrank[16] = { 0 };

	SV_DebugServerSideWeaponScript(sv_client, best_impulse);
	SV_NotifyUserOfBestWeapon(sv_client, best_impulse);

	// Over-write the list sent with the result
	{
		if (Info_Get(&sv_client->_userinfo_ctx_, "dev")[0] == '1') {
			SV_ClientPrintf(sv_client, PRINT_HIGH, "Best: %d, forgetorder enabled\n", best_impulse);
		}
	}
	sv_client->weaponswitch_priority[0] = best_impulse;
	sv_client->weaponswitch_priority[1] = (hide_impulse == 1 || best_impulse == 2 ? 1 : 2);
	sv_client->weaponswitch_priority[2] = (sv_client->weaponswitch_priority[1] != 1 ? 1 : 0);
	sv_client->weaponswitch_priority[3] = 0;

	new_wrank[0] = '0' + best_impulse;
	if (hide_impulse) {
		new_wrank[1] = '0' + hide_impulse;
		if (hide_impulse == 2) {
			new_wrank[2] = '1';
		}
	}
	else {
		new_wrank[1] = '2';
		new_wrank[2] = '1';
	}

	SV_UserSetWeaponRank(sv_client, new_wrank);
}

static void SV_ExecuteServerSideWeaponHideOnDeath(client_t* sv_client, int hide_impulse, int hide_weapon)
{
	char new_wrank[16] = { 0 };

	if (sv_client->edict->v->health > 0.0f || !sv_client->weaponswitch_hide_on_death) {
		return;
	}

	// might not have general hiding enabled...
	hide_impulse = (hide_impulse == 1 ? 1 : 2);
	hide_weapon = (hide_impulse == 1 ? IT_AXE : IT_SHOTGUN);
	new_wrank[0] = (hide_impulse == 1 ? '1' : '2');
	new_wrank[1] = (hide_impulse == 1 ? '0' : '1');
	sv_client->weaponswitch_priority[0] = (hide_impulse == 1 ? 1 : 2);
	sv_client->weaponswitch_priority[1] = (hide_impulse == 1 ? 1 : 2);
	sv_client->weaponswitch_priority[2] = 0;

	SV_DebugServerSideWeaponScript(sv_client, hide_impulse);
	SV_NotifyUserOfBestWeapon(sv_client, hide_impulse);
	SV_UserSetWeaponRank(sv_client, new_wrank);

	if (Info_Get(&sv_client->_userinfo_ctx_, "dev")[0] == '1' && sv_client->edict->v->weapon != hide_weapon) {
		SV_ClientPrintf(sv_client, PRINT_HIGH, "Hiding on death: %d\n", hide_impulse);
	}
}

static void SV_ServerSideWeaponLogic_PrePostThink(client_t* sv_client, ssw_info_t* ssw)
{
	entvars_t* ent = sv_client->edict->v;
	qbool dev_trace = (Info_Get(&sv_client->_userinfo_ctx_, "dev")[0] == '1');

	ssw->firing = (ent->button0 != 0);

	if ((sv_client->mvdprotocolextensions1 & MVD_PEXT1_SERVERSIDEWEAPON) && sv_client->weaponswitch_enabled) {
		int best_impulse, hide_impulse;
		qbool switch_to_best_weapon = false;
		int mode = sv_client->weaponswitch_mode;

		// modes: 0 immediately choose best, 1 preselect (wait until fire), 2 immediate if firing
		// mode 2 = "preselect(1) when not holding +attack, else immediate(0)"
		if (mode == 2) {
			mode = (ssw->firing ? 0 : 1);
		}
		switch_to_best_weapon = sv_client->weaponswitch_pending && (mode == 0 || ssw->firing) && (ent->health >= 1.0f);

		SV_ServerSideWeaponRank(sv_client, &ssw->best_weapon, &best_impulse, &ssw->hide_weapon, &hide_impulse);

		ssw->hiding = (sv_client->weaponswitch_wasfiring && !ssw->firing && hide_impulse);
		sv_client->weaponswitch_wasfiring |= ssw->firing;

		if (switch_to_best_weapon && sv_client->weaponswitch_forgetorder) {
			SV_ExecuteServerSideWeaponForgetOrder(sv_client, best_impulse, hide_impulse);
		}
		SV_ExecuteServerSideWeaponHideOnDeath(sv_client, hide_impulse, ssw->hide_weapon);

		if (!ent->impulse) {
			if (switch_to_best_weapon) {
				if (best_impulse && ent->weapon != ssw->best_weapon) {
					SV_DebugServerSideWeaponScript(sv_client, best_impulse);

					if (dev_trace) {
						SV_ClientPrintf(sv_client, PRINT_HIGH, "Switching to best weapon: %d\n", best_impulse);
					}

					ent->impulse = best_impulse;
					ssw->impulse_set = 2;
				}
				else {
					sv_client->weaponswitch_pending = false;
				}
			}
			else if (ssw->hiding) {
				if (ent->weapon != ssw->hide_weapon) {
					if (dev_trace) {
						SV_ClientPrintf(sv_client, PRINT_HIGH, "Hiding: %d\n", hide_impulse);
					}
					ent->impulse = hide_impulse;
					ssw->impulse_set = 1;
				}
				else {
					sv_client->weaponswitch_pending = false;
				}
			}
		}
		else {
			if (dev_trace) {
				SV_ClientPrintf(sv_client, PRINT_HIGH, "Non-wp impulse: %f\n", ent->impulse);
			}
		}
		sv_client->weaponswitch_pending &= (ent->health >= 1.0f);
	}
}

static void SV_ServerSideWeaponLogic_PostPostThink(client_t* sv_client, ssw_info_t* ssw)
{
	entvars_t* ent = sv_client->edict->v;
	qbool dev_trace = (Info_Get(&sv_client->_userinfo_ctx_, "dev")[0] == '1');

	if (ssw->impulse_set) {
		qbool hide_failed = (ssw->impulse_set == 1 && ent->weapon != ssw->hide_weapon);
		qbool pickbest_failed = (ssw->impulse_set == 2 && ent->weapon != ssw->best_weapon);
		qbool failure = (hide_failed || pickbest_failed);

		ent->impulse = 0;

		if (dev_trace) {
			if (failure) {
				SV_ClientPrintf(sv_client, PRINT_HIGH, "... %s failed, will try again\n", ssw->impulse_set == 1 ? "hide" : "pickbest");
			}
			else {
				SV_ClientPrintf(sv_client, PRINT_HIGH, "... %s successful, stopping\n", ssw->impulse_set == 1 ? "hide" : "pickbest");
			}
		}

		sv_client->weaponswitch_pending &= failure;
	}
	if (ssw->hiding && ent->weapon == ssw->hide_weapon) {
		if (dev_trace) {
			SV_ClientPrintf(sv_client, PRINT_HIGH, "Hide successful\n");
		}
		sv_client->weaponswitch_wasfiring = false;
	}
	else if (!(ssw->hiding || ssw->firing)) {
		if (sv_client->weaponswitch_wasfiring && dev_trace) {
			SV_ClientPrintf(sv_client, PRINT_HIGH, "No longer firing...\n");
		}
		sv_client->weaponswitch_wasfiring = false;
	}
}
#endif

/*
===========
SV_PostRunCmd
===========
Done after running a player command.
*/
void SV_PostRunCmd(void)
{
	vec3_t originalvel;
	qbool onground;
	// run post-think
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	ssw_info_t ssw = { 0 };
#endif

	if (!sv_client->spectator)
	{
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
		SV_ServerSideWeaponLogic_PrePostThink(sv_client, &ssw);
#endif

		onground = (int) sv_player->v->flags & FL_ONGROUND;
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(sv_player);
		VectorCopy (sv_player->v->velocity, originalvel);
		PR_GameClientPostThink(0);

		if ( onground && originalvel[2] < 0 && sv_player->v->velocity[2] == 0
		&& originalvel[0] == sv_player->v->velocity[0]
		&& originalvel[1] == sv_player->v->velocity[1] ) {
			// don't let KTeams mess with physics
			sv_player->v->velocity[2] = originalvel[2];
		}

		if (pr_nqprogs)
			VectorCopy (originalvel, sv_player->v->velocity);

		if (pr_nqprogs)
			SV_RunNQNewmis ();
		else
			SV_RunNewmis ();

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
		SV_ServerSideWeaponLogic_PostPostThink(sv_client, &ssw);
#endif
	}
	else
	{
		pr_global_struct->time = sv.time;
		pr_global_struct->self = EDICT_TO_PROG(sv_player);
		PR_GameClientPostThink(1);
	}
}

/*
SV_UserSetWeaponRank
Sets wrank userinfo for mods to pick best weapon based on user's preferences
*/
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
static void SV_UserSetWeaponRank(client_t* cl, const char* new_wrank)
{
	char old_wrank[128] = { 0 };
	strlcpy(old_wrank, Info_Get(&cl->_userinfo_ctx_, "w_rank"), sizeof(old_wrank));
	if (strcmp(old_wrank, new_wrank)) {
		Info_Set(&cl->_userinfo_ctx_, "w_rank", new_wrank);
		ProcessUserInfoChange(cl, "w_rank", old_wrank);

		if (Info_Get(&cl->_userinfo_ctx_, "dev")[0] == '1') {
			SV_ClientPrintf(cl, PRINT_HIGH, "Setting new w_rank: %s\n", new_wrank);
		}
	}
}
#endif

// SV_RotateCmd
// Rotates client command so a high-ping player can better control direction as they exit teleporters on high-ping
void SV_RotateCmd(client_t* cl, usercmd_t* cmd_)
{
	if (cl->lastteleport_teleport) {
		static vec3_t up = { 0, 0, 1 };
		vec3_t direction = { cmd_->sidemove, cmd_->forwardmove, 0 };
		vec3_t result;

		RotatePointAroundVector(result, up, direction, cl->lastteleport_teleportyaw);

		cmd_->sidemove = result[0];
		cmd_->forwardmove = result[1];
	}
	else {
		cmd_->angles[YAW] = (cl->edict)->v->angles[YAW];
	}
}

/*
===================
SV_ExecuteClientMove

Run one or more client move commands (more than one if some
packets were dropped)
===================
*/
static void SV_ExecuteClientMove(client_t* cl, usercmd_t oldest, usercmd_t oldcmd, usercmd_t newcmd)
{
	int net_drop;
	int playernum = cl - svs.clients;

	if (sv.paused) {
		return;
	}

	SV_PreRunCmd();

	net_drop = cl->netchan.dropped;
	if (net_drop < 20) {
		while (net_drop > 2) {
			SV_DebugClientCommand(playernum, &cl->lastcmd, net_drop);
			SV_RunCmd(&cl->lastcmd, false, false);
			net_drop--;
		}
	}
	if (net_drop > 1) {
		SV_DebugClientCommand(playernum, &oldest, 2);
		SV_RunCmd(&oldest, false, false);
	}
	if (net_drop > 0) {
		SV_DebugClientCommand(playernum, &oldcmd, 1);
		SV_RunCmd(&oldcmd, false, false);
	}
	SV_DebugClientCommand(playernum, &newcmd, 0);
#ifdef MVD_PEXT1_SERVERSIDEWEAPON
	{
		// This is necessary to interrupt LG/SNG where the firing takes place inside animation frames
		if (sv_client->weaponswitch_enabled && sv_client->weaponswitch_pending && !sv_client->edict->v->impulse) {
			sv_client->edict->v->impulse = 255;
			SV_RunCmd(&newcmd, false, false);
			sv_client->edict->v->impulse = 0;
		}
		else {
			SV_RunCmd(&newcmd, false, false);
		}
	}
#else
	SV_RunCmd(&newcmd, false, false);
#endif

	SV_PostRunCmd();
}

#ifdef MVD_PEXT1_DEBUG_ANTILAG
/*
SV_DebugWriteServerAntilagPositions

Writes the position of clients, as rewound by antilag
*/
static void SV_DebugWriteServerAntilagPositions(client_t* cl, int present)
{
	mvdhidden_block_header_t header;
	mvdhidden_antilag_position_header_t antilag_header;
	int i;
	float target_time = cl->laggedents_time;

	header.type_id = mvdhidden_antilag_position;
	header.length = sizeof_mvdhidden_antilag_position_header_t + present * sizeof_mvdhidden_antilag_position_t;

	antilag_header.incoming_seq = LittleLong(cl->netchan.incoming_sequence);
	antilag_header.playernum = cl - svs.clients;
	antilag_header.players = present;
	antilag_header.server_time = LittleFloat(sv.time);
	antilag_header.target_time = LittleFloat(target_time);

	if (MVDWrite_HiddenBlockBegin(sizeof_mvdhidden_block_header_t_range0 + header.length)) {
		header.length = LittleLong(header.length);
		MVD_SZ_Write(&header.length, sizeof(header.length));
		MVD_SZ_Write(&header.type_id, sizeof(header.type_id));
		MVD_SZ_Write(&antilag_header.playernum, sizeof(antilag_header.playernum));
		MVD_SZ_Write(&antilag_header.players, sizeof(antilag_header.players));
		MVD_SZ_Write(&antilag_header.incoming_seq, sizeof(antilag_header.incoming_seq));
		MVD_SZ_Write(&antilag_header.server_time, sizeof(antilag_header.server_time));
		MVD_SZ_Write(&antilag_header.target_time, sizeof(antilag_header.target_time));
		for (i = 0; i < MAX_CLIENTS; i++) {
			if (cl->laggedents[i].present) {
				mvdhidden_antilag_position_t pos = { 0 };
				int j;

				pos.playernum = i;
#ifdef MVD_PEXT1_DEBUG
				if (debug_info.antilag_clients[i].present) {
					pos.playernum |= MVD_PEXT1_ANTILAG_CLIENTPOS;
					pos.msec = debug_info.antilag_clients[i].msec;
					pos.predmodel = debug_info.antilag_clients[i].model;
					VectorCopy(debug_info.antilag_clients[i].pos, pos.clientpos);
				}
#endif
				MVD_SZ_Write(&pos.playernum, sizeof(pos.playernum));
				for (j = 0; j < 3; ++j) {
					pos.pos[j] = LittleFloat(cl->laggedents[i].laggedpos[j]);
					MVD_SZ_Write(&pos.pos[j], sizeof(pos.pos[j]));
				}
				MVD_SZ_Write(&pos.msec, sizeof(pos.msec));
				MVD_SZ_Write(&pos.predmodel, sizeof(pos.predmodel));
				for (j = 0; j < 3; ++j) {
					pos.clientpos[j] = LittleFloat(pos.clientpos[j]);
					MVD_SZ_Write(&pos.clientpos[j], sizeof(pos.clientpos[j]));
				}
			}
		}
	}
}
#endif // MVD_PEXT1_DEBUG_ANTILAG

#ifdef MVD_PEXT1_DEBUG_WEAPON
static void SV_DebugWriteWeaponScript(byte playernum, qbool server_side, int items, byte shells, byte nails, byte rockets, byte cells, byte choice, const char* weaponlist)
{
	if (sv_debug_weapons.value >= 1) {
		mvdhidden_block_header_t header;

		// Write out immediately
		header.type_id = (server_side ? mvdhidden_usercmd_weapons_ss : mvdhidden_usercmd_weapons);
		header.length = LittleLong(10 + strlen(weaponlist) + 1);

		if (MVDWrite_HiddenBlockBegin(sizeof_mvdhidden_block_header_t_range0 + header.length)) {
			MVD_SZ_Write(&header.length, sizeof(header.length));
			MVD_SZ_Write(&header.type_id, sizeof(header.type_id));
			MVD_SZ_Write(&playernum, sizeof(playernum));
			MVD_SZ_Write(&items, sizeof(items));
			MVD_SZ_Write(&shells, sizeof(shells));
			MVD_SZ_Write(&nails, sizeof(nails));
			MVD_SZ_Write(&rockets, sizeof(rockets));
			MVD_SZ_Write(&cells, sizeof(cells));
			MVD_SZ_Write(&choice, sizeof(choice));
			MVD_SZ_Write(weaponlist, strlen(weaponlist) + 1);
		}
	}
}

static void SV_DebugClientSideWeaponScript(client_t* cl)
{
	byte playernum = cl - svs.clients;
	int items = LittleLong(MSG_ReadLong());
	byte shells = MSG_ReadByte();
	byte nails = MSG_ReadByte();
	byte rockets = MSG_ReadByte();
	byte cells = MSG_ReadByte();
	byte choice = MSG_ReadByte();
	const char* weaponlist = MSG_ReadString();

	SV_DebugWriteWeaponScript(playernum, false, items, shells, nails, rockets, cells, choice, weaponlist);
}

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
static void SV_DebugServerSideWeaponInstruction(client_t* cl)
{
	if (sv_debug_weapons.value >= 1) {
		mvdhidden_block_header_t header;

		// Write out immediately
		header.type_id = mvdhidden_usercmd_weapon_instruction;
		header.length = sizeof_mvdhidden_usercmd_weapon_instruction;

		if (MVDWrite_HiddenBlockBegin(sizeof_mvdhidden_block_header_t_range0 + header.length)) {
			byte playernum = cl - svs.clients;
			byte flags = 0;
			int sequence_set = cl->weaponswitch_sequence_set;
			int mode = cl->weaponswitch_mode;
			byte weaponlist[10] = { 0 };

			flags |= (cl->weaponswitch_pending ? MVDHIDDEN_SSWEAPON_PENDING : 0);
			flags |= (cl->weaponswitch_hide == 1 ? MVDHIDDEN_SSWEAPON_HIDE_AXE : (cl->weaponswitch_hide == 2 ? MVDHIDDEN_SSWEAPON_HIDE_SG : 0));
			flags |= (cl->weaponswitch_hide_on_death ? MVDHIDDEN_SSWEAPON_HIDEONDEATH : 0);
			flags |= (cl->weaponswitch_wasfiring ? MVDHIDDEN_SSWEAPON_WASFIRING : 0);
			flags |= (cl->weaponswitch_enabled ? MVDHIDDEN_SSWEAPON_ENABLED : 0);
			flags |= (cl->weaponswitch_forgetorder ? MVDHIDDEN_SSWEAPON_FORGETORDER : 0);

			memcpy(weaponlist, cl->weaponswitch_priority, min(10, sizeof(cl->weaponswitch_priority)));

			MVD_SZ_Write(&header.length, sizeof(header.length));
			MVD_SZ_Write(&header.type_id, sizeof(header.type_id));
			MVD_SZ_Write(&playernum, sizeof(playernum));
			MVD_SZ_Write(&flags, sizeof(flags));
			MVD_SZ_Write(&sequence_set, sizeof(sequence_set));
			MVD_SZ_Write(&mode, sizeof(mode));
			MVD_SZ_Write(weaponlist, sizeof(weaponlist));
		}
	}
}

static void SV_DebugServerSideWeaponScript(client_t* cl, int best_impulse)
{
	if (sv_debug_weapons.value >= 1) {
		char old_wrank[128] = { 0 };
		char encoded[128] = { 0 };
		char* w;
		char* o;
		entvars_t* ent = cl->edict->v;

		strlcpy(old_wrank, Info_Get(&cl->_userinfo_ctx_, "w_rank"), sizeof(old_wrank));

		w = old_wrank;
		o = encoded;
		while (*w) {
			*o = (*w - '0');
			++w;
			++o;
		}

		SV_DebugWriteWeaponScript(cl - svs.clients, true, ent->items, ent->ammo_shells, ent->ammo_nails, ent->ammo_rockets, ent->ammo_cells, best_impulse, encoded);
	}
}
#endif

#endif

/*
===================
SV_ExecuteClientMessage
 
The current net_message is parsed for the given client
===================
*/
void SV_ExecuteClientMessage (client_t *cl)
{
	int             c, i;
	char            *s;
	usercmd_t       oldest, oldcmd, newcmd;
	client_frame_t  *frame;
	vec3_t          o;
	qbool           move_issued = false; //only allow one move command
	int             checksumIndex;
	byte            checksum, calculatedChecksum;
	int             seq_hash;

#ifdef MVD_PEXT1_DEBUG
	int             antilag_players_present = 0;
#endif

	if (!Netchan_Process(&cl->netchan))
		return;
//	if (cl->state == cs_zombie) // FIXME
//		return; // FIXME

	// this is a valid, sequenced packet, so process it
	svs.stats.packets++;
	cl->send_message = true; // reply at end of frame
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	cl->download_chunks_perframe = 0;
#endif

	// calc ping time
	frame = &cl->frames[cl->netchan.incoming_acknowledged & UPDATE_MASK];
	frame->ping_time = curtime - frame->senttime;

	// update delay based on ping and sv_minping
	if (!cl->spectator && !sv.paused)
	{
		if (frame->ping_time * 1000 > sv_minping.value + 1)
			cl->delay -= 0.001;
		else if (frame->ping_time * 1000 < sv_minping.value)
			cl->delay += 0.001;

		cl->delay = bound(0, cl->delay, 1);
	}

	cl->laggedents_count = 0; // init at least this
	cl->laggedents_frac = 1; // sv_antilag_frac.value;

	if (sv_antilag.value)
	{
//#pragma msg("FIXME: make antilag optionally support non-player ents too")

#define MAX_PREDICTION 0.02
#define MAX_EXTRAPOLATE 0.02

		double target_time, max_physfps = sv_maxfps.value;

		if (max_physfps < 20 || max_physfps > 1000)
			max_physfps = 77.0;

		if (sv_antilag_no_pred.value) {
			target_time = frame->sv_time;
		} else {
			// try to figure out what time client is currently predicting, basically this is just 6.5ms with 13ms ping and 13.5ms with higher
			// might be off with different max_physfps values
			target_time = min(frame->sv_time + (frame->ping_time < MAX_PREDICTION ? 1/max_physfps : MAX_PREDICTION), sv.time);
		}

		for (i = 0; i < MAX_CLIENTS; i++)
		{
			client_t *target_cl = &svs.clients[i];
			antilag_position_t *base, *interpolate = NULL;
			double factor;
			int j;

			// don't hit dead players
			if (target_cl->state != cs_spawned || target_cl->antilag_position_next == 0 || (target_cl->spectator == 0 && target_cl->edict->v->health <= 0)) {
				cl->laggedents[i].present = false;
				continue;
			}

			cl->laggedents[i].present = true;
			++antilag_players_present;

			// target player's movement commands are late, extrapolate his position based on velocity
			if (target_time > target_cl->localtime) {
				VectorMA(target_cl->edict->v->origin, min(target_time - target_cl->localtime, MAX_EXTRAPOLATE), target_cl->edict->v->velocity, cl->laggedents[i].laggedpos);
				continue;
			}

			// we have only one antilagged position, use that
			if (target_cl->antilag_position_next == 1) {
				VectorCopy(target_cl->antilag_positions[0].origin, cl->laggedents[i].laggedpos);
				continue;
			}

			// find the position before target time (base) and the one after that (interpolate)
			for (j = target_cl->antilag_position_next - 2; j > target_cl->antilag_position_next - 1 - MAX_ANTILAG_POSITIONS && j >= 0; j--) {
				if (target_cl->antilag_positions[j % MAX_ANTILAG_POSITIONS].localtime < target_time)
					break;
			}

			base = &target_cl->antilag_positions[j % MAX_ANTILAG_POSITIONS];
			interpolate = &target_cl->antilag_positions[(j + 1) % MAX_ANTILAG_POSITIONS];

			// we have two positions, just interpolate between them
			factor = (target_time - base->localtime) / (interpolate->localtime - base->localtime);
			VectorInterpolate(base->origin, factor, interpolate->origin, cl->laggedents[i].laggedpos);
		}

		cl->laggedents_count = MAX_CLIENTS; // FIXME: well, FTE do it a bit different way...
		cl->laggedents_time = target_time;
	}

	// make sure the reply sequence number matches the incoming
	// sequence number
	if (cl->netchan.incoming_sequence >= cl->netchan.outgoing_sequence)
		cl->netchan.outgoing_sequence = cl->netchan.incoming_sequence;
	else
		cl->send_message = false;	// don't reply, sequences have slipped

	// save time for ping calculations
	cl->frames[cl->netchan.outgoing_sequence & UPDATE_MASK].senttime = curtime;
	cl->frames[cl->netchan.outgoing_sequence & UPDATE_MASK].ping_time = -1;

	sv_client = cl;
	sv_player = sv_client->edict;

	seq_hash = cl->netchan.incoming_sequence;

	// mark time so clients will know how much to predict
	// other players
	cl->localtime = sv.time;
	cl->delta_sequence = -1;	// no delta unless requested
#ifdef MVD_PEXT1_DEBUG
	memset(&debug_info, 0, sizeof(debug_info));
#endif
	while (1)
	{
		if (msg_badread)
		{
			Con_Printf ("SV_ReadClientMessage: badread\n");
			SV_DropClient (cl);
			return;
		}

		c = MSG_ReadByte ();
		if (c == -1)
			break;

		switch (c)
		{
		default:
			Con_Printf ("SV_ReadClientMessage: unknown command char\n");
			SV_DropClient (cl);
			return;

		case clc_nop:
			break;

		case clc_delta:
			cl->delta_sequence = MSG_ReadByte ();
			break;

#ifdef MVD_PEXT1_DEBUG
		case clc_mvd_debug:
		{
			byte type = MSG_ReadByte();
			if (type == clc_mvd_debug_type_antilag) {
				int players = MSG_ReadByte();

				for (i = 0; i < players; ++i) {
					int num = MSG_ReadByte();
					int msec = MSG_ReadByte();
					int model = MSG_ReadByte();
					float x = LittleFloat(MSG_ReadFloat());
					float y = LittleFloat(MSG_ReadFloat());
					float z = LittleFloat(MSG_ReadFloat());

					if (num >= 0 && num < MAX_CLIENTS) {
						debug_info.antilag_clients[num].present = true;
						debug_info.antilag_clients[num].model = model;
						debug_info.antilag_clients[num].msec = msec;
						VectorSet(debug_info.antilag_clients[num].pos, x, y, z);
					}
				}
			}
			else if (type == clc_mvd_debug_type_weapon) {
				SV_DebugClientSideWeaponScript(cl);
			}
			else {
				Con_Printf("SV_ReadClientMessage: unknown debug message type %d\n", type);
				SV_DropClient(cl);
			}
			break;
		}
#endif

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
		case clc_mvd_weapon:
		{
			if (!SV_ClientExtensionWeaponSwitch(cl)) {
				Con_Printf("SV_ClientExtensionWeaponSwitch: corrupt data string\n");
				SV_DropClient(cl);
				return;
			}
			break;
		}
#endif

		case clc_move:
			if (move_issued)
				return;		// someone is trying to cheat...

			move_issued = true;

			checksumIndex = MSG_GetReadCount();
			checksum = (byte)MSG_ReadByte ();

			// read loss percentage
			//bliP: file percent ->
			cl->lossage = MSG_ReadByte();
			if (cl->file_percent)
				cl->lossage = cl->file_percent;

			/*if (cl->state < cs_spawned && cl->download != NULL) {
				if (cl->downloadsize)
					cl->lossage = cl->downloadcount*100/cl->downloadsize;
				else
					cl->lossage = 100;
			}*/
			//<-

#ifndef SERVERONLY
			MSG_ReadDeltaUsercmd (&nullcmd, &oldest, PROTOCOL_VERSION);
			MSG_ReadDeltaUsercmd (&oldest, &oldcmd, PROTOCOL_VERSION);
			MSG_ReadDeltaUsercmd (&oldcmd, &newcmd, PROTOCOL_VERSION);
#else
			MSG_ReadDeltaUsercmd (&nullcmd, &oldest);
			MSG_ReadDeltaUsercmd (&oldest, &oldcmd);
			MSG_ReadDeltaUsercmd (&oldcmd, &newcmd);
#endif

			if ( cl->state != cs_spawned )
				break;

#ifdef CHAT_ICON_EXPERIMENTAL
			s = Info_Get(&cl->_userinfoshort_ctx_, "chat");
			if ( s[0] ) {
// allow movement while in console
//				newcmd.forwardmove = newcmd.sidemove = newcmd.upmove = 0;
				newcmd.buttons &= BUTTON_JUMP; // only jump button allowed while in console

// somemods uses impulses for commands, so let them use
//				newcmd.impulse = 0;
			}
#endif

			// if the checksum fails, ignore the rest of the packet
			calculatedChecksum = COM_BlockSequenceCRCByte(
				net_message.data + checksumIndex + 1,
				MSG_GetReadCount() - checksumIndex - 1,
				seq_hash
			);

			if (calculatedChecksum != checksum)
			{
				Con_DPrintf ("Failed command checksum for %s(%d) (%d != %d)\n", cl->name, cl->netchan.incoming_sequence, checksum, calculatedChecksum);
				return;
			}

#ifdef MVD_PEXT1_HIGHLAGTELEPORT
			if (cl->mvdprotocolextensions1 & MVD_PEXT1_HIGHLAGTELEPORT) {
				if (cl->lastteleport_outgoingseq && cl->netchan.incoming_acknowledged < cl->lastteleport_outgoingseq) {
					if (cl->netchan.incoming_sequence - 2 > cl->lastteleport_incomingseq) {
						SV_RotateCmd(cl, &oldest);
					}
					if (cl->netchan.incoming_sequence - 1 > cl->lastteleport_incomingseq) {
						SV_RotateCmd(cl, &oldcmd);
					}
					SV_RotateCmd(cl, &newcmd);
				}
				else {
					cl->lastteleport_outgoingseq = 0;
				}
			}
#endif

			SV_ExecuteClientMove(cl, oldest, oldcmd, newcmd);

			cl->lastcmd = newcmd;
			cl->lastcmd.buttons = 0; // avoid multiple fires on lag

			if (sv_antilag.value) {
				if (cl->antilag_position_next == 0 || cl->antilag_positions[(cl->antilag_position_next - 1) % MAX_ANTILAG_POSITIONS].localtime < cl->localtime) {
					cl->antilag_positions[cl->antilag_position_next % MAX_ANTILAG_POSITIONS].localtime = cl->localtime;
					VectorCopy(cl->edict->v->origin, cl->antilag_positions[cl->antilag_position_next % MAX_ANTILAG_POSITIONS].origin);
					cl->antilag_position_next++;
				}
			} else {
				cl->antilag_position_next = 0;
			}
			break;

		case clc_stringcmd:
			s = MSG_ReadString ();
			s[1023] = 0;
			SV_ExecuteUserCommand (s);
			break;

		case clc_tmove:
			o[0] = MSG_ReadCoord();
			o[1] = MSG_ReadCoord();
			o[2] = MSG_ReadCoord();
			// only allowed by spectators
			if (sv_client->spectator)
			{
				VectorCopy(o, sv_player->v->origin);
				SV_LinkEdict(sv_player, false);
			}
			break;

		case clc_upload:
			SV_NextUpload();
			break;

#ifdef FTE_PEXT2_VOICECHAT
		case clc_voicechat:
			SV_VoiceReadPacket();
			break;
#endif
		}
	}

#ifdef MVD_PEXT1_DEBUG_ANTILAG
	if (antilag_players_present && sv_debug_antilag.value) {
		SV_DebugWriteServerAntilagPositions(cl, antilag_players_present);
	}
#endif
}

#ifdef MVD_PEXT1_SERVERSIDEWEAPON
static qbool SV_ClientExtensionWeaponSwitch(client_t* cl)
{
	int flags = MSG_ReadByte();
	int weap = 0, w = 0;
	qbool write = true;
	int sequence_set = cl->netchan.incoming_sequence;
	int weapon_hide_selection = 0;
	byte new_selections[MAX_WEAPONSWITCH_OPTIONS] = { 0 };
	char new_wrank[MAX_WEAPONSWITCH_OPTIONS + 1] = { 0 };
	int wrank_index = 0;

	if (flags == -1) {
		return false;
	}

	// This might be a duplicate that should be ignored
	if (flags & clc_mvd_weapon_forget_ranking) {
		int age = MSG_ReadByte();

		if (age < 0) {
			return false;
		}

		sequence_set = cl->netchan.incoming_sequence - age;

		write = (sequence_set > cl->weaponswitch_sequence_set);
	}

	while ((weap = MSG_ReadByte()) > 0) {
		if (flags & clc_mvd_weapon_full_impulse) {
			if (weap && write && w < MAX_WEAPONSWITCH_OPTIONS) {
				// only add 1-8 to the wrank weapon preference string...
				if (weap >= 1 && weap <= 8 && wrank_index < MAX_WEAPONSWITCH_OPTIONS) {
					new_wrank[wrank_index++] = '0' + weap;
				}
				new_selections[w++] = weap;
			}
		}
		else {
			int weap1 = (weap >> 4) & 15;
			int weap2 = (weap & 15);

			weap1 = bound(0, weap1, 9);
			weap2 = bound(0, weap2, 9);

			if (weap1 && write && w < MAX_WEAPONSWITCH_OPTIONS) {
				new_wrank[w] = '0' + weap1;
				new_selections[w++] = weap1;
			}
			if (weap1 && weap2 && write && w < MAX_WEAPONSWITCH_OPTIONS) {
				new_wrank[w] = '0' + weap2;
				new_selections[w++] = weap2;
			}

			if (!weap1 || !weap2) {
				break;
			}
		}
	}
	if (flags & clc_mvd_weapon_hide_axe) {
		weapon_hide_selection = 1;
	}
	else if (flags & clc_mvd_weapon_hide_sg) {
		weapon_hide_selection = 2;
	}

	if (weap < 0) {
		return false;
	}

	cl->weaponswitch_enabled = (flags & clc_mvd_weapon_switching);
	if (write) {
		cl->weaponswitch_sequence_set = sequence_set;
		cl->weaponswitch_forgetorder = (flags & clc_mvd_weapon_forget_ranking);
		cl->weaponswitch_mode = (flags & (clc_mvd_weapon_mode_presel | clc_mvd_weapon_mode_iffiring));
		cl->weaponswitch_hide = weapon_hide_selection;
		cl->weaponswitch_hide_on_death = (flags & clc_mvd_weapon_reset_on_death);
		memcpy(cl->weaponswitch_priority, new_selections, sizeof(new_selections));
		SV_DebugServerSideWeaponInstruction(cl);

		if (!cl->weaponswitch_forgetorder) {
			SV_UserSetWeaponRank(cl, new_wrank);
		}
	}
	cl->weaponswitch_pending |= write;
	cl->weaponswitch_sequence_set = sequence_set;
	return true;
}
#endif // MVD_PEXT1_SERVERSIDEWEAPON

/*
==============
SV_UserInit
==============
*/
void SV_UserInit (void)
{
	Cvar_Register (&sv_spectalk);
	Cvar_Register (&sv_sayteam_to_spec);
	Cvar_Register (&sv_mapcheck);
	Cvar_Register (&sv_minping);
	Cvar_Register (&sv_maxping);
	Cvar_Register (&sv_enable_cmd_minping);
	Cvar_Register (&sv_kickuserinfospamtime);
	Cvar_Register (&sv_kickuserinfospamcount);
	Cvar_Register (&sv_maxuploadsize);
#ifdef FTE_PEXT_CHUNKEDDOWNLOADS
	Cvar_Register (&sv_downloadchunksperframe);
#endif

#ifdef FTE_PEXT2_VOICECHAT
	Cvar_Register (&sv_voip);
	Cvar_Register (&sv_voip_echo);
	Cvar_Register (&sv_voip_record);
#endif

#ifdef MVD_PEXT1_DEBUG
	Cvar_Register(&sv_debug_weapons);
#endif
	Cvar_Register(&sv_debug_antilag);
	Cvar_Register(&sv_debug_usercmd);
}

static void SV_DebugClientCommand(byte playernum, const usercmd_t* usercmd, int dropnum_)
{
	if (playernum >= MAX_CLIENTS) {
		return;
	}

	if (sv_debug_usercmd.value >= 1 || svs.clients[playernum].mvd_write_usercmds) {
		mvdhidden_block_header_t header;
		byte dropnum = min(dropnum_, 255);

		header.type_id = mvdhidden_usercmd;
		header.length = sizeof_mvdhidden_block_header_t_usercmd;

		if (MVDWrite_HiddenBlockBegin(sizeof_mvdhidden_block_header_t_range0 + header.length)) {
			MVD_SZ_Write(&header.length, sizeof(header.length));
			MVD_SZ_Write(&header.type_id, sizeof(header.type_id));

			MVD_SZ_Write(&playernum, sizeof(playernum));
			MVD_SZ_Write(&dropnum, sizeof(dropnum));
			MVD_SZ_Write(&usercmd->msec, sizeof(usercmd->msec));
			MVD_SZ_Write(&usercmd->angles[0], sizeof(usercmd->angles[0]));
			MVD_SZ_Write(&usercmd->angles[1], sizeof(usercmd->angles[1]));
			MVD_SZ_Write(&usercmd->angles[2], sizeof(usercmd->angles[2]));
			MVD_SZ_Write(&usercmd->forwardmove, sizeof(usercmd->forwardmove));
			MVD_SZ_Write(&usercmd->sidemove, sizeof(usercmd->sidemove));
			MVD_SZ_Write(&usercmd->upmove, sizeof(usercmd->upmove));
			MVD_SZ_Write(&usercmd->buttons, sizeof(usercmd->buttons));
			MVD_SZ_Write(&usercmd->impulse, sizeof(usercmd->impulse));
		}
	}
}

static void SV_ClientDownloadComplete(client_t* cl)
{
	if (cl->download) {
		const char* val;

		VFS_CLOSE(cl->download);
		cl->download = NULL;
		cl->file_percent = 0; //bliP: file percent
		// set normal rate
		val = Info_Get(&cl->_userinfo_ctx_, "rate");
		cl->netchan.rate = 1.0 / SV_BoundRate(false, Q_atoi(*val ? val : "99999"));
		// set normal duplicate packets
		cl->netchan.dupe = cl->dupe;
	}
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_world.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// world.c -- world query functions

#ifndef CLIENTONLY
#include "qwsvdef.h"

/*

entities never clip against themselves, or their owner

line of sight checks trace->crosscontent, but bullets don't

*/


typedef struct
{
	vec3_t		boxmins, boxmaxs;// enclose the test object along entire move
	float		*mins, *maxs;	// size of the moving object
	vec3_t		mins2, maxs2;	// size when clipping against mosnters
	float		*start, *end;
	trace_t		trace;
	int			type;
	edict_t		*passedict;
} moveclip_t;


/*
================
SV_HullForEntity

Returns a hull that can be used for testing or clipping an object of mins/maxs
size.
Offset is filled in to contain the adjustment that must be added to the
testing object's origin to get a point to use with the returned hull.
================
*/
hull_t *SV_HullForEntity (edict_t *ent, vec3_t mins, vec3_t maxs, vec3_t offset)
{
	vec3_t size, hullmins, hullmaxs;
	cmodel_t *model;
	hull_t *hull;


	// decide which clipping hull to use, based on the size
	if (ent->v->solid == SOLID_BSP)
	{	// explicit hulls in the BSP model
		if (ent->v->movetype != MOVETYPE_PUSH)
			SV_Error ("SOLID_BSP without MOVETYPE_PUSH");

		if ((unsigned)ent->v->modelindex >= MAX_MODELS)
			SV_Error ("SV_HullForEntity: ent.modelindex >= MAX_MODELS");

		model = sv.models[(int)ent->v->modelindex];
		if (!model)
			SV_Error ("SOLID_BSP with a non-bsp model");

		VectorSubtract (maxs, mins, size);
		if (size[0] < 3)
			hull = &model->hulls[0];
		else if (size[0] <= 32)
			hull = &model->hulls[1];
		else
			hull = &model->hulls[2];

		// calculate an offset value to center the origin
		VectorSubtract (hull->clip_mins, mins, offset);
		VectorAdd (offset, ent->v->origin, offset);
	}
	else
	{	// create a temp hull from bounding box sizes

		VectorSubtract (ent->v->mins, maxs, hullmins);
		VectorSubtract (ent->v->maxs, mins, hullmaxs);
		hull = CM_HullForBox (hullmins, hullmaxs);
		
		VectorCopy (ent->v->origin, offset);
	}


	return hull;
}

/*
===============================================================================

ENTITY AREA CHECKING

===============================================================================
*/

// ClearLink is used for new headnodes
void ClearLink (link_t *l)
{
	l->prev = l->next = l;
}

void RemoveLink (link_t *l)
{
	l->next->prev = l->prev;
	l->prev->next = l->next;
}

void InsertLinkBefore (link_t *l, link_t *before)
{
	l->next = before;
	l->prev = before->prev;
	l->prev->next = l;
	l->next->prev = l;
}
void InsertLinkAfter (link_t *l, link_t *after)
{
	l->next = after->next;
	l->prev = after;
	l->prev->next = l;
	l->next->prev = l;
}

//============================================================================

// well, here should be all things related to world but atm it antilag only
typedef struct world_s
{
// { sv_antilag related
	float lagentsfrac;
	laggedentinfo_t *lagents;
	unsigned int maxlagents;
// }
} world_t;

static world_t w;

areanode_t sv_areanodes[AREA_NODES];
int sv_numareanodes;

/*
===============
SV_CreateAreaNode
===============
*/
areanode_t *SV_CreateAreaNode (int depth, vec3_t mins, vec3_t maxs)
{
	areanode_t	*anode;
	vec3_t		size;
	vec3_t		mins1, maxs1, mins2, maxs2;

	anode = &sv_areanodes[sv_numareanodes];
	sv_numareanodes++;

	ClearLink (&anode->trigger_edicts);
	ClearLink (&anode->solid_edicts);

	if (depth == AREA_DEPTH)
	{
		anode->axis = -1;
		anode->children[0] = anode->children[1] = NULL;
		return anode;
	}

	VectorSubtract (maxs, mins, size);
	if (size[0] > size[1])
		anode->axis = 0;
	else
		anode->axis = 1;

	anode->dist = 0.5 * (maxs[anode->axis] + mins[anode->axis]);
	VectorCopy (mins, mins1);
	VectorCopy (mins, mins2);
	VectorCopy (maxs, maxs1);
	VectorCopy (maxs, maxs2);

	maxs1[anode->axis] = mins2[anode->axis] = anode->dist;

	anode->children[0] = SV_CreateAreaNode (depth+1, mins2, maxs2);
	anode->children[1] = SV_CreateAreaNode (depth+1, mins1, maxs1);

	return anode;
}

/*
===============
SV_ClearWorld
===============
*/
void SV_ClearWorld (void)
{
	memset (sv_areanodes, 0, sizeof(sv_areanodes));
	sv_numareanodes = 0;
	SV_CreateAreaNode (0, sv.worldmodel->mins, sv.worldmodel->maxs);
}


/*
===============
SV_UnlinkEdict
===============
*/
void SV_UnlinkEdict (edict_t *ent)
{
	if (!ent->e.area.prev)
		return;		// not linked in anywhere
	RemoveLink (&ent->e.area);
	ent->e.area.prev = ent->e.area.next = NULL;
}

/*
====================
SV_AreaEdicts
====================
*/
int SV_AreaEdicts (vec3_t mins, vec3_t maxs, edict_t **edicts, int max_edicts, int area)
{
	link_t		*l, *start;
	edict_t		*touch;
	int			stackdepth = 0, count = 0;
	areanode_t	*localstack[AREA_NODES], *node = sv_areanodes;

// touch linked edicts
	while (1)
	{
		if (area == AREA_SOLID)
			start = &node->solid_edicts;
		else
			start = &node->trigger_edicts;

		for (l = start->next ; l != start ; l = l->next)
		{
			touch = EDICT_FROM_AREA(l);
			if (touch->v->solid == SOLID_NOT)
				continue;

			if (mins[0] > touch->v->absmax[0]
						 || mins[1] > touch->v->absmax[1]
						 || mins[2] > touch->v->absmax[2]
						 || maxs[0] < touch->v->absmin[0]
						 || maxs[1] < touch->v->absmin[1]
						 || maxs[2] < touch->v->absmin[2])
				continue;

			if (count == max_edicts)
				return count;
			edicts[count++] = touch;
		}

		if (node->axis == -1)
			goto checkstack;		// terminal node

		// recurse down both sides
		if (maxs[node->axis] > node->dist)
		{
			if (mins[node->axis] < node->dist)
			{
				localstack[stackdepth++] = node->children[0];
				node = node->children[1];
				continue;
			}
			node = node->children[0];
			continue;
		}
		if (mins[node->axis] < node->dist)
		{
			node = node->children[1];
			continue;
		}

checkstack:
		if (!stackdepth)
		return count;
		node = localstack[--stackdepth];
	}

	return count;
}

/*
====================
SV_TouchLinks
====================
*/
static void SV_TouchLinks ( edict_t *ent, areanode_t *node )
{
	int			i, numtouch;
	edict_t		*touchlist[MAX_EDICTS], *touch;
	int			old_self, old_other;

	numtouch = SV_AreaEdicts(ent->v->absmin, ent->v->absmax, touchlist, sv.max_edicts, AREA_TRIGGERS);

// touch linked edicts
	for (i = 0; i < numtouch; i++)
	{
		touch = touchlist[i];
		if (touch == ent)
			continue;
		if (!touch->v->touch || touch->v->solid != SOLID_TRIGGER)
			continue;

		old_self = pr_global_struct->self;
		old_other = pr_global_struct->other;

		pr_global_struct->self = EDICT_TO_PROG(touch);
		pr_global_struct->other = EDICT_TO_PROG(ent);
		pr_global_struct->time = sv.time;
		PR_EdictTouch (touch->v->touch);

		pr_global_struct->self = old_self;
		pr_global_struct->other = old_other;
	}
}

/*
====================
SV_LinkToLeafs
====================
*/
void SV_LinkToLeafs (edict_t *ent)
{
	int	i, leafnums[MAX_ENT_LEAFS];

	ent->e.num_leafs = CM_FindTouchedLeafs (ent->v->absmin, ent->v->absmax, leafnums,
					      MAX_ENT_LEAFS, 0, NULL);
	for (i = 0; i < ent->e.num_leafs; i++) {
		// ent->e.leafnums are real leafnum minus one (for pvs checks)
		ent->e.leafnums[i] = leafnums[i] - 1;
	}
}


/*
===============
SV_LinkEdict

===============
*/
void SV_LinkEdict (edict_t *ent, qbool touch_triggers)
{
	areanode_t	*node;
	
	if (ent->e.area.prev)
		SV_UnlinkEdict (ent);	// unlink from old position

	if (ent == sv.edicts)
		return;		// don't add the world

	if (ent->e.free)
		return;

// set the abs box
	VectorAdd (ent->v->origin, ent->v->mins, ent->v->absmin);
	VectorAdd (ent->v->origin, ent->v->maxs, ent->v->absmax);

	//
// to make items easier to pick up and allow them to be grabbed off
// of shelves, the abs sizes are expanded
	//
	if ((int)ent->v->flags & FL_ITEM)
	{
		ent->v->absmin[0] -= 15;
		ent->v->absmin[1] -= 15;
		ent->v->absmax[0] += 15;
		ent->v->absmax[1] += 15;
	}
	else
	{	// because movement is clipped an epsilon away from an actual edge,
		// we must fully check even when bounding boxes don't quite touch
		ent->v->absmin[0] -= 1;
		ent->v->absmin[1] -= 1;
		ent->v->absmin[2] -= 1;
		ent->v->absmax[0] += 1;
		ent->v->absmax[1] += 1;
		ent->v->absmax[2] += 1;
	}

// link to PVS leafs
	if (ent->v->modelindex)
		SV_LinkToLeafs (ent);
	else
		ent->e.num_leafs = 0;

	if (ent->v->solid == SOLID_NOT)
		return;

// find the first node that the ent's box crosses
	node = sv_areanodes;
	while (1)
	{
		if (node->axis == -1)
			break;
		if (ent->v->absmin[node->axis] > node->dist)
			node = node->children[0];
		else if (ent->v->absmax[node->axis] < node->dist)
			node = node->children[1];
		else
			break; // crosses the node
	}
	
// link it in	

	if (ent->v->solid == SOLID_TRIGGER)
		InsertLinkBefore (&ent->e.area, &node->trigger_edicts);
	else
		InsertLinkBefore (&ent->e.area, &node->solid_edicts);
	
// if touch_triggers, touch all entities at this node and decend for more
	if (touch_triggers)
		SV_TouchLinks ( ent, sv_areanodes );
}



/*
===============================================================================
 
POINT TESTING IN HULLS

===============================================================================
*/

/*
==================
SV_PointContents
 
==================
*/
int SV_PointContents (vec3_t p)
{
	return CM_HullPointContents (&sv.worldmodel->hulls[0], sv.worldmodel->hulls[0].firstclipnode, p);
}

//===========================================================================

/*
============
SV_TestEntityPosition

A small wrapper around SV_BoxInSolidEntity that never clips against the
supplied entity.
============
*/
edict_t	*SV_TestEntityPosition (edict_t *ent)
{
	trace_t	trace;

	if (ent->v->solid == SOLID_TRIGGER || ent->v->solid == SOLID_NOT)
		// only clip against bmodels
		trace = SV_Trace (ent->v->origin, ent->v->mins, ent->v->maxs, ent->v->origin, MOVE_NOMONSTERS, ent);
	else
		trace = SV_Trace(ent->v->origin, ent->v->mins, ent->v->maxs, ent->v->origin, MOVE_NORMAL, ent);
	
	if (trace.startsolid)
		return sv.edicts;
		
	return NULL;
}

/*
==================
SV_ClipMoveToEntity

Handles selection or creation of a clipping hull, and offseting (and
eventually rotation) of the end points
==================
*/
trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t *eorg, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end)
{
	trace_t		trace;
	vec3_t		offset;
	vec3_t		start_l, end_l;
	hull_t		*hull;

	// get the clipping hull
	hull = SV_HullForEntity (ent, mins, maxs, offset);

	// { well, its hack for sv_antilag
	if (eorg)
		VectorCopy((*eorg), offset);
	// }

	VectorSubtract (start, offset, start_l);
	VectorSubtract (end, offset, end_l);

	// trace a line through the apropriate clipping hull
	trace = CM_HullTrace (hull, start_l, end_l);

	// fix trace up by the offset
	VectorAdd (trace.endpos, offset, trace.endpos);

	// did we clip the move?
	if (trace.fraction < 1 || trace.startsolid)
		trace.e.ent = ent;

	return trace;
}

//===========================================================================

/*
====================
SV_ClipToLinks

Mins and maxs enclose the entire area swept by the move
====================
*/
void SV_ClipToLinks ( areanode_t *node, moveclip_t *clip )
{
	int			i, numtouch;
	edict_t		*touchlist[MAX_EDICTS], *touch;
	trace_t		trace;

	numtouch = SV_AreaEdicts (clip->boxmins, clip->boxmaxs, touchlist, sv.max_edicts, AREA_SOLID);

	// touch linked edicts
	for (i = 0; i < numtouch; i++)
	{
		// might intersect, so do an exact clip
		if (clip->trace.allsolid)
			return; // return!!!

		touch = touchlist[i];
		if (touch == clip->passedict)
			continue;
		if (touch->v->solid == SOLID_TRIGGER)
			SV_Error ("Trigger in clipping list");

		if ((clip->type & MOVE_NOMONSTERS) && touch->v->solid != SOLID_BSP)
			continue;

		if (clip->passedict && clip->passedict->v->size[0] && !touch->v->size[0])
			continue;	// points never interact

		if (clip->type & MOVE_LAGGED)
		{
			//can't touch lagged ents - we do an explicit test for them later in SV_AntilagClipCheck.
			if (touch->e.entnum - 1 < w.maxlagents)
				if (w.lagents[touch->e.entnum - 1].present)
					continue;
		}

		if (clip->passedict)
		{
			if (PROG_TO_EDICT(touch->v->owner) == clip->passedict)
				continue;	// don't clip against own missiles
			if (PROG_TO_EDICT(clip->passedict->v->owner) == touch)
				continue;	// don't clip against owner
		}

		if ((int)touch->v->flags & FL_MONSTER)
			trace = SV_ClipMoveToEntity (touch, NULL, clip->start, clip->mins2, clip->maxs2, clip->end);
		else
			trace = SV_ClipMoveToEntity (touch, NULL, clip->start, clip->mins, clip->maxs, clip->end);

		// qqshka: I have NO idea why we keep startsolid but let do it.

		// make sure we keep a startsolid from a previous trace
		clip->trace.startsolid |= trace.startsolid;

		if ( trace.allsolid || trace.fraction < clip->trace.fraction )
		{
			// set edict
			trace.e.ent = touch;
			// make sure we keep a startsolid from a previous trace
			trace.startsolid |= clip->trace.startsolid;
			// bit by bit copy trace struct
			clip->trace = trace;
		}
	}
}


/*
==================
SV_MoveBounds
==================
*/
void SV_MoveBounds (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, vec3_t boxmins, vec3_t boxmaxs)
{
#if 0
	// debug to test against everything
	boxmins[0] = boxmins[1] = boxmins[2] = -9999;
	boxmaxs[0] = boxmaxs[1] = boxmaxs[2] = 9999;
#else
	int		i;

	for (i=0 ; i<3 ; i++)
	{
		if (end[i] > start[i])
		{
			boxmins[i] = start[i] + mins[i] - 1;
			boxmaxs[i] = end[i] + maxs[i] + 1;
		}
		else
		{
			boxmins[i] = end[i] + mins[i] - 1;
			boxmaxs[i] = start[i] + maxs[i] + 1;
		}
	}
#endif
}

//=============================================

void SV_AntilagReset (edict_t *ent)
{
	if (ent->e.entnum == 0 || ent->e.entnum > MAX_CLIENTS)
		return;

	svs.clients[ent->e.entnum - 1].antilag_position_next = 0;
}

void SV_AntilagClipSetUp ( areanode_t *node, moveclip_t *clip )
{
	edict_t *passedict = clip->passedict;
	int entnum = passedict->e.entnum;

	clip->type &= ~MOVE_LAGGED;

	if (entnum && entnum <= MAX_CLIENTS && !svs.clients[entnum - 1].isBot)
	{
		clip->type |= MOVE_LAGGED;
		w.lagents = svs.clients[entnum - 1].laggedents;
		w.maxlagents = svs.clients[entnum - 1].laggedents_count;
		w.lagentsfrac = svs.clients[entnum - 1].laggedents_frac;
	}
	else if (passedict->v->owner)
	{
		int owner = PROG_TO_EDICT(passedict->v->owner)->e.entnum;

		if (owner && owner <= MAX_CLIENTS && !svs.clients[owner - 1].isBot)
		{
			clip->type |= MOVE_LAGGED;
			w.lagents = svs.clients[owner - 1].laggedents;
			w.maxlagents = svs.clients[owner - 1].laggedents_count;
			w.lagentsfrac = svs.clients[owner - 1].laggedents_frac;
		}
	}
}

void SV_AntilagClipCheck ( areanode_t *node, moveclip_t *clip )
{
	trace_t trace;
	edict_t *touch;
	vec3_t lp;
	int i;

	for (i = 0; i < w.maxlagents; i++)
	{
		if (clip->trace.allsolid)
			return; // return!!!

		if (!w.lagents[i].present)
			continue;

		touch = EDICT_NUM(i + 1);
		if (touch->v->solid == SOLID_NOT)
			continue;
		if (touch == clip->passedict)
			continue;
		if (touch->v->solid == SOLID_TRIGGER)
			SV_Error ("Trigger (%s) in clipping list", PR_GetEntityString(touch->v->classname));

		if ((clip->type & MOVE_NOMONSTERS) && touch->v->solid != SOLID_BSP)
			continue;

		VectorInterpolate(touch->v->origin, w.lagentsfrac, w.lagents[i].laggedpos, lp);

		if (   clip->boxmins[0] > lp[0]+touch->v->maxs[0]
			|| clip->boxmins[1] > lp[1]+touch->v->maxs[1]
			|| clip->boxmins[2] > lp[2]+touch->v->maxs[2]
			|| clip->boxmaxs[0] < lp[0]+touch->v->mins[0]
			|| clip->boxmaxs[1] < lp[1]+touch->v->mins[1]
			|| clip->boxmaxs[2] < lp[2]+touch->v->mins[2] )
			continue;

		if (clip->passedict && clip->passedict->v->size[0] && !touch->v->size[0])
			continue;	// points never interact

		if (clip->passedict)
		{
			if (PROG_TO_EDICT(touch->v->owner) == clip->passedict)
				continue;	// don't clip against own missiles
			if (PROG_TO_EDICT(clip->passedict->v->owner) == touch)
				continue;	// don't clip against owner
		}

		if ((int)touch->v->flags & FL_MONSTER)
			trace = SV_ClipMoveToEntity (touch, &lp, clip->start, clip->mins2, clip->maxs2, clip->end);
		else
			trace = SV_ClipMoveToEntity (touch, &lp, clip->start, clip->mins, clip->maxs, clip->end);

		// qqshka: I have NO idea why we keep startsolid but let do it.

		// make sure we keep a startsolid from a previous trace
		clip->trace.startsolid |= trace.startsolid;

		if ( trace.allsolid || trace.fraction < clip->trace.fraction )
		{
			// set edict
			trace.e.ent = touch;
			// make sure we keep a startsolid from a previous trace
			trace.startsolid |= clip->trace.startsolid;
			// bit by bit copy trace struct
			clip->trace = trace;
		}
	}
}

/*
==================
SV_Trace
==================
*/
trace_t SV_Trace (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int type, edict_t *passedict)
{
	moveclip_t	clip;
	int			i;

	memset ( &clip, 0, sizeof ( moveclip_t ) );

	// clip to world
	clip.trace = SV_ClipMoveToEntity ( sv.edicts, NULL, start, mins, maxs, end );

	clip.start = start;
	clip.end = end;
	clip.mins = mins;
	clip.maxs = maxs;
	clip.type = type;
	clip.passedict = passedict;

	if (type & MOVE_MISSILE)
	{
		for (i=0 ; i<3 ; i++)
		{
			clip.mins2[i] = -15;
			clip.maxs2[i] = 15;
		}
	}
	else
	{
		VectorCopy (mins, clip.mins2);
		VectorCopy (maxs, clip.maxs2);
	}

	// create the bounding box of the entire move
	SV_MoveBounds ( start, clip.mins2, clip.maxs2, end, clip.boxmins, clip.boxmaxs );

	// set up antilag
	if (clip.type & MOVE_LAGGED)
		SV_AntilagClipSetUp ( sv_areanodes, &clip );

	// clip to entities
	SV_ClipToLinks ( sv_areanodes, &clip );

	// additional antilag clip check
	if (clip.type & MOVE_LAGGED)
		SV_AntilagClipCheck ( sv_areanodes, &clip );

	return clip.trace;
}

#endif // !CLIENTONLY


================================================
FILE: src/sv_world.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// world.h
#ifndef __WORLD_H__
#define __WORLD_H__

#define	MOVE_NORMAL	0
#define	MOVE_NOMONSTERS	1
#define	MOVE_MISSILE	2
// { sv_antilag related
#define MOVE_LAGGED		64	//trace touches current last-known-state, instead of actual ents (just affects players for now)
// }

typedef struct areanode_s
{
	int		axis;		// -1 = leaf node
	float	dist;
	struct areanode_s	*children[2];
	link_t	trigger_edicts;
	link_t	solid_edicts;
} areanode_t;

#define AREA_SOLID	0
#define AREA_TRIGGERS	1

#define	AREA_DEPTH	4
#define	AREA_NODES	32

extern	areanode_t	sv_areanodes[AREA_NODES];

void SV_ClearWorld (void);
// called after the world model has been loaded, before linking any entities

void SV_UnlinkEdict (edict_t *ent);
// call before removing an entity, and before trying to move one,
// so it doesn't clip against itself
// flags ent->v->modified

void SV_LinkEdict (edict_t *ent, qbool touch_triggers);
// Needs to be called any time an entity changes origin, mins, maxs, or solid
// flags ent->v->modified
// sets ent->v->absmin and ent->v->absmax
// if touchtriggers, calls prog functions for the intersected triggers

int SV_PointContents (vec3_t p);
// returns the CONTENTS_* value from the world at the given point.
// does not check any entities at all

edict_t	*SV_TestEntityPosition (edict_t *ent);

trace_t SV_Trace (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int type, edict_t *passedict);
// mins and maxs are relative

// if the entire move stays in a solid volume, trace.allsolid will be set

// if the starting point is in a solid, it will be allowed to move out
// to an open area

// nomonsters is used for line of sight or edge testing, where mosnters
// shouldn't be considered solid objects

// passedict is explicitly excluded from clipping checks (normally NULL)

int SV_AreaEdicts (vec3_t mins, vec3_t maxs, edict_t **edicts, int max_edicts, int area);

void SV_AntilagReset (edict_t *ent);

#endif /* !__WORLD_H__ */


================================================
FILE: src/sys.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// sys.h -- non-portable functions

#include "q_platform.h"

#ifdef _WIN32
#define Sys_MSleep(x) Sleep(x)
#else
#define Sys_MSleep(x) usleep((x) * 1000)
#endif

#ifndef _WIN32
#define DWORD unsigned int
#define WINAPI
#ifndef MAX_PATH
	#define MAX_PATH (1024)
#endif
#define _MAX_FNAME 1024
#define _MAX_EXT 64
#define _MAX_DIR 1024

typedef void *DL_t;
#else
typedef HMODULE DL_t;
#endif

DL_t Sys_DLOpen(const char *path);
qbool Sys_DLClose(DL_t dl);
void *Sys_DLProc(DL_t dl, const char *name);

#include "localtime.h"

#include <SDL.h>

// create detached thread
int  Sys_CreateDetachedThread(int (*func)(void *), void *data);

// create thread
SDL_Thread *Sys_CreateThread(int (*func)(void *), void *data);

#define MAX_PATH_LENGTH 1024

typedef struct sys_dirent_s
{
    int directory;
    int hidden;
    char fname[MAX_PATH_LENGTH];
    unsigned int size;
    SYSTEMTIME time;
} sys_dirent; 

#ifdef _WIN32
typedef HANDLE SysDirEnumHandle;
#else
typedef unsigned long SysDirEnumHandle;
#endif

char *Sys_fullpath(char *absPath, const char *relPath, int maxLength);
SysDirEnumHandle  Sys_ReadDirFirst(sys_dirent *);               // 0 if failed
int            Sys_ReadDirNext(SysDirEnumHandle, sys_dirent *); // 0 if failed (EOF)
void           Sys_ReadDirClose(SysDirEnumHandle);
int    Sys_chdir (const char *path);
char * Sys_getcwd (char *buf, int bufsize);


// file IO
void Sys_mkdir (const char *path);
int Sys_remove (char *path);
int Sys_EnumerateFiles (char *gpath, char *match, int (*func)(char *, int, void *), void *parm);

// an error will cause the entire program to exit
void Sys_Error (char *error, ...);

// send text to the console
void Sys_Printf (char *fmt, ...);

void Sys_Quit (void);

double Sys_DoubleTime (void);


// Perform Key_Event() callbacks until the input que is empty
void Sys_SendKeyEvents (void);
// Some events (mouse wheel in particular) we won't get a secondary 'up/stop' event, so
//   we flag & execute them here, after any commands have been sent to the server
void Sys_SendDeferredKeyEvents(void);

void Sys_Init (void);

wchar *Sys_GetClipboardTextW(void);
void Sys_CopyToClipboard(const char *);

void Sys_GetFullExePath(char *path, unsigned int path_length, int long_name);

// Inter Process Call functions.
void Sys_InitIPC(void);
void Sys_ReadIPC(void);
void Sys_CloseIPC(void);
unsigned int Sys_SendIPC(const char *buf);
void Sys_RegisterQWURLProtocol_f(void);

// Semaphore functions
#ifdef _WIN32
typedef HANDLE sem_t;
#else
#include <semaphore.h>
#endif
int Sys_SemInit(sem_t *sem, int value, int max_value);
int Sys_SemWait(sem_t *sem);
int Sys_SemPost(sem_t *sem);
int Sys_SemDestroy(sem_t *sem);

// Timer Resolution
// On windows to Sleep(1) really take only 1 ms it is necessary to explicitly request
// such a high precision, otherwise the thread would sleep for much higher time (materials mention 18 ms or 50 ms)
// This interface allows to request a temporary increased resolution of the timer device
typedef struct timerresolution_session_s {
	int set;
	unsigned int interval;
} timerresolution_session_t;

#ifdef _WIN32

// for initialization of the session structure
void Sys_TimerResolution_InitSession(timerresolution_session_t * s);

// request minimum timer resolution for given session
// call this before a block in which you are using Sleep() with low argument value
void Sys_TimerResolution_RequestMinimum(timerresolution_session_t * s);

// release the requested resolution for this session
// lets timer device use lower resolution
// always call this after you don't need precise Sleep anymore!
void Sys_TimerResolution_Clear(timerresolution_session_t * s);

// Cancel deadkey combination for keyboards where console toggle is also deadkey
void Sys_CancelDeadKey (void);

void Sys_CheckQWProtocolHandler(void);

#else // NOT _WIN32 below

// not implemented on other platforms
#define Sys_CheckQWProtocolHandler(x)
#define Sys_TimerResolution_InitSession(x)
#define Sys_TimerResolution_RequestMinimum(x)
#define Sys_TimerResolution_Clear(x)

#endif

// MVDSV compatibility

#define MAX_DIRFILES 4096
#define MAX_DEMO_NAME 196

typedef struct
{
	char	name[MAX_DEMO_NAME];
	int	size;
	int	time;
	qbool	isdir; //bliP: list dir
} file_t;

typedef struct
{
	file_t *files;
	int	size;
	int	numfiles;
	int	numdirs;
} dir_t;

int		Sys_Script (const char *path, const char *args);

int		Sys_rmdir (const char *path);
dir_t	Sys_listdir (const char *path, const char *ext, int sort_type);

int		Sys_compare_by_date (const void *a, const void *b);
int		Sys_compare_by_name (const void *a, const void *b);
#define SORT_NO			0
#define SORT_BY_DATE	1
#define SORT_BY_NAME	2

#define ARRAY_LEN(x)		(sizeof(x) / sizeof(*(x)))

// library loading.

typedef struct
{
	void **funcptr;
	char *name;
} dllfunction_t;

typedef void *dllhandle_t;

dllhandle_t *Sys_LoadLibrary(const char *name, dllfunction_t *funcs);
void Sys_CloseLibrary(dllhandle_t *lib);
void *Sys_GetAddressForName(dllhandle_t *module, const char *exportname);

void Sys_CvarInit(void);

const char* Sys_FontsDirectory(void);
const char* Sys_HomeDirectory(void);


================================================
FILE: src/sys_osx.m
================================================
#import <AppKit/Appkit.h>
#import <Foundation/Foundation.h>
#import <SDL.h>
#import "common.h"

@interface URL : NSObject
- (void)getURL:(NSAppleEventDescriptor*)event withReplyEvent:(NSAppleEventDescriptor*)reply;
@end

@implementation URL
- (void)getURL:(NSAppleEventDescriptor*)event withReplyEvent:(NSAppleEventDescriptor*)reply
{
	Cbuf_AddText(va("qwurl \"%s\"\n", [[[event paramDescriptorForKeyword:keyDirectObject] stringValue] cStringUsingEncoding:NSASCIIStringEncoding]));
}
@end

static URL *url = NULL;

static void EzClearBookmarkedDirectory(void);

void init_macos_extras(void)
{
	if (url == NULL) {
		url = [[URL alloc] init];
	}

	[[NSAppleEventManager sharedAppleEventManager] setEventHandler:url andSelector:@selector(getURL:withReplyEvent:) forEventClass:kInternetEventClass andEventID:kAEGetURL];

	Cmd_AddCommand("sys_forget_sandbox", EzClearBookmarkedDirectory);
}

static void EzSimpleAlert(NSString *title, NSString *message)
{
	NSAlert *alert = [[NSAlert alloc] init];
	[alert setMessageText:title];
	[alert setInformativeText:message];
	[alert addButtonWithTitle:@"Ok"];
	[alert runModal];
}

static BOOL EzIsValidEzQuakeDirectory(NSString *directoryPath)
{
	NSString *id1Path = [directoryPath stringByAppendingPathComponent:@"id1"];
	NSString *pakFilePath = [id1Path stringByAppendingPathComponent:@"pak0.pak"];

	BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:pakFilePath];
	if (!exists) {
		EzSimpleAlert(@"Game directory not found", @"Select a directory containing 'id1/pak0.pak'.");
	}

	return exists;
}

static BOOL EzCheckExistingSettings(char *basedir, int length)
{
	NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
	NSData *bookmarkData = [defaults objectForKey:@"basedir"];
	NSString *version = [defaults stringForKey:@"version"];
	BOOL bookmarkDataIsStale = NO;
	NSError *error = nil;
	NSURL *resolvedURL;

	if (!(bookmarkData && version)) {
		return NO;
	}

	resolvedURL = [NSURL URLByResolvingBookmarkData:bookmarkData
	                                        options:NSURLBookmarkResolutionWithSecurityScope
	                                  relativeToURL:nil
	                            bookmarkDataIsStale:&bookmarkDataIsStale
	                                          error:&error];
	if (bookmarkDataIsStale || error) {
		NSString *msg = error.localizedDescription ? error.localizedDescription : @"Bookmark data is stale";
		EzSimpleAlert(@"Error resolving bookmark", msg);
		return NO;
	}

	if (![resolvedURL startAccessingSecurityScopedResource]) {
		EzSimpleAlert(@"Failed to start accessing security-scoped resource", @"");
		return NO;
	}

	NSString *resolvedPath = [resolvedURL path];
	if (EzIsValidEzQuakeDirectory(resolvedPath)) {
		strlcpy(basedir, [resolvedPath UTF8String], length);
		return YES;
	}

	return NO;
}

void SysLibrarySupportDir(char *basedir, int length)
{
	@autoreleasepool {
		// Need to temporarily start SDL here to not break initialization of application which
		// prevents both the dummy menu, and more importantly mouseMovedHandler from working.
		SDL_Window *window = SDL_CreateWindow(
				"ezQuake", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 0, 0, SDL_WINDOW_HIDDEN
		);

		if (EzCheckExistingSettings(basedir, length)) {
			SDL_DestroyWindow(window);
			return;
		}

		NSOpenPanel *openPanel = [NSOpenPanel openPanel];
		[openPanel setCanChooseFiles:NO];
		[openPanel setCanChooseDirectories:YES];
		[openPanel setAllowsMultipleSelection:NO];
		[openPanel setMessage:@"Select game directory containing id1/pak0.pak:"];

		BOOL validDirectorySelected = NO;
		while (!validDirectorySelected) {
			if ([openPanel runModal] != NSModalResponseOK) {
				break;
			}

			NSURL *directoryURL = [[openPanel URLs] objectAtIndex:0];
			if (!EzIsValidEzQuakeDirectory([directoryURL path])) {
				continue;
			}

			NSError *error = nil;
			NSData *bookmarkData = [directoryURL bookmarkDataWithOptions:NSURLBookmarkCreationWithSecurityScope
			                              includingResourceValuesForKeys:nil
			                                               relativeToURL:nil
			                                                       error:&error];
			if (error) {
				EzSimpleAlert(@"Error creating bookmark", error.localizedDescription);
				break;
			}

			[[NSUserDefaults standardUserDefaults] setObject:bookmarkData forKey:@"basedir"];
			[[NSUserDefaults standardUserDefaults] setObject:@VERSION forKey:@"version"];

			validDirectorySelected = YES;

			NSString *resolvedPath = [directoryURL path];
			strlcpy(basedir, [resolvedPath UTF8String], length);
		}

		SDL_DestroyWindow(window);
	}
}

static void EzClearBookmarkedDirectory(void) {
	NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];

	NSData *bookmarkData = [defaults objectForKey:@"basedir"];
	if (bookmarkData) {
		NSError *error = nil;
		BOOL bookmarkDataIsStale = NO;

		NSURL *resolvedURL = [NSURL URLByResolvingBookmarkData:bookmarkData
		                                               options:NSURLBookmarkResolutionWithSecurityScope
		                                         relativeToURL:nil
		                                   bookmarkDataIsStale:&bookmarkDataIsStale
		                                                 error:&error];
		if (!error && resolvedURL) {
			[resolvedURL stopAccessingSecurityScopedResource];
		}

		[defaults removeObjectForKey:@"basedir"];
		[defaults removeObjectForKey:@"version"];
		[defaults synchronize];

		Con_Printf("Sandbox directory cleared.\n");
	} else {
		Con_Printf("No sandbox directory selected.\n");
	}
}


================================================
FILE: src/sys_posix.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <string.h>
#include <ctype.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <semaphore.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sched.h>
#include <errno.h>
#include <dirent.h>
#include <sys/resource.h>

#include <SDL.h>
#include <dlfcn.h>

#include "quakedef.h"
#include "server.h"
#include <pcre2.h>


// BSD only defines FNDELAY:
#ifndef O_NDELAY
#  define O_NDELAY	FNDELAY
#endif


int noconinput = 0;

qbool stdin_ready;
int do_stdin = 1;

void OnChange_sys_highpriority (cvar_t *, char *, qbool *);

cvar_t sys_highpriority = {"sys_highpriority", "", 0, OnChange_sys_highpriority};
cvar_t sys_nostdout     = {"sys_nostdout", "0" };
cvar_t sys_fontsdir     = {"sys_fontsdir", "/usr/local/share/fonts/"};

void Sys_Printf (char *fmt, ...)
{
#ifdef DEBUG
	va_list argptr;
	char text[2048];
	unsigned char *p;

	return;

	va_start (argptr,fmt);
	vsnprintf (text, sizeof(text), fmt, argptr);
	va_end (argptr);

	if (sys_nostdout.value)
		return;

	for (p = (unsigned char *) text; *p; p++)
		if ((*p > 128 || *p < 32) && *p != 10 && *p != 13 && *p != 9)
			printf("[%02x]", *p);
		else
			putc(*p, stdout);
#else
	return;
#endif
}

void Sys_Quit(void)
{
	fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~O_NDELAY);
	exit(0);
}

void Sys_Init(void)
{
#ifdef __APPLE__
	extern void init_macos_extras(void);
	init_macos_extras();
#endif
	Cvar_Register(&sys_highpriority);
	Cvar_Register(&sys_fontsdir);
}

void Sys_Error(char *error, ...)
{
	extern FILE *qconsole_log;
	va_list argptr;
	char string[1024];

	fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~O_NDELAY);	//change stdin to non blocking

	va_start (argptr, error);
	vsnprintf (string, sizeof(string), error, argptr);
	va_end (argptr);
	fprintf(stderr, "Error: %s\n", string);
	if (qconsole_log)
		fprintf(qconsole_log, "Error: %s\n", string);

	Host_Shutdown ();
	SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error", string, NULL);
	exit(1);
}

void Sys_mkdir (const char *path)
{
	mkdir (path, 0777);
}

/*
================
Sys_remove
================
*/
int Sys_remove(char *path)
{
	return unlink(path);
}

int Sys_rmdir(const char *path)
{
	return rmdir(path);
}

int Sys_FileSizeTime(char *path, int *time1)
{
	struct stat buf;
	if (stat(path, &buf) == -1)
	{
		*time1 = -1;
		return 0;
	}
	else
	{
		*time1 = buf.st_mtime;
		return buf.st_size;
	}
}

/*
================
Sys_listdir
================
*/

dir_t Sys_listdir (const char *path, const char *ext, int sort_type)
{
	static file_t list[MAX_DIRFILES]; // FIXME: thread un-safe.
	dir_t dir;
	char pathname[MAX_OSPATH];
	DIR *d;
	DIR *testdir; //bliP: list dir
	struct dirent *oneentry;
	qbool all;

	PCRE2_SIZE error_offset;
	pcre2_code *preg = NULL;
	pcre2_match_data *match_data = NULL;
	int error;

	memset(list, 0, sizeof(list));
	memset(&dir, 0, sizeof(dir));

	dir.files = list;
	all = !strncmp(ext, ".*", 3);
	if (!all)
		if (!(preg = pcre2_compile((PCRE2_SPTR)ext, PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &error, &error_offset, NULL)))
		{
			PCRE2_UCHAR error_str[256];
			pcre2_get_error_message(error, error_str, sizeof(error_str));
			Con_Printf("Sys_listdir: pcre2_compile(%s) error: %s at offset %d\n",
			           ext, error_str, error_offset);
			pcre2_code_free(preg);
			return dir;
		}

	if (!(d = opendir(path)))
	{
		if (!all) {
			pcre2_code_free(preg);
		}
		return dir;
	}
	while ((oneentry = readdir(d)))
	{
		if (!strncmp(oneentry->d_name, ".", 2) || !strncmp(oneentry->d_name, "..", 3))
			continue;
		if (!all)
		{
			match_data = pcre2_match_data_create_from_pattern(preg, NULL);
			error = pcre2_match(preg, (PCRE2_SPTR)oneentry->d_name,
				strlen(oneentry->d_name), 0, 0, match_data, NULL);
			pcre2_match_data_free(match_data);
			if (error < 0) {
				if (error != PCRE2_ERROR_NOMATCH) {
					Con_Printf("Sys_listdir: pcre2_match(%s, %s) error code: %d\n",
						ext, oneentry->d_name, error);
				}
				continue;
			}
		}
		snprintf(pathname, sizeof(pathname), "%s/%s", path, oneentry->d_name);
		if ((testdir = opendir(pathname)))
		{
			dir.numdirs++;
			list[dir.numfiles].isdir = true;
			list[dir.numfiles].size = list[dir.numfiles].time = 0;
			closedir(testdir);
		}
		else
		{
			list[dir.numfiles].isdir = false;
			//list[dir.numfiles].time = Sys_FileTime(pathname);
			dir.size +=
				(list[dir.numfiles].size = Sys_FileSizeTime(pathname, &list[dir.numfiles].time));
		}
		strlcpy (list[dir.numfiles].name, oneentry->d_name, MAX_DEMO_NAME);

		if (++dir.numfiles == MAX_DIRFILES - 1)
			break;
	}
	closedir(d);
	if (!all) {
		pcre2_code_free(preg);
	}

	switch (sort_type)
	{
	case SORT_NO: break;
#ifndef CLIENTONLY
	case SORT_BY_DATE:
		qsort((void *)list, dir.numfiles, sizeof(file_t), Sys_compare_by_date);
		break;
	case SORT_BY_NAME:
		qsort((void *)list, dir.numfiles, sizeof(file_t), Sys_compare_by_name);
		break;
#endif
	}

	return dir;
}

int Sys_chdir(const char *path)
{
	return (chdir(path) == 0);
}

char *Sys_getcwd(char *buf, int bufsize)
{
	return getcwd(buf, bufsize);
}

#if (_POSIX_TIMERS > 0) && defined(_POSIX_MONOTONIC_CLOCK)
#include <time.h>
double Sys_DoubleTime(void)
{
	static unsigned int secbase;
	struct timespec ts;

#ifdef __linux__
	clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
#else
	clock_gettime(CLOCK_MONOTONIC, &ts);
#endif

	if (!secbase) {
		secbase = ts.tv_sec;
		return ts.tv_nsec / 1000000000.0;
	}

	return (ts.tv_sec - secbase) + ts.tv_nsec / 1000000000.0;
}
#else
double Sys_DoubleTime(void)
{
	struct timeval tp;
	struct timezone tzp;
	static int secbase;

	gettimeofday(&tp, &tzp);

	if (!secbase) {
	    secbase = tp.tv_sec;
	    return tp.tv_usec/1000000.0;
	}

	return (tp.tv_sec - secbase) + tp.tv_usec / 1000000.0;
}
#endif

int main(int argc, char **argv)
{
	double time, oldtime, newtime;
	int i;

#ifdef __linux__
	extern void InitSig(void);
	InitSig();
#endif

	COM_InitArgv (argc, argv);

	// let me use -condebug C:\condebug.log before Quake FS init, so I get ALL messages before quake fully init
	if ((i = COM_CheckParm(cmdline_param_console_debug)) && i < COM_Argc() - 1) {
		extern FILE *qconsole_log;
		char *s = COM_Argv(i + 1);
		if (*s != '-' && *s != '+')
			qconsole_log = fopen(s, "a");
	}

	signal(SIGFPE, SIG_IGN);

	// we need to check for -noconinput and -nostdout before Host_Init is called
	if (!(noconinput = COM_CheckParm(cmdline_param_client_nostdinput)))
		fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);

	if (COM_CheckParm(cmdline_param_client_nostdoutput))
		sys_nostdout.value = 1;

	Host_Init (argc, argv, 256 * 1024 * 1024);

	oldtime = Sys_DoubleTime ();
	while (1) {
		// find time spent rendering last frame
		newtime = Sys_DoubleTime();
		time = newtime - oldtime;
		oldtime = newtime;

		Host_Frame(time);
	}
}

void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length) {
	int r;
	unsigned long addr;
	int psize = getpagesize();

	addr = (startaddr & ~(psize - 1)) - psize;
	r = mprotect((char*) addr, length + startaddr - addr + psize, 7);
	if (r < 0)
    		Sys_Error("Protection change failed");
}

// kazik -->
// directory listing functions
int CopyDirent(sys_dirent *ent, struct dirent *tmpent)
{
    struct stat statbuf;
    struct tm * lintime;
    if (stat(tmpent->d_name, &statbuf) != 0)
        return 0;

    strncpy(ent->fname, tmpent->d_name, MAX_PATH_LENGTH);
    ent->fname[MAX_PATH_LENGTH-1] = 0;

    lintime = localtime(&statbuf.st_mtime);
    UnixtimeToWintime(&ent->time, lintime);

    ent->size = statbuf.st_size;

    ent->directory = (statbuf.st_mode & S_IFDIR);

    return 1;
}

SysDirEnumHandle Sys_ReadDirFirst(sys_dirent *ent)
{
    struct dirent *tmpent;
    DIR *dir = opendir(".");
    if (dir == NULL)
        return 0;

    tmpent = readdir(dir);
    if (tmpent == NULL)
    {
        closedir(dir);
        return 0;
    }

    if (!CopyDirent(ent, tmpent))
    {
        closedir(dir);
        return 0;
    }

    return (SysDirEnumHandle)dir;
}

int Sys_ReadDirNext(SysDirEnumHandle search, sys_dirent *ent)
{
    struct dirent *tmpent;

    tmpent = readdir((DIR*)search);

    if (tmpent == NULL)
        return 0;

    if (!CopyDirent(ent, tmpent))
        return 0;

    return 1;
}

void Sys_ReadDirClose(SysDirEnumHandle search)
{
    closedir((DIR *)search);
}

void _splitpath(const char *path, char *drive, char *dir, char *file, char *ext)
{
    const char *f, *e;

    if (drive)
    drive[0] = 0;

    f = path;
    while (strchr(f, '/'))
    f = strchr(f, '/') + 1;

    if (dir)
    {
    strncpy(dir, path, min(f-path, _MAX_DIR));
        dir[_MAX_DIR-1] = 0;
    }

    e = f;
    while (*e == '.')   // skip dots at beginning
    e++;
    if (strchr(e, '.'))
    {
    while (strchr(e, '.'))
        e = strchr(e, '.')+1;
    e--;
    }
    else
    e += strlen(e);

    if (file)
    {
        strncpy(file, f, min(e-f, _MAX_FNAME));
    file[min(e-f, _MAX_FNAME-1)] = 0;
    }

    if (ext)
    {
    strncpy(ext, e, _MAX_EXT);
    ext[_MAX_EXT-1] = 0;
    }
}

// full path
char *Sys_fullpath(char *absPath, const char *relPath, int maxLength)
{
    // too small buffer, copy in tmp[] and then look is enough space in output buffer aka absPath
    if (maxLength-1 < PATH_MAX)	{
		char tmp[PATH_MAX+1];
		if (realpath(relPath, tmp) && absPath && strlen(tmp) < maxLength) {
			strlcpy(absPath, tmp, maxLength);
			return absPath;
		}

		return NULL;
	}

    return realpath(relPath, absPath);
}
// kazik <--

int Sys_EnumerateFiles (char *gpath, char *match, int (*func)(char *, int, void *), void *parm)
{
	DIR *dir, *dir2;
	char apath[MAX_OSPATH];
	char file[MAX_OSPATH];
	char truepath[MAX_OSPATH];
	char *s;
	struct dirent *ent;

	//printf("path = %s\n", gpath);
	//printf("match = %s\n", match);

	if (!gpath)
		gpath = "";
	*apath = '\0';

	strlcpy(apath, match, sizeof(apath));
	for (s = apath+strlen(apath)-1; s >= apath; s--)
	{
		if (*s == '/')
		{
			s[1] = '\0';
			match += s - apath+1;
			break;
		}
	}
	if (s < apath)  //didn't find a '/'
		*apath = '\0';

	snprintf(truepath, sizeof(truepath), "%s/%s", gpath, apath);


	//printf("truepath = %s\n", truepath);
	//printf("gamepath = %s\n", gpath);
	//printf("apppath = %s\n", apath);
	//printf("match = %s\n", match);
	dir = opendir(truepath);
	if (!dir)
	{
		Com_DPrintf("Failed to open dir %s\n", truepath);
		return true;
	}
	do
	{
		ent = readdir(dir);
		if (!ent)
			break;
		if (*ent->d_name != '.')
			if (wildcmp(match, ent->d_name))
			{
				snprintf(file, sizeof(file), "%s/%s", truepath, ent->d_name);
				//would use stat, but it breaks on fat32.

				if ((dir2 = opendir(file)))
				{
					closedir(dir2);
					snprintf(file, sizeof(file), "%s%s/", apath, ent->d_name);
					//printf("is directory = %s\n", file);
				}
				else
				{
					snprintf(file, sizeof(file), "%s%s", apath, ent->d_name);
					//printf("file = %s\n", file);
				}

				if (!func(file, -2, parm))
				{
					closedir(dir);
					return false;
				}
			}
	} while(1);
	closedir(dir);

	return true;
}

/*************************** INTER PROCESS CALLS *****************************/
#define PIPE_BUFFERSIZE		1024

static int fifo_pipe = -1;

static char *Sys_PipeFile(void) {
	static char pipe[MAX_PATH] = {0};

	if (*pipe)
		return pipe;

	snprintf(pipe, sizeof(pipe), "/tmp/ezquake_fifo_%s", getlogin());
	return pipe;
}

void Sys_InitIPC(void)
{
	mode_t old;

	/* Don't use the user's umask, make sure we set the proper access */
	old = umask(0);
	// This could legitimately fail (pipe exists), but it should be fine.
	mkfifo(Sys_PipeFile(), 0600);
	umask(old); // Reset old mask

	/* Open in non blocking mode */
	if ((fifo_pipe = open(Sys_PipeFile(), O_RDONLY | O_NONBLOCK)) == -1) {
		// We failed ...
		return;
	}
}

void Sys_CloseIPC(void)
{
	if (fifo_pipe != -1) {
		close(fifo_pipe);
		fifo_pipe = -1;
		unlink(Sys_PipeFile());
	}
}

void Sys_ReadIPC(void)
{
	char buf[PIPE_BUFFERSIZE] = {0};
	int num_bytes_read = 0;

	if (fifo_pipe == -1)
		return;

	num_bytes_read = read(fifo_pipe, buf, sizeof(buf) - 1); // nul terminated.
	if (num_bytes_read <= 0) {
		return;
	}
	COM_ParseIPCData(buf, num_bytes_read);
}

unsigned int Sys_SendIPC(const char *buf)
{
	FILE *fifo_out;
	int nelms_written;
	
	if (!(fifo_out = fopen(Sys_PipeFile(), "w")))
		return true;

	nelms_written = fwrite(buf, strlen(buf) + 1, 1, fifo_out);

	fclose(fifo_out);

	if (nelms_written != 1)
		return false;
	
	return true;
}


/********************************** SEMAPHORES *******************************/
/* Sys_Sem*() returns 0 on success; on error, -1 is returned */
int Sys_SemInit(sem_t *sem, int value, int max_value) 
{
	return sem_init(sem, 0, value); // Don't share between processes
}

int Sys_SemWait(sem_t *sem) 
{
	return sem_wait(sem);
}

int Sys_SemPost(sem_t *sem)
{
	return sem_post(sem);
}

int Sys_SemDestroy(sem_t *sem)
{
	return sem_destroy(sem);
}

/*********************************************************************************/
int Sys_Script (const char *path, const char *args)
{
	char str[1024];

	snprintf(str, sizeof(str), "cd %s\n./%s.qws %s &\ncd ..", fs_gamedir, path, args);

	if (system(str) == -1)
		return 0;

	return 1;
}

DL_t Sys_DLOpen(const char *path)
{
	DL_t ret = dlopen(path,
#ifdef __OpenBSD__
	              DL_LAZY
#else
	              RTLD_NOW
#endif
	             );
	if (!ret)
		Con_DPrintf("Sys_DLOpen: %s\n", dlerror());
	return ret;
}

qbool Sys_DLClose(DL_t dl)
{
	return !dlclose(dl);
}

void *Sys_DLProc(DL_t dl, const char *name)
{
	return dlsym(dl, name);
}

/*********************************************************************************/

void Sys_CloseLibrary(dllhandle_t *lib)
{
	dlclose((void*)lib);
}

dllhandle_t *Sys_LoadLibrary(const char *name, dllfunction_t *funcs)
{
	int i;
	dllhandle_t lib;

	lib = dlopen (name, RTLD_LAZY);
	if (!lib)
		return NULL;

	for (i = 0; funcs[i].name; i++)
	{
		*funcs[i].funcptr = dlsym(lib, funcs[i].name);
		if (!*funcs[i].funcptr)
			break;
	}
	if (funcs[i].name)
	{
		Sys_CloseLibrary((dllhandle_t*)lib);
		lib = NULL;
	}

	return (dllhandle_t*)lib;
}

void *Sys_GetAddressForName(dllhandle_t *module, const char *exportname)
{
	if (!module)
		return NULL;
	return dlsym(module, exportname);
}

const char* Sys_FontsDirectory(void)
{
	return sys_fontsdir.string;
}

const char* Sys_HomeDirectory(void)
{
	char *ev = getenv("HOME");
	if (ev) {
		return ev;
	}
	return "";
}

#ifdef __MACOSX__

void Sys_RegisterQWURLProtocol_f(void)
{
	Con_Printf("Not yet implemented for this platform.");
	return;
}

#else

void Sys_RegisterQWURLProtocol_f(void)
{
    char open_cmd[MAX_PATH*2+1024] = { 0 };
    char exe_path[MAX_PATH] = { 0 };
    char buf[MAX_PATH] = { 0 };
    const char *homedir=Sys_HomeDirectory();
    int nchar = -1;
    FILE *fptr;

    qbool quiet = Cmd_Argc() == 2 && !strcmp(Cmd_Argv(1), "quiet");

    nchar = readlink("/proc/self/exe", exe_path, sizeof(exe_path)-1);
    if (nchar < 0 || nchar >= sizeof exe_path) {
        Con_Printf("Failed to get executable path.");
        return;
    }

    snprintf(open_cmd, sizeof(open_cmd), "[Desktop Entry]\n"
            "Type=Application\n"
            "Name=ezQuake\n"
            "GenericName=Handles qw:// protocol links from browsers\n"
            "Comment=Browser uses ezQuake to open qw:// urls.\n"
            "Keywords=qtv,qw://;\n"
            "Categories=quakeworld;qtv;Game;\n"
            "Exec=%s +qwurl %s\n"
            "Path=%s\n"
            "MimeType=x-scheme-handler/qw;\n"
            "Terminal=false\n"
            "StartupNotify=false\n"
            , exe_path, "%u", com_basedir);
    snprintf(buf, sizeof(buf), "%s/.local/share/applications/qw-url-handler.desktop", homedir);

    fptr = fopen(buf, "wb+");
    if(!fptr){
        //create directory path to url handler file
        snprintf(buf, sizeof(buf), "%s/.local", homedir);
        Sys_mkdir(buf);
        snprintf(buf, sizeof(buf), "%s/.local/share", homedir);
        Sys_mkdir(buf);
        snprintf(buf, sizeof(buf), "%s/.local/share/applications", homedir);
        Sys_mkdir(buf);
        //attempt opening the file again
        snprintf(buf, sizeof(buf), "%s/.local/share/applications/qw-url-handler.desktop", homedir);
        fptr = fopen(buf, "wb+");
    }
    if (fptr == NULL) {
        Con_Printf("Failed to open qw-url-handler file.");
        return;
    }
    fprintf(fptr, "%s", open_cmd);
    fclose(fptr);

	if(system("xdg-mime default qw-url-handler.desktop x-scheme-handler/qw") != 0){
        Con_Printf("Failed to register qw-url-handler file with xdg-mime, please make sure this program is installed.");
    }

    if (!quiet) {
        Com_Printf_State(PRINT_WARNING, "qw:// protocol registered\n");
    }

    return;
}

#endif //platforms other than osx

int Sys_SetPriority(int priority)
{
	int ret, i=0;

	switch (priority) {
		case 1:
			for (i=-19;i<0;i++) {
				ret = setpriority(PRIO_PGRP, 0, i);
				if (ret == 0) break;
			}
			break;
		case -1:
			for (i=19;i>0;i--) {
				ret = setpriority(PRIO_PGRP, 0, i);
				if (ret == 0) break;
			}
			break;
		default:
			ret = setpriority(PRIO_PGRP, 0, 0);
	}

	if (ret == 0) return i;
	return 255;
}

void OnChange_sys_highpriority (cvar_t *var, char *s, qbool *cancel)
{
	//do not attempt to change priority if cvar is unset
	if (s[0] == '\0') return;

	int priority, ret;
	char *desc;

	priority = Q_atoi(s);
	if (priority > 0){
		desc = "high";
	} else if (priority < 0) {
		desc = "low";
	} else {
		desc = "normal";
	}

	ret = Sys_SetPriority(priority);
	if (ret != 255) {
		Com_Printf("Process priority set to %s (nice level %d)\n", desc, ret);
	} else {
		Com_Printf("Failed to set process priority set to %s\n", desc);
	}
}


================================================
FILE: src/sys_sdl2.c
================================================
/*
Copyright (C) 2014-2016 ezQuake team 

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "quakedef.h"
#include <SDL.h>

cvar_t sys_yieldcpu = {"sys_yieldcpu", "0"};
cvar_t sys_inactivesound = {"sys_inactivesound", "0", CVAR_ARCHIVE};
cvar_t sys_inactivesleep = {"sys_inactivesleep", "1"};
cvar_t sys_disable_alt_enter = {"sys_disable_alt_enter", "0"};

static void Sys_BatteryInfo_f(void)
{
	SDL_PowerState res;
	int secs, percent;

	if ((res = SDL_GetPowerInfo(&secs, &percent)) == SDL_POWERSTATE_UNKNOWN) {
		Com_Printf("Failed to retrieve power state info\n");
		return;
	}

	switch (res) {
		case SDL_POWERSTATE_ON_BATTERY:
			Com_Printf("%d%% left (%d:%02dh)\n", percent, secs/3600, (secs%3600)/60);
			break;
		case SDL_POWERSTATE_NO_BATTERY:
			Com_Printf("No battery available\n");
			break;
		case SDL_POWERSTATE_CHARGING:
			Com_Printf("Plugged in, charging battery (%d%%)\n", percent);
			break;
		case SDL_POWERSTATE_CHARGED:
			Com_Printf("Plugged in, battery is fully charged\n");
			break;
		default:
			break;
	}
}

void Sys_CvarInit(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SYSTEM_SETTINGS);
	Cvar_Register(&sys_yieldcpu);
	Cvar_Register(&sys_inactivesound);
	Cvar_Register(&sys_inactivesleep);
	Cvar_Register(&sys_disable_alt_enter);
	Cvar_ResetCurrentGroup();

	Cmd_AddCommand("batteryinfo", Sys_BatteryInfo_f);
}

wchar *Sys_GetClipboardTextW(void)
{
	char *tmp;
	wchar *wtmp = NULL;

	if (SDL_HasClipboardText()) {
		tmp = SDL_GetClipboardText();
		wtmp = str2wcs(tmp);
		SDL_free(tmp);
	}

	return wtmp;
}

void Sys_CopyToClipboard(const char *text)
{
	SDL_SetClipboardText(text);
}

int Sys_CreateDetachedThread(int (*func)(void *), void *data)
{
	SDL_Thread *thread;
	
	thread = SDL_CreateThread((SDL_ThreadFunction)func, NULL, data);
	if (!thread) {
		return -1;
	}

	SDL_DetachThread(thread);

	return 0;
}

SDL_Thread *Sys_CreateThread(int (*func)(void *), void *data)
{
	return SDL_CreateThread((SDL_ThreadFunction)func, NULL, data);
}


================================================
FILE: src/sys_win.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
// sys_win.c

#include "quakedef.h"
#include <windows.h>
#include <commctrl.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <io.h>			// _open, etc
#include <direct.h>		// _mkdir
#include <conio.h>		// _putch
#include <tchar.h>
#include "keys.h"
#include "server.h"
#include "pcre2.h"
#include <shlobj.h>

// "Starting with the Release 302 drivers, application developers can direct the
// Optimus driver at runtime to use the High Performance Graphics to render any
// application -- even those applications for which there is no existing application
// profile. They can do this by exporting a global variable named NvOptimusEnablement.
// The Optimus driver looks for the existence and value of the export. Only the LSB of
// the DWORD matters at this time. A value of 0x00000001 indicates that rendering should
// be performed using High Performance Graphics. A value of 0x00000000 indicates that
// this method should be ignored.
// https://docs.nvidia.com/gameworks/content/technologies/desktop/optimus.htm
#ifdef _MSC_VER
_declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
#else
__attribute__((dllexport)) DWORD NvOptimusEnablement = 0x00000001;
#endif

// Many Gaming and workstation laptops are available with both(1) integrated power saving and
// (2) discrete high performance graphics devices.Unfortunately, 3D intensive application performance
// may suffer greatly if the best graphics device is not selected.For example, a game may run at 30
// Frames Per Second(FPS) on the integrated GPU rather than the 60 FPS the discrete GPU would enable.
// As a developer you can easily fix this problem by adding only one line to your executable's source code :
// https://gpuopen.com/amdpowerxpressrequesthighperformance/
#ifdef _MSC_VER
_declspec(dllexport) DWORD AmdPowerXpressRequestHighPerformance = 0x00000001;
#else
__attribute__((dllexport)) DWORD AmdPowerXpressRequestHighPerformance = 0x00000001;
#endif

#define MINIMUM_WIN_MEMORY	0x0c00000
#define MAXIMUM_WIN_MEMORY	0xfffffff

#define PAUSE_SLEEP		50				// sleep time on pause or minimization
#define NOT_FOCUS_SLEEP	20				// sleep time when not focus

void OnChange_sys_highpriority (cvar_t *, char *, qbool *);
cvar_t	sys_highpriority = {"sys_highpriority", "0", 0, OnChange_sys_highpriority};

static HANDLE	qwclsemaphore;
static HANDLE	tevent;
HANDLE	hinput, houtput;
HINSTANCE	global_hInstance;

void MaskExceptions (void);
void Sys_PopFPCW (void);
void Sys_PushFPCW_SetHigh (void);

typedef HRESULT (WINAPI *SetProcessDpiAwarenessFunc)(_In_ DWORD value);

#ifndef WITHOUT_WINKEYHOOK

#ifndef WH_KEYBOARD_LL
#define WH_KEYBOARD_LL 13
#endif

unsigned int windows_keys_down, windows_keys_up;

static HHOOK WinKeyHook;
static qbool WinKeyHook_isActive;
static qbool ScreenSaver_isDisabled = false;
static qbool PowerOff_isDisabled = false;

LRESULT CALLBACK LLWinKeyHook(int Code, WPARAM wParam, LPARAM lParam);
void OnChange_sys_disableWinKeys(cvar_t *var, char *string, qbool *cancel);
cvar_t	sys_disableWinKeys = {"sys_disableWinKeys", "0", 0, OnChange_sys_disableWinKeys};

extern qbool ActiveApp, Minimized;

static void ReleaseKeyHook (void)
{
	if (WinKeyHook_isActive) {
		UnhookWindowsHookEx (WinKeyHook);
		WinKeyHook_isActive = false;
	}
}

static qbool RegisterKeyHook (void)
{
	if (!WinKeyHook_isActive) {
		WinKeyHook = SetWindowsHookEx(WH_KEYBOARD_LL, LLWinKeyHook, global_hInstance, 0);
		WinKeyHook_isActive = (WinKeyHook != NULL);
	}

	return WinKeyHook_isActive;
}

void OnChange_sys_disableWinKeys(cvar_t *var, char *string, qbool *cancel) 
{
	extern cvar_t r_fullscreen;

	if (Q_atof(string) == 1 || (Q_atof(string) == 2 && r_fullscreen.value))
	{
		if (!WinKeyHook_isActive) 
		{
			if (! RegisterKeyHook())
			{
				Com_Printf("Failed to install winkey hook.\n");
				Com_Printf("Microsoft Windows NT 4.0, 2000 or XP is required.\n");
				*cancel = true;
				return;
			}
		}
	}
	else 
	{
		ReleaseKeyHook ();
	}
}

LRESULT CALLBACK LLWinKeyHook(int Code, WPARAM wParam, LPARAM lParam) 
{
	PKBDLLHOOKSTRUCT p = (PKBDLLHOOKSTRUCT) lParam;
	unsigned int* flags = (p->flags & LLKHF_UP) ? &windows_keys_up : &windows_keys_down;

	switch (p->vkCode)
	{
		case VK_LWIN:
			*flags |= WINDOWS_LWINDOWSKEY;
			return 1;
		case VK_RWIN:
			*flags |= WINDOWS_RWINDOWSKEY;
			return 1;
		case VK_APPS:
			*flags |= WINDOWS_MENU;
			return 1;
		case VK_SNAPSHOT:
			*flags |= WINDOWS_PRINTSCREEN;
			return 1;
		case VK_CAPITAL:
			if (key_dest != key_console && key_dest != key_message) {
				// Don't toggle capslock when in game
				*flags |= WINDOWS_CAPSLOCK;
				return 1;
			}
			break;
	}

	return CallNextHookEx(NULL, Code, wParam, lParam);
}

void Sys_ActiveAppChanged(void)
{
	static qbool appWasActive = true;
	static qbool hookWasActive = false;

	if (appWasActive == ActiveApp)
		return;

	appWasActive = ActiveApp;
	if (ActiveApp && hookWasActive) {
		RegisterKeyHook();
	}
	else if (!ActiveApp) {
		hookWasActive = WinKeyHook_isActive;

		ReleaseKeyHook();
	}
}

#endif


int Sys_SetPriority(int priority) 
{
    DWORD p;

	switch (priority) 
	{
		case 0:	p = IDLE_PRIORITY_CLASS; break;
		case 1:	p = NORMAL_PRIORITY_CLASS; break;
		case 2:	p = HIGH_PRIORITY_CLASS; break;
		case 3:	p = REALTIME_PRIORITY_CLASS; break;
		default: return 0;
	}

	return SetPriorityClass(GetCurrentProcess(), p);
}

void OnChange_sys_highpriority (cvar_t *var, char *s, qbool *cancel) 
{
	int ok, q_priority;
	char *desc;
	float priority;

	priority = Q_atof(s);
	if (priority == 1) 
	{
		q_priority = 2;
		desc = "high";
	} 
	else if (priority == -1) 
	{
		q_priority = 0;
		desc = "low";
	} 
	else 
	{
		q_priority = 1;
		desc = "normal";
	}

	if (!(ok = Sys_SetPriority(q_priority))) 
	{
		Com_Printf("Changing process priority failed\n");
		*cancel = true;
		return;
	}

	Com_Printf("Process priority set to %s\n", desc);
}

//===============================================================================
// FILE IO
//===============================================================================

void Sys_mkdir (const char *path) 
{
	_mkdir (path);
}

int Sys_remove (char *path)
{
	return remove(path);
}

int Sys_rmdir (const char *path)
{
	return _rmdir(path);
}

// D-Kure: This is added for FTE vfs
int Sys_EnumerateFiles (char *gpath, char *match, int (*func)(char *, int, void *), void *parm)
{
	HANDLE r;
	WIN32_FIND_DATA fd; 
	char apath[MAX_OSPATH];
	char apath2[MAX_OSPATH];
	char file[MAX_OSPATH];
	char *s;
	int go;
	if (!gpath)
		return 0;

	snprintf(apath, sizeof(apath), "%s/%s", gpath, match);
	for (s = apath+strlen(apath)-1; s> apath; s--)
	{
		if (*s == '/') 
			break;
	}
	*s = '\0';

	// This is what we ask windows for.
	snprintf(file, sizeof(file), "%s/*.*", apath);

	// We need to make apath contain the path in match but not gpath
	strlcpy(apath2, match, sizeof(apath));
	match = s+1;
	for (s = apath2+strlen(apath2)-1; s> apath2; s--)
	{
		if (*s == '/')
			break;
	}
	*s = '\0';
	if (s != apath2)
		strlcat (apath2, "/", sizeof (apath2));

	r = FindFirstFile(file, &fd);
	if (r==(HANDLE)-1)
		return 1;
	go = true;
	do
	{
		if (*fd.cFileName == '.');  // Don't ever find files with a name starting with '.'
		else if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)    //is a directory
		{
			if (wildcmp(match, fd.cFileName))
			{
				snprintf(file, sizeof(file), "%s%s/", apath2, fd.cFileName);
				go = func(file, fd.nFileSizeLow, parm);
			}
		}
		else
		{
			if (wildcmp(match, fd.cFileName))
			{
				snprintf(file, sizeof(file), "%s%s", apath2, fd.cFileName);
				go = func(file, fd.nFileSizeLow, parm);
			}
		}
	}
	while(FindNextFile(r, &fd) && go);
	FindClose(r);

	return go;
}

#ifndef CLIENTONLY
/*
================
Sys_listdir
================
*/
dir_t Sys_listdir (const char *path, const char *ext, int sort_type)
{
	static file_t	list[MAX_DIRFILES];
	dir_t	dir;
	HANDLE	h;
	WIN32_FIND_DATA fd;
	char	pathname[MAX_DEMO_NAME];
	qbool all;

	PCRE2_SIZE	error_offset;
	pcre2_code	*preg = NULL;
	pcre2_match_data *match_data = NULL;
	int error;

	memset(list, 0, sizeof(list));
	memset(&dir, 0, sizeof(dir));

	dir.files = list;
	all = !strncmp(ext, ".*", 3);
	if (!all) {
		if (!(preg = pcre2_compile((PCRE2_SPTR)ext, PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &error, &error_offset, NULL))) {
			Con_Printf("Sys_listdir: pcre2_compile(%s) error: %d at offset %d\n",
				ext, error, error_offset);
			return dir;
		}
	}

	snprintf(pathname, sizeof(pathname), "%s/*.*", path);
	if ((h = FindFirstFile (pathname , &fd)) == INVALID_HANDLE_VALUE)
	{
		if (!all) {
			pcre2_code_free(preg);
		}
		return dir;
	}

	do
	{
		if (!strncmp(fd.cFileName, ".", 2) || !strncmp(fd.cFileName, "..", 3))
			continue;
		if (!all)
		{
			match_data = pcre2_match_data_create_from_pattern(preg, NULL);
			error = pcre2_match(preg, (PCRE2_SPTR)fd.cFileName,
				strlen(fd.cFileName), 0, 0, match_data, NULL);
			pcre2_match_data_free(match_data);
			if (error < 0) {
				if (error != PCRE2_ERROR_NOMATCH) {
					Con_Printf("Sys_listdir: pcre2_match(%s, %s) error code: %d\n",
						ext, fd.cFileName, error);
				}
				continue;
			}
		}

		if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
			//bliP: list dir
			dir.numdirs++;
			list[dir.numfiles].isdir = true;
			list[dir.numfiles].size = list[dir.numfiles].time = 0;
		}
		else {
			list[dir.numfiles].isdir = false;
			snprintf(pathname, sizeof(pathname), "%s/%s", path, fd.cFileName);
			list[dir.numfiles].time = 0; //Sys_FileTime(pathname);
			dir.size += (list[dir.numfiles].size = fd.nFileSizeLow);
		}
		strlcpy (list[dir.numfiles].name, fd.cFileName, sizeof(list[0].name));

		if (++dir.numfiles == MAX_DIRFILES - 1) {
			break;
		}
	} while (FindNextFile(h, &fd));

	FindClose (h);
	if (!all) {
		pcre2_code_free(preg);
	}

	switch (sort_type)
	{
	case SORT_NO: break;
	case SORT_BY_DATE:
		qsort((void *)list, dir.numfiles, sizeof(file_t), Sys_compare_by_date);
		break;
	case SORT_BY_NAME:
		qsort((void *)list, dir.numfiles, sizeof(file_t), Sys_compare_by_name);
		break;
	}
	return dir;
}
#endif

// ===============================================================================
// SYSTEM IO
// ===============================================================================

/// turn back on screen saver and monitor power off
static void Sys_RestoreScreenSaving(void)
{
    if (ScreenSaver_isDisabled)
        SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, TRUE, 0, SPIF_SENDWININICHANGE);

	if (PowerOff_isDisabled)
		SystemParametersInfo(SPI_SETPOWEROFFACTIVE, TRUE, 0, SPIF_SENDWININICHANGE);
}

/// disable screen saver and monitor power off
static void Sys_DisableScreenSaving(void)
{
	int bIsEnabled = 0;

	// disables screen saver
	if ( SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, (PVOID)(&bIsEnabled), 0) && bIsEnabled ) 
	{
		if ( SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, 0, SPIF_SENDWININICHANGE) ) 
		{
			ScreenSaver_isDisabled = true;
		}
	}

	// disables screen power off
	if ( SystemParametersInfo(SPI_GETPOWEROFFACTIVE, 0, (PVOID)(&bIsEnabled), 0) && bIsEnabled ) 
	{
		if ( SystemParametersInfo(SPI_SETPOWEROFFACTIVE, FALSE, 0, SPIF_SENDWININICHANGE) ) 
		{
			PowerOff_isDisabled = true;
		}
	}
}

void Sys_Error (char *error, ...) 
{
	va_list argptr;
	char text[1024];

	va_start(argptr, error);
	vsnprintf(text, sizeof(text), error, argptr);
	va_end(argptr);

	Host_Shutdown ();

	MessageBox(NULL, text, "Error", 0);

	if (qwclsemaphore)
		CloseHandle (qwclsemaphore);

	Sys_RestoreScreenSaving();
 
	exit (1);
}

void Sys_Printf_Direct(const char* text)
{
#ifdef DEBUG_MEMORY_ALLOCATIONS
	if (houtput == NULL) {
		houtput = CreateFile("SysPrintf.log", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	}

	if (houtput != NULL) {
		DWORD dummy;

		WriteFile(houtput, text, strlen(text), &dummy, NULL);
	}
#endif
}

void Sys_Printf (char *fmt, ...) 
{
#ifndef _DEBUG
	return;
#endif

#ifdef DEBUG_MEMORY_ALLOCATIONS
	if (houtput == NULL) {
		houtput = CreateFile("SysPrintf.log", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	}

	if (houtput != NULL) {
		va_list argptr;
		char text[1024];
		DWORD dummy;
		int n;

		va_start(argptr, fmt);
		n = vsnprintf(text, sizeof(text), fmt, argptr);
		va_end(argptr);

		if (n >= sizeof(text)) {
			char* buffer = (char*)Q_malloc(n + 1);
			va_start(argptr, fmt);
			vsnprintf(buffer, n, fmt, argptr);
			va_end(argptr);

			WriteFile(houtput, (byte*)buffer, strlen(buffer), &dummy, NULL);
			Q_free(buffer);
		}
		else {
			WriteFile(houtput, text, strlen(text), &dummy, NULL);
		}
	}
#endif
}

void Sys_Quit (void) 
{
	if (tevent)
		CloseHandle (tevent);

	if (qwclsemaphore)
		CloseHandle (qwclsemaphore);

#ifndef WITHOUT_WINKEYHOOK
	if (WinKeyHook_isActive)
		UnhookWindowsHookEx(WinKeyHook);
#endif

	if (houtput) {
		if (houtput != GetStdHandle(STD_OUTPUT_HANDLE)) {
			CloseHandle(houtput);
			houtput = NULL;
		}
	}

	Sys_RestoreScreenSaving();
 
	exit (0);
}

static double pfreq;
static qbool hwtimer = false;

void Sys_InitDoubleTime (void) 
{
	__int64 freq;

	if (!COM_CheckParm(cmdline_param_client_nohardwaretimers) && QueryPerformanceFrequency((LARGE_INTEGER *)&freq) && freq > 0)
	{
		// Hardware timer available
		pfreq = (double)freq;
		hwtimer = true;
	} 
	else 
	{
		// Make sure the timer is high precision, otherwise NT gets 18ms resolution
		timeBeginPeriod (1);
	}
}

double Sys_DoubleTime (void) 
{
	__int64 pcount;
	static __int64 startcount;
	static DWORD starttime;
	static qbool first = true;
	DWORD now;

	if (hwtimer) 
	{
		QueryPerformanceCounter ((LARGE_INTEGER *)&pcount);
		if (first) 
		{
			first = false;
			startcount = pcount;
			return 0.0;
		}
		// TODO: check for wrapping
		return (pcount - startcount) / pfreq;
	}

	now = timeGetTime();

	if (first) {
		first = false;
		starttime = now;
		return 0.0;
	}

	if (now < starttime) // Wrapped?
		return (now / 1000.0) + (LONG_MAX - starttime / 1000.0);

	if (now - starttime == 0)
		return 0.0;

	return (now - starttime) / 1000.0;
}

BOOL WINAPI HandlerRoutine (DWORD dwCtrlType) 
{
	switch (dwCtrlType) {
		case CTRL_C_EVENT:		
		case CTRL_BREAK_EVENT:
		case CTRL_CLOSE_EVENT:
		case CTRL_LOGOFF_EVENT:
		case CTRL_SHUTDOWN_EVENT:
			Cbuf_AddText ("quit\n");
			return true;
	}
	return false;
}

// Quake calls this so the system can register variables before host_hunklevel is marked
void Sys_Init (void) 
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SYSTEM_SETTINGS);
	Cvar_Register(&sys_highpriority);
#ifndef WITHOUT_WINKEYHOOK
	Cvar_Register(&sys_disableWinKeys);	
#endif
	Cvar_ResetCurrentGroup();

}

void WinCheckOSInfo(void)
{
	OSVERSIONINFO vinfo;

	vinfo.dwOSVersionInfoSize = sizeof(vinfo);

	if (!GetVersionEx(&vinfo)) {
		Sys_Error("Couldn't get OS info");
		return;
	}

	if (vinfo.dwPlatformId != VER_PLATFORM_WIN32_NT || vinfo.dwMajorVersion < 5 || (vinfo.dwMajorVersion == 5 && vinfo.dwMinorVersion < 1)) {
		Sys_Error("ezQuake requires at least Windows XP.");
		return;
	}

	// Use raw resolutions, not scaled
	{
		HMODULE lib = LoadLibrary("Shcore.dll");
		if (lib != NULL) {
			SetProcessDpiAwarenessFunc SetProcessDpiAwareness;

			SetProcessDpiAwareness = (SetProcessDpiAwarenessFunc) GetProcAddress(lib, "SetProcessDpiAwareness");
			if (SetProcessDpiAwareness != NULL) {
				SetProcessDpiAwareness(2);
			}
			FreeLibrary(lib);
		}
	}
}

void Sys_Init_ (void) 
{
	if (!COM_CheckParm(cmdline_param_client_allowmultipleclients))
	{
		// Mutex will fail if semaphore already exists.
		qwclsemaphore = CreateMutex(
			NULL,		// Security attributes
			0,			// Owner
			"qwcl");	// Semaphore name

		if (!qwclsemaphore)
		{
			int qwurl_parm = COM_FindParm("+qwurl");
			char cmd[1024] = { 0 };

			if (COM_CheckArgsForPlayableFiles(cmd, sizeof(cmd)))
			{
				// Play a demo/.qtv file if it was specified as the first argument.
				Sys_SendIPC(cmd);
				Sys_Quit();
			}
			else if (qwurl_parm)
			{
				// If the user specified a QW URL on the commandline
				// we forward it to the already running client.
				Sys_SendIPC(COM_Argv(qwurl_parm + 1));
				Sys_Quit();
			}
			else
			{
				Sys_Error ("QWCL is already running on this system");
			}
		}
		
		CloseHandle (qwclsemaphore);

		qwclsemaphore = CreateSemaphore(
			NULL,		// Security attributes
			0,			// Initial count
			1,			// Maximum count
			"qwcl");	// Semaphore name
	}

	Sys_InitDoubleTime ();
}


//==============================================================================
// WINDOWS CRAP
//==============================================================================

#define MAX_NUM_ARGVS	50

int		argc;
char	*argv[MAX_NUM_ARGVS];
static char exename[1024] = {0};

void ParseCommandLine (char *lpCmdLine) 
{
    int i;
	argc = 1;
	argv[0] = exename;

	if(!(i = GetModuleFileName(NULL, exename, sizeof(exename)-1))) // here we get loong string, with full path
		exename[0] = 0; // oh, something bad
	else 
	{
		exename[i] = 0; // ensure null terminator
		strlcpy(exename, COM_SkipPath(exename), sizeof(exename));
	}

	while (*lpCmdLine && (argc < MAX_NUM_ARGVS))
	{
		while (*lpCmdLine && ((*lpCmdLine <= 32) || (*lpCmdLine > 126)))
			lpCmdLine++;

		if (*lpCmdLine)
		{
			if (*lpCmdLine == '\"')
			{
				lpCmdLine++;

				argv[argc] = lpCmdLine;
				argc++;

				while (*lpCmdLine && *lpCmdLine != '\"') // this include chars less that 32 and greate than 126... is that evil?
					lpCmdLine++;
			}
			else
			{
				argv[argc] = lpCmdLine;
				argc++;

				while (*lpCmdLine && ((*lpCmdLine > 32) && (*lpCmdLine <= 126)))
					lpCmdLine++;
			}

			if (*lpCmdLine)
			{
				*lpCmdLine = 0;
				lpCmdLine++;
			}
		}
	}
}

#define QW_URL_ROOT_REGKEY         "Software\\Classes\\qw"
#define QW_URL_OPEN_CMD_REGKEY     QW_URL_ROOT_REGKEY"\\shell\\Open\\Command"
#define QW_URL_DEFAULTICON_REGKEY  QW_URL_ROOT_REGKEY"\\DefaultIcon"

//
// Checks if this client is the default qw protocol handler.
//
static qbool Sys_CheckIfQWProtocolHandler(void)
{
	DWORD type;
	char reg_path[1024];
	DWORD len = (DWORD) sizeof(reg_path);
	HKEY hk;

	if (RegOpenKey(HKEY_CURRENT_USER, QW_URL_OPEN_CMD_REGKEY, &hk) != 0) {
		return false;
	}

	// Get the size we need to read.
	if (RegQueryValueEx(hk, NULL, 0, &type, (BYTE *) reg_path, &len) == ERROR_SUCCESS) {
		char expanded_reg_path[MAX_PATH];

		// Expand any environment variables in the reg value so that we get a real path to compare with.
		ExpandEnvironmentStrings(reg_path, expanded_reg_path, sizeof(expanded_reg_path));

		#if 0
		// This checks if the current exe is associated with, otherwise it will prompt the user
		// a bit more "in the face" if the user has more than one ezquake version.
		{
			char exe_path[MAX_PATH];
		
			// Get the long path of the current process.
			// C:\Program Files\Quake\ezquake-gl.exe
			Sys_GetFullExePath(exe_path, sizeof(exe_path), true);

			if (strstri(reg_path, exe_path) || strstri(expanded_reg_path, exe_path))
			{
				// This exe is associated with the qw:// protocol, return true.
				CloseHandle(hk);
				return true;
			}

			// Get the short path and check if that matches instead.
			// C:\Program~1\Quake\ezquake-gl.exe
			Sys_GetFullExePath(exe_path, sizeof(exe_path), false);

			if (strstri(reg_path, exe_path) || strstri(expanded_reg_path, exe_path))
			{
				CloseHandle(hk);
				return true;
			}
		}
		#else
		// Only check if ezquake is in the string that associates with the qw:// protocol
		// so if you have several ezquake exes it won't bug you if you just switch between those
		// (Only one will be registered as the protocol handler though ofcourse).

		if (strstri(reg_path, "ezquake"))
		{
			CloseHandle(hk);
			return true;
		}

		#endif
	}

	CloseHandle(hk);
	return false;
}

void Sys_CheckQWProtocolHandler(void)
{
	// Verify that ezQuake is associated with the QW:// protocl handler.
	//
	#define INITIAL_CON_WIDTH 35
	extern cvar_t cl_verify_qwprotocol;

	if (cl_verify_qwprotocol.integer >= 2) {
		// Always register the qw:// protocol.
		Cbuf_AddText("register_qwurl_protocol quiet\n");
	} else if (cl_verify_qwprotocol.integer == 1 && !Sys_CheckIfQWProtocolHandler()) {
		// Check if the running exe is the one associated with the qw:// protocol.
		Com_PrintVerticalBar(INITIAL_CON_WIDTH);
		Com_Printf("\n");
		Com_Printf("ezQuake is not associated with the ");
		Com_Printf("\x02QW:// protocol. ");
		Com_Printf("Register it using"); 
		Com_Printf("\x02/register_qwurl_protocol\n");
		Com_Printf("(set");
		Com_Printf("\x02 cl_verify_qwprotocol 0 ");
		Com_Printf("to hide this warning)\n");
		Com_PrintVerticalBar(INITIAL_CON_WIDTH);
		Com_Printf("\n\n");
	}
}

void Sys_RegisterQWURLProtocol_f(void)
{
	//
	// Note!
	// HKEY_CLASSES_ROOT is a "merged view" of both: HKEY_LOCAL_MACHINE\Software\Classes 
	// and HKEY_CURRENT_USER\Software\Classes. 
	// User specific settings has priority over machine settings.
	//
	// If you try to write to HKEY_CLASSES_ROOT directly, it will default to
	// trying to write to the machine specific settings. If the user isn't
	// admin this will fail. On Vista this requires UAC usage.
	// Because of this, we always write specifically to "HKEY_CURRENT_USER\Software\Classes"
	//
	qbool quiet = Cmd_Argc() == 2 && !strcmp(Cmd_Argv(1), "quiet");

	HKEY keyhandle;
	char exe_path[MAX_PATH];

	Sys_GetFullExePath(exe_path, sizeof(exe_path), true);

	//
	// HKCU\qw\shell\Open\Command
	//
	{
		char open_cmd[1024];
		snprintf(open_cmd, sizeof(open_cmd), "\"%s\" +qwurl %%1", exe_path);

		// Open / Create the key.
		if (RegCreateKeyEx(HKEY_CURRENT_USER,		// A handle to an open subkey.
						QW_URL_OPEN_CMD_REGKEY,		// Subkey.
						0,							// Reserved, must be 0.
						NULL,						// Class, ignored.
						REG_OPTION_NON_VOLATILE,	// Save the change to disk.
						KEY_WRITE,					// Access rights.
						NULL,						// Security attributes (NULL means default, inherited from direct parent).
						&keyhandle,					// Handle to the created key.
						NULL))						// Don't care if the key existed or not.
		{
			Com_Printf_State(PRINT_WARNING, "Could not create HKCU\\"QW_URL_OPEN_CMD_REGKEY"\n");
			return;
		}

		// Set the key value.
		if (RegSetValueEx(keyhandle, NULL, 0, REG_SZ, (BYTE *) open_cmd,  strlen(open_cmd) * sizeof(char)))
		{
			Com_Printf_State(PRINT_WARNING, "Could not set HKCU\\"QW_URL_OPEN_CMD_REGKEY"\\@\n");
			RegCloseKey(keyhandle);
			return;
		}

		RegCloseKey(keyhandle);
	}

	//
	// HKCU\qw\DefaultIcon
	//
	{
		char default_icon[1024];
		snprintf(default_icon, sizeof(default_icon), "\"%s\",1", exe_path);

		// Open / Create the key.
		if (RegCreateKeyEx(HKEY_CURRENT_USER, QW_URL_DEFAULTICON_REGKEY, 
			0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &keyhandle, NULL))
		{
			Com_Printf_State(PRINT_WARNING, "Could not create HKCU\\"QW_URL_OPEN_CMD_REGKEY"\n");
			return;
		}

		// Set the key value.
		if (RegSetValueEx(keyhandle, NULL, 0, REG_SZ, (BYTE *) default_icon, strlen(default_icon) * sizeof(char)))
		{
			Com_Printf_State(PRINT_WARNING, "Could not set HKCU\\"QW_URL_OPEN_CMD_REGKEY"\\@\n");
			RegCloseKey(keyhandle);
			return;
		}

		RegCloseKey(keyhandle);
	}

	//
	// HKCU\qw
	//
	{
		char protocol_name[] = "URL:QW Protocol";

		// Open / Create the key.
		if (RegCreateKeyEx(HKEY_CURRENT_USER, QW_URL_ROOT_REGKEY, 
			0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &keyhandle, NULL))
		{
			Com_Printf_State(PRINT_WARNING, "Could not create HKCU\\qw\n");
			return;
		}

		// Set the protocol name.
		if (RegSetValueEx(keyhandle, NULL, 0, REG_SZ, (BYTE *) protocol_name, strlen(protocol_name) * sizeof(char)))
		{
			Com_Printf_State(PRINT_WARNING, "Could not set HKCU\\qw\\@\n");
			RegCloseKey(keyhandle);
			return;
		}

		if (RegSetValueEx(keyhandle, "URL Protocol", 0, REG_SZ, (BYTE *) "", sizeof(char)))
		{
			Com_Printf_State(PRINT_WARNING, "Could not set HKCU\\qw\\URL Protocol\n");
			RegCloseKey(keyhandle);
			return;
		}

		RegCloseKey(keyhandle);

		if (!quiet) {
			Com_Printf_State(PRINT_WARNING, "qw:// protocol registered\n");
		}
	}
}

//============================================================================
HHOOK hMsgBoxHook;

LRESULT CALLBACK QWURLProtocolButtonsHookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
	HWND hwnd;
	HWND hwndYESButton;
	HWND hwndNOButton;
	HWND hwndCANCELButton;

	if(nCode < 0)
		return CallNextHookEx(hMsgBoxHook, nCode, wParam, lParam);

	switch(nCode)
	{
		case HCBT_ACTIVATE:
		{
			#define BUTTON_HEIGHT		23
			#define YES_BUTTON_WIDTH	110
			#define NO_BUTTON_WIDTH		110
			#define CANCEL_BUTTON_WIDTH	140
			#define BUTTON_GAP			5
			#define BOTTOM_OFFSET		10
			#define ALL_BUTTON_WIDTH	(YES_BUTTON_WIDTH + BUTTON_GAP + NO_BUTTON_WIDTH + BUTTON_GAP + CANCEL_BUTTON_WIDTH)

			RECT rectWindow;
			RECT rectClient;
			int y_pos = 0;
			int x_pos = 0;

			// Get handle to the message box.
			hwnd = (HWND)wParam;
			GetClientRect(hwnd, &rectClient);
			GetWindowRect(hwnd, &rectWindow);
			
			// Place the buttons at the bottom of the window.
			y_pos = rectClient.bottom - BOTTOM_OFFSET - BUTTON_HEIGHT;

			// Resize the messagebox to at least fit the buttons.
			if (rectClient.right < ALL_BUTTON_WIDTH)
			{
				// TODO: Hmm does this work properly? Got some weird behaviour where the control wouldn't draw if the cy argument wasn't a constant.
				SetWindowPos(hwnd, HWND_TOP, 20, 20, 
					(ALL_BUTTON_WIDTH + (BUTTON_GAP * 2)), 
					(int)(rectWindow.bottom - rectWindow.top), 
					0);
			}

			// Center the buttons.
			x_pos = Q_rint((rectClient.right - ALL_BUTTON_WIDTH) / 2.0);
			
			// Modify the Yes button.
			hwndYESButton = GetDlgItem(hwnd, IDYES);
			SetWindowText(hwndYESButton, _T("Set as default"));
			SetWindowPos(hwndYESButton, HWND_TOP, x_pos, y_pos, YES_BUTTON_WIDTH, BUTTON_HEIGHT, 0);
			ShowWindow(hwndYESButton, SW_SHOWNORMAL);
			x_pos += YES_BUTTON_WIDTH + BUTTON_GAP;

			// No button.
			hwndNOButton = GetDlgItem(hwnd, IDNO);
			SetWindowText(hwndNOButton, _T("Ask me later"));
			SetWindowPos(hwndNOButton, HWND_TOP, x_pos, y_pos, NO_BUTTON_WIDTH, BUTTON_HEIGHT, 0);
			ShowWindow(hwndNOButton, SW_SHOWNORMAL);
			x_pos += NO_BUTTON_WIDTH + BUTTON_GAP;

			// Cancel button.
			hwndCANCELButton = GetDlgItem(hwnd, IDCANCEL);
			SetWindowText(hwndCANCELButton, _T("Don't show me this again"));
			SetWindowPos(hwndCANCELButton, HWND_TOP, x_pos, y_pos, CANCEL_BUTTON_WIDTH, BUTTON_HEIGHT, 0);
			ShowWindow(hwndCANCELButton, SW_SHOWNORMAL);

			return 0;
		}
	}

	return CallNextHookEx(hMsgBoxHook, nCode, wParam, lParam);
}

int MsgBoxEx(HWND hwnd, TCHAR *szText, TCHAR *szCaption, HOOKPROC hookproc, UINT uType)
{
	int retval;

	// Install a window hook, so we can intercept the message-box
	// creation, and customize it
	if (hookproc != NULL)
	{
		hMsgBoxHook = SetWindowsHookEx(
			WH_CBT, 
			hookproc, 
			NULL, 
			GetCurrentThreadId()		// Only install for THIS thread!!!
			);
	}

	// Display a standard message box.
	retval = MessageBox(hwnd, szText, szCaption, uType);

	// Remove the window hook
	if (hookproc != NULL)
	{
		UnhookWindowsHookEx(hMsgBoxHook);
	}

	return retval;
}

typedef enum qwurl_regkey_e
{
	QWURL_DONT_ASK = 0,
	QWURL_ASK = 1,
	QWURL_ASK_IF_OTHER = 2
} qwurl_regkey_t;

//
// Sets the registry that decides if the QW URL dialog should be shown at startup or not.
//
void WinSetCheckQWURLRegKey(qwurl_regkey_t val)
{
	#define EZQUAKE_REG_SUBKEY			"Software\\ezQuake"
	#define EZQUAKE_REG_QWPROTOCOLKEY	"AskForQWProtocol"

	HKEY keyhandle;

	//
	// HKCU\Software\ezQuake
	//
	{
		DWORD dval = (DWORD)val;

		// Open / Create the key.
		if (RegCreateKeyEx(HKEY_CURRENT_USER, EZQUAKE_REG_SUBKEY, 
			0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &keyhandle, NULL))
		{
			Com_Printf_State(PRINT_WARNING, "Could not create HKCU\\"EZQUAKE_REG_SUBKEY"\n");
			return;
		}

		// Set the key value.
		if (RegSetValueEx(keyhandle, EZQUAKE_REG_QWPROTOCOLKEY, 0, REG_DWORD, (BYTE *)&dval, sizeof(DWORD)))
		{
			Com_Printf_State(PRINT_WARNING, "Could not set HKCU\\"EZQUAKE_REG_SUBKEY"\\"EZQUAKE_REG_QWPROTOCOLKEY"\n");
			RegCloseKey(keyhandle);
			return;
		}

		RegCloseKey(keyhandle);
	}
}

//
// Gets the registry value for the "HKCU\Software\ezQuake\AskForQWProtocol key"
//
qwurl_regkey_t WinGetCheckQWURLRegKey(void)
{
	HKEY keyhandle = NULL;
	DWORD returnval = QWURL_ASK;

	//
	// HKCU\Software\ezQuake
	//
	do
	{		
		DWORD val;
		DWORD type = REG_DWORD;
		DWORD size = sizeof(DWORD);
		LONG returnstatus;

		// Open the key.
		if ((returnstatus = RegOpenKeyEx(HKEY_CURRENT_USER, EZQUAKE_REG_SUBKEY, 0, KEY_ALL_ACCESS, &keyhandle)) != ERROR_SUCCESS)
		{
			Com_Printf_State(PRINT_WARNING, "Could not open HKCU\\"EZQUAKE_REG_SUBKEY", %l\n", returnstatus);
			break;
		}


		// Set the key value.
		if (RegQueryValueEx(keyhandle, EZQUAKE_REG_QWPROTOCOLKEY, 0, &type, (BYTE *)&val, &size))
		{
			Com_Printf_State(PRINT_WARNING, "Could not set HKCU\\"EZQUAKE_REG_SUBKEY"\\"EZQUAKE_REG_QWPROTOCOLKEY"\n");
			break;
		}

		returnval = (qwurl_regkey_t)val;
		break;	
	}
	while (0);

	if (keyhandle)
	{
		RegCloseKey(keyhandle);
	}

	return returnval;
}

//
// Check if we're the registered QW:// protocol handler, if not show a messagebox
// asking the user what to do. Returns false if the user wants to turn this check off.
//
qbool WinCheckQWURL(void)
{
	int retval;

	// Check the registry if we should ask at all. By relying on this
	// instead of the cfg, the user doesn't have to do a cfg_save after answering
	// "Don't ask me this again" to keep from getting bugged :D
	qwurl_regkey_t regstatus = WinGetCheckQWURLRegKey();

	switch (regstatus)
	{
		case QWURL_ASK:
			break;

		case QWURL_ASK_IF_OTHER:
			break;

		case QWURL_DONT_ASK:
			// Get out of here!!!
			return true;
	}

	if (Sys_CheckIfQWProtocolHandler()) {
		return true;
	}
	
	// Instead of creating a completly custom messagebox (which is a major pain)
	// just show a normal one, but replace the text on the buttons using event hooking.
	retval = MsgBoxEx(NULL, 
					"The current ezQuake client is not associated with the qw:// protocol,\n"
					"which lets you launch ezQuake by opening qw:// URLs (.qtv files).\n\n"
					"Do you want to associate ezQuake with the qw:// protocol?",
					"QW URL Protocol", QWURLProtocolButtonsHookProc, MB_YESNOCANCEL | MB_ICONWARNING);

	switch (retval)
	{
		case IDYES :
			Sys_RegisterQWURLProtocol_f();
			WinSetCheckQWURLRegKey(QWURL_ASK);
			return true;

		case IDNO :
			// Do nothing!
			return true;

		case IDCANCEL :
			// User doesn't want to be bugged anymore.
			WinSetCheckQWURLRegKey(QWURL_DONT_ASK);
			return false;
	}

	return true;
}

//
// Application entry point.
//
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) 
{
	int memsize, i;
	double time, oldtime, newtime;
	MEMORYSTATUS lpBuffer;

	global_hInstance = hInstance;

	WinCheckOSInfo();

	ParseCommandLine(lpCmdLine);

	// Check if we're the registered QW url protocol handler.
	if (!WinCheckQWURL() && ((argc + 3) < MAX_NUM_ARGVS))
	{
		// User doesn't want to be bothered again.
		argv[argc++] = "+cl_verify_qwprotocol";
		argv[argc++] = "0";
	}

	// We need to check some parms before Host_Init is called
	COM_InitArgv (argc, argv);

	// Let me use -condebug C:\condebug.log before Quake FS init, so I get ALL messages before quake fully init
	if ((i = COM_CheckParm(cmdline_param_console_debug)) && i < COM_Argc() - 1)
	{
		extern FILE *qconsole_log;
		char *s = COM_Argv(i + 1);
		if (*s != '-' && *s != '+')
			qconsole_log = fopen(s, "a");
	}

	Sys_DisableScreenSaving();

	// Take the greater of all the available memory or half the total memory,
	// but at least 8 Mb and no more than 32 Mb, unless they explicitly request otherwise
	lpBuffer.dwLength = sizeof(MEMORYSTATUS);
	GlobalMemoryStatus (&lpBuffer);

	// Maximum of 2GiB to work around signed int.
	if(lpBuffer.dwAvailPhys > 0x7FFFFFFF)
		lpBuffer.dwAvailPhys = 0x7FFFFFFF;

	if(lpBuffer.dwTotalPhys > 0x7FFFFFFF)
		lpBuffer.dwTotalPhys = 0x7FFFFFFF;

	memsize = lpBuffer.dwAvailPhys;

	if (memsize < MINIMUM_WIN_MEMORY)
		memsize = MINIMUM_WIN_MEMORY;

	if (memsize < (lpBuffer.dwTotalPhys >> 1))
		memsize = lpBuffer.dwTotalPhys >> 1;

	if (memsize > MAXIMUM_WIN_MEMORY)
		memsize = MAXIMUM_WIN_MEMORY;

	tevent = CreateEvent (NULL, FALSE, FALSE, NULL);
	if (!tevent)
		Sys_Error ("Couldn't create event");

	Sys_Init_();

	Sys_Printf ("Host_Init\n");
	Host_Init (argc, argv, memsize);

	oldtime = Sys_DoubleTime ();

    // Main window message loop.
	while (1) 
	{
		newtime = Sys_DoubleTime ();
		time = newtime - oldtime;
		Host_Frame (time);
		oldtime = newtime;

	}
    return TRUE;	/* return success of application */
}

void MakeDirent(sys_dirent *ent, WIN32_FIND_DATA *data)
{
    FILETIME ft1;

    strlcpy (ent->fname, data->cFileName, min(strlen(data->cFileName)+1, MAX_PATH_LENGTH));

	ent->size = (data->nFileSizeHigh > 0) ? 0xffffffff : data->nFileSizeLow;

    FileTimeToLocalFileTime(&data->ftLastWriteTime, &ft1);
    FileTimeToSystemTime(&ft1, &ent->time);

	ent->directory = (data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
	ent->hidden = (data->dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) ? 1 : 0;
}

SysDirEnumHandle Sys_ReadDirFirst(sys_dirent *ent)
{
    HANDLE search;
    WIN32_FIND_DATA data;

    search = FindFirstFile("*", &data);

    if (search == (HANDLE)ERROR_INVALID_HANDLE)
        return 0;

    MakeDirent(ent, &data);

    return (SysDirEnumHandle) search;
}

int Sys_ReadDirNext(SysDirEnumHandle search, sys_dirent *ent)
{
    WIN32_FIND_DATA data;
    if (!FindNextFile((HANDLE)search, &data))
        return 0;

    MakeDirent(ent, &data);
    return 1;
}

void Sys_ReadDirClose(SysDirEnumHandle search)
{
    FindClose((HANDLE)search);
}

int Sys_chdir (const char *path)
{
    if (SetCurrentDirectory(path))
        return 1;
    else
        return 0;
}

char * Sys_getcwd (char *buf, int bufsize)
{
    if (GetCurrentDirectory(bufsize, buf))
        return buf;
    else
        return NULL;
}

char *Sys_fullpath(char *absPath, const char *relPath, int maxLength)
{
    return _fullpath(absPath, relPath, maxLength);
} 

void Sys_GetFullExePath(char *path, unsigned int path_length, int long_name)
{
	GetModuleFileName(GetModuleHandle(NULL), path, path_length);

	if (!long_name)
	{
		GetShortPathName(path, path, path_length);
	}
}

#define EZQUAKE_MAILSLOT	"\\\\.\\mailslot\\ezquake"
#define MAILSLOT_BUFFERSIZE 1024

HANDLE ezquake_server_mailslot;

void Sys_InitIPC(void)
{	
	ezquake_server_mailslot = CreateMailslot( 
							  EZQUAKE_MAILSLOT,					// Mailslot name
							  MAILSLOT_BUFFERSIZE,              // Input buffer size 
							  0,								// Timeout
							  NULL);							// Default security attribute 
}

void Sys_CloseIPC(void)
{
	CloseHandle(ezquake_server_mailslot);
}

void Sys_ReadIPC(void)
{
	char buf[MAILSLOT_BUFFERSIZE] = {0};
	DWORD num_bytes_read = 0;

	if (INVALID_HANDLE_VALUE == ezquake_server_mailslot)
	{
		return;
	}

	// Read client message
	ReadFile( ezquake_server_mailslot,	// Handle to mailslot 
				buf,						// Buffer to receive data 
				sizeof(buf),				// Size of buffer 
				&num_bytes_read,			// Number of bytes read 
				NULL);						// Not overlapped I/O 
	if (num_bytes_read <= 0)
	{
		return;
	}

	COM_ParseIPCData(buf, num_bytes_read);
}

unsigned int Sys_SendIPC(const char *buf)
{
	HANDLE hMailslot;
	DWORD num_bytes_written;
	qbool result = false;

	// Connect to the server mailslot using CreateFile()
	hMailslot = CreateFile( EZQUAKE_MAILSLOT,		// Mailslot name 
							GENERIC_WRITE,			// Mailslot write only 
							FILE_SHARE_READ,		// Required for mailslots
							NULL,					// Default security attributes
							OPEN_EXISTING,			// Opens existing mailslot 
							FILE_ATTRIBUTE_NORMAL,	// Normal attributes 
							NULL);					// No template file 

	// Send the message to server.
	result = WriteFile( hMailslot,			// Handle to mailslot 
						buf,				// Buffer to write from 
						strlen(buf) + 1,	// Number of bytes to write, include the NULL
						&num_bytes_written,	// Number of bytes written 
						NULL);				// Not overlapped I/O

	 CloseHandle(hMailslot);
	 return result;
}

/********************************** SEMAPHORES *******************************/
/* Sys_Sem*() returns 0 on success; on error, -1 is returned */
int Sys_SemInit(sem_t *sem, int value, int max_value) 
{
	*sem = CreateSemaphore(NULL, value, max_value, NULL);// None named Semaphore
	if (*sem == NULL)
		return -1;
	return 0;
}

int Sys_SemWait(sem_t *sem) 
{
	if (WaitForSingleObject(*sem, INFINITE) == WAIT_FAILED)
		return -1;
	return 0;
}

int Sys_SemPost(sem_t *sem)
{
	if (ReleaseSemaphore(*sem, 1, NULL))
		return 0;
	return -1;
}

int Sys_SemDestroy(sem_t *sem)
{
	if (CloseHandle(*sem))
		return 0;
	return -1;
}

// Timer Resolution Requesting
void Sys_TimerResolution_InitSession(timerresolution_session_t * s)
{
	s->set = false;
	s->interval = 0;
}

void Sys_TimerResolution_RequestMinimum(timerresolution_session_t * s)
{
	TIMECAPS t;
	if (timeGetDevCaps(&t, sizeof(TIMECAPS)) == TIMERR_NOERROR) {
		if (timeBeginPeriod(t.wPeriodMin) == TIMERR_NOERROR) {
			s->set = true;
			s->interval = t.wPeriodMin;
		}
		else {
			Com_Printf("Error: Requesting minimum timer resolution failed\n");
		}
	}
	else {
		Com_Printf("Error: Failed querying timer device\n");
	}
}

void Sys_TimerResolution_Clear(timerresolution_session_t * s)
{
	if (s->set) {
		if (timeEndPeriod(s->interval) == TIMERR_NOERROR) {
			s->set = false;
		}
		else {
			Com_Printf("Error: Failed to clear timer resolution\n");
		}
	}
}

//========================================================================

int Sys_Script (const char *path, const char *args)
{
	STARTUPINFO			si;
	PROCESS_INFORMATION	pi;
	char cmdline[1024], curdir[MAX_OSPATH];

	memset (&si, 0, sizeof(si));
	si.cb = sizeof(si);
	si.dwFlags = STARTF_USESHOWWINDOW;
	si.wShowWindow = SW_SHOWMINNOACTIVE;

	GetCurrentDirectory(sizeof(curdir), curdir);


	snprintf(cmdline, sizeof(cmdline), "%s\\sh.exe %s.qws %s", curdir, path, args);
	strlcat(curdir, va("\\%s", fs_gamedir+2), MAX_OSPATH);

	return CreateProcess (NULL, cmdline, NULL, NULL,
	                      FALSE, 0/*DETACHED_PROCESS CREATE_NEW_CONSOLE*/ , NULL, curdir, &si, &pi);
}

//=========================================================================

DL_t Sys_DLOpen (const char *path)
{
	return LoadLibrary (path);
}

qbool Sys_DLClose (DL_t dl)
{
	return FreeLibrary (dl);
}

void *Sys_DLProc (DL_t dl, const char *name)
{
	return (void *) GetProcAddress (dl, name);
}

//===========================================================================

void Sys_CloseLibrary(dllhandle_t *lib)
{
	FreeLibrary((HMODULE)lib);
}

dllhandle_t *Sys_LoadLibrary(const char *name, dllfunction_t *funcs)
{
	int i;
	HMODULE lib;

	lib = LoadLibrary(name);
	if (!lib)
		return NULL;

	for (i = 0; funcs[i].name; i++)
	{
		*funcs[i].funcptr = GetProcAddress(lib, funcs[i].name);
		if (!*funcs[i].funcptr)
			break;
	}
	if (funcs[i].name)
	{
		Sys_CloseLibrary((dllhandle_t*)lib);
		lib = NULL;
	}

	return (dllhandle_t*)lib;
}

void *Sys_GetAddressForName(dllhandle_t *module, const char *exportname)
{
	if (!module)
		return NULL;
	return GetProcAddress((HINSTANCE)module, exportname);
}

// ===========================================================================

// Fakes a backspace character to take Windows out of deadkey mode
// See: https://github.com/ezQuake/ezquake-source/issues/101
// Bug is due to SDL not handling deadkeys correctly - this can probably
//     be removed in future, once library updated
// See: https://github.com/flibitijibibo/FNA-MGHistory/issues/277
void Sys_CancelDeadKey (void)
{
	INPUT input[2] = { { 0 } };
	input[0].type = input[1].type = INPUT_KEYBOARD;
	input[0].ki.wVk = input[1].ki.wVk = VK_BACK;
	input[1].ki.dwFlags = KEYEVENTF_KEYUP;
	SendInput (2, input, sizeof (INPUT));
}

const char* Sys_FontsDirectory(void)
{
	static char path[MAX_OSPATH];

	if (!SHGetSpecialFolderPath(NULL, path, CSIDL_FONTS, 0)) {
		path[0] = 0;
	}

	return path;
}

const char* Sys_HomeDirectory(void)
{
	static char path[MAX_OSPATH];

	// gets "C:\documents and settings\johnny\my documents" path
	if (!SHGetSpecialFolderPath(0, path, CSIDL_PERSONAL, 0)) {
		path[0] = 0;
	}

	// <Cokeman> yea, but it shouldn't be in My Documents
	// <Cokeman> it should be in the application data dir
	// c:\documents and settings\<user>\application data
	//if (!SHGetSpecialFolderPath(0, path, CSIDL_APPDATA, 0)) {
	//	path[0] = 0;
	//}

	return path;
}


================================================
FILE: src/teamplay.c
================================================
/*
Copyright (C) 2000-2003       Anton Gavrilov, A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    $Id: teamplay.c,v 1.96 2007-10-23 08:51:02 himan Exp $
*/

#include <time.h>
#include <string.h>
#include <limits.h>
#include "quakedef.h"
#include "ignore.h"
#include "gl_model.h"
#include "teamplay.h"
#include "rulesets.h"
#include "pmove.h"
#include "stats_grid.h"
#include "utils.h"
#include "qsound.h"
#include "tp_msgs.h"

#define CASE_PLAYER_COUNT_ALLOWED(c, fn) \
	case c: \
		if ((cl.fpd & FPD_ENABLE_PLAYER_COUNT)) { \
			macro_string = fn(); \
			break; \
		} else { \
			goto do_default; \
		}

void OnChangeSkinForcing(cvar_t *var, char *string, qbool *cancel);
void OnChangeColorForcing(cvar_t *var, char *string, qbool *cancel);
void OnChangeSkinAndColorForcing(cvar_t *var, char *string, qbool *cancel);

cvar_t cl_parseSay = {"cl_parseSay", "1"};
cvar_t cl_parseFunChars = {"cl_parseFunChars", "1"};
cvar_t cl_nofake = {"cl_nofake", "2"};
cvar_t tp_loadlocs = {"tp_loadlocs", "1"};
cvar_t tp_pointpriorities = {"tp_pointpriorities", "0"}; // FIXME: buggy
cvar_t tp_tookpriorities = {"tp_tookpriorities", "0"};
cvar_t tp_tooktimeout = {"tp_tooktimeout", "15"};
cvar_t tp_pointtimeout = {"tp_pointtimeout", "15"};
static cvar_t tp_poweruptextstyle = { "tp_poweruptextstyle", "0" };

cvar_t  cl_teamtopcolor = {"teamtopcolor", "-1", 0, OnChangeColorForcing};
cvar_t  cl_teambottomcolor = {"teambottomcolor", "-1", 0, OnChangeColorForcing};
cvar_t  cl_enemytopcolor = {"enemytopcolor", "-1", 0, OnChangeColorForcing};
cvar_t  cl_enemybottomcolor = {"enemybottomcolor", "-1", 0, OnChangeColorForcing};
cvar_t  cl_teamskin = {"teamskin", "", 0, OnChangeSkinForcing};
cvar_t  cl_enemyskin = {"enemyskin", "", 0, OnChangeSkinForcing};
cvar_t  cl_teamquadskin = {"teamquadskin", "", 0, OnChangeSkinForcing};
cvar_t  cl_enemyquadskin = {"enemyquadskin", "", 0, OnChangeSkinForcing};
cvar_t  cl_teampentskin = {"teampentskin", "", 0, OnChangeSkinForcing};
cvar_t  cl_enemypentskin = {"enemypentskin", "", 0, OnChangeSkinForcing};
cvar_t  cl_teambothskin = {"teambothskin", "", 0, OnChangeSkinForcing};
cvar_t  cl_enemybothskin = {"enemybothskin", "", 0, OnChangeSkinForcing};
cvar_t  cl_teamlock = {"teamlock", "0", 0, OnChangeSkinAndColorForcing};

cvar_t	tp_name_axe = {"tp_name_axe", "axe"};
cvar_t	tp_name_sg = {"tp_name_sg", "sg"};
cvar_t	tp_name_ssg = {"tp_name_ssg", "ssg"};
cvar_t	tp_name_ng = {"tp_name_ng", "ng"};
cvar_t	tp_name_sng = {"tp_name_sng", "sng"};
cvar_t	tp_name_gl = {"tp_name_gl", "gl"};
cvar_t	tp_name_rl = {"tp_name_rl", "{&cf13rl&cfff}"};
cvar_t	tp_name_lg = {"tp_name_lg", "{&c2aalg&cfff}"};
cvar_t	tp_name_rlg = {"tp_name_rlg", "{&cf13rl&cfff}{&c2aag&cfff}"};
cvar_t	tp_name_armortype_ra = {"tp_name_armortype_ra", "{&cf00r&cfff}"};
cvar_t	tp_name_armortype_ya = {"tp_name_armortype_ya", "{&cff0y&cfff}"};
cvar_t	tp_name_armortype_ga = {"tp_name_armortype_ga", "{&c0b0g&cfff}"};
cvar_t	tp_name_ra = {"tp_name_ra", "{&cf00ra&cfff}"};
cvar_t	tp_name_ya = {"tp_name_ya", "{&cff0ya&cfff}"};
cvar_t	tp_name_ga = {"tp_name_ga", "{&c0b0ga&cfff}"};
cvar_t	tp_name_quad = {"tp_name_quad", "{&c05fquad&cfff}"};
cvar_t	tp_name_pent = {"tp_name_pent", "{&cf00pent&cfff}"};
cvar_t	tp_name_ring = {"tp_name_ring", "{&cff0ring&cfff}"};
cvar_t	tp_name_suit = {"tp_name_suit", "suit"};
cvar_t	tp_name_shells = {"tp_name_shells", "shells"};
cvar_t	tp_name_nails = {"tp_name_nails", "nails"};
cvar_t	tp_name_rockets = {"tp_name_rockets", "rox"};
cvar_t	tp_name_cells = {"tp_name_cells", "cells"};
cvar_t	tp_name_mh = {"tp_name_mh", "{&c0a0mega&cfff}"};
cvar_t	tp_name_health = {"tp_name_health", "health"};
cvar_t	tp_name_armor = {"tp_name_armor", "armor"};
cvar_t	tp_name_weapon = {"tp_name_weapon", "weapon"};
cvar_t	tp_name_backpack = {"tp_name_backpack", "{&cf2apack&cfff}"};
cvar_t	tp_name_flag = {"tp_name_flag", "flag"};
cvar_t	tp_name_sentry = {"tp_name_sentry", "sentry gun"};
cvar_t	tp_name_disp = {"tp_name_disp", "dispenser"};
cvar_t	tp_name_filter = {"tp_name_filter", ""};
cvar_t	tp_name_rune1 = {"tp_name_rune1", "{&c0f0resistance&cfff}"};
cvar_t	tp_name_rune2 = {"tp_name_rune2", "{&cf00strength&cfff}"};
cvar_t	tp_name_rune3 = {"tp_name_rune3", "{&cff0haste&cfff}"};
cvar_t	tp_name_rune4 = {"tp_name_rune4", "{&c0ffregeneration&cfff}"};
cvar_t	tp_name_teammate = {"tp_name_teammate", ""};
cvar_t	tp_name_enemy = {"tp_name_enemy", "{&cf00enemy&cfff}"};
cvar_t	tp_name_eyes = {"tp_name_eyes", "{&cff0eyes&cfff}"};
cvar_t	tp_name_quaded = {"tp_name_quaded", "{&c05fquaded&cfff}"};
cvar_t	tp_name_pented = {"tp_name_pented", "{&cf00pented&cfff}"};
cvar_t	tp_name_nothing = {"tp_name_nothing", "nothing"};
cvar_t	tp_name_someplace = {"tp_name_someplace", "someplace"};
cvar_t	tp_name_at = {"tp_name_at", "at"};
cvar_t	tp_name_none = {"tp_name_none", ""};
cvar_t	tp_name_separator = {"tp_name_separator", "/"};
cvar_t	tp_weapon_order = {"tp_weapon_order", "78654321"};

cvar_t	tp_name_status_green = {"tp_name_status_green", "$G"};
cvar_t	tp_name_status_yellow = {"tp_name_status_yellow", "$Y"};
cvar_t	tp_name_status_red = {"tp_name_status_red", "$R"};
cvar_t	tp_name_status_blue = {"tp_name_status_blue", "$B"};
cvar_t	tp_name_status_white = {"tp_name_status_white", "$W"};

cvar_t	tp_need_ra = {"tp_need_ra", "120"};
cvar_t	tp_need_ya = {"tp_need_ya", "80"};
cvar_t	tp_need_ga = {"tp_need_ga", "60"};
cvar_t	tp_need_health = {"tp_need_health", "50"};
cvar_t	tp_need_weapon = {"tp_need_weapon", "87"};
cvar_t	tp_need_rl = {"tp_need_rl", "1"};
cvar_t	tp_need_rockets = {"tp_need_rockets", "5"};
cvar_t	tp_need_cells = {"tp_need_cells", "13"};
cvar_t	tp_need_nails = {"tp_need_nails", "0"}; // not so important, so let's not have it spam msg need
cvar_t	tp_need_shells = {"tp_need_shells", "0"}; // not so important, so let's not have it spam msg need

static qbool suppress;

char *skinforcing_team = "";

void TP_FindModelNumbers (void);
void TP_FindPoint (void);

static void CountNearbyPlayers(qbool dead);
char *Macro_LastTookOrPointed (void);
char *Macro_LastTookOrPointed2 (void);
void R_TranslatePlayerSkin (int playernum);

#define	POINT_TYPE_ITEM			1
#define POINT_TYPE_POWERUP		2
#define POINT_TYPE_TEAMMATE		3
#define	POINT_TYPE_ENEMY		4

#define TP_MACRO_ALIGNMENT_LEFT     0
#define TP_MACRO_ALIGNMENT_RIGHT    1
#define TP_MACRO_ALIGNMENT_CENTERED 2

tvars_t vars;

char lastip[64]; // FIXME: remove it

/*********************************** MACROS ***********************************/

#define MAX_MACRO_VALUE	256
static char	macro_buf[MAX_MACRO_VALUE] = "";

char *Macro_Lastip_f (void)
{
	snprintf (macro_buf, sizeof(macro_buf), "%s", lastip);
	return macro_buf;
}

char *Macro_Quote_f (void)
{
	return "\"";
}

char *Macro_Latency (void)
{
	snprintf(macro_buf, sizeof(macro_buf), "%i", Q_rint(cls.latency * 1000));
	return macro_buf;
}

char *Macro_Health (void)
{
	snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_HEALTH]);
	return macro_buf;
}

char *Macro_Armor (void)
{
	snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_ARMOR]);
	return macro_buf;
}

char *Macro_Shells (void)
{
	snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_SHELLS]);
	return macro_buf;
}

char *Macro_Nails (void)
{
	snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_NAILS]);
	return macro_buf;
}

char *Macro_Rockets (void)
{
	snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_ROCKETS]);
	return macro_buf;
}

char *Macro_Cells (void)
{
	snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_CELLS]);
	return macro_buf;
}

char *Macro_Ammo (void)
{
	snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_AMMO]);
	return macro_buf;
}

char *Macro_Weapon (void)
{
	return TP_ItemName(cl.stats[STAT_ACTIVEWEAPON]);
}

char *Macro_WeaponAndAmmo (void)
{
	char buf[MAX_MACRO_VALUE];
	snprintf (buf, sizeof(buf), "%s:%s", Macro_Weapon(), Macro_Ammo());
	strlcpy (macro_buf, buf, sizeof(macro_buf));
	return macro_buf;
}

char *Macro_WeaponNum (void)
{
	extern cvar_t cl_weaponpreselect;
	int best;

	if (cl_weaponpreselect.integer && (best = IN_BestWeapon(true))) {
		char buf[4];
		snprintf(buf, sizeof(buf), "%d", best);
		strlcpy(macro_buf, buf, sizeof(macro_buf));
		return macro_buf;
	}
	else {
		switch (cl.stats[STAT_ACTIVEWEAPON]) {
			case IT_AXE: return "1";
			case IT_SHOTGUN: return "2";
			case IT_SUPER_SHOTGUN: return "3";
			case IT_NAILGUN: return "4";
			case IT_SUPER_NAILGUN: return "5";
			case IT_GRENADE_LAUNCHER: return "6";
			case IT_ROCKET_LAUNCHER: return "7";
			case IT_LIGHTNING: return "8";
			default:
			return "0";
		}
	}
}

int BestWeapon (void)
{
	return BestWeaponFromStatItems (cl.stats[STAT_ITEMS]);
}

int BestWeaponFromStatItems (int stat)
{
	int i;
	char *t[] = {tp_weapon_order.string, "78654321", NULL}, **s;

	for (s = t; *s; s++) {
		for (i = 0 ; i < strlen(*s) ; i++) {
			switch ((*s)[i]) {
					case '1': if (stat & IT_AXE) return IT_AXE; break;
					case '2': if (stat & IT_SHOTGUN) return IT_SHOTGUN; break;
					case '3': if (stat & IT_SUPER_SHOTGUN) return IT_SUPER_SHOTGUN; break;
					case '4': if (stat & IT_NAILGUN) return IT_NAILGUN; break;
					case '5': if (stat & IT_SUPER_NAILGUN) return IT_SUPER_NAILGUN; break;
					case '6': if (stat & IT_GRENADE_LAUNCHER) return IT_GRENADE_LAUNCHER; break;
					case '7': if (stat & IT_ROCKET_LAUNCHER) return IT_ROCKET_LAUNCHER; break;
					case '8': if (stat & IT_LIGHTNING) return IT_LIGHTNING; break;
			}
		}
	}
	return 0;
}

char *Macro_BestWeapon (void)
{
	return TP_ItemName(BestWeapon());
}

char *TP_ItemName(int item_flag)
{
	switch (item_flag) {
		case IT_SHOTGUN: return tp_name_sg.string;
		case IT_SUPER_SHOTGUN: return tp_name_ssg.string;
		case IT_NAILGUN: return tp_name_ng.string;
		case IT_SUPER_NAILGUN: return tp_name_sng.string;
		case IT_GRENADE_LAUNCHER: return tp_name_gl.string;
		case IT_ROCKET_LAUNCHER: return tp_name_rl.string;
		case IT_LIGHTNING: return tp_name_lg.string;
		case IT_SUPER_LIGHTNING: return "slg";
		case IT_SHELLS: return tp_name_shells.string;
		case IT_NAILS: return tp_name_nails.string;
		case IT_ROCKETS: return tp_name_rockets.string;
		case IT_CELLS: return tp_name_cells.string;
		case IT_AXE: return tp_name_axe.string;
		case IT_ARMOR1: return tp_name_ga.string;
		case IT_ARMOR2: return tp_name_ya.string;
		case IT_ARMOR3: return tp_name_ra.string;
		case IT_SUPERHEALTH: return tp_name_mh.string;
		case IT_KEY1: return "key1";
		case IT_KEY2: return "key2";
		case IT_INVISIBILITY: return tp_name_ring.string;
		case IT_INVULNERABILITY: return tp_name_pent.string;
		case IT_SUIT: return tp_name_suit.string;
		case IT_QUAD: return tp_name_quad.string;
		case IT_SIGIL1: return tp_name_rune1.string;
		case IT_SIGIL2: return tp_name_rune2.string;
		case IT_SIGIL3: return tp_name_rune3.string;
		case IT_SIGIL4: return tp_name_rune4.string;
		default: return tp_name_none.string;
	}
}

char *Macro_BestAmmo (void)
{
	switch (BestWeapon()) {
			case IT_SHOTGUN: case IT_SUPER_SHOTGUN:
			snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_SHELLS]);
			return macro_buf;

			case IT_NAILGUN: case IT_SUPER_NAILGUN:
			snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_NAILS]);
			return macro_buf;

			case IT_GRENADE_LAUNCHER: case IT_ROCKET_LAUNCHER:
			snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_ROCKETS]);
			return macro_buf;

			case IT_LIGHTNING:
			snprintf(macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_CELLS]);
			return macro_buf;

			default: return "0";
	}
}

// needed for %b parsing
char *Macro_BestWeaponAndAmmo (void)
{
	char buf[MAX_MACRO_VALUE];

	snprintf (buf, sizeof(buf), "%s:%s", Macro_BestWeapon(), Macro_BestAmmo());

	strlcpy (macro_buf, buf, sizeof(macro_buf));
	return macro_buf;
}

char *Macro_Colored_Armor_f (void)
{
    snprintf(macro_buf, sizeof(macro_buf), "%s", TP_MSG_Colored_Armor());
    return macro_buf;
}

char *Macro_Colored_Powerups_f (void)
{
	snprintf (macro_buf, sizeof(macro_buf), "%s", TP_MSG_Colored_Powerup());
	return macro_buf;
}

char *Macro_Colored_Short_Powerups_f (void) // same as above, but displays "qrp" instead of "quad ring pent"
{
	snprintf (macro_buf, sizeof(macro_buf), "%s", TP_MSG_Colored_Short_Powerups());
	return macro_buf;
}

char* Macro_Teamplay_Powerups_f(void)
{
	if (tp_poweruptextstyle.integer) {
		return Macro_Colored_Short_Powerups_f();
	}
	return Macro_Colored_Powerups_f();
}

char *Macro_ArmorType (void)
{
	if (cl.stats[STAT_ITEMS] & IT_ARMOR1)
		return tp_name_armortype_ga.string;
	else if (cl.stats[STAT_ITEMS] & IT_ARMOR2)
		return tp_name_armortype_ya.string;
	else if (cl.stats[STAT_ITEMS] & IT_ARMOR3)
		return tp_name_armortype_ra.string;
	else
		return tp_name_none.string;
}

char *Macro_Powerups (void)
{
	int effects;

	macro_buf[0] = 0;

	if (cl.stats[STAT_ITEMS] & IT_QUAD)
		strlcpy(macro_buf, tp_name_quad.string, sizeof(macro_buf));

	if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_pent.string, sizeof(macro_buf));
	}

	if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_ring.string, sizeof(macro_buf));
	}

	effects = cl.frames[cl.parsecount & UPDATE_MASK].playerstate[cl.playernum].effects;
	if ( (effects & (EF_FLAG1|EF_FLAG2)) /* CTF */ ||
	        (cl.teamfortress && cl.stats[STAT_ITEMS] & (IT_KEY1|IT_KEY2)) /* TF */ ) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_flag.string, sizeof(macro_buf));
	}

	if (!macro_buf[0])
		strlcpy(macro_buf, tp_name_none.string, sizeof(macro_buf));

	return macro_buf;
}

char *Macro_Location (void)
{
	strlcpy(vars.lastreportedloc, TP_LocationName(cl.simorg), sizeof(vars.lastreportedloc));

	return vars.lastreportedloc;
}

char *Macro_LastDeath (void)
{
	return vars.deathtrigger_time ? vars.lastdeathloc : tp_name_someplace.string;
}

char *Macro_Last_Location (void)
{
	if (vars.deathtrigger_time && cls.realtime - vars.deathtrigger_time <= 5)
		strlcpy(vars.lastreportedloc, vars.lastdeathloc, sizeof(vars.lastreportedloc));
	else
		strlcpy(vars.lastreportedloc, TP_LocationName(cl.simorg), sizeof(vars.lastreportedloc));
	return vars.lastreportedloc;
}

char *Macro_LastReportedLoc(void)
{
	if (!vars.lastreportedloc[0])
		return tp_name_someplace.string;
	return vars.lastreportedloc;
}

char *Macro_Rune (void)
{
	if (cl.stats[STAT_ITEMS] & IT_SIGIL1)
		return tp_name_rune1.string;
	else if (cl.stats[STAT_ITEMS] & IT_SIGIL2)
		return tp_name_rune2.string;
	else if (cl.stats[STAT_ITEMS] & IT_SIGIL3)
		return tp_name_rune3.string;
	else if (cl.stats[STAT_ITEMS] & IT_SIGIL4)
		return tp_name_rune4.string;
	else
		return "";
}

char *Macro_Time (void)
{
	time_t t;
	struct tm *ptm;

	time (&t);
	if (!(ptm = localtime (&t)))
		return "#bad date#";
	strftime (macro_buf, sizeof(macro_buf) - 1, "%H:%M", ptm);
	return macro_buf;
}

char *Macro_Date (void)
{
	time_t t;
	struct tm *ptm;

	time (&t);
	if (!(ptm = localtime (&t)))
		return "#bad date#";
	strftime (macro_buf, sizeof(macro_buf) - 1, "%d.%m.%y", ptm);
	return macro_buf;
}

char *Macro_DateIso(void) {
	time_t t;
	struct tm *ptm;

	time (&t);
	if (!(ptm = localtime (&t)))
		return "#bad date#";
	strftime (macro_buf, sizeof(macro_buf) - 1, "%Y-%m-%d_%H-%M", ptm);
	return macro_buf;
}

char* Macro_TimeStamp(void)
{
	time_t t;
	struct tm* ptm;

	time(&t);
	if (!(ptm = localtime(&t)))
		return "_baddate_";

	strftime(macro_buf, sizeof(macro_buf) - 1, "%Y%m%d-%H%M", ptm);
	return macro_buf;
}

// returns the last item picked up
char *Macro_Took (void)
{
	if (TOOK_EMPTY())
		strlcpy (macro_buf, tp_name_nothing.string, sizeof(macro_buf));
	else
		strlcpy (macro_buf, vars.tookname, sizeof(macro_buf));
	return macro_buf;
}

// returns location of the last item picked up
char *Macro_TookLoc (void)
{
	if (TOOK_EMPTY())
		strlcpy (macro_buf, tp_name_someplace.string, sizeof(macro_buf));
	else
		strlcpy (macro_buf, vars.tookloc, sizeof(macro_buf));
	return macro_buf;
}

// %i macro - last item picked up in "name at location" style
char *Macro_TookAtLoc (void)
{
	if (TOOK_EMPTY())
		strlcpy (macro_buf, tp_name_nothing.string, sizeof(macro_buf));
	else {
		strlcpy (macro_buf, va("%s %s %s", vars.tookname, tp_name_at.string, vars.tookloc), sizeof(macro_buf));
	}
	return macro_buf;
}

// pointing calculations are CPU expensive, so the results are cached
// in vars.pointname & vars.pointloc
char *Macro_PointName (void)
{
	if (flashed) // there should be more smart way to do it
		return tp_name_nothing.string;

	TP_FindPoint ();
	return vars.pointname;
}

char *Macro_PointLocation (void)
{
	if (flashed) // there should be more smart way to do it
		return tp_name_nothing.string;

	TP_FindPoint ();
	return vars.pointloc[0] ? vars.pointloc : Macro_Location();
}

char *Macro_LastPointAtLoc (void)
{
	if (!vars.pointtime || cls.realtime - vars.pointtime > tp_pointtimeout.value)
		strlcpy (macro_buf, tp_name_nothing.string, sizeof(macro_buf));
	else
		snprintf (macro_buf, sizeof(macro_buf), "%s %s %s", vars.pointname, tp_name_at.string, vars.pointloc[0] ? vars.pointloc : Macro_Location());
	return macro_buf;
}

char *Macro_PointNameAtLocation (void)
{
	if (flashed) // there should be more smart way to do it
		return tp_name_nothing.string;

	TP_FindPoint();
	return Macro_LastPointAtLoc();
}

char *Macro_Weapons (void)
{
	macro_buf[0] = 0;

	if (cl.stats[STAT_ITEMS] & IT_LIGHTNING)
		strlcpy(macro_buf, tp_name_lg.string, sizeof(macro_buf));

	if (cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_rl.string, sizeof(macro_buf));
	}
	if (cl.stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_gl.string, sizeof(macro_buf));
	}
	if (cl.stats[STAT_ITEMS] & IT_SUPER_NAILGUN) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_sng.string, sizeof(macro_buf));
	}
	if (cl.stats[STAT_ITEMS] & IT_NAILGUN) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_ng.string, sizeof(macro_buf));
	}
	if (cl.stats[STAT_ITEMS] & IT_SUPER_SHOTGUN) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_ssg.string, sizeof(macro_buf));
	}
	if (cl.stats[STAT_ITEMS] & IT_SHOTGUN) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_sg.string, sizeof(macro_buf));
	}
	if (cl.stats[STAT_ITEMS] & IT_AXE) {
		if (macro_buf[0])
			strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat(macro_buf, tp_name_axe.string, sizeof(macro_buf));
	}

	if (!macro_buf[0])
		strlcpy(macro_buf, tp_name_none.string, sizeof(macro_buf));

	return macro_buf;
}

static char *Skin_To_TFSkin (char *myskin) // These four TF classes don't have their full names as the skin (i.e. they have tf_snipe instead of tf_sniper)
{
	if (!cl.teamfortress || cl.spectator || strncasecmp(myskin, "tf_", 3)) {
		strlcpy(macro_buf, myskin, sizeof(macro_buf));
	} else {
		if (!strcasecmp(myskin, "tf_demo"))
			strlcpy(macro_buf, "demoman", sizeof(macro_buf));
		else if (!strcasecmp(myskin, "tf_eng"))
			strlcpy(macro_buf, "engineer", sizeof(macro_buf));
		else if (!strcasecmp(myskin, "tf_snipe"))
			strlcpy(macro_buf, "sniper", sizeof(macro_buf));
		else if (!strcasecmp(myskin, "tf_sold"))
			strlcpy(macro_buf, "soldier", sizeof(macro_buf));
		else
			strlcpy(macro_buf, myskin + 3, sizeof(macro_buf));
	}
	return macro_buf;
}

char *Macro_TF_Skin (void)
{
	return Skin_To_TFSkin(Info_ValueForKey(cl.players[cl.playernum].userinfo, "skin"));
}

char *Macro_LastDrop (void)
{
	if (vars.lastdrop_time)
		return vars.lastdroploc;
	else
		return tp_name_someplace.string;
}

char *Macro_GameDir(void)
{
	snprintf(macro_buf, sizeof (macro_buf), "%s", cls.gamedirfile);
	return macro_buf;
}

char *Macro_LastTrigger_Match(void)
{
	return vars.lasttrigger_match;
}

char *Macro_LastDropTime (void)
{
	if (vars.lastdrop_time)
		snprintf (macro_buf, sizeof (macro_buf), "%d", (int) (cls.realtime - vars.lastdrop_time));
	else
		snprintf (macro_buf, sizeof (macro_buf), "%d", -1);
	return macro_buf;
}

// fixme: rewrite this function into two separate functions
// first will just set vars.needflags value (put into TP_GetNeed function below)
// second will read it's value and produce appropriate $need macro string
char *Macro_Need (void)
{
	int i, weapon;
	char *needammo = NULL;

	macro_buf[0] = 0;
	vars.needflags = 0;

	// check armor
	if (((cl.stats[STAT_ITEMS] & IT_ARMOR1) && cl.stats[STAT_ARMOR] < tp_need_ga.value)
		|| ((cl.stats[STAT_ITEMS] & IT_ARMOR2) && cl.stats[STAT_ARMOR] < tp_need_ya.value)
		|| ((cl.stats[STAT_ITEMS] & IT_ARMOR3) && cl.stats[STAT_ARMOR] < tp_need_ra.value)
		|| (!(cl.stats[STAT_ITEMS] & (IT_ARMOR1|IT_ARMOR2|IT_ARMOR3))
		&& (tp_need_ga.value || tp_need_ya.value || tp_need_ra.value))
	   )
	{
		strlcpy (macro_buf, tp_name_armor.string, sizeof(macro_buf));
		vars.needflags |= it_armor;
	}

	// check health
	if (tp_need_health.value && cl.stats[STAT_HEALTH] < tp_need_health.value) {
		if (macro_buf[0])
			strlcat (macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat (macro_buf, tp_name_health.string, sizeof(macro_buf));
		vars.needflags |= it_health;
	}

	if (cl.teamfortress) {
		if (cl.stats[STAT_ROCKETS] < tp_need_rockets.value)	{
			if (macro_buf[0])
				strlcat (macro_buf, tp_name_separator.string, sizeof(macro_buf));
			strlcat (macro_buf, tp_name_rockets.string, sizeof(macro_buf));
			vars.needflags |= it_rockets;
		}
		if (cl.stats[STAT_SHELLS] < tp_need_shells.value) {
			if (macro_buf[0])
				strlcat (macro_buf, tp_name_separator.string, sizeof(macro_buf));
			strlcat (macro_buf, tp_name_shells.string, sizeof(macro_buf));
			vars.needflags |= it_shells;
		}
		if (cl.stats[STAT_NAILS] < tp_need_nails.value)	{
			if (macro_buf[0])
				strlcat (macro_buf, tp_name_separator.string, sizeof(macro_buf));
			strlcat (macro_buf, tp_name_nails.string, sizeof(macro_buf));
			vars.needflags |= it_nails;
		}
		if (cl.stats[STAT_CELLS] < tp_need_cells.value)	{
			if (macro_buf[0])
				strlcat (macro_buf, tp_name_separator.string, sizeof(macro_buf));
			strlcat (macro_buf, tp_name_cells.string, sizeof(macro_buf));
			vars.needflags |= it_cells;
		}
		goto done;
	}

	// check weapon
	weapon = 0;
	for (i = strlen(tp_need_weapon.string) - 1 ; i >= 0 ; i--) {
		switch (tp_need_weapon.string[i]) {
				case '2': if (cl.stats[STAT_ITEMS] & IT_SHOTGUN) weapon = 2; break;
				case '3': if (cl.stats[STAT_ITEMS] & IT_SUPER_SHOTGUN) weapon = 3; break;
				case '4': if (cl.stats[STAT_ITEMS] & IT_NAILGUN) weapon = 4; break;
				case '5': if (cl.stats[STAT_ITEMS] & IT_SUPER_NAILGUN) weapon = 5; break;
				case '6': if (cl.stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER) weapon = 6; break;
				case '7': if (cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER) weapon = 7; break;
				case '8': if (cl.stats[STAT_ITEMS] & IT_LIGHTNING) weapon = 8; break;
		}
		if (weapon)
			break;
	}

	if (!weapon) {
		if (macro_buf[0])
			strlcat (macro_buf, tp_name_separator.string, sizeof(macro_buf));
		strlcat (macro_buf, tp_name_weapon.string, sizeof(macro_buf));
		vars.needflags |= it_weapons;
	} else {
		if (tp_need_rl.value && !(cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER)) {
			if (macro_buf[0])
				strlcat (macro_buf, tp_name_separator.string, sizeof(macro_buf));
			strlcat (macro_buf, tp_name_rl.string, sizeof(macro_buf));
			vars.needflags |= it_rl;
		}

		switch (weapon) {
				case 2: case 3: if (cl.stats[STAT_SHELLS] < tp_need_shells.value) {
					needammo = tp_name_shells.string;
					vars.needflags |= it_shells;
				}
				break;
				case 4: case 5: if (cl.stats[STAT_NAILS] < tp_need_nails.value) {
					needammo = tp_name_nails.string;
					vars.needflags |= it_nails;
				}
				break;
				case 6: case 7: if (cl.stats[STAT_ROCKETS] < tp_need_rockets.value) {
					needammo = tp_name_rockets .string;
					vars.needflags |= it_rockets;
				} break;
				case 8: if (cl.stats[STAT_CELLS] < tp_need_cells.value) {
					needammo = tp_name_cells.string;
					vars.needflags |= it_cells;
				} break;
		}

		if (needammo) {
			if (macro_buf[0])
				strlcat (macro_buf, tp_name_separator.string, sizeof(macro_buf));
			strlcat (macro_buf, needammo, sizeof(macro_buf));
			vars.needflags |= it_ammo;
		}
	}

done:
	if (!macro_buf[0])
		strlcpy (macro_buf, tp_name_nothing.string, sizeof(macro_buf));

	return macro_buf;
}

void TP_GetNeed(void)
{
	Macro_Need();
}

char *Macro_Point_LED(void)
{
	TP_FindPoint();

	if (vars.pointtype == POINT_TYPE_ENEMY)
		return tp_name_status_red.string;
	else if (vars.pointtype == POINT_TYPE_TEAMMATE)
		return tp_name_status_green.string;
	else if (vars.pointtype == POINT_TYPE_POWERUP)
		return tp_name_status_yellow.string;
	else // POINT_TYPE_ITEM
		return tp_name_status_blue.string;
}

static int Macro_TeamSort(const void* lhs_, const void* rhs_)
{
	const char* lhs = *(const char**)lhs_;
	const char* rhs = *(const char**)rhs_;

	return Q_strcmp2(lhs, rhs);
}

static const char* Macro_TeamPick(int team_number, const char* default_teamname)
{
	int i, j;
	int team_count = 0;
	const char* teamnames[MAX_CLIENTS];


	for (i = 0; i < sizeof(cl.players) / sizeof(cl.players[0]); ++i) {
		if (cl.players[i].name[0] && !cl.players[i].spectator) {
			const char* team = (cl.teamplay ? cl.players[i].team : cl.players[i].name);

			for (j = 0; j < team_count; ++j) {
				if (!strcmp(team, teamnames[j])) {
					break;
				}
			}

			if (j >= team_count && team_count < sizeof(teamnames) / sizeof(teamnames[0])) {
				teamnames[team_count++] = team;
			}
		}
	}

	if (team_count > team_number) {
		qsort((void*)teamnames, team_count, sizeof(teamnames[0]), Macro_TeamSort);

		return teamnames[team_number];
	}
	else {
		return default_teamname;
	}
}

char *Macro_Team1(void)
{
	static char buffer[MAX_MACRO_VALUE];

	strlcpy(buffer, Macro_TeamPick(0, "team1"), sizeof(buffer));

	return buffer;
}

char* Macro_Team2(void)
{
	static char buffer[MAX_MACRO_VALUE];

	strlcpy(buffer, Macro_TeamPick(1, "team2"), sizeof(buffer));

	return buffer;
}

char *Macro_MyStatus_LED(void)
{
	int count;
	float save_need_rl;
	char *s, *save_separator;
	static char separator[] = {'/', '\0'};

	save_need_rl = tp_need_rl.value;
	save_separator = tp_name_separator.string;
	tp_need_rl.value = 0;
	tp_name_separator.string = separator;
	s = Macro_Need();
	tp_need_rl.value = save_need_rl;
	tp_name_separator.string = save_separator;

	if (!strcmp(s, tp_name_nothing.string)) {
		count = 0;
	} else  {
		for (count = 1; *s; s++)
			if (*s == separator[0])
				count++;
	}

	if (count == 0)
		snprintf(macro_buf, sizeof(macro_buf), "%s", tp_name_status_green.string);
	else if (count <= 1)
		snprintf(macro_buf, sizeof(macro_buf), "%s", tp_name_status_yellow.string);
	else
		snprintf(macro_buf, sizeof(macro_buf), "%s", tp_name_status_red.string);

	return macro_buf;
}

char *Macro_EnemyStatus_LED(void)
{
	CountNearbyPlayers(false);
	if (vars.numenemies == 0)
		snprintf(macro_buf, sizeof(macro_buf), "\xffl%s\xff", tp_name_status_green.string);
	else if (vars.numenemies <= vars.numfriendlies)
		snprintf(macro_buf, sizeof(macro_buf), "\xffl%s\xff", tp_name_status_yellow.string);
	else
		snprintf(macro_buf, sizeof(macro_buf), "\xffl%s\xff", tp_name_status_red.string);

	suppress = true;
	return macro_buf;
}


#define TP_PENT 1
#define TP_QUAD 2
#define TP_RING 4

char *Macro_LastSeenPowerup(void)
{
	if (!vars.enemy_powerups_time || cls.realtime - vars.enemy_powerups_time > 5) {
		strlcpy(macro_buf, tp_name_quad.string, sizeof(macro_buf));
	} else {
		macro_buf[0] = 0;
		if (vars.enemy_powerups & TP_QUAD)
			strlcat(macro_buf, tp_name_quad.string, sizeof(macro_buf));
		if (vars.enemy_powerups & TP_PENT) {
			if (macro_buf[0])
				strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
			strlcat(macro_buf, tp_name_pent.string, sizeof(macro_buf));
		}
		if (vars.enemy_powerups & TP_RING) {
			if (macro_buf[0])
				strlcat(macro_buf, tp_name_separator.string, sizeof(macro_buf));
			strlcat(macro_buf, tp_name_ring.string, sizeof(macro_buf));
		}
	}
	return macro_buf;
}

qbool TP_SuppressMessage (wchar *buf)
{
	size_t len;
	wchar *s;

	if ((len = qwcslen (buf)) < 4)
		return false;

	s = buf + len - 4;

	if (s[0] == 0x7F && s[1] == '!' && s[3] == '\n') {
		*s++ = '\n';
		*s++ = 0;
		return (!cls.demoplayback && !cl.spectator && *s - 'A' == cl.playernum);
	}

	return false;
}

// things like content '%e' macro get hidden in here causing you yourself cannot see
// how many enemies are around you, the number get replaced with a 'x' char
// and then printed on screen as a message
void TP_PrintHiddenMessage(char *buf, int nodisplay)
{
	qbool team, hide = false;
	char dest[4096], msg[4096], *s, *d, c, *name;
	int length, offset, flags;
	extern cvar_t con_sound_mm2_file, con_sound_mm2_volume, cl_fakename, cl_fakename_suffix;

	if (!buf || !(length = strlen(buf)))
		return;

	team = !strcasecmp("say_team", Cmd_Argv(0));

	if (length >= 2 && buf[0] == '\"' && buf[length - 1] == '\"') {
		memmove(buf, buf + 1, length - 2);
		buf[length - 2] = 0;
	}

	s = buf;
	d = dest;

	while ((c = *s++) && (c != '\x7f')) {
		if (c == '\xff') {
			if ((hide = !hide)) {
				*d++ = (*s == 'z') ? 'x' : (char)139;
				s++;
				memmove(s - 2, s, strlen(s) + 1);
				s -= 2;
			} else {
				memmove(s - 1, s, strlen(s) + 1);
				s -= 1;
			}
		} else if (!hide) {
			*d++ = c;
		}
	}
	*d = 0;

	if (cls.demoplayback)
		return;

	// Player is ignoring themselves
	if (cl.players[cl.playernum].ignored) {
		return;
	}

	name = Info_ValueForKey (cl.players[cl.playernum].userinfo, "name");
	if (strlen(name) >= 32)
		name[31] = 0;

	if (team)
    {
        if (cl_fakename.string[0])
        {
        	char c_fn[1024], c_fna[1024];
        	strlcpy (c_fn, cl_fakename.string, sizeof(c_fn));
        	strlcpy (c_fna, cl_fakename_suffix.string, sizeof(c_fna));

			snprintf(msg, sizeof(msg), "%s\n", TP_ParseFunChars(strcat(strcat(c_fn, c_fna), dest) , true));
        }
        else
        {
            snprintf(msg, sizeof(msg), "(%s): %s\n", name, TP_ParseFunChars(dest, true));
        }
    }
	else
	{
		snprintf(msg, sizeof(msg), "%s: %s\n", name, TP_ParseFunChars(dest, true));
	}

	flags = TP_CategorizeMessage (msg, &offset);

	if (flags == msgtype_team && !TP_FilterMessage(str2wcs(msg) + offset))
		return;

	if (con_sound_mm2_volume.value > 0 && nodisplay == 0) {
		S_LocalSoundWithVol(con_sound_mm2_file.string, con_sound_mm2_volume.value);
	}

	if (cl_nofake.value == 1 || (cl_nofake.value == 2 && flags != msgtype_team)) {
		for (s = msg; *s; s++)
			if (*s == 0x0D || (*s == 0x0A && s[1]))
				*s = ' ';
	}

	if (nodisplay == 0) {
		Com_Printf(wcs2str(TP_ParseWhiteText (str2wcs(msg), team, offset)));
	}

}

static void CountNearbyPlayers(qbool dead)
{
	int i;
	player_state_t *state;
	player_info_t *info;
	static int lastframecount = -1;

	if (cls.framecount == lastframecount)
		return;
	lastframecount = cls.framecount;

	vars.numenemies = vars.numfriendlies = 0;

	if (!cl.spectator && !dead)
		vars.numfriendlies++;

	if (!cl.oldparsecount || !cl.parsecount || cls.state < ca_active)
		return;

	state = cl.frames[cl.oldparsecount & UPDATE_MASK].playerstate;
	info = cl.players;
	for (i = 0; i < MAX_CLIENTS; i++, info++, state++) {
		if (i != cl.playernum && state->messagenum == cl.oldparsecount && !info->spectator && !ISDEAD(state->frame)) {
			if (cl.teamplay && !strcmp(info->team, TP_PlayerTeam()))
				vars.numfriendlies++;
			else
				vars.numenemies++;
		}
	}
}

char *Macro_CountNearbyEnemyPlayers (void)
{
	const char* override_text = Ruleset_BlockPlayerCountMacros();

	if (override_text) {
		strlcpy(macro_buf, "\xff", sizeof(macro_buf));
		strlcat(macro_buf, override_text, sizeof(macro_buf));
		strlcat(macro_buf, "\xff", sizeof(macro_buf));
	}
	else {
		CountNearbyPlayers(false);
		snprintf(macro_buf, sizeof(macro_buf), "\xffz%d\xff", vars.numenemies);
		suppress = true;
	}
	return macro_buf;
}

char *Macro_Count_Last_NearbyEnemyPlayers (void)
{
	const char* override_text = Ruleset_BlockPlayerCountMacros();

	if (override_text) {
		strlcpy(macro_buf, override_text, sizeof(macro_buf));
	}
	else {
		if (vars.deathtrigger_time && cls.realtime - vars.deathtrigger_time <= 5) {
			snprintf(macro_buf, sizeof(macro_buf), "\xffz%d\xff", vars.last_numenemies);
		}
		else {
			CountNearbyPlayers(false);
			snprintf(macro_buf, sizeof(macro_buf), "\xffz%d\xff", vars.numenemies);
		}
		suppress = true;
	}
	return macro_buf;
}

char *Macro_CountNearbyFriendlyPlayers (void)
{
	const char* override_text = Ruleset_BlockPlayerCountMacros();

	if (override_text) {
		strlcpy(macro_buf, override_text, sizeof(macro_buf));
	}
	else {
		CountNearbyPlayers(false);
		snprintf(macro_buf, sizeof(macro_buf), "\xffz%d\xff", vars.numfriendlies);
		suppress = true;
	}
	return macro_buf;
}

char* Macro_Count_Last_NearbyFriendlyPlayers (void)
{
	const char* override_text = Ruleset_BlockPlayerCountMacros();

	if (override_text) {
		strlcpy(macro_buf, override_text, sizeof(macro_buf));
	}
	else {
		if (vars.deathtrigger_time && cls.realtime - vars.deathtrigger_time <= 5) {
			snprintf(macro_buf, sizeof(macro_buf), "\xffz%d\xff", vars.last_numfriendlies);
		}
		else {
			CountNearbyPlayers(false);
			snprintf(macro_buf, sizeof(macro_buf), "\xffz%d\xff", vars.numfriendlies);
		}
		suppress = true;
	}
	return macro_buf;
}

// Note: longer macro names like "armortype" must be defined
// _before_ the shorter ones like "armor" to be parsed properly
void TP_AddMacros(void)
{
	int teamplay = (int)Rulesets_RestrictTriggers();

	Cmd_AddMacro(macro_lastip, Macro_Lastip_f);
	Cmd_AddMacro(macro_qt, Macro_Quote_f);
	Cmd_AddMacro(macro_latency, Macro_Latency);
	Cmd_AddMacro(macro_ping, Macro_Latency);
	Cmd_AddMacro(macro_timestamp, Macro_TimeStamp);
	Cmd_AddMacro(macro_time, Macro_Time);
	Cmd_AddMacro(macro_date, Macro_Date);
	Cmd_AddMacro(macro_dateiso, Macro_DateIso);

	Cmd_AddMacroEx(macro_health, Macro_Health, teamplay);
	Cmd_AddMacroEx(macro_armortype, Macro_ArmorType, teamplay);
	Cmd_AddMacroEx(macro_armor, Macro_Armor, teamplay);
	Cmd_AddMacroEx(macro_colored_armor, Macro_Colored_Armor_f, teamplay);
	Cmd_AddMacroEx(macro_colored_powerups, Macro_Colored_Powerups_f, teamplay);
	Cmd_AddMacroEx(macro_colored_short_powerups, Macro_Colored_Short_Powerups_f, teamplay);
	Cmd_AddMacroEx(macro_tp_powerups, Macro_Teamplay_Powerups_f, teamplay);

	Cmd_AddMacroEx(macro_shells, Macro_Shells, teamplay);
	Cmd_AddMacroEx(macro_nails, Macro_Nails, teamplay);
	Cmd_AddMacroEx(macro_rockets, Macro_Rockets, teamplay);
	Cmd_AddMacroEx(macro_cells, Macro_Cells, teamplay);

	Cmd_AddMacro(macro_weaponnum, Macro_WeaponNum);
	Cmd_AddMacroEx(macro_weapons, Macro_Weapons, teamplay);
	Cmd_AddMacro(macro_weapon, Macro_Weapon);

	Cmd_AddMacroEx(macro_ammo, Macro_Ammo, teamplay);

	Cmd_AddMacroEx(macro_bestweapon, Macro_BestWeapon, teamplay);
	Cmd_AddMacroEx(macro_bestammo, Macro_BestAmmo, teamplay);

	Cmd_AddMacroEx(macro_powerups, Macro_Powerups, teamplay);

	Cmd_AddMacroEx(macro_location, Macro_Location, teamplay);
	Cmd_AddMacroEx(macro_deathloc, Macro_LastDeath, teamplay);

	Cmd_AddMacroEx(macro_tookatloc, Macro_TookAtLoc, teamplay);
	Cmd_AddMacroEx(macro_tookloc, Macro_TookLoc, teamplay);
	Cmd_AddMacroEx(macro_took, Macro_Took, teamplay);

	Cmd_AddMacroEx(macro_pointatloc, Macro_PointNameAtLocation, teamplay);
	Cmd_AddMacroEx(macro_pointloc, Macro_PointLocation, teamplay);
	Cmd_AddMacroEx(macro_point, Macro_PointName, teamplay);

	Cmd_AddMacroEx(macro_need, Macro_Need, teamplay);

	Cmd_AddMacroEx(macro_droploc, Macro_LastDrop, teamplay);
	Cmd_AddMacroEx(macro_droptime, Macro_LastDropTime, teamplay);

	Cmd_AddMacro(macro_tf_skin, Macro_TF_Skin);
	Cmd_AddMacro(macro_gamedir, Macro_GameDir);

	Cmd_AddMacro(macro_triggermatch, Macro_LastTrigger_Match);
	Cmd_AddMacroEx(macro_ledpoint, Macro_Point_LED, teamplay);
	Cmd_AddMacroEx(macro_ledstatus, Macro_MyStatus_LED, teamplay);

	Cmd_AddMacroEx(macro_lastloc, Macro_Last_Location, teamplay);
	Cmd_AddMacroEx(macro_lastpowerup, Macro_LastSeenPowerup, teamplay);

	Cmd_AddMacro(macro_team1, Macro_Team1);
	Cmd_AddMacro(macro_team2, Macro_Team2);
}

/********************** MACRO/FUNCHAR/WHITE TEXT PARSING **********************/

wchar *TP_ParseWhiteText (const wchar *s, qbool team, int offset)
{
	static wchar	buf[4096];
	wchar *out, *p1;
	const wchar* p;
	extern cvar_t	cl_parseWhiteText;
	qbool	parsewhite;

	parsewhite = cl_parseWhiteText.value == 1 || (cl_parseWhiteText.value == 2 && team);

	buf[0] = 0;
	out = buf;

	for (p = s; *p; p++) {
		if  (parsewhite && *p == '{' && p-s >= offset) {
			if ((p1 = qwcschr (p + 1, '}'))) {
				memcpy (out, p + 1, (p1 - p - 1)*sizeof(wchar));
				out += p1 - p - 1;
				p = p1;
				continue;
			}
		}
		if (*p != 10 && *p != 13 && !(p==s && (*p==1 || *p==2)) && *p <= 0x7F)
			*out++ = *p | 128;	// convert to red
		else
			*out++ = *p;
	}
	*out = 0;
	return buf;
}

static int TP_MacroStringLength(char* output, const char* text, int buffer_length, int printable_length)
{
	extern cvar_t cl_parseWhiteText;
	qbool in_colour = false;
	qbool in_braces = false;
	int printed_length = 0;
	int buffered_length = 0;
	const char* s = 0;

	memset(output, 0, buffer_length);
	buffer_length -= 1;
	for (s = text; *s && printed_length < printable_length && buffered_length < buffer_length - (in_braces ? 1 : 0) - (in_colour ? 2 : 0); ++s) {
		if (*s == '&') {
			if (s[1] == 'c' && s[2] && s[3] && s[4]) {
				if (HexToInt(s[2]) >= 0 && HexToInt(s[3]) >= 0 && HexToInt(s[4]) >= 0) {
					if (buffer_length - buffered_length <= 5)
						break;
					memcpy(output + buffered_length, s, 5);
					buffered_length += 5;
					in_colour = HexToInt(s[2]) != 15 || HexToInt(s[3]) != 15 || HexToInt(s[4]) != 15;	// &cFFF used instead of &r...
					s += 4;
					continue; 
				}
			}
			else if (s[1] == 'r') {
				if (buffer_length - buffered_length <= 2)
					break;
				output[buffered_length++] = '&';
				output[buffered_length++] = 'r';
				++s;
				in_colour = false;
				continue; 
			}
		}
		else if (cl_parseWhiteText.value) {
			// We don't really know if the other clients have this set, presume same settings on all machines
			if ((s[0] == '{' && s[1] != '{') || (s[0] == '}' && s[1] != '}')) {
				output[buffered_length++] = s[0];
				in_braces = (s[0] == '{');
				continue;
			}
		}

		output[buffered_length++] = s[0];
		++printed_length;
	}

	if (in_colour && buffered_length < buffer_length - 2) {
		output[buffered_length++] = '&';
		output[buffered_length++] = 'r';
	}
	if (in_braces && buffered_length < buffer_length - 1) {
		output[buffered_length++] = '}';
	}
	output[buffer_length - 1] = 0;

	return printed_length;
}

char* TP_AlignMacroText(char* text, int fixed_width, int alignment)
{
	static char output[MAX_MACRO_STRING];
	static char content[MAX_MACRO_STRING];
	int string_length = 0;
	int spaces = 0;

	if (fixed_width == 0)
		return text;

	string_length = TP_MacroStringLength(content, text, MAX_MACRO_STRING, fixed_width);
	spaces = max(fixed_width - string_length, 0);

	memset(output, 0, sizeof(output));
	switch (alignment)
	{
	case TP_MACRO_ALIGNMENT_RIGHT:
		snprintf(output, MAX_MACRO_STRING - 1, "%*s%s", spaces, "", content);
		break;
	case TP_MACRO_ALIGNMENT_CENTERED:
		snprintf(output, MAX_MACRO_STRING - 1, "%*s%s%*s", spaces / 2, "", content, (spaces + 1) / 2, "");
		break;
	case TP_MACRO_ALIGNMENT_LEFT:
	default:
		snprintf(output, MAX_MACRO_STRING - 1, "%s%*s", content, spaces, "");
		break;
	}

	return output;
}

void TP_SetDefaultMacroFormat(char* cvar_ext, int* fixed_width, int* alignment)
{
	char cvar_name[128] = { 0 };
	cvar_t* width_cvar; 
	cvar_t* alignment_cvar;

	snprintf(cvar_name, sizeof(cvar_name) - 1, "tp_length_%s", cvar_ext);
	width_cvar = Cvar_Find(cvar_name);

	*fixed_width = 0;
	*alignment = TP_MACRO_ALIGNMENT_LEFT;

	if (width_cvar) {
		*fixed_width = max(0, min(width_cvar->integer, 40));

		snprintf(cvar_name, sizeof(cvar_name) - 1, "tp_align_%s", cvar_ext);
		alignment_cvar = Cvar_Find(cvar_name);
		if (alignment_cvar && tolower(alignment_cvar->string[0]) == 'r')
			*alignment = TP_MACRO_ALIGNMENT_RIGHT;
		else if (alignment_cvar && tolower(alignment_cvar->string[0]) == 'c')
			*alignment = TP_MACRO_ALIGNMENT_CENTERED;
	}
}

static void TP_SetDefaultMacroCharFormat(qbool extended, char character, int* fixed_width, int* alignment)
{
	char cvar_ext[128] = { 0 };

	snprintf(cvar_ext, sizeof(cvar_ext) - 1, "%s%s%c", extended ? "ext_" : "", isupper(character) ? "caps_" : "", character);

	TP_SetDefaultMacroFormat(cvar_ext, fixed_width, alignment);
}

qbool TP_ReadMacroFormat(char* s, int* fixed_width, int* alignment, char** new_s)
{
	*new_s = s;
	*fixed_width = 0;
	*alignment = TP_MACRO_ALIGNMENT_LEFT;

	if (s[0] && s[1] == '<') {
		s += 2;

		while (s[0] && s[0] != '>') {
			if (s[0] >= '0' && s[0] <= '9') {
				*fixed_width = (*fixed_width) * 10 + (s[0] - '0');
			}
			else if ((s[0] == 'l' || s[0] == 'L') && s[1] == '>') {
				*alignment = TP_MACRO_ALIGNMENT_LEFT;
			}
			else if ((s[0] == 'r' || s[0] == 'R') && s[1] == '>') {
				*alignment = TP_MACRO_ALIGNMENT_RIGHT;
			}
			else if ((s[0] == 'c' || s[0] == 'C') && s[1] == '>') {
				*alignment = TP_MACRO_ALIGNMENT_CENTERED;
			}
			else {
				break;
			}
			++s;
		}

		// not valid string
		if (s[0] != '>') {
			*fixed_width = *alignment = 0;
			return false;
		}

		*new_s = s;
		return true;
	}

	return false;
}

//Parses %a-like expressions
char *TP_ParseMacroString (char *s)
{
	static char	buf[MAX_MACRO_STRING];
	int i = 0;
	int pN, pn;
	char *macro_string;

	int r = 0;

	player_state_t *state;
	player_info_t *info;
	static int lastframecount = -1;

	if (!cl_parseSay.value)
		return s;

	suppress = false;
	pn = pN = 0;

	while (*s && i < MAX_MACRO_STRING - 1) {
		qbool is_macro_indicator = (*s == '%');
		int fixed_width = 0;
		int alignment = 0;
		qbool explicit_format = false;

		// check for %<size[alignment]>
		explicit_format = is_macro_indicator && TP_ReadMacroFormat(s, &fixed_width, &alignment, &s);

		// check %[P], etc
		if (is_macro_indicator && s[1]=='[' && s[2] && s[3]==']') {
			static char mbuf[MAX_MACRO_VALUE];
			char cvar_lookup_char = s[2];

			switch (s[2]) {
				case 'a':
					macro_string = Macro_ArmorType();
					if (!strcmp(macro_string, tp_name_none.string))
						macro_string = "a";
					if (cl.stats[STAT_ARMOR] < 30)
						snprintf (mbuf, sizeof(mbuf), "\x10%s:%i\x11", macro_string, cl.stats[STAT_ARMOR]);
					else
						snprintf (mbuf, sizeof(mbuf), "%s:%i", macro_string, cl.stats[STAT_ARMOR]);
					macro_string = mbuf;
					break;

				case 'h':
					if (cl.stats[STAT_HEALTH] >= 50)
						snprintf (macro_buf, sizeof(macro_buf), "%i", cl.stats[STAT_HEALTH]);
					else
						snprintf (macro_buf, sizeof(macro_buf), "\x10%i\x11", cl.stats[STAT_HEALTH]);
					macro_string = macro_buf;
					break;

				case 'p':
				case 'P':
					macro_string = Macro_Powerups();
					if (strcmp(macro_string, tp_name_none.string))
						snprintf (mbuf, sizeof(mbuf), "\x10%s\x11", macro_string);
					else
						mbuf[0] = 0;
					macro_string = mbuf;
					break;

				default:
					buf[i++] = *s++;
					continue;
			}

			if (!explicit_format)
				TP_SetDefaultMacroCharFormat(true, cvar_lookup_char, &fixed_width, &alignment);

			if (fixed_width)
				macro_string = TP_AlignMacroText(macro_string, fixed_width, alignment);

			if (i + strlen(macro_string) >= MAX_MACRO_STRING - 1)
				Sys_Error("TP_ParseMacroString: macro string length > MAX_MACRO_STRING)");
			strlcpy (&buf[i], macro_string, MAX_MACRO_STRING - i);
			i += strlen(macro_string);
			s += 4;	// skip %[<char>]
			continue;
		}

		// check %a, etc
		if (is_macro_indicator) {
			char cvar_lookup_char = s[1];

			switch (s[1]) {
				//case '\x7f': macro_string = ""; break;// skip cause we use this to hide mesgs
				//case '\xff': macro_string = ""; break;
				case 'n':   pn = 1; macro_string = ""; break;
				case 'N':   pN = 1; macro_string = ""; break;
				case 'a':	macro_string = Macro_Armor(); break;
				case 'A':	macro_string = Macro_ArmorType(); break;
				case 'b':	macro_string = Macro_BestWeaponAndAmmo(); break;
				case 'c':	macro_string = Macro_Cells(); break;
				case 'd':	macro_string = Macro_LastDeath(); cvar_lookup_char = 'l'; break;
				case 'h':	macro_string = Macro_Health(); break;
				case 'i':	macro_string = Macro_TookAtLoc(); cvar_lookup_char = 'l'; break;
				case 'j':	macro_string = Macro_LastPointAtLoc(); cvar_lookup_char = 'l'; break;
				case 'k':	macro_string = Macro_LastTookOrPointed(); break;
				case 'l':	macro_string = Macro_Location(); cvar_lookup_char = 'l'; break;
				case 'L':	macro_string = Macro_Last_Location(); cvar_lookup_char = 'l'; break;
				case 'm':	macro_string = Macro_LastTookOrPointed(); break;
				case 'P':
				case 'p':	macro_string = Macro_Powerups(); cvar_lookup_char = 'p'; break;
				case 'q':	macro_string = Macro_LastSeenPowerup(); break;
				case 'r':	macro_string = Macro_LastReportedLoc(); cvar_lookup_char = 'l'; break;
				case 'R':	macro_string = Macro_Rune(); break;
				case 'S':	macro_string = Macro_TF_Skin(); break;
				case 't':	macro_string = Macro_PointNameAtLocation(); break;
				case 'u':	macro_string = Macro_Need(); break;
				case 'w':	macro_string = Macro_WeaponAndAmmo(); break;
				case 'x':	macro_string = Macro_PointName(); break;
				case 'X':	macro_string = Macro_Took(); cvar_lookup_char = 'x'; break;
				case 'y':	macro_string = Macro_PointLocation(); cvar_lookup_char = 'l'; break;
				case 'Y':	macro_string = Macro_TookLoc(); cvar_lookup_char = 'l'; break;
				CASE_PLAYER_COUNT_ALLOWED('E', Macro_Count_Last_NearbyEnemyPlayers)
				CASE_PLAYER_COUNT_ALLOWED('e', Macro_CountNearbyEnemyPlayers)
				CASE_PLAYER_COUNT_ALLOWED('O', Macro_Count_Last_NearbyFriendlyPlayers)
				CASE_PLAYER_COUNT_ALLOWED('o', Macro_CountNearbyFriendlyPlayers)
				CASE_PLAYER_COUNT_ALLOWED('s', Macro_EnemyStatus_LED)
				case '%':
					++s;	// deliberate fall-through, skip this % and print the next
				default:
				do_default:
					buf[i++] = '%';
					++s;
					continue;
			}

			if (!explicit_format)
				TP_SetDefaultMacroCharFormat(false, cvar_lookup_char, &fixed_width, &alignment);

			if (fixed_width)
				macro_string = TP_AlignMacroText(macro_string, fixed_width, alignment);

			if (i + strlen(macro_string) >= MAX_MACRO_STRING - 1)
				Sys_Error("TP_ParseMacroString: macro string length > MAX_MACRO_STRING)");
			strlcpy (&buf[i], macro_string, MAX_MACRO_STRING - i);
			i += strlen(macro_string);
			s += 2;	// skip % and letter
			continue;
		}
		buf[i++] = *s++;
	}
	buf[i] = 0;

	i = strlen(buf);

	if (pN) {
		buf[i++] = 0x7f;
		buf[i++] = '!';
		buf[i++] = 'A' + cl.playernum;
	}
	if (pn) {

		if (!pN)
			buf[i++] = 0x7f;

		if (cls.framecount != lastframecount) {

			lastframecount = cls.framecount;

			if (!(!cl.oldparsecount || !cl.parsecount || cls.state < ca_active)) {

				state = cl.frames[cl.oldparsecount & UPDATE_MASK].playerstate;
				info = cl.players;

				for (r = 0; r < MAX_CLIENTS; r++, info++, state++) {
					if (r != cl.playernum && state->messagenum == cl.oldparsecount && !info->spectator && !ISDEAD(state->frame)) {
						if (cl.teamplay && !strcmp(info->team, TP_PlayerTeam()))
							buf[i++] = 'A' + r;
					}
				}

			}

		}
	}

	if (suppress) {
		qbool quotes = false;

		TP_PrintHiddenMessage(buf,pN);

		i = strlen(buf);

		if (i > 0 && buf[i - 1] == '\"') {
			buf[i - 1] = 0;
			quotes = true;
			i--;
		}

		if (!pN) {
			if (!pn) {
				buf[i++] = 0x7f;
			}
			buf[i++] = '!';
			buf[i++] = 'A' + cl.playernum;
		}

		if (quotes)
			buf[i++] = '\"';
		buf[i] = 0;
	}


	return buf;
}

//Doesn't check for overflows, so strlen(s) should be < MAX_MACRO_STRING
char *TP_ParseFunChars (const char *s, qbool chat)
{
	static char	 buf[MAX_MACRO_STRING];
	char		*out = buf;
	int			 c;

	if (!cl_parseFunChars.value) {
		strlcpy(buf, s, sizeof(buf));
		return buf;
	}

	while (*s) {
		if (*s == '$' && s[1] == 'x') {
			int i;
			// check for $x10, $x8a, etc
			c = tolower((int)(unsigned char)s[2]);
			if ( isdigit(c) )
				i = (c - (int)'0') << 4;
			else if ( isxdigit(c) )
				i = (c - (int)'a' + 10) << 4;
			else goto skip;
			c = tolower((int)(unsigned char)s[3]);
			if ( isdigit(c) )
				i += (c - (int)'0');
			else if ( isxdigit(c) )
				i += (c - (int)'a' + 10);
			else goto skip;
			if (!i)
				i = (int)' ';
			*out++ = (char)i;
			s += 4;
			continue;
		}
		if (*s == '$' && s[1]) {
			c = 0;
			switch (s[1]) {
					case '\\': c = 0x0D; break;
					case ':': c = 0x0A; break;
					case '[': c = 0x10; break;
					case ']': c = 0x11; break;
					case 'G': c = 0x86; break; // green led
					case 'R': c = 0x87; break; // red led
					case 'Y': c = 0x88; break; // yellow led
					case 'B': c = 0x89; break; // blue led
					case 'W': c = 0x84; break; // white led
					case '(': c = 0x80; break;
					case '=': c = 0x81; break;
					case ')': c = 0x82; break;
					case 'a': c = 0x83; break;
					case '<': c = 0x1d; break;
					case '-': c = 0x1e; break;
					case '>': c = 0x1f; break;
					case ',': c = 0x1c; break;
					case '.': c = 0x9c; break;
					case 'b': c = 0x8b; break;
					case 'c':
					case 'd': c = 0x8d; break;
					case '$': c = '$'; break;
					case '^': c = '^'; break;
			}
			if ( isdigit((int)(unsigned char)s[1]) )
				c = s[1] - (int)'0' + 0x12;
			if (c) {
				*out++ = (char)c;
				s += 2;
				continue;
			}
		}
		if (!chat && *s == '^' && s[1] && s[1] != ' ') {
			*out++ = s[1] | 128;
			s += 2;
			continue;
		}
	skip:
		*out++ = *s++;
	}
	*out = 0;

	return buf;
}

/************************* SKIN FORCING & REFRESHING *************************/
qbool TP_TeamLockSpecified(void)
{
	// 1 => return 1st team (doesn't matter which, just locks colours)
	// non-blank string => use that teamname as the client's team
	return cl.spectator && (cl_teamlock.integer != 0 || (cl_teamlock.string[0] && strcmp(cl_teamlock.string, "0")));
}

char *TP_SkinForcingTeam(void)
{
	int tracknum;

	// FIXME: teams with names 0 & 1 will clash with this - teamlock & the team name should be diff cvars
	if (!cl.spectator)
	{
		// Normal player.
		return cl.players[cl.playernum].team;
	}
	else if (cl_teamlock.string[0] == '1' && cl_teamlock.string[1] == '\0') {
		extern const char* HUD_FirstTeam(void);
		int i;

		if (cls.mvdplayback && HUD_FirstTeam()[0]) {
			return (char*)HUD_FirstTeam();
		}

		for (i = 0; i < MAX_CLIENTS; i++) {
			if (cl.players[i].name[0] && !cl.players[i].spectator && cl.players[i].team[0]) {
				return cl.players[i].team;
			}
		}
	}
	else if (!(cl_teamlock.string[0] == '0' && cl_teamlock.string[1] == '\0')) {
		// anything that isn't "0" to disable
		return cl_teamlock.string;
	}
	else if ((tracknum = Cam_TrackNum()) != -1)
	{
		// Spectating and tracking someone (not free flying).
		return cl.players[tracknum].team;
	}

	return "";
}

static qbool need_skin_refresh;
void TP_UpdateSkins(void)
{
	int slot;

	if (!need_skin_refresh)
	{
		return;
	}

	for (slot = 0; slot < MAX_CLIENTS; slot++)
	{
		if (cl.players[slot].skin_refresh)
		{
			CL_NewTranslation(slot);
			cl.players[slot].skin_refresh = false;
		}
	}

	need_skin_refresh = false;
}

// Returns true if a change in player/team needs skins to be reloaded
qbool TP_NeedRefreshSkins(void)
{
	extern cvar_t r_enemyskincolor, r_teamskincolor;

	if (cl.teamfortress) {
		return false;
	}

	if ((cl_enemyskin.string[0] || cl_teamskin.string[0] || cl_enemypentskin.string[0] || cl_teampentskin.string[0] ||
	     cl_enemyquadskin.string[0] || cl_teamquadskin.string[0] || cl_enemybothskin.string[0] || cl_teambothskin.string[0])
	     && !(cl.fpd & FPD_NO_FORCE_SKIN))
		return true;

	if ((cl_teamtopcolor.value >= 0 || cl_enemytopcolor.value >= 0) && !(cl.fpd & FPD_NO_FORCE_COLOR))
		return true;

	if ((r_enemyskincolor.string[0] || r_teamskincolor.string[0])) {
		return true;
	}

	return false;
}

void TP_RefreshSkin(int slot)
{
	if (cls.state < ca_connected || slot < 0 || slot >= MAX_CLIENTS || !cl.players[slot].name[0] || cl.players[slot].spectator)
		return;

	// Multiview
	// Never allow a skin refresh in multiview, since it
	// results in players getting the wrong color when
	// force colors is used (Team/enemycolor).
	// TODO: Any better solution for this?
	/*if(cls.mvdplayback && cl_multiview.value)
	{
		return;
	}*/

	cl.players[slot].skin_refresh = true;
	need_skin_refresh = true;
}

void TP_RefreshSkins(void)
{
	int i;

	for (i = 0; i < MAX_CLIENTS; i++)
		TP_RefreshSkin(i);
}

void OnChangeSkinAndColorForcing(cvar_t *var, char *string, qbool *cancel)
{
	OnChangeColorForcing(var, string, cancel);
	OnChangeSkinForcing(var, string, cancel);
	return;
}

void OnChangeColorForcing(cvar_t *var, char *string, qbool *cancel)
{
	TP_RefreshSkins();
	return;
}

void TP_ColorForcing (cvar_t *topcolor, cvar_t *bottomcolor)
{
	int	top, bottom;

	if (Cmd_Argc() == 1) {
		if (topcolor->integer == -1 && bottomcolor->integer == -1)
			Com_Printf ("\"%s\" is \"off\"\n", Cmd_Argv(0));
		else
			Com_Printf ("\"%s\" is \"%i %i\"\n", Cmd_Argv(0), topcolor->integer, bottomcolor->integer);
		return;
	}

	if (!strcasecmp(Cmd_Argv(1), "off") || !strcasecmp(Cmd_Argv(1), "")) {
		Cvar_SetValue(topcolor, -1);
		Cvar_SetValue(bottomcolor, -1);
		TP_RefreshSkins();
		return;
	}

	if (Cmd_Argc() == 2) {
		top = bottom = atoi(Cmd_Argv(1));
	} else {
		top = atoi(Cmd_Argv(1));
		bottom = atoi(Cmd_Argv(2));
	}

	Cvar_SetValue(topcolor, bound(0, top, 16));
	Cvar_SetValue(bottomcolor, bound(0, bottom, 16));

	TP_RefreshSkins();
}

void TP_TeamColor_f(void)
{
	TP_ColorForcing(&cl_teamtopcolor, &cl_teambottomcolor);
}

void TP_EnemyColor_f(void)
{
	TP_ColorForcing(&cl_enemytopcolor, &cl_enemybottomcolor);
}

/************************* BASIC MATCH INFO FUNCTIONS *************************/

char *TP_PlayerName (void)
{
	static char myname[MAX_INFO_STRING];

	strlcpy (myname, Info_ValueForKey(cl.players[cl.playernum].userinfo, "name"), MAX_INFO_STRING);
	return myname;
}

char *TP_PlayerTeam (void)
{
	static char myteam[MAX_INFO_STRING];

	strlcpy (myteam, cl.players[cl.playernum].team, MAX_INFO_STRING);
	return myteam;
}

int	TP_CountPlayers (void)
{
	int	i, count = 0;

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0] && !cl.players[i].spectator)
			count++;
	}
	return count;
}

// tells the playernum of the player in the current point of view
int TP_CurrentTrackNum(void)
{
	if (!cl.spectator) return cl.playernum;
	else return Cam_TrackNum();
}

// returns true if the player in the current POV is from given team
qbool TP_ThisPOV_IsHisTeam(const char* team)
{
	int pn = TP_CurrentTrackNum();
	
	if (pn < 0 || pn >= MAX_CLIENTS)
		return false;
	else
		return !strcmp(team, cl.players[pn].team);
}

// returns the team of the player in the current POV
// if no player tracked in the POV, returns NULL pointer
static char* TP_ThisPOV_Team(void) {
	int n = TP_CurrentTrackNum();
	if (n >= 0 && n < MAX_CLIENTS)
		return cl.players[n].team;
	else
		return NULL;
}

int TP_PlayersNumber(int userid, const char* team)
{
	qbool t1 = TP_ThisPOV_IsHisTeam(team); // is the looked up one our teammate?
	qbool t2;
	char *pt = TP_ThisPOV_Team();
	int pc = 0, i;
	player_info_t* cp;

	for (i = 0; i < MAX_CLIENTS; i++) {
		cp = &cl.players[i];
		if (!cp->name[0] || cp->spectator) continue;
		if (pt)
			t2 = !strcmp(cp->team, pt);	// is the current one our teammate?
		else
			t2 = false;

		if ((t1 && t2) || (!t1 && !t2)) {
			pc++;
		}
		if (cp->userid == userid)
			return pc;
	}

	return 0;
}

char *TP_MapName(void)
{
	return host_mapname.string;
}

char *MT_GetSkyGroupName(char *mapname, qbool *system);

char *TP_GetSkyGroupName(char *mapname, qbool *system)
{
	return MT_GetSkyGroupName(mapname, system);
}

char *MT_GetMapGroupName(char *mapname, qbool *system);

char *TP_GetMapGroupName(char *mapname, qbool *system)
{
	return MT_GetMapGroupName(mapname, system);
}

/****************************** PUBLIC FUNCTIONS ******************************/

void TP_NewMap (void)
{
	memset (&vars, 0, sizeof(vars));
	TP_FindModelNumbers ();

	TP_LocFiles_NewMap();
	TP_ExecTrigger ("f_newmap");
	if (cl.teamfortress) {
		V_TF_ClearGrenadeEffects();
	}
	Ignore_ResetFloodList();
}

int TP_CategorizeMessage (const char *s, int *offset)
{
	int i, msglen, len, flags, tracknum;
	player_info_t	*player;
	char *name, *team=NULL;

	tracknum = -1;
	if (cl.spectator && (tracknum = Cam_TrackNum()) != -1)
		team = cl.players[tracknum].team;
	else if (!cl.spectator)
		team = cl.players[cl.playernum].team;

	flags = msgtype_unknown;
	*offset = 0;
	if (!(msglen = strlen(s)))
		return msgtype_unknown;

	for (i = 0, player = cl.players; i < MAX_CLIENTS; i++, player++)	{
		if (!player->name[0])
			continue;
		name = Info_ValueForKey (player->userinfo, "name");
		len = strlen(name);
		len = min (len, 31);
		// check messagemode1
		if (len + 2 <= msglen && s[len] == ':' && s[len + 1] == ' ' && !strncmp(name, s, len))	{
			if (player->spectator)
				flags |= msgtype_spec;
			else
				flags |= msgtype_normal;
			*offset = len + 2;
		}
		// check messagemode2
		else if (s[0] == '(' && len + 4 <= msglen && !strncmp(s + len + 1, "): ", 3) && !strncmp(name, s + 1, len)

		         && (!cl.spectator || tracknum != -1)
		        ) {
			// no team messages in teamplay 0, except for our own
			if (i == cl.playernum || ( cl.teamplay && !strcmp(team, player->team)) )
				flags |= msgtype_team;
			*offset = len + 4;
		}
		//check spec mm2
		else if (cl.spectator && !strncmp(s, "[SPEC] ", 7) && player->spectator &&
		         len + 9 <= msglen && s[len + 7] == ':' && s[len + 8] == ' ' && !strncmp(name, s + 7, len)) {
			flags |= msgtype_specteam;
			*offset = len + 9;
		}
	}
	return flags;
}

/****************************** POINTING & TOOK ******************************/

// symbolic names used in tp_took, tp_pickup, tp_point commands
char *pknames[] = {"quad", "pent", "ring", "suit", "ra", "ya",	"ga",
                   "mh", "health", "lg", "rl", "gl", "sng", "ng", "ssg", "pack",
                   "cells", "rockets", "nails", "shells", "flag",
                   "teammate", "enemy", "eyes", "sentry", "disp", "quaded", "pented", \
				   "rune1", "rune2", "rune3", "rune4", "resistance", "strength", "haste", "regeneration"};

#define default_pkflags ((unsigned int) (it_powerups|it_armor|it_weapons|it_mh|it_pack| \
				it_rockets|it_cells|it_pack|it_flag|it_runes))

 // tp_took
#define default_tookflags ((unsigned int) (it_powerups|it_armor|it_weapons|it_pack| \
				it_rockets|it_cells|it_mh|it_flag|it_runes))

/*
powerups flag runes players suit armor sentry  mh disp rl lg pack gl sng rockets cells nails
Notice this list takes into account ctf/tf as well. Dm players don't worry about ctf/tf items.

 below are defaults for tp_point (what comes up in point. also see tp_pointpriorities to prioritize this list) First items have highest priority (powerups in this case)
*/
// tp_point
#define default_pointflags ((unsigned int) (it_powerups|it_players|it_armor|it_weapons|it_mh|it_pack| \
				it_rockets|it_cells|it_sentry|it_disp|it_flag|it_runes))

unsigned int pkflags = default_pkflags;
unsigned int tookflags = default_tookflags;
unsigned int pointflags = default_pointflags;
byte tookpriorities[NUM_ITEMFLAGS];
byte pointpriorities[NUM_ITEMFLAGS];

static void DumpFlagCommand(FILE *f, char *name, unsigned int flags, unsigned int default_flags)
{
	int i;
	unsigned int all_flags = UINT_MAX;

	fprintf(f, "%s ", name);

	if (flags == 0) {
		fprintf(f, "none\n");
		return;
	}
	if (flags == all_flags) {
		fprintf(f, "all\n");
		return;
	} else if (flags == default_flags) {
		fprintf(f, "default\n");
		return;
	}

	if ((flags & it_powerups) == it_powerups) {
		fprintf(f, "powerups ");
		flags &= ~it_powerups;
	}
	if ((flags & it_weapons) == it_weapons) {
		fprintf(f, "weapons ");
		flags &= ~it_weapons;
	}
	if ((flags & it_armor) == it_armor) {
		fprintf(f, "armor ");
		flags &= ~it_armor;
	}
	if ((flags & it_ammo) == it_ammo) {
		fprintf(f, "ammo ");
		flags &= ~it_ammo;
	}
	if ((flags & it_players) == it_players) {
		fprintf(f, "players ");
		flags &= ~it_players;
	}
	if ((flags & it_runes) == it_runes) {
		fprintf(f, "runes ");
		flags &= ~it_runes;
	}
	for (i = 0; i < NUM_ITEMFLAGS; i++) {
		if (flags & (1 << i))
			fprintf (f, "%s ", pknames[i]);
	}
	fprintf(f, "\n");
}

void DumpFlagCommands(FILE *f)
{
	DumpFlagCommand(f, "tp_pickup   ", pkflags, default_pkflags);
	DumpFlagCommand(f, "tp_took     ", tookflags, default_tookflags);
	DumpFlagCommand(f, "tp_point    ", pointflags, default_pointflags);
}

static void FlagCommand(unsigned int* flags, unsigned int defaultflags)
{
	int i, j, c, offset = 0;
	unsigned int flag;
	char* p, str[255] = { 0 };
	qbool removeflag = false;
	byte *priorities = (flags == &tookflags) ? tookpriorities : pointpriorities;
	qbool use_priorities = (flags == &tookflags) ? tp_tookpriorities.integer : tp_pointpriorities.integer;

	c = Cmd_Argc();
	if (c == 1) {
		qbool notfirst = false;
		if (!*flags)
			strlcpy(str, "none", sizeof(str));

		if (use_priorities) {
			int p;
			for (p = 0; p < NUM_ITEMFLAGS; ++p) {
				for (i = 0; i < NUM_ITEMFLAGS; i++) {
					if (priorities[i] == p && (*flags & (1 << i))) {
						if (notfirst) {
							Com_Printf(" ");
						}

						notfirst = true;
						Com_Printf("%s", pknames[i]);
					}
				}
			}
		} else {
			for (i = 0; i < NUM_ITEMFLAGS; i++) {
				if (*flags & (1 << i)) {
					if (notfirst) {
						Com_Printf(" ");
					}

					notfirst = true;
					Com_Printf("%s", pknames[i]);
				}
			}
		}
		Com_Printf("\n");
		return;
	}

	if (c == 2 && !strcasecmp(Cmd_Argv(1), "none")) {
		*flags = 0;
		memset(priorities, 0, NUM_ITEMFLAGS);
		return;
	}

	if (*Cmd_Argv(1) != '+' && *Cmd_Argv(1) != '-') {
		*flags = 0;
		memset(priorities, 0, NUM_ITEMFLAGS);
	}
	else if (*Cmd_Argv(1) == '+') {
		for (i = 0; i < NUM_ITEMFLAGS; ++i) {
			if (*flags & (1 << i)) {
				++offset;
			}
		}
	}

	for (i = 1; i < c; i++) {
		p = Cmd_Argv(i);
		if (*p == '+') {
			removeflag = false;
			p++;
		}
		else if (*p == '-') {
			removeflag = true;
			p++;
		}

		flag = 0;
		for (j = 0; j < NUM_ITEMFLAGS; j++) {
			if (!strcasecmp(p, pknames[j])) {
				flag = 1 << j;
				break;
			}
		}

		if (!flag) {
			if (!strcasecmp(p, "armor"))
				flag = it_armor;
			else if (!strcasecmp(p, "weapons"))
				flag = it_weapons;
			else if (!strcasecmp(p, "powerups"))
				flag = it_powerups;
			else if (!strcasecmp(p, "ammo"))
				flag = it_ammo;
			else if (!strcasecmp(p, "players"))
				flag = it_players;
			else if (!strcasecmp(p, "default"))
				flag = defaultflags;
			else if (!strcasecmp(p, "runes"))
				flag = it_runes;
			else if (!strcasecmp(p, "all"))
				flag = UINT_MAX; //(1 << NUM_ITEMFLAGS); //-1;
		}

		if (flags != &pointflags) {
			flag &= ~(it_sentry | it_disp | it_players);
		}

		if (removeflag) {
			*flags &= ~flag;

			for (j = 1; j <= NUM_ITEMFLAGS; j++) {
				if (flag & (1 << (j - 1))) {
					priorities[j - 1] = 0;
				}
			}
		}
		else if (flag) {
			*flags |= flag;

			for (j = 1; j <= NUM_ITEMFLAGS; j++) {
				if (flag & (1 << (j - 1))) {
					priorities[j - 1] = i + offset;
				}
			}
		}
	}
}

void TP_Took_f (void)
{
	FlagCommand (&tookflags, default_tookflags);
}

void TP_Pickup_f (void)
{
	FlagCommand (&pkflags, default_pkflags);
}

void TP_Point_f (void)
{
	FlagCommand (&pointflags, default_pointflags);
}

typedef struct
{
	unsigned int		itemflag;
	cvar_t	*cvar;
	char	*modelname;
	vec3_t	offset;		// offset of model graphics center
	float	radius;		// model graphics radius
	unsigned int		flags;		// TODO: "NOPICKUP" (disp), "TEAMENEMY" (flag, disp)
} item_t;

item_t	tp_items[] = {
                        {	it_quad,	&tp_name_quad,	"progs/quaddama.mdl",
                          {0, 0, 24},	25,
                        },
                        {	it_pent,	&tp_name_pent,	"progs/invulner.mdl",
                          {0, 0, 22},	25,
                        },
                        {	it_ring,	&tp_name_ring,	"progs/invisibl.mdl",
                          {0, 0, 16},	12,
                        },
                        {	it_suit,	&tp_name_suit,	"progs/suit.mdl",
                          {0, 0, 24}, 20,
                        },
                        {	it_lg,		&tp_name_lg,	"progs/g_light.mdl",
                          {0, 0, 30},	20,
                        },
                        {	it_rl,		&tp_name_rl,	"progs/g_rock2.mdl",
                          {0, 0, 30},	20,
                        },
                        {	it_gl,		&tp_name_gl,	"progs/g_rock.mdl",
                          {0, 0, 30},	20,
                        },
                        {	it_sng,		&tp_name_sng,	"progs/g_nail2.mdl",
                          {0, 0, 30},	20,
                        },
                        {	it_ng,		&tp_name_ng,	"progs/g_nail.mdl",
                          {0, 0, 30},	20,
                        },
                        {	it_ssg,		&tp_name_ssg,	"progs/g_shot.mdl",
                          {0, 0, 30},	20,
                        },
                        {	it_cells,	&tp_name_cells,	"maps/b_batt0.bsp",
                          {16, 16, 24},	18,
                        },
                        {	it_cells,	&tp_name_cells,	"maps/b_batt1.bsp",
                          {16, 16, 24},	18,
                        },
                        {	it_rockets,	&tp_name_rockets,"maps/b_rock0.bsp",
                          {8, 8, 20},	18,
                        },
                        {	it_rockets,	&tp_name_rockets,"maps/b_rock1.bsp",
                          {16, 8, 20},	18,
                        },
                        {	it_nails,	&tp_name_nails,	"maps/b_nail0.bsp",
                          {16, 16, 10},	18,
                        },
                        {	it_nails,	&tp_name_nails,	"maps/b_nail1.bsp",
                          {16, 16, 10},	18,
                        },
                        {	it_shells,	&tp_name_shells,"maps/b_shell0.bsp",
                          {16, 16, 10},	18,
                        },
                        {	it_shells,	&tp_name_shells,"maps/b_shell1.bsp",
                          {16, 16, 10},	18,
                        },
                        {	it_health,	&tp_name_health,"maps/b_bh10.bsp",
                          {16, 16, 8},	18,
                        },
                        {	it_health,	&tp_name_health,"maps/b_bh25.bsp",
                          {16, 16, 8},	18,
                        },
                        {	it_mh,		&tp_name_mh,	"maps/b_bh100.bsp",
                          {16, 16, 14},	20,
                        },
                        {	it_pack,	&tp_name_backpack, "progs/backpack.mdl",
                          {0, 0, 18},	18,
                        },
                        {	it_flag,	&tp_name_flag,	"progs/tf_flag.mdl",
                          {0, 0, 14},	25,
                        },
                        {	it_flag,	&tp_name_flag,	"progs/tf_stan.mdl",
                          {0, 0, 45},	40,
                        },
                        {	it_flag,	&tp_name_flag,	"progs/w_g_key.mdl",
                          {0, 0, 20},	18,
                        },
                        {	it_flag,	&tp_name_flag,	"progs/w_s_key.mdl",
                          {0, 0, 20},	18,
                        },
                        {	it_flag,	&tp_name_flag,	"progs/m_g_key.mdl",
                          {0, 0, 20},	18,
                        },
                        {	it_flag,	&tp_name_flag,	"progs/m_s_key.mdl",
                          {0, 0, 20},	18,
                        },
                        {	it_flag,	&tp_name_flag,	"progs/b_s_key.mdl",
                          {0, 0, 20},	18,
                        },
                        {	it_flag,	&tp_name_flag,	"progs/b_g_key.mdl",
                          {0, 0, 20},	18,
                        },
						{	it_flag,	&tp_name_flag,	"progs/stag.mdl",
						  {0, 0, 20},	18,
						},
						{	it_flag,	&tp_name_flag,	"progs/basrkey.bsp",
						  {0, 0, 20},	18,
						},
						{	it_flag,	&tp_name_flag,	"progs/basbkey.bsp",
						  {0, 0, 20},	18,
						},
						{	it_flag,	&tp_name_flag,	"progs/ff_flag.mdl",
						  {0, 0, 20},	18,
						},
						{	it_flag,	&tp_name_flag,	"progs/harbflag.mdl",
						  {0, 0, 20},	18,
						},
						{	it_flag,	&tp_name_flag,	"progs/princess.mdl",
						  {0, 0, 20},	18,
						},
						{	it_flag,	&tp_name_flag,	"progs/flag.mdl",
                          {0, 0, 14},	25,
                        },
                        {	it_rune1,	&tp_name_rune1,	"progs/end1.mdl",
                          {0, 0, 20},	18,
                        },
                        {	it_rune2,	&tp_name_rune2,	"progs/end2.mdl",
                          {0, 0, 20},	18,
                        },
                        {	it_rune3,	&tp_name_rune3,	"progs/end3.mdl",
                          {0, 0, 20},	18,
                        },
                        {	(unsigned int) it_rune4,	&tp_name_rune4,	"progs/end4.mdl",
                          {0, 0, 20},	18,
                        },
                        {	it_ra|it_ya|it_ga, NULL,	"progs/armor.mdl",
                          {0, 0, 24},	22,
                        },
                        {	it_sentry, &tp_name_sentry, "progs/turrgun.mdl",
                          {0, 0, 23},	25,
                        },
                        {	it_disp, &tp_name_disp,	"progs/disp.mdl",
                          {0, 0, 24},	25,
                        }
                    };

#define NUMITEMS (sizeof(tp_items) / sizeof(tp_items[0]))

item_t *model2item[MAX_MODELS];

void TP_FindModelNumbers (void)
{
	int i, j;
	char *s;
	item_t *item;

	for (i = 0 ; i < MAX_MODELS ; i++) {
		model2item[i] = NULL;
		s = cl.model_name[i];
		if (!s)
			continue;
		for (j = 0, item = tp_items ; j < NUMITEMS ; j++, item++)
			if (!strcmp(s, item->modelname))
				model2item[i] = item;
	}
}

// on success, result is non-zero
// on failure, result is zero
// for armors, returns skinnum+1 on success
static int FindNearestItem (int flags, item_t **pitem)
{
	frame_t *frame;
	packet_entities_t *pak;
	entity_state_t *ent, *bestent = NULL;
	int	i;
	float bestdist, dist;
	vec3_t org, v;
	item_t *item;

	VectorCopy (cl.frames[cl.validsequence & UPDATE_MASK].playerstate[cl.playernum].origin, org);

	// look in previous frame
	frame = &cl.frames[cl.oldvalidsequence&UPDATE_MASK];
	pak = &frame->packet_entities;
	bestdist = 100 * 100;
	*pitem = NULL;
	for (i = 0, ent = pak->entities; i < pak->num_entities; i++, ent++) {
		item = model2item[ent->modelindex];
		if (!item || !(item->itemflag & flags))
			continue;

		VectorSubtract (ent->origin, org, v);
		VectorAdd (v, item->offset, v);
		dist = DotProduct (v, v);

		if (dist <= bestdist) {
			bestdist = dist;
			bestent = ent;
			*pitem = item;
		}
	}

	if (bestent)
		strlcpy(vars.nearestitemloc, TP_LocationName(bestent->origin), sizeof(vars.nearestitemloc));
	else
		vars.nearestitemloc[0] = 0;

	if (bestent && (*pitem)->itemflag == it_armor)
		return bestent->skinnum + 1;	// 1 = green, 2 = yellow, 3 = red

	return bestent ? bestent->modelindex : 0;
}

char *Macro_LastTookOrPointed (void)
{
	if (vars.tooktime && vars.tooktime > vars.pointtime && cls.realtime - vars.tooktime < 5)
		return Macro_TookAtLoc();
	else if (vars.pointtime && vars.tooktime <= vars.pointtime && cls.realtime - vars.pointtime < 5)
		return Macro_LastPointAtLoc();

	snprintf(macro_buf, sizeof(macro_buf), "%s %s %s", tp_name_nothing.string, tp_name_at.string, tp_name_someplace.string);
	return macro_buf;
}

static qbool CheckTrigger (void)
{
	int	i, count;
	player_info_t *player;
	char *myteam;
	extern cvar_t tp_forceTriggers;

	if (cl.spectator || Rulesets_RestrictTriggers())
		return false;

	if (tp_forceTriggers.value)
		return true;

	if (!cl.teamplay)
		return false;

	count = 0;
	myteam = cl.players[cl.playernum].team;
	for (i = 0, player= cl.players; i < MAX_CLIENTS; i++, player++) {
		if (player->name[0] && !player->spectator && i != cl.playernum && !strcmp(player->team, myteam))
			count++;
	}

	return count;
}

static int TP_TookPriority(unsigned int flag)
{
	int i, priority = 0;
	unsigned int item_flag;
	int item_priority;

	if (!tp_tookpriorities.integer)
		return 0;

	for (i = 0; i < NUM_ITEMFLAGS; i++) {
		item_flag = (unsigned int)1 << i;
		item_priority = tookpriorities[i];

		if (!(flag & item_flag) || !item_priority)
			continue;

		if (!priority || item_priority < priority)
			priority = item_priority;
	}

	return priority;
}

static qbool TP_TookPriorityCanReplace(unsigned int flag)
{
	int priority, old_priority;

	priority = TP_TookPriority(flag);
	old_priority = TP_TookPriority((unsigned int)vars.tookflag);

	return !old_priority || (priority && priority <= old_priority);
}

static qbool TP_ShouldStoreTook(unsigned int flag)
{
	if (TOOK_EMPTY())
		return true;

	if (!tp_tookpriorities.integer)
		return true;

	return TP_TookPriorityCanReplace(flag);
}

static void ExecTookTrigger (char *s, unsigned int flag, vec3_t org)
{
	int pkflags_dmm, tookflags_dmm;

	pkflags_dmm = pkflags;
	tookflags_dmm = tookflags;

	if (!cl.teamfortress && cl.deathmatch >= 1 && cl.deathmatch <= 4) {
		if (cl.deathmatch == 4) {
			pkflags_dmm &= ~(it_ammo|it_weapons);
			tookflags_dmm &= ~(it_ammo|it_weapons);
		}
	}
	if (!((pkflags_dmm|tookflags_dmm) & flag))
		return;

	if (TP_ShouldStoreTook(flag)) {
		vars.tooktime = cls.realtime;
		vars.tookflag = flag;
		strlcpy(vars.tookname, s, sizeof(vars.tookname));
		strlcpy(vars.tookloc, TP_LocationName(org), sizeof(vars.tookloc));
	}

	if ((tookflags_dmm & flag) && CheckTrigger())
		TP_ExecTrigger ("f_took");
}

void TP_ParsePlayerInfo(player_state_t *oldstate, player_state_t *state, player_info_t *info)
{
	if (TP_NeedRefreshSkins()) {
		if ((state->effects & (EF_BLUE|EF_RED) ) != (oldstate->effects & (EF_BLUE|EF_RED)))
			TP_RefreshSkin(info - cl.players);
	}

	if (!cl.spectator && cl.teamplay && strcmp(info->team, TP_PlayerTeam())) {
		qbool eyes;

		eyes = state->modelindex && cl.model_precache[state->modelindex] && cl.model_precache[state->modelindex]->modhint == MOD_EYES;

		if (state->effects & (EF_BLUE | EF_RED) || eyes) {
			vars.enemy_powerups = 0;
			vars.enemy_powerups_time = cls.realtime;

			if (state->effects & EF_BLUE)
				vars.enemy_powerups |= TP_QUAD;
			if (state->effects & EF_RED)
				vars.enemy_powerups |= TP_PENT;
			if (eyes)
				vars.enemy_powerups |= TP_RING;
		}
	}
	if (!cl.spectator && !cl.teamfortress && info - cl.players == cl.playernum) {
		if ((state->effects & (EF_FLAG1|EF_FLAG2)) && !(oldstate->effects & (EF_FLAG1|EF_FLAG2))) {
			ExecTookTrigger (tp_name_flag.string, it_flag, cl.frames[cl.validsequence & UPDATE_MASK].playerstate[cl.playernum].origin);
		} else if (!(state->effects & (EF_FLAG1|EF_FLAG2)) && (oldstate->effects & (EF_FLAG1|EF_FLAG2))) {
			vars.lastdrop_time = cls.realtime;
			strlcpy (vars.lastdroploc, Macro_Location(), sizeof (vars.lastdroploc));
		}
	}
}

static qbool TP_DetectWeaponPickup(void)
{
	if (vars.items & ~vars.olditems & IT_LIGHTNING)
		ExecTookTrigger(tp_name_lg.string, it_lg, cl.simorg);
	else if (vars.items & ~vars.olditems & IT_ROCKET_LAUNCHER)
		ExecTookTrigger(tp_name_rl.string, it_rl, cl.simorg);
	else if (vars.items & ~vars.olditems & IT_GRENADE_LAUNCHER)
		ExecTookTrigger(tp_name_gl.string, it_gl, cl.simorg);
	else if (vars.items & ~vars.olditems & IT_SUPER_NAILGUN)
		ExecTookTrigger(tp_name_sng.string, it_sng, cl.simorg);
	else if (vars.items & ~vars.olditems & IT_NAILGUN)
		ExecTookTrigger(tp_name_ng.string, it_ng, cl.simorg);
	else if (vars.items & ~vars.olditems & IT_SUPER_SHOTGUN)
		ExecTookTrigger(tp_name_ssg.string, it_ssg, cl.simorg);
	else
		return false;
	return true;
}

void TP_CheckPickupSound (char *s, vec3_t org)
{
	item_t *item;

	if (cl.spectator)
		return;

	if (!strcmp(s, "items/damage.wav"))
		ExecTookTrigger (tp_name_quad.string, it_quad, org);
	else if (!strcmp(s, "items/protect.wav"))
		ExecTookTrigger (tp_name_pent.string, it_pent, org);
	else if (!strcmp(s, "items/inv1.wav"))
		ExecTookTrigger (tp_name_ring.string, it_ring, org);
	else if (!strcmp(s, "items/suit.wav"))
		ExecTookTrigger (tp_name_suit.string, it_suit, org);
	else if (!strcmp(s, "items/health1.wav") || !strcmp(s, "items/r_item1.wav"))
		ExecTookTrigger (tp_name_health.string, it_health, org);
	else if (!strcmp(s, "items/r_item2.wav"))
		ExecTookTrigger (tp_name_mh.string, it_mh, org);
	else
		goto more;
	return;

more:
	if (!cl.validsequence || !cl.oldvalidsequence)
		return;

	// weapons
	if (!strcmp(s, "weapons/pkup.wav"))	{
		if (FindNearestItem (it_weapons, &item)) {
			ExecTookTrigger (item->cvar->string, item->itemflag, org);
		} else if (vars.stat_framecounts[STAT_ITEMS] == cls.framecount) {
			if (! TP_DetectWeaponPickup())
				cl.last_weapon_pickup = cls.framecount;
		} else {
			cl.last_weapon_pickup = cls.framecount;
		}
		return;
	}

	// armor
	if (!strcmp(s, "items/armor1.wav"))	{
		qbool armor_updated;
		int armortype;

		armor_updated = (vars.stat_framecounts[STAT_ARMOR] == cls.framecount);
		armortype = FindNearestItem (it_armor, &item);
		if (armortype == 1 || (!armortype && armor_updated && cl.stats[STAT_ARMOR] == 100))
			ExecTookTrigger (tp_name_ga.string, it_ga, org);
		else if (armortype == 2 || (!armortype && armor_updated && cl.stats[STAT_ARMOR] == 150))
			ExecTookTrigger (tp_name_ya.string, it_ya, org);
		else if (armortype == 3 || (!armortype && armor_updated && cl.stats[STAT_ARMOR] == 200))
			ExecTookTrigger (tp_name_ra.string, it_ra, org);
		else 
			cl.last_armor_pickup = cls.framecount;
		return;
	}

	// backpack, ammo or runes
	if (!strcmp (s, "weapons/lock4.wav")) {
		if (FindNearestItem(it_ammo | it_pack | it_runes, &item))
			ExecTookTrigger(item->cvar->string, item->itemflag, org);
		else
			cl.last_ammo_pickup = cls.framecount;
		return;
	}
}

qbool TP_IsItemVisible(item_vis_t *visitem)
{
	vec3_t end, v;
	trace_t trace;

	if (visitem->dist <= visitem->radius)
		return true;

	VectorNegate (visitem->dir, v);
	VectorNormalizeFast (v);
	VectorMA (visitem->entorg, visitem->radius, v, end);
	trace = PM_TraceLine (visitem->vieworg, end);
	if ((int)trace.fraction == 1)
		return true;

	VectorMA (visitem->entorg, visitem->radius, visitem->right, end);
	VectorSubtract (visitem->vieworg, end, v);
	VectorNormalizeFast (v);
	VectorMA (end, visitem->radius, v, end);
	trace = PM_TraceLine (visitem->vieworg, end);
	if ((int)trace.fraction == 1)
		return true;

	VectorMA(visitem->entorg, -visitem->radius, visitem->right, end);
	VectorSubtract(visitem->vieworg, end, v);
	VectorNormalizeFast(v);
	VectorMA(end, visitem->radius, v, end);
	trace = PM_TraceLine(visitem->vieworg, end);
	if ((int)trace.fraction == 1)
		return true;

	VectorMA(visitem->entorg, visitem->radius, visitem->up, end);
	VectorSubtract(visitem->vieworg, end, v);
	VectorNormalizeFast(v);
	VectorMA (end, visitem->radius, v, end);
	trace = PM_TraceLine(visitem->vieworg, end);
	if ((int)trace.fraction == 1)
		return true;

	// use half the radius, otherwise it's possible to see through floor in some places
	VectorMA(visitem->entorg, -visitem->radius / 2, visitem->up, end);
	VectorSubtract(visitem->vieworg, end, v);
	VectorNormalizeFast(v);
	VectorMA(end, visitem->radius, v, end);
	trace = PM_TraceLine(visitem->vieworg, end);
	if ((int)trace.fraction == 1)
		return true;

	return false;
}

static float TP_RankPoint(item_vis_t *visitem)
{
	vec3_t v2, v3;
	float miss;

	if (visitem->dist < 10)
		return -1;

	VectorScale (visitem->forward, visitem->dist, v2);
	VectorSubtract (v2, visitem->dir, v3);
	miss = VectorLength (v3);
	if (miss > 300)
		return -1;
	if (miss > visitem->dist * (tp_pointpriorities.value ? 0.55 : 1.7)) // for prioritized point
		return -1;		// over 60 degrees off

	if (tp_pointpriorities.value)
		return 1;
	if (visitem->dist < 3000.0 / 8.0)
		return miss * (visitem->dist * 8.0 * 0.0002f + 0.3f);
	else return miss;
}

void TP_FindPoint (void)
{
	packet_entities_t *pak;
	entity_state_t *ent;
	int	i, j, tempflags;
	unsigned int pointflags_dmm;
	float best = -1, rank;
	entity_state_t *bestent = NULL;
	vec3_t ang;
	item_t *item, *bestitem = NULL;
	player_state_t *state, *beststate = NULL;
	player_info_t *info, *bestinfo = NULL;
	item_vis_t visitem;
	extern cvar_t v_viewheight;

	if (vars.pointtime == cls.realtime)
		return;

	if (!cl.validsequence)
		goto nothing;

	ang[0] = cl.viewangles[0]; ang[1] = cl.viewangles[1]; ang[2] = 0;
	AngleVectors (ang, visitem.forward, visitem.right, visitem.up);
	VectorCopy (cl.simorg, visitem.vieworg);
	visitem.vieworg[2] += 22 + (v_viewheight.value ? bound (-7, v_viewheight.value, 4) : 0);

	pointflags_dmm = pointflags;
	if (!cl.teamfortress && cl.deathmatch >= 1 && cl.deathmatch <= 4) {
		if (cl.deathmatch == 4)
			pointflags_dmm &= ~it_ammo;
		if (cl.deathmatch != 1)
			pointflags_dmm &= ~it_weapons;
	}

	pak = &cl.frames[cl.validsequence & UPDATE_MASK].packet_entities;
	for (i = 0,ent = pak->entities; i < pak->num_entities; i++, ent++) {
		item = model2item[ent->modelindex];
		if (!item || !(item->itemflag & pointflags_dmm))
			continue;
		// special check for armors
		if (item->itemflag == (it_ra|it_ya|it_ga)) {
			switch (ent->skinnum) {
					case 0: if (!(pointflags_dmm & it_ga)) continue; break;
					case 1: if (!(pointflags_dmm & it_ya)) continue; break;
					case 2: if (!(pointflags_dmm & it_ra)) continue; break;
			}
		}

		VectorAdd (ent->origin, item->offset, visitem.entorg);
		VectorSubtract (visitem.entorg, visitem.vieworg, visitem.dir);
		visitem.dist = DotProduct (visitem.dir, visitem.forward);
		visitem.radius = ent->effects & (EF_BLUE|EF_RED|EF_DIMLIGHT|EF_BRIGHTLIGHT) ? 200 : item->radius;

		if ((rank = TP_RankPoint(&visitem)) < 0)
			continue;

		if (tp_pointpriorities.value && rank != -1) {
			tempflags = item->itemflag;
			for (j = 1; j < NUM_ITEMFLAGS; j++)
				if (!(tempflags & 1))
					tempflags >>= 1;
				else
					break;

			/* FIXME: Added to prevent potential array out of bounds.
			 * Look into if its practically possible ... Anyway it wont
			 * crash now in case the loop above runs out
			 */
			if (j == NUM_ITEMFLAGS) {
				j--;
			}
			rank = pointpriorities[j];
		}

		// check if we can actually see the object
		if ((rank < best || best < 0) && TP_IsItemVisible(&visitem)) {
			best = rank;
			bestent = ent;
			bestitem = item;
		}
	}

	state = cl.frames[cl.parsecount & UPDATE_MASK].playerstate;
	info = cl.players;
	for (j = 0; j < MAX_CLIENTS; j++, info++, state++) {
		if (state->messagenum != cl.parsecount || j == cl.playernum || info->spectator)
			continue;

		if (
		    ( state->modelindex == cl_modelindices[mi_player] && ISDEAD(state->frame) ) ||
		    ( state->modelindex == cl_modelindices[mi_h_player] )
		)
			continue;

		VectorCopy (state->origin, visitem.entorg);
		visitem.entorg[2] += 30;
		VectorSubtract (visitem.entorg, visitem.vieworg, visitem.dir);
		visitem.dist = DotProduct (visitem.dir, visitem.forward);
		visitem.radius = (state->effects & (EF_BLUE|EF_RED|EF_DIMLIGHT|EF_BRIGHTLIGHT) ) ? 200 : 27;

		if ((rank = TP_RankPoint(&visitem)) < 0)
			continue;

		// check if we can actually see the object
		if ((rank < best || best < 0) && TP_IsItemVisible(&visitem)) {
			qbool teammate, eyes = false;

			eyes = state->modelindex && cl.model_precache[state->modelindex] && cl.model_precache[state->modelindex]->modhint == MOD_EYES;
			teammate = !!(cl.teamplay && !strcmp(info->team, TP_PlayerTeam()));

			if (eyes && !(pointflags_dmm & it_eyes))
				continue;
			else if (teammate && !(pointflags_dmm & it_teammate))
				continue;
			else if (!(pointflags_dmm & it_enemy))
				continue;

			best = rank;
			bestinfo = info;
			beststate = state;
		}
	}

	if (best >= 0 && bestinfo) {
		qbool teammate, eyes;
		char *name, buf[256] = {0};
        int flag = 0;

		eyes = beststate->modelindex && cl.model_precache[beststate->modelindex] &&
		       cl.model_precache[beststate->modelindex]->modhint == MOD_EYES;
		if (cl.teamfortress) {
			teammate = !strcmp(Utils_TF_ColorToTeam(bestinfo->real_bottomcolor), TP_PlayerTeam());

			if (eyes)
            {
				name = tp_name_eyes.string;		//duck on 2night2.bsp (TF map)
                flag = it_eyes;
            }
			else if (cl.spectator)
            {
				name = bestinfo->name;
                flag = it_players;
            }
			else if (teammate)
            {
				name = tp_name_teammate.string[0] ? tp_name_teammate.string : "teammate";
                flag = it_teammate;
            }
			else
            {
				name = tp_name_enemy.string;
                flag = it_enemy;
            }

			if (!eyes)
				name = va("%s%s%s", name, name[0] ? " " : "", Skin_To_TFSkin(Info_ValueForKey(bestinfo->userinfo, "skin")));
		} else {
			teammate = (cl.teamplay && !strcmp(bestinfo->team, TP_PlayerTeam()));

			if (eyes)
            {
				name = tp_name_eyes.string;
                flag = it_eyes;
            }
			else if (cl.spectator || (teammate && !tp_name_teammate.string[0]))
            {
				name = bestinfo->name;
                flag = it_teammate;
            }
			else
            {
				name = teammate ? tp_name_teammate.string : tp_name_enemy.string;
                flag = teammate ? it_teammate : it_enemy;
            }
		}
		if (beststate->effects & EF_BLUE)
        {
			strlcat (buf, tp_name_quaded.string, sizeof (buf) - strlen (buf));
            flag |= it_quaded;
        }
		if (beststate->effects & EF_RED)
        {
			strlcat (buf, va("%s%s", buf[0] ? " " : "", tp_name_pented.string), sizeof (buf) - strlen (buf));
            flag |= it_pented;
        }
		strlcat (buf, va("%s%s", buf[0] ? " " : "", name), sizeof (buf) - strlen (buf));
		strlcpy (vars.pointname, buf, sizeof (vars.pointname));
        vars.pointflag = flag;
		strlcpy (vars.pointloc, TP_LocationName(beststate->origin), sizeof(vars.pointloc));
		
		vars.pointtype = (teammate && !eyes) ? POINT_TYPE_TEAMMATE : POINT_TYPE_ENEMY;
	} else if (best >= 0) {
		char *p;

        vars.pointflag = bestitem->itemflag;

        if (!bestitem->cvar) {
			// armors are special
			switch (bestent->skinnum) {
					case 0: p = tp_name_ga.string; vars.pointflag = it_ga; break;
                    case 1: p = tp_name_ya.string; vars.pointflag = it_ya; break;
					default: p = tp_name_ra.string; vars.pointflag = it_ra;
			}
		} else {
			p = bestitem->cvar->string;
		}

		vars.pointtype = (bestitem->itemflag & (it_powerups|it_flag)) ? POINT_TYPE_POWERUP : POINT_TYPE_ITEM;
		strlcpy (vars.pointname, p, sizeof(vars.pointname));
		strlcpy (vars.pointloc, TP_LocationName(bestent->origin), sizeof(vars.pointloc));
	} else {
	nothing:
		strlcpy (vars.pointname, tp_name_nothing.string, sizeof(vars.pointname));
		vars.pointloc[0] = 0;
		vars.pointtype = POINT_TYPE_ITEM;
        vars.pointflag = 0;
	}
	vars.pointtime = cls.realtime;
}

void TP_ParseWeaponModel(model_t *model)
{
	static model_t *last_model = NULL;

	if (cl.teamfortress && (!cl.spectator || Cam_TrackNum() != -1)) {
		if (model && !last_model)
			TP_ExecTrigger ("f_reloadend");
		else if (!model && last_model)
			TP_ExecTrigger ("f_reloadstart");
	}
	last_model = model;
}

void TP_StatChanged (int stat, int value)
{
	int effects;

	effects = cl.frames[cl.parsecount & UPDATE_MASK].playerstate[cl.playernum].effects;

	switch (stat) {
		case STAT_HEALTH:
			if (value > 0) {
				if (vars.health <= 0) {
					extern cshift_t	cshift_empty;
					if (cl.teamfortress)
						memset (&cshift_empty, 0, sizeof(cshift_empty));
					if (CheckTrigger())
						TP_ExecTrigger ("f_respawn");
				}
				vars.health = value;
				return;
			}
			if (vars.health > 0) {		// We have just died
				vars.deathtrigger_time = cls.realtime;
				strlcpy (vars.lastdeathloc, Macro_Location(), sizeof (vars.lastdeathloc));

				CountNearbyPlayers(true);
				vars.last_numenemies = vars.numenemies;
				vars.last_numfriendlies = vars.numfriendlies;

				if (CheckTrigger()) {
					if (cl.teamfortress && (cl.stats[STAT_ITEMS] & (IT_KEY1|IT_KEY2)))
						TP_ExecTrigger ("f_flagdeath");
					else if (effects & (EF_FLAG1|EF_FLAG2))
						TP_ExecTrigger ("f_flagdeath");
					else
						TP_ExecTrigger ("f_death");
				}
			}
			vars.health = value;
			break;
		case STAT_ITEMS:
			if (value & ~vars.items & (IT_KEY1|IT_KEY2)) {
				if (cl.teamfortress && !cl.spectator)
					ExecTookTrigger (tp_name_flag.string, it_flag, cl.frames[cl.validsequence & UPDATE_MASK].playerstate[cl.playernum].origin);
			}
			if (!cl.spectator && cl.teamfortress && ~value & vars.items & (IT_KEY1|IT_KEY2)) {
				vars.lastdrop_time = cls.realtime;
				strlcpy (vars.lastdroploc, Macro_Location(), sizeof (vars.lastdroploc));
			}

			vars.olditems = vars.items;
			vars.items = value;

			// If we have received a sound previously, update 
			if (cl.last_weapon_pickup == cls.framecount)
				TP_DetectWeaponPickup();
			else if (cl.last_ammo_pickup == cls.framecount)
				ExecTookTrigger(tp_name_backpack.string, it_pack, cl.simorg);
			cl.last_weapon_pickup = 0;

			break;
		case STAT_ARMOR:
			if (cl.last_armor_pickup == cls.framecount)
			{
				if (value == 100)
					ExecTookTrigger(tp_name_ga.string, it_ga, cl.simorg);
				else if (value == 150)
					ExecTookTrigger(tp_name_ya.string, it_ya, cl.simorg);
				else if (value == 200)
					ExecTookTrigger(tp_name_ra.string, it_ra, cl.simorg);

				cl.last_armor_pickup = 0;
			}
			break;
		case STAT_ACTIVEWEAPON:
			if (cl.stats[STAT_ACTIVEWEAPON] != vars.activeweapon) {
				TP_ExecTrigger ("f_weaponchange");
				vars.activeweapon = cl.stats[STAT_ACTIVEWEAPON];
			}
			break;
	}
	vars.stat_framecounts[stat] = cls.framecount;
}

/****************************** MESSAGE FILTERS ******************************/

#ifdef _WIN32
#define wcscasecmp(s1, s2)	_wcsicmp  ((s1),   (s2))
#endif

#define MAX_FILTER_LENGTH 4
char filter_strings[8][MAX_FILTER_LENGTH + 1];
int	num_filters = 0;

//returns false if the message shouldn't be printed.
//Matching filters are stripped from the message
qbool TP_FilterMessage (wchar *source)
{
	size_t i, j, maxlen, len;

	if (!num_filters)
		return true;

	len = qwcslen (source);
	if (len < 2 || source[len - 1] != '\n' || source[len - 2] == '#')
		return true;

	maxlen = MAX_FILTER_LENGTH + 1;
	for (i = len - 2 ; i != 0 && maxlen != 0 ; i--, maxlen--) {
		if (source[i] == ' ')
			return true;
		if (source[i] == '#')
			break;
	}
	if (!i || !maxlen)
		return true; // no filter at all

	source[len - 1] = 0; // so that strcmp works properly

	for (j = 0; j < num_filters; j++)
#ifdef _WIN32
		if (!wcscasecmp(source + i + 1, str2wcs(filter_strings[j]))) {
#else
		if (!strcasecmp(wcs2str(source + i + 1), filter_strings[j])) {
#endif
			// strip the filter from message
			if (i && source[i - 1] == ' ')	{
				// there's a space just before the filter, remove it
				// so that soundtriggers like ^blah #att work
				source[i - 1] = '\n';
				source[i] = 0;
			} else {
				source[i] = '\n';
				source[i + 1] = 0;
			}
			return true;
		}

	source[len - 1] = '\n';
	return false; // this message is not for us, don't print it
}

void TP_MsgFilter_f (void)
{
	int c, i;
	char *s;

	if ((c = Cmd_Argc()) == 1) {
		if (!num_filters) {
			Com_Printf ("No filters defined\n");
			return;
		}
		for (i = 0; i < num_filters; i++)
			Com_Printf ("%s#%s", i ? " " : "", filter_strings[i]);
		Com_Printf ("\n");
		return;
	}

	if (c == 2 && (Cmd_Argv(1)[0] == 0 || !strcasecmp(Cmd_Argv(1), "clear"))) {
		num_filters = 0;
		return;
	}

	num_filters = 0;
	for (i = 1; i < c; i++) {
		s = Cmd_Argv(i);
		if (*s != '#') {
			Com_Printf ("A filter must start with \"#\"\n");
			return;
		}
		if (strchr(s + 1, ' ')) {
			Com_Printf ("A filter may not contain spaces\n");
			return;
		}
		strlcpy (filter_strings[num_filters], s + 1, sizeof(filter_strings[0]));
		num_filters++;
		if (num_filters >= 8)
			break;
	}
}

void TP_DumpMsgFilters(FILE *f)
{
	int i;

	fprintf(f, "filter       ");
	if (!num_filters)
		fprintf(f, "clear");

	for (i = 0; i < num_filters; i++)
		fprintf (f, "#%s ", filter_strings[i]);

	fprintf(f, "\n");
}

/************************************ INIT ************************************/
extern void TP_InitTriggers (void);
void TP_Init (void)
{
	TP_InitTriggers();
	TP_AddMacros();

	Cvar_SetCurrentGroup(CVAR_GROUP_CHAT);
	Cvar_Register (&cl_parseFunChars);
	Cvar_Register (&cl_parseSay);
	Cvar_Register (&cl_nofake);

	Cvar_SetCurrentGroup(CVAR_GROUP_SKIN);
	Cvar_Register (&cl_teamtopcolor);
	Cvar_Register (&cl_teambottomcolor);
	Cvar_Register (&cl_enemytopcolor);
	Cvar_Register (&cl_enemybottomcolor);
	Cvar_Register (&cl_enemybothskin);
	Cvar_Register (&cl_teambothskin);
	Cvar_Register (&cl_enemypentskin);
	Cvar_Register (&cl_teampentskin);
	Cvar_Register (&cl_enemyquadskin);
	Cvar_Register (&cl_teamquadskin);
	Cvar_Register (&cl_enemyskin);
	Cvar_Register (&cl_teamskin);
	Cvar_Register (&cl_teamlock);

	Cvar_SetCurrentGroup(CVAR_GROUP_COMMUNICATION);
	Cvar_Register(&tp_loadlocs);
	Cvar_Register(&tp_pointpriorities);
	Cvar_Register(&tp_tookpriorities);
	Cvar_Register(&tp_weapon_order);
	Cvar_Register(&tp_tooktimeout);
	Cvar_Register(&tp_pointtimeout);
	Cvar_Register(&tp_poweruptextstyle);

	Cvar_SetCurrentGroup(CVAR_GROUP_ITEM_NAMES);
	Cvar_Register (&tp_name_separator);
	Cvar_Register (&tp_name_none);
	Cvar_Register (&tp_name_nothing);
	Cvar_Register (&tp_name_at);
	Cvar_Register (&tp_name_someplace);

	Cvar_Register (&tp_name_rune1);
	Cvar_Register (&tp_name_rune2);
	Cvar_Register (&tp_name_rune3);
	Cvar_Register (&tp_name_rune4);

	Cvar_Register (&tp_name_status_blue);
	Cvar_Register (&tp_name_status_red);
	Cvar_Register (&tp_name_status_yellow);
	Cvar_Register (&tp_name_status_green);
	Cvar_Register (&tp_name_status_white);

	Cvar_Register (&tp_name_pented);
	Cvar_Register (&tp_name_quaded);
	Cvar_Register (&tp_name_eyes);
	Cvar_Register (&tp_name_enemy);
	Cvar_Register (&tp_name_teammate);
	Cvar_Register (&tp_name_disp);
	Cvar_Register (&tp_name_sentry);
	Cvar_Register (&tp_name_filter);
	Cvar_Register (&tp_name_flag);
	Cvar_Register (&tp_name_backpack);
	Cvar_Register (&tp_name_weapon);
	Cvar_Register (&tp_name_armor);
	Cvar_Register (&tp_name_health);
	Cvar_Register (&tp_name_mh);
	Cvar_Register (&tp_name_suit);
	Cvar_Register (&tp_name_ring);
	Cvar_Register (&tp_name_pent);
	Cvar_Register (&tp_name_quad);
	Cvar_Register (&tp_name_cells);
	Cvar_Register (&tp_name_rockets);
	Cvar_Register (&tp_name_nails);
	Cvar_Register (&tp_name_shells);
	Cvar_Register (&tp_name_armortype_ra);
	Cvar_Register (&tp_name_armortype_ya);
	Cvar_Register (&tp_name_armortype_ga);
	Cvar_Register (&tp_name_ra);
	Cvar_Register (&tp_name_ya);
	Cvar_Register (&tp_name_ga);
	Cvar_Register (&tp_name_lg);
	Cvar_Register (&tp_name_rl);
	Cvar_Register (&tp_name_rlg);
	Cvar_Register (&tp_name_gl);
	Cvar_Register (&tp_name_sng);
	Cvar_Register (&tp_name_ng);
	Cvar_Register (&tp_name_ssg);
	Cvar_Register (&tp_name_sg);
	Cvar_Register (&tp_name_axe);

	Cvar_SetCurrentGroup(CVAR_GROUP_ITEM_NEED);
	Cvar_Register (&tp_need_health);
	Cvar_Register (&tp_need_cells);
	Cvar_Register (&tp_need_rockets);
	Cvar_Register (&tp_need_nails);
	Cvar_Register (&tp_need_shells);
	Cvar_Register (&tp_need_ra);
	Cvar_Register (&tp_need_ya);
	Cvar_Register (&tp_need_ga);
	Cvar_Register (&tp_need_weapon);
	Cvar_Register (&tp_need_rl);

	TP_LocFiles_Init();

	Cvar_ResetCurrentGroup();
	Cmd_AddCommand ("teamcolor", TP_TeamColor_f);
	Cmd_AddCommand ("enemycolor", TP_EnemyColor_f);

	Cmd_AddCommand ("tp_msgreport", TP_Msg_Report_f);
	Cmd_AddCommand ("tp_msgcoming", TP_Msg_Coming_f);
    Cmd_AddCommand ("tp_msglost", TP_Msg_Lost_f);
    Cmd_AddCommand ("tp_msgenemypwr", TP_Msg_EnemyPowerup_f);
	Cmd_AddCommand ("tp_msgquaddead", TP_Msg_QuadDead_f);
    Cmd_AddCommand ("tp_msgsafe", TP_Msg_Safe_f);
	Cmd_AddCommand ("tp_msgkillme", TP_Msg_KillMe_f);
    Cmd_AddCommand ("tp_msghelp", TP_Msg_Help_f);
	Cmd_AddCommand ("tp_msggetquad", TP_Msg_GetQuad_f);
	Cmd_AddCommand ("tp_msggetpent", TP_Msg_GetPent_f);
	Cmd_AddCommand ("tp_msgpoint", TP_Msg_Point_f);
	Cmd_AddCommand ("tp_msgtook", TP_Msg_Took_f);
	Cmd_AddCommand ("tp_msgtrick", TP_Msg_Trick_f);
	Cmd_AddCommand ("tp_msgreplace", TP_Msg_Replace_f);
	Cmd_AddCommand ("tp_msgneed", TP_Msg_Need_f);
	Cmd_AddCommand ("tp_msgyesok", TP_Msg_YesOk_f);
	Cmd_AddCommand ("tp_msgnocancel", TP_Msg_NoCancel_f);
	Cmd_AddCommand ("tp_msgutake", TP_Msg_YouTake_f);
	Cmd_AddCommand ("tp_msgitemsoon", TP_Msg_ItemSoon_f);
	Cmd_AddCommand ("tp_msgwaiting", TP_Msg_Waiting_f);
	Cmd_AddCommand ("tp_msgslipped", TP_Msg_Slipped_f);
	//TF messages
	Cmd_AddCommand ("tp_msgtfconced", TP_Msg_TFConced_f);
}

extern void TP_ShutdownTriggers(void);

void TP_Shutdown(void)
{
	TP_ShutdownTriggers();

	TP_LocFiles_Shutdown();
}


================================================
FILE: src/teamplay.h
================================================
/*
	teamplay.c

	Teamplay enhancements ("proxy features")

	Copyright (C) 2000-2001       Anton Gavrilov

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version 2
	of the License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

	See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA
*/

#include <pcre2.h>

extern cvar_t cl_parsesay;
extern cvar_t cl_nofake;
extern cvar_t cl_teamskin, cl_enemyskin, cl_teamquadskin, cl_enemyquadskin;
extern cvar_t cl_teampentskin, cl_enemypentskin, cl_teambothskin, cl_enemybothskin;

typedef struct item_vis_s {
	vec3_t	vieworg;
	vec3_t	forward;
	vec3_t	right;
	vec3_t	up;
	vec3_t	entorg;
	float	radius;
	vec3_t	dir;		
	float	dist;		
} item_vis_t;

qbool TP_IsItemVisible(item_vis_t *visitem);


// triggers
void TP_ExecTrigger (const char *s);
void TP_StatChanged (int stat, int value);
void TP_CheckPickupSound (char *s, vec3_t org);
qbool TP_CheckSoundTrigger (wchar *str);

char *TP_PlayerName(void);
char *TP_PlayerTeam(void);
char *TP_MapName(void);
int	TP_CountPlayers(void);

// returns true if the player in the current POV is from given team
qbool TP_ThisPOV_IsHisTeam(const char* team);

// assigns numbers 1..n to teammates and enemies, returns given players number
int TP_PlayersNumber(int userid, const char* team);

// teamcolor & enemycolor
extern cvar_t cl_teamtopcolor, cl_teambottomcolor, cl_enemytopcolor, cl_enemybottomcolor;

char *TP_GetSkyGroupName(char *mapname, qbool *system);
char *TP_GetMapGroupName(char *mapname, qbool *system);
char *TP_ParseMacroString (char *s);
char *TP_ParseFunChars (const char *s, qbool chat);
void TP_NewMap (void);


#define msgtype_unknown   0
#define msgtype_normal    1
#define msgtype_team      2
#define msgtype_spec      4
#define msgtype_specteam  8
#define msgtype_qtv       16
/*
returns a logical combination of msgtype_* values
Note that sometimes we can't be sure who really sent the message,  e.g. when there's a
player "unnamed" in your team and "(unnamed)" in the enemy team. The result will be 3 (1+2)
*/
int TP_CategorizeMessage (const char *s, int *offset);
qbool TP_FilterMessage (wchar *s);


wchar *TP_ParseWhiteText (const wchar *s, qbool team, int offset);



void TP_UpdateSkins(void);
void TP_RefreshSkin(int);
void TP_RefreshSkins(void);
qbool TP_NeedRefreshSkins(void);

extern char *skinforcing_team;
char *TP_SkinForcingTeam(void);
qbool TP_TeamLockSpecified(void);

void TP_Init(void);
void TP_Shutdown(void);

//#define FPD_NO_TEAM_MACROS	1
#define FPD_NO_TIMERS		2
#define FPD_NO_SOUNDTRIGGERS	4 // disables triggers
#define FPD_NO_FORCE_SKIN	256
#define FPD_NO_FORCE_COLOR	512
#define FPD_LIMIT_PITCH		(1 << 14)
#define FPD_LIMIT_YAW		(1 << 15)
#define FPD_ENABLE_PLAYER_COUNT	(1 << 16)

/*fpd values from qizmo.txt
  1 = Disable %-reporting
  2 = Disable use of powerup timer (obsolete in v2.55)
  4 = Disable use of soundtrigger
  8 = Disable use of lag features
 16 = Make Qizmo report any changes in lag settins
 32 = Silent %e enemy vicinity reporting (reporter doesn't see the message)
      (always on in v2.55)
 64 = Spectators can't talk to players and vice versa (voice)
128 = Silent %x and %y (reporter doesn't see the message) (always on in v2.8)
256 = Disable skin forcing
512 = Disable color forcing
*/

#define MAX_LOC_NAME		64
#define MAX_MACRO_STRING 	2048

typedef struct locdata_s {
	vec3_t coord;
	char *name;
	struct locdata_s *next;
} locdata_t;

int BestWeaponFromStatItems (int stat);

#define it_quad		(1 << 0)
#define it_pent		(1 << 1)
#define it_ring		(1 << 2)
#define it_suit		(1 << 3)
#define it_ra		(1 << 4)
#define it_ya		(1 << 5)
#define it_ga		(1 << 6)
#define it_mh		(1 << 7)
#define it_health	(1 << 8)
#define it_lg		(1 << 9)
#define it_rl		(1 << 10)
#define it_gl		(1 << 11)
#define it_sng		(1 << 12)
#define it_ng		(1 << 13)
#define it_ssg		(1 << 14)
#define it_pack		(1 << 15)
#define it_cells	(1 << 16)
#define it_rockets	(1 << 17)
#define it_nails	(1 << 18)
#define it_shells	(1 << 19)
#define it_flag		(1 << 20)
#define it_teammate	(1 << 21)
#define it_enemy	(1 << 22)
#define it_eyes		(1 << 23)
#define it_sentry   (1 << 24)
#define it_disp		(1 << 25)
#define it_quaded   (1 << 26)
#define it_pented   (1 << 27)
#define it_rune1	(1 << 28)
#define it_rune2	(1 << 29)
#define it_rune3	(1 << 30)
#define it_rune4	((unsigned int) (1 << 31))
#define NUM_ITEMFLAGS 32
 
#define it_runes	(it_rune1|it_rune2|it_rune3|it_rune4)
#define it_powerups	(it_quad|it_pent|it_ring|it_suit)
#define it_weapons	(it_lg|it_rl|it_gl|it_sng|it_ssg)
#define it_armor	(it_ra|it_ya|it_ga)
#define it_ammo		(it_cells|it_rockets|it_nails|it_shells)
#define it_players	(it_teammate|it_enemy|it_eyes)

// this structure is cleared after entering a new map
typedef struct tvars_s
{
	int		health;
	int		items;
	int		olditems;
	int		activeweapon;
	int		stat_framecounts[MAX_CL_STATS];
	double	deathtrigger_time;
	float	f_skins_reply_time;
	float	f_version_reply_time;
	char	lastdeathloc[MAX_LOC_NAME];
	char	tookname[32];
    int     tookflag;
    char	tookloc[MAX_LOC_NAME];
	double	tooktime;
	double	pointtime; // cls.realtime for which pointitem & pointloc are valid
	char	pointname[64];
    int     pointflag;
	char	pointloc[MAX_LOC_NAME];
	int		pointtype;
	char	nearestitemloc[MAX_LOC_NAME];
	char	lastreportedloc[MAX_LOC_NAME];
	double	lastdrop_time;
	char	lastdroploc[MAX_LOC_NAME];
	char	lasttrigger_match[256];
	int		needflags;	// sum of items player needs, updated on TP_GetNeed()
 
	int	numenemies;
	int	numfriendlies;
	int	last_numenemies;
	int	last_numfriendlies;
 
	int enemy_powerups;
	double enemy_powerups_time;
} tvars_t;
 
extern tvars_t vars;

extern char *TP_PlayerName (void);

extern cvar_t tp_tooktimeout;

extern void TP_FindPoint (void);
#define TOOK_EMPTY() (!vars.tooktime || cls.realtime > vars.tooktime + tp_tooktimeout.value)

// updates the state of vars.needflags
void TP_GetNeed(void);

char *Macro_PointName (void);

// Locations
char *TP_LocationName (vec3_t location);
void TP_LocFiles_Init(void);
void TP_LocFiles_NewMap(void);
void TP_LocFiles_Shutdown(void);

char *TP_ItemName(int item_flag);


================================================
FILE: src/teamplay_locfiles.c
================================================
/*
Copyright (C) 2000-2003       Anton Gavrilov, A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

$Id: teamplay.c,v 1.96 2007-10-23 08:51:02 himan Exp $
*/

#include "quakedef.h"
#include "teamplay.h"

/********************************* .LOC FILES *********************************/

static locdata_t *locdata = NULL;
static int loc_count = 0;

static void TP_ClearLocs(void)
{
	locdata_t *node, *temp;

	for (node = locdata; node; node = temp) {
		Q_free(node->name);
		temp = node->next;
		Q_free(node);
	}

	locdata = NULL;
	loc_count = 0;
}

static void TP_ClearLocs_f(void)
{
	int num_locs = 0;

	if (Cmd_Argc() > 1) {
		Com_Printf("clearlocs : Clears all locs in memory.\n");
		return;
	}

	num_locs = loc_count;
	TP_ClearLocs();

	Com_Printf("Cleared %d locs.\n", num_locs);
}

static void TP_AddLocNode(vec3_t coord, char *name)
{
	locdata_t *newnode, *node;

	newnode = (locdata_t *)Q_malloc(sizeof(locdata_t));
	newnode->name = Q_strdup(name);
	newnode->next = NULL;
	memcpy(newnode->coord, coord, sizeof(vec3_t));

	if (!locdata) {
		locdata = newnode;
		loc_count++;
		return;
	}

	for (node = locdata; node->next; node = node->next)
		;

	node->next = newnode;
	loc_count++;
}

#define SKIPBLANKS(ptr) while (*ptr == ' ' || *ptr == '\t' || *ptr == '\r') ptr++
#define SKIPTOEOL(ptr) {while (*ptr != '\n' && *ptr != 0) ptr++; if (*ptr == '\n') ptr++;}

qbool TP_LoadLocFile(char *path, qbool quiet)
{
	char *buf, *p, locname[MAX_OSPATH] = { 0 }, location[MAX_LOC_NAME];
	int i, n, sign, line, nameindex, overflow;
	vec3_t coord;

	if (!*path) {
		return false;
	}

	strlcpy(locname, "locs/", sizeof(locname));
	if (strlen(path) + strlen(locname) + 2 + 4 > MAX_OSPATH) {
		Com_Printf("TP_LoadLocFile: path name > MAX_OSPATH\n");
		return false;
	}

	strlcat(locname, path, sizeof(locname) - strlen(locname));
	COM_DefaultExtension(locname, ".loc", sizeof(locname));

	if (!(buf = (char *)FS_LoadHeapFile(locname, NULL))) {
		if (!quiet) {
			Com_Printf("Could not load %s\n", locname);
		}
		return false;
	}

	TP_ClearLocs();

	// Parse the whole file now
	p = buf;
	line = 1;

	while (1) {
		SKIPBLANKS(p);

		if (!*p) {
			goto _endoffile;
		}
		else if (*p == '\n') {
			p++;
			goto _endofline;
		}
		else if (*p == '/' && p[1] == '/') {
			SKIPTOEOL(p);
			goto _endofline;
		}

		// parse three ints
		for (i = 0; i < 3; i++) {
			n = 0;
			sign = 1;
			while (1) {
				switch (*p++) {
					case ' ':
					case '\t':
						goto _next;
					case '-':
						if (n) {
							Com_Printf("Locfile error (line %d): unexpected '-'\n", line);
							SKIPTOEOL(p);
							goto _endofline;
						}
						sign = -1;
						break;
					case '0': case '1': case '2': case '3': case '4':
					case '5': case '6': case '7': case '8': case '9':
						n = n * 10 + (p[-1] - '0');
						break;
					default:	// including eol or eof
						Com_Printf("Locfile error (line %d): couldn't parse coords\n", line);
						SKIPTOEOL(p);
						goto _endofline;
				}
			}
		_next:
			n *= sign;
			coord[i] = n / 8.0;

			SKIPBLANKS(p);
		}

		// parse location name
		overflow = nameindex = 0;
		while (1) {
			switch (*p) {
				case '\r':
					p++;
					break;
				case '\n':
				case '\0':
					location[nameindex] = 0;
					TP_AddLocNode(coord, location);
					if (*p == '\n')
						p++;
					goto _endofline;
				default:
					if (nameindex < MAX_LOC_NAME - 1) {
						location[nameindex++] = *p;
					}
					else if (!overflow) {
						overflow = 1;
						Com_Printf("Locfile warning (line %d): truncating loc name to %d chars\n", line, MAX_LOC_NAME - 1);
					}
					p++;
			}
		}
	_endofline:
		line++;
	}
_endoffile:

	Q_free(buf);

	if (loc_count) {
		if (!quiet) {
			Com_Printf("Loaded locfile \"%s\" (%i loc points)\n", COM_SkipPath(locname), loc_count); // loc_numentries);
		}
	}
	else {
		TP_ClearLocs();
		if (!quiet) {
			Com_Printf("Locfile \"%s\" was empty\n", COM_SkipPath(locname));
		}
	}

	return true;
}

void TP_LoadLocFile_f(void)
{
	if (Cmd_Argc() != 2) {
		Com_Printf("loadloc <filename> : load a loc file\n");
		return;
	}
	TP_LoadLocFile(Cmd_Argv(1), false);
}

qbool TP_SaveLocFile(char *path, qbool quiet)
{
	locdata_t	*node;
	char		*buf;
	char		locname[MAX_OSPATH];

	// Prevents saving of junk data
	if (!loc_count) {
		Com_Printf("TP_SaveLocFile: There is no locations to save.\n");
		return false;
	}

	// Make sure we have a path to work with.
	if (!*path) {
		return false;
	}

	// Check if the filename is too long.
	if (strlen(path) > MAX_LOC_NAME) {
		Com_Printf("TP_SaveLocFile: Filename too long. Max allowed is %d characters\n", MAX_LOC_NAME);
		return false;
	}

	// Get the default path for loc-files and make sure the path
	// won't be too long.
	strlcpy(locname, "locs/", sizeof(locname));
	if (strlen(path) + strlen(locname) + 2 + 4 > MAX_OSPATH) {
		Com_Printf("TP_SaveLocFile: path name > MAX_OSPATH\n");
		return false;
	}

	// Add an extension if it doesn't exist already.
	strlcat(locname, path, sizeof(locname) - strlen(locname));
	COM_DefaultExtension(locname, ".loc", sizeof(locname));

	// Allocate a buffer to hold the file contents.
	buf = (char *)Q_calloc(loc_count * (MAX_LOC_NAME + 24), sizeof(char));

	if (!buf) {
		Com_Printf("TP_SaveLocFile: Could not initialize buffer.\n");
		return false;
	}

	// Write all the nodes to the buffer.
	//for (node = locdata; node; node = node->next) {
	node = locdata;
	while (node) {
		char row[2 * MAX_LOC_NAME];

		snprintf(row, sizeof(row), "%4d %4d %4d %s\n", Q_rint(8 * node->coord[0]), Q_rint(8 * node->coord[1]), Q_rint(8 * node->coord[2]), node->name);
		strlcat(buf, row, (loc_count * (MAX_LOC_NAME + 24)));
		node = node->next;
	}

	// Try writing the buffer containing the locs to file.
	if (!FS_WriteFile(locname, buf, strlen(buf))) {
		if (!quiet) {
			Com_Printf("TP_SaveLocFile: Could not open %s for writing\n", locname);
		}

		// Make sure we free our buffer.
		Q_free(buf);

		return false;
	}

	// Make sure we free our buffer.
	Q_free(buf);

	return true;
}

void TP_SaveLocFile_f(void)
{
	if (Cmd_Argc() != 2) {
		Com_Printf("saveloc <filename> : save a loc file\n");
		return;
	}
	TP_SaveLocFile(Cmd_Argv(1), false);
}

void TP_AddLoc(char *locname)
{
	vec3_t location;

	// We need to be up and running.
	if (cls.state != ca_active) {
		Com_Printf("Need to be active to add a location.\n");
		return;
	}

	if (cl.players[cl.playernum].spectator && Cam_TrackNum() >= 0) {
		VectorCopy(cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].playerstate[Cam_TrackNum()].origin, location);
	}
	else {
		VectorCopy(cl.simorg, location);
	}

	TP_AddLocNode(location, locname);

	Com_Printf("Added location \"%s\" at (%4.0f, %4.0f, %4.0f)\n", locname, location[0], location[1], location[2]);
}

static void TP_AddLoc_f(void)
{
	if (Cmd_Argc() != 2) {
		Com_Printf("addloc <name of location> : add a location\n");
		return;
	}
	TP_AddLoc(Cmd_Argv(1));
}

static void TP_RemoveClosestLoc(vec3_t location)
{
	float dist, mindist;
	vec3_t vec;
	locdata_t *node, *best, *previous, *best_previous;

	best_previous = previous = best = NULL;
	mindist = 0;

	// Find the closest loc.
	node = locdata;
	while (node) {
		// Get the distance to the loc.
		VectorSubtract(location, node->coord, vec);
		dist = vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2];

		// Check if it's closer than the previously best.
		if (!best || dist < mindist) {
			best_previous = previous;
			best = node;
			mindist = dist;
		}

		// Advance and save the previous node.
		previous = node;
		node = node->next;
	}

	if (!best) {
		Com_Printf("There is no locations left for deletion!\n");
		return;
	}


	Com_Printf("Removed location \"%s\" at (%4.0f, %4.0f, %4.0f)\n", best->name, best->coord[0], best->coord[1], best->coord[2]);

	// If the node we're trying to delete has a
	// next node attached to it, copy the data from
	// that node into the node we're deleting, and then
	// delete the next node instead.
	if (best->next) {
		locdata_t *temp;

		// Copy the data from the next node into the one we're deleting.
		VectorCopy(best->next->coord, best->coord);

		Q_free(best->name);
		best->name = (char *)Q_calloc(strlen(best->next->name) + 1, sizeof(char));
		strcpy(best->name, best->next->name);

		// Save the pointer to the next node.
		temp = best->next->next;

		// Free the current next node.
		Q_free(best->next->name);
		Q_free(best->next);

		// Set the pointer to the next node.
		best->next = temp;
	}
	else {
		// Free the current node.
		Q_free(best->name);
		Q_free(best);
		best = NULL;

		// Make sure the previous node doesn't point to garbage.
		if (best_previous != NULL) {
			best_previous->next = NULL;
		}
	}

	// Decrease the loc count.
	loc_count--;

	// If this was the last loc, remove the entire node list.
	if (loc_count <= 0) {
		locdata = NULL;
	}
}

static void TP_RemoveLoc_f(void)
{
	if (Cmd_Argc() == 1) {
		if (cl.players[cl.playernum].spectator && Cam_TrackNum() >= 0) {
			TP_RemoveClosestLoc(cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK].playerstate[Cam_TrackNum()].origin);
		}
		else {
			TP_RemoveClosestLoc(cl.simorg);
		}
	}
	else {
		Com_Printf("removeloc : remove the closest location\n");
		return;
	}
}

typedef struct locmacro_s {
	char *macro;
	char *val;
} locmacro_t;

static locmacro_t locmacros[] = {
	{ "ssg", "ssg" },
	{ "ng", "ng" },
	{ "sng", "sng" },
	{ "gl", "gl" },
	{ "rl", "rl" },
	{ "lg", "lg" },
	{ "separator", "-" },
	{ "ga", "ga" },
	{ "ya", "ya" },
	{ "ra", "ra" },
	{ "quad", "quad" },
	{ "pent", "pent" },
	{ "ring", "ring" },
	{ "suit", "suit" },
	{ "mh", "mega" },
};

#define NUM_LOCMACROS	(sizeof(locmacros) / sizeof(locmacros[0]))

char *TP_LocationName(vec3_t location)
{
	char *in, *out, *value;
	int i;
	float dist, mindist;
	vec3_t vec;
	static locdata_t *node, *best;
	cvar_t *cvar;
	extern cvar_t tp_name_someplace;
	static qbool recursive;
	static char	buf[1024], newbuf[MAX_LOC_NAME];

	if (!locdata || cls.state != ca_active) {
		return tp_name_someplace.string;
	}

	if (recursive) {
		return "";
	}

	best = NULL;
	mindist = 0;

	for (node = locdata; node; node = node->next) {
		VectorSubtract(location, node->coord, vec);
		dist = vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2];
		if (!best || dist < mindist) {
			best = node;
			mindist = dist;
		}
	}

	newbuf[0] = 0;
	out = newbuf;
	in = best->name;
	while (*in && out - newbuf < sizeof(newbuf) - 1) {
		if (!strncasecmp(in, "$loc_name_", 10)) {
			in += 10;
			for (i = 0; i < NUM_LOCMACROS; i++) {
				if (!strncasecmp(in, locmacros[i].macro, strlen(locmacros[i].macro))) {
					if ((cvar = Cvar_Find(va("loc_name_%s", locmacros[i].macro))))
						value = cvar->string;
					else
						value = locmacros[i].val;
					if (out - newbuf >= sizeof(newbuf) - strlen(value) - 1)
						goto done_locmacros;
					strcpy(out, value);
					out += strlen(value);
					in += strlen(locmacros[i].macro);
					break;
				}
			}
			if (i == NUM_LOCMACROS) {
				if (out - newbuf >= sizeof(newbuf) - 10 - 1)
					goto done_locmacros;
				strcpy(out, "$loc_name_");
				out += 10;
			}
		}
		else {
			*out++ = *in++;
		}
	}
done_locmacros:
	*out = 0;

	buf[0] = 0;
	recursive = true;
	Cmd_ExpandString(newbuf, buf);
	recursive = false;

	return buf;
}

void TP_LocFiles_Init(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_COMMUNICATION);
	Cmd_AddCommand("locations_loadfile", TP_LoadLocFile_f);
	Cmd_AddLegacyCommand("loadloc", "locations_loadfile");
	Cmd_AddCommand("locations_savefile", TP_SaveLocFile_f);
	Cmd_AddLegacyCommand("saveloc", "locations_savefile");
	Cmd_AddCommand("locations_add", TP_AddLoc_f);
	Cmd_AddLegacyCommand("addloc", "locations_add");
	Cmd_AddCommand("locations_remove", TP_RemoveLoc_f);
	Cmd_AddLegacyCommand("removeloc", "locations_remove");
	Cmd_AddCommand("locations_clearall", TP_ClearLocs_f);
	Cmd_AddLegacyCommand("clearlocs", "locations_clearall");
	Cvar_ResetCurrentGroup();
}

void TP_LocFiles_NewMap(void)
{
	static char last_map[MAX_QPATH] = { 0 };
	char *groupname;
	qbool system;
	char* mapname = TP_MapName();
	extern cvar_t tp_loadlocs;

	if (strcmp(mapname, last_map)) {	// map name has changed
		TP_ClearLocs();					// clear loc file

		// always load when playing back demos (teaminfo might be enabled etc)
		if ((tp_loadlocs.integer && cl.deathmatch) || cls.demoplayback) {
			if (!TP_LoadLocFile(va("%s.loc", mapname), true)) {
				if ((groupname = TP_GetMapGroupName(mapname, &system)) && !system) {
					TP_LoadLocFile(va("%s.loc", groupname), true);
				}
			}
			strlcpy(last_map, mapname, sizeof(last_map));
		}
		else {
			last_map[0] = 0;
		}
	}
}

void TP_LocFiles_Shutdown(void)
{
	TP_ClearLocs();
}


================================================
FILE: src/textencoding.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
//#include "q_shared.h"
#include "common.h"		// Com_DPrintf
#include "textencoding.h"
#include "utils.h"

#define ENCODED_BUFFER_SIZE 1024

// Each encoding function should return the number of bytes written to the output string
//   maxCharacters gives the characters before end of string, if function can't generate in given space, output ? instead
typedef int(*EncodingFunction)(char* output, wchar input, int maxCharacters);

static int koiEncoder(char* output, wchar input, int maxCharacters);
static int utf8Encoder(char* output, wchar input, int maxCharacters);
static int fteEncoder(char* output, wchar input, int maxCharacters);

static const char* encodingStrings[] = { "=`k8:", "=`utf8:", "" };
static const char* encodingSuffixes[] = { "`=", "`=", "" };
static const EncodingFunction encodingFunctions[] = { koiEncoder, utf8Encoder, fteEncoder };

extern cvar_t cl_textEncoding;
extern qbool R_CharAvailable (wchar c);

/* KOI8-R encodes Russian capital hard sign as 0xFF, but we can't use it
because it breaks older clients (qwcl).  We use 0xaf ('/'+ 0x80) instead. */
static char *wc2koi_table =
	"?3??4?67??" "??" "??" ">?"
	"abwgdevzijklmnop"
	"rstufhc~{}/yx|`q"
	"ABWGDEVZIJKLMNOP"
	"RSTUFHC^[]_YX\\@Q"
	"?#??$?&'??" "??" "??.?";

static int koiEncoder(char* out, wchar in, int maxCharacters) {
	if (in <= 255)
		out[0] = in;
	else if (in >= 0x400 && in <= 0x45f)
		out[0] = wc2koi_table[in - 0x400] + 128;
	else
		out[0] = '?';
	return 1;
}

static int utf8Encoder(char* out, wchar in, int maxCharacters) {
	if (in <= 0x7F) {
		// <= 127 is encoded as single byte, no translation
		out[0] = in;
		return 1;
	}
	else if (in <= 0x7FF && maxCharacters >= 2) {
		// Two byte characters... 5 bits then 6
		out[0] = 0xC0 | ((in >> 6) & 0x1F);
		out[1] = 0x80 | (in & 0x3F);
		return 2;
	}
	else if (in <= 0xFFFF && maxCharacters >= 3) {
		// Three byte characters... 4 bits then 6 then 6
		out[0] = 0xE0 | ((in >> 12) & 0x0F);
		out[1] = 0x80 | ((in >> 6) & 0x3F);
		out[2] = 0x80 | (in & 0x3F);
		return 3;
	}
	else {
		// Can't support four characters at the moment - values would be higher than wchar's two bytes
		// If we're here for a character we could support, we don't have room for it...
		out[0] = '?';
		return 1;
	}
}

// FIXME: Should we encode ^ as ^^?  FTE interprets ^^ as ^, but doesn't encode that way.
static int fteEncoder(char* out, wchar in, int maxCharacters) {
	if (in <= 0x7F) {
		// <= 127 is encoded as single byte, no translation
		out[0] = in;
		return 1;
	}

	// Otherwise it is ^UXXXX where XXXX is the codepage in hex - so need an extra 5 characters
	if (maxCharacters < sizeof(wchar) * 2 + 1)
	{
		out[0] = '?';
		return 1;
	}

	snprintf(out, maxCharacters + 1, "^U%04x", in);
	return 6;
}

static int TextEncodingMethod(void)
{
	return bound(0, cl_textEncoding.value, sizeof(encodingFunctions) / sizeof(encodingFunctions[0]) - 1);
}

int TextEncodingEncode(char* out, wchar input, int maxBytes)
{
	return (*encodingFunctions[TextEncodingMethod()])(out, input, maxBytes);
}

const char* TextEncodingPrefix(void)
{
	return encodingStrings[TextEncodingMethod()];
}

const char* TextEncodingSuffix(void)
{
	return encodingSuffixes[TextEncodingMethod()];
}

char *encode_say (wchar *in)
{
	static char buf[ENCODED_BUFFER_SIZE];
	wchar *p;
	char *out;

	memset(buf, 0, sizeof(buf));
	for (p = in; *p; p++)
		if (*p > 255)
			goto encode;
	strlcpy (buf, wcs2str(in), sizeof(buf));
	return buf;
encode:
	strlcpy (buf, wcs2str(in), min(p - in + 1, sizeof(buf)));
	in = p;
	strlcat (buf, TextEncodingPrefix(), sizeof(buf));
	out = buf + strlen(buf);
	
	char* lastValidCharacter = &buf[ENCODED_BUFFER_SIZE - strlen(TextEncodingSuffix()) - 1];	// Leave space for terminator
	while (*in && out <= lastValidCharacter)
	{
		out += TextEncodingEncode(out, *in, lastValidCharacter - out + 1);
		++in;
	}
	strlcat(buf, TextEncodingSuffix(), sizeof(buf));
	return buf;
}

//
// Decoding functions
//

static wchar koi2wc (char c)
{
	static char koi2wc_table[64] = {
		0x4e,0x30,0x31,0x46,0x34,0x35,0x44,0x33,0x45,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,
		0x3f,0x4f,0x40,0x41,0x42,0x43,0x36,0x32,0x4c,0x4b,0x37,0x48,0x4d,0x49,0x47,0x4a,
		0x2e,0x10,0x11,0x26,0x14,0x15,0x24,0x13,0x25,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,
		0x1f,0x2f,0x20,0x21,0x22,0x23,0x16,0x12,0x2c,0x2b,0x17,0x28,0x2d,0x29,0x27,0x2a
	};

	unsigned char uc = c;

	if (uc >= 192 /* && (unsigned char)c <= 255 */)
		return koi2wc_table[(unsigned char)c - 192] + 0x400;
	else if (uc == '#' + 128)
		return 0x0451;	// russian small yo
	else if (uc == '3' + 128)
		return 0x0401;	// russian capital yo
	else if (uc == '4' + 128)
		return 0x0404;	// ukrainian capital round E
	else if (uc == '$' + 128)
		return 0x0454;	// ukrainian small round E
	else if (uc == '6' + 128)
		return 0x0406;	// ukrainian capital I
	else if (uc == '&' + 128)
		return 0x0456;	// ukrainian small i
	else if (uc == '7' + 128)
		return 0x0407;	// ukrainian capital I with two dots
	else if (uc == '\'' + 128)
		return 0x0457;	// ukrainian small i with two dots
	else if (uc == '>' + 128)
		return 0x040e;	// belarusian Y
	else if (uc == '.' + 128)
		return 0x045e;	// belarusian y
	else if (uc == '/' + 128)
		return 0x042a;	// russian capital hard sign
	else
		return (wchar)(unsigned char)c;
}

static wchar cp1251towc (char c)
{
	unsigned char uc = c;
	if (uc >= 192)
		return 0x0410 + (uc - 192);
	else if (uc == 168)
		return 0x0401;	// russian capital yo
	else if (uc == 184)
		return 0x0451;	// russian small yo
	else if (uc == 170)
		return 0x0404;	// ukrainian capital round E
	else if (uc == 186)
		return 0x0454;	// ukrainian small round E
	else if (uc == 178)
		return 0x0406;	// ukrainian capital I
	else if (uc == 179)
		return 0x0456;	// ukrainian small i
	else if (uc == 175)
		return 0x0407;	// ukrainian capital I with two dots
	else if (uc == 191)
		return 0x0457;	// ukrainian small i with two dots
	else if (uc == 161)
		return 0x040e;	// belarusian Y
	else if (uc == 162)
		return 0x045e;	// belarusian y
	return (wchar)uc;
}

// returns Q_malloc'ed data
wchar *decode_koi8q (char *str) {
	wchar *buf, *out;
	buf = out = Q_malloc ((strlen(str) + 1)*sizeof(wchar));
	while (*str)
		*out++ = koi2wc(*str++);
	*out = 0;
	return buf;
};

// returns Q_malloc'ed data
wchar *decode_cp1251 (char *str) {
	wchar *buf, *out;
	buf = out = Q_malloc ((strlen(str) + 1)*sizeof(wchar));
	while (*str)
		*out++ = cp1251towc(*str++);
	*out = 0;
	return buf;
};

wchar TextEncodingDecodeUTF8(char* str, int* index)
{
	int stringLength = strlen(str);
	int extraBytes = 0;
	wchar result = 0;

	if (!(str[*index] & 0x80))
	{
		// Standard ASCII
		result = str[*index];
	}
	else
	{
		char valueMask = 0x7F;
		char lengthBits = (str[*index] << 1);

		// First character is 1<length in set bits><value>
		while (lengthBits & 0x80)
		{
			++extraBytes;
			lengthBits = (lengthBits << 1);

			valueMask >>= 1;
		}

		// Extract value from first character
		result = str[*index] & valueMask;

		while (extraBytes--)
		{
			*index = *index + 1;

			// Extra characters must be 10xx xxxx
			if (*index >= stringLength || (str[*index] & 0xC0) != 0x80)
				return 0;

			result <<= 6;
			result += str[*index] & 0x3F;
		}
	}

	return result;
}

wchar* decode_utf8(char* str) {
	wchar *buf, *out;
	int length = strlen(str);
	int i = 0;

	buf = out = Q_malloc((length + 1)*sizeof(wchar));	// This size would be worst case scenario
	for (i = 0; i < length; ++i)
	{
		*out = TextEncodingDecodeUTF8(str, &i);
		out++;
	}
	*out = 0;
	return buf;
};

typedef wchar *(*decodeFUNC) (char *);

static struct {
	char *name;
	decodeFUNC func;
} decode_table[] = {
	{"koi8q", decode_koi8q},
	{"koi8r", decode_koi8q},
	{"k8", decode_koi8q},
	{"cp1251", decode_cp1251},
	{"wr", decode_cp1251},	// wc = Windows Cyrillic wr = Windows Russian
	{"utf8", decode_utf8},
	{NULL, NULL}
};

qbool ishex(char ch)
{
	return (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f');
}

qbool wc_ishex(wchar ch)
{
	return ch < 127 && ishex(ch);
}

int wc_hextodec(wchar ch)
{
	return ch < 127 ? HexToInt(ch) : 0;
}

void decode_fte_string(wchar* s)
{
	while (s[0] && s[1])
	{
		if (s[0] == '^' && s[1] == '^')
		{
			// ^^ => ^
			qwcscpy(s + 1, s + 2);
		}
		else if (s[0] == '^' && s[1] == 'U' && s[2] && s[3] && s[4] && s[5] && wc_ishex(s[2]) && wc_ishex(s[3]) && wc_ishex(s[4]) && wc_ishex(s[5]))
		{
			// ^UXXXX, XXXX is hex for wchar
			s[0] = (wc_hextodec(s[2]) << 12) + (wc_hextodec(s[3]) << 8) + (wc_hextodec(s[4]) << 4) + wc_hextodec(s[5]);

			qwcscpy(s + 1, s + 6);
		}
		else if (s[0] == '^' && s[1] == '{')
		{
			// ^U{XXX...}, XXX.. is hex for wchar
			wchar* num = s + 2;
			wchar result = 0;

			while (*num && wc_ishex(*num))
			{
				result = result * 16 + wc_hextodec(*num);

				++num;
			}

			if (*num == '}')
			{
				if (result)
					s[0] = result;
				else
					s[0] = '?';

				qwcscpy(s + 1, num + 1);
			}
			else
			{
				s[0] = '?';
			}
		}
		++s;
	}
}

wchar *decode_string (const char *s)
{
	static wchar buf[2048];	// should be enough for everyone!!!
	char encoding[13];
	char enc_str[1024];
	const char *p, *q, *r;
	wchar *decoded;
	int i;

	buf[0] = 0;
	p = s;

	while (1)
	{
		p = strstr(p, "=`");
		if (!p)
			break;

		// copy source string up to p as is
		qwcslcat (buf, str2wcs(s), min(p-s+qwcslen(buf)+1, sizeof(buf)/sizeof(buf[0])));
		s = p;

		p += 2;		// skip the =`
		for (q = p; isalnum(*q) && q - p < 12; q++)	{
			;
		}
		if (!*q)
			break;
		if (*q != ':') {
			p += 2;
			continue;
		}

		q++;	// skip the :
		assert (q - p <= sizeof(encoding));
		strlcpy (encoding, p, q - p);
		
		r = strstr(q, "`=");
		if (!r) {
			p = q;
			continue;
		}

		strlcpy (enc_str, q, min(r - q + 1, sizeof(enc_str)));

		for (i = 0; decode_table[i].name; i++) {
			if (!strcasecmp(encoding, decode_table[i].name))
				break;	// found it
		}

		if (!decode_table[i].name) {
			// unknown encoding
			Con_DPrintf("Unknown encoding %s\n", encoding);
			p = r + 2;
			continue;	
		}

		decoded = decode_table[i].func(enc_str);
		qwcslcat (buf, decoded, sizeof(buf)/sizeof(buf[0]));
		Q_free (decoded);
		s = p = r + 2;
	}

	// copy remainder as is
	qwcslcat (buf, str2wcs(s), sizeof(buf)/sizeof(buf[0]));

	// FTE encodes strings differently. Decoded is always smaller, can execute in-place
	decode_fte_string(buf);

	return maybe_transliterate(buf);
}


char cyr_trans_table[] = {"ABVGDEZZIJKLMNOPRSTUFHCCSS'Y'EYY"};
wchar *transliterate_char (wchar c)
{
	static wchar s[2] = {0};

	if (c == 0x401)
		return str2wcs("YO");
	if (c == 0x404)
		return str2wcs("E");
	if (c == 0x406)
		return str2wcs("I");
	if (c == 0x407)
		return str2wcs("J");
	if (c == 0x40e)
		return str2wcs("U");
	if (c == 0x416)
		return str2wcs("ZH");
	if (c == 0x427)
		return str2wcs("CH");
	if (c == 0x428)
		return str2wcs("SH");
	if (c == 0x429)
		return str2wcs("SH");
	if (c == 0x42e)
		return str2wcs("YU");
	if (c == 0x42f)
		return str2wcs("YA");
	if (c == 0x451)
		return str2wcs("yo");
	if (c == 0x454)
		return str2wcs("e");
	if (c == 0x456)
		return str2wcs("i");
	if (c == 0x457)
		return str2wcs("j");
	if (c == 0x45e)
		return str2wcs("u");
	if (c == 0x436)
		return str2wcs("zh");
	if (c == 0x447)
		return str2wcs("ch");
	if (c == 0x448)
		return str2wcs("sh");
	if (c == 0x449)
		return str2wcs("sh");
	if (c == 0x44e)
		return str2wcs("yu");
	if (c == 0x44f)
		return str2wcs("ya");
	if (c >= 0x0410 && c < 0x0430)
		s[0] = cyr_trans_table[c - 0x410];
	else if (c >= 0x0430 && c < 0x0450)
		s[0] = tolower(cyr_trans_table[c - 0x430]);
	else
		s[0] = '?';
	return s;
}

// Make sure the renderer can display all Unicode chars in the string,
// otherwise try to replace them with Latin equivalents
wchar *maybe_transliterate (wchar *src)
{
	wchar *dst, *trans;
	static wchar buf[2048];
#define buflen (sizeof(buf)/sizeof(buf[0]))
	int len;

	dst = buf;
	while (*src && dst < buf+buflen-1) {
		if (R_CharAvailable(*src)) {
			*dst++ = *src;
		}
		else {
			trans = transliterate_char (*src);
			len = min(qwcslen(trans), buf+buflen-1 - dst);
			memcpy (dst, trans, len*sizeof(wchar));
			dst += len;
		}
		src++;
	}
	*dst = 0;

	return buf;
}


================================================
FILE: src/textencoding.h
================================================
/*
Copyright (C) 2011-2015 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

wchar *decode_string (const char *s);
char *encode_say (wchar *in);

wchar TextEncodingDecodeUTF8(char* str, int* index);

// Make sure the renderer can display all Unicode chars in the string,
// otherwise try to replace them with Latin equivalents
wchar *maybe_transliterate (wchar *src);


================================================
FILE: src/tp_msgs.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**

  Inbuilt teamplay messages module

  made by johnnycz, Up2nOgoOd[ROCK]
  last edit:
  $Id: tp_msgs.c,v 1.6 2007-10-23 08:51:02 himan Exp $

*/

#include "quakedef.h"
#include "teamplay.h"

#define GLOBAL /* */
#define LOCAL static

#define NEED_WEAPON() (NEED(rl) || NEED(lg))
#define HAVE_FLAG() (cl.stats[STAT_ITEMS] & IT_FLAG)
#define HAVE_RL() (cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER)
#define HAVE_LG() (cl.stats[STAT_ITEMS] & IT_LIGHTNING)
#define HAVE_GL() (cl.stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER)
#define HAVE_SNG() (cl.stats[STAT_ITEMS] & IT_SUPER_NAILGUN)
#define HAVE_SSG() (cl.stats[STAT_ITEMS] & IT_SUPER_SHOTGUN)
#define HOLD_GL() (cl.stats[STAT_ACTIVEWEAPON] == IT_GRENADE_LAUNCHER)
#define HOLD_RL() (cl.stats[STAT_ACTIVEWEAPON] == IT_ROCKET_LAUNCHER)
#define HOLD_LG() (cl.stats[STAT_ACTIVEWEAPON] == IT_LIGHTNING)
 
#define HAVE_POWERUP() (HAVE_QUAD() || HAVE_PENT() || HAVE_RING())
#define HAVE_QUAD() (cl.stats[STAT_ITEMS] & IT_QUAD) //quad
#define HAVE_PENT() (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) //pent
#define HAVE_RING() (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) //ring
#define HAVE_GA() (cl.stats[STAT_ITEMS] & IT_ARMOR1) //ga
#define HAVE_YA() (cl.stats[STAT_ITEMS] & IT_ARMOR2) //ya
#define HAVE_RA() (cl.stats[STAT_ITEMS] & IT_ARMOR3) //ra

#define HAVE_CELLS() (cl.stats[STAT_CELLS] > 0)
#define HAVE_ROCKETS() (cl.stats[STAT_ROCKETS] > 0)

// just some shortcuts:
#define INPOINTARMOR() (INPOINT(ra) || INPOINT(ya) || INPOINT(ga))
#define INPOINTWEAPON() (INPOINT(rl) || INPOINT(lg) || INPOINT(gl) || INPOINT(sng))
#define INPOINTPOWERUP() (INPOINT(quad) || INPOINT(pent) || INPOINT(ring))
#define INPOINTAMMO() (INPOINT(rockets) || INPOINT(cells) || INPOINT(nails))
 
#define TOOK(x) (!TOOK_EMPTY() && vars.tookflag == it_##x)
#define COLORED(c,str) "{&c" #c #str "&cfff}"

// it's important to call TP_FindPoint() before using these
// don't call TP_FindPoint if (flashed) is true
#define POINT_EMPTY() (!vars.pointflag)
#define INPOINT(thing) (!flashed && (vars.pointflag & it_##thing))

#define DEAD() (cl.stats[STAT_HEALTH] < 1)

// call TP_GetNeed() before using this!
#define NEED(x) (vars.needflags & it_##x)

typedef const char * MSGPART;
 
extern cvar_t cl_fakename;
// will return short version of player's nick for teamplay messages
LOCAL char *TP_ShortNick(void)
{
	static char buf[64];
 
	if (*(cl_fakename.string)) return "";
	else {
		if (*(Cvar_String("nick"))) { // isn't cl_fakename and name enough?
			snprintf(buf, sizeof(buf), "$\\%s%s", Cvar_String("nick"), Cvar_String("cl_fakename_suffix"));
		} else {
			snprintf(buf, sizeof(buf), "$\\%.3s%s", TP_PlayerName(), Cvar_String("cl_fakename_suffix"));
		}
		return buf;
	}
}      
 
// wrapper for snprintf & Cbuf_AddText that will add say_team nick part
LOCAL void TP_Send_TeamSay(char *format, ...)
{
    char tp_msg_head[256], tp_msg_body[256], tp_msg[512];
    va_list argptr;
 
    snprintf(tp_msg_head, sizeof(tp_msg_head), "say_team %s", TP_ShortNick());
 
	va_start (argptr, format);
    vsnprintf(tp_msg_body, sizeof(tp_msg_body), format, argptr);
	va_end (argptr);
 
    snprintf(tp_msg, sizeof(tp_msg), "%s%s\n", tp_msg_head, tp_msg_body);
 
    Cbuf_AddText(tp_msg);
}
 
 
 
///////////////////////////////////
////// Start teamplay scripts /////
///////////////////////////////////

GLOBAL void TP_Msg_Lost_f (void)
{
    MSGPART quad = "";
	MSGPART over = "";
	MSGPART dropped_or_lost = "";
	MSGPART location_enemy = " {&cf00[&cfff}{%d}{&cf00]&cfff} {%E}";
	extern cvar_t tp_name_quad;

	if (DEAD()) {
		if (HAVE_QUAD()) {
			quad = tp_name_quad.string;			
			over = " over ";
			location_enemy = "{&cf00[&cfff}{%d}{&cf00]&cfff} {%E}";
		}
		else
			dropped_or_lost = "{&cf00lost&cfff}";

		if (HOLD_RL() || HOLD_LG()) {
			dropped_or_lost = "{&cf00DROPPED} $weapon";
			location_enemy = " {&cf00[&cfff}{%d}{&cf00]&cfff} {%E}";
		}
	}
	else
		dropped_or_lost = "{&cf00lost&cfff}";

	TP_Send_TeamSay("%s%s%s%s", quad, over, dropped_or_lost, location_enemy);
}

GLOBAL void TP_Msg_Report_f (void)
{
	extern cvar_t tp_name_lg, tp_name_rl, tp_name_gl, tp_name_sng, tp_name_ssg;
	MSGPART powerup = "";
	MSGPART armor_health = "$colored_armor/%h";
	MSGPART location = "$[{%l}$]";
	MSGPART weapon = "";
	MSGPART rl = ""; // note we need by "rl" "lg" and "weapon" for the case that player has both
	MSGPART lg = "";
	MSGPART cells = "";
	MSGPART extra_cells = ""; //"extra" MSGPART needed to we can put these after %l
	MSGPART rockets = "";
	MSGPART extra_rockets = "";
	MSGPART ammo = "";
 
	if (DEAD()) {
		TP_Msg_Lost_f();
		return;
	}
	
	if (HAVE_POWERUP())
		powerup = "$tp_powerups ";
 
	if	(HAVE_RL() && HAVE_LG()) {
		rl = tp_name_rl.string;
		rockets = ":$rockets ";
		lg = tp_name_lg.string;
		cells = ":$cells ";
	}
	else if (HAVE_RL()) {
		rl = tp_name_rl.string;
		rockets = ":$rockets ";
	}
	else if (HAVE_LG()) {
		lg = tp_name_lg.string;
		cells = ":$cells ";
	}
	else if (HAVE_GL()) {
		weapon = tp_name_gl.string;
		ammo = ":$rockets ";
	}
	else if (HAVE_SNG()) {
		weapon = tp_name_sng.string;
		ammo = ":$nails ";
	}
	else if (HAVE_SSG()) {
		weapon = tp_name_ssg.string;
		ammo = ":$shells ";
	}
	
	// extra rockets and cells
	if (!HAVE_RL() && HAVE_ROCKETS())
		extra_rockets = " {&cf13r&cfff}:$rockets"; // see below comment
	if (!HAVE_LG() && HAVE_CELLS())
		extra_cells = " {&c2aac&cfff}:$cells"; //the "r" and "c" are hard-coded to have the same colors as tp_name_rl and tp_name_lg. Not sure if this is a good idea
											  //since the user can change those colors and then it won't match up
 	 
	TP_Send_TeamSay("%s%s %s%s%s%s%s%s%s%s%s", powerup, armor_health, weapon, ammo, rl, rockets, lg, cells, location, extra_rockets, extra_cells);
}

void TP_Msg_Need_f (void);
GLOBAL void TP_Msg_EnemyPowerup_f (void) // might as well add flag to this monster. need $point and $took to see red/blue flag!
{
	/*	This is the "go-to" function!". It contains all possible scenarios for any player, teammate or enemy, with any combination of powerup.
	!!! Please note this function is grouped into four parts: player with eyes (assumed enemy), enemy with powerup, you with powerup, teammate with powerup. !!! */
	extern cvar_t tp_name_quad, tp_name_pent, tp_name_quaded, tp_name_pented, tp_name_eyes, tp_name_enemy;
	MSGPART quad = "";
	MSGPART quaded = "";
	MSGPART pent = "";
	MSGPART pented = "";
	MSGPART eyes = "";
	MSGPART team = "";
	MSGPART enemy = "";
	MSGPART location = "at $[{%y}$]";
	MSGPART space = "";
	
	if (flashed) return;
    TP_FindPoint();
	
	/* Note we don't have && INPOINT(enemy) in the below if.
	This is because $point DOES NOT TELL YOU TEAMMATE/ENEMY if they have ring (because there is no way to know).
	Therefore, we don't assume enemy when we see eyes anymore because this confuses people into thinking it's ALWAYS enemy, so we just say "eyes at location" */		
	if (INPOINT(eyes)) {
		eyes = tp_name_eyes.string;

		if (INPOINT(quaded) && INPOINT(pented))	{ // Since we can't say "enemy (or) team eyes", instead we say "quaded pented eyes"
			quaded = tp_name_quaded.string;
			pented = tp_name_pented.string;
		}
		else if (INPOINT(quaded))
			quad = tp_name_quad.string;
		else if (INPOINT(pented))
			pent = tp_name_pent.string;
	}
	else if (INPOINT(enemy)) {
		enemy = tp_name_enemy.string; // %q is last seen powerup of enemy. defaults to quad, which is nice (but it won't be colored)
		space = " ";

		if (INPOINT(quaded) && INPOINT(pented))	{
			quad = tp_name_quad.string;
			pent = tp_name_pent.string;
		}
		else if (INPOINT(quaded))
			quad = tp_name_quad.string;
		else if (INPOINT(pented))
			pent = tp_name_pent.string;
		else {// Default to "enemy powerup", because that's the purpose of this function
			quad = "%q"; //we're hi-jacking "quad" here
			location = ""; //Report only "enemy quad", not "enemy quad %l" which is confusing
		}
	}
	else if (HAVE_POWERUP()) {
		if (DEAD()) { // if you are dead with powerup, then you dont technically have it.
			TP_Msg_Lost_f(); // this function will take care of it
			return;
		}
		
		TP_GetNeed();	
		if (NEED(health) || NEED(armor) || NEED_WEAPON() || NEED(rockets) || NEED(cells)) { // Note this doesn't include shells/nails. Not as broad as tp_msgneed.
			TP_Msg_Need_f();
			return;
		}
		else
			team = "{&c0b0team&cfff} $tp_powerups";
	}
	else if (INPOINT(teammate)) {
		team = "{&c0b0team&cfff} ";

		if (INPOINT(quaded) && INPOINT(pented))	{
			quad = tp_name_quad.string;
			pent = tp_name_pent.string;
		}
		else if (INPOINT(quaded))
			quad = tp_name_quad.string;
		else if (INPOINT(pented))
			pent = tp_name_pent.string;
		else { // Default to "enemy powerup", because that's the purpose of this function
			team = tp_name_enemy.string; // We're hi-jacking "team" to mean enemy here. %q is last seen powerup of enemy. defaults to quad, which is nice (but it won't be colored)
			quad = "%q"; // we're hi-jacking "quad" here
			location = ""; //Report only "enemy quad", not "enemy quad %l" which is confusing
		}
	}
	else { // Default to "enemy powerup", because that's the purpose of this function
		enemy = tp_name_enemy.string; // %q is last seen powerup of enemy. defaults to quad, which is nice (but it won't be colored)
		location = "%q"; //we're hi-jacking "location" here
	}

	TP_Send_TeamSay("%s%s%s%s%s%s%s%s %s", team, enemy, space, quad, pent, quaded, pented, eyes, location);
}


LOCAL void TP_Msg_GetPentQuad(qbool quad)
{
	extern cvar_t tp_name_quad, tp_name_pent;
	MSGPART get = "get";
	MSGPART powerup = "";

	TP_FindPoint();
 
	if (quad)
	{
		if (INPOINT(eyes) && INPOINT(quaded))
			return; // Don't know for sure if it's enemy or not, and can't assume like we do in tp_enemypwr because this isn't tp_ENEMYpwr
		else if (HAVE_QUAD() || INPOINT(quaded)) {
			TP_Msg_EnemyPowerup_f(); // let tp_msgenemypwr handle it. Also works for the case that we have quad and are dead
			return;
		}
		else
			powerup = tp_name_quad.string;
	}
	else // get pent
	{
		if (INPOINT(eyes) && INPOINT(pented))
			return; // Don't know for sure if it's enemy or not, and can't assume like we do in tp_enemypwr because this isn't tp_ENEMYpwr
		else if (HAVE_PENT() || INPOINT(pented)) { // if anyone has pent, as long as they dont have ring
			TP_Msg_EnemyPowerup_f(); // send to tp_enemypwr
			return;
		}			
		else
			powerup = tp_name_pent.string;
	}
 
	TP_Send_TeamSay("%s %s", get, powerup);
}
GLOBAL void TP_Msg_GetQuad_f (void) { TP_Msg_GetPentQuad(true); }
GLOBAL void TP_Msg_GetPent_f (void) { TP_Msg_GetPentQuad(false); }

GLOBAL void TP_Msg_QuadDead_f (void)
{
	extern cvar_t tp_name_quad;
    MSGPART quad = tp_name_quad.string;
	MSGPART dead = "dead/over";

	TP_FindPoint();
	if (HAVE_QUAD() && DEAD()) {
		TP_Msg_Lost_f(); // we use this function because it checks for dropped RL's, etc
		return;
	}
	else if (INPOINT(quaded)) { // This check is to make sure the button is not pressed accidentally.
		TP_Msg_EnemyPowerup_f(); // tp_enemypwr can handle this & all cases regarding players/powerups
		return;
	}

	TP_Send_TeamSay("%s %s", quad, dead);
}


GLOBAL void TP_Msg_Took_f (void)
{
	extern cvar_t tp_name_lg, tp_name_rl, tp_name_gl, tp_name_sng, tp_name_backpack, tp_name_cells, tp_name_rockets, tp_name_mh,
		tp_name_ra, tp_name_ya, tp_name_ga, tp_name_flag, tp_name_rune1, tp_name_rune2, tp_name_rune3, tp_name_rune4;
	MSGPART took = "";
	MSGPART at_location = " $[{%Y}$]"; // %Y is took location, remembers for 15 secs
	MSGPART powerup = "";
	MSGPART took_msg = "";
 
	if (TOOK_EMPTY())
		return;
	
	if (TOOK(quad) || TOOK(pent) || TOOK(ring)) {
		TP_GetNeed();
		
		if (DEAD())	{
			TP_Msg_QuadDead_f();
			return;
		}
		
		// Note that we check if you are holding powerup. This is because TOOK remembers for 15 seconds.
		// So a case could arise where you took quad then died less than 15 seconds later, and you'd be reporting "team need %u" (because $tp_powerups would be empty)
		else if ((NEED(health) || NEED(armor) || NEED_WEAPON() || NEED(rockets) || NEED(cells)) && HAVE_POWERUP())
			took = "{&c0b0team&cfff} $tp_powerups need %u";
		else if (HAVE_QUAD() || HAVE_RING()) // notice we can't send this check to tp_msgenemypwr, because if enemy with powerup is in your view, tp_enemypwr reports enemypwr first, but in this function you want to report TEAM powerup.
			took = "{&c0b0team&cfff} $tp_powerups";
		else { // In this case, you took quad or ring and died before 15 secs later. So just report what you need, nothing about powerups.
			took = "need %u"; //notice we don't say quad over, because it could be that you held ring. No way to distinguish
		}
	}
	else {
		if		(TOOK(rl))			took = tp_name_rl.string;
		else if (TOOK(lg))			took = tp_name_lg.string;
		else if (TOOK(gl))			took = tp_name_gl.string;
		else if (TOOK(sng))			took = tp_name_sng.string;
		else if (TOOK(pack))    	took = tp_name_backpack.string;
		else if (TOOK(cells))		took = tp_name_cells.string;
		else if (TOOK(rockets))		took = tp_name_rockets.string;
		else if (TOOK(mh))			took = tp_name_mh.string;
		else if (TOOK(ra))			took = tp_name_ra.string;
		else if (TOOK(ya))			took = tp_name_ya.string;
		else if (TOOK(ga))			took = tp_name_ga.string;
		else if (TOOK(flag))		took = tp_name_flag.string;
		else if (TOOK(rune1))		took = tp_name_rune1.string;
		else if (TOOK(rune2))		took = tp_name_rune2.string;
		else if (TOOK(rune3))		took = tp_name_rune3.string;
		else if (TOOK(rune4))		took = tp_name_rune4.string;
		else 						took = "{$took}"; // This should never happen
		
		took_msg = "took ";
		
		if (HAVE_POWERUP())
			powerup = "$tp_powerups ";
		else
			powerup = "";	
	}
	TP_Send_TeamSay("%s%s%s%s", powerup, took_msg, took, at_location);
}


GLOBAL void TP_Msg_Point_f (void)
{
	extern cvar_t tp_name_quad, tp_name_pent, tp_name_ring, tp_name_lg, tp_name_rl, tp_name_gl, tp_name_sng, tp_name_backpack,
		tp_name_ra, tp_name_ya, tp_name_ga, tp_name_cells, tp_name_rockets, tp_name_nails, tp_name_shells, tp_name_mh,
		tp_name_flag, tp_name_disp,	tp_name_sentry, tp_name_rune1, tp_name_rune2, tp_name_rune3, tp_name_rune4, tp_name_teammate, tp_name_enemy;
	MSGPART point = "";	
	MSGPART at_location = "at $[{%y}$] {%E}";
	MSGPART enemy = "";
	MSGPART powerup = "";
 
    if (flashed) // for teamfortres.
			return;

    TP_FindPoint();

	if (POINT_EMPTY())
		return;
	else if (INPOINT(eyes) || INPOINT(quaded) || INPOINT (pented)) {
		TP_Msg_EnemyPowerup_f(); // we use tp_enemypwr because it checks for all cases of player + powerup =)
		return;
	}

	// if you see something other than a player with powerup
	if (INPOINT(enemy))	{
		point = "{%E}";
		enemy = tp_name_enemy.string;
		at_location = " at $[{%y}$]"; // here we change at_location (remove {%E} at the end) because our point says how many enemies we have.
	}
	else if (INPOINT(teammate))	{
		if (tp_name_teammate.string[0]) // This will print the nick of your teammate if tp_name_teammate "" (not set). Else, it will print the value for tp_name_teammate
			point = tp_name_teammate.string;
		else
			point = va ("{&c0b0%s&cfff}", Macro_PointName());
	}
	else if (INPOINTPOWERUP() || INPOINTWEAPON() || INPOINTARMOR() || INPOINTAMMO() || INPOINT(pack) || INPOINT(mh) || INPOINT(flag) || INPOINT (disp) || INPOINT(sentry) || INPOINT(runes)) {
		if		(INPOINT(quad))		point = tp_name_quad.string;
		else if (INPOINT(pent))		point = tp_name_pent.string;
		else if (INPOINT(ring))		point = tp_name_ring.string;
		
		else if (INPOINT(rl))		point = tp_name_rl.string;
		else if (INPOINT(lg))		point = tp_name_lg.string;
		else if (INPOINT(gl))		point = tp_name_gl.string;
		else if (INPOINT(sng))		point = tp_name_sng.string;
		else if (INPOINT(pack))		point = tp_name_backpack.string;
		
		else if (INPOINT(ra))		point = tp_name_ra.string;
		else if (INPOINT(ya))		point = tp_name_ya.string;
		else if (INPOINT(ga))		point = tp_name_ga.string;
		
		else if (INPOINT(rockets)) 	point = tp_name_rockets.string;
		else if (INPOINT(cells)) 	point = tp_name_cells.string;
		else if (INPOINT(nails)) 	point = tp_name_nails.string;
		else if (INPOINT(shells)) 	point = tp_name_shells.string;
		
		else if (INPOINT(mh))		point = tp_name_mh.string;
		
		//TF. Note we can't tell whether they are enemy or team flag/disp/sent
		else if (INPOINT(flag))		point = tp_name_flag.string;
		else if (INPOINT(disp))		point = tp_name_disp.string;
		else if (INPOINT(sentry))	point = tp_name_sentry.string;
		
		//ctf, other
		else if (INPOINT(rune1))	point = tp_name_rune1.string;
		else if (INPOINT(rune2))	point = tp_name_rune2.string;
		else if (INPOINT(rune3))	point = tp_name_rune3.string;
		else if (INPOINT(rune4))	point = tp_name_rune4.string;
	}
	else point = "{$point}"; // this should never happen

	TP_Send_TeamSay("%s%s %s%s", powerup, point, enemy, at_location);
}


GLOBAL void TP_Msg_Need_f (void)
{
	MSGPART team_powerup = "";
    MSGPART need = "";
 
	if (DEAD())
		return;

	TP_GetNeed();

	if (NEED(health) || NEED(armor) || NEED_WEAPON() || NEED(rockets) || NEED(cells) || NEED(shells) || NEED(nails)) {
		need = "need %u $[{%l}$]";
		
		if (HAVE_POWERUP())
			team_powerup = "{&c0b0team&cfff} $tp_powerups ";
		
		if (need[0] == 0 && team_powerup[0] == 0)
			return;

		TP_Send_TeamSay("%s%s", team_powerup, need);
	}
}

GLOBAL void TP_Msg_Safe_f (void)
{
	extern cvar_t tp_name_rlg, tp_name_separator;
	MSGPART armor = "";
	MSGPART separator = "";
	MSGPART weapon = "";

	if (DEAD())
		return;

	TP_FindPoint(); // needed to make sure the area is, in fact, safe
	if (INPOINT(enemy) && !(INPOINT(quaded) || INPOINT(pented))) {
		return; //if you see an enemy without powerup, the place is still not 100% safe. But maybe you can handle him, so don't report anything yet.
	}
	if (INPOINT(enemy) && (INPOINT(quaded) || INPOINT(pented))) {
		TP_Msg_EnemyPowerup_f(); // if you see an enemy with a powerup, place is definitely not secure. report enemy powerup.
		return;
	}
	
	if ((HAVE_RA() || HAVE_YA() || HAVE_GA()) && (HAVE_RL() || HAVE_LG()))
		separator = tp_name_separator.string;
	if (HAVE_RA() || HAVE_YA() || HAVE_GA())
		armor = "$colored_armor";
	if (HAVE_RL() && HAVE_LG())
		weapon = tp_name_rlg.string;
	else if (HAVE_RL() || HAVE_LG())
		weapon = "$bestweapon";
	TP_Send_TeamSay("%s %s%s%s", "{&c0b0safe&cfff} {&c0b0[&cfff}{%l}{&c0b0]&cfff}", armor, separator, weapon);
}

GLOBAL void TP_Msg_KillMe_f (void)
{
	extern cvar_t tp_name_rl, tp_name_lg;
	MSGPART point = "";
	MSGPART kill_me = "{&cb1akill me [&cfff}{%l}{&cf2a]&cfff}";
	MSGPART weapon = "";
	MSGPART weapon_ammo = "";
	MSGPART extra_rockets = "";
	MSGPART extra_cells = "";

	if (DEAD())
		return;

	TP_FindPoint();
	if (INPOINT(teammate))
		point = va ("{&c0b0%s&cfff} ", Macro_PointName()); // Saying teammate kill me isn't much help. Only report if you can say e.g. Up2 Kill Me!

	if (HOLD_RL()) {
		weapon = tp_name_rl.string;
		weapon_ammo = ":$rockets ";
	}
	else if (HOLD_LG()) {
		weapon = tp_name_lg.string;
		weapon_ammo = ":$cells ";
	}

	if (!HOLD_RL() && HAVE_ROCKETS())
		extra_rockets = "{&cf13r&cfff}:$rockets "; // see below comment
	if (!HOLD_LG() && HAVE_CELLS())
		extra_cells = "{&c2aac&cfff}:$cells"; //the "r" and "c" are hard-coded to have the same colors as tp_name_rl and tp_name_lg. Not sure if this is a good idea
											  //since the user can change those colors and then it won't match up

	TP_Send_TeamSay("%s%s %s%s%s%s", point, kill_me, weapon, weapon_ammo, extra_rockets, extra_cells);
}

GLOBAL void TP_Msg_YouTake_f (void)
{
	MSGPART point = "";
	MSGPART take = "you take $[{%l}$]";

	TP_FindPoint();
	if (INPOINT(teammate)) {
			point = va ("{&c0b0%s&cfff} ", Macro_PointName()); // Saying teammate take isn't much help. Only report if you can say e.g. Up2 take!
			take = "take $[{%l}$]";
	}

	TP_Send_TeamSay("%s%s", point, take);
}

GLOBAL void TP_Msg_Help_f (void)
{
	TP_Send_TeamSay("%s%s", (HAVE_POWERUP() ? "$tp_powerups " : ""), "{&cff0help&cfff} {&cff0[&cfff}{%l}{&cff0]&cfff} {%e}"); // yellow help
}

// The following define allows us to make as many functions as we want and get the message "powerup message location"
#define TP_MSG_GENERIC(type) TP_Send_TeamSay("%s" type " $[{%%l}$]", (HAVE_POWERUP() ? "$tp_powerups " : ""))

GLOBAL void TP_Msg_YesOk_f (void)		{ TP_MSG_GENERIC("{yes/ok}"); }
GLOBAL void TP_Msg_NoCancel_f (void)	{ TP_MSG_GENERIC("{&cf00no/cancel&cfff}"); } //red no/cancel
GLOBAL void TP_Msg_ItemSoon_f (void)	{ TP_MSG_GENERIC("item soon"); }
GLOBAL void TP_Msg_Waiting_f (void)		{ TP_MSG_GENERIC("waiting"); }
GLOBAL void TP_Msg_Slipped_f (void)		{ TP_MSG_GENERIC("enemy slipped"); }
GLOBAL void TP_Msg_Replace_f (void)		{ TP_MSG_GENERIC("replace"); }
GLOBAL void TP_Msg_Trick_f (void)		{ TP_MSG_GENERIC("trick"); }
GLOBAL void TP_Msg_Coming_f (void)		{ TP_MSG_GENERIC("coming"); }

//TF binds
GLOBAL void TP_Msg_TFConced_f (void)
{
	extern cvar_t tp_name_filter;
	MSGPART conced = "";
	MSGPART filter = tp_name_filter.string;

	TP_FindPoint();
	if (INPOINT(enemy))
		conced = "$point conced at $[{%y}$]";
	else
		conced = "{Enemy conced}";

	TP_Send_TeamSay("%s %s", conced, filter);
}

///////////////////////////////////
////// End teamplay scripts ///////
///////////////////////////////////


GLOBAL const char *TP_MSG_Colored_Armor(void) // $colored_armor
{
	MSGPART armor = "";
 
	if (HAVE_GA())
		armor = COLORED(0b0,%a);
	else if (HAVE_YA())
		armor = COLORED(ff0,%a);
	else if (HAVE_RA())
		armor = COLORED(e00,%a);
	else
		armor = "0";
 
    return armor;
}

GLOBAL const char * TP_MSG_Colored_Powerup(void)
{
	extern cvar_t tp_name_pent, tp_name_quad, tp_name_ring, tp_name_separator;
    MSGPART pent = "";
	MSGPART quad = "";
	MSGPART ring = "";

	if (HAVE_QUAD() && HAVE_PENT() && HAVE_RING()) {
		pent = tp_name_pent.string;
		quad = tp_name_quad.string;
		ring = tp_name_ring.string;
	}
	else if (HAVE_QUAD() && HAVE_PENT()) {
		pent = tp_name_pent.string;
		quad = tp_name_quad.string;
	}
	else if (HAVE_QUAD() && HAVE_RING()) {
		quad = tp_name_quad.string;
		ring = tp_name_ring.string;
	}
	else if (HAVE_PENT() && HAVE_RING()) {
		pent = tp_name_pent.string;
		ring = tp_name_ring.string;
	}
	else if (HAVE_QUAD())
		quad = tp_name_quad.string;
	else if (HAVE_PENT())
		pent = tp_name_pent.string;
	else if (HAVE_RING())
		ring = tp_name_ring.string;

    return va("%s%s%s", quad, pent, ring);
}

#define tp_ib_name_q	    COLORED(03F,q)		// blue q for quad
#define tp_ib_name_p	    COLORED(e00,p)		// red p for pent
#define tp_ib_name_r	    COLORED(ff0,r)		// yellow r for ring

GLOBAL const char * TP_MSG_Colored_Short_Powerups(void) // this displays "qrp" instead of "quad ring pent", some people prefer this!
{
    MSGPART msg = "";

    if (HAVE_QUAD() && HAVE_RING() && HAVE_PENT())
		msg = tp_ib_name_q tp_ib_name_r tp_ib_name_p;
	else if (HAVE_QUAD() && HAVE_PENT())
		msg = tp_ib_name_q tp_ib_name_p;
	else if (HAVE_QUAD() && HAVE_RING())
		msg = tp_ib_name_q tp_ib_name_r;
	else if (HAVE_PENT() && HAVE_RING())
		msg = tp_ib_name_p tp_ib_name_r;
	else if (HAVE_QUAD())
		msg = tp_ib_name_q;
	else if (HAVE_PENT())
		msg = tp_ib_name_p;
	else if (HAVE_RING())
		msg = tp_ib_name_r;
	else
		msg = "";

    return msg;
}


================================================
FILE: src/tp_msgs.h
================================================
/*
Copyright (C) 2011 johnnycz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
  \file

  \brief
  Inbuilt teamplay messages module

  \author johnnycz
  \author Up2nOgOoD[ROCK]
**/

#ifndef __TP_MSGS_H__
#define __TP_MSGS_H__

extern void TP_Msg_Lost_f (void);
extern void TP_Msg_Report_f (void);
extern void TP_Msg_Coming_f (void);
extern void TP_Msg_EnemyPowerup_f (void);
extern void TP_Msg_Safe_f (void);
extern void TP_Msg_KillMe_f (void);
extern void TP_Msg_Help_f (void);
extern void TP_Msg_GetQuad_f (void);
extern void TP_Msg_GetPent_f (void);
extern void TP_Msg_QuadDead_f (void);
extern void TP_Msg_Took_f (void);
extern void TP_Msg_Point_f (void);
extern void TP_Msg_Need_f (void);
extern void TP_Msg_YesOk_f (void);
extern void TP_Msg_NoCancel_f (void);
extern void TP_Msg_YouTake_f (void);
extern void TP_Msg_ItemSoon_f (void);
extern void TP_Msg_Waiting_f (void);
extern void TP_Msg_Slipped_f (void);
extern void TP_Msg_Replace_f (void);
extern void TP_Msg_Trick_f (void);
//TF messages
extern void TP_Msg_TFConced_f (void);

extern const char* TP_MSG_Colored_Armor(void);
extern const char * TP_MSG_Colored_Powerup(void);
extern const char * TP_MSG_Colored_Short_Powerups(void);

#endif // __TP_MSGS_H__


================================================
FILE: src/tp_triggers.c
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: tp_triggers.c,v 1.9 2007-10-01 18:31:06 disconn3ct Exp $
*/

#include "quakedef.h"
#include "qsound.h"
#include "teamplay.h"
#include "rulesets.h"
#include "tp_triggers.h"
#include "utils.h"

cvar_t tp_msgtriggers = {"tp_msgtriggers", "1"};
cvar_t tp_soundtrigger = {"tp_soundtrigger", "~"};
cvar_t tp_triggers = {"tp_triggers", "1"};
cvar_t tp_forceTriggers = {"tp_forceTriggers", "0"};
// re-triggers stuff
cvar_t re_sub[10] = {{"re_trigger_match_0", "", CVAR_ROM},
                    {"re_trigger_match_1", "", CVAR_ROM},
                    {"re_trigger_match_2", "", CVAR_ROM},
                    {"re_trigger_match_3", "", CVAR_ROM},
                    {"re_trigger_match_4", "", CVAR_ROM},
                    {"re_trigger_match_5", "", CVAR_ROM},
                    {"re_trigger_match_6", "", CVAR_ROM},
                    {"re_trigger_match_7", "", CVAR_ROM},
                    {"re_trigger_match_8", "", CVAR_ROM},
                    {"re_trigger_match_9", "", CVAR_ROM}};
 
cvar_t re_subi[10] = {{"internal0"},
                     {"internal1"},
                     {"internal2"},
                     {"internal3"},
                     {"internal4"},
                     {"internal5"},
                     {"internal6"},
                     {"internal7"},
                     {"internal8"},
                     {"internal9"}};
 
static pcre_trigger_t *re_triggers;
static pcre_internal_trigger_t *internal_triggers;

extern char lastip[64];

/********************************** TRIGGERS **********************************/
 
typedef struct f_trigger_s {
	char *name;
	qbool restricted;
	qbool teamplay;
} f_trigger_t;
 
f_trigger_t f_triggers[] = {
	{"f_newmap", false, false},
	{"f_spawn", false, false},
	{"f_mapend", false, false},
	{"f_reloadstart", false, false},
	{"f_reloadend", false, false},
	{"f_cfgload", false, false},
	{"f_exit", false, false},
	{"f_demostart", false, false},
	{"f_demoend", false, false},
	{"f_captureframe", false, false},
	{"f_sbrefreshdone", false, false},
	{"f_sbupdatesourcesdone", false, false},
	{"f_focusgained", false, false},

	{"f_freeflyspectate", false, false},
	{"f_trackspectate", false, false},

	{"f_weaponchange", false, false},

	{"f_took", true, true},
	{"f_respawn", true, true},
	{"f_death", true, true},
	{"f_flagdeath", true, true},

	{"f_conc", true, true},
	{"f_flash", true, true},
	{"f_bonusflash", true, true},

	{"f_demomatchstart", false, false},
	{"f_countdownstart", false, false},
	{"f_countdownbreak", false, false}
};
 
#define num_f_triggers	(sizeof(f_triggers) / sizeof(f_triggers[0]))
 
void TP_ExecTrigger (const char *trigger)
{
	int i, j, numteammates = 0;
	cmd_alias_t *alias;
 
	if (!tp_triggers.value || ((cls.demoplayback || cl.spectator) && cl_restrictions.value))
		return;
 
	for (i = 0; i < num_f_triggers; i++) {
		if (!strcmp (f_triggers[i].name, trigger))
			break;
	}

	if (i == num_f_triggers) {
		Com_Printf ("Unknown f_trigger \"%s\"", trigger);
		return;
	}
 
	if (f_triggers[i].teamplay && !tp_forceTriggers.value) {
		if (!cl.teamplay)
			return;
 
		for (j = 0; j < MAX_CLIENTS; j++)
			if (cl.players[j].name[0] && !cl.players[j].spectator && j != cl.playernum)
				if (!strcmp(cl.players[j].team, cl.players[cl.playernum].team))
					numteammates++;
 
		if (!numteammates)
			return;
	}
 
	if ((alias = Cmd_FindAlias (trigger))) {
		if (!(f_triggers[i].restricted && Rulesets_RestrictTriggers ())) {
			Cbuf_AddTextEx(alias->flags & ALIAS_SERVER ? &cbuf_svc : &cbuf_main,
				va("%s\n", alias->value));
		}
	}
}
 
/******************************* SOUND TRIGGERS *******************************/
 
//Find and execute sound triggers. A sound trigger must be terminated by either a CR or LF.
//Returns true if a sound was found and played
qbool TP_CheckSoundTrigger (wchar *wstr)
{
	char *str;
	int i, j, start, length;
	char soundname[MAX_OSPATH];
	vfsfile_t *v;

	str = wcs2str (wstr);
 
	if (!*str) {
		return false;
	}
 
	if (!tp_soundtrigger.string[0]) {
		return false;
	}

	if (Rulesets_RestrictTriggers()) {
		return false;
	}
 
	for (i = strlen (str) - 1; i; i--)	{
		if (str[i] != 0x0A && str[i] != 0x0D)
			continue;
 
		for (j = i - 1; j >= 0; j--) {
			// quick check for chars that cannot be used
			// as sound triggers but might be part of a file name
			if (isalnum((unsigned char)str[j]))
				continue;	// file name or chat
 
			if (strchr(tp_soundtrigger.string, str[j]))	{
				// this might be a sound trigger
 
				start = j + 1;
				length = i - start;
 
				if (!length)
					break;
				if (length >= MAX_QPATH)
					break;
 
				strlcpy (soundname, str + start, length + 1);
				if (strstr(soundname, ".."))
					break;	// no thank you
 
				// clean up the message
				Q_strcpy (str + j, str + i);
				qwcscpy (wstr + j, wstr + i);
 
				if (!snd_initialized || !snd_started)
					return false;
 
				COM_DefaultExtension (soundname, ".wav", sizeof(soundname));
 
				// make sure we have it on disk (FIXME)
				if (!(v = FS_OpenVFS(va("sound/%s", soundname), "rb", FS_ANY))) 
					return false;
				VFS_CLOSE(v);
 
				// now play the sound
				S_LocalSound (soundname);
				return true;
			}
			if (str[j] == '\\')
				str[j] = '/';
			if (str[j] <= ' ' || strchr("\"&'*,:;<>?\\|\x7f", str[j]))
				break;	// we don't allow these in a file name
		}
	}
 
	return false;
}

/****************************** MESSAGE TRIGGERS ******************************/
 
typedef struct msg_trigger_s
{
	char	name[32];
	char	string[64];
	int		level;
	struct msg_trigger_s *next;
} msg_trigger_t;
 
static msg_trigger_t *msg_triggers;
 
void TP_ResetAllTriggers (void)
{
	msg_trigger_t *temp;
 
	while (msg_triggers) {
		temp = msg_triggers->next;
		Q_free(msg_triggers);
		msg_triggers = temp;
	}
}
 
void TP_DumpTriggers (FILE *f)
{
	msg_trigger_t *t;
 
	for (t = msg_triggers; t; t = t->next) {
		if (t->level == PRINT_HIGH)
			fprintf(f, "msg_trigger  %s \"%s\"\n", t->name, t->string);
		else
			fprintf(f, "msg_trigger  %s \"%s\" -l %c\n", t->name, t->string, t->level == 4 ? 't' : '0' + t->level);
	}
}
 
msg_trigger_t *TP_FindTrigger (char *name)
{
	msg_trigger_t *t;
 
	for (t = msg_triggers; t; t = t->next)
		if (!strcmp(t->name, name))
			return t;
 
	return NULL;
}
 
void TP_MsgTrigger_f (void)
{
	int c;
	char *name;
	msg_trigger_t *trig;
 
	c = Cmd_Argc();
 
	if (c > 5) {
		Com_Printf ("msg_trigger <trigger name> \"string\" [-l <level>]\n");
		return;
	}
 
	if (c == 1) {
		if (!msg_triggers)
			Com_Printf ("no triggers defined\n");
		else
			for (trig=msg_triggers; trig; trig=trig->next)
				Com_Printf ("%s : \"%s\"\n", trig->name, trig->string);
		return;
	}
 
	name = Cmd_Argv(1);
	if (strlen(name) > 31) {
		Com_Printf ("trigger name too long\n");
		return;
	}
 
	if (c == 2) {
		trig = TP_FindTrigger (name);
		if (trig)
			Com_Printf ("%s: \"%s\"\n", trig->name, trig->string);
		else
			Com_Printf ("trigger \"%s\" not found\n", name);
		return;
	}
 
	if (c >= 3) {
		if (strlen(Cmd_Argv(2)) > 63) {
			Com_Printf ("trigger string too long\n");
			return;
		}
 
		if (!(trig = TP_FindTrigger (name))) {
			// allocate new trigger
			trig = (msg_trigger_t *) Q_malloc(sizeof(msg_trigger_t));
			trig->next = msg_triggers;
			msg_triggers = trig;
			strlcpy (trig->name, name, sizeof (trig->name));
			trig->level = PRINT_HIGH;
		}
 
		strlcpy (trig->string, Cmd_Argv(2), sizeof(trig->string));
		if (c == 5 && !strcasecmp (Cmd_Argv(3), "-l")) {
			if (!strcmp(Cmd_Argv(4), "t")) {
				trig->level = 4;
			} else {
				trig->level = Q_atoi (Cmd_Argv(4));
				if ((unsigned) trig->level > PRINT_CHAT)
					trig->level = PRINT_HIGH;
			}
		}
	}
}
 
static qbool TP_IsFlagMessage (const char *message)
{
	if (strstr(message, " has your key!") ||
	        strstr(message, " has taken your Key") ||
	        strstr(message, " has your flag") ||
	        strstr(message, " took your flag!") ||
	        strstr(message, " &#65533;&#65533; &#65533;&#65533; flag!") ||
	        strstr(message, " &#65533;&#65533;&#65533;&#65533; &#65533;&#65533;") || strstr(message, " &#65533;&#65533;&#65533;&#65533;&#65533;&#65533;&#65533;") ||
	        strstr(message, " took the blue flag") || strstr(message, " took the red flag") ||
	        strstr(message, " Has the Red Flag") || strstr(message, " Has the Blue Flag")
	   )
		return true;
 
	return false;
}
 
void TP_SearchForMsgTriggers (const char *s, int level)
{
	msg_trigger_t	*t;
	char *string;
 
	// message triggers disabled
	if (!tp_msgtriggers.value)
		return;
 
	// triggers banned by ruleset
	if (Rulesets_RestrictTriggers () && !cls.demoplayback && !cl.spectator)
		return;
 
	// we are in spec/demo mode, so play triggers if user want it
	if ((cls.demoplayback || cl.spectator) && cl_restrictions.value)
		return;
 
	for (t = msg_triggers; t; t = t->next) {
		if ((t->level == level || (t->level == 3 && level == 4)) && t->string[0] && strstr(s, t->string)) {
			if (level == PRINT_CHAT && (
			            strstr (s, "f_version") || strstr (s, "f_skins") || strstr(s, "f_fakeshaft") ||
			            strstr (s, "f_server") || strstr (s, "f_scripts") || strstr (s, "f_cmdline") ||
			            strstr (s, "f_system") || strstr (s, "f_speed") || strstr (s, "f_modified"))
			   )
				continue; // don't let llamas fake proxy replies
 
			if (cl.teamfortress && level == PRINT_HIGH && TP_IsFlagMessage (s))
				continue;
 
			if ((string = Cmd_AliasString (t->name))) {
				strlcpy(vars.lasttrigger_match, s, sizeof (vars.lasttrigger_match));
				Cbuf_AddTextEx (&cbuf_safe, va("%s\n", string));
			} else {
				Com_Printf ("trigger \"%s\" has no matching alias\n", t->name);
			}
		}
	}
}
 
/**************************** REGEXP TRIGGERS *********************************/
 
typedef void ReTrigger_func (pcre_trigger_t *);
 
static void Trig_ReSearch_do (ReTrigger_func f)
{
	pcre_trigger_t *trig;
 
	for( trig = re_triggers; trig; trig = trig->next) {
		if (ReSearchMatch (trig->name))
			f (trig);
	}
}
 
static pcre_trigger_t *prev;
pcre_trigger_t *CL_FindReTrigger (char *name)
{
	pcre_trigger_t *t;
 
	prev=NULL;
	for (t=re_triggers; t; t=t->next) {
		if (!strcmp(t->name, name))
			return t;
 
		prev = t;
	}
	return NULL;
}
 
static void DeleteReTrigger (pcre_trigger_t *t)
{
	if (t->regexp)
		(pcre2_code_free)(t->regexp);

	if (t->regexpstr)
		Q_free(t->regexpstr);

	Q_free(t->name);
	Q_free(t);
}
 
static void RemoveReTrigger (pcre_trigger_t *t)
{
	// remove from list
	if (prev)
		prev->next = t->next;
	else
		re_triggers = t->next;
	// free memory
	DeleteReTrigger(t);
}
 
static void CL_RE_Trigger_f (void)
{
	int c,i,m;
	char *name;
	char *regexpstr;
	pcre_trigger_t *trig;
	pcre2_code *re;
	int error;
	PCRE2_SIZE error_offset;
	qbool newtrigger=false;
	qbool re_search = false;
 
	c = Cmd_Argc();
	if (c > 3) {
		Com_Printf ("re_trigger <trigger name> <regexp>\n");
		return;
	}
 
	if (c == 2 && IsRegexp(Cmd_Argv(1))) {
		re_search = true;
	}
 
	if (c == 1 || re_search) {
		if (!re_triggers) {
			Com_Printf ("no regexp_triggers defined\n");
		} else {
			if (re_search && !ReSearchInit(Cmd_Argv(1)))
				return;
 
			Com_Printf ("List of re_triggers:\n");
 
			for (trig=re_triggers, i=m=0; trig; trig=trig->next, i++) {
				if (!re_search || ReSearchMatch(trig->name)) {
					Com_Printf ("%s : \"%s\" : %d\n", trig->name, trig->regexpstr, trig->counter);
					m++;
				}
			}
 
			Com_Printf ("------------\n%i/%i re_triggers\n", m, i);
			if (re_search)
				ReSearchDone();
		}
		return;
	}
 
	name = Cmd_Argv(1);
	trig = CL_FindReTrigger (name);
 
	if (c == 2) {
		if (trig) {
			Com_Printf ("%s: \"%s\"\n", trig->name, trig->regexpstr);
			Com_Printf ("  options: mask=%d interval=%g%s%s%s%s%s\n", trig->flags & 0xFF,
			            trig->min_interval,
			            trig->flags & RE_FINAL ? " final" : "",
			            trig->flags & RE_REMOVESTR ? " remove" : "",
			            trig->flags & RE_NOLOG ? " nolog" : "",
			            trig->flags & RE_ENABLED ? "" : " disabled",
			            trig->flags & RE_NOACTION ? " noaction" : ""
			           );
			Com_Printf ("  matched %d times\n", trig->counter);
		} else {
			Com_Printf ("re_trigger \"%s\" not found\n", name);
		}
		return;
	}
 
	if (c == 3) {
		regexpstr = Cmd_Argv(2);
		if (!trig) {
			// allocate new trigger
			newtrigger = true;
			trig = (pcre_trigger_t *) Q_malloc(sizeof(pcre_trigger_t));
			trig->next = re_triggers;
			re_triggers = trig;
			trig->name = Q_strdup(name);
			trig->flags = RE_PRINT_ALL | RE_ENABLED; // catch all printed messages by default
		}
 
		error = 0;
		if ((re = pcre2_compile((PCRE2_SPTR)regexpstr, PCRE2_ZERO_TERMINATED, 0, &error, &error_offset, NULL))) {
			error = 0;
			if (!newtrigger) {
				(pcre2_code_free)(trig->regexp);
				Q_free(trig->regexpstr);
			}
			trig->regexpstr = Q_strdup(regexpstr);
			trig->regexp = re;
			return;
		} else {
			Com_Printf ("Invalid regexp: %s\n", error);
		}
		prev = NULL;
		RemoveReTrigger(trig);
	}
}
 
static void CL_RE_Trigger_Options_f (void)
{
	int c,i;
	char* name;
	pcre_trigger_t *trig;
 
	c = Cmd_Argc ();
	if (c < 3) {
		Com_Printf ("re_trigger_options <trigger name> <option1> <option2>\n");
		return;
	}
 
	name = Cmd_Argv (1);
	trig = CL_FindReTrigger (name);
 
	if (!trig) {
		Com_Printf ("re_trigger \"%s\" not found\n", name);
		return;
	}
 
	for(i=2; i<c; i++) {
		if (!strcmp(Cmd_Argv(i), "final")) {
			trig->flags |= RE_FINAL;
		} else if (!strcmp(Cmd_Argv(i), "remove")) {
			trig->flags |= RE_REMOVESTR;
		} else if (!strcmp(Cmd_Argv(i), "notfinal")) {
			trig->flags &= ~RE_FINAL;
		} else if (!strcmp(Cmd_Argv(i), "noremove")) {
			trig->flags &= ~RE_REMOVESTR;
		} else if (!strcmp(Cmd_Argv(i), "mask")) {
			trig->flags &= ~0xFF;
			trig->flags |= 0xFF & atoi(Cmd_Argv(i+1));
			i++;
		} else if (!strcmp(Cmd_Argv(i), "interval") ) {
			trig->min_interval = atof(Cmd_Argv(i+1));
			i++;
		} else if (!strcmp(Cmd_Argv(i), "enable")) {
			trig->flags |= RE_ENABLED;
		} else if (!strcmp(Cmd_Argv(i), "disable")) {
			trig->flags &= ~RE_ENABLED;
		} else if (!strcmp(Cmd_Argv(i), "noaction")) {
			trig->flags |= RE_NOACTION;
		} else if (!strcmp(Cmd_Argv(i), "action")) {
			trig->flags &= ~RE_NOACTION;
		} else if (!strcmp(Cmd_Argv(i), "nolog")) {
			trig->flags |= RE_NOLOG;
		} else if (!strcmp(Cmd_Argv(i), "log")) {
			trig->flags &= ~RE_NOLOG;
		} else {
			Com_Printf("re_trigger_options: invalid option.\n"
			           "valid options:\n  final\n  notfinal\n  remove\n"
			           "  noremove\n  mask <trigger_mask>\n  interval <min_interval>)\n"
			           "  enable\n  disable\n  noaction\n  action\n  nolog\n  log\n");
		}
	}
}
 
static void CL_RE_Trigger_Delete_f (void)
{
	pcre_trigger_t *trig, *next_trig;
	char *name;
	int i;
 
	for (i = 1; i < Cmd_Argc(); i++) {
		name = Cmd_Argv(i);
		if (IsRegexp(name)) {
			if(!ReSearchInit(name))
				return;
			prev = NULL;
			for (trig = re_triggers; trig; ) {
				if (ReSearchMatch (trig->name)) {
					next_trig = trig->next;
					RemoveReTrigger(trig);
					trig = next_trig;
				} else {
					prev = trig;
					trig = trig->next;
				}
			}
			ReSearchDone();
		} else {
			if ((trig = CL_FindReTrigger(name)))
				RemoveReTrigger(trig);
		}
	}
}
 
static void Trig_Enable(pcre_trigger_t *trig)
{
	trig->flags |= RE_ENABLED;
}
 
static void CL_RE_Trigger_Enable_f (void)
{
	pcre_trigger_t *trig;
	char *name;
	int i;
 
	for (i = 1; i < Cmd_Argc(); i++) {
		name = Cmd_Argv (i);
		if (IsRegexp (name)) {
			if(!ReSearchInit (name))
				return;
			Trig_ReSearch_do (Trig_Enable);
			ReSearchDone ();
		} else {
			if ((trig = CL_FindReTrigger (name)))
				Trig_Enable (trig);
		}
	}
}
 
static void Trig_Disable (pcre_trigger_t *trig)
{
	trig->flags &= ~RE_ENABLED;
}
 
static void CL_RE_Trigger_Disable_f (void)
{
	pcre_trigger_t *trig;
	char *name;
	int i;
 
	for (i = 1; i < Cmd_Argc (); i++) {
		name = Cmd_Argv (i);
		if (IsRegexp (name)) {
			if(!ReSearchInit (name))
				return;
			Trig_ReSearch_do (Trig_Disable);
			ReSearchDone ();
		} else {
			if ((trig = CL_FindReTrigger (name)))
				Trig_Disable (trig);
		}
	}
}
 
void CL_RE_Trigger_ResetLasttime (void)
{
	pcre_trigger_t *trig;
 
	for (trig=re_triggers; trig; trig=trig->next)
		trig->lasttime = 0.0;
}

void Re_Trigger_Copy_Subpatterns (const char *s, size_t* offsets, int num, cvar_t *re_sub)
{
	int i;
	char *tmp;
	size_t len;

	for (i = 0; i < 2 * num; i += 2) {
		len = offsets[i + 1] - offsets[i] + 1;
		tmp = (char *) Q_malloc(len);
		snprintf (tmp, len, "%s", s + offsets[i]);
		Cvar_ForceSet(&re_sub[i / 2], tmp);
		Q_free(tmp);
	}
}
 
static void CL_RE_Trigger_Match_f (void)
{
	int c;
	char *tr_name;
	char *s;
	pcre_trigger_t *rt;
	char *string;
	int result;

	c = Cmd_Argc();
 
	if (c != 3) {
		Com_Printf ("re_trigger_match <trigger name> <string>\n");
		return;
	}
 
	tr_name = Cmd_Argv(1);
	s = Cmd_Argv(2);
 
	for (rt = re_triggers; rt; rt = rt->next)
		if (!strcmp(rt->name, tr_name)) {
			pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(rt->regexp, NULL);
			result = pcre2_match (rt->regexp, (PCRE2_SPTR)s, strlen(s), 0, 0, match_data, NULL);
 
			if (result >= 0) {
				rt->lasttime = cls.realtime;
				rt->counter++;

				PCRE2_SIZE *offsets = pcre2_get_ovector_pointer(match_data);
				Re_Trigger_Copy_Subpatterns (s, offsets, min (result,10), re_sub);

				if (!(rt->flags & RE_NOACTION)) {
					string = Cmd_AliasString (rt->name);
					if (string) {
						Cbuf_InsertTextEx (&cbuf_safe, "\nwait\n");
						Cbuf_InsertTextEx (&cbuf_safe, string);
						Cbuf_ExecuteEx (&cbuf_safe);
					} else {
						Com_Printf ("re_trigger \"%s\" has no matching alias\n", rt->name);
					}
				}
			}
			pcre2_match_data_free (match_data);
			return;
		}
	Com_Printf ("re_trigger \"%s\" not found\n", tr_name);
}
 
qbool allow_re_triggers;
qbool CL_SearchForReTriggers (const char *s, unsigned trigger_type)
{
	pcre_trigger_t *rt;
	pcre_internal_trigger_t *irt;
	cmd_alias_t *trig_alias;
	qbool removestr = false;
	int result;
	int len = strlen(s);
	pcre2_match_data *match_data;
	PCRE2_SIZE *offsets;
 
	// internal triggers - always enabled
	if (trigger_type < RE_PRINT_ECHO) {
		allow_re_triggers = true;
		for (irt = internal_triggers; irt; irt = irt->next) {
			if (irt->flags & trigger_type) {
				match_data = pcre2_match_data_create_from_pattern(irt->regexp, NULL);
				result = pcre2_match (irt->regexp, (PCRE2_SPTR)s, len, 0, 0, match_data, NULL);
				if (result >= 0) {
					offsets = pcre2_get_ovector_pointer(match_data);
					Re_Trigger_Copy_Subpatterns (s, offsets, min(result,10), re_subi);
					irt->func (s);
				}
				pcre2_match_data_free (match_data);
			}
		}
		if (!allow_re_triggers)
			return false;
	}
 
	// message triggers disabled
	if (!tp_msgtriggers.value)
		return false;
 
	// triggers banned by ruleset or FPD and we are a player
	if (((cl.fpd & FPD_NO_SOUNDTRIGGERS) || (cl.fpd & FPD_NO_TIMERS) ||
	        Rulesets_RestrictTriggers ()) && !cls.demoplayback && !cl.spectator)
		return false;
 
	// we are in spec/demo mode, so play triggers if user want it
	if ((cls.demoplayback || cl.spectator) && cl_restrictions.value)
		return false;
 
	// regexp triggers
	for (rt = re_triggers; rt; rt = rt->next)
		if ( (rt->flags & RE_ENABLED) &&	// enabled
		        (rt->flags & trigger_type) &&	// mask fits
		        rt->regexp &&					// regexp not empty
		        (rt->min_interval == 0.0 ||
		         cls.realtime >= rt->min_interval + rt->lasttime)) // not too fast.
			// TODO: disable it ^^^ for FPD_NO_TIMERS case.
			// probably it dont solve re_trigger timers problem
			// you always trigger on statusbar(TF) or wp_stats (KTPro/KTX) messages and get 0.5~1.5 accuracy for your timer
		{
			pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(rt->regexp, NULL);
			result = pcre2_match (rt->regexp, (PCRE2_SPTR)s, len, 0, 0, match_data, NULL);
			if (result >= 0) {
				rt->lasttime = cls.realtime;
				rt->counter++;
				offsets = pcre2_get_ovector_pointer(match_data);
				Re_Trigger_Copy_Subpatterns (s, offsets, min(result,10), re_sub);
 
				if (!(rt->flags & RE_NOACTION)) {
					trig_alias = Cmd_FindAlias (rt->name);
					Print_current++;
					if (trig_alias) {
						Cbuf_InsertTextEx (&cbuf_safe, "\nwait\n");
						Cbuf_InsertTextEx (&cbuf_safe, rt->name);
						Cbuf_ExecuteEx (&cbuf_safe);
					} else
						Com_Printf ("re_trigger \"%s\" has no matching alias\n", rt->name);
					Print_current--;
				}
 
				if (rt->flags & RE_REMOVESTR)
					removestr = true;
				if (rt->flags & RE_NOLOG)
					Print_flags[Print_current] |= PR_LOG_SKIP;
				if (rt->flags & RE_FINAL)
					break;
			}
			pcre2_match_data_free (match_data);
		}
 
	if (removestr)
		Print_flags[Print_current] |= PR_SKIP;
 
	return removestr;
}
 
// Internal triggers
static void AddInternalTrigger (char* regexpstr, unsigned mask, internal_trigger_func func)
{
	pcre_internal_trigger_t *trig;
	int error;
	PCRE2_SIZE error_offset;
 
	trig = (pcre_internal_trigger_t *) Q_malloc(sizeof(pcre_internal_trigger_t));
	trig->next = internal_triggers;
	internal_triggers = trig;
 
	trig->regexp = pcre2_compile ((PCRE2_SPTR)regexpstr, PCRE2_ZERO_TERMINATED, 0, &error, &error_offset, NULL);
	trig->func = func;
	trig->flags = mask;
}
 
static void INTRIG_Disable (const char *s)
{
	allow_re_triggers = false;
	Print_flags[Print_current] |= PR_LOG_SKIP;
}
 
static void INTRIG_Lastip_port (const char *s)
{
	/* subpatterns of this regexp is maximum 21 chars */
	/* strlen (<3>.<3>.<3>.<3>:< 5 >) = 21 */
	/* or if it's matched as a string it can be up to 63 characters */
 
	// reset current lastip value
	memset (lastip, 0, sizeof (lastip));
 
	if ( strlen(re_subi[1].string) <= 3 ) {
		snprintf (lastip, sizeof (lastip), "%d.%d.%d.%d:%d",
						re_subi[1].integer,
						re_subi[2].integer,
						re_subi[3].integer,
						re_subi[4].integer,
						re_subi[5].integer);
	} else {
		snprintf (lastip, sizeof (lastip), "%s", re_subi[1].string);
	}
}
 
static void InitInternalTriggers(void)
{
	// dont allow cheating by triggering showloc command
	AddInternalTrigger("^(Location :|Angles   :)", 4, INTRIG_Disable); // showloc command
	// dont allow cheating by triggering dispenser warning
	AddInternalTrigger("^Enemies are using your dispenser!$", 16, INTRIG_Disable);
	// lastip
	AddInternalTrigger("([0-9]|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.([0-9]|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.([0-9]|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.([0-9]|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\:(\\d{4,5})", 8, INTRIG_Lastip_port);
	// lastip address, restricted to 64 bytes
	AddInternalTrigger("\\b([A-Za-z0-9-.]{1,53}?\\.[A-Za-z]{2,5}\\:\\d{4,5})", 8, INTRIG_Lastip_port);
}
 
void TP_InitTriggers (void)
{
	unsigned i;
 
	for(i=0;i<10;i++)
		Cvar_Register (re_sub+i);
 
	Cmd_AddCommand ("re_trigger", CL_RE_Trigger_f);
	Cmd_AddCommand ("re_trigger_options", CL_RE_Trigger_Options_f);
	Cmd_AddCommand ("re_trigger_delete", CL_RE_Trigger_Delete_f);
	Cmd_AddCommand ("re_trigger_enable", CL_RE_Trigger_Enable_f);
	Cmd_AddCommand ("re_trigger_disable", CL_RE_Trigger_Disable_f);
	Cmd_AddCommand ("re_trigger_match", CL_RE_Trigger_Match_f);
	InitInternalTriggers();

	Cvar_SetCurrentGroup(CVAR_GROUP_COMMUNICATION);
	Cvar_Register (&tp_msgtriggers);
	Cvar_Register (&tp_soundtrigger);
	Cvar_Register (&tp_triggers);
	Cvar_Register (&tp_forceTriggers);
	Cvar_ResetCurrentGroup();
}

void TP_ShutdownTriggers(void)
{
	pcre_internal_trigger_t* trigger;
	pcre_internal_trigger_t* next_trigger;

	for (trigger = internal_triggers; trigger; trigger = next_trigger) {
		next_trigger = trigger->next;
		if (trigger->regexp) {
			(pcre2_code_free)(trigger->regexp);
		}

		Q_free(trigger);
	}
}


================================================
FILE: src/tp_triggers.h
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: tp_triggers.h,v 1.2 2007-05-13 13:41:44 johnnycz Exp $
*/

#define		RE_PRINT_LOW		1
#define		RE_PRINT_NEDIUM		2
#define		RE_PRINT_HIGH		4
#define		RE_PRINT_CHAT		8
#define		RE_PRINT_CENTER		16
#define		RE_PRINT_ECHO		32
#define		RE_PRINT_INTERNAL	64
#define		RE_PRINT_ALL		31 // all of the above except internal
#define		RE_FINAL			256 // do not look for other triggers if matching is succesful
#define		RE_REMOVESTR		512 // do not display string if matching is uccesful
#define		RE_NOLOG			1024 // do not log string if matching is succesful
#define		RE_ENABLED			2048 // trigger is enabled
#define		RE_NOACTION			4096 // do not call alias

typedef struct pcre_trigger_s {
	char					*name;
	char					*regexpstr;
	struct pcre_trigger_s*	next;
	pcre2_code*				regexp;
	unsigned				flags;
	float					min_interval;
	double					lasttime;
	int						counter;
} pcre_trigger_t;

typedef void internal_trigger_func (const char *s);

typedef struct pcre_internal_trigger_s {
	struct pcre_internal_trigger_s	*next;
	pcre2_code						*regexp;
	internal_trigger_func			*func;
	unsigned						flags;
} pcre_internal_trigger_t;

// re-triggers
qbool CL_SearchForReTriggers (const char *s, unsigned trigger_type);
// if true, string should not be displayed
pcre_trigger_t *CL_FindReTrigger (char *name);
void CL_RE_Trigger_ResetLasttime (void);

// message triggers
void TP_SearchForMsgTriggers (const char *s, int level);


================================================
FILE: src/tr_types.h
================================================
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//
#ifndef __TR_TYPES_H
#define __TR_TYPES_H

#ifdef X11_GAMMA_WORKAROUND
#include <SDL.h>
#include <SDL_syswm.h>
#include <X11/extensions/xf86vmode.h>
#endif
/*
** glconfig_t
**
** Contains variables specific to the OpenGL configuration
** being run right now.  These are constant once the OpenGL
** subsystem is initialized.
*/

// FIXME: Is this still relevant?
typedef enum {
	GLHW_GENERIC, // where everthing works the way it should
	GLHW_INTEL    // Causes flickering console if you write directly to the front 
	              // buffer and then flip the back buffer for instance when drawing
	              // the I/O icon or doing timerefresh.
	              // http://www.intel.com/cd/ids/developer/asmo-na/eng/168252.htm?page=7
} glHardwareType_t;

#define R_SUPPORT_FRAMEBUFFERS        (1 << 0)      // rendering to framebuffers
#define R_SUPPORT_RENDERING_SHADERS   (1 << 1)      // rendering using shaders
#define R_SUPPORT_COMPUTE_SHADERS     (1 << 2)      // non-rendering shaders
#define R_SUPPORT_PRIMITIVERESTART    (1 << 3)      // primitive restart indexes
#define R_SUPPORT_MULTITEXTURING      (1 << 4)      // multi-texturing (some people still disable this...)
#define R_SUPPORT_IMAGE_PROCESSING    (1 << 5)      // reading/writing to images
#define R_SUPPORT_TEXTURE_SAMPLERS    (1 << 6)      // samplers
#define R_SUPPORT_TEXTURE_ARRAYS      (1 << 7)      // 3D images (texture arrays)
#define R_SUPPORT_INDIRECT_RENDERING  (1 << 8)      // indirect rendering (api parameters stored in buffer)
#define R_SUPPORT_INSTANCED_RENDERING (1 << 9)      // instanced rendering
#define R_SUPPORT_FRAMEBUFFERS_BLIT   (1 << 10)     // blit from one framebuffer to another
#define R_SUPPORT_BGRA_LIGHTMAPS      (1 << 11)     // BGRA lightmaps (if optimal format)
#define R_SUPPORT_INT8888R_LIGHTMAPS  (1 << 12)     // Lightmaps uploaded as UINT8888R rather than UNSIGNED_BYTE
#define R_SUPPORT_SEAMLESS_CUBEMAPS   (1 << 13)     // filtering works across faces of the cubemap
#define R_SUPPORT_DEPTH32F            (1 << 14)     // floating point 32-bit depth buffers
#define R_SUPPORT_FRAMEBUFFERS_SRGB   (1 << 15)     // framebuffers support sRGB
#define R_SUPPORT_IMMEDIATEMODE       (1 << 16)     // immediate-mode rendering (doesn't require programs)
#define R_SUPPORT_FOG                 (1 << 17)     // fog (OpenGL 1.4+, not currently working)
#define R_SUPPORT_CUBE_MAPS           (1 << 18)     // cube maps (OpenGL 1.3+)
#define R_SUPPORT_FRAMEBUFFER_MS      (1 << 19)     // multi-sampled framebuffers

#define R_SUPPORT_FEATURE_HW_LIGHTING (R_SUPPORT_TEXTURE_ARRAYS | R_SUPPORT_COMPUTE_SHADERS | R_SUPPORT_IMAGE_PROCESSING)

#define R_SUPPORT_MODERN_OPENGL_REQUIREMENTS ( \
	R_SUPPORT_FRAMEBUFFERS | R_SUPPORT_RENDERING_SHADERS | R_SUPPORT_PRIMITIVERESTART | \
	R_SUPPORT_MULTITEXTURING | R_SUPPORT_TEXTURE_SAMPLERS | R_SUPPORT_TEXTURE_ARRAYS \
)

#define R_BROKEN_GLBINDTEXTURES       (1 << 0)
#define R_BROKEN_PREFERMULTIDRAW      (1 << 1)

typedef struct {
	const unsigned char                     *renderer_string;
	const unsigned char                     *vendor_string;
	const unsigned char                     *version_string;
	const unsigned char                     *glsl_version;

	int		colorBits, depthBits, stencilBits;
	int		vidWidth, vidHeight;
	int		displayFrequency;
	int     majorVersion;
	int     minorVersion;
	qbool   coreProfile;
	qbool   amd_issues;                    // github bug #416: avoid certain paths to workaround

	glHardwareType_t			hardwareType;

	qbool					initialized;
#ifdef X11_GAMMA_WORKAROUND
	struct {
		SDL_SysWMinfo info;
		Display *display;
		int screen;
		int size;
	} gammacrap;
#endif

	int gl_max_size_default;
	int max_3d_texture_size;
	int max_texture_depth;
	int texture_units;
	int max_multisampling_level;

	int tripleBufferIndex;
	int uniformBufferOffsetAlignment;
	int shaderStorageBufferOffsetAlignment;

	unsigned int supported_features;
	unsigned int broken_features;
	unsigned int preferred_format;
	unsigned int preferred_type;

	qbool reversed_depth;
} glconfig_t;

#define GL_Supported(x) ((glConfig.supported_features & (x)) == (x))
#define GL_WorkaroundNeeded(x) ((glConfig.broken_features & (x)) == (x))

extern glconfig_t	glConfig;

//
// latched variables that can only change over a restart
//

extern cvar_t	r_colorbits;
extern cvar_t	r_24bit_depth;
extern cvar_t	r_fullscreen;
extern cvar_t	vid_width;
extern cvar_t	vid_height;
extern cvar_t	vid_win_width;
extern cvar_t	vid_win_height;
extern cvar_t	r_win_save_pos;
extern cvar_t	r_win_save_size;
extern cvar_t	r_displayRefresh;
extern cvar_t	vid_borderless;
extern cvar_t   vid_usedesktopres;

//
// archived variables that can change at any time
//
extern cvar_t	r_swapInterval;
extern cvar_t	vid_xpos;
extern cvar_t	vid_ypos;
extern cvar_t	vid_minpos;
extern cvar_t	r_conwidth;
extern cvar_t	r_conheight;
extern cvar_t	vid_ref;
extern cvar_t	vid_flashonactivity;
extern cvar_t	r_verbose;
extern cvar_t r_showextensions;


#endif	// __TR_TYPES_H


================================================
FILE: src/utils.c
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: utils.c,v 1.47 2007-09-30 22:59:24 disconn3ct Exp $
*/

#include "quakedef.h"
#include <pcre2.h>
#include "hud.h"
#include "utils.h"
#include "qtv.h"
#include "teamplay.h"
#include "q_shared.h"

int TP_CategorizeMessage (const char *s, int *offset);

/************************************** General Utils **************************************/

void str_align_right (char *target, size_t size, const char *source, size_t length)
{
	if (length > size - 1)
		length = size - 1;

	if (strlen(source) >= length) {
		strlcpy(target, source, size);
		target[length] = 0;
	} else {
		int i;

		for (i = 0; i < length - strlen(source); i++) {
			target[i] = ' ';
		}

		strlcpy(target + i, source, size - i);
	}
}

char *str_repeat (char *str, int amount)
{
	char *ret = NULL;
	int i = 0;

	if (str == NULL)
		return NULL;

	if (amount <= 0)
		amount = 0;

	ret = (char *) Q_calloc(strlen(str) * amount + 1, sizeof(char)); 

	for (i = 0; i < amount; i++)
		strcat(ret, str);

	return ret;
}

char *CreateSpaces(int amount) {
	static char spaces[1024];
	int size;

	size = bound(1, amount, sizeof(spaces) - 1);
	memset(spaces, ' ', size);
	spaces[size] = 0;

	return spaces;
}

char *SecondsToMinutesString(int print_time) {
	static char time[128];
	int tens_minutes, minutes, tens_seconds, seconds;

	tens_minutes = fmod (print_time / 600, 6);
	minutes = fmod (print_time / 60, 10);
	tens_seconds = fmod (print_time / 10, 6);
	seconds = fmod (print_time, 10);
	snprintf (time, sizeof(time), "%i%i:%i%i", tens_minutes, minutes, tens_seconds, seconds);
	return time;
}

char *SecondsToHourString(int print_time) {
	static char time[128];
	int tens_hours, hours,tens_minutes, minutes, tens_seconds, seconds;

	tens_hours = fmod (print_time / 36000, 10);
	hours = fmod (print_time / 3600, 10);
	tens_minutes = fmod (print_time / 600, 6);
	minutes = fmod (print_time / 60, 10);
	tens_seconds = fmod (print_time / 10, 6);
	seconds = fmod (print_time, 10);
	snprintf (time, sizeof(time), "%i%i:%i%i:%i%i", tens_hours, hours, tens_minutes, minutes, tens_seconds, seconds);
	return time;
}

#define RGB_COLOR_RED					"255 0 0"
#define RGB_COLOR_GREEN					"0 255 0"
#define RGB_COLOR_BLUE					"0 0 255"
#define RGB_COLOR_BLACK					"0 0 0"
#define RGB_COLOR_WHITE					"255 255 255"
#define RGB_COLOR_YELLOW				"255 255 0"
#define RGB_COLOR_PINK					"255 0 255"

#define COLOR_CHECK(_colorname, _colorstring, _rgbstring) \
	if(!strncmp(_colorstring, _colorname, sizeof(_colorstring))) return _rgbstring

char *ColorNameToRGBString(char *color_name)
{
	COLOR_CHECK(color_name, "red",		RGB_COLOR_RED);
	COLOR_CHECK(color_name, "green",	RGB_COLOR_GREEN);
	COLOR_CHECK(color_name, "blue",		RGB_COLOR_BLUE);
	COLOR_CHECK(color_name, "black",	RGB_COLOR_BLACK);
	COLOR_CHECK(color_name, "yellow",	RGB_COLOR_YELLOW);
	COLOR_CHECK(color_name, "pink",		RGB_COLOR_PINK);
	COLOR_CHECK(color_name, "white",	RGB_COLOR_WHITE);

	return color_name;
}

/// \brief converts "255 255 0 128" to (255, 255, 0, 128) array and saves it to rgb output argument
/// \param[in] s string in "R G B A" format
/// \param[out] rgb array of 4 bytes
int StringToRGB_W(char *s, byte *rgb)
{
	int i;
	char buf[20]; // "255 255 255 255" - the longest possible string
	char *result;

	rgb[0] = rgb[1] = rgb[2] = rgb[3] = 255;

	strlcpy(buf, s, sizeof(buf));
	result = strtok(buf, " ");

	for (i = 0; i < 4 && result; i++, result = strtok(NULL, " ")) {
		rgb[i] = (byte) Q_atoi(result);
	}

	// TODO: Ok to do this in software also?
	// Use normal quake pallete if not all arguments where given.
	if (i < 3)
	{
		byte *col = (byte *) &d_8to24table[rgb[0]];
		rgb[0] = col[0];
		rgb[1] = col[1];
		rgb[2] = col[2];
	}

	return i;
}

void TrackerStringToRGB_W(const char *s, byte *rgb)
{
	rgb[0] = rgb[1] = rgb[2] = rgb[3] = 255;

	if (s[0] >= '0' && s[0] <= '9' && s[1] >= '0' && s[1] <= '9' && s[2] >= '0' && s[2] <= '9') {
		rgb[0] = ((s[0] - '0') / 9.0f) * 255;
		rgb[1] = ((s[1] - '0') / 9.0f) * 255;
		rgb[2] = ((s[2] - '0') / 9.0f) * 255;
	}
}

byte* StringToRGB(char *s)
{
	static byte rgb[4];
	StringToRGB_W(s, rgb);
	return rgb;
}

void RGBToString(const byte *rgb, char *s) {
	// Scale down each value from 0x0 to 0xff to the range of 0x0 to 0xf.
	byte r = rgb[0] * 0xf / 0xff;
	byte g = rgb[1] * 0xf / 0xff;
	byte b = rgb[2] * 0xf / 0xff;

	// Convert the value to its hex representation. The characters will be
	// used in a "&cRGB" string.
	s[0] = (r < 10) ? ('0' + r) : ('a' + r - 0xa);
	s[1] = (g < 10) ? ('0' + g) : ('a' + g - 0xa);
	s[2] = (b < 10) ? ('0' + b) : ('a' + b - 0xa);
}

/*
   float f[10];
   int size = sizeof(f)/sizeof(f[0]);

// this will fill "f" with succesfully parsed floats from first string parammeter
// "size" will contain count of parsed floats
ParseFloats("1.0 2.0 999 5", f, &size);
*/
int ParseFloats(char *s, float *f, int *f_size) {
	int i, argc;
	tokenizecontext_t ctx;

	if (!s || !f || !f_size) {
		Sys_Error("ParseFloats() wrong params");
		return 0;
	}

	if (f_size[0] <= 0)
		return (f_size[0] = 0); // array have no size, unusual but no crime

	Cmd_TokenizeStringEx(&ctx, s);

	argc = min(Cmd_ArgcEx(&ctx), f_size[0]);

	for(i = 0; i < argc; i++)
		f[i] = Q_atof(Cmd_ArgvEx(&ctx, i));

	for( ; i < f_size[0]; i++)
		f[i] = 0; // zeroing unused elements

	return (f_size[0] = argc);
}

int strlen_color_by_terminator(const char *str, char terminator)
{
	int len = 0;

	if ( !str )
		return 0;

	while ( str[0] && str[0] != terminator )
	{
		if (str[0] == '&')
		{
			if (str[1] == 'c' && HexToInt(str[2]) >= 0 && HexToInt(str[3]) >= 0 && HexToInt(str[4]) >= 0)
			{
				str += 5; // skip "&cRGB"
				continue;
			}
			else if (str[1] == 'r')
			{
				str += 2; // skip "&r"
				continue;
			}
		}

		len++;
		str++;
	}

	return len;
}

// don't count ezquake color sequence
int strlen_color(const char *str)
{
	return strlen_color_by_terminator(str, 0);
}

// skip ezquake color sequence
void Util_SkipEZColors(char *dst, const char *src, size_t size)
{
	if (!dst || !src) {
		Sys_Error("Util_SkipColors: invalid input params");
		return;
	}

	if ( !size )
		return; // no space

	while ( src[0] && size )
	{
		if ( src[0] == '&' )
		{
			if ( src[1] == 'c' && HexToInt(src[2]) >= 0 && HexToInt(src[3]) >= 0 && HexToInt(src[4]) >= 0 )
			{
				src += 5; // skip "&cRGB"
				continue;
			}
			else if ( src[1] == 'r' )
			{
				src += 2; // skip "&r"
				continue;
			}
		}

		*dst++ = *src++;
		size--;
	}

	if ( !size )
		dst--; // seems we truncate string, step back for null terminator

	dst[0] = 0;
}

// strips all @chars chars from the @src string
void Util_SkipChars(const char *src, const char *chars, char *dst, size_t dstsize) {
	if (!dst || !src || !dstsize) {
		Com_Printf("Util_SkipChatWhite: illegal argument\n");
		return;
	}
	else {
		char *dstlast = dst + dstsize - 1;
		size_t chars_len = strlen(chars);
		int i;

		while (*src && dst < dstlast) {
			char c = *src++;
			qbool skipped = false;
			for (i = 0; i < chars_len; i++) {
				if (c == chars[i]) {
					skipped = true;
					break;
				}
			}
			if (!skipped) {
				*dst++ = c;
			}
		}
		*dst = '\0';
	}
}

char *str_trim(char *str)
{
	char *start; // points at first non-whitespace
	char *end; // points at last non-whitespace
	char *pos = str, *orig_str = str;

	while (*pos && isspace(*pos)) {
		pos++;
	}

	if (*pos == '\0') {
		*str = '\0';
		return orig_str;
	}

	start = pos;
	end = pos++;

	while (*pos) {
		if (!isspace(*pos)) {
			end = pos;
		}
		pos++;
	}

	if (start != orig_str || (end + 1) != pos) {
		for (pos = start; pos <= end; pos++) {
			*str++ = *pos;
		}

		*str = '\0';
	}

	return orig_str;
}

int HexToInt(char c)
{
	if (isdigit(c))
		return c - '0';
	else if (c >= 'a' && c <= 'f')
		return 10 + c - 'a';
	else if (c >= 'A' && c <= 'F')
		return 10 + c - 'A';
	else
		return -1;
}

/************************************** Game Mode Utils *********************************/

char *get_ktx_mode (void)
{
	return Info_ValueForKey(cl.serverinfo, "mode");
}

qbool check_ktx_ca (void)	// playing clan arena
{
	char *ktxmode = get_ktx_mode();

	return (strstr(ktxmode, "-ca") != NULL);
}

qbool check_ktx_wo (void)	// playing wipeout
{
	char *ktxmode = get_ktx_mode();

	return (strstr(ktxmode, "-wo") != NULL);
}

qbool check_ktx_ca_wo (void) // playing clan arena or wipeout
{
	return (check_ktx_ca() || check_ktx_wo());
}

/************************************** File Utils **************************************/

int Util_Extend_Filename(char *filename, char **ext) {
	char extendedname[1024], **s;
	int i, offset;
	FILE *f;

	strlcpy(extendedname, filename, sizeof(extendedname));
	offset = strlen(extendedname);

	i = -1;
	while(1) {
		if (++i == 1000)
			break;
		for (s = ext; *s; s++) { 
			snprintf (extendedname + offset, sizeof(extendedname) - offset, "_%03i.%s", i, *s);
			if ((f = fopen(extendedname, "rb"))) {
				fclose(f);
				break;
			}
		}
		if (!*s)
			return i;
	}
	return -1;
}

void Util_Process_FilenameEx(char *string, qbool allow_root) {
	int i;

	if (!string)
		return;

	for (i = 0; i < strlen(string); i++)
		if (string[i] == '\\')
			string[i] = '/';

	if (!allow_root && string[0] == '/')
		for (i = 1; i <= strlen(string); i++)
			string[i - 1] = string[i];
}

void Util_ToValidFileName(const char* i, char* o, size_t buffersize)
{
	int k;
	unsigned char c;
	buffersize--;	// keep space for terminating zero

	for (k = 0; *i && k < buffersize; i++, k++) {
		c = (*i) & 127;
		if (c < 32 || c == '?' || c == '*' || c == ':' || c == '<' || c == '>' || c == '"')
			o[k] = '_'; // u can't use skin with such chars, so replace with some safe char
		else
			o[k] = c;
	}
	o[k] = '\0';
}

void Util_Process_Filename(char *string) {
	Util_Process_FilenameEx(string, false);
}

qbool Util_Is_Valid_FilenameEx(char *s, qbool drive_prefix_valid) {
	static char badchars[] = {'?', '*', ':', '<', '>', '"', '\0'};

	if (!s || !*s)
		return false;

	// this will allow things like this: c:/quake/<demo_dir>
	// probably windows specific only
	if ( drive_prefix_valid && (isupper(s[0]) || islower(s[0])) && s[1] == ':' )
		s += 2;

	if (strstr(s, "../") || strstr(s, "..\\") )
		return false;

	while (*s) {
		if (*s < 32 || *s >= 127 || strchr(badchars, *s))
			return false;
		s++;
	}
	return true;
}

qbool Util_Is_Valid_Filename(char *s)
{
	return  Util_Is_Valid_FilenameEx(s, false);
}

char *Util_Invalid_Filename_Msg(char *s) {
	static char err[192];

	if (!s)
		return NULL;

	snprintf(err, sizeof(err), "%s is not a valid filename (?*:<>\" are illegal characters)\n", s);
	return err;
}

/************************************* Player Utils *************************************/

static int Player_Compare (const void *p1, const void *p2) {
	player_info_t *player1, *player2;
	int team_comp;

	player1 = *((player_info_t **) p1);
	player2 = *((player_info_t **) p2);

	if (player1->spectator)
		return player2->spectator ? (player1 - player2) : 1;
	if (player2->spectator)
		return -1;

	if (cl.teamplay && (team_comp = strcmp(player1->team, player2->team)))
		return team_comp;

	return (player1 - player2);
}

int Player_NumtoSlot (int num) 
{
	int count, i;
	player_info_t *players[MAX_CLIENTS];

	// Get all the joined players (including spectators).
	for (count = i = 0; i < MAX_CLIENTS; i++)
	{
		if (cl.players[i].name[0])
		{
			players[count++] = &cl.players[i];
		}
	}

	// Sort them according to team and if they're a spectator.
	qsort(players, count, sizeof(player_info_t *), Player_Compare);

	if (num < 1 || num > count)
	{
		return PLAYER_NUM_NOMATCH;
	}

	// Find the ith player.
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		if (&cl.players[i] == players[num-1])
		{
			return i;
		}
	}

	return PLAYER_NUM_NOMATCH;
}

int Player_IdtoSlot (int id) {
	int j;

	for (j = 0; j < MAX_CLIENTS; j++) {
		if (cl.players[j].name[0] && cl.players[j].userid == id)
			return j;
	}
	return -1;
}

char *Player_StripNameColor(const char *name)
{	
	extern char readableChars[]; // console.c
	char *stripped = NULL;
	int i, name_length;
	name_length = strlen(name);

	stripped = (char *)Q_calloc(name_length + 1, sizeof(char));

	// Strip the color by setting bit 7 = 0 on all letters.
	for (i = 0; i < name_length; i++)
	{
		stripped[i] = readableChars[(unsigned char)name[i]] & 127;
	}

	stripped[i] = '\0';

	return stripped;
}

int Player_IdStringToSlot(const char* arg)
{
	int i;

	// Check if the argument is a user id instead
	// Make sure all chars in the given arg are digits in that case.
	for (i = 0; arg[i]; i++)
	{
		if (!isdigit((byte)arg[i])) {
			return PLAYER_NAME_NOMATCH;
		}
	}

	// Get player ID.
	return Player_IdtoSlot(Q_atoi(arg));
}

int Player_StringtoSlot(char *arg, qbool use_regular_expression, qbool prioritise_user_id)
{
	int i, slot, arg_length;

	if (!arg[0]) {
		return PLAYER_NAME_NOMATCH;
	}

	if (prioritise_user_id) {
		slot = Player_IdStringToSlot(arg);

		if (slot >= 0) {
			return slot;
		}
	}

	// Match on partial names by only comparing the
	// same amount of chars as in the given argument
	// with all the player names. The first match will be picked.
	arg_length = strlen(arg) + 1;

	// Try finding the player by comparing the argument to all the player names (CASE SENSITIVE)
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		if (cl.players[i].name[0] && !strncmp(arg, cl.players[i].name, arg_length))
		{
			return i;
		}
	}

	// Maybe the user didn't use the correct case, so try without CASE SENSITIVITY.
	// (We loop once more so that if the correct case is given, that match will get precedence).
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		if (cl.players[i].name[0] && !strncasecmp(arg, cl.players[i].name, arg_length))
		{
			return i;
		}
	}

	// If the players name is color coded it's hard to type. 
	// So strip the color codes and see if it's a match.
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		char *stripped = Player_StripNameColor(cl.players[i].name);

		if (cl.players[i].name[0] && !strncasecmp(arg, stripped, arg_length))
		{
			Q_free(stripped);
			return i;
		}

		Q_free(stripped);
	}

	if (use_regular_expression) {
		// Regexp match against stripped player name if previous attempts have failed
		for (i = 0; i < MAX_CLIENTS; i++) {
			char *stripped = Player_StripNameColor(cl.players[i].name);

			if (cl.players[i].name[0] && Utils_RegExpMatch(arg, stripped)) {
				Q_free(stripped);
				return i;
			}

			Q_free(stripped);
		}
	}

	// Regexp match against stripped player name if previous attempts have failed
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		char *stripped = Player_StripNameColor(cl.players[i].name);

		if (cl.players[i].name[0] && Utils_RegExpMatch(arg, stripped))
		{
			Q_free(stripped);
			return i;
		}

		Q_free(stripped);
	}

	slot = Player_IdStringToSlot(arg);
	return (slot >= 0) ? slot : PLAYER_ID_NOMATCH;
}

int Player_NametoSlot(char *name) {
	int i;

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (cl.players[i].name[0] && !strncmp(Info_ValueForKey(cl.players[i].userinfo, "name"), name, 31))
			return i;
	}
	return PLAYER_NAME_NOMATCH;
}

int Player_SlottoId (int slot) {	
	return (slot >= 0 && slot < MAX_CLIENTS && cl.players[slot].name[0]) ? cl.players[slot].userid : -1;
}

char *Player_MyName (void) {
	return Info_ValueForKey(cls.demoplayback ? cls.userinfo : cl.players[cl.playernum].userinfo, "name");
}

int Player_GetTrackId(int player_id)
{
	int i, count;
	player_info_t *players[MAX_CLIENTS];

	// Get all the joined players (including spectators).
	for (count = i = 0; i < MAX_CLIENTS; i++)
	{
		if (cl.players[i].name[0])
		{
			players[count++] = &cl.players[i];
		}
	}

	// Sort them according to team and if they're a spectator.
	qsort(players, count, sizeof(player_info_t *), Player_Compare);

	// Find track_id of player.
	for (i = 0; i < count; i++)
	{
		if (player_id == players[i]->userid)
		{
			return i+1;
		}
	}
	return -1;
}


int Player_GetSlot(char *arg, qbool prioritise_user_id)
{
	int response;

	// Try getting the slot by name or id.
	if ((response = Player_StringtoSlot(arg, false, prioritise_user_id)) >= 0 )
		//|| response == PLAYER_ID_NOMATCH)
	{
		return response;
	}

	// We didn't find any player or ID that matched
	// so we'll try treating it as the players
	// sorted position.
	if (arg[0] != '#')
	{
		return response;
	}

	if ((response = Player_NumtoSlot(Q_atoi(arg + 1))) >= 0)
	{
		return response;
	}

	return PLAYER_NUM_NOMATCH;
}

/********************************** Nick completion related ****************************************/

const char disallowed_in_nick[] = {'\n', '\f', '\\', '/', '\"', ' ' , ';', '\0'};

// yet another utility, there also exist at least one similar function Player_StripNameColor(), but not the same
void RemoveColors (char *name, size_t len)
{
	extern char readableChars[];
	char *s = name;

	if (!s || !*s)
		return;

	while (*s)
	{
		*s = readableChars[(unsigned char)*s] & 127;

		if (strchr (disallowed_in_nick, *s))
			*s = '_';

		s++;
	}

	// get rid of whitespace
	s = name;
	for (s = name; *s == '_'; s++) ;
	memmove (name, s, strlen(s) + 1);

	for (s = name + strlen(name); s > name  &&  (*(s - 1) == '_'); s--)
		; // empty

	*s = 0;

	if (!name[0])
		strlcpy (name, "_", len);
}

qbool FindBestNick (const char *nick, int flags, char *result, size_t result_len)
{
	int i, bestplayer = -1, best = 999999;
	char name[MAX_SCOREBOARDNAME], *match;

	result[0] = 0;

	for (i = 0; i < MAX_CLIENTS; i++)
	{
		if (flags & FBN_IGNORE_SPECS)
			if (cl.players[i].spectator)
				continue;
		if (flags & FBN_IGNORE_PLAYERS)
			if (!cl.players[i].spectator)
				continue;

		if (!cl.players[i].name[0])
			continue;

		strlcpy(name, cl.players[i].name, sizeof(name));
		RemoveColors (name, sizeof (name));
		for (match = name; match[0]; match++)
			match[0] = tolower(match[0]);

		if (!name[0])
			continue;

		if ((match = strstr(name, nick))  && match - name < best)
		{
			best = match - name;
			bestplayer = i;
		}
	}

	if (bestplayer != -1)
	{
		strlcpy(result, cl.players[bestplayer].name, result_len);
		return true;
	}

	if (flags & FBN_IGNORE_QTVSPECS)
		return false;

	return QTV_FindBestNick (nick, result, result_len);
}


/********************************** Clipboard ****************************************/

#ifndef _WIN32
#define CLIPBOARDSIZE 1024
static char clipboard[CLIPBOARDSIZE] = "\0";    // for clipboard implementation
#endif
// copies given text to clipboard
void CopyToClipboard(const char *text)
{
#ifdef _WIN32
	if (OpenClipboard(NULL))
	{
		LPTSTR  lptstrCopy;
		HGLOBAL hglbCopy;

		EmptyClipboard();
		hglbCopy = GlobalAlloc(GMEM_DDESHARE, strlen(text)+1);
		lptstrCopy = GlobalLock(hglbCopy);
		strcpy((char *)lptstrCopy, text);
		GlobalUnlock(hglbCopy);
		SetClipboardData(CF_TEXT, hglbCopy);

		CloseClipboard();
	}
#else
	strlcpy (clipboard, text, CLIPBOARDSIZE);
	Sys_CopyToClipboard(text);
#endif
}

// reads from clipboard
char *ReadFromClipboard(void)
{
#ifdef _WIN32
	static char clipbuf[1024];
	int     i;
	HANDLE  th;
	char    *clipText;

	clipbuf[0] = 0;

	if (OpenClipboard(NULL))
	{
		th = GetClipboardData(CF_TEXT);
		if (th)
		{
			clipText = GlobalLock(th);
			if (clipText)
			{
				strlcpy(clipbuf, clipText, sizeof (clipbuf));
				for (i=0; i < strlen(clipbuf); i++)
					if (clipbuf[i]=='\n' || clipbuf[i]=='\t' || clipbuf[i]=='\b')
						clipbuf[i] = ' ';
			}
			GlobalUnlock(th);
		}
		CloseClipboard();
	}
	return clipbuf;
#else
	return clipboard;
#endif
}


/********************************** String Utils ****************************************/

qbool Util_F_Match (const char *_msg, char *f_request) {
	int offset, i, status, flags;
	char *s, *msg;

	msg = Q_strdup(_msg);
	flags = TP_CategorizeMessage(msg, &offset);

	if (flags != msgtype_normal && flags != msgtype_spec) {
		Q_free(msg);
		return false;
	}

	for (i = 0, s = msg + offset; i < strlen(s); i++)
		s[i] = s[i] & ~128;		

	if (strstr(s, f_request) != s) {
		Q_free(msg);
		return false;
	}
	status = 0;
	for (s += strlen(f_request); *s; s++) {
		if (isdigit(*s) && status <= 1) {
			status = 1;
		} else if (isspace(*s)) {
			status = (status == 1) ? 2 : status;
		} else {
			Q_free(msg);			
			return false;
		}
	}
	Q_free(msg);
	return true;
}


void Replace_In_String (char *src, int n, char delim, int num_args, ...)
{
	va_list ap;
	char msg[1024];
	char buf[256];
	char *msgp;
	int i, pad;
	qbool right;
	char *arg1, *arg2;

	// we will write the result back to src in code that follows
	strlcpy(msg,src,sizeof(msg));
	msgp = msg;
	*src = '\0';

	while (*msgp)
	{
		if(*msgp != delim)
		{
			buf[0] = *msgp++;
			buf[1] = '\0';
			strlcat(src, buf, n);
		}
		else
		{
			// process the delimiter
			msgp++;
			if (!*msgp) break;

			// process the initial minus
			right = *msgp == '-';
			if (right) msgp++;
			if (!*msgp) break;

			// process the number
			pad = atoi(msgp);
			while (isdigit(*msgp)) msgp++;
			if (!*msgp) break;

			// go through all available patterns
			va_start(ap, num_args);
			for (i=0; i < num_args; i++)
			{
				arg1 = va_arg(ap,char *);   // the pattern
				if (!arg1) break;

				arg2 = va_arg(ap,char *);   // the string to replace it with
				if (!arg2) break;

				// the pattern matched
				if (*msgp == *arg1)
				{
					if (pad)
					{
						if (right)  snprintf(buf, sizeof(buf)-1, "%-*s", pad, arg2);
						else        snprintf(buf, sizeof(buf)-1, "%*s", pad, arg2);
					}
					else
					{
						strlcpy(buf, arg2, sizeof(buf));
					}

					strlcat(src, buf, n);
					break;
				}
			}
			va_end(ap);

			msgp++;
		}
	}	
}

// compares two fun strings
int funcmp(const char *s1, const char *s2)
{
	char *t1, *t2;
	int ret;

	if (s1 == NULL  &&  s2 == NULL)
		return 0;

	if (s1 == NULL)
		return -1;

	if (s2 == NULL)
		return 1;

	t1 = Q_strdup(s1);
	t2 = Q_strdup(s2);

	FunToSort(t1);
	FunToSort(t2);

	ret = strcmp(t1, t2);

	Q_free(t1);
	Q_free(t2);

	return ret;
}

void FunToSort(char *text)
{
	char *tmp;
	char *s, *d;
	unsigned char c;
	tmp = (char *)Q_malloc(strlen(text) + 1);

	s = text;
	d = tmp;

	while ((c = (unsigned char)(*s++)) != 0) {
		if (c >= 18  &&  c <= 27)
			c += 30;
		else if (c >= 146  &&  c <= 155)
			c -= 98; // Yellow numbers.
		else if (c >= 32  &&  c <= 126)
			c = tolower(c);
		else if (c >= 160  &&  c <= 254)
			c  = tolower(c-128);
		else {
			switch (c) {
				case 1:
				case 2:
				case 3:
				case 4:
				case 6:
				case 7:
				case 8:
				case 9:
				case 132:   // kwadrat
					c = 210; break;
				case 5:
				case 14:
				case 15:
				case 28:
				case 133:
				case 142:
				case 143:
				case 156:   // dot
					c = 201; break;
				case 29:
				case 157:   // <
					c = 202; break;
				case 30:
				case 158:   // -
					c = 203; break;
				case 31:
				case 159:   // >
					c = 204; break;
				case 128:   // '('
					c = 205; break;
				case 129:   // '='
					c = 206; break;
				case 130:   // ')'
					c = 207; break;
				case 131:   // '+'
					c = 208; break;
				case 127:
				case 255:   // <-
					c = 209; break;
				case 134:   // d1
					c = 211; break;
				case 135:   // d2
					c = 212; break;
				case 136:   // d3
					c = 213; break;
				case 137:   // d4
					c = 214; break;
				case 16:
				case 144:   // '['
					c = '['; break;
				case 17:
				case 145:   // ']'
					c = ']'; break;
				case 141:   // '>'
					c = 200; break;
				case 10:
				case 11:
				case 12:
				case 13:
				case 138:
				case 139:
				case 140:   // ' '
					c = ' '; break;
			}
		}

		*d++ = c;
	}
	*d = 0;

	strcpy(text, tmp);
	Q_free(tmp);
}

#ifdef UNUSED_CODE
// todo: these functions are unused and there might already exist
// equivalent functions in our project; in such case remove them
unsigned char CharToBrown(unsigned char ch)
{
	if ( ch > 32 && ch <= 127 )
		return ch + 128;
	else
		return ch;
}

unsigned char CharToWhite(unsigned char ch)
{
	if ( ch > 160 )
		return ch - 128;
	else
		return ch;
}
#endif

void CharsToBrown(char* start, char* end)
{
	char *p = start;

	while (p < end) {
		if ( *p > 32 && *p <= 127 )
			*p += 128;
		p++;
	}
}

char *CharsToBrownStatic(char *in) // Print brown characters to console
{
	static char string[8][1024];
	static int idx = 0;
	int write_pos = 0;

	idx++;
	if (idx == 8)
		idx = 0;

	for (; *in && write_pos < 1023; in++) {
		string[idx][write_pos++] = 128 + *in;
	}
	string[idx][write_pos] = '\0';

	return string[idx];
}

void CharsToWhite(char* start, char* end)
{
	unsigned char *p = (unsigned char *)start;

	while (p < (unsigned char*)end) {
		if ( *p > 160 )
			*p -= 128;
		p++;
	}
}

/********************************** TF Utils ****************************************/

static char *Utils_TF_ColorToTeam_Failsafe(int color) {
	int i, j, teamcounts[8], numteamsseen = 0, best = -1;
	char *teams[MAX_CLIENTS];

	memset(teams, 0, sizeof(teams));
	memset(teamcounts, 0, sizeof(teamcounts));

	for (i = 0; i < MAX_CLIENTS; i++) {
		if (!cl.players[i].name[0] || cl.players[i].spectator)
			continue;
		if (cl.players[i].real_bottomcolor != color)
			continue;
		for (j = 0; j < numteamsseen; j++) {
			if (!strcmp(cl.players[i].team, teams[j]))
				break;
		}
		if (j == numteamsseen) {
			teams[numteamsseen] = cl.players[i].team;
			teamcounts[numteamsseen] = 1;
			numteamsseen++;
		} else {
			teamcounts[j]++;
		}
	}
	for (i = 0; i < numteamsseen; i++) {
		if (best == -1 || teamcounts[i] > teamcounts[best])
			best = i;
	}
	return (best == -1) ? "" : teams[best];
}

char *Utils_TF_ColorToTeam(int color) {
	switch (color) {
		case 13:
			return cl.fixed_team_names[0];
		case 4:
			return cl.fixed_team_names[1];
		case 12:
			return cl.fixed_team_names[2];
		case 11:
			return cl.fixed_team_names[3];
		default:
			return "";
	}
	return Utils_TF_ColorToTeam_Failsafe(color);
}

int Utils_TF_TeamToColor(char *team) {
	if (!strcasecmp(team, Utils_TF_ColorToTeam(13)))
		return 13;
	if (!strcasecmp(team, Utils_TF_ColorToTeam(4)))
		return 4;
	if (!strcasecmp(team, Utils_TF_ColorToTeam(12)))
		return 12;
	if (!strcasecmp(team, Utils_TF_ColorToTeam(11)))
		return 11;
	return 0;
}

/********************************** REGEXP ****************************************/

qbool Utils_RegExpMatch(char *regexp, char *matchstring)
{
	pcre2_code *re = NULL;
	int error;
	PCRE2_SIZE error_offset = 0;
	int match = 0;
	pcre2_match_data *match_data = NULL;

	re = pcre2_compile(
			(PCRE2_SPTR)regexp,	// The pattern.
			PCRE2_ZERO_TERMINATED,
			PCRE2_CASELESS,		// Case insensitive.
			&error,				// Error message.
			&error_offset,		// Error offset.
			NULL);				// use default character tables.

	// Check for an error compiling the regexp.
	if (!re)
		return false;

	// Check if we have a match.
	match_data = pcre2_match_data_create_from_pattern(re, NULL);
	if (re && (match = pcre2_match(re, (PCRE2_SPTR)matchstring, strlen(matchstring), 0, 0, match_data, NULL)) >= 0) {
		pcre2_match_data_free(match_data);
		pcre2_code_free(re);

		return true;
	}

	// Make sure we clean up.
	if (re) {
		pcre2_match_data_free(match_data);
		pcre2_code_free(re);
	}
	return false;
}

qbool Utils_RegExpGetGroup(char *regexp, char *matchstring, const char **resultstring, int *resultlength, int group)
{
	pcre2_code *re = NULL;
	int error;
	PCRE2_SIZE error_offset = 0;
	int match = 0;
	pcre2_match_data *match_data;

	re = pcre2_compile(
			(PCRE2_SPTR)regexp,	// The pattern.
			PCRE2_ZERO_TERMINATED,
			PCRE2_CASELESS,		// Case insensitive.
			&error,				// Error message.
			&error_offset,		// Error offset.
			NULL);				// use default character tables.

	if (!re)
		return false;

	match_data = pcre2_match_data_create_from_pattern(re, NULL);
	if (re && (match = pcre2_match(re, (PCRE2_SPTR)matchstring, strlen(matchstring), 0, 0, match_data, NULL)) >= 0) {
		int substring_length = 0;
		error = pcre2_substring_get_bynumber (match_data, group, (PCRE2_UCHAR8**)resultstring, (size_t*)&substring_length);

		if (resultlength != NULL) {
			(*resultlength) = substring_length;
		}

		pcre2_match_data_free (match_data);
		if (re) {
			pcre2_code_free(re);
		}

		return (error != PCRE2_ERROR_NOSUBSTRING && error != PCRE2_ERROR_NOMEMORY);
	}

	pcre2_match_data_free (match_data);
	if (re) {
		pcre2_code_free(re);
	}

	return false;
}


// QW262 -->
// regexp match support for group operations in scripts
int			wildcard_level = 0;
pcre2_code	*wildcard_re[4];

qbool IsRegexp(const char *str)
{
	if (*str == '+' || *str == '-') {
		// +/- aliases; valid regexp can not start with +/-
		return false;
	}

	return (strcspn(str, "\\\"()[]{}.*+?^$|")) != strlen(str) ? true : false;
}

qbool ReSearchInit(const char* wildcard)
{
	return ReSearchInitEx(wildcard, true);
}

qbool ReSearchInitEx(const char *wildcard, qbool case_sensitive)
{
	int error;
	PCRE2_SIZE error_offset;

	if (wildcard_level == 4) {
		Com_Printf("Error: Regexp commands nested too deep\n");
		return false;
	}
	wildcard_re[wildcard_level] = pcre2_compile((PCRE2_SPTR)wildcard, PCRE2_ZERO_TERMINATED, (case_sensitive ? 0 : PCRE2_CASELESS), &error, &error_offset, NULL);
	if (!wildcard_re[wildcard_level]) {
		PCRE2_UCHAR error_str[256];
		pcre2_get_error_message(error, error_str, sizeof(error_str));
		Com_Printf ("Invalid regexp: %s %d\n", error_str, error_offset);
		return false;
	}


	wildcard_level++;
	return true;
}

qbool ReSearchMatch (const char *str)
{
	int result;
	pcre2_match_data *match_data = NULL;
	match_data = pcre2_match_data_create_from_pattern(wildcard_re[wildcard_level-1], NULL);
	result = pcre2_match(wildcard_re[wildcard_level-1],
			(PCRE2_SPTR)str, strlen(str), 0, 0, match_data, NULL);
	pcre2_match_data_free(match_data);
	return (result>0) ? true : false;
}

void ReSearchDone (void)
{
	wildcard_level--;
	if (wildcard_re[wildcard_level]) {
		(pcre2_code_free)(wildcard_re[wildcard_level]);
	}
}
// <-- QW262


// ***************** VC issues **********************************

#if (_MSC_VER && (_MSC_VER < 1400))
extern _ftol2(double f);
long _ftol2_sse(double f)
{
	return _ftol2(f);
}
#endif

// ***************** random *************************************

float f_rnd( float from, float to )
{
	float r;

	if ( from >= to )
		return from;

	r = from + (to - from) * ((float)rand() / RAND_MAX);

	return bound(from, r, to);
}

int i_rnd( int from, int to )
{
	float r;

	if ( from >= to )
		return from;

	r = (int)(from + (1.0 + to - from) * ((float)rand() / RAND_MAX));

	return bound(from, r, to);
}

//
// Gets the next part of a string that fits within a specified width.
//
//		input			= The string we want to wordwrap.
//		target			= The string that we should put the next line in.
//		start_index		= The index in the input string where we start wordwrapping.
//		end_index		= The returned end index of the word wrapped string.
//		target_max_size = The length of the target string buffer.
//		max_pixel_width	= The pixel width that the string should be wordwrapped within.
//		char_size		= The size of the characters in the string.
//
qbool Util_GetNextWordwrapString(const char *input, char *target, int start_index, int *end_index_ret, int target_max_size, int max_pixel_width, int char_size)
{
	qbool wrap_found	= false;
	int retval			= true;

	int max_char_width	= Q_rint((float)max_pixel_width / char_size - 1);	// The max number of characters allowed (excluding white spaces at the end).
	int end_index		= start_index;										// The index of the last character to include in this line.
	int input_len		= strlen(input + start_index) + 1;					// Length of the input including \0.
	int max_width		= min(max_char_width, input_len);					// The max width allowed for the line.

	// New lines take precendence as a wrap.
	for (end_index = start_index; end_index < (start_index + max_width); end_index++)
	{
		if (input[end_index] == '\n')
		{
			wrap_found = true;
			break;
		}

		// Have we reached the end of the string?
		if (input[end_index] == '\0')
		{
			retval = false;
			break;
		}
	}

	if (!wrap_found)
	{
		if (input[end_index] != ' ')
		{
			// We're in the middle of a word, try to find a word boundary instead.
			int i;

			for (i = end_index; i > start_index; i--)
			{
				if (input[i] == ' ')
				{
					end_index = i;
					break;
				}
			}
		}
		else
		{
			// Eat up all white spaces at the end of the line.
			while (input[end_index + 1] == ' ')
			{
				end_index++;
			}
		}
	}

	// Return the end index.
	if (end_index_ret)
	{
		(*end_index_ret) = end_index;
	}

	// Copy the wrap string to the target buffer.
	if (target)
	{
		snprintf(target, min(target_max_size, max_width), "%s", input + start_index);
	}

	return retval;
}

void Utils_RegExpFreeSubstring(char* substring)
{
	if (substring) {
		pcre2_substring_free((PCRE2_UCHAR8*)substring);
	}
}



================================================
FILE: src/utils.h
================================================
/*

Copyright (C) 2001-2002       A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the included (GNU.txt) GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: utils.h,v 1.21 2007-09-15 15:26:17 cokeman1982 Exp $

*/

#ifndef __UTILS_H__
#define __UTILS_H__

#define	PLAYER_ID_NOMATCH		-1
#define	PLAYER_NAME_NOMATCH		-2
#define	PLAYER_NUM_NOMATCH		-3

/// 
/// General Utils
///

char *CreateSpaces(int amount);
char *SecondsToMinutesString(int print_time);
char *SecondsToHourString(int time);
char *ColorNameToRGBString(char *color_name);
byte *StringToRGB(char *s);
int StringToRGB_W(char *s, byte *rgb);
void RGBToString(const byte *rgb, char *s);
void TrackerStringToRGB_W(const char *s, byte *rgb);
int ParseFloats(char *s, float *f, int *f_size);

// don't count ezquake color sequence
int strlen_color(const char *str);
int strlen_color_by_terminator(const char *str, char terminator);
// skip ezquake color sequence
void Util_SkipEZColors(char *dst, const char *src, size_t size);
void Util_SkipChars(const char *src, const char *chars, char *dst, size_t dstsize);
void str_align_right (char *target, size_t size, const char *source, size_t length);

// skip whitespace from both beginning and end
char *str_trim(char *str);

int HexToInt(char c);

///
/// Game Mode utils
///

char *get_ktx_mode(void);
qbool check_ktx_ca(void);
qbool check_ktx_wo(void);
qbool check_ktx_ca_wo(void);

///
/// Filename utils
///

int Util_Extend_Filename(char *filename, char **ext);
qbool Util_Is_Valid_Filename(char *s);
qbool Util_Is_Valid_FilenameEx(char *s, qbool drive_prefix_valid);
char *Util_Invalid_Filename_Msg(char *s);
void Util_Process_Filename(char *string);
void Util_Process_FilenameEx(char *string, qbool allow_root);
void Util_ToValidFileName(const char* input, char* output, size_t buffersize);

///
/// Player utils
///

int Player_IdtoSlot (int id);
int Player_SlottoId (int slot);
int Player_NametoSlot(char *name);
int Player_StringtoSlot(char *arg, qbool use_regular_expressions, qbool prioritise_user_id);
int Player_NumtoSlot (int num);
int Player_GetSlot(char *arg, qbool prioritise_user_id);
int Player_GetTrackId(int player_id);
char *Player_MyName(void);

///
/// Nick completion related
///


// yet another utility, there also exist at least one similar function Player_StripNameColor(), but not the same
void RemoveColors (char *name, size_t len);

#define FBN_IGNORE_SPECS		(1<<0)
#define FBN_IGNORE_PLAYERS		(1<<1)
#define FBN_IGNORE_QTVSPECS		(1<<2)

qbool FindBestNick (const char *nick, int flags, char *result, size_t result_len);

///
/// Clipboard
///
void CopyToClipboard(const char *text);
char *ReadFromClipboard(void);

///
/// TF Team-Color Utils
///

char *Utils_TF_ColorToTeam(int);
int Utils_TF_TeamToColor(char *);

///
/// String Utils 
///

qbool Util_F_Match (const char *msg, char *f_req);
void Replace_In_String (char *src,int n, char delim, int arg, ...);
/// converts fun text to string prepared to sort
void FunToSort(char *text);
/// compares two fun strings
int funcmp(const char *s1, const char *s2);
#ifdef UNUSED_CODE
unsigned char CharToBrown(unsigned char ch);
unsigned char CharToWhite(unsigned char ch);
#endif
void CharsToBrown(char* start, char* end);
char *CharsToBrownStatic(char *in);
void CharsToWhite(char* start, char* end);

///
/// REGEXP
///

qbool Utils_RegExpMatch(char *regexp, char *matchstring);
qbool Utils_RegExpGetGroup(char *regexp, char *matchstring, const char **resultstring, int *resultlength, int group);
void Utils_RegExpFreeSubstring(char* substring);

// regexp match support for group operations in scripts
qbool IsRegexp(const char *str);
qbool ReSearchInit(const char *wildcard);
qbool ReSearchInitEx(const char* wildcard, qbool case_sensitive);
qbool ReSearchMatch(const char *str);
void ReSearchDone(void);

///
/// RANDOM GENERATORS
///

float f_rnd( float from, float to );
int i_rnd( int from, int to );

//
// Gets the next part of a string that fits within a specified width.
//
//		input			= The string we want to wordwrap.
//		target			= The string that we should put the next line in.
//		start_index		= The index in the input string where we start wordwrapping.
//		end_index		= The returned end index of the word wrapped string.
//		target_max_size = The length of the target string buffer.
//		max_pixel_width	= The pixel width that the string should be wordwrapped within.
//		char_size		= The size of the characters in the string.
//
qbool Util_GetNextWordwrapString(const char *input, char *target, int start_index, int *end_index, int target_max_size, int max_pixel_width, int char_size);

#endif /* !__UTILS_H__ */


================================================
FILE: src/version.c
================================================
/*
	version.c

	Build number and version strings

	Copyright (C) 1996-1997 Id Software, Inc.

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version 2
	of the License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

	See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA

	$Id: version.c,v 1.14 2007-05-28 10:47:36 johnnycz Exp $
*/

#include "common.h"
#include "version.h"

#include <jansson.h>
#include <SDL_mutex.h>
#include <SDL_thread.h>
#include <curl/curl.h>


#define VERSION_UNKNOWN "Unknown"
#define VERSION_GITHUB_MAXLEN 32768 // ~2k @ ~2023
#define VERSION_GITHUB_URL "https://api.github.com/repos/qw-group/ezquake-source/releases/latest"

static char version_latest[VERSION_MAX_LEN] = VERSION_UNKNOWN;
static qbool version_refreshing = false;
static SDL_mutex *version_mutex = NULL;

static void VersionCheck_OnConfigChange(cvar_t *var, char *string, qbool *cancel);
static cvar_t allow_update_check  = {"sys_update_check",  "1", CVAR_NONE, VersionCheck_OnConfigChange};

/*
=======================
CL_Version_f
======================
*/
void CL_Version_f (void)
{
	Com_Printf ("ezQuake %s\n", VersionString());
	Com_Printf ("Exe: "__DATE__" "__TIME__"\n");

#ifdef _DEBUG
	Con_Printf("debug build\n");
#endif

#ifdef __MINGW32__
	Con_Printf("Compiled with MinGW version: %i.%i\n",__MINGW32_MAJOR_VERSION, __MINGW32_MINOR_VERSION);
#endif

#ifdef __CYGWIN__
	Con_Printf("Compiled with Cygwin\n");
#endif

#ifdef __GNUC__
	Con_Printf("Compiled with GCC version: %i.%i.%i (%i)\n",__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__, __VERSION__);

	#ifdef __OPTIMIZE__
		#ifdef __OPTIMIZE_SIZE__
			Con_Printf("GCC Optimization: Optimized for size\n");
		#else
			Con_Printf("GCC Optimization: Optimized for speed\n");
		#endif
	#endif

	#ifdef __NO_INLINE__
		Con_Printf("GCC Optimization: Functions currently not inlined into their callers\n");
	#else
		Con_Printf("GCC Optimization: Functions currently inlined into their callers\n");
	#endif
#endif

#ifdef _M_IX86
	Con_Printf("x86 code optimized for: ");

	if (_M_IX86 == 600) { Con_Printf("Pentium Pro, Pentium II and Pentium III"); }
	else if (_M_IX86 == 500) { Con_Printf("Pentium"); }
	else if (_M_IX86 == 400) { Con_Printf("486"); }
	else if (_M_IX86 == 300) { Con_Printf("386"); }
	else
	{
		Con_Printf("Unknown (%i)\n",_M_IX86);
	}

	Con_Printf("\n");
#endif

#ifdef _M_IX86_FP
	if (_M_IX86_FP == 0) { Con_Printf("SSE & SSE2 instructions disabled\n"); }
	else if (_M_IX86_FP == 1) { Con_Printf("SSE instructions enabled\n"); }
	else if (_M_IX86_FP == 2) { Con_Printf("SSE2 instructions enabled\n"); }
	else
	{
		Con_Printf("Unknown Arch specified: %i\n",_M_IX86_FP);
	}
#endif

#ifdef EZ_FREETYPE_SUPPORT
	Con_Printf("Portions of this software are copyright (c) 2018 The FreeType Project(www.freetype.org). All rights reserved.\n");
#endif
}

/*
=======================
VersionString
======================
*/
char *VersionString (void)
{
	static char str[64];

	snprintf (str, sizeof(str), "%s %s", VERSION_NUMBER, VERSION);

	return str;
}

char *VersionStringColour(void)
{
	static char str[64];

	snprintf (str, sizeof(str), "&c1e1%s&r %s", VERSION_NUMBER, VERSION);

	return str;
}

char *VersionStringFull (void)
{
	static char str[256];

	snprintf (str, sizeof(str), SERVER_NAME " %s " "(" QW_PLATFORM ")" "\n", VersionString());

	return str;
}

typedef struct version_context_St
{
	char *buffer;
	char *ptr;
} version_context_t;

static size_t VersionReadGitHubResponse(void* chunk, size_t size, size_t nmemb, void* user_data)
{
	version_context_t* ctx = (version_context_t *) user_data;

	size_t chunk_len = size * nmemb;
	size_t remaining = VERSION_GITHUB_MAXLEN - (ctx->ptr - ctx->buffer) - 1;

	if (chunk_len > remaining)
	{
		return 0;
	}

	memcpy(ctx->ptr, chunk, chunk_len);
	ctx->ptr += chunk_len;
	*ctx->ptr = '\0';

	return chunk_len;
}

static int VersionCheck_Thread(void *args)
{
	char buffer[VERSION_GITHUB_MAXLEN] = { 0 };
	json_error_t error;
	json_t *root, *tag_name;
	struct curl_slist *headers = NULL;
	version_context_t ctx = {
		.buffer = buffer,
		.ptr = buffer,
	};

	root = tag_name = NULL;

	CURL* curl = curl_easy_init();
	if (!curl)
	{
		Com_DPrintf("Unable to create cURL client\n");
		goto cleanup;
	}

	curl_easy_setopt(curl, CURLOPT_URL, VERSION_GITHUB_URL);
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, VersionReadGitHubResponse);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ctx);

	headers = curl_slist_append(headers, "User-Agent: Shub-Niggurath Inc");
	curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
	
	CURLcode res = curl_easy_perform(curl);
	if (res != CURLE_OK)
	{
		Com_DPrintf("Could not fetch latest version: %s", curl_easy_strerror(res));
		goto cleanup;
	}

	root = json_loads(buffer, 0, &error);
	if (!root)
	{
		Com_DPrintf("JSON decode failed: %s", error.text);
		goto cleanup;
	}
	
	tag_name = json_object_get(root, "tag_name");
	if (!json_is_string(tag_name))
	{
		Com_DPrintf("Version not found in GitHub response");
		goto cleanup;
	}

	const char* version_str = json_string_value(tag_name);

	SDL_LockMutex(version_mutex);
	strlcpy(version_latest, version_str, VERSION_MAX_LEN);
	SDL_UnlockMutex(version_mutex);

cleanup:
	if (root != NULL)
	{
		json_decref(root);
	}
	if (curl != NULL)
	{
		curl_slist_free_all(headers);
		curl_easy_cleanup(curl);
	}

	SDL_LockMutex(version_mutex);
	version_refreshing = false;
	SDL_UnlockMutex(version_mutex);

	return 0;
}

static void VersionCheck_Refresh(void)
{
	SDL_LockMutex(version_mutex);

	if (!version_refreshing)
	{
		SDL_Thread *thread = SDL_CreateThread(VersionCheck_Thread, "Version fetcher", NULL);
		if (!thread)
		{
			Com_DPrintf("Could not start version fetcher: %s\n", SDL_GetError());
			version_refreshing = false;
		}
		else
		{
			SDL_DetachThread(thread);
			version_refreshing = true;
		}
	}

	SDL_UnlockMutex(version_mutex);
}

static void VersionCheck_OnConfigChange(cvar_t *cfg, char *string, qbool *cancel)
{
	if (strcmp(string, "0") == 0)
	{
		return;
	}

	VersionCheck_Refresh();
}

void VersionCheck_Init(void)
{
	Cvar_Register(&allow_update_check);

	version_mutex = SDL_CreateMutex();
}

void VersionCheck_Shutdown(void)
{
	if (version_mutex != NULL)
	{
		SDL_DestroyMutex(version_mutex);
		version_mutex = NULL;
	}
}

typedef struct semantic_version_St
{
	int major;
	int minor;
	int patch;
} semantic_version_t;

static qbool SemanticVersionFromString(const char* value, semantic_version_t* version)
{
	if (!value)
		return false;
	if (sscanf(value, "%d.%d.%d", &version->major, &version->minor, &version->patch) != 3)
		return false;
	return true;
}

static qbool VersionCheck_CompareVersions(const semantic_version_t *this_version, const semantic_version_t *latest_version)
{
	if (this_version->major < latest_version->major)
		return true;
	if (this_version->major > latest_version->major)
		return false;
	if (this_version->minor < latest_version->minor)
		return true;
	if (this_version->minor > latest_version->minor)
		return false;
	return this_version->patch < latest_version->patch;
}

// Assumes any failures = already on latest version to avoid erroneous showing of update message
static qbool VersionCheck_IsOutdated(const char recent_version[VERSION_MAX_LEN])
{
	semantic_version_t v1, v2;

	if (strcmp(recent_version, VERSION_UNKNOWN) == 0)
		return false;
	
	if (!SemanticVersionFromString(VERSION_NUMBER, &v1))
	{
		Com_DPrintf("Could not parse own version: %s", VERSION_NUMBER);
		return false;
	}

	if (!SemanticVersionFromString(recent_version, &v2))
	{
		Com_DPrintf("Could not parse recent version: %s", recent_version);
		return false;
	}

	return VersionCheck_CompareVersions(&v1, &v2);
}

qbool VersionCheck_GetLatest(char dest[VERSION_MAX_LEN])
{
	SDL_LockMutex(version_mutex);
	strlcpy(dest, version_latest, VERSION_MAX_LEN);
	SDL_UnlockMutex(version_mutex);

	return VersionCheck_IsOutdated(dest);
}

================================================
FILE: src/version.h
================================================
/*

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: version.h,v 1.7 2007-10-04 15:18:20 johnnycz Exp $
*/
// version.h

#ifndef __VERSION_H__
#define __VERSION_H__

#if defined(_WIN32)
// Warning: this is different from mvdsv (no 64-bit check)
#if defined(_WIN64)
	#define QW_PLATFORM			"Win64"
#else
	#define QW_PLATFORM			"Win32"
#endif
#define QW_PLATFORM_SHORT	"w"

#elif defined(__FreeBSD__)
#define QW_PLATFORM			"FreeBSD"
#define QW_PLATFORM_SHORT	"f"

#elif defined(__OpenBSD__)
#define QW_PLATFORM			"OpenBSD"
#define QW_PLATFORM_SHORT	"o"

#elif defined(__NetBSD__)
#define QW_PLATFORM			"NetBSD"
#define QW_PLATFORM_SHORT	"n"

#elif defined(__DragonFly__)
#define QW_PLATFORM			"DragonFly"
#define QW_PLATFORM_SHORT	"d"

#elif defined(__linux__)
// Warning: this is different from mvdsv (no 64-bit check)
	#ifdef __x86_64__
		#define QW_PLATFORM	"Linux64"
	#else
		#define QW_PLATFORM	"Linux32"
	#endif
#define QW_PLATFORM_SHORT	"l"

#elif defined(__sun__)
#define QW_PLATFORM			"SunOS"
#define QW_PLATFORM_SHORT	"s"

#elif defined(__APPLE__)
#define QW_PLATFORM			"MacOSX"
#define QW_PLATFORM_SHORT	"m"

#else
#define QW_PLATFORM			"Unknown"
#define QW_PLATFORM_SHORT	"u"
#endif

#define QW_RENDERER			"GL"

#ifdef _DEBUG
#define QW_CONFIGURATION	"Debug"
#else
#define QW_CONFIGURATION	"Release"
#endif

// Note: for server mods to detect version, change VERSION_NUM below
#define VERSION_NUMBER "3.7.0-dev"
#define VERSION_MAX_LEN 32

void CL_Version_f(void);
char *VersionString(void);
char *VersionStringColour(void);
char *VersionStringFull(void);

void VersionCheck_Init(void);
void VersionCheck_Shutdown(void);
qbool VersionCheck_GetLatest(char dest[VERSION_MAX_LEN]);

#ifndef SERVERONLY
#define SERVER_NAME         "EZQUAKE"
#else
#define SERVER_NAME         "MVDSV"
#endif

// MVDSV compatibility
#define	QW_VERSION			"2.40"
#define SERVER_VERSION      "0.34-beta"
#define SERVER_VERSION_NUM  0.33
#define SERVER_FULLNAME     "MVDSV: MultiView Demo SerVer"
#define SERVER_HOME_URL     "https://mvdsv.deurk.net"
#define VERSION_NUM         3.6
#define BUILD_DATE          __DATE__ ", " __TIME__
#define GIT_COMMIT          ""

// ezQuake URLs etc
#define EZ_VERSION_WEBSITE "http://www.ezquake.com/"
#define EZ_MVD_SIGNOFF \
	"\x1d\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1f\n" \
	"Recorded by ezQuake (http://www.ezquake.com/)\n" \
	"Discord: http://discord.quake.world/\n" \
	"Forums: http://quakeworld.nu/\n" \
	"\x1d\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1f\n"
#define EZ_QWD_SIGNOFF EZ_MVD_SIGNOFF
	// "\x1d\x1e\x1e\x1e\x1e\x1e\x1e Recorded by ezQuake \x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1f"

#endif /* !__VERSION_H__ */


================================================
FILE: src/vfs.h
================================================
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *     
 * $Id: vfs.h,v 1.13 2007-10-13 16:24:50 dkure Exp $
 *             
 */

#ifndef __VFS_H__
#define __VFS_H__

#include "hash.h"

//=================================
// Quake filesystem
//=================================
extern hashtable_t *filesystemhash;
extern int fs_hash_dups;		
extern int fs_hash_files;		

typedef struct {
	struct searchpath_s *search;
	int             index;
	char            rawname[MAX_OSPATH];
	int             offset;
	int             len;
} flocation_t;

typedef struct {
	void	(*PrintPath)(void *handle);
	void	(*ClosePath)(void *handle);
	void	(*BuildHash)(void *handle);
	qbool   (*FindFile)(void *handle, flocation_t *loc, const char *name, void *hashedresult);	
		// true if found (hashedresult can be NULL)
		// note that if rawfile and offset are set, many Com_FileOpens will 
		// read the raw file otherwise ReadFile will be called instead.
	void	(*ReadFile)(void *handle, flocation_t *loc, char *buffer);	
		// reads the entire file
	int		(*EnumerateFiles)(void *handle, char *match, int (*func)(char *, int, void *), void *parm);

	void	*(*OpenNew)(vfsfile_t *file, const char *desc);	
		// returns a handle to a new pak/path

	int		(*GeneratePureCRC) (void *handle, int seed, int usepure);

	vfsfile_t *(*OpenVFS)(void *handle, flocation_t *loc, char *mode);
} searchpathfuncs_t;

typedef struct searchpath_s
{
	searchpathfuncs_t *funcs;
	qbool copyprotected;	// don't allow downloads from here.
	qbool istemporary;
	void *handle;
	int crc_check;	// client sorts packs according to this checksum
	int crc_reply;	// client sends a different crc back to the server, 
	                // for the paks it's actually loaded.
	struct searchpath_s *nextpure;
	struct searchpath_s *next;
} searchpath_t;


//=================================
// STDIO Files (OS)
//=================================
typedef struct {
	vfsfile_t funcs; // <= must be at top/begining of struct

	FILE *handle;

} vfsosfile_t;

vfsfile_t *FS_OpenTemp(void);
vfsfile_t *VFSOS_Open(char *osname, char *mode);

extern searchpathfuncs_t osfilefuncs;

//====================
// PACK (*pak) Support
//====================

// in memory
// VFS-FIXME: This is a bad name, it really is just a filename + offset....
typedef struct
{
	char	name[MAX_QPATH];
	int		filepos, filelen;
} packfile_t;

extern searchpathfuncs_t packfilefuncs;

//===========================
// ZIP (*.zip, *.pk3) Support
//===========================
#ifdef WITH_ZIP
extern searchpathfuncs_t zipfilefuncs;
#endif // WITH_ZIP

//=============================
// TCP Support - VFS Functions
//=============================
int VFSTCP_ReadBytes (struct vfsfile_s *file, void *buffer, int bytestoread, vfserrno_t *err);
int VFSTCP_WriteBytes (struct vfsfile_s *file, const void *buffer, int bytestowrite);
int VFSTCP_Seek (struct vfsfile_s *file, unsigned long pos, int whence);
unsigned long VFSTCP_Tell (struct vfsfile_s *file);
unsigned long VFSTCP_GetLen (struct vfsfile_s *file);
void VFSTCP_Close (struct vfsfile_s *file);
void VFSTCP_Tick(void);
vfsfile_t *FS_OpenTCP(char *name);

//=====================
// GZIP (*.gz) Support
//=====================
#ifdef WITH_ZLIB
extern searchpathfuncs_t gzipfilefuncs;
#endif // WITH_ZLIB

//=====================
// TAR (*.tar) Support
//=====================
extern searchpathfuncs_t tarfilefuncs;

//=====================
// Memory Mapped files
//=====================
vfsfile_t *FSMMAP_OpenVFS(void *buf, size_t buf_len);
qbool FSMMAP_IsMemoryMapped(vfsfile_t* file);

//=====================
// Doomwad Support
//=====================
#ifdef DOOMWADS
extern searchpathfuncs_t doomwadfilefuncs;
#endif //DOOMWADS

// FS_FLocateFile return type.
typedef enum
{
	FSLFRT_IFFOUND,			// return true if file found, false if not found.
	FSLFRT_LENGTH,			// return file length if found, -1 if not found.
	FSLFRT_DEPTH_OSONLY,	// return depth (no paks), 0x7fffffff if not found.
	FSLFRT_DEPTH_ANYPATH	// return depth, 0x7fffffff if not found.
} FSLF_ReturnType_e;

void FS_FlushFSHash(void);
int FS_FLocateFile(const char *filename, FSLF_ReturnType_e returntype, flocation_t *loc);
void FS_Shutdown(void);

#endif /* __VFS_H__ */


================================================
FILE: src/vfs_doomwad.c
================================================
/*
 Copyright (C) 1996-1997 Id Software, Inc.
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 $Id: vfs_doomwad.c,v 1.3 2007-09-30 22:59:24 disconn3ct Exp $
*/


#include "quakedef.h"
#include "hash.h"
#include "common.h"
#include "fs.h"
#include "vfs.h"

#ifdef DOOMWADS
typedef struct
{
	int		filepos, filelen;
	char	name[8];
} dwadfile_t;

typedef struct
{
	char	id[4];
	int		dirlen;
	int		dirofs;
} dwadheader_t;

void *FSPAK_LoadDoomWadFile (vfsfile_t *packhandle, char *desc)
{
	dwadheader_t	header;
	int				i;
	packfile_t		*newfiles;
	int				numpackfiles;
	pack_t			*pack;
	dwadfile_t		info;

	int section=0;
	char sectionname[MAX_QPATH];
	char filename[52];
	char neatwadname[52];

	if (packhandle == NULL)
		return NULL;

	VFS_READ(packhandle, &header, sizeof(header), NULL);
	if (header.id[1] != 'W'	|| header.id[2] != 'A' || header.id[3] != 'D')
		return NULL;	//not a doom wad

	//doom wads come in two sorts. iwads and pwads.
	//iwads are the master wads, pwads are meant to replace parts of the master wad.
	//this is awkward, of course.
	//we ignore the i/p bit for the most part, but with maps, pwads are given a prefixed name.
	if (header.id[0] == 'I')
		*neatwadname = '\0';
	else if (header.id[0] == 'P')
	{
		COM_FileBase(desc, neatwadname);
		strlcat (neatwadname, "#", sizeof (neatwadname));
	}
	else
		return NULL;

	header.dirofs = LittleLong (header.dirofs);
	header.dirlen = LittleLong (header.dirlen);

	numpackfiles = header.dirlen;
	newfiles = (packfile_t*)Q_malloc (numpackfiles * sizeof(packfile_t));
	VFS_SEEK(packhandle, header.dirofs, SEEK_SET);

	//doom wads are awkward.
	//they have no directory structure, except for start/end 'files'.
	//they follow along the lines of lumps after the parent name.
	//a map is the name of that map, and then a squence of the lumps that form that map (found by next-with-that-name).
	//this is a problem for a real virtual filesystem, so we add a hack to recognise special names and expand them specially.
	for (i=0 ; i<numpackfiles ; i++)
	{
		VFS_READ (packhandle, &info, sizeof(info), NULL);

		strlcpy (filename, info.name, sizeof (filename));
		filename[8] = '\0';
		Q_strlwr(filename);

		newfiles[i].filepos = LittleLong(info.filepos);
		newfiles[i].filelen = LittleLong(info.filelen);

		switch(section)	//be prepared to remap filenames.
		{
newsection:
		case 0:
			if (info.filelen == 0)
			{	//marker for something...

				if (!strcmp(filename, "s_start"))
				{
					section = 2;
					snprintf (newfiles[i].name, sizeof (newfiles[i].name), "sprites/%s", filename);	//the model loader has a hack to recognise .dsp
					break;
				}
				if (!strcmp(filename, "p_start"))
				{
					section = 3;
					snprintf (newfiles[i].name, sizeof (newfiles[i].name), "patches/%s", filename); //the map loader will find these.
					break;
				}
				if (!strcmp(filename, "f_start"))
				{
					section = 4;
					snprintf (newfiles[i].name, sizeof (newfiles[i].name), "flats/%s", filename);	//the map loader will find these
					break;
				}
				if ((filename[0] == 'e' && filename[2] == 'm') || !strncmp(filename, "map", 3))
				{	//this is the start of a beutiful new map
					section = 1;
					strlcpy (sectionname, filename, sizeof (sectionname));
					snprintf (newfiles[i].name, sizeof (newfiles[i].name), "maps/%s%s.bsp", neatwadname, filename);	//generate fake bsps to allow the server to find them
					newfiles[i].filepos = 0;
					newfiles[i].filelen = 4;
					break;
				}
				if (!strncmp(filename, "gl_", 3) && ((filename[4] == 'e' && filename[5] == 'm') || !strncmp(filename+3, "map", 3)))
				{	//this is the start of a beutiful new map
					section = 5;
					strlcpy (sectionname, filename+3, sizeof (sectionname));
					break;
				}
			}

			snprintf (newfiles[i].name, sizeof (newfiles[i].name), "wad/%s", filename);	//but there are many files that we don't recognise/know about. archive them off to keep the vfs moderatly clean.
			break;
		case 1:	//map section
			if (strcmp(filename, "things") &&
				strcmp(filename, "linedefs") &&
				strcmp(filename, "sidedefs") &&
				strcmp(filename, "vertexes") &&
				strcmp(filename, "segs") &&
				strcmp(filename, "ssectors") &&
				strcmp(filename, "nodes") &&
				strcmp(filename, "sectors") &&
				strcmp(filename, "reject") &&
				strcmp(filename, "blockmap"))
			{
				section = 0;
				goto newsection;
			}
			snprintf (newfiles[i].name, sizeof (newfiles[i].name), "maps/%s%s.%s", neatwadname, sectionname, filename);
			break;
		case 5:	//glbsp output section
			if (strcmp(filename, "gl_vert") &&
				strcmp(filename, "gl_segs") &&
				strcmp(filename, "gl_ssect") &&
				strcmp(filename, "gl_pvs") &&
				strcmp(filename, "gl_nodes"))
			{
				section = 0;
				goto newsection;
			}
			snprintf (newfiles[i].name, sizeof (newfiles[i].name), "maps/%s%s.%s", neatwadname, sectionname, filename);
			break;
		case 2:	//sprite section
			if (!strcmp(filename, "s_end"))
			{
				section = 0;
				goto newsection;
			}
			snprintf (newfiles[i].name, sizeof (newfiles[i].name), "sprites/%s", filename);
			break;
		case 3:	//patches section
			if (!strcmp(filename, "p_end"))
			{
				section = 0;
				goto newsection;
			}
			snprintf (newfiles[i].name, sizeof (newfiles[i].name), "patches/%s", filename);
			break;
		case 4:	//flats section
			if (!strcmp(filename, "f_end"))
			{
				section = 0;
				goto newsection;
			}
			snprintf (newfiles[i].name, sizeof (newfiles[i].name), "flats/%s", filename);
			break;
		}
	}

	pack = (pack_t*)Q_malloc (sizeof (pack_t));
	strlcpy (pack->filename, desc, sizeof (pack->filename));
	pack->handle = packhandle;
	pack->numfiles = numpackfiles;
	pack->files = newfiles;
	pack->filepos = 0;
	VFS_SEEK(packhandle, pack->filepos, SEEK_SET);

	pack->references++;

	Com_Printf("Added packfile %s (%i files)\n", desc, numpackfiles);
	return pack;
}

searchpathfuncs_t doomwadfilefuncs = {
	FSPAK_PrintPath,
	FSPAK_ClosePath,
	FSPAK_BuildHash,
	FSPAK_FLocate,
	FSOS_ReadFile,
	FSPAK_EnumerateFiles,
	FSPAK_LoadDoomWadFile,
	NULL,
	FSPAK_OpenVFS
};


#endif // DOOMWADS



================================================
FILE: src/vfs_gzip.c
================================================
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *     
 * $Id: vfs_gzip.c,v 1.12 2007-10-13 17:30:09 borisu Exp $
 *             
 */

#ifdef WITH_ZLIB

#include <zlib.h>
#ifdef _WIN32
#include <io.h>
#endif // _WIN32
#include "quakedef.h"
#include "hash.h"
#include "common.h"
#include "hash.h"
#include "fs.h"
#include "vfs.h"

//=============================================================================
//                       G Z I P   V F S
//=============================================================================
typedef struct gzipfile_s
{
	char filename[MAX_QPATH];
	vfsfile_t *handle;

	packfile_t file; // Only one file can be stored in a gzip file

	unsigned long filepos;
	vfsfile_t *raw;

	int references;
} gzipfile_t;


typedef struct 
{
	vfsfile_t funcs; // <= must be at top/begining of struct

	gzipfile_t *parent;

	unsigned long startpos;
	unsigned long length;
	unsigned long currentpos;
} vfsgzipfile_t;

// FIXME:
// Everything below assumes that the input file was an OS file
// This may not be the case if we are opening a gz file in a gz file...
// The assumption is due to the minizip library not having hooks for
// f* operations (fread, fwrite, fseek etc)
//
// This assumption may be possible to over come by using streams instead
//
static int VFSGZIP_ReadBytes(vfsfile_t *file, void *buffer, int bytestoread, vfserrno_t *err) 
{
	int r;
	vfsgzipfile_t *vfsgz = (vfsgzipfile_t *)file;

	if (bytestoread < 0)
		        Sys_Error("VFSGZIP_ReadBytes: bytestoread < 0");
	
	r = gzread((gzFile)vfsgz->parent->handle, buffer, bytestoread);
	// r == -1 on error

	if (err) // if bytestoread <= 0 it will be treated as non error even we read zero bytes
		*err = ((r || bytestoread <= 0) ? VFSERR_NONE : VFSERR_EOF);


	return r;
}

static int VFSGZIP_WriteBytes(vfsfile_t *file, const void *buffer, int bytestowrite) 
{
	int r;
	vfsgzipfile_t *vfsgz = (vfsgzipfile_t *)file;

	r = gzwrite((gzFile)vfsgz->parent->handle, buffer, bytestowrite);

	// r == 0 on error
	
	return r;
}

static int VFSGZIP_Seek(vfsfile_t *file, unsigned long offset, int whence) 
{
	int r;
	vfsgzipfile_t *vfsgz = (vfsgzipfile_t *)file;

	r = gzseek((gzFile)vfsgz->parent->handle, offset, whence);

	if (r == -1)
		return -1;
	else
		return 0;
}

static unsigned long VFSGZIP_Tell(vfsfile_t *file) 
{
	int r;
	vfsgzipfile_t *vfsgz = (vfsgzipfile_t *)file;

	r = gztell((gzFile)vfsgz->parent->handle);
	return r;
}

static unsigned long VFSGZIP_GetLen(vfsfile_t *file) 
{
	int r, currentpos;
	vfsgzipfile_t *vfsgz = (vfsgzipfile_t *)file;
	
	// VFS-FIXME: Error handling
	currentpos = gztell((gzFile)vfsgz->parent->handle);
	r = gzseek((gzFile)vfsgz->parent->handle, 0, SEEK_END);
	gzseek((gzFile)vfsgz->parent->handle, currentpos, SEEK_SET);

	return r;
}

static void FSGZIP_ClosePath(void *handle);
static void VFSGZIP_Close(vfsfile_t *file) 
{
	vfsgzipfile_t *vfsgz = (vfsgzipfile_t *)file;

	FSGZIP_ClosePath(vfsgz->parent);
}

static void VFSGZIP_Flush(vfsfile_t *file) 
{
	vfsgzipfile_t *vfsgz = (vfsgzipfile_t *)file;

	// gzflush((gzFile)vfsgz->parent->handle, Z_NO_FLUSH); 	// <-- Allows better compression
	(void) gzflush((gzFile)vfsgz->parent->handle, Z_SYNC_FLUSH); 	// <-- All pending output is flushed
}

static vfsfile_t *FSGZIP_OpenVFS(void *handle, flocation_t *loc, char *mode) 
{
	gzipfile_t *gzip = (gzipfile_t *)handle;
	vfsgzipfile_t *vfsgz;

	if (strcmp(mode, "rb"))
		return NULL;

	vfsgz = Q_calloc(1, sizeof(*vfsgz));
	vfsgz->parent = gzip;
	gzip->references++;

	vfsgz->startpos   = loc->offset;
	vfsgz->length     = loc->len;
	vfsgz->currentpos = vfsgz->startpos;

	vfsgz->funcs.ReadBytes  = strcmp(mode, "rb") ? NULL : VFSGZIP_ReadBytes;
	vfsgz->funcs.WriteBytes = strcmp(mode, "wb") ? NULL : VFSGZIP_WriteBytes;
	vfsgz->funcs.Seek       = VFSGZIP_Seek;
	vfsgz->funcs.Tell       = VFSGZIP_Tell;
	vfsgz->funcs.GetLen     = VFSGZIP_GetLen;
	vfsgz->funcs.Close      = VFSGZIP_Close;
	vfsgz->funcs.Flush      = VFSGZIP_Flush;
	if (loc->search)
		vfsgz->funcs.copyprotected = loc->search->copyprotected;

	return (vfsfile_t *)vfsgz;
}


//=============================================
// GZIP file  (*.gz) - Search Functions
//=============================================
static void FSGZIP_PrintPath(void *handle)
{
	gzipfile_t *gzip = (gzipfile_t *)handle;

	if (gzip->references != 1)
		Com_Printf("%s (%i)\n", gzip->filename, gzip->references-1);
	else
		Com_Printf("%s\n", gzip->filename);
}

static void FSGZIP_ClosePath(void *handle)
{
	gzipfile_t *gzip = (gzipfile_t *)handle;

	if (--gzip->references > 0)
		return; //not yet time


	gzclose((gzFile)gzip->handle);
	VFS_CLOSE(gzip->raw);
	Q_free(gzip);
}

static void FSGZIP_BuildHash(void *handle)
{
	gzipfile_t *gzip = (gzipfile_t *)handle;

	if (!Hash_GetInsensitive(filesystemhash, gzip->file.name))
	{
		Hash_AddInsensitive(filesystemhash, gzip->file.name, &gzip->file);
		fs_hash_files++;
	}
	else {
		fs_hash_dups++;
	}
}

static qbool FSGZIP_FLocate(void *handle, flocation_t *loc, const char *filename, void *hashedresult)
{
	packfile_t *pf = hashedresult;
	gzipfile_t *gzip = (gzipfile_t *)handle;

	// look through all the pak file elements

	//is this a pointer to a file in this pak?
	if (pf && pf != &(gzip->file)) {
		return false;   //was found in a different path
	} else if (!strcmp (gzip->file.name, filename)) {
		pf = &gzip->file;
	}

	if (pf)
	{
		if (loc)
		{
			loc->index = 0;
			snprintf(loc->rawname, sizeof(loc->rawname), "%s/%s", gzip->filename, filename);
			loc->offset = pf->filepos;
			loc->len = pf->filelen;
		}
		return true;
	}
	return false;

}

static void FSGZIP_ReadFile(void *handle, flocation_t *loc, char *buffer)
{
	gzipfile_t *gzip = handle;
	int err;

	VFS_SEEK(gzip->handle, gzip->file.filepos, SEEK_SET);

	err = VFS_READ(gzip->handle, buffer, gzip->file.filelen, NULL);

	if (err!=gzip->file.filelen)
	{
		Com_Printf ("Can't extract file \"%s:%s\" (corrupt)\n", gzip->filename, gzip->file.name);
		return;
	}
	return;
}

static int FSGZIP_EnumerateFiles (void *handle, char *match, int (*func)(char *, int, void *), void *parm)
{
	gzipfile_t *gzip = handle;

	if (wildcmp(match, gzip->file.name))
	{
		if (!func(gzip->file.name, gzip->file.filelen, parm))
			return false;
	}

	return true;
}

// =================
// FSTAR_LoadGZipFile
// =================
// Takes an explicit (not game tree related) path to a gzip file.
//
// Loads the header and directory, adding the files at the beginning
// of the list so they override previous pack files.

static void *FSGZIP_LoadGZipFile(vfsfile_t *gziphandle, const char *desc)
{
	gzipfile_t *gzip;
	const char *base;
	char *ext;
	int fd;

	gzip = Q_calloc(1, sizeof(*gzip));
	strlcpy(gzip->filename, desc, sizeof(gzip->filename));
	if (gziphandle == NULL) goto fail;
	gzip->raw = gziphandle;

	fd = fileno(((vfsosfile_t *)gziphandle)->handle); // <-- ASSUMPTION! that file is OS
	gzip->handle = (vfsfile_t *)gzdopen(dup(fd), "r");
	gzip->references = 1;

	/* Remove the .gz from the file.name */
	base = COM_SkipPath(desc);
	ext = COM_FileExtension(desc);
	if (strcmp(ext, "gz") == 0) {
		COM_StripExtension(base, gzip->file.name, sizeof(gzip->file.name));
	} else {
		strlcpy(gzip->file.name, base, sizeof(gzip->file.name));
	}

	return gzip;

fail:
	// Q_free is safe to call on NULL pointers
	Q_free(gzip);
	return NULL;
}

searchpathfuncs_t gzipfilefuncs = {
	FSGZIP_PrintPath,
	FSGZIP_ClosePath,
	FSGZIP_BuildHash,
	FSGZIP_FLocate,
	FSGZIP_ReadFile,
	FSGZIP_EnumerateFiles,
	FSGZIP_LoadGZipFile,
	NULL, // VFS-FIXME: Might be used for f_modification
	FSGZIP_OpenVFS 
};

#endif // WITH_ZLIB


================================================
FILE: src/vfs_mmap.c
================================================
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *     
 * $Id: vfs_mmap.c,v 1.2 2007-10-10 17:30:43 dkure Exp $
 *             
 */

//#ifdef WITH_VFS_MMAP

#include "quakedef.h"
#include "hash.h"
#include "common.h"
#include "hash.h"
#include "fs.h"
#include "vfs.h"

//=============================================================================
//                       M M A P    V F S
//=============================================================================
// These functions give a VFS layer to operations for a file in 
// mapped in memory (aka mmap)

typedef struct {
	vfsfile_t funcs; // <= must be at top/begining of struct

	byte *handle;
	size_t position;
	size_t len;
} vfsmmapfile_t;

static int VFSMMAP_ReadBytes(vfsfile_t *file, void *buffer, int bytestoread_, vfserrno_t *err) 
{
	vfsmmapfile_t *intfile = (vfsmmapfile_t *)file;
	size_t bytestoread = bytestoread_;

	if (bytestoread < 0) {
		Sys_Error("VFSMMAP_ReadBytes: bytestoread < 0");
	}

	/* Make sure we don't read past the valid memory */
	if ((bytestoread + intfile->position) > intfile->len) {
		bytestoread = max(0, intfile->len - intfile->position);
	}

	// Read.
	memcpy(buffer, intfile->handle + intfile->position, bytestoread);

	// Advance in the file.
	intfile->position += bytestoread;

	if (err) {
		*err = (bytestoread == 0) ? VFSERR_EOF : VFSERR_NONE;
	}

	// safe cast: will be <= bytestoread_
	return (int)bytestoread;
}

static int VFSMMAP_WriteBytes(vfsfile_t *file, const void *buffer, int bytestowrite) 
{
	vfsmmapfile_t *intfile = (vfsmmapfile_t *)file;

	/* Allocate more memory if we would overflow */
	if (bytestowrite + intfile->position > intfile->len) {
		size_t newlen  = bytestowrite + intfile->position;
		void *p = Q_realloc(intfile->handle, newlen);
		if (!p) {
			Com_Printf("VFSMMAP_WriteBytes: Unable to write to file, memory full\n");
			return 0;
		} 
		intfile->handle = p;
	}

	memcpy(intfile->handle + intfile->position, buffer, bytestowrite);
	intfile->position += bytestowrite;

	return bytestowrite;
}

static int VFSMMAP_Seek(vfsfile_t *file, unsigned long offset, int whence) 
{
	vfsmmapfile_t *intfile = (vfsmmapfile_t *)file;

	switch(whence) 
	{
		case SEEK_SET: 
			intfile->position = offset;
			break;
		case SEEK_CUR: 
			intfile->position += offset;
			break;
		case SEEK_END: 
			intfile->position = intfile->len + offset; 
			break;
		default:
			Sys_Error("VFSMMAP_Seek: Unknown whence value(%d)\n", whence);
			return -1;
	}

	// We seeked outside the bounds.
	if (intfile->position > intfile->len)
	{
		// Be sure we don't have an invalid file position. (Should we do this?)
		clamp(intfile->position, 0, intfile->len);
		return -1;
	}

	return 0;
}

static unsigned long VFSMMAP_Tell(vfsfile_t *file) 
{
	vfsmmapfile_t *intfile = (vfsmmapfile_t *)file;

	return (unsigned long)intfile->position;
}

static unsigned long VFSMMAP_GetLen(vfsfile_t *file) 
{
	vfsmmapfile_t *intfile = (vfsmmapfile_t *)file;
	
	return (unsigned long)intfile->len;
}

static void VFSMMAP_Close(vfsfile_t *file) 
{
	vfsmmapfile_t *intfile = (vfsmmapfile_t *)file;

	Q_free(intfile->handle);
	Q_free(intfile);
}

static void VFSMMAP_Flush(vfsfile_t *file) 
{
	vfsmmapfile_t *intfile = (vfsmmapfile_t *)file;

	(void)intfile;
	Sys_Error("VFSMMAP_Flush: Invalid operation\n");
}

vfsfile_t *FSMMAP_OpenVFS(void *buf, size_t buf_len) 
{
	vfsmmapfile_t *mmapfile = Q_calloc(1, sizeof(*mmapfile));

	mmapfile->handle           = buf;
	mmapfile->len              = buf_len;
	mmapfile->funcs.ReadBytes  = VFSMMAP_ReadBytes;
	mmapfile->funcs.WriteBytes = VFSMMAP_WriteBytes;
	mmapfile->funcs.Seek       = VFSMMAP_Seek;
	mmapfile->funcs.Tell       = VFSMMAP_Tell;
	mmapfile->funcs.GetLen     = VFSMMAP_GetLen;
	mmapfile->funcs.Close      = VFSMMAP_Close;
	mmapfile->funcs.Flush      = VFSMMAP_Flush;

	return (vfsfile_t *)mmapfile;
}

qbool FSMMAP_IsMemoryMapped(vfsfile_t* file)
{
	return file && file->ReadBytes == VFSMMAP_ReadBytes;
}

//#endif // WITH_VFS_MMAP


================================================
FILE: src/vfs_os.c
================================================
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *     
 * $Id: vfs_os.c,v 1.11 2007/10/10 17:30:43 dkure Exp $
 *             
 */

#include "quakedef.h"
#include "hash.h"
#include "common.h"
#include "fs.h"
#include "vfs.h"

//==================================
// STDIO files (OS) - VFS Functions
//==================================
static int VFSOS_ReadBytes (struct vfsfile_s *file, void *buffer, int bytestoread, vfserrno_t *err)
{
	size_t r;
	vfsosfile_t *intfile = (vfsosfile_t*)file;

	if (bytestoread < 0)
		Sys_Error("VFSOS_ReadBytes: bytestoread < 0"); // ffs

	r = fread(buffer, 1, bytestoread, intfile->handle);

	if (err) // if bytestoread <= 0 it will be treated as non error even we read zero bytes
		*err = ((r || bytestoread <= 0) ? VFSERR_NONE : VFSERR_EOF);

	return (int)r;
}

static int VFSOS_WriteBytes (struct vfsfile_s *file, const void *buffer, int bytestowrite)
{
	vfsosfile_t *intfile = (vfsosfile_t*)file;
	return (int)fwrite(buffer, 1, bytestowrite, intfile->handle);
}

static int VFSOS_Seek (struct vfsfile_s *file, unsigned long pos, int whence)
{
	vfsosfile_t *intfile = (vfsosfile_t*)file;
	return (int)fseek(intfile->handle, pos, whence);
}

static unsigned long VFSOS_Tell (struct vfsfile_s *file)
{
	vfsosfile_t *intfile = (vfsosfile_t*)file;
	return ftell(intfile->handle);
}

static unsigned long VFSOS_GetSize (struct vfsfile_s *file)
{
	vfsosfile_t *intfile = (vfsosfile_t*)file;

	unsigned long curpos, maxlen;

	// FIXME: add error checks here?

	curpos = ftell(intfile->handle);
	fseek(intfile->handle, 0, SEEK_END);
	maxlen = ftell(intfile->handle);
	fseek(intfile->handle, curpos, SEEK_SET);

	return maxlen;
}

static void VFSOS_Close(vfsfile_t *file)
{
	vfsosfile_t *intfile = (vfsosfile_t*)file;
	fclose(intfile->handle);
	Q_free(file);
}

vfsfile_t *FS_OpenTemp(void)
{
	FILE *f;
	vfsosfile_t *file;

	f = tmpfile();
	if (!f)
		return NULL;

	file = Q_calloc(1, sizeof(vfsosfile_t));

	file->funcs.ReadBytes	= VFSOS_ReadBytes;
	file->funcs.WriteBytes	= VFSOS_WriteBytes;
	file->funcs.Seek		= VFSOS_Seek;
	file->funcs.Tell		= VFSOS_Tell;
	file->funcs.GetLen		= VFSOS_GetSize;
	file->funcs.Close		= VFSOS_Close;

	file->handle = f;

	return (vfsfile_t*)file;
}

// VFS-XXX: This is slightly different to fs.c version in that we don't take in a FILE *f
vfsfile_t *VFSOS_Open(char *osname, char *mode)
{
	FILE *f;
	vfsosfile_t *file;
	qbool read   = !!strchr(mode, 'r');
	qbool write  = !!strchr(mode, 'w');
	qbool append = !!strchr(mode, 'a');
	qbool text   = !!strchr(mode, 't');
	char newmode[10];
	int modec = 0;

	if (read)
		newmode[modec++] = 'r';
	if (write)
		newmode[modec++] = 'w';
	if (append)
		newmode[modec++] = 'a';
	if (text)
		newmode[modec++] = 't';
	else
		newmode[modec++] = 'b';
	newmode[modec++] = '\0';

	f = fopen(osname, newmode);
	if (!f)
		return NULL;

	file = Q_calloc_named(1, sizeof(vfsosfile_t), osname);

	file->funcs.ReadBytes  = ( strchr(mode, 'r')                      ? VFSOS_ReadBytes  : NULL);
	file->funcs.WriteBytes = ((strchr(mode, 'w') || strchr(mode, 'a'))? VFSOS_WriteBytes : NULL);
	file->funcs.Seek       = VFSOS_Seek;
	file->funcs.Tell       = VFSOS_Tell;
	file->funcs.GetLen     = VFSOS_GetSize;
	file->funcs.Close      = VFSOS_Close;

	file->handle = f;

	return (vfsfile_t*)file;
}

//==================================
// STDIO files (OS) - Search functions
//==================================
vfsfile_t *FSOS_OpenVFS(void *handle, flocation_t *loc, char *mode)
{
	char diskname[MAX_OSPATH];

	snprintf(diskname, sizeof(diskname), "%s/%s", (char*)handle, loc->rawname);

	return VFSOS_Open(diskname, mode);
}

static void FSOS_PrintPath(void *handle)
{
	Com_Printf("%s\n", handle);
}

static void FSOS_ClosePath(void *handle)
{
	Q_free(handle);
}

static int FSOS_RebuildFSHash(char *filename, int filesize, void *data)
{
	if (filename[strlen(filename)-1] == '/')
	{	//this is actually a directory

		char childpath[256];
		snprintf(childpath, sizeof (childpath), "%s*", filename);
		Sys_EnumerateFiles((char*)data, childpath, FSOS_RebuildFSHash, data);
		return true;
	}
	if (!Hash_GetInsensitive(filesystemhash, filename))
	{
		Hash_AddInsensitive(filesystemhash, filename, data);
		fs_hash_files++;
	}
	else
		fs_hash_dups++;
	return true;
}

static void FSOS_BuildHash(void *handle)
{
	Sys_EnumerateFiles(handle, "*", FSOS_RebuildFSHash, handle);
}

static qbool FSOS_FLocate(void *handle, flocation_t *loc, const char *filename, void *hashedresult)
{
	FILE *f;
	int len;
	char netpath[MAX_OSPATH];


	if (hashedresult && (void *)hashedresult != handle)
		return false;

/*
	if (!static_registered)
	{	// if not a registered version, don't ever go beyond base
		if ( strchr (filename, '/') || strchr (filename,'\\'))
			continue;
	}
*/

// check a file in the directory tree
	snprintf (netpath, sizeof(netpath)-1, "%s/%s",(char*)handle, filename);

	// VFS-FIXME: This could be optimised to only do this once and save the result!
	f = fopen(netpath, "rb");
	if (!f)
		return false;

	fseek(f, 0, SEEK_END);
	len = ftell(f);
	fclose(f);
	if (loc)
	{
		loc->len = len;
		loc->offset = 0;
		loc->index = 0;
		strlcpy (loc->rawname, filename, sizeof (loc->rawname));
	}

	return true;
}

void FSOS_ReadFile(void *handle, flocation_t *loc, char *buffer)
{
	FILE *f;
	int read;

	f = fopen(loc->rawname, "rb");
	if (!f)	//err...
		return;
	fseek(f, loc->offset, SEEK_SET);
	read = (int)fread(buffer, 1, loc->len, f);
	if (read != loc->len) {
		Com_Printf ("Can't read file \"%s\" (%d bytes, expected %d)\n", loc->rawname, read, loc->len);
	}
	fclose(f);
}

static int FSOS_EnumerateFiles (void *handle, char *match, int (*func)(char *, int, void *), void *parm)
{
	return Sys_EnumerateFiles(handle, match, func, parm);
}

searchpathfuncs_t osfilefuncs = {
	FSOS_PrintPath,
	FSOS_ClosePath,
	FSOS_BuildHash,
	FSOS_FLocate,
	FSOS_ReadFile,
	FSOS_EnumerateFiles,
	NULL,
	NULL,
	FSOS_OpenVFS
};


================================================
FILE: src/vfs_pak.c
================================================
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *     
 * $Id: vfs_pak.c,v 1.17 2007-10-13 16:02:51 dkure Exp $
 *             
 */

#include "quakedef.h"
#include "hash.h"
#include "common.h"
#include "fs.h"
#include "vfs.h"

// on disk
typedef struct pack_s
{
	char    filename[MAX_OSPATH];
	vfsfile_t    *handle;
	unsigned int filepos;   // the pos the subfiles left it at 
							// (to optimize calls to vfs_seek)
	int references;         // seeing as all vfiles from a pak file use the 
							// parent's vfsfile, we need to keep the parent 
							// open until all subfiles are closed.

	int     numfiles;
	packfile_t  *files;
} pack_t;

typedef struct
{
	char    name[56];
	int     filepos, filelen;
} dpackfile_t;

typedef struct
{
	char    id[4];
	int     dirofs;
	int     dirlen;
} dpackheader_t;

typedef struct {
    vfsfile_t funcs; // <= must be at top/begining of struct
	pack_t *parentpak;
    unsigned long startpos;
    unsigned long length;
    unsigned long currentpos;
} vfspack_t;

#define	MAX_FILES_IN_PACK	2048

//=====================================
//PACK files (*.pak) - VFS functions
//=====================================
static int VFSPAK_ReadBytes (struct vfsfile_s *vfs, void *buffer, int bytestoread, vfserrno_t *err)
{
	vfspack_t *vfsp = (vfspack_t*)vfs;
	int read;

	if (vfsp->currentpos - vfsp->startpos + bytestoread > vfsp->length)
		bytestoread = vfsp->length - (vfsp->currentpos - vfsp->startpos);
	if (bytestoread <= 0)
		return -1;

	if (vfsp->parentpak->filepos != vfsp->currentpos) {
		VFS_SEEK(vfsp->parentpak->handle, vfsp->currentpos, SEEK_SET);
	}

	read = VFS_READ(vfsp->parentpak->handle, buffer, bytestoread, err);
	vfsp->currentpos += read;
	vfsp->parentpak->filepos = vfsp->currentpos;

	// VFS-FIXME: Need to handle errors

	return read;
}
static int VFSPAK_WriteBytes (struct vfsfile_s *vfs, const void *buffer, int bytestoread)
{	//not supported.
	Sys_Error("VFSPAK_WriteBytes: Cannot write to pak files");
	return 0;
}

static int VFSPAK_Seek (struct vfsfile_s *vfs, unsigned long offset, int whence)
{
	vfspack_t *vfsp = (vfspack_t*)vfs;
	int rel_offset;

	// VFS-FIXME Support other whence types
	switch(whence) {
	case SEEK_SET: 
		vfsp->currentpos = vfsp->startpos + offset; 
		break;
	case SEEK_CUR: 
		vfsp->currentpos += offset; 
		break;
	case SEEK_END: 
		vfsp->currentpos = vfsp->startpos + vfsp->length + offset;
		break;
	default:
		Sys_Error("VFSTAR_Seek: Unknown whence value(%d)\n", whence);
		return -1;
	}

	rel_offset = vfsp->currentpos - vfsp->startpos;
	if (rel_offset < 0 || rel_offset >= vfsp->length) {
		Com_Printf("VFSPAK_Seek: Warning seeking past the file's size\n");
	}

	return 0;
}

static unsigned long VFSPAK_Tell (struct vfsfile_s *vfs)
{
	vfspack_t *vfsp = (vfspack_t*)vfs;
	return vfsp->currentpos - vfsp->startpos;
}

static unsigned long VFSPAK_GetLen (struct vfsfile_s *vfs)
{
	vfspack_t *vfsp = (vfspack_t*)vfs;
	return vfsp->length;
}

static void FSPAK_ClosePath(void *handle);
static void VFSPAK_Close(vfsfile_t *vfs)
{
	vfspack_t *vfsp = (vfspack_t*)vfs;
	FSPAK_ClosePath(vfsp->parentpak);	// tell the parent that we don't need it open any 
										// more (reference counts)
	Q_free(vfsp);
}

static vfsfile_t *FSPAK_OpenVFS(void *handle, flocation_t *loc, char *mode)
{
	pack_t *pack = (pack_t*)handle;
	vfspack_t *vfsp;

	if (strcmp(mode, "rb"))
		return NULL; //urm, unable to write/append

	vfsp = Q_calloc(1, sizeof(*vfsp));

	vfsp->parentpak = pack;
	vfsp->parentpak->references++;

	vfsp->startpos   = loc->offset;
	vfsp->length     = loc->len;
	vfsp->currentpos = vfsp->startpos;

	vfsp->funcs.ReadBytes     = strcmp(mode, "rb") ? NULL : VFSPAK_ReadBytes;
	vfsp->funcs.WriteBytes    = strcmp(mode, "wb") ? NULL : VFSPAK_WriteBytes;
	vfsp->funcs.Seek		  = VFSPAK_Seek;
	vfsp->funcs.Tell		  = VFSPAK_Tell;
	vfsp->funcs.GetLen	      = VFSPAK_GetLen;
	vfsp->funcs.Close	      = VFSPAK_Close;
	vfsp->funcs.Flush         = NULL;
	if (loc->search)
		vfsp->funcs.copyprotected = loc->search->copyprotected;

	return (vfsfile_t *)vfsp;
}

//======================================
// PACK files (*.pak) - Search functions
//======================================
static void FSPAK_PrintPath(void *handle)
{
	pack_t *pak = handle;

	if (pak->references != 1)
		Com_Printf("%s (%i)\n", pak->filename, pak->references-1);
	else
		Com_Printf("%s\n", pak->filename);
}

static void FSPAK_ClosePath(void *handle)
{
	pack_t *pak = handle;

	pak->references--;
	if (pak->references > 0)
		return;	//not free yet

	VFS_CLOSE (pak->handle);
	if (pak->files)
		Q_free(pak->files);
	Q_free(pak);
}

static void FSPAK_BuildHash(void *handle)
{
	pack_t *pak = handle;
	int i;

	for (i = 0; i < pak->numfiles; i++)
	{
		if (!Hash_GetInsensitive(filesystemhash, pak->files[i].name))
		{
			Hash_AddInsensitive(filesystemhash, pak->files[i].name, &pak->files[i]);
			fs_hash_files++;
		}
		else
			fs_hash_dups++;
	}
}

static qbool FSPAK_FLocate(void *handle, flocation_t *loc, const char *filename, void *hashedresult)
{
	packfile_t *pf = hashedresult;
	int i;
	pack_t		*pak = handle;

// look through all the pak file elements

	if (pf)
	{	//is this a pointer to a file in this pak?
		if (pf < pak->files || pf > pak->files + pak->numfiles)
			return false;	//was found in a different path
	}
	else
	{
		for (i=0 ; i<pak->numfiles ; i++)	//look for the file
		{
			if (!strcmp (pak->files[i].name, filename))
			{
				pf = &pak->files[i];
				break;
			}
		}
	}

	if (pf)
	{
		if (loc)
		{
			loc->index = pf - pak->files;
			snprintf(loc->rawname, sizeof(loc->rawname), "%s/%s", pak->filename, filename);
			loc->offset = pf->filepos;
			loc->len = pf->filelen;
		}
		return true;
	}
	return false;
}

static int FSPAK_EnumerateFiles (void *handle, char *match, int (*func)(char *, int, void *), void *parm)
{
	pack_t	*pak = handle;
	int		num;

	for (num = 0; num<(int)pak->numfiles; num++)
	{
		if (wildcmp(match, pak->files[num].name))
		{
			if (!func(pak->files[num].name, pak->files[num].filelen, parm))
				return false;
		}
	}

	return true;
}

/*
=================
FSPAK_LoadPackFile

Takes an explicit (not game tree related) path to a pak file.

Loads the header and directory, adding the files at the beginning
of the list so they override previous pack files.
=================
*/
static void *FSPAK_LoadPackFile (vfsfile_t *file, const char *desc)
{
	dpackheader_t	header;
	int				i;
	packfile_t		*newfiles;
	int				numpackfiles;
	pack_t			*pack;
	vfsfile_t		*packhandle;
	dpackfile_t		info;
	vfserrno_t err;

	packhandle = file;
	if (packhandle == NULL)
		return NULL;

	VFS_READ(packhandle, &header, sizeof(header), &err);
	if (header.id[0] != 'P' || header.id[1] != 'A'
	|| header.id[2] != 'C' || header.id[3] != 'K')
	{
		return NULL;
	}
	header.dirofs = LittleLong (header.dirofs);
	header.dirlen = LittleLong (header.dirlen);

	numpackfiles = header.dirlen / sizeof(dpackfile_t);

//	if (numpackfiles != PAK0_COUNT)
//		com_modified = true;	// not the original file

	newfiles = (packfile_t*)Q_malloc (numpackfiles * sizeof(packfile_t));

	VFS_SEEK(packhandle, header.dirofs, SEEK_SET);
//	fread (&info, 1, header.dirlen, packhandle);

// crc the directory to check for modifications
//	crc = QCRC_Block((qbyte *)info, header.dirlen);


//	QCRC_Init (&crc);

	pack = (pack_t *)Q_calloc(1, sizeof (pack_t));

// parse the directory
	for (i=0 ; i<numpackfiles ; i++)
	{
		*info.name = '\0';
		VFS_READ(packhandle, &info, sizeof(info), &err);
/*
		for (j=0 ; j<sizeof(info) ; j++)
			CRC_ProcessByte(&crc, ((qbyte *)&info)[j]);
*/
		strlcpy (newfiles[i].name, info.name, MAX_QPATH);
		newfiles[i].filepos = LittleLong(info.filepos);
		newfiles[i].filelen = LittleLong(info.filelen);
	}
/*
	if (crc != PAK0_CRC)
		com_modified = true;
*/
	strlcpy (pack->filename, desc, sizeof (pack->filename));
	pack->handle = packhandle;
	pack->numfiles = numpackfiles;
	pack->files = newfiles;
	pack->filepos = 0;
	VFS_SEEK(packhandle, pack->filepos, SEEK_SET);

	pack->references++;

	return pack;
}

extern void FSOS_ReadFile(void *handle, flocation_t *loc, char *buffer);

searchpathfuncs_t packfilefuncs = {
	FSPAK_PrintPath,
	FSPAK_ClosePath,
	FSPAK_BuildHash,
	FSPAK_FLocate,
	FSOS_ReadFile,
	FSPAK_EnumerateFiles,
	FSPAK_LoadPackFile,
	NULL,
	FSPAK_OpenVFS
};


================================================
FILE: src/vfs_tar.c
================================================
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *     
 * $Id: vfs_tar.c,v 1.8 2007-10-13 16:02:51 dkure Exp $
 *             
 */

#include "quakedef.h"
#include "hash.h"
#include "common.h"
#include "hash.h"
#include "fs.h"
#include "vfs.h"
#include "vfs_tar.h"

//=============================================================================
//                       T A R    V F S
//=============================================================================
// These functions give a VFS layer to operations for a file tar file 

typedef struct tarfile_s
{
	char filename[MAX_QPATH];
	hashtable_t hash;
	vfsfile_t *raw;

	int numfiles;
	packfile_t  *files;

	unsigned long filepos;

	int references;
} tarfile_t;

typedef struct 
{
	vfsfile_t funcs; // <= must be at top/begining of struct

	tarfile_t *parent;

	unsigned long startpos;
	unsigned long length;
	unsigned long currentpos;
} vfstarfile_t;

// convert octal digits to int
// on error return -1
static int getoct (char *p,int width)
{
	int result = 0;
	char c;

	while (width--)
	{
		c = *p++;
		if (c == 0)
			break;
		if (c == ' ')
			continue;
		if (c < '0' || c > '7')
			return -1;
		result = result * 8 + (c - '0');
	}
	return result;
}

// =====================
// tarOperationGetFiles
// =====================
// Returns the number of files found
// Placing the names in files if a valid pointer
//
// -1 is returned on error

static int tarOperationIndexFiles(vfsfile_t *in, packfile_t *files) {
	// Tar vars
	union  tar_buffer buffer;
	int    len;
	int    getheader = HEADER_SHORTNAME;
	int    remaining = 0;
	char   fname[BLOCKSIZE];
	// Quake vars
	int numfiles = 0;

	VFS_SEEK(in, 0, SEEK_SET); /* Read the file from the begining */

	while (1)
	{
		len = VFS_READ(in, &buffer, BLOCKSIZE, NULL);
		if (len < 0 || len != BLOCKSIZE) {
			Com_Printf("Invalid tar file\n");
			return -1;
		}

		// We have reached the end of the tar 
		if (len == 0 || buffer.header.name[0] == 0)
			break;

		if (getheader == HEADER_SHORTNAME)
		{
			strlcpy(fname,buffer.header.name,sizeof(fname));
			if (fname[SHORTNAMESIZE-1] != 0)
				fname[SHORTNAMESIZE] = 0;
		}
		else
		{
			/* The file name is longer than SHORTNAMESIZE */
			if (strncmp(fname,buffer.header.name,SHORTNAMESIZE-1) != 0) {
				Com_Printf("bad long name\n");
				return -1;
			}
			getheader = HEADER_SHORTNAME;
		}

		/* Act according to the type flag */
		switch (buffer.header.typeflag)
		{
			case DIRTYPE:
				break;
			case REGTYPE:
			case AREGTYPE:
				remaining = getoct(buffer.header.size,12);
				if (remaining == -1)
				{
					Com_Printf("Invalid tar file\n");
					return -1;
				}

				//Com_Printf(" %9d %s\n",remaining,fname);

				if (files) {
					strlcpy(files[numfiles].name, fname, sizeof(files[numfiles].name));
					files[numfiles].filelen = remaining;
					files[numfiles].filepos = VFS_TELL(in);
				}
				numfiles++;

				getheader = HEADER_NONE;
				break;
			case GNUTYPE_LONGLINK:
			case GNUTYPE_LONGNAME:
				/* FIXME: Handle long names */
				remaining = getoct(buffer.header.size,12);
				if (remaining < 0 || remaining >= BLOCKSIZE)
				{
					printf("Invalid tar file\n");
					return -1;
				}
				len = VFS_READ(in, fname, BLOCKSIZE, NULL);
				if (len < 0) {
					printf("Problem reading blocksize");
					return -1;
				}
				if (fname[BLOCKSIZE-1] != 0 || (int)strlen(fname) > remaining)
				{
					printf("Invalid tar file\n");
					return -1;
				}
				getheader = HEADER_LONGNAME;
				break;
			default:
				printf("      <---> %s\n",fname);
				numfiles++;
				break;
		}

		/* Seek the next valid header which contains file names */
		if (getheader == HEADER_NONE) {
			unsigned int offset; 

			/* Round up to the nearest BLOCKSIZE */
			if (remaining % BLOCKSIZE) {
				offset = remaining + (BLOCKSIZE - (remaining % BLOCKSIZE));
			} else {
				offset = remaining;
			}

			VFS_SEEK(in, offset, SEEK_CUR);
			getheader = HEADER_SHORTNAME;
		}
	}


	return numfiles;
}

//=============================================================================

static int VFSTAR_ReadBytes(vfsfile_t *file, void *buffer, int bytestoread, vfserrno_t *err) 
{
	vfstarfile_t *vfst = (vfstarfile_t *)file;
	int read;
	//unsigned long base, bytes; <-- For reading in multiples of BLOCKSIZE

	// VFS-FIXME: Need to read in chunks of BLOCKSIZE
	if (vfst->currentpos - vfst->startpos + bytestoread > vfst->length)
		bytestoread = vfst->length - (vfst->currentpos - vfst->startpos);

	if (bytestoread < 0)
		Sys_Error("VFSTAR_ReadBytes: bytestoread < 0");

	if (vfst->parent->filepos != vfst->currentpos) {
		VFS_SEEK(vfst->parent->raw, vfst->currentpos, SEEK_SET);
	}

	read = VFS_READ(vfst->parent->raw, buffer, bytestoread, NULL);
	vfst->currentpos += read;
	vfst->parent->filepos = vfst->currentpos;

	// VFS-FIXME: Need to figure out errors
	if (err) 
		*err = bytestoread == 0 ? VFSERR_EOF : VFSERR_NONE;

	return read;
}

static int VFSTAR_WriteBytes(vfsfile_t *file, const void *buffer, int bytestowrite) 
{
	Sys_Error("VFSTAR_WriteBytes: Invalid operatioin\n");
	return 0;
}

static int VFSTAR_Seek(vfsfile_t *file, unsigned long offset, int whence) 
{
	vfstarfile_t *vfst = (vfstarfile_t *)file;

	switch(whence) {
	case SEEK_SET: 
		vfst->currentpos = vfst->startpos + offset; 
		break;
	case SEEK_CUR: 
		vfst->currentpos += offset; 
		break;
	case SEEK_END: 
		vfst->currentpos = vfst->startpos + vfst->length + offset;
		break;
	default:
		Sys_Error("VFSTAR_Seek: Unknown whence value(%d)\n", whence);
		return -1;
	}

	if (vfst->currentpos > vfst->length) {
		Com_Printf("VFSTAR_Seek: Warning seeking past the file's size\n");
	}

	return 0;
}

static unsigned long VFSTAR_Tell(vfsfile_t *file) 
{
	vfstarfile_t *vfst = (vfstarfile_t *)file;

	return vfst->currentpos - vfst->startpos;;
}

static unsigned long VFSTAR_GetLen(vfsfile_t *file) 
{
	vfstarfile_t *vfst = (vfstarfile_t *)file;
	
	return vfst->length;
}

static void FSTAR_ClosePath(void *handle);
static void VFSTAR_Close(vfsfile_t *file) 
{
	vfstarfile_t *vfst = (vfstarfile_t *)file;

	FSTAR_ClosePath(vfst->parent);
	Q_free(vfst);
}

static void VFSTAR_Flush(vfsfile_t *file) 
{
	Sys_Error("VFSTAR_Flush: Invalid operation\n");
}

static vfsfile_t *FSTAR_OpenVFS(void *handle, flocation_t *loc, char *mode) 
{
	tarfile_t *tar = (tarfile_t *) handle;
	vfstarfile_t *vfst;
	
	if (strcmp(mode, "rb"))
		return NULL;

	vfst = Q_calloc(1, sizeof(*vfst));
	vfst->parent = tar;
	vfst->parent->references++;

	vfst->startpos   = loc->offset;
	vfst->length     = loc->len;
	vfst->currentpos = vfst->startpos;

	vfst->funcs.ReadBytes  = VFSTAR_ReadBytes;
	vfst->funcs.WriteBytes = VFSTAR_WriteBytes;
	vfst->funcs.Seek       = VFSTAR_Seek;
	vfst->funcs.Tell       = VFSTAR_Tell;
	vfst->funcs.GetLen     = VFSTAR_GetLen;
	vfst->funcs.Close      = VFSTAR_Close;
	vfst->funcs.Flush      = VFSTAR_Flush;
	if (loc->search)
		vfst->funcs.copyprotected = loc->search->copyprotected;

	return (vfsfile_t *)vfst;
}

//=============================================
// TAR file  (*.tar) - Search Functions
//=============================================
static void FSTAR_PrintPath(void *handle)
{
	tarfile_t *tar = (tarfile_t *)handle;

	if (tar->references != 1)
		Com_Printf("%s (%i)\n", tar->filename, tar->references-1);
	else
		Com_Printf("%s\n", tar->filename);
}

static void FSTAR_ClosePath(void *handle)
{
	tarfile_t *tar = (tarfile_t *)handle;

	if (--tar->references > 0)
		return; //not yet time

	VFS_CLOSE(tar->raw);
	if (tar->files)
		Q_free(tar->files);
	Q_free(tar);
}

static void FSTAR_BuildHash(void *handle)
{
	tarfile_t *tar = (tarfile_t *)handle;
	int i;

	for (i = 0; i < tar->numfiles; i++)
	{
		if (!Hash_GetInsensitive(filesystemhash, tar->files[i].name))
		{
			Hash_AddInsensitive(filesystemhash, tar->files[i].name, &tar->files[i]);
			fs_hash_files++;
		}
		else
			fs_hash_dups++;
	}
}

static qbool FSTAR_FLocate(void *handle, flocation_t *loc, const char *filename, void *hashedresult)
{
	packfile_t *pf = (packfile_t *) hashedresult;
	tarfile_t *tar = (tarfile_t  *) handle;
	int i;

	// look through all the pak file elements

	if (pf)
	{   //is this a pointer to a file in this pak?
		if (pf < tar->files || pf > tar->files + tar->numfiles)
			return false;   //was found in a different path
	}
	else
	{
		for (i=0 ; i<tar->numfiles ; i++)   //look for the file
		{
			if (!strcmp (tar->files[i].name, filename))
			{
				pf = &tar->files[i];
				break;
			}
		}
	}

	if (pf)
	{
		if (loc)
		{
			loc->index = pf - tar->files;
			snprintf(loc->rawname, sizeof(loc->rawname), "%s/%s", tar->filename, filename);
			loc->offset = pf->filepos;
			loc->len = pf->filelen;
		}
		return true;
	}
	return false;

}

static void FSTAR_ReadFile(void *handle, flocation_t *loc, char *buffer)
{
	tarfile_t *tar = handle;
	int err;

	VFS_SEEK(tar->raw, tar->files[loc->index].filepos, SEEK_SET);

	err = VFS_READ(tar->raw, buffer, tar->files[loc->index].filelen, NULL);

	if (err!=tar->files[loc->index].filelen)
	{
		Com_Printf ("Can't extract file \"%s:%s\" (corrupt)\n", tar->filename, tar->files[loc->index].name);
		return;
	}
	return;
}

static int FSTAR_EnumerateFiles (void *handle, char *match, int (*func)(char *, int, void *), void *parm)
{
	tarfile_t *tar = handle;
	int     num;

	for (num = 0; num < tar->numfiles; num++)
	{
		if (wildcmp(match, tar->files[num].name))
		{
			if (!func(tar->files[num].name, tar->files[num].filelen, parm))
				return false;
		}
	}

	return true;
}

// =================
// FSTAR_LoadTarFile
// =================
// Takes an explicit (not game tree related) path to a tar file.
//
// Loads the header and directory, adding the files at the beginning
// of the list so they override previous pack files.

static void *FSTAR_LoadTarFile(vfsfile_t *tarhandle, const char *desc)
{
	tarfile_t *tar;

	tar = Q_calloc(1, sizeof(*tar));
	strlcpy (tar->filename, desc, sizeof (tar->filename));
	tar->raw = tarhandle;
	if (!tar->raw) goto fail;

	// Get the number of files inside the tar
	tar->numfiles = tarOperationIndexFiles(tar->raw, NULL);
	if (tar->numfiles < 0) goto fail;

	// Create a list of the number of files
	tar->files = (packfile_t *)Q_malloc(tar->numfiles * sizeof(packfile_t));
	tarOperationIndexFiles(tar->raw, tar->files);

	tar->references = 1;

	return tar;

fail:
	// Q_free is safe to call on NULL pointers
	Q_free(tar->files);
	Q_free(tar);
	return NULL;
}

searchpathfuncs_t tarfilefuncs = {
	FSTAR_PrintPath,
	FSTAR_ClosePath,
	FSTAR_BuildHash,
	FSTAR_FLocate,
	FSTAR_ReadFile,
	FSTAR_EnumerateFiles,
	FSTAR_LoadTarFile,
	NULL, // VFS-FIXME: Might be used for f_modification
	FSTAR_OpenVFS 
};


================================================
FILE: src/vfs_tar.h
================================================
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *     
 * $Id: vfs_tar.h,v 1.1 2007-10-08 14:50:53 dkure Exp $
 *             
 */

#ifndef __VFS_TAR_H__
#define __VFS_TAR_H__

/* values used in typeflag field */

#define REGTYPE  '0'            /* regular file */
#define AREGTYPE '\0'           /* regular file */
#define LNKTYPE  '1'            /* link */
#define SYMTYPE  '2'            /* reserved */
#define CHRTYPE  '3'            /* character special */
#define BLKTYPE  '4'            /* block special */
#define DIRTYPE  '5'            /* directory */
#define FIFOTYPE '6'            /* FIFO special */
#define CONTTYPE '7'            /* reserved */

/* GNU tar extensions */

#define GNUTYPE_DUMPDIR  'D'    /* file names from dumped directory */
#define GNUTYPE_LONGLINK 'K'    /* long link name */
#define GNUTYPE_LONGNAME 'L'    /* long file name */
#define GNUTYPE_MULTIVOL 'M'    /* continuation of file from another volume */
#define GNUTYPE_NAMES    'N'    /* file name that does not fit into main hdr */
#define GNUTYPE_SPARSE   'S'    /* sparse file */
#define GNUTYPE_VOLHDR   'V'    /* tape/volume header */


/* tar header */

#define BLOCKSIZE     512
#define SHORTNAMESIZE 100

struct tar_header
{                               /* byte offset */
  char name[100];               /*   0 */
  char mode[8];                 /* 100 */
  char uid[8];                  /* 108 */
  char gid[8];                  /* 116 */
  char size[12];                /* 124 */
  char mtime[12];               /* 136 */
  char chksum[8];               /* 148 */
  char typeflag;                /* 156 */
  char linkname[100];           /* 157 */
  char magic[6];                /* 257 */
  char version[2];              /* 263 */
  char uname[32];               /* 265 */
  char gname[32];               /* 297 */
  char devmajor[8];             /* 329 */
  char devminor[8];             /* 337 */
  char prefix[155];             /* 345 */
                                /* 500 */
};

union tar_buffer
{
  char               buffer[BLOCKSIZE];
  struct tar_header  header;
};

struct attr_item
{
  struct attr_item  *next;
  char              *fname;
  int                mode;
  time_t             time;
};

enum { 
	TGZ_EXTRACT,
	TGZ_LIST,
	TGZ_INVALID 
};

typedef enum { 
	HEADER_NONE,
	HEADER_SHORTNAME,
	HEADER_LONGNAME,
	GET_HEADER = HEADER_SHORTNAME | HEADER_LONGNAME
} vfsTarHeaderType_t;

#endif /* __VFS_TAR_H__ */



================================================
FILE: src/vfs_tcp.c
================================================
/*
 Copyright (C) 1996-1997 Id Software, Inc.
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 $Id: vfs_tcp.c,v 1.2 2007-09-28 05:21:45 dkure Exp $
*/

#include "quakedef.h"
#include "hash.h"
#include "common.h"
#include "fs.h"
#include "vfs.h"

//==========
// TCP file
//==========

typedef struct tcpfile_s {
	vfsfile_t funcs; // <= must be at top/begining of struct

	int		sock;

	char	readbuffer [5 * 65536];
	int		readbuffered;

	char	writebuffer[5 * 65536];
	int		writebuffered;

	struct tcpfile_s *next;

} tcpfile_t;


tcpfile_t *vfs_tcp_list = NULL;


void VFSTCP_Error(tcpfile_t *f)
{
	if (f->sock != INVALID_SOCKET)
	{
		closesocket(f->sock);
		f->sock = INVALID_SOCKET;
	}
}

int VFSTCP_ReadBytes (struct vfsfile_s *file, void *buffer, int bytestoread, vfserrno_t *err)
{
	tcpfile_t *tf = (tcpfile_t*)file;

	if (bytestoread < 0)
		Sys_Error("VFSTCP_ReadBytes: bytestoread < 0"); // ffs

	if (tf->sock != INVALID_SOCKET)
	{
		int len;

		if (sizeof(tf->readbuffer) == tf->readbuffered)
			len = -2; // full buffer
		else
			len = recv(tf->sock, tf->readbuffer + tf->readbuffered, sizeof(tf->readbuffer) - tf->readbuffered, 0);

		if (len == -2) {
			; // full buffer
		}
		else if (len == -1)
		{
			int e = qerrno;
	
			if (e == EWOULDBLOCK) {
				; // no data yet, nothing to do
			} else {

				if (e == ECONNABORTED || e == ECONNRESET)
					Com_Printf ("VFSTCP: Connection lost or aborted\n"); //server died/connection lost.
				else
					Com_Printf ("VFSTCP: Error (%i): %s\n", e, strerror(e));

				VFSTCP_Error(tf);
			}
		}
		else if (len == 0) {
			Com_Printf ("VFSTCP: EOF on socket\n");
			VFSTCP_Error(tf);
		}
		else
			tf->readbuffered += len;
	}

	if (bytestoread <= tf->readbuffered)
	{ // we have all required bytes
		if (bytestoread > 0) {
			memcpy(buffer, tf->readbuffer, bytestoread);
			tf->readbuffered -= bytestoread;
			memmove(tf->readbuffer, tf->readbuffer+bytestoread, tf->readbuffered);
		}

		if (err)
			*err = VFSERR_NONE; // we got required bytes somehow, so no error

		return bytestoread;
	}
	else
	{ // lack of data, but probably have at least something in buffer
		if (tf->readbuffered > 0 && buffer != NULL) {
			bytestoread = tf->readbuffered;
			memcpy(buffer, tf->readbuffer, tf->readbuffered);
			tf->readbuffered = 0;
		}
		else
			bytestoread = 0; // this help guess EOF

		if (err) // if socket is not closed we still have chance to get data, so no error
			*err = ((bytestoread || tf->sock != INVALID_SOCKET) ? VFSERR_NONE : VFSERR_EOF);

		return bytestoread;
	}
}

int VFSTCP_WriteBytes (struct vfsfile_s *file, const void *buffer, int bytestowrite)
{
	tcpfile_t *tf = (tcpfile_t*)file;
	int len;

	if (bytestowrite < 0)
		Sys_Error("VFSTCP_WriteBytes: bytestowrite < 0"); // ffs

	if (tf->sock == INVALID_SOCKET)
		return 0;

	if (bytestowrite > (int)sizeof(tf->writebuffer) - tf->writebuffered)
	{
		Com_Printf("VFSTCP: failed to write %d bytes, buffer overflow, closing link\n", bytestowrite);
		VFSTCP_Error(tf);
		return 0;
	}

	// append data
	memmove(tf->writebuffer + tf->writebuffered, buffer, bytestowrite);
	tf->writebuffered += bytestowrite;

	len = send(tf->sock, tf->writebuffer, tf->writebuffered, 0);

	if (len < 0)
	{
		int err = qerrno;

		if (err != EWOULDBLOCK/* FIXME: this is require winsock2.h on windows && err != EAGAIN && err != ENOTCONN */)
		{
			Com_Printf("VFSTCP: failed to write %d bytes, closing link, socket error %d\n", bytestowrite, err);
			VFSTCP_Error(tf);
			return 0;
		}
	}
	else if (len > 0)
	{
		tf->writebuffered -= len;
		memmove(tf->writebuffer, tf->writebuffer + len, tf->writebuffered);
	}
	else
	{
		// hm, zero bytes was sent
	}

	return bytestowrite; // well at least we put something in buffer, sure if bytestowrite not zero
}

int VFSTCP_Seek (struct vfsfile_s *file, unsigned long pos, int whence)
{
	Com_Printf("VFSTCP: seek is illegal, closing link\n");
	VFSTCP_Error((tcpfile_t*)file);
	return -1;
}

unsigned long VFSTCP_Tell (struct vfsfile_s *file)
{
	Com_Printf("VFSTCP: tell is illegal, closing link\n");
	VFSTCP_Error((tcpfile_t*)file);
	return 0;
}

unsigned long VFSTCP_GetLen (struct vfsfile_s *file)
{
	Com_Printf("VFSTCP: GetLen non functional\n");
	return 0;
}

void VFSTCP_Close (struct vfsfile_s *file)
{
	tcpfile_t *tmp, *prev;

	VFSTCP_Error((tcpfile_t*)file); // close socket

	// link out
	for (tmp = prev = vfs_tcp_list; tmp; tmp = tmp->next)
	{
		if (tmp == (tcpfile_t*)file)
		{
			if (tmp == vfs_tcp_list)
				vfs_tcp_list = tmp->next; // we remove from head a bit different
			else
				prev->next   = tmp->next; // removing not from head

			break;
		}

		prev = tmp;
	}

	if (!tmp)
		Com_Printf("VFSTCP: Close: not found in list\n");

	Q_free(file);
}

void VFSTCP_Tick(void)
{
	tcpfile_t *tmp;
	vfserrno_t err;

	for (tmp = vfs_tcp_list; tmp; tmp = tmp->next)
	{
		VFSTCP_ReadBytes  ((vfsfile_t*)tmp, NULL, 0, &err); // perform read in our internal buffer
		VFSTCP_WriteBytes ((vfsfile_t*)tmp, NULL, 0);		// perform write from our internall buffer

//		Com_Printf("r %d, w %d\n", tmp->readbuffered, tmp->writebuffered);
	}
}

vfsfile_t *FS_OpenTCP(char *name)
{
	tcpfile_t *newf;
	int sock;
//	int _true = true;
	netadr_t adr = {0};

	if (NET_StringToAdr(name, &adr))
	{
		sock = TCP_OpenStream(adr);
		if (sock == INVALID_SOCKET)
			return NULL;

//		if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&_true, sizeof(_true)) == -1)
//			Com_Printf ("FS_OpenTCP: setsockopt: (%i): %s\n", qerrno, strerror(qerrno));

		newf = Q_calloc(1, sizeof(tcpfile_t));
		memset(newf, 0, sizeof(tcpfile_t));
		newf->sock				= sock;
		newf->funcs.Close		= VFSTCP_Close;
		newf->funcs.Flush		= NULL;
		newf->funcs.GetLen		= VFSTCP_GetLen;
		newf->funcs.ReadBytes	= VFSTCP_ReadBytes;
		newf->funcs.Seek		= VFSTCP_Seek;
		newf->funcs.Tell		= VFSTCP_Tell;
		newf->funcs.WriteBytes	= VFSTCP_WriteBytes;
		newf->funcs.seekingisabadplan = true;

		// link in
		newf->next   = vfs_tcp_list;
		vfs_tcp_list = newf;

		return &newf->funcs;
	}
	else
		return NULL;
}

void VFS_TICK(void)
{
	VFSTCP_Tick(); // fill in/out our internall buffers (do read/write on socket)
}


================================================
FILE: src/vfs_zip.c
================================================
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *     
 * $Id: vfs_zip.c,v 1.12 2007-10-13 16:02:51 dkure Exp $
 *             
 */

#ifdef WITH_ZIP

#include "quakedef.h"
#include "hash.h"
#include "common.h"
#include "fs.h"
#include "vfs.h"

//===========================
// Unzip library interfacing
//===========================
// These functions provide IO support for the unzip library using our VFS layer

static void *FSZIP_ZOpenFile(void *fin, const char *filename, int mode) {
	vfsfile_t *vfs_fin = (vfsfile_t *)fin;

	// VFS-TODO Maybe need to increase reference count
	if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) {
	} else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) {
		Sys_Error("FSZIP_ZOpenFile: Unsupported file mode: MODE_EXISTING");
		return NULL;
	} else if (mode & ZLIB_FILEFUNC_MODE_CREATE) {
		Sys_Error("FSZIP_ZOpenFile: Unsupported file mode: write");
		return NULL;
	}

	return vfs_fin;
}

static unsigned long FSZIP_ZReadFile(void *fin, void *stream, void *buf, unsigned long size) {
	vfsfile_t *vfs_fin = (vfsfile_t *)stream;
	return VFS_READ(vfs_fin, buf, size, NULL);
}

static unsigned long FSZIP_ZWriteFile(void *fin, void *stream, const void *buf, unsigned long size) {
	vfsfile_t *vfs_fin = (vfsfile_t *)stream;
	return VFS_WRITE(vfs_fin, buf, size);
}

static long FSZIP_ZTellFile(void *fin, void *stream) {
	vfsfile_t *vfs_fin = (vfsfile_t *)stream;
	return VFS_TELL(vfs_fin);
}

static long FSZIP_ZSeekFile(void *fin, void *stream, unsigned long offset, int origin) {
	vfsfile_t *vfs_fin = (vfsfile_t *)stream;
	int fseek_origin;
	int r;

	switch (origin)
	{
	case ZLIB_FILEFUNC_SEEK_CUR: fseek_origin = SEEK_CUR; break;
	case ZLIB_FILEFUNC_SEEK_END: fseek_origin = SEEK_END; break;
	case ZLIB_FILEFUNC_SEEK_SET: fseek_origin = SEEK_SET; break;
	default: 
		Sys_Error("FSZIP_ZSeekFile: Unsupported seek origin: Unknown");
		return -1;
	}

	r = VFS_SEEK(vfs_fin, offset, fseek_origin);

	return r;
}

static int FSZIP_ZCloseFile(void *fin, void *stream) {
	// vfsfile_t *vfs_fin = (vfsfile_t *)stream;
	// VFS-TODO: Need to decrease references 
	// VFS_CLOSE(vfs_fin);
	return 0; 
}

static int FSZIP_ZErrorFileFile(void *fin, void *stream) {
	// vfsfile_t *vfs_fin = (vfsfile_t *)stream;
	// VFS-TODO: Need to get the error code somehow
	return 0;
}

static void FSZIP_CreteFileFuncs(zlib_filefunc_def *funcs) {
	if (funcs == NULL)
		return;

	funcs->zopen_file  = FSZIP_ZOpenFile;
	funcs->zread_file  = FSZIP_ZReadFile;
	funcs->zwrite_file = FSZIP_ZWriteFile;
	funcs->ztell_file  = FSZIP_ZTellFile;
	funcs->zseek_file  = FSZIP_ZSeekFile;
	funcs->zclose_file = FSZIP_ZCloseFile;
	funcs->zerror_file = FSZIP_ZErrorFileFile;
}

//==========================================
// ZIP file  (*.zip, *.pk3) - VFS Functions
//==========================================
typedef struct zipfile_s
{
	char filename[MAX_QPATH];
	unzFile handle;
	int		numfiles;
	packfile_t	*files;

#ifdef HASH_FILESYSTEM
	hashtable_t hash;
#endif

	zlib_filefunc_def zlib_funcs;

	vfsfile_t *raw;
	vfsfile_t *currentfile;	//our unzip.c can only handle one active file at any one time
							//so we have to keep closing and switching.
							//slow, but it works. most of the time we'll only have a single file open anyway.
	int references;	//and a reference count
} zipfile_t;

typedef struct {
	vfsfile_t funcs;

	vfsfile_t *defer;

	//in case we're forced away.
	zipfile_t *parent;
	int pos;
	int length;	//try and optimise some things
	int index;
	int startpos;
} vfszip_t;

// VFS-FIXME Need to figure what this function is trying to do
static void VFSZIP_MakeActive(vfszip_t *vfsz)
{
	int i;
	char buffer[8192];	//must be power of two

	if ((vfszip_t*)vfsz->parent->currentfile == vfsz)
		return;	//already us
	if (vfsz->parent->currentfile)
		unzCloseCurrentFile(vfsz->parent->handle);

	//unzLocateFileMy(vfsz->parent->handle, vfsz->index, vfsz->startpos);
	unzSetOffset(vfsz->parent->handle, vfsz->startpos);
	unzOpenCurrentFile(vfsz->parent->handle);

	if (vfsz->pos > 0)
	{
		Com_DPrintf("VFSZIP_MakeActive: Shockingly inefficient\n");

		//now we need to seek up to where we had previously gotten to.
		for (i = 0; i < vfsz->pos-sizeof(buffer); i++)
			unzReadCurrentFile(vfsz->parent->handle, buffer, sizeof(buffer));
		unzReadCurrentFile(vfsz->parent->handle, buffer, vfsz->pos - i);
	}

	vfsz->parent->currentfile = (vfsfile_t*)vfsz;
}

static int VFSZIP_ReadBytes (struct vfsfile_s *file, void *buffer, int bytestoread, vfserrno_t *err)
{
	int read;
	vfszip_t *vfsz = (vfszip_t*)file;

	if (vfsz->defer)
		return VFS_READ(vfsz->defer, buffer, bytestoread, err);

	VFSZIP_MakeActive(vfsz);
	read = unzReadCurrentFile(vfsz->parent->handle, buffer, bytestoread);

	if (err)
		*err = ((read || bytestoread <= 0) ? VFSERR_NONE : VFSERR_EOF);

	vfsz->pos += read;
	return read;
}

static int VFSZIP_WriteBytes (struct vfsfile_s *file, const void *buffer, int bytestoread)
{
	Sys_Error("VFSZIP_WriteBytes: Not supported\n");
	return 0;
}

// VFS-FIXME: What is going on here... why not just unzSetOffset
static int VFSZIP_Seek (struct vfsfile_s *file, unsigned long pos, int whence)
{
	vfszip_t *vfsz = (vfszip_t*)file;

	if (vfsz->defer)
		return VFS_SEEK(vfsz->defer, pos, whence);

	//This is *really* inefficient
	if (vfsz->parent->currentfile == file)
	{
		char buffer[8192];
		unsigned int chunk;
		unsigned int i;
		unsigned int length;

		vfsz->defer = FS_OpenTemp();
		if (vfsz->defer)
		{
			unzCloseCurrentFile(vfsz->parent->handle);
			vfsz->parent->currentfile = NULL;	//make it not us

			length = vfsz->length;
			i = 0;
			vfsz->pos = 0;
			VFSZIP_MakeActive(vfsz);
			while (1)
			{
				chunk = length - i;
				if (chunk > sizeof(buffer))
					chunk = sizeof(buffer);
				if (chunk == 0)
					break;
				unzReadCurrentFile(vfsz->parent->handle, buffer, chunk);
				VFS_WRITE(vfsz->defer, buffer, chunk);

				i += chunk;
			}
		}

		unzCloseCurrentFile(vfsz->parent->handle);
		vfsz->parent->currentfile = NULL;	//make it not us

		if (vfsz->defer)
			return VFS_SEEK(vfsz->defer, pos, SEEK_SET);
	}



	if (pos > vfsz->length)
		return -1;
	vfsz->pos = pos;

	return 0;
}

static unsigned long VFSZIP_Tell (struct vfsfile_s *file)
{
	vfszip_t *vfsz = (vfszip_t*)file;

	if (vfsz->defer)
		return VFS_TELL(vfsz->defer);

	return vfsz->pos;
}

static unsigned long VFSZIP_GetLen (struct vfsfile_s *file)
{
	vfszip_t *vfsz = (vfszip_t*)file;
	return vfsz->length;
}

static void FSZIP_ClosePath(void *handle);
static void VFSZIP_Close (struct vfsfile_s *file)
{
	vfszip_t *vfsz = (vfszip_t*)file;

	if (vfsz->parent->currentfile == file)
		vfsz->parent->currentfile = NULL;	//make it not us

	if (vfsz->defer)
		VFS_CLOSE(vfsz->defer);

	FSZIP_ClosePath(vfsz->parent);
	Q_free(vfsz);
}

static vfsfile_t *FSZIP_OpenVFS(void *handle, flocation_t *loc, char *mode)
{
	//int rawofs;
	zipfile_t *zip = handle;
	vfszip_t *vfsz;

	if (strcmp(mode, "rb"))
		return NULL; //urm, unable to write/append

	vfsz = Q_calloc(1, sizeof(vfszip_t));

	vfsz->parent = zip;
	vfsz->index = loc->index;
	vfsz->startpos = zip->files[loc->index].filepos;
	vfsz->length = loc->len;

	vfsz->funcs.ReadBytes  = strcmp(mode, "rb") ? NULL : VFSZIP_ReadBytes;
	vfsz->funcs.WriteBytes = strcmp(mode, "wb") ? NULL : VFSZIP_WriteBytes;
	vfsz->funcs.Seek       = VFSZIP_Seek;
	vfsz->funcs.seekingisabadplan = true;
	vfsz->funcs.Tell       = VFSZIP_Tell;
	vfsz->funcs.GetLen     = VFSZIP_GetLen;
	vfsz->funcs.Close      = VFSZIP_Close;
	if (loc->search)
		vfsz->funcs.copyprotected = loc->search->copyprotected;

	zip->references++;

	return (vfsfile_t*)vfsz;
}

//=============================================
// ZIP file  (*.zip, *.pk3) - Search Functions
//=============================================
static void FSZIP_PrintPath(void *handle)
{
	zipfile_t *zip = handle;

	if (zip->references != 1)
		Com_Printf("%s (%i)\n", zip->filename, zip->references-1);
	else
		Com_Printf("%s\n", zip->filename);
}

static void FSZIP_ClosePath(void *handle)
{
	zipfile_t *zip = handle;

	if (--zip->references > 0)
		return;	//not yet time

	unzClose(zip->handle);
	VFS_CLOSE(zip->raw);
	if (zip->files)
		Q_free(zip->files);
	Q_free(zip);
}
static void FSZIP_BuildHash(void *handle)
{
	zipfile_t *zip = handle;
	int i;

	for (i = 0; i < zip->numfiles; i++)
	{
		if (!Hash_GetInsensitive(filesystemhash, zip->files[i].name))
		{
			Hash_AddInsensitive(filesystemhash, zip->files[i].name, &zip->files[i]);
			fs_hash_files++;
		}
		else
			fs_hash_dups++;
	}
}

static qbool FSZIP_FLocate(void *handle, flocation_t *loc, const char *filename, void *hashedresult)
{
	packfile_t *pf  = (packfile_t *) hashedresult;
	zipfile_t  *zip = (zipfile_t  *) handle;
	int i;

// look through all the pak file elements

	if (pf)
	{	//is this a pointer to a file in this pak?
		if (pf < zip->files || pf >= zip->files + zip->numfiles)
			return false;	//was found in a different path
	}
	else
	{
		for (i=0 ; i<zip->numfiles ; i++)	//look for the file
		{
			if (!strcasecmp (zip->files[i].name, filename))
			{
				pf = &zip->files[i];
				break;
			}
		}
	}

	if (pf)
	{
		if (loc)
		{
			loc->index = pf - zip->files;
			strlcpy (loc->rawname, zip->filename, sizeof (loc->rawname));
			loc->offset = pf->filepos;
			loc->len = pf->filelen;
			loc->search = NULL;
	
			// VFS-FIXME: What is the purpose of the stuff below....
//			unzLocateFileMy (zip->handle, loc->index, zip->files[loc->index].filepos);
//			loc->offset = unzGetCurrentFileUncompressedPos(zip->handle);
//			if (loc->offset<0)
//			{	//file not found, or is compressed.
//				*loc->rawname = '\0';
//				loc->offset=0;
//			}
		}
		return true;
	}
	return false;
}


static void FSZIP_ReadFile(void *handle, flocation_t *loc, char *buffer)
{
	zipfile_t *zip = handle;
	int err;

	unzSetOffset(zip->handle, zip->files[loc->index].filepos);

	unzOpenCurrentFile (zip->handle);
	err = unzReadCurrentFile (zip->handle, buffer, zip->files[loc->index].filelen);
	unzCloseCurrentFile (zip->handle);

	if (err!=zip->files[loc->index].filelen)
	{
		Com_Printf ("Can't extract file \"%s:%s\" (corrupt)\n", zip->filename, zip->files[loc->index].name);
		return;
	}
	return;
}


static int FSZIP_EnumerateFiles (void *handle, char *match, int (*func)(char *, int, void *), void *parm)
{
	zipfile_t *zip = handle;
	int		num;

	for (num = 0; num < zip->numfiles; num++)
	{
		if (wildcmp(match, zip->files[num].name))
		{
			if (!func(zip->files[num].name, zip->files[num].filelen, parm))
				return false;
		}
	}

	return true;
}

/*
=================
COM_LoadZipFile

Takes an explicit (not game tree related) path to a pak file.

Loads the header and directory, adding the files at the beginning
of the list so they override previous pack files.
=================
*/
static void *FSZIP_LoadZipFile(vfsfile_t *packhandle, const char *desc)
{
	int i, r;

	zipfile_t *zip;
	packfile_t		*newfiles;
	zlib_filefunc_def *funcs = NULL;
	unz_global_info info;
	
	zip   = (zipfile_t *) Q_calloc(1, sizeof(*zip));
	strlcpy (zip->filename, desc, sizeof (zip->filename));
	FSZIP_CreteFileFuncs(&(zip->zlib_funcs));
	zip->raw = packhandle;
	zip->handle = unzOpen2(desc, funcs);
	if (!zip->handle) goto fail;

	if (unzGetGlobalInfo(zip->handle, &info) != UNZ_OK) goto fail;

	// Get the number of zip files
	zip->numfiles = info.number_entry;

	// Create a list of the number of files
	zip->files = newfiles = Q_malloc (zip->numfiles * sizeof(packfile_t));
	if (unzGoToFirstFile(zip->handle) != UNZ_OK) goto fail;
	for (i = 0; i < zip->numfiles; i++) {
		unz_file_info file_info;
		if (unzGetCurrentFileInfo(zip->handle, &file_info, newfiles[i].name, sizeof(newfiles[i].name), NULL, 0, NULL, 0) != UNZ_OK) goto fail;

		Q_strlwr(newfiles[i].name);
		newfiles[i].filelen = file_info.uncompressed_size;
		newfiles[i].filepos = unzGetOffset(zip->handle); // VFS-FIXME: Need to verify this
		r = unzGoToNextFile (zip->handle);
		if (r == UNZ_END_OF_LIST_OF_FILE) {
			break;
		} else if (r != UNZ_OK) {
			goto fail;
		}

	}
	
	zip->references = 1;
	zip->currentfile = NULL;

	return zip;

fail:
	// Q_free is safe to call on NULL pointers
	Q_free(funcs);
	Q_free(zip->handle);
	Q_free(zip->files);
	Q_free(zip);
	return NULL;
}

// VFS-FIXME: Don't really seem to know what this does
static int FSZIP_GeneratePureCRC(void *handle, int seed, int crctype)
{
	zipfile_t *zip = handle;
	unz_file_info   file_info;

	int *filecrcs;
	int numcrcs=0;
	int i;

	filecrcs = Q_malloc((zip->numfiles+1)*sizeof(int));
	filecrcs[numcrcs++] = seed;

	unzGoToFirstFile(zip->handle);
	for (i = 0; i < zip->numfiles; i++)
	{
		if (zip->files[i].filelen>0)
		{
			unzGetCurrentFileInfo (zip->handle, &file_info, NULL, 0, NULL, 0, NULL, 0);
			filecrcs[numcrcs++] = file_info.crc;
		}
		unzGoToNextFile (zip->handle);
	}

	if (crctype)
		return Com_BlockChecksum(filecrcs, numcrcs*sizeof(int));
	else
		return Com_BlockChecksum(filecrcs+1, (numcrcs-1)*sizeof(int));
}

searchpathfuncs_t zipfilefuncs = {
	FSZIP_PrintPath,
	FSZIP_ClosePath,
	FSZIP_BuildHash,
	FSZIP_FLocate,
	FSZIP_ReadFile,
	FSZIP_EnumerateFiles,
	FSZIP_LoadZipFile,
	FSZIP_GeneratePureCRC,
	FSZIP_OpenVFS
};

#endif // WITH_ZIP


================================================
FILE: src/vid.h
================================================
/*
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: vid.h,v 1.7 2007-01-07 21:48:47 disconn3ct Exp $
*/
// vid.h -- video driver defs

#ifndef EZQUAKE_VID_HEADER
#define EZQUAKE_VID_HEADER

#include <SDL.h>

#define VID_CBITS 6
#define VID_GRADES (1 << VID_CBITS)

// a pixel can be one, two, or four bytes
typedef byte pixel_t;

typedef struct vrect_s {
	int x,y,width,height;
	struct vrect_s *pnext;
} vrect_t;

typedef struct {
	pixel_t*        colormap;       // 256 * VID_GRADES size
	int             width;
	int             height;
	float           aspect;         // width / height -- < 0 is taller than wide
	int             numpages;
	int             recalc_refdef;  // if true, recalc vid-based stuff
	int             conwidth;
	int             conheight;
} viddef_t;

extern viddef_t vid; // global video state
extern unsigned short d_8to16table[256];
extern unsigned	d_8to24table[256];
extern unsigned d_8to24table2[256];
extern qbool vid_windowedmouse;
extern void (*vid_menudrawfn)(void);
extern void (*vid_menukeyfn)(int key);

void VID_SetPalette (unsigned char *palette);
// called at startup and after any gamma correction

void VID_Init (unsigned char *palette);
// Called at startup to set up translation tables, takes 256 8 bit RGB values
// the palette data will go away after the call, so it must be copied off if
// the video driver will need it again

int VID_ScaledWidth3D(void);
int VID_ScaledHeight3D(void);

int VID_RenderWidth2D(void);
int VID_RenderHeight2D(void);

void VID_Shutdown(qbool restart);
void VID_SoftRestart(void);
// Called at shutdown

// int VID_SetMode (int modenum, unsigned char *palette);
// sets the mode; only used by the Quake engine for resetting to mode 0 (the
// base mode) on memory allocation failures

qbool IN_QuakeMouseCursorRequired (void);
qbool IN_MouseTrackingRequired (void);

void VID_NotifyActivity(void);

void VID_SetCaption (char *text);

int VID_SetDeviceGammaRamp (unsigned short *ramps);
extern qbool vid_hwgamma_enabled;

extern int glx, gly, glwidth, glheight;

void VID_Minimize(void);
void VID_Restore(void);

qbool VID_VSyncIsOn(void);
qbool VID_VSyncLagFix(void);
qbool VID_VsyncLagEnabled(void);
void VID_RenderFrameEnd(void);

const SDL_DisplayMode *VID_GetDisplayMode(int index);
int VID_GetCurrentModeIndex(void);
int VID_GetModeIndexCount(void);

void VID_ReloadCheck(void);

#endif // EZQUAKE_VID_HEADER


================================================
FILE: src/vid_common_gl.c
================================================
/*
Copyright (C) 2002-2003 A Nourai

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// vid_common_gl.c -- Common code for vid_wgl.c and vid_glx.c

#include <SDL.h>

#include "quakedef.h"
#include "gl_model.h"
#include "gl_local.h"
#include "tr_types.h"
#include "image.h"
#include "r_texture.h"
#include "r_renderer.h"

int anisotropy_ext = 0;

qbool gl_mtexable = false;
int gl_textureunits = 1;

byte color_white[4] = {255, 255, 255, 255};
byte color_black[4] = {0, 0, 0, 255};

void GL_CheckMultiTextureExtensions(void);
static void OnChange_gl_ext_texture_compression(cvar_t *, char *, qbool *);

static cvar_t gl_ext_texture_compression = {"gl_ext_texture_compression", "0", CVAR_SILENT, OnChange_gl_ext_texture_compression};

/************************************* EXTENSIONS *************************************/

static qbool GL_InitialiseRenderer(void)
{
	qbool shaders_supported = false;

	glConfig.supported_features = 0;
	glConfig.broken_features = 0;

	GL_InitialiseFramebufferHandling();
	GL_LoadProgramFunctions();
	GL_LoadStateFunctions();
	GL_LoadTextureManagementFunctions();
	GL_LoadDrawFunctions();
	GL_InitialiseDebugging();

	shaders_supported = GL_Supported(R_SUPPORT_MODERN_OPENGL_REQUIREMENTS);
	if ((glConfig.preferred_format == 0 && GL_VersionAtLeast(1, 2)) || glConfig.preferred_format == GL_BGRA) {
		glConfig.supported_features |= R_SUPPORT_BGRA_LIGHTMAPS;
	}
	if ((glConfig.preferred_type == 0 && GL_VersionAtLeast(1, 2)) || glConfig.preferred_type == GL_UNSIGNED_INT_8_8_8_8_REV) {
		glConfig.supported_features |= R_SUPPORT_INT8888R_LIGHTMAPS;
	}

	R_TraceAPI("Supported features:");
	if (glConfig.supported_features & R_SUPPORT_FRAMEBUFFERS) {
		R_TraceAPI("... rendering to framebuffers");
	}
	if (glConfig.supported_features & R_SUPPORT_RENDERING_SHADERS) {
		R_TraceAPI("... rendering using shaders");
	}
	if (glConfig.supported_features & R_SUPPORT_COMPUTE_SHADERS) {
		R_TraceAPI("... non-rendering shaders");
	}
	if (glConfig.supported_features & R_SUPPORT_PRIMITIVERESTART) {
		R_TraceAPI("... primitive restart indexes");
	}
	if (glConfig.supported_features & R_SUPPORT_MULTITEXTURING) {
		R_TraceAPI("... multi-texturing (some people still disable this...)");
	}
	if (glConfig.supported_features & R_SUPPORT_IMAGE_PROCESSING) {
		R_TraceAPI("... reading/writing to images");
	}
	if (glConfig.supported_features & R_SUPPORT_TEXTURE_SAMPLERS) {
		R_TraceAPI("... texture samplers");
	}
	if (glConfig.supported_features & R_SUPPORT_TEXTURE_ARRAYS) {
		R_TraceAPI("... 3D images (texture arrays)");
	}
	if (glConfig.supported_features & R_SUPPORT_INDIRECT_RENDERING) {
		R_TraceAPI("... indirect rendering (api parameters stored in buffer)");
	}
	if (glConfig.supported_features & R_SUPPORT_INSTANCED_RENDERING) {
		R_TraceAPI("... instanced rendering");
	}
	if (glConfig.supported_features & R_SUPPORT_FRAMEBUFFERS_BLIT) {
		R_TraceAPI("... blit from one framebuffer to another");
	}
	if (glConfig.supported_features & R_SUPPORT_BGRA_LIGHTMAPS) {
		R_TraceAPI("... BGRA lightmaps (if optimal format)");
	}
	if (glConfig.supported_features & R_SUPPORT_INT8888R_LIGHTMAPS) {
		R_TraceAPI("... Lightmaps uploaded as UINT8888R rather than UNSIGNED_BYTE");
	}
	if (glConfig.supported_features & R_SUPPORT_CUBE_MAPS) {
		R_TraceAPI("... cube maps");
	}
	if (glConfig.supported_features & R_SUPPORT_SEAMLESS_CUBEMAPS) {
		R_TraceAPI("... filtering works across faces of the cubemap");
	}
	if (glConfig.supported_features & R_SUPPORT_DEPTH32F) {
		R_TraceAPI("... floating point 32-bit depth buffers");
	}
	if (glConfig.supported_features & R_SUPPORT_FRAMEBUFFERS_SRGB) {
		R_TraceAPI("... framebuffers support sRGB");
	}
	if (glConfig.supported_features & R_SUPPORT_IMMEDIATEMODE) {
		R_TraceAPI("... immediate-mode rendering (doesn't require programs)");
	}
	if (glConfig.supported_features & R_SUPPORT_FOG) {
		R_TraceAPI("... fog");
	}

	if (glConfig.broken_features) {
		R_TraceAPI("Broken features:");
		if (GL_WorkaroundNeeded(R_BROKEN_GLBINDTEXTURES)) {
			R_TraceAPI("... glBindTextures() - not using");
		}
		if (GL_WorkaroundNeeded(R_BROKEN_PREFERMULTIDRAW)) {
			R_TraceAPI("... glDrawArray() - using glMultiDrawArrays()");
		}
	}

	if (R_UseModernOpenGL() && shaders_supported) {
		Con_Printf("&c0f0Renderer&r: OpenGL (GLSL)\n");
		return true;
	}
	else if (R_UseImmediateOpenGL()) {
		Con_Printf("&c0f0Renderer&r: OpenGL (classic)\n");
		return true;
	}

	return false;
}

static void OnChange_gl_ext_texture_compression(cvar_t *var, char *string, qbool *cancel)
{
	if (renderer.TextureCompressionSet) {
		renderer.TextureCompressionSet(Q_atof(string));
	}
}

/************************************** GL INIT **************************************/

static qbool GL_BrokenAmdVersion(void)
{
	if (COM_CheckParm(cmdline_param_client_no_amd_fix)) {
		// user has asked for driver detection to be turned off
		return false;
	}

	if (!strstr((const char*)glConfig.vendor_string, "ATI")) {
		return false;
	}

	// <anything>.13399 <anything>, might get different version number depending on what we asked for previously
	return strstr((const char*)glConfig.version_string, ".13399 ") != NULL;
}

static void GL_PopulateConfig(void)
{
	int r, g, b, a;

	SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &r);
	SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &g);
	SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &b);
	SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &a);

	glConfig.colorBits = r + g + b + a;
	SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &glConfig.depthBits);
	SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &glConfig.stencilBits);

	glConfig.vendor_string = glGetString(GL_VENDOR);
	glConfig.renderer_string = glGetString(GL_RENDERER);
	glConfig.version_string = glGetString(GL_VERSION);

	if (glConfig.version_string) {
		const char* dot = strchr((const char*)glConfig.version_string, '.');
		glConfig.majorVersion = atoi((const char*)glConfig.version_string);
		glConfig.minorVersion = (dot ? atoi(dot + 1) : 0);
	}
	else {
		glConfig.majorVersion = 2;
		glConfig.minorVersion = 1;
	}

	if (GL_VersionAtLeast(3, 2)) {
		GLint profile = 0;
		glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &profile);
		glConfig.coreProfile = (profile & GL_CONTEXT_CORE_PROFILE_BIT) != 0;
	}
	else {
		glConfig.coreProfile = false;
	}

	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &glConfig.gl_max_size_default);
	if (R_UseImmediateOpenGL()) {
		if (GL_VersionAtLeast(2, 1)) {
			glGetIntegerv(GL_MAX_TEXTURE_UNITS, &glConfig.texture_units);
		}
		else if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {
			glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &glConfig.texture_units);
		}
		else {
			glConfig.texture_units = 1;
		}
	}
	else {
		glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &glConfig.texture_units);
	}
	glConfig.texture_units = max(glConfig.texture_units, 1);

	glConfig.max_3d_texture_size = 0;
	glConfig.glsl_version = (unsigned char*)"0";
	glConfig.max_texture_depth = 0;
	glConfig.uniformBufferOffsetAlignment = 0;
	glConfig.shaderStorageBufferOffsetAlignment = 0;
	if (GL_VersionAtLeast(2, 0)) {
		glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, &glConfig.max_3d_texture_size);
		glConfig.glsl_version = glGetString(GL_SHADING_LANGUAGE_VERSION);

		if (GL_VersionAtLeast(3, 0)) {
			glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &glConfig.max_texture_depth);

			if (GL_VersionAtLeast(3, 1)) {
				glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &glConfig.uniformBufferOffsetAlignment);

				if (GL_VersionAtLeast(4, 3)) {
					glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &glConfig.shaderStorageBufferOffsetAlignment);
				}
			}
		}
	}

	R_TraceAPI("---Config---");
	if (glConfig.renderer_string) {
		R_TraceAPI("Renderer: %s", glConfig.renderer_string);
	}
	if (glConfig.vendor_string) {
		R_TraceAPI("Vendor: %s", glConfig.vendor_string);
	}
	if (glConfig.version_string) {
		R_TraceAPI("Version: %s", glConfig.version_string);
	}
	if (glConfig.glsl_version) {
		R_TraceAPI("GLSL: %s", glConfig.glsl_version);
	}

	R_TraceAPI("OpenGL version: %d.%d", glConfig.majorVersion, glConfig.minorVersion);
	R_TraceAPI("Color/depth/stencil: %d/%d/%d", glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits);
	R_TraceAPI("Hardware type: %d", glConfig.hardwareType);
	R_TraceAPI("Max sizes: %d %d %d", glConfig.gl_max_size_default, glConfig.max_3d_texture_size, glConfig.max_texture_depth);
	R_TraceAPI("Texture units: %d", glConfig.texture_units);
	R_TraceAPI("Alignments: ubo(%d) ssb(%d)", glConfig.uniformBufferOffsetAlignment, glConfig.shaderStorageBufferOffsetAlignment);

	glConfig.amd_issues = GL_BrokenAmdVersion();
}

// meag: EXT => ARB didn't change value of constants, so still using _EXT versions
static void GL_CheckAnisotropyExtensions(void)
{
	anisotropy_ext = 0;
	R_TraceAPI("Checking for anisotropic filtering...");
	if (GL_VersionAtLeast(4, 6) || SDL_GL_ExtensionSupported("GL_ARB_texture_filter_anisotropic") || SDL_GL_ExtensionSupported("GL_EXT_texture_filter_anisotropic")) {
		int gl_anisotropy_factor_max;

		anisotropy_ext = 1;

		glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_anisotropy_factor_max);

		Com_Printf_State(PRINT_OK, "Anisotropic Filtering Extension Found (%d max)\n", gl_anisotropy_factor_max);
		R_TraceAPI("... filtering extension found (max level %d)", gl_anisotropy_factor_max);
	}
}

static void GL_CheckTextureCompressionExtensions(void)
{
	R_TraceAPI("Checking for texture compression...");
	if (GL_VersionAtLeast(1, 3) || SDL_GL_ExtensionSupported("GL_ARB_texture_compression")) {
		Com_Printf_State(PRINT_OK, "Texture compression extensions found\n");
		R_TraceAPI("... texture compression extensions found");
		Cvar_SetCurrentGroup(CVAR_GROUP_TEXTURES);
		Cvar_Register(&gl_ext_texture_compression);
		Cvar_ResetCurrentGroup();
	}
}

static void GL_CheckNPOTTextureExtensions(void)
{
	qbool supported = false;

	if (!COM_CheckParm(cmdline_param_client_no_npot_textures)) {
		supported = (GL_VersionAtLeast(2, 0) || SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two"));
	}

	R_SetNonPowerOfTwoSupport(supported);
	Com_Printf_State(PRINT_OK, "GL_ARB_texture_non_power_of_two extension %s\n", supported ? "found" : "not found");
	R_TraceAPI("Non-power-of-two textures: %s", supported ? "supported" : "not supported (!)");
}

static void GL_CheckExtensions(void)
{
	GL_CheckMultiTextureExtensions();
	GL_CheckAnisotropyExtensions();
	GL_CheckTextureCompressionExtensions();
	GL_CheckNPOTTextureExtensions();
}

void GL_Init(void)
{
	GL_PopulateConfig();

	if (!GL_InitialiseRenderer()) {
		Sys_Error("Failed to initialise graphics renderer");
	}

	GL_CheckExtensions();

#if !defined( _WIN32 ) && !defined( __linux__ ) /* we print this in different place on WIN and Linux */
	{
		/* FIXME/TODO: FreeBSD too? */
		Com_Printf_State(PRINT_INFO, "GL_VENDOR: %s\n", (const char*)glGetString(GL_VENDOR));
		Com_Printf_State(PRINT_INFO, "GL_RENDERER: %s\n", (const char*)glGetString(GL_RENDERER));
		Com_Printf_State(PRINT_INFO, "GL_VERSION: %s\n", (const char*)glGetString(GL_VERSION));
		if (COM_CheckParm(cmdline_param_client_printopenglextensions)) {
			const char* gl_extensions = "";
			if (R_UseModernOpenGL()) {
				gl_extensions = "(using modern OpenGL)\n";
			}
			else {
				gl_extensions = (const char*)glGetString(GL_EXTENSIONS);
			}
			Com_Printf_State(PRINT_INFO, "GL_EXTENSIONS: %s\n", gl_extensions);
		}
	}
#endif
}


================================================
FILE: src/vid_sdl2.c
================================================
/*
   ===========================================================================
   Copyright (C) 1999-2005 Id Software, Inc.

   This file is part of Quake III Arena source code.

   Quake III Arena source code is free software; you can redistribute it
   and/or modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the License,
   or (at your option) any later version.

   Quake III Arena source code is distributed in the hope that it will be
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with Foobar; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
   ===========================================================================

 */

#include "quakedef.h"

#include <SDL.h>
#include <SDL_syswm.h>

#ifdef X11_GAMMA_WORKAROUND
#include <X11/extensions/xf86vmode.h>
#endif

#ifdef _WIN32
#include <windows.h>

void Sys_ActiveAppChanged (void);
#endif

#ifdef __APPLE__
#include <OpenGL/gl.h>
#include <OpenGL/OpenGL.h>
#include "in_osx.h"
#else
#include <GL/gl.h>
#endif

#include "ezquake-icon.c"
#include "keys.h"
#include "tr_types.h"
#include "input.h"
#include "rulesets.h"
#include "utils.h"
#include "textencoding.h"

#include "r_local.h"
#include "gl_framebuffer.h"
#include "r_texture.h"
#include "qmb_particles.h"
#include "r_state.h"
#include "r_buffers.h"
#include "r_renderer.h"
#include "r_program.h"

SDL_GLContext GLM_SDL_CreateContext(SDL_Window* window);
SDL_GLContext GLC_SDL_CreateContext(SDL_Window* window);

#ifdef __linux__
// This is hack to ignore keyboard events we receive between FOCUS_GAINED & TAKE_FOCUS
// Without it the keys you press to switch back to ezQuake will fire, which is probably not desired
// Affects X11 only - might also be needed on FreeBSD/OSX?
static qbool block_keyboard_input = false;
#endif
#ifdef __APPLE__
static int deadkey_modifiers_held_down = 0;
static cvar_t in_ignore_deadkeys = { "in_ignore_deadkeys", "1", CVAR_SILENT };

#define APPLE_RALT_HELD_DOWN 1
#define APPLE_LALT_HELD_DOWN 2
#endif

#define	WINDOW_CLASS_NAME	"ezQuake"

#define VID_RENDERER_MIN 0
#define VID_RENDERER_MAX 1

#define VID_MULTISAMPLED   1
#define VID_ACCELERATED    2
#define VID_DEPTHBUFFER24  4
#define VID_GAMMACORRECTED 8

/* FIXME: This should be in a header file and it probably shouldn't be called TP_
 *        since there are a lot of triggers that has nothing to do with teamplay.
 *        Should probably split them
 */
extern void TP_ExecTrigger(const char *);

static void in_raw_callback(cvar_t *var, char *value, qbool *cancel);
static void in_grab_windowed_mouse_callback(cvar_t *var, char *value, qbool *cancel);
static void conres_changed_callback (cvar_t *var, char *string, qbool *cancel);
static void framebuffer_smooth_changed_callback(cvar_t* var, char* string, qbool* cancel);
static void vid_reload_callback(cvar_t* var, char* string, qbool* cancel);
static void GrabMouse(qbool grab, qbool raw);
static void HandleEvents(void);
static void VID_UpdateConRes(void);
void IN_Restart_f(void);

static SDL_Window       *sdl_window;
static SDL_GLContext    sdl_context;

glconfig_t glConfig;
qbool vid_hwgamma_enabled = false;
static qbool mouse_active = false;
qbool mouseinitialized = false; // unfortunately non static, lame...
int mx, my;
static int old_x = 0, old_y = 0;
extern double cursor_x, cursor_y;

qbool ActiveApp = true;
qbool Minimized = false;

double vid_vsync_lag;
double vid_last_swap_time;

static SDL_DisplayMode *modelist;
static int modelist_count;

#ifdef X11_GAMMA_WORKAROUND
static unsigned short sysramps[3*4096];
#endif

qbool vid_initialized = false;

static int last_working_width;
static int last_working_height;
static int last_working_hz;
static int last_working_display;
static qbool last_working_values = false;

// deferred events (Sys_SendDeferredKeyEvents)
static qbool wheelup_deferred = false;
static qbool wheeldown_deferred = false;

// vid_reload
#define CVAR_RELOAD_GFX_COMMAND "vid_reload"
static qbool vid_reload_pending = false;
static cvar_t vid_reload_auto = { "vid_reload_auto", "1", 0, vid_reload_callback };

static void vid_reload_callback(cvar_t* var, char* string, qbool* cancel)
{
	vid_reload_pending = false;

	if (atoi(string) != 0) {
		vid_reload_pending = Cvar_AnyModified(CVAR_RELOAD_GFX);
	}
}

//
// OS dependent cvar defaults
//
#ifdef __APPLE__
	#define CVAR_DEF1 "0"
#else
	#define CVAR_DEF1 "1"
#endif

#if defined(__linux__) || defined(__FreeBSD__)
	#define CVAR_DEF2 "0"
#else
	#define CVAR_DEF2 "1"
#endif

//
// cvars
//
extern cvar_t sys_inactivesleep;

// latched variables that can only change over a restart
cvar_t r_colorbits                = {"vid_colorbits",              "0",       CVAR_LATCH_GFX };
cvar_t r_24bit_depth              = {"vid_24bit_depth",            "1",       CVAR_LATCH_GFX };
cvar_t r_fullscreen               = {"vid_fullscreen",             "1",       CVAR_LATCH_GFX };
cvar_t r_displayRefresh           = {"vid_displayfrequency",       "0",       CVAR_LATCH_GFX | CVAR_AUTO };
cvar_t vid_displayNumber          = {"vid_displaynumber",          "0",       CVAR_LATCH_GFX | CVAR_AUTO };
cvar_t vid_usedesktopres          = {"vid_usedesktopres",          "1",       CVAR_LATCH_GFX | CVAR_AUTO };
cvar_t vid_win_borderless         = {"vid_win_borderless",         "0",       CVAR_LATCH_GFX };
cvar_t vid_width                  = {"vid_width",                  "0",       CVAR_LATCH_GFX | CVAR_AUTO };
cvar_t vid_height                 = {"vid_height",                 "0",       CVAR_LATCH_GFX | CVAR_AUTO };
cvar_t vid_win_width              = {"vid_win_width",              "640",     CVAR_LATCH_GFX };
cvar_t vid_win_height             = {"vid_win_height",             "480",     CVAR_LATCH_GFX };
#ifdef __APPLE__
cvar_t vid_hwgammacontrol         = {"vid_hwgammacontrol",         "2",       CVAR_LATCH_GFX };
#else
cvar_t vid_hwgammacontrol         = {"vid_hwgammacontrol",         "0",       CVAR_LATCH_GFX };
#endif
cvar_t vid_minimize_on_focus_loss = {"vid_minimize_on_focus_loss", CVAR_DEF1, CVAR_LATCH_GFX };
// TODO: Move the in_* cvars
cvar_t in_raw                     = {"in_raw",                     "1",       CVAR_ARCHIVE | CVAR_SILENT, in_raw_callback};
cvar_t in_grab_windowed_mouse     = {"in_grab_windowed_mouse",     "1",       CVAR_ARCHIVE | CVAR_SILENT, in_grab_windowed_mouse_callback};
cvar_t vid_grab_keyboard          = {"vid_grab_keyboard",          "0",       CVAR_LATCH_GFX }; /* Needs vid_restart thus vid_.... */
#ifdef EZ_MULTIPLE_RENDERERS
cvar_t vid_renderer               = {"vid_renderer",               "1",       CVAR_LATCH_GFX };
#endif
cvar_t vid_gl_core_profile        = {"vid_gl_core_profile",        "0",       CVAR_LATCH_GFX };

#ifdef X11_GAMMA_WORKAROUND
cvar_t vid_gamma_workaround       = {"vid_gamma_workaround",       "1",       CVAR_LATCH_GFX };
#endif

cvar_t in_release_mouse_modes     = {"in_release_mouse_modes",     "2",       CVAR_SILENT };
cvar_t in_ignore_touch_events     = {"in_ignore_touch_events",     "1",       CVAR_SILENT };
#ifdef __linux__
cvar_t in_ignore_unfocused_keyb   = {"in_ignore_unfocused_keyb",   "0",       CVAR_SILENT };
#endif
cvar_t vid_vsync_lag_fix          = {"vid_vsync_lag_fix",          "0"                    };
cvar_t vid_vsync_lag_tweak        = {"vid_vsync_lag_tweak",        "1.0"                  };
cvar_t r_swapInterval             = {"vid_vsync",                  "0",       CVAR_SILENT };
cvar_t r_win_save_pos             = {"vid_win_save_pos",           "1",       CVAR_SILENT };
cvar_t r_win_save_size            = {"vid_win_save_size",          "1",       CVAR_SILENT };
cvar_t vid_xpos                   = {"vid_xpos",                   "3",       CVAR_SILENT };
cvar_t vid_ypos                   = {"vid_ypos",                   "39",      CVAR_SILENT };
cvar_t vid_win_displayNumber      = {"vid_win_displaynumber",      "0",       CVAR_SILENT };
cvar_t r_conwidth                 = {"vid_conwidth",               "0",       CVAR_NO_RESET | CVAR_SILENT | CVAR_AUTO, conres_changed_callback };
cvar_t r_conheight                = {"vid_conheight",              "0",       CVAR_NO_RESET | CVAR_SILENT | CVAR_AUTO, conres_changed_callback };
cvar_t r_conscale                 = {"vid_conscale",               "2.0",     CVAR_NO_RESET | CVAR_SILENT, conres_changed_callback };
cvar_t vid_flashonactivity        = {"vid_flashonactivity",        "1",       CVAR_SILENT };
cvar_t r_verbose                  = {"vid_verbose",                "0",       CVAR_SILENT };
cvar_t r_showextensions           = {"vid_showextensions",         "0",       CVAR_SILENT };
cvar_t gl_multisamples            = {"gl_multisamples",            "0",       CVAR_LATCH_GFX | CVAR_AUTO }; // It's here because it needs to be registered before window creation
cvar_t vid_gammacorrection        = {"vid_gammacorrection",        "0",       CVAR_LATCH_GFX };
#ifdef __APPLE__
cvar_t vid_software_palette       = {"vid_software_palette",       "0",       CVAR_NO_RESET | CVAR_LATCH_GFX };
#else
cvar_t vid_software_palette       = {"vid_software_palette",       "1",       CVAR_NO_RESET | CVAR_LATCH_GFX };
#endif

cvar_t vid_framebuffer             = {"vid_framebuffer",               "0",       CVAR_NO_RESET | CVAR_LATCH_GFX, conres_changed_callback };
cvar_t vid_framebuffer_blit        = {"vid_framebuffer_blit",          "0",       CVAR_NO_RESET };
cvar_t vid_framebuffer_width       = {"vid_framebuffer_width",         "0",       CVAR_NO_RESET | CVAR_AUTO, conres_changed_callback };
cvar_t vid_framebuffer_height      = {"vid_framebuffer_height",        "0",       CVAR_NO_RESET | CVAR_AUTO, conres_changed_callback };
cvar_t vid_framebuffer_scale       = {"vid_framebuffer_scale",         "1",       CVAR_NO_RESET, conres_changed_callback };
cvar_t vid_framebuffer_depthformat = {"vid_framebuffer_depthformat",   "0",       CVAR_NO_RESET | CVAR_LATCH_GFX };
cvar_t vid_framebuffer_hdr         = {"vid_framebuffer_hdr",           "0",       CVAR_NO_RESET | CVAR_LATCH_GFX };
cvar_t vid_framebuffer_hdr_tonemap = {"vid_framebuffer_hdr_tonemap",   "0" };
cvar_t vid_framebuffer_smooth      = {"vid_framebuffer_smooth",        "1",       CVAR_NO_RESET, framebuffer_smooth_changed_callback };
cvar_t vid_framebuffer_sshotmode   = {"vid_framebuffer_sshotmode",     "0" };
cvar_t vid_framebuffer_multisample = {"vid_framebuffer_multisample",   "0" };
cvar_t vid_framebuffer_fxaa        = {"vid_framebuffer_fxaa",          "0" };

//
// function declaration
//

// True if we need to release the mouse and let the OS show cursor again
static qbool IN_OSMouseCursorRequired(void)
{
	// Explicit check here for key_game... really setting all modes is equivalent to "in_grab_windowed_mouse 0"
	qbool in_os_cursor_mode = (key_dest != key_game || cls.demoplayback) && (in_release_mouse_modes.integer & (1 << key_dest));

	// Windowed & (not-grabbing mouse | in OS cursor mode)
	return (!r_fullscreen.value && (!in_grab_windowed_mouse.value || in_os_cursor_mode));
}

// True if we're in a mode where we need to keep track of mouse movement
qbool IN_MouseTrackingRequired(void)
{
	return (key_dest == key_menu || key_dest == key_hudeditor || key_dest == key_demo_controls);
}

// True if we need to display the internal Quake cursor to track the mouse
qbool IN_QuakeMouseCursorRequired(void)
{
	return mouse_active && IN_MouseTrackingRequired() && !IN_OSMouseCursorRequired();
}

static void IN_SnapMouseBackToCentre(void)
{
	SDL_WarpMouseInWindow(sdl_window, glConfig.vidWidth / 2, glConfig.vidHeight / 2);
	old_x = glConfig.vidWidth / 2;
	old_y = glConfig.vidHeight / 2;
}

static void in_raw_callback(cvar_t *var, char *value, qbool *cancel)
{
	if ((var == &in_raw) && (atoi(value) != in_raw.value)) {
		Cvar_SetValue(&in_raw, atoi(value));
		IN_Restart_f();
	}
}

static void in_grab_windowed_mouse_callback(cvar_t *val, char *value, qbool *cancel)
{
	GrabMouse((atoi(value) > 0 ? true : false), in_raw.integer);
}

static void GrabMouse(qbool grab, qbool raw)
{
	if ((grab && mouse_active && raw == in_raw.integer) || (!grab && !mouse_active) || !mouseinitialized || !sdl_window) {
		return;
	}

	if (!r_fullscreen.integer && in_grab_windowed_mouse.integer == 0) {
		if (!mouse_active) {
			return;
		}
		grab = 0;
	}

	// set initial position
	if (!raw && grab) {
		// the first getState() will still return the old values so snapping back doesn't work...
		// ... open problem, people will get a jump if releasing mouse when re-grabbing with in_raw 0
		IN_SnapMouseBackToCentre();
	}

	SDL_SetWindowGrab(sdl_window, grab ? SDL_TRUE : SDL_FALSE);
	SDL_SetRelativeMouseMode((raw && grab) ? SDL_TRUE : SDL_FALSE);
	SDL_GetRelativeMouseState(NULL, NULL);

	// never show real cursor in fullscreen
	if (r_fullscreen.integer) {
		SDL_ShowCursor(SDL_DISABLE);
	} else {
		SDL_ShowCursor(grab ? SDL_DISABLE : SDL_ENABLE);
	}

	// Force rewrite of it
	SDL_SetCursor(NULL);

	mouse_active = grab;
}

void IN_StartupMouse(void)
{
	Cvar_Register(&in_raw);
	Cvar_Register(&in_grab_windowed_mouse);
	Cvar_Register(&in_release_mouse_modes);
	Cvar_Register(&in_ignore_touch_events);
#ifdef __APPLE__
	Cvar_Register(&in_ignore_deadkeys);

	if (in_raw.integer > 0) {
		if (OSX_Mouse_Init() != 0) {
			Com_Printf("warning: failed to initialize raw input mouse thread...\n");
			Cvar_SetValue(&in_raw, 0);
		}
	}
#endif

	mouseinitialized = true;

	Com_Printf("%s mouse input initialized\n", in_raw.integer > 0 ? "RAW" : "SDL");
	if (in_raw.integer == 0) {
		IN_SnapMouseBackToCentre();
	}
}

void IN_ActivateMouse(void)
{
	GrabMouse(true, in_raw.integer);
}

void IN_DeactivateMouse(void)
{
	GrabMouse(false, in_raw.integer);
}

static void IN_Frame(void)
{
	if (!sdl_window) {
		return;
	}

	HandleEvents();

	if (!ActiveApp || Minimized || IN_OSMouseCursorRequired()) {
		IN_DeactivateMouse();
		return;
	}
	else {
		IN_ActivateMouse();
	}

	if (mouse_active && SDL_GetRelativeMouseMode()) {
#ifdef __APPLE__
		OSX_Mouse_GetMouseMovement(&mx, &my);
#else
		SDL_GetRelativeMouseState(&mx, &my);
#endif
	}
	
}

void Sys_SendDeferredKeyEvents(void)
{
	if (wheelup_deferred) {
		Key_Event(K_MWHEELUP, false);
		wheelup_deferred = false;
	}
	if (wheeldown_deferred) {
		Key_Event(K_MWHEELDOWN, false);
		wheeldown_deferred = false;
	}
}

void Sys_SendKeyEvents(void)
{
	IN_Frame();

	if (sys_inactivesleep.integer > 0) {
		// Yield the CPU a little
		if ((ISPAUSED && (!ActiveApp)) || Minimized || block_drawing) {
			if (!cls.download) {
				SDL_Delay(50);
			}
			scr_skipupdate = 1; // no point to draw anything
		} else if (!ActiveApp) { // Delay a bit less if just not active window
			if (!cls.download) {
				SDL_Delay(20);
			}
		}
	}
}

void IN_Restart_f(void)
{
	qbool old_mouse_active = mouse_active;

	IN_Shutdown();
	IN_Init();

	// if mouse was active before restart, try to re-activate it
	if (old_mouse_active) {
		IN_ActivateMouse();
	}
}

// Converts co-ordinates for the whole desktop to co-ordinates for a specific display
static void VID_RelativePositionFromAbsolute(int* x, int* y, int* display)
{
	int displays = SDL_GetNumVideoDisplays();
	int i = 0;

	for (i = 0; i < displays; ++i)
	{
		SDL_Rect bounds;

		if (SDL_GetDisplayBounds(i, &bounds) == 0)
		{
			if (*x >= bounds.x && *x < bounds.x + bounds.w && *y >= bounds.y && *y < bounds.y + bounds.h)
			{
				*x = *x - bounds.x;
				*y = *y - bounds.y;
				*display = i;
				return;
			}
		}
	}

	*display = 0;
}

// Converts co-ordinates for a specific display to those for whole desktop
static void VID_AbsolutePositionFromRelative(int* x, int* y, int* display)
{
	SDL_Rect bounds;
	
	// Try and get bounds for the specified display - default back to main display if there's an issue
	if (SDL_GetDisplayBounds(*display, &bounds))
	{
		*display = 0;
		if (SDL_GetDisplayBounds(*display, &bounds))
		{
			// Still an issue - reset back to top-left of screen
			Com_Printf("Error detecting resolution...\n");
			*x = *y = 0;
			return;
		}
	}

	// Adjust co-ordinates, making sure some of the window will always be visible
	*x = bounds.x + min(*x, bounds.w - 30);
	*y = bounds.y + min(*y, bounds.h - 30);
}

static int VID_SetDeviceGammaRampReal(unsigned short *ramps)
{
#ifdef X11_GAMMA_WORKAROUND
	static short once = 1;
	static short gamma_works = 0;

	if (!vid_gamma_workaround.integer) {
		SDL_SetWindowGammaRamp(sdl_window, ramps, ramps + 4096, ramps + (2 * 4096));
		vid_hwgamma_enabled = true;
		return 0;
	}

	if (once) {
		if (glConfig.gammacrap.size < 0 || glConfig.gammacrap.size > 4096) {
			Com_Printf("error: gamma size is broken, gamma won't work (reported size %d)\n", glConfig.gammacrap.size);
			once = 0;
			return 0;
		}
		if (!XF86VidModeGetGammaRamp(glConfig.gammacrap.display, glConfig.gammacrap.screen, glConfig.gammacrap.size, sysramps, sysramps + 4096, sysramps + (2 * 4096))) {
			Com_Printf("error: cannot get system gamma ramps, gamma won't work\n");
			once = 0;
			return 0;
		}
		once = 0;
		gamma_works = 1;
	}

	if (gamma_works) {
		/* Just double check the gamma size... */
		if (glConfig.gammacrap.size < 0 || glConfig.gammacrap.size > 4096) {
			Com_Printf("error: gamma size broken but worked initially, wtf?! gamma won't work\n");
			gamma_works = 0;
			vid_hwgamma_enabled = false;
		}
		/* It returns true unconditionally ... */
		XF86VidModeSetGammaRamp(glConfig.gammacrap.display, glConfig.gammacrap.screen, glConfig.gammacrap.size, ramps, ramps + 4096, ramps + (2 * 4096));
		vid_hwgamma_enabled = true;
	}
	return 0;
#else
	if (SDL_SetWindowGammaRamp(sdl_window, ramps, ramps + 256, ramps + 512) == 0) {
		vid_hwgamma_enabled = true;
		return 0;
	}
	return -1;
#endif
}

#ifdef X11_GAMMA_WORKAROUND
static void VID_RestoreSystemGamma(void)
{
	if (!sdl_window || COM_CheckParm(cmdline_param_client_nohardwaregamma)) {
		return;
	}
	VID_SetDeviceGammaRampReal(sysramps);
}
#endif

static void window_event(SDL_WindowEvent *event)
{
	extern qbool scr_skipupdate;
	int flags = SDL_GetWindowFlags(sdl_window);

	switch (event->event) {
		case SDL_WINDOWEVENT_MINIMIZED:
			Minimized = true;

		case SDL_WINDOWEVENT_FOCUS_LOST:
			ActiveApp = false;
#ifdef __linux__
			block_keyboard_input = in_ignore_unfocused_keyb.integer;
#endif
#ifdef X11_GAMMA_WORKAROUND
			if (vid_gamma_workaround.integer) {
				if (Minimized || vid_hwgammacontrol.integer != 3) {
					VID_RestoreSystemGamma();
				}
			}
#endif
#ifdef _WIN32
			Sys_ActiveAppChanged ();
#endif
			break;

		case SDL_WINDOWEVENT_FOCUS_GAINED:
			TP_ExecTrigger("f_focusgained");
			/* Fall through */
		case SDL_WINDOWEVENT_RESTORED:
			Minimized = false;
			ActiveApp = true;
			scr_skipupdate = 0;
#ifdef X11_GAMMA_WORKAROUND
			if (vid_gamma_workaround.integer) {
				v_gamma.modified = true;
			}
#endif
#ifdef _WIN32
			Sys_ActiveAppChanged ();
#endif
			break;

		case SDL_WINDOWEVENT_MOVED:
			if (!(flags & SDL_WINDOW_FULLSCREEN) && r_win_save_pos.integer) {
				int displayNumber = 0;
				int x = event->data1;
				int y = event->data2;

				VID_RelativePositionFromAbsolute(&x, &y, &displayNumber);

				Cvar_SetValue(&vid_win_displayNumber, displayNumber);
				Cvar_SetValue(&vid_xpos, x);
				Cvar_SetValue(&vid_ypos, y);
			}
			break;

		case SDL_WINDOWEVENT_RESIZED:
			if (!(flags & SDL_WINDOW_FULLSCREEN)) {
				glConfig.vidWidth = event->data1;
				glConfig.vidHeight = event->data2;
				if (r_win_save_size.integer) {
					Cvar_LatchedSetValue(&vid_win_width, event->data1);
					Cvar_LatchedSetValue(&vid_win_height, event->data2);
				}
				if (!r_conwidth.integer || !r_conheight.integer)
					VID_UpdateConRes();
			}
			if (renderer.InvalidateViewport)
				renderer.InvalidateViewport();
			break;

#ifdef __linux__
		case SDL_WINDOWEVENT_TAKE_FOCUS:
			// On X, sequence is FOCUS_GAINED, [Keyboard 'down' events], TAKE_FOCUS
			// On Windows, it's just FOCUS_GAINED then TAKE_FOCUS, so nothing to block really
			block_keyboard_input = false;
			break;
#endif
	}
}

// FIXME: APPLE K_F13-15 etc...

static const byte scantokey[128] = {
//  0               1               2               3               4               5               6                   7
//  8               9               A               B               C               D               E                   F
    0,              0,              0,              0,              'a',            'b',            'c',                'd',            // 0
    'e',            'f',            'g',            'h',            'i',            'j',            'k',                'l',
    'm',            'n',            'o',            'p',            'q',            'r',            's',                't',            // 1
    'u',            'v',            'w',            'x',            'y',            'z',            '1',                '2',
    '3',            '4',            '5',            '6',            '7',            '8',            '9',                '0',            // 2
    K_ENTER,        K_ESCAPE,       K_BACKSPACE,    K_TAB,          K_SPACE,        '-',            '=',                '[',
    ']',            '\\',           0,              ';',            '\'',           '`',            ',',                '.',            // 3
    '/' ,           K_CAPSLOCK,     K_F1,           K_F2,           K_F3,           K_F4,           K_F5,               K_F6,
    K_F7,           K_F8,           K_F9,           K_F10,          K_F11,          K_F12,          K_PRINTSCR,         K_SCRLCK,    // 4
    K_PAUSE,        K_INS,          K_HOME,         K_PGUP,         K_DEL,          K_END,          K_PGDN,             K_RIGHTARROW,
    K_LEFTARROW,    K_DOWNARROW,    K_UPARROW,      KP_NUMLOCK,     KP_SLASH,       KP_STAR,        KP_MINUS,           KP_PLUS,        // 5
    KP_ENTER,       KP_END,         KP_DOWNARROW,   KP_PGDN,        KP_LEFTARROW,   KP_5,           KP_RIGHTARROW,      KP_HOME,
    KP_UPARROW,     KP_PGUP,        KP_INS,         KP_DEL,         K_ISO,          K_MENU,         0,                  0,              // 6
    0,              0,              0,              0,              0,              0,              0,                  0,
    0,              0,              0,              0,              0,              0,              K_MENU,             0,              // 7
#ifdef __APPLE__
    K_LCTRL,        K_LSHIFT,       K_LALT,         K_CMD,          K_RCTRL,        K_RSHIFT,       K_RALT,             K_CMD,         // E
#else
    K_LCTRL,        K_LSHIFT,       K_LALT,         K_LWIN,         K_RCTRL,        K_RSHIFT,       K_RALT,             K_RWIN,         // E
#endif
};

byte Key_ScancodeToQuakeCode(int scancode)
{
	byte quakeCode = 0;
	if (scancode < 120)
		quakeCode = scantokey[scancode];
	else if (scancode >= 224 && scancode < 224 + 8)
		quakeCode = scantokey[scancode - 104];

	if (cl_keypad.integer == 0 || key_dest == key_menu || (cl_keypad.integer == 2 && !(key_dest == key_console || key_dest == key_message))) {
		// compatibility mode without knowledge about keypad-keys:
		switch (quakeCode)
		{
		case KP_NUMLOCK:     quakeCode = K_PAUSE;          break;
		case KP_SLASH:       quakeCode = '/';              break;
		case KP_STAR:        quakeCode = '*';              break;
		case KP_MINUS:       quakeCode = '-';              break;
		case KP_HOME:        quakeCode = K_HOME;           break;
		case KP_UPARROW:     quakeCode = K_UPARROW;        break;
		case KP_PGUP:        quakeCode = K_PGUP;           break;
		case KP_LEFTARROW:   quakeCode = K_LEFTARROW;      break;
		case KP_5:           quakeCode = '5';              break;
		case KP_RIGHTARROW:  quakeCode = K_RIGHTARROW;     break;
		case KP_PLUS:        quakeCode = '+';              break;
		case KP_END:         quakeCode = K_END;            break;
		case KP_DOWNARROW:   quakeCode = K_DOWNARROW;      break;
		case KP_PGDN:        quakeCode = K_PGDN;           break;
		case KP_INS:         quakeCode = K_INS;            break;
		case KP_DEL:         quakeCode = K_DEL;            break;
		case KP_ENTER:       quakeCode = K_ENTER;          break;
		default:                                           break;
		}
	}
	else if (cl_keypad.integer == 1 && key_dest != key_game) {
		// Treat as normal return key
		if (quakeCode == KP_ENTER) {
			quakeCode = K_ENTER;
		}
	}

	return quakeCode;
}

byte Key_CharacterToQuakeCode(char ch)
{
	// Uses fact that SDLK_a == 'a'... is this okay?
	
	// Convert from key-code to scan-code to see what physical button they pressed
	int scancode = SDL_GetScancodeFromKey(ch);

	return Key_ScancodeToQuakeCode(scancode);
}

wchar Key_Event_TextInput(wchar unichar);

static void keyb_textinputevent(char* text)
{
	int i = 0;
	int len = 0;
	wchar unichar = 0;

	// Only process text input messages here
	if (key_dest != key_console && key_dest != key_message)
		return;

	if (!*text)
		return;

#ifdef __APPLE__
	// operating system is sending deadkey-modified input... ignore
	if (deadkey_modifiers_held_down) {
		return;
	}
#endif

#ifdef __linux__
	if (block_keyboard_input) {
		return;
	}
#endif

	len = strlen(text);
	for (i = 0; i < len; ++i)
	{
		unichar = TextEncodingDecodeUTF8(text, &i);

		if (unichar)
			Key_Event_TextInput(unichar);
	}
}

static void keyb_event(SDL_KeyboardEvent *event)
{
	byte result = Key_ScancodeToQuakeCode(event->keysym.scancode);

#ifdef __APPLE__
	if (in_ignore_deadkeys.integer) {
		// Apologies for the guesswork, no Apple keyboard...
		int left_alt = (in_ignore_deadkeys.integer == 2 ? SDLK_LALT : SDLK_LGUI);
		int right_alt = (in_ignore_deadkeys.integer == 2 ? SDLK_RALT : SDLK_RGUI);

		if (event->keysym.sym == left_alt) {
			deadkey_modifiers_held_down ^= APPLE_LALT_HELD_DOWN;
			deadkey_modifiers_held_down |= (event->state ? APPLE_LALT_HELD_DOWN : 0);
		}
		else if (event->keysym.sym == right_alt) {
			deadkey_modifiers_held_down ^= APPLE_RALT_HELD_DOWN;
			deadkey_modifiers_held_down |= (event->state ? APPLE_RALT_HELD_DOWN : 0);
		}
	}
#endif

	if (result == 0) {
		Com_DPrintf("%s: unknown scancode %d\n", __func__, event->keysym.scancode);
		return;
	}

#ifdef __linux__
	if (block_keyboard_input) {
		Com_DPrintf("%s: scan-code %d, qchar %d: suppressed\n", __func__, event->keysym.scancode, result);
		return;
	}
#endif
	Key_Event(result, event->state);
}

static void mouse_button_event(SDL_MouseButtonEvent *event)
{
	unsigned key;

	switch (event->button) {
	case SDL_BUTTON_LEFT:
		key = K_MOUSE1;
		break;
	case SDL_BUTTON_RIGHT:
		key = K_MOUSE2;
		break;
	case SDL_BUTTON_MIDDLE:
		key = K_MOUSE3;
		break;
	case 8:
	case SDL_BUTTON_X1:
		key = K_MOUSE4;
		break;
	case 9:
	case SDL_BUTTON_X2:
		key = K_MOUSE5;
		break;
	default:
		Com_DPrintf("%s: unknown button %d\n", __func__, event->button);
		return;
	}

	Key_Event(key, event->state);
}

static void mouse_wheel_event(SDL_MouseWheelEvent *event)
{
	if (event->y > 0) {
		if (wheelup_deferred) {
			Key_Event(K_MWHEELUP, false);
		}
		Key_Event(K_MWHEELUP, true);
		wheelup_deferred = true;
	}
	else if (event->y < 0) {
		if (wheeldown_deferred) {
			Key_Event(K_MWHEELDOWN, false);
		}
		Key_Event(K_MWHEELDOWN, true);
		wheeldown_deferred = true;
	}
}

#if defined(_WIN32) && !defined(WITHOUT_WINKEYHOOK)
static void HandleWindowsKeyboardEvents(unsigned int flags, qbool down)
{
	if (flags & WINDOWS_LWINDOWSKEY) {
		Key_Event(K_LWIN, down);
	}
	if (flags & WINDOWS_RWINDOWSKEY) {
		Key_Event(K_RWIN, down);
	}
	if (flags & WINDOWS_MENU) {
		Key_Event(K_MENU, down);
	}
	if (flags & WINDOWS_PRINTSCREEN) {
		Key_Event(K_PRINTSCR, down);
	}
	if (flags & WINDOWS_CAPSLOCK) {
		Key_Event(K_CAPSLOCK, down);
	}
}
#endif

static void HandleEvents(void)
{
	SDL_Event event;
	qbool track_movement_through_state = (mouse_active && !SDL_GetRelativeMouseMode());

#if defined(_WIN32) && !defined(WITHOUT_WINKEYHOOK)
	HandleWindowsKeyboardEvents(windows_keys_down, true);
	HandleWindowsKeyboardEvents(windows_keys_up, false);

	windows_keys_down = windows_keys_up = 0;
#endif

	while (SDL_PollEvent(&event)) {
		switch (event.type) {
		case SDL_QUIT:
			Sys_Quit();
			break;
		case SDL_WINDOWEVENT:
			window_event(&event.window);
			break;
		case SDL_KEYDOWN:
		case SDL_KEYUP:
#ifdef __APPLE__
			if (developer.integer == 2) {
				Con_Printf("key%s event, scan=%d, sym=%d, mod=%d\n", event.type == SDL_KEYDOWN ? "down" : "up", event.key.keysym.scancode, event.key.keysym.sym, event.key.keysym.mod);
			}
#endif
			keyb_event(&event.key);
			break;
		case SDL_TEXTINPUT:
			keyb_textinputevent(event.text.text);
			break;
		case SDL_MOUSEMOTION:
			if (event.motion.which != SDL_TOUCH_MOUSEID || !in_ignore_touch_events.integer) {
#ifdef __APPLE__
				if (developer.integer == 2) {
					Con_Printf("motion event, which=%d\n", event.motion.which);
				}
#endif
				if (!track_movement_through_state) {
					float factor = (IN_MouseTrackingRequired() ? cursor_sensitivity.value : 1);

					cursor_x += event.motion.xrel * factor;
					cursor_y += event.motion.yrel * factor;

					cursor_x = bound(0, cursor_x, VID_RenderWidth2D());
					cursor_y = bound(0, cursor_y, VID_RenderHeight2D());
				}
			}
			break;
		case SDL_MOUSEBUTTONDOWN:
		case SDL_MOUSEBUTTONUP:
#ifdef __APPLE__
			if (developer.integer == 2) {
				Con_Printf("mouse%s event, which=%d, button=%d\n", event.type == SDL_MOUSEBUTTONDOWN ? "down" : "up", event.button.which, event.button.button);
			}
#endif
			if (event.button.which != SDL_TOUCH_MOUSEID || !in_ignore_touch_events.integer) {
				mouse_button_event(&event.button);
			}
			break;
		case SDL_MOUSEWHEEL:
			if (event.wheel.which != SDL_TOUCH_MOUSEID || !in_ignore_touch_events.integer) {
				mouse_wheel_event(&event.wheel);
			}
			break;
		case SDL_DROPFILE:
			/* TODO: Add handling for different file types */
			if (strncmp(event.drop.file, "qw://", 5) == 0) {
				Cbuf_AddText("qwurl ");
			} else {
				Cbuf_AddText("playdemo ");
			}
			Cbuf_AddText(event.drop.file);
			Cbuf_AddText("\n");
			SDL_free(event.drop.file);
			break;
		}
	}

	if (track_movement_through_state) {
		float factor = (IN_MouseTrackingRequired() ? cursor_sensitivity.value : 1);
		int pos_x, pos_y;

		SDL_GetMouseState(&pos_x, &pos_y);

		mx = pos_x - old_x;
		my = pos_y - old_y;

		cursor_x = min(max(0, cursor_x + (pos_x - glConfig.vidWidth / 2) * factor), VID_RenderWidth2D());
		cursor_y = min(max(0, cursor_y + (pos_y - glConfig.vidHeight / 2) * factor), VID_RenderHeight2D());

		IN_SnapMouseBackToCentre();
	}
}

/*****************************************************************************/

void VID_SoftRestart(void)
{
	R_Shutdown(r_shutdown_reload);
	QMB_ShutdownParticles();
}

void VID_Shutdown(qbool restart)
{
	IN_DeactivateMouse();

	SDL_StopTextInput();

#ifdef X11_GAMMA_WORKAROUND
	if (vid_gamma_workaround.integer) {
		VID_RestoreSystemGamma();
	}
#endif

	R_Shutdown(restart ? r_shutdown_restart : r_shutdown_full);

	if (sdl_context) {
		SDL_GL_DeleteContext(sdl_context);
		sdl_context = NULL;
	}

	if (sdl_window) {
		SDL_DestroyWindow(sdl_window);
		sdl_window = NULL;
	}

	SDL_GL_ResetAttributes();

	if (SDL_WasInit(SDL_INIT_VIDEO) != 0) {
		SDL_QuitSubSystem(SDL_INIT_VIDEO);
	}

	memset(&glConfig, 0, sizeof(glConfig));

	Q_free(modelist);
	modelist_count = 0;
	vid_hwgamma_enabled = false;
	vid_initialized = false;

	if (!restart) {
		QMB_ShutdownParticles();
	}
}

static int VID_SDL_InitSubSystem(void)
{
	if (SDL_WasInit(SDL_INIT_VIDEO) == 0) {
		if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
			Sys_Error("Couldn't initialize SDL video: %s\n", SDL_GetError());
			return -1;
		}
	}

	SDL_StartTextInput();

	return 0;
}

// This is called during video initialisation & vid_restart, but not vid_reload
// Do not include any cvars here that should take effect without full restart
static void VID_RegisterLatchCvars(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_VIDEO);

	Cvar_Register(&vid_width);
	Cvar_Register(&vid_height);
	Cvar_Register(&vid_win_width);
	Cvar_Register(&vid_win_height);
	Cvar_Register(&vid_hwgammacontrol);
	Cvar_Register(&r_colorbits);
	Cvar_Register(&r_24bit_depth);
	Cvar_Register(&r_fullscreen);
	Cvar_Register(&r_displayRefresh);
	Cvar_Register(&vid_usedesktopres);
	Cvar_Register(&vid_win_borderless);
	Cvar_Register(&gl_multisamples);
	Cvar_Register(&vid_displayNumber);
	Cvar_Register(&vid_minimize_on_focus_loss);
	Cvar_Register(&vid_grab_keyboard);
#ifdef EZ_MULTIPLE_RENDERERS
	Cvar_Register(&vid_renderer);
#endif
	Cvar_Register(&vid_gl_core_profile);
	Cvar_Register(&vid_framebuffer);
	Cvar_Register(&vid_software_palette);
	Cvar_Register(&vid_framebuffer_depthformat);
	Cvar_Register(&vid_framebuffer_hdr);

#ifdef X11_GAMMA_WORKAROUND
	Cvar_Register(&vid_gamma_workaround);
#endif
	Cvar_Register(&vid_gammacorrection);

	Cvar_ResetCurrentGroup();
}

void VID_RegisterCvars(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_VIDEO);

	Cvar_Register(&vid_vsync_lag_fix);
	Cvar_Register(&vid_vsync_lag_tweak);
	Cvar_Register(&r_win_save_pos);
	Cvar_Register(&r_win_save_size);
	Cvar_Register(&r_swapInterval);
	Cvar_Register(&r_verbose);
	Cvar_Register(&vid_xpos);
	Cvar_Register(&vid_ypos);
	Cvar_Register(&r_conwidth);
	Cvar_Register(&r_conheight);
	Cvar_Register(&r_conscale);
	Cvar_Register(&vid_flashonactivity);
	Cvar_Register(&r_showextensions);
	Cvar_Register(&vid_win_displayNumber);
#ifdef __linux__
	Cvar_Register(&in_ignore_unfocused_keyb);
#endif

	Cvar_Register(&vid_framebuffer_blit);
	Cvar_Register(&vid_framebuffer_width);
	Cvar_Register(&vid_framebuffer_height);
	Cvar_Register(&vid_framebuffer_scale);
	Cvar_Register(&vid_framebuffer_hdr_tonemap);
	Cvar_Register(&vid_framebuffer_smooth);
	Cvar_Register(&vid_framebuffer_sshotmode);
	Cvar_Register(&vid_framebuffer_multisample);
	Cvar_Register(&vid_framebuffer_fxaa);

	Cvar_Register(&vid_reload_auto);

	Cvar_ResetCurrentGroup();
}

// Returns valid display number
int VID_DisplayNumber(qbool fullscreen)
{
	int displayNumber = (fullscreen ? vid_displayNumber.value : vid_win_displayNumber.value);
	int displays = SDL_GetNumVideoDisplays();

	return max(0, min(displays - 1, displayNumber));
}

static void VID_SetupModeList(void)
{
	int i;

	modelist_count = SDL_GetNumDisplayModes(VID_DisplayNumber(r_fullscreen.integer == 1));

	if (modelist_count <= 0) {
		Com_Printf("error getting display modes: %s\n", SDL_GetError());
		modelist_count = 0;
	}

	modelist = Q_calloc(modelist_count, sizeof(*modelist));

	for (i = 0; i < modelist_count; i++) {
		SDL_GetDisplayMode(0, i, &modelist[i]);
	}
}

static void VID_SetupResolution(void)
{
	SDL_DisplayMode display_mode;
	int display_nbr;

	if (r_fullscreen.integer) {
		display_nbr = VID_DisplayNumber(true);
		if (vid_usedesktopres.integer == 1) {
			if (SDL_GetDesktopDisplayMode(display_nbr, &display_mode) == 0) {
				glConfig.vidWidth = last_working_width = display_mode.w;
				glConfig.vidHeight = last_working_height = display_mode.h;
				glConfig.displayFrequency = last_working_hz = display_mode.refresh_rate;
				last_working_display = display_nbr;
				last_working_values = true;
				Cvar_AutoSetInt(&vid_width, display_mode.w);
				Cvar_AutoSetInt(&vid_height, display_mode.h);
				Cvar_AutoSetInt(&r_displayRefresh, display_mode.refresh_rate);
				return;
			} else {
				Com_Printf("warning: failed to get desktop resolution\n");
			}
		}
		/* Note the fall through in case the above fails */

		if (vid_width.integer == 0 || vid_height.integer == 0) {
			/* Try some default if nothing is set and we failed to get desktop res */
			glConfig.vidWidth = 1024;
			glConfig.vidHeight = 768;
			glConfig.displayFrequency = 0;

			Cvar_LatchedSetValue(&vid_width, 1024);
			Cvar_LatchedSetValue(&vid_height, 768);
			Cvar_LatchedSetValue(&r_displayRefresh, 0);

			return;
		}

		/* USER specified resolution */
		glConfig.vidWidth = bound(320, vid_width.integer, vid_width.integer);
		glConfig.vidHeight = bound(200, vid_height.integer, vid_height.integer);
		glConfig.displayFrequency = r_displayRefresh.integer;

	} else { /* Windowed mode */
		if (vid_win_width.integer == 0 || vid_win_height.integer == 0) {
			Cvar_LatchedSetValue(&vid_win_width, 640);
			Cvar_LatchedSetValue(&vid_win_height, 480);
			Cvar_LatchedSetValue(&r_displayRefresh, 0);
		}

		glConfig.vidWidth = bound(320, vid_win_width.integer, vid_win_width.integer);
		glConfig.vidHeight = bound(240, vid_win_height.integer, vid_win_height.integer);
		glConfig.displayFrequency = 0;
	}
}

int VID_GetCurrentModeIndex(void)
{
	int i;

	int best_freq = 0;
	int best_idx = -1;

	for (i = 0; i < modelist_count; i++) {
		if (modelist[i].w == vid_width.integer && modelist[i].h == vid_height.integer) {
			if (modelist[i].refresh_rate == r_displayRefresh.integer) {
				Com_DPrintf("MATCHED: %dx%d hz:%d\n", modelist[i].w, modelist[i].h, modelist[i].refresh_rate);
				return i;
			}

			if (modelist[i].refresh_rate > best_freq) {
				best_freq = modelist[i].refresh_rate;
				best_idx = i;
			}
		}
	}

	/* width/height matched but not hz, using the best available */
	if (best_idx >= 0) {
		Cvar_AutoSetInt(&r_displayRefresh, modelist[best_idx].refresh_rate);
	}

	return best_idx;
}

int VID_GetModeIndexCount(void) {
	return modelist_count;
}

const SDL_DisplayMode *VID_GetDisplayMode(int index)
{
	if (index < 0 || index >= modelist_count) {
		return NULL;
	}

	return &modelist[index];
}

static void VID_SDL_GL_SetupWindowAttributes(int options)
{
	SDL_GL_ResetAttributes();
	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, options & VID_MULTISAMPLED ? 1 : 0);
	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, options & VID_MULTISAMPLED ? bound(2, gl_multisamples.integer, 16) : 0);
	SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, options & VID_ACCELERATED ? 1 : 0);
	if (vid_framebuffer.integer) {
		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
	}
	else {
		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, options & VID_DEPTHBUFFER24 ? 24 : 16);
	}
	SDL_GL_SetAttribute(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, options & VID_GAMMACORRECTED ? 1 : 0);
}

static SDL_GLContext VID_SDL_GL_SetupContextAttributes(void)
{
#ifdef EZ_MULTIPLE_RENDERERS
	if (vid_renderer.integer < VID_RENDERER_MIN || vid_renderer.integer > VID_RENDERER_MAX) {
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
		Con_Printf("Invalid vid_renderer value detected, falling back to default.\n");
		Cvar_LatchedSetValue(&vid_renderer, VID_RENDERER_MIN);
#else
		Sys_Error("Invalid vid_renderer value detected");
#endif
	}
#endif

#ifdef RENDERER_OPTION_MODERN_OPENGL
	if (R_UseModernOpenGL()) {
		return GLM_SDL_CreateContext(sdl_window);
	}
#endif
#ifdef RENDERER_OPTION_CLASSIC_OPENGL
	if (R_UseImmediateOpenGL()) {
		return GLC_SDL_CreateContext(sdl_window);
	}
#endif
#ifdef RENDERER_OPTION_VULKAN
	if (R_UseVulkan()) {
		//return VK_SDL_CreateContext(sdl_window);
	}
#endif

	return NULL;
}

static int VID_SetWindowIcon(SDL_Window *sdl_window)
{
#ifdef __APPLE__
	// on OS X the icon is handled by the app bundle
	// it actually is higher resolution than the one here.
	return 0;
#else
	SDL_Surface *icon_surface;
        icon_surface = SDL_CreateRGBSurfaceFrom((void *)ezquake_icon.pixel_data, ezquake_icon.width, ezquake_icon.height, ezquake_icon.bytes_per_pixel * 8,
                ezquake_icon.width * ezquake_icon.bytes_per_pixel,
                0x000000FF,0x0000FF00,0x00FF0000,0xFF000000);

	if (icon_surface) {
		SDL_SetWindowIcon(sdl_window, icon_surface);
		SDL_FreeSurface(icon_surface);
		return 0;
	}

	return -1;
#endif
}

static SDL_Window *VID_SDL_CreateWindow(int flags)
{
	if (r_fullscreen.integer == 0) {
		int displayNumber = VID_DisplayNumber(false);
		int xpos = vid_xpos.integer;
		int ypos = vid_ypos.integer;

		VID_AbsolutePositionFromRelative(&xpos, &ypos, &displayNumber);

		return SDL_CreateWindow(WINDOW_CLASS_NAME, xpos, ypos, glConfig.vidWidth, glConfig.vidHeight, flags);
	}
	else {
		int windowWidth = glConfig.vidWidth;
		int windowHeight = glConfig.vidHeight;
		int windowX = SDL_WINDOWPOS_CENTERED;
		int windowY = SDL_WINDOWPOS_CENTERED;
		int displayNumber = VID_DisplayNumber(true);
		SDL_Rect bounds;

		if (SDL_GetDisplayBounds(displayNumber, &bounds) == 0) {
			windowX = bounds.x;
			windowY = bounds.y;
			windowWidth = bounds.w;
			windowHeight = bounds.h;
		}
		else {
			Com_Printf("Couldn't determine bounds of display #%d, defaulting to main display\n", displayNumber);
		}

		return SDL_CreateWindow(WINDOW_CLASS_NAME, windowX, windowY, windowWidth, windowHeight, flags);
	}
}

#ifdef X11_GAMMA_WORKAROUND
static void VID_X11_GetGammaRampSize(void)
{
	glConfig.gammacrap.size = -1;

	SDL_VERSION(&glConfig.gammacrap.info.version);
	glConfig.gammacrap.screen = SDL_GetWindowDisplayIndex(sdl_window);

	if (glConfig.gammacrap.screen < 0) {
		Com_Printf("error: couldn't get screen number to set gamma\n");
		return;
	}

	if (SDL_GetWindowWMInfo(sdl_window, &glConfig.gammacrap.info) != SDL_TRUE) {
		Com_Printf("error: can not get display pointer, gamma won't work: %s\n", SDL_GetError());
		return;
	}

	if (glConfig.gammacrap.info.subsystem != SDL_SYSWM_X11) {
		Com_Printf("error: not x11, gamma won't work\n");
		return;
	}

	glConfig.gammacrap.display = glConfig.gammacrap.info.info.x11.display;
	XF86VidModeGetGammaRampSize(glConfig.gammacrap.display, glConfig.gammacrap.screen, &glConfig.gammacrap.size);

	if (glConfig.gammacrap.size <= 0 || glConfig.gammacrap.size > 4096) {
		Com_Printf("error: gamma size '%d' seems weird, refusing to use it\n", glConfig.gammacrap.size);
		glConfig.gammacrap.size = -1;
		return;
	}
}
#endif

static void VID_SetWindowResolution(void)
{
	if (r_fullscreen.integer > 0 && vid_usedesktopres.integer != 1) {
		int index = VID_GetCurrentModeIndex();

		if (index < 0) {
			Com_Printf("Couldn't find a matching video mode for the selected values, check video settings!\n");
			if (last_working_values == true) {
				Com_Printf("Using last known working settings: %dx%d@%dHz\n", last_working_width, last_working_height, last_working_hz);
				Cvar_LatchedSetValue(&vid_width, (float)last_working_width);
				Cvar_LatchedSetValue(&vid_height, (float)last_working_height);
				Cvar_LatchedSetValue(&r_displayRefresh, (float)last_working_hz);
				Cvar_LatchedSetValue(&vid_displayNumber, (float)last_working_display);
				Cvar_AutoSetInt(&vid_width, last_working_width);
				Cvar_AutoSetInt(&vid_height, last_working_height);
				Cvar_AutoSetInt(&r_displayRefresh, last_working_hz);
				Cvar_AutoSetInt(&vid_displayNumber, last_working_display);
			}
			else {
				Com_Printf("Using desktop resolution as fallback\n");
				Cvar_LatchedSet(&vid_usedesktopres, "1");
				Cvar_AutoSet(&vid_usedesktopres, "1");
			}
			VID_SetupResolution();
		}
		else {
			if (SDL_SetWindowDisplayMode(sdl_window, &modelist[index]) != 0) {
				Com_Printf("sdl error: %s\n", SDL_GetError());
			}
			else {
				last_working_width = (&modelist[index])->w;
				last_working_height = (&modelist[index])->h;
				last_working_hz = (&modelist[index])->refresh_rate;
				last_working_display = vid_displayNumber.integer;
				last_working_values = true;
			}
		}

		if (SDL_SetWindowFullscreen(sdl_window, SDL_WINDOW_FULLSCREEN) < 0) {
			Com_Printf("Failed to change to fullscreen mode\n");
		}
	}

	SDL_SetWindowMinimumSize(sdl_window, 320, 240);
}

static void VID_SDL_Init(void)
{
	int flags;
	
	if (glConfig.initialized == true) {
		return;
	}

	VID_SDL_InitSubSystem();

	flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL | SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_SHOWN;
	// MEAG: deliberately not specifying SDL_WINDOW_ALLOW_HIGHDPI as in our current workflow, it
	//          breaks retina devices (we ask for display resolution and get told lower value)
	//       Understand this is meant to be helped by NSHighResolutionCapable in Info.plist, but
	//          BLooD_DoG tried that and it didn't help.  No OSX device to test on, so removed
	//          for the moment.
	//       Flag has no effect on Windows (see SetProcessDpiAwarenessFunc in sys_win.c)
	if (r_fullscreen.integer > 0) {
		flags |= (vid_usedesktopres.integer == 1 ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
	}
	else {
		flags |= (vid_win_borderless.integer > 0 ? SDL_WINDOW_BORDERLESS : 0);
	}

	SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, vid_minimize_on_focus_loss.integer == 0 ? "0" : "1");
#ifdef __APPLE__
	SDL_SetHint(SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES, "0");
#endif
	SDL_SetHint(SDL_HINT_GRAB_KEYBOARD, vid_grab_keyboard.integer == 0 ? "0" : "1");
	SDL_SetHintWithPriority(SDL_HINT_MOUSE_RELATIVE_MODE_WARP, "0", SDL_HINT_OVERRIDE);
#ifdef __APPLE__
#ifdef SDL_HINT_TOUCH_MOUSE_EVENTS
	SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0");
#endif
#endif

	{
		int i;
		int vid_options[] = {
			// Try to get everything they ask for...
			VID_MULTISAMPLED | VID_ACCELERATED | VID_DEPTHBUFFER24 | VID_GAMMACORRECTED,
			// ... multisampled off
			VID_ACCELERATED | VID_DEPTHBUFFER24 | VID_GAMMACORRECTED,
			// ... give up on gamma corrected
			VID_MULTISAMPLED | VID_ACCELERATED | VID_DEPTHBUFFER24,
			VID_ACCELERATED | VID_DEPTHBUFFER24,
			// 
			VID_ACCELERATED | VID_DEPTHBUFFER24 | VID_GAMMACORRECTED,
			VID_ACCELERATED | VID_GAMMACORRECTED,
			VID_ACCELERATED,
			// Un-accelerated and at this point we're desperate
			VID_DEPTHBUFFER24,
			VID_GAMMACORRECTED,
			0
		};

		while (true) {
			for (i = 0, sdl_window = NULL; sdl_window == NULL && i < sizeof(vid_options) / sizeof(vid_options[0]); ++i) {
				if ((vid_options[i] & VID_MULTISAMPLED) && gl_multisamples.integer <= 0) {
					continue;
				}
				if ((vid_options[i] & VID_DEPTHBUFFER24) && !r_24bit_depth.integer) {
					continue;
				}
				if ((vid_options[i] & VID_ACCELERATED) && COM_CheckParm(cmdline_param_client_unaccelerated_visuals)) {
					continue;
				}
				if ((vid_options[i] & VID_GAMMACORRECTED) && vid_gammacorrection.integer == 0) {
					continue;
				}
				if (!(vid_options[i] & VID_GAMMACORRECTED) && vid_gammacorrection.integer == 2) {
					continue;
				}

				sdl_window = NULL;
				VID_SDL_GL_SetupWindowAttributes(vid_options[i]);
				VID_SetupModeList();
				VID_SetupResolution();
				sdl_window = VID_SDL_CreateWindow(flags);

				if (sdl_window) {
					VID_SetWindowResolution();

					// Try to create context and see what we get
					sdl_context = VID_SDL_GL_SetupContextAttributes();

					if (!sdl_context) {
						SDL_DestroyWindow(sdl_window);
						sdl_window = NULL;
					}
					else {
						break;
					}
				}
			}

#if defined(RENDERER_OPTION_CLASSIC_OPENGL) && defined(EZ_MULTIPLE_RENDERERS)
			// FIXME: Implement falling back from Vulkan too
			if (!sdl_window && !R_UseImmediateOpenGL()) {
				Con_Printf("&cf00Error&r: failed to create rendering context, trying classic OpenGL...\n");

				Cvar_LatchedSetValue(&vid_renderer, 0);
				continue;
			}
#endif

			break;
		}

		if (!sdl_window) {
			Sys_Error("Failed to create SDL window/context: %s\n", SDL_GetError());
		}

		// Alert user if our mode doesn't match what they requested
		if (!(vid_options[i] & VID_MULTISAMPLED) && gl_multisamples.integer > 0) {
			Cvar_AutoSetInt(&gl_multisamples, 0);
			Com_Printf("WARNING: MSAA request failed - disabled\n");
		}

		if (!(vid_options[i] & VID_DEPTHBUFFER24) && r_24bit_depth.integer) {
			Cvar_AutoSetInt(&r_24bit_depth, 0);
			Com_Printf("WARNING: 24-bit depth buffer request failed\n");
		}

		if (!(vid_options[i] & VID_ACCELERATED) && !COM_CheckParm(cmdline_param_client_unaccelerated_visuals)) {
			Com_Printf("WARNING: Using unaccelerated graphics\n");
		}

		if (vid_gammacorrection.integer && !(vid_options[i] & VID_GAMMACORRECTED)) {
			Com_Printf("WARNING: Not able to apply gamma-correction\n");
			Cvar_LatchedSetValue(&vid_gammacorrection, 0);
		}
	}

	if (VID_SetWindowIcon(sdl_window) < 0) {
		Com_Printf("Failed to set window icon");
	}

	v_gamma.modified = true;
	r_swapInterval.modified = true;

#ifdef X11_GAMMA_WORKAROUND
	/* PLEASE REMOVE ME AS SOON AS SDL2 AND XORG ARE TALKING NICELY TO EACHOTHER AGAIN IN TERMS OF GAMMA */
	if (vid_gamma_workaround.integer != 0) {
		VID_X11_GetGammaRampSize();
	} else {
		glConfig.gammacrap.size = 256;
	}
#endif

	R_Initialise();

	//always get/set refresh rate
	SDL_DisplayMode display_mode;
	int display_nbr;

	display_nbr = VID_DisplayNumber(true);
	if (SDL_GetDesktopDisplayMode(display_nbr, &display_mode) == 0) {
		Cvar_AutoSetInt(&r_displayRefresh, display_mode.refresh_rate);
	}

	glConfig.initialized = true;
}

static void VID_SwapBuffers (void)
{
	SDL_GL_SwapWindow(sdl_window);
}

static void VID_SwapBuffersWithVsyncFix(void)
{
	double time_before_swap;

	time_before_swap = Sys_DoubleTime();

	SDL_GL_SwapWindow(sdl_window);

	vid_last_swap_time = Sys_DoubleTime();
	vid_vsync_lag = vid_last_swap_time - time_before_swap;
}

void R_BeginRendering(int *x, int *y, int *width, int *height)
{

	*x = *y = 0;
	*width = glConfig.vidWidth;
	*height = glConfig.vidHeight;

	if (renderer.IsFramebufferEnabled3D()) {
		int scaled_width = VID_ScaledWidth3D();
		int scaled_height = VID_ScaledHeight3D();

		if (scaled_width && scaled_height) {
			*width = scaled_width;
			*height = scaled_height;
		}
	}

	if (cls.state != ca_active) {
		renderer.ClearRenderingSurface(true);
	}
}

void R_EndRendering(void)
{
	if (r_swapInterval.modified) {
		if (r_swapInterval.integer == 0) {
			if (SDL_GL_SetSwapInterval(0)) {
				Con_Printf("vsync: Failed to disable vsync...\n");
			}
            // MacOS vsync fix
            #ifdef __APPLE__
            GLint                       sync = 0;
            CGLContextObj               ctx = CGLGetCurrentContext();
            CGLSetParameter(ctx, kCGLCPSwapInterval, &sync);
            #endif
		} else if (r_swapInterval.integer == -1) {
			if (SDL_GL_SetSwapInterval(-1)) {
				Con_Printf("vsync: Failed to enable late swap tearing (vid_vsync -1), setting vid_vsync 1 instead...\n");
				Cvar_SetValueByName("vid_vsync", 1);
			}
		}

		if (r_swapInterval.integer == 1) {
			if (SDL_GL_SetSwapInterval(1)) {
				Con_Printf("vsync: Failed to enable vsync...\n");
			}
		}

		r_swapInterval.modified = false;
    }

	if (!scr_skipupdate || block_drawing) {
		if (vid_vsync_lag_fix.integer > 0) {
			VID_SwapBuffersWithVsyncFix();
		}
		else {
			VID_SwapBuffers(); 
		}
	}

	buffers.EndFrame();
}

void VID_SetCaption (char *text)
{
	if (!sdl_window) {
		return;
	}

	SDL_SetWindowTitle(sdl_window, text);
}

void VID_NotifyActivity(void)
{
#ifdef _WIN32
	SDL_SysWMinfo info;
	SDL_VERSION(&info.version);

	if (ActiveApp || !vid_flashonactivity.value) {
		return;
	}

	if (SDL_GetWindowWMInfo(sdl_window, &info) == SDL_TRUE) {
		if (info.subsystem == SDL_SYSWM_WINDOWS) {
			FlashWindow(info.info.win.window, TRUE);
		}
	}
	else {
		Com_DPrintf("Sys_NotifyActivity: SDL_GetWindowWMInfo failed: %s\n", SDL_GetError());
	}
#endif
}

int VID_SetDeviceGammaRamp(unsigned short *ramps)
{
	if (!sdl_window || (COM_CheckParm(cmdline_param_client_nohardwaregamma) && Ruleset_AllowNoHardwareGamma())) {
		return 0;
	}

	if (r_fullscreen.integer > 0) {
		if (vid_hwgammacontrol.integer > 0) {
			return VID_SetDeviceGammaRampReal(ramps);
		}
	}
	else {
		if (vid_hwgammacontrol.integer >= 2) {
			return VID_SetDeviceGammaRampReal(ramps);
		}
	}

	return 0;
}

void VID_Minimize (void) 
{
	if (!sdl_window) {
		return;
	}

	SDL_MinimizeWindow(sdl_window);
}

void VID_Restore (void)
{
	if (!sdl_window || (SDL_GetWindowFlags(sdl_window) & SDL_WINDOW_INPUT_FOCUS)) {
		return;
	}

	SDL_RestoreWindow(sdl_window);
	SDL_RaiseWindow(sdl_window);
}

static void VID_ParseCmdLine(void)
{
	int i, w = 0, h = 0, display = 0;

	if (COM_CheckParm(cmdline_param_client_windowedmode) || COM_CheckParm(cmdline_param_client_startwindowed)) {
		Cvar_LatchedSetValue(&r_fullscreen, 0);
	}

	if ((i = COM_CheckParm(cmdline_param_client_video_frequency)) && i + 1 < COM_Argc()) {
		Cvar_LatchedSetValue(&r_displayRefresh, Q_atoi(COM_Argv(i + 1)));
	}

	if ((i = COM_CheckParm(cmdline_param_client_video_bpp)) && i + 1 < COM_Argc()) {
		Cvar_LatchedSetValue(&r_colorbits, Q_atoi(COM_Argv(i + 1)));
	}

	if (COM_CheckParm(cmdline_param_client_video_nodesktopres)) {
		Cvar_LatchedSetValue(&vid_usedesktopres, 0);
	}

	w = ((i = COM_CheckParm(cmdline_param_client_video_width))  && i + 1 < COM_Argc()) ? Q_atoi(COM_Argv(i + 1)) : 0;
	h = ((i = COM_CheckParm(cmdline_param_client_video_height)) && i + 1 < COM_Argc()) ? Q_atoi(COM_Argv(i + 1)) : 0;

	display = ((i = COM_CheckParm(cmdline_param_client_video_displaynumber)) && i + 1 < COM_Argc()) ? Q_atoi(COM_Argv(i + 1)) : 0;
	if (i) {
		if (COM_CheckParm(cmdline_param_client_windowedmode)) {
			Cvar_LatchedSetValue(&vid_win_displayNumber, display);
		} else {
			Cvar_LatchedSetValue(&vid_displayNumber, display);
		}
	}

	if (w && h) {
		if (COM_CheckParm(cmdline_param_client_windowedmode)) {
			Cvar_LatchedSetValue(&vid_win_width,  w);
			Cvar_LatchedSetValue(&vid_win_height, h);
		}
		else {
			Cvar_LatchedSetValue(&vid_width, w);
			Cvar_LatchedSetValue(&vid_height, h);
		}
	} // else if (w || h) { Sys_Error("Must specify both -width and -height\n"); }

	if ((i = COM_CheckParm(cmdline_param_client_video_conwidth)) && i + 1 < COM_Argc()) {
		Cvar_SetIgnoreCallback(&r_conwidth, COM_Argv(i + 1));
	}

	if ((i = COM_CheckParm(cmdline_param_client_video_conheight)) && i + 1 < COM_Argc()) {
		Cvar_SetIgnoreCallback(&r_conheight, COM_Argv(i + 1));
	}

#if defined(EZ_MULTIPLE_RENDERERS) && defined(RENDERER_OPTION_MODERN_OPENGL)
	if (COM_CheckParm(cmdline_param_client_video_glsl_renderer)) {
		Cvar_LatchedSetValue(&vid_renderer, 1);
	}
#endif
}

void GFX_Init(void);
void ReloadPaletteAndColormap(void);

static void VID_Startup(void)
{
	qbool old_con_suppress = con_suppress;

	// force models to reload (just flush, no actual loading code here)
	Cache_Flush();

	// shut up warnings during GFX_Init();
	con_suppress = !developer.integer;
	// reload 2D textures, particles textures, some other textures and gfx.wad
	GFX_Init();

	// reload skins
	Skin_Skins_f();

	con_suppress = old_con_suppress;

	// we need done something like for map reloading, for example reload textures for brush models
	R_NewMap(true);

	// window may be re-created, so caption need to be forced to update
	CL_UpdateCaption(true);

	// last chance
	CachePics_AtlasFrame();
	// compile all programs
	R_ProgramCompileAll();

	Cvar_ClearAllModifiedFlags(CVAR_RELOAD_GFX);
}

void VID_ReloadCvarChanged(cvar_t* var)
{
	if (!vid_reload_auto.integer) {
		Con_Printf("%s needs %s to immediately take effect.\n", var->name, CVAR_RELOAD_GFX_COMMAND);
	}
	else {
		vid_reload_pending = true;
	}
}

static void VID_Reload_f(void)
{
	if (!host_initialized) { // sanity
		Com_Printf("Can't do %s yet\n", Cmd_Argv(0));
		return;
	}

	VID_SoftRestart();
	ReloadPaletteAndColormap();
	VID_Startup();
	vid_reload_pending = false;
}

void VID_ReloadCheck(void)
{
	if (vid_reload_pending && host_initialized) {
		VID_Reload_f();
	}
}

static void VID_Restart_f(void)
{
	if (!host_initialized) { // sanity
		Com_Printf("Can't do %s yet\n", Cmd_Argv(0));
		return;
	}

	VID_Shutdown(true);

	ReloadPaletteAndColormap();

	// keys can get stuck because SDL2 doesn't send keyup event when the video system is down
	Key_ClearStates();

	VID_Init(host_basepal);

	VID_Startup();
}

static void VID_DisplayList_f(void)
{
	int displays = SDL_GetNumVideoDisplays();
	int i;

	for (i = 0; i < displays; i++) {
		const char *displayname = SDL_GetDisplayName(i);
		if (displayname == NULL) {
			displayname = "Unknown";
		}
		Com_Printf("%d: %s\n", i, displayname);
	}
}

static void VID_ModeList_f(void)
{
	int i = 0;

	if (modelist == NULL || modelist_count <= 0) {
		Com_Printf("error: no modes available\n");
		return;
	}
	
	for (; i < modelist_count; i++) {
		Com_Printf("%dx%d@%dHz\n", (&modelist[i])->w, (&modelist[i])->h, (&modelist[i])->refresh_rate);
	}
}

void VID_RegisterCommands(void) 
{
	if (!host_initialized) {
		Cmd_AddCommand("vid_gfxinfo", VID_GfxInfo_f);
		Cmd_AddCommand("vid_restart", VID_Restart_f);
		Cmd_AddCommand(CVAR_RELOAD_GFX_COMMAND, VID_Reload_f);
		Cmd_AddCommand("vid_displaylist", VID_DisplayList_f);
		Cmd_AddCommand("vid_modelist", VID_ModeList_f);
		Cmd_AddLegacyCommand("vid_framebuffer_palette", vid_software_palette.name);
	}
}

static void VID_UpdateConRes(void)
{
	qbool set_width = false;
	qbool set_height = false;

	int vidWidth = glConfig.vidWidth;
	int vidHeight = glConfig.vidHeight;

	int effective_width = vid_framebuffer.integer == 1 ? VID_ScaledWidth3D() : 0;
	int effective_height = vid_framebuffer.integer == 1 ? VID_ScaledHeight3D() : 0;

	if (effective_width && effective_height) {
		vidWidth = effective_width;
		vidHeight = effective_height;

		Cvar_AutoSetInt(&vid_framebuffer_width, effective_width);
		Cvar_AutoSetInt(&vid_framebuffer_height, effective_height);
	}
	else {
		Cvar_AutoReset(&vid_framebuffer_width);
		Cvar_AutoReset(&vid_framebuffer_height);
	}

	// Default
	if (r_conwidth.integer == 0 && r_conheight.integer == 0) {
		vid.width = vid.conwidth = bound(320, (int)(vidWidth  / r_conscale.value), vidWidth);
		vid.height = vid.conheight = bound(200, (int)(vidHeight / r_conscale.value), vidHeight);

		set_width = set_height = true;
	}
	else if (r_conwidth.integer == 0) {
		double ar_w = (double)vidWidth/(double)vidHeight;

		vid.height = vid.conheight = bound(200, r_conheight.integer, vidHeight);
		vid.width = vid.conwidth = bound(320, (int)(r_conheight.integer*ar_w + 0.5), vidWidth);

		set_width = true;
	}
	else if (r_conheight.integer == 0) {
		double ar_h = (double)vidHeight/(double)vidWidth;

		vid.height = vid.conheight = bound(200, (int)(r_conwidth.integer*ar_h + 0.5), vidHeight);
		vid.width = vid.conwidth = bound(320, r_conwidth.integer, vidWidth);

		set_height = true;
	}
	else {
		// User specified, use that but check boundaries
		vid.width = vid.conwidth = bound(320, r_conwidth.integer,  vidWidth);
		vid.height = vid.conheight = bound(200, r_conheight.integer, vidHeight);

		Cvar_SetValue(&r_conwidth, vid.conwidth);
		Cvar_SetValue(&r_conheight, vid.conheight);
	}

	if (set_width) {
		Cvar_AutoSetInt(&r_conwidth, vid.conwidth);
	}
	if (set_height) {
		Cvar_AutoSetInt(&r_conheight, vid.conheight);
	}

	vid.aspect = (double) vidWidth / (double) vidHeight;

	vid.numpages = 2; // ??
	Draw_AdjustConback();
	vid.recalc_refdef = 1;
	Con_CheckResize();
}

void GL_FramebufferSetFiltering(qbool linear);

static void framebuffer_smooth_changed_callback(cvar_t* var, char* string, qbool* cancel)
{
	if (string[0] == '\0' || string[1] != '\0' || !(string[0] == '0' || string[0] == '1')) {
		Com_Printf("Value of %s must be 0 or 1\n", var->name);
		*cancel = true;
		return;
	}

	GL_FramebufferSetFiltering(string[0] == '1');
}

static void conres_changed_callback(cvar_t *var, char *string, qbool *cancel)
{
	/* Cvar_SetValue won't trigger a recursive callback since we're in the callback,
	 * but it's required to set the values here first to make them apply, and then cancel
	 * set to true will force the caller to return immediatly when this callback returns...
	 */
	if (var == &r_conwidth) {
		Cvar_SetValue(&r_conwidth, Q_atoi(string));
	}
	else if (var == &r_conheight) {
		Cvar_SetValue(&r_conheight, Q_atoi(string));
	}
	else if (var == &r_conscale) {
		Cvar_SetValue(&r_conscale, Q_atof(string));
	}
	else if (var == &vid_framebuffer) {
		Cvar_SetValue(&vid_framebuffer, Q_atof(string));
	}
	else if (var == &vid_framebuffer_width) {
		Cvar_SetValue(&vid_framebuffer_width, Q_atof(string));
	}
	else if (var == &vid_framebuffer_height) {
		Cvar_SetValue(&vid_framebuffer_height, Q_atof(string));
	}
	else if (var == &vid_framebuffer_scale) {
		Cvar_SetValue(&vid_framebuffer_scale, Q_atof(string));
	}
	else {
		Com_Printf("Called with unknown variable: %s\n", var->name ? var->name : "unknown");
	}

	VID_UpdateConRes();
	*cancel = true;
}

void VID_Init(unsigned char *palette)
{
	vid.colormap = host_colormap;

	Check_Gamma(palette);
	VID_SetPalette(palette);

	VID_RegisterLatchCvars();

	if (!host_initialized) {
		VID_RegisterCvars();
		VID_RegisterCommands();
		VID_ParseCmdLine();
	}

	VID_SDL_Init();

	// print info
	if (!host_initialized || r_verbose.integer) {
		VID_GfxInfo_f();
	}

	VID_UpdateConRes();

	vid_initialized = true;
}

int VID_ScaledWidth3D(void)
{
	if (vid_framebuffer_scale.value > 0) {
		return glConfig.vidWidth / max(vid_framebuffer_scale.value, 0.25);
	}
	else if (vid_framebuffer_width.integer > 0) {
		return max(vid_framebuffer_width.integer, 320);
	}
	return glConfig.vidWidth;
}

int VID_ScaledHeight3D(void)
{
	if (vid_framebuffer_scale.value > 0) {
		return glConfig.vidHeight / max(vid_framebuffer_scale.value, 0.25);
	}
	else if (vid_framebuffer_height.integer > 0) {
		return max(vid_framebuffer_height.integer, 200);
	}
	return glConfig.vidHeight;
}

int VID_RenderWidth2D(void)
{
	if (vid_framebuffer.integer == USE_FRAMEBUFFER_3DONLY) {
		return glConfig.vidWidth;
	}
	return glwidth;
}

int VID_RenderHeight2D(void)
{
	if (vid_framebuffer.integer == USE_FRAMEBUFFER_3DONLY) {
		return glConfig.vidHeight;
	}
	return glheight;
}


================================================
FILE: src/vid_vsync.c
================================================
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#include "quakedef.h"
#include "tr_types.h"

extern cvar_t r_swapInterval;
extern cvar_t vid_vsync_lag_fix;
extern cvar_t vid_vsync_lag_tweak;

#define NUMTIMINGS 5
static double timings[NUMTIMINGS];
static double render_frame_start, render_frame_end;

qbool VID_VSyncIsOn(void)
{
	return (r_swapInterval.integer != 0);
}

qbool VID_VsyncLagEnabled(void)
{
	return VID_VSyncIsOn() && vid_vsync_lag_fix.integer;
}

void VID_RenderFrameEnd(void)
{
	extern double render_frame_end;

	if (VID_VsyncLagEnabled()) {
		render_frame_end = Sys_DoubleTime();
	}
}

// Returns true if it's not time yet to run a frame
qbool VID_VSyncLagFix(void)
{
	extern double vid_last_swap_time;
	double avg_rendertime, tmin, tmax;

	static int timings_idx;
	int i;

	if (!VID_VSyncIsOn() || !vid_vsync_lag_fix.integer) {
		return false;
	}

	if (!glConfig.displayFrequency) {
		Com_Printf("VID_VSyncLagFix: displayFrequency isn't set, can't enable vsync lag fix\n");
		return false;
	}

	// collect statistics so that
	timings[timings_idx] = render_frame_end - render_frame_start;
	timings_idx = (timings_idx + 1) % NUMTIMINGS;
	avg_rendertime = tmin = tmax = 0;
	for (i = 0; i < NUMTIMINGS; i++) {
		if (timings[i] == 0) {
			return false;   // not enough statistics yet
		}

		avg_rendertime += timings[i];

		if (timings[i] < tmin || !tmin) {
			tmax = timings[i];
		}

		if (timings[i] > tmax) {
			tmax = timings[i];
		}
	}
	avg_rendertime /= NUMTIMINGS;
	// if (tmax and tmin differ too much) do_something(); ?
	avg_rendertime = tmax;  // better be on the safe side

	double time_left = vid_last_swap_time + 1.0 / glConfig.displayFrequency - Sys_DoubleTime();
	time_left -= avg_rendertime;
	time_left -= vid_vsync_lag_tweak.value * 0.001;
	if (time_left > 0) {
		extern cvar_t sys_yieldcpu;

		if (time_left > 0.001 && sys_yieldcpu.integer) {
			Sys_MSleep(min(time_left * 1000, 500));
		}

		return true;    // don't run a frame yet
	}

	render_frame_start = Sys_DoubleTime();
	return false;
}


================================================
FILE: src/vk_blending.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_blending.c
// - Converts internal v_blendfunc_t => Vulkan structures

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"
#include "r_state.h"

#include "vk_local.h"

void VK_BlendingConfigure(VkPipelineColorBlendStateCreateInfo* info, VkPipelineColorBlendAttachmentState* blending, r_blendfunc_t func)
{
	memset(info, 0, sizeof(*info));

	info->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
	info->logicOpEnable = VK_FALSE;
	info->logicOp = VK_LOGIC_OP_COPY;
	info->attachmentCount = 1;
	info->pAttachments = blending;
	info->blendConstants[0] = info->blendConstants[1] = info->blendConstants[2] = info->blendConstants[3] = 0.0f;

	memset(blending, 0, sizeof(*blending));

	blending->colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
	blending->colorBlendOp = blending->alphaBlendOp = VK_BLEND_OP_ADD;

	switch (func) {
		case r_blendfunc_overwrite:
			blending->srcColorBlendFactor = blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
			blending->dstColorBlendFactor = blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
			blending->blendEnable = false;
			break;
		case r_blendfunc_additive_blending:
			blending->srcColorBlendFactor = blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
			blending->dstColorBlendFactor = blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
			blending->blendEnable = true;
			break;
		case r_blendfunc_premultiplied_alpha:
			blending->srcColorBlendFactor = blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
			blending->dstColorBlendFactor = blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
			blending->blendEnable = true;
			break;
		case r_blendfunc_src_dst_color_dest_zero:
			blending->srcColorBlendFactor = VK_BLEND_FACTOR_DST_COLOR;
			blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;
			blending->dstColorBlendFactor = blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
			blending->blendEnable = true;
			break;
		case r_blendfunc_src_dst_color_dest_one:
			blending->srcColorBlendFactor = VK_BLEND_FACTOR_DST_COLOR;
			blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;
			blending->dstColorBlendFactor = blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
			blending->blendEnable = true;
			break;
		case r_blendfunc_src_dst_color_dest_src_color:
			blending->srcColorBlendFactor = VK_BLEND_FACTOR_DST_COLOR;
			blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;
			blending->dstColorBlendFactor = VK_BLEND_FACTOR_SRC_COLOR;
			blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
			blending->blendEnable = true;
			break;
		case r_blendfunc_src_zero_dest_one_minus_src_color:
			blending->srcColorBlendFactor = blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
			blending->dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
			blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
			blending->blendEnable = true;
			break;
		case r_blendfunc_src_zero_dest_src_color:
			blending->srcColorBlendFactor = blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
			blending->dstColorBlendFactor = VK_BLEND_FACTOR_SRC_COLOR;
			blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
			blending->blendEnable = true;
			break;
		case r_blendfunc_src_one_dest_zero:
			blending->srcColorBlendFactor = blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
			blending->dstColorBlendFactor = blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
			blending->blendEnable = true;
			break;
		case r_blendfunc_src_zero_dest_one:
			blending->srcColorBlendFactor = blending->srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
			blending->dstColorBlendFactor = blending->dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
			blending->blendEnable = true;
			break;
	}
}

#endif // RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_buffers.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_buffers.c
// - Vulkan buffer handling

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"

#include "vk_local.h"
#include "r_local.h"
#include "r_buffers.h"

typedef struct vk_buffer_s {
	VkBuffer handle;
} vk_buffer_t;

static vk_buffer_t bufferData[64];

static VkBufferUsageFlags VK_BufferMemoryStyle(bufferusage_t usage)
{
	switch (usage) {
		case bufferusage_once_per_frame:
			// filled & used once per frame
			break;
		case bufferusage_reuse_per_frame:
			// filled & used many times per frame
			break;
		case bufferusage_reuse_many_frames:
			// filled once, expect to use many times over subsequent frames
			break;
		case bufferusage_constant_data:
			// filled once, never updated again
			break;
	}
}

static VkBufferUsageFlags VK_BufferUsageForType(buffertype_t type)
{
	switch (type) {
		case buffertype_vertex:
			return VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
		case buffertype_index:
			return VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
		case buffertype_indirect:
			return VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
		case buffertype_storage:
			return VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
		case buffertype_uniform:
			return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
	}

	assert(false);
	Sys_Error("Invalid buffertype passed to VK_BufferUsage(%d)", type);
	return 0;
}

static void VK_BufferStartFrame(void)
{
}

static void VK_BufferEndFrame(void)
{
}

static qbool VK_BufferReady(void)
{
	return true;
}

static buffer_ref VK_BufferCreate(buffertype_t type, const char* name, int size, void* data, bufferusage_t usage)
{
	VkBuffer buffer = { 0 };
	VkBufferCreateInfo bufferInfo = { 0 };
	VkMemoryRequirements memRequirements = { 0 };

	bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
	bufferInfo.size = size;
	bufferInfo.usage = VK_BufferUsageForType(type);
	bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; // FIXME: compute queue?
	if (vkCreateBuffer(vk_options.logicalDevice, &bufferInfo, NULL, &buffer) != VK_SUCCESS) {
		return null_buffer_reference;
	}

	vkGetBufferMemoryRequirements(vk_options.logicalDevice, buffer, &memRequirements);

	// TODO
	//memRequirements.
	return null_buffer_reference;
}

static void VK_BufferEnsureSize(buffer_ref buffer, int size)
{
}

static void VK_BufferInitialiseState(void)
{
}

static size_t VK_BufferSize(buffer_ref vbo)
{
	return 0;
}

static uintptr_t VK_BufferOffset(buffer_ref ref)
{
	return 0;
}

static void VK_BufferBind(buffer_ref ref)
{
}

static void VK_BufferBindBase(buffer_ref ref, unsigned int index)
{
}

static void VK_BufferBindRange(buffer_ref ref, unsigned int index, ptrdiff_t offset, int size)
{
}

static void VK_BufferUnBind(buffertype_t type)
{
}

static void VK_BufferUpdate(buffer_ref vbo, int size, void* data)
{
}

static void VK_BufferUpdateSection(buffer_ref vbo, ptrdiff_t offset, int size, const void* data)
{
}

static buffer_ref VK_BufferResize(buffer_ref vbo, int size, void* data)
{
	return null_buffer_reference;
}

static qbool VK_BufferIsValid(buffer_ref ref)
{
	return false;
}

static void VK_BufferSetElementArray(buffer_ref ref)
{
	return;
}

static void VK_BufferShutdown(void)
{
	return;
}

#ifdef WITH_RENDERING_TRACE
static void VK_PrintBufferState(FILE* output, int depth)
{
}
#endif

void VK_InitialiseBufferHandling(api_buffers_t* api)
{
	memset(api, 0, sizeof(*api));

	api->InitialiseState = VK_BufferInitialiseState;

	api->StartFrame = VK_BufferStartFrame;
	api->EndFrame = VK_BufferEndFrame;
	api->FrameReady = VK_BufferReady;

	api->Size = VK_BufferSize;
	api->Create = VK_BufferCreate;
	api->BufferOffset = VK_BufferOffset;

	api->Bind = VK_BufferBind;
	api->BindBase = VK_BufferBindBase;
	api->BindRange = VK_BufferBindRange;
	api->UnBind = VK_BufferUnBind;

	api->Update = VK_BufferUpdate;
	api->UpdateSection = VK_BufferUpdateSection;
	api->Resize = VK_BufferResize;
	api->EnsureSize = VK_BufferEnsureSize;

	api->IsValid = VK_BufferIsValid;
	api->SetElementArray = VK_BufferSetElementArray;
	api->Shutdown = VK_BufferShutdown;

#ifdef WITH_RENDERING_TRACE
	api->PrintState = VK_PrintBufferState;
#endif
}

#endif // #ifdef RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_debug.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_debug.c
// - Vulkan debug callback

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"

#include <SDL.h>
#include <SDL_vulkan.h>

#include "vk_local.h"

static qbool callbackRegistered = false;
static VkDebugReportCallbackEXT callbackHandle;

static VKAPI_ATTR VkBool32 VKAPI_CALL VK_DebugCallback
(
	VkDebugReportFlagsEXT flags,
	VkDebugReportObjectTypeEXT objType,
	uint64_t obj,
	size_t location,
	int32_t code,
	const char* layerPrefix,
	const char* msg,
	void* userData
)
{
	Con_Printf("vulkan: %s\n", msg);

	return VK_FALSE;
}

void VK_InitialiseDebugCallback(VkInstance instance)
{
	EZ_VKFUNC_DECL_LOAD(instance, vkCreateDebugReportCallbackEXT);

	if (qvkCreateDebugReportCallbackEXT) {
		VkDebugReportCallbackCreateInfoEXT createInfo = { 0 };
		createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
		createInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
		createInfo.pfnCallback = VK_DebugCallback;

		if (qvkCreateDebugReportCallbackEXT(instance, &createInfo, NULL, &callbackHandle) == VK_SUCCESS) {
			callbackRegistered = true;
			Con_Printf("Callback registered\n");
		}
		else {
			Con_Printf("Callback registration failed\n");
		}
	}
	else {
		Con_Printf("Callback not supported\n");
	}
}

void VK_ShutdownDebugCallback(VkInstance instance)
{
	if (callbackRegistered) {
		EZ_VKFUNC_DECL_LOAD(instance, vkDestroyDebugReportCallbackEXT);

		if (qvkDestroyDebugReportCallbackEXT) {
			qvkDestroyDebugReportCallbackEXT(instance, callbackHandle, NULL);
		}
		callbackRegistered = false;
	}
}

#endif // RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_draw.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_draw.c

#ifdef RENDERER_OPTION_VULKAN

#include "quakedef.h"

void VK_HudDrawComplete(void)
{

}

void VK_HudPrepareCircles(void)
{
}

void VK_HudDrawCircles(texture_ref tex, int start, int end)
{
}

void VK_HudPrepareImages(void)
{
}

void VK_HudDrawImages(texture_ref tex, int start, int end)
{
}

void VK_HudPreparePolygons(void)
{
}

void VK_HudDrawPolygons(texture_ref tex, int start, int end)
{
}

void VK_HudPrepareLines(void)
{
}

void VK_HudDrawLines(texture_ref ref, int start, int end)
{
}

void VK_DrawImage(float x, float y, float width, float height, float tex_s, float tex_t, float tex_width, float tex_height, byte* color, int flags)
{
}

void VK_DrawRectangle(float x, float y, float width, float height, byte* color)
{
}

void VK_AdjustImages(int first, int last, float x_offset)
{
}

#endif // #ifdef RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_graphics_pipeline.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_vao.c
// - Vulkan graphics pipeline functions

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"

void VK_CreateGraphicsPipelines(void)
{
	VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
	vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
	vertexInputInfo.vertexBindingDescriptionCount = 0;
	vertexInputInfo.pVertexBindingDescriptions = nullptr; // Optional
	vertexInputInfo.vertexAttributeDescriptionCount = 0;
	vertexInputInfo.pVertexAttributeDescriptions = nullptr; // Optional

	VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
	inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
	inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
	inputAssembly.primitiveRestartEnable = VK_FALSE;
}

#endif // RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_instance.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_instance.c
// - Code to create a vulkan instance

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"

#include <SDL.h>
#include <SDL_vulkan.h>

#include "vk_local.h"

// VK_EXT_debug_report extension to get debug messages 
#define EZ_MAX_ADDITIONAL_EXTENSIONS 1

static const char* validationLayers[] = { "VK_LAYER_LUNARG_standard_validation" };

static qbool VK_AddValidationLayers(VkInstanceCreateInfo* createInfo)
{
	VkLayerProperties* availableLayers = NULL;

	createInfo->enabledLayerCount = 0;
	if (COM_CheckParm(cmdline_param_developer_mode)) {
		unsigned int layerCount, j;
		int i;
		qbool available = true;
		VkResult result;

		result = vkEnumerateInstanceLayerProperties(&layerCount, NULL);
		if (result != VK_SUCCESS) {
			return false;
		}

		availableLayers = Q_malloc(sizeof(availableLayers[0]) * layerCount);
		result = vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
		if (result != VK_SUCCESS) {
			Q_free(availableLayers);
			return false;
		}
		for (i = 0; i < sizeof(validationLayers) / sizeof(validationLayers[0]); ++i) {
			qbool found = false;
			for (j = 0; j < layerCount && !found; ++j) {
				found |= !strcmp(availableLayers[j].layerName, validationLayers[i]);
			}
			available &= found;
		}
		Q_free(availableLayers);

		if (available) {
			createInfo->ppEnabledLayerNames = validationLayers;
			createInfo->enabledLayerCount = sizeof(validationLayers) / sizeof(validationLayers[0]);
			return true;
		}
	}

	return false;
}

qbool VK_CreateInstance(SDL_Window* window, VkInstance* instance)
{
	qbool debugCallback = false;
	VkInstanceCreateInfo createInfo = { 0 };
	VkApplicationInfo appInfo = { 0 };
	VkResult result;
	uint32_t extensionCount = 0;
	const char** extensionStrings;

	appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	appInfo.pApplicationName = "ezQuake";
	appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
	appInfo.pEngineName = "?";
	appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
	appInfo.apiVersion = VK_API_VERSION_1_0;

	createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	createInfo.pApplicationInfo = &appInfo;

	if (!SDL_Vulkan_GetInstanceExtensions(window, &extensionCount, NULL)) {
		Con_Printf("vulkan:GetInstanceExtensions() failed\n");
		return false;
	}

	extensionStrings = Q_malloc(sizeof(extensionStrings[0]) * (extensionCount + EZ_MAX_ADDITIONAL_EXTENSIONS));
	if (!SDL_Vulkan_GetInstanceExtensions(window, &extensionCount, extensionStrings)) {
		Con_Printf("vulkan:GetInstanceExtensions() failed\n");
		return false;
	}

	if (VK_AddValidationLayers(&createInfo)) {
		// Add VK_EXT_DEBUG_REPORT_EXTENSION_NAME
		extensionStrings[extensionCount++] = VK_EXT_DEBUG_REPORT_EXTENSION_NAME;
		Con_Printf("vulkan: validation layers available\n");
		debugCallback = true;
	}

	createInfo.enabledExtensionCount = extensionCount;
	createInfo.ppEnabledExtensionNames = extensionStrings;

	result = vkCreateInstance(&createInfo, NULL, instance);
	Q_free((void*)extensionStrings);
	if (result != VK_SUCCESS) {
		*instance = NULL;
		Con_Printf("vulkan:GetInstanceExtensions() failed\n");
		return false;
	}

	Con_Printf("Vulkan initialised successfully!");

	if (debugCallback) {
		VK_InitialiseDebugCallback(*instance);
	}

	return true;
}

#endif // RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_lightmaps.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifdef RENDERER_OPTION_VULKAN

void VK_CreateLightmapTextures(void)
{
}

void VK_UploadLightmap(int textureUnit, int lightmapnum)
{

}

void VK_BuildLightmap(int lightmapnum)
{
}

#endif // #ifdef RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_local.h
================================================
/*
Copyright (C) 2018 ezQuake team.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_VK_LOCAL_HEADER
#define EZQUAKE_VK_LOCAL_HEADER

#define EZ_VKFUNC_DECL_LOAD(instance, func) PFN_##func q##func = (PFN_##func)vkGetInstanceProcAddr(instance, #func)
#define EZ_VKFUNC_LOAD(instance, func) q##func = (PFN_##func)vkGetInstanceProcAddr(instance, #func)

// vk_main.c
qbool VK_Initialise(SDL_Window* window);
void VK_Shutdown(void);

// vk_instance.c
qbool VK_CreateInstance(SDL_Window* window, VkInstance* instance);

// vk_debug.c
void VK_ShutdownDebugCallback(VkInstance instance);
void VK_InitialiseDebugCallback(VkInstance instance);

// vk_physical_devices.c
qbool VK_SelectPhysicalDevice(VkInstance instance, VkSurfaceKHR surface);
uint32_t VK_PhysicalDeviceGraphicsQueueFamilyIndex(void);
uint32_t VK_PhysicalDeviceComputeQueueFamilyIndex(void);
uint32_t VK_PhysicalDevicePresentQueueFamilyIndex(void);
qbool VK_CreateLogicalDevice(VkInstance instance);

// vk_window_surface.c
qbool VK_CreateWindowSurface(SDL_Window* window, VkInstance instance, VkSurfaceKHR* surface);
void VK_DestroyWindowSurface(VkInstance instance, VkSurfaceKHR surface);

// vk_swapchain.c
qbool VK_CreateSwapChain(SDL_Window* window, VkInstance instance, VkSurfaceKHR surface);
void VK_DestroySwapChain(void);

// vk_blending.c
void VK_BlendingConfigure(VkPipelineColorBlendStateCreateInfo* info, VkPipelineColorBlendAttachmentState* blending, r_blendfunc_t func);

// (common)
typedef struct vk_options_s {
	VkInstance instance;
	VkSurfaceKHR surface;

	VkPhysicalDevice physicalDevice;
	VkPhysicalDeviceFeatures physicalDeviceFeatures;
	VkPhysicalDeviceProperties physicalDeviceProperties;
	uint32_t physicalDeviceGraphicsQueueFamilyIndex;
	uint32_t physicalDeviceComputeQueueFamilyIndex;
	uint32_t physicalDevicePresentQueueFamilyIndex;
	VkPresentModeKHR physicalDevicePresentationMode;
	VkSurfaceFormatKHR physicalDeviceSurfaceFormat;
	VkSurfaceCapabilitiesKHR physicalDeviceSurfaceCapabilities;
	VkDevice logicalDevice;
	VkQueue graphicsQueue;
	VkQueue presentQueue;
	struct {
		VkSwapchainKHR handle;
		VkImage* images;
		VkImageView* imageViews;
		VkExtent2D imageSize;
		int imageCount;
	} swapChain;
} vk_options_t;

extern vk_options_t vk_options;

void VK_PrintGfxInfo(void);

#define VK_Initialise(x) { memset(&x, 0, sizeof(x)); }

#endif


================================================
FILE: src/vk_main.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_main.c
// - Main entry point for Vulkan

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"

#include <SDL.h>
#include <SDL_vulkan.h>

#include "vk_local.h"

vk_options_t vk_options;

qbool VK_Initialise(SDL_Window* window)
{
	memset(&vk_options, 0, sizeof(vk_options));

	if (!VK_CreateInstance(window, &vk_options.instance)) {
		return false;
	}

	if (!VK_CreateWindowSurface(window, vk_options.instance, &vk_options.surface)) {
		VK_Shutdown();
		return false;
	}

	if (!VK_SelectPhysicalDevice(vk_options.instance, vk_options.surface)) {
		VK_Shutdown();
		return false;
	}

	if (!VK_CreateLogicalDevice(vk_options.instance)) {
		VK_Shutdown();
		return false;
	}

	if (!VK_CreateSwapChain(window, vk_options.instance, vk_options.surface)) {
		VK_Shutdown();
		return false;
	}

	Con_Printf("Vulkan initialised successfully\n");
	return true;
}

void VK_Shutdown(r_shutdown_mode_t mode)
{
	if (mode != r_shutdown_reload) {
		VK_DestroySwapChain();

		VK_RenderPassDelete();

		if (vk_options.instance) {
			VK_DestroyWindowSurface(vk_options.instance, vk_options.surface);
			VK_ShutdownDebugCallback(vk_options.instance);
			vkDestroyInstance(vk_options.instance, NULL);
		}

		memset(&vk_options, 0, sizeof(vk_options));
	}

	// FIXME
}

void VK_PopulateConfig(void)
{
}

#endif


================================================
FILE: src/vk_md3.c
================================================

/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_VULKAN

#include "quakedef.h"

void VK_DrawAlias3Model(entity_t* ent, qbool outline, qbool additive_pass)
{
}

#endif // #ifdef RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_misc.c
================================================

/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef RENDERER_OPTION_VULKAN

#include "quakedef.h"

void VK_PrintGfxInfo(void)
{
}

#endif // #ifdef RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_physical_devices.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_physical_devices.c

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"

#include <SDL.h>
#include <SDL_vulkan.h>

#include "vk_local.h"

static const char* validationLayers[] = { "VK_LAYER_LUNARG_standard_validation" };
static const char* requiredDeviceExtensions[] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };

static void VK_PhysicalDeviceQueryQueueFamilies(VkPhysicalDevice device, VkSurfaceKHR surface, int* graphics_queue_index, int* compute_queue_index, int* present_queue_index)
{
	uint32_t queue_families_count;
	VkQueueFamilyProperties* queue_family_properties;
	uint32_t j;

	vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_families_count, NULL);
	queue_family_properties = Q_malloc(sizeof(VkQueueFamilyProperties) * queue_families_count);
	vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_families_count, queue_family_properties);

	*graphics_queue_index = *compute_queue_index = *present_queue_index = -1;
	for (j = 0; j < queue_families_count; ++j) {
		if (queue_family_properties[j].queueCount > 0) {
			if (queue_family_properties[j].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
				*graphics_queue_index = j;

				if (surface != VK_NULL_HANDLE) {
					VkBool32 present_supported;

					if (vkGetPhysicalDeviceSurfaceSupportKHR(device, j, surface, &present_supported) == VK_SUCCESS && present_supported) {
						*present_queue_index = j;
					}
				}
			}
			else if (queue_family_properties[j].queueFlags & VK_QUEUE_COMPUTE_BIT) {
				*compute_queue_index = j;
			}
		}
	}

	Q_free(queue_family_properties);
}

static qbool VK_PhysicalDeviceSupportsRequiredExtensions(VkPhysicalDevice device)
{
	// 
	uint32_t count;
	VkExtensionProperties* properties;
	uint32_t foundCount = 0;
	uint32_t i, j;

	vkEnumerateDeviceExtensionProperties(device, NULL, &count, NULL);
	properties = Q_malloc(count * sizeof(VkExtensionProperties));
	vkEnumerateDeviceExtensionProperties(device, NULL, &count, properties);

	for (i = 0; i < count; ++i) {
		for (j = 0; j < sizeof(requiredDeviceExtensions) / sizeof(requiredDeviceExtensions[0]); ++j) {
			if (!strcmp(properties[i].extensionName, requiredDeviceExtensions[j])) {
				++foundCount;
				break;
			}
		}
	}
	Q_free(properties);

	return (foundCount == sizeof(requiredDeviceExtensions) / sizeof(requiredDeviceExtensions[0]));
}

static qbool VK_PhysicalDeviceBestPresentationMode(VkPhysicalDevice device, VkSurfaceKHR surface, VkPresentModeKHR* best)
{
	extern cvar_t r_swapInterval;
	VkPresentModeKHR preferredModes[] = {
		VK_PRESENT_MODE_MAILBOX_KHR,       // triple buffered
		VK_PRESENT_MODE_IMMEDIATE_KHR,     // tearing
		VK_PRESENT_MODE_FIFO_RELAXED_KHR,
		VK_PRESENT_MODE_FIFO_KHR
	};
	VkPresentModeKHR* presentationModes;
	uint32_t count;
	uint32_t i, j;

	// This is guaranteed to be supported
	if (r_swapInterval.integer) {
		*best = VK_PRESENT_MODE_FIFO_KHR;
		return true;
	}

	if (vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &count, NULL) != VK_SUCCESS) {
		return false;
	}

	presentationModes = Q_malloc(count * sizeof(presentationModes[0]));
	if (vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &count, presentationModes) != VK_SUCCESS) {
		Q_free(presentationModes);
		return false;
	}

	for (i = 0; i < sizeof(preferredModes) / sizeof(preferredModes[0]); ++i) {
		for (j = 0; j < count; ++j) {
			if (preferredModes[i] == presentationModes[j]) {
				Q_free(presentationModes);
				*best = preferredModes[i];
				return true;
			}
		}
	}

	Q_free(presentationModes);
	*best = VK_PRESENT_MODE_FIFO_KHR;
	return true;
}

static qbool VK_PhysicalDeviceSwapChainCompatible(VkPhysicalDevice device, VkSurfaceKHR surface, VkSurfaceFormatKHR* preferred_format, VkSurfaceCapabilitiesKHR* capabilities)
{
	extern cvar_t vid_gammacorrection;
	uint32_t num_formats;
	VkSurfaceFormatKHR* formats;
	VkColorSpaceKHR req_color_space = (vid_gammacorrection.integer ? VK_COLOR_SPACE_SRGB_NONLINEAR_KHR : VK_COLOR_SPACE_PASS_THROUGH_EXT);

	if (vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, capabilities) != VK_SUCCESS) {
		return false;
	}

	if (vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &num_formats, NULL) != VK_SUCCESS || num_formats == 0) {
		return false;
	}
	formats = Q_malloc(num_formats * sizeof(formats[0]));
	if (vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &num_formats, formats) != VK_SUCCESS) {
		Q_free(formats);
		return false;
	}

	if (num_formats == 1 && formats[0].format == VK_FORMAT_UNDEFINED) {
		// Special case: no preferred format
		preferred_format->colorSpace = req_color_space;
		preferred_format->format = VK_FORMAT_B8G8R8A8_UNORM;
	}
	else {
		// Find optimal format.... FIXME (what are we really doing here?)
		uint32_t i;

		for (i = 0; i < num_formats; ++i) {
			if (formats[i].format == VK_FORMAT_B8G8R8A8_UNORM && formats[i].colorSpace == req_color_space) {
				preferred_format->colorSpace = req_color_space;
				preferred_format->format = VK_FORMAT_B8G8R8A8_UNORM;
				break;
			}
		}

		if (i >= num_formats) {
			preferred_format->colorSpace = formats[0].colorSpace;
			preferred_format->format = formats[0].format;
		}
	}
	Q_free(formats);
	return true;
}

qbool VK_SelectPhysicalDevice(VkInstance instance, VkSurfaceKHR surface)
{
	uint32_t deviceCount = 0;
	VkResult result;
	VkPhysicalDevice* physicalDevices;
	uint32_t i;

	result = vkEnumeratePhysicalDevices(instance, &deviceCount, NULL);
	if (result != VK_SUCCESS) {
		Con_Printf("vulkan: enumerating physical devices failed\n");
		return false;
	}
	physicalDevices = Q_malloc(deviceCount * sizeof(VkPhysicalDevice));
	result = vkEnumeratePhysicalDevices(instance, &deviceCount, physicalDevices);
	if (result != VK_SUCCESS) {
		Q_free(physicalDevices);
		return false;
	}

	vk_options.physicalDevice = VK_NULL_HANDLE;
	for (i = 0; i < deviceCount; ++i) {
		VkPhysicalDeviceFeatures features;
		VkPhysicalDeviceProperties properties;
		VkPresentModeKHR best_presentation_mode;
		qbool new_best = true;
		int graphics_queue_index = -1;
		int compute_queue_index = -1;
		int present_queue_index = -1;
		VkSurfaceFormatKHR preferred_format;
		VkSurfaceCapabilitiesKHR capabilities;

		vkGetPhysicalDeviceProperties(physicalDevices[i], &properties);
		Con_Printf("Device %d: %s\n", i, properties.deviceName);

		if (!VK_PhysicalDeviceSupportsRequiredExtensions(physicalDevices[i])) {
			continue;
		}

		// Must support graphics queues
		VK_PhysicalDeviceQueryQueueFamilies(physicalDevices[i], surface, &graphics_queue_index, &compute_queue_index, &present_queue_index);
		if (graphics_queue_index < 0) {
			continue;
		}

		if (!VK_PhysicalDeviceSwapChainCompatible(physicalDevices[i], surface, &preferred_format, &capabilities)) {
			continue;
		}

		if (!VK_PhysicalDeviceBestPresentationMode(physicalDevices[i], surface, &best_presentation_mode)) {
			continue;
		}

		if (vk_options.physicalDevice != VK_NULL_HANDLE) {
			// Score?  Or cvar...
			/*
			vkGetPhysicalDeviceFeatures(physicalDevices[i], &features);

			if (properties.deviceType == )
			physicalDevices[i]*/
			new_best = false;
		}

		if (new_best) {
			vk_options.physicalDevice = physicalDevices[i];
			memcpy(&vk_options.physicalDeviceFeatures, &features, sizeof(vk_options.physicalDeviceFeatures));
			memcpy(&vk_options.physicalDeviceProperties, &properties, sizeof(vk_options.physicalDeviceProperties));
			vk_options.physicalDeviceGraphicsQueueFamilyIndex = graphics_queue_index;
			vk_options.physicalDeviceComputeQueueFamilyIndex = compute_queue_index;
			vk_options.physicalDevicePresentQueueFamilyIndex = present_queue_index;
			vk_options.physicalDevicePresentationMode = best_presentation_mode;
			vk_options.physicalDeviceSurfaceFormat = preferred_format;
			vk_options.physicalDeviceSurfaceCapabilities = capabilities;
		}
	}

	Q_free(physicalDevices);
	if (vk_options.physicalDevice == VK_NULL_HANDLE) {
		Com_Printf("No appropriate device found :(\n");
		return false;
	}

	Com_Printf("Selected device: %s\n", vk_options.physicalDeviceProperties.deviceName);

	return true;
}

uint32_t VK_PhysicalDeviceGraphicsQueueFamilyIndex(void)
{
	assert(vk_options.physicalDevice != VK_NULL_HANDLE);

	return vk_options.physicalDeviceGraphicsQueueFamilyIndex;
}

uint32_t VK_PhysicalDeviceComputeQueueFamilyIndex(void)
{
	assert(vk_options.physicalDevice != VK_NULL_HANDLE);

	return vk_options.physicalDeviceComputeQueueFamilyIndex;
}

uint32_t VK_PhysicalDevicePresentQueueFamilyIndex(void)
{
	assert(vk_options.physicalDevice != VK_NULL_HANDLE);

	return vk_options.physicalDevicePresentQueueFamilyIndex;
}

static qbool VK_AddDeviceValidationLayers(VkDeviceCreateInfo* createInfo)
{
	VkLayerProperties* availableLayers = NULL;

	createInfo->enabledLayerCount = 0;
	if (COM_CheckParm(cmdline_param_developer_mode)) {
		unsigned int layerCount, j;
		int i;
		qbool available = true;
		VkResult result;

		result = vkEnumerateInstanceLayerProperties(&layerCount, NULL);
		if (result != VK_SUCCESS) {
			return false;
		}

		availableLayers = Q_malloc(sizeof(availableLayers[0]) * layerCount);
		result = vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
		if (result != VK_SUCCESS) {
			Q_free(availableLayers);
			return false;
		}
		for (i = 0; i < sizeof(validationLayers) / sizeof(validationLayers[0]); ++i) {
			qbool found = false;
			for (j = 0; j < layerCount && !found; ++j) {
				found |= !strcmp(availableLayers[j].layerName, validationLayers[i]);
			}
			available &= found;
		}
		Q_free(availableLayers);

		if (available) {
			createInfo->ppEnabledLayerNames = validationLayers;
			createInfo->enabledLayerCount = sizeof(validationLayers) / sizeof(validationLayers[0]);
			return true;
		}
	}

	return false;
}

qbool VK_CreateLogicalDevice(VkInstance instance)
{
	VkDeviceQueueCreateInfo queueInfos[2] = { { 0 } };
	VkDeviceCreateInfo deviceInfo = { 0 };
	VkPhysicalDeviceFeatures deviceFeatures = { 0 };
	float priorities[] = { 1.0f };
	uint32_t queueCount = 0;

	queueInfos[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
	queueInfos[0].queueFamilyIndex = VK_PhysicalDeviceGraphicsQueueFamilyIndex();
	queueInfos[0].queueCount = sizeof(priorities) / sizeof(priorities[0]);
	queueInfos[0].pQueuePriorities = priorities;
	++queueCount;

	if (VK_PhysicalDeviceGraphicsQueueFamilyIndex() != VK_PhysicalDevicePresentQueueFamilyIndex()) {
		queueInfos[queueCount].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
		queueInfos[queueCount].queueFamilyIndex = VK_PhysicalDevicePresentQueueFamilyIndex();
		queueInfos[queueCount].queueCount = sizeof(priorities) / sizeof(priorities[0]);
		queueInfos[queueCount].pQueuePriorities = priorities;
		++queueCount;
	}

	deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
	deviceInfo.pQueueCreateInfos = queueInfos;
	deviceInfo.queueCreateInfoCount = sizeof(queueInfos) / sizeof(queueInfos[0]);
	deviceInfo.pEnabledFeatures = &deviceFeatures;

	deviceInfo.enabledExtensionCount = 0;
	VK_AddDeviceValidationLayers(&deviceInfo);

	vk_options.logicalDevice = VK_NULL_HANDLE;
	if (vkCreateDevice(vk_options.physicalDevice, &deviceInfo, NULL, &vk_options.logicalDevice) != VK_SUCCESS) {
		Con_Printf("vkCreateDevice() failed\n");
		return false;
	}

	vkGetDeviceQueue(vk_options.logicalDevice, VK_PhysicalDeviceGraphicsQueueFamilyIndex(), 0, &vk_options.graphicsQueue);
	if (VK_PhysicalDeviceGraphicsQueueFamilyIndex() != VK_PhysicalDevicePresentQueueFamilyIndex()) {
		vkGetDeviceQueue(vk_options.logicalDevice, VK_PhysicalDevicePresentQueueFamilyIndex(), 0, &vk_options.presentQueue);
	}
	else {
		vk_options.presentQueue = vk_options.graphicsQueue;
	}

	return true;
}

#endif // RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_renderpass.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_vao.c
// - Vulkan VAO-equivalent functions

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"
#include "r_state.h"

#include "vk_local.h"

typedef enum {
	vk_renderpass_none,

	vk_renderpass_count
} vk_renderpass_id;

static VkRenderPass renderPasses[vk_renderpass_count];

qbool VK_RenderPassCreate(vk_renderpass_id id)
{
	VkAttachmentDescription colorAttachment;
	VkAttachmentReference colorAttachmentRef;
	VkSubpassDescription subpass;
	VkRenderPassCreateInfo renderPassInfo;

	// single color buffer attachment
	VK_InitialiseStructure(colorAttachment);
	colorAttachment.format = vk_options.physicalDeviceSurfaceFormat.format;
	colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
	colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
	colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

	// attachment reference
	VK_InitialiseStructure(colorAttachmentRef);
	colorAttachmentRef.attachment = 0;
	colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

	// Sub-passes
	VK_InitialiseStructure(subpass);
	subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
	subpass.colorAttachmentCount = 1;
	subpass.pColorAttachments = &colorAttachmentRef;

	// Render pass
	VK_InitialiseStructure(renderPassInfo);
	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
	renderPassInfo.attachmentCount = 1;
	renderPassInfo.pAttachments = &colorAttachment;
	renderPassInfo.subpassCount = 1;
	renderPassInfo.pSubpasses = &subpass;

	if (vkCreateRenderPass(vk_options.logicalDevice, &renderPassInfo, NULL, &renderPasses[id]) != VK_SUCCESS) {
		return false;
	}

	return true;
}

void VK_RenderPassDelete(vk_renderpass_id id)
{
	int i;

	for (i = 0; i < vk_renderpass_count; ++i) {
		if (renderPasses[i]) {
			vkDestroyRenderPass(vk_options.logicalDevice, renderPasses[i], NULL);
		}
	}
}

#endif // RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_sdl.c
================================================
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================

*/

#ifdef RENDERER_OPTION_VULKAN

#include <SDL.h>
#include "quakedef.h"

void VK_SDL_SetupAttributes(void)
{
	// Do nothing at the moment...
}

#endif // #ifdef RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_swapchain.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_main.c
// - Main entry point for Vulkan

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"

#include <SDL.h>
#include <SDL_vulkan.h>

#include "vk_local.h"

qbool VK_CreateSwapChain(SDL_Window* window, VkInstance instance, VkSurfaceKHR surface)
{
	uint32_t requestedImageCount;
	uint32_t queueFamilyIndices[2];
	uint32_t swapChainImageCount;
	uint32_t i;
	VkSwapchainCreateInfoKHR createInfo = { 0 };

	requestedImageCount = vk_options.physicalDeviceSurfaceCapabilities.minImageCount;
	if (vk_options.physicalDevicePresentationMode == VK_PRESENT_MODE_MAILBOX_KHR) {
		requestedImageCount += 1;
	}
	if (vk_options.physicalDeviceSurfaceCapabilities.maxImageCount > 0) {
		requestedImageCount = min(requestedImageCount, vk_options.physicalDeviceSurfaceCapabilities.maxImageCount);
	}

	createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
	createInfo.minImageCount = requestedImageCount;
	createInfo.surface = surface;
	createInfo.imageArrayLayers = 1;
	createInfo.imageColorSpace = vk_options.physicalDeviceSurfaceFormat.colorSpace;
	createInfo.imageFormat = vk_options.physicalDeviceSurfaceFormat.format;
	if (vk_options.physicalDeviceSurfaceCapabilities.currentExtent.width == ~(uint32_t)0) {
		createInfo.imageExtent = vk_options.physicalDeviceSurfaceCapabilities.currentExtent;
	}
	else {
		int width, height;

		SDL_GL_GetDrawableSize(window, &width, &height);

		width = bound(vk_options.physicalDeviceSurfaceCapabilities.minImageExtent.width, width, vk_options.physicalDeviceSurfaceCapabilities.maxImageExtent.width);
		height = bound(vk_options.physicalDeviceSurfaceCapabilities.minImageExtent.height, height, vk_options.physicalDeviceSurfaceCapabilities.maxImageExtent.height);

		createInfo.imageExtent.width = width;
		createInfo.imageExtent.height = height;
	}
	createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; // VK_IMAGE_USAGE_TRANSFER_DST_BIT if pre-processing enabled
	if (VK_PhysicalDeviceGraphicsQueueFamilyIndex() != VK_PhysicalDevicePresentQueueFamilyIndex()) {
		queueFamilyIndices[0] = VK_PhysicalDeviceGraphicsQueueFamilyIndex();
		queueFamilyIndices[1] = VK_PhysicalDevicePresentQueueFamilyIndex();

		createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
		createInfo.queueFamilyIndexCount = 2;
		createInfo.pQueueFamilyIndices = queueFamilyIndices;
	}
	else {
		createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
		createInfo.queueFamilyIndexCount = 0;
		createInfo.pQueueFamilyIndices = NULL;
	}
	createInfo.preTransform = vk_options.physicalDeviceSurfaceCapabilities.currentTransform;
	createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
	createInfo.presentMode = vk_options.physicalDevicePresentationMode;
	createInfo.clipped = VK_FALSE; // meag: setting this to false so we can read-back for screenshots
	createInfo.oldSwapchain = vk_options.swapChain.handle;

	if (vkCreateSwapchainKHR(vk_options.logicalDevice, &createInfo, NULL, &vk_options.swapChain.handle) != VK_SUCCESS) {
		return false;
	}

	// Create images
	Q_free(vk_options.swapChain.images);
	if (vkGetSwapchainImagesKHR(vk_options.logicalDevice, vk_options.swapChain.handle, &swapChainImageCount, NULL) != VK_SUCCESS) {
		return false;
	}
	vk_options.swapChain.images = Q_malloc(swapChainImageCount * sizeof(vk_options.swapChain.images[0]));
	if (vkGetSwapchainImagesKHR(vk_options.logicalDevice, vk_options.swapChain.handle, &swapChainImageCount, vk_options.swapChain.images) != VK_SUCCESS) {
		Q_free(vk_options.swapChain.images);
		return false;
	}
	vk_options.swapChain.imageCount = swapChainImageCount;
	vk_options.swapChain.imageSize = createInfo.imageExtent;

	// Create image views
	vk_options.swapChain.imageViews = Q_malloc(swapChainImageCount * sizeof(vk_options.swapChain.imageViews[0]));
	for (i = 0; i < vk_options.swapChain.imageCount; ++i) {
		VkImageViewCreateInfo createImageViewInfo = { 0 };
		createImageViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
		createImageViewInfo.image = vk_options.swapChain.images[i];
		createImageViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
		createImageViewInfo.format = createInfo.imageFormat;
		createImageViewInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
		createImageViewInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
		createImageViewInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
		createImageViewInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
		createImageViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		createImageViewInfo.subresourceRange.baseMipLevel = 0;
		createImageViewInfo.subresourceRange.levelCount = 1;
		createImageViewInfo.subresourceRange.baseArrayLayer = 0;
		createImageViewInfo.subresourceRange.layerCount = 1;
		if (vkCreateImageView(vk_options.logicalDevice, &createImageViewInfo, NULL, &vk_options.swapChain.imageViews[i]) != VK_SUCCESS) {
			return false;
		}
	}

	return true;
}

void VK_DestroySwapChain(void)
{
	if (vk_options.swapChain.imageViews) {
		uint32_t i;

		for (i = 0; i < vk_options.swapChain.imageCount; ++i) {
			vkDestroyImageView(vk_options.logicalDevice, vk_options.swapChain.imageViews[i], NULL);
		}

		Q_free(vk_options.swapChain.imageViews);
	}

	if (vk_options.swapChain.handle != VK_NULL_HANDLE) {
		vkDestroySwapchainKHR(vk_options.logicalDevice, vk_options.swapChain.handle, NULL);
		vk_options.swapChain.handle = VK_NULL_HANDLE;
	}
}

#endif // RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_vao.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_vao.c
// - Vulkan VAO-equivalent functions

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"
#include "gl_model.h"
#include "r_local.h"
#include "r_vao.h"
#include "r_state.h"

#include "vk_local.h"

#define MAX_VAO_BINDINGS 16

typedef struct {
	VkVertexInputBindingDescription bindings[MAX_VAO_BINDINGS];
	VkVertexInputAttributeDescription attributes[MAX_VAO_BINDINGS];
	VkPipelineVertexInputStateCreateInfo vertexInfo;
} vk_vao_t;

static vk_vao_t vaos[vao_count];

void VK_ConfigureVertexAttribPointer(r_vao_id vao, buffer_ref vbo, uint32_t index, VkFormat format, int stride, uint32_t offset, qbool instanced)
{
	VkVertexInputBindingDescription* binding = vaos[vao].bindings + index;
	VkVertexInputAttributeDescription* attribute = vaos[vao].attributes + index;

	assert(index < MAX_VAO_BINDINGS);

	memset(attribute, 0, sizeof(*attribute));
	memset(binding, 0, sizeof(*binding));

	binding->binding = index;
	binding->stride = stride;
	binding->inputRate = (instanced ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX);

	attribute->binding = index;
	attribute->location = index;
	attribute->format = format;
	attribute->offset = offset;
}

qbool VK_CreateAliasModelPipeline(buffer_ref aliasModelVBO, buffer_ref instanceVBO)
{
	VkPipelineInputAssemblyStateCreateInfo inputAssembly;
	VkViewport viewport = { 0 };
	VkRect2D scissor = { 0 };
	VkPipelineViewportStateCreateInfo viewportState;
	VkPipelineRasterizationStateCreateInfo rasterizer;
	VkPipelineDepthStencilStateCreateInfo depthStencil;
	VkPipelineMultisampleStateCreateInfo multisampling;
	VkPipelineColorBlendAttachmentState blending;
	VkPipelineColorBlendStateCreateInfo colorBlending;
	VkPipeline pipelineLayout;
	VkPipelineLayoutCreateInfo pipelineLayoutInfo;

	VK_InitialiseStructure(inputAssembly);
	VK_InitialiseStructure(viewport);
	VK_InitialiseStructure(scissor);
	VK_InitialiseStructure(viewportState);
	VK_InitialiseStructure(rasterizer);
	VK_InitialiseStructure(depthStencil);
	VK_InitialiseStructure(multisampling);
	VK_InitialiseStructure(blending);
	VK_InitialiseStructure(pipelineLayoutInfo);

	VK_InitialiseStructure(vaos[vao_aliasmodel].vertexInfo);
	vaos[vao_aliasmodel].vertexInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
	vaos[vao_aliasmodel].vertexInfo.pVertexBindingDescriptions = vaos[vao_aliasmodel].bindings;
	vaos[vao_aliasmodel].vertexInfo.pVertexAttributeDescriptions = vaos[vao_aliasmodel].attributes;

	VK_ConfigureVertexAttribPointer(vao_aliasmodel, aliasModelVBO, 0, VK_FORMAT_R32G32B32_SFLOAT, sizeof(vbo_model_vert_t), VK_VBO_FIELDOFFSET(vbo_model_vert_t, position), false);
	VK_ConfigureVertexAttribPointer(vao_aliasmodel, aliasModelVBO, 1, VK_FORMAT_R32G32_SFLOAT, sizeof(vbo_model_vert_t), VK_VBO_FIELDOFFSET(vbo_model_vert_t, texture_coords), false);
	VK_ConfigureVertexAttribPointer(vao_aliasmodel, aliasModelVBO, 2, VK_FORMAT_R32G32B32_SFLOAT, sizeof(vbo_model_vert_t), VK_VBO_FIELDOFFSET(vbo_model_vert_t, normal), false);
	VK_ConfigureVertexAttribPointer(vao_aliasmodel, instanceVBO, 3, VK_FORMAT_R32_UINT, sizeof(uint32_t), 0, true);
	//VK_ConfigureVertexAttribPointer(vao_aliasmodel, aliasModelVBO, 4, VK_FORMAT_R32_SINT, sizeof(vbo_model_vert_t), VK_VBO_FIELDOFFSET(vbo_model_vert_t, flags), false);
	
	inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
	inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
	inputAssembly.primitiveRestartEnable = VK_FALSE;

	viewport.x = 0.0f;
	viewport.y = 0.0f;
	viewport.width = (float)vk_options.swapChain.imageSize.width;
	viewport.height = (float)vk_options.swapChain.imageSize.height;
	viewport.minDepth = 0.0f;
	viewport.maxDepth = 1.0f;

	scissor.offset.x = scissor.offset.y = 0;
	scissor.extent = vk_options.swapChain.imageSize;

	viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
	viewportState.viewportCount = 1;
	viewportState.pViewports = &viewport;
	viewportState.scissorCount = 1;
	viewportState.pScissors = &scissor;

	rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
	rasterizer.depthClampEnable = VK_FALSE;
	rasterizer.rasterizerDiscardEnable = VK_FALSE;
	rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
	rasterizer.lineWidth = 1.0f;
	rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
	rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
	rasterizer.depthBiasEnable = VK_FALSE;
	rasterizer.depthBiasConstantFactor = 0.0f; // Optional
	rasterizer.depthBiasClamp = 0.0f; // Optional
	rasterizer.depthBiasSlopeFactor = 0.0f; // Optional

	multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
	multisampling.sampleShadingEnable = VK_FALSE;
	multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
	multisampling.minSampleShading = 1.0f; // Optional
	multisampling.pSampleMask = NULL; // Optional
	multisampling.alphaToCoverageEnable = VK_FALSE; // Optional
	multisampling.alphaToOneEnable = VK_FALSE; // Optional

	// depth-buffer: todo

	// blending modes
	VK_BlendingConfigure(&colorBlending, &blending, r_blendfunc_premultiplied_alpha);

	pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
	pipelineLayoutInfo.setLayoutCount = 0; // Optional
	pipelineLayoutInfo.pSetLayouts = NULL; // Optional
	pipelineLayoutInfo.pushConstantRangeCount = 0; // Optional
	pipelineLayoutInfo.pPushConstantRanges = NULL; // Optional

	if (vkCreatePipelineLayout(vk_options.logicalDevice, &pipelineLayoutInfo, NULL, &pipelineLayout) != VK_SUCCESS) {
		return false;
	}

	return true;
}

void VK_DeleteVAOs(void)
{
}

void VK_GenVertexArray(r_vao_id vao)
{
}

qbool VK_VertexArrayCreated(r_vao_id vao)
{
	return false;
}

void VK_BindVertexArray(r_vao_id vao)
{
}

qbool VK_InitialiseVAOHandling(void)
{
	return true;
}

#endif // RENDERER_OPTION_VULKAN


================================================
FILE: src/vk_vao.h
================================================
/*
Copyright (C) 2018 ezQuake team.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef EZQUAKE_VK_VAO_HEADER
#define EZQUAKE_VK_VAO_HEADER

#include "r_vao.h"

void VK_DeleteVAOs(void);
void VK_GenVertexArray(r_vao_id vao, const char* name);
qbool VK_VertexArrayCreated(r_vao_id vao);
void VK_BindVertexArray(r_vao_id vao);
qbool VK_InitialiseVAOHandling(void);

#endif // EZQUAKE_VK_VAO_HEADER



================================================
FILE: src/vk_window_surface.c
================================================
/*
Copyright (C) 2018 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

// vk_window_surface.c
// - Window surfaces

#ifdef RENDERER_OPTION_VULKAN

#include <vulkan/vulkan.h>
#include "quakedef.h"

#include <SDL.h>
#include <SDL_vulkan.h>

#include "vk_local.h"

qbool VK_CreateWindowSurface(SDL_Window* window, VkInstance instance, VkSurfaceKHR* surface)
{
	surface = VK_NULL_HANDLE;

	if (SDL_Vulkan_CreateSurface(window, instance, surface) != SDL_TRUE) {
		return false;
	}

	return true;
}

void VK_DestroyWindowSurface(VkInstance instance, VkSurfaceKHR surface)
{
	if (surface != VK_NULL_HANDLE) {
		vkDestroySurfaceKHR(instance, surface, NULL);
		surface = VK_NULL_HANDLE;
	}
}

#endif


================================================
FILE: src/vm.c
================================================
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 */
// vm.c -- virtual machine
/*


intermix code and data
symbol table

a dll has one imported function: VM_SystemCall
and one exported function: Perform


*/
#ifdef USE_PR2
#include "qwsvdef.h"
#include "vm_local.h"

opcode_info_t ops[ OP_MAX ] =
{
	{ 0, 0, 0, 0 }, // undef
	{ 0, 0, 0, 0 }, // ignore
	{ 0, 0, 0, 0 }, // break

	{ 4, 0, 0, 0 }, // enter
	{ 4,-4, 0, 0 }, // leave
	{ 0, 0, 1, 0 }, // call
	{ 0, 4, 0, 0 }, // push
	{ 0,-4, 1, 0 }, // pop

	{ 4, 4, 0, 0 }, // const
	{ 4, 4, 0, 0 }, // local
	{ 0,-4, 1, 0 }, // jump

	{ 4,-8, 2, JUMP }, // eq
	{ 4,-8, 2, JUMP }, // ne

	{ 4,-8, 2, JUMP }, // lti
	{ 4,-8, 2, JUMP }, // lei
	{ 4,-8, 2, JUMP }, // gti
	{ 4,-8, 2, JUMP }, // gei

	{ 4,-8, 2, JUMP }, // ltu
	{ 4,-8, 2, JUMP }, // leu
	{ 4,-8, 2, JUMP }, // gtu
	{ 4,-8, 2, JUMP }, // geu

	{ 4,-8, 2, JUMP }, // eqf
	{ 4,-8, 2, JUMP }, // nef

	{ 4,-8, 2, JUMP }, // ltf
	{ 4,-8, 2, JUMP }, // lef
	{ 4,-8, 2, JUMP }, // gtf
	{ 4,-8, 2, JUMP }, // gef

	{ 0, 0, 1, 0 }, // load1
	{ 0, 0, 1, 0 }, // load2
	{ 0, 0, 1, 0 }, // load4
	{ 0,-8, 2, 0 }, // store1
	{ 0,-8, 2, 0 }, // store2
	{ 0,-8, 2, 0 }, // store4
	{ 1,-4, 1, 0 }, // arg
	{ 4,-8, 2, 0 }, // bcopy

	{ 0, 0, 1, 0 }, // sex8
	{ 0, 0, 1, 0 }, // sex16

	{ 0, 0, 1, 0 }, // negi
	{ 0,-4, 3, 0 }, // add
	{ 0,-4, 3, 0 }, // sub
	{ 0,-4, 3, 0 }, // divi
	{ 0,-4, 3, 0 }, // divu
	{ 0,-4, 3, 0 }, // modi
	{ 0,-4, 3, 0 }, // modu
	{ 0,-4, 3, 0 }, // muli
	{ 0,-4, 3, 0 }, // mulu

	{ 0,-4, 3, 0 }, // band
	{ 0,-4, 3, 0 }, // bor
	{ 0,-4, 3, 0 }, // bxor
	{ 0, 0, 1, 0 }, // bcom

	{ 0,-4, 3, 0 }, // lsh
	{ 0,-4, 3, 0 }, // rshi
	{ 0,-4, 3, 0 }, // rshu

	{ 0, 0, 1, 0 }, // negf
	{ 0,-4, 3, 0 }, // addf
	{ 0,-4, 3, 0 }, // subf
	{ 0,-4, 3, 0 }, // divf
	{ 0,-4, 3, 0 }, // mulf

	{ 0, 0, 1, 0 }, // cvif
	{ 0, 0, 1, 0 } // cvfi
};

const char *opname[ 256 ] = {
	"OP_UNDEF", 

	"OP_IGNORE", 

	"OP_BREAK",

	"OP_ENTER",
	"OP_LEAVE",
	"OP_CALL",
	"OP_PUSH",
	"OP_POP",

	"OP_CONST",

	"OP_LOCAL",

	"OP_JUMP",

	//-------------------

	"OP_EQ",
	"OP_NE",

	"OP_LTI",
	"OP_LEI",
	"OP_GTI",
	"OP_GEI",

	"OP_LTU",
	"OP_LEU",
	"OP_GTU",
	"OP_GEU",

	"OP_EQF",
	"OP_NEF",

	"OP_LTF",
	"OP_LEF",
	"OP_GTF",
	"OP_GEF",

	//-------------------

	"OP_LOAD1",
	"OP_LOAD2",
	"OP_LOAD4",
	"OP_STORE1",
	"OP_STORE2",
	"OP_STORE4",
	"OP_ARG",

	"OP_BLOCK_COPY",

	//-------------------

	"OP_SEX8",
	"OP_SEX16",

	"OP_NEGI",
	"OP_ADD",
	"OP_SUB",
	"OP_DIVI",
	"OP_DIVU",
	"OP_MODI",
	"OP_MODU",
	"OP_MULI",
	"OP_MULU",

	"OP_BAND",
	"OP_BOR",
	"OP_BXOR",
	"OP_BCOM",

	"OP_LSH",
	"OP_RSHI",
	"OP_RSHU",

	"OP_NEGF",
	"OP_ADDF",
	"OP_SUBF",
	"OP_DIVF",
	"OP_MULF",

	"OP_CVIF",
	"OP_CVFI"
};

cvar_t	vm_rtChecks		= { "vm_rtChecks", "1"};

int		vm_debugLevel;

// used by SV_Error to get rid of running vm's before longjmp
// static int forced_unload;

struct vm_s	vmTable[ VM_COUNT ];
void VM_VmInfo_f( void );
void VM_VmProfile_f( void );


void VM_Debug( int level ) {
	vm_debugLevel = level;
}


/*
==============
VM_CheckBounds
==============
*/
void VM_CheckBounds( const vm_t *vm, unsigned int address, unsigned int length )
{
	//if ( !vm->entryPoint )
	{
		if ( (address | length) > vm->dataMask || (address + length) > vm->dataMask )
		{
			SV_Error( "program tried to bypass data segment bounds" );
		}
	}
}

/*
==============
VM_CheckBounds2
==============
*/
void VM_CheckBounds2( const vm_t *vm, unsigned int addr1, unsigned int addr2, unsigned int length )
{
	//if ( !vm->entryPoint )
	{
		if ( (addr1 | addr2 | length) > vm->dataMask || (addr1 + length) > vm->dataMask || (addr2+length) > vm->dataMask )
		{
			SV_Error( "program tried to bypass data segment bounds" );
		}
	}
}

/*
==============
VM_Init
==============
*/

void ED2_PrintEdicts (void);
void PR2_Profile_f (void);
void ED2_PrintEdict_f (void);
void ED_Count (void);
void PR_CleanLogText_Init(void); 
vm_t	*currentVM = NULL; // bk001212
vm_t	*lastVM    = NULL; // bk001212
int     vm_debugLevel;


void *VM_ArgPtr( intptr_t intValue ) {
	if ( !intValue ) {
		return NULL;
	}
	// bk001220 - currentVM is missing on reconnect
	if ( currentVM==NULL )
	  return NULL;

	if ( currentVM->entryPoint ) {
		return (void *)(currentVM->dataBase + intValue);
	}
	else {
		return (void *)(currentVM->dataBase + (intValue & currentVM->dataMask));
	}
}

void *VM_ExplicitArgPtr( vm_t *vm, intptr_t intValue ) {
	if ( !intValue ) {
		return NULL;
	}

	// bk010124 - currentVM is missing on reconnect here as well?
	if ( vm==NULL )
	  return NULL;

	//
	if ( vm->entryPoint ) {
		return (void *)(vm->dataBase + intValue);
	}
	else {
		return (void *)(vm->dataBase + (intValue & vm->dataMask));
	}
}

intptr_t VM_Ptr2VM( void* ptr ) {
	if ( !ptr ) {
		return 0;
	}
	// bk001220 - currentVM is missing on reconnect
	if ( currentVM==NULL )
	  return 0;

	if ( currentVM->entryPoint ) {
		return (intptr_t)ptr;
	} else {
		return (((byte*)ptr - currentVM->dataBase )) & currentVM->dataMask;
	}
}


intptr_t VM_ExplicitPtr2VM( vm_t *vm, void* ptr ) {
	if ( !ptr ) {
		return 0;
	}
	// bk001220 - currentVM is missing on reconnect
	if ( vm==NULL )
	  return 0;

	if ( vm->entryPoint ) {
		return (intptr_t)ptr;
	} else {
		return (((byte*)ptr - vm->dataBase )) & vm->dataMask;
	}
}

/*
===============
VM_ValueToSymbol

Assumes a program counter value
===============
*/
const char *VM_ValueToSymbol( vm_t *vm, int value ) {
	vmSymbol_t	*sym;
	static char		text[MAX_COM_TOKEN];

	sym = vm->symbols;
	if ( !sym ) {
		return "NO SYMBOLS";
	}

	// find the symbol
	while ( sym->next && sym->next->symValue <= value ) {
		sym = sym->next;
	}

	if ( value == sym->symValue ) {
		return sym->symName;
	}

	snprintf( text, sizeof( text ), "%s+%i", sym->symName, value - sym->symValue );

	return text;
}

/*
===============
VM_ValueToFunctionSymbol

For profiling, find the symbol behind this value
===============
*/
vmSymbol_t *VM_ValueToFunctionSymbol( vm_t *vm, int value ) {
	vmSymbol_t	*sym;
	static vmSymbol_t	nullSym;

	sym = vm->symbols;
	if ( !sym ) {
		return &nullSym;
	}

	while ( sym->next && sym->next->symValue <= value ) {
		sym = sym->next;
	}

	return sym;
}

/*
===============
VM_SymbolToValue
===============
*/
int VM_SymbolToValue( vm_t *vm, const char *symbol ) {
	vmSymbol_t	*sym;

	for ( sym = vm->symbols ; sym ; sym = sym->next ) {
		if ( !strcmp( symbol, sym->symName ) ) {
			return sym->symValue;
		}
	}
	return 0;
}

/*
===============
ParseHex
===============
*/
int	ParseHex( const char *text ) {
	int		value;
	int		c;

	value = 0;
	while ( ( c = *text++ ) != 0 ) {
		if ( c >= '0' && c <= '9' ) {
			value = value * 16 + c - '0';
			continue;
		}
		if ( c >= 'a' && c <= 'f' ) {
			value = value * 16 + 10 + c - 'a';
			continue;
		}
		if ( c >= 'A' && c <= 'F' ) {
			value = value * 16 + 10 + c - 'A';
			continue;
		}
	}

	return value;
}

/*
===============
VM_LoadSymbols
===============
*/
void VM_LoadSymbols( vm_t *vm ) {
	union {
		char	*c;
		void	*v;
	} mapfile;
	const char *text_p;
	//char	name[MAX_QPATH];
	char	symbols[MAX_QPATH];
	vmSymbol_t	**prev, *sym;
	int		count;
	int		value;
	size_t	chars;
	int		segment;
	int		numInstructions;

	// don't load symbols if not developer
	//if ( !com_developer->integer ) { return; }

	//COM_StripExtension((char*)vm->name, name);
    snprintf( symbols, sizeof( symbols ), "%s.map", vm->name );
	mapfile.v = FS_LoadTempFile( symbols, NULL );
	if ( !mapfile.c ) {
		Con_Printf( "Couldn't load symbol file: %s\n", symbols );
		return;
	}

	numInstructions = vm->instructionCount;

	// parse the symbols
	text_p = mapfile.c;
	prev = &vm->symbols;
	count = 0;

	while ( 1 ) {
		text_p = COM_Parse( text_p );
		if ( !text_p ) {
			break;
		}
		segment = ParseHex( com_token );
		if ( segment ) {
			COM_Parse( text_p );
			COM_Parse( text_p );
			continue;		// only load code segment values
		}

		text_p = COM_Parse( text_p );
		if ( !text_p ) {
			Con_Printf( "WARNING: incomplete line at end of file\n" );
			break;
		}
		value = ParseHex( com_token );

		text_p = COM_Parse( text_p );
		if ( !text_p ) {
			Con_Printf( "WARNING: incomplete line at end of file\n" );
			break;
		}
		chars = strlen( com_token );
		sym = Hunk_AllocName( sizeof( *sym ) + chars, "qvm-symbols");
		*prev = sym;
		prev = &sym->next;
		sym->next = NULL;

		// convert value from an instruction number to a code offset
		if ( vm->instructionPointers && value >= 0 && value < numInstructions ) {
			value = vm->instructionPointers[value];
		}

		sym->symValue = value;
		strlcpy( sym->symName, com_token, chars + 1 );

		count++;
	}

	vm->numSymbols = count;
	Con_Printf( "%i symbols parsed from %s\n", count, symbols );
    
}

static void VM_SwapLongs( void *data, int length )
{
	int i, *ptr;
	ptr = (int *) data;
	length /= sizeof( int );
	for ( i = 0; i < length; i++ ) {
		ptr[ i ] = LittleLong( ptr[ i ] );
	}
}

/*
============
VM_DllSyscall

Dlls will call this directly

 rcg010206 The horror; the horror.

  The syscall mechanism relies on stack manipulation to get its args.
   This is likely due to C's inability to pass "..." parameters to
   a function in one clean chunk. On PowerPC Linux, these parameters
   are not necessarily passed on the stack, so while (&arg[0] == arg)
   is true, (&arg[1] == 2nd function parameter) is not necessarily
   accurate, as arg's value might have been stored to the stack or
   other piece of scratch memory to give it a valid address, but the
   next parameter might still be sitting in a register.

  Quake's syscall system also assumes that the stack grows downward,
   and that any needed types can be squeezed, safely, into a signed int.

  This hack below copies all needed values for an argument to a
   array in memory, so that Quake can get the correct values. This can
   also be used on systems where the stack grows upwards, as the
   presumably standard and safe stdargs.h macros are used.

  As for having enough space in a signed int for your datatypes, well,
   it might be better to wait for DOOM 3 before you start porting.  :)

  The original code, while probably still inherently dangerous, seems
   to work well enough for the platforms it already works on. Rather
   than add the performance hit for those platforms, the original code
   is still in use there.

  For speed, we just grab 15 arguments, and don't worry about exactly
   how many the syscall actually needs; the extra is thrown away.
 
============
*/
#if 1 // - disabled because now is different for each module
intptr_t QDECL VM_DllSyscall( intptr_t arg, ... ) {
#if !idx386 || defined __clang__
  // rcg010206 - see commentary above
  intptr_t	args[16];
  va_list	ap;
  int i;
  
  args[0] = arg;
  
  va_start( ap, arg );
  for (i = 1; i < ARRAY_LEN( args ); i++ )
    args[ i ] = va_arg( ap, intptr_t );
  va_end( ap );
  
  return currentVM->systemCall( args );
#else // original id code
	return currentVM->systemCall( &arg );
#endif
}
#endif

/*
=================
VM_ValidateHeader
=================
*/
static char *VM_ValidateHeader( vmHeader_t *header, int fileSize ) 
{
	static char errMsg[128];
	int n;

	// truncated
	if ( fileSize < ( sizeof( vmHeader_t ) - sizeof( int ) ) ) {
		sprintf( errMsg, "truncated image header (%i bytes long)", fileSize );
		return errMsg;
	}

	// bad magic
	if ( LittleLong( header->vmMagic ) != VM_MAGIC && LittleLong( header->vmMagic ) != VM_MAGIC_VER2 ) {
		sprintf( errMsg, "bad file magic %08x", LittleLong( header->vmMagic ) );
		return errMsg;
	}
	
	// truncated
	if ( fileSize < sizeof( vmHeader_t ) && LittleLong( header->vmMagic ) != VM_MAGIC_VER2 ) {
		sprintf( errMsg, "truncated image header (%i bytes long)", fileSize );
		return errMsg;
	}

	if ( LittleLong( header->vmMagic ) == VM_MAGIC_VER2 )
		n = sizeof( vmHeader_t );
	else
		n = ( sizeof( vmHeader_t ) - sizeof( int ) );

	// byte swap the header
	VM_SwapLongs( header, n );

	// bad code offset
	if ( header->codeOffset >= fileSize ) {
		sprintf( errMsg, "bad code segment offset %i", header->codeOffset );
		return errMsg;
	}

	// bad code length
	if ( header->codeLength <= 0 || header->codeOffset + header->codeLength > fileSize ) {
		sprintf( errMsg, "bad code segment length %i", header->codeLength );
		return errMsg;
	}

	// bad data offset
	if ( header->dataOffset >= fileSize || header->dataOffset != header->codeOffset + header->codeLength ) {
		sprintf( errMsg, "bad data segment offset %i", header->dataOffset );
		return errMsg;
	}

	// bad data length
	if ( header->dataOffset + header->dataLength > fileSize )  {
		sprintf( errMsg, "bad data segment length %i", header->dataLength );
		return errMsg;
	}

	if ( header->vmMagic == VM_MAGIC_VER2 ) 
	{
		// bad lit/jtrg length
		if ( header->dataOffset + header->dataLength + header->litLength + header->jtrgLength != fileSize ) {
			sprintf( errMsg, "bad lit/jtrg segment length" );
			return errMsg;
		}
	} 
	// bad lit length
	else if ( header->dataOffset + header->dataLength + header->litLength != fileSize ) 
	{
		sprintf( errMsg, "bad lit segment length %i", header->litLength );
		return errMsg;
	}

	return NULL;	
}

/*
=================
VM_LoadQVM

Load a .qvm file

if ( alloc )
 - Validate header, swap data
 - Alloc memory for data/instructions
 - Alloc memory for instructionPointers - NOT NEEDED
 - Load instructions
 - Clear/load data
else
 - Check for header changes
 - Clear/load data

=================
*/
static vmHeader_t *VM_LoadQVM( vm_t *vm, qbool alloc ) {
	int					length;
	unsigned int		dataLength;
	unsigned int		dataAlloc;
	int					i;
	char				filename[MAX_QPATH], *errorMsg;
	unsigned int		crc32sum;
	//qbool			tryjts;
	vmHeader_t			*header;
	char    num[32];

	// load the image
	snprintf( filename, sizeof( filename ), "%s.qvm", vm->name );
	Con_Printf( "Loading vm file %s...\n", filename );
	header = ( vmHeader_t*)FS_LoadTempFile( filename, &length );
	if ( !header ) {
		Con_Printf( "Failed.\n" );
		VM_Free( vm );
		return NULL;
	}

	crc32sum = CRC_Block( ( byte * ) header, length );
	sprintf( num, "%i",  crc32sum );
	Info_SetValueForStarKey( svs.info, "*progs", num, MAX_SERVERINFO_STRING );

	// will also swap header
	errorMsg = VM_ValidateHeader( header, length );
	if ( errorMsg ) {
		VM_Free( vm );
		Con_Printf( "%s\n", errorMsg );
		return NULL;
	}

	vm->crc32sum = crc32sum;
	//tryjts = false;

	if( header->vmMagic == VM_MAGIC_VER2 ) {
		Con_Printf( "...which has vmMagic VM_MAGIC_VER2\n" );
	} else {
	//	tryjts = true;
	}

	vm->exactDataLength = header->dataLength + header->litLength + header->bssLength;
	dataLength = vm->exactDataLength + PROGRAM_STACK_EXTRA;
	vm->dataLength = dataLength;

	// round up to next power of 2 so all data operations can
	// be mask protected
	for ( i = 0 ; dataLength > ( 1 << i ) ; i++ ) 
		;
	dataLength = 1 << i;

	// reserve some space for effective LOCAL+LOAD* checks
	dataAlloc = dataLength + 1024;

	if ( dataLength >= (1U<<31) || dataAlloc >= (1U<<31) ) {
		VM_Free( vm );
		Con_Printf( "%s: data segment is too large\n", __func__ );
		return NULL;
	}

	if ( alloc ) {
		// allocate zero filled space for initialized and uninitialized data
		vm->dataBase = Hunk_AllocName( dataAlloc, "qvm");
		vm->dataMask = dataLength - 1;
		vm->dataAlloc = dataAlloc;
	} else {
		// clear the data, but make sure we're not clearing more than allocated
		if ( vm->dataAlloc != dataAlloc ) {
			VM_Free( vm );
			Con_Printf( "Warning: Data region size of %s not matching after"
					"VM_Restart()\n", filename );
			return NULL;
		}
		memset( vm->dataBase, 0, vm->dataAlloc );
	}

	// copy the intialized data
	memcpy( vm->dataBase, (byte *)header + header->dataOffset, header->dataLength + header->litLength );

	// byte swap the longs
	VM_SwapLongs( vm->dataBase, header->dataLength );

	if( header->vmMagic == VM_MAGIC_VER2 ) {
		int previousNumJumpTableTargets = vm->numJumpTableTargets;

		header->jtrgLength &= ~0x03;

		vm->numJumpTableTargets = header->jtrgLength >> 2;
		Con_Printf( "Loading %d jump table targets\n", vm->numJumpTableTargets );

		if ( alloc ) {
			vm->jumpTableTargets = Hunk_AllocName( header->jtrgLength, "qvm-jtt");
		} else {
			if ( vm->numJumpTableTargets != previousNumJumpTableTargets ) {
				VM_Free( vm );

				Con_Printf( "Warning: Jump table size of %s not matching after "
						"VM_Restart()\n", filename );
				return NULL;
			}

			memset( vm->jumpTableTargets, 0, header->jtrgLength );
		}

		memcpy( vm->jumpTableTargets, (byte *)header + header->dataOffset +
				header->dataLength + header->litLength, header->jtrgLength );

		// byte swap the longs
		VM_SwapLongs( vm->jumpTableTargets, header->jtrgLength );
	}

	/*if ( tryjts == true && (length = Load_JTS( vm, crc32sum, NULL, vmPakIndex )) >= 0 ) {
		// we are trying to load newer file?
		if ( vm->jumpTableTargets && vm->numJumpTableTargets != length >> 2 ) {
			Con_Printf( "Reload jts file\n" );
			vm->jumpTableTargets = NULL;
			alloc = true;
		}
		vm->numJumpTableTargets = length >> 2;
		Con_Printf( "Loading %d external jump table targets\n", vm->numJumpTableTargets );
		if ( alloc == true ) {
			vm->jumpTableTargets = Hunk_Alloc( length);
		} else {
			memset( vm->jumpTableTargets, 0, length );
		}
		Load_JTS( vm, crc32sum, vm->jumpTableTargets, vmPakIndex );
	}*/

	return header;
}

/*
=================
VM_LoadInstructions

loads instructions in structured format
=================
*/
const char *VM_LoadInstructions( const byte *code_pos, int codeLength, int instructionCount, instruction_t *buf )
{
	static char errBuf[ 128 ];
	const byte *code_start, *code_end;
	int i, n, op0, op1, opStack;
	instruction_t *ci;
	
	code_start = code_pos; // for printing
	code_end = code_pos + codeLength;

	ci = buf;
	opStack = 0;
	op1 = OP_UNDEF;

	// load instructions and perform some initial calculations/checks
	for ( i = 0; i < instructionCount; i++, ci++, op1 = op0 ) {
		op0 = *code_pos;
		if ( op0 < 0 || op0 >= OP_MAX ) {
			sprintf( errBuf, "bad opcode %02X at offset %d", op0, (int)(code_pos - code_start) );
			return errBuf;
		}
		n = ops[ op0 ].size;
		if ( code_pos + 1 + n  > code_end ) {
			sprintf( errBuf, "code_pos > code_end" );
			return errBuf;
		}
		code_pos++;
		ci->op = op0;
		if ( n == 4 ) {
			ci->value = LittleLong( *((int*)code_pos) );
			code_pos += 4;
		} else if ( n == 1 ) { 
			ci->value = *((unsigned char*)code_pos);
			code_pos += 1;
		} else {
			ci->value = 0;
		}

		// setup jump value from previous const
		if ( op0 == OP_JUMP && op1 == OP_CONST ) {
			ci->value = (ci-1)->value;
		}

		ci->opStack = opStack;
		opStack += ops[ op0 ].stack;
	}

	return NULL;
}

/*
===============================
VM_CheckInstructions

performs additional consistency and security checks
===============================
*/
const char *VM_CheckInstructions( instruction_t *buf,
								int instructionCount,
								const byte *jumpTableTargets,
								int numJumpTableTargets,
								int dataLength )
{
	static char errBuf[ 128 ];
	int i, n, v, op0, op1, opStack, pstack;
	instruction_t *ci, *proc;
	int startp, endp;

	ci = buf;
	opStack = 0;

	// opstack checks
	for ( i = 0; i < instructionCount; i++, ci++ ) {
		opStack += ops[ ci->op ].stack;
		if ( opStack < 0 ) {
			sprintf( errBuf, "opStack underflow at %i", i ); 
			return errBuf;
		}
		if ( opStack >= PROC_OPSTACK_SIZE * 4 ) {
			sprintf( errBuf, "opStack overflow at %i", i ); 
			return errBuf;
		}
	}

	ci = buf;
	pstack = 0;
	op1 = OP_UNDEF;
	proc = NULL;

	startp = 0;
	endp = instructionCount - 1;

	// Additional security checks

	for ( i = 0; i < instructionCount; i++, ci++, op1 = op0 ) {
		op0 = ci->op;

		// function entry
		if ( op0 == OP_ENTER ) {
			// missing block end 
			if ( proc || ( pstack && op1 != OP_LEAVE ) ) {
				sprintf( errBuf, "missing proc end before %i", i ); 
				return errBuf;
			}
			if ( ci->opStack != 0 ) {
				v = ci->opStack;
				sprintf( errBuf, "bad entry opstack %i at %i", v, i ); 
				return errBuf;
			}
			v = ci->value;
			if ( v < 0 || v >= PROGRAM_STACK_SIZE || (v & 3) ) {
				sprintf( errBuf, "bad entry programStack %i at %i", v, i ); 
				return errBuf;
			}
			
			pstack = ci->value;
			
			// mark jump target
			ci->jused = 1;
			proc = ci;
			startp = i + 1;

			// locate endproc
			for ( endp = 0, n = i+1 ; n < instructionCount; n++ ) {
				if ( buf[n].op == OP_PUSH && buf[n+1].op == OP_LEAVE ) {
					endp = n;
					break;
				}
			}

			if ( endp == 0 ) {
				sprintf( errBuf, "missing end proc for %i", i ); 
				return errBuf;
			}

			continue;
		}

		// proc opstack will carry max.possible opstack value
		if ( proc && ci->opStack > proc->opStack ) 
			proc->opStack = ci->opStack;

		// function return
		if ( op0 == OP_LEAVE ) {
			// bad return programStack
			if ( pstack != ci->value ) {
				v = ci->value;
				sprintf( errBuf, "bad programStack %i at %i", v, i ); 
				return errBuf;
			}
			// bad opStack before return
			if ( ci->opStack != 4 ) {
				v = ci->opStack;
				sprintf( errBuf, "bad opStack %i at %i", v, i );
				return errBuf;
			}
			v = ci->value;
			if ( v < 0 || v >= PROGRAM_STACK_SIZE || (v & 3) ) {
				sprintf( errBuf, "bad return programStack %i at %i", v, i ); 
				return errBuf;
			}
			if ( op1 == OP_PUSH ) {
				if ( proc == NULL ) {
					sprintf( errBuf, "unexpected proc end at %i", i ); 
					return errBuf;
				}
				proc = NULL;
				startp = i + 1; // next instruction
				endp = instructionCount - 1; // end of the image
			}
			continue;
		}

		// conditional jumps
		if ( ops[ ci->op ].flags & JUMP ) {
			v = ci->value;
			// conditional jumps should have opStack == 8
			if ( ci->opStack != 8 ) {
				sprintf( errBuf, "bad jump opStack %i at %i", ci->opStack, i ); 
				return errBuf;
			}
			//if ( v >= header->instructionCount ) {
			// allow only local proc jumps
			if ( v < startp || v > endp ) {
				sprintf( errBuf, "jump target %i at %i is out of range (%i,%i)", v, i-1, startp, endp );
				return errBuf;
			}
			if ( buf[v].opStack != 0 ) {
				n = buf[v].opStack;
				sprintf( errBuf, "jump target %i has bad opStack %i", v, n ); 
				return errBuf;
			}
			// mark jump target
			buf[v].jused = 1;
			continue;
		}

		// unconditional jumps
		if ( op0 == OP_JUMP ) {
			// jumps should have opStack == 4
			if ( ci->opStack != 4 ) {
				sprintf( errBuf, "bad jump opStack %i at %i", ci->opStack, i ); 
				return errBuf;
			}
			if ( op1 == OP_CONST ) {
				v = buf[i-1].value;
				// allow only local jumps
				if ( v < startp || v > endp ) {
					sprintf( errBuf, "jump target %i at %i is out of range (%i,%i)", v, i-1, startp, endp );
					return errBuf;
				}
				if ( buf[v].opStack != 0 ) {
					n = buf[v].opStack;
					sprintf( errBuf, "jump target %i has bad opStack %i", v, n ); 
					return errBuf;
				}
				if ( buf[v].op == OP_ENTER ) {
					n = buf[v].op;
					sprintf( errBuf, "jump target %i has bad opcode %i", v, n ); 
					return errBuf;
				}
				if ( v == (i-1) ) {
					sprintf( errBuf, "self loop at %i", v ); 
					return errBuf;
				}
				// mark jump target
				buf[v].jused = 1;
			} else {
				if ( proc )
					proc->swtch = 1;
				else
					ci->swtch = 1;
			}
			continue;
		}

		if ( op0 == OP_CALL ) {
			if ( ci->opStack < 4 ) {
				sprintf( errBuf, "bad call opStack at %i", i ); 
				return errBuf;
			}
			if ( op1 == OP_CONST ) {
				v = buf[i-1].value;
				// analyse only local function calls
				if ( v >= 0 ) {
					if ( v >= instructionCount ) {
						sprintf( errBuf, "call target %i is out of range", v ); 
						return errBuf;
					}
					if ( buf[v].op != OP_ENTER ) {
						n = buf[v].op;
						sprintf( errBuf, "call target %i has bad opcode %i", v, n );
						return errBuf;
					}
					if ( v == 0 ) {
						sprintf( errBuf, "explicit vmMain call inside VM" );
						return errBuf;
					}
					// mark jump target
					buf[v].jused = 1;
				}
			}
			continue;
		}

		if ( ci->op == OP_ARG ) {
			v = ci->value & 255;
			// argument can't exceed programStack frame
			if ( v < 8 || v > pstack - 4 || (v & 3) ) {
				sprintf( errBuf, "bad argument address %i at %i", v, i );
				return errBuf;
			}
			continue;
		}

		if ( ci->op == OP_LOCAL ) {
			v = ci->value;
			if ( proc == NULL ) {
				sprintf( errBuf, "missing proc frame for local %i at %i", v, i );
				return errBuf;
			}
			if ( (ci+1)->op == OP_LOAD1 || (ci+1)->op == OP_LOAD2 || (ci+1)->op == OP_LOAD4 || (ci+1)->op == OP_ARG ) {
				// FIXME: alloc 256 bytes of programStack in VM_CallCompiled()?
				if ( v < 8 || v >= proc->value + 256 ) {
					sprintf( errBuf, "bad local address %i at %i", v, i );
					return errBuf;
				}
			}
		}

		if ( ci->op == OP_LOAD4 && op1 == OP_CONST ) {
			v = (ci-1)->value;
			if ( v < 0 || v > dataLength - 4 ) {
				sprintf( errBuf, "bad load4 address %i at %i", v, i - 1 );
				return errBuf;
			}
		}

		if ( ci->op == OP_LOAD2 && op1 == OP_CONST ) {
			v = (ci-1)->value;
			if ( v < 0 || v > dataLength - 2 ) {
				sprintf( errBuf, "bad load2 address %i at %i", v, i - 1 );
				return errBuf;
			}
		}

		if ( ci->op == OP_LOAD1 && op1 == OP_CONST ) {
			v =  (ci-1)->value;
			if ( v < 0 || v > dataLength - 1 ) {
				sprintf( errBuf, "bad load1 address %i at %i", v, i - 1 );
				return errBuf;
			}
		}

		if ( ci->op == OP_BLOCK_COPY ) {
			v = ci->value;
			if ( v >= dataLength ) {
				sprintf( errBuf, "bad count %i for block copy at %i", v, i - 1 );
				return errBuf;
			}
		}

//		op1 = op0;
//		ci++;
	}

	if ( op1 != OP_UNDEF && op1 != OP_LEAVE ) {
		sprintf( errBuf, "missing return instruction at the end of the image" );
		return errBuf;
	}

	// ensure that the optimization pass knows about all the jump table targets
	if ( jumpTableTargets ) {
		// first pass - validate
		for( i = 0; i < numJumpTableTargets; i++ ) {
			n = *(int *)(jumpTableTargets + ( i * sizeof( int ) ) );
			if ( n < 0 || n >= instructionCount ) {
				Con_Printf( "jump target %i set on instruction %i that is out of range [0..%i]",
					i, n, instructionCount - 1 ); 
				break;
			}
			if ( buf[n].opStack != 0 ) {
				Con_Printf( "jump target %i set on instruction %i (%s) with bad opStack %i\n",
					i, n, opname[ buf[n].op ], buf[n].opStack ); 
				break;
			}
		}
		if ( i != numJumpTableTargets ) {
			// we may trap this on buggy VM_MAGIC_VER2 images
			// but we can safely optimize code even without JTRGSEG
			// so just switch to VM_MAGIC path here
			goto __noJTS;
		}
		// second pass - apply
		for( i = 0; i < numJumpTableTargets; i++ ) {
			n = *(int *)(jumpTableTargets + ( i * sizeof( int ) ) );
			buf[n].jused = 1;
		}
	} else {
__noJTS:
		v = 0;
		// instructions with opStack > 0 can't be jump labels so its safe to optimize/merge
		for ( i = 0, ci = buf; i < instructionCount; i++, ci++ ) {
			if ( ci->op == OP_ENTER ) {
				v = ci->swtch;
				continue;
			}
			// if there is a switch statement in function -
			// mark all potential jump labels
			if ( ci->swtch )
				v = ci->swtch;
			if ( ci->opStack > 0 )
				ci->jused = 0;
			else if ( v )
				ci->jused = 1;
		}
	}

	return NULL;
}
qbool VM_LoadNative( vm_t * vm)
{
	char    name[MAX_OSPATH];
	char   *gpath = NULL;
	void    ( *dllEntry ) ( void * );

	while ( ( gpath = FS_NextPath( gpath ) ) )
	{
		snprintf( name, sizeof( name ), "%s/%s." DLEXT, gpath, vm->name );
		vm->dllHandle = Sys_DLOpen( name );
		if ( vm->dllHandle )
		{
			Con_Printf( "LoadLibrary (%s)\n", name );
			break;
		}
	}
	if ( !vm->dllHandle )
		return false;

	dllEntry = Sys_DLProc( vm->dllHandle, "dllEntry" );
	vm->entryPoint = Sys_DLProc( vm->dllHandle, "vmMain" );
	if ( !dllEntry || !vm->entryPoint )
	{
        Sys_DLClose( vm->dllHandle );
		SV_Error( "VM_LoadNative: couldn't initialize module %s", name );
	}
	dllEntry( vm->dllSyscall );

	Info_SetValueForStarKey( svs.info, "*qvm", DLEXT, MAX_SERVERINFO_STRING );
	Info_SetValueForStarKey( svs.info, "*progs", DLEXT, MAX_SERVERINFO_STRING );
	vm->type = VMI_NATIVE;
	return true;
}

/*
================
VM_Create

If image ends in .qvm it will be interpreted, otherwise
it will attempt to load as a system dll
================
*/
vm_t *VM_Create( vmIndex_t index, const char	*name, syscall_t systemCalls, /*dllSyscall_t dllSyscalls,*/ vmInterpret_t interpret ) {
	//int			remaining;
	vmHeader_t	*header;
	vm_t		*vm;

	if ( !systemCalls ) {
		SV_Error( "VM_Create: bad parms" );
	}

	if ( (unsigned)index >= VM_COUNT ) {
		SV_Error( "VM_Create: bad vm index %i", index );	
	}

	//remaining = Hunk_MemoryRemaining();

	vm = &vmTable[ index ];

	// see if we already have the VM
	if ( vm->name ) {
		if ( vm->index != index ) {
			SV_Error( "VM_Create: bad allocated vm index %i", vm->index );
			return NULL;
		}
		return vm;
	}

	vm->name = name;
	vm->index = index;
	vm->systemCall = systemCalls;
	vm->dllSyscall = VM_DllSyscall;//dllSyscalls;
	//vm->privateFlag = CVAR_PRIVATE;

	// never allow dll loading with a demo
	/*if ( interpret == VMI_NATIVE ) {
		if ( Cvar_VariableIntegerValue( "fs_restrict" ) ) {
			interpret = VMI_COMPILED;
		}
	}*/

	if ( interpret == VMI_NATIVE ) {
		// try to load as a system dll
		//Con_Printf( "Loading dll file %s.\n", name );
		if ( VM_LoadNative( vm ) ) {
			//vm->privateFlag = 0; // allow reading private cvars
			vm->dataAlloc = ~0U;
			vm->dataMask = ~0U;
			vm->dataBase = 0;
			return vm;
		}

		Con_Printf( "Failed to load dll, looking for qvm.\n" );
		interpret = VMI_COMPILED;
	}

	// load the image
	if( ( header = VM_LoadQVM( vm, true ) ) == NULL ) {
		return NULL;
	}

	// allocate space for the jump targets, which will be filled in by the compile/prep functions
	vm->instructionCount = header->instructionCount;
	//vm->instructionPointers = Hunk_Alloc(vm->instructionCount * sizeof(*vm->instructionPointers), h_high);
	vm->instructionPointers = NULL;

	// copy or compile the instructions
	vm->codeLength = header->codeLength;

	// the stack is implicitly at the end of the image
	vm->programStack = vm->dataMask + 1;
	vm->stackBottom = vm->programStack - PROGRAM_STACK_SIZE - PROGRAM_STACK_EXTRA;

	vm->compiled = false;


#ifdef NO_VM_COMPILED
	if(interpret >= VMI_COMPILED) {
		Con_Printf("Architecture doesn't have a bytecode compiler, using interpreter\n");
		interpret = VMI_BYTECODE;
	}
#else
	if ( interpret >= VMI_COMPILED ) {
		if ( VM_Compile( vm, header ) ) {
			vm->compiled = true;
		}
	}
#endif
	// VM_Compile may have reset vm->compiled if compilation failed
	if ( !vm->compiled ) {
		if ( !VM_PrepareInterpreter2( vm, header ) ) {
			//FS_FreeFile( header );	// free the original file
			VM_Free( vm );
			return NULL;
		}
	}
	vm->type = interpret;

	// free the original file
	//FS_FreeFile( header );

	// load the map file
	VM_LoadSymbols( vm );

	//Con_Printf( "%s loaded in %d bytes on the hunk\n", vm->name, remaining - Hunk_MemoryRemaining() );

	return vm;
}

/*
==============
VM_Free
==============
*/
void VM_Free( vm_t *vm ) {

	if( !vm ) {
		return;
	}

/*	if ( vm->callLevel ) {
		if ( !forced_unload ) {
			SV_Error( ERR_FATAL, "VM_Free(%s) on running vm", vm->name );
			return;
		} else {
			Con_Printf( "forcefully unloading %s vm\n", vm->name );
		}
	}*/

	if ( vm->destroy )
		vm->destroy( vm );

	if ( vm->dllHandle )
			Sys_DLClose( vm->dllHandle );

#if 0	// now automatically freed by hunk
	if ( vm->codeBase.ptr ) {
		Z_Free( vm->codeBase.ptr );
	}
	if ( vm->dataBase ) {
		Z_Free( vm->dataBase );
	}
	if ( vm->instructionPointers ) {
		Z_Free( vm->instructionPointers );
	}
#endif
	currentVM = NULL;
	lastVM = NULL;
	memset( vm, 0, sizeof( *vm ) );
}


void VM_Clear( void ) {
	int i;
	for ( i = 0; i < VM_COUNT; i++ ) {
		VM_Free( &vmTable[ i ] );
	}
	currentVM = NULL;
	lastVM = NULL;
}

/*
==============
VM_Call


Upon a system call, the stack will look like:

sp+32	parm1
sp+28	parm0
sp+24	return value
sp+20	return address
sp+16	local1
sp+14	local0
sp+12	arg1
sp+8	arg0
sp+4	return stack
sp		return address

An interpreted function will immediately execute
an OP_ENTER instruction, which will subtract space for
locals from sp
==============
*/

intptr_t QDECL VM_Call( vm_t *vm, int nargs, int callnum, ... )
{
	vm_t	*oldVM;
	intptr_t r;
	int i;

	if ( !vm ) {
		SV_Error( "VM_Call with NULL vm" );
	}


	oldVM = currentVM;
	currentVM = vm;
	lastVM = vm;

	if ( vm_debugLevel ) {
	  Con_Printf( "VM_Call( %d )\n", callnum );
	}

#ifdef DEBUG
	if ( nargs >= MAX_VMMAIN_CALL_ARGS ) {
		SV_Error( "VM_Call: nargs >= MAX_VMMAIN_CALL_ARGS" );
	}
#endif

	++vm->callLevel;
	// if we have a dll loaded, call it directly
	if ( vm->entryPoint ) 
	{
		//rcg010207 -  see dissertation at top of VM_DllSyscall() in this file.
		int args[MAX_VMMAIN_CALL_ARGS-1] = {0};
		va_list ap;
		va_start( ap, callnum );
		for ( i = 0; i < nargs; i++ ) {
			args[i] = va_arg( ap, int );
		}
		va_end(ap);

		// add more agruments if you're changed MAX_VMMAIN_CALL_ARGS:
		r = vm->entryPoint( callnum, args[0], args[1], args[2] );
	} else {
#if idx386 && !defined __clang__ // calling convention doesn't need conversion in some cases
#ifndef NO_VM_COMPILED
		if ( vm->compiled )
			r = VM_CallCompiled( vm, nargs+1, (int*)&callnum );
		else
#endif
			r = VM_CallInterpreted2( vm, nargs+1, (int*)&callnum );
#else
		int args[MAX_VMMAIN_CALL_ARGS] = {0};
		va_list ap;

		args[0] = callnum;
		va_start( ap, callnum );
		for ( i = 0; i < nargs; i++ ) {
			args[i+1] = va_arg( ap, int );
		}
		va_end(ap);
#ifndef NO_VM_COMPILED
		if ( vm->compiled )
			r = VM_CallCompiled( vm, nargs+1, &args[0] );
		else
#endif
			r = VM_CallInterpreted2( vm, nargs+1, &args[0] );
#endif
	}
	--vm->callLevel;
	if ( oldVM != NULL ) // bk001220 - assert(currentVM!=NULL) for oldVM==NULL
	  currentVM = oldVM;

	return r;
}


//=================================================================

static int QDECL VM_ProfileSort( const void *a, const void *b ) {
	vmSymbol_t	*sa, *sb;

	sa = *(vmSymbol_t **)a;
	sb = *(vmSymbol_t **)b;

	if ( sa->profileCount < sb->profileCount ) {
		return -1;
	}
	if ( sa->profileCount > sb->profileCount ) {
		return 1;
	}
	return 0;
}

/*
==============
VM_VmProfile_f

==============
*/
void VM_VmProfile_f( void ) {
	vm_t		*vm;
	vmSymbol_t	**sorted, *sym;
	int			i;
	double		total;

    vm = &vmTable[VM_GAME];

	if ( !vm->name ) {
		Con_Printf( " VM is not running.\n" );
		return;
	}
	if ( vm == NULL ) {
		return;
	}

	if ( !vm->numSymbols ) {
		return;
	}

	sorted = Q_malloc( vm->numSymbols * sizeof( *sorted ) );
	sorted[0] = vm->symbols;
	total = sorted[0]->profileCount;
	for ( i = 1 ; i < vm->numSymbols ; i++ ) {
		sorted[i] = sorted[i-1]->next;
		total += sorted[i]->profileCount;
	}

	qsort( sorted, vm->numSymbols, sizeof( *sorted ), VM_ProfileSort );

	for ( i = 0 ; i < vm->numSymbols ; i++ ) {
		int		perc;

		sym = sorted[i];

		perc = 100 * (float) sym->profileCount / total;
		Con_Printf( "%2i%% %9i %s\n", perc, sym->profileCount, sym->symName );
		sym->profileCount = 0;
	}

	Con_Printf("    %9.0f total\n", total );

	Q_free( sorted );
}

/*
==============
VM_VmInfo_f
==============
*/
void VM_VmInfo_f( void ) {
	vm_t	*vm;
	int		i;

	Con_Printf( "Registered virtual machines:\n" );
	for ( i = 0 ; i < VM_COUNT ; i++ ) {
		vm = &vmTable[i];
		if ( !vm->name ) {
			continue;
		}
		Con_Printf( "%s : ", vm->name );
		if ( vm->dllHandle ) {
			Con_Printf( "native\n" );
			continue;
		}
		if ( vm->compiled ) {
			Con_Printf( "compiled on load\n" );
		} else {
			Con_Printf( "interpreted\n" );
		}
		Con_Printf( "    code length : %7i\n", vm->codeLength );
		Con_Printf( "    table length: %7i\n", vm->instructionCount*4 );
		Con_Printf( "    data length : %7i\n", vm->dataMask + 1 );
	}
}

/*
===============
VM_LogSyscalls

Insert calls to this while debugging the vm compiler
===============
*/
void VM_LogSyscalls(int *args) {
#if 1
	static	int		callnum;
	static	FILE	*f;

	if (!f) {
		f = fopen("syscalls.log", "w");
		if (!f) {
			return;
		}
	}
	callnum++;
	fprintf(f, "%i: %p (%i) = %i %i %i %i\n", callnum, (void*)(args - (int *)currentVM->dataBase),
		args[0], args[1], args[2], args[3], args[4]);
#endif
}
#endif				/* USE_PR2 */


================================================
FILE: src/vm.h
================================================
#ifndef VM_H
#define VM_H

/*
==============================================================

VIRTUAL MACHINE

==============================================================
*/

#ifdef _WIN32
#define QDECL __cdecl
#else
#define QDECL
#endif

typedef struct vm_s vm_t;

typedef enum {
	VMI_NONE,
	VMI_NATIVE,
	VMI_BYTECODE,
	VMI_COMPILED
} vmInterpret_t;


typedef enum {
	VM_BAD = -1,
	VM_GAME = 0,
	VM_COUNT
} vmIndex_t;

extern  vm_t    *currentVM;
typedef intptr_t (*syscall_t)( intptr_t *parms );
typedef intptr_t (QDECL *dllSyscall_t)( intptr_t callNum, ... );
typedef void (QDECL *dllEntry_t)( dllSyscall_t syscallptr );


void	VM_Init( void );
vm_t	*VM_Create( vmIndex_t index, const char* name, syscall_t systemCalls, /*dllSyscall_t dllSyscalls,*/ vmInterpret_t interpret );

extern  vm_t    *currentVM;

// module should be bare: "cgame", not "cgame.dll" or "vm/cgame.qvm"

void	VM_Free( vm_t *vm );
void	VM_Clear(void);
void	VM_Forced_Unload_Start(void);
void	VM_Forced_Unload_Done(void);
vm_t	*VM_Restart( vm_t *vm );

intptr_t	QDECL VM_Call( vm_t *vm, int nargs, int callNum, ... );

void	VM_Debug( int level );
void	VM_CheckBounds( const vm_t *vm, unsigned int address, unsigned int length );
void	VM_CheckBounds2( const vm_t *vm, unsigned int addr1, unsigned int addr2, unsigned int length );

#if 1
#define VM_CHECKBOUNDS VM_CheckBounds
#define VM_CHECKBOUNDS2 VM_CheckBounds2
#else // for performance evaluation purposes
#define VM_CHECKBOUNDS(vm,a,b)
#define VM_CHECKBOUNDS2(vm,a,b,c)
#endif

void	    *VM_ArgPtr( intptr_t intValue );
void *VM_ExplicitArgPtr( vm_t *vm, intptr_t intValue );
intptr_t     VM_Ptr2VM( void* ptr ) ;
intptr_t VM_ExplicitPtr2VM( vm_t *vm, void* ptr );

typedef union floatint_u
{
	int i;
	unsigned int u;
	float f;
	byte b[4];
}
floatint_t;

#define	VMA(x) VM_ArgPtr(args[x])
static inline float _vmf(intptr_t x)
{
	floatint_t v;
	v.i = (int)x;
	return v.f;
}
#define	VMF(x)	_vmf(args[x])

#endif


================================================
FILE: src/vm_interpreted.c
================================================
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifdef USE_PR2
#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "quakedef.h"
#endif
#include "vm_local.h"


char *VM_Indent( vm_t *vm ) {
	static char	*string = "                                        ";
	if ( vm->callLevel > 20 ) {
		return string;
	}
	return string + 2 * ( 20 - vm->callLevel );
}


void VM_StackTrace( vm_t *vm, int programCounter, int programStack ) {
	int		count;

	count = 0;
	do {
		Con_Printf( "%s\n", VM_ValueToSymbol( vm, programCounter ) );
		programStack =  *(int *)&vm->dataBase[programStack+4];
		programCounter = *(int *)&vm->dataBase[programStack];
	} while ( programCounter != -1 && ++count < 32 );

}

// macro opcode sequences
typedef enum {
	MOP_LOCAL_LOAD4 = OP_MAX,
	MOP_LOCAL_LOAD4_CONST,
	MOP_LOCAL_LOCAL,
	MOP_LOCAL_LOCAL_LOAD4,
} macro_op_t;


/*
=================
VM_FindMOps

Search for known macro-op sequences
=================
*/
static void VM_FindMOps( instruction_t *buf, int instructionCount )
{
	int i, op0;
	instruction_t *ci;
	
	ci = buf;
	i = 0;

	while ( i < instructionCount )
	{
		op0 = ci->op;

		if ( op0 == OP_LOCAL && (ci+1)->op == OP_LOAD4 && (ci+2)->op == OP_CONST ) {
			ci->op = MOP_LOCAL_LOAD4_CONST;
			ci += 3; i += 3;
			continue;
		}

		if ( op0 == OP_LOCAL && (ci+1)->op == OP_LOAD4 ) {
			ci->op = MOP_LOCAL_LOAD4;
			ci += 2; i += 2;
			continue;
		}

		if ( op0 == OP_LOCAL && (ci+1)->op == OP_LOCAL && (ci+2)->op == OP_LOAD4 ) {
			ci->op = MOP_LOCAL_LOCAL_LOAD4;
			ci += 3; i += 3;
			continue;
		}

		if ( op0 == OP_LOCAL && (ci+1)->op == OP_LOCAL ) {
			ci->op = MOP_LOCAL_LOCAL;
			ci += 2; i += 2;
			continue;
		}

		ci++;
		i++;
	}
}


/*
====================
VM_PrepareInterpreter2
====================
*/
qbool VM_PrepareInterpreter2( vm_t *vm, vmHeader_t *header ) 
{
	const char *errMsg;
	instruction_t *buf;
	buf = ( instruction_t *) Hunk_AllocName( (vm->instructionCount + 8) * sizeof( instruction_t ), "vm");

	errMsg = VM_LoadInstructions( (byte *) header + header->codeOffset, header->codeLength, header->instructionCount, buf );
	if ( !errMsg ) {
		errMsg = VM_CheckInstructions( buf, vm->instructionCount, vm->jumpTableTargets, vm->numJumpTableTargets, vm->exactDataLength );
	}
	if ( errMsg ) {
		Con_Printf( "VM_PrepareInterpreter2 error: %s\n", errMsg );
		return false;
	}

	//VM_ReplaceInstructions( vm, buf );

	VM_FindMOps( buf, vm->instructionCount );

	vm->codeBase.ptr = (void*)buf;
	return true;
}


/*
==============
VM_CallInterpreted2


Upon a system call, the stack will look like:

sp+32	parm1
sp+28	parm0
sp+24	return stack
sp+20	return address
sp+16	local1
sp+14	local0
sp+12	arg1
sp+8	arg0
sp+4	return stack
sp		return address

An interpreted function will immediately execute
an OP_ENTER instruction, which will subtract space for
locals from sp
==============
*/
int	VM_CallInterpreted2( vm_t *vm, int nargs, int *args ) {
	int		stack[MAX_OPSTACK_SIZE];
	int		*opStack, *opStackTop;
	unsigned int programStack;
	unsigned int stackOnEntry;
	byte	*image;
	int		v1, v0;
	int		dataMask;
	instruction_t *inst, *ci;
	floatint_t	r0, r1;
	int		opcode;
	int		*img;
	int		i;

	// interpret the code
	//vm->currentlyInterpreting = true;

	// we might be called recursively, so this might not be the very top
	programStack = stackOnEntry = vm->programStack;

	// set up the stack frame 
	image = vm->dataBase;
	inst = (instruction_t *)vm->codeBase.ptr;
	dataMask = vm->dataMask;
	
	// leave a free spot at start of stack so
	// that as long as opStack is valid, opStack-1 will
	// not corrupt anything
	opStack = &stack[1];
	opStackTop = stack + ARRAY_LEN( stack ) - 1;

	programStack -= (MAX_VMMAIN_CALL_ARGS+2)*4;
	img = (int*)&image[ programStack ];
	for ( i = 0; i < nargs; i++ ) {
		img[ i + 2 ] = args[ i ];
	}
	img[ 1 ] = 0; 	// return stack
	img[ 0 ] = -1;	// will terminate the loop on return

	ci = inst;

	// main interpreter loop, will exit when a LEAVE instruction
	// grabs the -1 program counter

	while ( 1 ) {

		r0.i = opStack[0];
		r1.i = opStack[-1];

nextInstruction2:

		v0 = ci->value;
		opcode = ci->op; 
		ci++;

		switch ( opcode ) {

		case OP_BREAK:
			vm->breakCount++;
			goto nextInstruction2;

		case OP_ENTER:
			// get size of stack frame
			programStack -= v0;
			if ( programStack <= vm->stackBottom ) {
                VM_StackTrace(vm, ci - (instruction_t *)vm->codeBase.ptr, programStack);
				SV_Error( "VM programStack overflow" );
			}
			if ( opStack + ((ci-1)->opStack/4) >= opStackTop ) {
                VM_StackTrace(vm, ci - (instruction_t *)vm->codeBase.ptr, programStack);
				SV_Error( "VM opStack overflow" );
			}
			break;

		case OP_LEAVE:
			// remove our stack frame
			programStack += v0;

			// grab the saved program counter
			v1 = *(int *)&image[ programStack ];
			// check for leaving the VM
			if ( v1 == -1 ) {
				goto done;
			} else if ( (unsigned)v1 >= vm->instructionCount ) {
                VM_StackTrace(vm, ci - (instruction_t *)vm->codeBase.ptr, programStack);
				SV_Error( "VM program counter out of range in OP_LEAVE" );
			}
			ci = inst + v1;
			break;

		case OP_CALL:
			// save current program counter
			*(int *)&image[ programStack ] = ci - inst;
			
			// jump to the location on the stack
			if ( r0.i < 0 ) {
				// system call
				// save the stack to allow recursive VM entry
				//vm->programStack = programStack - 4;
				vm->programStack = programStack - 8;
				*(int *)&image[ programStack + 4 ] = ~r0.i;
				if (sizeof(int) != sizeof(intptr_t)) {
					// the vm has ints on the stack, we expect
					// longs so we have to convert it
					intptr_t argarr[16];
					int argn;
					for ( argn = 0; argn < ARRAY_LEN( argarr ); ++argn ) {
						argarr[ argn ] = *(int*)&image[ programStack + 4 + 4*argn ];
					}
					v0 = vm->systemCall( &argarr[0] );
				} else {
                    //VM_LogSyscalls( (int *)&image[ programStack + 4 ] );
					v0 = vm->systemCall( (intptr_t *)&image[ programStack + 4 ] );
				}

				// save return value
				//opStack++;
				ci = inst + *(int *)&image[ programStack ];
				*opStack = v0;
			} else if ( r0.u < vm->instructionCount ) {
				// vm call
				ci = inst + r0.i;
				opStack--;
			} else {
                VM_StackTrace(vm, ci - (instruction_t *)vm->codeBase.ptr, programStack);
				SV_Error( "VM program counter out of range in OP_CALL" );
			}
			break;

		// push and pop are only needed for discarded or bad function return values
		case OP_PUSH:
			opStack++;
			break;

		case OP_POP:
			opStack--;
			break;

		case OP_CONST:
			opStack++;
			r1.i = r0.i;
			r0.i = *opStack = v0;
			goto nextInstruction2;

		case OP_LOCAL:
			opStack++;
			r1.i = r0.i;
			r0.i = *opStack = v0 + programStack;
			goto nextInstruction2;

		case OP_JUMP:
			if ( r0.u >= vm->instructionCount ) {
                VM_StackTrace(vm, ci - (instruction_t *)vm->codeBase.ptr, programStack);
				SV_Error( "VM program counter out of range in OP_JUMP" );
			}
			ci = inst + r0.i;
			opStack--;
			break;

		/*
		===================================================================
		BRANCHES
		===================================================================
		*/

		case OP_EQ:
			opStack -= 2;
			if ( r1.i == r0.i )
				ci = inst + v0;
			break;

		case OP_NE:
			opStack -= 2;
			if ( r1.i != r0.i )
				ci = inst + v0;
			break;

		case OP_LTI:
			opStack -= 2;
			if ( r1.i < r0.i )
				ci = inst + v0;
			break;

		case OP_LEI:
			opStack -= 2;
			if ( r1.i <= r0.i )
				ci = inst + v0;
			break;

		case OP_GTI:
			opStack -= 2;
			if ( r1.i > r0.i )
				ci = inst + v0;
			break;

		case OP_GEI:
			opStack -= 2;
			if ( r1.i >= r0.i )
				ci = inst + v0;
			break;

		case OP_LTU:
			opStack -= 2;
			if ( r1.u < r0.u )
				ci = inst + v0;
			break;

		case OP_LEU:
			opStack -= 2;
			if ( r1.u <= r0.u )
				ci = inst + v0;
			break;

		case OP_GTU:
			opStack -= 2;
			if ( r1.u > r0.u )
				ci = inst + v0;
			break;

		case OP_GEU:
			opStack -= 2;
			if ( r1.u >= r0.u )
				ci = inst + v0;
			break;

		case OP_EQF:
			opStack -= 2;
			if ( r1.f == r0.f )
				ci = inst + v0;
			break;

		case OP_NEF:
			opStack -= 2;
			if ( r1.f != r0.f )
				ci = inst + v0;
			break;

		case OP_LTF:
			opStack -= 2;
			if ( r1.f < r0.f )
				ci = inst + v0;
			break;

		case OP_LEF:
			opStack -= 2;
			if ( r1.f <= r0.f )
				ci = inst + v0;
			break;

		case OP_GTF:
			opStack -= 2;
			if ( r1.f > r0.f )
				ci = inst + v0;
			break;

		case OP_GEF:
			opStack -= 2;
			if ( r1.f >= r0.f )
				ci = inst + v0;
			break;

		//===================================================================

		case OP_LOAD1:
			r0.i = *opStack = image[ r0.i & dataMask ];
			goto nextInstruction2;

		case OP_LOAD2:
			r0.i = *opStack = *(unsigned short *)&image[ r0.i & dataMask ];
			goto nextInstruction2;

		case OP_LOAD4:
			r0.i = *opStack = *(int *)&image[ r0.i & dataMask ];
			goto nextInstruction2;

		case OP_STORE1:
			image[ r1.i & dataMask ] = r0.i;
			opStack -= 2;
			break;

		case OP_STORE2:
			*(short *)&image[ r1.i & dataMask ] = r0.i;
			opStack -= 2;
			break;

		case OP_STORE4:
			*(int *)&image[ r1.i & dataMask ] = r0.i;
			opStack -= 2;
			break;

		case OP_ARG:
			// single byte offset from programStack
			*(int *)&image[ ( v0 + programStack ) /*& ( dataMask & ~3 ) */ ] = r0.i;
			opStack--;
			break;

		case OP_BLOCK_COPY:
			{
				int		*src, *dest;
				int		count, srci, desti;

				count = v0;
				// MrE: copy range check
				srci = r0.i & dataMask;
				desti = r1.i & dataMask;
				count = ((srci + count) & dataMask) - srci;
				count = ((desti + count) & dataMask) - desti;

				src = (int *)&image[ srci ];
				dest = (int *)&image[ desti ];
				
				memcpy( dest, src, count );
				opStack -= 2;
			}
			break;

		case OP_SEX8:
			*opStack = (signed char)*opStack;
			break;

		case OP_SEX16:
			*opStack = (short)*opStack;
			break;

		case OP_NEGI:
			*opStack = -r0.i;
			break;

		case OP_ADD:
			opStack[-1] = r1.i + r0.i;
			opStack--;
			break;

		case OP_SUB:
			opStack[-1] = r1.i - r0.i;
			opStack--;
			break;

		case OP_DIVI:
			opStack[-1] = r1.i / r0.i;
			opStack--;
			break;

		case OP_DIVU:
			opStack[-1] = r1.u / r0.u;
			opStack--;
			break;

		case OP_MODI:
			opStack[-1] = r1.i % r0.i;
			opStack--;
			break;

		case OP_MODU:
			opStack[-1] = r1.u % r0.u;
			opStack--;
			break;

		case OP_MULI:
			opStack[-1] = r1.i * r0.i;
			opStack--;
			break;

		case OP_MULU:
			opStack[-1] = r1.u * r0.u;
			opStack--;
			break;

		case OP_BAND:
			opStack[-1] = r1.u & r0.u;
			opStack--;
			break;

		case OP_BOR:
			opStack[-1] = r1.u | r0.u;
			opStack--;
			break;

		case OP_BXOR:
			opStack[-1] = r1.u ^ r0.u;
			opStack--;
			break;

		case OP_BCOM:
			*opStack = ~ r0.u;
			break;

		case OP_LSH:
			opStack[-1] = r1.i << r0.i;
			opStack--;
			break;

		case OP_RSHI:
			opStack[-1] = r1.i >> r0.i;
			opStack--;
			break;

		case OP_RSHU:
			opStack[-1] = r1.u >> r0.i;
			opStack--;
			break;

		case OP_NEGF:
			*(float *)opStack =  - r0.f;
			break;

		case OP_ADDF:
			*(float *)(opStack-1) = r1.f + r0.f;
			opStack--;
			break;

		case OP_SUBF:
			*(float *)(opStack-1) = r1.f - r0.f;
			opStack--;
			break;

		case OP_DIVF:
			*(float *)(opStack-1) = r1.f / r0.f;
			opStack--;
			break;

		case OP_MULF:
			*(float *)(opStack-1) = r1.f * r0.f;
			opStack--;
			break;

		case OP_CVIF:
			*(float *)opStack = (float) r0.i;
			break;

		case OP_CVFI:
			*opStack = (int) r0.f;
			break;

		case MOP_LOCAL_LOAD4:
			ci++;
			opStack++;
			r1.i = r0.i;
			r0.i = *opStack = *(int *)&image[ v0 + programStack ];
			goto nextInstruction2;

		case MOP_LOCAL_LOAD4_CONST:
			r1.i = opStack[1] = *(int *)&image[ v0 + programStack ];
			r0.i = opStack[2] = (ci+1)->value;
			opStack += 2;
			ci += 2;
			goto nextInstruction2;

		case MOP_LOCAL_LOCAL:
			r1.i = opStack[1] = v0 + programStack;
			r0.i = opStack[2] = ci->value + programStack;
			opStack += 2;
			ci++;
			goto nextInstruction2;

		case MOP_LOCAL_LOCAL_LOAD4:
			r1.i = opStack[1] = v0 + programStack;
			r0.i /*= opStack[2]*/ = ci->value + programStack;
			r0.i = opStack[2] = *(int *)&image[ r0.i /*& dataMask*/ ];
			opStack += 2;
			ci += 2;
			goto nextInstruction2;
		}
	}

done:
	//vm->currentlyInterpreting = false;

	if ( opStack != &stack[2] ) {
        VM_StackTrace(vm, ci - (instruction_t *)vm->codeBase.ptr, programStack);
		SV_Error( "Interpreter error: opStack = %ld", (long int) (opStack - stack) );
	}

	vm->programStack = stackOnEntry;

	// return the result
	return *opStack;
}
#endif				/* USE_PR2 */


================================================
FILE: src/vm_local.h
================================================
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 */

#ifndef VM_LOCAL_H
#define VM_LOCAL_H

#include "vm.h"
#define	MAX_OPSTACK_SIZE	512
#define	PROC_OPSTACK_SIZE	30
#define	STACK_MASK	(MAX_OPSTACK_SIZE-1)
#define	DEBUGSTR va("%s%i", VM_Indent(vm), opStack-stack )

// we don't need more than 4 arguments (counting callnum) for vmMain, at least in Quake3
#define MAX_VMMAIN_CALL_ARGS 4

// don't change
// Hardcoded in q3asm an reserved at end of bss
#define	PROGRAM_STACK_SIZE	0x10000

// for some buggy mods
#define	PROGRAM_STACK_EXTRA	(32*1024)

#define PAD(base, alignment)	(((base)+(alignment)-1) & ~((alignment)-1))
#define PADLEN(base, alignment)	(PAD((base), (alignment)) - (base))

typedef enum {
	OP_UNDEF,

	OP_IGNORE,

	OP_BREAK,

	OP_ENTER,
	OP_LEAVE,
	OP_CALL,
	OP_PUSH,
	OP_POP,

	OP_CONST,
	OP_LOCAL,

	OP_JUMP,

	//-------------------

	OP_EQ,
	OP_NE,

	OP_LTI,
	OP_LEI,
	OP_GTI,
	OP_GEI,

	OP_LTU,
	OP_LEU,
	OP_GTU,
	OP_GEU,

	OP_EQF,
	OP_NEF,

	OP_LTF,
	OP_LEF,
	OP_GTF,
	OP_GEF,

	//-------------------

	OP_LOAD1,
	OP_LOAD2,
	OP_LOAD4,
	OP_STORE1,
	OP_STORE2,
	OP_STORE4,				// *(stack[top-1]) = stack[top]
	OP_ARG,

	OP_BLOCK_COPY,

	//-------------------

	OP_SEX8,
	OP_SEX16,

	OP_NEGI,
	OP_ADD,
	OP_SUB,
	OP_DIVI,
	OP_DIVU,
	OP_MODI,
	OP_MODU,
	OP_MULI,
	OP_MULU,

	OP_BAND,
	OP_BOR,
	OP_BXOR,
	OP_BCOM,

	OP_LSH,
	OP_RSHI,
	OP_RSHU,

	OP_NEGF,
	OP_ADDF,
	OP_SUBF,
	OP_DIVF,
	OP_MULF,

	OP_CVIF,
	OP_CVFI,

	OP_MAX
} opcode_t;

typedef struct {
	int		value;	// 32
	byte	op;		// 8
	byte	opStack;	// 8
	unsigned jused:1;
	unsigned swtch:1;
} instruction_t;

typedef struct vmSymbol_s {
	struct vmSymbol_s	*next;
	int		symValue;
	int		profileCount;
	char	symName[1];		// variable sized
} vmSymbol_t;


//typedef void(*vmfunc_t)(void);

typedef union vmFunc_u {
	byte		*ptr;
	void (*func)(void);
} vmFunc_t;

#define	VM_MAGIC	0x12721444
#define	VM_MAGIC_VER2	0x12721445
typedef struct
{
	int		vmMagic;

	int		instructionCount;

	int		codeOffset;
	int		codeLength;

	int		dataOffset;
	int		dataLength;
	int		litLength;			// ( dataLength - litLength ) should be byteswapped on load
	int		bssLength;			// zero filled memory appended to datalength
    	//!!! below here is VM_MAGIC_VER2 !!!
	int		jtrgLength;			// number of jump table targets
} vmHeader_t;


typedef struct vm_s vm_t;

struct vm_s {

	unsigned int programStack;		// the vm may be recursively entered
	syscall_t	systemCall;
	byte		*dataBase;
	int			*opStack;			// pointer to local function stack

	int			instructionCount;
	intptr_t	*instructionPointers;

	//------------------------------------
   
	const char	*name;
	vmIndex_t	index;

	// for dynamic linked modules
	void		*dllHandle;
	dllSyscall_t entryPoint;
	dllSyscall_t dllSyscall;
	void (*destroy)(vm_t* self);

	// for interpreted modules
	//qbool	currentlyInterpreting;

	qbool	compiled;

	vmFunc_t	codeBase;
	unsigned int codeSize;			// code + jump targets, needed for proper munmap()
	unsigned int codeLength;		// just for information

	unsigned int dataMask;
	unsigned int dataLength;			// data segment length
	unsigned int exactDataLength;	// from qvm header
	unsigned int dataAlloc;			// actually allocated

	unsigned int stackBottom;		// if programStack < stackBottom, error
	int			*opStackTop;

	int			numSymbols;
	vmSymbol_t	*symbols;

	int			callLevel;			// counts recursive VM_Call
	int			breakFunction;		// increment breakCount on function entry to this
	int			breakCount;

	byte		*jumpTableTargets;
	int			numJumpTableTargets;

	uint32_t	crc32sum;

	qbool	forceDataMask;
    vmInterpret_t type;
	qbool pr2_references;
	//int			privateFlag;
};

extern	int		vm_debugLevel;

extern cvar_t	vm_rtChecks;
qbool VM_Compile( vm_t *vm, vmHeader_t *header );
int	VM_CallCompiled( vm_t *vm, int nargs, int *args );

qbool VM_PrepareInterpreter2( vm_t *vm, vmHeader_t *header );
int	VM_CallInterpreted2( vm_t *vm, int nargs, int *args );

vmSymbol_t *VM_ValueToFunctionSymbol( vm_t *vm, int value );
int VM_SymbolToValue( vm_t *vm, const char *symbol );
const char *VM_ValueToSymbol( vm_t *vm, int value );
void VM_LogSyscalls( int *args );

const char *VM_LoadInstructions( const byte *code_pos, int codeLength, int instructionCount, instruction_t *buf );
const char *VM_CheckInstructions( instruction_t *buf, int instructionCount, 
								 const byte *jumpTableTargets, 
								 int numJumpTableTargets, 
								 int dataLength );

//void VM_ReplaceInstructions( vm_t *vm, instruction_t *buf );

#define JUMP	(1<<0)

typedef struct opcode_info_s 
{
	int   size; 
	int	  stack;
	int   nargs;
	int   flags;
} opcode_info_t ;

extern opcode_info_t ops[ OP_MAX ];

void	VM_Init( void );
vm_t	*VM_Create( vmIndex_t index, const char* name, syscall_t systemCalls, /*dllSyscall_t dllSyscalls,*/ vmInterpret_t interpret );

// module should be bare: "cgame", not "cgame.dll" or "vm/cgame.qvm"

void	VM_Free( vm_t *vm );
void	VM_Clear(void);
void	VM_Forced_Unload_Start(void);
void	VM_Forced_Unload_Done(void);
vm_t	*VM_Restart( vm_t *vm );

intptr_t	QDECL VM_Call( vm_t *vm, int nargs, int callNum, ... );

void	VM_Debug( int level );
void	VM_CheckBounds( const vm_t *vm, unsigned int address, unsigned int length );
void	VM_CheckBounds2( const vm_t *vm, unsigned int addr1, unsigned int addr2, unsigned int length );

#if 1
#define VM_CHECKBOUNDS VM_CheckBounds
#define VM_CHECKBOUNDS2 VM_CheckBounds2
#else // for performance evaluation purposes
#define VM_CHECKBOUNDS(vm,a,b)
#define VM_CHECKBOUNDS2(vm,a,b,c)
#endif



#endif // VM_LOCAL_H



================================================
FILE: src/vm_x86.c
================================================
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 */

#ifdef USE_PR2
#ifdef SERVERONLY
#include "qwsvdef.h"
#else
#include "quakedef.h"
#include "pr_comp.h"
#include "g_public.h"
#endif
#include "vm_local.h"

#if ( idx386) || (idx64)
#ifdef _WIN32
#include <windows.h>
#endif

#ifdef __FreeBSD__
#include <sys/types.h>
#endif

#ifndef _WIN32
#include <sys/mman.h> // for PROT_ stuff
#endif

/* need this on NX enabled systems (i386 with PAE kernel or
 * noexec32=on x86_64) */
#if defined(__linux__) || defined(__FreeBSD__)
#define VM_X86_MMAP
#endif

//#define VM_LOG_SYSCALLS
#define JUMP_OPTIMIZE 0

#if JUMP_OPTIMIZE
#define NUM_PASSES 7
#else
#define NUM_PASSES 3
#endif

/*
** --------------------------------------------------------------------------------
**
** PROCESSOR STUFF
**
** --------------------------------------------------------------------------------
*/

#define CPU_FCOM   0x01
#define CPU_MMX    0x02
#define CPU_SSE    0x04
#define CPU_SSE2   0x08
#define CPU_SSE3   0x10

int		CPU_Flags = 0;
#if defined _MSC_VER

static void CPUID( int func, unsigned int *regs )
{
#if _MSC_VER >= 1400
	__cpuid( regs, func );
#else
	__asm {
		mov edi,regs
		mov eax,[edi]
		cpuid
		mov [edi], eax
		mov [edi+4], ebx
		mov [edi+8], ecx
		mov [edi+12], edx
	}
#endif
}

#else

static void CPUID( int func, unsigned int *regs )
{
	__asm__ __volatile__( "cpuid" :
		"=a"(regs[0]),
		"=b"(regs[1]),
		"=c"(regs[2]),
		"=d"(regs[3]) :
		"a"(func) );
}
#endif

int Sys_GetProcessorId( char *vendor )
{
	unsigned int regs[4];

	// setup initial features
#if idx64
	CPU_Flags |= CPU_SSE | CPU_SSE2 | CPU_FCOM;
#else
	CPU_Flags = 0;
#endif

	// get CPU feature bits
	CPUID( 1, regs );

	// bit 15 of EDX denotes CMOV/FCMOV/FCOMI existence
	if ( regs[3] & ( 1 << 15 ) )
		CPU_Flags |= CPU_FCOM;

	// bit 23 of EDX denotes MMX existence
	if ( regs[3] & ( 1 << 23 ) )
		CPU_Flags |= CPU_MMX;

	// bit 25 of EDX denotes SSE existence
	if ( regs[3] & ( 1 << 25 ) )
		CPU_Flags |= CPU_SSE;

	// bit 26 of EDX denotes SSE2 existence
	if ( regs[3] & ( 1 << 26 ) )
		CPU_Flags |= CPU_SSE2;

	// bit 0 of ECX denotes SSE3 existence
	if ( regs[2] & ( 1 << 0 ) )
		CPU_Flags |= CPU_SSE3;

	if ( vendor ) {
#if idx64
		strcpy( vendor, "64-bit " );
		vendor += strlen( vendor );
#else
		vendor[0] = '\0';
#endif
		// get CPU vendor string
		CPUID( 0, regs );
		memcpy( vendor+0, (char*) &regs[1], 4 );
		memcpy( vendor+4, (char*) &regs[3], 4 );
		memcpy( vendor+8, (char*) &regs[2], 4 );
		vendor[12] = '\0'; vendor += 12;
		if ( CPU_Flags ) {
			// print features
#if !idx64	// do not print default 64-bit features in 32-bit mode
			strcat( vendor, " w/" );
			if ( CPU_Flags & CPU_FCOM )
				strcat( vendor, " CMOV" );
			if ( CPU_Flags & CPU_MMX )
				strcat( vendor, " MMX" );
			if ( CPU_Flags & CPU_SSE )
				strcat( vendor, " SSE" );
			if ( CPU_Flags & CPU_SSE2 )
				strcat( vendor, " SSE2" );
#endif
			//if ( CPU_Flags & CPU_SSE3 )
			//	strcat( vendor, " SSE3" );
		}
	}
	return 1;
}

static void *VM_Alloc_Compiled( vm_t *vm, int codeLength, int tableLength );
static void VM_Destroy_Compiled( vm_t *vm );

/*
  -------------
  eax	scratch
  ebx*	dataBase
  ecx	scratch (required for shifts)
  edx	scratch (required for divisions)
  esi*	program stack
  edi*	opstack
  ebp*  current proc stack ( dataBase + program stack )
  -------------
  rax	scratch
  rbx*	dataBase
  rcx	scratch (required for shifts)
  rdx	scratch (required for divisions)
  rsi*	programStack
  rdi*	opstack
  rbp*  current proc stack ( dataBase + program stack )
  r8	instructionPointers
  r9    dataMask
  r12*  systemCall
  r13*  stackBottom
  r14*  opStackTop
  xmm0  scratch
  xmm1  scratch
  xmm2  scratch
  xmm3  scratch
  xmm4  scratch
  xmm5  scratch

  Windows  ABI: you are required to preserve the XMM6-XMM15 registers
  System V ABI: you don't have to preserve any of the XMM registers

  Example how data segment will look like during vmMain execution:
  | .... |
  |------| vm->programStack -=36 (8+12+16) // set by vmMain
  | ???? | +0 - unused, reserved for interpreter
  | ???? | +4 - unused, reserved for interpreter
  |-------
  | arg0 | +8  \
  | arg4 | +12  | - passed arguments, accessible from subroutines
  | arg8 | +16 /
  |------|
  | loc0 | +20 \
  | loc4 | +24  \ - locals, accessible only from local scope
  | loc8 | +28  /
  | lc12 | +32 /
  |------| vm->programStack -= 24 ( 8 + MAX_VMMAIN_CALL_ARGS*4 ) // set by VM_CallCompiled()
  | ???? | +0 - unused, reserved for interpreter
  | ???? | +4 - unused, reserved for interpreter
  | arg0 | +8  \
  | arg1 | +12  \ - passed arguments, accessible from vmMain
  | arg2 | +16  / 
  | arg3 | +20 /
  |------| vm->programStack = vm->dataMask + 1 // set by VM_Create()

  jump/call opStack rules:

  1) opStack must be 8 before conditional jump
  2) opStack must be 4 before unconditional jump
  3) opStack must be >=4 before OP_CALL
  4) opStack must remain the same after OP_CALL
  5) you may not jump in/call locations with opStack != 0

*/

#define ISS8(V) ( (V) >= -128 && (V) <= 127 )
#define ISU8(V) ( (V) >= 0 && (V) <= 127 )

#define REWIND(N) { compiledOfs -= (N); instructionOffsets[ ip-1 ] = compiledOfs; };

typedef enum 
{
	REG_EAX = 0,
	REG_ECX
} reg_t;


typedef enum 
{
	LAST_COMMAND_NONE = 0,
	LAST_COMMAND_MOV_EDI_EAX,
	LAST_COMMAND_MOV_EDI_CONST,
	LAST_COMMAND_MOV_EAX_EDI,
	LAST_COMMAND_MOV_EAX_EDI_CALL,
	LAST_COMMAND_SUB_DI_4,
	LAST_COMMAND_SUB_DI_8,
	LAST_COMMAND_SUB_DI_12,
	LAST_COMMAND_STORE_FLOAT_EDI,
	LAST_COMMAND_STORE_FLOAT_EDI_X87,
	LAST_COMMAND_STORE_FLOAT_EDI_SSE
} ELastCommand;

typedef enum 
{
	FUNC_ENTR = 0,
	FUNC_CALL,
	FUNC_SYSC,
	FUNC_FTOL,
	FUNC_BCPY,
	FUNC_NCPY,
	FUNC_PSOF,
	FUNC_OSOF,
	FUNC_BADJ,
	FUNC_ERRJ,
	FUNC_DATA,
	FUNC_LAST
} funcx86_t;

// macro opcode sequences
typedef enum {
	MOP_UNDEF = OP_MAX,
	MOP_IGNORE4,
	MOP_ADD4,
	MOP_SUB4,
	MOP_BAND4,
	MOP_BOR4,
	MOP_NCPY,
} macro_op_t;

static	byte     *code;
static	int      compiledOfs;
static	int      *instructionOffsets;
static	intptr_t *instructionPointers;

static  instruction_t *inst = NULL;
static  instruction_t *ci;
static  instruction_t *ni;

static int fp_cw[2] = { 0x0000, 0x0F7F }; // [0] - current value, [1] - round towards zero

static	int	ip, pass;
static	int	lastConst;
static	opcode_t	pop1;

static	ELastCommand	LastCommand;

int		funcOffset[FUNC_LAST];

#ifdef DEBUG_VM
static int	errParam = 0;
#endif

static void ErrJump( void )
{
	SV_Error( "program tried to execute code outside VM" ); 
}


static void BadJump( void )
{
	SV_Error( "program tried to execute code at bad location inside VM" ); 
}


static void BadStack( void )
{
	SV_Error( "program tried to overflow program stack" ); 
}


static void BadOpStack( void )
{
	SV_Error( "program tried to overflow opcode stack" ); 
}


static void BadData( void )
{
#ifdef DEBUG_VM	
	SV_Error( "program tried to read/write out of data segment at %i", errParam ); 
#else
	SV_Error( "program tried to read/write out of data segment" ); 
#endif
}


static void (*const errJumpPtr)(void) = ErrJump;
static void (*const badJumpPtr)(void) = BadJump;
static void (*const badStackPtr)(void) = BadStack;
static void (*const badOpStackPtr)(void) = BadOpStack;
static void (*const badDataPtr)(void) = BadData;

static void VM_FreeBuffers( void )
{
	// should be freed in reversed allocation order
	Q_free( instructionOffsets );
	Q_free( inst ); 
}

static const inline qbool HasFCOM( void )
{
#if idx386
	return ( CPU_Flags & CPU_FCOM );
#else
	return true; // assume idx64
#endif
}


static const inline qbool HasSSEFP( void )
{
#if idx386
	return ( CPU_Flags & CPU_SSE ) && ( CPU_Flags & CPU_SSE2 );
#else
	return true; // assume idx64
#endif
}

static void Emit1( int v )
{
	if ( code ) 
	{
		code[ compiledOfs ] = v;
	}
	compiledOfs++;

	LastCommand = LAST_COMMAND_NONE;
}

static void Emit4( int v )
{
	Emit1( v & 255 );
	Emit1( ( v >> 8 ) & 255 );
	Emit1( ( v >> 16 ) & 255 );
	Emit1( ( v >> 24 ) & 255 );
}


#if idx64
static void Emit8( int64_t v )
{
	Emit1( ( v >> 0 ) & 255 );
	Emit1( ( v >> 8 ) & 255 );
	Emit1( ( v >> 16 ) & 255 );
	Emit1( ( v >> 24 ) & 255 );
	Emit1( ( v >> 32 ) & 255 );
	Emit1( ( v >> 40 ) & 255 );
	Emit1( ( v >> 48 ) & 255 );
	Emit1( ( v >> 56 ) & 255 );
}
#endif


static void EmitPtr( const void *ptr )
{
#if idx64
	Emit8( (intptr_t)ptr );
#else
	Emit4( (intptr_t)ptr );
#endif
}


static int Hex( int c ) 
{
	if ( c >= '0' && c <= '9' ) {
		return c - '0';
	}
	if ( c >= 'A' && c <= 'F' ) {
		return 10 + c - 'A';
	}
	if ( c >= 'a' && c <= 'f' ) {
		return 10 + c - 'a';
	}

	VM_FreeBuffers();
	SV_Error( "Hex: bad char '%c'", c );

	return 0;
}


static void EmitString( const char *string )
{
	int		c1, c2;
	int		v;

	while ( 1 ) {
		c1 = string[0];
		c2 = string[1];

		v = ( Hex( c1 ) << 4 ) | Hex( c2 );
		Emit1( v );

		if ( !string[2] ) {
			break;
		}
		string += 3;
	}
}


static void EmitRexString( const char *string )
{
#if idx64
	Emit1( 0x48 );
#endif
	EmitString( string );
}


static void EmitAlign( int align )
{
	int i, n;

	n = compiledOfs & ( align - 1 );

	for ( i = 0; i < n ; i++ )
		EmitString( "90" );	// nop
}


static void EmitCommand( ELastCommand command )
{
	switch( command )
	{
		case LAST_COMMAND_MOV_EDI_EAX:
			EmitString( "89 07" );		// mov dword ptr [edi], eax
			break;

		case LAST_COMMAND_MOV_EAX_EDI:
			EmitString( "8B 07" );		// mov eax, dword ptr [edi]
			break;

		case LAST_COMMAND_SUB_DI_4:
			EmitRexString( "83 EF 04" );	// sub edi, 4
			break;

		case LAST_COMMAND_SUB_DI_8:
			EmitRexString( "83 EF 08" );	// sub edi, 8
			break;

		case LAST_COMMAND_SUB_DI_12:
			EmitRexString( "83 EF 0C" );	// sub edi, 12
			break;

		case LAST_COMMAND_STORE_FLOAT_EDI_SSE:
			EmitString( "F3 0F 11 07" );	// movss dword ptr [edi], xmm0
			break;

		case LAST_COMMAND_STORE_FLOAT_EDI_X87:
			EmitString( "D9 1F" );			// fstp dword ptr [edi]
			break;

		case LAST_COMMAND_STORE_FLOAT_EDI:	// meta command
			if ( HasSSEFP() ) {
				EmitString( "F3 0F 11 07" );// movss dword ptr [edi], xmm0
				command = LAST_COMMAND_STORE_FLOAT_EDI_SSE;
			} else {
				EmitString( "D9 1F" );		// fstp dword ptr [edi]
				command = LAST_COMMAND_STORE_FLOAT_EDI_X87;
			}
			break;

		default:
			break;
	}
	LastCommand = command;
}

static void EmitAddEDI4( vm_t *vm )
{
	if ( LastCommand == LAST_COMMAND_NONE ) 
	{
		EmitRexString( "83 C7 04" );			// add edi,4
		return;
	}

	if ( LastCommand == LAST_COMMAND_SUB_DI_4 ) // sub edi, 4
	{
#if idx64
		REWIND( 4 );
#else
		REWIND( 3 );
#endif
		LastCommand = LAST_COMMAND_NONE;
		return;
	}

	if ( LastCommand == LAST_COMMAND_SUB_DI_8 ) // sub edi, 8
	{	
#if idx64
		REWIND( 4 );
#else
		REWIND( 3 );
#endif
		EmitCommand( LAST_COMMAND_SUB_DI_4 );
		return;
	}

	if ( LastCommand == LAST_COMMAND_SUB_DI_12 ) // sub edi, 12
	{	
#if idx64
		REWIND( 4 );
#else
		REWIND( 3 );
#endif
		EmitCommand( LAST_COMMAND_SUB_DI_8 );
		return;
	}

	EmitRexString( "83 C7 04" );				// add edi,4
}


static void EmitMovEAXEDI( vm_t *vm )
{
	opcode_t pop = pop1;
	pop1 = OP_UNDEF;

	if ( LastCommand == LAST_COMMAND_NONE ) 
	{
		EmitString( "8B 07" );		// mov eax, dword ptr [edi]
		return;
	}

	if ( LastCommand == LAST_COMMAND_MOV_EAX_EDI )
		return;

	if ( LastCommand == LAST_COMMAND_MOV_EAX_EDI_CALL )
		return;

	if ( LastCommand == LAST_COMMAND_MOV_EDI_EAX ) // mov dword ptr [edi], eax
	{	
		REWIND( 2 );
		LastCommand = LAST_COMMAND_NONE; 
		return;
	}

	if ( pop == OP_DIVI || pop == OP_DIVU || pop == OP_MULI || pop == OP_MULU ||
		pop == OP_STORE4 || pop == OP_STORE2 || pop == OP_STORE1 ) 
	{	
		return;
	}

	if ( LastCommand == LAST_COMMAND_MOV_EDI_CONST ) // mov dword ptr [edi], 0x12345678
	{	
		REWIND( 6 );
		if ( lastConst == 0 ) {
			EmitString( "31 C0" );		// xor eax, eax
		} else {
			EmitString( "B8" );			// mov	eax, 0x12345678
			Emit4( lastConst );
		}
		return;
	}

	EmitString( "8B 07" );		    // mov eax, dword ptr [edi]
}


void EmitMovECXEDI( vm_t *vm ) 
{
	opcode_t pop = pop1;
	pop1 = OP_UNDEF;

	if ( LastCommand == LAST_COMMAND_NONE ) 
	{
		EmitString( "8B 0F" );		// mov ecx, dword ptr [edi]
		return;
	}

	if ( LastCommand == LAST_COMMAND_MOV_EAX_EDI_CALL ) 
	{
		EmitString( "89 C1" );		// mov ecx, eax
		return;
	}

	if ( LastCommand == LAST_COMMAND_MOV_EAX_EDI ) // mov eax, dword ptr [edi] 
	{
		REWIND( 2 );
		EmitString( "8B 0F" );		// mov ecx, dword ptr [edi]
		return;
	}

	if ( LastCommand == LAST_COMMAND_MOV_EDI_EAX ) // mov dword ptr [edi], eax
	{
		REWIND( 2 );
		EmitString( "89 C1" );		// mov ecx, eax
		return;
	}

	if (pop == OP_DIVI || pop == OP_DIVU || pop == OP_MULI || pop == OP_MULU ||
		pop == OP_STORE4 || pop == OP_STORE2 || pop == OP_STORE1 ) 
	{	
		EmitString( "89 C1" );		// mov ecx, eax
		return;
	}

	if ( LastCommand == LAST_COMMAND_MOV_EDI_CONST ) // mov dword ptr [edi], 0x12345678
	{	
		REWIND( 6 );
		EmitString( "B9" );			// mov ecx, 0x12345678
		Emit4( lastConst );
		return;
	}

	EmitString( "8B 0F" );		    // mov ecx, dword ptr [edi]
}


static void EmitCheckReg( vm_t *vm, int reg, int size )
{
	int n;

	if ( !( (int)vm_rtChecks.value & 8 ) || vm->forceDataMask ) {
		if ( vm->forceDataMask ) {
			if ( reg == REG_EAX )
				EmitString( "25" ); 	// and eax, 0x12345678
			else
				EmitString( "81 E1" );  // and ecx, 0x12345678
			Emit4( vm->dataMask );
		}
		return;
	}

#ifdef DEBUG_VM
	EmitString( "50" );			// push eax
	EmitRexString( "B8" );		// mov eax, &errParam
	EmitPtr( &errParam );
	EmitString( "C7 00" );		// mov [rax], ip-1
	Emit4( ip-1 );
	EmitString( "58" );			// pop eax
#endif

#if idx64
	if ( reg == REG_EAX )
		EmitString( "44 39 C8" );// cmp eax, r9d // vm->dataMask
	else
		EmitString( "44 39 C9" );// cmp ecx, r9d // vm->dataMask
#else
	if ( reg == REG_EAX )
		EmitString( "3D" );		// cmp eax, 0x12345678
	else
		EmitString( "81 F9" );	// cmp ecx, 0x12345678

	Emit4( vm->dataMask - (size - 1) );
#endif

	// error reporting
	EmitString( "0F 87" );		// ja +errorFunction
	n = funcOffset[FUNC_DATA] - compiledOfs;
	Emit4( n - 6 );
}


static int EmitLoadFloatEDI_SSE( vm_t *vm )
{
	// movss dword ptr [edi], xmm0
	if ( LastCommand == LAST_COMMAND_STORE_FLOAT_EDI_SSE )
	{
		if ( !vm )
			return 1;
		REWIND( 4 );
		LastCommand = LAST_COMMAND_NONE;
		return 1;
	}
	EmitString( "F3 0F 10 07" ); // movss xmm0, dword ptr [edi]
	return 0;
}


static int EmitLoadFloatEDI_X87( vm_t *vm )
{
	// fstp dword ptr [edi]
	if ( LastCommand == LAST_COMMAND_STORE_FLOAT_EDI_X87 )
	{ 	
		if ( !vm )
			return 1;
		REWIND( 2 );
		LastCommand = LAST_COMMAND_NONE;
		return 1;
	}

	EmitString( "D9 07" );		// fld dword ptr [edi]
	return 0;
}


static int EmitLoadFloatEDI( vm_t *vm )
{
	if ( HasSSEFP() )
		return EmitLoadFloatEDI_SSE( vm );
	else
		return EmitLoadFloatEDI_X87( vm );
}

#if JUMP_OPTIMIZE
const char *NearJumpStr( int op ) 
{
	switch ( op )
	{
		case OP_EQF:
		case OP_EQ:  return "74"; // je
		
		case OP_NEF:
		case OP_NE:  return "75"; // jne
		
		case OP_LTI: return "7C"; // jl
		case OP_LEI: return "7E"; // jle
		case OP_GTI: return "7F"; // jg
		case OP_GEI: return "7D"; // jge

		case OP_LTF:
		case OP_LTU: return "72"; // jb
		
		case OP_LEF:
		case OP_LEU: return "76"; // jbe
		
		case OP_GTF:
		case OP_GTU: return "77"; // ja 
		
		case OP_GEF:
		case OP_GEU: return "73"; // jae

		case OP_JUMP: return "EB";   // jmp

		//default:
		//	SV_Error( "Bad opcode %i", op );
	};
	return NULL;
}
#endif


const char *FarJumpStr( int op, int *n ) 
{
	switch ( op )
	{
		case OP_EQF:
		case OP_EQ:  *n = 2; return "0F 84"; // je
		
		case OP_NEF:
		case OP_NE:  *n = 2; return "0F 85"; // jne
		
		case OP_LTI: *n = 2; return "0F 8C"; // jl
		case OP_LEI: *n = 2; return "0F 8E"; // jle
		case OP_GTI: *n = 2; return "0F 8F"; // jg
		case OP_GEI: *n = 2; return "0F 8D"; // jge

		case OP_LTF:
		case OP_LTU: *n = 2; return "0F 82"; // jb

		case OP_LEF:
		case OP_LEU: *n = 2; return "0F 86"; // jbe
		
		case OP_GTF:
		case OP_GTU: *n = 2; return "0F 87"; // ja 
		
		case OP_GEF:
		case OP_GEU: *n = 2; return "0F 83"; // jae

		case OP_JUMP: *n = 1; return "E9";   // jmp
	};
	return NULL;
}


void EmitJump( vm_t *vm, instruction_t *i, int op, int addr ) 
{
	const char *str;
	int v, jump_size = 0;

	v = instructionOffsets[ addr ] - compiledOfs;

#if JUMP_OPTIMIZE
	if ( i->njump ) {
		// can happen
		if ( v < -126 || v > 129 ) {
			str = FarJumpStr( op, &jump_size );	
			EmitString( str );
			Emit4( v - 4 - jump_size ); 
			i->njump = 0;
			return;
		}
		EmitString( NearJumpStr( op ) );
		Emit1( v - 2 );
		return;
	}

	if ( pass >= 2 && pass < NUM_PASSES-2 ) {
		if ( v >= -126 && v <= 129 ) {
			EmitString( NearJumpStr( op ) );
			Emit1( v - 2 ); 
			i->njump = 1;
			return;
		}
	}
#endif

	str = FarJumpStr( op, &jump_size );	
	if ( jump_size == 0 ) {
		SV_Error( "VM_CompileX86 error: %s\n", "bad jump size" );
	} else {
		EmitString( str );
		Emit4( v - 4 - jump_size );
	}
}


void EmitFloatJump( vm_t *vm, instruction_t *i, int op, int addr ) 
{
	switch ( op ) {
		case OP_EQF:
			EmitString( "80 E4 40" );	// and ah,0x40
			EmitJump( vm, i, OP_NE, addr );
			break;			

		case OP_NEF:
			EmitString( "80 E4 40" );	// and ah,0x40
			EmitJump( vm, i, OP_EQ, addr );
			break;			

		case OP_LTF:
			EmitString( "80 E4 01" );	// and ah,0x01
			EmitJump( vm, i, OP_NE, addr );
			break;			

		case OP_LEF:
			EmitString( "80 E4 41" );	// and ah,0x41
			EmitJump( vm, i, OP_NE, addr );
			break;			

		case OP_GTF:
			EmitString( "80 E4 41" );	// and ah,0x41
			EmitJump( vm, i, OP_EQ, addr );
			break;			

		case OP_GEF:
			EmitString( "80 E4 01" );	// and ah,0x01
			EmitJump( vm, i, OP_EQ, addr );
			break;			
	};

}


static void EmitCallAddr( vm_t *vm, int addr )
{
	int v;
	v = instructionOffsets[ addr ] - compiledOfs;
	EmitString( "E8" );
	Emit4( v - 5 ); 
}


static void EmitCallOffset( funcx86_t Func )
{
	int  v;
	v = funcOffset[ Func ] - compiledOfs;
	EmitString( "E8" );		// call +funcOffset[ Func ]
	Emit4( v - 5 );
}


#ifdef _WIN32
#define SHADOW_BASE 40
#else // linux/*BSD ABI
#define SHADOW_BASE 8
#endif

#define PUSH_STACK  32
#define PARAM_STACK 128

static void EmitCallFunc( vm_t *vm )
{
	static int sysCallOffset = 0;
	int n;

	EmitString( "85 C0" );				// test eax, eax
	EmitString( "7C" );					// jl +offset (SystemCall) 
	Emit1( sysCallOffset );				// will be valid after first pass
sysCallOffset = compiledOfs;				

	// jump target range check
	if ( (int)vm_rtChecks.value & 4 ) {
		EmitString( "3D" );					// cmp eax, vm->instructionCount
		Emit4( vm->instructionCount );
		EmitString( "0F 83" );				// jae +funcOffset[FUNC_ERRJ]
		n = funcOffset[FUNC_ERRJ] - compiledOfs;
		Emit4( n - 6 );
	}

	EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4

	// save proc base and programStack
	EmitString( "55" );				// push ebp
	EmitString( "56" );				// push esi

	// calling another vm function
#if idx64
	EmitString( "41 FF 14 C0" );		// call dword ptr [r8+rax*8]
#else
	EmitString( "8D 0C 85" );			// lea ecx, [vm->instructionPointers+eax*4]
	EmitPtr( instructionPointers );
	EmitString( "FF 11" );				// call dword ptr [ecx]
#endif

	// restore proc base and programStack so there is 
	// no need to validate programStack anymore
	EmitString( "5E" );				// pop esi
	EmitString( "5D" );				// pop ebp

	EmitString( "C3" );				// ret

sysCallOffset = compiledOfs - sysCallOffset;

	// systemCall:
	// convert negative num to system call number
	// and store right before the first arg
	EmitString( "F7 D0" );          // not eax

	EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4

	// we may jump here from ConstOptimize() also
funcOffset[FUNC_SYSC] = compiledOfs;

#if idx64
	// allocate stack for shadow(win32)+parameters
	EmitString( "48 81 EC" );				// sub rsp, 200
	Emit4( SHADOW_BASE + PUSH_STACK + PARAM_STACK );

	// save scratch registers
	EmitString( "48 8D 54 24" );			// lea rdx, [rsp+SHADOW_BASE]
	Emit1( SHADOW_BASE );
	EmitString( "48 89 32" );				// mov [rdx+00], rsi
	EmitString( "48 89 7A 08" );			// mov [rdx+08], rdi
	EmitString( "4C 89 42 10" );			// mov [rdx+16], r8
	EmitString( "4C 89 4A 18" );			// mov [rdx+24], r9

	// ecx = &int64_params[0]
	EmitString( "48 8D 4C 24" );			// lea rcx, [rsp+SHADOW_BASE+PUSH_STACK]
	Emit1( SHADOW_BASE + PUSH_STACK );

	// save syscallNum
	EmitString( "48 89 01" );				// mov [rcx], rax

	// vm->programStack = programStack - 4;
	EmitString( "48 BA" );					// mov rdx, &vm->programStack
	EmitPtr( &vm->programStack );
	//EmitString( "8D 46 FC" );				// lea eax, [esi-4]
	EmitString( "8D 46 F8" );				// lea eax, [esi-8]
	EmitString( "89 02" );					// mov [rdx], eax
	//EmitString( "89 32" );				// mov dword ptr [rdx], esi

	// params = (vm->dataBase + programStack + 8);
	EmitString( "48 8D 74 33 08" );			// lea rsi, [rbx+rsi+8]

	// rcx = &int64_params[1]
	EmitString( "48 83 C1 08" );			// add rcx, 8

	// dest_params[1-15] = params[1-15];
	EmitString( "31 D2" );					// xor edx, edx
	// loop
	EmitString( "48 63 04 96" );			// movsxd rax, dword [rsi+rdx*4]
	EmitString( "48 89 04 D1" );			// mov qword ptr[rcx+rdx*8], rax
	EmitString( "48 83 C2 01" );			// add rdx, 1
	EmitString( "48 83 FA" );				// cmp rdx, 15
	Emit1( (PARAM_STACK/8) - 1 );
	EmitString( "7C EE" );					// jl -18

#ifdef _WIN32
	// rcx = &int64_params[0]
	EmitString( "48 83 E9 08" );			// sub rcx, 8
#else // linux/*BSD ABI
	// rdi = &int64_params[0]
	EmitString( "48 8D 79 F8" );			// lea rdi, [rcx-8]
#endif
	
	// currentVm->systemCall( param );
	EmitString( "41 FF 14 24" );			// call qword [r12]

	// restore registers
	EmitString( "48 8D 54 24" );			// lea rdx, [rsp+SHADOW_BASE]
	Emit1( SHADOW_BASE );
	EmitString( "48 8B 32" );				// mov rsi, [rdx+00]
	EmitString( "48 8B 7A 08" );			// mov rdi, [rdx+08]
	EmitString( "4C 8B 42 10" );			// mov r8,  [rdx+16]
	EmitString( "4C 8B 4A 18" );			// mov r9,  [rdx+24]

	// we added the return value: *(opstack+1) = eax
	EmitAddEDI4( vm );						// add edi, 4
	EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax

	// return stack
	EmitString( "48 81 C4" );				// add rsp, 200
	Emit4( SHADOW_BASE + PUSH_STACK + PARAM_STACK );

	EmitRexString( "8D 2C 33" );			// lea rbp, [rbx+rsi]

	EmitString( "C3" );						// ret

#else // i386

	// params = (int *)((byte *)currentVM->dataBase + programStack + 4);
	EmitString( "8D 4D 04" );				// lea ecx, [ebp+4]

	// function prologue
	EmitString( "55" );						// push ebp
	EmitRexString( "89 E5" );				// mov ebp, esp
	EmitRexString( "83 EC 04" );			// sub esp, 4
	// align stack before call
	EmitRexString( "83 E4 F0" );			// and esp, -16

	// ABI note: esi/edi must not change during call!

	// currentVM->programStack = programStack - 4;
	EmitString( "8D 56 FC" );				// lea edx, [esi-4]
	EmitString( "89 15" );					// mov [&vm->programStack], edx 
	EmitPtr( &vm->programStack );

	// params[0] = syscallNum
	EmitString( "89 01" );					// mov [ecx], eax

	// cdecl - set params
	EmitString( "89 0C 24" );				// mov [esp], ecx
	
	// currentVm->systemCall( param );
	EmitString( "FF 15" );					// call dword ptr [&currentVM->systemCall]
	EmitPtr( &vm->systemCall );
	
	// we added the return value: *(opstack+1) = eax
#if 0
	EmitAddEDI4( vm );						// add edi, 4
	EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov [edi], eax
#else // break dependency from edi value?
	EmitString( "89 47 04" );				// mov [edi+4], eax
	EmitAddEDI4( vm );						// add edi, 4
#endif

	// function epilogue
	EmitRexString( "89 EC" );				// mov esp, ebp
	EmitString( "5D" );						// pop ebp
	EmitString( "C3" );						// ret
#endif
}


static void EmitFTOLFunc( vm_t *vm )
{
	EmitRexString( "B8" );		// mov eax, &fp_cw[0]
	EmitPtr( &fp_cw[0] );		
	EmitString( "9B D9 38" );	// fnstcw word ptr [eax]
	EmitString( "D9 68 04" );	// fldcw word ptr [eax+4]
	EmitString( "DB 1F" );		// fistp dword ptr [edi]
	EmitString( "D9 28" );		// fldcw word ptr [eax]
	EmitString( "C3" );			// ret
}


static void EmitBCPYFunc( vm_t *vm )
{
	// FIXME: range check
	EmitString( "56" );						// push esi
	EmitString( "57" );						// push edi
	EmitString( "8B 37" );					// mov esi,[edi] 
	EmitString( "8B 7F FC" );				// mov edi,[edi-4] 
	EmitString( "B8" );						// mov eax, datamask
	Emit4( vm->dataMask );
	EmitString( "21 C6" );					// and esi, eax
	EmitString( "21 C7" );					// and edi, eax
#if idx64
	EmitString( "48 01 DE" );				// add rsi, rbx
	EmitString( "48 01 DF" );				// add rdi, rbx
#else
	EmitString( "03 F3" );					// add esi, ebx
	EmitString( "03 FB" );					// add edi, ebx
#endif
	EmitString( "F3 A5" );					// rep movsd
	EmitString( "5F" );						// pop edi
	EmitString( "5E" );						// pop esi
	EmitCommand( LAST_COMMAND_SUB_DI_8 );	// sub edi, 8
	EmitString( "C3" );						// ret
}


static void EmitPSOFFunc( vm_t *vm )
{
	EmitRexString( "B8" );			// mov eax, badStackPtr
	EmitPtr( &badStackPtr );
	EmitString( "FF 10" );			// call [eax]
	EmitString( "C3" );				// ret
}


static void EmitOSOFFunc( vm_t *vm )
{
	EmitRexString( "B8" );			// mov eax, badOptackPtr
	EmitPtr( &badOpStackPtr );
	EmitString( "FF 10" );			// call [eax]
	EmitString( "C3" );				// ret
}


static void EmitBADJFunc( vm_t *vm )
{
	EmitRexString( "B8" );			// mov eax, badJumpPtr
	EmitPtr( &badJumpPtr );
	EmitString( "FF 10" );			// call [eax]
	EmitString( "C3" );				// ret
}


static void EmitERRJFunc( vm_t *vm )
{
	EmitRexString( "B8" );			// mov eax, errJumpPtr
	EmitPtr( &errJumpPtr );
	EmitString( "FF 10" );			// call [eax]
	EmitString( "C3" );				// ret
}


static void EmitDATAFunc( vm_t *vm )
{
	EmitRexString( "B8" );			// mov eax, badDataPtr
	EmitPtr( &badDataPtr );
	EmitString( "FF 10" );			// call [eax]
	EmitString( "C3" );				// ret
}


static void EmitNCPYFunc( vm_t *vm )
{
	static int Lend, Lcopy, Lpadz, Lpop0, Lpop1; // jump labels
	int n;

	//EmitString( "8B 4D 10" );	// mov ecx, dword ptr [ebp+16] // counter
	EmitString( "89 C1" );		// mov ecx, eax // get cached value from previous OP_ARG instruction
	EmitString( "85 C9" );		// test ecx, ecx
	EmitString( "74" );			// je +Lend
	Emit1( Lend );	Lend = compiledOfs;
	EmitString( "57" );			// push edi
	EmitString( "8B 55 0C" );	// mov edx, dword ptr [ebp+12] // source
	EmitString( "8B 7D 08" );	// mov edi, dword ptr [ebp+08] // destination
	EmitRexString( "01 DA" );	// add edx, ebx // + vm->dataBase

#if 0
	if ( vm->forceDataMask )
	{
#ifdef idx64
		EmitString( "44 21 CF" );	// and edi, r9d
#else
		EmitString( "81 E7" );		// and edi, vm->dataMask
		Emit4( vm->dataMask );
#endif
		EmitRexString( "01 DF" );	// add edi, ebx // + vm->dataBase
	}
	else
#endif
	if ( (int)vm_rtChecks.value & 8 ) // security checks
	{
		EmitString( "89 F8" );		// mov eax, edi
		EmitString( "09 C8" );		// or eax, ecx
		EmitString( "3D" );			// cmp eax, vm->dataMask
		Emit4( vm->dataMask );
		EmitString( "0F 87" );		// ja +errorFunction
		n = funcOffset[FUNC_DATA] - compiledOfs;
		Emit4( n - 6 );
		EmitString( "8D 04 0F" );	// lea eax, dword ptr [edi + ecx]
		EmitRexString( "01 DF" );	// add edi, ebx // + vm->dataBase
		EmitString( "3D" );			// cmp eax, vm->dataMask
		Emit4( vm->dataMask );
		EmitString( "0F 87" );		// ja +errorFunction
		n = funcOffset[FUNC_DATA] - compiledOfs;
		Emit4( n - 6 );
	}
	else
	{
		EmitRexString( "01 DF" );	// add edi, ebx // + vm->dataBase
	}

Lcopy = compiledOfs - Lcopy;
	EmitString( "8A 02" );		// mov al, dword ptr [edx]
	EmitString( "88 07" );		// mov dword ptr [edi], al
	EmitRexString( "83 C2 01" );// add edx, 1
	EmitRexString( "83 C7 01" );// add edi, 1
	EmitRexString( "84 C0" );	// test al, al
	EmitString( "74" );			// je +Lpadz
	Emit1( Lpadz );	Lpadz = compiledOfs;
	EmitString( "83 E9 01" );	// sub ecx, 1
	EmitString( "75" );			// jne +Lcopy
	Emit1( Lcopy );	Lcopy = compiledOfs;
	EmitString( "5F" );			// pop edi
	EmitString( "C3" );			// ret
Lpadz = compiledOfs - Lpadz;
	EmitString( "85 C9" );		// test ecx, ecx
	EmitString( "74" );			// je +Lpop0
	Emit1( Lpop0 );	Lpop0 = compiledOfs;
#if 0
	// zero only one char
	EmitString( "31 C0" );		// xor eax, eax
	EmitString( "88 07" );		// mov dword ptr [edi], al
#else
	// zero all remaining chars
	EmitString( "83 E9 01" );	// sub ecx, 1
	EmitString( "74" );			// je +Lpop1
	Emit1( Lpop1 );	Lpop1 = compiledOfs;
	EmitString( "89 CA" );		// mov edx, ecx
	EmitString( "C1 E9 02" );	// shr ecx, 2
	EmitString( "31 C0" );		// xor eax, eax
	EmitString( "83 E2 03" );	// and edx, 3
	EmitString( "F3 AB" );		// rep stosd
	EmitString( "89 D1" );		// mov ecx, edx
	//EmitString( "83 E1 03" );	// and ecx, 3
	EmitString( "F3 AA" );		// rep stosb
Lpop1 = compiledOfs - Lpop1;
#endif
Lpop0 = compiledOfs - Lpop0;
	EmitString( "5F" );			// pop edi
Lend = compiledOfs - Lend;
	EmitString( "C3" );			// ret
}


/*
=================
EmitFCalcEDI
=================
*/
static void EmitFCalcEDI( int op )
{
	switch ( op )
	{
		case OP_ADDF: EmitString( "D8 07" ); break; // fadd dword ptr [edi]
		case OP_SUBF: EmitString( "D8 27" ); break;	// fsub dword ptr [edi]
		case OP_MULF: EmitString( "D8 0F" ); break; // fmul dword ptr [edi]
		case OP_DIVF: EmitString( "D8 37" ); break; // fdiv dword ptr [edi]
		default: SV_Error( "bad float op" ); break;
	};
}


/*
=================
EmitFCalcPop
=================
*/
static void EmitFCalcPop( int op )
{
	switch ( op )
	{
		case OP_ADDF: EmitString( "DE C1" ); break; // faddp
		case OP_SUBF: EmitString( "DE E9" ); break; // fsubp
		case OP_MULF: EmitString( "DE C9" ); break; // fmulp
		case OP_DIVF: EmitString( "DE F9" ); break; // fdivp
		default: SV_Error( "bad opcode %02x", op ); break;
	};
}


/*
=================
CommuteFloatOp
=================
*/
static int CommuteFloatOp( int op ) 
{
	switch ( op ) {
		case OP_LEF: return OP_GEF;
		case OP_LTF: return OP_GTF;
		case OP_GEF: return OP_LEF;
		case OP_GTF: return OP_LTF;
		default: return op;
	}
}


/*
=================
ConstOptimize
=================
*/
static qbool ConstOptimize( vm_t *vm ) 
{
	int v;
	int op1;
	qbool sign_extend;

	op1 = ni->op;

	switch ( op1 ) {

	case OP_LOAD4:
		EmitAddEDI4( vm );
		if ( ISS8( ci->value ) ) {
			EmitString( "8B 43" );		// mov eax, dword ptr [ebx+0x7F]
			Emit1( ci->value );
		} else {
			EmitString( "8B 83" );		// mov eax, dword ptr [ebx+0x12345678]
			Emit4( ci->value );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX ); // mov dword ptr [edi], eax
		ip += 1;
		return true;

	case OP_LOAD2:
		EmitAddEDI4( vm );
		sign_extend = ( (ci+2)->op == OP_SEX16 );
		if ( ISS8( ci->value ) ) {
			if ( sign_extend ) {
				EmitString( "0F BF 43" );	// movsx eax, word ptr [ebx+0x7F]
				ip += 1;
			} else {
				EmitString( "0F B7 43" );	// movzx eax, word ptr [ebx+0x7F]
			}
			Emit1( ci->value );
		} else {
			if ( sign_extend ) {
				EmitString( "0F BF 83" );	// movsx eax, word ptr [ebx+0x12345678]
				ip += 1;
			} else {
				EmitString( "0F B7 83" );	// movzx eax, word ptr [ebx+0x12345678]
			}
			Emit4( ci->value );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX ); // mov dword ptr [edi], eax
		ip += 1;
		return true;

	case OP_LOAD1:
		EmitAddEDI4( vm );
		sign_extend = ( (ci+2)->op == OP_SEX8 );
		if ( ISS8( ci->value ) ) {
			if ( sign_extend ) {
				EmitString( "0F BE 43" );	// movsx eax, byte ptr [ebx+0x7F]
				ip += 1;
			} else {
				EmitString( "0F B6 43" );	// movzx eax, byte ptr [ebx+0x7F]
			}
			Emit1( ci->value );
		} else {
			if ( sign_extend ) {
				EmitString( "0F BE 83" );	// movsx eax, word ptr [ebx+0x12345678]
				ip += 1;
			} else {
				EmitString( "0F B6 83" );	// movzx eax, word ptr [ebx+0x12345678]
			}
			Emit4( ci->value );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX ); // mov dword ptr [edi], eax
		ip += 1;
		return true;

	case OP_STORE4:
		EmitMovEAXEDI( vm );
		if ( !ci->value ) {
			EmitString( "31 C9" );		// xor ecx, ecx
		} else {
			EmitString( "B9" );			// mov	ecx, 0x12345678
			Emit4( ci->value );
		}
		EmitCheckReg( vm, REG_EAX, 4 );
		EmitString( "89 0C 03" );		// mov dword ptr [ebx + eax], ecx
		EmitCommand( LAST_COMMAND_SUB_DI_4 );		// sub edi, 4
		ip += 1;
		return true;

	case OP_STORE2:
		EmitMovEAXEDI( vm );
		if ( !ci->value ) {
			EmitString( "31 C9" );		// xor ecx, ecx
		} else {
			EmitString( "B9" );			// mov	ecx, 0x12345678
			Emit4( ci->value );
		}
		EmitCheckReg( vm, REG_EAX, 2 );
		EmitString( "66 89 0C 03" );	// mov word ptr [ebx + eax], cx
		EmitCommand( LAST_COMMAND_SUB_DI_4 ); // sub edi, 4
		ip += 1;
		return true;

	case OP_STORE1:
		EmitMovEAXEDI( vm );
		if ( !ci->value ) {
			EmitString( "31 C9" );		// xor ecx, ecx
		} else {
			EmitString( "B9" );			// mov	ecx, 0x12345678
			Emit4( ci->value );
		}
		EmitCheckReg( vm, REG_EAX, 1 );
		EmitString( "88 0C 03" );		// mov byte ptr [ebx + eax], cl
		EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
		ip += 1;
		return true;
	
	case OP_ADD:
		v = ci->value;
		EmitMovEAXEDI( vm ); 
		if ( ISS8( v ) ) {
			EmitString( "83 C0" );	// add eax, 0x7F
			Emit1( v );
		} else {
			EmitString( "05" );		// add eax, 0x12345678
			Emit4( v );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1; // OP_ADD
		return true;

	case OP_SUB:
		v = ci->value;
		EmitMovEAXEDI( vm );
		if ( ISS8( v ) ) {
			EmitString( "83 E8" );	// sub eax, 0x7F
			Emit1( v );
		} else {
			EmitString( "2D" );		// sub eax, 0x12345678
			Emit4( v );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1;
		return true;

	case OP_MULI:
		v = ci->value;
		EmitMovEAXEDI( vm );
		if ( ISS8( v ) ) {
			EmitString( "6B C0" );	// imul eax, 0x7F
			Emit1( v );
		} else {
			EmitString( "69 C0" );	// imul eax, 0x12345678
			Emit4( v );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1;
		return true;

	case OP_MULF:
	case OP_DIVF:
	case OP_ADDF:
	case OP_SUBF:
		v = ci->value;
		EmitLoadFloatEDI( vm );
		if ( HasSSEFP() ) {
			EmitString( "C7 45 00" );			// mov dword ptr [ebp], v
			Emit4( v );
			EmitString( "F3 0F 10 4D 00" );		// movss xmm1, dword ptr [ebp]
			switch( op1 ) {
				case OP_ADDF: EmitString( "0F 58 C1" ); break;	// addps xmm0, xmm1
				case OP_SUBF: EmitString( "0F 5C C1" ); break;	// subps xmm0, xmm1
				case OP_MULF: EmitString( "0F 59 C1" ); break;	// mulps xmm0, xmm1
				case OP_DIVF: EmitString( "0F 5E C1" ); break;	// divps xmm0, xmm1
			}
		} else {
			EmitString( "C7 45 00" );	// mov dword ptr [ebp], 0x12345678
			Emit4( v );
			EmitString( "D9 45 00" );	// fld dword ptr [ebp]
			EmitFCalcPop( op1 );		// fmulp/fdivp/faddp/fsubp
		}
		EmitCommand( LAST_COMMAND_STORE_FLOAT_EDI );
		ip +=1;
		return true;

	case OP_LSH:
		v = ci->value;
		if ( v < 0 || v > 31 )
			break;
		EmitMovEAXEDI( vm );
		EmitString( "C1 E0" );	// shl eax, 0x12
		Emit1( v );
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1; // OP_LSH
		return true;

	case OP_RSHI:
		v = ci->value;
		if ( v < 0 || v > 31 )
			break;
		EmitMovEAXEDI( vm );
		EmitString( "C1 F8" );	// sar eax, 0x12
		Emit1( v );
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1;
		return true;

	case OP_RSHU:
		v = ci->value;
		if ( v < 0 || v > 31 )
			break;
		EmitMovEAXEDI( vm );
		EmitString( "C1 E8" );	// shr eax, 0x12
		Emit1( v );
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1;
		return true;

	case OP_BAND:
		v = ci->value;
		EmitMovEAXEDI( vm );
		if ( ISU8( v ) ) {
			EmitString( "83 E0" ); // and eax, 0x7F
			Emit1( v );
		} else {
			EmitString( "25" ); // and eax, 0x12345678
			Emit4( v );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1;
		return true;

	case OP_BOR:
		v = ci->value;
		EmitMovEAXEDI( vm );
		if ( ISU8( v ) ) {
			EmitString( "83 C8" ); // or eax, 0x7F
			Emit1( v );
		} else {
			EmitString( "0D" );    // or eax, 0x12345678
			Emit4( v );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1;
		return true;

	case OP_BXOR:
		v = ci->value;
		EmitMovEAXEDI( vm );
		if ( ISU8( v ) ) {
			EmitString( "83 F0" );	// xor eax, 0x7F
			Emit1( v );
		} else {
			EmitString( "35" );		// xor eax, 0x12345678
			Emit4( v );
		}
		EmitCommand( LAST_COMMAND_MOV_EDI_EAX );
		ip += 1;
		return true;

	case OP_JUMP:
		EmitJump( vm, ni, ni->op, ci->value );
		ip += 1; // OP_JUMP
		return true;

	case OP_CALL:
#ifdef VM_LOG_SYSCALLS
		// [dataBase + programStack + 0] = ip;
		EmitString( "C7 45 00" );	// mov dword ptr [ebp], 0x12345678
		Emit4( ip );
#endif
		v = ci->value;
		// try to inline some syscalls
		if ( HasSSEFP() && v == ~g_sqrt ) {
			// inline SSE implementation of sin/cos is too problematic...
			EmitString( "F3 0F 10 45 08" );		// movss xmm0, dword ptr [ebp + 8]
			EmitAddEDI4( vm );
			EmitString( "F3 0F 51 C0" );		// sqrtss xmm0, xmm0
			EmitCommand( LAST_COMMAND_STORE_FLOAT_EDI );
			ip += 1;
			return true;
		} else if ( v == ~g_sin || v == ~g_cos || v == ~g_sqrt ) {
			EmitString( "D9 45 08" );		// fld dword ptr [ebp + 8]
			switch ( v ) {
				case ~g_sqrt: EmitString( "D9 FA" ); break; // fsqrt
				case ~g_sin: EmitString( "D9 FE" ); break;  // fsin
				case ~g_cos: EmitString( "D9 FF" ); break;  // fcos
			}
			EmitAddEDI4( vm );								// add edi, 4
			EmitCommand( LAST_COMMAND_STORE_FLOAT_EDI_X87 );// fstp dword ptr[edi]
			ip += 1;
			return true;
		}

		if ( v < 0 ) // syscall
		{
			EmitString( "B8" );		// mov eax, 0x12345678
			Emit4( ~v );
			EmitCallOffset( FUNC_SYSC );
			LastCommand = LAST_COMMAND_MOV_EAX_EDI_CALL;
			ip += 1; // OP_CALL
			return true;
		}
		EmitString( "55" );	// push ebp
		EmitString( "56" );	// push rsi
		EmitString( "53" );	// push rbx
		EmitCallAddr( vm, v ); // call +addr
		EmitString( "5B" );	// pop rbx
		EmitString( "5E" );	// pop rsi
		EmitString( "5D" );	// pop ebp
		ip += 1; // OP_CALL
		return true;

	case OP_EQF:
	case OP_NEF:
	case OP_LTF:
	case OP_LEF:
	case OP_GTF:
	case OP_GEF:
		if ( !HasFCOM() )
			return false;
		EmitLoadFloatEDI( vm );
		EmitCommand( LAST_COMMAND_SUB_DI_4 );
		v = ci->value;
		if ( HasSSEFP() ) {
			if ( v == 0 ) {
				EmitString( "0F 57 C9" );			// xorps xmm1, xmm1
			} else {
				EmitString( "C7 45 00" );			// mov dword ptr [ebp], v
				Emit4( v );
				EmitString( "F3 0F 10 4D 00" );		// movss xmm1, dword ptr [ebp]
			}
			EmitString( "0F 2F C1" );				// comiss xmm0, xmm1
			EmitJump( vm, ni, ni->op, ni->value );
		} else {
			if ( v == 0 ) {
				EmitString( "D9 EE" );		// fldz
			} else {
				EmitString( "C7 45 00" );	// mov [ebp], 0x12345678
				Emit4( v );
				EmitString( "D9 45 00" );	// fld dword ptr [ebp]
			}
			EmitString( "DF E9" );		// fucomip
			EmitString( "DD D8" );		// fstp st(0)
			EmitJump( vm, ni, CommuteFloatOp( ni->op ), ni->value );
		}
		ip +=1;
		return true;

	case OP_EQ:
	case OP_NE:
	case OP_GEI:
	case OP_GTI:
	case OP_GTU:
	case OP_GEU:
	case OP_LTU:
	case OP_LEU:
	case OP_LEI:
	case OP_LTI:
		EmitMovEAXEDI( vm );
		EmitCommand( LAST_COMMAND_SUB_DI_4 );
		v = ci->value;
		if ( v == 0 && ( op1 == OP_EQ || op1 == OP_NE ) ) {
			EmitString( "85 C0" );       // test eax, eax
		} else {
			if ( ISS8( v ) ) {
				EmitString( "83 F8" );   // cmp eax, 0x7F
				Emit1( v );
			} else {
				EmitString( "3D" );      // cmp eax, 0xFFFFFFFF
				Emit4( v );
			}
		}
		EmitJump( vm, ni, ni->op, ni->value );
		ip += 1; 
		return true;

	default:
		break;
	}

	return false;
}

/*
=================
VM_FindMOps

Search for known macro-op sequences
=================
*/
static void VM_FindMOps( instruction_t *buf, int instructionCount )
{
	int n, v, op0;
	instruction_t *i;
	
	i = buf;
	n = 0;

	while ( n < instructionCount )
	{
		op0 = i->op;
		if ( op0 == OP_LOCAL ) {
			// OP_LOCAL + OP_LOCAL + OP_LOAD4 + OP_CONST + OP_XXX + OP_STORE4
			if ( (i+1)->op == OP_LOCAL && i->value == (i+1)->value && (i+2)->op == OP_LOAD4 && (i+3)->op == OP_CONST && (i+4)->op != OP_UNDEF && (i+5)->op == OP_STORE4 ) {
				v = (i+4)->op;
				if ( v == OP_ADD ) {
					i->op = MOP_ADD4;
					i += 6; n += 6;
					continue;
				}
				if ( v == OP_SUB ) {
					i->op = MOP_SUB4;
					i += 6; n += 6;
					continue;
				}
				if ( v == OP_BAND ) {
					i->op = MOP_BAND4;
					i += 6; n += 6;
					continue;
				}
				if ( v == OP_BOR ) {
					i->op = MOP_BOR4;
					i += 6; n += 6;
					continue;
				}
			}

			// skip useless sequences
			if ( (i+1)->op == OP_LOCAL && (i+0)->value == (i+1)->value && (i+2)->op == OP_LOAD4 && (i+3)->op == OP_STORE4 ) {
				i->op = MOP_IGNORE4;
				i += 4; n += 4;
				continue;
			}
		} else if ( op0 == OP_CONST && (i+1)->op == OP_CALL && (i+2)->op == OP_POP && i >= buf+6 && (i-1)->op == OP_ARG && !i->jused ) {
			// some void function( arg1, arg2, arg3 )
			if ( i->value == ~g_strlcpy ) {
				i->op = MOP_NCPY;
				i += 3; n += 3;
				continue;
			}
		}

		i++;
		n++;
	}
}


/*
=================
EmitMOPs
=================
*/
static qbool EmitMOPs( vm_t *vm, int op ) 
{
	int v, n;
	switch ( op ) 
	{
		//[local] += CONST
		case MOP_ADD4:
			n = inst[ip+2].value;
			v = ci->value; // local variable address
			if ( ISS8( n ) ) {
				if ( ISS8( v ) ) {
					EmitString( "83 45" );	// add dword ptr [ebp + 0x7F], 0x12
					Emit1( v );
					Emit1( n );
				} else {
					EmitString( "83 85" );	// add dword ptr [ebp + 0x12345678], 0x12
					Emit4( v );
					Emit1( n );
				}
			} else {
				if ( ISS8( v ) ) {
					EmitString( "81 45" );	// add dword ptr [ebp + 0x7F], 0x12345678
					Emit1( v );
					Emit4( n );
				} else {
					EmitString( "81 85" );	// add dword ptr [ebp + 0x12345678], 0x12345678
					Emit4( v );
					Emit4( n );
				}
			}
			ip += 5;
			return true;

		//[local] -= CONST
		case MOP_SUB4:
			n = inst[ip+2].value;
			v = ci->value; // local variable address
			if ( ISS8( n ) ) {
				if ( ISS8( v ) ) {
					EmitString( "83 6D" );	// sub dword ptr [ebp + 0x7F], 0x12
					Emit1( v );
					Emit1( n );
				} else {
					EmitString( "83 AD" );	// sub dword ptr [ebp + 0x12345678], 0x12
					Emit4( v );
					Emit1( n );
				}
			} else {
				if ( ISS8( v ) ) {
					EmitString( "81 6D" );	// sub dword ptr [ebp + 0x7F], 0x12345678
					Emit1( v );
					Emit4( n );
				} else {
					EmitString( "81 AD" );	// sub dword ptr[esi+0x12345678], 0x12345678
					Emit4( v );
					Emit4( n );
				}
			}
			ip += 5;
			return true;

		//[local] &= CONST
		case MOP_BAND4:
			n = inst[ip+2].value;
			v = ci->value; // local variable address
			if ( ISS8( n ) ) {
				if ( ISS8( v ) ) {
					EmitString( "83 65" );	// and dword ptr [ebp + 0x7F], 0x12
					Emit1( v );
					Emit1( n );
				} else {
					EmitString( "83 A5" );	// and dword ptr [ebp + 0x12345678], 0x12
					Emit4( v );
					Emit1( n );
				}
			} else {
				if ( ISS8( v ) ) {
					EmitString( "81 65" );	// and dword ptr [ebp + 0x7F], 0x12345678
					Emit1( v );
					Emit4( n );
				} else {
					EmitString( "81 A5" );	// and dword ptr [ebp + 0x12345678], 0x12345678
					Emit4( v );
					Emit4( n );
				}
			}
			ip += 5;
			return true;

		//[local] |= CONST
		case MOP_BOR4:
			n = inst[ip+2].value;
			v = ci->value; // local variable address
			if ( ISS8( n ) ) {
				if ( ISS8( v ) ) {
					EmitString( "83 4D" );	// or dword ptr [ebp + 0x7F], 0x12
					Emit1( v );
					Emit1( n );
				} else {
					EmitString( "83 8D" );	// or dword ptr [ebp + 0x12345678], 0x12
					Emit4( v );
					Emit1( n );
				}
			} else {
				if ( ISS8( v ) ) {
					EmitString( "81 4D" );	// or dword ptr [ebp + 0x7F], 0x12345678
					Emit1( v );
					Emit4( n );
				} else {
					EmitString( "81 8D" );	// or dword ptr [ebp + 0x12345678], 0x12345678
					Emit4( v );
					Emit4( n );
				}
			}
			ip += 5;
			return true;

		// [local] = [local]
		case MOP_IGNORE4:
			ip += 3;
			return true;

		// const + call + pop
		case MOP_NCPY:
			EmitCallOffset( FUNC_NCPY );
			ip += 2;
			return true;

	};
	return false;
}

/*
=================
VM_Compile
=================
*/
qbool VM_Compile( vm_t *vm, vmHeader_t *header ) {
	const char *errMsg;
	int     instructionCount;
	int		proc_base;
	int		proc_len;
	int		i, n, v;
	qbool wantres;

    Sys_GetProcessorId(NULL);
	inst = (instruction_t*)Q_malloc( (header->instructionCount + 8 ) * sizeof( instruction_t ) );
	instructionOffsets = (int*)Q_malloc( header->instructionCount * sizeof( int ) );

	errMsg = VM_LoadInstructions( (byte *) header + header->codeOffset, header->codeLength, header->instructionCount, inst );
	if ( !errMsg ) {
		errMsg = VM_CheckInstructions( inst, vm->instructionCount, vm->jumpTableTargets, vm->numJumpTableTargets, vm->exactDataLength );
	}
	if ( errMsg ) {
		VM_FreeBuffers();
		Con_Printf( "VM_CompileX86 error: %s\n", errMsg );
		return false;
	}
	
	//VM_ReplaceInstructions( vm, inst );

	VM_FindMOps( inst, vm->instructionCount );

	code = NULL; // we will allocate memory later, after last defined pass
	instructionPointers = NULL;

	memset( funcOffset, 0, sizeof( funcOffset ) );

	instructionCount = header->instructionCount;

	for( pass = 0; pass < NUM_PASSES; pass++ ) 
	{
__compile:
	pop1 = OP_UNDEF;
	lastConst = 0;

	// translate all instructions
	ip = 0;
	compiledOfs = 0;
	LastCommand = LAST_COMMAND_NONE;

	proc_base = -1;
	proc_len = 0;
	
#if idx64
	EmitString( "53" );				// push rbx
	EmitString( "56" );				// push rsi
	EmitString( "57" );				// push rdi
	EmitString( "55" );				// push rbp
	EmitString( "41 54" );			// push r12
	EmitString( "41 55" );			// push r13
	EmitString( "41 56" );			// push r14
	EmitString( "41 57" );			// push r15

	EmitRexString( "BB" );			// mov rbx, vm->dataBase
	EmitPtr( vm->dataBase );

	EmitString( "49 B8" );			// mov r8, vm->instructionPointers
	EmitPtr( instructionPointers );

	EmitString( "49 C7 C1" );		// mov r9, vm->dataMask
	Emit4( vm->dataMask );

	EmitString( "49 BC" );			// mov r12, vm->systemCall
	EmitPtr( &vm->systemCall );

	EmitString( "49 C7 C5" );		// mov r13, vm->stackBottom
	Emit4( vm->stackBottom );

	EmitRexString( "B8" );			// mov rax, &vm->programStack
	EmitPtr( &vm->programStack );
	EmitString( "8B 30" );			// mov esi, [rax]

	EmitRexString( "B8" );			// mov rax, &vm->opStack
	EmitPtr( &vm->opStack );
	EmitRexString( "8B 38" );		// mov rdi, [rax]

	EmitRexString( "B8" );			// mov rax, &vm->opStackTop
	EmitPtr( &vm->opStackTop );
	EmitString( "4C 8B 30" );		// mov r14, [rax]

#else
	EmitString( "60" );				// pushad

	EmitRexString( "BB" );			// mov ebx, vm->dataBase
	EmitPtr( vm->dataBase );

	EmitString( "8B 35" );			// mov esi, [vm->programStack]
	EmitPtr( &vm->programStack );
	
	EmitString( "8B 3D" );			// mov edi, [vm->opStack]
	EmitPtr( &vm->opStack );
#endif

	EmitCallOffset( FUNC_ENTR );

#if idx64

#ifdef DEBUG_VM
	EmitRexString( "B8" );			// mov rax, &vm->programStack
	EmitPtr( &vm->programStack );
	EmitString( "89 30" );			// mov [rax], esi
#endif

	EmitRexString( "B8" );			// mov rax, &vm->opStack
	EmitPtr( &vm->opStack );
	EmitRexString( "89 38" );		// mov [rax], rdi

	EmitString( "41 5F" );			// pop r15
	EmitString( "41 5E" );			// pop r14
	EmitString( "41 5D" );			// pop r13
	EmitString( "41 5C" );			// pop r12
	EmitString( "5D" );				// pop rbp
	EmitString( "5F" );				// pop rdi
	EmitString( "5E" );				// pop rsi
	EmitString( "5B" );				// pop rbx
#else

#ifdef DEBUG_VM
	EmitString( "89 35" );			// [vm->programStack], esi
	EmitPtr( &vm->programStack );
#endif

	EmitString( "89 3D" );			// [vm->opStack], edi
	EmitPtr( &vm->opStack );

	EmitString( "61" );				// popad
#endif
	
	EmitString( "C3" );				// ret
	
	EmitAlign( 4 );

	 // main function entry offset
	funcOffset[FUNC_ENTR] = compiledOfs;
	
	while ( ip < instructionCount )
	{
		instructionOffsets[ ip ] = compiledOfs;

		ci = &inst[ ip ];
		ni = &inst[ ip + 1 ];
		ip++;

		if ( ci->jused ) {
			LastCommand = LAST_COMMAND_NONE;
			pop1 = OP_UNDEF;
		}
	
		switch ( ci->op ) {

		case OP_UNDEF:
		case OP_IGNORE:
			break;

		case OP_BREAK:
			EmitString( "CC" );		// int 3
			break;

		case OP_ENTER:
			v = ci->value;
			if ( ISU8( v ) ) {
				EmitString( "83 EE" );		// sub	esi, 0x12
				Emit1( v );
			} else {
				EmitString( "81 EE" );		// sub	esi, 0x12345678
				Emit4( v );
			}

			// locate endproc
			for ( n = -1, i = ip + 1; i < instructionCount; i++ ) {
				if ( inst[ i ].op == OP_PUSH && inst[ i + 1 ].op == OP_LEAVE ) {
					n = i;
					break;
				}
			}

			// should never happen because equal check in VM_LoadInstructions() but anyway
			if ( n == -1 ) {
				VM_FreeBuffers();
				Con_Printf( "VM_CompileX86 error: %s\n", "missing proc end" );
				return false;
			}

			proc_base = ip + 1;
			proc_len = n - proc_base + 1 ;

			// programStack overflow check
			if ( (int)vm_rtChecks.value & 1 ) {
#if idx64
				EmitString( "4C 39 EE" );		// cmp	rsi, r13
#else
				EmitString( "81 FE" );			// cmp	esi, vm->stackBottom
				Emit4( vm->stackBottom );
#endif
				EmitString( "0F 82" );			// jb +funcOffset[FUNC_PSOF]
				n = funcOffset[FUNC_PSOF] - compiledOfs;
				Emit4( n - 6 );
			}

			// opStack overflow check
			if ( (int)vm_rtChecks.value & 2 ) {
				if ( ISU8( ci->opStack ) ) {
					EmitRexString( "8D 47" );		// lea eax, [edi+0x7F]
					Emit1( ci->opStack );
				} else {
					EmitRexString( "8D 87" );		// lea eax, [edi+0x12345678]
					Emit4( ci->opStack );
				}
#if idx64
				EmitString( "4C 39 F0" );		// cmp rax, r14
#else
				EmitString( "3B 05" );			// cmp eax, [&vm->opStackTop]
				EmitPtr( &vm->opStackTop );
#endif
				EmitString( "0F 87" );			// ja +funcOffset[FUNC_OSOF]
				n = funcOffset[FUNC_OSOF] - compiledOfs;
				Emit4( n - 6 );
			}

			EmitRexString( "8D 2C 33" );		// lea ebp, [ebx+esi]
			break;

		case OP_CONST:
			
			// we can safely perform optimizations only in case if 
			// we are 100% sure that next instruction is not a jump label
			if ( !ni->jused && ConstOptimize( vm ) )
				break;

			EmitAddEDI4( vm );					// add edi, 4
			EmitString( "C7 07" );				// mov dword ptr [edi], 0x12345678
			lastConst = ci->value;
			Emit4( lastConst );
			LastCommand = LAST_COMMAND_MOV_EDI_CONST;
			break;

		case OP_LOCAL:
			// optimization: merge OP_LOCAL + OP_LOAD4
			if ( ni->op == OP_LOAD4 ) {
				EmitAddEDI4( vm );				// add edi, 4
				v = ci->value;
				if ( ISU8( v ) ) {
					EmitString( "8B 45" );		// mov eax, dword ptr [ebp + 0x7F]
					Emit1( v );
				} else {
					EmitString( "8B 85" );		// mov eax, dword ptr [ebp + 0x12345678]
					Emit4( v );
				}
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX ); // mov dword ptr [edi], eax
				ip++;
				break;
			}

			// optimization: merge OP_LOCAL + OP_LOAD2
			if ( ni->op == OP_LOAD2 ) {
				EmitAddEDI4( vm );				// add edi, 4
				v = ci->value;
				if ( ISU8( v ) ) {
					EmitString( "0F B7 45" );	// movzx eax, word ptr [ebp + 0x7F]
					Emit1( v );
				} else {
					EmitString( "0F B7 85" );	// movzx eax, word ptr [ebp + 0x12345678]
					Emit4( v );
				} 
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX ); // mov dword ptr [edi], eax
				ip++;
				break;
			}

			// optimization: merge OP_LOCAL + OP_LOAD1
			if ( ni->op == OP_LOAD1 ) {
				EmitAddEDI4( vm );				// add edi, 4
				v = ci->value;
				if ( ISU8( v ) ) {
					EmitString( "0F B6 45" );	// movzx eax, byte ptr [ebp + 0x7F]
					Emit1( v );
				} else {
					EmitString( "0F B6 85" );	// movzx eax, byte ptr [ebp + 0x12345678]
					Emit4( v );
				}
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX ); // mov dword ptr [edi], eax
				ip++;
				break;
			}

			// TODO: i = j + k;
			// TODO: i = j - k;

			EmitAddEDI4( vm );					// add edi, 4
			v = ci->value;
			if ( ISU8( v ) ) {
				EmitString( "8D 46" );			// lea eax, [esi + 0x7F]
				Emit1( v );
			} else {
				EmitString( "8D 86" );			// lea eax, [esi + 0x12345678]
				Emit4( v );
			}
			EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			break;

		case OP_ARG:
			if ( LastCommand == LAST_COMMAND_STORE_FLOAT_EDI_SSE ) {
				REWIND(4);
				v = ci->value;
				if ( ISU8( v ) ) {
					EmitString( "F3 0F 11 45" ); // movss dword ptr [ebp + 0x7F], xmm0
					Emit1( v );
				} else {
					EmitString( "F3 0F 11 85" ); // movss dword ptr [ebp + 0x12345678], xmm0
					Emit4( v );
				}
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
				break;
			}
			EmitMovEAXEDI( vm );					// mov	eax, dword ptr [edi]
			if ( (ci+1)->op == MOP_NCPY && !(ci+1)->jused ) {
				// we will read counter from eax
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
				break;
			}
			v = ci->value;
			if ( ISU8( v ) ) {
				EmitString( "89 45" );				// mov	dword ptr [ebp + 0x7F], eax
				Emit1( v );
			} else {
				EmitString( "89 85" );				// mov	dword ptr [ebp + 0x12345678], eax
				Emit4( v );
			}
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_CALL:
#ifdef VM_LOG_SYSCALLS
			// [dataBase + programStack + 0] = ip-1;
			EmitString( "C7 45 00" );				// mov dword ptr [ebp], 0x12345678
			Emit4( ip-1 );
#endif
			EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
			EmitCallOffset( FUNC_CALL );			// call +FUNC_CALL
			break;

		case OP_PUSH:
			EmitAddEDI4( vm );						// add edi, 4
			break;

		case OP_POP:
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_LEAVE:
#ifdef DEBUG_VM
			v = ci->value;
			if ( ISU8( v ) ) {
				EmitString( "83 C6" );		// add	esi, 0x12
				Emit1( v );
			} else {
				EmitString( "81 C6" );		// add	esi, 0x12345678
				Emit4( v );
			}
#endif
			EmitString( "C3" );							// ret
			break;

		case OP_LOAD4:
			if ( LastCommand == LAST_COMMAND_MOV_EDI_EAX ) {
				REWIND( 2 );
				EmitCheckReg( vm, REG_EAX, 4 );			// range check eax
				EmitString( "8B 04 03" );				// mov	eax, dword ptr [ebx + eax]
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
				break;
			}
			EmitMovECXEDI( vm );						// mov ecx, dword ptr [edi]		
			EmitCheckReg( vm, REG_ECX, 4 );				// range check ecx
			EmitString( "8B 04 0B" );					// mov	eax, dword ptr [ebx + ecx]
			EmitCommand( LAST_COMMAND_MOV_EDI_EAX );	// mov dword ptr [edi], eax
			break;

		case OP_LOAD2:
			if ( LastCommand == LAST_COMMAND_MOV_EDI_EAX ) {
				REWIND( 2 );
				EmitCheckReg( vm, REG_EAX, 2 );			// range check eax
				if ( ni->op == OP_SEX16 ) {
					EmitString( "0F BF 04 03" );		// movsx eax, word ptr [ebx + eax]
					ip++;
				} else {
					EmitString( "0F B7 04 03" );		// movzx eax, word ptr [ebx + eax]
				}
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
				break;
			}
			EmitMovECXEDI( vm );						// mov ecx, dword ptr [edi]
			EmitCheckReg( vm, REG_ECX, 2 );				// range check ecx
			if ( ni->op == OP_SEX16 ) {
				EmitString( "0F BF 04 0B" );			// movsx eax, word ptr [ebx + ecx]
				ip++;
			} else {
				EmitString( "0F B7 04 0B" );			// movzx eax, word ptr [ebx + ecx]
			}
			EmitCommand( LAST_COMMAND_MOV_EDI_EAX );	// mov dword ptr [edi], eax
			break;

		case OP_LOAD1:
			if ( LastCommand == LAST_COMMAND_MOV_EDI_EAX ) {
				REWIND( 2 );
				EmitCheckReg( vm, REG_EAX, 1 );			// range check eax
				if ( ni->op == OP_SEX8 ) {
					EmitString( "0F BE 04 03" );		// movsx eax, byte ptr [ebx + eax]
					ip++;
				} else {
					EmitString( "0F B6 04 03" );		// movzx eax, byte ptr [ebx + eax]
				}
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
				break;
			}
			EmitMovECXEDI( vm );						// mov ecx, dword ptr [edi]
			EmitCheckReg( vm, REG_ECX, 1 );				// range check ecx
			if ( ni->op == OP_SEX8 ) {
				EmitString( "0F BE 04 0B" );			// movsx eax, byte ptr [ebx + ecx]
				ip++;
			} else {
				EmitString( "0F B6 04 0B" );			// movzx eax, byte ptr [ebx + ecx]
			}
			EmitCommand( LAST_COMMAND_MOV_EDI_EAX );	// mov dword ptr [edi], eax
			break;

		case OP_STORE4:
			EmitMovEAXEDI( vm );						// mov eax, dword ptr [edi]
			EmitString( "8B 4F FC" );					// mov ecx, dword ptr [edi-4]
			EmitCheckReg( vm, REG_ECX, 4 );				// range check
			EmitString( "89 04 0B" );					// mov dword ptr [ebx + ecx], eax
			EmitCommand( LAST_COMMAND_SUB_DI_8 );		// sub edi, 8
			break;

		case OP_STORE2:
			EmitMovEAXEDI( vm );						// mov eax, dword ptr [edi]	
			EmitString( "8B 4F FC" );					// mov ecx, dword ptr [edi-4]
			EmitCheckReg( vm, REG_ECX, 2 );				// range check
			EmitString( "66 89 04 0B" );				// mov word ptr [ebx + ecx], ax
			EmitCommand( LAST_COMMAND_SUB_DI_8 );		// sub edi, 8
			break;

		case OP_STORE1:
			EmitMovEAXEDI( vm );						// mov eax, dword ptr [edi]	
			EmitString( "8B 4F FC" );					// mov ecx, dword ptr [edi-4]
			EmitCheckReg( vm, REG_ECX, 1 );				// range check
			EmitString( "88 04 0B" );					// mov byte ptr [ebx + ecx], al
			EmitCommand( LAST_COMMAND_SUB_DI_8 );		// sub edi, 8
			break;

		case OP_EQ:
		case OP_NE:
		case OP_LTI:
		case OP_LEI:
		case OP_GTI:
		case OP_GEI:
		case OP_LTU:
		case OP_LEU:
		case OP_GTU:
		case OP_GEU:
			EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
			EmitCommand( LAST_COMMAND_SUB_DI_8 );	// sub edi, 8
			EmitString( "39 47 04" );				// cmp dword ptr [edi+4], eax
			EmitJump( vm, ci, ci->op, ci->value );
			break;

		case OP_EQF:
		case OP_NEF:
		case OP_LTF:
		case OP_LEF:
		case OP_GTF:
		case OP_GEF:
			if ( HasFCOM() ) {
				EmitLoadFloatEDI( vm );
				if ( HasSSEFP() ) {
					EmitString( "F3 0F 10 4F FC" );			// movss xmm1, dword ptr [edi-4]
					EmitCommand( LAST_COMMAND_SUB_DI_8 );	// sub edi, 8
					EmitString( "0F 2F C8" );				// comiss xmm1, xmm0
				} else {
					EmitCommand( LAST_COMMAND_SUB_DI_8 );	// sub edi, 8
					//EmitString( "D9 47 08" );				// fld dword ptr [edi+8]
					EmitString( "D9 47 04" );				// fld dword ptr [edi+4]
					EmitString( "DF E9" );					// fucomip
					EmitString( "DD D8" );					// fstp st(0)
				}
				EmitJump( vm, ci, ci->op, ci->value );
			} else {
				EmitCommand( LAST_COMMAND_SUB_DI_8 );	// sub edi, 8
				EmitString( "D9 47 04" );				// fld dword ptr [edi+4]
				EmitString( "D8 5F 08" );				// fcomp dword ptr [edi+8]
				EmitString( "DF E0" );					// fnstsw ax
				EmitFloatJump( vm, ci, ci->op, ci->value );
			}
			pop1 = OP_UNDEF;
			break;			

		case OP_NEGI:
			EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
			EmitString( "F7 D8" );					// neg eax
			EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			break;

		case OP_ADD:
			wantres = ( ops[ ni->op ].stack <= 0 );
			EmitMovEAXEDI( vm );						// mov eax, dword ptr [edi]
			if ( wantres ) {
				EmitString( "03 47 FC" );				// add eax, dword ptr [edi-4]
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			} else {
				EmitString( "01 47 FC" );				// add dword ptr [edi-4],eax
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			}
			break;

		case OP_SUB:
			wantres = ( ops[ ni->op ].stack <= 0 );
			if ( wantres ) {
				EmitMovECXEDI( vm );					// mov ecx,dword ptr [edi]
				EmitString( "8B 47 FC" );				// mov eax,dword ptr [edi-4]
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
				EmitString( "29 C8" );					// sub eax, ecx
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			} else {
				EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
				EmitString( "29 47 FC" );				// sub dword ptr [edi-4],eax
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			}
			break;

		case OP_DIVI:
			wantres = ( ops[ ni->op ].stack <= 0 );
			EmitMovECXEDI( vm );					// mov ecx,dword ptr [edi]
			EmitString( "8B 47 FC" );				// mov eax,dword ptr [edi-4]
			if ( wantres ) {
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
				EmitString( "99" );						// cdq
				EmitString( "F7 F9" );					// idiv ecx
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			} else{
				EmitString( "99" );						// cdq
				EmitString( "F7 F9" );					// idiv ecx
				EmitString( "89 47 FC" );				// mov dword ptr [edi-4],eax
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			}
			break;

		case OP_DIVU:
			EmitString( "8B 47 FC" );				// mov eax,dword ptr [edi-4]
			EmitString( "33 D2" );					// xor edx, edx
			EmitString( "F7 37" );					// div dword ptr [edi]
			EmitString( "89 47 FC" );				// mov dword ptr [edi-4],eax
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_MODI:
			EmitString( "8B 47 FC" );				// mov eax,dword ptr [edi-4]
			EmitString( "99" );						// cdq
			EmitString( "F7 3F" );					// idiv dword ptr [edi]
			EmitString( "89 57 FC" );				// mov dword ptr [edi-4],edx
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_MODU:
			EmitString( "8B 47 FC" );				// mov eax,dword ptr [edi-4]
			EmitString( "33 D2" );					// xor edx, edx
			EmitString( "F7 37" );					// div dword ptr [edi]
			EmitString( "89 57 FC" );				// mov dword ptr [edi-4],edx
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_MULI:
			wantres = ( ops[ ni->op ].stack <= 0 );
			EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
			EmitString( "F7 6F FC" );				// imul eax, dword ptr [edi-4]
			if ( wantres ) {
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			} else {
				EmitString( "89 47 FC" );				// mov dword ptr [edi-4],eax
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			}
			break;

		case OP_MULU:
			EmitString( "8B 47 FC" );				// mov eax,dword ptr [edi-4]
			EmitString( "F7 27" );					// mul dword ptr [edi]
			EmitString( "89 47 FC" );				// mov dword ptr [edi-4],eax
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_BAND:
			wantres = ( ops[ ni->op ].stack <= 0 );
			EmitMovEAXEDI( vm );						// mov eax, dword ptr [edi]
			if ( wantres ) {
				EmitString( "23 47 FC" );				// and eax, dword ptr [edi-4]
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			} else {
				EmitString( "21 47 FC" );				// and dword ptr [edi-4],eax
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			}
			break;

		case OP_BOR:
			EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
			EmitString( "09 47 FC" );				// or dword ptr [edi-4],eax
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_BXOR:
			EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
			EmitString( "31 47 FC" );				// xor dword ptr [edi-4],eax
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_BCOM:
			EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
			EmitString( "F7 D0" );					// not eax
			EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			break;

		case OP_LSH:
			EmitMovECXEDI( vm );					// mov ecx, dword ptr [edi]
			EmitString( "D3 67 FC" );				// shl dword ptr [edi-4], cl
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_RSHI:
			EmitMovECXEDI( vm );					// mov ecx, dword ptr [edi]
			EmitString( "D3 7F FC" );				// sar dword ptr [edi-4], cl
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_RSHU:
			EmitMovECXEDI( vm );					// mov ecx, dword ptr [edi]
			EmitString( "D3 6F FC" );				// shr dword ptr [edi-4], cl
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			break;

		case OP_NEGF:
			//if ( !ci->fpu )
			EmitLoadFloatEDI( vm );					// fld dword ptr [edi] | movss xmm0, dword ptr [edi]
			if ( HasSSEFP() ) {
				EmitString( "0F 57 C9" );			// xorps xmm1, xmm1
				EmitString( "0F 5C C8" );			// subps xmm1, xmm0
				EmitString( "0F 28 C1" );			// movaps xmm0, xmm1
			} else {
				EmitString( "D9 E0" );				// fchs
			}
			//if ( !ci->fpu || ci->store )
			EmitCommand( LAST_COMMAND_STORE_FLOAT_EDI ); // fstp dword ptr [edi]
			break;

		case OP_ADDF:
		case OP_SUBF:
		case OP_DIVF:
		case OP_MULF:
			wantres = ( ops[ ni->op ].stack <= 0 );
			if ( HasSSEFP() ) {
				if ( LastCommand == LAST_COMMAND_STORE_FLOAT_EDI_SSE ) {
					REWIND(4);
					EmitString( "0F 28 C8" );		// movaps xmm1, xmm0
				} else {
					EmitString( "F3 0F 10 0F" );	// movss xmm1, dword ptr [edi]
				}
				EmitString( "F3 0F 10 47 FC" );		// movss xmm0, dword ptr [edi-4]
				if ( wantres ) {
					if ( ni->op == OP_STORE4 ) {
						 EmitString( "8B 47 F8" );	// mov eax, dword ptr [edi-8]
						 EmitCheckReg( vm, REG_EAX, 4 );
					} else if ( ni->op == OP_ARG ) {
						//
					} else {
						EmitCommand( LAST_COMMAND_SUB_DI_4 );
					}
				}
				switch( ci->op ) {
					case OP_ADDF: EmitString( "0F 58 C1" ); break;	// addps xmm0, xmm1
					case OP_SUBF: EmitString( "0F 5C C1" ); break;	// subps xmm0, xmm1
					case OP_MULF: EmitString( "0F 59 C1" ); break;	// mulps xmm0, xmm1
					case OP_DIVF: EmitString( "0F 5E C1" ); break;	// divps xmm0, xmm1
				}
				if ( wantres ) {
					if ( ni->op == OP_STORE4 ) {
						EmitString( "F3 0F 11 04 03" );		// movss dword ptr [ebx + eax], xmm0
						EmitCommand( LAST_COMMAND_SUB_DI_12 );
						pop1 = OP_UNDEF;
						ip++; // OP_STORE4
					} else if ( ni->op == OP_ARG ) {
						v = ni->value;
						if ( ISU8( v ) ) {
							EmitString( "F3 0F 11 45" ); // movss dword ptr [ebp + 0x7F], xmm0
							Emit1( v );
						} else {
							EmitString( "F3 0F 11 85" ); // movss dword ptr [ebp + 0x12345678], xmm0
							Emit4( v );
						}
						EmitCommand( LAST_COMMAND_SUB_DI_8 );
						pop1 = OP_UNDEF;
						ip++; // OP_ARG
					} else {
						EmitCommand( LAST_COMMAND_STORE_FLOAT_EDI );
					}
				} else {
					EmitString( "F3 0F 11 47 FC" );			// movss dword ptr [edi-4], xmm0
					EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
				}
			} else {
				EmitString( "D9 47 FC" );			// fld dword ptr [edi-4]
				EmitFCalcEDI( ci->op );				// fadd|fsub|fmul|fdiv dword ptr [edi]
				EmitString( "D9 5F FC" );			// fstp dword ptr [edi-4]
				EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4
			}
			break;

		case OP_CVIF:
			if ( HasSSEFP() ) {
				if ( LastCommand == LAST_COMMAND_MOV_EDI_EAX ) {
					REWIND(2);
					EmitString( "F3 0F 2A C0" );	// cvtsi2ss xmm0, eax
				} else {
					EmitString( "F3 0F 2A 07" );	// cvtsi2ss xmm0, dword ptr [edi]
				}
			} else {
				EmitString( "DB 07" );				// fild dword ptr [edi]
			}
			//if ( !ci->fpu ) 
			EmitCommand( LAST_COMMAND_STORE_FLOAT_EDI );
			break;

		case OP_CVFI:
			if ( HasSSEFP() ) {
				// assume that rounding mode in MXCSR is correctly set in 64-bit environment
				EmitLoadFloatEDI_SSE( vm );				// movss xmm0, dword ptr [edi]
				EmitString( "F3 0F 2C C0" );			// cvttss2si eax, xmm0
				EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			} else {
				EmitLoadFloatEDI_X87( vm );			// fld dword ptr [edi]
				// call the library conversion function
				EmitCallOffset( FUNC_FTOL );	// call +FUNC_FTOL
			}
			break;

		case OP_SEX8:
			EmitString( "0F BE 07" );				// movsx eax, byte ptr [edi]
			EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			break;

		case OP_SEX16:
			EmitString( "0F BF 07" );				// movsx eax, word ptr [edi]
			EmitCommand( LAST_COMMAND_MOV_EDI_EAX );// mov dword ptr [edi], eax
			break;

		case OP_BLOCK_COPY:
			EmitString( "B9" );						// mov ecx, 0x12345678
			Emit4( ci->value >> 2 );
			EmitCallOffset( FUNC_BCPY );
			break;

		case OP_JUMP:
			EmitMovEAXEDI( vm );					// mov eax, dword ptr [edi]
			EmitCommand( LAST_COMMAND_SUB_DI_4 );	// sub edi, 4

			// jump target range check
			if ( (int)vm_rtChecks.value & 4 ) {
				if ( proc_base != -1 ) {
					// allow jump within local function scope only
					EmitString( "89 C2" );			// mov edx, eax
					if ( ISU8( proc_base ) ) {
						EmitString( "83 EA" );		// sub edx, 0x7F
						Emit1( proc_base );
					} else {
						EmitString( "81 EA" );		// sub edx, 0x12345678
						Emit4( proc_base );
					}
					if ( ISU8( proc_len ) ) {
						EmitString( "83 FA" );		// cmp edx, 0x7F
						Emit1( proc_len );
					} else {
						EmitString( "81 FA" );		// cmp edx, 0x12345678
						Emit4( proc_len );
					}
				} else {
					EmitString( "3D" );				// cmp eax, 0x12345678
					Emit4( vm->instructionCount );
				}
				EmitString( "0F 83" );				// jae +funcOffset[FUNC_BADJ]
				n = funcOffset[FUNC_BADJ] - compiledOfs;
				Emit4( n - 6 );
			}
#if idx64
			EmitString( "41 FF 24 C0" );			// jmp dword ptr [r8 + rax*8]
#else
			EmitString( "FF 24 85" );				// jmp dword ptr [instructionPointers + eax * 4]
			EmitPtr( instructionPointers );
#endif
			break;

		case MOP_IGNORE4:
		case MOP_ADD4:
		case MOP_SUB4:
		case MOP_BAND4:
		case MOP_BOR4:
		case MOP_NCPY:
			if ( !EmitMOPs( vm, ci->op ) )
				SV_Error( "VM_CompileX86: bad opcode %02X", ci->op );
			break;

		default:
			SV_Error( "VM_CompileX86: bad opcode %02X", ci->op );
			VM_FreeBuffers();
			return false;
		}

		pop1 = (opcode_t)ci->op;
	} // while( ip < header->instructionCount )

		// ****************
		// system functions
		// ****************
		EmitAlign( 8 );
		funcOffset[FUNC_CALL] = compiledOfs;
		EmitCallFunc( vm );

		EmitAlign( 8 );
		funcOffset[FUNC_FTOL] = compiledOfs;
		EmitFTOLFunc( vm );

		EmitAlign( 8 );
		funcOffset[FUNC_BCPY] = compiledOfs;
		EmitBCPYFunc( vm );

		EmitAlign( 8 );
		funcOffset[FUNC_NCPY] = compiledOfs;
		EmitNCPYFunc( vm );

		// ***************
		// error functions
		// ***************

		// bad jump
		EmitAlign( 8 );
		funcOffset[FUNC_BADJ] = compiledOfs;
		EmitBADJFunc( vm );

		// error jump
		EmitAlign( 8 );
		funcOffset[FUNC_ERRJ] = compiledOfs;
		EmitERRJFunc( vm );

		// programStack overflow
		EmitAlign( 8 );
		funcOffset[FUNC_PSOF] = compiledOfs;
		EmitPSOFFunc( vm );

		// opStack overflow
		EmitAlign( 8 );
		funcOffset[FUNC_OSOF] = compiledOfs;
		EmitOSOFFunc( vm );

		// read/write access violation
		EmitAlign( 8 );
		funcOffset[FUNC_DATA] = compiledOfs;
		EmitDATAFunc( vm );

		EmitAlign( sizeof( intptr_t ) ); // for instructionPointers

	} // for( pass = 0; pass < n; pass++ )

	n = header->instructionCount * sizeof( intptr_t );

	if ( code == NULL ) {
		code = (byte*)VM_Alloc_Compiled( vm, PAD(compiledOfs,8), n );
		if ( code == NULL ) {
			return false;
		}
		instructionPointers = (intptr_t*)(byte*)(code + PAD(compiledOfs,8));
		//vm->instructionPointers = instructionPointers; // for debug purposes?
		pass = NUM_PASSES-1; // repeat last pass
		goto __compile;
	}

	// offset all the instruction pointers for the new location
	for ( i = 0 ; i < header->instructionCount ; i++ ) {
		if ( !inst[i].jused ) {
			instructionPointers[ i ] = (intptr_t)badJumpPtr;
			continue;
		}
		instructionPointers[ i ] = (intptr_t)vm->codeBase.ptr + instructionOffsets[ i ];
	}

	VM_FreeBuffers();

#ifdef VM_X86_MMAP
	if ( mprotect( vm->codeBase.ptr, vm->codeSize, PROT_READ|PROT_EXEC ) ) {
		VM_Destroy_Compiled( vm );
		Con_Printf( "VM_CompileX86: mprotect failed\n" );
		return false;
	}
#elif _WIN32
	{
		DWORD oldProtect = 0;
		
		// remove write permissions.
		if ( !VirtualProtect( vm->codeBase.ptr, vm->codeSize, PAGE_EXECUTE_READ, &oldProtect ) ) {
			VM_Destroy_Compiled( vm );
			Con_Printf( "VM_CompileX86: VirtualProtect failed\n" );
			return false;
		}
	}
#endif

	vm->destroy = VM_Destroy_Compiled;

	Con_Printf( "VM file %s compiled to %i bytes of code\n", vm->name, compiledOfs );

	return true;
}
/*
=================
VM_Alloc_Compiled
=================
*/
static void *VM_Alloc_Compiled( vm_t *vm, int codeLength, int tableLength )
{
	void	*ptr;
	int		length;

	length = codeLength + tableLength;
#ifdef VM_X86_MMAP
	ptr = mmap( NULL, length, PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0 );
	if ( ptr == MAP_FAILED ) {
		SV_Error( "VM_CompileX86: mmap failed" );
		return NULL;
	}
#elif _WIN32
	// allocate memory with EXECUTE permissions under windows.
	ptr = VirtualAlloc( NULL, length, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
	if ( !ptr ) {
		SV_Error( "VM_CompileX86: VirtualAlloc failed" );
		return NULL;
	}
#else
	ptr = malloc( length );
	if ( !ptr ) {
		SV_Error( "VM_CompileX86: malloc failed" );
		return NULL;
	}
#endif
	vm->codeBase.ptr = (byte*)ptr;
	vm->codeLength = codeLength;
	vm->codeSize = length;

	return vm->codeBase.ptr;
}


/*
==============
VM_Destroy_Compiled
==============
*/
static void VM_Destroy_Compiled( vm_t* vm )
{
#ifdef VM_X86_MMAP
	munmap( vm->codeBase.ptr, vm->codeSize );
#elif _WIN32
	VirtualFree( vm->codeBase.ptr, 0, MEM_RELEASE );
#else
	free( vm->codeBase.ptr );
#endif
	vm->codeBase.ptr = NULL;
}

/*
==============
VM_CallCompiled

This function is called directly by the generated code
==============
*/
int	VM_CallCompiled( vm_t *vm, int nargs, int *args ) 
{
	int		opStack[MAX_OPSTACK_SIZE];
	unsigned int stackOnEntry;
	int		*image;
	int		*oldOpTop;
	int		i;

	// we might be called recursively, so this might not be the very top
	stackOnEntry = vm->programStack;
	oldOpTop = vm->opStackTop;

	vm->programStack -= (MAX_VMMAIN_CALL_ARGS+2)*4;

	// set up the stack frame 
	image = (int*)( vm->dataBase + vm->programStack );
	for ( i = 0; i < nargs; i++ ) {
		image[ i + 2 ] = args[ i ];
	}

	image[1] =  0;	// return stack
	image[0] = -1;	// will terminate loop on return

	opStack[1] = 0;

	vm->opStack = opStack;
	vm->opStackTop = opStack + ARRAY_LEN( opStack ) - 1;

	vm->codeBase.func(); // go into generated code

	if ( vm->opStack != &opStack[1] ) {
		SV_Error( "opStack corrupted in compiled code" );
	}

#ifdef DEBUG_VM
	if ( vm->programStack != stackOnEntry - CALL_PSTACK ) {
		SV_Error( "programStack corrupted in compiled code" );
	}
#endif

	vm->programStack = stackOnEntry;
	vm->opStackTop = oldOpTop;

	return vm->opStack[0];
}
#else
int	VM_CallCompiled( vm_t *vm, int nargs, int *args ) { return 0;}
qbool VM_Compile( vm_t *vm, vmHeader_t *header ) { return false; }
#endif
#endif				/* USE_PR2 */



================================================
FILE: src/vx_camera.c
================================================
/*
Copyright (C) 2011 VULTUREIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

//VULTUREIIC
//Like so many other things, the camera features never got finished. I had in mind all kinds of neat things too


#include "quakedef.h"
#include "vx_stuff.h"


vec3_t	camera_pos; //Where the camera is
vec3_t	camera_angles; //Where the camera is looking
vec3_t	camera_pos_finish; //Where we want the camera to stop
vec3_t	camera_angles_finish; //Where we want the camera looking when we stop
float	camera_speed; //Speed that the camera moves

cameramode_t cameratype;

void CameraRandomPoint (vec3_t org)
{
	/* ?TONIK? WTF is cl.simorg */
	vec3_t stop, normal, dest, forward, right, up, vec;

	dest[0] = org[0] + (rand() % 500 - 250);
	dest[1] = org[1] + (rand() % 500 - 250);
	dest[2] = org[2] + (rand() % 100 + 50);

	CL_TraceLine (org, dest, stop, normal);
	VectorSubtract (org, stop, vec);
	AngleVectors (vec, forward, right, up);
	if (!VectorCompare (dest, stop)) {
		dest[0] = stop[0] + forward[0] * 15 + normal[0] * 15;
		dest[1] = stop[1] + forward[1] * 15 + normal[1] * 15;
		dest[2] = stop[2] + forward[2] * 15 + normal[2] * 15;
	}

	VectorCopy (dest, camera_pos);
}

void CameraUpdate (qbool dead)
{
	vec3_t dest, destangles;
	if ((cls.demoplayback || cl.spectator) && cl_camera_tpp.integer == 1)
		cameratype = C_CHASECAM;
	else if ((cls.demoplayback || cl.spectator) && cl_camera_tpp.integer == 2)
	{
		if (cameratype == C_NORMAL)
			CameraRandomPoint (cl.simorg);
		cameratype = C_EXTERNAL;
	}
	else if (dead && (cls.demoplayback || cl.spectator) && amf_camera_death.value)
	{
		if (cameratype == C_NORMAL)
			CameraRandomPoint (cl.simorg);
		cameratype = C_EXTERNAL;
	}
	else
		cameratype = C_NORMAL;
	if (cameratype == C_NORMAL)
	{
		VectorCopy (cl.simorg, camera_pos);
		VectorCopy (cl.simangles, camera_angles);
		return;
	}

	//CHASECAM
	if (cameratype == C_CHASECAM)
	{
		if (!dead)
		{
			float	dist = amf_camera_chase_dist.value;
			float	height = amf_camera_chase_height.value;
			int i;
			vec3_t	forward, up, right, normal, impact;
			
			AngleVectors (cl.viewangles, forward, right, up);
			for (i=0;i<3;i++)
				dest[i] = r_refdef.vieworg[i] + forward[i] * dist;
			dest[2] = dest[2] + height;
			CL_TraceLine (r_refdef.vieworg, dest, impact, normal);
			if (!VectorCompare(dest, impact))
			{
				dest[0] = impact[0] + forward[0] * 8 + normal[0] * 4;
				dest[1] = impact[1] + forward[1] * 8 + normal[1] * 4;
				dest[2] = impact[2] + forward[2] * 8 + normal[2] * 4;
			}
			VectorCopy(cl.simangles, destangles);
		}
		else
		{
			cameratype = C_EXTERNAL;
			//cameratype = C_NORMAL;
			return;
		}
	}
	else if (cameratype == C_EXTERNAL)
	{
		vec3_t normal, impact, vec;
		CL_TraceLine (camera_pos, cl.simorg, impact, normal);
		if (!VectorCompare(cl.simorg, impact))
			CameraRandomPoint (cl.simorg);
		VectorSubtract(cl.simorg, camera_pos, vec);
		vectoangles(vec, destangles);
		destangles[0] = -destangles[0];
		VectorCopy(camera_pos, dest);
	}

	VectorCopy(dest, r_refdef.vieworg);
	VectorCopy(destangles, r_refdef.viewangles);
	VectorCopy (dest, camera_pos);
	VectorCopy (destangles, camera_angles);
}


================================================
FILE: src/vx_camera.h
================================================
/*
Copyright (C) 2011 VultureIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

//vx_camera.h for QWAMF
//VultureIIC

void Start_DeathCam(void);
void Update_DeathCam(void);
void End_DeathCam(void);
extern cvar_t r_deathcam;
extern cvar_t chase_back;
extern cvar_t chase_up;
extern cvar_t chase_active;
extern cvar_t r_externcam;
extern qbool chasecam_allowed;

extern int externcam;
extern vec3_t death_org;


//Screen shaking
extern vec3_t shakemag[1];
extern cvar_t r_screenshaking;

void ApplyRadialForce(vec3_t org, float power);
void Update_ScreenShake (void);
void Reset_ScreenShake (void);
void Init_ScreenShake (void);


================================================
FILE: src/vx_coronas.c
================================================
/*
Copyright (C) 2011 VULTUREIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "vx_stuff.h"
#include "glm_texture_arrays.h"
#include "r_sprite3d.h"
#include "r_state.h"

//fixme: move to header
extern float bubblecolor[NUM_DLIGHTTYPES][4];
static void CoronaStats(int change);

typedef struct corona_s
{
	vec3_t origin;
	float scale;
	float growth;
	float die;
	vec3_t color;
	float alpha;
	float fade;
	coronatype_t type;
	qbool sighted;
	qbool los; //to prevent having to trace a line twice
	int texture;
	struct corona_s* next;

	int static_entity_id;
	int client_entity_id;
} corona_t;

//Tei: original whas 256, upped so whas low (?!) for some games
#define MAX_CORONAS 300

static corona_t r_corona[MAX_CORONAS];
static corona_t* r_corona_by_tex[CORONATEX_COUNT];

#define CORONA_SCALE 130
#define CORONA_ALPHA 1

void R_UpdateCoronas(void)
{
	int i;
	corona_t *c;
	float frametime = cls.frametime;

	memset(r_corona_by_tex, 0, sizeof(r_corona_by_tex));

	CoronaStats(-CoronaCount);
	for (i = 0; i < MAX_CORONAS; i++) {
		c = &r_corona[i];

		if (c->type == C_FREE) {
			continue;
		}
		if (c->type == C_EXPLODE) {
			if (c->die < cl.time && c->texture != CORONATEX_EXPLOSIONFLASH7) {
				c->texture++;
				c->die = cl.time + 0.03;
			}
		}

		// First, check to see if it's time to die.
		if (!amf_coronas.integer || c->die < cl.time || c->scale <= 0 || c->alpha <= 0) {
			// Free this corona up.
			c->scale = 0;
			c->alpha = 0;
			c->type = C_FREE;
			c->sighted = false;
			c->client_entity_id = 0; // so can be reused
			c->static_entity_id = 0;
			continue;
		}

		CoronaStats(1);
		c->scale += c->growth * frametime;
		c->alpha += c->fade * frametime;

		c->next = r_corona_by_tex[c->texture];
		r_corona_by_tex[c->texture] = c;

		c->los = true;
		if (c->static_entity_id > 0) {
			c->los = (cl_static_entities[c->static_entity_id - 1].visframe >= r_framecount - 1);
		}
		else if (c->client_entity_id > 0) {
			c->los = (cl_entities[c->client_entity_id - 1].sequence == cl.validsequence);
		}
		if (c->los) {
			vec3_t impact = { 0,0,0 }, normal, temp;

			VectorCopy(c->origin, temp);
			if (c->type == C_FIRE) {
				temp[2] += 6;
			}
			CL_TraceLine(r_refdef.vieworg, temp, impact, normal);
			c->los = VectorCompare(impact, temp);
		}
		if (!c->los) {
			//Can't see it, so make it fade out(faster)
			c->scale = 0;
			c->alpha = 0;
		}
		else {
			if (c->type == C_FIRE) {
				c->fade = 1.5;
				c->growth = 1000;
				if (c->scale > 150) {
					c->scale = 150 + rand() % 15; //flicker when at full radius
				}
				c->alpha = min(c->alpha, 0.2f);
			}
			c->sighted = true;
		}
	}
}

//R_DrawCoronas
void R_DrawCoronas(void)
{
	vec3_t dist, up, right;
	float fdist, scale, alpha;
	corona_t *c;
	corona_texture_id tex;

	if (!amf_coronas.integer && !CoronaCount) {
		return;
	}

	if (!ISPAUSED) {
		R_UpdateCoronas();
	}

	VectorScale(vup, 1, up);//1.5
	VectorScale(vright, 1, right);

	for (tex = CORONATEX_STANDARD; tex < CORONATEX_COUNT; ++tex) {
		sprite3d_batch_id batch_id = SPRITE3D_CORONATEX_STANDARD + (tex - CORONATEX_STANDARD);
		corona_texture_t* texture = &corona_textures[tex];
		byte color[4];

		if (!r_corona_by_tex[tex]) {
			continue;
		}

		R_Sprite3DInitialiseBatch(batch_id, r_state_coronas, R_UseModernOpenGL() ? texture->array_tex : texture->texnum, texture->array_index, r_primitive_triangle_strip);

		for (c = r_corona_by_tex[tex]; c; c = c->next) {
			r_sprite3d_vert_t* vert;
			if (c->type == C_FREE) {
				continue;
			}
			if (!c->los) {
				// can't see it and
				if (!c->sighted) {
					// haven't seen it before
					continue; // don't draw it
				}
			}
			// else it will be fading out, so that's 'kay

			VectorSubtract(r_refdef.vieworg, c->origin, dist);
			fdist = VectorLength(dist);

			fdist = max(fdist, 24);
			scale = (1 - 1 / fdist) * c->scale;
			alpha = c->alpha;

			color[0] = (c->color[0] * alpha) * 255;
			color[1] = (c->color[1] * alpha) * 255;
			color[2] = (c->color[2] * alpha) * 255;
			color[3] = 0;

			vert = R_Sprite3DAddEntry(batch_id, 4);
			if (!vert) {
				break;
			}

			R_Sprite3DSetVert(
				vert++,
				// Left/Up
				c->origin[0] + up[0] * (scale / 2) + (right[0] * (scale / 2)*-1),
				c->origin[1] + up[1] * (scale / 2) + (right[1] * (scale / 2)*-1),
				c->origin[2] + up[2] * (scale / 2) + (right[2] * (scale / 2)*-1),
				0, 0, color, texture->array_index
			);
			R_Sprite3DSetVert(
				vert++,
				// Right/Up
				c->origin[0] + right[0] * (scale / 2) + up[0] * (scale / 2),
				c->origin[1] + right[1] * (scale / 2) + up[1] * (scale / 2),
				c->origin[2] + right[2] * (scale / 2) + up[2] * (scale / 2),
				texture->array_scale_s, 0, color, texture->array_index
			);
			R_Sprite3DSetVert(
				vert++,
				// Left/Down
				c->origin[0] + (right[0] * (scale / 2)*-1) + (up[0] * (scale / 2)*-1),
				c->origin[1] + (right[1] * (scale / 2)*-1) + (up[1] * (scale / 2)*-1),
				c->origin[2] + (right[2] * (scale / 2)*-1) + (up[2] * (scale / 2)*-1),
				0, texture->array_scale_t, color, texture->array_index
			);
			R_Sprite3DSetVert(
				vert++,
				// Right/Down
				c->origin[0] + right[0] * (scale / 2) + (up[0] * (scale / 2)*-1),
				c->origin[1] + right[1] * (scale / 2) + (up[1] * (scale / 2)*-1),
				c->origin[2] + right[2] * (scale / 2) + (up[2] * (scale / 2)*-1),
				texture->array_scale_s, texture->array_scale_t, color, texture->array_index
			);

			// It's sort of cheap, but lets draw a few more here to make the effect more obvious
			if (c->type == C_FLASH || c->type == C_BLUEFLASH) {
				int a;

				for (a = 0; a < 5; a++) {
					vert = R_Sprite3DAddEntry(batch_id, 4);
					if (!vert) {
						break;
					}

					R_Sprite3DSetVert(
						vert++,
						// Left/Up
						c->origin[0] + up[0] * (scale / 30) + (right[0] * (scale)*-1),
						c->origin[1] + up[1] * (scale / 30) + (right[1] * (scale)*-1),
						c->origin[2] + up[2] * (scale / 30) + (right[2] * (scale)*-1),
						0, 0, color, texture->array_index
					);
					R_Sprite3DSetVert(
						vert++,
						// Right/Up
						c->origin[0] + right[0] * (scale)+up[0] * (scale / 30),
						c->origin[1] + right[1] * (scale)+up[1] * (scale / 30),
						c->origin[2] + right[2] * (scale)+up[2] * (scale / 30),
						texture->array_scale_s, 0, color, texture->array_index
					);
					R_Sprite3DSetVert(
						vert++,
						// Left/Down
						c->origin[0] + (right[0] * (scale)*-1) + (up[0] * (scale / 30)*-1),
						c->origin[1] + (right[1] * (scale)*-1) + (up[1] * (scale / 30)*-1),
						c->origin[2] + (right[2] * (scale)*-1) + (up[2] * (scale / 30)*-1),
						0, texture->array_scale_t, color, texture->array_index
					);
					R_Sprite3DSetVert(
						vert++,
						// Right/Down
						c->origin[0] + right[0] * (scale)+(up[0] * (scale / 30)*-1),
						c->origin[1] + right[1] * (scale)+(up[1] * (scale / 30)*-1),
						c->origin[2] + right[2] * (scale)+(up[2] * (scale / 30)*-1),
						texture->array_scale_s, texture->array_scale_t, color, texture->array_index
					);
				}
			}
		}
	}
}

static void R_CoronasNewImpl(coronatype_t type, vec3_t origin, int entity_id)
{
	corona_t *c = NULL;
	int i;
	qbool corona_found = false;
	int corona_id = 0;
	customlight_t cst_lt = { 0 };

	if (ISPAUSED || !amf_coronas.integer) {
		return;
	}

	if (entity_id) {
		entity_id = bound(0, entity_id, CL_MAX_EDICTS);

		corona_id = cl_entities[entity_id - 1].corona_id;
		if (corona_id >= 0 && corona_id < MAX_CORONAS) {
			if (r_corona[corona_id].client_entity_id == entity_id) {
				c = &r_corona[corona_id];
				corona_found = true;
			}
		}
	}

	if (!c) {
		c = r_corona;
		for (i = 0; i < MAX_CORONAS; i++, c++) {
			if (c->type == C_FREE) {
				memset(c, 0, sizeof(*c));
				corona_found = true;
				break;
			}
		}
	}

	if (!corona_found) {
		//Tei: last attempt to get a valid corona to "canibalize"
		c = r_corona;
		for (i = 0; i < MAX_CORONAS; i++, c++) {
			//Search a fire corona that is about to die soon
			if ((c->type == C_FIRE) &&
				(c->die < (cl.time + 0.1f) || c->scale <= 0.1f || c->alpha <= 0.1f)
				) {
				memset(c, 0, sizeof(*c));
				corona_found = true;
				// succesfully canibalize a fire corona that whas about to die.
				break;
			}
		}
		//If can't canibalize a corona, It exit silently
		//This is the worst case scenario, and will never happend
		return;
	}

	c->sighted = false;
	VectorCopy(origin, c->origin);
	c->type = type;
	c->los = false;
	c->texture = CORONATEX_STANDARD;
	c->client_entity_id = entity_id;
	if (entity_id) {
		cl_entities[entity_id - 1].corona_id = c - r_corona;
	}

	if (type == C_FLASH || type == C_BLUEFLASH) {
		if (type == C_BLUEFLASH) {
			VectorCopy(bubblecolor[lt_blue], c->color);
		}
		else {
			dlightColorEx(r_explosionlightcolor.value, r_explosionlightcolor.string, lt_explosion, false, &cst_lt);
			if (cst_lt.type == lt_custom) {
				VectorCopy(cst_lt.color, c->color);
				VectorScale(c->color, (1.0 / 255), c->color); // cast byte to float
			}
			else {
				VectorCopy(bubblecolor[cst_lt.type], c->color);
			}
			VectorMA(c->color, 1.5, c->color, c->color);
		}
		c->scale = 600;
		c->die = cl.time + 0.2;
		c->alpha = 0.25;
		c->fade = 0;
		c->growth = -3000;
	}
	else if (type == C_SMALLFLASH) {
		c->color[0] = 1;
		c->color[1] = 0.8;
		c->color[2] = 0.3;
		c->scale = 150;
		c->die = cl.time + 0.1;
		c->alpha = 0.66;
		c->fade = 0;
		c->growth = -2000 + (rand() % 500) - 250;
	}
	else if (type == C_LIGHTNING) {
		VectorCopy(bubblecolor[lt_blue], c->color);
		c->scale = 80;
		c->die = cl.time + 0.01;
		c->alpha = 0.33;
		c->fade = 0;
		c->growth = 0;
	}
	else if (type == C_SMALLLIGHTNING) {
		VectorCopy(bubblecolor[lt_blue], c->color);
		c->scale = 40;
		c->die = cl.time + 0.01;
		c->alpha = 0.33;
		c->fade = 0;
		c->growth = 0;
	}
	else if (type == C_ROCKETLIGHT) {
		dlightColorEx(r_rocketlightcolor.value, r_rocketlightcolor.string, lt_rocket, false, &cst_lt);
		c->alpha = 1;
		if (cst_lt.type == lt_custom) {
			VectorCopy(cst_lt.color, c->color);
			VectorScale(c->color, (1.0 / 255), c->color); // cast byte to float
			c->alpha = cst_lt.alpha * (1.0 / 255);
		}
		else {
			VectorCopy(bubblecolor[cst_lt.type], c->color);
		}
		c->scale = 60;
		c->die = cl.time + 0.01;
		c->fade = 0;
		c->growth = 0;
	}
	else if (type == C_GREENLIGHT) {
		c->color[0] = 0;
		c->color[1] = 1;
		c->color[2] = 0;
		c->scale = 20;
		c->die = cl.time + 0.01;
		c->alpha = 0.5;
		c->fade = 0;
		c->growth = 0;
	}
	else if (type == C_REDLIGHT) {
		c->color[0] = 1;
		c->color[1] = 0;
		c->color[2] = 0;
		c->scale = 20;
		c->die = cl.time + 0.01;
		c->alpha = 0.5;
		c->fade = 0;
		c->growth = 0;
	}
	else if (type == C_BLUESPARK) {
		VectorCopy(bubblecolor[lt_blue], c->color);
		c->scale = 30;
		c->die = cl.time + 0.75;
		c->alpha = 0.5;
		c->fade = -1;
		c->growth = -60;
	}
	else if (type == C_GUNFLASH) {
		vec3_t normal, impact, vec;
		c->color[0] = c->color[1] = c->color[2] = 1;
		c->texture = CORONATEX_GUNFLASH;
		c->scale = 50;
		c->die = cl.time + 0.1;
		c->alpha = 0.66;
		c->fade = 0;
		c->growth = -500;
		//A lot of the time the message is being sent just inside of a wall or something
		//I want to move it out of the wall so we can see it
		//Mainly for the hwguy
		//Sigh, if only they knew "omg see gunshots thru wall hax"
		CL_TraceLine(r_refdef.vieworg, origin, impact, normal);
		if (!VectorCompare(origin, impact)) {
			VectorSubtract(r_refdef.vieworg, origin, vec);
			VectorNormalize(vec);
			VectorMA(origin, 2, vec, c->origin);
		}
	}
	else if (type == C_EXPLODE) {
		c->color[0] = c->color[1] = c->color[2] = 1;
		c->scale = 200;
		c->die = cl.time + 0.03;
		c->alpha = 1;
		c->growth = 0;
		c->fade = 0;
		c->texture = CORONATEX_EXPLOSIONFLASH1;
	}
	else if (type == C_WHITELIGHT) {
		c->color[0] = 1;
		c->color[1] = 1;
		c->color[2] = 1;
		c->scale = 40;
		c->die = cl.time + 1;
		c->alpha = 0.5;
		c->fade = -1;
		c->growth = -200;
	}
	else if (type == C_WIZLIGHT) {
		c->color[0] = 0;
		c->color[1] = 0.5;
		c->color[2] = 0;
		c->scale = 60;
		c->die = cl.time + 0.01;
		c->alpha = 1;
		c->fade = 0;
		c->growth = 0;
	}
	else if (type == C_KNIGHTLIGHT) {
		c->color[0] = 1;
		c->color[1] = 0.3;
		c->color[2] = 0;
		c->scale = 60;
		c->die = cl.time + 0.01;
		c->alpha = 1;
		c->fade = 0;
		c->growth = 0;
	}
	else if (type == C_VORELIGHT) {
		c->color[0] = 0.3;
		c->color[1] = 0;
		c->color[2] = 1;
		c->scale = 60;
		c->die = cl.time + 0.01;
		c->alpha = 1;
		c->fade = 0;
		c->growth = 0;
	}
}

void R_CoronasNew(coronatype_t type, vec3_t origin)
{
	R_CoronasNewImpl(type, origin, 0);
}

void R_CoronasEntityNew(coronatype_t type, centity_t* cent)
{
	R_CoronasNewImpl(type, cent->lerp_origin, (cent - cl_entities) + 1);
}

void InitCoronas(void)
{
	corona_t *c;
	int i;

	//VULT STATS
	CoronaCount = 0;
	CoronaCountHigh = 0;
	for (i = 0; i < MAX_CORONAS; i++) {
		c = &r_corona[i];
		c->type = C_FREE;
		c->los = false;
		c->sighted = false;
	}
}

//NewStaticLightCorona
//Throws down a permanent light at origin, and wont put another on top of it
//This needs fixing so it wont be called so often
void NewStaticLightCorona(coronatype_t type, vec3_t origin, int entity_id)
{
	corona_t* c;
	corona_t* e = NULL;
	int	      i;
	qbool     breakage = true;

	if (entity_id) {
		int corona_id = cl_static_entities[entity_id - 1].corona_id;

		if (corona_id >= 0 && corona_id < MAX_CORONAS) {
			if (r_corona[corona_id].static_entity_id == entity_id) {
				e = &r_corona[corona_id];
			}
		}
	}

	if (!e) {
		c = r_corona;
		for (i = 0; i < MAX_CORONAS; i++, c++) {
			if (!e && c->type == C_FREE) {
				e = c;
				breakage = false;
			}
			else if (entity_id && entity_id == c->static_entity_id) {
				return;
			}

			if (c->type == C_FIRE && VectorCompare(c->origin, origin)) {
				return;
			}
		}
		if (breakage) {
			//no free coronas
			return;
		}
	}

	memset(e, 0, sizeof(*e));

	e->sighted = false;
	VectorCopy(origin, e->origin);
	e->type = type;
	e->los = false;
	e->texture = CORONATEX_STANDARD;
	e->static_entity_id = entity_id;
	if (entity_id) {
		cl_static_entities[entity_id - 1].corona_id = e - r_corona;
	}

	if (type == C_FIRE) {
		e->color[0] = 0.5;
		e->color[1] = 0.2;
		e->color[2] = 0.05;
		//e->scale = 0.1;
		e->scale = 150 + rand() % 15;
		e->die = cl.time + 800;
		e->alpha = 0.2f;
		e->fade = 0.5;
		e->growth = 800;
	}
}

static void CoronaStats(int change)
{
	if (CoronaCount > CoronaCountHigh) {
		CoronaCountHigh = CoronaCount;
	}
	CoronaCount += change;
}

void VX_FlagTexturesForArray(texture_flag_t* texture_flags)
{
	corona_texture_id tex;

	for (tex = CORONATEX_STANDARD; tex < CORONATEX_COUNT; ++tex) {
		if (R_TextureReferenceIsValid(corona_textures[tex].texnum)) {
			texture_flags[corona_textures[tex].texnum.index].flags |= (1 << TEXTURETYPES_SPRITES);
		}
	}
}

void VX_ImportTextureArrayReferences(texture_flag_t* texture_flags)
{
	corona_texture_id tex;

	for (tex = CORONATEX_STANDARD; tex < CORONATEX_COUNT; ++tex) {
		if (R_TextureReferenceIsValid(corona_textures[tex].texnum)) {
			texture_array_ref_t* array_ref = &texture_flags[corona_textures[tex].texnum.index].array_ref[TEXTURETYPES_SPRITES];

			corona_textures[tex].array_tex = array_ref->ref;
			corona_textures[tex].array_index = array_ref->index;
			corona_textures[tex].array_scale_s = array_ref->scale_s;
			corona_textures[tex].array_scale_t = array_ref->scale_t;
		}
	}
}


================================================
FILE: src/vx_stuff.c
================================================
/*
Copyright (C) 2011 VULTUREIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "quakedef.h"
#include "gl_model.h"
#include "hud.h"
#include "hud_common.h"
#include "vx_stuff.h"
#include "sbar.h"
#include "fonts.h"
#include "r_texture.h"
#include "qmb_particles.h"

corona_texture_t corona_textures[CORONATEX_COUNT];

cvar_t		tei_lavafire = { "gl_surface_lava", "0" };
cvar_t		tei_slime = { "gl_surface_slime", "0" };

cvar_t		amf_coronas = { "gl_coronas", "0" }; // 1
cvar_t		amf_coronas_tele = { "gl_coronas_tele", "0" };
cvar_t		amf_weather_rain = { "gl_weather_rain", "0" };
cvar_t		amf_weather_rain_fast = { "gl_weather_rain_fast", "0" };
cvar_t		amf_extratrails = { "gl_extratrails", "0" }; // 1
cvar_t		amf_detpacklights = { "gl_detpacklights", "0" }; // 1
cvar_t		amf_buildingsparks = { "gl_buildingsparks", "0" }; // 1
cvar_t		amf_cutf_tesla_effect = { "gl_cutf_tesla_effect", "0" }; // 1
cvar_t		amf_underwater_trails = { "gl_turb_trails", "0" }; // 1
cvar_t      amf_underwater_fire = { "gl_turb_fire", "1" };
cvar_t      amf_underwater_effects = { "gl_turb_effects", "1" };

cvar_t		amf_hidenails = { "cl_hidenails", "0" };
cvar_t		amf_hiderockets = { "cl_hiderockets", "0" };

cvar_t		amf_stat_loss = { "r_damagestats", "0" };
cvar_t		amf_lightning = { "gl_lightning", "0" }; // 1

cvar_t		amf_lightning_size = { "gl_lightning_size", "3" };
cvar_t		amf_lightning_sparks = { "gl_lightning_sparks", "0" }; // 0.4
cvar_t		amf_lightning_sparks_size = { "gl_lightning_sparks_size", "300", CVAR_RULESET_MAX | CVAR_RULESET_MIN, NULL, 300, 300, 1 };
cvar_t		amf_lightning_color = { "gl_lightning_color", "120 140 255", CVAR_COLOR };
cvar_t		amf_lighting_vertex = { "gl_lighting_vertex", "0" }; // 1
cvar_t		amf_lighting_colour = { "gl_lighting_color", "0" }; // 1

cvar_t		amf_inferno_trail = { "gl_inferno_trail", "2" };
cvar_t		amf_inferno_speed = { "gl_inferno_speed", "1000" };

cvar_t		cl_camera_tpp = { "cl_camera_tpp", "0" };
cvar_t		amf_camera_chase_dist = { "cl_camera_tpp_distance", "-56" };
cvar_t		amf_camera_chase_height = { "cl_camera_tpp_height", "24" };
cvar_t		amf_camera_death = { "cl_camera_death", "0" }; // 1
cvar_t		amf_nailtrail_water = { "gl_nailtrail_turb", "0" };
cvar_t		amf_nailtrail_plasma = { "gl_nailtrail_plasma", "0" };
cvar_t		amf_nailtrail = { "gl_nailtrail", "0" }; // 1

cvar_t		amf_part_gunshot = { "gl_particle_gunshots", "0" };
cvar_t		amf_part_gunshot_type = { "gl_particle_gunshots_type", "1" };
cvar_t		amf_part_spikes = { "gl_particle_spikes", "0" }; // 0.1
cvar_t		amf_part_spikes_type = { "gl_particle_spikes_type", "1" };
cvar_t		amf_part_shockwaves = { "gl_particle_shockwaves", "0" }; // 1
cvar_t		amf_part_2dshockwaves = { "gl_particle_shockwaves_flat", "0" };
cvar_t		amf_part_blood = { "gl_particle_blood", "0" }; // 1
cvar_t		amf_part_blood_color = { "gl_particle_blood_color", "1" };
cvar_t		amf_part_blood_type = { "gl_particle_blood_type", "1" };
cvar_t		amf_part_explosion = { "gl_particle_explosions", "0" };
cvar_t		amf_part_blobexplosion = { "gl_particle_blobs", "0" }; // 0.1
cvar_t		amf_part_gibtrails = { "gl_particle_gibtrails", "0" }; // 1
cvar_t		amf_part_muzzleflash = { "gl_particle_muzzleflash", "0" };
cvar_t		amf_part_deatheffect = { "gl_particle_deatheffect", "0" }; // 1
cvar_t		amf_part_teleport = { "gl_particle_telesplash", "0" };
cvar_t		amf_part_fire = { "gl_particle_fire", "0" }; // 1
cvar_t		amf_part_firecolor = { "gl_particle_firecolor", "" }; // 1
cvar_t		amf_part_sparks = { "gl_particle_sparks", "0" }; // 1
cvar_t		amf_part_traillen = { "gl_particle_trail_length", "1" };
cvar_t		amf_part_trailtime = { "gl_particle_trail_time",   "1" };
cvar_t		amf_part_trailwidth = { "gl_particle_trail_width",  "3" };
cvar_t		amf_part_traildetail = { "gl_particle_trail_detail", "1" };
cvar_t		amf_part_trailtype = { "gl_particle_trail_type",   "1" };

static int vxdamagepov;
static int vxdamagecount;
static int vxdamagecount_oldhealth;
static int vxdamagecount_time;
static int vxdamagecountarmour;
static int vxdamagecountarmour_oldhealth;
static int vxdamagecountarmour_time;

void Amf_Reset_DamageStats(void)
{
	vxdamagepov = cl.spectator ? Cam_TrackNum() : -1;
	vxdamagecount = 0;
	vxdamagecount_time = 0;
	vxdamagecount_oldhealth = 0;
	vxdamagecountarmour = 0;
	vxdamagecountarmour_time = 0;
	vxdamagecountarmour_oldhealth = 0;
}

char *TP_ConvertToWhiteText(char *s)
{
	static char	buf[4096];
	char	*out, *p;
	buf[0] = 0;
	out = buf;

	for (p = s; *p; p++) {
		*out++ = *p - (*p & 128);
	}
	*out = 0;
	return buf;
}

///////////////////////////////////////
//Model Checking
typedef struct
{
	char *number;
	char *name;
	char *description;
	qbool notify;
} checkmodel_t;

checkmodel_t tp_checkmodels[] =
{
	{"6967", "Eyes Model", "", false},
	{"8986", "Player Model with External Skins", "Possible external fullbright skins.", true},
	{"20572", "Dox TF PAK", ".", false},
	{"37516", "Unknown non-cheating model", "I was told it wasn't a cheat model by Kay", false},
	{"13845", "TF 2.8 Standard", "", false},
	{"33168", "Q1 Standard", "", false},
	{"10560", "Ugly Quake Guy", "", false},
	{"44621", "Women's TF PAK", "", false},
	{"64351", "Razer PAK", "Glowing/Spiked plus other cheats.", true},
	{"17542", "Glow13 and Razer PAK", "Glowing/Spiked plus other cheats.", true},
	{"43672", "Modified/Original Glow", "This model is a cheat.", true},
	{"52774", "Thugguns PAK", "Spiked Player Model.", true},
	{"54273", "YourRom3ro's PAK", "Spiked Player Model.", true},
	{"47919", "DMPAK", "Spiked/Fullbright Player Model and loud water", true},
	{"60647", "Navy Seals PAK", "No Information (Considered cheat by TF Anti-Cheat", true},
	{"36870", "Clan Llama Force", "Fullbright Player Model", true},
	{"58759", "Clan LF / Acid Angel", "Fullbright Player Model plus other cheats", true},
	{"36870", "WBMod", "Hacked/Glowing Models", true},
	{"64524", "Fullbright", "Fullbright Player Model missing the head", true}
};

#define NUMCHECKMODELS (sizeof(tp_checkmodels) / sizeof(tp_checkmodels[0]))

checkmodel_t *TP_GetModels(char *s)
{
	unsigned int i;
	char *f = TP_ConvertToWhiteText(s);
	checkmodel_t *model = tp_checkmodels;

	for (i = 0, model = tp_checkmodels; i < NUMCHECKMODELS; i++, model++) {
		if (strstr(f, model->number)) {
			return model;
		}
	}

	return NULL;
}

////////////////////////////////
/// test stuff
void Draw_AlphaWindow(int x1, int y1, int x2, int y2, int col, float alpha)
{
	int dist;

	dist = x2 - x1;
	Draw_Fill(x1, y1, dist + 1, 1, 2);      //Border - Top
	Draw_Fill(x1, y2, dist, 1, 1);          //Border - Bottom
	dist = y2 - y1;
	Draw_Fill(x1, y1, 1, dist, 2);          //Border - Left
	Draw_Fill(x2, y1, 1, dist + 1, 1);      //Border - Right

	Draw_AlphaFill(x1, y1, x2 - x1, y2 - y1, col, alpha);
}

void Draw_AMFStatLoss(int stat, hud_t* hud)
{
	static int *vxdmgcnt, *vxdmgcnt_t, *vxdmgcnt_o;
	static int x;
	static cvar_t* scale[2] = { NULL, NULL };
	static cvar_t* style[2];
	static cvar_t* digits[2];
	static cvar_t* align[2];
	static cvar_t* duration[2];
	static cvar_t* proportional[2];
	int index = (stat == STAT_HEALTH ? 0 : 1);
	float effect_duration;

	if (cl.spectator && Cam_TrackNum() != vxdamagepov) {
		Amf_Reset_DamageStats();
	}

	if (stat == STAT_HEALTH) {
		vxdmgcnt = &vxdamagecount;
		vxdmgcnt_t = &vxdamagecount_time;
		vxdmgcnt_o = &vxdamagecount_oldhealth;
		x = 136;
	}
	else {
		vxdmgcnt = &vxdamagecountarmour;
		vxdmgcnt_t = &vxdamagecountarmour_time;
		vxdmgcnt_o = &vxdamagecountarmour_oldhealth;
		x = 24;
	}

	if (scale[index] == NULL && hud) {
		// first time called
		scale[index] = HUD_FindVar(hud, "scale");
		style[index] = HUD_FindVar(hud, "style");
		digits[index] = HUD_FindVar(hud, "digits");
		align[index] = HUD_FindVar(hud, "align");
		duration[index] = HUD_FindVar(hud, "duration");
		proportional[index] = HUD_FindVar(hud, "proportional");
	}
	effect_duration = hud && duration[index] ? duration[index]->value : amf_stat_loss.value;

	//VULT STAT LOSS
	//Pretty self explanitory, I just thought it would be a nice feature to go with my "what the hell is going on?" theme
	//and obscure even more of the screen
	if (cl.stats[stat] < (*vxdmgcnt_o - 1)) {
		if (*vxdmgcnt_t > cl.time) {
			//add to damage
			*vxdmgcnt = *vxdmgcnt + (*vxdmgcnt_o - cl.stats[stat]);
		}
		else {
			*vxdmgcnt = *vxdmgcnt_o - cl.stats[stat];
		}
		*vxdmgcnt_t = cl.time + 2 * effect_duration;
	}
	*vxdmgcnt_o = cl.stats[stat];

	if (*vxdmgcnt_t > cl.time) {
		float alpha = min(1, (*vxdmgcnt_t - cl.time));
		float old_alpha = Draw_MultiplyOverallAlpha(alpha);
		if (hud) {
			SCR_HUD_DrawNum(hud, abs(*vxdmgcnt), 1, scale[index]->value, style[index]->value, digits[index]->integer, align[index]->string, proportional[index]->integer);
		}
		else {
			Sbar_DrawNum(x, -24, abs(*vxdmgcnt), 3, (*vxdmgcnt) > 0);
		}
		Draw_SetOverallAlpha(old_alpha);
	}
}

void InitVXStuff(void)
{
	int flags = TEX_COMPLAIN | TEX_MIPMAP | TEX_ALPHA | TEX_NOSCALE;
	int i;

	if (!qmb_initialized) {
		// FIXME: hm, in case of vid_restart, what we must do if before vid_restart qmb_initialized was true?
		return;
	}

	for (i = 0; i < CORONATEX_COUNT; ++i) {
		corona_textures[i].array_scale_s = 1;
		corona_textures[i].array_scale_t = 1;
		corona_textures[i].array_index = 0;
		R_TextureReferenceInvalidate(corona_textures[i].array_tex);
		R_TextureReferenceInvalidate(corona_textures[i].texnum);
	}

	corona_textures[CORONATEX_STANDARD].texnum = R_LoadTextureImage("textures/flash", NULL, 0, 0, flags);
	corona_textures[CORONATEX_GUNFLASH].texnum = R_LoadTextureImage("textures/gunflash", NULL, 0, 0, flags);
	corona_textures[CORONATEX_EXPLOSIONFLASH1].texnum = R_LoadTextureImage("textures/explosionflash1", NULL, 0, 0, flags);
	corona_textures[CORONATEX_EXPLOSIONFLASH2].texnum = R_LoadTextureImage("textures/explosionflash2", NULL, 0, 0, flags);
	corona_textures[CORONATEX_EXPLOSIONFLASH3].texnum = R_LoadTextureImage("textures/explosionflash3", NULL, 0, 0, flags);
	corona_textures[CORONATEX_EXPLOSIONFLASH4].texnum = R_LoadTextureImage("textures/explosionflash4", NULL, 0, 0, flags);
	corona_textures[CORONATEX_EXPLOSIONFLASH5].texnum = R_LoadTextureImage("textures/explosionflash5", NULL, 0, 0, flags);
	corona_textures[CORONATEX_EXPLOSIONFLASH6].texnum = R_LoadTextureImage("textures/explosionflash6", NULL, 0, 0, flags);
	corona_textures[CORONATEX_EXPLOSIONFLASH7].texnum = R_LoadTextureImage("textures/explosionflash7", NULL, 0, 0, flags);

	InitCoronas(); // safe re-init

	Init_VLights(); // safe re-init imo

	Cvar_SetCurrentGroup(CVAR_GROUP_SBAR);
	Cvar_Register(&amf_stat_loss);
	Cvar_ResetCurrentGroup();

	Cvar_SetCurrentGroup(CVAR_GROUP_SPECTATOR);
	Cvar_Register(&cl_camera_tpp);
	Cvar_Register(&amf_camera_chase_dist);
	Cvar_Register(&amf_camera_chase_height);
	Cvar_Register(&amf_camera_death);
	Cvar_ResetCurrentGroup();

	Cvar_SetCurrentGroup(CVAR_GROUP_EYECANDY);
	Cvar_Register(&amf_hiderockets);
	Cvar_Register(&amf_hidenails);
	Cvar_ResetCurrentGroup();

	Cvar_SetCurrentGroup(CVAR_GROUP_LIGHTING);
	Cvar_Register(&amf_coronas);
	Cvar_Register(&amf_coronas_tele);
	Cvar_Register(&amf_lighting_vertex);
	Cvar_Register(&amf_lighting_colour);
	Cvar_ResetCurrentGroup();

	Cvar_SetCurrentGroup(CVAR_GROUP_PARTICLES);
	Cvar_Register(&amf_part_blood);
	Cvar_Register(&amf_part_blood_color);
	Cvar_Register(&amf_part_blood_type);
	Cvar_Register(&amf_part_muzzleflash);
	Cvar_Register(&amf_part_fire);
	Cvar_Register(&amf_part_firecolor);
	Cvar_Register(&amf_part_deatheffect);
	Cvar_Register(&amf_part_gunshot);
	Cvar_Register(&amf_part_gunshot_type);
	Cvar_Register(&amf_part_spikes);
	Cvar_Register(&amf_part_spikes_type);
	Cvar_Register(&amf_part_explosion);
	Cvar_Register(&amf_part_blobexplosion);
	Cvar_Register(&amf_part_teleport);
	Cvar_Register(&amf_part_sparks);
	Cvar_Register(&amf_part_2dshockwaves);
	Cvar_Register(&amf_part_shockwaves);
	Cvar_Register(&amf_part_gibtrails);
	Cvar_Register(&amf_part_traillen);
	Cvar_Register(&amf_part_trailtime);
	Cvar_Register(&amf_part_traildetail);
	Cvar_Register(&amf_part_trailwidth);
	Cvar_Register(&amf_part_trailtype);
	Cvar_ResetCurrentGroup();

	Cvar_SetCurrentGroup(CVAR_GROUP_TURB);
	Cvar_Register(&tei_lavafire);
	Cvar_Register(&tei_slime);
	Cvar_Register(&amf_weather_rain);
	Cvar_Register(&amf_weather_rain_fast);
	Cvar_Register(&amf_underwater_trails);
	Cvar_Register(&amf_underwater_fire);
	Cvar_Register(&amf_underwater_effects);
	Cvar_ResetCurrentGroup();

	Cvar_SetCurrentGroup(CVAR_GROUP_OPENGL);
	Cvar_Register(&amf_nailtrail);
	Cvar_Register(&amf_nailtrail_plasma);
	Cvar_Register(&amf_nailtrail_water);
	Cvar_Register(&amf_extratrails);
	Cvar_Register(&amf_detpacklights);
	Cvar_Register(&amf_buildingsparks);
	Cvar_Register(&amf_lightning);
	Cvar_Register(&amf_lightning_color);
	Cvar_Register(&amf_lightning_size);
	Cvar_Register(&amf_lightning_sparks);
	Cvar_Register(&amf_lightning_sparks_size);
	Cvar_Register(&amf_inferno_trail);
	Cvar_Register(&amf_inferno_speed);
	Cvar_Register(&amf_cutf_tesla_effect);
	Cvar_ResetCurrentGroup();
}




================================================
FILE: src/vx_stuff.h
================================================
/*
Copyright (C) 2011 VultureIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
// VultureIIC
#ifndef __VX_STUFF__H__
#define __VX_STUFF__H__

#include "hud.h"

// For coronas
typedef enum
{
	C_FLASH,			// Explosion type - Basically just fades out
	C_SMALLFLASH,		// Muzzleflash
	C_BLUEFLASH,		// Blob expl
	C_FREE,				// Unused
	C_LIGHTNING,		// Used on lightning beams
	C_SMALLLIGHTNING,	// Used on lightning beams
	C_FIRE,				// Used in torches
	C_ROCKETLIGHT,		// A rockets glow...
	C_GREENLIGHT,		// Detpack
	C_REDLIGHT,			// Detpack about to blow
	C_BLUESPARK,		// Gibbed building spark
	C_GUNFLASH,			// Shotgun hit effect
	C_EXPLODE,			// Animated explosion
	C_WHITELIGHT,		// Gunshot #2 effect
	C_WIZLIGHT,			// CREATURE TRACER LIGHTS
	C_KNIGHTLIGHT,
	C_VORELIGHT,
} coronatype_t;

void R_CoronasNew(coronatype_t type, vec3_t origin);
void R_CoronasEntityNew(coronatype_t type, centity_t* cent);
void R_DrawCoronas(void);
void InitCoronas(void);
void InitVXStuff(void);
void NewStaticLightCorona(coronatype_t type, vec3_t origin, int entity_id);

typedef enum {
	CORONATEX_STANDARD,
	CORONATEX_GUNFLASH,
	CORONATEX_EXPLOSIONFLASH1,
	CORONATEX_EXPLOSIONFLASH2,
	CORONATEX_EXPLOSIONFLASH3,
	CORONATEX_EXPLOSIONFLASH4,
	CORONATEX_EXPLOSIONFLASH5,
	CORONATEX_EXPLOSIONFLASH6,
	CORONATEX_EXPLOSIONFLASH7,

	CORONATEX_COUNT
} corona_texture_id;

typedef struct corona_texture_s {
	texture_ref texnum;

	texture_ref array_tex;
	int         array_index;
	float       array_scale_s;
	float       array_scale_t;
} corona_texture_t;

extern corona_texture_t corona_textures[CORONATEX_COUNT];


float CL_TraceLine(vec3_t start, vec3_t end, vec3_t impact, vec3_t normal);
void WeatherEffect(void);
void SparkGen(vec3_t org, byte col[3], float count, float size, float life);
extern cvar_t tei_lavafire;
extern cvar_t tei_slime;

extern cvar_t amf_coronas;
extern cvar_t amf_coronas_tele;
extern cvar_t amf_weather_rain;
extern cvar_t amf_weather_rain_fast;
extern cvar_t amf_nailtrail;
extern cvar_t amf_hidenails;
extern cvar_t amf_extratrails;
extern cvar_t amf_detpacklights;
extern cvar_t amf_buildingsparks;
extern cvar_t amf_lightning;
extern cvar_t amf_lightning_color;
extern cvar_t amf_lightning_size;
extern cvar_t amf_lightning_sparks;
extern cvar_t amf_lightning_sparks_size;
extern cvar_t cl_camera_tpp;
extern cvar_t amf_camera_chase_dist;
extern cvar_t amf_camera_chase_height;
extern cvar_t amf_camera_death;
extern cvar_t amf_stat_loss;
extern cvar_t amf_part_gunshot;
extern cvar_t amf_part_spikes;
extern cvar_t amf_part_explosion;
extern cvar_t amf_part_blobexplosion;
extern cvar_t amf_part_teleport;
extern cvar_t amf_part_blood;
extern cvar_t amf_part_traillen;
extern cvar_t amf_underwater_trails;
extern cvar_t amf_part_sparks;
extern cvar_t amf_hiderockets;
extern cvar_t amf_nailtrail_plasma;
extern cvar_t amf_part_muzzleflash;
extern cvar_t amf_inferno_trail;
extern cvar_t amf_inferno_speed;
extern cvar_t amf_part_2dshockwaves;
extern cvar_t amf_part_shockwaves;
extern cvar_t amf_part_trailtime;
extern cvar_t amf_part_gunshot_type;
extern cvar_t amf_part_spikes_type;
extern cvar_t amf_part_blood_color;
extern cvar_t amf_part_blood_type;
extern cvar_t amf_part_gibtrails;
extern cvar_t amf_lighting_vertex;
extern cvar_t amf_lighting_colour;
extern cvar_t amf_part_fire;
extern cvar_t amf_part_firecolor;
extern cvar_t amf_tracker_frags;
extern cvar_t amf_tracker_flags;
extern cvar_t amf_tracker_streaks;
extern cvar_t amf_cutf_tesla_effect;
extern cvar_t amf_nailtrail_water;
extern cvar_t amf_part_deatheffect;
extern cvar_t amf_part_traildetail;
extern cvar_t amf_part_trailwidth;
extern cvar_t amf_part_trailtype;

extern int ParticleCount, ParticleCountHigh, CoronaCount, CoronaCountHigh;

void ParticleAlphaTrail(centity_t* cent, float size, float life);
void ParticleNailTrail(centity_t* client_ent, float size, float life);

typedef enum
{
	C_NORMAL, //Normal camera
	C_CHASECAM, //Chase cam is on
	C_EXTERNAL, //Looking at the player for whatever reason
} cameramode_t;

extern cameramode_t cameratype;
void CameraUpdate(qbool dead);
void VXGunshot(vec3_t org, float count);
void VXTeleport(vec3_t org);
void VXBlobExplosion(vec3_t org);
void VXExplosion(vec3_t org);
void VXBlood(vec3_t org, float count);
void FuelRodGunTrail(centity_t* cent);
void FireballTrail(centity_t* cent, byte col[3], float size, float life);
void FireballTrailWave(centity_t* cent, byte col[3], float size, float life, vec3_t angle);

void DrawMuzzleflash(vec3_t start, vec3_t angle, vec3_t vel);
void VXNailhit(vec3_t org, float count);
void FuelRodExplosion(vec3_t org);
void Init_VLights(void);
void ParticleFire(vec3_t org);
void ParticleTorchFire(entity_t* ent);
void VX_TeslaCharge(vec3_t org);

void VX_LightningBeam(vec3_t start, vec3_t end);
void VX_DeathEffect(vec3_t org);
void VX_GibEffect(vec3_t org);
void VX_DetpackExplosion(vec3_t org);
void VX_LightningTrail(vec3_t start, vec3_t end);

void Amf_Reset_DamageStats(void);
void Draw_AMFStatLoss(int stat, hud_t* hud);

int VX_OwnFragTextLen(float scale, qbool proportional);
double VX_OwnFragTime(void);
const char * VX_OwnFragText(void);
qbool VX_TrackerIsEnemy(int player);

#endif // __VX_STUFF__H__


================================================
FILE: src/vx_tracker.c
================================================
/*
Copyright (C) 2011 VULTUREIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
	\file

	\brief
	Frags Tracker Screen Element

	\author
	VULTUREIIC
**/

#include "quakedef.h"
#include "utils.h"
#include "vx_tracker.h"
#include "gl_model.h"
#include "fonts.h"
#include "hud.h"
#include "r_texture.h"

#define MAX_IMAGENAME 32

// This can't be increased without changing private use image reservations (PRIVATE_USE_IMAGES_TRACKERIMAGES_BASE etc)
#define MAX_IMAGES_PER_WEAPON 4
#define TEXTFLAG_WEAPON 1

typedef struct weapon_label_s {
	char label[64];
	int starts[4];
	byte colors[4][4];
	int count;
} weapon_label_t;

static int weapon_images[MAX_WEAPON_CLASSES];
static weapon_label_t weapon_labels[MAX_WEAPON_CLASSES];

// hard-coded values, remember tracker color codes were 0-9, not 0-F
static const byte color_white[4] = { 255, 255, 255, 255 };
static const byte color960[4] = { 255, 170, 0, 255 };      // 'you died', suicides etc
static const byte color940[4] = { 255, 113, 0, 255 };      // streaks
static const byte color900[4] = { 255,   0, 0, 255 };      // <x> killed you
static const byte color380[4] = {  77, 227, 0, 255 };      // teamkills

//static void VX_TrackerAddText(char *msg, tracktype_t tt);

static void VX_TrackerAddSegmented4(const char* lhs_text, const byte* lhs_color, const char* center_text, const byte* center_color, const char* rhs_text, const byte* rhs_color, const char* extra_text, const byte* extra_color);
#define VX_TrackerAddSegmented(lhs_text, lhs_color, center_text, center_color, rhs_text, rhs_color) VX_TrackerAddSegmented4(lhs_text, lhs_color, center_text, center_color, rhs_text, rhs_color, "", NULL)
static void VX_TrackerAddWeaponImageSplit(const char* lhs_text, const byte* lhs_color, int weapon, const char* rhs_text, const byte* rhs_color);
static void VX_TrackerAddWeaponTextSplit(char* lhs_text, int weapon, const byte* color, char* rhs_text);

//STREAKS
typedef struct {
	int frags;
	char *spreestring;
	char *name; //internal name
	char *wavfilename;
} killing_streak_t;

killing_streak_t tp_streak[] = {
	{ 100, "teh chet",           "0wnhack",     "client/streakx6.wav" },
	{ 50,  "the master now",     "master",      "client/streakx5.wav" },
	{ 20,  "godlike",            "godlike",     "client/streakx4.wav" },
	{ 15,  "unstoppable",        "unstoppable", "client/streakx3.wav" },
	{ 10,  "on a rampage",       "rampage",     "client/streakx2.wav" },
	{ 5,   "on a killing spree", "spree",       "client/streakx1.wav" },
};

#define NUMSTREAK (sizeof(tp_streak) / sizeof(tp_streak[0]))

extern cvar_t		cl_useimagesinfraglog;

static int active_track = 0;
static int max_active_tracks = 0;

static void VXSCR_DrawTrackerString(float x_pos, float y_pos, float width, int name_width, qbool proportional, float scale, float image_scale, qbool align_right);
static void OnChange_TrackerNameWidth(cvar_t* var, char* value, qbool* cancel);

cvar_t r_tracker                                   = {"r_tracker", "1"};
cvar_t amf_tracker_flags                           = {"r_tracker_flags", "0"};
cvar_t amf_tracker_frags                           = {"r_tracker_frags", "1"};
cvar_t amf_tracker_streaks                         = {"r_tracker_streaks", "0"};
cvar_t amf_tracker_time                            = {"r_tracker_time", "4"};
cvar_t amf_tracker_messages                        = {"r_tracker_messages", "20"};
static cvar_t amf_tracker_colorfix				         = {"r_tracker_colorfix", "0"};
static cvar_t amf_tracker_pickups                  = {"r_tracker_pickups", "0"};
cvar_t amf_tracker_align_right                     = {"r_tracker_align_right", "1"};
cvar_t amf_tracker_scale                           = {"r_tracker_scale", "1"};
static cvar_t amf_tracker_inconsole                = {"r_tracker_inconsole", "0"};
static cvar_t amf_tracker_inconsole_colored_weapon = {"r_tracker_inconsole_colored_weapon", "0"};
static cvar_t amf_tracker_x                        = {"r_tracker_x", "0"};
static cvar_t amf_tracker_y                        = {"r_tracker_y", "0"};
static cvar_t amf_tracker_frame_color              = {"r_tracker_frame_color", "0 0 0 0", CVAR_COLOR};
static cvar_t amf_tracker_images_scale             = {"r_tracker_images_scale", "1"};
static cvar_t amf_tracker_color_good               = {"r_tracker_color_good",     "090", CVAR_TRACKERCOLOR }; // good news
static cvar_t amf_tracker_color_bad                = {"r_tracker_color_bad",      "900", CVAR_TRACKERCOLOR }; // bad news
static cvar_t amf_tracker_color_tkgood             = {"r_tracker_color_tkgood",   "990", CVAR_TRACKERCOLOR }; // team kill, not on ur team
static cvar_t amf_tracker_color_tkbad              = {"r_tracker_color_tkbad",    "009", CVAR_TRACKERCOLOR }; // team kill, on ur team
static cvar_t amf_tracker_color_myfrag             = {"r_tracker_color_myfrag",   "090", CVAR_TRACKERCOLOR }; // use this color for frag which u done
static cvar_t amf_tracker_color_fragonme           = {"r_tracker_color_fragonme", "900", CVAR_TRACKERCOLOR }; // use this color when u frag someone
static cvar_t amf_tracker_color_suicide            = {"r_tracker_color_suicide",  "900", CVAR_TRACKERCOLOR }; // use this color when u suicides
static cvar_t amf_tracker_string_suicides          = {"r_tracker_string_suicides", " (suicides)"};
static cvar_t amf_tracker_string_died              = {"r_tracker_string_died",     " (died)"};
static cvar_t amf_tracker_string_teammate          = {"r_tracker_string_teammate", "teammate"};
static cvar_t amf_tracker_string_enemy             = {"r_tracker_string_enemy",    "enemy"};
static cvar_t amf_tracker_string_inconsole_prefix  = {"r_tracker_string_inconsole_prefix", ""};
static cvar_t amf_tracker_name_width               = {"r_tracker_name_width",      "0", 0, OnChange_TrackerNameWidth};
static cvar_t amf_tracker_own_frag_prefix          = {"r_tracker_own_frag_prefix", "You fragged "};
static cvar_t amf_tracker_positive_enemy_suicide   = {"r_tracker_positive_enemy_suicide", "0"};	// Medar wanted it to be customizable
static cvar_t amf_tracker_positive_enemy_vs_enemy  = {"r_tracker_positive_enemy_vs_enemy", "0"};
static cvar_t amf_tracker_proportional             = {"r_tracker_proportional", "0"};
static cvar_t amf_tracker_weapon_first             = {"r_tracker_weapon_first", "0"};
static cvar_t amf_tracker_row_spacing              = {"r_tracker_row_spacing", "0"};

#define MAX_TRACKERMESSAGES 30
#define MAX_TRACKER_MSG_LEN 500
#define MAX_IMAGES_PER_LINE 2
#define MAX_SEGMENTS_PER_LINE 6

typedef struct 
{
	float die;

	// If set, delete subsequent message at same time as this one
	qbool linked;

	// Pre-parse now, don't do this every frame
	char text[MAX_SEGMENTS_PER_LINE][64];
	int text_flags[MAX_SEGMENTS_PER_LINE];
	byte colors[MAX_SEGMENTS_PER_LINE][4];
	mpic_t* images[MAX_SEGMENTS_PER_LINE];
	text_alignment_t alignment[MAX_SEGMENTS_PER_LINE];
	int segments;

	// Kept this as it's used for positioning...
	int printable_characters;
	int image_characters;
	qbool pad;
} trackmsg_t;

static trackmsg_t trackermsg[MAX_TRACKERMESSAGES];

static void VX_PreProcessMessage(trackmsg_t* msg);

static qbool VX_FilterDeaths(void)
{
	extern cvar_t amf_tracker_frags;

	return !amf_tracker_frags.integer;
}

static qbool VX_FilterStreaks(void)
{
	return !amf_tracker_streaks.integer;
}

static qbool VX_FilterFlags(void)
{
	return !amf_tracker_flags.integer;
}

static qbool VX_FilterPickups(void)
{
	return !amf_tracker_pickups.integer;
}

static struct {
	double time;
	char text[MAX_SCOREBOARDNAME+20];
} ownfragtext;

void InitTracker(void)
{
	Cvar_SetCurrentGroup(CVAR_GROUP_SCREEN);

	Cvar_Register(&r_tracker);
	Cvar_Register(&amf_tracker_frags);
	Cvar_Register(&amf_tracker_flags);
	Cvar_Register(&amf_tracker_streaks);
	Cvar_Register(&amf_tracker_messages);
	Cvar_Register(&amf_tracker_colorfix);
	Cvar_Register(&amf_tracker_inconsole);
	Cvar_Register(&amf_tracker_inconsole_colored_weapon);
	Cvar_Register(&amf_tracker_time);
	Cvar_Register(&amf_tracker_align_right);
	Cvar_Register(&amf_tracker_x);
	Cvar_Register(&amf_tracker_y);
	Cvar_Register(&amf_tracker_frame_color);
	Cvar_Register(&amf_tracker_scale);
	Cvar_Register(&amf_tracker_images_scale);
	Cvar_Register(&amf_tracker_pickups);

	Cvar_Register(&amf_tracker_color_good);
	Cvar_Register(&amf_tracker_color_bad);
	Cvar_Register(&amf_tracker_color_tkgood);
	Cvar_Register(&amf_tracker_color_tkbad);
	Cvar_Register(&amf_tracker_color_myfrag);
	Cvar_Register(&amf_tracker_color_fragonme);
	Cvar_Register(&amf_tracker_color_suicide);

	Cvar_Register(&amf_tracker_string_suicides);
	Cvar_Register(&amf_tracker_string_died);
	Cvar_Register(&amf_tracker_string_teammate);
	Cvar_Register(&amf_tracker_string_enemy);
	Cvar_Register(&amf_tracker_string_inconsole_prefix);

	Cvar_Register(&amf_tracker_name_width);
	Cvar_Register(&amf_tracker_own_frag_prefix);
	Cvar_Register(&amf_tracker_positive_enemy_suicide);
	Cvar_Register(&amf_tracker_positive_enemy_vs_enemy);
	Cvar_Register(&amf_tracker_proportional);
	Cvar_Register(&amf_tracker_weapon_first);
	Cvar_Register(&amf_tracker_row_spacing);
}

void VX_TrackerClear(void)
{
	int i;

	// this block VX_TrackerAddText() untill first VX_TrackerThink()
	//   which mean we connected and may start process it right
	active_track = max_active_tracks = 0;

	memset(trackermsg, 0, sizeof(trackermsg[0]));
	for (i = 0; i < MAX_TRACKERMESSAGES; i++) {
		trackermsg[i].die = -1;
	}
	memset(&ownfragtext, 0, sizeof(ownfragtext));
}

//When a message fades away, this moves all the other messages up a slot
void VX_TrackerThink(void)
{
	int i;

	if (r_tracker.integer) {
		VXSCR_DrawTrackerString(amf_tracker_x.value, vid.height * 0.2 / bound(0.1, amf_tracker_scale.value, 10) + amf_tracker_y.value, vid.width, amf_tracker_name_width.integer, amf_tracker_proportional.integer, amf_tracker_scale.value, amf_tracker_images_scale.value, amf_tracker_align_right.integer);
	}

	if (ISPAUSED) {
		return;
	}

	active_track = 0; // 0 slots active
	max_active_tracks = bound(0, amf_tracker_messages.value, MAX_TRACKERMESSAGES);

	for (i = 0; i < max_active_tracks; i++) {
		if (trackermsg[i].die < r_refdef2.time) {
			// inactive
			continue;
		}

		active_track = i+1; // i+1 slots active

		if (!i) {
			continue;
		}

		if (trackermsg[i - 1].die < r_refdef2.time && trackermsg[i].die >= r_refdef2.time) {
			// free slot above
			memcpy(&trackermsg[i - 1], &trackermsg[i], sizeof(trackermsg[0]));
			memset(&trackermsg[i], 0, sizeof(trackermsg[0]));
			trackermsg[i].die = -1;

			active_track = i; // i slots active
			continue;
		}
	}
}

static qbool VX_TrackerStringPrint(const char* text)
{
	switch (amf_tracker_inconsole.integer) {
		case 1:
			Com_Printf("%s\n", text);
			return false;
		case 2:
			Com_Printf("%s\n", text);
			return true;
		case 3:
		{
			int flags = Print_flags[Print_current];
			Print_flags[Print_current] |= PR_NONOTIFY;
			Com_Printf("%s\n", text);
			Print_flags[Print_current] = flags;
			return true;
		}
	}

	return true;
}

static qbool VX_TrackerStringPrintSegments(const char* text1, const char* text2, const char* text3, const char* text4)
{
	int i;

	if (!amf_tracker_inconsole.integer) {
		return true;
	}

	for (i = 0; i < 4; ++i) {
		if (text1 == NULL || !text1[0]) {
			text1 = text2;
			text2 = text3;
			text3 = text4;
			text4 = NULL;
		}
	}

	switch (amf_tracker_inconsole.integer) {
		case 1:
			Com_Printf("%s%s%s%s%s%s%s%s\n", amf_tracker_string_inconsole_prefix.string, text1 ? text1 : "", text1 && text2 ? " " : "", text2 ? text2 : "", text2 && text3 ? " " : "", text3 ? text3 : "", text3 && text4 ? " " : "", text4 ? text4 : "");
			return false;
		case 2:
			Com_Printf("%s%s%s%s%s%s%s%s\n", amf_tracker_string_inconsole_prefix.string, text1 ? text1 : "", text1 && text2 ? " " : "", text2 ? text2 : "", text2 && text3 ? " " : "", text3 ? text3 : "", text3 && text4 ? " " : "", text4 ? text4 : "");
			return true;
		case 3:
		{
			int flags = Print_flags[Print_current];
			Print_flags[Print_current] |= PR_NONOTIFY;
			Com_Printf("%s%s%s%s%s%s%s%s\n", amf_tracker_string_inconsole_prefix.string, text1 ? text1 : "", text1 && text2 ? " " : "", text2 ? text2 : "", text2 && text3 ? " " : "", text3 ? text3 : "", text3 && text4 ? " " : "", text4 ? text4 : "");
			Print_flags[Print_current] = flags;
			return true;
		}
	}

	return true;
}

static qbool VX_TrackerStringPrintSegmentsWithImage(const char* text1, const byte* text1_color, int weapon, const char* text3, const byte* text3_color)
{
	wchar imagetext[MAX_IMAGES_PER_WEAPON + 1] = { 0 };
	int offset = weapon * MAX_IMAGES_PER_WEAPON;
	int base = (PRIVATE_USE_TRACKERIMAGES_CHARSET << 8) + offset;
	int flags = Print_flags[Print_current];
	qbool suppress_from_tracker = amf_tracker_inconsole.integer == 1;
	qbool suppress_from_notify = amf_tracker_inconsole.integer == 3;

	if (!amf_tracker_inconsole.integer) {
		return true;
	}

	if (R_TextureReferenceIsValid(char_textures[PRIVATE_USE_TRACKERIMAGES_CHARSET].glyphs[offset].texnum)) {
		int i;
		for (i = 0; i < weapon_images[weapon]; ++i) {
			imagetext[i] = base + i;
		}
	}
	else {
		return VX_TrackerStringPrintSegments(text1, GetWeaponName(weapon), text3, NULL);
	}

	Print_flags[Print_current] |= (PR_NORESET | (suppress_from_notify ? PR_NONOTIFY : 0));

	Com_Printf("%s", amf_tracker_string_inconsole_prefix.string);

	if (text1 && text1[0]) {
		if (text1_color) {
			Com_Printf("&c%x%x%x%s&r ", text1_color[0] / 16, text1_color[1] / 16, text1_color[2] / 16, text1);
		}
		else {
			Com_Printf("%s ", text1);
		}
	}
	Con_PrintW(imagetext);
	if (text3 && text3[0]) {
		if (text1 && text1[0]) {
			if (text3_color) {
				Com_Printf(" &c%x%x%x%s&r\n", text3_color[0] / 16, text3_color[1] / 16, text3_color[2] / 16, text3);
			}
			else {
				Com_Printf(" %s\n", text3);
			}
		}
		else {
			if (text3_color) {
				Com_Printf(" &c%x%x%x%s&r\n", text3_color[0] / 16, text3_color[1] / 16, text3_color[2] / 16, text3);
			}
			else {
				Com_Printf("%s\n", text3);
			}
		}
	}
	else {
		Com_Printf("\n");
	}

	Print_flags[Print_current] = flags;
	return !suppress_from_tracker;
}

static trackmsg_t* VX_NewTrackerMsg(void)
{
	if (!max_active_tracks) {
		return NULL;
	}

	// free space by removing the oldest one
	if (active_track >= max_active_tracks) {
		int i;
		int remove = 1;

		for (i = 0; i < max_active_tracks; ++i) {
			if (!trackermsg[i].linked) {
				break;
			}
			++remove;
		}

		for (i = remove; i < max_active_tracks; i++) {
			memcpy(&trackermsg[i - remove], &trackermsg[i], sizeof(trackermsg[0]));
		}
		active_track = max_active_tracks - remove;
		memset(&trackermsg[active_track], 0, sizeof(trackermsg[active_track]) * remove);
	}
	else {
		memset(&trackermsg[active_track], 0, sizeof(trackermsg[active_track]));
	}
	trackermsg[active_track].die = r_refdef2.time + max(0, amf_tracker_time.value);
	return &trackermsg[active_track++];
}

static void VX_TrackerAddFlaggedTextSegment(trackmsg_t* msg, const char* text, const byte* color, int flags)
{
	if (text && text[0] && color && msg->segments < sizeof(msg->colors) / sizeof(msg->colors[0])) {
		memcpy(msg->colors[msg->segments], color, sizeof(msg->colors[msg->segments]));
		strlcpy(msg->text[msg->segments], text, sizeof(msg->text[msg->segments]));
		msg->text_flags[msg->segments] = flags;
		++msg->segments;
	}
}

static void VX_TrackerAddTextSegment(trackmsg_t* msg, const char* text, const byte* color)
{
	VX_TrackerAddFlaggedTextSegment(msg, text, color, 0);
}

static void VX_TrackerAddImageSegment(trackmsg_t* msg, mpic_t* pic)
{
	if (pic) {
		msg->text[msg->segments][0] = '\0';
		msg->images[msg->segments] = pic;
		++msg->segments;
	}
}

static void VX_TrackerAddSimpleText(const char* text, const byte* color)
{
	trackmsg_t* msg;

	if (!text || !text[0] || CL_Demo_SkipMessage(true)) {
		return;
	}

	if (!VX_TrackerStringPrint(text)) {
		return;
	}

	msg = VX_NewTrackerMsg();
	if (msg) {
		VX_TrackerAddTextSegment(msg, text, color);
		VX_PreProcessMessage(msg);
	}
}

static void VX_TrackerAddSegmented4(const char* lhs_text, const byte* lhs_color, const char* center_text, const byte* center_color, const char* rhs_text, const byte* rhs_color, const char* extra_text, const byte* extra_color)
{
	trackmsg_t* msg;

	if (!lhs_text || !lhs_text[0] || CL_Demo_SkipMessage(true)) {
		return;
	}

	if (!VX_TrackerStringPrintSegments(lhs_text, center_text, rhs_text, extra_text)) {
		return;
	}

	msg = VX_NewTrackerMsg();
	if (msg) {
		VX_TrackerAddTextSegment(msg, lhs_text, lhs_color);
		VX_TrackerAddTextSegment(msg, center_text, center_color);
		VX_TrackerAddTextSegment(msg, rhs_text, rhs_color);
		VX_TrackerAddTextSegment(msg, extra_text, extra_color);
		VX_PreProcessMessage(msg);
	}
}

static void VX_TrackerAddWeaponImageSplit(const char* lhs_text, const byte* lhs_color, int weapon, const char* rhs_text, const byte* rhs_color)
{
	trackmsg_t* msg;
	int i;

	while (lhs_text && isspace((byte)lhs_text[0] & 127)) {
		++lhs_text;
	}

	while (rhs_text && isspace((byte)rhs_text[0] & 127)) {
		++rhs_text;
	}

	if (((!lhs_text || !lhs_text[0]) && (!rhs_text || !rhs_text[0])) || CL_Demo_SkipMessage(true)) {
		return;
	}

	if (!VX_TrackerStringPrintSegmentsWithImage(lhs_text, lhs_color, weapon, rhs_text, rhs_color)) {
		return;
	}

	msg = VX_NewTrackerMsg();
	if (msg) {
		msg->pad = lhs_text && rhs_text && lhs_text[0] && rhs_text[0];

		if (!amf_tracker_weapon_first.integer)
			VX_TrackerAddTextSegment(msg, lhs_text, lhs_color);

		for (i = 0; i < weapon_images[weapon]; ++i) {
			mpic_t* pic = &char_textures[PRIVATE_USE_TRACKERIMAGES_CHARSET].glyphs[weapon * MAX_IMAGES_PER_WEAPON + i];

			if (R_TextureReferenceIsValid(pic->texnum)) {
				VX_TrackerAddImageSegment(msg, pic);
			}
		}

		if (amf_tracker_weapon_first.integer)
			VX_TrackerAddTextSegment(msg, lhs_text, lhs_color);

		VX_TrackerAddTextSegment(msg, rhs_text, rhs_color);
		VX_PreProcessMessage(msg);
	}
}

static void VX_TrackerAddWeaponTextSplit(char* lhs_text, int weapon, const byte* color, char* rhs_text)
{
	trackmsg_t* msg;
	int i;
	char *weapon_text;

	if (((!lhs_text || !lhs_text[0]) && (!rhs_text || !rhs_text[0])) || CL_Demo_SkipMessage(true)) {
		return;
	}

	weapon_text = amf_tracker_inconsole_colored_weapon.integer == 0
		? GetWeaponName(weapon)
		: GetColoredWeaponName(weapon, color);

	if (!VX_TrackerStringPrintSegments(
		amf_tracker_weapon_first.integer ? weapon_text : lhs_text,
		amf_tracker_weapon_first.integer ? lhs_text : weapon_text,
		rhs_text, NULL)) {
		return;
	}

	msg = VX_NewTrackerMsg();
	if (msg) {
		msg->pad = lhs_text && rhs_text && lhs_text[0] && rhs_text[0];

		if (!amf_tracker_weapon_first.integer)
			VX_TrackerAddTextSegment(
				msg,
				amf_tracker_colorfix.integer ? Q_normalizetext(lhs_text) : lhs_text,
				amf_tracker_colorfix.integer ? color : color_white);

		for (i = 0; i < weapon_labels[weapon].count; ++i) {
			if (weapon_labels[weapon].colors[i][3]) {
				VX_TrackerAddFlaggedTextSegment(msg, weapon_labels[weapon].label + weapon_labels[weapon].starts[i], weapon_labels[weapon].colors[i], TEXTFLAG_WEAPON);
			}
			else {
				VX_TrackerAddFlaggedTextSegment(msg, weapon_labels[weapon].label + weapon_labels[weapon].starts[i], color, TEXTFLAG_WEAPON);
			}
		}

		if (amf_tracker_weapon_first.integer)
			VX_TrackerAddTextSegment(
				msg,
				amf_tracker_colorfix.integer ? Q_normalizetext(lhs_text) : lhs_text,
				amf_tracker_colorfix.integer ? color : color_white);

		VX_TrackerAddTextSegment(
			msg,
			amf_tracker_colorfix.integer ? Q_normalizetext(rhs_text) : rhs_text,
			amf_tracker_colorfix.integer ? color : color_white);
		VX_PreProcessMessage(msg);
	}
}

static void VX_TrackerLinkStrings(void)
{
	if (active_track > 1) {
		trackermsg[active_track - 2].linked = true;
	}
}

static char* VX_Name(int player, char* buffer, int max_length)
{
	strlcpy(buffer, cl.players[player].shortname, max_length);

	return buffer;
}

// Own Frags Text
static void VX_OwnFragNew(const char *victim)
{
	ownfragtext.time = r_refdef2.time;

	snprintf(ownfragtext.text, sizeof(ownfragtext.text), "%s%s", amf_tracker_own_frag_prefix.string, victim);
}

int VX_OwnFragTextLen(float scale, qbool proportional)
{
	return Draw_StringLengthColors(ownfragtext.text, -1, scale, proportional);
}

double VX_OwnFragTime(void)
{
	return r_refdef2.time - ownfragtext.time;
}

const char * VX_OwnFragText(void)
{
	return ownfragtext.text;
}

// return true if player enemy comparing to u, handle spectator mode
qbool VX_TrackerIsEnemy(int player)
{
	int selfnum;

	if (!cl.teamplay) // non teamplay mode, so player is enemy if not u 
		return !(cl.playernum == player || (player == Cam_TrackNum() && cl.spectator));

	// ok, below is teamplay

	if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator))
		return false;

	selfnum = (cl.spectator ? Cam_TrackNum() : cl.playernum);

	if (selfnum == -1)
		return true; // well, seems u r spec, but tracking noone

	return strncmp(cl.players[player].team, cl.players[selfnum].team, sizeof(cl.players[0].team)-1);
}

// is this player you, or you track him in case of spec
static qbool its_you(int player)
{
	return (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator));
}

static byte* SuicideColor(int player)
{
	if (its_you(player)) {
		return amf_tracker_color_suicide.color;
	}

	// with images color_bad == enemy color
	// without images color bad == bad frag for us
	if (cl_useimagesinfraglog.integer) {
		if (amf_tracker_positive_enemy_suicide.integer) {
			return (VX_TrackerIsEnemy(player) ? amf_tracker_color_good.color : amf_tracker_color_bad.color);
		}
		else {
			return (VX_TrackerIsEnemy(player) ? amf_tracker_color_bad.color : amf_tracker_color_good.color);
		}
	}
	else {
		return (VX_TrackerIsEnemy(player) ? amf_tracker_color_good.color : amf_tracker_color_bad.color);
	}
}

static byte* XvsYFullColor(int killed, int killer)
{
	if (its_you(killed)) {
		return amf_tracker_color_fragonme.color;
	}

	if (its_you(killer)) {
		return amf_tracker_color_myfrag.color;
	}

	if(VX_TrackerIsEnemy(killer) && VX_TrackerIsEnemy(killed)) {
		return (amf_tracker_positive_enemy_vs_enemy.integer) ? amf_tracker_color_good.color : amf_tracker_color_bad.color;
	}

	return (VX_TrackerIsEnemy(killed) ? amf_tracker_color_good.color : amf_tracker_color_bad.color);
}

static byte* OddFragFullColor(int killer)
{
	if (its_you(killer)) {
		return amf_tracker_color_myfrag.color;
	}

	return (!VX_TrackerIsEnemy(killer) ? amf_tracker_color_good.color : amf_tracker_color_bad.color);
}

static byte* EnemyFullColor(void)
{
	return amf_tracker_color_bad.color;
}

static byte* TeamKillColor(int player)
{
	return (VX_TrackerIsEnemy(player) ? amf_tracker_color_tkgood.color : amf_tracker_color_tkbad.color);
}

void VX_TrackerDeath(int player, int weapon, int count)
{
	if (VX_FilterDeaths()) {
		return;
	}

	if (amf_tracker_frags.integer == 2) {
		char player_name[MAX_SCOREBOARDNAME];

		VX_Name(player, player_name, MAX_SCOREBOARDNAME);

		if (cl_useimagesinfraglog.integer) {
			//snprintf(outstring, sizeof(outstring), "&c%s%s&r %s&c%s%s&r", SuiColor(player), VX_Name(player), GetWeaponName(weapon), SuiColor(player), amf_tracker_string_died.string);
			Q_normalizetext(player_name);
			VX_TrackerAddWeaponImageSplit(player_name, SuicideColor(player), weapon, amf_tracker_string_died.string, SuicideColor(player));
		}
		else {
			//snprintf(outstring, sizeof(outstring), "&r%s &c%s%s&r%s", VX_Name(player), SuiColor(player), GetWeaponName(weapon), amf_tracker_string_died.string);
			VX_TrackerAddWeaponTextSplit(player_name, weapon, SuicideColor(player), amf_tracker_string_died.string);
		}
	}
	else if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		char outstring[MAX_TRACKER_MSG_LEN];

		//snprintf(outstring, sizeof(outstring), "&c960You died&r\n%s deaths: %i", GetWeaponName(weapon), count);
		VX_TrackerAddSimpleText("You died", color960);
		if (cl_useimagesinfraglog.integer) {
			snprintf(outstring, sizeof(outstring), "deaths: %i", count);
			VX_TrackerAddWeaponImageSplit(NULL, NULL, weapon, outstring, color_white);
		}
		else {
			snprintf(outstring, sizeof(outstring), "%s deaths: %i", GetWeaponName(weapon), count);
			VX_TrackerAddSimpleText(outstring, color_white);
		}
		VX_TrackerLinkStrings();
	}
}

void VX_TrackerSuicide(int player, int weapon, int count)
{
	if (VX_FilterDeaths()) {
		return;
	}

	if (amf_tracker_frags.integer == 2) {
		char player_name[MAX_SCOREBOARDNAME];

		VX_Name(player, player_name, MAX_SCOREBOARDNAME);

		if (cl_useimagesinfraglog.integer) {
			//snprintf(outstring, sizeof(outstring), "&c%s%s&r %s&c%s%s&r", SuiColor(player), VX_Name(player), GetWeaponName(weapon), SuiColor(player), amf_tracker_string_suicides.string);
			Q_normalizetext(player_name);

			VX_TrackerAddWeaponImageSplit(player_name, SuicideColor(player), weapon, amf_tracker_string_suicides.string, SuicideColor(player));
		}
		else {
			//snprintf(outstring, sizeof(outstring), "&r%s &c%s%s&r%s", VX_Name(player), SuiColor(player), GetWeaponName(weapon), amf_tracker_string_suicides.string);
			VX_TrackerAddWeaponTextSplit(player_name, weapon, SuicideColor(player), amf_tracker_string_suicides.string);
		}
	}
	else if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		char outstring[MAX_TRACKER_MSG_LEN];

		//snprintf(outstring, sizeof(outstring), "&c960You killed yourself&r\n%s suicides: %i", GetWeaponName(weapon), count);
		VX_TrackerAddSimpleText("You killed yourself", color960);
		if (cl_useimagesinfraglog.integer) {
			snprintf(outstring, sizeof(outstring), "suicides: %i", count);

			VX_TrackerAddWeaponImageSplit(NULL, NULL, weapon, amf_tracker_string_suicides.string, SuicideColor(player));
		}
		else {
			snprintf(outstring, sizeof(outstring), "%s suicides: %i", GetWeaponName(weapon), count);
			VX_TrackerAddSimpleText(outstring, color_white);
		}
		VX_TrackerLinkStrings();
	}
}

void VX_TrackerFragXvsY(int player, int killer, int weapon, int player_wcount, int killer_wcount)
{
	int colorfix = amf_tracker_colorfix.integer;
	char outstring[20];
	char player_name[MAX_SCOREBOARDNAME];
	char killer_name[MAX_SCOREBOARDNAME];

	if (VX_FilterDeaths()) {
		return;
	}

	if (amf_tracker_frags.integer == 2) {
		VX_Name(player, player_name, MAX_SCOREBOARDNAME);
		VX_Name(killer, killer_name, MAX_SCOREBOARDNAME);

		if (cl_useimagesinfraglog.integer) {
			//snprintf(outstring, sizeof(outstring), "&c%s%s&r %s &c%s%s&r", XvsYColor(player, killer), VX_Name(killer), GetWeaponName(weapon), XvsYColor(killer, player), VX_Name(player));
			Q_normalizetext(player_name);
			Q_normalizetext(killer_name);

			VX_TrackerAddWeaponImageSplit(killer_name, XvsYFullColor(player, killer), weapon, player_name, colorfix ? XvsYFullColor(player, killer) : XvsYFullColor(killer, player));
		}
		else {
			VX_TrackerAddWeaponTextSplit(killer_name, weapon, XvsYFullColor(player, killer), player_name);
		}
	}
	else if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		VX_Name(killer, killer_name, MAX_SCOREBOARDNAME);

		//snprintf(outstring, sizeof(outstring), "&r%s &c900killed you&r\n%s deaths: %i", cl.players[killer].name, GetWeaponName(weapon), player_wcount);
		VX_TrackerAddSegmented(killer_name, color_white, " ", color_white, "killed you", color900);

		if (cl_useimagesinfraglog.integer) {
			snprintf(outstring, sizeof(outstring), " deaths: %i", player_wcount);
			VX_TrackerAddWeaponImageSplit(NULL, NULL, weapon, outstring, color_white);
		}
		else {
			snprintf(outstring, sizeof(outstring), "%s deaths: %i", GetWeaponName(weapon), player_wcount);
			VX_TrackerAddSimpleText(outstring, color_white);
		}
		VX_TrackerLinkStrings();
	}
	else if (cl.playernum == killer || (killer == Cam_TrackNum() && cl.spectator)) {
		VX_Name(player, player_name, MAX_SCOREBOARDNAME);

		//snprintf(outstring, sizeof(outstring), "&c900You killed &r%s\n%s kills: %i", cl.players[player].name, GetWeaponName(weapon), killer_wcount);
		VX_TrackerAddSegmented("You killed ", color900, " ", color_white, player_name, color_white);
		if (cl_useimagesinfraglog.integer) {
			snprintf(outstring, sizeof(outstring), " kills: %i", killer_wcount);
			VX_TrackerAddWeaponImageSplit(NULL, NULL, weapon, outstring, color_white);
		}
		else {
			snprintf(outstring, sizeof(outstring), "%s kills: %i", GetWeaponName(weapon), killer_wcount);
			VX_TrackerAddSimpleText(outstring, color_white);
		}
		VX_TrackerLinkStrings();
	}

	if (cl.playernum == killer || (killer == Cam_TrackNum() && cl.spectator)) {
		VX_OwnFragNew(cl.players[player].name);
	}
}

void VX_TrackerOddFrag(int player, int weapon, int wcount)
{
	char outstring[20];
	char player_name[MAX_SCOREBOARDNAME];

	if (VX_FilterDeaths()) {
		return;
	}

	if (amf_tracker_frags.integer == 2) {
		VX_Name(player, player_name, MAX_SCOREBOARDNAME);

		if (cl_useimagesinfraglog.integer) {
			//snprintf(outstring, sizeof(outstring), "&c%s%s&r %s &c%s%s&r", OddFragColor(player), VX_Name(player), GetWeaponName(weapon), EnemyColor(), amf_tracker_string_enemy.string);

			Q_normalizetext(player_name);

			VX_TrackerAddWeaponImageSplit(player_name, OddFragFullColor(player), weapon, amf_tracker_string_enemy.string, EnemyFullColor());
		}
		else {
			//snprintf(outstring, sizeof(outstring), "&r%s &c%s%s&r %s", VX_Name(player), OddFragColor(player), GetWeaponName(weapon), amf_tracker_string_enemy.string);
			VX_TrackerAddWeaponTextSplit(player_name, weapon, OddFragFullColor(player), amf_tracker_string_enemy.string);
		}
	}
	else if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		//snprintf(outstring, sizeof(outstring), "&c900You killed&r an enemy\n%s kills: %i", GetWeaponName(weapon), wcount);
		VX_TrackerAddSegmented("You killed", color900, " an enemy", color_white, "", NULL);

		if (cl_useimagesinfraglog.integer) {
			snprintf(outstring, sizeof(outstring), " kills: %i", wcount);
			VX_TrackerAddWeaponImageSplit(NULL, NULL, weapon, outstring, color_white);
		}
		else {
			snprintf(outstring, sizeof(outstring), "%s kills: %i", GetWeaponName(weapon), wcount);
			VX_TrackerAddSimpleText(outstring, color_white);
		}
		VX_TrackerLinkStrings();
	}
}

void VX_TrackerTK_XvsY(int player, int killer, int weapon, int p_count, int p_icount, int k_count, int k_icount)
{
	char outstring[20];
	char player_name[MAX_SCOREBOARDNAME];
	char killer_name[MAX_SCOREBOARDNAME];

	if (VX_FilterDeaths()) {
		return;
	}

	if (amf_tracker_frags.integer == 2) {
		byte* color = TeamKillColor(player);

		VX_Name(player, player_name, MAX_SCOREBOARDNAME);
		VX_Name(killer, killer_name, MAX_SCOREBOARDNAME);

		if (cl_useimagesinfraglog.integer) {
			//snprintf(outstring, sizeof(outstring), "&c%s%s&r %s &c%s%s&r", TKColor(player), VX_Name(killer), GetWeaponName(weapon), TKColor(player), VX_Name(player));
			Q_normalizetext(player_name);
			Q_normalizetext(killer_name);

			VX_TrackerAddWeaponImageSplit(killer_name, color, weapon, player_name, color);
		}
		else {
			//snprintf(outstring, sizeof(outstring), "&r%s &c%s%s&r %s", VX_Name(killer), TKColor(player), GetWeaponName(weapon), VX_Name(player));
			VX_TrackerAddWeaponTextSplit(killer_name, weapon, color, player_name);
		}
	}
	else if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		VX_Name(killer, killer_name, MAX_SCOREBOARDNAME);

		//snprintf(outstring, sizeof(outstring), "&c380Teammate&r %s &c900killed you\nTimes: %i\nTotal Teamkills: %i", cl.players[killer].name, p_icount, p_count);
		VX_TrackerAddSegmented("Teammate ", color380, killer_name, color_white, " killed you", color900);
		//snprintf(outstring, sizeof(outstring), "&c380Teammate&r %s &c900killed you\nTimes: %i\nTotal Teamkills: %i", cl.players[killer].name, p_icount, p_count);
		snprintf(outstring, sizeof(outstring), "Times: %i", p_icount);
		VX_TrackerAddSimpleText(outstring, color_white);
		VX_TrackerLinkStrings();
		snprintf(outstring, sizeof(outstring), "Total Teamkills: %i", p_count);
		VX_TrackerAddSimpleText(outstring, color_white);
		VX_TrackerLinkStrings();
	}
	else if (cl.playernum == killer || (killer == Cam_TrackNum() && cl.spectator)) {
		VX_Name(player, player_name, MAX_SCOREBOARDNAME);

		//snprintf(outstring, sizeof(outstring), "&c900You killed &c380teammate&r %s\nTimes: %i\nTotal Teamkills: %i", cl.players[player].name, k_icount, k_count);
		VX_TrackerAddSegmented("You killed ", color900, "teammate ", color380, player_name, color_white);
		snprintf(outstring, sizeof(outstring), "Times: %i", k_icount);
		VX_TrackerAddSimpleText(outstring, color_white);
		VX_TrackerLinkStrings();
		snprintf(outstring, sizeof(outstring), "Total Teamkills: %i", k_count);
		VX_TrackerAddSimpleText(outstring, color_white);
		VX_TrackerLinkStrings();
	}
}

void VX_TrackerOddTeamkill(int player, int weapon, int count)
{
	char outstring[20];
	char player_name[MAX_SCOREBOARDNAME];

	if (VX_FilterDeaths()) {
		return;
	}

	if (amf_tracker_frags.integer == 2) {
		VX_Name(player, player_name, MAX_SCOREBOARDNAME);

		if (cl_useimagesinfraglog.integer) {
			//snprintf(outstring, sizeof(outstring), "&c%s%s&r %s &c%s%s&r", TKColor(player), VX_Name(player), GetWeaponName(weapon), TKColor(player), amf_tracker_string_teammate.string);
			Q_normalizetext(player_name);

			VX_TrackerAddWeaponImageSplit(player_name, TeamKillColor(player), weapon, amf_tracker_string_teammate.string, TeamKillColor(player));
		}
		else {
			//snprintf(outstring, sizeof(outstring), "&r%s &c%s%s&r %s", VX_Name(player), TKColor(player), GetWeaponName(weapon), amf_tracker_string_teammate.string);
			VX_TrackerAddWeaponTextSplit(player_name, weapon, TeamKillColor(player), amf_tracker_string_teammate.string);
		}
	}
	else if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		//snprintf(outstring, sizeof(outstring), "&c900You killed &c380a teammate&r\nTotal Teamkills: %i", count);
		VX_TrackerAddSegmented("You killed ", color900, "a teammate", color380, "", NULL);
		snprintf(outstring, sizeof(outstring), "Total Teamkills: %i", count);
		VX_TrackerAddSimpleText(outstring, color_white);
		VX_TrackerLinkStrings();
	}
}

void VX_TrackerOddTeamkilled(int player, int weapon)
{
	char player_name[MAX_SCOREBOARDNAME];

	if (VX_FilterDeaths()) {
		return;
	}

	VX_Name(player, player_name, sizeof(player_name));

	if (amf_tracker_frags.integer == 2) {
		if (cl_useimagesinfraglog.integer) {
			VX_TrackerAddWeaponImageSplit(amf_tracker_string_teammate.string, TeamKillColor(player), weapon, player_name, TeamKillColor(player));
		}
		else {
			VX_TrackerAddWeaponTextSplit(amf_tracker_string_teammate.string, weapon, TeamKillColor(player), player_name);
		}
	}
	else if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		VX_TrackerAddSegmented("Teammate ", color380, "killed you", color900, "", NULL);
	}
}

void VX_TrackerFlagTouch(int count)
{
	char outstring[MAX_TRACKER_MSG_LEN];

	if (VX_FilterFlags()) {
		return;
	}

	VX_TrackerAddSimpleText("You've taken the flag", color960);
	snprintf(outstring, sizeof(outstring), "Flags taken: %i", count);
	VX_TrackerAddSimpleText(outstring, color_white);
	VX_TrackerLinkStrings();
}

void VX_TrackerFlagDrop(int count)
{
	char outstring[MAX_TRACKER_MSG_LEN];

	if (VX_FilterFlags()) {
		return;
	}

	VX_TrackerAddSimpleText("You've dropped the flag", color960);
	snprintf(outstring, sizeof(outstring), "Flags dropped: %i", count);
	VX_TrackerAddSimpleText(outstring, color_white);
	VX_TrackerLinkStrings();
}

void VX_TrackerFlagCapture(int count)
{
	char outstring[MAX_TRACKER_MSG_LEN];

	if (VX_FilterFlags()) {
		return;
	}

	VX_TrackerAddSimpleText("You've captured the flag", color960);
	snprintf(outstring, sizeof(outstring), "Flags captured: %i", count);
	VX_TrackerAddSimpleText(outstring, color_white);
	VX_TrackerLinkStrings();
}

killing_streak_t *VX_GetStreak (int frags)	
{
	unsigned int i;
	killing_streak_t *streak = tp_streak;

	for (i = 0, streak = tp_streak; i < NUMSTREAK; i++, streak++) {
		if (frags >= streak->frags) {
			return streak;
		}
	}

	return NULL;
}

void VX_TrackerStreak (int player, int count)
{
	char outstring[MAX_TRACKER_MSG_LEN]="";
	killing_streak_t *streak = VX_GetStreak(count);

	if (VX_FilterStreaks()) {
		return;
	}

	if (!streak || streak->frags != count) {
		return;
	}

	if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		snprintf(outstring, sizeof(outstring), "You are %s (%i kills)", streak->spreestring, count);

		VX_TrackerAddSimpleText(outstring, color940);
	}
	else {
		snprintf(outstring, sizeof(outstring), "is %s (%i kills)", streak->spreestring, count);

		VX_TrackerAddSegmented(cl.players[player].name, color_white, outstring, color940, "", NULL);
	}
}

void VX_TrackerStreakEnd(int player, int killer, int count)
{
	char outstring[MAX_TRACKER_MSG_LEN]="";
	killing_streak_t *streak = VX_GetStreak(count);

	if (!streak) {
		return;
	}

	if (VX_FilterStreaks()) {
		return;
	}

	if (player == killer) {
		// streak ends due to suicide
		gender_id gender = cl.players[player].gender;

		if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
			snprintf(outstring, sizeof(outstring), "You were looking good until you killed yourself (%i kills)", count);
			VX_TrackerAddSimpleText(outstring, color940);
		}
		else if (gender == gender_male) {
			snprintf(outstring, sizeof(outstring), " was looking good until he killed himself (%i kills)", count);
			VX_TrackerAddSegmented(cl.players[player].name, color_white, outstring, color940, "", NULL);
		}
		else if (gender == gender_female) {
			snprintf(outstring, sizeof(outstring), " was looking good until she killed herself (%i kills)", count);
			VX_TrackerAddSegmented(cl.players[player].name, color_white, outstring, color940, "", NULL);
		}
		else if (gender == gender_neutral) {
			snprintf(outstring, sizeof(outstring), " was looking good until it killed itself (%i kills)", count);
			VX_TrackerAddSegmented(cl.players[player].name, color_white, outstring, color940, "", NULL);
		}
		else {
			snprintf(outstring, sizeof(outstring), " was looking good, then committed suicide (%i kills)", count);
			VX_TrackerAddSegmented(cl.players[player].name, color_white, outstring, color940, "", NULL);
		}
	}
	else {
		// non suicide
		if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
			snprintf(outstring, sizeof(outstring), " (%i kills)", count);
			VX_TrackerAddSegmented("Your streak was ended by ", color940, cl.players[killer].name, color_white, outstring, color940);
		}
		else if (cl.playernum == killer || (killer == Cam_TrackNum() && cl.spectator)) {
			snprintf(outstring, sizeof(outstring), "'s streak was ended by you (%i kills)", count);
			VX_TrackerAddSegmented(cl.players[player].name, color_white, outstring, color940, "", NULL);
		}
		else {
			snprintf(outstring, sizeof(outstring), " (%i kills)", count);
			VX_TrackerAddSegmented4(cl.players[player].name, color_white, "'s streak was ended by ", color940, cl.players[killer].name, color_white, outstring, color940);
		}
	}
}

void VX_TrackerStreakEndOddTeamkilled(int player, int count)
{
	char outstring[MAX_TRACKER_MSG_LEN]="";
	killing_streak_t *streak = VX_GetStreak(count);

	if (!streak) {
		return;
	}

	if (VX_FilterStreaks()) {
		return;
	}

	if (cl.playernum == player || (player == Cam_TrackNum() && cl.spectator)) {
		snprintf(outstring, sizeof(outstring), "Your streak was ended by teammate (%i kills)", count);

		VX_TrackerAddSimpleText(outstring, color940);
	}
	else {
		snprintf(outstring, sizeof(outstring), "'s streak was ended by teammate (%i kills)", count);

		VX_TrackerAddSegmented(cl.players[player].name, color_white, outstring, color940, "", NULL);
	}
}

void VXSCR_MeasureTracker(float* width, float* height, float scale, qbool proportional, int name_width)
{
	int i;
	int padded_width = 8 * bound(name_width, 0, MAX_SCOREBOARDNAME - 1) * scale;

	*width = *height = 0;

	if (!active_track) {
		return;
	}

	// Draw the max allowed trackers allowed at the same time
	// the latest ones are always shown.
	for (i = 0; i < max_active_tracks; i++) {
		int printable_chars;
		float x = 0;
		int s;

		// Time expired for this tracker, don't draw it.
		if (trackermsg[i].die < r_refdef2.time) {
			continue;
		}

		printable_chars = trackermsg[i].printable_characters + trackermsg[i].image_characters;
		if (printable_chars <= 0) {
			break;
		}

		// Place the tracker.
		x = FontFixedWidth(1, scale, false, proportional);

		// Draw the segments.
		for (s = 0; s < trackermsg[i].segments; ++s) {
			mpic_t* pic = trackermsg[i].images[s];

			if (pic) {
				x += 8 * 2 * scale;
			}
			else {
				if (trackermsg[i].pad && padded_width && !trackermsg[i].text_flags[s]) {
					x += padded_width;
				}
				else {
					x += Draw_StringLength(trackermsg[i].text[s], -1, scale, proportional);
				}
			}

			x += 8 * scale;
		}

		*width = max(*width, x);
		*height += 8 * scale;	// Next line.
	}
}

// We need a seperate function, since our messages are in colour... and transparent
static void VXSCR_DrawTrackerString(float x_pos, float y_pos, float width, int name_width, qbool proportional, float scale, float image_scale, qbool align_right)
{
	int		x, y;
	int		i, printable_chars, s;
	float	alpha = 1, width_one_char;
	int     padded_width = 8 * bound(name_width, 0, MAX_SCOREBOARDNAME - 1) * scale;

	scale = bound(0.1, scale, 10);
	image_scale = bound(0.1, image_scale, 10);
	if (!active_track) {
		return;
	}

	width_one_char = FontFixedWidth(1, scale, false, proportional);

	// Draw the max allowed trackers allowed at the same time
	// the latest ones are always shown.
	y = y_pos;
	for (i = 0; i < max_active_tracks; i++) {
		int initial_position;

		// Time expired for this tracker, don't draw it.
		if (trackermsg[i].die < r_refdef2.time) {
			continue;
		}

		// Fade the text as it gets older.
		alpha = min(1, (trackermsg[i].die - r_refdef2.time) / 2);

		printable_chars = trackermsg[i].printable_characters + trackermsg[i].image_characters;
		if (printable_chars <= 0) {
			break;
		}

		// Place the tracker.
		if (!proportional) {
			x = x_pos + (align_right ? width - (printable_chars + 1) * width_one_char : width_one_char);
		}
		else {
			x = x_pos + width_one_char;
		}

		// Draw the segments.
		initial_position = Draw_ImagePosition();
		for (s = 0; s < trackermsg[i].segments; ++s) {
			mpic_t* pic = trackermsg[i].images[s];

			if (pic) {
				// Draw pic
				Draw_FitPicAlpha(
					(float)x - 0.5 * 8 * 2 * (image_scale - 1) * scale,
					(float)y - 0.5 * 8 * (image_scale - 1) * scale,
					image_scale * 8 * 2 * scale,
					image_scale * 8 * scale, pic, alpha
				);

				x += 8 * 2 * scale;
			}
			else {
				// Draw text
				clrinfo_t clr;

				clr.c = RGBAVECT_TO_COLOR_PREMULT_SPECIFIC(trackermsg[i].colors[s], alpha);
				clr.i = 0;

				if (trackermsg[i].pad && padded_width && !trackermsg[i].text_flags[s]) {
					Draw_SColoredStringAligned(x, y, trackermsg[i].text[s], &clr, 1, scale, alpha, proportional, trackermsg[i].alignment[s], x + padded_width);
					x += padded_width;
				}
				else {
					x += Draw_SColoredAlphaString(x, y, trackermsg[i].text[s], &clr, 1, 0, scale, alpha, proportional);
				}
			}

			x += 8 * scale;
		}
		if (proportional && align_right) {
			// shift into correct location, now we know where it ended
			int new_draw_position = Draw_ImagePosition();

			Draw_AdjustImages(initial_position, new_draw_position, width - (x - x_pos));
		}

		y += (8 + amf_tracker_row_spacing.value) * scale;	// Next line with configurable spacing.
	}
}

static void VX_PreProcessMessage(trackmsg_t* msg)
{
	int s;
	int padded_chars = bound(amf_tracker_name_width.integer, 0, MAX_SCOREBOARDNAME - 1);

	msg->printable_characters = msg->image_characters = 0;
	for (s = 0; s < msg->segments; ++s) {
		if (msg->images[s]) {
			msg->image_characters += 2;
		}
		else  {
			int length = 0;

			if (msg->pad && !msg->text_flags[s] && padded_chars) {
				length = padded_chars;
			}
			else {
				length = strlen(msg->text[s]);
			}
			msg->printable_characters += length;
		}
		++msg->printable_characters;
	}

	--msg->printable_characters;
}

static void OnChange_TrackerNameWidth(cvar_t* var, char* value, qbool* cancel)
{
	int i;

	Cvar_SetIgnoreCallback(var, value);

	for (i = 0; i < max_active_tracks; ++i) {
		if (trackermsg[i].die < cl.time) {
			continue;
		}

		VX_PreProcessMessage(&trackermsg[i]);
	}
}

void VX_TrackerInit(void)
{
	int i;
	char fullpath[MAX_PATH];

	memset(weapon_images, 0, sizeof(weapon_images));
	memset(weapon_labels, 0, sizeof(weapon_labels));

	char_textures[PRIVATE_USE_TRACKERIMAGES_CHARSET].custom_scale_x = 2;
	char_textures[PRIVATE_USE_TRACKERIMAGES_CHARSET].custom_scale_y = 1;

	// Pre-cache weapon-class images
	for (i = 0; i < MAX_WEAPON_CLASSES; ++i) {
		const char* image = GetWeaponImageName(i);
		const char* text = GetWeaponTextName(i);

		if (image && image[0]) {
			const char* start = image;
			int l = 0;

			while (start[l] && start[l] != '\n') {
				// Image escape.
				if (start[l] == '\\') {
					// We found opening slash, get image name now.
					int from, to;

					from = to = ++l;

					for (; start[l]; l++) {
						if (start[l] == '\n')
							break; // Something bad, we didn't find a closing slash.

						if (start[l] == '\\')
							break; // Found a closing slash.

						to = l + 1;
					}

					if (to > from) {
						char imagename[128];

						// We got potential image name, treat image as two printable characters.
						if (to - from < sizeof(imagename)) {
							int base = (i * MAX_IMAGES_PER_WEAPON);
							mpic_t* texture;

							strncpy(imagename, start + from, to - from);
							imagename[to - from] = '\0';

							snprintf(fullpath, sizeof(fullpath), "textures/tracker/%s", imagename);

							texture = R_LoadPicImage(fullpath, NULL, 0, 0, TEX_ALPHA);
							if (texture) {
								mpic_t* pic = &char_textures[PRIVATE_USE_TRACKERIMAGES_CHARSET].glyphs[base + weapon_images[i]];

								*pic = *texture;
								pic->width = 16;
								pic->height = 8;
								++weapon_images[i];
							}
						}
					}

					if (start[l] == '\\') {
						l++; // Advance.
					}

					continue;
				}

				l++; // Increment count of any chars in string untill end or new line.
			}
		}

		if (text && text[0]) {
			int j, pos = 0, count = 0;
			int len;

			strlcpy(weapon_labels[i].label, text, sizeof(weapon_labels[i].label));

			len = strlen(weapon_labels[i].label);
			for (j = 0; j < len; ++j) {
				if (text[j] == '&' && text[j + 1] == 'c' && text[j + 2] && text[j + 3] && text[j + 4]) {
					weapon_labels[i].label[j] = '\0';

					if (count) {
						++weapon_labels[i].count;
						if (weapon_labels[i].count >= sizeof(weapon_labels[i].starts) / sizeof(weapon_labels[i].starts[0])) {
							break;
						}
					}

					weapon_labels[i].colors[weapon_labels[i].count][0] = HexToInt(text[j + 2]) * 16;
					weapon_labels[i].colors[weapon_labels[i].count][1] = HexToInt(text[j + 3]) * 16;
					weapon_labels[i].colors[weapon_labels[i].count][2] = HexToInt(text[j + 4]) * 16;
					weapon_labels[i].colors[weapon_labels[i].count][3] = 255;
					count = 0;
					j += 4;
				}
				else if (text[j] == '&' && text[j + 1] == 'r') {
					weapon_labels[i].label[pos++] = '\0';

					if (count) {
						++weapon_labels[i].count;
						if (weapon_labels[i].count >= sizeof(weapon_labels[i].starts) / sizeof(weapon_labels[i].starts[0])) {
							break;
						}
					}

					memset(weapon_labels[i].colors[0], 0, sizeof(weapon_labels[i].colors[0]));
					count = 0;
					j += 1;
				}
				else if (text[j] == ' ') {
					weapon_labels[i].label[pos++] = '\0';

					if (count) {
						++weapon_labels[i].count;
						if (weapon_labels[i].count >= sizeof(weapon_labels[i].starts) / sizeof(weapon_labels[i].starts[0])) {
							break;
						}
					}

					memset(weapon_labels[i].colors[0], 0, sizeof(weapon_labels[i].colors[0]));
					count = 0;
				}
				else {
					if (!count) {
						weapon_labels[i].starts[weapon_labels[i].count] = pos;
					}
					weapon_labels[i].label[pos++] = text[j];
					++count;
				}
			}

			if (!weapon_labels[i].count && count) {
				weapon_labels[i].count = 1;
			}
		}
	}

	CachePics_MarkAtlasDirty();
}

void SCR_HUD_DrawTracker(hud_t* hud)
{
	int x = 0, y = 0;
	float width = 0, height = 0;

	static cvar_t
		*hud_tracker_scale = NULL,
		*hud_tracker_proportional,
		*hud_tracker_name_width,
		*hud_tracker_image_scale,
		*hud_tracker_align_right;

	if (!hud_tracker_scale) {
		hud_tracker_scale = HUD_FindVar(hud, "scale");
		hud_tracker_proportional = HUD_FindVar(hud, "proportional");
		hud_tracker_name_width = HUD_FindVar(hud, "name_width");
		hud_tracker_align_right = HUD_FindVar(hud, "align_right");
		hud_tracker_image_scale = HUD_FindVar(hud, "image_scale");
	}

	VXSCR_MeasureTracker(&width, &height, hud_tracker_scale->value, hud_tracker_proportional->integer, hud_tracker_name_width->integer);

	if (height > 0 && width > 0 && HUD_PrepareDraw(hud, ceil(width), ceil(height), &x, &y)) {
		VXSCR_DrawTrackerString(x, y, ceil(width), hud_tracker_name_width->integer, hud_tracker_proportional->integer, hud_tracker_scale->value, hud_tracker_image_scale->value, hud_tracker_align_right->integer);
	}
}

// This needs improved...
void VX_TrackerPickupText(const char* line)
{
	if (VX_FilterPickups()) {
		return;
	}

	VX_TrackerAddSimpleText(line, color_white);
}


================================================
FILE: src/vx_tracker.h
================================================
/*
Copyright (C) 2011 VultureIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __VX_TRACKER_H__
#define __VX_TRACKER_H__

extern cvar_t amf_tracker_messages;
extern cvar_t amf_tracker_time;
extern cvar_t amf_tracker_align_right;
extern cvar_t amf_tracker_scale;

void VX_TrackerDeath(int player, int weapon, int count);
void VX_TrackerSuicide(int player, int weapon, int count);
void VX_TrackerFragXvsY(int player, int killer, int weapon, int player_wcount, int killer_wcount);
void VX_TrackerOddFrag(int player, int weapon, int wcount);

void VX_TrackerTK_XvsY(int player, int killer, int weapon, int p_count, int p_icount, int k_count, int k_icount);
void VX_TrackerOddTeamkill(int player, int weapon, int count);
void VX_TrackerOddTeamkilled(int player, int weapon);

void VX_TrackerFlagTouch(int count);
void VX_TrackerFlagDrop(int count);
void VX_TrackerFlagCapture(int count);

char* GetWeaponName(int num);
char* GetColoredWeaponName(int num, const byte *color);
const char* GetWeaponImageName(int num);
const char* GetWeaponTextName(int num);
void VX_TrackerThink(void);
void VX_TrackerInit(void);
void VX_TrackerClear(void);
void VX_TrackerStreak(int player, int count);
void VX_TrackerStreakEnd(int player, int killer, int count);
void VX_TrackerStreakEndOddTeamkilled(int player, int count);

// This needs improved...
void VX_TrackerPickupText(const char* line);

#define MAX_WEAPON_CLASSES		64
#define MAX_FRAG_DEFINITIONS	512
#define MAX_FRAGMSG_LENGTH		256
#define MAX_TRACKER_IMAGES      128

#endif // __VX_TRACKER_H__


================================================
FILE: src/vx_vertexlights.c
================================================
/*
Copyright (C) 2011 VULTUREIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// RIOT - Vertex lighting for models
#include "quakedef.h"
#include "vx_vertexlights.h"
#include "gl_local.h"

//#define DEG2RAD(a) (a * M_PI / 180.0)

// Meag: these were set in R_AliasSetupLighting(), but only used in VLight_ResetAnormTable(),
//       which is only called during startup...
#define VLIGHT_PITCH 45.0f
#define VLIGHT_YAW   45.0f
#define VLIGHT_HIGHCUT (240.0f / 255.0f)
#define VLIGHT_LOWCUT (40.0f / 255.0f)
#define VLIGHT_RANGE (VLIGHT_HIGHCUT - VLIGHT_LOWCUT)

static byte anorm_pitch[162];
static byte anorm_yaw[162];

static float vlighttable[256][256];

#ifdef _WIN32
#ifndef fabsf
#define fabsf(x) (float)fabs((double)x)
#endif
#ifndef fmodf
#define fmodf(x, y) (float)fmod((double)x, (double)y)
#endif
#endif

static float VLight_GetLightValueByAngles(float pitchofs, float yawofs, float apitch, float ayaw)
{
	int pitch, yaw;
	float retval[4];
	float weight[2], diff[2];

	pitchofs = fabsf(pitchofs + (apitch * 256) / 360);
	yawofs = fabsf(yawofs) + (ayaw * 256) / 360;

	pitch = (unsigned int)pitchofs;
	yaw = (unsigned int)yawofs;

	weight[0] = pitchofs - pitch;
	weight[1] = yawofs - yaw;

	retval[0] = vlighttable[pitch % 256][yaw % 256];
	retval[1] = vlighttable[(pitch + 1) % 256][yaw % 256];
	retval[2] = vlighttable[pitch % 256][(yaw + 1) % 256];
	retval[3] = vlighttable[(pitch + 1) % 256][(yaw + 1) % 256];

	diff[0] = retval[0] + (retval[1] - retval[0]) * weight[0];
	diff[1] = retval[2] + (retval[3] - retval[2]) * weight[0];

	retval[0] = (diff[0] + (diff[1] - diff[0]) * weight[1]);
	retval[0] = max(retval[0], cl.minlight / 255.0f);
	return bound(0, retval[0], 2);
}

static float VLight_GetLightValue(int index, float apitch, float ayaw)
{
	return VLight_GetLightValueByAngles(anorm_pitch[index], anorm_yaw[index], apitch, ayaw);
}

float VLight_LerpLightByAngles(float pitchofs1, float yawofs1, float pitchofs2, float yawofs2, float ilerp, float apitch, float ayaw)
{
	float lightval1, lightval2;

	lightval1 = VLight_GetLightValueByAngles(pitchofs1, yawofs1, apitch, ayaw);
	if (pitchofs1 == pitchofs2 && yawofs1 == yawofs2) {
		return lightval1;
	}

	lightval2 = VLight_GetLightValueByAngles(pitchofs2, yawofs2, apitch, ayaw);
	return (lightval2 * ilerp) + (lightval1 * (1 - ilerp));
}

float VLight_LerpLight(int index1, int index2, float ilerp, float apitch, float ayaw)
{
	float lightval1, lightval2;

	lightval1 = VLight_GetLightValue(index1, apitch, ayaw);
	if (index1 == index2) {
		return lightval1;
	}

	lightval2 = VLight_GetLightValue(index2, apitch, ayaw);
	return (lightval2 * ilerp) + (lightval1 * (1 - ilerp));
}

static void VLight_ResetAnormTable(void)
{
	int i,j;
	float angle;
	float sp, sy, cp, cy;
	float precut;
	vec3_t normal;
	vec3_t lightvec;

	// Define the light vector here
	angle	= DEG2RAD(VLIGHT_PITCH);
	sy		= sin(angle);
	cy		= cos(angle);
	angle	= DEG2RAD(-VLIGHT_YAW);
	sp		= sin(angle);
	cp		= cos(angle);
	VectorSet(lightvec, cp * cy, cp * sy, -sp);

	// First thing that needs to be done is the conversion of the
	// anorm table into a pitch/yaw table
	for (i = 0; i < NUMVERTEXNORMALS; ++i) {
		extern float r_avertexnormals[NUMVERTEXNORMALS][3];
		float ang[3];

		vectoangles(r_avertexnormals[i], ang);
		anorm_pitch[i] = ang[0] * 256.0f / 360.0f;
		anorm_yaw[i] = ang[1] * 256.0f / 360.0f;
	}

	// Next, a light value table must be constructed for pitch/yaw offsets
	for (i = 0; i < 256; i++) {
		angle = DEG2RAD(i * 360.0f / 256.0f);
		sy = sin(angle);
		cy = cos(angle);

		for (j = 0; j < 256; j++) {
			angle = DEG2RAD(j * 360.0f / 256.0f);
			sp = sin(angle);
			cp = cos(angle);

			VectorSet(normal, cp * cy, cp * sy, -sp);

			// rescale [-1, 1] => [0, 1]
			precut = (DotProduct(normal, lightvec) + 1) * 0.5f;
			// rescale within low/high cut range
			precut = (precut * VLIGHT_RANGE + VLIGHT_LOWCUT);
			// rescale back to [0, 2]
			vlighttable[i][j] = precut * 2;
		}
	}
}

void Init_VLights(void)
{
	VLight_ResetAnormTable();
}


================================================
FILE: src/vx_vertexlights.h
================================================
/*
Copyright (C) 2011 VultureIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

float VLight_LerpLight(int index1, int index2, float ilerp, float apitch, float ayaw);
float VLight_LerpLightByAngles(float pitchofs1, float yawofs1, float pitchofs2, float yawofs2, float ilerp, float apitch, float ayaw);

void Init_VLights(void);


================================================
FILE: src/wad.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

	$Id: wad.c,v 1.20 2007-10-04 14:56:54 dkure Exp $
*/
// wad.c

#include "quakedef.h"
#include "gl_model.h"
#include "wad.h"
#include "crc.h"

typedef struct {
	int			filepos;
	int			disksize;
	int			size;					// uncompressed
	char		type;
	char		compression;
	char		pad1, pad2;
	char		name[16];				// must be null terminated
} lumpinfo_t;

typedef struct {
	char		identification[4];		// should be WAD2 or 2DAW
	int			numlumps;
	int			infotableofs;
} wadinfo_t;

static int			wad_numlumps;
static int			wad_filesize;
static lumpinfo_t	*wad_lumps;
static byte			*wad_base = NULL;

static void W_InsertOcranaLeds(byte *data);

void SwapPic(qpic_t *pic)
{
	pic->width = LittleLong(pic->width);
	pic->height = LittleLong(pic->height);
}

/*
Lowercases name and pads with spaces and a terminating 0 to the length of lumpinfo_t->name.
Used so lumpname lookups can proceed rapidly by comparing 4 chars at a time
Space padding is so names can be printed nicely in tables. Can safely be performed in place.
*/
static void W_CleanupName(const char *in, char *out)
{
	int i, c;

	for (i = 0; i < 16; i++) {
		c = in[i];
		if (!c)
			break;

		if (c >= 'A' && c <= 'Z')
			c += ('a' - 'A');
		out[i] = c;
	}

	for (; i < 16; i++) {
		out[i] = 0;
	}
}

void W_FreeWadFile(void)
{
	Q_free(wad_base);
	wad_base = NULL;
	wad_lumps = NULL;
	wad_numlumps = 0;
	wad_filesize = 0;
}

void W_LoadWadFile(const char *filename)
{
	lumpinfo_t *lump_p;
	wadinfo_t *header;
	unsigned i;
	int infotableofs;

	// only one .wad can be loaded at a time
	W_FreeWadFile();

	wad_base = FS_LoadHeapFile(filename, &wad_filesize);

	if (!wad_base) {
		if (!strcmp(filename, "gfx.wad"))
			Sys_Error("Couldn't load gfx.wad.\n"
				"This usually happens when you don't have original Quake 1 files in id1 subdirectory.\n"
				"Ensure you have pak0.pak and pak1.pak in subdirectory id1.");
		else
			Sys_Error("W_LoadWadFile: couldn't load %s", filename);
	}
	header = (wadinfo_t *)wad_base;

	if (memcmp(header->identification, "WAD2", 4))
		Sys_Error("Wad file %s doesn't have WAD2 id\n", filename);

	wad_numlumps = LittleLong(header->numlumps);
	infotableofs = LittleLong(header->infotableofs);
	wad_lumps = (lumpinfo_t *)(wad_base + infotableofs);

	if (infotableofs + wad_numlumps * sizeof(lump_t) > wad_filesize)
		Sys_Error("Wad lump table exceeds file size");

	for (i = 0, lump_p = wad_lumps; i < wad_numlumps; i++, lump_p++) {
		lump_p->filepos = LittleLong(lump_p->filepos);
		lump_p->size = LittleLong(lump_p->size);

		W_CleanupName(lump_p->name, lump_p->name);

		if (lump_p->filepos < sizeof(wadinfo_t) || lump_p->filepos + LittleLong(lump_p->disksize) > wad_filesize)
			Sys_Error("Wad lump %s exceeds file size", lump_p->name);

		if (lump_p->type == TYP_QPIC)
			SwapPic((qpic_t *)(wad_base + lump_p->filepos));
	}
}

lumpinfo_t *W_GetLumpinfo(const char *name)
{
	int i;
	lumpinfo_t	*lump_p;
	char clean[16];

	W_CleanupName(name, clean);
	for (lump_p = wad_lumps, i = 0; i < wad_numlumps; i++, lump_p++) {
		if (!strcmp(clean, lump_p->name)) {
			return lump_p;
		}
	}

	Sys_Error("W_GetLumpinfo: %s not found", name);
	return NULL;
}

void* W_GetLumpName(const char *name)
{
	lumpinfo_t* lump = W_GetLumpinfo(name);

	// Make sure we have a lump. 
	if (!lump) {
		return NULL;
	}

	// If we got the conchars lump, check if the CRC is the same
	// as in the original gfx.wad, and if so, insert leds into it.
	if (!strcmp(name, "conchars")) {
		if (lump->filepos + lump->size < wad_filesize
			&& CRC_Block(wad_base + lump->filepos, lump->size) == 798) {
			W_InsertOcranaLeds(wad_base + lump->filepos);
		}
	}

	return (void *)(wad_base + lump->filepos);
}

void* W_GetLumpNum(int num)
{
	lumpinfo_t *lump;

	if (num < 0 || num > wad_numlumps) {
		Sys_Error("W_GetLumpNum: bad number: %i", num);
	}

	lump = wad_lumps + num;

	return (void *)(wad_base + lump->filepos);
}

static byte ocrana_leds[4][8][8] = {
	{
		// green
		{0x00,0x38,0x3b,0x3b,0x3b,0x3b,0x35,0x00},
		{0x38,0x3b,0x3d,0x3f,0x3f,0x3d,0x38,0x35},
		{0x3b,0x3d,0xfe,0x3f,0x3f,0x3f,0x3b,0x35},
		{0x3b,0x3f,0x3f,0x3f,0x3f,0x3f,0x3b,0x35},
		{0x3b,0x3f,0x3f,0x3f,0x3f,0x3d,0x3b,0x35},
		{0x3b,0x3d,0x3f,0x3f,0x3d,0x3b,0x38,0x35},
		{0x35,0x38,0x3b,0x3b,0x3b,0x38,0x35,0x35},
		{0x00,0x35,0x35,0x35,0x35,0x35,0x35,0x00}
	},
	{
		// red
		{0x00,0xf8,0xf9,0xf9,0xf9,0xf9,0x4c,0x00},
		{0xf8,0xf9,0xfa,0xfb,0xfb,0xfa,0xf8,0x4c},
		{0xf9,0xfa,0xfe,0xfb,0xfb,0xfb,0xf9,0x4c},
		{0xf9,0xfb,0xfb,0xfb,0xfb,0xfb,0xf9,0x4c},
		{0xf9,0xfb,0xfb,0xfb,0xfb,0xfa,0xf9,0x4c},
		{0xf9,0xfa,0xfb,0xfb,0xfa,0xf9,0xf8,0x4c},
		{0x4c,0xf8,0xf9,0xf9,0xf9,0xf8,0x4c,0x4c},
		{0x00,0x4c,0x4c,0x4c,0x4c,0x4c,0x4c,0x00}
	},
	{
		// yellow
		{0x00,0xc8,0xc5,0xc5,0xc5,0xc5,0xcb,0x00},
		{0xc8,0xc5,0xc2,0x6f,0x6f,0xc2,0xc8,0xcb},
		{0xc5,0xc2,0xfe,0x6f,0x6f,0x6f,0xc5,0xcb},
		{0xc5,0x6f,0x6f,0x6f,0x6f,0x6f,0xc5,0xcb},
		{0xc5,0x6f,0x6f,0x6f,0x6f,0xc2,0xc5,0xcb},
		{0xc5,0xc2,0x6f,0x6f,0xc2,0xc5,0xc8,0xcb},
		{0xcb,0xc8,0xc5,0xc5,0xc5,0xc8,0xcb,0xcb},
		{0x00,0xcb,0xcb,0xcb,0xcb,0xcb,0xcb,0x00}
	},
	{
		// blue
		{0x00,0xd8,0xd5,0xd5,0xd5,0xd5,0xdc,0x00},
		{0xd8,0xd5,0xd2,0xd0,0xd0,0xd2,0xd8,0xdc},
		{0xd5,0xd2,0xfe,0xd0,0xd0,0xd0,0xd5,0xdc},
		{0xd5,0xd0,0xd0,0xd0,0xd0,0xd0,0xd5,0xdc},
		{0xd5,0xd0,0xd0,0xd0,0xd0,0xd2,0xd5,0xdc},
		{0xd5,0xd2,0xd0,0xd0,0xd2,0xd5,0xd8,0xdc},
		{0xdc,0xd8,0xd5,0xd5,0xd5,0xd8,0xdc,0xdc},
		{0x00,0xdc,0xdc,0xdc,0xdc,0xdc,0xdc,0x00}
	}
};

static void W_InsertOcranaLeds(byte *data)
{
	byte *leddata;
	int i, x, y;

	for (i = 0; i < 4; i++) {
		leddata = data + (0x80 >> 4 << 10) + (0x06 << 3) + (i << 3);

		for (y = 0; y < 8; y++) {
			for (x = 0; x < 8; x++)
				*leddata++ = ocrana_leds[i][y][x];
			leddata += 128 - 8;
		}
	}
}

/*
=============================================================================
WAD3 Texture Loading for BSP 3.0 Support
=============================================================================
*/

#define TEXWAD_MAXIMAGES 16384
typedef struct {
	char name[MAX_QPATH];
	vfsfile_t *file;
	int position;
	int size;
} texwadlump_t;

static texwadlump_t texwadlump[TEXWAD_MAXIMAGES];
static int wad3_numlumps = 0;

void WAD3_LoadWadFile(const char *filename)
{
	lumpinfo_t *lumps, *lump_p;
	wadinfo_t header;
	int i, j, infotableofs, numlumps, lowmark;
	vfsfile_t *file;
	vfserrno_t err;

	if (wad3_numlumps == TEXWAD_MAXIMAGES)
		return;

	if (!(file = FS_OpenVFS(va("textures/halflife/%s", filename), "rb", FS_ANY)))
		if (!(file = FS_OpenVFS(va("textures/wad3/%s", filename), "rb", FS_ANY)))
			if (!(file = FS_OpenVFS(va("textures/%s", filename), "rb", FS_ANY)))
				if (!(file = FS_OpenVFS(filename, "rb", FS_ANY))) {
					Com_Printf("WAD3_LoadWadFile: couldn't load halflife wad \"%s\"", filename);
					return;
				}
	if (VFS_READ(file, &header, sizeof(wadinfo_t), &err) != sizeof(wadinfo_t)) {
		Com_Printf("WAD3_LoadWadFile: unable to read wad header\n");
		return;
	}

	if (memcmp(header.identification, "WAD3", 4)) {
		Com_Printf("WAD3_LoadWadFile: Wad file %s doesn't have WAD3 id\n", filename);
		return;
	}

	numlumps = LittleLong(header.numlumps);
	if (numlumps < 1 || numlumps > TEXWAD_MAXIMAGES) {
		Com_Printf("WAD3_LoadWadFile: invalid number of lumps (%i)\n", numlumps);
		return;
	}

	infotableofs = LittleLong(header.infotableofs);
	if (VFS_SEEK(file, infotableofs, SEEK_SET)) {
		Com_Printf("WAD3_LoadWadFile: unable to seek to lump table\n");
		return;
	}

	lowmark = Hunk_LowMark();
	if (!(lumps = Hunk_AllocName(sizeof(lumpinfo_t) * numlumps, filename))) {
		Com_Printf("WAD3_LoadWadFile: unable to allocate temporary memory for lump table\n");
		return;
	}

	if (((size_t)VFS_READ(file, lumps, sizeof(lumpinfo_t)*numlumps, &err)) != sizeof(lumpinfo_t) * numlumps) {
		Com_Printf("WAD3_LoadWadFile: unable to read lump table\n");
		Hunk_FreeToLowMark(lowmark);
		return;
	}

	for (i = 0, lump_p = lumps; i < numlumps; i++, lump_p++) {
		W_CleanupName(lump_p->name, lump_p->name);
		for (j = 0; j < wad3_numlumps; j++) {
			if (!strcmp(lump_p->name, texwadlump[j].name))
				goto skip_duplicate;
		}
		strlcpy(texwadlump[j].name, lump_p->name, sizeof(texwadlump[j].name));
		texwadlump[j].file = file;
		texwadlump[j].position = LittleLong(lump_p->filepos);
		texwadlump[j].size = LittleLong(lump_p->disksize);
		wad3_numlumps++;
		if (wad3_numlumps == TEXWAD_MAXIMAGES) {
			break;
		}
skip_duplicate:
		;
	}

	Hunk_FreeToLowMark(lowmark);
	//leaves the file open
}

//converts paletted to rgba
byte *ConvertWad3ToRGBA(int width, int height, byte *in, qbool alpha)
{
	byte *data, *pal;
	int i, p, image_size;

	image_size = width * height;
	data = Q_malloc(image_size * 4);

	pal = (byte *)in + ((image_size * 85) / 64) + 2;

	for (i = 0; i < image_size; i++) {
		p = *in++;
		if (p == 255 && alpha) {
			((int *)data)[i] = 0;
		}
		else {
			p *= 3;
			data[i * 4 + 0] = pal[p];
			data[i * 4 + 1] = pal[p + 1];
			data[i * 4 + 2] = pal[p + 2];
			data[i * 4 + 3] = 255;
		}
	}
	return data;
}

byte *WAD3_LoadTexture(texture_t *tx)
{
	int i, j = 0;
	miptex_t *mt;
	byte *data;
	vfsfile_t *file;
	vfserrno_t err;

	if (tx->offsets[0])
		return ConvertWad3ToRGBA(tx->width, tx->height, (byte *)(tx + 1), (tx->name[0] == '{'));

	for (i = 0; i < wad3_numlumps; i++) {
		if (strcasecmp(tx->name, texwadlump[i].name))
			continue;

		file = texwadlump[i].file;
		if (VFS_SEEK(file, texwadlump[i].position, SEEK_SET)) {
			Com_Printf("WAD3_LoadTexture: corrupt WAD3 file\n");
			return NULL;
		}
		mt = Q_malloc(texwadlump[i].size);
		if (VFS_READ(file, mt, texwadlump[i].size, &err) < texwadlump[i].size) {
			Com_Printf("WAD3_LoadTexture: corrupt WAD3 file\n");
			Q_free(mt);
			return NULL;
		}
		mt->width = LittleLong(mt->width);
		mt->height = LittleLong(mt->height);
		if (mt->width != tx->width || mt->height != tx->height) {
			Q_free(mt);
			return NULL;
		}
		for (j = 0;j < MIPLEVELS;j++)
			mt->offsets[j] = LittleLong(mt->offsets[j]);
		data = ConvertWad3ToRGBA(mt->width, mt->height, (byte *)(mt + 1), (tx->name[0] == '{'));
		Q_free(mt);
		return data;
	}
	return NULL;
}


================================================
FILE: src/wad.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// wad.h

#ifndef _WAD_H
#define _WAD_H

//#include "bspfile.h"

//===============
//   TYPES
//===============

#define	CMP_NONE		0
#define	CMP_LZSS		1

#define	TYP_NONE		0
#define	TYP_LABEL		1

#define	TYP_LUMPY		64				// 64 + grab command number
#define	TYP_PALETTE		64
#define	TYP_QTEX		65
#define	TYP_QPIC		66
#define	TYP_SOUND		67
#define	TYP_MIPTEX		68

typedef struct {
	int			width, height;
	byte		data[4];			// variably sized
} qpic_t;

void W_LoadWadFile(const char *filename);
void* W_GetLumpName(const char *name);
void W_FreeWadFile(void);

void SwapPic(qpic_t *pic);

void WAD3_LoadWadFile(const char *filename);
byte* WAD3_LoadTexture(texture_t *tx);

#endif // _WAD_H


================================================
FILE: src/winquake.rc
================================================
#include <windows.h>
#include "version.h"

1 VERSIONINFO
{
	BLOCK "StringFileInfo"
	{
		BLOCK "040904B0"
		{
			VALUE "ProductName", "ezQuake"
			VALUE "ProductVersion", VERSION_NUMBER " Build " VERSION
			VALUE "FileDescription", "ezQuake v" VERSION_NUMBER " - QuakeWorld(r) Today"
			VALUE "FileVersion", VERSION_NUMBER
			VALUE "CompanyName", "The ezQuake Developers"
			VALUE "OriginalFileName", "ezquake.exe"
			VALUE "InternalName", "ezquake"
		}
	}

	BLOCK "VarFileInfo"
	{
		VALUE "Translation",  0x0409, 0x04B0
	}
}

1 ICON "ezquake.ico"
CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "ezquake.exe.manifest"


================================================
FILE: src/xsd.c
================================================
/*
Copyright (C) 2011 VULTUREIIC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
// $Id: xsd.c,v 1.14 2007-10-29 12:48:12 cokeman1982 Exp $

#include "quakedef.h"
#include "expat.h"
#include "xsd.h"

typedef xml_t * (*XSD_DocumentLoadType)(vfsfile_t *v, int len);
typedef void (*XSD_DocumentFreeType)(xml_t *);
typedef xml_document_t * (*XSD_DocumentConvertType)(xml_t *);

typedef struct xsd_mapping_s
{
    char *document_type;
    XSD_DocumentLoadType load_function;
    XSD_DocumentFreeType free_function;
    XSD_DocumentConvertType convert_function;
}
xsd_mapping_t;

xsd_mapping_t xsd_mappings[] = {
    //{"variable", XSD_Variable_LoadFromHandle, XSD_Variable_Free, XSD_Variable_Convert},
    //{"command", XSD_Command_LoadFromHandle, XSD_Command_Free, NULL},
    {"document", XSD_Document_LoadFromHandle, XSD_Document_Free, NULL},
    {NULL, NULL, NULL}
};

// get value attribute from the array
const char *XSD_GetAttribute(const char **atts, const char *name)
{
    while (*atts)
    {
        if (!strcmp(*atts, name))
            return *(atts+1);

        atts += 2;
    }

    return NULL;
}

// add text (strcat) with realocation
char *XSD_AddText(char *dst, const char *src, int src_len)
{
    char *buf;
	size_t len;

    if (dst == NULL)
    {
        buf = (char *) Q_malloc(src_len + 1);
        memcpy(buf, src, src_len);
        buf[src_len] = 0;
    }
    else
    {
		len = 1 + src_len + strlen(dst);
        buf = (char *) Q_malloc(len);
        strlcpy (buf, dst, len);
        memcpy(buf+strlen(buf), src, src_len);
        buf[src_len+strlen(dst)] = 0;
        Q_free(dst);
    }

    return buf;
}

// test if character is valid XML space
int XSD_IsSpace(char c)
{
    if (c == ' '  ||  c == '\t'  ||  c == '\n'  ||  c == '\r')
        return 1;
    return 0;
}

// strip spaces multiple spaces from in-between words
char *XSD_StripSpaces (char *str)
{
    char *buf, *ret;
    unsigned int p = 0, q = 0;

    if (str == NULL)
        return str;

    buf = (char *) Q_malloc(strlen(str)+1);
    for (p=0; p < strlen(str); p++)
    {
        if (XSD_IsSpace(str[p]))
        {
            if (q == 0  ||  XSD_IsSpace(buf[q-1]))
                ;
            else
                buf[q++] = ' ';
        }
        else
            buf[q++] = str[p];
    }

    // strip spaces from the end
    while (q > 0  &&  XSD_IsSpace(buf[q-1]))
        q--;
    buf[q] = 0;

    ret = (char *) Q_strdup(buf);
    Q_free(buf);
    Q_free(str);
    return ret;
}

// check if we are somewhere inside given element
int XSD_IsIn(char *path, char *subPath)
{
    size_t sublen = strlen(subPath);

    // if path is shorter than subpath
    if (strlen(path) < sublen)
        return 0;

    // if it matches
    if (!strncmp(path, subPath, sublen)  &&
        (path[sublen] == 0  ||  path[sublen] == '/'))
    {
        return 1;
    }

    // no match
    return 0;
}

// initialize parser stack
void XSD_InitStack(xml_parser_stack_t *stack)
{
    memset(stack, 0, sizeof(xml_parser_stack_t));
}

// restore parser handlers from previous one in stack
void XSD_RestoreStack(xml_parser_stack_t *stack)
{
    XML_SetStartElementHandler(stack->parser, stack->oldStartHandler);
    XML_SetEndElementHandler(stack->parser, stack->oldEndHandler);
    XML_SetCharacterDataHandler(stack->parser, stack->oldCharacterDataHandler);
    XML_SetUserData(stack->parser, stack->oldUserData);
}

// call when element starts
void XSD_OnStartElement(xml_parser_stack_t *stack, const XML_Char *name, const XML_Char **atts)
{
    strlcat(stack->path, "/", sizeof (stack->path));
    strlcat(stack->path, name, sizeof (stack->path));
}

// call when element ends
void XSD_OnEndElement(xml_parser_stack_t *stack, const XML_Char *name)
{
    char *t = strrchr(stack->path, '/');
    *t = 0;
}

static void XSD_DetectType_OnStartElement(void *userData, const XML_Char *name, const XML_Char **atts)
{
    char *type = (char *) userData;

    if (type[0] == 0)
        strcpy(type, name);
}

// load document, auto-recognizing its type, returns NULL in case of failure
xml_t * XSD_LoadDocument(char *filename)
{
    xml_t *ret = NULL;
    int i;
	vfsfile_t *f;
    XML_Parser parser = NULL;
    int len;
	int filelen;
    char buf[XML_READ_BUFSIZE];
    char document_type[1024];
	
	// FIXME: D-Kure, does FS_ANY handle both the above cases
	if (!(f = FS_OpenVFS(filename, "rb", FS_ANY))) {
		return NULL;
	}
	filelen = VFS_GETLEN(f);

    // initialize XML parser
    parser = XML_ParserCreate(NULL);
	if (parser == NULL) {
		Com_Printf("could not open2\n");
        goto error;
	}
    XML_SetStartElementHandler(parser, XSD_DetectType_OnStartElement);
    XML_SetUserData(parser, document_type);

    document_type[0] = 0;

    while (document_type[0] == 0  &&  (len = VFS_READ(f, buf, XML_READ_BUFSIZE, NULL)) > 0)
    {
		if (XML_Parse(parser, buf, len, 0) != XML_STATUS_OK) {
			Com_Printf("could not open3\n");
            goto error;
		}
    }
	if (document_type[0] == 0) {
		Com_Printf("could not open4\n");
        goto error;
	}

    // now we know what document type it is...

    // parser is no more needed
    XML_ParserFree(parser);
    parser = NULL;

    // fseek to the beginning of the file
	VFS_SEEK(f, 0, SEEK_SET);

    // execute loading parser
    i = 0;
    while (xsd_mappings[i].document_type != NULL)
    {
        if (!strcmp(xsd_mappings[i].document_type, document_type))
        {
			//???
            ret = xsd_mappings[i].load_function(f, filelen);
            break;
        }
        i++;
    }

    if (ret)
    {
		VFS_CLOSE(f);
        return ret;
    }

error:
    if (f)
		VFS_CLOSE(f);

    if (parser)
        XML_ParserFree(parser);
    return NULL;
}

// load document and convert it to xml_document_t
xml_document_t * XSD_LoadDocumentWithXsl(char *filename)
{
    xml_t *doc;
    xml_document_t *document;

    doc = XSD_LoadDocument(filename);

    if (doc == NULL)
        return NULL;

    if (!strcmp(doc->document_type, "document"))
        return (xml_document_t *) doc; // no conversion

    // convert
    document = XSD_XslConvert(doc);
    XSD_FreeDocument(doc);
    return document;

}

// free document loaded with XSD_LoadDocument
void XSD_FreeDocument(xml_t *document)
{
    int i = 0;
    while (xsd_mappings[i].document_type != NULL)
    {
        if (!strcmp(xsd_mappings[i].document_type, document->document_type))
        {
            xsd_mappings[i].free_function(document);
            return;
        }
        i++;
    }
}

// convert any known xml document to "document" type
xml_document_t * XSD_XslConvert(xml_t *doc)
{
    int i = 0;
    while (xsd_mappings[i].document_type != NULL)
    {
        if (!strcmp(xsd_mappings[i].document_type, doc->document_type))
        {
            if (xsd_mappings[i].convert_function)
                return (xml_document_t *)xsd_mappings[i].convert_function(doc);
            else
                return NULL;
        }
        i++;
    }

    return NULL;
}


================================================
FILE: src/xsd.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __XSD_H__
#define __XSD_H__


#define XML_READ_BUFSIZE 4096

typedef struct xml_s
{
    char *document_type;

    // ----------------

    // rest goes here...
}
xml_t;


// include different document types handlers
#include "xsd_document.h"


#define PARSER_STACK_PATH_SIZE  1024    // temporary

typedef struct xml_parser_stack_s
{
    XML_Parser parser;
    xml_t *document;

    char path[PARSER_STACK_PATH_SIZE];

    // previous parser handlers
    // allows for switching parser functions during parsing
    XML_StartElementHandler oldStartHandler;
    XML_EndElementHandler oldEndHandler;
    XML_CharacterDataHandler oldCharacterDataHandler;
    void *oldUserData;

    // parser specific data
    void *parser_specific;
}
xml_parser_stack_t;


// get value attribute from the array
const char *XSD_GetAttribute(const char **atts, const char *name);

// add text (strcat) with realocation
char *XSD_AddText(char *dst, const char *src, int src_len);

// test if character is valid XML space
int XSD_IsSpace(char);

// strip spaces multiple spaces from in-between words
char *XSD_StripSpaces(char *);

// check if we are somewhere inside given element
int XSD_IsIn(char *path, char *subPath);

// initialize parser stack
void XSD_InitStack(xml_parser_stack_t *stack);

// restore parser handlers from previous one in stack
void XSD_RestoreStack(xml_parser_stack_t *stack);

// call when element starts
void XSD_OnStartElement(xml_parser_stack_t *stack, const XML_Char *name, const XML_Char **atts);

// call when element ends
void XSD_OnEndElement(xml_parser_stack_t *stack, const XML_Char *name);




// load document, auto-recognizing its type, returns NULL in case of failure
xml_t * XSD_LoadDocument(char *filename);

// load document and convert it to xml_document_t
xml_document_t * XSD_LoadDocumentWithXsl(char *filename);

// free document loaded with XSD_LoadDocument
void XSD_FreeDocument(xml_t *);

// convert any known xml document to "document" type
xml_document_t * XSD_XslConvert(xml_t *doc);



#endif // __XSD_H__


================================================
FILE: src/xsd_document.c
================================================
/*
Copyright (C) 2011 ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
// $Id: xsd_document.c,v 1.9 2007-10-04 14:56:54 dkure Exp $

#include "quakedef.h"
#include "expat.h"
#include "xsd.h"
#include "xsd_document.h"


// general parser
static void OnStartElement(void *userData, const XML_Char *name, const XML_Char **atts);
static void OnEndElement(void *userData, const XML_Char *name);
static void OnCharacterData(void *userData, const XML_Char *s, int len);

// BLOCKS parser
static void OnStartElement_Blocks(void *userData, const XML_Char *name, const XML_Char **atts);
static void OnEndElement_Blocks(void *userData, const XML_Char *name);
static void OnCharacterData_Blocks(void *userData, const XML_Char *s, int len);


// init xml_document_t struct
static void XSD_Document_Init(xml_document_t *document)
{
    memset(document, 0, sizeof(xml_document_t));
}

// create new document
xml_document_t * XSD_Document_New(void)
{
    xml_document_t *doc = (xml_document_t *) Q_malloc(sizeof(xml_document_t));
    XSD_Document_Init(doc);
    doc->document_type = Q_strdup("document");
    return doc;
}

static void XSD_Free_Tags(document_tag_t *t);

// free document_tag_p_t
static void XSD_Free_Tag_P(document_tag_p_t *p)
{
    XSD_Free_Tags(p->tags);
    Q_free(p);
}

// free document_tag_section_t
static void XSD_Free_Tag_Section(document_tag_section_t *s)
{
    if (s->id)
        Q_free(s->id);
    if (s->title)
        Q_free(s->title);
    XSD_Free_Tags(s->tags);
    Q_free(s);
}

// free document_tag_em_t
static void XSD_Free_Tag_Em(document_tag_em_t *i)
{
    XSD_Free_Tags(i->tags);
    Q_free(i);
}

// free document_tag_color_t
static void XSD_Free_Tag_Color(document_tag_color_t *c)
{
    XSD_Free_Tags(c->tags);
    Q_free(c);
}

// free document_tag_a_t
static void XSD_Free_Tag_A(document_tag_a_t *a)
{
    if (a->href)
        Q_free(a->href);
    XSD_Free_Tags(a->tags);
    Q_free(a);
}

// free document_tag_img_t
static void XSD_Free_Tag_Img(document_tag_img_t *i)
{
    XSD_Free_Tags(i->tags);
    Q_free(i);
}

// free document_tag_br_t
static void XSD_Free_Tag_Br(document_tag_br_t *br)
{
    Q_free(br);
}

// free document_tag_sp_t
static void XSD_Free_Tag_Sp(document_tag_sp_t *sp)
{
    Q_free(sp);
}

// free document_tag_hr_t
static void XSD_Free_Tag_Hr(document_tag_hr_t *hr)
{
    Q_free(hr);
}

// free document_tag_pre_t
static void XSD_Free_Tag_Pre(document_tag_pre_t *pre)
{
    if (pre->text)
        Q_free(pre->text);
    if (pre->alt)
        Q_free(pre->alt);
    Q_free(pre);
}

// free document_tag_h_t
static void XSD_Free_Tag_H(document_tag_h_t *h)
{
    XSD_Free_Tags(h->tags);
    Q_free(h);
}

// free document_tag_list_t
static void XSD_Free_Tag_List(document_tag_list_t *l)
{
    XSD_Free_Tags((document_tag_t *)l->items);
    Q_free(l);
}

// free document_tag_li_t
static void XSD_Free_Tag_Li(document_tag_li_t *l)
{
    XSD_Free_Tags(l->tags);
    Q_free(l);
}

// free document_tag_list_t
static void XSD_Free_Tag_Dict(document_tag_dict_t *l)
{
    XSD_Free_Tags((document_tag_t *)l->items);
    Q_free(l);
}

// free document_tag_di_t
static void XSD_Free_Tag_Di(document_tag_di_t *l)
{
    XSD_Free_Tags(l->name);
    XSD_Free_Tags(l->description);
    Q_free(l);
}

// free document_tag_text_t tag
static void XSD_Free_Tag_Text(document_tag_text_t *t)
{
    if (t->text)
        Q_free(t->text);
    Q_free(t);
}

// free tag chain
static void XSD_Free_Tags(document_tag_t *t)
{
    while (t)
    {
        document_tag_t *next = t->next;

        switch (t->type)
        {
        case tag_text:
            XSD_Free_Tag_Text((document_tag_text_t *) t);
            break;

        case tag_section:
            XSD_Free_Tag_Section((document_tag_section_t *) t);
            break;

        case tag_p:
            XSD_Free_Tag_P((document_tag_p_t *) t);
            break;

        case tag_hr:
            XSD_Free_Tag_Hr((document_tag_hr_t *) t);
            break;

        case tag_pre:
            XSD_Free_Tag_Pre((document_tag_pre_t *) t);
            break;

        case tag_h:
            XSD_Free_Tag_H((document_tag_h_t *) t);
            break;

        case tag_list:
            XSD_Free_Tag_List((document_tag_list_t *) t);
            break;

        case tag_li:
            XSD_Free_Tag_Li((document_tag_li_t *) t);
            break;

        case tag_dict:
            XSD_Free_Tag_Dict((document_tag_dict_t *) t);
            break;

        case tag_di:
            XSD_Free_Tag_Di((document_tag_di_t *) t);
            break;

        case tag_em:
            XSD_Free_Tag_Em((document_tag_em_t *) t);
            break;

        case tag_color:
            XSD_Free_Tag_Color((document_tag_color_t *) t);
            break;

        case tag_a:
            XSD_Free_Tag_A((document_tag_a_t *) t);
            break;

        case tag_img:
            XSD_Free_Tag_Img((document_tag_img_t *) t);
            break;

        case tag_br:
            XSD_Free_Tag_Br((document_tag_br_t *) t);
            break;

        case tag_sp:
            XSD_Free_Tag_Sp((document_tag_sp_t *) t);
            break;

        default:
            assert(0);
        }

        t = next;
    }
}

// free xml_document_t struct
void XSD_Document_Free(xml_t *doc)
{
    xml_document_t *document = (xml_document_t *) doc;

    if (document->title)
        Q_free(document->title);

    XSD_Free_Tags(document->content);

    if (document->document_type)
        Q_free(document->document_type);

    // delete document
    Q_free(document);
}

// find last tag in chain
static document_tag_t *GetLast(document_tag_t *tag)
{
    if (tag == NULL)
        return NULL;

    while (tag->next)
        tag = tag->next;
    return tag;
}

// ----------------------------------------------------------------------------
//
// BLOCKS parser
//
static void OnStartElement_Blocks(void *userData, const XML_Char *name, const XML_Char **atts)
{
    xml_parser_stack_t *stack = (xml_parser_stack_t *) userData;
    xml_document_t *document = (xml_document_t *) stack->document;
    document_parser_specific_t *specific = (document_parser_specific_t *) stack->parser_specific;

    if (stack->path[0] == 0)
    {
        if (!strcmp(name, "p"))
        {
            const char *attr;

            document_tag_p_t *p = (document_tag_p_t *) Q_malloc(sizeof(document_tag_p_t));
            memset(p, 0, sizeof(document_tag_p_t));
            p->type = tag_p;

            // check indentation
            attr = XSD_GetAttribute(atts, "indent");
            if (attr == NULL  ||  !strcmp(attr, "false"))
                p->indent = false;
            else
                p->indent = true;

            // check alignment
            attr = XSD_GetAttribute(atts, "align");
            p->align = align_left;
            if (attr != NULL)
            {
                if (!strcmp(attr, "right"))
                    p->align = align_right;
                else  if (!strcmp(attr, "center"))
                    p->align = align_center;
            }

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) p;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) p;

            // and now parse this element with new parser
            // create sub-parser
            {
                xml_parser_stack_t *newstack;
                document_parser_specific_t *specific;

                newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
                specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

                specific->tag = &p->tags;

                // prepare user data
                XSD_InitStack(newstack);
                newstack->parser_specific = specific;
                newstack->parser = stack->parser;
                newstack->document = (xml_t *) document;
                newstack->oldUserData = userData;
                newstack->oldStartHandler = OnStartElement_Blocks;
                newstack->oldEndHandler = OnEndElement_Blocks;
                newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

                XML_SetUserData(stack->parser, newstack);
                XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
                XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
                XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

                return;
            }
        }
        
        if (!strcmp(name, "section"))
        {
            const char *attr;

            document_tag_section_t *p = (document_tag_section_t *) Q_malloc(sizeof(document_tag_section_t));
            memset(p, 0, sizeof(document_tag_section_t));
            p->type = tag_section;

            // check indentation
            attr = XSD_GetAttribute(atts, "indent");
            if (attr == NULL  ||  !strcmp(attr, "false"))
                p->indent = false;
            else
                p->indent = true;

            // check id
            attr = XSD_GetAttribute(atts, "id");
            if (attr)
                p->id = Q_strdup(attr);
            else
                p->id = Q_strdup(va("%___%d", specific->section_num++));

            // check title
            attr = XSD_GetAttribute(atts, "title");
            if (attr)
                p->title = Q_strdup(attr);
            else
                p->title = Q_strdup("<unnamed>");

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) p;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) p;

            // and now parse this element with new parser
            // create sub-parser
            {
                xml_parser_stack_t *newstack;
                document_parser_specific_t *specific;

                newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
                specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

                specific->tag = &p->tags;

                // prepare user data
                XSD_InitStack(newstack);
                newstack->parser_specific = specific;
                newstack->parser = stack->parser;
                newstack->document = (xml_t *) document;
                newstack->oldUserData = userData;
                newstack->oldStartHandler = OnStartElement_Blocks;
                newstack->oldEndHandler = OnEndElement_Blocks;
                newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

                XML_SetUserData(stack->parser, newstack);
                XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
                XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
                XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

                return;
            }
        }
        
        if (!strcmp(name, "list"))
        {
            const char *attr;

            // create new list and add to tag list
            document_tag_list_t *list = (document_tag_list_t *) Q_malloc(sizeof(document_tag_list_t));
            memset(list, 0, sizeof(document_tag_list_t));
            list->type = tag_list;

            // check bullet type
            list->bullet = list_bullet_none;
            attr = XSD_GetAttribute(atts, "bullet");
            if (attr == NULL  ||  !strcmp(attr, "dot"))
                list->bullet = list_bullet_dot;
            else if (!strcmp(attr, "none"))
                list->bullet = list_bullet_none;
            else if (!strcmp(attr, "number"))
                list->bullet = list_bullet_number;
            else if (!strcmp(attr, "letter"))
                list->bullet = list_bullet_letter;
            else if (!strcmp(attr, "big-letter"))
                list->bullet = list_bullet_bigletter;

            // check separator type
            attr = XSD_GetAttribute(atts, "separator");
            list->separator = list_separator_none;
            if (attr == NULL  ||  !strcmp(attr, "none"))
                list->separator = list_separator_none;
            else if (!strcmp(attr, "dot"))
                list->separator = list_separator_dot;
            else if (!strcmp(attr, "par"))
                list->separator = list_separator_par;

            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) list;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) list;
        }

        if (!strcmp(name, "dict"))
        {
            const char *attr;

            // create new dict and add to tag list
            document_tag_dict_t *dict = (document_tag_dict_t *) Q_malloc(sizeof(document_tag_dict_t));
            memset(dict, 0, sizeof(document_tag_dict_t));
            dict->type = tag_dict;

            // check bullet type
            dict->bullet = list_bullet_none;
            attr = XSD_GetAttribute(atts, "bullet");
            if (attr == NULL  ||  !strcmp(attr, "none"))
                dict->bullet = list_bullet_none;
            else if (!strcmp(attr, "dot"))
                dict->bullet = list_bullet_dot;
            else if (!strcmp(attr, "number"))
                dict->bullet = list_bullet_number;
            else if (!strcmp(attr, "letter"))
                dict->bullet = list_bullet_letter;
            else if (!strcmp(attr, "big-letter"))
                dict->bullet = list_bullet_bigletter;

            // check separator type
            attr = XSD_GetAttribute(atts, "separator");
            dict->separator = list_separator_none;
            if (attr == NULL  ||  !strcmp(attr, "none"))
                dict->separator = list_separator_none;
            else if (!strcmp(attr, "dot"))
                dict->separator = list_separator_dot;
            else if (!strcmp(attr, "par"))
                dict->separator = list_separator_par;

            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) dict;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) dict;
        }

        if (!strcmp(name, "hr"))
        {
            document_tag_hr_t *hr = (document_tag_hr_t *) Q_malloc(sizeof(document_tag_hr_t));
            memset(hr, 0, sizeof(document_tag_hr_t));
            hr->type = tag_hr;

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) hr;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) hr;
        }

        if (!strcmp(name, "pre"))
        {
            const char *attr;

            document_tag_pre_t *pre = (document_tag_pre_t *) Q_malloc(sizeof(document_tag_pre_t));
            memset(pre, 0, sizeof(document_tag_pre_t));
            pre->type = tag_pre;

            // check alt
            attr = XSD_GetAttribute(atts, "alt");
            if (attr != NULL)
                pre->alt = Q_strdup(attr);

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) pre;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) pre;
        }

        if (!strcmp(name, "h"))
        {
            const char *attr;

            document_tag_h_t *h = (document_tag_h_t *) Q_malloc(sizeof(document_tag_h_t));
            memset(h, 0, sizeof(document_tag_h_t));
            h->type = tag_h;

            // check alignment
            attr = XSD_GetAttribute(atts, "align");
            h->align = align_left;
            if (attr != NULL)
            {
                if (!strcmp(attr, "right"))
                    h->align = align_right;
                else  if (!strcmp(attr, "center"))
                    h->align = align_center;
            }

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) h;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) h;

            // and now parse this element with new parser
            // create sub-parser
            {
                xml_parser_stack_t *newstack;
                document_parser_specific_t *specific;

                newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
                specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

                specific->tag = &h->tags;

                // prepare user data
                XSD_InitStack(newstack);
                newstack->parser_specific = specific;
                newstack->parser = stack->parser;
                newstack->document = (xml_t *) document;
                newstack->oldUserData = userData;
                newstack->oldStartHandler = OnStartElement_Blocks;
                newstack->oldEndHandler = OnEndElement_Blocks;
                newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

                XML_SetUserData(stack->parser, newstack);
                XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
                XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
                XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

                return;
            }
        }

        if (!strcmp(name, "em"))
        {
            document_tag_em_t *i = (document_tag_em_t *) Q_malloc(sizeof(document_tag_em_t));
            memset(i, 0, sizeof(document_tag_em_t));
            i->type = tag_em;

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) i;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) i;

            // and now parse this element with new parser
            // create sub-parser
            {
                xml_parser_stack_t *newstack;
                document_parser_specific_t *specific;

                newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
                specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

                specific->tag = &i->tags;

                // prepare user data
                XSD_InitStack(newstack);
                newstack->parser_specific = specific;
                newstack->parser = stack->parser;
                newstack->document = (xml_t *) document;
                newstack->oldUserData = userData;
                newstack->oldStartHandler = OnStartElement_Blocks;
                newstack->oldEndHandler = OnEndElement_Blocks;
                newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

                XML_SetUserData(stack->parser, newstack);
                XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
                XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
                XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

                return;
            }
        }

        if (!strcmp(name, "color"))
        {
            document_tag_color_t *i = (document_tag_color_t *) Q_malloc(sizeof(document_tag_color_t));
            memset(i, 0, sizeof(document_tag_color_t));
            i->type = tag_color;

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) i;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) i;

            // and now parse this element with new parser
            // create sub-parser
            {
                xml_parser_stack_t *newstack;
                document_parser_specific_t *specific;

                newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
                specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

                specific->tag = &i->tags;

                // prepare user data
                XSD_InitStack(newstack);
                newstack->parser_specific = specific;
                newstack->parser = stack->parser;
                newstack->document = (xml_t *) document;
                newstack->oldUserData = userData;
                newstack->oldStartHandler = OnStartElement_Blocks;
                newstack->oldEndHandler = OnEndElement_Blocks;
                newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

                XML_SetUserData(stack->parser, newstack);
                XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
                XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
                XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

                return;
            }
        }

        if (!strcmp(name, "a"))
        {
            const char *attr;

            document_tag_a_t *i = (document_tag_a_t *) Q_malloc(sizeof(document_tag_a_t));
            memset(i, 0, sizeof(document_tag_a_t));
            i->type = tag_a;

            // check href
            attr = XSD_GetAttribute(atts, "href");
            if (attr)
                i->href = Q_strdup(attr);

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) i;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) i;

            // and now parse this element with new parser
            // create sub-parser
            {
                xml_parser_stack_t *newstack;
                document_parser_specific_t *specific;

                newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
                specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

                specific->tag = &i->tags;

                // prepare user data
                XSD_InitStack(newstack);
                newstack->parser_specific = specific;
                newstack->parser = stack->parser;
                newstack->document = (xml_t *) document;
                newstack->oldUserData = userData;
                newstack->oldStartHandler = OnStartElement_Blocks;
                newstack->oldEndHandler = OnEndElement_Blocks;
                newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

                XML_SetUserData(stack->parser, newstack);
                XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
                XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
                XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

                return;
            }
        }

        if (!strcmp(name, "img"))
        {
            document_tag_img_t *i = (document_tag_img_t *) Q_malloc(sizeof(document_tag_img_t));
            memset(i, 0, sizeof(document_tag_img_t));
            i->type = tag_img;

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) i;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) i;

            // and now parse this element with new parser
            // create sub-parser
            {
                xml_parser_stack_t *newstack;
                document_parser_specific_t *specific;

                newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
                specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

                specific->tag = &i->tags;

                // prepare user data
                XSD_InitStack(newstack);
                newstack->parser_specific = specific;
                newstack->parser = stack->parser;
                newstack->document = (xml_t *) document;
                newstack->oldUserData = userData;
                newstack->oldStartHandler = OnStartElement_Blocks;
                newstack->oldEndHandler = OnEndElement_Blocks;
                newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

                XML_SetUserData(stack->parser, newstack);
                XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
                XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
                XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

                return;
            }
        }

        if (!strcmp(name, "br"))
        {
            document_tag_br_t *i = (document_tag_br_t *) Q_malloc(sizeof(document_tag_br_t));
            memset(i, 0, sizeof(document_tag_br_t));
            i->type = tag_br;

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) i;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) i;
        }

        if (!strcmp(name, "sp"))
        {
            document_tag_sp_t *i = (document_tag_sp_t *) Q_malloc(sizeof(document_tag_sp_t));
            memset(i, 0, sizeof(document_tag_sp_t));
            i->type = tag_sp;

            // add to list
            if (specific->tag[0] == NULL)
                specific->tag[0] = (document_tag_t *) i;
            else
                GetLast(specific->tag[0])->next = (document_tag_t *) i;
        }
    }

    if (!strcmp(stack->path, "/list")  &&  !strcmp(name, "li"))
    {
        xml_parser_stack_t *newstack;
        document_tag_list_t *list;
        document_tag_li_t *item;

        // find last elemend (LIST)
        list = (document_tag_list_t *) GetLast(specific->tag[0]);
        assert(list->type == tag_list);

        // create new LI and add to list
        item = (document_tag_li_t *) Q_malloc(sizeof(document_tag_li_t));
        memset(item, 0, sizeof(document_tag_li_t));
        item->type = tag_li;
        if (list->items == NULL)
            list->items = item;
        else
            GetLast((document_tag_t *)list->items)->next = (document_tag_t *)item;

        // start new parser for LI
        {
            document_parser_specific_t *specific;
            newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
            specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

            specific->tag = &item->tags;

            // prepare user data
            XSD_InitStack(newstack);
            newstack->parser_specific = specific;
            newstack->parser = stack->parser;
            newstack->document = (xml_t *) document;
            newstack->oldUserData = userData;
            newstack->oldStartHandler = OnStartElement_Blocks;
            newstack->oldEndHandler = OnEndElement_Blocks;
            newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

            XML_SetUserData(stack->parser, newstack);
            XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
            XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
            XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

            return;
        }
    }

    if (!strcmp(stack->path, "/dict")  &&  !strcmp(name, "di"))
    {
        document_tag_dict_t *dict;
        document_tag_di_t *item;

        // find last elemend (DICT)
        dict = (document_tag_dict_t *) GetLast(specific->tag[0]);
        assert(dict->type == tag_dict);

        // create new DI and add to dict
        item = (document_tag_di_t *) Q_malloc(sizeof(document_tag_di_t));
        memset(item, 0, sizeof(document_tag_di_t));
        item->type = tag_di;
        if (dict->items == NULL)
            dict->items = item;
        else
            GetLast((document_tag_t *)dict->items)->next = (document_tag_t *)item;
    }

    if (!strcmp(stack->path, "/dict/di")  &&  !strcmp(name, "name"))
    {
        xml_parser_stack_t *newstack;
        document_tag_dict_t *dict;
        document_tag_di_t *item;

        // find last elemend (DICT)
        dict = (document_tag_dict_t *) GetLast(specific->tag[0]);
        assert(dict->type == tag_dict);

        // find last element (DI)
        item = (document_tag_di_t *) GetLast((document_tag_t *)dict->items);
        assert(item->type == tag_di);

        // start new parser for DI/name
        {
            document_parser_specific_t *specific;
            newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
            specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

            specific->tag = &item->name;

            // prepare user data
            XSD_InitStack(newstack);
            newstack->parser_specific = specific;
            newstack->parser = stack->parser;
            newstack->document = (xml_t *) document;
            newstack->oldUserData = userData;
            newstack->oldStartHandler = OnStartElement_Blocks;
            newstack->oldEndHandler = OnEndElement_Blocks;
            newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

            XML_SetUserData(stack->parser, newstack);
            XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
            XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
            XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

            return;
        }
    }

    if (!strcmp(stack->path, "/dict/di")  &&  !strcmp(name, "description"))
    {
        xml_parser_stack_t *newstack;
        document_tag_dict_t *dict;
        document_tag_di_t *item;

        // find last elemend (DICT)
        dict = (document_tag_dict_t *) GetLast(specific->tag[0]);
        assert(dict->type == tag_dict);

        // find last element (DI)
        item = (document_tag_di_t *) GetLast((document_tag_t *)dict->items);
        assert(item->type == tag_di);

        // start new parser for DI/name
        {
            document_parser_specific_t *specific;
            newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
            specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

            specific->tag = &item->description;

            // prepare user data
            XSD_InitStack(newstack);
            newstack->parser_specific = specific;
            newstack->parser = stack->parser;
            newstack->document = (xml_t *) document;
            newstack->oldUserData = userData;
            newstack->oldStartHandler = OnStartElement_Blocks;
            newstack->oldEndHandler = OnEndElement_Blocks;
            newstack->oldCharacterDataHandler = OnCharacterData_Blocks;

            XML_SetUserData(stack->parser, newstack);
            XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
            XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
            XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

            return;
        }
    }

    XSD_OnStartElement(stack, name, atts);
}

static void OnEndElement_Blocks(void *userData, const XML_Char *name)
{
    xml_parser_stack_t *stack = (xml_parser_stack_t *) userData;
//    xml_document_t *document = (xml_document_t *) stack->document;
//    document_parser_specific_t *specific = (document_parser_specific_t *) stack->parser_specific;

    // if element ends and our stack is empty, it means we
    // should return to parent stack & parser
    if (stack->path[0] == 0)
    {
        XSD_RestoreStack(stack);
        Q_free(stack->parser_specific);
        Q_free(stack);
        return;
    }

    XSD_OnEndElement(stack, name);
}

static void OnCharacterData_Blocks(void *userData, const XML_Char *s, int len)
{
    xml_parser_stack_t *stack = (xml_parser_stack_t *) userData;
//    xml_document_t *document = (xml_document_t *) stack->document;
    document_parser_specific_t *specific = (document_parser_specific_t *) stack->parser_specific;

    if (stack->path[0] == 0)
    {
        document_tag_text_t *text;
        document_tag_t *last = GetLast(specific->tag[0]);

        if (last == NULL)
        {
            // create new text tag and start chain with it
            text = (document_tag_text_t *) Q_malloc(sizeof(document_tag_text_t));
            memset(text, 0, sizeof(document_tag_text_t));
            text->type = tag_text;
            specific->tag[0] = (document_tag_t *) text;
        }
        else if (last->type == tag_text)
        {
            // append to this tag
            text = (document_tag_text_t *) last;
        }
        else
        {
            // create new text tag and add it to the chain
            text = (document_tag_text_t *) Q_malloc(sizeof(document_tag_text_t));
            memset(text, 0, sizeof(document_tag_text_t));
            text->type = tag_text;
            last->next = (document_tag_t *) text;
        }

        text->text = XSD_AddText(text->text, s, len);
    }

    if (!strcmp(stack->path, "/pre"))
    {
        document_tag_pre_t *pre;

        // find last element (pre)
        pre = (document_tag_pre_t *) GetLast(specific->tag[0]);
        assert(pre->type = tag_pre);

        // and add text to it
        pre->text = XSD_AddText(pre->text, s, len);
    }
}


// ----------------------------------------------------------------------------
//
// general parser
//

static void OnStartElement(void *userData, const XML_Char *name, const XML_Char **atts)
{
    xml_parser_stack_t *stack = (xml_parser_stack_t *) userData;
    xml_document_t *document = (xml_document_t *) stack->document;
//    document_parser_specific_t *specific = (document_parser_specific_t *) stack->parser_specific;

    if (stack->path[0] == 0)
        document->document_type = Q_strdup(name);

    if (!strcmp(stack->path, "/document/head/authors")  &&  !strcmp(name, "author"))
    {
        xml_document_author_t *author = (xml_document_author_t *) Q_malloc(sizeof(xml_document_author_t));
        memset(author, 0, sizeof(xml_document_author_t));

        if (document->authors == NULL)
            document->authors = author;
        else
        {
            xml_document_author_t *last = (xml_document_author_t *)
                GetLast((document_tag_t *)document->authors);
            last->next = author;
        }
    }

    if (XSD_IsIn(stack->path, "/document"))
    {
        if (!strcmp(name, "body"))
        {
            // create sub-parser
            xml_parser_stack_t *newstack;
            document_parser_specific_t *specific;

            newstack = (xml_parser_stack_t *) Q_malloc(sizeof(xml_parser_stack_t));
            specific = (document_parser_specific_t *) Q_malloc(sizeof(document_parser_specific_t));

            specific->tag = &document->content;

            // prepare user data
            XSD_InitStack(newstack);
            newstack->parser_specific = specific;
            newstack->parser = stack->parser;
            newstack->document = (xml_t *) document;
            newstack->oldUserData = userData;
            newstack->oldStartHandler = OnStartElement;
            newstack->oldEndHandler = OnEndElement;
            newstack->oldCharacterDataHandler = OnCharacterData;

            XML_SetUserData(stack->parser, newstack);
            XML_SetStartElementHandler(stack->parser, OnStartElement_Blocks);
            XML_SetEndElementHandler(stack->parser, OnEndElement_Blocks);
            XML_SetCharacterDataHandler(stack->parser, OnCharacterData_Blocks);

            return;
        }
    }

    XSD_OnStartElement(stack, name, atts);
}

static void OnEndElement(void *userData, const XML_Char *name)
{
    xml_parser_stack_t *stack = (xml_parser_stack_t *) userData;
    xml_document_t *document = (xml_document_t *) stack->document;

    // strip spaces from elements already loaded
    if (!strcmp(stack->path, "/document/title"))
        document->title = XSD_StripSpaces(document->title);

    XSD_OnEndElement(stack, name);
}

static void OnCharacterData(void *userData, const XML_Char *s, int len)
{
    xml_parser_stack_t *stack = (xml_parser_stack_t *) userData;
    xml_document_t *document = (xml_document_t *) stack->document;

    if (!strcmp(stack->path, "/document/head/title"))
        document->title = XSD_AddText(document->title, s, len);

    if (!strcmp(stack->path, "/document/head/date"))
        document->date = XSD_AddText(document->date, s, len);

    if (!strcmp(stack->path, "/document/head/authors/author"))
    {
        xml_document_author_t *a = (xml_document_author_t *)
            GetLast((document_tag_t *)document->authors);

        if (!strcmp(stack->path, "/document/head/authors/name"))
            a->name = XSD_AddText(a->name, s, len);
        if (!strcmp(stack->path, "/document/head/authors/email"))
            a->name = XSD_AddText(a->email, s, len);
        if (!strcmp(stack->path, "/document/head/authors/im"))
            a->name = XSD_AddText(a->im, s, len);
    }
}

// read document content from file, return 0 if error
xml_t * XSD_Document_LoadFromHandle(vfsfile_t *v, int filelen) {
	vfserrno_t err;
    xml_document_t *document;
    XML_Parser parser = NULL;
    int len;
	int pos = 0;
    char buf[XML_READ_BUFSIZE];
    xml_parser_stack_t parser_stack;

    // create blank document
    document = (xml_document_t *) Q_malloc(sizeof(xml_document_t));
    XSD_Document_Init(document);

    // initialize XML parser
    parser = XML_ParserCreate(NULL);
    if (parser == NULL)
        goto error;
    XML_SetStartElementHandler(parser, OnStartElement);
    XML_SetEndElementHandler(parser, OnEndElement);
    XML_SetCharacterDataHandler(parser, OnCharacterData);

    // prepare user data
    XSD_InitStack(&parser_stack);
    parser_stack.document = (xml_t *) document;
    parser_stack.parser = parser;
    XML_SetUserData(parser, &parser_stack);

    while ((len = VFS_READ(v, buf, min(XML_READ_BUFSIZE, filelen-pos), &err)) > 0)
    {
        if (XML_Parse(parser, buf, len, 0) != XML_STATUS_OK)
            goto error;

		pos += len;
    }
    if (XML_Parse(parser, NULL, 0, 1) != XML_STATUS_OK)
        goto error;

    XML_ParserFree(parser);

    return (xml_t *) document;

error:

    if (parser)
        XML_ParserFree(parser);
    XSD_Document_Free((xml_t *)document);

    return NULL;
}

// read document content from file, return 0 if error
xml_document_t * XSD_Document_Load(char *filename)
{
    xml_document_t *document;
	vfsfile_t *f;

	if (!(f = FS_OpenVFS(filename, "rb", FS_ANY))) {
		return NULL;
	}
    document = (xml_document_t *) XSD_Document_LoadFromHandle(f, VFS_GETLEN(f));
	VFS_CLOSE(f);
    return document;
}


================================================
FILE: src/xsd_document.h
================================================
/*
Copyright (C) 2011 azazello and ezQuake team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __XSD_DOCUMENT_H__
#define __XSD_DOCUMENT_H__

#include "xsd.h"

typedef enum
{
    // plain text
    tag_text,

    // block elements
    tag_section,
    tag_p,
    tag_list,
    tag_dict,
    tag_hr,
    tag_h,
    tag_pre,

    // inline elements
    tag_em,
    tag_a,
    tag_img,
    tag_color,
    tag_br,
    tag_sp,

    // other
    tag_li,
    tag_di
}
document_tag_type_t;

typedef enum
{
    align_left,
    align_center,
    align_right
}
document_align_t;


// This is a base for all tag structures. Every tag structure
// should inherit fields defined here. This one is abstract.
typedef struct document_tag_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------

    // rest of data follow
    // ...
}
document_tag_t;


typedef struct document_tag_text_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    char *text;
}
document_tag_text_t;


typedef struct document_tag_p_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *tags;
    qbool indent;
    document_align_t align;
}
document_tag_p_t;


typedef struct document_tag_section_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *tags;
    qbool indent;
    char *title;
    char *id;
}
document_tag_section_t;


typedef struct document_tag_hr_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
}
document_tag_hr_t;


typedef struct document_tag_h_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *tags;
    document_align_t align;
}
document_tag_h_t;


typedef struct document_tag_em_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *tags;
}
document_tag_em_t;


typedef struct document_tag_color_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *tags;
}
document_tag_color_t;


typedef struct document_tag_a_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *tags;
    char *href;
}
document_tag_a_t;


typedef struct document_tag_img_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *tags;
}
document_tag_img_t;


typedef struct document_tag_br_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
}
document_tag_br_t;


typedef struct document_tag_pre_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    char *text;
    char *alt;
}
document_tag_pre_t;


typedef struct document_tag_sp_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
}
document_tag_sp_t;


typedef enum
{
    list_bullet_none,
    list_bullet_dot,
    list_bullet_number,
    list_bullet_letter,
    list_bullet_bigletter
}
list_bullet_t;

typedef enum
{
    list_separator_none,
    list_separator_dot,
    list_separator_par
}
list_separator_t;

typedef struct document_tag_li_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *tags;
}
document_tag_li_t;

typedef struct document_tag_list_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_li_t *items;
    list_bullet_t bullet;
    list_separator_t separator;
}
document_tag_list_t;


typedef struct document_tag_di_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_t *name;
    document_tag_t *description;
}
document_tag_di_t;

typedef struct document_tag_dict_s
{
    document_tag_type_t type;
    struct document_tag_s *next;
    // --------------------
    document_tag_di_t *items;
    list_bullet_t bullet;
    list_separator_t separator;
}
document_tag_dict_t;


typedef struct xml_document_author_s
{
    document_tag_type_t type;   // nothing for this type
    struct xml_document_author_s *next;
    // --------------------

    char *name;
    char *email;
    char *im;
}
xml_document_author_t;

typedef struct xml_document_s
{
    char *document_type;

    // head
    char *title;
    char *date;
    xml_document_author_t *authors;

    // body
    document_tag_t *content;
}
xml_document_t;


// document parser specific data
typedef struct document_parser_specific_s
{
    document_tag_t **tag;
    int section_num;
}
document_parser_specific_t;


// create new document
xml_document_t * XSD_Document_New(void);

// free xml_document_t struct
void XSD_Document_Free(xml_t *);

// read document content from file, return NULL if error
xml_t * XSD_Document_LoadFromHandle(vfsfile_t *v, int filelen);

// read document content from file, return NULL if error
xml_document_t * XSD_Document_Load(char *filename);

#endif // __XSD_DOCUMENT_H__


================================================
FILE: src/zone.c
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// zone.c - memory management

#ifdef SERVERONLY
#include "qwsvdef.h"

static void Cache_FreeLow(int new_low_hunk);
static void Cache_FreeHigh(int new_high_hunk);
#else
#include "common.h"
#include "gl_model.h"

#define Cache_FreeLow(...)
#define Cache_FreeHigh(...)
#define Cache_Init(...)
#endif

//============================================================================

#define HUNK_SENTINEL 0x1df001ed

typedef struct {
	int		sentinel;
	int		size; // including sizeof(hunk_t), -1 = not allocated
	char	name[8];
} hunk_t;

byte	*hunk_base;
int		hunk_size;

int		hunk_low_used;
int		hunk_high_used;

qbool	hunk_tempactive;
int		hunk_tempmark;

/*
==============
Hunk_Check

Run consistency and sentinel trashing checks
==============
*/
void Hunk_Check(void)
{
	hunk_t *h;

	for (h = (hunk_t *)hunk_base; (byte *)h != hunk_base + hunk_low_used;) {
		if (h->sentinel != HUNK_SENTINEL) {
			Sys_Error("Hunk_Check: trashed sentinel");
		}
		if (h->size < 16 || h->size + (byte *)h - hunk_base > hunk_size) {
			Sys_Error("Hunk_Check: bad size");
		}
		h = (hunk_t *)((byte *)h + h->size);
	}
}

/*
==============
Hunk_Print

If "all" is specified, every single allocation is printed.
Otherwise, allocations with the same name will be totaled up before printing.
==============
*/
void Hunk_Print(qbool all)
{
	hunk_t  *h, *next, *endlow, *starthigh, *endhigh;
	int     sum;
	int     totalblocks;
	char    name[9];

	name[8] = 0;
	sum = 0;
	totalblocks = 0;

	h = (hunk_t *)hunk_base;
	endlow = (hunk_t *)(hunk_base + hunk_low_used);
	starthigh = (hunk_t *)(hunk_base + hunk_size - hunk_high_used);
	endhigh = (hunk_t *)(hunk_base + hunk_size);

	Con_Printf("          :%8i total hunk size\n", hunk_size);
	Con_Printf("-------------------------\n");

	while (1) {
		// skip to the high hunk if done with low hunk
		if (h == endlow) {
			Con_Printf("-------------------------\n");
			Con_Printf("        :%8ikb REMAINING\n", (hunk_size - hunk_low_used - hunk_high_used) / 1024);
			Con_Printf("-------------------------\n");
			h = starthigh;
		}

		// if totally done, break
		if (h == endhigh) {
			break;
		}

		// run consistency checks
		if (h->sentinel != HUNK_SENTINEL) {
			Sys_Error("Hunk_Print: trashed sentinel");
		}
		if (h->size < 16 || h->size + (byte *)h - hunk_base > hunk_size) {
			Sys_Error("Hunk_Print: bad size");
		}

		next = (hunk_t *)((byte *)h + h->size);
		totalblocks++;
		sum += h->size;

		// print the single block
		memcpy(name, h->name, 8);
		if (all) {
			Con_Printf("%8p :%8i %8s\n", h, h->size, name);
		}

		// print the total
		if (next == endlow || next == endhigh || strncmp(h->name, next->name, 8)) {
			if (!all) {
				Con_Printf("          :%8ikb %8s (TOTAL)\n", sum / 1024, name);
			}
			sum = 0;
		}

		h = next;
	}

	Con_Printf("-------------------------\n");
	Con_Printf("%8i total blocks\n", totalblocks);
	Con_Printf("High used %i, low used %i\n", hunk_high_used, hunk_low_used);
}

void Hunk_Print_f(void)
{
	qbool all = Cmd_Argc() != 1;

	Hunk_Print(all);
}

/*
===================
Hunk_AllocName
===================
*/
void *Hunk_AllocName(int size, const char *name)
{
	hunk_t *h;

#ifdef PARANOID
	Hunk_Check();
#endif

	if (size < 0) {
		Sys_Error("Hunk_AllocName: bad size: %i", size);
	}

	size = sizeof(hunk_t) + ((size + 15) & ~15);

	if (hunk_size - hunk_low_used - hunk_high_used < size) {
		if ((int)developer.value)
		{
			Hunk_Print(true);
		}
#ifdef SERVERONLY
		Sys_Error("Hunk_AllocName: Not enough RAM allocated. Try starting using \"-mem 64\" (or more) on the command line.");
#else
		Sys_Error("Hunk_AllocName: Not enough RAM allocated. Try starting using \"-mem 128\" (or more) on the command line.");
#endif
	}

	h = (hunk_t *)(hunk_base + hunk_low_used);
	hunk_low_used += size;

	Cache_FreeLow(hunk_low_used);

	memset(h, 0, size);

	h->size = size;
	h->sentinel = HUNK_SENTINEL;
	strlcpy(h->name, name, sizeof(h->name));

	return (void *)(h + 1);
}

int	Hunk_LowMark(void)
{
	return hunk_low_used;
}

void Hunk_FreeToLowMark(int mark)
{
	if (mark < 0 || mark > hunk_low_used) {
		Sys_Error("Hunk_FreeToLowMark: bad mark %i, hunk_low_used = %i", mark, hunk_low_used);
	}
	memset(hunk_base + mark, 0, hunk_low_used - mark);
	hunk_low_used = mark;
}

static int Hunk_HighMark(void)
{
	return hunk_high_used;
}

static void Hunk_FreeToHighMark(int mark)
{
	if (mark < 0 || mark > hunk_high_used) {
		Sys_Error("Hunk_FreeToHighMark: bad mark %i", mark);
	}
	memset(hunk_base + hunk_size - hunk_high_used, 0, hunk_high_used - mark);
	hunk_high_used = mark;
}

/*
===================
Hunk_HighAllocName
===================
*/
static void *Hunk_HighAllocName(int size, char *name)
{
	hunk_t *h;

	if (size < 0) {
		Sys_Error("Hunk_HighAllocName: bad size: %i", size);
	}

#ifdef PARANOID
	Hunk_Check();
#endif

	size = sizeof(hunk_t) + ((size + 15)&~15);

	if (hunk_size - hunk_low_used - hunk_high_used < size) {
#ifdef SERVERONLY
		Sys_Error("Hunk_HighAllocName: Not enough RAM allocated. Try starting using \"-mem 64\" (or more) on the command line.");
#else
		Sys_Error("Hunk_HighAllocName: Not enough RAM allocated. Try starting using \"-mem 128\" (or more) on the command line.");
#endif
	}

	hunk_high_used += size;
	Cache_FreeHigh(hunk_high_used);

	h = (hunk_t *)(hunk_base + hunk_size - hunk_high_used);

	memset(h, 0, size);
	h->size = size;
	h->sentinel = HUNK_SENTINEL;
	strlcpy(h->name, name, sizeof(h->name));

	return (void *)(h + 1);
}

/*
=================
Hunk_TempFlush

Free the temporary memory zone to baseline.
=================
*/
void Hunk_TempFlush(void)
{
	if (hunk_tempactive) {
		Hunk_FreeToHighMark(hunk_tempmark);
		hunk_tempactive = false;
	}

	hunk_tempmark = Hunk_HighMark();
}

/*
=================
Hunk_TempAlloc

Return space from the top of the hunk
=================
*/
void *Hunk_TempAlloc(int size)
{
	void *buf;

	Hunk_TempFlush();

	buf = Hunk_HighAllocName(size, "temp");

	hunk_tempactive = true;

	return buf;
}

/*
=================
Hunk_TempAllocMore

Return space after any previous temporary allocation without clearing first.
=================
*/
void *Hunk_TempAllocMore(int size)
{
	if (!hunk_tempactive)
		return Hunk_TempAlloc(size);

	return Hunk_HighAllocName(size, "temp+");
}

#ifdef SERVERONLY
/*
===============================================================================

CACHE MEMORY

===============================================================================
*/

typedef struct cache_system_s {
	int                     size; // including this header
	cache_user_t*           user;
	char                    name[16];
	struct cache_system_s   *prev, *next;
	struct cache_system_s   *lru_prev, *lru_next; // for LRU flushing
} cache_system_t;

cache_system_t* Cache_TryAlloc(int size, qbool nobottom);

cache_system_t cache_head;

/*
===========
Cache_Move
===========
*/
void Cache_Move(cache_system_t* c)
{
	cache_system_t* new_block;

	// we are clearing up space at the bottom, so only allocate it late
	new_block = Cache_TryAlloc(c->size, true);
	if (new_block) {
		memcpy(new_block + 1, c + 1, c->size - sizeof(cache_system_t));
		new_block->user = c->user;
		memcpy(new_block->name, c->name, sizeof(new_block->name));
		Cache_Free(c->user);
		new_block->user->data = (void*)(new_block + 1);
	}
	else {
		Cache_Free(c->user); // tough luck...
	}
}

/*
============
Cache_FreeLow

Throw things out until the hunk can be expanded to the given point
============
*/
void Cache_FreeLow(int new_low_hunk)
{
	cache_system_t* c;

	while (1) {
		c = cache_head.next;
		if (c == &cache_head) {
			return; // nothing in cache at all
		}
		if ((byte*)c >= hunk_base + new_low_hunk) {
			return; // there is space to grow the hunk
		}
		Cache_Move(c); // reclaim the space
	}
}

/*
============
Cache_FreeHigh

Throw things out until the hunk can be expanded to the given point
============
*/
void Cache_FreeHigh(int new_high_hunk)
{
	cache_system_t *c, *prev;

	prev = NULL;
	while (1) {
		c = cache_head.prev;
		if (c == &cache_head) {
			return; // nothing in cache at all
		}
		if ((byte*)c + c->size <= hunk_base + hunk_size - new_high_hunk) {
			return; // there is space to grow the hunk
		}
		if (c == prev) {
			Cache_Free(c->user); // didn't move out of the way
		}
		else {
			Cache_Move(c); // try to move it
			prev = c;
		}
	}
}

void Cache_UnlinkLRU(cache_system_t* cs)
{
	if (!cs->lru_next || !cs->lru_prev) {
		Sys_Error("Cache_UnlinkLRU: NULL link");
	}

	cs->lru_next->lru_prev = cs->lru_prev;
	cs->lru_prev->lru_next = cs->lru_next;

	cs->lru_prev = cs->lru_next = NULL;
}

void Cache_MakeLRU(cache_system_t* cs)
{
	if (cs->lru_next || cs->lru_prev) {
		Sys_Error("Cache_MakeLRU: active link");
	}

	cache_head.lru_next->lru_prev = cs;
	cs->lru_next = cache_head.lru_next;
	cs->lru_prev = &cache_head;
	cache_head.lru_next = cs;
}

/*
============
Cache_TryAlloc

Looks for a free block of memory between the high and low hunk marks
Size should already include the header and padding
============
*/
cache_system_t* Cache_TryAlloc(int size, qbool nobottom)
{
	cache_system_t *cs, *new_block;

	// is the cache completely empty?
	if (!nobottom && cache_head.prev == &cache_head) {
		if (hunk_size - hunk_high_used - hunk_low_used < size) {
			Sys_Error("Cache_TryAlloc: %i is greater than free hunk", size);
		}

		new_block = (cache_system_t*)(hunk_base + hunk_low_used);
		memset(new_block, 0, sizeof(*new_block));
		new_block->size = size;

		cache_head.prev = cache_head.next = new_block;
		new_block->prev = new_block->next = &cache_head;

		Cache_MakeLRU(new_block);
		return new_block;
	}

	// search from the bottom up for space
	new_block = (cache_system_t*)(hunk_base + hunk_low_used);
	cs = cache_head.next;

	do {
		if (!nobottom || cs != cache_head.next) {
			if ((byte*)cs - (byte*)new_block >= size) {
				// found space
				memset(new_block, 0, sizeof(*new_block));
				new_block->size = size;

				new_block->next = cs;
				new_block->prev = cs->prev;
				cs->prev->next = new_block;
				cs->prev = new_block;

				Cache_MakeLRU(new_block);

				return new_block;
			}
		}

		// continue looking
		new_block = (cache_system_t*)((byte*)cs + cs->size);
		cs = cs->next;
	} while (cs != &cache_head);

	// try to allocate one at the very end
	if (hunk_base + hunk_size - hunk_high_used - (byte*)new_block >= size) {
		memset(new_block, 0, sizeof(*new_block));
		new_block->size = size;

		new_block->next = &cache_head;
		new_block->prev = cache_head.prev;
		cache_head.prev->next = new_block;
		cache_head.prev = new_block;

		Cache_MakeLRU(new_block);

		return new_block;
	}

	return NULL; // couldn't allocate
}

/*
============
Cache_Flush

Throw everything out, so new data will be demand cached
============
*/
void Cache_Flush(void)
{
	while (cache_head.next != &cache_head) {
		Cache_Free(cache_head.next->user); // reclaim the space
	}
#ifndef SERVERONLY
	Mod_ClearSimpleTextures();
#endif
}

/*
============
Cache_Print

============
*/
void Cache_Print(void)
{
	cache_system_t* cd;

	for (cd = cache_head.next; cd != &cache_head; cd = cd->next) {
		Con_Printf("%5.1f kB : %s\n", (cd->size / (float)(1024)), cd->name);
	}
}

/*
============
Cache_Report

============
*/
void Cache_Report(void)
{
	Con_Printf("%4.1f of %4.1f megabyte data cache free\n",
		(float)(hunk_size - hunk_high_used - hunk_low_used) / (1024 * 1024),
		(float)hunk_size / (1024 * 1024));
}

/*
============
Cache_Init

============
*/
void Cache_Init(void)
{
	cache_head.next = cache_head.prev = &cache_head;
	cache_head.lru_next = cache_head.lru_prev = &cache_head;

#ifndef WITH_DP_MEM
	// If DP mem is used then we can't add commands untill Cmd_Init() executed.
	Cache_Init_Commands();
#endif
}

void Cache_Init_Commands(void)
{
	Cmd_AddCommand("flush", Cache_Flush);
	Cmd_AddCommand("cache_print", Cache_Print);
	Cmd_AddCommand("cache_report", Cache_Report);
}

#ifndef WITH_DP_MEM
/*
==============
Cache_Free

Frees the memory and removes it from the LRU list
==============
*/
void Cache_Free(cache_user_t* c)
{
	cache_system_t* cs;

	if (!c->data) {
		Sys_Error("Cache_Free: not allocated");
	}

	cs = ((cache_system_t*)c->data) - 1;

	cs->prev->next = cs->next;
	cs->next->prev = cs->prev;
	cs->next = cs->prev = NULL;

	c->data = NULL;

	Cache_UnlinkLRU(cs);
}

/*
==============
Cache_Check
==============
*/
void* Cache_Check(cache_user_t* c)
{
	cache_system_t* cs;

	if (!c->data) {
		return NULL;
	}

	cs = ((cache_system_t*)c->data) - 1;

	// move to head of LRU
	Cache_UnlinkLRU(cs);
	Cache_MakeLRU(cs);

	return c->data;
}

/*
==============
Cache_Alloc
==============
*/
void* Cache_Alloc(cache_user_t* c, int size, const char* name)
{
	cache_system_t* cs;

	if (c->data) {
		Sys_Error("Cache_Alloc: already allocated");
	}

	if (size <= 0) {
		Sys_Error("Cache_Alloc: size %i", size);
	}

	size = (size + sizeof(cache_system_t) + 15) & ~15;

	// find memory for it
	while (1) {
		cs = Cache_TryAlloc(size, false);
		if (cs) {
			strlcpy(cs->name, name, sizeof(cs->name));
			c->data = (void*)(cs + 1);
			cs->user = c;
			break;
		}

		// free the least recently used cahedat
		if (cache_head.lru_prev == &cache_head) {
			Sys_Error("Cache_Alloc: out of memory");
		}

		// not enough memory at all
		Cache_Free(cache_head.lru_prev->user);
	}

	return Cache_Check(c);
}
#endif // !WITH_DP_MEM
#endif // SERVERONLY

//============================================================================

/*
========================
Memory_Init
========================
*/
void Memory_Init(void *buf, int size)
{
	hunk_base = (byte *)buf;
	hunk_size = size;
	hunk_low_used = 0;
	hunk_high_used = 0;

	Cache_Init();

	Cmd_AddCommand("hunk_print", Hunk_Print_f);
}


================================================
FILE: src/zone.h
================================================
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
#ifndef __ZONE_H__
#define __ZONE_H__

/*
 memory allocation


H_??? The hunk manages the entire memory block given to quake.  It must be
contiguous.  Memory can be allocated from either the low or high end in a
stack fashion.  The only way memory is released is by resetting one of the
pointers.

Hunk allocations should be given a name, so the Hunk_Print () function
can display usage.

Hunk allocations are guaranteed to be 16 byte aligned.

The video buffers are allocated high to avoid leaving a hole underneath
server allocations when changing to a higher video mode.


Cache_??? Cache memory is for objects that can be dynamically loaded and
can usefully stay persistent between levels.  The size of the cache
fluctuates from level to level.

To allocate a cachable object


Temp_??? Temp memory is used for file loading and surface caching.  The size
of the cache memory is adjusted so that there is a minimum of 512k remaining
for temp memory.


------ Top of Memory -------

high hunk allocations

<--- high hunk reset point held by vid

video buffer

z buffer

surface cache

<--- high hunk used

cachable memory

<--- low hunk used

client and server low hunk allocations

<-- low hunk reset point held by host

startup hunk allocations

----- Bottom of Memory -----



*/

void Memory_Init (void *buf, int size);

void *Hunk_AllocName (int size, const char *name);

int	Hunk_LowMark (void);
void Hunk_FreeToLowMark (int mark);

void Hunk_TempFlush(void);
void *Hunk_TempAlloc (int size);
void *Hunk_TempAllocMore(int size);

void Hunk_Check (void);

#ifdef SERVERONLY
typedef struct cache_user_s
{
	void *data;
} cache_user_t;

void Cache_Flush (void);

void *Cache_Check (cache_user_t *c);
// returns the cached data, and moves to the head of the LRU list
// if present, otherwise returns NULL

void Cache_Free(cache_user_t *c);

void *Cache_Alloc (cache_user_t *c, int size, const char *name);
// Returns NULL if all purgeable data was tossed and there still
// wasn't enough room.

void Cache_Report (void);
void Cache_Init_Commands (void);
#endif

#endif /* !__ZONE_H__ */


================================================
FILE: vcpkg.json
================================================
{
  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
  "name": "ezquake",
  "version": "1.0.0",
  "dependencies": [
    { "name": "pkgconf", "default-features": false, "platform": "osx", "host": true },
    { "name": "zlib", "default-features": false },
    { "name": "pcre2", "default-features": false },
    { "name": "minizip", "default-features": false },
    { "name": "expat", "default-features": false },
    { "name": "jansson", "default-features": false },
    { "name": "curl", "default-features": false, "features": ["ssl"], "platform": "windows" },
    { "name": "curl", "default-features": false, "features": ["mbedtls"], "platform": "linux, osx" },
    { "name": "libpng", "default-features": false },
    { "name": "libjpeg-turbo", "default-features": false },
    { "name": "freetype", "default-features": false, "features": ["zlib"] },
    { "name": "speex", "default-features": false },
    { "name": "speexdsp", "default-features": false },
    { "name": "libsndfile", "default-features": false, "features": ["external-libs"] },
    { "name": "alsa", "default-features": false, "platform": "linux" },
    { "name": "sdl2", "default-features": false, "platform": "windows, osx" },
    { "name": "sdl2", "default-features": false, "features": ["wayland", "x11", "alsa"], "platform": "linux" }
  ]
}